π
<-

News 2024
June (4)
May (4)
April (2)

News 2023
August (2)
July (3)
June (3)
May (7)
April (2)
March (3)

News 2022
August (3)
July (1)
June (4)
May (1)
April (6)
March (4)
January (12)

News 2021
August (8)
July (28)
June (20)
May (19)
April (25)
March (15)

News 2020
August (16)
July (13)
June (17)
May (38)
April (21)
March (17)

News 2019
August (10)
July (3)
June (4)
May (11)
April (8)
March (18)
January (14)

News 2018
August (5)
July (1)
June (9)
May (10)
April (2)
March (14)
January (12)

News 2017
August (10)
July (14)
June (14)
May (11)
April (9)
March (12)
January (11)

News 2016
October (10)
August (8)
July (4)
June (8)
May (14)
April (9)
March (13)
January (11)

News 2015
October (15)
August (11)
July (4)
June (7)
May (12)
April (6)
March (11)

News 2014
August (2)
July (4)
June (2)
May (5)
April (4)
March (5)

News 2013
August (6)
July (6)
June (8)
May (14)
April (24)
March (16)
January (10)

News 2012
October (11)
August (6)
July (7)
June (8)
May (16)
April (16)
March (6)

News 2011
August (4)
July (4)
June (11)
May (5)
April (2)
March (6)

News 2010
July (1)
June (1)
May (2)
April (1)

News 2009
August (2)
April (1)

Exploration module Python ce_box TI-83 Premium CE 5.5

New postby critor » 20 May 2020, 10:30

12382Dans sa prochaine mise à jour 5.5 gratuite prévue pour Mai 2020, Texas Instruments va rajouter de formidables possibilités historiques à ta TI-83 Premium CE :
  • mise à jour en 5.5 de l'application SciTools
  • mise à jour en 5.5 de l'application Periodic
  • mise à jour en 5.5 de l'application Python (TI-83 Premium CE Édition Python uniquement)

Python 5.5 offre de nouveaux modules intégrés pour tes scripts Python :
  • time, certes déjà présent mais maintenant listé au menu et donc officiel
  • ti_system, avec diverses possibilités :
    • détection des simples pressions de touches clavier, y compris avec un clavier USB externe !
    • affichage dans la console à la ligne que tu veux
    • exportation de listes de nombres du contexte Python vers l'environnement de la calculatrice
    • importation dans le contexte Python de listes existant dans l'environnement de la calculatrice vers
    • et donc plus généralement un début d'intégration du Python à l'environnement mathématique de la calculatrice; plus besoin de traiter les tâches numériques à part, l'application Python 5.5 va enfin pouvoir servir s'articulier naturellement au sein de la résolution de problèmes et tâches complexes !
  • ti_plotlib, une bibliothèque graphique pour tracer dans un repère othogonal, conformément aux programmes de Mathématiques et Physique-Chimie, comparable à matplotl chez Casio ou encore matplotlib.pyplot, et gérant ici les diagrammes suivants :
    • nuage de points
    • diagramme en ligne brisée
    • droite de régression linéaire
  • ti_graphics pour contrôler directement les pixels de l'écran, comparable à kandinsky chez NumWorks ou encore casioplot
  • ti_hub, pour les projets d'objects connectés à l'aide de l'interface TI-Innovator Hub
  • ti_rover, pour les projets de robotique à l'aide du TI-Innovator Rover
Mais ce n'est pas tout car Python 5.5 gère également la possibilité inédite de rajouter des modules Python complémentaires :
  • ce_turtl, comparable à turtle
  • ce_box pour les diagrammes en boîte
  • ce_chart pour les histogrammes et aires entre courbes
  • ce_quivr pour les diagrammes utilisant des champs de vecteurs

Nous disposons aujourd'hui enfin de ces 4 modules complémentaires et nous proposons de commencer à te les explorer plus en profondeur.
Attention, ces modules ne sont apparemment pas inclus dans la mise à jour et seront à charger séparément.

Attention également selon nos premiers tests, contrairement aux modules intégrés ces modules complémentaires ne seront pas utilisables en mode examen. :#non#:

Nous commençons dès maintenant par ce_box pour les diagrammes en boîte.




Sommaire :




1) importation et taille ce_box

Go to top

Une fois le fichier ce_box.8xv chargé dans la calculatrice, à première vue aucun changement.

ce_box n'apparaît pas dans la liste des script Python, et la calculatrice ne l'identifie d'ailleurs clairement pas comme un script Python.

ce_box n'apparaît pas non plus dans la liste des modules disponibles.

Mais pas grave, tentons quand même notre première importation de ce_box.

A l'aide du module intégré gc et du script suivant, voyons ce que cette importation consomme sur le tas (heap) Python de 17 Ko et quelques.
Code: Select all
from gc import mem_free as mf

smod = input('Module : ')
mf1, mf2 = 0, 0
scmd = 'from ' + s + ' import *'
mf1 = mf()
exec(scmd)
mf2 = mf()
print(mf1 - mf2)

Comme tu peux voir, la consommation de tas est énorme, le module ce_box fait 13,44 Ko. Il nous reste maintenant moins de 3 Ko de heap Python disponible, on ne va pas pouvoir aller coder bien loin... :#roll#:

On peut toutefois facilement comprendre cela. Il s'agit d'un module de tracé :
  • qui probablement importe lui-même en interne ti_plotlib (7,232 Ko)
  • ti_plotlib importe à son tour le module sys (224 o)
  • ti_plotlib importe lui-même à son tour ti_graphics (2,896 Ko)
  • ti_graphics importe également le module sys (224 o)
  • ti_graphics import aussi le module math (336 o)
Donc en contrepartie de cette consommation de heap, tu as déjà à ta disposition une bonne partie des modules et de leurs fonctionnalités sans avoir à rien importer d'autre. :bj:




2) menus ce_box

Go to top

Le module ce_box n'est en fait rajouté aux menus qu'à partir du moment où tu édites ou crées un script qui l'importe.

En l'absence de menus jusque-là, il te faudra donc saisir toi-même le nom du module pour la commande d'imporation.




3) exemples ce_box

Go to top

La fonction ce_box.show() est tout simplement équivalente au code suivant :
Code: Select all
while not ti_system.escape():
  pass

C'est-à-dire que contrairement à ce que son nom indique, ce_box.show() n'affiche rien mais gèle l'affichage courant le temps que l'utilisateur appuie sur une touche d'interruption. C'est nécessaire puisque sur TI-83 Premium CE Edition Python les affichages graphiques sont effectués sur l'écran de la console, et seront donc automatiquement nettoyés et perdus en fin d'exécution d'un script.

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


Code: Select all
from random import *
from ce_box import *
data = [randint(-10, 42) for i in range(200)]
diag = box(data)
diag.title("Températures")
diag.show()




Dernière question, quelle est la définition utilisée pour les quartiles ? Au lycée français c'est particulier, contrairement à la médiane les quarties sont toujours des valeurs de la série statistique.

La TI-83 Premium CE adopte cette définition par défaut mais laisse le choix.

Prenons donc en Python un cas qui fait la différence comme par exemple [1, 2, 3, 4, 5] :
Code: Select all
from ce_box import *
d = (1, 2, 3, 4, 5)
b = box(d)
b.show()

Excellente nouvelle, ce_box nous fait visiblement des "quartiles à la française", et ce d'ailleurs peu importe le réglage de la calculatrice. Mais peut-être que le comportement sera différent sur la modèle international TI-84 Plus CE Python Edition à venir pour cette rentrée 2020.




4) exploration ce_box

Go to top

Enfin, terminons par une exploration intégrale du contenu du module ce_box, à l'aide du script suivant :
Code: Select all
#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E / G35+E II
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE / Trinket M0
#5: Xcas / HP Prime
#6: KhiCAS / Graph 90+E

def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ("HP" in version()))
      except:
        id=2
  return id

platform=getplatform()
#lines shown on screen
#plines=[29,12,  7, 9,11,0,0]
plines=[29,16,  7, 9,11,0,0]
#max chars per line
#(error or CR if exceeded)
pcols =[53,99,509,32,32,0,0]

unsafe = ((), (), (), ('sys.argv', 'sys.path'), (), (), ())

if platform>=0:
  curline=0
  _p = print
  nlines=plines[platform]
  ncols=pcols[platform]
  def print(*ls):
    global curline
    st=""
    for s in ls:
      if not(isinstance(s,str)):
        s=str(s)
      st=st+s
    stlines=1+int(len(st)/ncols)
    if curline+stlines>=nlines:
      input("Input to continue:")
      curline=0
    _p(st)
    curline+=stlines

def sstr(obj):
  try:
    s=obj.__name__
  except:
    s=str(obj)
    a=s.find("'")
    b=s.rfind("'")
    if a>=0 and b!=a:
      s=s[a+1:b]
  return s

def isExplorable(obj):
  for k in done:
    try:
      if isinstance(obj, eval(k)):
        t, done[k] = done[k], True
        return not t
    except: pass
  if str(obj).startswith("<module"): return False
  l = ()
  try: l = dir(obj)
  except: pass
  return len(l)

done = {'str':False, 'list':False, 'tuple':False, 'dict':False, 'complex':False, 'set':False, 'frozenset': False}

def explmod(pitm, pitmsl=[], reset=True):
  global curline
  spitm=sstr(pitm)
  if(reset):
    curline=0
    pitmsl=[spitm]
    for k in done: done[k] = False
  hd="."*(len(pitmsl)-1)
  c,c2=0,0
  l = sorted(dir(pitm))
  for i in range(len(l)):
    l[i] = (l[i], getattr(pitm, l[i]))
  try:
    if not isinstanceof(pitm, str):
      for i in range(len(pitm)):
        l.append((spitm+'['+str(i)+']',pitm[i]))
  except: pass
  for itm in l:
    c,c2=c+1,c2+1
    isUnsafe = platform >= 0 and '.'.join(pitmsl + [itm[0]]) in unsafe[platform]
    try:
      if isUnsafe: raise Exception
      print(hd+itm[0]+"="+str(itm[1]))
    except:
      print(hd+itm[0])
    if not isUnsafe and isExplorable(itm) and itm[1] != pitm and itm[0] not in pitmsl:
      pitmsl2=pitmsl.copy()
      pitmsl2.append(itm[0])
      c2=c2+explmod(itm[1], pitmsl2, False)[1]
  if c>0 and reset:
    print(hd+"Total: "+str(c)+" 1st level item(s)")
    if c2>0 and c2!=c:
      print(hd+"       "+str(c2)+" item(s)")
  return [c,c2]


Notons en passant la présence d'une fonction permettant à tes scripts de tester la version ce_box, ici 1.0.

On valide en passant l'hypothèse formulée plus haut, le module ti_plotlib est bien inclus dans ce_box et accessible via ce_box.plt.

Le module ce_box offre donc 5 éléments au premier niveau, et jusqu'à 32 en comptant les sous-éléments.

