TI-Planet | News

by **critor** » 18 May 2020, 20:26

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 :

mise à jour en 5.5 de l'application SciTools
mise à jour en 5.5 de l'application Periodic
mise à jour en 5.5 de l'application Python (TI-83 Premium CE Édition Python uniquement)

Python 5.5 offre de nouveaux modules intégrés pour tes scripts Python :

time, certes déjà présent mais maintenant listé au menu et donc officiel
ti_system, avec diverses possibilités :
- 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
ti_rover, pour les projets de robotique à l'aide du TI-Innovator Rover

Mais ce n'est pas tout car Python 5.5 gère également la possibilité inédite de rajouter des modules Python complémentaires :

ce_turtl, comparable à turtle
ce_box pour les diagrammes en boîte
ce_chart pour les histogrammes et aires entre courbes
ce_quivr pour les diagrammes utilisant des champs de vecteurs

Aujourd'hui nous poursuivons notre exploration du module complémentaire ce_turtl, donc voici enfin ci-dessous le détail des menus :

Comme tu peux le voir, nous disposons à priori de tout ce qu'il faut pour une faire aussi bien qu'avec le module turtle standard.

Le module ce_turtl semble comporter lui-même un sous-module turtle.

Une même script pourrait même tourner a priori aussi bien avec ce_turtl que le turtle standard sur ordinateur, à condition de tenir compte de tout cela à l'importation. Nous pouvons faire au choix :

Code: Select all: try: from ce_turtl.turtle import * except ImportError: from turtle import *

Code: Select all: try: from ce_turtl import * except ImportError: import turtle

Notons que la saisie via les menus ce_turtl préfixe toutes les commandes d'un turtle. et n'est donc adaptée qu'à ce dernier point.

Nous allons donc maintenant tester la compatibilité de ce_turtl avec les solutions concurrentes, ainsi que sa conformité au standard turtle.
Précisons que nous ne disposons pas à ce jour du fichier permettant de rajouter ce_turtl à la calculatrice, et sommes donc limités aux exemples fournis par Texas Instruments.

Pour cela nous allons commencer doucement en y allant fonction par fonction, avant d'aborder des exemples plus poussés.

Démarrons donc avec un tracé de polygone tout simple:

Code: Select all: try: from ce_turtl import * except ImportError: import turtle def polyg(l,n): for i in range(n): turtle.forward(l) turtle.left(360/n) polyg(100,4)

Ainsi que tu peux voir, comme avec ti_plotlib et ti_graphics, les tracés ce_turtl sont effectués directement sur l'écran d'affichage de la console Python.

D'où la nécessité de commencer par effacer l'écran avec ici non pas le turtle.clearscreen() standard, mais turtle.clear().

De plus, comme les affichages sortent sur la console, ils sont nettoyés et perdus dès que ton script rend la main. Il faut donc insérer une boucle d'attente en fin de script, ici fournie par l'appel non standard turtle.show(). Contrairement à ce que son nom indique, cette fonction n'affiche rien par elle-même et ne fait qu'attendre l'appui sur une touche d'interruption par l'utilisateur. Elle est donc équivalente aux appels ti_plotlib.show_plot() et ti_system.disp_wait(), ainsi qu'au code suivante :

Code: Select all: while not ti_system.escape(): pass

Graph 35+E II	Graph 90+E	TI-83 Premium CE Edition Python	Num Works	ordi

Code: Select all `try: from ce_turtl import * turtle.clear() except ImportError: import turtle def polyg(l,n): for i in range(n): turtle.forward(l) turtle.left(360/n) polyg(100,4) try: turtle.show() except: pass`

Mettons maintenant de la couleur, par exemple du bleu. Et voici les ennuis de compatibilité arriver.

Déjà, les différentes plateformes n'utilisent même pas les mêmes systèmes de coordonnées pour les composantes RVB de couleurs :

nombre flottant de 0.0 à 1.0 sur Casio et ordinateur
nombre entier de 0 à 255 sur NumWorks et TI-83 Premium CE Edition Python

De plus, le standard turtle offre deux fonctions pour régler la couleur :

turtle.pencolor() qui contrôle la couleur du stylo, ici absente sur TI-83 Premium CE Edition Python
turtle.color() qui règle à la fois la couleur du stylo et du pinceau (remplissage), absente cette fois-ci chez Casio

