π
<-
Chat plein-écran
[^]

Test TI-83 Premium CE Edition Python (proto. DVT), Orme 2019

:32ti73: :32ti73e: :32ti73e2: :32ti76f: :32ti80: :32ti81: :32ti82: :32ti85: :32ti86: :32ti82s: :32ti82sf: :32ti82sfn: :32ti83: :32ti83p: :32ti83pb: :32ti83pr: :32ti83pfr: :32ti83pse: :32ti84p: :32ti84pse: :32ti84ppse: :32ti84pfr: :32ti84pcse: :32ti83pfrusb: :32ti82p: :32ti82a: :32ti84pce: :32ti83pce:

Quel matériel pour la nouvelle TI-83 Premium CE Edition Python ?

carte du module externe TI-Python incluse dans le boîtier et connectée à la carte mère
1
8%
2 puces ASIC : la 2ème pour le Python (processeur ARM 32 bits + Flash pour le firmware) directement soudée sur la carte mère
5
38%
1 puce ASIC avec 2 processeurs : l'eZ80 8 bits historique et un processeur ARM 32 bits pour le Python
2
15%
1 puce Flash intégrant non seulement les images eZ80 historiques (boot, OS, apps...) mais aussi le firmware Python
1
8%
migration de la puce Flash externe vers une Flash interne à la puce ASIC
2
15%
1 puce ASIC avec 1 processeur : ARM 32 bits et une couche d'émulation eZ80
2
15%
 
Nombre total de votes : 13

Test TI-83 Premium CE Edition Python (proto. DVT), Orme 2019

Message non lude critor » 08 Mai 2019, 13:56

11131Ce jeudi 25 avril, nous étions à Marseille pour les rencontres de l'Orme 2019. Elles se déroulaient cette année dans le cadre exceptionnel du Palais du Pharo.

Le formidable panorama visible du site s'étendant du Nord-Ouest à l'Est nous présentait entre autres la digue du Large, le phare de Sainte-Marie/Joliette, le MuCEM, la cathédrale de Sainte-Marie-Majeure, la tour du fanal, le fort Saint-Jean, la tour du Roi René, le Vieux-Port et le fort Ganteaume.
1114811147111291112811130


1121611218Quelle aubaine pour les stands qui étaient situés dans la galerie orientale, comme celui de Casio. L'équipe y présentait ses gammes de vidéoprojecteurs et de calculatrices, insistant dans ce dernier cas sur ses modèles programmables : les fx-92+ Spéciale Collège (à la Scratch), Graph 90+E (Python) et Graph 35+E II (Python). Toutefois la Graph 35+E II présente sur le stand était munie de la version système 3.00 que nous t'avons déjà testée et n'incluait donc pas encore l'application Python. Donc rien de plus à ajouter pour le moment. Rappelons que la mise à jour 3.10 gratuite permettant de rajouter cette application devrait sortir le Mercredi 22 Mai.

11231Et merci pour les nouveaux goodies qui nous permettront de te gâter, dont un sac Casio grand format ainsi qu'une balle anti-stress Casio en forme de globe terrestre. :D



112111120911210Rendons-nous maintenant sur le stand de Texas Instruments.

L'équipe y mettait en avant ses journées d'été TI-Python, et distribuait une sélection d'extraits du nouveau livret d'activités pour les TI-83 Premium CE à la rentrée 2019, Algorithme et programmation en Python, Maths 2nde par Jean-Baptiste Civet et Boris Hanuš, points que nous avons déjà abordés.

11232Merci donc en passant pour les goodies qui nous permettront de te gâter bientôt, dont outre cette sélection d'extraits un nouveau porte-documents Texas Instruments.

Les activités proposées sur le stand tournaient autour du robot TI-Innovator Rover piloté par une TI-83 Premium CE. Au menu tracer de polygones et park assist, qui ont pas mal intéressé les classes de primaire ayant fait le déplacement :


11229Bon, passons maintenant aux calculatrices présentes sur le stand. Il y avait une TI-Nspire CX II-T CAS, munie de la même version 5.0.0.1509 non finale étant venue d'origine avec nos échantillons, ainsi qu'une TI-82 Advanced sans rien de nouveau non plus.

Les enseignants visitant le stand était pour leur part bien davantage intéressés par les possibilités de programmation en Python et donc par les TI-83 Premium CE, aussi explorons maintenant ce point.

Rappelons que les actuels possesseurs de TI-83 Premium CE peuvent rajouter la possibilité d'exécuter des scripts Python en faisant l'acquisition d'un module externe TI-Python.
Ce module externe est basé matériellement sur une pyboard (carte de développement Python) Adafruit Trinket M0 munie d'un processeur 32-bits Cortex/ARMv7 @48MHz cette fois-ci correctement dimensionné, et logiciellement sur l'implémentation CircuitPython qui va avec.

Mais pour la rentrée 2019, Texas Instruments sort un nouvelle TI-83 Premium CE Edition Python qui à la différence sera nativement capable d'exécuter des scripts Python, sans aucun besoin de module externe donc.
Une belle énigme matérielle. Qu'est-ce qui va faire que cette fois-ci ce sera possible ? Ils ont juste mis la même pyboard dans le boîtier, ou bien sont-ils allés plus loin dans l'intégration ?

Nous espérions trouver un début de réponse aujourd'hui.


A priori nous ne voyons malheureusement que des TI-83 Premium CE qui ont l'air normales.

Il y en avait toutefois une belle collection avec de quoi tester quelques combinaisons intéressantes, puisque plusieurs d'entre elles étaient munies de versions non finales :
  • OS 5.3.5.10 + appli PyAdaptr 5.3.5.10 avec le firmware TI-Python 3.0.0.15
  • OS 5.3.5.17 + appli PyAdaptr 5.3.5.17 avec le firmware TI-Python 3.0.0.20
11227112201122811221


Nous avons pu constater que l'application PyAdaptr reprogrammait systématiquement le firmware du module externe TI-Python si il différait de la version qu'elle intégrait, et ce sans tenir compte du fait que cette version soit plus récente ou plus ancienne. Une protection conçue pour interdire l'utilisation de firmwares tiers, et heureusement déjouée depuis.



1116011161Et puis, parmi toutes les TI-83 Premium CE du stand, nous finissons par tomber sur la nouvelle la nouvelle TI-83 Premium CE Edition Python qui tentait de se cacher dans la masse, la coquine. ;) Elle n'est clairement pas finale puisque continuant à utiliser le boîtier actuel. De face on dirait en effet une TI-83 Premium CE normale, mais au dos on trouve un sticker TI-83 Premium CE Edition Python. A l'emplacement du numéro de série nous notons :
L-DVT-000146
DVT NOT FOR SALE

Il s'agit donc d'un prototype de niveau DVT, ici assemblé dans la même usine de code L qui assemble les TI-83 Premium CE et TI-84 Plus CE depuis leur sortie en 2015, Kinpo Electronics aux Philippines. Visiblement, on peut estimer le nombre de ces prototypes TI-83 Premium CE Edition Python DVT actuellement entre les mains de Texas Instruments et des différents partenaires contribuant à la conception à plusieurs centaines.
Rappelons les différents niveaux de prototypage par lesquels passe un nouveau produit chez TI :
  1. PROTO (Prototype)
  2. EVT (Engineering Validation Tests)
  3. DVT (Design Validation Tests)
  4. PVT (Production Validation Tests)
  5. MP (Mass Production)
