[critor]

Nous te l'annoncions dans une actualité précédente, les TI-83 Premium CE Edition Python et compatibles (TI-84 Plus CE-T Python Edition en Europe, TI-84 Plus CE Python en Amérique du Nord, TI-84 Plus CE dans le reste du monde) ont subi une nouvelle phase de réduction des coûts de fabrication pour la rentrée 2021.

Au menu à partir de la révision matérielle T (machines assemblées à compter de Juin 2021), la suppression de la diode témoin utilisée lors de la recharge de la batterie sur la tranche latérale à côté du port mini-USB. Peut-être as-tu eu la malchance de tomber sur une de ces machines...

Nous regrettons bien évidemment la disparition de cette diode qui nous était très utile, mais on peut voir la chose différemment. Cette suppression permet en conséquence des économies sur les coûts de fabrication qui, en période de pénurie mondiale de semi-conducteurs, devraient peut-être permettre à Texas Instruments de ne pas augmenter ses prix ou sinon de s'en tenir à une augmentation raisonnable, contrairement à d'autres constructeurs.

Restait une grande question. Les calculatrices en révision matérielle T allaient-elles bénéficier d'une nouvelle carte électronique, ou bien conserver la même carte avec juste les composants relatifs à la diode de charge absents ?

Ajoutons que selon Adriweb, certaines calculatrices vont conserver la diode de charge : les TI-84 Plus CE Python School Property. Également appelées TI-84 Plus CE EZ Spot (pour "easy spot" soit faciles à remarquer), ces machines sont disponibles exclusivement à l'achat pour les établissements scolaires nord-américains, conservées au sein de l'établissement et mises à disposition des élèves lors des cours les nécessitant. Bardées de marques jaunes caractéristiques des bus scolaires nord-américains, elles sont ainsi très aisément identifiables et limitent les possibilités d'être emportées par les élèves, volontairement ou non.

Pour toutes les autres calculatrices donc, nous penchions en conséquence pour l'hypothèse de conservation de la même carte électronique sans les composants relatifs à la diode.

Connaissant Texas Instruments ce ne serait pas surprenant. Ce serait loin d'être la première fois ; par exemple les TI-84 Plus CE Python américaine et TI-84 Plus CE internationale n'ont pas la diode examen mais utilisent la même carte électronique que les autres modèles. Les emplacements correspondant au circuit de la diode examen sont alors laissés vides, ci-contre en haut à gauche.

LogicalJoe vient justement de récupérer une TI-84 Plus CE Python en révision matérielle T, de la démonter et d'en partager une photo. De quoi enfin répondre à nos dernières interrogations.

Donc c'est confirmé, les TI-84 Plus CE en révision matérielle T continuent à utiliser la même carte électronique de référence SG95N/F/T-11(2L) que la révision matérielle S précédente, carte que nous t'avions déjà présentée.

La seule différence, semble donc être l'absence de la diode D10G à côté du port USB, à gauche ci-contre et en bas ci-dessous. L'emplacement reste vide, 2 résistances voisines R36G et R39G sont également manquantes, ainsi que 2 transistors Q06G et Q07G. Si toi aussi tu as eu la malchance de récupérer une calculatrice en révision matérielle T et regrettes l'absence de la diode de charge, au moins maintenant tu sais quoi rajouter.

Image 1 vs. Image 2

[critor]

Pour accompagner en douceur la transition du Scratch au Python en Seconde, la plupart des solutions Python sur calculatrices graphiques offrent turtle, un module permettant du tracé relatif comme en Scratch. On peut citer :

• la NumWorks dont l'application Python intègre directement turtle
• les Casio Graph 35+E II et Graph 90+E dont l'application Python intègre directement turtle
• les TI-Nspire CX II sur lesquelles on peut rajouter un module turtle officiel à l'environnement Python
• et sur les TI-83 Premium CE Edition Python (France), TI-84 Plus CE-T Python Edition (Europe) et TI-84 Plus CE Python (Amérique du Nord), on pouvait jusqu'ici rajouter un module officiel ce_turtl à l'application Python

L'utilisation de ce_turtl sur TI-83 Premium CE Edition Python et compatible n'était jusqu'à présent pas de tout repos, loin de là. En effet énorme problème, les modules complémentaires comme ce_turtl n'étaient par défaut pas disponibles au menu.

Ils apparaissaient au menu uniquement lorsque l'on était en train d'éditer un script comportant une ligne les important (dans notre cas forcément sous la forme from ce_turtl import, et pas un simple import ce_turtl).

Lors de la création d'un script, afin d'obtenir le menu te permettant de saisir facilement et rapidement les appels aux différentes méthodes de ce_turtl, tu devrais donc commencer par te taper la saisie lettre par lettre au clavier de sa ligne d'importation, avec en prime le caractère tiret bas qui n'est pas au clavier et était donc à aller chercher dans un menu.

Mais attends car le pire, c'est que c'était encore loin d'être le pire...

Mais surtout bien pire que cela, ce_turtl était une véritable catastrophe ambulante !

Aucun effort ne semblait avoir été fait pour coller au standard : des méthodes essentielles manquantes, des noms de méthodes fantaisistes, des arguments attendus différant du standard dans leur nombre, leur ordre ou leur type... et ne parlons même pas encore du comportement attendu.

Si tu ne faisais pas l'effort d'adapter ton code, il t'était fort probable d'obtenir n'importe quoi. Voici ci-contre ce que donne un escargot sur ordinateur et l'ensemble de la concurrence, et sur TI-83 Premium CE Edition Python et compatibles avec ce_turtl...

Quel professeur allait perdre du temps à faire apprendre un sous-dialecte du turtle ne fonctionnant que sur calculatrice TI-83 Premium CE Edition Python, risquant ainsi de mélanger les élèves par rapport aux documents, ouvrages ou autres autres plateformes auxquels ils ont accès (ordinateur, tablette, smartphone, calculatrice d'un autre modèle) ?...

Nous savons parfaitement que la mémoire de tas (heap) du Python des TI-83 Premium CE Edition Python et compatibles est extrêmement limitée, seulement 19,968 Ko de capacité, et en pratique souvent bien moins de disponible car les modules importés prennent de la place.

Dans ce contexte nous comprenons parfaitement qu'il faille se limiter et faire des choix.

Mais nous persistons à penser que l'on pouvait faire largement mieux niveau compatibilité et conformité que ce que nous a offert ce_turtl, et ce sans augmenter la consommation de heap à l'exécution.

Dans le cadre de sa mise à jour 5.7 pour TI-83 Premium CE Edition Python et compatibles, Texas Instruments publie un nouveau module complémentaire s'appelant cette fois-ci turtle. On pourrait donc s'attendre à un meilleur respect du standard, mais cela va être à vérifier.

Ce nouveau module turtle peut être installé indépendamment de la mise à jour ; il fonctionne tout aussi bien sur les versions précédentes selon nos tests.

Mais si tu mets à jour en version 5.7 tu bénificieras d'un formidable avantage : un nouvel onglet de bas d'écran te permet enfin de lister les modules complémentaires importables et turtle en fait partie !

Donc plus de saisie fastidieuse, une seule touche suffit à coller la ligne d'importation et alors faire apparaître tout le contenu du nouveau module turtle au menu !

Mais reste à voir pour le reste. Découvrons donc maintenant ensemble si le nouveau module turtle est effectivement meilleur que ce_turtl.

1. Informations et fonctionnement
2. Le tour des menus
3. Premier script comparatif (ce_turtl + turtle)
4. Tests de conformité comparatifs (tous modèles)
5. 12 exemples comparatifs (tous modèles)
   
   1. Rosace à la Casio
   2. Fractale de Koch
   3. Flocons de Koch
   4. Sous le soleil exactement
   5. Escargot de lumière
   6. Triangles de Sierpiński
   7. Casio Graph 90+E
   8. Sapin de Noël
   9. Supernova PhiX 177
   10. Champ de zinnias en été
   11. Courtepointe de grand-mère
   12. Vitrail de Notre-Dame
6. Conclusion
7. Téléchargements

A) Informations et fonctionnement

Go to top

La publication de Texas Instruments consiste en 2 fichiers de variables d'application pour calculatrice :

• TURTLE.8xv
• GRID.8xv

TURTLE.8xv est le module Python complémentaire en question, ici en version 2.0.0. Soit cela signifie qu'il y a eu des versions inférieures de test auxquelles nous n'avons pas eu accès, soit ce changement de numérotation majeure est pour noter une différence significative par rapport à ce_turtle.

Le fichier TURTLE.8xv a été généré par Texas Instruments à l'aide de py2appvar, un outil non public de Texas Instruments permettant à partir d'un fichier source Python :

• la conversion du cose source Python en bytecode Python
• l'énumération des éléments à mettre au menu à partir de lignes de commentaires spécialement formatées à cette fin dans le code source

Contrairement à CE_TURTL.8xv, TURTLE.8xv a été généré à l'aide d'une version plus récente de l'outil py2appvar, non plus la 1.2.0 mais la 1.2.1. Nous supposons que py2appvar 1.2.1 ajoute la gestion de la nouvelle ligne de commentaire permettant de spécifier l'ajout de la commande d'importation au menu des modules complémentaires.

GRID.8xv quant à lui n'est rien d'autre qu'une image 320×210 pixels au format IM8C directement affichable par les scripts Python de la calculatrice et que voici justement ci-contre ; il s'agit donc d'une grille.

Code: Select all

from ti_image import *
load_image("GRID")
show_image(0, 0)
show_screen()

Cette image sera affichée automatiquement à chaque début d'appel à des fonctions de tracé turtle, se comportant donc comme une sorte de fond d'écran.

Code: Select all

from turtle import *
t = Turtle()
t.circle(52)
t.done()

Tu peux très bien te passer de GRID, soit ne pas transférer ou effacer la variable en question. Dans ce cas cela ne déclenche pas d'erreur, mais rappelons que le Python sur TI-83 Premium CE Edition Python et compatible ne dispose pas d'un buffer dédié aux affichages graphiques, ces derniers étant effectués par-dessus la console. Ne trouvant alors rien à afficher, l'écran ne sera pas nettoyé et il te faudra alors rajouter du code en ce sens.

Tu peux également t'amuser à remplacer le fond d'écran du module turtle comme bon te semble. Notre outil en ligne img2calc te permet de convertir n'importe quelle image au format IM8C de Texas Instruments, et il te suffira alors juste de choisir le nom GRID pour la calculatrice.

Rappelons que comme le buffer d'affichage est ici unique, tu dois effectuer une pause en fin de script sous peine de voir ton tracé une fois terminé être immédiatement écrasé par l'affichage de la console. Le module turtle t'offre pour cela la méthode .done() qui attend l'appui sur la touche

annul

(ou

clear

sur les TI-84 Plus CE), mais tu es libre d'utiliser n'importe quel autre code générant une attente.

À noter que le module turtle t'offre la possibilité de désactiver l'affichage de la grille. Il te suffira d'appeler la méthode .hidegrid() avant ta première instruction d'affichage.

En pratique la méthode .hidegrid() efface simplement l'écran en blanc.

B) Le tour des menus

Go to top

Les méthodes au menu sont réparties sous différents onglets :

• Move : pour les déplacements de la tortue
• Draw : pour les tracés autres que des segments (cercle, texte, remplissage, ...)
• Pen : pour tout ce qui concerne le stylo (levé, baissé, couleur, taille)
• Settings : pour différents réglages (effacement du tracé, cacher/montrer la tortue, désactiver l'affichage de la grille comme déjà vu, vitesse)
• State : pour interroger l'état de la tortue (position, orientation)

Mais ce qui est extraordinaire ici et à ce jour une exclusivité toute concurrence confondue, c'est la présence des méthodes de remplissage de formes !

De quoi a priori étendre très largement les possibilités et facilités de tracé pour les élèves !

C) Premier script comparatif (ce_turtl + turtle)