On pourrait penser régler proprement et définitivement ce dernier problème de compatibilité dès l'importation pour n'avoir plus rien à faire par la suite, en rajoutant la fonction manquante. Si l'on importe directement le contenu de turtle, on peut faire :

Code: Select all: try: from ce_turtl.turtle import * pencolor = color except ImportError: from turtle import * try: color except: color = pencolor

Mais traitons maintenant du cas d'importation adapté à la saisie via les menus; on pourrait faire :

Code: Select all: try: from ce_turtl import * ce_turtl.pencolor = ce_turtl.color except ImportError: import turtle try: turtle.color except: turtle.color = turtle.pencolor

Ce dernier code marche parfaitement sur Casio et sur ordi (standard), mais hélas pas sur NumWorks qui refuse à la différence que l'on rajoute après importation une fonction à un module.

Tant pis, le code de compatibilité sera donc moins propre en attendant que l'on trouve mieux.

Nous réglerons de plus l'épaisseur de crayon à 1.

Graph 35+E II	Graph 90+E	TI-83 Premium CE Edition Python	Num Works	ordi

Code: Select all try: from ce_turtl import * turtle.clear() except ImportError: import turtle def my_turtle_pencolor(t): cmax = 255 try: turtle.pencolor((0,0,0)) fc = turtle.pencolor except: fc = turtle.color try: fc((2,2,2)) except: cmax = 1 if(cmax == 1 and max(t)>1): t = tuple(u/255 for u in t) elif(cmax == 255 and any(isinstance(u, float) for u in t)): t=tuple(int(255*u) for u in t) fc(t) def polyg(l,n): for i in range(n): turtle.forward(l) turtle.left(360/n) turtle.pensize(1) my_turtle_pencolor((0,0,255)) polyg(100,4) try: turtle.show() except: pass

Autre divergence ici sur TI-83 Premium CE Edition Python, où le turtle.pensize(1) produit des traits de plus d'1 pixel d'épaisseur contrairement à toutes les autres plateformes.

Tentons maintenant de commencer le tracé ailleurs :

Graph 35+E II	Graph 90+E	TI-83 Premium CE Edition Python	Num Works	ordi

Code: Select all try: from ce_turtl import * turtle.clear() except ImportError: import turtle def my_turtle_pencolor(t): cmax = 255 try: turtle.pencolor((0,0,0)) fc = turtle.pencolor except: fc = turtle.color try: fc((2,2,2)) except: cmax = 1 if(cmax == 1 and max(t)>1): t = tuple(u/255 for u in t) elif(cmax == 255 and any(isinstance(u, float) for u in t)): t=tuple(int(255*u) for u in t) fc(t) def polyg(l,n): for i in range(n): turtle.forward(l) turtle.left(360/n) turtle.pensize(1) my_turtle_pencolor((0,0,255)) turtle.goto(-70,-70) polyg(100,4) try: turtle.show() except: pass

Recommençons maintenant en levant le stylo afin d'éviter le tracé parasite au départ :

Graph 35+E II	Graph 90+E	TI-83 Premium CE Edition Python	Num Works	ordi

Code: Select all try: from ce_turtl import * turtle.clear() except ImportError: import turtle def my_turtle_pencolor(t): cmax = 255 try: turtle.pencolor((0,0,0)) fc = turtle.pencolor except: fc = turtle.color try: fc((2,2,2)) except: cmax = 1 if(cmax == 1 and max(t)>1): t = tuple(u/255 for u in t) elif(cmax == 255 and any(isinstance(u, float) for u in t)): t=tuple(int(255*u) for u in t) fc(t) def polyg(l,n): for i in range(n): turtle.forward(l) turtle.left(360/n) turtle.penup() turtle.pensize(1) my_turtle_pencolor((0,0,255)) turtle.goto(-70,-70) turtle.pendown() polyg(100,4) try: turtle.show() except: pass

Passons maintenant à un hexagone :

Graph 35+E II	Graph 90+E	TI-83 Premium CE Edition Python	Num Works	ordi

Code: Select all try: from ce_turtl import * turtle.clear() except ImportError: import turtle def my_turtle_pencolor(t): cmax = 255 try: turtle.pencolor((0,0,0)) fc = turtle.pencolor except: fc = turtle.color try: fc((2,2,2)) except: cmax = 1 if(cmax == 1 and max(t)>1): t = tuple(u/255 for u in t) elif(cmax == 255 and any(isinstance(u, float) for u in t)): t=tuple(int(255*u) for u in t) fc(t) def polyg(l,n): for i in range(n): turtle.forward(l) turtle.left(360/n) turtle.penup() turtle.pensize(1) my_turtle_pencolor((0,0,255)) turtle.goto(-70,-70) turtle.pendown() polyg(100,6) try: turtle.show() except: pass