Habituellement chez TI, les prototypes DVT ont un matériel et un logiciel déjà très proches de ceux du modèle de production, les quelques différences visibles pouvant encore concerner le boîtier.

Maintenant que nous avons malgré tout trouvé ce qu'il nous fallait, c'est donc parti pour le test ! :D



Sommaire :Go to top




1) Versions système, boot et diagnostic :

Go to top

11158Ce prototype TI-83 Premium CE Edition Python DVT est doté de la future version système 5.3.6. Plus précisément, son écran A propos nous apprend :
  • que logiciellement, le nom de modèle est toujours TI-83 Premium CE
  • que le numéro de version complet du système est 5.3.6.0009; il s'agit donc seulement de la 9ème recompilation de la version 5.3.6
  • que l'identifiant du modèle est toujours 13 (en hexadécimal), ce qui suggère donc une compatibilité avec les anciennes TI-83 Premium CE

Effectivement, nous arrivons à y exécuter des applications et programmes assembleur conçus pour les anciennes TI-83 Premium CE.

1120611159Accédons à l'écran de lancement du menu de diagnostic, avec la combinaison secrète
mode
alpha
S
. Et la surprise, nous apprenons l'utilisation d'un tout nouveau boot code, ce qui suggère habituellement des changements matériels ou sécuritaires majeurs. Notons de plus que son développement semble être fortement lié aux nouvelles fonctionnalités du système, puisqu'il porte le même numéro de version : 5.3.6.0009.

Si nous lançons maintenant le menu de diagnostic, l'écran d'information qu'il commence par afficher comporte quelques ajouts notables :
  • une mention Python en bleu en haut à droite, sans doute non affichée si l'on transfère l'OS 5.3.6 sur un ancien modèle
  • une mention POB: 3.00, peut-être pour Python On Board. La pyboard intégrée d'une façon ou d'une autre, ferait donc tourner un firmware en version 3.00, comparable donc aux firmwares pour le module externe TI-Python.

1120811207Ce n'est pas tout car avant d'arriver au menu, nous nous voyons présenter un écran supplémentaire, traitant apparemment de la protection contre l'écriture des secteurs de la mémoire Flash. Peut-être est-ce significatif de changements autour de la mémoire Flash, ou peut-être est-ce juste spécifique à ce prototype dont la mémoire Flash n'est peut-être pas autant verrouillée que cette d'un modèle de production, afin notamment de pouvoir reprogrammer le boot code qui semble évoluer parallèlement au système.




2) Performances générales :

Go to top

11204Ce qui se dégage au premier abord par rapport aux anciennes TI-83 Premium CE, c'est une inhabituelle impression de puissance. Tentons de vérifier cela en traduisant le script Python suivant dans le langage interprété historique des TI-83 Premium CE et modèles concurrents.

Nous notons en passant que la touche
prgm
adopte enfin un comportement que nous avions suggéré il y a quelques années pour les seules TI-83 Premium CE françaises (et donc pas les TI-84 Plus CE internationales). Au lieu d'accéder directement à la liste des programmes TI-Basic, l'utilisateur doit désormais dabord préciser le langage qu'il souhaite utiliser, TI-Basic ou Python, ce qui dans ce dernier cas lance l'application Python associée.

Code: Tout sélectionner
try:
  from time import *
except:
  pass

def hastime():
  try:
    monotonic()
    return True
  except:
    return False

def seuil(d):
  timed,n=hastime(),0
  start,u=0 or timed and monotonic(),2.
  d=d**2
  while (u-1)**2>=d:
    u=1+1/((1-u)*(n+1))
    n=n+1
  return [(timed and monotonic() or 1)-start,n,u]


11205Effectivement c'est extraordinaire, l'appel seuil(0.02) s'exécute en seulement 16,24s sur la nouvelle TI-83 Premium CE Edition Python, contre 31,27s sur les anciennes TI-83 Premium CE ! :o

Voici le classement parmi les calculatrices graphiques ou programmables conformes 2020 :
  1. 0,0625s : HP Prime G2 (32 bits : Cortex/ARMv7 @528MHz)
  2. 0,127s : NumWorks (32 bits : Cortex/ARMv7 @100MHz)
  3. 0,371s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
  4. 1,45s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
  5. 1,64s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz)
  6. 2,89s : TI-Nspire CX révisions W+/CR4+ (ARM9/ARMv5 @156MHz)
  7. 3,02s : TI-Nspire CX révisions A-V (ARM9/ARMv5 @132MHz)
  8. 7,92s : Casio Graph 90+E (32 bits : SH4 @118MHz)
  9. 13,36s : Casio Graph 35+E II (32 bits : SH4 @59MHz)
  10. 15,98s : Casio Graph 35/75+E (32 bits : SH4 @29,5MHz)
  11. 16,24s : TI-83 Premium CE Edition Python : ?
  12. 18,89s : Casio Graph 25+E : (32 bits : SH4 @29,5MHz)
  13. 31.27s : TI-83 Premium CE / TI-84 Plus CE-T (8 bits : eZ80 @48MHz)
  14. 41.71s : TI-82 Advanced / TI-84 Plus T (8 bits : z80 @15MHz)
  15. 97,72s : Casio fx-CP400+E : (32 bits : SH4 @118MHz)
  16. 107.29s : Casio fx-92+ Spéciale Collège (8 bits : nX-U8/100 >1,5MHz - spécifications ancien modèle fx-92 Collège 2D+, non confirmées sur le nouveau)
  17. >292s : Lexibook GC3000FR (non programmable, estimation la plus favorable relativement aux performances en tracer de graphes des autres modèles monochromes d'entrée de gamme et de leur largeur en pixels de zone graphique)

Des performances de calcul apparemment multipliées par deux pour la nouvelle TI-83 Premium CE Edition Python, ce n'est pas rien, ce qui permet enfin de combler en grande partie le défaut de performances qu'il y avait par rapport aux Casio Graph monochromes ! :bj:


Sur le stand l'équipe Texas Instruments nous a dit que cette amélioration des performances venait de l'utilisation d'un nouveau processeur. Sauf que le processeur eZ80 des anciennes TI-83 Premium CE est censé tourner à 48MHz, et un doublement de la fréquence n'est pas envisageable puisque le maximum parmi les processeurs eZ80 commercialisés est de 50MHz. A moins que Texas Instruments ait fait de l'overclocking mais nous en doutons fortement, ce n'est pas trop le genre de la maison...

Mais qu'est-ce que Texas Instruments a donc bien pu fabriquer pour obtenir un tel résultat ?... ;)




3) Applications Python et PyAdaptr :

Go to top

1115111150Sur la nouvelle TI-83 Premium CE Edition Python l'application qui permet d'accéder aux fonctionnalités Python ne s'appelle plus PyAdaptr, mais justement Python. Elle aussi en version 5.3.6.0009, elle ne précise plus de version firmware pour une éventuelle pyboard intégrée.

Toutefois, avec une taille toujours aussi énorme de 329,125Ko, il semble clair que comme PyAdaptr, la nouvelle application Python continue à embarquer un firmware pour une pyboard qui serait donc intégrée quelque part.

1116311162Puisque nous avons largement de quoi faire quelques échanges sur le stand, nous remarquons que la nouvelle application Python refuse de démarrer sur les anciennes TI-83 Premium CE en version 5.3.5.