Go to top

Tentons un premier script dessinant une cible :

ce_turtl	turtle
Code: Select all from ce_turtl import * turtle.clear() turtle.goto(0,-95) s = 3 for r in range(0, 159, r):   turtle.circle(r) turtle.show()	Code: Select all from turtle import * t = Turtle() t.goto(0,-95) s = 3 for r in range(0, 159, r):   t.left(90)   t.circle(r)   t.right(90) t.done()

Déjà ce script met en évidence un bug en Python des TI-83 Premium CE Edition Python et compatibles : au-delà d'une certaine valeur de rayon les tracés de cercles se déforment très rapidement et tendent vers des carrés.

Le bug n'est en fait ni dans ce_turtl ni dans turtle, mais dans le module de tracé par pixels ti_graphics qu'ils utilisent tous les deux sur ces calculatrices, visiblement toujours pas corrigé en version 5.7.

Mais problème... Si tu regardes bien bien que la structure soit similaire, nous avons dû écrire 2 scripts différents pour ce_turtl et turtle.

Si en plus on fait rentrer la concurrence dans l'équation, il n'est pas envisageable pour nous de maintenir jusqu'à 7 versions différentes pour chaque script testé...

D) Tests de conformité comparatifs (tous modèles)

Go to top

Tentons donc un autodiagnostic des différences entres tous les modules turtle, c'est-à-dire la vérification de tout ce qui peut différer du standard.

Voici des scripts en ce sens, une amélioration majeure de ceux développés dans le code de notre test de rentrée QCC 2021 :

ttl_chk.py ttl_diags.py

Code: Select all

_turtle_errors = 0

def _turtle_error(k):
  global _turtle_errors
  _turtle_errors |= 1 << k

# import turtle
try:
  import turtle
  if not "forward" in dir(turtle):
    turtle = turtle.Turtle()
except ImportError: #TI-83 Premium CE
  from ce_turtl import turtle
  _turtle_error(0)
try:
  turtle.clear()
except:
  turtle.reset()

# can turtle be patched ?
_fix_turtle = True
try:
  def _fixcolor(c): return c
  turtle._fixcolor = _fixcolor
except:
  _fix_turtle = False

# test color() + pencolor() + fillcolor()
if not "pencolor" in dir(turtle):
  pencolor = turtle.color
  _turtle_error(1)
else:
  pencolor = turtle.pencolor
if not "color" in dir(turtle):
  _turtle_error(2)
if not "fillcolor" in dir(turtle):
  _turtle_error(12)

if not "clear" in dir(turtle):
  _turtle_error(13)
if not "reset" in dir(turtle):
  _turtle_error(14)
if not "heading" in dir(turtle):
  _turtle_error(11)

# test color argument types
_color_types = 0
try:
  pencolor([0, 0, 0])
  _color_types |= 1 << 0
except: _turtle_error(4)
try:
  pencolor((0, 0, 0))
  _color_types |= 1 << 1
except: _turtle_error(5)
try:
  pencolor(0, 0, 0)
  _color_types |= 1 << 2
except: _turtle_error(6)
try:
  pencolor("black")
  _color_types |= 1 << 3
except: _turtle_error(7)

# test colormode()
if not "colormode" in dir(turtle):
  _turtle_error(3)

# test color strings
_colors_fix={
  "blue":(0,0,1),
  "green":(0,1,0),
  "red":(1,0,0),
  "cyan":(0,1,1),
  "yellow":(1,1,0),
  "magenta":(1,0,1),
  "white":(1,1,1),
  "orange":(1,0.65,0),
  "purple":(0.66,0,0.66),
  "brown":(0.75,0.25,0.25),
  "pink":(1,0.75,0.8),
  "grey":(0.66,0.66,0.66),
  "black":(0,0,0),
}
for c in tuple(_colors_fix.keys()):
  try:
    pencolor(c)
    _colors_fix.pop(c)
  except: pass
if len(_colors_fix):
  if _color_types & 1 << 3:
    _turtle_error(8)

# test circle(,)
try: turtle.circle(0,0)
except:
  _turtle_error(9)

# test for unfixable missing functions
_missing_fct=["write","pensize","dot"]
for f in tuple(_missing_fct):
  try:
    eval("turtle."+f)
    _missing_fct.remove(f)
  except: pass
if len(_missing_fct):
    _turtle_error(15)

_missing_alias=[
  ["backward","back","bk"],
  ["forward","fd"],
  ["right","rt"],
  ["left","lt"],
  ["position","pos"],
  ["goto","setpos","setposition"],
  ["setheading","seth"],
  ["pendown","pd","down"],
  ["penup","pu","up"],
  ["pensize","width"],
  ["showturtle","st"],
  ["hideturtle","ht"],
]
for aliases in tuple(_missing_alias):
  validf = None
  for f in tuple(aliases):
    try:
      eval("turtle."+f)
      validf = f
      aliases.remove(f)
      break
    except: pass
  for f in tuple(aliases):
    try:
      eval("turtle."+f)
      aliases.remove(f)
    except: pass
  if not len(aliases):
    _missing_alias.remove(aliases)
  else:
    aliases.insert(0, validf)
if len(_missing_alias):
    _turtle_error(16)

try:
  turtle.position()
except:
  try:
    turtle.pos()
  except:
    _turtle_error(10)

Code: Select all

from ttl_chk import *
from ttl_chk import _fix_turtle, _turtle_errors, _colors_fix, _missing_fct, _missing_alias

def turtle_diags():
  print("Type: " + str(type(turtle)))
  print("Patchable: " + (_fix_turtle and "yes" or "no"))
  errors_msg = (
    "No <import turtle>",
    "No pencolor()",
    "No color()",
    "No colormode()",
    "No color as list",
    "No color as tuple",
    "No color as args",
    "No color as string",
    "Missing colors strings: ",
    "No circle(,angle)",
    "Can't get position()",
    "No heading()",
    "No fill",
    "No clear()",
    "No reset()",
    "Other missing: ",
    "Missing aliases: ",
  )
  errors = 0
  for k in range(len(errors_msg)):
    if _turtle_errors & 1 << k:
      errors += 1
      msg = "Err " + str(k) + ": " + errors_msg[k]
      if k == 8:
        msg += str(len(_colors_fix)) + " " + str(tuple(_colors_fix.keys()))
      if k == 15:
        msg += str(len(_missing_fct)) + " " + " ".join(_missing_fct)
      if k == 16:
        l = []
        for v in _missing_alias:
          l.extend(v[1:])
        msg += str(len(l)) + " " + " ".join(l)
      print(msg)
  print(str(errors) + " error" + ((errors > 1) and "s" or ""))

turtle_diags()

Voici ce que nous racontent les scripts sur calculatrices Texas Instruments :

TI-83PCE/84+CE ce_turtl	TI-83PCE/84+CE turtle	TI-Nspire CX II turtle

Pas étonnant que ce_turtle fasse n'importe quoi, c'est une véritable calamité. Pas moins de 11 erreurs, et encore ce sont juste celles qui sont détectées. La grande majorité de ce qui est testé ne va pas :

• ligne d'importation non standard (à cause du nom)
• réglage non standard de la couleur du tracé, utilisant la méthode .color() au lieu de .pencolor()
• absence de la méthode .colormode() et donc pas de possibilité de modifier le mode des coordonnées de couleurs (maximum de chaque composante à 1 ou à 255)
• refus des paramètres de couleurs sous forme de tuple, liste ou chaîne de caractères, les fonctions concernée prennent obligatoirement 3 paramètres avec les valeurs de chaque composante
• la méthode .circle() ne prend qu'un seul argument et ne gère donc pas les arcs de cercle
• absence des méthodes de remplissage
• absence de la méthode d'effacement et réinitialisation de la tortue .reset()
• absence de la méthode d'écriture de texte .write()
• absence de 18 alias courts pour les noms de méthodes

Avec le nouveau module turtle nous tombons à seulement 7 erreurs.

Son code source ne semblerait pas dériver de celui de ce_turtl, puisque certaines erreurs disparaissent alors qu'une autre apparaît.

Restent donc :

• absence de la méthode .color()
• absence de la méthode .colormode() et donc pas de possibilité de modifier le mode des coordonnées de couleurs (maximum de chaque composante à 1 ou à 255)
• refus des paramètres de couleurs sous forme de liste ou chaîne de caractères, mais les tuples sont acceptés
• la méthode .circle() ne prend qu'un seul argument et ne gère donc pas les arcs de cercle
• absence de la méthode d'effacement et réinitialisation de la tortue .reset()
• absence de 16 alias courts pour les noms de méthodes

Le turtle des TI-Nspire CX II pour sa part ne donne que 5 erreurs. Vu la grande similarité, on pourrait se demander si le nouveau module turtle des TI-83 Premium CE Edition Python et compatibles ne découlerait pas de celui des TI-Nspire CX II, avec juste la suppression des paramètres de couleurs sous forme de chaîne de caractères afin d'économiser un peu de place en heap.

Voici pour référence les résultats du même test chez la concurrence :

Casio Graph 90/35+E II	NumWorks	KhiCAS NumWorks TI-Nspire CX II CX

Un avantage des Texas Instruments et des Casio, c'est que le module turtle peut être modifié, et la plupart des erreurs sont ainsi corrigeables !

À nuancer toutefois, car vu la faible capacité du heap des TI-83 Premium CE Edition Python et compatibles, on ne peut pas non plus envisager de tout corriger.

Voici un script qu'il suffit d'importer à la place du module turtle de chaque machine, et lorsque autorisé corrige la plupart des erreurs détectées :

Code: Select all

from ttl_chk import *
from ttl_chk import _color_types, _turtle_errors, _colors_fix, _missing_fct, _missing_alias

_fix_turtle = True

def nop(*argv): return None
idty = lambda c: c

try: # can turtle be patched ?
  turtle._fixcolorlist = idty
  turtle._fixcolorval = idty
  turtle._fixcolorstring = idty
  turtle._fixcolorargs = idty
  turtle._fixcolor = lambda c: turtle._fixcolorlist(turtle._fixcolorval(turtle._fixcolorstring(turtle._fixcolorargs(c))))
except:
  _fix_turtle = False

