Dans sa prochaine mise à jour 5.5 gratuite prévue pour Mai 2020, Texas Instruments va rajouter de formidables possibilités historiques à ta TI-83 Premium CE :
détection des simples pressions de touches clavier (sans validation donc) par l'utilisateur, avec même l'éventuel modificateur actif (
2nde
ou
alpha
), et ça marche aussi avec un clavier USB !
affichage dans la console à la ligne que tu veux
exportation de listes de nombres (entiers, flottants ou complexes) existant dans le contexte Python vers l'environnement de la calculatrice, pour traitement à l'aide d'autres applications
importation depuis le contexte Python de listes ou équation de régression existant dans l'environnement de la calculatrice
et donc plus généralement un début d'intégration du Python à l'environnement mathématique de la calculatrice, enfin l'application Python va pouvoir servir non plus seulement à coder un truc déconnecté dans un coin, mais à traiter des problèmes et tâches complexes dans leur globalité !
ti_plotlib, une bibliothèque graphique pour tracer dans un repère othogonal, conformément aux programmes de Mathématiques et Physique-Chimie, comparable à matplotl chez Casio ou encore matplotlib.pyplot, et gérant ici les diagrammes suivants :
nuage de points
diagramme en ligne brisée
droite de régression linéaire
ti_graphics pour contrôler directement les pixels de l'écran, comparable à kandinsky chez NumWorks ou encore casioplot
ti_hub, pour les projets d'objects connectés à l'aide de l'interface TI-Innovator Hub
ce_chart pour les histogrammes et aires entre courbes
ce_quivr pour les diagrammes utilisant des champs de vecteurs
Aujourd'hui nous découvrons enfin avec toi le menu associé au module complémentaire ce_box.
Pas grand chose au menu mais justement c'est une bonne nouvelle, l'utilisation de ce_box pour tracer tes diagrammes en boîte semble donc extrêmement simple.
On peut supposer la fonctions ce_box.show() équivalente aux appels ti_system.disp_wait(), ti_plotlib.show_plot() et ce_turtl.turtle.show(), ainsi qu'au code suivant :
C'est-à-dire que contrairement à ce que son nom indique, ce_box.show() n'affiche rien mais gèle l'affichage courant le temps que l'utilisateur appuie sur une touche d'interruption. C'est nécessaire puisque sur TI-83 Premium CE Edition Python les affichages graphiques sont effectués sur l'écran de la console, et seront donc perdus en fin de script. En passant, a priori ça commence à être fatigant d'avoir maintenant 4 noms différents de fonctions qui font la même chose...
Le programme de Physique-Chimie de Seconde indique d'aborder divers tracés en Python :
nuages de points
histogrammes
positions successives d'un système modélisé par un point
vecteurs vitesse associés à chacun de ces points
Dans sa prochaine mise à jour 5.5 gratuite prévue pour Mai 2020, Texas Instruments rajoute de formidables possibilités historiques à la TI-83 Premium CE, et en profite pour palier ces nouveaux besoins.
Nous avions déjà vu la possibilité de tracer des nuages de points à l'aide du nouveau module Pythonti_plotlib.
Mais qu'en est-il par contre des diagrammes permettant l'étude du mouvement d'un système ponctuel, et plus généralement la représentation de diagrammes utilisant des champs de vecteurs ?
Et bien ici encore, Texas Instruments a tout prévu. Cela se passe ici avec ce_quivr, un module complémentaire pour l'application Python.
En voici les menus ci-contre, difficile de faire plus simple.
Une seule et uniquement fonction à apprendre donc, quiver(x, y, u, v, éch, "couleur", type="vector"), avec :
(u,v) les coordonnées du vecteur à tracer
(x,y) les coordonnées du point où tracer le vecteur en question
éch, l'échelle spécifique à utiliser pour le tracé du vecteur, particulièrement utile dans le contexte d'un diagramme et donc d'autres éléments présents à l'écran, avec le champ de vecteurs qui pourrait souffrir de diverses superpositions
type, le type valant par défaut "vector" pour la représentation d'un vecteur et donc le tracé d'une flèche, ou sinon "line" pour un simple segment quiver(x, y, u, v, 1, "couleur", "line") est donc à la couleur près équivalent à ti_plotlib.line(x, y, x + u, y + v)
Découvrons cela de suite à travers quelques exemples.
Voici pour étudier un mouvement rectiligne qui semble alors uniformément accéléré :
def motion(min, max, n): dt = (max-min) / n t = min for i in range(n): quiver(t, fx(t), t+dt, fx(t+dt), 1, 'blk', 'line') if i % 7 == 0: quiver(t, fx(t), 0, dx(t), .4, 'r', 'vector') quiver(t, fx(t), 0, d2x(t), .4, 'b') t += dt
plt.window(-.25, 4, -5, 7) plt.cls() plt.title('Motion in one Dimension') plt.color(0, 0, 0) plt.axes('on') plt.labels('Time', ' X Position ', 7, 3) motion(0, 4, 49) plt.show_plot()
Le programme de Physique-Chimie de Seconde indique d'aborder divers tracés en Python :
nuages de points
histogrammes
positions successives d'un système modélisé ar un point
vecteurs vitesse associés à chacun de ces points
Dans sa prochaine mise à jour 5.5 gratuite prévue pour Mai 2020, Texas Instruments rajoute de formidables possibilités historiques à la TI-83 Premium CE, et en profite pour répondre à ces divers besoins.
Nous avions déjà vu la possibilité de :
tracer des nuages de points à l'aide du nouveau module Pythonti_plotlib.
tracer des diagrammes utilisant des champs de vecteurs avec le module Python complémentaire ce_quivr, couvrant bien l'étude du mouvement d'un système ponctuel
Mais qu'en est-il par contre des histogrammes ?
Et bien non, Texas Instruments n'a rien laissé de côté, les besoins en histogrammes sont quant à eux couverts par le module complémentaire ce_chart dont voici les menus ci-contre.
from random import * from ce_chart import * n = 5 cx = [randint(0,12) for i in range(n + 1)] connex = [("Ke", cx[1] / 12), ("Jo", cx[2] / 12), ("Am", cx[3] / 12, ("Pa", cx[4] / 12), ("Ma", cx[5] / 12)] cht = chart() cht.data(connex) cht.title("Temps de connexion") cht.frequencies(2) cht.show()
Mais ce n'est pas tout, Texas Instruments a également eu la bonne idée d'exposer la fonction interne de tracé de rectangle servant pour les barres d'histogramme dans un 2nd onglet de menu. Contrairement à la fonction drawRect() du module intégré ti_graphics, ici cela permet de travailler non pas en comptant les pixels, mais directement avec les coordonnées dans le repère du diagramme !
Une application par exemple en Mathématiques, c'est l'approche de l'aire entre deux courbes par la méthode des rectangles. Et la fonction draw_fx() est justement là pour compléter le tracé avec la courbe en question.
def calc_area(n, min, max, fx): sum = 0 dx = (max - min) / n for i in range(0, n) a_rectangle = rectangle(min, 0, dx, fx(min + dx/2), 'b') sum += a_ractangle.area a_rectangle.draw() min += dx return sum
Dans sa prochaine mise à jour 5.5 gratuite prévue pour Mai 2020, Texas Instruments va rajouter de formidables possibilités historiques à ta TI-83 Premium CE :
détection des simples pressions de touches clavier, y compris avec un clavier USB externe !
affichage dans la console à la ligne que tu veux
exportation de listes de nombres du contexte Python vers l'environnement de la calculatrice
importation dans le contexte Python de listes existant dans l'environnement de la calculatrice vers
et donc plus généralement un début d'intégration du Python à l'environnement mathématique de la calculatrice; plus besoin de traiter les tâches numériques à part, l'application Python 5.5 va enfin pouvoir servir s'articulier naturellement au sein de la résolution de problèmes et tâches complexes !
ti_plotlib, une bibliothèque graphique pour tracer dans un repère othogonal, conformément aux programmes de Mathématiques et Physique-Chimie, comparable à matplotl chez Casio ou encore matplotlib.pyplot, et gérant ici les diagrammes suivants :
nuage de points
diagramme en ligne brisée
droite de régression linéaire
ti_graphics pour contrôler directement les pixels de l'écran, comparable à kandinsky chez NumWorks ou encore casioplot
ti_hub, pour les projets d'objects connectés à l'aide de l'interface TI-Innovator Hub
Dans le langage historique TI-Basic, les fonctions relatives au robot TI-Innovator Rover étaient extrêmement limitées :
send() pour envoyer une commande au robot
et get() pour récupérer un éventuel retour d'information
En effet, le TI-Innovator Rover disposait de son propre langage de script, utilisé donc en paramètre de la fonction send().
Une difficulté pour aborder des projets en classe était donc la nécessité pour les élèves de connaître et utiliser simulatnément deux langages :
le langage historique TI-Basic de la TI-83 Premium CE
le langage de script du TI-Innovator Rover
Et bien dès l'arrivée dans le 1er onglet de menus du module ti_rover, on se rend compte que Texas Instruments a entièrement repensé son langage TI-Rover dans l'esprit du langage Python !
Finis les send() et get() qui devaient être pensés différemment, nous disposons ici directement de fonctions Python pour chaque action du TI-Innovator Rover !
L'onglet Commandes nous met également à portée de main quelques éléments bien pratiques du module ti_system. L'ongler Réglages comporte de quoi saisir rapidement les unités à fournir en paramètres de divers commandes. Le TI-Innovator Rover est bien plus qu'une voiture, il a tout ce qu'il faut pour devenir une voiture intelligente si tu codes bien.
Il dispose d'une part en entrée de plusieurs capteurs dont on découvre ici les fonctions d'accès dans l'onglet E/S :
sonar frontal
détecteur de couleur sur sa face inférieure
En sortie il dispose également d'une diode RVB dont on trouve ici encore les fonctions d'accès.
Tu peux même si tu le souhaites directement contrôler ses deux moteurs latéraux de façon indépendante, et en régler la vitesse.
Mais ce n'est pas tout, le TI-Innovator Rover est bardé de capteurs internes (gyroscope entre autres) lui permettant dans certains cas de corriger lui-même sa trajectoire, et dont l'accès t'est également offert ici.
La commande d'importation mise en avant par les menus est donc import ti_rover as rv. Nulle obligation de la suivre, mais les menus supposent que c'est celle-ci qui est utilisée et préfixent automatiquement les différentes saisies d'un rv.. À défaut tes saisies via les menus devront être corrigées.
Rappelons que le tas (heap)Python a ici une capacité de 19,968 Ko, mais seulement entre 17 Ko et 17,5 Ko d'espace libre à vide.
Utilisons le script suivant pour déterminer la taille consommée sur le tas (heap)Python par l'importation du ti_rover :
4,848 Ko de consommés donc sur nos 17 Ko et quelques, ce n'est pas négligeable, c'est quand même déjà plus du quart alors que nous n'avons encore rien codé.
Avant de creuser plus profondément, abordons quelques exemples de projets pour te montrer comme il est maintenant simple de coder en Python de grandes choses pour le TI-Innovator Rover.
Commençons avec un petit tracé de polygone régulier.
from time import * from ti_system import * import ti_rover as rv import ti_plotlib as plt
def polygone(l,c): plt.cls() plt.axes("on") plt.pen("medium", "solid") plt.color(255, 0, 0) plt.grid(1, 1, "dot") plt.title("polygone regulier a " + str(c) + " cotes") x = 0 y = 0 b = 360 / c for i in range(c): rv.forward(l) rv.right(b) rv.wait_until_done() X = rv.waypoint_x() Y = rv.waypoint_y() plt.line(x, y, X, Y, "arrow") x = X y = Y plt.show_plot() rv.disconnect_rv()
L'appel polygone(2, 5) nous permet ici de tracer un pentagone régulier de 20 cm de côté.
De plus nous avons ici un tracé simultané sur l'écran de la calculatrice. Il ne s'agit pas d'un affichage du tracé théorique, mais bien d'un retour en temps réel sur le tracé effectivement réalisé par le robot, grâce à ses capteurs internes que l'on interroge ici ! D'ailleurs, si l'on s'amuse à embêter le robot dans ses déplacements de façon tellement insistante qu'il n'arrive plus à les corriger correctement, on note bien que le tracé obtenu sur écran est alors faux, et ton programme pourrait éventuellement en tenir compte.
Après ce petit amusement, on passe maintenant aux choses sérieuses avec le park assist.
Demandons donc au TI-Innovator Rover de parcourir une rue et de se garer en créneau dans la première place libre trouvée. Cela nécessite l'ajout d'un sonar latéral, ici à droite :
# TI-Rover from time import * from ti_system import * import ti_rover as rv from ranger import *
b = 0 a = ranger("IN 1") p = 0 while p == 0: rv.forward(50) while b<=0.2: b=a.measurement() print(b) rv.stop() rv.path_clear() rv.forward(50) while b>0.2: b = a.measurement() print(b) d = rv.waypoint_distance() print("d=", d) rv.stop() if d > 0.3: p = 1 rv.color_rgb(0, 255, 0) wait(1) rv.backward(0.5) wait(1) rv.left(45) wait(1) rv.backward(2) wait(1) rv.right(45) wait(1) rv.forward(0.5) wait(1) rv.disconnect_rv()
Et passons maintenant à la voiture autonome, celle qui sauve des vies en freinant toute seule devant les piétons :
from time import * from ti_system import * import ti_rover as rv
def voiture(): disp_clr() disp_at(8, "appuyer sur annul ou arreter", "left") rv.forward(6) rv.left(90) rv.forward(1) while not escape(): a = rv.ranger_measurement() if a < 0.2: rv.color_rgb(255, 0, 0) rv.stop() else: rv.color_off() rv.resume()
Décidément pas besoin d'attendre, avec le TI-Innovator Rover ta future voiture est déjà entre tes mains !
def getplatform(): id=-1 try: import sys try: if sys.platform=='nspire':id=0 if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':id=4 except:id=3 except: try: import kandinsky id=1 except: try: if chr(256)==chr(0):id=5+(not ("HP" in version())) except: id=2 return id
platform=getplatform() #lines shown on screen #plines=[29,12, 7, 9,11,0,0] plines=[29,16, 7, 9,11,0,0] #max chars per line #(error or CR if exceeded) pcols =[53,99,509,32,32,0,0]
if platform>=0: curline=0 _p = print nlines=plines[platform] ncols=pcols[platform] def print(*ls): global curline st="" for s in ls: if not(isinstance(s,str)): s=str(s) st=st+s stlines=1+int(len(st)/ncols) if curline+stlines>=nlines: input("Input to continue:") curline=0 _p(st) curline+=stlines
def sstr(obj): try: s=obj.__name__ except: s=str(obj) a=s.find("'") b=s.rfind("'") if a>=0 and b!=a: s=s[a+1:b] return s
def isExplorable(obj): for k in done: try: if isinstance(obj, eval(k)): t, done[k] = done[k], True return not t except: pass if str(obj).startswith("<module"): return False l = () try: l = dir(obj) except: pass return len(l)
def explmod(pitm, pitmsl=[], reset=True): global curline spitm=sstr(pitm) if(reset): curline=0 pitmsl=[spitm] for k in done: done[k] = False hd="."*(len(pitmsl)-1) c,c2=0,0 l = sorted(dir(pitm)) for i in range(len(l)): l[i] = (l[i], getattr(pitm, l[i])) try: if not isinstanceof(pitm, str): for i in range(len(pitm)): l.append((spitm+'['+str(i)+']',pitm[i])) except: pass for itm in l: c,c2=c+1,c2+1 isUnsafe = platform >= 0 and '.'.join(pitmsl + [itm[0]]) in unsafe[platform] try: if isUnsafe: raise Exception print(hd+itm[0]+"="+str(itm[1])) except: print(hd+itm[0]) if not isUnsafe and isExplorable(itm) and itm[1] != pitm and itm[0] not in pitmsl: pitmsl2=pitmsl.copy() pitmsl2.append(itm[0]) c2=c2+explmod(itm[1], pitmsl2, False)[1] if c>0 and reset: print(hd+"Total: "+str(c)+" 1st level item(s)") if c2>0 and c2!=c: print(hd+" "+str(c2)+" item(s)") return [c,c2]
Le module ti_rover offre donc 66 éléments au premier niveau, et jusqu'à 92 en comptant les sous-éléments.
De quoi mettre à jour notre comparatif de la richesse des différentes solutions Python sur calculatrices :
Mine de rien le ti_rover a su faire la différence, pour la richesse de sa solution Python la TI-83 Premium CE Edition Python est à compter de maintenant classée dans tous les cas première, et ce alors que nous n'en avons même pas encore exploré tous les modules !
ti_rover, Texas Instruments nous apporte une fois de plus le fruit d'un travail formidable pour la mise à jour 5.5.
S'appuyant cette fois-ci intégralement sur le seul langage Python, la bibliothèque robotique ti_rover est conforme aux programmes scolaires aussi bien dans l'esprit que dans la forme !
Comme les autres bibliothèques Python apportées par la mise à jour 5.5 de la TI-83 Premium CE Edition Python, la bibliothèque ti_rover est extrêmement bien fournie, si bien que comme tu l'as vu il ne te suffit que de quelques lignes pour construire facilement des projets extraordinaires !
Les élèves et enseignants de SNT en Seconde puis spécialité NSI ont franchement de la chance, ils vont pouvoir se régaler !
Envie de te faire ta propre opinion ?
Rendez-vous ce Mercredi 20 Mai de 18h30 à 20h pour une vidéoconférence de présentation des modules ti_hub et ti_rover, dans le cadre de l'enseignement SNT en Seconde.
Dans sa prochaine mise à jour 5.5 gratuite prévue pour Mai 2020, Texas Instruments va rajouter de formidables possibilités historiques à ta TI-83 Premium CE :
détection des simples pressions de touches clavier, y compris avec un clavier USB externe !
affichage dans la console à la ligne que tu veux
exportation de listes de nombres du contexte Python vers l'environnement de la calculatrice
importation dans le contexte Python de listes existant dans l'environnement de la calculatrice vers
et donc plus généralement un début d'intégration du Python à l'environnement mathématique de la calculatrice; plus besoin de traiter les tâches numériques à part, l'application Python 5.5 va enfin pouvoir servir s'articulier naturellement au sein de la résolution de problèmes et tâches complexes !
ti_plotlib, une bibliothèque graphique pour tracer dans un repère othogonal, conformément aux programmes de Mathématiques et Physique-Chimie, comparable à matplotl chez Casio ou encore matplotlib.pyplot, et gérant ici les diagrammes suivants :
nuage de points
diagramme en ligne brisée
droite de régression linéaire
ti_graphics pour contrôler directement les pixels de l'écran, comparable à kandinsky chez NumWorks ou encore casioplot
ti_hub, pour les projets d'objects connectés à l'aide de l'interface TI-Innovator Hub
Comme tu peux voir, la consommation de tas est énorme, le module ce_box fait 13,44 Ko. Il nous reste maintenant moins de 3 Ko de heapPython disponible, on ne va pas pouvoir aller coder bien loin...
On peut toutefois facilement comprendre cela. Il s'agit d'un module de tracé :
qui probablement importe lui-même en interne ti_plotlib(7,232 Ko)
ti_plotlib importe à son tour le module sys(224 o)
ti_plotlib importe lui-même à son tour ti_graphics(2,896 Ko)
ti_graphics importe également le module sys(224 o)
ti_graphics import aussi le module math(336 o)
Donc en contrepartie de cette consommation de heap, tu as déjà à ta disposition une bonne partie des modules et de leurs fonctionnalités sans avoir à rien importer d'autre.
C'est-à-dire que contrairement à ce que son nom indique, ce_box.show() n'affiche rien mais gèle l'affichage courant le temps que l'utilisateur appuie sur une touche d'interruption. C'est nécessaire puisque sur TI-83 Premium CE Edition Python les affichages graphiques sont effectués sur l'écran de la console, et seront donc automatiquement nettoyés et perdus en fin d'exécution d'un script.
from random import * from ce_box import * data = [randint(-10, 42) for i in range(200)] diag = box(data) diag.title("Températures") diag.show()
Dernière question, quelle est la définition utilisée pour les quartiles ? Au lycée français c'est particulier, contrairement à la médiane les quarties sont toujours des valeurs de la série statistique.
La TI-83 Premium CE adopte cette définition par défaut mais laisse le choix.
Prenons donc en Python un cas qui fait la différence comme par exemple [1, 2, 3, 4, 5] :
from ce_box import * d = (1, 2, 3, 4, 5) b = box(d) b.show()
Excellente nouvelle, ce_box nous fait visiblement des "quartiles à la française", et ce d'ailleurs peu importe le réglage de la calculatrice. Mais peut-être que le comportement sera différent sur la modèle international TI-84 Plus CE Python Edition à venir pour cette rentrée 2020.
def getplatform(): id=-1 try: import sys try: if sys.platform=='nspire':id=0 if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':id=4 except:id=3 except: try: import kandinsky id=1 except: try: if chr(256)==chr(0):id=5+(not ("HP" in version())) except: id=2 return id
platform=getplatform() #lines shown on screen #plines=[29,12, 7, 9,11,0,0] plines=[29,16, 7, 9,11,0,0] #max chars per line #(error or CR if exceeded) pcols =[53,99,509,32,32,0,0]
if platform>=0: curline=0 _p = print nlines=plines[platform] ncols=pcols[platform] def print(*ls): global curline st="" for s in ls: if not(isinstance(s,str)): s=str(s) st=st+s stlines=1+int(len(st)/ncols) if curline+stlines>=nlines: input("Input to continue:") curline=0 _p(st) curline+=stlines
def sstr(obj): try: s=obj.__name__ except: s=str(obj) a=s.find("'") b=s.rfind("'") if a>=0 and b!=a: s=s[a+1:b] return s
def isExplorable(obj): for k in done: try: if isinstance(obj, eval(k)): t, done[k] = done[k], True return not t except: pass if str(obj).startswith("<module"): return False l = () try: l = dir(obj) except: pass return len(l)
def explmod(pitm, pitmsl=[], reset=True): global curline spitm=sstr(pitm) if(reset): curline=0 pitmsl=[spitm] for k in done: done[k] = False hd="."*(len(pitmsl)-1) c,c2=0,0 l = sorted(dir(pitm)) for i in range(len(l)): l[i] = (l[i], getattr(pitm, l[i])) try: if not isinstanceof(pitm, str): for i in range(len(pitm)): l.append((spitm+'['+str(i)+']',pitm[i])) except: pass for itm in l: c,c2=c+1,c2+1 isUnsafe = platform >= 0 and '.'.join(pitmsl + [itm[0]]) in unsafe[platform] try: if isUnsafe: raise Exception print(hd+itm[0]+"="+str(itm[1])) except: print(hd+itm[0]) if not isUnsafe and isExplorable(itm) and itm[1] != pitm and itm[0] not in pitmsl: pitmsl2=pitmsl.copy() pitmsl2.append(itm[0]) c2=c2+explmod(itm[1], pitmsl2, False)[1] if c>0 and reset: print(hd+"Total: "+str(c)+" 1st level item(s)") if c2>0 and c2!=c: print(hd+" "+str(c2)+" item(s)") return [c,c2]
Notons en passant la présence d'une fonction permettant à tes scripts de tester la version ce_box, ici 1.0.
On valide en passant l'hypothèse formulée plus haut, le module ti_plotlib est bien inclus dans ce_box et accessible via ce_box.plt.
Le module ce_box offre donc 5 éléments au premier niveau, et jusqu'à 32 en comptant les sous-éléments.
De quoi mettre à jour notre comparatif de la richesse des différentes solutions Python sur calculatrices :
by 
Dans sa prochaine mise à jour 5.5 gratuite prévue pour Mai 2020, Texas Instruments va rajouter de formidables possibilités historiques à ta TI-83 Premium CE :
Python 5.5 offre de nouveaux modules intégrés pour tes scripts Python :
Aujourd'hui nous découvrons enfin avec toi le menu associé au module complémentaire ce_box.