Et inversement, l'ancienne application PyAdaptr refuse également de démarrer sur la nouvelle TI-83 Premium CE Edition Python.




4) Ensembles de nombres :

Go to top

Commençons par tester les nombres flottants qui, rappelons-le, sont représentés en mémoire sous la forme
$mathjax$\pm M\times 2^{E-E_{min}}$mathjax$
avec
$mathjax$M\in [1;2[$mathjax$
. Prenons la fonction Python suivante :
Code: Tout sélectionner
def precm(b):
  k,b=0,float(b)
  while 1+b**-k-1>0:
    k+=1
  return k

11156L'appel precm(2) nous apprend que la mantisse M des nombres flottants peut avoir jusqu'à 53 bits, et l'appel precm(10) nous précise que cela correspond en base décimale à environ 16 chiffres significatifs.

Continuons à creuser les flottants avec la fonction Python suivante :
Code: Tout sélectionner
def prece():
  a=-1
  while 2.**a>0:
    a*=2
  while 2.**a==0:
    a+=1
  b=1
  while str(2.**b)[0:3]!='inf':
    b*=2
  while str(2.**b)[0:3]=='inf':
    b-=1
  return [a,b]

L'appel prece() nous indique que les bits restants permettent à l'exposant des nombres flottants de prendre des valeurs allant de -1074 à +1023.

11154Passons maintenant aux nombres entiers. Avec sys.maxsize==2**31-1, les nombres entiers représentables nativement dans le contexte matériel de la machine sont donc codés sur 32 bits, dont 1 bit de signe. Comme il est de plus apparemment possible de dépasser sys.maxsize, le support des entiers longs a donc été activité.

Jusqu'à présent c'est le minimum attendu pour toute implémentation qui se veut sérieuse dans un contexte scientifique, et c'est le cas à ce jour de toutes les solutions concurrentes sur calculatrice. :bj:

11153Les nombres complexes quant à eux ne sont visiblement pas gérés puisque l'évaluation de 1j renvoie une erreur.

MicroPython
TI-Nspire
NumWorks
Casio
Graph 35+E II
Graph 90+E
CasioPython
Graph 35+E II
Graph 35+E/USB
Graph 75/85/95
TI-83 Premium CE Edition Python
TI-83 Premium CE + TI-Python
firmware tiers
TI-Python /
TI-83 Premium CE
nombres complexes
module cmath
(fonctions complexes)


D'où le classement suivant pour les seuls nombres complexes :
  1. NumWorks + Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII (application CasioPython) + TI-Nspire (application MicroPython) + module externe TI-Python pour TI-83 Premium CE (firmware tiers) avec nombres et fonctions complexes
  2. Casio Graph 35+E II / 90+E / fx-CG50 avec nombres complexes
  3. TI-83 Premium CE Edition Python + module externe TI-Python pour TI-83 Premium CE

Contrairement à l'ensemble de la concurrence, l'absence totale de gestion des nombres complexes est fort regrettable pour les élèves de Terminale S/STI2D/STL.

On peut certes objecter que peu d'entre eux devraient utiliser le Python pour l'algorithmique au BAC 2019, puisque ce n'est qu'à la rentrée 2017 que ce langage est devenu obligatoire en Seconde.

Toutefois cet argument n'est plus recevable pour le BAC 2020, et il est donc fort dommage que la TI-83 Premium CE Edition Python ne soit apparemment pas prête.




5) Liste modules Python :

Go to top

11152Nous venons donc de voir que la nouvelle TI-83 Premium CE Edition Python ne disposait pas du module cmath. En fait l'appel help("modules") nous liste exactement la même chose qu'avec le module externe TI-Python pour les anciennes TI-83 Premium CE; l'implémentation semble donc a priori ne pas avoir été améliorée entre temps :
  • collections
  • random
  • array
  • gc
  • sys
  • builtins
  • math
  • time

MicroPython
TI-Nspire
NumWorks
Casio
Graph 35+E II
Graph 90+E
CasioPython
Graph 35+E II
Graph 35+E/USB
Graph 75/85/95
TI-83 Premium CE Edition Python
TI-Python / TI-83 Premium CE
firmware tiers
TI-Python /
TI-83 Premium CE
builtins
array
collections
cmath
gc
math
micropython
os
random
sys
time
turtle


 




 
 

 
 

 
 

 


 

 


 
 
 
 

 
 

 
 
 


 




 


 
 



 


 




 











 
spécifiquenspkandinskyboard
storage
Total8838813


D'où le classement suivant en terme d'éventail de modules :
  1. 13 modules : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
  2. 8 modules : TI-83 Premium CE Edition Python + NumWorks + Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII + TI-Nspire (application MicroPython) + module externe TI-Python pour TI-83 Premium CE
  3. 3 modules : Casio Graph 35+E II / 90+E / fx-CG50

L'absence d'un module graphique se fait de plus en plus pesante.

Que cela n'ait pas été fait pour le module externe TI-Python peut se comprendre si le but était juste de dépanner temporairement les candidats aux examens 2019 et 2020.

Que cela n'ait toujours pas été fait pour le modèle accompagnant les nouveaux programmes de rentrée 2019 est plus regrettable. Notamment le nouveau programme de Physique-Chimie en Seconde, où les enseignants devront donc promouvoir et peut-être durablement adopter des alternatives à la TI-83 Premium CE Edition Python.




6) Exploration module sys :

Go to top