if _fix_turtle:

  # fix color() + pencolor()
  if _turtle_errors & 2:
    turtle.pencolor = turtle.color
  if _turtle_errors & 4:
    turtle.color = turtle.pencolor
  if _turtle_errors & 0x1000:
    turtle.fillcolor, turtle.begin_fill, turtle.end_fill = idty, nop, nop

  _fix_color = _color_types & 0b11 != 0b11 or not "colormode" in dir(turtle)

  # fix list/tuple color argument
  if _color_types & 0b11 == 0b10:
    def _fixcolorlist(c): return type(c) is list and tuple(c) or c
    turtle._fixcolorlist = _fixcolorlist
  if _color_types & 0b11 == 0b01:
    def _fixcolorlist(c): return type(c) is list and list(c) or c
    turtle._fixcolorlist = _fixcolorlist
  if not _color_types & 4:
    def _fixcolorargs(*argv):
      return len(argv) != 1 and argv or argv[0]

  if _fix_color:
    turtle._color = turtle.color
    turtle._pencolor = turtle.pencolor
    turtle._fillcolor = turtle.fillcolor
    if _color_types & 0b11:
      def _color(*argv):
        if not(len(argv)): return turtle._color()
        turtle._color(turtle._fixcolor(len(argv) > 1 and argv or argv[0]))
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        turtle._pencolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0]))
      def _fillcolor(*argv):
        if not(len(argv)): return turtle._fillcolor()
        turtle._fillcolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0]))
    else:
      def _color(*argv):
        if not(len(argv)): return turtle._color()
        c = turtle._fixcolor(len(argv)>1 and argv or argv[0])
        turtle._color(c[0], c[1], c[2])
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        c = turtle._fixcolor(len(argv)>1 and argv or argv[0])
        turtle._pencolor(c[0], c[1], c[2])
      def _fillcolor(*argv):
        if not(len(argv)): return turtle._fillcolor()
        c = turtle._fixcolor(len(argv)>1 and argv or argv[0])
        turtle._fillcolor(c[0], c[1], c[2])
    turtle.color = _color
    turtle.pencolor = _pencolor
    turtle.fillcolor = _fillcolor

  # fix colormode()
  if _turtle_errors & 8:
    # test color mode
    try:
      turtle.pencolor([255, 0, 0])
      _color_mode = 255
    except: _color_mode = 1.0
    turtle._color_mode = _color_mode
    def _colormode(*argv):
      if not(len(argv)): return turtle._color_mode
      if int(argv[0]) in (1, 255):
        turtle._color_mode = int(argv[0]) == 255 and 255 or 1.0
    turtle.colormode = _colormode
    if _color_mode == 255:
      turtle._fixcolorval = lambda c: int(turtle._color_mode) == 1 and type(c) in (list, tuple) and [int(c[k] * 255) for k in range(3)] or c
    else:
      turtle._fixcolorval = lambda c: turtle._color_mode == 255 and type(c) in (list, tuple) and [c[k] / 255 for k in range(3)] or c

  # fix color strings
  if len(_colors_fix):
    def _fixcolorstring(c):
      if type(c) is str and c in _colors_fix:
        c = _colors_fix[c]
        if turtle.colormode() == 255:
          c = [int(c[k] * 255) for k in range(3)]
      return c
    turtle._fixcolorstring = _fixcolorstring

  # fix circle(,)
  if _turtle_errors & 0x200:
    turtle._circle = turtle.circle
    def _circle(r, a=360): turtle._circle(r)
    turtle.circle = _circle

  if len(_missing_fct):
    for f in _missing_fct:
      exec("turtle."+f+"=nop")

  if len(_missing_alias):
    for aliases in _missing_alias:
      validf = aliases[0]
      for f in aliases[1:]:
        exec(validf and "turtle."+f+"=turtle."+validf or "turtle."+f+"=nop")

  # fix clear()
  if _turtle_errors & 0x2000:
    turtle.clear = turtle.reset

  # fix reset()
  if _turtle_errors & 0x4000:
    turtle.reset = turtle.clear

Nous pouvons envisager à partir de maintenant d'avoir une unique version de chaque script utilisable sur l'ensemble des machines.

E) 12 exemples comparatifs (tous modèles)

Go to top

Maintenant que nous avons de quoi faire tourner une unique version de chaque script sur l'ensemble des machines, poursuivons l'exploration de l'ensemble des modules turtle avec quelques exemples de script.

Cela va justement être l'occasion de voir si il y a d'autres problèmes qui n'ont pas pu être détectés automatiquement

1. Rosace à la Casio
2. Fractale de Koch
3. Flocons de Koch
4. Sous le soleil exactement
5. Escargot de lumière
6. Triangles de Sierpiński
7. Casio Graph 90+E
8. Sapin de Noël
9. Supernova PhiX 177
10. Champ de zinnias en été
11. Courtepointe de grand-mère
12. Vitrail de Notre-Dame

Exemple n°1 : Rosace à la Casio

Go to top

C'est donc parti pour quelques exemples afin d'approfondir les améliorations du nouveau module turtle pour TI-83 Premium CE Edition Python et compatibles, ainsi que les points forts et faibles par rapport aux autres modèles de calculatrices.

Précisons que les problèmes récurrents ne seront pas systématiquement réévoqués sur chaque exemple.

Commençons par une petite rosace à la Casio ; tout possesseur de Graph 35+E II sait en effet que Casio aime bien ça :

Code: Select all

from ttl_fix import *

turtle.speed(0)
turtle.pensize(1)
turtle.pencolor("black")
for i in range(12):
  turtle.left(30)
  for i in range(8):
    turtle.forward(30)
    turtle.left(45)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

C'est la base, tout-le-monde s'en sort à peu près, mais tu peux déjà constater quelques légers écarts.

Il y avait donc avec ce_turtl un problème d'écart par rapport au standard, un décalage d'une unité lors du réglage de l'épaisseur via la méthode turtle.pensize().

Ici l'appel turtle.pensize(1) produisait l'effet d'un turtle.pensize(2).
Et plus généralement un appel turtle.pensize(s) produisait l'effet d'un turtle.pensize(s+1).

On peut noter que le problème disparaît avec le nouveau module turtle.

KhiCAS donne également l'impression d'avoir un problème d'épaisseur, mais si tu regardes bien c'est en fait un tout autre problème. L'épaisseur est correcte sur les segments horizontaux et verticaux, seuls les segments obliques sont plus épais qu'ils ne devraient. Cela découle de l'algorithme de tracé choisi dans ce cas.

L'écran de la Casio Graph 35+E II a une définition très inférieure de seulement 128×64 pixels, et bien évidemment le tracé est donc tronqué. Pour le coup, là cela aurait été particulièrement utile de pouvoir faire défiler le tracé...

Exemple n°2 : Fractale de Koch

Go to top

Poursuivons avec une fractale, la fractale de Koch, et profitons-en pour choisir une couleur :

Code: Select all

from ttl_fix import *

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)

turtle.speed(0)
turtle.pensize(1)
turtle.pencolor("blue")
turtle.penup()
turtle.goto(-180, -50)
turtle.pendown()
koch(4, 360)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Il y avait avec ce_turtl un décalage progressif du tracé, l'affichage obtenu dans la fenêtre n'étant pas symétrique alors que calculé pour.

Ici encore le problème disparaît avec le nouveau module turtle.

Le cas de KhiCAS est complètement différent et n'est à la différence pas un problème. La fenêtre obtenue défile automatiquement en fonction des mouvements de la tortue, et peut même être défilée au clavier une fois le tracé terminé, ce qui est d'ailleurs fort utile pour explorer des tracés débordant de la fenêtre graphique. Une exclusivité à ce jour sur calculatrices !

Exemple n°3 : Flocons de Koch

Go to top

Altérons légèrement le tracé afin d'obtenir cette fois-ci des flocons de Koch, et usons de plusieurs couleurs :

Code: Select all

from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

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)

c = [127, 255, 0]
turtle.speed(0)
turtle.colormode(255)
l = 80
for j in range(2):
  for i in range(3):
    n = j and 3 + i or 2 - i
    s = (7 - n) // 2
    turtle.penup()
    turtle.goto(i*117-157, j*95-25)
    turtle.pencolor(tuple(c))
    turtle.pensize(s)
    turtle.setheading(0)
    turtle.pendown()
    flock(n, l)
    n += 1
    rotate_list(c)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Cette fois impossible de ne pas le voir, énorme décalage avec ce_turtl dont le tracé part littéralement dans le décor pour le flocon en haut à droite.

Heureusement, plus aucun problème de ce genre avec le nouveau module turtle.

KhiCAS pour sa part ne termine pas le tracé à cause d'une erreur de mémoire.

Exemple n°4 : Sous le soleil exactement

Go to top

Plaçons-nous maintenant sous le soleil exactement, profitant ainsi de toutes ses couleurs :

Code: Select all

from ttl_fix import *

from math import exp

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(1.0)
for i in range(36):
  turtle.pencolor([exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)])
  for i in range(1, 5):
    turtle.forward(60)
    turtle.right(90)
  turtle.right(10)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple n°5 : Escargot de lumière

Go to top

Nous voyons maintenant passer un escargot de lumière, notre premier usage de la méthode turtle.circle() :

Code: Select all

from ttl_fix import *

from math import exp

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(1.0)
turtle.penup()
turtle.goto(0, -20)
turtle.pendown()
for i in range(36):
  turtle.pencolor([exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)])
  turtle.circle(50 - i)
  turtle.right(10)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

De nouveau une véritable catastrophe avec ce_turtl qui semble tracer n'importe quoi et pas ce qui est demandé.

C'est que la méthode turtle.circle() de ce_turtl nous trace ici des cercles ayant pour centre la position actuelle de la tortue. Alors que dans le standard, le cercle tracé passe par la position de la tortue.

Heureusement, le nouveau module turtle pour sa part se comporte enfin correctement et conformément au standard.

Exemple n°6 : Triangles de Sierpiński

Go to top

Revenons aux fractales et à la récursivité avec les triangles de Sierpiński :

Code: Select all

from ttl_fix import *

def sierp(n, l):
  if n == 0:
    for i in range (0, 3):
      turtle.forward(l)
      turtle.left(120)
  if n > 0:
    sierp(n - 1, l / 2)
    turtle.forward(l / 2)
    sierp(n - 1, l / 2)
    turtle.backward(l / 2)
    turtle.left(60)
    turtle.forward(l / 2)
    turtle.right(60)
    sierp(n - 1, l / 2)
    turtle.left(60)
    turtle.backward(l / 2)
    turtle.right(60)

turtle.speed(0)
turtle.pensize(1)
turtle.penup()
turtle.backward(109)
turtle.left(90)
turtle.backward(100)
turtle.right(90)
turtle.pendown()
turtle.pencolor("red")
sierp(6, 217)
turtle.penup()
turtle.forward(400)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

À nouveau un décalage avec ce_turtl qui nous trace bêtement une bonne partie de la figure hors fenêtre, un tracé de plus ici très grossier avec le problème déjà évoqué de l'épaisseur.

Heureusement, le nouveau module turtle trace quant à lui à la perfection.

De nouveau un problème de mémoire avec KhiCAS empêchant d'achever le tracé.

Exemple n°7 : Casio Graph 90+E

Go to top

Accordons-nous une petite pause le temps d'une page de publicité à la gloire Casio Graph 90+E :

Code: Select all

from ttl_fix import *

turtle.pencolor("black")
turtle.speed(0)
turtle.forward(40)
turtle.backward(100)
turtle.left(90)
turtle.forward(30)
turtle.right(60)
turtle.forward(60)
turtle.right(30)
turtle.forward(30)
turtle.penup()
turtle.forward(18)
turtle.right(90)
turtle.forward(60)
turtle.pendown()
turtle.right(30)
turtle.backward(30)
turtle.right(60)
turtle.forward(60)
turtle.pencolor("red")
turtle.penup()
turtle.goto(80,40)
turtle.right(140)
turtle.pendown()
turtle.circle(30)
turtle.penup()
turtle.goto(105,50)
turtle.pencolor("green")
turtle.pendown()
turtle.circle(-50)
turtle.penup()
turtle.pencolor("red")
turtle.right(21)
turtle.goto(60,20)
turtle.pendown()
turtle.circle(40,60)
turtle.penup()
turtle.pencolor("blue")
turtle.goto(-50,15)
turtle.setheading(0)
turtle.pendown()
turtle.write("CASIO")

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Là avec ce_turtl c'est un festival, la page de publicité se fait littéralement censurer. 3 problèmes essentiels :

• Absence de la méthode turtle.write() permettant d'écrire du texte à la position de la tortue, et donc absence du mot CASIO sur le rendu.
• La méthode standard turtle.circle(r, a=360) permet de préciser l'angle au centre en 2^ème argument et ainsi de tracer des arcs de cercle, l'omission de ce paramètre donnant par défaut un angle au centre de 360° et donc un cercle. C'est utilisé ici pour tracer le pied du 9 en rouge. Sauf que l'implémentation dans ce_turtl ne respecte pas le standard et ne gère pas ce 2^ème argument. Notre script correctif intercepte le cas et empêche l'interruption du rendu sur une erreur, mais trace alors un cercle complet à la place.
• La méthode standard turtle.circle(r, a=360) accepte de plus une valeur de rayon négative, inversant dans ce cas le sens de tracé. C'est utilisé ici pour tracé le 0 en vert. Sauf que ce_turtl ne comprend pas ce cas et ne trace alors rien du tout.

