TI Codes : TI-83 Premium CE Edition Python
Démarrez pas à pas sur Python avec ses principales commandes et les modules de
bases déjà intégrés à la calculatrice.
Unité 1: Débuter la programmation en Python
Compétence 1 : Calculer avec Python
Notes de l'enseignantDans cette première leçon de l’unité 1, vous allez découvrir l’application TI-Python en utilisant les fonctions mathématiques les plus courantes incorporées à la calculatrice TI-83 Premium CE.
Objectifs :
- Utiliser le module TI-Python
- Découvrir les fonctions mathématiques en Python
- Distinguer l’éditeur de programmes et la console (Shell)
- Utiliser une instruction de programmation dans la console
étape 1
Appuyer sur la touche prgm.
Choisir l’application Python App
étape 2
Lorsque votre module Python est connecté à la calculatrice, un indicateur (carré vert) le précise juste à côté de celui de la charge de la batterie. 
étape 3
Mettre la calculatrice sous tension et appeler l’application Python App.
Valider en appuyant sur la touche ¼.
étape 4
Dans un premier temps nous allons utiliser la console également appelée « Shell »
Les touches F_1…F_5 sont utilisées pour accéder à toutes les fonctionnalités de l’éditeur.
Appuyer sur la touche F4 pour accéder à la console (Shell)
Quelques commandes de base.
Les variables sont généralement nommées par des lettres minuscules. Pour y accéder ainsi qu’aux commandes de base, appuyer sur F2 [ a A # ]
c←5 va s’écrire en Python c=5 et s’obtient sur la calculatrice en tapant :
(c [ sto → ] 5). Cette instruction signifie que 5 est affecté à la variable c.
Pour tester la valeur de la variable c : on écrira c == 5 ou bien c >= 5…
étape 5
Les calculs classiques :
- Le reste de la division de a par b s’écrit a%b
- Le quotient euclidien de a par b s’écrit a //b
- x à la puissance n s’écrit x**n. On peut aussi écrire pow(x,n)
Remarque : Le chargement du module (bibliothèque) « math import » est nécessaire pour effectuer des calculs sur les racines carrées et sur les fractions.
Pour incorporer ce module, appuyer sur la touche F1 [ Fns... ] et choisir Modul puis enfin le menu 1 : math…
- La racine carrée de x (x≥0) s’écrit sqrt(x)
- Le nombre π s’écrit pi
étape 6
Les commandes relatives aux chaines de caractères.
Les chaines de caractères se définissent à l’aide de guillemets doubles ou simples. « TI-Python » ou bien ‘TI-Python’
- Obtenir la longueur d’une chaine de caractères len(c) (Menu Fns… puis List)
- c[k] renvoie le k+1 élément de la chaine c.
- Pour concaténer deux chaines de caractères, simplement les additionner.
Remarque : Pour effacer une console des évènements précédents, appuyer sur F3 (Outils) et choisir le menu 5 : Effacer l’écran ou 6 : Nouveau Shell si vous ne souhaitez pas conserver les variables.
étape 7
Un peu d’astuce :
Lors de l’affectation de plusieurs variables, il est possible de le faire en une seule fois comme le montre l’écran ci-contre.
étape 8
Utiliser une instruction de programmation dans le Shell.
Le langage Python possède la richesse de pouvoir observer indépendamment d’un script, une fonctionnalité particulière.
Ainsi sur l’écran de droite, on peut analyser le fonctionnement d’une boucle for à laquelle on accède en appuyant sur F1 puis en choisissant dans le menu Ctl l’option 5 : for i in range( début , fin) :
Nous reviendrons sur les boucles dans une leçon ultérieure.
étape 9
Appliquons nos connaissances.
L’énergie cinétique d’un solide en mouvement est donnée par la relation EC=½ mv²
m est la masse du solide en kg
v est sa vitesse en m/s
En utilisant la console, quelle est la valeur de la variable energie si la masse est de 50 kg et la vitesse de 12 km/h ?
étape 10
Pour quitter l’application Python, procéder comme avec toutes les applications en appuyant sur les touches [ 2nde ][ mode ] puis F5 (OK)
Compétence 2 : Les types de données en Python
Notes de l'enseignantDans cette deuxième leçon de l’unité 1, vous allez découvrir comment utiliser le type des données en Python.
Objectifs :
- Connaitre les différentes types de données en langage Python.
- Mettre en forme le format d’une donnée numérique
étape 1
Connaitre le type des grandeurs utilisé.
Lorsque vous utilisez un script en langage Python, il peut s’avérer nécessaire de connaitre le type de variable utilisé, ou bien de modifier ces variables en vue d’une utilisation ultérieure. Par exemple si la grandeur renvoyée par un script Python correspondant à une mesure en sciences physiques, il n’est pas nécessairement opportun de conserver un résultat à 6 décimales.
Vous allez créer un script dans l’application Python permettant de distinguer les types de grandeurs utilisées.
- Une chaine de caractère
- Un nombre réel
- Un nombre irrationnel, √2 par exemple
Vous afficherez le nombre ainsi que son type à l’aide l’instruction type.
étape 2
- Importer le module maths (Fns… puis [→] Modul puis 1 : math… et enfin 1 : from math import *) puis appuyer sur la touche entrer.
- L’ensemble des commandes utilisé peut être obtenu en appuyant sur la touche F1 Fns… puis en choisissant les sous menus E/S (entrée/sortie) et Type.
- La commande type qui permet de connaitre la nature d’une variable peut être tapée « à la main ».
étape 3
Astuce : L’utilisation des touches de direction [↑] permet de recopier une ligne lorsque l’utilisateur travaille dans la console.
Remarques :
- L’opérateur int() extrait lorsque c’est possible, un entier d’une chaîne de caractères et renvoie la partie entière d’un nombre comprise entre ± 2 147 483 648 (codage sur 32 bits, soit 4 octets).
- L’opérateur str() transforme un nombre en une chaine de caractères.
- L’opérateur float() extrait lorsque c’est possible, un flottant d’une chaîne de caractères.
étape 4
Une autre astuce :
Pour incrémenter une variable dans un compteur, on dispose de deux possibilités :
- Écrire par exemple :compteur = 0
demander l’affichage de la variable compteur
- Ou bien :
compteur = 0
compteur+=1
compteur
étape 5
Pour aller plus loin :
Le format des nombres : La méthode format de l’objet string est un outil très puissant permettant de créer des chaines de caractères en remplaçant certains champs (entre accolades) par des valeurs (passées en argument de la fonction format) après conversion de celles-ci. On peut préciser à l’intérieur de chaque accolade un code de conversion, ainsi que le gabarit d’affichage. Donnons quelques exemples.
étape 6
>>> ‘{ :g}’.format(x) # choisit le format le plus approprié ‘1.04e+03’
>>> ‘{ :.3f}’.format(x) # fixe le nombre de décimales
‘1037.123’
>>> ‘{ :.3e}’.format(x) # notation scientifique
‘1.037e+03’
>>> ‘{0 :20.3f}’.format(x) # précise la longueur de la chaîne
‘ 1037.123’
>>> ‘{0 :>20.3f}’.format(x) # justifié à droite
‘ 1037.123’
>>> ‘{0 :<20.3f}’.format(x) # justifié à gauche
‘1037.123 ‘
>>> ‘{0 :^20.3f}’.format(x) # centré
‘ 1037.123 ‘
>>> ‘{0 :+.3f} ; {1 :+.3f}’.format(x, -x) # affiche toujours le signe ‘+1037.123 ; -1037.123’
>>> ‘{0 : .3f} ; {1 : .3f}’.format(x, -x) # affiche un espace si x>0
Appuyer sur la touche F2 (a A #) afin d’accéder à la table de caractères
Compétence 3 : Les fonctions en Python
Notes de l'enseignantDans cette troisième leçon de l’unité 1, vous allez utiliser l’éditeur de programme (script) afin de créer des fonctions, puis exécuter celui-ci afin d’observer les résultats dans la console.
Objectifs :
- Découvrir la notion de fonction en Python.
- Créer une fonction.
étape 1
Vers la notion de fonction en Python.
Mettre en œuvre l’algorithme suivant :
x ← 3
y ← 2 × x + 3
Dans une console, ceci se réalise très simplement.
Mais si l’on souhaite répéter ce type de calcul pour une autre valeur de x il faut écrire de nouveau l’ensemble de la séquence. Ce qui, sur un exemple moins trivial, peut s’avérer vite fastidieux.
On est donc conduit à créer une fonction qui nous permettra de dupliquer aisément le traitement de l’algorithme.
étape 2
|
En algorithmique, une fonction peut être considérée comme une séquence d’instructions, réalisant une certaine tâche, en utilisant un ou plusieurs arguments. Cette fonction reçoit un nom. • La programmation d’une fonction commence toujours par def suivi du nom de la fonction, suivi des arguments de celle-ci. Cette ligne se termine par le symbole : • Les deux points marquent le démarrage du bloc d’instructions définissant la fonction : toutes ces instructions sont indentées, c’est-à-dire décalées vers la droite par rapport à la première ligne. On ajoute en tête de chaque ligne, le même nombre d’espaces. |
def nom_fonction(liste des arguments) : |
La fonction renvoie un résultat par l’intermédiaire de la commande return. Le résultat peut être constitué d’une liste de résultats, une chaîne de caractères…
L’indentation, obtenue avec la touche de tabulation ou avec des espaces, est primordiale : tout ce qui est indenté après le def() sera exécuté́ comme un bloc. Il ne faut pas que l’indentation varie (nombre d’espaces, passer de la tabulation à des espaces…) en cours de bloc.
étape 3
Mise en œuvre d’un premier exemple.
- Créer un nouveau script.
Ouvrir l’application Python et choisir la création d’un nouveau script en appuyant sur F3 « Nouv ».
étape 4
- Donner un nom à votre script. Par exemple CALC puis valider en appuyant sur [entrer] (Le nombre maximal de caractères est fixé à 8).
- Le nom de votre script apparait ensuite en haut dans le bandeau gris EDITEUR : CALC
étape 5
- Choisir ensuite l’onglet F1 Fns… et utiliser les touches de direction [→] afin d’atteindre le menu Fonc
- Choisir le menu 1 : def fonction() : la parenthèse ouvrante clignote. Appuyer sur [alpha] afin de donner un titre à l’intérieur des parenthèses puis valider par Í.
étape 6
- Vous devriez obtenir l’écran ci-contre. Vous remarquerez l’indentation automatique du curseur
- Continuez ensuite par les instructions de traitement de l’algorithme. Souvenez-vous que l’affectation d’une variable s’effectue en appuyant sur la touche [sto →].
- Terminer votre script en appuyant de nouveau sur F1 Fns… puis les touches de direction [→] afin d’atteindre le menu Fonc
- Choisir seconde option 2 : return puis compléter l’instruction.
étape 7
A présent vous êtes prêts pour exécuter votre script.
- Appuyer sur l’onglet F4 Exec
- La console s’affiche et un message vous informe du chargement du script.
- Compléter l’invite de commande par le nom de la fonction avec les arguments prévus (un seul dans cet exemple), puis valider.
- Les touches de déplacement [↑] [↓] permettent de rappeler la dernière Entrée (voir la section Outils).
Application : Les fonctions en Python
Notes de l'enseignantÉcrire quelques scripts permettant de réinvestir les notions vues dans les leçons de l’unité 1.
– Fonction en langage Python.
– Création d’une liste.
Objectifs :
- Créer un convertisseur de température.
- Créer un script permettant de développer une expression algébrique.
étape 1
Exemple n°1 : Convertir une température.
Pour mesurer la température en France, on utilise le degré Celsius (°C). Dans les pays anglo-saxons, on utilise le degré Fahrenheit (°F).
Votre travail consiste à programmer une fonction qui réalise la conversion de température dans les deux sens : °C ↔ °F
Existe-t-il une température qui soit égale dans les deux unités ?
On rappelle : t(°F) = 9/5 × t(°C) + 32 et en première approximation on peut utiliser t(°F) = t(°C) × 1.8 + 32
étape 2
- Ouvrir l’application Python et commencer un nouveau script F3 (Nouv).
- Nommer le script TEMPERAT et valider en appuyant sur F5 (OK).
- Importer le module maths (Fns… puis [→] Modul puis 1 : math… et enfin 1 : from math import *).
- Créer une première fonction de conversion °C → °F (Fns… puis ~ Fonc et enfin def fonction( ) : ).
- Exécuter le début du script en réalisant la conversion en degré Fahrenheit d’une température de 40°C f(40).
étape 3
- Terminer la réalisation du script en rajoutant à la suite les instructions nécessaires à la conversion °F ↔ °C.
- Remarque utile : Utiliser dans la palette Outils l’option 2 : Indent ← afin de revenir à la ligne non indentée (sinon, un message d’erreur s’affichera lors de l’exécution du script).
- En résumé, la fonction f(c) donne une température °C → °F et la fonction c(f) réalise la conversion °F → °C.
étape 5
Pour rechercher enfin une valeur de la température qui soit identique dans les deux unités, de nombreuses méthodes sont possibles mettant en œuvre les boucles et les tests que nous verrons dans les unités 2 et 3.
Nous allons procéder en balayant une boucle avec un pas de 10° (à affiner éventuellement, et créer dans un autre script.
Aller dans le gestionnaire de scripts en appuyant sur F5.
- Mettre le curseur face au script TEMPERAT.
- Choisir l’onglet F5 (Gérer) puis choisir 1 : Dupliquer le script.
- Donner un autre nom au script (TEMP2) par exemple, puis valider par F5 OK.
étape 5
Le script est ainsi dupliqué sous un autre nom.
Nous rechercherons la solution dans l’intervalle [-60 ; 10] par pas fixé à 10° dans un premier temps. Le pas est une donnée à demander à l’utilisateur.
Nous allons utiliser trois instructions supplémentaires.
- round(a,2) afin d’arrondir un nombre « a » à 2 décimales.
- for i in range(début , fin , pas) afin de créer une double liste.
- Et enfin l’instruction print afin d’afficher les résultats.
Les fonctions s’obtiennent par F1 (Fns…) puis à partir des menus E/S ; Type et Ops. L’instruction round( ) se trouve dans le catalogue, mais peut aussi être entrée manuellement.
étape 6
Vous devriez obtenir les résultats de droite après avoir exécuté le script F4.
La boucle FOR, sera abordée lors de l’étude de l’unité 2 compétence 2.
- Compétence 1
- Compétence 2
- Compétence 3
- Application
Unité 2: Débuter la programmation en Python
Compétence 1 : Instruction conditionnelle
Notes de l'enseignantDans cette première leçon de l’unité 2, vous allez découvrir comment écrire et utiliser une instruction conditionnelle en Python.
Objectifs :
- Écrire et utiliser une instruction conditionnelle
- Réinvestir la notion de fonction en Python
étape 1
|
Dans un programme, il est particulièrement fréquent d’avoir à orienter l’exécution de celui-ci en fonction de conditions qui affectent les différentes variables. Une condition est un énoncé qui peut être vrai ou faux. Par exemple : a = b ou bien a ≥ b mais aussi n est pair sont des conditions qui sont vérifiées selon les valeurs affectées à ces variables. Dans un programme, on peut tester une condition et selon que celle-ci est vraie ou fausse, effectuer un traitement ou un autre. On parle alors de traitement conditionnel. |
If condition :
Instruction A else : Instruction B |
étape 2
|
Exemple : Une société de location de voitures propose à ses clients le contrat suivant : Un forfait de 66 € auquel s’ajoute 0.25 € par kilomètre au-delà de 70 km. Votre travail consiste à écrire un script qui permette de calculer automatiquement le coût C du contrat en fonction de la distance parcourue. |
Langage naturel X←a |
étape 3
Mise en œuvre :
- Démarrer l’application (PyAdaptr pour TI-83 Premium CE & adaptateur) ou (Python App pour TI-83 Premium CE Edition Python).
- Commencer un nouveau script F3 (Nouv) et le nommer « TARIF ». Valider en appuyant sur la touche F5 (OK).
- Appuyer sur la touche F1 (Fns..).
- L’instruction If est obtenue à partir du menu Ctl.
- Choisir le menu 3 :if..elif..else.
étape 4
- Observer l’indentation du bloc conditionnel.
- Le compléter en utilisant l’algorithme proposé en langage naturel.
étape 5
- Vous devriez obtenir le script ci-contre.
- L’instruction < et <= ainsi que and se trouve dans le menu (Fns…) puis Ops mais sont également accessibles en appuyant sur les touches y ».
étape 6
- Exécuter le script pour déterminer le coût d’un trajet avec une voiture louée à cette société.
étape 7
Appliquons nos connaissances : Fonction par morceaux
On donne la fonction affine par morceaux ƒ définie par :
Copier le script ci-contre et l’exécuter afin de compléter le
tableau ci-dessous.
| x | -4 | -1.5 | -0.5 | -0.1 | 0.6 | 2.5 | 4.8 | 7.3 |
| ƒ |
Compétence 2 : La boucle bornée For
Notes de l'enseignantDans cette seconde leçon de l’unité 2, vous allez découvrir comment répéter un processus ou un ensemble d’instructions en utilisant une boucle bornée FOR.
Objectifs :
- Découvrir et mettre en œuvre la boucle bornée FOR.
- Utiliser la boucle FOR dans des exemples simples.
étape 1
Il est parfois utile dans un programme de répéter une ou plusieurs instructions un nombre défini de fois. Si le nombre de répétition du processus est connu à l’avance, on utilise une boucle bornée For.
La syntaxe d’une boucle For est la suivante :
Langage naturel
Pour variable allant de minimum à maximum
Instructions
Langage Python
for variable in range () :
Instructions
étape 2
La fonction range() permet d’énumérer le nombre de passages dans la boucle bornée. Elle peut être appelée de plusieurs façons :
- for i in range(taille) : prend les valeurs entière de 0 à taille — 1, donc "taille" valeurs.
- for i in range(début, fin) : la variable i prend des valeurs entières de début à ƒin — 1, où début et ƒin sont ici des entiers.
- for i in range(début, fin, pas) : la variable i prend des valeurs entières de début à ƒin — 1 par valeurs s’incrémentant de pas. début, ƒin et pas sont ici des entiers.
- for i in liste : la variable i utilisera directement les valeurs de la liste de la première valeur jusqu’à la dernière.
Il n’existe pas d’instruction de fin de boucle. C’est l’indentation, c’est-à-dire le décalage vers la droite d’une ou plusieurs lignes, qui permet de marquer la fin de la boucle.
étape 3
Mise en œuvre :
Vous allez créer un script permettant de bien comprendre ce qu’est une boucle ainsi qu’un processus d’itération.
- Commencer un nouveau script et le nommer « BOUCLE ».
- Initialiser une liste vide avec l’instruction b=[ ]. En langage Python, les éléments d’une listes sont placés entre [ ], séparés par des virgules.
- Appuyer sur F1 (Fns…) et choisir dans le menu Ctl, l’option 4 : for i in range(taille)
- L’instruction .append( ) permet de compléter une liste. Ainsi, b.append(i**2) incrémente la liste b des carrés de i. A chaque valeur de i, la valeur de i2 est placée en fin de liste.
- La variable i variant de 0 à 4 ce qui correspond bien à un éventail de 5 valeurs.
étape 4
- Appuyer sur la touche F4 pour exécuter le script.
Demander ensuite l’affichage des valeurs de b à partir de la console
étape 5
Appliquons nos connaissances :
On réalise une construction à base de bâtons.
La première rangée notée « rangée 0 » est formée de 3 bâtons, la seconde de 7 bâtons et la troisième rangée de 11 bâtons.
étape 6
De combien de bâtons sera formée la rangée n°4.
Réaliser le script, puis l’exécuter
- Exécuter le programme pour déterminer combien la 100ème rangée comptera de bâtons.
Compétence 3 : La boucle non bornée While
Notes de l'enseignantDans cette troisième leçon de l’unité 2, vous allez découvrir comment répéter un processus ou un ensemble d’instructions en utilisant une boucle non bornée While.
Objectifs :
- Découvrir et mettre en œuvre la boucle non bornée While.
- Utiliser la boucle While dans des exemples simples.
étape 1
Il est parfois utile dans un programme de répéter une ou plusieurs instructions un nombre indéfini de fois. Si le nombre de répétition du processus n’est pas connu à l’avance, on utilise une boucle non bornée While.
La boucle est alors parcourue un nombre de fois jusqu’à ce qu’une condition ne soit plus vérifiée. Tant que cette condition est vérifiée, la boucle continue.
étape 2
La syntaxe d’une boucle While est la suivante :Langage naturel Tant que condition faire
Instructions
Langage Python while condition :
Instructions
Il n’existe pas d’instruction de fin de boucle. C’est l’indentation, c’est-à-dire le décalage vers la droite d’une ou plusieurs lignes, qui permet de marquer la fin de la boucle.
étape 3
|
Mise en œuvre : Exemple n°1 Vous allez créer un script permettant de bien comprendre ce qu’est une Mettre en œuvre l’algorithme ci-dessous : L’algorithme a pour objet de déterminer le plus petit entier n tel que le terme |
n←0 c←3.4 Tant que c ≥ 1 n←n + 1 c←0.8c Fin Tant que |
étape 4
- Commencer un nouveau script et le nommer « WHILE »
- L’instruction While est accessible en tapant sur F1 (Fns…) puis en choisissant le menu Ctl et enfin l’instruction 8 : while condition :
- Tant que la variable c sera strictement supérieure au seuil la variable n sera incrémentée de 1.
étape 5
- Appuyer sur F4 pour exécuter le script et observer l’affichage.
étape 6
Appliquons nos connaissances : Les rebonds du ballon :
Une balle est lâchée d’une hauteur de 1,20 m et rebondit sur le sol
des ⅗ de la hauteur du rebond précédent.
Vous devez élaborer un algorithme donnant le nombre de rebonds au bout duquel la hauteur atteinte par la balle est strictement inférieure à 1 cm.
- Définir une variable H dans laquelle on stockera la hauteur du rebond exprimée en cm et R une variable pour compter les rebonds
- On devra répéter plusieurs fois l’instruction H prend la valeur
⅗ × H sans connaitre à l’avance le nombre de répétitions. - On testera donc si H>1 et le traitement dans la boucle sera réalisé tant que cette condition restera vérifiée.
étape 7
Algorithme
H ← 90
R ← 0
Tant que H ≥ 1
H ← 3/5 × H
R ← R+1Fin Tant que
- Créer un nouveau script et le nommer rebonds.
- On propose d’utiliser une fonction. Ainsi on veillera à respecter les indentations (une pour l’instruction While et une seconde pour l’instruction Return permettant de renvoyer le contenu de la variable R.
- On peut également comme dans l’exemple n°1 créer une liste puis afficher les hauteurs successives des rebonds.
- Appuyer sur F3 (Outils) et choisir le menu 2 : Indent ← afin de fermer la boucle While, tout en conservant l’exécution de la fonction.
étape 8
- Pour exécuter le script, appuyer sur F4 (Exec).
- Entrer le nom de la fonction « rebonds() » et valider en appuyant sur la touche.
- Enrichir éventuellement le script à l’aide d’un message, par exemple :
return (« Nombre de rebonds = »,R)
Application : Boucles et tests
Notes de l'enseignantPour cette application de l’unité 2, on se propose de réinvestir les notions vues dans les leçons concernant les instructions conditionnelles ainsi que les boucles bornées et non bornées.
Objectifs :
- Utiliser la boucle While et For pour mettre en œuvre un algorithme relatif à un problème de probabilités ou de statistiques.
étape 1
Dans cette application, vous allez écrire un script permettant de :
- Obtenir un nombre aléatoire en créant une fonction
lancer. - Utiliser cette fonction dans un autre script afin de déterminer le nombre de lancers nécessaires pour obtenir une somme de 12 lors du lancer de 2 dés parfaitement équilibrés.
- Lors du lancer d’un seul dé, obtenir le nombre de fois où chaque face apparait afin éventuellement de calculer une fréquence à comparer à la probabilité de sortie de chaque face.
étape 2
Lancer un dé.
- Le travail sur les nombres aléatoires nécessite le chargement du module random avant la définition de la fonction.
- Créer un nouveau script et le nommer LANCER
- Appuyer sur F1 (Fns…) puis [←] (Modul) et choisir le module 2 : random
- Définir la fonction lancer( ) permettant d’obtenir un nombre aléatoire entier entre 1 et 6.
étape 3
- Tester votre script après avoir vérifié.
- Utiliser les touches de direction vers le haut ( } ) afin de relancer le script.
étape 4
Nombre d’essais nécessaires.
On lance deux dés à 6 faces parfaitement équilibrés et on additionne les deux résultats obtenus. Vous allez écrire un autre script afin de modéliser les lancers de ces deux dés et rechercher le nombre n de lancers nécessaires afin d’obtenir la somme de 12.
De nombreuses solutions sont possibles, mais la première qui vient à l’esprit est de réutiliser la fonction précédente.
étape 5
- La variable s donne la somme des lancers et n le nombre de lancers nécessaires avant d’atteindre 12.
- Toutes deux sont initialisées à 0
- En langage Python, le symbole ≠ est obtenu en appuyant sur les touches [2nde] [math] ou bien à partir du menu Fns… puis Ops lors de l’édition du script. Ce symbole est représenté par !=.
- Compléter le script en veillant à respecter l’indentation puis l’exécuter.
- Le premier nombre donne le nombre de lancers nécessaires pour atteindre la somme 12 affichée par le second.
étape 6
Échantillonnage et fréquence
Vous venez d’observer sur l’exemple précédent que le nombre d’essais nécessaires avant d’obtenir un 12 fluctue. On peut donc être conduit à calculer la fréquence d’échantillonnage, qui pour un grand nombre d’essais doit tendre vers la probabilité théorique.
Vous allez dans ce dernier script :
Utiliser une boucle for pour répéter un seul lancer.
- Calculer le nombre de fois où une face apparait.
- Utiliser une liste, ce qui a l’avantage de rendre le script plus court.
étape 7
- Créer un nouveau script et le nommer DE1
- Le résultat d’un lancer est stocké dans la liste l précédemment initialisée vide par l’instruction l=[ ].
- La liste f contient les numéros des faces.
- Ensuite un test est effectué sur la valeur de la variable (1 à 6) et chaque fois qu’une condition est vérifiée, une nouvelle liste fl est créé dans laquelle est stocké, pour chaque numéro de face variant de 1 à 6, le nombre d’occurrence observées.
- Modifier éventuellement le script afin de calculer la fréquence d’apparition de chaque face.
étape 8
Appuyer sur la touche F4 afin d’exécuter le script. Observer les effectifs de sortie de chaque face, pour 100 lancers, les fréquences sont simples à calculer.
- Compétence 1
- Compétence 2
- Compétence 3
- Application
Unité 3: Débuter la programmation en Python
Compétence 1 : Fonctions et boucles
Notes de l'enseignantDans cette première leçon de l’unité 3, vous allez mettre en œuvre vos connaissances en algorithmique et
en langage Python afin de :
- Rechercher les solutions d’une équation : ƒ (x) = 0
- Résoudre un problème d’optimisation.
Objectifs :
- Utiliser une fonction en langage Python.
- Mettre en œuvre la boucle bornée While.
étape 1
Principe de la dichotomie
On considère la fonction f définie sur l’intervalle [-2, 3] par ƒ (x) = x2 - 7x + 5
On utilise la calculatrice afin de tracer la courbe Cf représentant les variations de la fonction ƒ.
Vous allez résoudre l’équation ƒ (x) = 0 en écrivant un script Python correspondant à un algorithme connu et appelé « algorithme de dichotomie ».
étape 2
Pour comprendre ce qu'est la dichotomie, on propose une petite expérience : « chercher un mot dans un gros dictionnaire papier de 1024 pages » :
- Vous l'ouvrez au milieu : le mot ne s'y trouve pas, mais il est avant (il est donc dans les 512 premières pages).
- Vous ouvrez la moitié de la 1ère moitié : le mot ne s'y trouve pas, mais il est après (il est donc dans les pages 257 à 512).
- Vous ouvrez la moitié de la 2ème moitié, etc…
A chaque fois que vous progressez, le nombre de pages qui reste à examiner est divisé par 2.
Ainsi, dans un dictionnaire de 1024 pages, vous êtes certain de trouver votre page en 10 recherches seulement, puisque 1024/(210)=1
étape 3
|
Algorithme :
|
Commentaires : [a,b] :0 Bornes de l’intervalle d’étude |
étape 4
Mise en œuvre de l’algorithme :
- Encadrer entre deux entiers la valeur x0 solution de l’équation ƒ (x) = 0 avec une
précision donnée « prec ». - Vous remarquerez que : ƒ (0) × ƒ (1) < 0
- Calculer : ƒ (0) × ƒ (½) et ƒ × ƒ (1)
- En déduire si x0 appartient à l’intervalle [0; ½] ou [½; 1].
étape 5
Créer un nouveau script et le nommer DICHO
- Entrer les différentes instructions, celles-ci se trouvent pour leur ensemble sous l’onglet (Fns…).
- Les tests peuvent être obtenus directement par l’appui sur les touches y ».
- Appuyer sur y ƒ pour bloquer le clavier en mode alphanumérique.
- [a, b] représente l’intervalle d’étude et n le nombre d’étapes.
étape 6
Exécuter le script :
A partir de la représentation graphique de la fonction, tester le script.
étape 7
Affiner votre recherche afin de trouver une solution proche de celle qui est proposée par la calculatrice.
La valeur exacte de x0 dans l’intervalle [0; 1] étant donnée par :
x0 = (7 - √29) / 2
étape 8
Prolongements possibles :
a) Au lieu de donner la précision, on peut travailler avec le nombre d’étapes.
étape 9
La suite du script reste identique
b) Envisager une programmation récursive
if (b-a)<=prec :
return a,b
else :
c=(a+b)/2
if f(a)*f(b)<=0 :
return dicho(a,c,prec)
else :
return dicho(c,b,prec)
Compétence 2 : La boucle bornée For
Notes de l'enseignantDans cette seconde leçon de l’unité 3, vous allez découvrir comment répéter un processus ou un ensemble d’instructions en utilisant une boucle bornée FOR.
Objectifs :
- Appliquer une fonction.
- Découvrir et mettre en œuvre la boucle bornée FOR.
- Utiliser la boucle FOR dans des exemples simples.
étape 1
Constituer un échantillon :
Un sac opaque contient six jetons rouges et quatre jetons verts. On tire au hasard un jeton du sac, on note sa couleur puis on le replace
dans le sac.
Programmer une fonction couleur( ) simulant une expérience aléatoire de variable.
- Quelles sont les valeurs possibles prises par la variable x ?
- On souhaite écrire un script qui permette de distinguer les
boules rouges des vertes à l’aide d’un test
étape 2
- Commencer un nouveau script et le nommer « ECHANTIL »
- Comme vous travaillez sur des nombres aléatoires, le chargement de la bibliothèque « random » est nécessaire. Pour cela, appuyer sur l’onglet F1 (Fns…) et choisir le menu Modul puis 2 : random…
- Entrer le script ci-contre dans l’éditeur en veillant à respecter l’indentation.
étape 3
- Afficher le résultat de la fonction dans la console.
- Exécuter le script plusieurs fois en appelant la fonction couleur( ).
étape 4
Appliquons nos connaissances : Échantillonnage et prise de décision :
On a réalisé un sondage à la sortie du nouveau spectacle proposé par un artiste. Ce sondage réalisé dans une grande ville montre que les deux tiers des personnes ayant vu le spectacle l’ont aimé. L’agent de l’artiste pense que toute la population française est dans le même état d’esprit. Il commande une enquête auprès d’un institut de sondage pour le vérifier.
étape 5
Étude de la population :
Pour des besoins de l’enquête statistique, l’institut de sondage doit créer une fonction qui simule la réponse à la situation.
Votre travail consiste à créer cette fonction en respectant le cahier des charges suivant :
- Le spectacle a été apprécié, avec une probabilité p = ⅔.
- Le spectacle n’est pas apprécié, avec une probabilité p = ⅓.
- Commencer un nouveau script et le nommer PROBAS.
- Écrire cette fonction dans l’éditeur et la tester plusieurs fois en appuyant sur F4 (Exec) puis en tapant dans la console le nom de la fonction sans arguments : question( )
Astuce : on peut utiliser la touche VAR puis flèche du haut pour répéter l’exécution, (c’est peut-être plus rapide que de taper le nom de la fonction…)
étape 6
Simulation d’un échantillon de taille n :
L’institut de sondage souhaite simuler des échantillons de taille variable.
Vous devez donc créer dans le script courant une fonction échantillon(n) permettant de poser la question<br> à un échantillon de taille n.
- Pour cela, créer une liste vide l.
- Remplir cette liste en utilisant la fonction question() et en utilisant une boucle For.
étape 7
- Tester la fonction echantillon(n) pour un échantillon de taille 20, en exécutant le script et en tapant dans la console « echantillon(20) ».
étape 8
|
Validation de l’échantillon : L’institut de sondage souhaite déterminer le pourcentage d’échantillons dont la fréquence de personnes qui ont apprécié le spectacle appartient à l’intervalle de fluctuation à 95% de p = ⅔ A la suite du script précédent, il vous est demandé de créer deux fonctions :
|
Algorithme  |
étape 9
A partir de la fonction interv_fluctu écrit en langage naturel, vérifier que vous obtenez la fonction interv_fluctu en Python.
étape 10
- Tester le script plusieurs fois pour un échantillon de taille 100
- En déduire pour un exemple, l’intervalle de fluctuation à 95%.
- Cette étude statistique remet-elle en question l’affirmation de l’agent de l’artiste ?
Compétence 3 : Programmation et récursivité
Notes de l'enseignantDans cette troisième leçon de l’unité 3, vous allez utiliser les fonctions afin de réaliser une programmation récursive.
Objectifs :
- Appliquer une fonction.
- Découvrir et mettre en œuvre la programmation récursive.
étape 1
Calcul de PGCD (Méthode itérative)
Pour calculer le « plus grand commun diviseur de deux nombres » (PGCD), on utilise l’algorithme d’Euclide.
Remarque : a > b
On procède de la manière suivante :
- On effectue la division euclidienne de a par b. On note r le reste (on n’utilise pas le quotient).
- On remplace ensuite a par b et b par r.
- Tant que le reste est différent de 0, on réitère le procédé.
Après un certain nombre d’itérations, on obtient un reste égal à 0.
étape 2
Le PGCD de a et de b est alors le reste précédent (c’est à dire le dernier reste non nul).
- Créer un nouveau script et le nommer pgcd
- Créer une fonction pgcd(a,b) en tapant sur F1 menu (Fonc)
- Le symbole ≠ s’écrit en langage Python à l’aide de ! = et se trouve dans le menu F2 (a A…) ou bien dans le menu tests de la calculatrice.
- Noter l’affectation a,b=b,r dans le script qui permet de gagner une ligne de code, mais qui correspond à la réalisation des affectations a = b et b = r
étape 3
- Exécuter le script pour différents nombres.
étape 4
Un pas plus loin .
3 : Programmation récursive :
Un algorithme est dit récursif si, à un moment, il s'appelle lui-même.
La récursivité peut posséder de nombreux avantages dans un algorithme. Premièrement, elle permet de résoudre des problèmes, d'habitude insolubles avec l'utilisation de simples boucles pour ou tant que. Elle peut aussi rendre un algorithme plus lisible et plus court, mais surtout, elle permet, dans certains cas, un gain colossal de temps comme c'est le cas dans les algorithmes de tri.
étape 5
Un premier exemple de récursivité :
- Créer un nouveau script et le nommer REC1.
- Entrer le script ci-contre.
- Quel est le cas de base dans cette fonction récursive ?
- Qu’est ce qui garantit dans cette fonction récursive, que le script finira par s’arrêter ?
- Écrire le processus complet.
étape 6
- Exécuter le script dans une console.
- Que retourne f(a,b) a et b étant des entiers naturels non nuls ?
étape 7
3.1 : Un calcul de pgcd récursif :
Le calcul du PGCD de deux entiers positifs a et b utilise toujours l'algorithme d'Euclide. Soit r le reste de la division euclidienne de a par b :
a = b*q + r , r < b.
Tout diviseur commun de a et b divise aussi r = a – b*q
et réciproquement tout diviseur commun de b et r divise aussi a = b*q + r.
Donc le calcul du PGCD de a et b se ramène à celui du PGCD de b et r ; et on peut recommencer sans craindre une boucle sans fin, car les restes successifs sont strictement décroissants. Le dernier reste non nul obtenu est le PGCD cherché.
étape 8
Par exemple si a=96 et b=81, les calculs sont les suivants :
et le PGCD est 3
étape 9
- Exécuter le script en appuyant sur la touche F4 (Exec) et le tester pour quelques valeurs.
Application : Tests, boucles
Notes de l'enseignantDans cette application de l’unité 3, vous allez utiliser les notions acquises dans les leçons précédentes afin de programmer des algorithmes vous permettant d’affiner vos connaissances des nombres et en particulier des nombres premiers.
Objectifs :
- Mettre en œuvre les boucles et tests pour la programmation complète d’un algorithme en Python.
étape 1
Un nombre entier est dit premier s’il possède exactement deux diviseurs : 1 et lui-même.
Par exemple :
- 1 n’est pas premier (il ne possède qu’un seul diviseur : 1)
- 7 est un nombre premier (ses diviseurs sont 1 et 7).
- 8 n’est pas premier (il possède quatre diviseurs : 1, 2, 4 et 8)
Les nombres premiers sont : 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, …
Il en existe une infinité.
On se propose de déterminer le 2019ème nombre premier.
étape 2
|
On considère l’algorithme ci-contre.
|
 |
étape 3
|
La partie principale du programme est donnée par l’algorithme ci-contre. Votre travail consiste à implémenter cet algorithme en langage Python afin de répondre au problème posé. |
 |
étape 4
- Commencer un nouveau script et le nommer NBREPREM.
- Entrer les différentes instructions en veillant à respecter l’indentation.
étape 5
- Appuyer sur la touche F4 pour exécuter le script (temps de calcul très long sur la calculatrice environ 10 minutes).
- Vérifier que le 2019e nombre premier est bien 17569.
- Compétence 1
- Compétence 2
- Compétence 3
- Application
Unité 4: Utiliser le module ti_plotlib
Compétence 1 : Paramétrer une représentation
Notes de l'enseignantAttention : ces unités sont réalisées avec la mise à jour 5.5 pour TI-83 Premium CE Edition Python. Pour la télécharger, rendez-vous dans l'onglet "Mise à jour et logiciels".
Dans cette première leçon de l’unité 4, vous allez découvrir comment écrire et utiliser une instruction permettant de faire des représentations graphiques en Python. Vous apprendrez également à représenter un graphique et paramétrer l’affichage.
Objectifs :
- Découvrir le module ti_plotlib.
- Représenter un point, un segment.
- Paramétrer une représentation graphique.
étape 1
1 : La librairie ou module ti_plotlib
Pour effectuer une représentation graphique lors de l’exécution d’un script, celui-ci doit être en mesure de comprendre les instructions graphiques. Il est donc nécessaire « d’embarquer » les fonctions graphiques au sein d’une bibliothèque ti_plotlib.
Commencer un nouveau script en le nommant U4SB1 et inclure dans celui-ci le module ti-plotlib (touches : [ f(x) ] [ ← ]). Choisir le menu 5 : ti_plotlib… puis le menu 1 : import ti_plotlib as plt.
étape 2
Pour cette première partie, vous allez écrire un script permettant d’afficher un point dont les coordonnées sont connues. Ensuite, vous modifierez votre script afin de localiser votre point dans un repère et modifierez sa couleur.
Pour terminer cette première leçon, vous demanderez l’affichage du nom de chaque axe et donnerez un titre à votre graphique.
étape 3
Définir une fonction ayant pour argument les coordonnées d’un point, puis demander l’affichage de ce point.
- Dans un premier temps, nettoyez votre écran en utilisant l’instruction plt.cls() que vous trouverez dans le module ti_plotlib au menu Configurer (2 : cls()).
- Pour dessiner le point, choisir l’instruction 6 : Tracé un point, située dans le menu Dessin du module ti-plotlib.
- Choisir la marque désirée.
étape 4
Terminer le script en demandant l’affichage de la représentation par le choix de l’instruction plt.show_plot() (instruction n°9 du module ti-plotlib, menu configurer).
- Demander l’exécution du script (touche F4), puis appuyer sur la touche [ var ] afin de rappeler dans la console la fonction point().
- Donner les coordonnées d’un point et observer votre écran.
étape 5
- Appuyer sur la touche [ annul ] pour sortir de l’écran graphique, puis sur [ var ] afin de retrouver la liste des variables du script.
- Modifier les coordonnées de votre point (par exemple point(10,10) et constater que celui-ci n’est plus visible à l’écran.
étape 6
2 : Affiner votre représentation
Inclure l’instruction plt.cls() sous la définition de la fonction, afin d’éviter d’avoir la barre de menu (Fns à Script) superposée à votre représentation graphique.
étape 7
A partir des différentes options du menu Configurer du module ti_plotlib, rajouter dans votre script les instructions permettant :
- De définir une fenêtre graphique telle que : Xmin = -10 ; Xmax = 10 ; Ymin = -10 et Ymax = 10 (instruction 4 : window).
- Afficher une grille (instruction 3 : grid) le type de grille est laissé à votre choix.
- Afficher les axes (instruction 6 : axes).
- Modifier la couleur du point (Menu Dessin, puis 1 : color(r,v,b)).
étape 8
Exécuter votre script et observer les changements. Vous devriez obtenir un écran identique à celui ci-contre.
étape 9
Modifier à nouveau le script afin de donner un nom à vos axes. Par exemple (« abscisse » et « ordonnée »).
Pour cela, inclure dans votre script (peu importe l’emplacement) une ligne plt.labels. Celle-ci se trouve à l’emplacement 7 : labels() du menu Configurer dans le module ti_plot.
étape 10
Si vous le souhaitez, vous pouvez également ajouter un titre à l’aide de l’instruction plt.title(« Repérage »).
Rappel : Les caractères accentués sont obtenus à partir de l’éditeur de script en appuyant sur la touche F2 [ a A # ], puis en utilisant les touches de direction afin de choisir dans la palette le caractère souhaité.
étape 11
Pour aller plus loin : Compléter votre script en écrivant une fonction vous permettant de représenter graphiquement un segment. Vous trouverez ci-contre les instructions essentielles. Vous pouvez bien entendu si vous le souhaitez modifier le script afin d’afficher les axes, une grille …etc.
étape 12
L’option plt.pen accessible via le menu Dessin (9 : pen(« taille », « type »)), permet de paramétrer la largeur du trait.
Compétence 2 : Représenter graphiquement une fonction
Notes de l'enseignantDans cette seconde leçon de l’unité 4, vous allez découvrir comment représenter graphiquement une fonction en utilisant la librairie Python ti_plotlib.
Objectifs :
- Représenter graphiquement une fonction.
- Réinvestir la notion de boucle fermée.
- Paramétrer la représentation graphique.
étape 1
On se propose de réaliser un script utilisant la librairie ti_plotlib et permettant de tracer la représentation graphique d’une fonction pour x prenant ses valeurs dans un intervalle [a ; b] avec N segments.
Le script que vous allez créer sera très général afin de pouvoir être réinvesti pour d’autres exemples.
étape 2
- Commencer un nouveau script et le nommer U4SB2.
- Importer le module ti_plotlib, celui-ci s’obtient en appuyant sur la touche o | puis en choisissant 5 : ti_plotlib.
- Définir la fonction g:x ⟼ x2 - 3x + 4.
étape 3
A présent vous êtes prêts pour effectuer la représentation graphique de la fonction. Insérer les instructions permettant de :
- Nettoyer l’écran : plt.cls().
étape 4
- Régler les paramètres de la fenêtre graphique :
plt.window(xmin, xmax, ymin, ymax). - Afficher les axes du repère : plt.axes(« on »).
- Afficher le nom des axes : plt.labels(« x », « y »).
- Effectuer la représentation graphique plt.plot(lx,ly, « + »).
- Afficher la représentation graphique : plt.shox_plot().
L’ensemble de ces instructions se trouve dans le module ti_plotlib, les paramètres de réglages de la représentation graphique dans le menu Configurer et l’instruction de représentation graphique dans le menu Dessin puis 5 : Tracé connecté avec listes.
étape 5
Remarque : les instructions pour le choix de la couleur en RVB (rouge, vert, bleu) sont à coder entre 0 et 255 et à placer judicieusement, afin d’éviter par exemple d’avoir les axes en rouge.
étape 6
Exécuter le script puis choisir la fonction graphe() en appuyant sur la touche [ var ] .
Demander la représentation graphique de la fonction contrainte sur l’intervalle [0 ; 3] avec 25 segments.
étape 7
Prolongements possibles :
- Afficher un quadrillage.
- Changer de fonction ou en étudier plusieurs.
- Réaliser une étude mathématique (calcul différentiel), représenter par exemple la fonction avec 6 segments puis 50.
Compétence 3 : Nuage de points et régression
Notes de l'enseignantDans cette troisième leçon de l’unité 4, vous allez découvrir comment représenter graphiquement une série de données, puis rechercher un modèle mathématique s’ajustant au mieux au nuage de points.
Objectifs :
- Réaliser la représentation d’un nuage de points.
- Rechercher et utiliser un modèle de régression.
- Utiliser les listes en Python.
étape 1
Position du problème : Lors d’une inondation, afin de fournir à la population des informations pratiques, les autorités enregistrent, chaque heure à partir du début de la décrue, la hauteur d’eau maximale par rapport à un point de référence.
Les données sont fournies dans le tableau ci-dessous. On souhaite représenter le nuage de points en utilisant la librairie ti_plotlib, puis rechercher un modèle mathématique permettant de faire une extrapolation, afin de prévoir le temps total de la décrue.
| T(h) | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
| H(cm) | 130 | 127 | 123 | 118 | 116 | 111 | 105 | 103 | 101 | 95 | 86 | 80 | 71 |
étape 2
Mise en œuvre : Commencer un nouveau script et le nomme U4SB3.
- Importer le module ti_plotlib.
- Enregistrer les données dans deux listes « lt » et « lh ».
étape 3
- Préparer ensuite la représentation graphique :
- Effacer l’écran plt.cls().
- Régler les paramètres de la fenêtre graphique : xmin = -2 ; xmax = 20 ; ymin = -20 ; ymax = 200 en écrivant plt.window(-2, 20, -20, 200).
- Afficher les axes plt.axes().
- Afficher la représentation graphique sous forme d’un nuage de points plt.scatter().
Les instructions de paramétrage de la fenêtre graphique se trouvent dans le module ti_plotlib dans le menu Configurer. La syntaxe de la représentation du nuage de points se situe quant à elle dans le menu Dessin.
étape 4
Exécuter le script et observer la représentation graphique. Si tout se passe correctement, vous devriez obtenir l’écran ci-contre.
L’ensemble des points semble-t-il aligné ?
Vous allez maintenant rechercher le modèle mathématique (affine) passant au mieux par l’ensemble des points du nuage.
Pour cela, vous devez rajouter la ligne plt.lin_reg(xliste,yliste,1) dans votre script afin que la droite de régression soit calculée à partir des listes de données lt et lh, puis affichée.
étape 5
Afin de connaitre l’heure de la décrue totale, il vous reste à résoudre l’équation du premier degré -4.64x + 132.90 = 0
étape 6
Améliorons notre représentation graphique :
Inclure dans votre script des instructions permettant de conserver les axes en noir plt.color(0,0,0), puis une représentation graphique du nuage de point en rouge plt.color(255,0,0) et enfin une représentation en bleu de la droite de régression plt.color(0,0,255)
étape 7
Il est aussi intéressant de rajouter un titre et des étiquettes aux axes
Application : Positions successive d’un mouvement
Notes de l'enseignantDans l’application de l’unité 4, vous allez découvrir comment étudier un mouvement à partir des mesures effectuées sur une chronophotographie et réinvestir les connaissances acquises lors de l’utilisation du module ti_plotlib.
Objectifs :
- Représenter un nuage de points.
- Effectuer le calcul puis la représentation de vecteurs d’un système modélisé par un point.
étape 1
Le problème : On étudie le mouvement d’une balle de golf à partir d’une chronophotographie (enregistrement d’un mouvement par prise de photographies selon un intervalle de temps fixé). On souhaite représenter l’évolution du vecteur vitesse au cours du temps.
Les positions sont relevées toutes les 0,066 s et sont rassemblées dans un tableau.
Remarque : dans l’unité 5, vous apprendrez à importer les mesures depuis les listes de la calculatrice en utilisant le module ti_system.
étape 2
| t(s) | 0 | 0.066 | 0.132 | 0.198 | 0.264 | 0.33 | 0.396 | 0.462 | 0.528 | 0.594 | 0.66 |
| x(m) | 0.01 | 0.25 | 0.57 | 0.91 | 1.22 | 1.54 | 1.87 | 2.16 | 2.49 | 2.81 | 3.15 |
| y(m) | 0.015 | 0.34 | 0.681 | 1.01 | 1.297 | 1.559 | 1.768 | 1.95 | 2.08 | 2.158 | 2.193 |
étape 3
Mise en œuvre :
- Entrée des mesures et création des valeurs du temps.
- Commencer un nouveau script et le nommer U4APPS.
- Importer la librairie ti_plotlib de représentation graphique.
- Entrer les mesures correspondant aux coordonnées d’un point repéré lors de l’analyse de la chronophotographie.
- Calcul des vecteurs vitesses.
étape 4
Le vecteur vitesse à un instant t est donné par la relation : 
On ne peut donc pas dessiner le vecteur vitesse du dernier point de la liste, il faut en tenir compte dans le code.
Astuce : Afin de rendre la représentation graphique lisible, on utilisera un facteur d’échelle de 2.
étape 5
- Régler les paramètres de la représentation graphique :
- plt.cls() pour effacer l’écran.
- plt.title(« titre ») pour donner un titre à la représentation graphique.
- plt.window(xmin, xmax, ymin, ymax) pour régler la fenêtre graphique.
- plt.grid(xscl, ysc, « type ») pour afficher une grille de graduation 0.5.
- plt.color(255,0,255) pour un affichage en couleur magenta.
- plt.scatter(xlist, ylist, « type ») pour un affichage sous forme d’un nuage de points.
- plt.color(0,0,0) pour un affichage en couleur noire pour les axes.
- plt.pen(« medium », « solid ») pour un affichage des axes en épaisseur moyenne.
étape 6
- plt.labels(« x(m) », « y(m) ») pour afficher les étiquettes aux lignes 12 et 2 par défaut.
Le tracé des vecteurs est effectué au sein d’une boucle fermée de n-1 valeurs.
- plt.line(x0,y0,x1,y1) pour le tracé d’un vecteur vitesse.
- plt.show() pour afficher la représentation graphique.
étape 7
Rappel : La position de la balle entre les instants ti et ti+1 peut-être repérée dans un repère cartésien par xi + vxi × dt pour l’abscisse et yi + vyi × dt pour l’ordonnée.
Exécuter votre script ; vous devriez obtenir une représentation graphique analogue à celle de l’écran ci-contre.
- Compétence 1
- Compétence 2
- Compétence 3
- Application
Unité 5: Utiliser le module ti_system
Compétence 1 : Travailler sur des données
Notes de l'enseignantAttention : ces unités sont réalisées avec la mise à jour 5.5 pour TI-83 Premium CE Edition Python. Pour la télécharger, rendez-vous dans l'onglet "Mise à jour et logiciels".
Dans cette première leçon de l’unité 2, vous allez découvrir comment utiliser la librairie ti_system pour importer ou exporter des listes dans un script Python.
Objectifs :
- Importer-exporter des listes.
- Réinvestir les notions de l’unité 4 sur les représentations graphiques.
étape 1
La librairie ou module ti_system utilisée seule ou en complément des autres, permet de communiquer (dans les deux sens) avec la calculatrice graphique.
2 : var=recall_list(« nom ») et 3 : store_list(« nom »,var)
étape 2
Les autres options de cette librairie seront abordées dans les autres leçons de cette unité.
étape 3
1 : Importer des données depuis la calculatrice.
a) Création de deux listes
Dans un premier temps nous allons simplement entrer des données dans des listes (L1 et L2).
- La calculatrice étant en fonctionnement habituel (hors programmation), effacer le contenu des listes en allant dans le menu mémoire (2nd + ) » en appuyant sur [ 2nde ] [ + ] puis 4 : EffTtesListes.
étape 4
- Entrer dans l’éditeur de liste et mettre le curseur sur L1 comme sur l’écran ci-contre.
étape 5
Vous allez créer dans la liste L1 une suite de nombre entre 0 et 12 afin de pouvoir représenter graphiquement les points calculés dont on a calculé les coordonnées à l’aide d’une fonction définie par : x ⟼ -x2 /2 + 3x + 1
étape 6
Appuyer sur [ 2nde ] [ stats ] [ → ] [ → ] puis choisir l’instruction 5 : suite et compléter les paramètres afin de construire une suite de nombres dans l’intervalle [0 ; 12] par pas de 0.2.
étape 7
Une fois le curseur sur Coller, appuyer sur la touche [ entrer ] afin de valider la création de la suite.
étape 8
Les valeurs calculées sont recopiées dans la liste L1.
étape 9
Placer le curseur sur L2 et demander le calcul des images par la fonction :
x ⟼ -x2 / 2 + 3x + 1 des valeurs de la liste L1 à l’aide de l’instruction L2 = -0.5L12 + 3L1 + 1, puis valider le calcul [ entrer ].
étape 10
Paramétrer votre représentation graphique sous forme d’un nuage de points. Afficher la représentation graphique [ zoom ] [ 9 ] en vérifiant par ailleurs qu’aucune fonction n’est activée (touche [ f(x) ]).
étape 11
Régler les paramètres de la fenêtre graphique tels que : Xmin = -1.2 ; Xmax = 8 ; Ymin = -0.5 et enfin Ymax = 6.5.
étape 12
b) Import des données dans un script Python
- Commencer un nouveau script et le nommer U5SB1.
- Créer deux variables listes (vides) absc et ordo.
- Importer les librairies ti_system et ti_plotlib (il n’y a pas d’ordre)
étape 13
- Créer une variable absc puis, à partir des options de la librairie ti_system, choisir l’option 2 : var=recall_list(« nom »). Comme les abscisses sont dans la liste L1, le champ « nom » est complété par le nombre 1
- Créer une autre variable ordo et procéder de la même manière avec la liste L2.
étape 14
- Exécuter le script puis vérifier le contenu de vos variables absc et ordo en appuyant sur la touche [ var ].
- Rappeler ensuite le nom de la « liste » absc puis valider [ entrer ].
- Procéder de la même façon avec la liste des ordonnées (ordo)
étape 15
c) Représentation graphique
Paramétrer votre représentation graphique comme proposé sur l’écran ci- contre.
étape 16
Exécuter votre script (touche F4).
étape 17
2 : Exporter des données
Créer un nouveau script et le nommer U5SB11
étape 18
- Créer une fonction nommée data(a,b,n).
- Vous allez créer deux listes de données à représenter sous forme d’un nuage de points comportant des valeurs dans un intervalle [a ; b], calculées avec un pas n.
- Dans la liste y, on calcule la racine carrée des valeurs de la liste x.
- Pour créer ces listes de données, nous allons construire une boucle fermée après avoir bien entendu crée deux listes vides.
- Pour l’export de listes vers celles de la calculatrice, la syntaxe est la suivante : store_list(« n° de liste »,nom). Le numéro de liste dans la calculatrice correspondant aux listes L1 à L6
étape 19
Remarque : Attention à l’indentation, les instructions store_list n’ont pas à être dans la boucle. Utiliser le menu Outils (F3), puis l’option 2 : Indent <- afin de supprimer un niveau de décalage, (Il est aussi possible d’utiliser la touche [ suppr ].
- Exécuter votre script. On prend ici 20 valeurs de 0 à 20 par pas de 1
- Sortir de l’environnement Python et afficher la représentation graphique de vos listes L1 et L2.
Compétence 2 : Modélisation
Notes de l'enseignantDans cette seconde leçon de l’unité 5, vous allez découvrir comment importer les résultats d’une modélisation en utilisant la librairie ti_system.
Objectifs :
- Effectuer une modélisation linéaire.
- Importer les résultats de cette modélisation dans un script Python.
étape 1
Vous allez dans cette leçon effectuer une modélisation linéaire à partir de données préalablement inscrites dans les listes de la calculatrice. Ensuite, vous écrirez un script afin d’importer les résultats de cette modélisation afin de les utiliser pour une représentation graphique, une interpolation ou extrapolation…
Le problème : Dans une journée, le pic de consommation d’électricité est atteint vers 19 h. Au niveau national, on a enregistré un pic de consommation de 96 350 mégawatts le mercredi 15 décembre 2019 à 19h02. Vous désirez prévoir les pics de consommation du prochain week-end pour la zone directement raccordée à la centrale.
Pour établir cette prévision, vous disposez de dix relevés de consommations réalisés à 19h en fonction de la températureet présentés dans le tableau ci-dessous.
| T°C | 11 | -5 | -8 | -6 | 9 | 14 | 4 | -1 | -12 | 3 |
| MW | 3 | 5.7 | 6.6 | 6.3 | 3.4 | 2.7 | 4 | 5.1 | 7.1 | 4.6 |
étape 2
Les données sont entrées dans les listes de la calculatrice, la température dans L1 et la consommation en MW dans L2.
étape 3
Appuyer sur [ stats ] [ → ] [ ↓ ] [ ↓ ] [ ↓ ] pour effectuer une modélisation linéaire sous la forme y = ax + b.
étape 4
Suivre les indications proposées et sauvegarder le résultat de la régression dans l’éditeur de fonction en Y1.
étape 5
La fonction permettant de prévoir la consommation en fonction de la température est donc : C = - 0.18 × t + 5.01 .
étape 6
Utilisation des résultats de la modélisation dans un script Python.
- Commencer un nouveau script et le nommer U5SB2.
- Incorporer le menu ti_system et ti_plotlib.
- Créer deux listes temp et conso vides (temp = [ ] et conso = [ ] .
étape 7
Rappeler le contenu des listes L1 et L2 dans leurs noms respectifs.
L’instruction var=recall_list(« nom ») est accessible dans le menu du module ti_system (voir Unité 5 Compétence 1).
Rappeler également dans une variable eq, l’expression du modèle linéaire calculé.
étape 8
Tester votre script et demander l’affichage des différentes variables ainsi créées en appuyant sur la touche [ var ] puis en choisissant vos variables.
étape 9
Remarque : l’équation de régression est importée en tant que chaîne de caractères.
étape 10
Pour compléter cette leçon et réinvestir les compétences acquises lors de l’unité 4, vous pouvez effectuer la représentation graphique de vos mesures ainsi que du modèle de régression calculé.
étape 11
L’instruction plt.lin_reg ( ) correspond à l’option 8 : plt.lin_reg(x-liste, y-liste, aff) du menu Dessin de la librairie ti_plotlib.
étape 12
Remarque : l’instruction plt.auto_window(x_list, y_list) permet d’ajuster automatiquement les paramètres de la fenêtre graphique. C’est en quelque sorte l’équivalent du ZOOM 9 (ZOOM Statistiques) de la calculatrice TI-83 Premium CE.
étape 13
Prolongement : prévoir la consommation pour une température donnée.
Vous allez récupérer dans deux variables a et b les coefficients de l’équation afin de les utiliser dans une fonction vous permettant de réaliser ainsi une extrapolation ou une interpolation de la consommation électrique, lorsque la température est connue.
Définir une fonction prev(t) qui retournera la consommation prévue pour une température t.
étape 14
Exécuter votre script et effectuer quelques tests pour différentes températures.
On rappelle que le modèle représente une prévision de consommation électrique à 19h02 en fonction de la température.
Vous pouvez ainsi déterminer les limites de validité de votre modèle.
Compétence 3 : Affichage et temporisation
Notes de l'enseignantDans cette troisième leçon de l’unité 5, vous allez découvrir comment utiliser les options d’affichage et de « temporisation » de la librairie Python ti_system.
Objectifs :
- Comprendre le fonctionnement des instructions disp…
- Utiliser ces instructions dans un script en complément de celles des autres librairies.
étape 1
1 : Les instructions disp
Lors des leçons 1 et 2 de cette unité, vous avez appris à importer exporter des listes de données puis à travailler sur l’équation de régression.
étape 2
- Commencer un nouveau script et le nommer U5SB3.
- Importer le module ti_system.
- Incorporer la ligne disp_clr().
- Appuyer sur la touche F5 afin d’afficher la liste des scripts et passer en mode console (shell, touche F4).
- Observer dans votre console la présence de lignes de texte ou messages d’information.
étape 3
- Rappeler votre script U5SB3 et demander son exécution. Vous devriez obtenir l’écran ci-contre.
étape 4
L’instruction disp_clr() nettoie l’écran et place le prompt de la console en haut de l’écran. Vous obtenez ainsi au sein d’un programme un écran débarrassé de ses précédents affichages.
étape 5
- Continuer l’édition du script en insérant dans une boucle fermée, l’instruction 7 : disp_at(ligne, « txt », « align ») que vous trouverez dans le module ti_system. Cette instruction affiche à la ligne i de l’écran, le texte en l’alignant à gauche, droite ou centre de la ligne.
étape 6
- Exécuter à nouveau votre script et observer ce que vous obtenez.
étape 7
Reprendre le script et le modifier comme sur l’écran ci-contre en créant trois variables chaînes de caractères l, c, r que l’on inclue ensuite dans une liste p (position).
Par la suite, lors de l’exécution de la boucle fermée, le mot devrait être décalé.
L’indice d’écriture du mot est décalé, puisqu’il est commun avec celui de la liste p. On ne peut pas écrire sur une ligne d’indice 0, cela causera un message d’erreur lors du fonctionnement du script.
étape 8
Une suggestion pour prolonger cette instruction : réaliser des poèmes graphiques.
étape 9
L’instruction disp_wait() met l’exécution du script en pause. Appuyer sur la touche [ entrer ] afin de poursuivre son exécution.
étape 10
Supprimer l’instruction disp_wait() et lui substituer sleep(secondes). Cette dernière instruction introduit une temporisation de la durée indiquée.
Ainsi, le mot proposé s’affichera dans sa position correspondant à la valeur de la liste p[ i ] toutes les 2 secondes.
étape 11
L’instruction disp_cursor(1) affichera le curseur sous la forme d’un trait vertical, à la fin du mot à afficher.
étape 12
disp_cursor(0) ne l’affichera pas.
étape 13
2 : les instructions escape()
Créer un nouveau script et le nommer USB531.
- Mettre l’instruction disp_clr() afin d’effacer l’écran.
- Définir une fonction ayant pour argument un entier.
Dans une boucle fermée, l’instruction if escape() : break arrêtera l’exécution du script si vous appuyez sur la touche [ annul ].
- Sinon la valeur i de l’incrément de la boucle sera stockée dans une variable x .
- Une pause de 1 seconde permet de voir affiché à l’écran le texte « 00 ».
étape 14
Lors de l’exécution du script, vous verrez votre écran scintiller très légèrement. L’objectif de ce script est d’afficher lors de l’appel de la fonction c(n) de provoquer l’affichage ci-contre.
étape 15
Le fonctionnement de l’instruction while not escape() est identique quant à la touche à presser, mais son action est semblable à la précédente puisqu’ici, le script poursuivra son exécution tant que l’on n’appuie pas sur la touche [ annul ].
Application : Etude de la chute libre
Notes de l'enseignantDans cette application de l’unité 5, vous allez réinvestir les notions vues lors dans l’unité 4 et 5 afin de créer un simulateur permettant de décrire un mouvement.
Objectifs :
- Effectuer une simulation d’une chronophotographie.
- Exporter les résultats dans les listes de la calculatrice.
étape 1
On propose dans cette application de l’unité 5, d’utiliser le langage Python afin de créer un simulateur d’un phénomène physique. Nous retenons l’étude de la chute libre :
- Le script devra permettre la description d’un mouvement ;
- La représentation graphique des données sous forme d’une chronophotographie ;
- L’export des données vers les listes de la calculatrice.
Le problème : Une balle est lâchée sans vitesse initiale d’une hauteur h. Les photographies sont effectuées au cours du temps toutes les 60 ms.
Vous allez écrire un script permettant de calculer, au cours du temps, la position de la balle, puis de la représenter graphiquement.
étape 2
a) Calcul des positions successives
Lors de la chute libre, à partir d’une origine des temps et des espaces choisis (y>0), la position de la balle peut être calculée en utilisant la relation y = -g/2 × t2+h0 .
Rappelons que, g = 9,81 m.s-2.
Créer un nouveau script et le nommer U5Apps.
- Importer les modules ti_system et ti_plotlib.
- Nettoyer l’écran.
- Créer une fonction chrono(h) prenant comme paramètre la hauteur initiale à laquelle est lâchée la balle et qui affiche la position de la balle en fonction du temps.
- Créer trois listes vides, abscisse x, ordonnée y et temps te.
- Les ordonnées sont calculées toutes les 60 ms.
- Les valeurs sont sauvegardées dans les listes si y >0 (la balle ne s’enfonce pas dans le sol)
étape 3
Créer une boucle fermée permettant de calculer l’altitude de la balle en fonction du temps. Les résultats sont exprimés à 10-2 près et stockés dans leurs listes respectives. Comme on souhaite avoir une représentation graphique de la chronophotographie correspondant à un cas réel, la liste des abscisses est complétée avec des 0.
Enfin, les listes te et y sont respectivement exportées dans les listes L1 et L2 de la calculatrice.
étape 4
b) Représentation graphique
Paramétrer une représentation graphique :
- Nettoyer l’écran plt.cls().
- Afficher une grille d’unité 2 plt.grid(xscl, yscl, type,(r,v,b)).
- Régler la fenêtre graphique plt.window(xmin, xmax, ymin, ymax).
- Fixer la couleur du point au magenta plt.color(255,0,255).
- Représenter le nuage de point plt.plot(x-list, y-list, marque).
- Afficher le graphe plt.show_plot().
étape 5
Exécuter votre script et appeler la fonction chrono [ var ] puis lui fournir comme argument la hauteur initiale du lâché (8m par exemple).
étape 6
La chronophotographie est représentée.
étape 7
c) Visualisation des données exportées
Quitter l’éditeur Python et afficher les listes.
Demander la représentation graphique de ces listes.
étape 8
Utiliser l’outil [ trace ] pour explorer la représentation graphique (durée totale de la chute…).
- Compétence 1
- Compétence 2
- Compétence 3
- Application
Unité 6: Utiliser la librairie ti_hub & ti_rover
Compétence 1 : Les capteurs intégrés au hub
Notes de l'enseignantAttention : ces unités sont réalisées avec la mise à jour 5.5 pour TI-83 Premium CE Edition Python. Pour la télécharger, rendez-vous dans l'onglet "Mise à jour et logiciels".
Dans cette première leçon de l’unité 6, vous allez découvrir comment utiliser la librairie ti_hub afin de commander les dispositifs intégrés au hub TI-Innovator™.
Objectifs :
- Découvrir le module ti-hub.
- Écrire un script intégrant la librairie ti-hub pour les dispositifs intégrés.
étape 1
Vous allez, dans cette leçon, utiliser la librairie ti_Innovator afin de noter visuellement un changement de luminosité pour, par la suite, simuler un interrupteur crépusculaire, ou bien enregistrer une série de mesures lors du lever du soleil ou du crépuscule.
Vous commencerez par ailleurs à envisager comment associer cette librairie à celle que vous connaissez déjà (ti_plotlib & ti_system) afin de créer un projet scientifique complet.
Le script que vous allez écrire correspond à l’algorithme simple suivant :
Lum0 ← mesure ± (tolérance ?)
Modifier l’intensité lumineuse (lampe ; cache devant le capteur)
Lum1 ← mesure
Si Lum1 > Lum 0 :
Alors allumer la DEL RVB en rouge (2s)
Sinon Si Lum0 < Lum1 :
Alors allumer la DEL RVB en vert (2s)
Sinon : Ne rien faire
étape 2
Commencer un nouveau script et le nommer U6SB1
Ce script doit intégrer la librairie ti_hub. Pour cela, vous avez plusieurs possibilités.
a) Appuyer sur la touche F3 [Types] puis choisir le menu 6 : Hub Projet. Valider ensuite en appuyant sur [ entrer ] deux fois ou une seule fois puis OK.
étape 3
b) Vous pouvez également partir d’un script vierge, puis incorporer manuellement les librairies dont vous avez besoin.
c) Enfin, vous pouvez aussi utiliser les librairies et variables qui ont été écrites lors des projets TI STEM. Celles-ci seront immédiatement recopiées comme « Objet du projet ». Cette dernière option n’est intéressante que pour créer un script analogue à ceux ayant été définis lors du projet STEM.
étape 4
En choisissant le type 6 : Hub Projet, Vous devriez obtenir l’écran ci-contre.
étape 5
Nous allons utiliser le capteur de luminosité intégré au TI-Innovator, ainsi que la diode RVB. Afin que le script soit en mesure de les gérer, intégrons les librairies correspondantes. Pour cela choisir dans le menu Modul puis 6 : ti_hub… et enfin dans le sous-menu 1 : Dispositifs intégrés du Hub.
étape 6
étape 7
étape 8
- Afin que le programme affiche des informations sur un écran « propre », nettoyer celui-ci, à l’aide l’instruction disp_clr() se trouvant dans la librairie ti_system.
étape 9
- Créer une variable lum0, à laquelle on affecte une mesure de la luminosité. L’instruction brightns.measurement() se trouve dans le module 9 : Brightness, chargé dès lors que le module correspondant est importé.
étape 10
- Mettre le programme en attente disp_wait(), le temps d’effectuer cette modification.
- Créer une variable lum1 à laquelle, on affecte la nouvelle mesure.
étape 11
- Les mesures sont ensuite comparées. Selon le résultat de l’instruction conditionnelle, la DEL RVB s’allumera en vert ou rouge pendant un délai de 2 secondes.
étape 12
Prolongement de l’activité :
Modifier le script précédent ou en créer un autre U6SB11
Ce nouveau script doit sur 40 minutes enregistrer les mesures de la luminosité.
Les mesures sont sauvegardées dans une liste r[ ].
Celles correspondant à la valeur du temps dans une liste t[ ].
Le script proposé ci-dessous propose également la représentation graphique des mesures afin de le comparer à la représentation ci-contre.
Il est également proposé un export vers les listes de la calculatrice,
étape 13
a) Acquisition des données
étape 14
b) Représentation graphique
étape 15
La fonction bri(n) réalise l’acquisition de données toutes les minutes pendant n minutes et renvoie les liste t et r
La fonction graphe(t,r) réalise la représentation graphique des données t[ ] et r[ ], puis les exporte vers les listes L1 et L2 de la calculatrice.
Compétence 2 : les dispositifs d’entrée-sortie
Notes de l'enseignantDans cette seconde leçon de l’unité 6, vous allez découvrir comment connecter et utiliser un dispositif d’entrée-sortie du TI-Innovator à l’aide de la librairie ti_hub.
Objectifs :
- Découvrir le module ti_hub.
- Écrire et utiliser un script permettant d’utiliser un composant d’entrée sortie « grove ».
étape 1
Vous allez dans cette leçon, utiliser un composant essentiel dans toute chaîne de mesure utilisant des capteurs, il s’agit d’un potentiomètre.
Un potentiomètre est un type de résistance variable à trois bornes, dont une est reliée à un curseur se déplaçant sur une piste résistante terminée par les deux autres à laquelle est soumise la résistance. Les potentiomètres sont couramment employés dans les circuits électroniques. Ils servent par exemple à contrôler le volume d'une radio. Les potentiomètres peuvent aussi être utilisés comme des transducteurs, puisqu'ils convertissent une position en une tension. Ce type de dispositif peut être rencontré dans des joysticks.
Vous allez écrire un script permettant de mesurer la tension électrique entre deux bornes du potentiomètre, puis de l’afficher à l’écran.
Remarque : L’esprit de cette leçon ne porte pas sur l’étude du composant en lui-même, mais sur son intégration au sein d’un script Python afin d’obtenir les informations que celui-ci doit fournir. Ainsi le script que vous allez réaliser sera aisément transposable à tout autre type de transducteur.
étape 2
Mise en œuvre :
Commencer un nouveau script et le nommer U6SB2. Choisir en appuyant sur la touche F3, lors de l’écriture du nom du script.
étape 3
Les librairies ti_system et time sont importées, vous allez à présent importer la librairie du Hub correspondant au potentiomètre et éventuellement la librairie ti_plot.
étape 4
Appuyer sur la touche F1 (Fns) [ f(x) ] [ ← ] puis afin d’accéder au menu modul, puis choisir 6 : ti_hub puis 2 : Dispositifs d’entrée…et enfin 0 : Potentiometer.
étape 5
Toutes les commandes relatives au potentiomètre seront maintenant accessibles dans le menu modul, en complément de ceux déjà présent.
étape 6
- Commencer par nettoyer l’écran afin d’obtenir une console vide de toute information. Pour cela, inclure l’instruction dispclr() disponible dans le module ti_system.
- Créer une fonction pot( ) ne comportant pas d’argument pour le moment.
- Créer une variable mes et laisser le curseur clignoter derrière le nom de cette variable. Puis rechercher dans le menu modul puis 8 : Potentiometer… la première instruction var=potentiometer(« port »)
étape 7
- Valider en appuyant sur la touche [ entrer ], l’affectation de l’instruction permettant de connecter le potentiomètre au port IN est achevée.
étape 8
- Créer une variable v permettant de collecter la mesure du capteur connecté (variable mes).
étape 9
- Vérifier le fonctionnement de votre capteur après avoir préalablement placé le potentiomètre sur une position centrale.
- Connecter le TI-Innovator à la calculatrice puis le potentiomètre au port IN1
- Appeler la fonction pot( ).
- Vous devriez obtenir une information du même ordre de grandeur que celle de l’écran ci-contre, mais constater qu’il ne s’agit pas d’une tension puisque votre potentiomètre est alimenté par une tension de 3.3V. La valeur à trouver appartiendra àl’intervalle [0 ; 3.3].
étape 10
- Modifier votre script afin de prendre en compte la résolution du convertisseur analogique numérique (14 bits). Ainsi la mesure de la tension sera :
u = Ualim × v / 214 - La tension sera arrondie à 10-2 près.
étape 11
- La tension précédente est d’environ 1.97 V.
étape 12
Quelques idées pour prolonger la leçon :
- Utiliser un potentiomètre pour réaliser un capteur angulaire (une mesure de tension correspond à la valeur d’un angle lue sur un rapporteur), puis réaliser la représentation graphique de la fonction modélisée α = f(u).
- Entre 0 et 3.3v, associer une plage de tension à une couleur en utilisant la DEL RVB du TI-Innovator™.
- Associer la mesure de la tension aux coordonnées d’un point repéré (principe d’un joystick)…etc.
Compétence 3 : les dispositifs d’entrée-sortie
Notes de l'enseignantDans cette seconde leçon de l’unité 6, vous allez découvrir comment connecter le ti-rover à l’aide de la librairie ti_rover.
Objectifs :
- Découvrir le module ti_rover.
- Écrire et utiliser un script permettant d’utiliser le ti-rover et ses actionneurs associés.
- Utiliser une boucle ouverte et une instruction conditionnelle.
étape 1
Vous allez, dans cette leçon, réaliser un script donnant au ROVER la possibilité d’effectuer un parcours marqué par l’illumination de la diode RVB, tant que la distance (mesurée par le capteur RANGER) respecte une limite inscrite dans une instruction conditionnelle.
Tant que le mouvement n’est pas stoppé par l’utilisateur
a ⟵ distance à un objet mesurée
si a < 0.2
alors afficher une couleur rouge et s’arrêter
sinon afficher une couleur verte et continuer
S’arrêter, afficher une couleur bleue
Attendre 1s
Eteindre la diode
Allumer la diode en bleu pour marquer la fin
étape 2
- Commencer un nouveau script et le nommer U6SB3.
- A partir du menu modul, importer la librairie ti-rover.
étape 3
- Valider en appuyant sur la touche [ entrer ].
étape 4
- Effacer votre écran à l’aide de l’instruction disp_clr() située dans le menu ti_system.
- Toujours dans le menu ti_system, choisir l’instruction disp_cursor( ) affectée de la valeur 0 afin de ne pas afficher le curseur.
étape 5
- Demander au ROVER de se déplacer en avant. L’unité de mesure de la distance est laissée à votre choix sachant que par défaut, celle-ci est fixée à 0.1 m. Ainsi rv.forward(20) assignera au robot un déplacement en avant sur une distance de 2 m. L’instruction rv.forward( ) est située dans le menu modul, puis 7 : ti_rover et enfin 2 : forward(distance) dans le menu Conduire.
- Inscrire ensuite, le début d’une boucle ouverte que l’on trouve dans le menu modul puis dans celui de la librairie ti_system.
étape 6
- Créer une variable a à laquelle est affectée la distance mesurée par le RANGER. Pour cela, commencer à écrire la lettre a, puis laisser le curseur à la fin de cette lettre. Inscrire ensuite l’instruction rv.ranger_measurement( ) située dans le menu modul puis 7 : ti_rover puis E/S (entrées sorties) ; 1 : Entrées et enfin 1 : rv.ranger_measurement( ). L’unité de mesure est le mètre.
- Créer à présent l’instruction conditionnelle. Si la distance mesurée est inférieure à 20 cm, le robot s’arrête et la diode RVB s’allume en rouge. L’instruction rv.color( ) est disponible dans la librairie ti_rover au menu E/S puis 2 : sortie. rv.stop( ) est une instruction de conduite et donc placée sous le menu correspondant. Sinon la diode RVB est de couleur verte, et le robot poursuit son parcours jusqu’à attendre la distance fixée. L’instruction rv.resume() termine le traitement des actions en court dans la file d’attente.
- A la fin de la boucle :
- Le robot s’arrête. rv.stop().
- L’écran est effacé.
- La diode affiche une couleur bleue.
- Un délai d’attente de 1s précède l’extinction de la diode.
Application : Représenter un parcours
Notes de l'enseignantDans cette application de l’unité 6, vous allez connecter le ti-rover à l’aide de la librairie ti_hub et construire un script permettant d’enregistrer des coordonnées de points lors d’un parcours, puis de les représenter graphiquement.
Objectifs :
- Découvrir le module ti_rover.
- Écrire et utiliser un script permettant d’utiliser le ti-rover et ses actionneurs associés.
- Utiliser une boucle fermée.
- Représenter graphiquement des données.
étape 1
Vous allez, dans cette leçon, réaliser un script donnant au ti-rover la possibilité d’effectuer un parcours correspondant au dessin d’un polygone.
Les coordonnées des sommets seront sauvegardées dans des listes puis représentées graphiquement à l’aide des instructions de la librairie ti_plot.
étape 2
Mise en œuvre :
- Commencer un nouveau script et le nommer U6APPS
- A partir du menu modul, importer la librairie ti-rover
- Valider en appuyant sur la touche [ entrer ].
- Importer également la librairie ti_plotlib
étape 3
- Bien que cela ne soit pas impérativement nécessaire, les instructions permettant d’effacer l’écran et de ne pas afficher le curseur sont toujours d’un rendu plus agréable. Insérer disp_clr() et disp_cursor(0) se trouvant dans le menu modul puis ti_system.
- Créer une fonction poly(), prenant en argument n le nombre de côtés du polygone et l la longueur en unité par défaut pour le TI-Rover, c’est-à-dire le dm.
- L’angle au sommet de chaque polygone sera donc égal a = 360 / n .
- Créer deux listes vides absc et ordo destinées à recevoir les coordonnées de chacun de ces sommets.
étape 4
- Créer une boucle ouverte de taille n.
Les instructions suivantes se trouvent dans la librairie ti_rover.
- Faire avancer le rover de l décimètres pour n fois.
- Tourner sur la gauche d’un angle a.
- Mettre entre chaque étape un délai de 1s.
- Stocker dans les listes x et y les coordonnées des points.
- Déconnecter le rover à la fin du parcours.
- Exporter les coordonnées absc et ordo respectivement dans les listes L1 et L2.
étape 5
- Passer ensuite à la représentation graphique, celle-ci est ici incluse dans la fonction, mais il est toujours possible de créer une fonction graphe séparément comme nous avons pu le faire dans d’autres leçons (Unité 5).
étape 6
Fonctionnement du script :
Exécuter votre script F4 et appeler la fonction poly( ) en lui fournissant par exemple les arguments poly(4, 1) afin de dessiner un carré de 1 dm de côté.
étape 7
Un essai avec un hexagone de 1 dm fournit la représentation suivante.
étape 8
L’export des listes vers la calculatrice donne la représentation graphique ci-contre. L’utilisation de la touche [ trace ] permettra de retrouver les coordonnées de chaque point.
Remarque : ajuster le format de votre grille, en fonction des polygones que vous souhaitez tracer. Celle-ci a volontairement été réglée ici aux paramètres par défaut, afin d’observer la précision du tracé du ROVER.
Prendre garde également à la nature de la surface sur laquelle se déplace le robot. Celle-ci ne doit pas opposer trop de résistance au déplacement ou au contraire, favoriser les glissements.
- Compétence 1
- Compétence 2
- Compétence 3
- Application