Puisque nous avons la chance de disposer du module sys, explorons-le à la recherche d'informations sur l'implémentation Python. Pour cela, utilisons le script Python suivant :
Code: Tout sélectionner
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):
  s=str(obj)
  return s.startswith("<module '") or s.startswith("<class '")

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c=0
  for itms in sorted(dir(pitm)):
    c=c+1
    try:
      itm=eval(spath+"."+itms)
      print(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      print(hd+itms)
  if c>0:
    print(hd+"Total: "+str(c)+" item(s)")
  return c

1117011169Voici la sortie de l'appel explmod(sys) :
Code: Tout sélectionner
>>> # Shell Reinitialized
>>> from explmod import *
>>> import sys
>>> explmod(sys)
__name__=sys
argv=[]
byteorder=little
exit=<function>
implementation=(name='tipython', version=(3, 0, 0))
maxsize=2147483647
modules={'EXPLMOD': <module 'EXPLMOD' from 'EXPLMOD.py'}
path=['', '/', '/lib', '.frozen']
platform=TI-Python
print_exception=<function>
stderr=<io.FileIO 2>
stdin=<io.FileIO 0>
stdout=<io.FileIO 1>
version=3.4.0
version_info=(3, 4, 0)
Total: 15 item(s)
15
>>>


Confontons cela aux modèles concurrents disposant du module sys :


MicroPython
TI-Nspire
CasioPython
Graph 35+E II
Graph 35+E/USB
Graph 75/85/95
TI-Python /
TI-83 Premium CE
TI-83 Premium CE
Edition Python
firmware tiers
TI-Python /
TI-83 Premium CE
__name__
argv[]
byteorder
exc_info()
exit()
getsizeof()
'sys'

'little'


 
'sys'

'big'
 

'sys'

'little'
 

 
'sys'

'little'
 

 
'sys'

'little'
 

 
implementation.name='micropython'
.version=(1,4,6)
.name='micropython'
.version=(1,9,4)
.name='circuitpython'
.version=(3,0,0)
.name='tipython'
.version=(3,0,0)
.name='circuitpython'
.version=(4,0,0)
maxsize
modules
path
platform
print_exception()
stderr
stdin
stdout
version
version_info
Total
2147483647
 

'nspire'

<io.TextIOWrapper 2>
<io.TextIOWrapper 0>
<io.TextIOWrapper 1>
'3.4.0'
(3,4,0)
15
2147483647


 

 
 
 
'3.4.0'
(3,4,0)
12
2147483647


'TI-Python Adapter'

<io.FileIO 2>
<io.FileIO 0>
<io.FileIO 1>
'3.4.0'
(3,4,0)
15
2147483647


'TI-Python'

<io.FileIO 2>
<io.FileIO 0>
<io.FileIO 1>
'3.4.0'
(3,4,0)
15
2147483647


'TI-Python Adapter'

<io.FileIO 2>
<io.FileIO 0>
<io.FileIO 1>
'3.4.0'
(3,4,0)
15




Comparons particulièrement avec l'implémentation du module externe TI-Python pour les anciennes TI-83 Premium CE, puisque nous avons vu que celle de la nouvelle TI-83 Premium CE Edition Python semblait être basée dessus. Nous notons deux changements :
  • platform=='TI-Python' au lieu de platform=='TI-Python Adapter', point important à préciser pour les scripts Python proposant des interfaces et se voulant multi-plateformes, le comportement de la console Python variant d'un modèle à un autre
  • implementation.name=='tipython' au lieu de implementation.name=='circuitpython'

Ce dernier changement est surprenant. Cela voudrait-il dire que l'implémentation Python n'est plus basée sur le CircuitPython de l'Adafruit Trinket M0 ? Ou que Texas Instruments y a apporté des changements tellement importants que l'implémentation ne peut plus être considérée comme étant encore du CircuitPython ?

Nous n'avons certes pas encore fouillé le code machine, mais vu comme l'implémentation Python de la nouvelle TI-83 Premium CE Edition Python semble calquée sur celle du module externe TI-Python pour les anciennes TI-83 Premium CE nous doutons fortement que CircuitPython n'ait plus rien à voir dans l'histoire.

Même si cet usage est a priori légal sous la licence MIT de CircuitPython, il nous semblerait moralement très discutable de supprimer ainsi a posteriori la seule référence visible au projet autour duquel lequel Texas Instruments a construit, et donc à la communauté de développement Adafruit/CircuitPython ayant fourni (gratuitement) l'essentiel du code côté Python. Cela s'ajoute au fait que, bien qu'ayant réutilisé une implémentation Python au code libre, le code de l'implémentation modifiée/améliorée par Texas Instruments dans le contexte de l'utilisation sur TI-83 Premium CE ne soit ni libre ni même ouvert. En effet, cela signifie qu'après avoir profité de la communauté de développement CircuitPython/Adafruit, le constructeur ne contribuerait donc rien en retour. :mj:




7) Exploration module builtins :

Go to top

Munis du même script ci-dessus, explorons maintenant le module builtins.

Nous obtenons la sortie suivante :
Code: Tout sélectionner
>>> # Shell Reinitialized
>>> from explmod import *
>>> import builtins
>>> explmod(builtins)
ArithmeticError=<class 'ArithmeticError'>
AssertionError=<class 'AssertionError'>
AttributeError=<class 'AttributeError'>
BaseException=<class 'BaseException'>
.__init__=<function>
.Total: 1 item(s)
EOFError=<class 'EOFError'>
Ellipsis=Ellipsis
Exception=<class 'Exception'>
GeneratorExit=<class 'GeneratorExit'>
ImportError=<class 'ImportError'>
IndentationError=<class 'IndentationError'>
IndexError=<class 'IndexError'>
KeyError=<class 'KeyError'>
KeyboardInterrupt=<class 'KeyboardInterrupt'>
LookupError=<class 'LookupError'>
MemoryError=<class 'MemoryError'>
NameError=<class 'NameError'>
NotImplementedError=<class 'NotImplementedError'>
OSError=<class 'OSError'>
OverflowError=<class 'OverflowError'>
ReloadException=<class 'ReloadException'>
RuntimeError=<class 'RuntimeError'>
StopIteration=<class 'StopIteration'>
SyntaxError=<class 'SyntaxError'>
SystemExit=<class 'SystemExit'>
TypeError=<class 'TypeError'>
UnicodeError=<class 'UnicodeError'>
ValueError=<class 'ValueError'>
ZeroDivisionError=<class 'ZeroDivisionError'>
__build_class__=<function>
__import__=<function>
__name__=builtins
__repl_print__=<function>
abs=<function>
all=<function>
any=<function>
bin=<function>
bool=<class 'bool'>
bytearray=<class 'bytearray'>
.append=<function>
.extend=<function>
.Total: 2 item(s)
bytes=<class 'bytes'>
.count=<function>
.endswith=<function>
.find=<function>
.format=<function>
.index=<function>
.isalpha=<function>
.isdigit=<function>
.islower=<function>
.isspace=<function>
.isupper=<function>
.join=<function>
.lower=<function>
.lstrip=<function>
.replace=<function>
.rfind=<function>
.rindex=<function>
.rsplit=<function>
.rstrip=<function>
.split=<function>
.startswith=<function>
.strip=<function>
.upper=<function>
.Total: 22 item(s)
callable=<function>
chr=<function>
classmethod=<class 'classmethod'>
dict=<class 'dict'>
.__delitem__=<function>
.__getitem__=<function>
.__setitem__=<function>
.clear=<function>
.copy=<function>
.fromkeys=<bound_method>
.get=<function>
.items=<function>
.keys=<function>
.pop=<function>
.popitem=<function>
.setdefault=<function>
.update=<function>
.values=<function>
.Total: 14 item(s)
dir=<function>
divmod=<function>
enumerate=<class 'enumerate'>
eval=<function>
exec=<function>
filter=<class 'filter'>
float=<class 'float'>
get=<function>
getattr=<function>
globals=<function>
hasattr=<function>
hash=<function>
help=<function>
help=<function>
hex=<function>
id=<function>
input=<function>
input=<function>
int=<class 'int'>
.from_bytes=<bound_method>
.to_bytes=<function>
.Total: 2 item(s)
isinstance=<function>
issubclass=<function>
iter=<function>
len=<function>
list=<class 'list'>
.append=<function>
.clear=<function>
.copy=<function>
.count=<function>
.extend=<function>
.index=<function>
.insert=<function>
.pop=<function>
.remove=<function>
.reverse=<function>
.sort=<function>
.Total: 11 item(s)
locals=<function>
map=<class 'map'>
max=<function>
memoryview=<class 'memoryview'>
min=<function>
next=<function>
object=<class 'object'>
oct=<function>
open=<function>
ord=<function>
pow=<function>
print=<function>
property=<class 'property'>
.deleter=<function>
.getter=<function>
.setter=<function>
.Total: 3 item(s)
range=<class 'range'>
repr=<function>
round=<function>
send=<function>
set=<class 'set'>
.__contains__=<function>
.add=<function>
.clear=<function>
.copy=<function>
.difference=<function>
.difference_update=<function>
.discard=<function>
.intersection=<function>
.intersection_update=<function>
.isdisjoint=<function>
.issubset=<function>
.issuperset=<function>
.pop=<function>
.remove=<function>
.symmetric_difference=<function>
.symmetric_difference_update=<function>
.union=<function>
.update=<function>
.Total: 18 item(s)
setattr=<function>
slice=<class 'slice'>
sorted=<function>
staticmethod=<class 'staticmethod'>
str=<class 'str'>
.count=<function>
.endswith=<function>
.find=<function>
.format=<function>
.index=<function>
.isalpha=<function>
.isdigit=<function>
.islower=<function>
.isspace=<function>
.isupper=<function>
.join=<function>
.lower=<function>
.lstrip=<function>
.replace=<function>
.rfind=<function>
.rindex=<function>
.rsplit=<function>
.rstrip=<function>
.split=<function>
.startswith=<function>
.strip=<function>
.upper=<function>
.Total: 22 item(s)
sum=<function>
super=<class 'super'>
tuple=<class 'tuple'>
.count=<function>
.index=<function>
.Total: 2 item(s)
type=<class 'type'>
zip=<class 'zip'>
Total: 192 item(s)
192
>>>