Le nouveau module turtle corrige les 2 premiers points.

La TI-Nspire CX II fait un peu moins bien, ne gérant pas le tracé d'arcs de cercle.

Notons une divergence du standard chez une bonne partie des modèles concernant la méthode turtle.write(). La norme est d'écrire le texte dans un rectangle horizontal prenant la position courante de la tortue comme sommet inférieur gauche. Or beaucoup d'implémentations utilisent le sommet supérieur gauche : le nouveau turtle pour TI-83 Premium CE Edition Python et compatibles, ainsi que les Casio Graph 35+E II et Graph 90+E.

Exemple n°8 : Sapin de Noël

Go to top

Passons maintenant au sapin de Noël d'Isabelle Vanacker:

Code: Select all

from ttl_fix import *
from math import sqrt

def triangle(t):
  for i in range(4):
    turtle.forward(t/(i%4 == 0 and 2 or sqrt(2)))
    turtle.left(i==1 and 90 or not(i%2) and 135)

def etoiles():
  turtle.pencolor("yellow")
  turtle.pensize(2)
  for i in range(8):
    etoile(-60-30*(i%4)+(i>=4 and 220), (-80,10,-40,60)[i%4])
   
def etoile(x,y):
  turtle.up()
  turtle.goto(x,y)
  turtle.down()
  for i in range(12):
    turtle.forward(10)
    turtle.left(i%2 and -60 or 120)

turtle.up()
turtle.goto(0,60)
turtle.down()
turtle.pencolor("green")
turtle.pensize(5)
for i in range(4):
  triangle(50+20*i)
  turtle.up()
  turtle.goto(0,30-40*i)
  turtle.down()
turtle.pencolor("brown")
turtle.backward(10)
for i in range(4):
  turtle.forward(i%2 and 40 or 20)
  turtle.left(90)

etoiles()

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Cette fois-ci sur KhiCAS cela ne va plus du tout, le sapin pousse complètement de travers...

Bizarrement ici aussi, La TI-Nspire CX II se met soudainement à ne plus respecter les instructions relatives à l'épaisseur du tracé, alors qu'elles marchaient plus haut...

Exemple n°9 : Supernova PhiX 177

Go to top

Partons justement chercher l'inspiration dans les étoiles, avec la supernova PhiX 177, et notre premier usage des méthodes de remplissage :

Code: Select all

from ttl_fix import *

def poly_reg_a(l, a):
  h0 = turtle.heading()
  while True:
    turtle.forward(l)
    turtle.left(a)
    if abs(h0 - turtle.heading()) < .1:
      break

turtle.colormode(255)
turtle.pensize(2)
turtle.penup()
turtle.goto(-90,16)
turtle.pendown()
turtle.pencolor((246,89,164))
try:
  turtle.fillcolor((180,20,90))
  turtle.begin_fill()
except: pass
poly_reg_a(180, 160)
try:
  turtle.end_fill()
except: pass

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Comme l'ensemble de la concurrence, le module ce_turtl ne gérait pas les méthodes de remplissage.

Et bien là nous sommes en plein sur ce qui fait à ce jour la supériorité et l'exclusivité de la solution turtle par Texas Instruments. Comme la TI-Nspire CX II le nouveau module turtle pour TI-83 Premium CE Edition Python et compatibles gère les méthodes de remplissage, un véritable régal pour les yeux et autant de stimulation supplémentaire pour inciter les élèves à approfondir leurs constructions !

Les méthodes de remplissage si manquantes étant directement interceptées dans le code du script, ici c'est pour une autre raison que le tracé échoue sur KhiCAS : l'absence de la possibilité d'interroger l'orientation de la tortue via turtle.heading().

Exemple n°10 : Champ de zinnias en été

Go to top

Redescendons sur Terre, nous atterrissons au milieu d'un champ de zinnias en été :

Code: Select all

from ttl_fix import *
from random import randint, seed

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def poly_reg_a(l, a):
  h0 = turtle.heading()
  while True:
    turtle.forward(l)
    turtle.left(a)
    if abs(h0 - turtle.heading()) < .1:
      break

seed(33)
turtle.colormode(255)
turtle.pensize(1)
turtle.hideturtle()
turtle.speed(0)
c=[255,127,0]
cf=[127,255,0]
for k in range(18):
  turtle.penup()
  turtle.goto(randint(-200,120), randint(-100,100))
  turtle.pendown()
  turtle.pencolor(tuple(c))
  try:
    turtle.fillcolor(tuple(cf))
    turtle.begin_fill()
  except: pass
  poly_reg_a(80, 162)
  try:
    turtle.end_fill()
  except: pass
  rotate_list(c)
  rotate_list(cf)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple n°11 : Courtepointe de grand-mère

Go to top

Envie de pique-niquer ou t'allonger un moment ? Quelle chance d'avoir emporté avec soi la courtepointe de grand-mère :

Code: Select all

from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def poly_reg_a(l, a):
  h0 = turtle.heading()
  while True:
    turtle.forward(l)
    turtle.left(a)
    if abs(h0 - turtle.heading()) < .1:
      break

turtle.hideturtle()
turtle.speed(0)
turtle.pensize(1)
turtle.colormode(255)
c = [255, 127, 0]
for j in range(4):
  for i in range(4):
    turtle.penup()
    turtle.goto(i*88-172, j*85-142)
    turtle.pendown()
    turtle.pencolor(tuple(c))
    poly_reg_a(80, 140)
    rotate_list(c)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple n°12 : Vitrail de Notre-Dame

Go to top

Et nous voici enfin devant le vitrail de Notre-Dame :

Code: Select all

from ttl_fix import *
from math import sqrt

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def reg_poly(l, n):
  for i in range(n):
    turtle.forward(l)
    turtle.left(360/n)

def square(l):
  reg_poly(l, 4)

turtle.pencolor(0,0,0)
turtle.colormode(255)
turtle.speed(0)
turtle.pensize(3)
turtle.hideturtle()
d=200
c=[0,255,127]
turtle.penup()
turtle.goto(-d/2,-d/2)
turtle.setheading(0)
turtle.pendown()
for i in range(8):
  try:
    turtle.fillcolor(tuple(c))
    turtle.begin_fill()
  except: pass
  square(d)
  try:
    turtle.end_fill()
  except: pass
  turtle.penup()
  turtle.forward(d/2)
  turtle.left(45)
  turtle.pendown()
  d/=sqrt(2)
  rotate_list(c)

try: turtle.show() #TI-83 Premium CE
except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Que le module ce_turtl ne colorie pas, c'est normal. Par contre il délire complètement sur le tracé, et là c'est un tout autre problème...

Heureusement, plus aucun problème avec le nouveau module turtle.

Conclusion

Go to top

Après l'accident ce_turtl qui était inutilisable en pratique, Texas Instruments nous opère un virage à 180° avec le nouveau module turtle pour TI-83 Premium CE Edition Python et compatibles.

La conformité au standard de turtle n'est certes pas parmi les meilleures, mais c'est sans comparaison avec ce que valait ce_turtl. La conformité est très proche de celle des TI-Nspire CX II, et de plus une bonne partie des défauts restants ne sont pas majeurs dans le sens où ils sont aisément contournables sans avoir à écrire de code conséquent.

Qui plus est Texas Instruments s'offre même le luxe d'aller jusqu'à inclure les méthodes de remplissage de formes, à ce jour une exclusivité toute concurrence confondue !
Des possibilités et facilités de tracés largement accrues en conséquence, de quoi inviter encore plus les élèves à tester et créer !

Nous nous devons toutefois de modérer légèrement ce dernier point.

Aucun problème sur TI-Nspire CX II, mais par contre sur TI-83 Premium CE Edition Python et compatibles la taille du heap fait qu'il ne faut pas abuser des méthodes de remplissage.

En effet à partir d'un appel .begin_fill(), l'ensemble des étapes intermédiaires de la tortue est stocké en mémoire afin de pouvoir en effectuer le remplissage suite au prochain appel .end_fill().

Des formes à remplir trop complexes ou trop nombreuses déclencheront une erreur de mémoire insuffisante, et les exemples précédents de remplissages les plus complexes n'en étaient pas bien loin.

C'est franchement dommage et rageant de devoir ainsi se brider dans l'exploitation de cette formidable possibilité...

Téléchargements

Go to top

