Découverte ce_turtl 83 Premium CE 5.5 + tests compatibilité

[critor]

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: Tout sélectionner

try: from ce_turtl.turtle import *
except ImportError: from turtle import *

Code: Tout sélectionner

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: Tout sélectionner

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: Tout sélectionner

while not ti_system.escape():
  pass

Graph 35+E II	Graph 90+E	TI-83 Premium CE Edition Python	Num Works	ordi
Code: Tout sélectionner 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: Tout sélectionner

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: Tout sélectionner

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: Tout sélectionner 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: Tout sélectionner 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: Tout sélectionner 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: Tout sélectionner 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: Tout sélectionner 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: Tout sélectionner 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