111981119111186Grosse suprise, contrairement à l'implémentation du module externe TI-Python pour les anciennes TI-83 Premium CE, le module builtins n'a pas 190 mais 192 éléments ici sur la nouvelle TI-83 Premium CE Edition Python.

Il y a donc eu deux ajouts, faisons une petite comparaison afin de déterminer de quoi il s'agit :

MicroPython
TI-Nspire
NumWorks
Casio
Graph 35+E II
Graph 90+E
CasioPython
Graph 35+E II
Graph 35+E/USB
Graph 75/85/95
TI-Python /
TI-83 Premium CE
TI-83 Premium CE
Edition Python
firmware tiers
TI-Python /
TI-83 Premium CE
ArithmeticError<>
AssertionError<>
AttributeError<>
BaseException<>
EOFError<>
Ellipsis=Ellipsis
Exception<>
GeneratorExit<>
ImportError<>
IndentationError<>
IndexError<>
KeyError<>
KeyboardInterrupt<>
LookupError<>
MemoryError<>
NameError<>
NotImplemented
NotImplementedError<>
OSError<>
OverflowError<>
ReloadException<>
RuntimeError<>
StopIteration<>
SyntaxError<>
SystemExit<>
TypeError<>
UnicodeError<>
ValueError<>
ViperTypeError<>
ZeroDivisionError<>
__build_class__()
__import__()
__name__
__repl_print__()
abs()
all()
any()
bin()
bool<>
bytearray<>
bytes<>
callable()
chr()
classmethod<>
compile()
complex<>
dict<>
dir()
divmod()
enumerate<>
eval()
exec()
filter<>
float<>
frozenset<>
get()
getattr()
globals()
hasattr()
hash()
help()
help()
hex()
id()
input()
input()
int<>
isinstance()
issubclass()
iter()
len()
list<11>
locals()
map<>
max()
memoryview<>
min()
next()
object<>
oct()
open()
ord()
pow()
print()
property<>
range<>
repr()
reversed<>
round()
send()
set<>
setattr()
slice<>
sorted()
staticmethod<>
str<>
sum()
super<>
tuple<>
type<>
zip<>
Total
0
0
0
1
0
'Ellipsis'
0
0
0
0
0
0
0
0
0
0
'NotImplemented'
0
0
0

0
0
0
0
0
0
0
0
0








0
2
26


0

0
14


0


0
0
18











2




11

0

0


2





3
0

0


18



0
26

0
2
0
0
218
0
0
0
0
0
'Ellipsis'
0
0
0
0
0
0
0
0
0
0

0
0
0

0
0
0
0
0
0
0
0
0


'builtins'





0

22


0

0
14


0


0
0
9











2




11

0




0






0

0


18

0

0
22

0
2
0
0
188
0
0
0
0
0
'Ellipsis'
0
0
0
0
0
0
0
0
0
0

0
0
0

0
0
0
0
0
0
0
0
0


'builtins'





0

22


0

0
14






0












2




11

0




0






0




18

0

0
22

0
2
0
0
175
0
0
0
0
0
'Ellipsis'
0
0
0
0
0
0
0
0
0
0

0
0
0

0
0
0
0
0
0
0
0
0


'builtins'





0
2
26


0

0
14


0


0
0
9











2




11

0

0


0





3
0

0


18

0

0
26

0
2
0
0
204
0
0
0
1
0
'Ellipsis'
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0


'builtins'





0
2
22


0


14


0


0
0












2




11

0

0


0





3
0




18

0

0
22

0
2
0
0
190
0
0
0
1
0
'Ellipsis'
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0


'builtins'





0
2
22


0


14


0


0
0












2




11

0

0


0





3
0




18

0

0
22

0
2
0
0
192
0
0
0
0
0
'Ellipsis'
0
0
0
0
0
0
0
0
0
0

0
0
0
0
0
0
0
0
0
0
0
0
0


'builtins'





0
2
23


0

0
14


0


0
0












2




11

0

0


0





3
0

0


18

0

0
23

0
2
0
0
191


Par rapport à l'implémentation du module externe TI-Python pour les anciennes TI-83 Premium CE, le module builtins de la nouvelle TI-83 Premium CE Edition Python rajoute donc les fonctions get() et send().

Possiblement étrange puisque ce ne sont pas des fonctions Python standard.

Peut-être penses-tu, vu la signification de ces mots, qu'il s'agit d'un simple moyen d'importer/exporter des variables entre l'application Python et le système de la calculatrice ?... ;)

Si l'on remonte dans le temps, des fonctions get() et send() ont justement été rajoutées récemment dans le langage interprété historique des TI-83 Premium CE, TI-84 Plus CE et TI-Nspire CX, à l'occasion de la sortie de l'interface TI-Innovator Hub pour la rentrée 2017.

D'où une hypothèse alternative, il semblerait donc que Texas Instruments a l'intention de se démarquer de la concurrence et de proposer très prochainement en Python la possibilité de lire des capteurs et contrôler des actionneurs, soit de coder en lien avec le monde réel conformément aux dernières évolutions des programmes du collège qui commencent à assaisonner les nouveaux programmes du lycée. :D
Cela impliquerait par extension la possibilité de piloter le robot TI-Innovator Rover sorti pour la rentrée 2018, là encore en parfaite adéquation avec les dernières évolutions des programmes ! :bj:

Cette dernière hypothèse nous semblerait bien plus probable, cohérente à la fois dans le contexte des dernières évolutions de l'entreprise et du lycée français.

Dans les deux cas c'est génial. :D
On peut effectivement reprocher à l'ensemble de la concurrence actuelle de cloisonner l'application Python dans son coin. Impossible d'y importer ou d'en exporter des valeurs et donc par extension d'interagir avec les autres applications de la calculatrice, l'application Python ne peut donc servir à rien d'autre qu'à faire du Python, ce qui limite fortement les possibilités de résolution de problèmes concrets posés en Mathématiques ou Physique-Chimie. :mj:

Contrairement à la concurrence, la TI-83 Premium CE Edition Python sous ces deux hypothèses serait la première calculatrice où l'application Python pourra enfin interagir au-delà de sa bulle, une révolution ! :bj:


Peut-être même que ça marche déjà, mais comme nous n'avons remarqué la présence des fonctions get() et send() sur nos photos qu'a posteriori, nous ne les avons donc pas testées sur place.