• Modules complémentaires de tracé relatif à la tortue : ce_turtl (l'ancien) turtle (le nouveau)
• pack de mises à jour 5.7 pour TI-83 Premium CE TI-84 Plus CE, ou séparément :
  
  • Système 5.7 pour TI-83 Premium CE TI-84 Plus CE
  • Application Python 5.7 (nécessite le système 5.7 pour fonctionner)
  • Modules complémentaires de tracé par pixels ou dans un repère ti_draw ti_image

Source : https://education.ti.com/en/product-res ... 4ce-python

[critor]

Texas Instruments vient de sortir une mise à jour 5.7 pour l'ensemble de ses modèles TI-83 Premium CE et TI-84 Plus CE. Elle remplace donc enfin la version 5.6.1 sortie le 25 février 2021 il y a près de 9 mois.

Plus précisément le système d'exploitation de cette mise à jour est en version 5.7.0.0017 et a été compilé le 19 octobre 2021. On retrouve bien l'habituel délai de 4 semaines que Texas Instruments se donne usuellement pour valider une mise à jour avant de la publier.

Plusieurs applications sont également mises à jour dans ce contexte.

Nous allons bien évidemment couvrir toutes les formidables nouveautés, mais avant cela nous avons, hélas, une mise en garde à effectuer par rapport à une restriction.

Attention, l'installation de la version 5.7 du système modifie le certificat en mémoire Flash, augmentant son champ 0x37 à 5.7.0, et rappelons qu'aucun menu ne permet de réinitialiser ce certificat. C'est-à-dire qu'une fois la mise à jour effectuée, ta calculatrice refusera définitivement toute tentative de réinstaller une version inférieure à 5.7.0.
(seule et unique exception, les toutes premières TI-83 Premium CE et TI-84 Plus CE de 2015 dont le Boot en version 5.0.0 ne supporte pas l'écriture ou la lecture de ce champ)

Si jamais ta calculatrice fait encore tourner une version 5.5.0 ou inférieure, rappelons que l'installation de toute version 5.5.1 ou supérieure et y compris donc cette 5.7.0 supprimera la capacité de ta calculatrice à exécuter des programmes en langage machine dits ASM (compilés à partir de code source en langage C ou C++, ou bien assemblés à partir de code source en langage assembleur eZ80).

En pratique il reste possible de profiter des programmes ASM sur ta calculatrice via une faille de l'application CabriJr dans sa version 5.0.0.0089. L'outil arTIfiCE exploitant cette faille te permet alors d'installer un autre outil qui te permettra d'exécuter des programmes ASM, comme Cesium ou AsmHook, et nous avons même un tuto pour t'assister.

Précisons que l'application CabriJr n'est pas mise à jour dans le cadre de la sortie de cette version 5.7.

arTIfiCE et AsmHook continueront à fonctionner correctement, TI continue donc de respecter sa promesse !

Par contre attention si tu préférais Cesium, pense bien à utiliser la dernière version (v3.6.0 à ce jour) qui vient de sortir et qui en plus de corriger des bugs, permet aussi d'être compatible avec l'OS 5.7

Avant d'aborder les nouveautés de la version 5.7, poursuivons avec une mise en garde et mauvaise nouvelle.

Le certificat en mémoire Flash comporte un champ 0x42 comportant le nom de la calculatrice, soit d'usine TI-83 Premium CE ou TI-84 Plus CE.

Depuis des années notre programme CERMASTR te permettait d'éditer le certificat, et donc notamment de renommer ta calculatrice comme bon te semblait. Une bonne protection contre le vol qui, rappelons-le, est officiellement présente sur les calculatrices Casio Graph. Ici le nom modifié était alors affiché sur différents écrans d'informations de la calculatrice !

Changement unilatéral effectué par Texas Instruments pour cette mise à jour 5.7 comme découvert et signalé par Shadow, le nom présent dans le certificat n'est plus utilisé pour ces affichages !

Est désormais affiché le seul nom TI-83 Premium CE ou TI-84 Plus CE inscrit dans le système d'exploitation, et donc couvert par sa signature électronique. Ce qui veut dire qu'il devient impossible de renommer sa calculatrice.

Avec le mal que l'on se donne dans le contexte de l'outil CERMASTR pour ne pas marcher sur les pieds de Texas Instruments, notamment dans le contexte des champs concernant le mode examen ainsi que la version minimale autorisée, nous aurions apprécié d'être au minimum prévenus avant le blocage de ce qui restait désormais la seule fonctionnalité utile de cet outil. Cela remet en question nombre de choix de limitations de cet outil décidées exprès dans l'intérêt de Texas Instruments...

Bref, restriction décidée unilatéralement, sans même prévenir, sans aucun élément déclencheur connu depuis la précédente mise à jour, et qui semble ainsi à ce jour totalement incompréhensible. De quoi recommencer à générer du ressentiment...

Donc pourquoi un tel changement ?

On peut imaginer des utilisateurs hors de France ayant transformé leur TI-84 Plus CE en TI-83 Premium CE, afin de pouvoir profiter du moteur de calcul exact QPiRac possiblement interdit à leurs examens.

Une méthode est de démonter sa TI-84 Plus CE et de remplacer sa carte électronique par celle d'une TI-83 Premium CE, la modification via CERMASTR du nom TI-83 Premium CE en TI-84 Plus CE venant terminer le maquillage.
Toutefois cela nécessite donc d'acheter 2 calculatrices, et nous pensons que ce surcoût doit rendre la chose au pire anecdotique...

Une autre possibilité est le programme BootSwap qui permet d'altérer le Boot pour en faire sauter les vérifications effectuées lors de l'installation d'une mise à jour, et ainsi installer directement une mise à jour TI-83 Premium CE sur TI-84 Plus CE. Ici jusqu'à présent pas besoin de renommer pour masquer la chose, puisque le certificat contenait déjà le nom TI-84 Plus CE qui continuait alors à être utilisé. Donc effectivement ici, ignorer le nom modifiable du certificat pour afficher le nom inaltérable venant avec le système d'exploitation, c'est-à-dire dans ce cas TI-83 Premium CE, retire toute discrétion à cette transformation si effectuée avec une version 5.7 ou supérieure (laissons de côté les utilisateurs qui se seront piégés en version 5.7 par eux-mêmes - même si ce n'est pas le cas en France, rappelons pour d'autres examens l'installation de la dernière mise à jour est obligatoire).
L'outil BootSwap avait été publié par commandblockguy à la rentrée 2020 dans un contexte de relations extrêmement tendues avec Texas Instruments, justement suite au blocage des programmes ASM. N'ayant droit qu'à au mieux 1 à 2 mises à jour de la calculatrice par an, le délai serait cohérent pour qualifier ce changement de riposte de la part de Texas Instruments.
Toutefois, BootSwap n'est compatible qu'avec les calculatrices en révision matérielle L ou inférieure (Boot en version 5.3.1 ou inférieure, assemblées jusqu'en Mai 2019, ce qui exclut toutes les TI-83 Premium CE Edition Python). Cela fait donc déjà 2 ans et demi que les machines impactées par cette faille ont cessé d'être fabriquées et donc distribuées, soit presque un cursus intégral au lycée. Rappelons de plus que nous n'avons exprès produit aucun tutoriel pour aider à cette transformation. Quel intérêt donc à réagir maintenant alors que ces machines sont déjà en voie de disparition ?...

Sommaire

1. Menu de diagnostics
2. Nouveautés applications de langue
3. Autres nouveautés système
4. Application CellSheet (tableur)
5. Application Hub
6. Application Python
7. Modules Python additionnels ti_draw et ti_image
8. Autres applications (Inequalz, Transfrm, Plysmlt2, ProbSim)
9. Conclusion
10. Téléchargements

1) Menu de diagnostics

Go to top

Le système d'exploitation des TI-83 Premium CE et TI-84 Plus CE intègre un menu d'autodiagnostic ("self-test") accessible via la combinaison secrète

mode

alpha

ln

.

Avec cette version 5.7 les différents tests qu'il permet bénéficient d'une belle refonte visuelle et fonctionnelle.

Déjà, les titres des différents tests qu'il permet de déclencher bénéficient d'une uniformisation graphique sous la forme d'une barre de titre en blanc sur fond vert.

Le test de la diode examen était problématique, dans le sens où aucun retour à l'écran ne t'indiquait qu'il était terminé et que tu pouvais taper une touche pour retourner au menu principal.

Tu pouvais donc croire que ta calculatrice était coincée, ou sinon devais bouger la calculatrice pour voir si la diode avait bien achevé le motif de test.

Pour cette version 5.7 Texas Instruments t'offre enfin une correction de ce problème, un message venant s'afficher en fin de test !

Le test clavier était lui aussi problématique. Il consiste à taper une par une les touches du clavier dont les codes TI-Basic te sont indiqués à l'écran, de gauche à droite et de haut en bas. Ce test ne concerne que 49 des 50 touches du clavier, la touche

on

(code TI-Basic 101 pour 10^ème ligne en partant du haut et 1^ère colonne en partant de la gauche) étant exclue.

Devoir taper 49 touches clavier sans se tromper, même avec l'habitude ça prend un certain temps et tu pouvais donc avoir envie d'interrompre le test.

Problème, jusqu'à présent c'était totalement impossible, la seule solution étant de redémarrer la calculatrice avec le bouton reset au dos (ou en déconnectant la batterie si tu préfères), à condition donc de disposer sous la main de l'outil adéquat pour cela.

Avec cette mise à jour 5.7, Texas Instruments nous solutionne enfin ce problème.

La touche

on

qui jusqu'à présent ne servait à rien dans ce test, te permet maintenant de l'interrompre à tout moment.

Enfin on peut signaler un changement des messages affichés pour le test de mémoire RAM.

2) Nouveautés applications de langue

Go to top

6 applications de langues sont disponibles pour ta calculatrice : Deutsch (Allemand), Español (Espagnol), Français, Nederlan (Néerlandais), Portug (Portugais) et Svenska (Suédois). Le système d'exploitation incluant de base les messages en Anglais, ce sont ces applications qui permettent le remplacement à l'affichage de ces différents messages par une traduction dans ta langue, le choix de langue étant disponible à l'écran

mode

.

Or, il se trouve que ces applications ont elles aussi mises à jour, passant en version 5.7.0.0.0017 avec un message de copyright actualisé pour 2021.

Cela signifie donc qu'il y a eu des changements. Et cela tombe bien pour nous, car les fichiers de ces applications contiennent essentiellement du texte. C'est donc pour nous une façon simple de découvrir rapidement une partie des modifications apportées au système d'exploitation.

Ta calculatrice te permet de demander différents calculs sur un intervalle directement à partir de la représentation graphique de fonctions, notamment intersection avec l'axe des abscisses (racine), minimum et maximum. L'interface t'invite alors à valider le choix de la borne de gauche, puis de la borne de droite, puis à indiquer une valeur initiale autour de laquelle initier la recherche.

Problème, l'interface ne t'empêche absolument pas de préciser une borne de droite inférieure à la borne de gauche, déclenchant alors une erreur BORNE.

La pire étant que le message d'explication accompagnant l'erreur en question était totalement incompréhensible, disant à la fois une chose et son contraire, et ce peu importe la langue.

Avec la nouvelle version 5.7 Texas Instruments vient enfin de te corriger l'explication.

Tous les messages système ne font toutefois pas l'objet d'une traduction. Par exemple jusqu'à présent, le menu de choix du langage de programmation affiché par la touche

prgm

, t'affichait systématiquement un titre de Programming, et ce peu importe le réglage de langue, ci-contre en Français.

Changement avec cette version 5.7, le titre de ce menu passe en caractères majuscules et bénéficie enfin d'une traduction en fonction de la langue réglée.

Ta calculatrice dispose de 2 types de mémoires :

• la mémoire de travail (RAM) permettant d'enregistrer tes variables et d'exécuter tes programmes
• la mémoire de stockage en Flash, dite mémoire d'archive, permettant aussi bien d'accueillir des variables que des applications

Le menu mémoire comporte justement différents choix de réinitialisation : RAM ou Archive, et dans ce dernier cas Variables ou Applications.

Là pour le coup ce n'est pas une amélioration, nous déplorons une erreur de la part de Texas Instruments, désormais le message explicatif accompagnant la demande d'effacement des variables archivées en mémoire Flash est erroné en version 5.7, mentionnant la mémoire RAM.

Une erreur d'autant plus difficilement compréhensible qu'elle n'est présente qu'avec un réglage de langue en Français.

3) Autres nouveautés système

Go to top

Passons maintenant au reste des changements apportés au système d'exploitation, c'est-à-dire en dehors des applications accessibles via

2nde

résol

sur TI-83 Premium CE ou

apps

sur TI-84 Plus CE.

Il n'était pas affichable officiellement sur calculatrice à notre connaissance, mais depuis la version 5.3.6 compilée le 7 mars 2019, le système d'exploitation comportait un message secret d'hommage en mémoire de James D. Hammerquist, ingénieur de Texas Instruments EdTech qui nous a quittés si jeune le 3 mars 2019, à l'âge de seulement 60 ans :

OS 5.3.6 dedicated to James D. Hammerquist, Aug 14, 1958 - Mar 3, 2019; Rest well my friend.

Dans la version 5.7, certes bien loin de 5.3.6, cette chaîne de caractères n'est plus présente.

Tout comme le symbole égal, le symbole moins en mathématiques a différentes significations selon le contexte. On distingue par exemple :

• l'opérateur unaire de signe (s'appliquant à 1 opérande), préfixé dans la notation usuelle, par exemple -4
• l'opérateur binaire (s'appliquant à 2 opérandes), infixé dans la notation usuelle, par exemple 7-3

Cela peut paraître anecdotique, mais quand on code un logiciel de mathématiques et plus précisément un logiciel de calcul, il est essentiel d'en tenir compte.

Dès 1990 avec sa toute première calculatrice graphique TI-81, Texas Instruments a fait le choix historique d'offrir ces 2 opérateurs au clavier avec ses touches

-

et

(-)

.

Problème, les utilisateurs ne saisissent pas toujours cette nuance et confondent alors les touches.

Or si la saisie

6

-

7

donnera -1, la saisie

6

(-)

7

donnera pour sa part 42, le signe moins étant ici l'opérateur unaire préfixé ne s'appliquant qu'au terme de droite, donnant alors dans le moteur de calcul les 2 nombres 6 et -7 juxtaposés sans opérateur, et ainsi une multiplication implicite.

Rien à voir donc, les conséquences pouvaient facilement devenir dramatiques, notamment dans le contexte d'examens...

Avec cette version 5.7, Texas Instruments s'attaque à cette difficulté.