Voici maintenant les flocons de Koch :

Graph 35+E II	Graph 90+E	TI-83 Premium CE Edition Python	Num Works	ordi

Code: Select all try: from ce_turtl import * turtle.clear() except ImportError: import turtle def my_turtle_pencolor(t): cmax = 255 try: turtle.pencolor((0,0,0)) fc = turtle.pencolor except: fc = turtle.color try: fc((2,2,2)) except: cmax = 1 if(cmax == 1 and max(t)>1): t = tuple(u/255 for u in t) elif(cmax == 255 and any(isinstance(u, float) for u in t)): t=tuple(int(255*u) for u in t) fc(t) def koch(n, l): if n<=0: turtle.forward(l) else: koch(n-1, l/3) turtle.left(60) koch(n-1, l/3) turtle.right(120) koch(n-1, l/3) turtle.left(60) koch(n-1, l/3) def flock(n, l): koch(n, l) turtle.right(120) koch(n, l) turtle.right(120) koch(n, l) l=80 turtle.penup() turtle.goto(105,3) turtle.left(120) turtle.pendown() my_turtle_pencolor((0, 0, 0)) flock(3, l) turtle.left(120) turtle.penup() turtle.goto(105,-10) turtle.right(60) turtle.pendown() my_turtle_pencolor((255, 127, 0)) flock(4, l) turtle.right(60) turtle.pensize(1) turtle.penup() turtle.goto(5,45) turtle.right(60) turtle.pendown() my_turtle_pencolor((0, 0, 255)) flock(2, l) turtle.right(60) turtle.penup() turtle.goto(-100,17) turtle.left(120) turtle.pendown() my_turtle_pencolor((255, 0, 0)) flock(0, l) turtle.left(120) turtle.pensize(2) turtle.penup() turtle.goto(-100,-5) turtle.right(60) turtle.pendown() my_turtle_pencolor((0, 255, 0)) flock(1, l) turtle.right(60) turtle.penup() turtle.forward(400) try: turtle.show() except: pass

Evidemment, le code utilisant les paramètres turtle.pensize() non standard de la TI-83 Premium CE Edition Python, il ne produit pas le même effet sur la concurrence.
Notons toutefois en passant que les réglages turtle.pensize() semblent totalement ignorés chez Casio.

Et maintenant les triangles de Sierpiński :

Graph 35+E II	Graph 90+E	TI-83 Premium CE Edition Python	Num Works	ordi

Code: Select all try: from ce_turtl import * turtle.clear() except ImportError: import turtle def my_turtle_pencolor(t): cmax = 255 try: turtle.pencolor((0,0,0)) fc = turtle.pencolor except: fc = turtle.color try: fc((2,2,2)) except: cmax = 1 if(cmax == 1 and max(t)>1): t = tuple(u/255 for u in t) elif(cmax == 255 and any(isinstance(u, float) for u in t)): t=tuple(int(255*u) for u in t) fc(t) def sierp(n, l): if n == 0: for i in range (0, 3): turtle.fd(l) turtle.left(120) if n > 0: sierp(n-1, l/2) turtle.fd(l/2) sierp(n-1, l/2) turtle.bk(l/2) turtle.left(60) turtle.fd(l/2) turtle.right(60) sierp(n-1, l/2) turtle.left(60) turtle.bk(l/2) turtle.right(60) turtle.penup() turtle.backward(109) turtle.left(90) turtle.backward(100) turtle.right(90) turtle.pendown() my_turtle_pencolor((255, 0, 0)) sierp(6, 217) turtle.penup() turtle.forward(400) try: turtle.show() except: pass

Bien que non parfaite, les bibliothèques turtle de Casio et NumWorks jouissaient d'une très bonne conformité au standard, ce qui permettait quasiment sans aucune modification d'utiliser les mêmes scripts turtle sur ces modèles différents.

Ici avec ce_turtle sur TI-83 Premium CE Edition Python la compatibilité semble nettement inférieure, et le nombre à gérer de cas particuliers connus à ce jour suffisamment important. A priori une bibliothèque compatibilité turtle va donc malgré tout être nécessaire si l'on souhaite que les scripts turtle standard qui tournent déjà sur Casio/NumWorks puissent également fonctionner sur TI-83 Premium CE Edition Python, et inversement.