De quoi mettre à jour notre comparatif de la richesse des différentes solutions Python sur calculatrices :
Casio Graph
35+E II
90+E
NumWorks
TI-83PCE
Ed. Python
builtins
array
collections
cmath
gc
math
matplotlib
matplotlib.pyplot
micropython
os
random
sys
time
turtle
uerrno
84-197
.
.
.
.
25-47
.
.
.
.
8-30
.
.
.
.
97-1581
3-363
.
13-428
9-404
42-602
.
.
10-410
.
.
17-977
.
.
25-1277
89-211
.
.
12-34
.
41-63
3-25
11-33
6-28
.
9-31
.
3-25
38-60
.
92-211
2-24
2-24
.
7-29
28-50
.
.
.
.
8-30
15-93
4-26
.
.
spécifiquecasioplot:6-28prime:3-368ion:48-162
kandinsky:8-30
ti_graphics:30-75
ti_hub:?
ti_plotlib:49-84
ti_system:12-34
ti_rover:66-92
Modules491113
Eléments123-302219-6042267-701315-772

Classement en terme de richesse :
  1. 315-772 éléments : TI-83 Premium CE Edition Python
  2. 267-701 éléments : NumWorks
  3. 219-6042 éléments : HP Prime (version alpha)
  4. 123-302 éléments : Casio Graph 90+E / 35+E II
Casio Graph
35+E II
90+E
CasioPython
Casio Graph
35+E II
35+E/USB
75/85/95
MicroPython
TI-Nspire
TI-Python
TI-83PCE
Ed. Python
builtins
array
collections
cmath
gc
math
matplotlib
matplotlib.pyplot
micropython
os
random
sys
time
turtle
uerrno
84-197
.
.
.
.
25-47
.
.
.
.
8-30
.
.
69-126
.
91-230
2-28
.
12-38
7-33
41-67
.
.
6-32
.
8-34
12-38
.
.
24-108
93-218
2-28
.
12-38
7-33
41-67
.
.
3-29
.
.
15-86
.
.
.
92-212
2-24
2-24
.
7-29
28-50
.
.
.
.
8-30
15-93
4-26
.
.
93-214
2-25
2-25
12-35
7-30
41-64
.
.
6-29
15-38
8-31
15-99
8-33
.
.
92-211
2-24
2-24
.
7-29
28-50
.
.
.
.
8-30
15-93
4-26
.
.
spécifiquecasioplot:6-28
matplotl:25-68
nsp:3-10board:22
storage:7-47
ce_box:5-32
ce_chart:?
ce_quivr:?
ce_turtl:?
ti_graphics:30-75
ti_hub:?
ti_plotlib:49-84
ti_system:12-34
ti_rover:66-92
Modules69891317
Eléments217-496203-608176-509158-488238-692320-804

Classement en terme de richesse :
  1. 320-804 éléments : TI-83 Premium CE Edition Python
  2. 267-701 éléments : NumWorks
  3. 238-692 éléments : TI-83 Premium CE + TI-Python (firmware tiers)
  4. 219-6042 éléments : HP Prime (version alpha)
  5. 217-496 éléments : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
  6. 203-608 éléments : Casio Graph 75/85/95 / 35+E/USB / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
  7. 176-509 éléments : TI-Nspire (appli MicroPython)
  8. 158-488 éléments : TI-83 Premium CE + TI-Python

Tuto-vidéos :

Exploration module Python ce_quivr TI-83 Premium CE 5.5

New postby critor » 20 May 2020, 11:06

12382Dans sa prochaine mise à jour 5.5 gratuite prévue pour Mai 2020, Texas Instruments va rajouter de formidables possibilités historiques à ta TI-83 Premium CE :
  • mise à jour en 5.5 de l'application SciTools
  • mise à jour en 5.5 de l'application Periodic
  • mise à jour en 5.5 de l'application Python (TI-83 Premium CE Édition Python uniquement)

Python 5.5 offre de nouveaux modules intégrés pour tes scripts Python :
  • time, certes déjà présent mais maintenant listé au menu et donc officiel
  • ti_system, avec diverses possibilités :
    • détection des simples pressions de touches clavier, y compris avec un clavier USB externe !
    • affichage dans la console à la ligne que tu veux
    • exportation de listes de nombres du contexte Python vers l'environnement de la calculatrice
    • importation dans le contexte Python de listes existant dans l'environnement de la calculatrice vers
    • et donc plus généralement un début d'intégration du Python à l'environnement mathématique de la calculatrice; plus besoin de traiter les tâches numériques à part, l'application Python 5.5 va enfin pouvoir servir s'articulier naturellement au sein de la résolution de problèmes et tâches complexes !
  • ti_plotlib, une bibliothèque graphique pour tracer dans un repère othogonal, conformément aux programmes de Mathématiques et Physique-Chimie, comparable à matplotl chez Casio ou encore matplotlib.pyplot, et gérant ici les diagrammes suivants :
    • nuage de points
    • diagramme en ligne brisée
    • droite de régression linéaire
  • ti_graphics pour contrôler directement les pixels de l'écran, comparable à kandinsky chez NumWorks ou encore casioplot
  • ti_hub, pour les projets d'objects connectés à l'aide de l'interface TI-Innovator Hub
  • ti_rover, pour les projets de robotique à l'aide du TI-Innovator Rover
Mais ce n'est pas tout car Python 5.5 gère également la possibilité inédite de rajouter des modules Python complémentaires :
  • ce_turtl, comparable à turtle
  • ce_box pour les diagrammes en boîte
  • ce_chart pour les histogrammes et aires entre courbes
  • ce_quivr pour les diagrammes utilisant des champs de vecteurs

Nous disposons aujourd'hui enfin de ces 4 modules complémentaires et nous proposons de commencer à t'analyser.
Attention, ces modules ne sont apparemment pas inclus dans la mise à jour et seront à charger séparément.

Attention également selon nos premiers tests, contrairement aux modules intégrés ces modules complémentaires ne seront pas utilisables en mode examen. :#non#:

Explorons maintenant plus en profondeur ce_quivr pour les diagrammes utilisant des champs de vecteurs.




Sommaire :




1) importation et taille ce_quivr

Go to top

Une fois le fichier ce_quivr.8xv chargé dans la calculatrice, à première vue aucun changement.

ce_quivr n'apparaît pas dans la liste des script Python, et la calculatrice ne l'identifie d'ailleurs clairement pas comme un script Python.

ce_quivr n'apparaît pas non plus dans la liste des modules disponibles.

Mais pas grave, tentons quand même notre première importation de ce_quivr.

A l'aide du module intégré gc et du script suivant, voyons ce que cette importation consomme sur le tas (heap) Python de 17 Ko et quelques.
Code: Select all
from gc import mem_free as mf

smod = input('Module : ')
mf1, mf2 = 0, 0
scmd = 'from ' + s + ' import *'
mf1 = mf()
exec(scmd)
mf2 = mf()
print(mf1 - mf2)

Comme tu peux voir, la consommation de tas est significative, le module ce_quivr fait 8,832 Ko. Il nous reste maintenant moins de 8 Ko de heap Python disponible, on ne va pas pouvoir coder des monuments... :#roll#:

On peut toutefois facilement comprendre cela. Il s'agit d'un module de tracé :
  • qui probablement importe lui-même en interne ti_plotlib (7,232 Ko)
  • ti_plotlib importe à son tour le module sys (224 o)
  • ti_plotlib importe lui-même à son tour ti_graphics (2,896 Ko)
  • ti_graphics importe également le module sys (224 o)
  • ti_graphics import aussi le module math (336 o)
Donc en contrepartie de cette consommation de heap, tu aurais déjà à ta disposition une bonne partie des modules et de leurs fonctionnalités sans avoir à rien importer d'autre. :bj:




2) menus ce_quivr

Go to top

Le module ce_quivr n'est en fait rajouté aux menus qu'à partir du moment où tu édites ou crées un script qui l'importe.

En l'absence de menus jusque-là, il te faudra donc saisir toi-même le nom du module pour la commande d'imporation.




3) exemples ce_quivr

Go to top

Le programme de Physique-Chimie de Seconde indique d'aborder divers tracés en Python :
  • nuages de points
  • histogrammes
  • positions successives d'un système modélisé par un point
  • vecteurs vitesse associés à chacun de ces points

Nous avions déjà vu que la possibilité de tracer des nuages de points était couverte par le nouveau module Python ti_plotlib.
Pour les diagrammes permettant l'étude du mouvement d'un système ponctuel, et plus généralement la représentation de diagrammes utilisant des champs de vecteurs, c'est donc ce_quivr qui s'en occupe.


Découvrons cela de suite à travers quelques exemples.

Voici pour étudier un mouvement rectiligne qui semble alors uniformément accéléré :
Code: Select all
import ti_plotlib as plt
from ti_system import *
from ce_quivr imort *

#Les fonctions
def calc_vitesses(absc, temps):
  v = []
  for n in range(len(absc) - 1):
    v.append((absc[n + 1] - absc[n]) / (temps[n + 1] - temps[n]))
  temps = temps[:-1]
  return v, temps

def rep_vitesses(absc, vitesses):
  for i in range(len(vitesses)):
  quiver(absc[i], 0, vitesses[i], 0, 0.06, "b", "vector")

#Le programme
plt.cls()
plt.title("Etude du MRUA")
plt.window(-0.2, 1.2, -1, 1)
x = recall_list("2")
t = recall_list("1")
v, temps_v = calc_vitesses(x, t)
rep_vitesses(x, v)
plt.show_plot()


Et maintenant pour l'étude d'un mouvement à une dimension sur un axe :
Code: Select all
import ti_plotlib as plt
from ce_quivr import *

fx = lambda x: x**3 - 4*x**2 + 3*x - 2
dx = lambda x: 3*x**2 - 8*x + 3
d2x = lambda x: 6*x - 8

def motion(min, max, n):
  dt = (max-min) / n
  t = min
  for i in range(n):
    quiver(t, fx(t), t+dt, fx(t+dt), 1, 'blk', 'line')
    if i % 7 == 0:
      quiver(t, fx(t), 0, dx(t), .4, 'r', 'vector')
      quiver(t, fx(t), 0, d2x(t), .4, 'b')
    t += dt

plt.window(-.25, 4, -5, 7)
plt.cls()
plt.title('Motion in one Dimension')
plt.color(0, 0, 0)
plt.axes('on')
plt.labels('Time', '   X Position     ', 7, 3)
motion(0, 4, 49)
plt.show_plot()




4) exploration ce_quivr

Go to top

Enfin, terminons par une exploration intégrale du contenu du module ce_quivr, à l'aide du script suivant :
Code: Select all
#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E / G35+E II
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE / Trinket M0
#5: Xcas / HP Prime
#6: KhiCAS / Graph 90+E

def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ("HP" in version()))
      except:
        id=2
  return id

platform=getplatform()
#lines shown on screen
#plines=[29,12,  7, 9,11,0,0]
plines=[29,16,  7, 9,11,0,0]
#max chars per line
#(error or CR if exceeded)
pcols =[53,99,509,32,32,0,0]

unsafe = ((), (), (), ('sys.argv', 'sys.path'), (), (), ())

if platform>=0:
  curline=0
  _p = print
  nlines=plines[platform]
  ncols=pcols[platform]
  def print(*ls):
    global curline
    st=""
    for s in ls:
      if not(isinstance(s,str)):
        s=str(s)
      st=st+s
    stlines=1+int(len(st)/ncols)
    if curline+stlines>=nlines:
      input("Input to continue:")
      curline=0
    _p(st)
    curline+=stlines