Rien ne change pour les résultats, mais par contre, les multiplications implicites induites par l'utilisation de la touche

(-)

seront désormais indiquées clairement dans l'historique une fois le calcul saisi validé.

En plus donc déjà des différences visuelles entre les signes au clavier et à l'affichage, Texas Instruments donne ainsi de façon bienveillante aux utilisateurs une chance supplémentaire de comprendre qu'ils ont fait une erreur de saisie. Merci TI !

4) Application CellSheet (tableur)

Go to top

Ta calculatrice bénéficie d'une application de feuille de calcul nommée CellSheet. La dernière version était la 5.1.0.0110 compilée le 1^er septembre 2015. L'application n'avait plus jamais été mise à jour depuis.

Toutefois nous nous doutions que quelque chose était en préparation. La TI-82 Advanced Edition Python sortie pour cette rentrée 2021 a repris une partie des applications des TI-83 Premium CE et TI-84 Plus CE.
Le système d'exploitation étant différent bien évidemment l'application de langue Français différait également, ainsi que l'application Python82 puisqu'offrant un nombre restreint de modules intégrés. Toutefois le reste des applications reprises (PlySmlt2, ProbSim, Inequalz, Transfrm) reprenaient bien le dernier numéro de version de leurs équivalents pour TI-83 Premium CE et TI-84 Plus CE, à une seule exception près, CellSheet qui passait en version 5.1.1.0017.

Sans surprise donc, aujourd'hui dans le cadre de la mise à jour 5.7, l'application CellSheet pour TI-83 Premium CE et TI-84 Plus CE passe à son tour sur la nouvelle version 5.1.1.0017.

Il y a clairement eu des modifications de code par rapport à la version précédente et même par rapport à la version sur TI-82 Advanced Edition Python, mais désolé nous n'avons pas réussi à identifier de différence visuelle ou fonctionnelle. Nous ignorons donc la finalité des changements apportés par Texas Instruments.

5) Application Hub

Go to top

En avril 2021, Texas Instruments avait sorti une mise à jour en version 1.5 pour TI-Innovator Hub, l'interface pour piloter des projets STEM depuis ta calculatrice TI-83 Premium CE, TI-84 Plus CE ou TI-Nspire CX

Une mise à jour majeure apportant énormément de nouveautés que nous t'avions détaillées :

• activation d'un nouveau capteur intégré, TIMER
• paramètre TEMPO pour émettre du son de façon discontinue (bips)
• paramètre TIME pour récupérer le temps de vol d'un sonar
• possibilité de commander plusieurs capteurs/actionneurs simultanément, supprimant ainsi tout décalage
• commande COLLECT pour récupérer sans boucle une série de mesures
• contrôle simultané de plusieurs diodes du TI-RGB Array, ou de tout ruban de diodes RGB adressables compatible
• ...

L'application Hub pour sa part rajoute à l'éditeur de programmes en langage TI-Basic de ta calculatrice, un menu pour insérer facilement les commandes concernant le TI-Innovator Hub.

Sauf que la dernière version de l'application Hub était jusqu'à aujourd'hui la 5.4.0.0034 compilée le 31 mai 2019, et ne comportait bien évidemment aucun menu permettant de saisir ces nouvelles commandes et options.

En langage TI-Basic ce n'était toutefois pas bloquant. C'était en effet contournable : dans ce langage en effet, les menus de programmation servent juste à saisir rapidement des lignes de commandes qui vont être envoyées texto pour exécution au TI-Innovator Hub. En cas de nouveau mot de vocabulaire non présent au menu (ici donc entre autres TEMPO, PATTERN, RATE, AND, COLLECT, ...), il suffisait juste de le saisir à la main au clavier alphabétique.

C'était il n'empêche un peu pénible.

Après plus de 7 mois, nous avons donc enfin aujourd'hui une mise à jour de l'application Hub, en version 5.7.0.0017.

Nous y trouvons bien de nouvelles entrées permettant désormais de saisir rapidement les nouvelles commandes et paramètres :

6) Application Python

Go to top

Si tu disposes d'une TI-83 Premium CE Edition Python, TI-84 Plus CE-T Python Edition ou TI-84 Plus CE Python, ta calculatrice bénéficie d'une application Python. La dernière version commençait à dater, la 5.5.2.0044 compilée le 30 juillet 2020.

Avec cette mise à jour 5.7 nous bénéficions d'une nouvelle application Python en version 5.7.0.0017, découvrons-en les nouveautés.

Rappelons que sur ces calculatrices le processeur est un eZ80 (8 bits), et que l'exécution de code Python est alors confiée à un coprocesseur Cortex-M0+ ARMv6 (32 bits). L'application Python inclut un firmware TI-Python (un dérivé de CircuitPython) tout spécialement dédié à ce coprocesseur, dont on peut consulter la version en appelant sys.implementation. La dernière version étant donc la 3.1.0.58.

Nous nous attentions ici encore à une nouvelle version firmware, la TI-82 Advanced Edition Python sortie entre temps pour la rentrée 2021 passant pour sa part à un firmware TI-Python en version 3.2, plus précisément 3.2.0.71.

Et effectivement avec cette mise à jour 5.7, la nouvelle application Python intègre elle aussi un nouveau firmware TI-Python 3.2, plus précisément en version 3.2.0.76.

Bonne nouvelle, c'est-à-dire que l'on peut s'attendre aussi bien à des nouveautés au niveau de l'interface que des capacités Python, voyons tout ça.

Pour le contexte, rappelons que l'application Python intègre une bel éventail de de modules enrichissant les capacités de tes scripts. Pour certains, tout ou partie de leurs fonctions sont directement disponibles dans les menus :

• builtins (catalogue)
• math
• random
• time
• ti_system
• ti_plotlib
• ti_hub
• ti_rover

D'autres modules ne bénéficient pas de cette aide à la saisie via les menus mais restent quand même intégrés et utilisables.
On peut les consulter avec help("modules") :

• array
• collections
• gc
• sys
• ti_graphics

Le module ti_system par exemple t'offre nombre de possibilités au menu :

• l'intégration avec l'importation/exportation de listes ou expression avec les autres applications de la calculatrice
• mettre en pause un script en testant/attendant un appui sur la touche

  annul

  sur TI-83 Premium CE ou

  clear

  sur TI-84 Plus CE
• afficher un texte sur la ligne de ton choix
• figer l'affichage
• effacer l'écran

Mais ti_system permettait aussi d'autres choses n'étant pas au menu.

Par exemple la méthode ti_system.wait_key() te permettait d'attendre une action clavier, et te renvoyait alors un code tenant compte à la fois de la touche pressée et du contexte (modificateurs

2nde

ou

alpha

, verrouillage alphabétique, mode majuscule ou minuscule).

Une formidable possibilité pour coder des interfaces, menus ou même jeux !

Sauf que cette méthode n'était pas au menu. Donc d'une part la plupart des utilisateurs ignoraient son existence, et d'autres part pour ceux qui étaient au courant l'utilisation en était pénible, nécessitant de saisir le nom de méthode lettre par lettre au clavier alphabétique.

Et bien excellente nouvelle, Texas Instruments met maintenant clairement en avant cette la méthode wait_key() au menu dont la saisie ne nécessitera donc plus qu'une seule touche, et par conséquent également toutes les formidables possibilités qu'elle ouvre !

Le module ti_hub permet lui le contrôle évoqué plus haut du TI-Innovator Hub avec ses capteurs/actionneurs intégrés ou connectables, quand le module ti_rover se spécialise lui autour du TI-Innovator Rover.

Il y avait donc ici le même genre de problème avec le TI-Innovator Hub, les dernières nouveautés du firmware 1.5 n'étaient pas accessibles aux menus de l'éditeur Python.

Un problème bien plus embêtant ici car beaucoup moins facilement contournable. Ici les menus ne permettent que d'appeler des fonctions des modules associés ti_hub et ti_rover, masquant complètement les lignes de commandes échangées entre la calculatrice et le TI-Innovator Hub pour leur donner un habillage fonctionnel, conformément aux programmes scolaires.

Par exemple l'appel pour allumer la diode RGB en violet, l'appel color.rgb(255, 0, 255) correspondait en fait en interne à l'envoi de la commande SET COLOR 255 0 255.
Et justement il est à noter qu'une méthode alternative utilisant ce langage de script interne est possible en Python : ti_hub.send("set color 255 0 0").

Comment faire alors pour émettre des bips de 400 Hz pendant 5 secondes au rythme de 4 bips par seconde ? La chose n'étant pas disponible au menu, une solution était de connaître le langage de script interne spécifique au TI-Innovator Hub, et de faire ti_hub.send("set sound 500 time 5 tempo 4").

Pas évident à deviner toutefois alors que ce fonctionnement interne est ici totalement masqué, pénible à saisir à la main au clavier alphabétique également, et c'était peut-être beaucoup demander à certains élèves d'utiliser le langage Python pour écrire dans un autre langage.

Fini les acrobaties de ce genre, avec la mise à jour 5.7 les nouvelles commandes et options TI-Innovator Hub 1.5 ont été transcrites sous forme fonctionnelle au menu !

Dans l'exemple que nous venons de prendre, un simple sound.tone(400, 5, 4) suffira.

Bien évidemment des équivalents fonctionnels ont été rajoutés aux menus pour toutes les autres nouveautés : objet collect pour les collections de données, méthode ti_rover.ranger_rime() pour le temps de vol du sonar, etc.

Tant que nous y sommes, attardons-nous maintenant sur le module ti_rover dédié pilotage du TI-Innovator Rover à travers un TI-Innovator Hub.

Pour commander un déplacement tu avais entre autres les méthodes ti_rover.forward(d) et ti_rover.backward(d) pour le faire avancer ou reculer d'une certaine distance d, par défaut en unités arbitraires.

Ces méthodes acceptaient également des paramètres optionnels et le menu te permettait de faire appel à des interfaces en assistant la saisie :

• unité de distance (arbitraires, mètres ou révolutions)
• v, vitesse
• unité de vitesse (arbitraires, mètres ou révolutions par seconde)

Mais peut-être avais-tu envie de préciser l'unité de distance sans rajouter de précision de vitesse ? Surtout que le paramètre de vitesse doit être obligatoirement entre 0,14 m/s et 0,23 m/s, toute valeur extérieure déclenchant une erreur, ce qui ne se devine pas.

Et là c'était embêtant :

• soit tu utilisais l'interface précédente, t'obligeant à choisir une unité de vitesse, pour ensuite effacer les 2 derniers paramètres
• soit tu saisissais simplement forward(d) ou backward(d) via le menu, pour ensuite rajouter manuellement au clavier le paramètre d'unité

Et bien bonne nouvelle, Texas Instruments a rajouté au menu les interfaces de saisie correspondant à ce cas.

7) Modules Python additionnels ti_draw et ti_image

Go to top

Les TI-83 Premium CE Edition Python, TI-84 Plus CE-T Python Edition et TI-84 Plus CE Python offrent à tes scripts Python de formidables possibilités graphiques grâce au module de tracé par pixels ti_graphics.

Au menu une superbe collection de primitives et même la gestion d'un format d'image dédié IM8C pour lequel nous t'avons conçu un convertisseur dédié en ligne !

Problème, le module ti_graphics n'était pas disponible au menu.

Pas évidement donc pour tout-le-monde de le trouver, d'en découvrir les différentes méthodes, et ensuite de deviner les paramètres attendus

Jusqu'à présent Texas Instruments n'avait mis en avant qu'assez timidement et partiellement ces grandes possibilités graphiques de la calculatrice à travers des modules additionnels :