Tuto-vidéo : utilisation du module complémentaire ce_turtl

by **critor** » 18 May 2020, 21:28

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 :

mise à jour en 5.5 de l'application SciTools
mise à jour en 5.5 de l'application Periodic
mise à jour en 5.5 de l'application Python (TI-83 Premium CE Édition Python uniquement)

Python 5.5 offre de nouveaux modules intégrés pour tes scripts Python :

time, certes déjà présent mais maintenant listé au menu et donc officiel
ti_system, avec diverses possibilités :
- 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
ti_rover, pour les projets de robotique à l'aide du TI-Innovator Rover

Mais ce n'est pas tout car Python 5.5 gère également la possibilité inédite de rajouter des modules Python complémentaires :

ce_turtl, comparable à turtle
ce_box pour les diagrammes en boîte
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 :

Code: Select all: while not ti_system.escape(): pass

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

Quelques exemples :

Code: Select all: from ce_box import * data = [3,2,3,3,1,5,4,3,1,5,2,1,4,3,3,0,1,3,3,1,2,4,2,4,0,0,2,2,3,2] Ex1 = box(data) Ex1.title('Exercice 4-1') Ex1.show()

Code: Select all: 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()

Nous ignorons toutefois à ce jour si c'est bien la définition particulière des quartiles en vigueur au lycée français qui est utilisée.

Tuto-vidéo : utilisation du module complémentaire ce_box

by **critor** » 18 May 2020, 22:29

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 Python ti_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é :

Code: Select all: import ti_plotlib as plt from ti_system import * from ce_quivr imort * #Les fonctions def calc_vitesses(absc, temps): v = [] for n in range(len(absc) - 1): v.append((absc[n + 1] - absc[n]) / (temps[n + 1] - temps[n])) temps = temps[:-1] return v, temps def rep_vitesses(absc, vitesses): for i in range(len(vitesses)): quiver(absc[i], 0, vitesses[i], 0, 0.06, "b", "vector") #Le programme plt.cls() plt.title("Etude du MRUA") plt.window(-0.2, 1.2, -1, 1) x = recall_list("2") t = recall_list("1") v, temps_v = calc_vitesses(x, t) rep_vitesses(x, v) plt.show_plot()

Et maintenant pour l'étude d'un mouvement à une dimension sur un axe :

Code: Select all: import ti_plotlib as plt from ce_quivr import * fx = lambda x: x**3 - 4*x**2 + 3*x - 2 dx = lambda x: 3*x**2 - 8*x + 3 d2x = lambda x: 6*x - 8 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()

Tuto-vidéo : utilisation du module complémentaire ce_quivr

by **critor** » 19 May 2020, 08:19

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 Python ti_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.

Regardons-en de suite l'utilisation à cette fin :

Code: Select all: 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 2^nd 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.

Code: Select all: from ce_chart import * import ti_plotlib as plt from math import * cht = chart() plt.cls() plt.window(-pi, pi, -1.1, 1.4) plt.grid(.6, .40, "solid") plt.color(0,0,0) plt.axes() f = lambda x:sin(x) 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 draw_fx(-pi, pi, f, 40, "g") the_area = calc_area(50, -pi, pi, f) plt.title("Somme des Aires = " + str(round(the_area, 4))) plt.show_plot()

Tuto-vidéo : utilisation du module complémentaire ce_chart

by **critor** » 20 May 2020, 01:33

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 :

mise à jour en 5.5 de l'application SciTools
mise à jour en 5.5 de l'application Periodic
mise à jour en 5.5 de l'application Python (TI-83 Premium CE Édition Python uniquement)

Python 5.5 offre de nouveaux modules intégrés pour tes scripts Python :

time, certes déjà présent mais maintenant listé au menu et donc officiel
ti_system, avec diverses possibilités :
- 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
ti_rover, pour les projets de robotique à l'aide du TI-Innovator Rover

Mais ce n'est pas tout car Python 5.5 gère également la possibilité inédite de rajouter des modules Python complémentaires :

ce_turtl, comparable à turtle
ce_box pour les diagrammes en boîte
ce_chart pour les histogrammes et aires entre courbes
ce_quivr pour les diagrammes utilisant des champs de vecteurs