Si c'est bien notre hypothèse alternative qui est la bonne, aussi génial que ce soit sur le plan pédagogique et technique, on peut toutefois se demander si cela n'arrive pas ou trop tôt ou trop tard. En effet, les enseignants concernés ont déjà dû trouver des solutions pour le codage en lien avec le monde réel et la robotique depuis la rentrée 2016. Pas sûr qu'ils soient nombreux maintenant à basculer sur la solution TI-Innovator même si compatible Python, solution qui est loin d'être la plus abordable, et qui de plus aura la contrainte de nécessiter un groupe classe entièrement ou presque entièrement équipée en TI-83 Premium CE Edition Python.




8) Exploration autres modules Python :

Go to top

Le même script ci-dessus nous permet d'explorer les divers autres modules Python de la nouvelle TI-83 Premium CE Edition Python, mais là nous ne notons pas de différence par rapport à l'implémentation du module externe TI-Python pour les anciennes TI-83 Premium CE.
111671116611168111651116411174


Passons donc au bilan tous modules confondus :
MicroPython
TI-Nspire
NumWorks
Casio
Graph 35+E II
Graph 90+E
CasioPython
Graph 35+E II
Graph 35+E/USB
Graph 75/85/95
TI-Python /
TI-83 Premium CE
TI-83 Premium CE
Edition Python
firmware tiers
TI-Python /
TI-83 Premium CE
builtins
array
collections
cmath
gc
math
micropython
os
random
sys
time
turtle
218
4
 
12
7
41
3
 
 
15
 
 
188
 
 
12
 
41
6
 
8
 
3
38
175
 
 
 
 
25
 
 
8
 
 
 
204
4
 
12
7
41
6
 
8
12
 
 
190
4
2
 
7
28
 

8
15
4
 
192
4
2
 
7
28
 

8
15
4
 
191
4
2
12
7
41
6
15
8
15
10
 
spécifique10(nsp)5(kandinsky)22(board)
21(storage)
Total310301208294258260354


D'où le classement suivant en terme de richesse des modules Python :
  1. 354 éléments : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
  2. 310 éléments : TI-Nspire (application MicroPython)
  3. 301 éléments : NumWorks
  4. 294 éléments : Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII (application CasioPython)
  5. 260 éléments : TI-83 Premium CE Edition Python
  6. 258 éléments : module externe TI-Python pour TI-83 Premium CE
  7. 208 éléments : Casio Graph 35+E II / 90+E / fx-CG50




9) Mémoire de travail Python :

Go to top

La mémoire de travail en Python va accueillir :
  • les définitions globales (variables, fonctions, classes) issues des scripts importés
  • les arguments d'appel de la ou des fonctions en cours d'exécution
  • les définitions locales effectuées par la ou les fonctions en cours d'exécution
La taille de la mémoire de travail conditionne donc jusqu'où il sera possible d'aller en Python, nombre d'appels récursifs par exemple.

Voici quelques tailles occupées en mémoire par des variables Python :
  • 64 octets pour une liste vide
  • 8 octets par élément de liste supplémentaire
  • 24 octets pour un entier nul
  • 28 octets pour un entier court non nul
  • 49 octets pour une chaîne vide
  • 1 octet par caractère de chaîne supplémentaire

En se basant sur ces tailles, le script suivant permet d'estimer la capacité de la mémoire de travail en allouant plusieurs blocs de mémoire jusqu'à épuisement :
Code: Tout sélectionner
def mem():
  try:
    l=[]
    try:
      l+=[0]
      l+=[""]
      l[1]+="x"
      while True:
        try:
          l[1]+=l[1][l[0]:]
        except:
          if l[0]<len(l[1])-1:
            l[0]=len(l[1])-1
          else:
            raise(Exception)
    except:
      print("+",len(l)>1 and len(l[1]))
      return 64+8*len(l)+(len(l) and 24+4*(l[0]>0)+(len(l)>1 and 49+len(l[1])))+mem()
  except:
    return 0


11157Voici la sortie obtenue par l'appel mem() :
TI-83 Premium CE Edition Python a écrit:>>> from mem import *
>>> mem()
+ 8209
+ 3070
+ 2048
+ 1279
+ 639
+ 397
+ 158
16899
>>>


Le script arrive donc à allouer en mémoire de travail de la TI-83 Premium CE Edition Python jusqu'à 16,899 Ko. :bj:

D'où le classement par capacité de mémoire de travail :
  1. 2,046 Mo : TI-Nspire (application MicroPython)
  2. 1,027 Mo : Casio Graph 90+E / fx-CG50
  3. 255,07 Ko : Casio Graph 35+E / 35+USB/75/95 SH4 / fx-9750/9860GII SH4 (application CasioPython)
  4. 95,549 Ko : Casio Graph 35+E II
  5. 28,625 Ko : Casio Graph 35+E II / 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3 (application CasioPython)
  6. 19,842 Ko : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
  7. 17,192 Ko : module externe TI-Python pour TI-83 Premium CE
  8. 16,899 Ko : TI-83 Premium CE Edition Python
  9. 13,658 Ko : calculatrice NumWorks
  10. 5,946 Ko : logiciel web NumWorks


La nouvelle TI-83 Premium CE Edition Python offrirait donc a priori légèrement moins de mémoire de travail Python que le module externe TI-Python pour les anciennes TI-83 Premium CE. Et c'est certes possible vu que nous avons vu plus haut qu'il y avait eu des ajouts dans le module par défault builtins.

Toutefois notre fonction mem() a le défaut d'avoir un résultat qui varie selon le contexte Python courant. Les variations ne sont certes pas énormes, mais ici avec seulement 1,7% de moins sur une unique mesure sur la nouvelle TI-83 Premium CE Edition Python par rapport au module externe TI-Python pour les anciennes TI-83 Premium CE, il pourrait très bien s'agir d'une erreur.

Peut-être qu'une amélioration du protocole de test pour une prochaine fois pourrait être de faire la moyenne d'une série d'appels mem().




10) Performances Python :

Go to top

Enfin, terminons en voyant les performances. Commençons dans le cadre des nombres entiers avec le script suivant :
Code: Tout sélectionner
try:
  from time import *
except:
  pass

def hastime():
  try:
    monotonic()
    return True
  except:
    return False

def genseed(ndigits):
  nmax,s,k=5*10**(ndigits-1),0,1
  while s<nmax:
    s+=k
    k*=2
  return s

def genarr(ndigits):
  sd,arr=genseed(ndigits),[]
  for k in range(1,ndigits):
    for j in range(ndigits):
      t=sd%10**k
      arr.extend([t,-t,10**k-t,t-10**k])
      sd=sd//10+(sd%10)*10**(ndigits-1)
  arr.extend([sd,-sd])
  return arr

def sortarr(arr,sdiff):
  segs=[0,len(arr)-1]
  while len(segs):
    iref=segs[0]
    for k in range(segs[0],segs[1]+1):
      if sdiff*(arr[k]-arr[iref])>0:
        t=arr[iref]
        arr[iref]=arr[k]
        arr[k]=arr[iref+1]
        arr[iref+1]=t
        iref+=1
    if iref>=segs[0]+2:
      segs.extend([segs[0],iref-1])
    if iref<=segs[1]-2:
      segs.extend([iref+1,segs[1]])
    segs.pop(0)
    segs.pop(0)
  return arr