def sstr(obj):
  try:
    s=obj.__name__
  except:
    s=str(obj)
    a=s.find("'")
    b=s.rfind("'")
    if a>=0 and b!=a:
      s=s[a+1:b]
  return s

def isExplorable(obj):
  for k in done:
    try:
      if isinstance(obj, eval(k)):
        t, done[k] = done[k], True
        return not t
    except: pass
  if str(obj).startswith("<module"): return False
  l = ()
  try: l = dir(obj)
  except: pass
  return len(l)

done = {'str':False, 'list':False, 'tuple':False, 'dict':False, 'complex':False, 'set':False, 'frozenset': False}

def explmod(pitm, pitmsl=[], reset=True):
  global curline
  spitm=sstr(pitm)
  if(reset):
    curline=0
    pitmsl=[spitm]
    for k in done: done[k] = False
  hd="."*(len(pitmsl)-1)
  c,c2=0,0
  l = sorted(dir(pitm))
  for i in range(len(l)):
    l[i] = (l[i], getattr(pitm, l[i]))
  try:
    if not isinstanceof(pitm, str):
      for i in range(len(pitm)):
        l.append((spitm+'['+str(i)+']',pitm[i]))
  except: pass
  for itm in l:
    c,c2=c+1,c2+1
    isUnsafe = platform >= 0 and '.'.join(pitmsl + [itm[0]]) in unsafe[platform]
    try:
      if isUnsafe: raise Exception
      print(hd+itm[0]+"="+str(itm[1]))
    except:
      print(hd+itm[0])
    if not isUnsafe and isExplorable(itm) and itm[1] != pitm and itm[0] not in pitmsl:
      pitmsl2=pitmsl.copy()
      pitmsl2.append(itm[0])
      c2=c2+explmod(itm[1], pitmsl2, False)[1]
  if c>0 and reset:
    print(hd+"Total: "+str(c)+" 1st level item(s)")
    if c2>0 and c2!=c:
      print(hd+"       "+str(c2)+" item(s)")
  return [c,c2]


Notons en passant la présence d'une fonction permettant à tes scripts de tester la version ce_quivr, ici 1.0.

On valide en passant l'hypothèse formulée plus haut, le module ti_plotlib est bien inclus dans ce_quivr et accessible via ce_quivr.plt.

Le module ce_quivr offre donc 5 éléments au premier niveau, et jusqu'à 41 en comptant les sous-éléments.

De quoi mettre à jour notre comparatif de la richesse des différentes solutions Python sur calculatrices :
Casio Graph
35+E II
90+E
NumWorks
TI-83PCE
Ed. Python
builtins
array
collections
cmath
gc
math
matplotlib
matplotlib.pyplot
micropython
os
random
sys
time
turtle
uerrno
84-197
.
.
.
.
25-47
.
.
.
.
8-30
.
.
.
.
97-1581
3-363
.
13-428
9-404
42-602
.
.
10-410
.
.
17-977
.
.
25-1277
89-211
.
.
12-34
.
41-63
3-25
11-33
6-28
.
9-31
.
3-25
38-60
.
92-211
2-24
2-24
.
7-29
28-50
.
.
.
.
8-30
15-93
4-26
.
.
spécifiquecasioplot:6-28prime:3-368ion:48-162
kandinsky:8-30
ti_graphics:30-75
ti_hub:?
ti_plotlib:49-84
ti_system:12-34
ti_rover:66-92
Modules491113
Eléments123-302219-6042267-701315-772

Classement en terme de richesse :
  1. 315-772 éléments : TI-83 Premium CE Edition Python
  2. 267-701 éléments : NumWorks
  3. 219-6042 éléments : HP Prime (version alpha)
  4. 123-302 éléments : Casio Graph 90+E / 35+E II
Casio Graph
35+E II
90+E
CasioPython
Casio Graph
35+E II
35+E/USB
75/85/95
MicroPython
TI-Nspire
TI-Python
TI-83PCE
Ed. Python
builtins
array
collections
cmath
gc
math
matplotlib
matplotlib.pyplot
micropython
os
random
sys
time
turtle
uerrno
84-197
.
.
.
.
25-47
.
.
.
.
8-30
.
.
69-126
.
91-230
2-28
.
12-38
7-33
41-67
.
.
6-32
.
8-34
12-38
.
.
24-108
93-218
2-28
.
12-38
7-33
41-67
.
.
3-29
.
.
15-86
.
.
.
92-212
2-24
2-24
.
7-29
28-50
.
.
.
.
8-30
15-93
4-26
.
.
93-214
2-25
2-25
12-35
7-30
41-64
.
.
6-29
15-38
8-31
15-99
8-33
.
.
92-211
2-24
2-24
.
7-29
28-50
.
.
.
.
8-30
15-93
4-26
.
.
spécifiquecasioplot:6-28
matplotl:25-68
nsp:3-10board:22
storage:7-47
ce_box:5-32
ce_chart:?
ce_quivr:5-41
ce_turtl:?
ti_graphics:30-75
ti_hub:?
ti_plotlib:49-84
ti_system:12-34
ti_rover:66-92
Modules69891317
Eléments217-496203-608176-509158-488238-692325-845

Classement en terme de richesse :
  1. 325-845 éléments : TI-83 Premium CE Edition Python
  2. 267-701 éléments : NumWorks
  3. 238-692 éléments : TI-83 Premium CE + TI-Python (firmware tiers)
  4. 219-6042 éléments : HP Prime (version alpha)
  5. 217-496 éléments : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
  6. 203-608 éléments : Casio Graph 75/85/95 / 35+E/USB / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
  7. 176-509 éléments : TI-Nspire (appli MicroPython)
  8. 158-488 éléments : TI-83 Premium CE + TI-Python

Tuto-vidéos :

Exploration module Python ce_chart TI-83 Premium CE 5.5

New postby critor » 20 May 2020, 12:31

12382Dans sa prochaine mise à jour 5.5 gratuite prévue pour Mai 2020, Texas Instruments va rajouter de formidables possibilités historiques à ta TI-83 Premium CE :
  • mise à jour en 5.5 de l'application SciTools
  • mise à jour en 5.5 de l'application Periodic
  • mise à jour en 5.5 de l'application Python (TI-83 Premium CE Édition Python uniquement)

Python 5.5 offre de nouveaux modules intégrés pour tes scripts Python :
  • time, certes déjà présent mais maintenant listé au menu et donc officiel
  • ti_system, avec diverses possibilités :
    • détection des simples pressions de touches clavier, y compris avec un clavier USB externe !
    • affichage dans la console à la ligne que tu veux
    • exportation de listes de nombres du contexte Python vers l'environnement de la calculatrice
    • importation dans le contexte Python de listes existant dans l'environnement de la calculatrice vers
    • et donc plus généralement un début d'intégration du Python à l'environnement mathématique de la calculatrice; plus besoin de traiter les tâches numériques à part, l'application Python 5.5 va enfin pouvoir servir s'articulier naturellement au sein de la résolution de problèmes et tâches complexes !
  • ti_plotlib, une bibliothèque graphique pour tracer dans un repère othogonal, conformément aux programmes de Mathématiques et Physique-Chimie, comparable à matplotl chez Casio ou encore matplotlib.pyplot, et gérant ici les diagrammes suivants :
    • nuage de points
    • diagramme en ligne brisée
    • droite de régression linéaire
  • ti_graphics pour contrôler directement les pixels de l'écran, comparable à kandinsky chez NumWorks ou encore casioplot
  • ti_hub, pour les projets d'objects connectés à l'aide de l'interface TI-Innovator Hub
  • ti_rover, pour les projets de robotique à l'aide du TI-Innovator Rover
Mais ce n'est pas tout car Python 5.5 gère également la possibilité inédite de rajouter des modules Python complémentaires :
  • ce_turtl, comparable à turtle
  • ce_box pour les diagrammes en boîte
  • ce_chart pour les histogrammes et aires entre courbes
  • ce_quivr pour les diagrammes utilisant des champs de vecteurs

Nous disposons aujourd'hui enfin de ces 4 modules complémentaires et nous proposons de commencer à t'analyser.
Attention, ces modules ne sont apparemment pas inclus dans la mise à jour et seront à charger séparément.

Attention également selon nos premiers tests, contrairement aux modules intégrés ces modules complémentaires ne seront pas utilisables en mode examen. :#non#:

Explorons maintenant plus en profondeur ce_chart pour quelques diagrammes complémentaires.




Sommaire :




1) importation et taille ce_chart

Go to top

Une fois le fichier ce_chart.8xv chargé dans la calculatrice, à première vue aucun changement.

ce_chart n'apparaît pas dans la liste des script Python, et la calculatrice ne l'identifie d'ailleurs clairement pas comme un script Python.

ce_chart n'apparaît pas non plus dans la liste des modules disponibles.

Mais pas grave, tentons quand même notre première importation de ce_chart.

A l'aide du module intégré gc et du script suivant, voyons ce que cette importation consomme sur le tas (heap) Python de 17 Ko et quelques.
Code: Select all
from gc import mem_free as mf

smod = input('Module : ')
mf1, mf2 = 0, 0
scmd = 'from ' + s + ' import *'
mf1 = mf()
exec(scmd)
mf2 = mf()
print(mf1 - mf2)

Comme tu peux voir, la consommation de tas est importante, le module ce_chart fait 13,344 Ko. Il nous reste maintenant moins de 3 Ko de heap Python disponible, on ne va pas pouvoir être bien ambitieux... :#roll#:

On peut toutefois facilement comprendre cela. Il s'agit d'un module de tracé :
  • qui probablement importe lui-même en interne ti_plotlib (7,232 Ko)
  • ti_plotlib importe à son tour le module sys (224 o)
  • ti_plotlib importe lui-même à son tour ti_graphics (2,896 Ko)
  • ti_graphics importe également le module sys (224 o)
  • ti_graphics import aussi le module math (336 o)
Donc en contrepartie de cette consommation de heap, tu aurais déjà à ta disposition une bonne partie des modules et de leurs fonctionnalités sans avoir à rien importer d'autre. :bj:




2) menus ce_chart

Go to top

Le module ce_chart n'est en fait rajouté aux menus qu'à partir du moment où tu édites ou crées un script qui l'importe.

En l'absence de menus jusque-là, il te faudra donc saisir toi-même le nom du module pour la commande d'imporation.

Nous avons donc maintenant deux onglets à notre disposition, ce_chart et Rectangle.




3) exemples ce_chart

Go to top

Le programme de Physique-Chimie de Seconde indique d'aborder divers tracés en Python :
  • nuages de points
  • histogrammes
  • positions successives d'un système modélisé par un point
  • vecteurs vitesse associés à chacun de ces points

Nous avions déjà vu que la possitibilité de tracer des diagrammes avec champs de vecteurs pour couvrir les deux derniers points était disponible via le module complémentaire ce_quivr, et celle de tracer des nuages de points pour sa part couverte par le module intégré ti_plotlib.
Il manquait donc les histogrammes, et c'est justement l'objet de ce_chart.

Découvrons cela de suite à travers quelques exemples.