Nous nous proposons aujourd'hui d'explorer le module de robotique ti_rover.

Sommaire :

menus ti_rover et langage
importation et taille ti_rover
ti_rover et projets
exploration ti_rover
conclusion

1) menus ti_rover et langage

Go to top

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 1^er 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.

2) importation et taille ti_rover

Go to top

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 :

Code: Select all: from gc import mem_free as mf smod = input('Module : ') mf1, mf2 = 0, 0 scmd = 'from ' + s + ' import *' mf1 = mf() exec(scmd) mf2 = mf() print(mf1 - mf2)

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

3) ti_rover et projets

Go to top

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.

Code: Select all: # TI-Rover 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 :

Code: Select all: # 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 :

Code: Select all: # TI-Rover 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 !

4) exploration ti_rover

Go to top

Enfin, terminons par une exploration intégrale du contenu du module ti_rover, à l'aide du script suivant :

Code: Select all: #platforms: #0: MicroPython / TI-Nspire #1: MicroPython / NumWorks #2: MicroPython / G90+E / G35+E II #3: MicroPython / G35+E/USB / G75/85/95 #4: CircuitPython / TI-Python / 83PCE / Trinket M0 #5: Xcas / HP Prime #6: KhiCAS / Graph 90+E 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] unsafe = ((), (), (), ('sys.argv', 'sys.path'), (), (), ()) 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) done = {'str':False, 'list':False, 'tuple':False, 'dict':False, 'complex':False, 'set':False, 'frozenset': False} 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 :

aux examens
français hors
examens

	Casio Graph 35+E II 90+E	version alpha HP Prime	NumWorks	TI-83PCE Ed. Python
builtins array collections cmath gc math matplotlib matplotlib.pyplot micropython os random sys time turtle uerrno	84-197 . . . . 25-47 . . . . 8-30 . . . .	97-1581 3-363 . 13-428 9-404 42-602 . . 10-410 . . 17-977 . . 25-1277	89-211 . . 12-34 . 41-63 3-25 11-33 6-28 . 9-31 . 3-25 38-60 .	92-211 2-24 2-24 . 7-29 28-50 . . . . 8-30 15-93 4-26 . .
spécifique	casioplot:6-28	prime:3-368	ion:48-162 kandinsky:8-30	ti_graphics:30-75 ti_hub:? ti_plotlib:49-84 ti_system:12-34 ti_rover:66-92
Modules	4	9	11	13
Eléments	123-302	219-6042	267-701	315-772

Classement en terme de richesse :

315-772 éléments : TI-83 Premium CE Edition Python
267-701 éléments : NumWorks
219-6042 éléments : HP Prime (version alpha)
123-302 éléments : Casio Graph 90+E / 35+E II

	Casio Graph 35+E II 90+E	CasioPython Casio Graph 35+E II 35+E/USB 75/85/95	MicroPython TI-Nspire	TI-Python	firmware tiers TI-Python
builtins array collections cmath gc math matplotlib matplotlib.pyplot micropython os random sys time turtle uerrno	84-197 . . . . 25-47 . . . . 8-30 . . 69-126 .	91-230 2-28 . 12-38 7-33 41-67 . . 6-32 . 8-34 12-38 . . 24-108	93-218 2-28 . 12-38 7-33 41-67 . . 3-29 . . 15-86 . . .	92-212 2-24 2-24 . 7-29 28-50 . . . . 8-30 15-93 4-26 . .	93-214 2-25 2-25 12-35 7-30 41-64 . . 6-29 15-38 8-31 15-99 8-33 . .
spécifique	casioplot:6-28 matplotl:25-68		nsp:3-10		board:22 storage:7-47
Modules	6	9	8	9	13
Eléments	217-496	203-608	176-509	158-488	238-692

Classement en terme de richesse :

315-772 éléments : TI-83 Premium CE Edition Python
267-701 éléments : NumWorks
238-692 éléments : TI-83 Premium CE + TI-Python (firmware tiers)
219-6042 éléments : HP Prime (version alpha)
217-496 éléments : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
203-608 éléments : Casio Graph 75/85/95 / 35+E/USB / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
176-509 éléments : TI-Nspire (appli MicroPython)
158-488 éléments : TI-83 Premium CE + TI-Python

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 !

5) conclusion

Go to top

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.

Pour t'inscrire, c'est par ici.

Tuto-vidéos ti_rover :