• ce_turtl, pour du tracé relatif à la tortue
• ce_box, ce_chart et ce_quivr pour du tracé de diagrammes et vecteurs dans un repère

À la différence des modules intégrés, les modules additionnels ne sont pas disponibles en mode examen.

Enorme problème toutefois avec cette approche jusqu'à présent, les modules complémentaires n'étaient par défaut pas disponibles au menu.

Ils apparaissaient au menu uniquement lorsque l'on était en train d'éditer un script comportant une ligne les important (et obligatoire sous la forme from module import, pas un simple import module).

Tu commences donc à voir le problème ? Lors de la création d'un script, afin d'obtenir le menu te permettant de saisir facilement et rapidement les appels aux différentes méthodes d'un module complémentaire, tu devrais commencer par te taper la saisie fastidieuse lettre par lettre au clavier de sa ligne d'importation.

Enfin dernier problème, pas de module ti_graphics sur les TI-Nspire CX II, mais des modules hybrides ti_draw et ti_image pouvant fonctionner à la fois par pixels ou par coordonnées dans un repère.

C'est-à-dire que jusqu'à présent il n'y avait aucune compatibilité :

• les commandes graphiques de scripts Python TI-Nspire CX II ne marchaient pas sur les TI-83 Premium CE ou TI-84 Plus CE
• et inversement les commandes graphiques de scripts Python TI-83 Premium CE ou TI-84 Plus CE ne marchaient pas sur les TI-Nspire CX II

Avec cette mise à jour 5.7, Texas Instruments se propose de résoudre simultanément tous ces 3 gros problèmes.

D'une part, l'onglet listant les modules utilisables comporte maintenant un menu de bas d'écran permettant de saisir d'une seule touche la ligne d'importation des modules complémentaires installés, et ajouter ainsi leur contenu au menu.

À noter que cela ne fonctionne pas avec les modules complémentaires partagés jusqu'à présent par Texas Instruments, sans doute ont-ils besoin d'une mise à jour, si tant est que ce soit prévu.

Par contre, la mise à jour 5.7 intègre 2 nouveaux modules complémentaires ti_draw et ti_image que tu pourras donc ainsi rajouter au menu.

ti_draw et ti_image sont techniquement des modules interface : ils te présentent des méthodes qui en interne vont effectuer les appels adaptés au module ti_graphics, t'évitant ainsi diverses considérations techniques spécifiques à ton modèle de calculatrice.

Les modules complémentaires sont écrits en Python et convertis en fichier pour calculatrice par Texas Instruments en utilisant un outil nommé py2appvar, compilant le Python en bytecode et générant les menus associés aux différentes méthodes à l'aide des commentaires présents dans le code source. Nous notons ici en entête des fichiers l'utilisation d'une nouvelle version de py2appvar, non plus la 1.2.0 comme pour les derniers modules complémentaires précédents, mais maintenant la 1.2.1. Peut-être la version gérant les nouveaux commentaires rendant les modules complémentaires listables pour importation ou pas.

ti_draw est ici en version 1.0.0.

Finalement il ne s'agit pas d'une simple interface pour le module de tracé par pixels ti_graphics, ti_draw fait un peu plus que ça.

ti_draw est en fait un module de tracé hybride :

• par défaut il se comporte en tant que module de tracé par pixels comme ti_graphics
• mais si tu fais appelle à sa méthode ti_draw.set_window(xmin, xmax, ymin, ymax), il se transforme alors en mode de tracé par coordonnées dans un repère

ti_draw porte donc le même nom que sur TI-Nspire CX II et ce n'est pas un hasard, on y retrouve quasiment les mêmes appels que sur TI-Nspire CX II :

Quelques petites différences certes au niveau des contrôles toutefois, suite à des comportements différents (les affichages TI-Nspire CX II peuvent bénéficier d'un double buffering, les affichages TI-83 Premium CE et TI-84 Plus CE non et sont de plus effacés en fin de script) dont on pourra tenir compte via un if/else ou un try/except.

Mais c'est extraordinaire, pour qui le souhaite la compatibilité Python graphique entre TI-83 Premium CE, TI-84 Plus CE et TI-Nspire CX II est maintenant possible et relativement accessible, félicitations Texas Instruments !

Et sans aller jusque-là, ce sera aussi bien pratique pour les enseignants de n'avoir plus qu'à apprendre et faire apprendre qu'une seule bibliothèque graphique à de rares variations près.

ti_image est lui aussi en version 1.0.0.

Ici encore il s'agit d'un module interface appelant les méthodes dédiées au format d'image PY8 du module ti_graphics.

Par contre ici malgré le nom, aucune compatibilité avec le ti_draw des TI-Nspire CX II, les méthodes n'ont rien à voir, sans grande surprise puisque c'était déjà le cas des formats d'images et même des façons de les générer.

8) Autres applications (Inequalz, Transfrm, Plysmlt2, ProbSim)

Go to top

D'autres applications sont également mises à jour en accompagnement de cette version 5.7 mais fort bizarrement sans changement du numéro de version de l'application, chose qui ne s'était jamais produite :

Inequalz reste apparemment en version 5.1.0.0110, sauf que l'on note que sa date de compilation n'est plus le 1^er septembre 2015 mais le 19 octobre 2021

L'application comportait 2 messages de copyright 2001-2015 identiques. Dans sa nouvelle version, l'un des deux messages de copyright est modifié avec un 2021, mais il ne s'agit apparemment pas de celui affiché pour la liste des applications en mémoire ni à l'écran à propos de l'application.

Nous notons de nombreuses différences dans le reste du code, mais n'arrivons pas à les interpréter.

Par contre la nouvelle application est plus petite, passant de 44,736 Ko à 44,152 Ko, ce n'est pas de refus.

L'application Transfrm prétend elle aussi toujours être en version 5.3.1.0034, sauf qu'ici encore la date de compilation indiquée dans le header ne trompe pas : non plus le 31 mai 2019, mais le 19 octobre 2021.

De même le code de l'application comportait 2 messages de copyright identiques en 2001-2019, et l'un des deux messages passe en 2021, sans que nous arrivions à en obtenir d'affichage nulle-part.

Des différences significatives dans le reste du code sur lesquelles nous ne pouvons hélas pas t'éclairer aujourd'hui. Ici encore la nouvelle application est plus petite, passant de 28,182 Ko à 27,923 Ko.

La façade de l'application ProbSim tente elle aussi de faire croire qu'il n'y a pas eu de changements : version 5.1.0.0110. Sauf que la date de compilation passe du 1^er septembre 2015 au 19 octobre 2021.

Cette application comportait bizarrement 2 numéros de versions différents : un 5.1.0.0110 dans le header, puis un 5.1.0.0 plus loin au milieu du code, numéro jamais affiché selon nos tests.

Dans la nouvelle version, ce 2^ème numéro de version est modifié, passant à 5.7.0.0, de même sans que nous en constations d'affichage nulle-part.

De nombreuses différences dans le reste du code qui restent un mystère à ce jour.

Par contre ici la nouvelle application est plus grosse, passant de 71,487 Ko à 71,512 Ko.

L'application PolySmlt2 reste en apparence en version 5.5.0.0038, sauf que sa date de compilation passe du 12 mai 2020 au 19 octobre 2021.

Cette application comportait ici aussi 2 numéros de version différents : un 5.5.0.0038 dans le header, puis un 5.5.1.0038 plus loin dans le code, numéro ici encore jamais affiché.

Dans la nouvelle version, ce 2^ème numéro de version passe à 5.7.0.0038, de même sans affichage nulle-part.

Mais ce qui est encore plus étrange ici, c'est que tout le reste du code est absolument identique. Donc Texas Instruments se serait embêté à recompiler l'application juste pour changer un numéro de version qui apparemment n'est affiché nulle-part ?... Cela ne tient pas debout.



Tout ceci est extrêmement curieux. Nous avons tenté d'installer ces nouvelles applications sur d'anciennes versions du système et même d'anciennes TI-83 Premium CE, et avons pu les utiliser sans aucun problème.

On pourrait imaginer que Texas Instruments ait effectué des modifications à son compilateur, et n'ait peut-être pas tout configuré correctement.

Ou sinon, en couplant ceci à des numéros de versions qui étrangement apparaissant ou changent également dans le code du système sans être affichés nulle-part, on pourrait se demander si il n'y aurait pas anguille sous roche, et si Texas Instruments ne serait pas en train de concevoir et déployer une nouvelle sécurité permettant de refuser une application dont le numéro de version est trop ancien. Une finalité en serait évidente : le blocage de Cabri 5.0.0.0089 dont une future mise à jour deviendrait alors obligatoire, et ainsi d'arTIfiCE, et par conséquent de AsmHook et à nouveau tout programme ASM. Espérons nous tromper...

Conclusion

Go to top

À nouveau une superbe mise à jour si tu as une TI-83 Premium CE Edition Python, TI-84 Plus CE-T Python Edition ou TI-84 Plus CE Python.

Texas Instruments repousse encore et toujours plus loin les superbes capacités Python de ses calculatrices.

Retenons l'essentiel :

• les nouveaux modules ti_draw et ti_image mettant enfin au menu les formidables possibilités graphiques du Python et invitant donc enfin les utilisateurs à se mettre à créer en conséquence !
• pour ti_draw l'extraordinaire compatibilité graphique avec les TI-Nspire CX II, un exploit, de quoi réunir les utilisateurs autour de projets communs transcendant les modèles et milieux sociaux !

Mais qu'attends-tu encore ?...

Téléchargements

Go to top

• pack de mises à jour 5.7 pour TI-83 Premium CE TI-84 Plus CE
• Système 5.7 seul pour TI-83 Premium CE TI-84 Plus CE
• Application Python 5.7.0.0017 (nécessite la mise à jour système 5.7 pour fonctionner)
• Application CellSheet 5.1.1.0017
• Application Inequalz 5.1.0.0110 modifiée
• Application Hub 5.7.0.0017
• Application PltSmlt2 5.5.0.0038 modifiée
• Application ProbSim 5.1.0.0110 modifiée
• Application Transfrom 5.3.1.0034 modifiée
• Modules complémentaires 1.0.0 ti_draw ti_image
• Applications de langues 5.7.0.0017 Français Allemand Espagnol Néerlandais Portugais Suédois

[critor]

Les TI-83 Premium CE (TI-84 Plus CE hors de France) et TI-Nspire CX II sont les calculatrices graphiques les plus connectées à ce jour. Grâce à leur port mini-USB capable de fonctionner en mode hôte, tu peux t'en servir pour piloter énormément de choses dans le cadre de tes projets STEM :