def test(l,n):
  timed=hastime()
  start,stop,sdiff,arr=0 or timed and monotonic(),1,-1,[]
  arr.extend(genarr(l))
  for k in range(n):
    arr.extend(sortarr(arr,sdiff))
    sdiff=-sdiff
  stop=timed and monotonic() or 1
  return stop-start,len(arr),arr[0],arr[len(arr)//2-1],arr[len(arr)//2],arr[len(arr)-1]


11203La ligne d'appel test(9,2) se termine en 26,60s sur la nouvelle TI-83 Premium CE Edition Python, contre 23,20s pour le module externe TI-Python sur les anciennes TI-83 Premium CE.

D'où le classement suivant pour les performances en calcul entier :
  1. 1,41s : TI-Nspire (application MicroPython) (32 bits : ARM9/ARMv5 @120MHz)
  2. 1,56s : TI-Nspire CM / CX révisions A-V (application MicroPython) (32 bits : ARM9/ARMv5 @132MHz)
  3. 2,40s : TI-Nspire CX révisions W+/CR4+ (application MicroPython) (32 bits : ARM9/ARMv5 @156MHz)
  4. 3,74s : NumWorks (32 bits : Cortex/ARMv7 @100MHz)
  5. 4,75s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
  6. 8,81s : HP Prime G2 (32 bits : Cortex/ARMv7 @528MHz)
  7. 9,56s : Casio Graph 35+E/75+E / 35+USB/75/95 SH4 / fx-9750/9860GII SH4 (application CasioPython) (32 bits : SH4 @29,5MHz)
  8. 10,19s : Casio Graph 35+E II (application CasioPython) (32 bits : SH4 @59MHz)
  9. 12,99s : Casio Graph 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3 (application CasioPython) (32 bits : SH3 @29,5MHz)
  10. 14,93s : Casio Graph 35+E II (32 bits : SH4 @59MHz)
  11. 20,73s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
  12. 23,20s : module externe TI-Python pour TI-83 Premium CE (32 bits : Cortex/ARMv7 @48MHz)
  13. 26,60s : TI-83 Premium CE Edition Python (?)
  14. 33,48s : module externe TI-Python pour TI-83 Premium CE (firmware tiers) (32 bits : Cortex/ARMv7 @48MHz)
  15. 60,71s : application KhiCAS sur Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
  16. 116,93s : application KhiCAS sur Casio fx-CG10/20 (32 bits : SH4 @59MHz)


Là bizarrement, par rapport au module externe pour les anciennes TI-83 Premium CE, nous notons un recul des performances pour la nouvelle TI-83 Premium CE Edition Python. Avec des durées d'exécution cette fois-ci peu variables et plus de 10% d'écart, il est peu probable qu'il s'agisse d'une erreur de mesure.

Passons maintenant aux nombres flottants avec le script suivant :
Code: Tout sélectionner
try:
  from time import *
except:
  pass

def hastime():
  try:
    monotonic()
    return True
  except:
    return False

def seuil(d):
  timed=hastime()
  start,stop,n,u,l,d=0 or timed and monotonic(),1,0,2.,1,d**2
  while (u-l)**2>=d: u,n=1+(1/((1-u)*(n+1))),n+1
  stop=timed and monotonic() or 1
  return [stop-start,n,u]


La ligne d'appel seuil(0.005) se termine en 10,38s sur la nouvelle TI-83 Premium CE Edition Python, contre 9,68s pour le module externe TI-Python sur les anciennes TI-83 Premium CE.

D'où le classement suivant dans le contexte des calculs en virgule flottante :
  1. 0,962s : HP Prime G2 (32 bits : Cortex/ARMv7 @528MHz)
  2. 1,08s : TI-Nspire CM / CX CR3- (application MicroPython) (32 bits : ARM9/ARMv5 @132MHz)
  3. 1,29s : TI-Nspire (application MicroPython) (32 bits : ARM9/ARMv5 @120MHz)
  4. 1,61s : TI-Nspire CX CR4+ (application MicroPython) (32 bits : ARM9/ARMv5 @156MHz)
  5. 2,036s : NumWorks (32 bits : Cortex/ARMv7 @100MHz)
  6. 3,068s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
  7. 8,94s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
  8. 9,68s : module externe TI-Python pour TI-83 Premium CE (32 bits : Cortex/ARMv7 @48MHz)
  9. 10,38s : TI-83 Premium CE Edition Python (?)
  10. 10,68s : Casio Graph 35+E II (application CasioPython) (32 bits : SH4 @59MHz)
  11. 11,26s : Casio 35+E/75+E / 35+USB/75/95 SH4 / fx-9750/9860GII SH4 (application CasioPython) (32 bits : SH4 @29,5MHz)
  12. 11,46s : module externe TI-Python pour TI-83 Premium CE (firmware tiers) (32 bits : Cortex/ARMv7 @48MHz)
  13. 13,87s : Casio Graph 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3 (application CasioPython) (32 bits : SH3 @29,5MHz)
  14. 19,98s : application KhiCAS sur Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
  15. 25,19s : Casio Graph 35+E II (32 bits : SH4 @59MHz)
  16. 35,55s : application KhiCAS sur Casio fx-CG10/20 (32 bits : SH4 @59MHz)


Dans des proportions similaires, on confirme donc un léger recul des performances sur la TI-83 Premium CE Edition Python par rapport à ce que le module externe TI-Python pour les anciennes TI-83 Premium CE permettait d'espérer.




Conclusion :

Go to top

La TI-83 Premium CE Edition Python est à ce jour une véritable énigme technologique. :D

Le minimum aurait été d'intégrer une pyboard similaire à celle utilisée pour le module externe TI-Python dans le boîtier.

Mais alors, pourquoi est-elle à la fois beaucoup plus rapide dans le contexte de l'environnement historique, et dans le contexte Python légèrement plus lente que le module externe TI-Python ?
On peut avancer l'hypothèse de deux processeurs eZ80 8 bits pour l'environnement historique et ARM 32 bits pour le Python, mais pourtant le processeur eZ80 sauf erreur ne peut pas être accéléré...

Peut-être qu'alors il s'agit d'une nouvelle puce ASIC avec un unique processeur ARM 32 bits ? Dans ce cas, puisque nous arrivons toujours à y exécuter des applications et programmes assembleur conçus pour les anciennes TI-83 Premium CE, il y aurait une couche d'émulation eZ80, qui pourrait effectivement être plus rapide que le matériel d'origine.

Mais aussi, nous avons cru voir à l'écran de diagnostics que la mémoire Flash avait été touchée. Peut-être que des temps de latence différents expliquent cette accélération dans le contexte historique.
Mais pourquoi la Flash a-t-elle été touchée ? Etait-ce pour la mutualiser en y rajoutant un firmware comparable à celui du module externe TI-Python ? Auquel cas pourrait-il s'agir d'une Flash interne à une nouvelle puce ASIC comme c'était le cas avec le module externe TI-Python ?



Il semble que Texas Instruments ne se soit ici pas contenté du minimum, et ait fait un bel effort niveau processeur/ASIC pour que la nouvelle TI-83 Premium CE Edition Python puisse rester dans la course un bon moment, et s'adapter à d'éventuelles futures évolutions des programmes scolaires. :bj:

Nous avons donc hâte de pouvoir découvrir ce que la nouvelle TI-83 Premium CE Edition Python a dans le ventre, et en attendant tu peux voter pour ton explication préférée sur la page de commentaires. ;)
Vivement cette première calculatrice où l'application Python pourra servir à autre chose qu'à simplement afaire du Python; nous avons notamment hâte de pouvoir piloter le robot TI-Innovator Rover depuis nos scripts Python. :D