Regardons-en de suite l'utilisation à cette fin :
Code: Select all
from random import *
from ce_chart import *
n = 5
cx = [randint(0,12) for i in range(n + 1)]
connex = [("Ke", cx[1] / 12), ("Jo", cx[2] / 12), ("Am", cx[3] / 12, ("Pa", cx[4] / 12), ("Ma", cx[5] / 12)]
cht = chart()
cht.data(connex)
cht.title("Temps de connextion")
cht.frequencies(2)
cht.show()


Mais ce n'est pas tout, Texas Instruments a également eu la bonne idée d'exposer la fonction interne de tracé de rectangle servant pour les barres d'histogramme dans un 2nd onglet de menu.
Contrairement à la fonction drawRect() du module intégré ti_graphics, ici cela permet de travailler non pas en comptant les pixels, mais directement avec les coordonnées dans le repère du diagramme ! :bj:

Une application par exemple en Mathématiques, c'est l'approche de l'aire entre deux courbes par la méthode des rectangles. Et la fonction draw_fx() est justement là pour compléter le tracé avec la courbe en question.
Code: Select all
from ce_chart import *
import ti_plotlib as plt
from math import *

cht = chart()
plt.cls()
plt.window(-pi, pi, -1.1, 1.4)
plt.grid(.6, .40, "solid")
plt.color(0,0,0)
plt.axes()

f = lambda x:sin(x)

def calc_area(n, min, max, fx):
  sum = 0
  dx = (max - min) / n
  for i in range(0, n)
    a_rectangle = rectangle(min, 0, dx, fx(min + dx/2), 'b')
    sum += a_ractangle.area
    a_rectangle.draw()
    min += dx
  return sum

draw_fx(-pi, pi, f, 40, "g")
the_area = calc_area(50, -pi, pi, f)
plt.title("Somme des Aires = " + str(round(the_area, 4)))
plt.show_plot()



4) exploration ce_chart

Go to top

Enfin, terminons par une exploration intégrale du contenu du module ce_chart, à l'aide du script suivant :
Code: Select all
#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E / G35+E II
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE / Trinket M0
#5: Xcas / HP Prime
#6: KhiCAS / Graph 90+E

def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ("HP" in version()))
      except:
        id=2
  return id

platform=getplatform()
#lines shown on screen
#plines=[29,12,  7, 9,11,0,0]
plines=[29,16,  7, 9,11,0,0]
#max chars per line
#(error or CR if exceeded)
pcols =[53,99,509,32,32,0,0]

unsafe = ((), (), (), ('sys.argv', 'sys.path'), (), (), ())

if platform>=0:
  curline=0
  _p = print
  nlines=plines[platform]
  ncols=pcols[platform]
  def print(*ls):
    global curline
    st=""
    for s in ls:
      if not(isinstance(s,str)):
        s=str(s)
      st=st+s
    stlines=1+int(len(st)/ncols)
    if curline+stlines>=nlines:
      input("Input to continue:")
      curline=0
    _p(st)
    curline+=stlines

def sstr(obj):
  try:
    s=obj.__name__
  except:
    s=str(obj)
    a=s.find("'")
    b=s.rfind("'")
    if a>=0 and b!=a:
      s=s[a+1:b]
  return s

def isExplorable(obj):
  for k in done:
    try:
      if isinstance(obj, eval(k)):
        t, done[k] = done[k], True
        return not t
    except: pass
  if str(obj).startswith("<module"): return False
  l = ()
  try: l = dir(obj)
  except: pass
  return len(l)

done = {'str':False, 'list':False, 'tuple':False, 'dict':False, 'complex':False, 'set':False, 'frozenset': False}

def explmod(pitm, pitmsl=[], reset=True):
  global curline
  spitm=sstr(pitm)
  if(reset):
    curline=0
    pitmsl=[spitm]
    for k in done: done[k] = False
  hd="."*(len(pitmsl)-1)
  c,c2=0,0
  l = sorted(dir(pitm))
  for i in range(len(l)):
    l[i] = (l[i], getattr(pitm, l[i]))
  try:
    if not isinstanceof(pitm, str):
      for i in range(len(pitm)):
        l.append((spitm+'['+str(i)+']',pitm[i]))
  except: pass
  for itm in l:
    c,c2=c+1,c2+1
    isUnsafe = platform >= 0 and '.'.join(pitmsl + [itm[0]]) in unsafe[platform]
    try:
      if isUnsafe: raise Exception
      print(hd+itm[0]+"="+str(itm[1]))
    except:
      print(hd+itm[0])
    if not isUnsafe and isExplorable(itm) and itm[1] != pitm and itm[0] not in pitmsl:
      pitmsl2=pitmsl.copy()
      pitmsl2.append(itm[0])
      c2=c2+explmod(itm[1], pitmsl2, False)[1]
  if c>0 and reset:
    print(hd+"Total: "+str(c)+" 1st level item(s)")
    if c2>0 and c2!=c:
      print(hd+"       "+str(c2)+" item(s)")
  return [c,c2]


Notons en passant la présence d'une fonction permettant à tes scripts de tester la version ce_box, ici 1.0.

On valide en passant l'hypothèse formulée plus haut, le module ti_plotlib est bien inclus dans ce_box et accessible via ce_box.plt.

Le module ce_box offre donc 8 éléments au premier niveau, et jusqu'à 67 en comptant les sous-éléments.

De quoi mettre à jour notre comparatif de la richesse des différentes solutions Python sur calculatrices :
Casio Graph
35+E II
90+E
NumWorks
TI-83PCE
Ed. Python
builtins
array
collections
cmath
gc
math
matplotlib
matplotlib.pyplot
micropython
os
random
sys
time
turtle
uerrno
84-197
.
.
.
.
25-47
.
.
.
.
8-30
.
.
.
.
97-1581
3-363
.
13-428
9-404
42-602
.
.
10-410
.
.
17-977
.
.
25-1277
89-211
.
.
12-34
.
41-63
3-25
11-33
6-28
.
9-31
.
3-25
38-60
.
92-211
2-24
2-24
.
7-29
28-50
.
.
.
.
8-30
15-93
4-26
.
.
spécifiquecasioplot:6-28prime:3-368ion:48-162
kandinsky:8-30
ti_graphics:30-75
ti_hub:?
ti_plotlib:49-84
ti_system:12-34
ti_rover:66-92
Modules491113
Eléments123-302219-6042267-701315-772

Classement en terme de richesse :
  1. 315-772 éléments : TI-83 Premium CE Edition Python
  2. 267-701 éléments : NumWorks
  3. 219-6042 éléments : HP Prime (version alpha)
  4. 123-302 éléments : Casio Graph 90+E / 35+E II
Casio Graph
35+E II
90+E
CasioPython
Casio Graph
35+E II
35+E/USB
75/85/95
MicroPython
TI-Nspire
TI-Python
TI-83PCE
Ed. Python
builtins
array
collections
cmath
gc
math
matplotlib
matplotlib.pyplot
micropython
os
random
sys
time
turtle
uerrno
84-197
.
.
.
.
25-47
.
.
.
.
8-30
.
.
69-126
.
91-230
2-28
.
12-38
7-33
41-67
.
.
6-32
.
8-34
12-38
.
.
24-108
93-218
2-28
.
12-38
7-33
41-67
.
.
3-29
.
.
15-86
.
.
.
92-212
2-24
2-24
.
7-29
28-50
.
.
.
.
8-30
15-93
4-26
.
.
93-214
2-25
2-25
12-35
7-30
41-64
.
.
6-29
15-38
8-31
15-99
8-33
.
.
92-211
2-24
2-24
.
7-29
28-50
.
.
.
.
8-30
15-93
4-26
.
.
spécifiquecasioplot:6-28
matplotl:25-68
nsp:3-10board:22
storage:7-47
ce_box:5-32
ce_chart:8-67
ce_quivr:5-41
ce_turtl:?
ti_graphics:30-75
ti_hub:?
ti_plotlib:49-84
ti_system:12-34
ti_rover:66-92
Modules69891317
Eléments217-496203-608176-509158-488238-692333-912

Classement en terme de richesse :
  1. 322-912 éléments : TI-83 Premium CE Edition Python
  2. 267-701 éléments : NumWorks
  3. 238-692 éléments : TI-83 Premium CE + TI-Python (firmware tiers)
  4. 219-6042 éléments : HP Prime (version alpha)
  5. 217-496 éléments : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
  6. 203-608 éléments : Casio Graph 75/85/95 / 35+E/USB / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
  7. 176-509 éléments : TI-Nspire (appli MicroPython)
  8. 158-488 éléments : TI-83 Premium CE + TI-Python

Tuto-vidéos :

gc.collect(): optimisation tas/heap Python 83 Premium CE 5.5

New postby critor » 20 May 2020, 17:16

12382Dans sa prochaine mise à jour 5.5 gratuite prévue pour Mai 2020, Texas Instruments va rajouter de formidables possibilités historiques à ta TI-83 Premium CE :
  • mise à jour en 5.5 de l'application SciTools
  • mise à jour en 5.5 de l'application Periodic
  • mise à jour en 5.5 de l'application Python (TI-83 Premium CE Édition Python uniquement)

Python 5.5 offre de nouveaux modules intégrés pour tes scripts Python :
  • time, certes déjà présent mais maintenant listé au menu et donc officiel
  • ti_system, avec diverses possibilités :
    • détection des simples pressions de touches clavier, y compris avec un clavier USB externe !
    • affichage dans la console à la ligne que tu veux
    • exportation de listes de nombres du contexte Python vers l'environnement de la calculatrice
    • importation dans le contexte Python de listes existant dans l'environnement de la calculatrice vers
    • et donc plus généralement un début d'intégration du Python à l'environnement mathématique de la calculatrice; plus besoin de traiter les tâches numériques à part, l'application Python 5.5 va enfin pouvoir servir s'articulier naturellement au sein de la résolution de problèmes et tâches complexes !
  • ti_plotlib, une bibliothèque graphique pour tracer dans un repère othogonal, conformément aux programmes de Mathématiques et Physique-Chimie, comparable à matplotl chez Casio ou encore matplotlib.pyplot, et gérant ici les diagrammes suivants :
    • nuage de points
    • diagramme en ligne brisée
    • droite de régression linéaire
  • ti_graphics pour contrôler directement les pixels de l'écran, comparable à kandinsky chez NumWorks ou encore casioplot
  • ti_hub, pour les projets d'objects connectés à l'aide de l'interface TI-Innovator Hub
  • ti_rover, pour les projets de robotique à l'aide du TI-Innovator Rover
Mais ce n'est pas tout car Python 5.5 gère également la possibilité inédite de rajouter des modules Python complémentaires :
  • ce_turtl, comparable à turtle
  • ce_box pour les diagrammes en boîte
  • ce_chart pour les histogrammes et aires entre courbes
  • ce_quivr pour les diagrammes utilisant des champs de vecteurs



Sommaire :



1) mémoire de tas / heap et module gc

Go to top

L'appel mem() avec le script mem.py suivant permet d'estimer la capacité du tas (heap) Python, et retournait jusqu'à présent près de 20K sur TI-83 Premium CE Édition Python :
Code: Select all
def sizeenv():
  s=0
  import __main__
  for o in dir(__main__):
    try:s+=size(eval(o))
    except:pass
  return s
def size(o):
  s,t=0,type(o)
  if t==str:s=49+len(o)
  if str(t)=="<class 'function'>":s=136
  if t==int:
    s=24
    while o:
      s+=4
      o>>=30
  if t==list:
    s+=64
    for so in o:s+=8+size(so)
  return s