• carte BBB micro:bit (aussi bien v1 que v2)
• interface TI-Innovator Hub
• robot TI-Innovator Rover
• TI-RGB Array (grille de 2×8 diodes RVB)
• capteur de température Vernier EasyTemp
• interface Vernier EasyLink
• capteurs et actionneurs (selon l'interface format Grove, Vernier et/ou breadboard)
• ...

Rien à voir a priori, mais peut-être connais-tu l'application Cesium ?

Ce petit bijou par MateoConLechuga apporte une interface graphique permet de lancer facilement des programmes sur ta TI-83 Premium CE ou compatible, peu importe qu'il s'agisse de programmes TI-Basic ou dits Asm (c'est-à-dire assemblés à partir de code assembleur eZ80 ou compilés à partir de code en langage C).

Il est devenu incontournable depuis que Texas Instruments a retiré le support officiel des programmes Asm avec la mise à jour 5.5.1 de Mai 2020.

Et bien Cesium te permet également d'étendre de façon fantastique la déjà formidable connectivité de ta TI-83 Premium CE ou compatible.

En effet depuis la version 3.4.1 de mars 2021, Cesium te permet d'accéder au contenu de clés USB directement depuis ta calculatrice !

De quoi également étendre démesurément la capacité mémoire de ta calculatrice !
C'est aussi l'occasion de jongler facilement sans ordinateur avec les niveaux Geometry Dash, permettant en effet d'en avoir un maximum sous la main sans dépasser le nombre maximal de niveaux géré en mémoire de la calculatrice.

Il te faut pour cela un adaptateur USB. Au choix :

• USB mini-A mâle ↔ USB A femelle
• USB mini-B OTG mâle ↔ USB A femelle

Il te faut donc installer l'application Cesium, ou la mettre à jour si ta version est inférieure à 3.4.1 (vérifiable directement depuis Cesium en tapant

mode

).

Si ta calculatrice ne permet pas l'exécution de programmes Asm sans passer par Cesium, il te faudra passer par l'outil arTIfiCE et son tutoriel dédié.

L'écran d'accueil de Cesium une fois à jour doit te lister un lecteur USB Flash Drive, même sans aucune connexion. Si jamais ce n'était pas le cas alors il te suffit d'activer manuellement le support USB via

mode

→

:

Tu as de plus besoin de rajouter les bibliothèques C et bibliothèques USB

Et voilà, une fois tout ceci fait, tu auras accès au contenu de n'importe quelle clé USB formattée en FAT32, ce qui est à ce jour le cas d'une écrasante majorité.

Cesium te permet alors :

• de lancer directement les programmes présents sur la clé USB, peu importe qu'ils soient de type TI-Basic ou Asm
  (à condition qu'ils ne nécessitent pas d'autres fichiers présents sur la clé USB)
• ou bien de copier facilement ces fichiers vers la mémoire de ta calculatrice grâce à la touche

  prgm

  

Attention toutefois, Cesium semble à ce jour avoir du mal si les fichiers que tu cibles sont situés non pas à la racine de la clé USB mais dans un sous-dossier de la clé USB, aussi bien pour l'exécution que pour la copie.

Tu peux dans ces cas obtenir des blocages (et décoincer la calculatrice en déconnectant la clé USB) ou pire des plantages.

Attention, l'usage sur ta calculatrice d'une clé USB et de façon générale de tout module externe, peu importe qu'il soit connectable ou enfichable, est strictement interdit aux épreuves d'examen en France.

En dehors de ces épreuves régies par le cadre national, par exemple pour le contrôle continu, l'autorisation sera à la discrétion de l'enseignant ou établissement concerné.

Téléchargements :

• arTIfiCE
• Cesium
• bibliothèques C
• bibliothèques USB

Lien : tutoriel arTIfiCE

[Shadow]

Depuis 2016, la TI-83 Premium CE bénéficie d'une superbe adaptation de Geometry Dash par Epharius aidé d'Anonyme0.

La version téléchargeable du jeu inclut actuellement des adaptations de huit des 21 niveaux accompagnant la version complète du jeu mobile :

• Stereo Madness (niveau 1) par Shadow et Anonyme0
• Back On Track (niveau 2) par Shadow
• Polargeist (niveau 3) par Shadow et Anonyme0
• Dry Out (niveau 4) par Shadow et Anonyme0
• Base after base (niveau 5) par Shadow
• Can't let go (niveau 6) par Shadow
• Jumper (niveau 7) par Shadow et Lil Nas X3009
• Time Machine (niveau 8) par Shadow

Mais bien d'autres choses sont possibles car vous pouvez très facilement créer et charger vos propres niveaux.

Un éditeur intégré à Geometry Dash est accessible avec la touche

+

, rien de plus simple pour rajouter un niveau.

Si vous préférez bénéficier d'un écran plus grand pour une meilleure vue d'ensemble, la conception peut également se faire sur ordinateur avec le logiciel Tiled où il suffira d'utiliser le tileset de Geometry Dash, puis d'en exporter une version .csv avant de la convertir en ligne.
Pour plus d'informations, cliquez ici.

Cela a justement permis l'adaptation de plusieurs autres niveaux du jeu original, ainsi que diverses créations, telles que :

• Shiphard par Colisalia
• Chaos par Programmator88
• Astra par gst the darkstyle
• Fire and Flammes par _Orlando_
• Meany Means par Capysquid
• Hidden Figures par Lil Nas X3009
• Stop Up Down par Oh11115

À ce jour, l’équipe des Geometry Dasheurs¹, en accord avec l’administration TI-Planet, a décidé de mettre en place un concours de création de niveau Geometry Dash !

Le but paraît plutôt simple :

1. Créez vous-même un niveau Geometry Dash à votre goût, comme vous pensez. (Cf. ci-dessus)
2. Envoyez-le nous à l’adresse suivante : info@tiplanet.org²
3. L’équipe des Geometry Dasheurs seront les jury : ils seront chargés d’évaluer vos niveaux et de les classer.
4. Les 2 créateurs de niveaux en tête du classement gagneront plusieurs prix³ au choix.
   
   Vous serez majoritairement évalués sur la façon d'utiliser les éléments de conception, de les répartir dans votre niveau de façon artistique. Mais aussi sur la qualité de lier la difficulté avec un visage. Nous sommes également ouverts sur les reçus de thèmes, qui pourrait faire lien avec le nom de votre niveau. Pensez à bien vous appliquer pour marquer un maximum de score via les 4 jurys (dont 1 avec coefficient double) !
   
   
   Pour enregistrer votre niveau sur votre ordinateur, rendez-vous sur TI-Connect et trouvez le niveau dans l'explorateur des fichiers. Notez que votre niveau s'intitule sous la forme "L" puis les initiales du nom du niveau. Faites un clic gauche dessus et sauvegardez-le.
   
   Un tutoriel pour sauvegarder du contenu de votre calculatrice à l'ordinateur : lien YouTube
   
   
   Une fois que vôtre niveau a été envoyé, vous pourrez jeter un coup d'oeil au score reçu⁴/classement : ici
   Les résultats seront annoncés le 1^er décembre 2021
   
   Bonne chance à tous, n’hésitez pas à poser des questions en cas de problèmes

Les lots ainsi que leur acheminement leur sont gracieusement offerts par :Go to top

• Calcuso (goodies TI)
• Texas Instruments (calculatrices + goodies)
• Vincent Robert alias cent20 / Lycée Louis Pasteur à Avignon (calculatrices + goodies TI)
• TI-Planet / UPECS (frais de port + goodies)

Les concepteurs ou conceptrices des 2 meilleurs niveaux Geometry Dash recevront :

• 1 calculatrice au choix avec ses accessoires :
  
  • TI-Nspire CX II-T CAS ou TI-Nspire CX II-T + licence logiciel TI-Nspire CX élève
    
    
  • TI-83 Premium CE Edition Python⁵ + licence émulateur TI-SmartView CE + adaptateur USB + clavier USB dédié + film de protection écran Wyngs dédié
  
• 1 stylo TI au choix
• 1 clé USB TI au choix :
  
  • clé USB T³ France (2 Go) bleue
  • clé USB TI (4 Go) : TI-Primaire Plus, TI-Innovator Rover, TI-83 Premium CE, TI rouge avc inscription blanche
  • clé USB TI (1 Mo) rouge avec inscription noire (promotion TI-Primaire Plus défectueuse)
  
• 1 poster TI plié au choix :
  
  • format ANSI-D (55,9×86,4 cm²) : TI-Nspire, TI-Nspire CAS
  • format 55,75×83,5 cm² : TI-Nspire CX, TI-Nspire CX CAS
  
• 1 autocollant TI-Planet au choix
• 1 aimantin TI-Planet au choix
• 1 compte premium TI-Planet
  
  
• 1 cahier d'activités Texas Instruments au choix :
  
  • Enseignement de spécialité Mathématiques (1ère et Tle), par Jean-Baptiste Civet et Boris Hanuš
  • Algorithmique et programmation en Python (2nde), par Jean-Baptiste Civet et Boris Hanuš
  • Programmation en Python au lycée (LEGT), par Ludovic Diana et Jérôme Lenoir
  • Projets Python pour l'enseignement SNT (2nde), par Jean-Baptiste Civet et Boris Hanuš
  • Algorithmique et programmation avec le robot TI-Innovator Rover et le Hub (2nde et 1ère ICN), par Jean-Baptiste Civet et Boris Hanuš
  • Algorithmique et programmation avec la TI-83 Premium CE (2nde ICN), par Jean-Baptiste Civet et Boris Hanuš
  • Algorithmique et programmation en mathématiques & physique-chimie (BAC Pro), par Jérôme Lenoir et Ludovic Diana
  • Livret d’activités en mathématiques, par Boris Hanuš, Laurent Didier et Florent Girod
  • Prise en main de la TI-83 Premium CE Edition Python, par Calcuso
  • Activités Python avec la TI-83 Premium CE au lycée (lycée général et professionnel maths-physique-chimie), par T³ France
  • Livret d'activités pour la seconde professionnelle (2nde Pro), par Jérôme Lenoir
  • Livret d'activités pour la seconde professionnelle (2nde Pro), par Jérôme Lenoir (nouvelle édition compatible TI-82 Advanced Edition Python)
  • Fiches d'activités TI-83 Premium CE Edition Python (2nde Pro), par Vanessa Pavan
  • Les applications TI-83 Premium CE, par Jean-Louis Balas
  • Les raccourcis Python sur les calculatrices Texas Instruments

Attention, Geometry Dash rentre dans la catégorie des programmes en langage machine dits ASM.
Suite à un acte irresponsable d'un enseignant de Mathématiques français avec ses gesticulations dans le contexte de la réforme du lycée, Texas Instruments a réagi en supprimant la gestion de tels programmes depuis la mise à jour 5.5.1.

Pour savoir la version (OS) de votre calculatrice, effectuez la démarche suivante :

2nde

puis

+

puis

1

(à propos) ; ce qui est écrit en dessous de "TI-83 Premium CE" correspond à l'OS de votre calculatrice.


Si vous êtes ainsi sur une des versions bridées, vous pouvez quand même en profiter. Pour cela, il vous faut :

1. installer arTIfiCE pour remettre la possibilité de lancer des programmes ASM
2. ensuite de préférence installer Cesium afin de pouvoir lancer les programmes ASM plus facilement, voire même AsmHook pour pouvoir les lancer comme avant

Un tutoriel est disponible ici.
L'OS le plus récent de la TI-83 Premium CE est la version 5.7.0.

Téléchargements :

• Geometry Dash CE
• Autres niveaux adaptés à tous
• TI-Connect 5.6.3 (Windows) / TI-Connect 5.6.3 (Mac)
• arTIfiCE
• Cesium
• AsmHook

Liens/Tutoriaux :
Rétablissement de l'ASM (OS > 5.5.1) ; tutoriel installation arTIfiCE + Cesium / AsmHook
Vidéo : Tutoriel de sauvegarde de contenu de la calculatrice via TI-Connect
Tutoriel transfert de fichiers via TI-Connect

Notes :Go to top

¹ : Un Geometry Dasheur est une personne qui participe au développement de Geometry Dash CE : en adaptant des niveaux du jeu original ou programmant de nouvelles fonctionnalitées au jeu. Voir conditions de recrutement ici.
² : En envoyant un mail, vous accepterez de donner votre adresse si vous êtes nommé(e) gagnant(e).
³ : Mettez toutes vos chances de gagner en envoyant un maximum de vos créations. Attention, tout niveau plagié provenant de TI-Planet entraîne la discalification.
⁴ : Le score du niveau envoyé sera affiché dans les maximum 48 heures ; dans le tableau de classement, vous verez le score obtenu (sur 20) associé au nom du niveau.
⁵ : La TI-83 Premium CE (édition Python) sera préchargée de Geometry Dash CE ainsi que tous les niveaux du jeu, version lite.