A bientôt... ;)
Image
Avatar de l’utilisateur
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Prochain niv.: 41.8%
 
Messages: 41465
Images: 14479
Inscription: 25 Oct 2008, 00:00
Localisation: Montpellier
Genre: Homme
Calculatrice(s):
MyCalcs profile
YouTube: critor3000
Twitter/X: critor2000
GitHub: critor

Re: Test TI-83 Premium CE Edition Python (proto. DVT), Orme

Message non lude zardam » 08 Mai 2019, 18:22

En tout cas, il y a le petit carré vert dans la barre de statut qui donne l'état de la connexion avec le module externe.

Y avait-il l'étape d'upload des scripts vers le module ? (L'écran qui affiche "Veuillez patienter...", la liste des scripts et ensuite "Configuration terminée.")
Avatar de l’utilisateur
zardamPremium
Niveau 9: IC (Compteur Infatigable)
Niveau 9: IC (Compteur Infatigable)
Prochain niv.: 34.6%
 
Messages: 233
Images: 13
Inscription: 11 Oct 2017, 23:39
Genre: Non spécifié
Calculatrice(s):
MyCalcs profile

Re: Test TI-83 Premium CE Edition Python (proto. DVT), Orme

Message non lude critor » 08 Mai 2019, 18:26

Oui, y'a toujours.

Visible partiellement ici :
11200
Image
Avatar de l’utilisateur
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Prochain niv.: 41.8%
 
Messages: 41465
Images: 14479
Inscription: 25 Oct 2008, 00:00
Localisation: Montpellier
Genre: Homme
Calculatrice(s):
MyCalcs profile
YouTube: critor3000
Twitter/X: critor2000
GitHub: critor

Re: Test TI-83 Premium CE Edition Python (proto. DVT), Orme

Message non lude parisse » 08 Mai 2019, 18:38

J'avais deja trouve que realiser un module externe pour le marche existant etait cher, mais si en plus ce n'est pas le meme type de solution en interne, ca serait vraiment tres cher... Comment la memoire est-elle geree s'il y a bien 2 processeurs ? Peut-on avoir une memoire partagee et dans ce cas y-a-t-il des delais d'attente?
Avatar de l’utilisateur
parisseVIP++
Niveau 12: CP (Calculatrice sur Pattes)
Niveau 12: CP (Calculatrice sur Pattes)
Prochain niv.: 77.2%
 
Messages: 3500
Inscription: 13 Déc 2013, 16:35
Genre: Non spécifié
Calculatrice(s):
MyCalcs profile

Re: Test TI-83 Premium CE Edition Python (proto. DVT), Orme

Message non lude Lionel Debroux » 08 Mai 2019, 19:43

A mon avis, ils ont intégré un ATSAMD21 au PCB de la 83PCE EP, et on a deux chips bien distincts, chacun avec sa RAM et sa Flash propres, comme avec le TI-Python Adapter.
Membre de la TI-Chess Team.
Co-mainteneur de GCC4TI (documentation en ligne de GCC4TI), TIEmu et TILP.
Avatar de l’utilisateur
Lionel DebrouxSuper Modo
Niveau 14: CI (Calculateur de l'Infini)
Niveau 14: CI (Calculateur de l'Infini)
Prochain niv.: 11.2%
 
Messages: 6859
Inscription: 23 Déc 2009, 00:00
Localisation: France
Genre: Homme
Calculatrice(s):
MyCalcs profile
Classe: -
GitHub: debrouxl

Re: Test TI-83 Premium CE Edition Python (proto. DVT), Orme

Message non lude Elouan147 » 10 Mai 2019, 15:11

Ma prof a tellement hâte de la sortie de cette calculatrice: elle m'en avait déjà parlé cet été!
J'aime les shih tzu
Avatar de l’utilisateur
Elouan147
Niveau 7: EP (Espèce Protégée: geek)
Niveau 7: EP (Espèce Protégée: geek)
Prochain niv.: 51.6%
 
Messages: 51
Inscription: 16 Jan 2019, 14:33
Localisation: Nice
Genre: Homme
Calculatrice(s):
MyCalcs profile
Classe: Première

Re: Test TI-83 Premium CE Edition Python (proto. DVT), Orme

Message non lude critor » 10 Mai 2019, 15:27

Ah, ta prof a de bons contacts alors vu que nous avons appris son arrivée seulement en Mars 2019. ;)
Image
Avatar de l’utilisateur
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Prochain niv.: 41.8%
 
Messages: 41465
Images: 14479
Inscription: 25 Oct 2008, 00:00
Localisation: Montpellier
Genre: Homme
Calculatrice(s):
MyCalcs profile
YouTube: critor3000
Twitter/X: critor2000
GitHub: critor

Re: Test TI-83 Premium CE Edition Python (proto. DVT), Orme

Message non lude Azerpogba » 10 Mai 2019, 18:53

Et la c'est le bug :troll: :'D
Image
Avatar de l’utilisateur
AzerpogbaAmbianceur
Niveau 13: CU (Calculateur Universel)
Niveau 13: CU (Calculateur Universel)
Prochain niv.: 60%
 
Messages: 397
Images: 16
Inscription: 04 Déc 2018, 19:40
Genre: Homme
Calculatrice(s):
MyCalcs profile
Classe: Etude sup

Re: Test TI-83 Premium CE Edition Python (proto. DVT), Orme

Message non lude OulanB » 14 Mai 2019, 11:59

Ils ont du intégrer la flash eZ80 dans l'asic, donc les wait states sont plus bas et hop, vitesse en langage historique plus rapide (de mémoire l'eZ80 à 48 MHz "semble" fonctionner à 15 MHz avec les wait states avec la 83PCE actuelle ...)
Avatar de l’utilisateur
OulanB
Niveau 3: MH (Membre Habitué)
Niveau 3: MH (Membre Habitué)
Prochain niv.: 0%
 
Messages: 11
Inscription: 18 Déc 2018, 15:03
Genre: Non spécifié
Calculatrice(s):
MyCalcs profile

Re: Test TI-83 Premium CE Edition Python (proto. DVT), Orme

Message non lude critor » 14 Mai 2019, 12:55

Effectivement, cela se tient. :)
Merci à toi.

Par contre, ça repose la question de pourquoi ils auraient fait ça. Un lien peut-être matériel avec le Python ?
Parce que TI n'améliore habituellement pas les performances sans besoin.
Image
Avatar de l’utilisateur
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Prochain niv.: 41.8%
 
Messages: 41465
Images: 14479
Inscription: 25 Oct 2008, 00:00
Localisation: Montpellier
Genre: Homme
Calculatrice(s):
MyCalcs profile
YouTube: critor3000
Twitter/X: critor2000
GitHub: critor

Suivante

Retourner vers News TI-z80 (TI-73, 76, 80, 81, 82, 83, 84, 85, 86)

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 205 invités

-
Rechercher
-
Social TI-Planet
-
Sujets à la une
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Aidez la communauté à documenter les révisions matérielles en listant vos calculatrices graphiques !
Phi NumWorks jailbreak
123
-
Faire un don / Premium
Pour plus de concours, de lots, de tests, nous aider à payer le serveur et les domaines...
Faire un don
Découvrez les avantages d'un compte donateur !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partenaires et pub
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
2088 utilisateurs:
>2072 invités
>12 membres
>4 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)
-
Autres sites intéressants
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)