def mem(v=1,r=1):
  try:
    l=[]
    try:
      l+=[r and 793+sizeenv()]
      if v*r:print(" ",l[0])
      l+=[0]
      l+=[""]
      l[2]+="x"
      while 1:
        try:l[2]+=l[2][l[1]:]
        except:
          if l[1]<len(l[2])-1:l[1]=len(l[2])-1
          else:raise(Exception)
    except:
      if v:print("+",size(l))
      try:l[0]+=size(l)
      except:pass
      try:l[0]+=mem(v,0)
      except:pass
      return l[0]
  except:return 0

Les formidables nouveautés de la version 5.5 semblent hélas avoir un coût important, à vide nous trouvons désormais à peine 17,5K de libres avec la version 5.5, un effondrement non négligeable de plus de 2,5K. :'(

La TI-83 Premium CE Édition Python fait partie des très rares calculatrices à disposer du module gc (garbage collect), module qui va nous être bien pratique pour comprendre ce qui se passe. Retenons les appels suivants :
  • gc.mem_alloc() retourne l'espace occupé sur le tas (heap)
  • gc.mem_free() retourne l'espace libre sur le tas (heap)
  • gc.collect(), formidable fonction qui nettoie / optimise le tas (heap)

Testons à vide à l'aide du petit script suivant, sur l'ancienne et la nouvelle version :
Code: Select all
from gc import *
a, f = 0, 0
a, f = mem_alloc(), mem_free()
(a, f, a+f)

Nous découvrons donc que le tas Python de la TI-83 Premium CE Édition Python a dans tous les cas une capacité totale de 19,968 Ko.

Ce n'est donc pas la capacité globale qui change mais la consommation du tas à vide, à peine plus de 600 o en version 5.4, et maintenant plus de 3 Ko en version 5.5. En effet lorsque tu lances tes scripts Python plusieurs choses sont initialisées et consomment du tas avant même l'exécution de ta première ligne de code. Et c'est là qu'il y a une lourde différence :

En passant il est normal ici de trouver un peu moins d'espace mémoire libre qu'avec le script précédent, vu qu'il le tas a subit une consommation supplémentaire à cause de l'imporation du module gc.

Tentons maintenant un appel explicite demandant de nettoyer la mémoire, avec gc.collect().

Et ben non, pas de chance ici, le nettoyage mémoire non seulement ne nous libère rien mais arriver même à consommer un petit peu. :troll

D'où le classement définitif en terme de capacité tas (heap) maximale utilisable pour tes scripts, avec la capacité totale précisée lorsque le module gc est disponible :
  1. 1,032942 Mo : Casio Graph 90+E
  2. 1,022145 / 1,024512 Mo : HP Prime G1 (version alpha)
  3. 100,560 Ko : Casio Graph 35+E II
  4. 32,339 Ko : NumWorks (firmware Omega)
  5. 31,624 Ko : NumWorks
  6. 19,500 / 19,968 Ko : TI-83 Premium CE Édition Python (ancienne version)
  7. 17,359 / 19,968 Ko : TI-83 Premium CE Édition Python (nouvelle version)
  1. 2,049276 Mo : TI-Nspire (application MicroPython)
  2. 1,032942 Mo : Casio Graph 90+E / fx-CG50
  3. 1,022145 Mo : HP Prime G1 (version alpha)
  4. 257,636 / 258,048 Ko : Casio Graph 35+E / 75+ / 35+ USB Power Graphic 2 / 75/95 USB Power Graphic 2 / fx-9750/9860GII USB Power Graphic 2
  5. 100,560 Ko : Casio Graph 35+E II / fx-9750/9860GIII
  6. 32,339 Ko : NumWorks (firmware Omega)
  7. 31,624 Ko : NumWorks
  8. 31,520 / 32,256 Ko : Casio Graph 35+E II / 85 / 35+ USB Power Graphic 1 / 75/95 USB Power Graphic 1 / fx-9750/9860GIII / fx-9750/9860GII USB Power Graphic 1 / fx-9860G
  9. 22,605 / 22,912 Ko : TI-83 Premium CE + TI-Python (firmware tiers)
  10. 19,500 / 19,968 Ko : TI-83 Premium CE + TI-Python + TI-83 Premium CE Édition Python (ancienne version)
  11. 17,359 / 19,968 Ko : TI-83 Premium CE Édition Python (nouvelle version)

La TI-83 Premium CE Édition Python était déjà la pire solution Python pour la capacité tas, et cela ne fait donc qu'empirer.

C'est probablement largement suffisant pour les petits algo-musements de quelques lignes qui seront traités en Mathématiques ou Physique-Chimie.

Le problème est ailleurs, ceux qui auront suffisamment accroché pour avoir envie d'aller plus loin risquent d'être rapidement déçus par leur calculatrice...
Ceux qui aborderont des projets (SNT, NSI, ... ou même non scolaires) risquent d'obtenir des erreurs de mémoire assez rapidement après le début du projet...

Car le Python ce n'est pas du C, les objets Python les plus élémentaires sont extrêmement gourmands en mémoire :
  • 64 octets rien que pour une liste vide
  • plus 8 octets pour chaque élément de liste supplémentaire, sans compter la taille de l'élément en question
  • 24 octets pour un entier nul
  • 28 octets pour un entier court non nul
  • 49 octets rien que pour une chaîne vide
  • plus 1 octet par caractère de chaîne supplémentaire
  • ...
Alors imagine la catastrophe que cela pourrait être pour des projets tu multiplies le nombre de ces objets au sein de listes, ou pire lorsque tu passes à la 2ème dimension avec des listes de listes... :#roll#:

Mais attends nous n'avons pas encore dit notre dernier mot, passons aux modules importables et voyons ce que la fonction gc.collect() peut bien donner dessus. ;)




2) importations modules et consommation tas / heap

Go to top

Voyons maintenant un petit peu ce que consomme l'importation de chaque module disponible sur le tas (heap), grâce ici aux formidables possibiltés exclusives du module gc.

Il suffit d'appeler les fonctions du module gc vues plus haut, juste avant et après l'importation d'un module, afin de vérifier l'espace consommé sur le tas. Nous allons même tenter en prime un nettoyage du tas après importation, et voir si cela améliore les choses.

Voici un script en ce sens, volontairement minimaliste sans définition de fonction afin de minimiser les chances de déclencher un nettoyage mémoire en dehors des appels explicites à gc.collect() :
Code: Select all
from gc import mem_free, collect

smod = input('Module : ')
mf1, mf2, mf3 = 0, 0, 0
scmd = 'from ' + smod + ' import *'
collect()
mf1 = mem_free()
exec(scmd)
mf2 = mem_free()
collect()
mf3 = mem_free()
print("initial: ", mf1)
print("importation: ", mf2, mf2-mf1)
print("nettoyage: ", mf3, mf3-mf1)

Voici donc les consommations de tas à l'importation puis après nettoyage des différents modules intégrés :
  • builtins : 800 o à l'importation, 720 o après nettoyage
  • array : 96 o à l'importation, 16 o après nettoyage
  • collections : 96 o à l'importation, 16 o après nettoyage
  • gc : 112 o à l'importation, 32 o après nettoyage (mesure possiblement faussée, puisque le module est déjà partiellement importé)
  • math : 320 o à l'importation, 240 o après nettoyage
  • random : 160 o à l'importation, 80 o après nettoyage
  • sys : 208 o à l'importation, 128 o après nettoyage
  • time : 112 o à l'importation, 32 o après nettoyage
  • ti_graphics : 2,880 Ko à l'importation, 1,584 Ko après nettoyage
  • ti_hub : 256 o à l'importation, 176 o après nettoyage
  • ti_plotlib : 7,216 Ko à l'importation, 3,504 Ko après nettoyage
  • ti_rover : 4,832 Ko à l'importation, 2,352 Ko après nettoyage
  • ti_system : 208 o à l'importation, 128 o après nettoyage
  • ce_box : 13,440 Ko à l'importation, 6,704 Ko après nettoyage
  • ce_chart : 13,328 Ko à l'importation, 6,448 Ko après nettoyage
  • ce_quivr : 8,832 Ko à l'importation, 3,904 Ko après nettoyage
  • ce_turtl : 9,792 Ko à l'importation, 4,944 Ko après nettoyage


Et oui, c'est fantastique, l'appel gc.collect() à ce jour exclusif sur TI-83 Premium CE Edition Pyton te permet de libérer du tas, et ce de façon très significative dans le contexte de l'utilisation des plus gros modules dont certains te remplissaient quasiment tout les tas ! :bj:

ti_graphics, ti_plotlib, ti_rover, ce_box, ce_chart, ce_quivr et ce_turtl, la consommation énorme de chacun de ces modules à l'importation est immédiatement quasiment réduite de moitié ! :D

Mise à jour 5.5 supprime assembleur TI-83 Premium CE & 84+CE

New postby Admin » 20 May 2020, 17:21


EDIT September 2020: A jailbreak is now available! Un jailbreak existe désormais !


Résumé pour les personnes pressées :


Show/Hide spoilerAfficher/Masquer le spoiler
  • Lors de leurs premières années, les calculatrices graphiques de Texas Instruments n'étaient pas explicitement ouvertes à la programmation native (en assembleur), mais on pouvait y parvenir en exploitant diverses failles de sécurité;
  • Un peu plus tard, des modèles gérant officiellement la programmation en assembleur sont apparus, et même de la documentation officielle et des outils officiels (de qualité variable, mais ce n'est pas le propos), pour ce faire;
  • Au fil du temps, le monde a changé, les réglementations d'examens se sont faites de plus en plus contraignantes, et les modèles de TI ouverts à la programmation en assembleur (qui peut certes théoriquement fournir un moyen de contourner les limitations, même si de tels outils sont restés limités) se sont faits de plus en plus rares ; cf. la TI-82 Advanced, TI-84 Plus T qui sont des modèles sans support d'ASM tiers;
  • A partir de maintenant, avec l'OS 5.5 des TI-83 Premium CE (et TI-84 Plus CE), il n'y en a plus, TI a supprimé l'assembleur sur les CE où il était extrêmement utile/utilisé par la communauté, et pas pour tricher... :'(
  • C'est vraisemblablement à la suite du comportement hautement maladroit de deux personnes qui ne font pas partie de la communauté d'utilisateurs (TI-Planet etc.), et certainement de la pression de ceux qui réglementent les examens et indiquent les modèles autorisés et interdits ainsi que leurs caractéristiques;
  • L'âge d'or, qui aura duré plus d'une vingtaine d'année, est définitivement terminé, et c'est un crève-cœur pour beaucoup de membres de la communauté. Existera-t-il sur CE une sorte de jailbreak comme Ndless sur TI-Nspire ? Seul le futur nous le dira...

Summary for those in a hurry :


Show/Hide spoilerAfficher/Masquer le spoiler
  • In their early years, Texas Instruments graphing calculators were not explicitly open to native programming (in assembly), but this could be achieved by exploiting various security flaws;
  • A little later, models officially supporting assembly programming were released, and even official documentation and official tools (of variable quality, but that's not the point) about that as well;
  • Over time, the world has changed, examination regulations have become more and more restrictive, and TI calculators open to assembly programming (which theoretically can provide a way to get around the limitations, even if such tools have remained limited) have become increasingly rare ; for instance, the TI-82 Advanced and TI-84 Plus T are models without 3rd-party ASM support;
  • As of now, with OS 5.5 for the TI-83 Premium CE (and TI-84 Plus CE), there isn't any anymore, TI has removed ASM support on the CE where it was extensively used/useful by and for the community, and not for cheating purposes… :'(
  • This is likely due to the careless behavior of two people who are not part of the user community (TI-Planet etc.), and certainly from the pressure from those who regulate exams and decide which calculator models are allowed or not, and their features;
  • The golden age, which will have lasted more than twenty years, is definitely over, and it is heartbreaking for many members of the enthusiast community. Will there be on the CE some kind of jailbreak like Ndless on the TI-Nspire? Only time will tell...




Sommaire :



1) Il était une fois, dans une contrée lointaine, très lointaine… Texas Instruments (1990-1993)

Go to top

Pour la rentrée 1990, Texas Instruments démarre sa formidable épopée dans le monde des calculatrices graphiques avec son tout premier modèle TI-81, muni d'un processeur Zilog z80 8 bits et dépourvu d'un port de communication.
Ce modèle était programmable dans une première version de ce qu'on appelle aujourd'hui le langage TI-Basic. Les premiers fans Texas Instruments furent rapidement confrontés aux limites de ce langage. D'une part il s'agit d'un langage interprété, c'est-à-dire que les lignes sont lues une par une à l'exécution et alors seulement traduites en instructions machine pour exécution. Un langage donc assez lent, peu adapté aux jeux notamment. D'autre part tu étais limité(e) aux seules instructions prévues par Texas Instruments, à l'époque peu nombreuses. Pas de gestion des chaînes de caractères, matrices ou images, et bien qu'il y ait eu des progrès c'est encore assez rudimentaire sur ces dernières aujourd'hui.


2) Age d’or programmation assembleur sur calculatrices TI (1994-2005)

Go to top

Pour la rentrée 1992, Texas Instruments récidive avec la TI-85, munie d'un langage similaire étendu avec les matrices, et cette fois-ci d'un port de communication, dans la version normale de la calculatrice. Mais Texas Instruments allait ici avoir quelque surprise...

Car en novembre 1994 Dan Eble, Magnus Hagander et Rob Taylor sont entrés dans l'histoire en tant que pionniers avec ZShell. Premier shell assembleur pour la TI-85, ZShell est un outil qui permettait :
  1. de programmer en langage assembleur z80 sur ton ordinateur
  2. de compiler le code en question en langage machine TI-85
  3. d'encapsuler le code machine obtenu dans un format de variable transférable sur TI-85, ici des chaînes de caractères
  4. et enfin d'exécuter les variables en question une fois transférées sur la TI-85
Sur calculatrice, l'installation de ZShell exploitait une faille dans une fonctionnalité officielle, la possibilité de transférer et recevoir des backups (sauvegardes), et donc de réécrire intégralement le contenu de la mémoire RAM avec tout ce que l'on voulait. Un fichier backup tout spécialement trafiqué était ainsi fourni pour l'installation de ZShell sur calculatrice. Ce fut pour la communauté Texas Instruments alors naissante une formidable révolution. Des dizaines de programmes codés en assembleur sont sortis en quelques mois pour ZShell et d'autres shells s'en inspirant. De formidables jeux, des outils révolutionnaires à l'époque (affichage d'images, sortie son sur le port série mini-Jack 2.5 de la calculatrice, ...). ZShell aura, pour un temps, contribué à changer la face du monde.
https://www.ticalc.org/pub/85/asm/

C'est en février 2010 après près de 20 ans que la TI-81 permettra pour sa part enfin l'exécution de programmes assembleurs, grâce au shell Unity par Benjamin Moody. Toutefois l'installation n'exploite pas de transfert de fichier backup ici, vu que le modèle n'a pas de port de communication, hormis le rare modèle spécial VSC. Il fallait mettre en mémoire le code machine du shell en tapant des séries en l'apparence inintelligibles de symboles et commandes dans un programme, puis placer ce code au bon endroit mémoire via des manipulations de menus exploitant plusieurs failles. L'exploit est à saluer, mais sorti bien trop tard le succès fut quasi nul.
https://www.ticalc.org/pub/81/asm/

La TI-92 sort pour la rentrée 1995 avec cette fois-ci un processeur Motorola 68k 16 bits, un modèle alors révolutionnaire avec le calcul formel issu du logiciel Derive, ainsi qu'une application de géométrie dynamique. Le langage de programmation toujours appelé TI-Basic n'avait rien à voir avec les précédents, étant cette fois-ci construit autour de la définition et l'appel de fonctions. Il n'en restait toutefois pas moins un langage interprété avec donc les mêmes défauts de vitesse et dans une moindre mesure de puissance.

10 Novembre 1995 soit à peine quelques semaines après la disponibilité du modèle, David Ellsworth apporte sa pierre à l'édifice avec Fargo, un shell assembleur pour la TI-92, exploitant la même famille de failles avec le transfert d'un fichier backup trafiqué. La communauté s'empressa de s'engouffrer dans les possibilités inédites offertes ainsi par le contrôle total de ce processeur très supérieur.
https://www.ticalc.org/pub/92/asm/

On avance à la rentrée 1996, Texas Instruments sort la TI-83, dont le système d'exploitation sera réutilisé après mise à jour pour les futurs modèles d'entrée de gamme reprenant la technologie matérielle de cette machine : TI-82 STATS (2004), TI-82 Stats.fr (2006) et TI-76.fr (2009). Chez Texas Instruments, l'un des ingénieurs derrière l'écriture de ce système d'exploitation, Pat Milheron, fut particulièrement impressionné par le formidable travail communautaire déjà effectué donc autour de l'assembleur des TI-85 et TI-92, et défendit l'idée d'intégrer un moyen d'exécuter du code assembleur pour les utilisateurs les plus passionnées et exigeants. Le projet fut a priori validé mais dans un premier temps à de simples fins de test : la TI-83 et ses modèles dérivés dissimulent une instruction initialement secrète pour exécuter des programmes contenant du code assembleur, Send(9prgm.... Oui, c'est l'instruction de transfert de fichier qui n'a en apparence rien à voir qui servait via un paramètre spécial à exécuter un programme assembleur, digne d'un easter egg (œuf de Pâques). Les programmes assembleur étaient donc cette fois-ci facilement utilisables par tout-le-monde puisque la fonctionnalité n'avait pas à être installée via des manipulations plus ou moins complexes. La communauté entra en véritable ébullition et battit rapidement en quantité l'exploit TI-85 précédent :
https://www.ticalc.org/pub/83/asm/

La TI-82 était entre temps sortie pour la rentrée 1993, bien évidemment à l'époque sans support assembleur officiel pour sa part.

Cette lacune est partiellement résolue le 7 août 1997 par Jason Todd et Andy Selle qui sortent OShell-82, le premier shell assembleur pour TI-82, toujours la même méthode s'appuyant sur le transfert d'un fichier backup trafiqué. Toutefois ce dernier avait le défaut de ne pas offrir de relocation mémoire, et c'est en fait un autre shell que l'histoire retiendra, Ash du 26 août 1997 par Dines Justesen et Mattias Lindqvist. Le succès ne fut cette fois-ci pas au rendez-vous, avec une productivité très faible en comparaison. Il faut dire que ces shells avaient le défaut de sortir sur un modèle d'entrée de gamme moins intéressant que plusieurs modèles précédents, et de plus très tardivement 4 ans après le lancement du modèle approchant maintenant de la fin de sa vie. De plus un autre accident allait gravement handicaper l'assembleur communautaire sur TI-82. Pour la rentrée 2001 Texas Instruments commença à distribuer des TI-82 munies d'une version 19.006 du système d'exploitation. En fait ce n'était matériellement plus des TI-82, elles utilisaient la carte électronique très différente des TI-83. La version 19.006 n'était donc pas une mise à jour du système d'exploitation TI-82, mais un portage de la version 19.0 de ce dernier pour le matériel TI-83. En conséquence les shells précédents ne fonctionnaient plus, et il fallut attendre des mises à jour ou nouveaux shells pour disposer de l'assembleur sur cette nouvelle TI-82. Sans compter que la compatibilité avec les anciennes et nouvelles TI-82 n'était pas systématique aussi bien pour les shells que pour les programmes assembleur, et compliquait la vie des utilisateurs…
https://www.ticalc.org/pub/82/asm/

Rentrée 1997 nouvelle étape franchie chez Texas Instruments avec le remplacement de la TI-85 par la TI-86. Apparemment conforté par l'expérience de l'assembleur caché dans la TI-83, l'ingénieur Texas Instruments Pat Milheron arrive ici à faire accepter la prochaine étape, la TI-86 incluant une commande officielle pour l'exécution de programmes assembleur, et cette fois-ci qui ne se cache plus puisque nommée très clairement Asm(. Un succès absolument phénoménal en terme de productivité :
https://www.ticalc.org/pub/86/asm/

Rentrée 1998: la TI-89, sorte de version de poche de la TI-92, sort cette fois-ci avec une commande asm() intégrée, commande qui sera reprise par le modèle successeur TI-89 Titanium (2004) !
https://www.ticalc.org/pub/89/asm/
La TI-92 évolue pour sa part en TI-92 Plus, d'abord sous la forme d’un module d’extension commercialisé pour TI-92 (92+ HW1), puis à la rentrée 1999 sous la forme d’un modèle à part entière (92+ HW2), avec ici encore la commande asm() officielle, qui sera conservée sur le modèle successeur TI-Voyage 200 (2002) !
https://www.ticalc.org/pub/92p/asm/
https://www.ticalc.org/pub/v200/asm/
Le plus ancien OS 92+ est un peu antérieur au plus ancien OS 89. Il y a eu plusieurs grosses casses de compatibilité logicielle et matérielle dans cette famille de calculatrices: AMS 2.xx a cassé les programmes sales qui utilisaient directement les variables du système, puis HW2 a changé notamment le mode d'affichage et ajouté des protections d'exécution, puis HW3 (89T uniquement) a cassé encore beaucoup de choses.

Rentrée 1999, la TI-83 est remplacée par la TI-83 Plus, avec cette fois-ci une commande Asm( n'ayant pas peur de s'afficher, et qui suivra sur les modèles compatibles reprenant ou faisant évoluer la technologie de cette machine : TI-84 Plus (2004) et TI-82 Plus (2014). Mais grosse évolution, la commande en question gère maintenant 2 types différents de programmes assembleur :
  • comme sur TI-83 les programmes contenant du code source assembleur, soit des séries de codes hexadécimaux consultables et modifiables dans l'éditeur de programmes
  • les programmes contenant du code machine directement exécutable par le processeur
Le succès est d'un tout autre niveau, et est clairement indiscutable.
https://www.ticalc.org/pub/83plus/

Pour la rentrée 1998 Texas Instruments avait également sorti la TI-73, sorte de version d'entrée de gamme de la TI-83 Plus, mais ici sans aucun support du langage assembleur.

C'est corrigé maintenant en 2005 avec Michael Vincent qui sort Mallard, le premier shell TI-73, toujours installable via envoi à la calculatrice d'un fichier backup truqué. Une sortie hélas bien tardive sur un modèle d'entrée de gamme, le succès n'est pas au rendez-vous.
https://www.ticalc.org/pub/73/asm/

Décidément, nous vivions une époque dorée pour l'assembleur. :D



3) Combat pour conserver accès assembleur sur calculatrices TI (2007-2019)

Go to top

On saute à la rentrée 2007, le monde a visiblement changé entre temps, sans que l’on ait le temps de s’en rendre compte… :#roll#:
Texas Instruments lance la TI-Nspire, un modèle haut de gamme beaucoup plus puissant avec un tout nouveau processeur ARM, mais bizarrement dépourvu de tout support assembleur. Après des travaux fin 2009 sur United-TI, où la façon dont le boot2 était compressé avait été comprise, sort le 26 février 2010 Ndless, un jailbreak permettant d'exécuter des programmes assembleur. Le succès fut initialement considérable, avec plein de jeux et utilitaires encore jamais vus sur calculatrices. Hélas Texas Instruments combatit Ndless férocement et sans relâche. Sortie systématique de mises à jour cassant les méthodes d'installation utilisées, interdiction logicielle de revenir à une version précédente pour contourner les dernières limitations, et régulièrement sortie de révisions matérielles cassant de toutes façons définitivement la compatibilité avec les anciennes versions. En plus de 10 ans de Ndless à ce jour, les développeurs et utilisateurs ont déjà été privés de Ndless à plusieurs reprises suite à la sortie de certaines mises à jour ou nouvelles révisions matérielles, pendant plusieurs semaines, mois ou même années. L'intérêt pour la solution Ndless hélas intermittente s'est en conséquence effondré, le nombre de développeurs a fondu comme peau de chagrin. Aujourd'hui Texas Instruments a gagné pour l'instant, Ndless n'a pas été mis à jour pour la version 4.5.1 du 13 février 2019. Ndless est donc à ce jour inutilisable sur les TI-Nspire CX mises à jour avec les dernières versions 4.5.1 ou 4.5.2 ainsi que sur les TI-Nspire CX II forcément en version 5.0 ou supérieure.

Rentrée 2015, Texas Instruments sort la TI-82 Advanced, un modèle d'entrée de gamme avec diode examen. Il reprenait malgré son nom le matériel des TI-84 Plus, mais étrangement en en supprimant la possibilité d'installer des applications, et surtout la commande Asm(.

Pour janvier 2019, parrotgeek1 en s’appuyant sur une ébauche de Brandon Wilson finalise une méthode ici encore basée sur une envoi de fichier backup permettant d'installer des applications, et donc entre autres des shells assembleur. Sortie hélas à un moment où plus personne ne l'attendait, et qui plus est sur un modèle d'entrée de gamme, le succès n'en fut qu'extrêmement décevant.

Rentrée 2016, Texas Instruments sort la TI-84 Plus T, un modèle comparable à la TI-82 Advanced mais pour les Pays-Bas. Pas d'assembleur, et aucune ouverture à ce jour puisque le support de réception des fichiers backups en a été totalement retiré.




4) Epilogue sur TI-83 Premium CE et TI-84 Plus CE (2020)

Go to top

La TI-83 Premium CE à écran couleur et son équivalent international TI-84 Plus CE sont lancés à la rentrée 2015.

Dans un contexte pourtant apparemment défavorable, ces modèles faisaient exception en ayant conservé le support de l'assembleur, c'étaient les derniers modèles Texas Instruments à encore permettre cela.
Avec ici un bel avantage niveau accessibilité, puisqu’il a été rendu possible de compiler du code C dès 2015 (puis C++ plus tard) directement en langage machine pour cette calculatrice grâce aux formidables travaux communautaires, particulièrement de MateoConLechuga, jacobly, Runer112, Adriweb, et d'autres. Ces mêmes personnes (et d'autres dont CommandBlockGuy, DrDnar, GrosGed...) ont aussi travaillé sur des bibliothèques (libs) C utilisés par les développeurs pour aisément faire appel à des fonctionnalités communes optimisées. On ne pourra pas oublier de mentionner aussi l'émulateur (tout autant libre/open-source), CEmu, doté d'un éventail de fonctionnalités jamais vu dans le monde des calculatrices.
Ici sur TI-Planet, Adriweb a aussi consacré beaucoup de temps depuis 2015 à développer le "Project Builder", environnement de programmation (avec fonctionnalités spéciales comme la programmation collaborative en temps-réel), tout en ligne, pour développer du C et C++ ciblant les calculatrices CE, et ceci avec émulateur intégré.
Bref, le succès de la toolchain et des outils qui tournent autour fut absolument astronomique, avec des créations sans commune mesure avec ce qui avait existé jusqu’alors sur les modèles de milieu de gamme précédents.

Des créateurs de plus en plus expérimentés et jeunes ont concocté pour CE une ludothèque absolument formidable exploitant à fond les possibilités de l'écran couleur et dont nous te parlons sans relâche depuis cinq ans.

Impossible de tout citer ici, mais on peut retenir 1000 Bornes, 20000 loons under the sea, Ace Recon CE, Adaptative Parkour, Androides, Attack of the Snails, Banchor : Legend of the Hellspawn, Bejeweled CE, Billy Box, Boxman CE, Calcuzap, Catylizm CE, Cellar 3D, l’émulateur de CHIP-8 CHIP84, CMonster, Color Switch CE, Columns CE, Crystann, Desert Bus II : I am a tree, Diams, Dinorun CE, Donkey Kong CE, DStar, Electric Circuit, Escape the Buoy, Fishy CE, Flappy Bird, FlowCE, GalagACE, Geometry Dash CE et tous ses niveaux perso, le moteur de rendu 3D gLib et toutes ses démos, HailStorm CE, Headlights CE, High Definition Picture Viewer, House Paint CE, Land Loon, LogicalJoe, Loonar lander, Mahjong Solitaire, Mandragore, Minecraft 2D CE, Monkey Adventure, le moteur de jeu Mario-like Oiram CE et tous ses packs de niveaux perso, Pacman CE, Pegs CE, Pen Pineapple Apple Pen CE, PineappleCAS, Plane Jump, Portal CE et toutes ses salles de tests perso, Runner, Scarth, Scogger CE, SnailMaze, Snowball Struggle, SolitiCE, Spaze Invaders, Splat, SQRXZ, Stacker CE, Star Collector CE, Switch Operator, Tetric A, The chicken adventure, TheOregonTrail CE, This is the Only Level, l'émulateur de console de jeux Nintendo Game Boy TI-Boy CE et toutes les ROMs Nintendo Game Boy, Tower Defense CE, Wal-Rush CE, Water CE, ...

De véritables bijoux qui ont sans aucun doute contribué au succès des calculatrices TI CE en France et dans le monde, fait découvrir et s’intéresser nombre d'autres jeunes au langage C et plus généralement à la programmation... combien d’étudiants ou même ingénieurs en informatique aujourd’hui ont fait leurs premiers pas sur TI-83 Premium CE ? Ceci étant un sujet que l'on a déjà évoqué...;)

9339Mais tout n’est pas rose pour autant. La possibilité de rajouter des applications tierces sur les modèles de milieu de gamme précédents a ici été retirée. L’OS 5.3.1 du 22 février 2018 rend indisponible brutalement la commande d’exécution dédiée à l’un des deux types de programmes assembleur historiques, ceux contenant du code assembleur source visualisable (en hexadécimal) et modifiable sur calculatrice, certes rarement utilisée mais c'était déjà un très mauvais signe.



Et malheureusement, c’est ce dernier point qui vient de l’emporter. Nous ne te l’avions pas dit plus tôt, car la version 5.5.0 non finale dont nous disposons depuis quelques semaines pour nos articles de présentation n’avait pas de restriction en ce sens, elle comportait uniquement les nouveautés Python et Apps. Mais cette formidable et belle aventure de l’assembleur sur calculatrices Texas Instruments touche hélas à son terme. La gestion de l'assembleur vient d’être placée en voie d’extinction sur TI-83 Premium CE et TI-84 Plus CE, Texas Instruments ayant décidé de supprimer cette fonctionnalité à compter de la mise à jour d'OS 5.5.1. :'(

Bien évidemment, une fois l'OS 5.5.1 installé sur ta calculatrice, cette perte de fonctionnalité sera définitive; il te sera impossible de revenir à une version précédente pour récupérer cette fonctionnalité. En effet, une fois l'installation de l'OS 5.5.1 terminée, une interdiction de toute version inférieure à 5.5.1 sera inscrite dans une zone de ta mémoire Flash qu'aucun menu ne permet de réinitialiser.

Marquons un temps de silence pour la ludothèque désormais perdue de la TI-83 Premium CE, partageons ensemble une petite pensée envers toutes les œuvres sur le point de disparaître dans le néant, toutes ces innombrables heures de travail parties en fumée : :'(
532953325454589760326062626463296353656665686888690369367370738974977528755875747581769776987727775881678432845985218523854885548586863187368772877488608982898990079074908690879111960898541003710188109131125411272113991146311493115021154012520120331212712276123031230412495125121251512521




5) Mettre ou ne pas mettre à jour ? Telle est la question

Go to top

Si tu disposes d'une TI-83 Premium CE Edition Python, tu te dois donc de choisir, et le choix est douloureux :
  • passer en version 5.5.1 pour obtenir les nouvelles formidables fonctionnalités Python, mais en renonçant alors définitivement au support de l'assembleur
  • rester en version 5.4 pour conserver le support assembleur mais alors tu n'auras pas les nouveautés Python; même si installée séparément sans mise à jour de l'OS, la nouvelle application Python 5.5 refuse de démarrer sur un l'OS 5.4 précédent
Si tu disposes d'une ancienne TI-83 Premium CE le choix est moins clivant, tu n'as de toutes façons pas droit aux nouvelles fonctionnalités Python. Les seules choses remarquables pour toi sont les nouvelles applications Periodic 5.5 et SciTools 5.5, mais à la différence ces applications marcheront sur l'OS 5.4 précédent si tu les installes séparément; nous te communiquerons les fichiers à cette fin dès que possible. Donc pour les anciennes TI-83 Premium CE, tu n'as à notre sens aucun avantage nécessitant de passer à la version d'OS 5.5.1, et tu ne dois donc pas installer l'OS 5.5.1.

Bien évidemment cette forme résistance est perdante d’avance, elle ne permettra que de retarder l'échéance. Nombre d'utilisateurs mettront à jour sans commencer par venir nous lire, finiront par mettre à jour par erreur ou par nécessité scolaire dans le cas de la TI-83 Premium CE Edition Python, et pour les futurs utilisateurs de la rentrée 2020 la question ne se posera même plus, puisque les nouveaux stocks de TI-83 Premium CE Edition Python viendront bientôt préchargés avec l'OS 5.5.1.




6) Sag warum ! (dis pourquoi)

Go to top

Pourquoi donc cette cruelle régression historique des droits de l'utilisateur sur une machine qui pourtant lui appartient ? Nous estimons que tu as au moins le droit de savoir.

Déjà, la raison rejoint ce qu'il y a derrière le combat acharné de Texas Instruments contre Ndless sur TI-Nspire, et donc un changement de politique du constructeur entre 1999 et 2007. Un contexte où les institutions scolaires sont désormais de plus en plus regardantes sur ce qu'il y a dans les calculatrices aux examens, estimant qu'elles permettent trop de choses. Comme si une véritable épreuve scientifique bien conçue et inédite, c'est-à-dire nécessitant non pas de ressortir du par cœur mais de faire appel à ses esprits d'analyse et de synthèse à partir des données du problème, pouvait être gravement faussée par de bêtes informations pré-saisies en mémoire, mais bref... Avec tout cela nous en arrivons au mode examen, institutionnalisé en France en 2015, mais également depuis aux Pays-Bas ainsi qu'au Portugal. Pour la France, son but est d'effacer ou rendre inaccessible toute donnée non officielle présente en mémoire.

Sur TI-83 Premium CE en mode examen :
  • les programmes, images et variables d'application Python sont verrouillées, c'est-à-dire rendu inaccessibles via les menus
  • toutes les autres variables d'application (notamment utilisées par des programmes assembleur) sont définitivement supprimées, ce qui était déjà bien embêtant avec la nécessité de tout réinstaller après chaque utilisation du mode examen


Notre position dans nos relations avec Texas Instruments a toujours été difficile. Nous avons constamment défendu la préservation d'un maximum de droits pour l'utilisateur scolaire, en échange d'un travail bénévole de modération de la communauté de notre part. L'assembleur c'est super pour s'amuser ou découvrir, mais ce n'est pas pour frauder aux examens, sinon tout-le-monde sera puni. C’est le message que nous te déclinions régulièrement, dans l’intérêt du plus grand nombre. Nous n'avons aucune sympathie envers la fraude, comme réaffirmé officiellement récemment. C'est-à-dire que nous avions le courage de nous engager personnellement pour les intérêts d'un public tiers, sur lequel nous n'avions pourtant ni autorité ni contrôle. Le bilan de ces bientôt 9 ans est certes mitigé :
  • à compter de 2015 et donc de l'officialisation du mode examen, certes aucun outil assembleur n'est sorti avec le but d'aider à frauder aux examens
  • malgré cela nous avons quand même perdu définitivement l'assembleur sur les modèles monochromes (TI-82 Advanced)
  • malgré cela nous n'avons jamais pu obtenir la moindre avancée dans le sens des droits de l'utilisateur sur TI-Nspire
  • mais jusqu'à aujourd'hui, nous avions pu préserver l'assembleur sur TI-83 Premium CE

Hélas, Texas Instruments a malencontreusement introduit une faille à compter de la version d'OS 5.2.0 du 28 juin 2016. Si les programmes préexistants n'étaient en mode examen ni listés aux menus ni exécutables, on pouvait en fait les ouvrir dans l'éditeur en utilisant les raccourcis alphabétiques au clavier, ces derniers ayant apparemment été codés pour travailler sur la liste totale des programmes mémoire et non la seule liste des programmes visibles. On pouvait alors consulter les informations si il s'agissait d'un simple texte, ou copier-coller le code vers un nouveau programme non verrouillé si il s'agissait d'un programme exécutable.

Cette faille sera par la suite signalée au constructeur dès que nous en aurons connaissance en novembre 2017, ce dernier étant alors très réactif en sortant l'OS 5.3.1 dès le 22 février 2018, soit en cours d'année scolaire et donc bien à temps pour ce qui se devait encore d'être à l'époque la première utilisation du mode examen aux épreuves nationales en France. Bien évidemment, la mise à jour 5.3.1 t'interdisait tout retour à une version précédente.

Or l'assembleur offre un contrôle quasi-total de la machine, et via astuces, entre autres la possibilité de retirer l'interdiction des versions antérieures inscrite en mémoire Flash, permettant alors le retour à une version inférieure, et donc la réactivation de la faille en question. La connaissance de cette faille était donc problématique. Contrairement à d'autres astuces facilement parables par les surveillants que nous avons traitées dans notre flux d'actualités depuis sans les détailler et avec à chaque fois les bonnes pratiques pour les surveillants, nous avions soigneusement évité de reparler de cette faille.

Sauf qu'un élève et son enseignant ont cru malin de publier le 12 février 2020 sur une chaîne Youtube grand public une vidéo de 2 minutes tout spécialement dédiée à cette faille, présente rappelons-le exclusivement sur une version lourdement obsolète de l'OS, et non sans détailler visuellement l'intégralité de la manipulation... nous voulons bien croire qu’il n’y avait pas de mauvaise intention derrière, mais trouvons quand même cette démarche, peut-être effectuée sous le coup de l’émotion de la découverte, extrêmement maladroite. :mj:
Quand on pense de notre côté au soin méticuleux apporté dans notre flux d’actualités aux articles traitant du mode examen et des contournements circulant sur les réseaux, chaque mot étant pesé, qu'est-ce qu'on montre et jusqu'à quel point (non filmer n'est pas nécessaire sauf pour aider à la fraude, une simple photo du résultat suffit pour illustration), qu'est-ce qu'on dit à l'attention des candidats, qu'est-ce qu'on dit à l'attention des surveillants, nous ne pouvions qu'être extrêmement choqués. Balancer ça comme ça sans filtre sur une chaîne grand public, sans au minimum avoir la politesse ou le respect de prendre conseil ou informer au préalable, que ce soit auprès de nous ou du constructeur concerné...

Nous avons dans l’urgence signalé cette vidéo hautement problématique le jour-même de sa sortie, directement auprès du constructeur Texas Instruments. Malheureusement elle est resté en ligne et a fait le buzz au-delà de tout contrôle, avec presque ¼ de million de vues à ce jour. Une part très significative des candidats ont donc pu prendre connaissance du bug, du détail de la manipulation associée, et commencer à se renseigner le cas échéant sur les moyens de s’installer une ancienne version permettant de l’exploiter.

Nous n'en avons pas les détails, mais nous te laissons imaginer qu'il doit y avoir des institutionnels haut placés au sein du public touché, et que Texas Instruments a dû être fortement sollicité ces derniers mois, une position clairement inconfortable.

Sans doute que le constructeur n'avait plus d'autre choix que de donner ce genre de garantie aux institutions. Une part significative de calculatrices TI-83 Premium CE / TI-84 Plus CE en circulation seront donc bientôt verrouillées, et cette proportion ne fera qu'augmenter avec le temps. Avec les stocks neufs qui seront vendus dès la rentrée 2020 déjà préchargés avec la version verrouillée et bien sûr avec interdiction d’installer une version plus ancienne, la majorité devrait être atteinte chez les utilisateurs actifs assez rapidement, une affaire plutôt de mois que d’années, probablement d’ici la rentrée de septembre 2021 au plus tard.

Nous avons donc hélas échoué, le dernier modèle encore officiellement ouvert au développement assembleur chez Texas Instruments ne le sera bientôt plus. La faute impardonnable est finalement venue de quelqu'un ne faisant pas partie du public dont nous étions censés modérer les mauvaises ardeurs.

Mais c'est toutefois bien la communauté et nous-mêmes qui allons en subir les dramatiques conséquences. Finies les parties d'Oiram CE, de Pokémon via l'émulateur GameBoy ou autres programmes au lycée qui rendaient jaloux d'envie tes potes sur Casio ou NumWorks... Fini la possibilité de dumper l'OS de ta calculatrice pour l'utiliser sur l'émulateur communautaire CEmu... C'est environ 25 ans d'assembleur et d'aventures vidéoludiques sur calculatrices Texas Instruments qui se terminent brutalement.




7) The End :'( (la fin)

Go to top

Nous arrivons à comprendre la décision, mais nous en déplorons par ailleurs le calendrier. En pleine crise sanitaire alors qu'Oiram CE a bénéficié d'un succès phénoménal en ces temps de confinement. La TI-83 Premium CE a ainsi incité à rester chez soi et a certainement contribué à sauver des vies, alors que le virus est encore très loin d'avoir été vaincu, et que le confinement est à ce jour en France levé sans réouverture des lycées. Peut-être le pire moment pour faire passer ça...

C'est un anéantissement, nous sommes écœurés au plus haut point; à cause d'une bêtise, une part massive des fichiers les plus populaires que nous hébergions et servions bénévolement, et qui n'ont rien à avoir avec une quelconque fraude, seront bientôt inutilisables. Des années de travail formidable dépassant en profondeur tout ce qui avait jamais été atteint sur les plateformes précédentes, bientôt bonnes pour la corbeille. Merci donc particulièrement aux deux responsables de cette destruction massive au retentissement mondial, et merci aussi à ceux qui réglementent les examens...

Aux performances graphiques constatées, le Python n'est absolument pas mûr à ce jour pour permettre un quelconque remplacement des jeux à la hauteur de tout ce qui disparaît, et ne le sera jamais sur les TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition actuellement existantes. Le Python ainsi qu'interprété sur ces machines par CircuitPython est bien trop lent, surtout avec l'architecture processeur-coprocesseur utilisée là par TI.

Le fun sous la forme où nous l'avons connu est désormais officiellement terminé, et la communauté TI ne sera plus jamais la même... Acen, Adriweb, Alric, Anonyme0, BasicTH, Botboy3000, BrandonW, calc84maniac, calclover2514, CalcMeister, _Candyman_, ckosmic, Colisalalia, CommandBlockGuy, critor, Dabmaster_Arush, Darth Vader, DJ Omnimaga, DrDnar, Epharius, epsilon5, Flalamèche, Flip, GalacticPirate, GrosGed, gst the darkstyle, Iambian, _iPhoenix_, jacobly, James Vernon, jonbush, JWinslow23, Kerm Martian, Kosmic, MateoConLechuga, MMBC_Chris, Monogon, neuronix, ohernandez, OldNewTimer, Ooggle, Parziter, Patrick Davidson (dont la TI-85 reste la préférée, on le sait), Pieman7373, PocketArt, Poulpogaz, Programmator88, PT_, puppy65, Raiseit, Rico, Runer112, Sam, slimeenergy, Spenceboy98, squishy, TheLastMillennial, TheMachine02, TheMustardCat, Ti64CLi++, tifreak8x, tr1p1ea, UnCurieux, Unicorn, xMarmingq_ et bien d'autres... vous tous trop nombreux pour être listés ici qui avez su graver vos (sur)noms dans nos cœurs ces dernières années et apporter de la joie sur la planète entière, ainsi que tous ceux qui ont contribué à cette formidable aventure de l’assembleur sur calculatrices Texas Instruments depuis 1994, merci, nous ne vous oublierons jamais. :'(

Références :

-
Search
-
Social TI-Planet
-
Featured topics
Comparaisons des meilleurs prix pour acheter sa calculatrice !
"1 calculatrice pour tous", le programme solidaire de Texas Instruments. Reçois gratuitement et sans aucune obligation d'achat, 5 calculatrices couleur programmables en Python à donner aux élèves les plus nécessiteux de ton lycée. Tu peux recevoir au choix 5 TI-82 Advanced Edition Python ou bien 5 TI-83 Premium CE Edition Python.
Enseignant(e), reçois gratuitement 1 exemplaire de test de la TI-82 Advanced Edition Python. À demander d'ici le 31 décembre 2024.
Aidez la communauté à documenter les révisions matérielles en listant vos calculatrices graphiques !
1234
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...
Donate
Discover the the advantages of a donor account !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partner and ad
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
703 utilisateurs:
>629 invités
>66 membres
>8 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)
-
Other interesting websites
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)