π
<-
Chat plein-écran
[^]

TI-z80 Maj clé USB émulation TI-SmartView 83 Premium CE Python 5.5

New postby critor » 14 Sep 2020, 11:29

Pour cette rentrée 2020,
Texas Instruments
introduit de formidables nouveautés
Python
sur
TI-83 Premium CE Edition Python
.

Disponible pour
Windows
et
Mac
, le logiciel
TI-SmartView CE
est un émulateur de calculatrices
TI-83 Premium CE Edition Python
et
TI-82 Advanced
. Son usage est fort pertinent pour une mutualisation de la recherche en classe grâce à son grand écran et son historique visuel des touches pressées. Son clavier dédié est de plus un véritable plaisir avec un vidéoprojecteur interactif.
Mais voilà, au-delà d'une période d'essai de 90 jours, l'utilisation de ce logiciel nécessite une licence.

Pour l'enseignant qui se trimballe d'une salle à l'autre avec son propre ordinateur portable, pas de problème.

Par contre pour les enseignants qui utilisent l'ordinateur de la salle de classe, c'est autre chose.

D'une part, l'enseignant ne disposant normalement pas des droits d'administration sur l'ordinateur de la salle, l'installation du logiciel
TI-SmartView CE
pouvait lui être refusée.

D'autre part, une fois utilisé le numéro de licence est définitivement lié à l'ordinateur sur lequel il a été saisi, et ne peut donc pas être réutilisé. Si l'enseignant reçoit ses élèves dans différentes salles, il lui fallait donc au moins une licence pour chaque salle. Et même à ça les ennuis ne sont pas définitivement écartés, car c'est sans compter les habituels imprévus : remplacement de l'ordinateur suite à une panne, une dégradation ou un vol, changement exceptionnel de salle, ...

Texas Instruments
, toujours soucieux du bien-être des enseignants, avait sorti une solution dès la rentrée 2016, l'émulateur
TI-SmartView CE
permanent sur clé
USB
.

Avec cette clé spéciale plus besoin de s'embêter avec les droits d'administration ou les numéros de licence, il y avait juste à la brancher sur n'importe quel ordinateur pour pouvoir lancer directement l'émulateur. :bj:

Mais voilà, cette clé
USB
ne pouvait hélas pas être mise à jour avec les mêmes fichiers que la calculatrice. :#non#:

Il t'était donc jusqu'à présent impossible d'utiliser les dernières nouveautés
Python
dans ce contexte à moins de réussir à obtenir une nouvelle clé
USB
d'émulation
TI-SmartView CE
, particulièrement handicapant en cette période de rentrée. :'(


Toutefois ici encore,
Texas Instruments
propose une solution gratuite aux enseignants pour cette rentrée 2020.

Aucune obligation de te commander une nouvelle clé
USB
TI-SmartView CE
, tu peux tout simplement mettre à jour celle que tu possèdes déjà et bénéficier dès maintenant de toutes les dernières nouveautés ! :bj:

Il te suffira juste pour cela :
  1. d'en effacer l'ancien contenu, par exemple en reformatant la clé en question
  2. de télécharger et ouvrir le fichier
    .zip
    de mise à jour ci-dessous
  3. de copier l'intégralité de son contenu sur ta clé
    USB
Attention, cette édition
USB
de l'émulateur n'acceptera bien évidemment de fonctionner que si elle détecte une clé
USB
TI-SmartView CE
officielle, protection contre la copie oblige. :#non#:

Téléchargement
:
Mise à jour
5.5
clé
USB
d'émulation
TI-SmartView 83 Premium CE Edition Python

TI-z80 Formation Python micro:bit & TI-83 Premium CE : 16 septembre

New postby critor » 14 Sep 2020, 10:51

12970Pour cette rentrée 2020,
Texas Instruments
rajoute à sa
TI-83 Premium CE Edition Python
la possibilité d'interagir avec les cartes
BBC micro:bit
, qui plus est en
Python
! :bj:

Ce
mercredi 16 septembre
de
18h30
à
20h
,
Texas Instruments
en la personne de , formateur
T3
, se propose de t'accompagner dans la prise en main de cette solution.
Image


Au menu de cette première édition :
  • installation des modules
    Python
    nécessaires pour la compatibilité
    BBC micro:bit
    , mais que tu peux déjà effectuer à partir des liens ci-après
  • prise en main à travers divers exemples de scripts
    Python
    faisant appel à des éléments intégrés de la carte
    BBC micro:bit


Inscription
:
https://tiedtech.webex.com/mw3300/myweb ... iedtech-fr

Téléchargements
:


Casio Batterie externe USB Casio, extension pour ta calculatrice !

New postby critor » 13 Sep 2020, 13:55

1298612985Cette année comme chaque année
Casio
t'a conçu de tous nouveaux
goodies
. Voici donc ci-contre une des dernières créations du constructeur, une batterie
USB
externe estampillée à son nom.

Un goodies exceptionnel qui pour une fois n'ira pas ramasser la poussière sur ton étagère ou dormir au fond de ton tiroir mais saura se rendre utile, et qui plus est pourra être utilisé directement avec ta calculatrice ! :bj:
Et puis ce serait toute une fierté d'adjoindre ça à ta
Casio
, non ? ;)

1298812990Il s'agit en fait de la , un objet publicitaire personnalisable distribué en Europe par
Inspirion
.

La batterie offre une capacité de
2200 mAh
.

12989Nous disposons donc d'un port
USB micro-B
pour la recharge, ainsi que d'un port
USB A
pour alimenter ta calculatrice ou tout autre appareil compatible.

Une fois chargée et connectée au port
USB
de ta calculatrice, la batterie externe te permet selon les modèles :
  • d'alimenter ta calculatrice et donc de prolonger la durée de vie de ses piles ou de sa batterie interne
  • de recharger la batterie interne de ta calculatrice

12991Avec la
Graph 35+E II
et autres calculatrices
Casio Graph
monochromes c'est particulièrement impressionnant, puisque la calculatrice accepte parfaitement de s'allumer et continuer à fonctionner correctement alimentée par la seule batterie externe, piles internes retirées donc ! :bj:
Tu pourras donc même continuer à utiliser ta calculatrice une fois les piles complètement déchargées ! :D
Attention toutefois, piqûre de rappel, en tant que module externe cette batterie
USB
est strictement interdite d'utilisation aux examens en France. :#non#:


La batterie externe
USB Casio
n'étant pas sectaire, voici d'autres modèles qui s'accomodent parfaitement de cette seule alimentation externe : :bj:
  • TI-Nspire CX
  • HP Prime

Les modèles
Casio
couleur
Graph 90+E
et
fx-CP400+E
quant à eux n'acceptent pas de fonctionner en l'absence de l'alimentation interne par piles. Malgré l'alimentation externe, la calculatrice s'allume puis s'éteint immédiatement. Soit l'alimentation externe est insuffisante ce qui serait quand même surprenant vu les deux derniers modèles testés, soit ces modèles sont tout simplement plus stricts dans leurs vérifications de l'alimentation interne.

Le reste des modèles testés refuse catégoriquement de s'allumer lorsque alimentés uniquement en externe via leur port
USB
:
  • TI-83 Premium CE
  • TI-82 Advanced
  • NumWorks
  • TI-Nspire
    monochromes

Avec le nombre d'événements annulés cette année, tu risques ne ne pas avoir beaucoup d'occasions de récupérer ce
goodies
d'exception... :'(

Et bien réjouis-toi car nous allons t'en faire gagner très prochainement tout un stock à notre concours de rentrée ; il y en aura pour récompenser tous les gagnants optant pour un lot
Casio
! :bj:

TI-z80 Sortie émulateur TI-SmartView 84 Plus CE-T avec Python 5.5.2

New postby critor » 13 Sep 2020, 10:20

Les logiciels
TI-SmartView
de
Texas Intruments
sont des outils de haute qualité, permettant de reproduire sur ton ordinateur le fonctionnement de ta calculatrice.

Ils sont très fidèles comme en témoigne l'édition
TI-83 Premium CE
; tout y marche : :D
  • programmes
    TI-Basic
  • scripts
    Python
  • applications
  • programmes assembleur
Un très bel outil notamment pour l'enseignant avec l'a possibilité de prendre des captures d'écran pour composer ses documents. Egalement taillé sur-mesure pour une vidéoprojection permettant de mutualiser l'usage de la calculatrice en classe, avec notamment : :bj:
  • l'historique des touches pressées
  • le clavier montrant la position de la dernière touche pressée
Hélas gros handicap pour cette rentrée 2020, l'édition
TI-83 Premium CE
du logiciel
TI-SmartView
n'est toujours pas à jour. Restant en version
5.4
, elle ne permet donc pas de traiter des formidables nouveautés
Python
apportées à partir de la mise à jour
5.5
. :'(

Et impossible de mettre à jour l'émulateur avec les mêmes fichiers que la calculatrice, les transferts en ce sens sont tout simplement refusés, y compris celui de la dernière application
Python 5.5.2
! :#non#:

En attendant qu'une mise à jour soit enfin disponible pour l'édition
TI-83 Premium CE
du logiciel
TI-SmartView
, nous te livrons une petite astuce pour te dépanner dans les prochaines semaines.

Il te suffit tout simplement d'utiliser la nouvelle édition
TI-84 Plus CE-T
du logiciel
TI-SmartView
qui vient tout juste de sortir.

Cette édition n'émule pas le modèle français
TI-83 Premium CE Edition Python
mais le nouveau modèle européen
TI-84 Plus CE-T Python Edition
ici parfaitement à jour avec la dernière application
Python 5.5.2
et le dernier système
5.6
! :bj:

Les interfaces et menus y sont identiques, et tu pourras les passer en français à l'aide de la touche
mode
.

Attention cette astuce ne sera valable que pour le 1er trimestre,
Texas Instruments
n'autorisant que 90 jours d'utilisation gratuite à compter du 1er lancement.

Espérons donc qu'une autre solution sortira d'ici-là.

Téléchargement
:
TI-SmartView édition TI-84 Plus CE-T
pour
Windows
/
Mac

TI-z80 2 nouveaux coloris TI-84 Plus CE rentrée 2020

New postby critor » 12 Sep 2020, 10:54

La
TI-84 Plus CE
, le modèle remplaçant notre
TI-83 Premium CE
française chez nos voisins européens et dans le monde, est à la différence disponible dans de nombreux coloris.

En France cela avait déjà été proposé du temps des
TI-83 Plus
et
TI-84 Plus
monochromes, et il faut croire que cela n'a pas rencontré de succès bien extraordinaire. Nombre de familles voient en effet encore la calculatrice graphique de Seconde comme un achat contraint et non comme un achat plaisir ou outil d'accompagnement vers la réussite, et opteront donc de toutes façons pour le modèle classique/standard légèrement moins cher si on leur laissait le choix. :'(

Pour le lancement à la rentrée 2015, nous avions eu droit à pas moins de 8 éditions différentes :
  • Classic
    (noir)
  • Denim
    (bleu marin)
  • Lightning
    (bleu é-clair)
  • Plum Pi
    (pi-zza aux prunes)
  • Positively Pink
    (rose positif)
  • Radical Red
    (rouge radical)
  • Silver Linings
    (double argent)
  • True Blue
    (bleu réel)

Les anglophones noteront quelques jeux de mots intéressants dans le contexte des mathématiques, pas toujours aisés à retranscrire en français. ;)


Pour la rentrée 2016, 2 nouveautés ont permis de passer à un éventail de 10 coloris différents :
  • Bright White
    (blanc brillant)
  • Golden Ratio
    (proportion dorée - brillant ; du nombre d'or ou divine proportion)

La rentrée 2017 marque un gros changement.
Texas Instruments
ne reconduit que 5 des anciens coloris, mais sort 4 nouveautés pour un arc-en-ciel de 9 coloris différents :
  • Bionic Blue
    (bleu bionique)
  • Count on Coral
    (compte sur corail)
  • Galaxy Gray
    (gris galactique - brillant)
  • Measure Mint
    (menthe mesuré)


Pour la rentrée 2018 le constructeur reconduit 8 des anciens coloris, mais sort 1 nouveauté qui nous permet donc de rester sur un total de 9 coloris différents :
  • Rose Curve Gold
    (rose or - brillant)

Pour la rentrée 2019,
Texas Instruments
reconduit 9 anciens coloris et sort 2 nouveautés, pour un éventail de 11 coloris différents :
  • Matte-matic Black
    (noir mat-hématique)
  • Tangent Teal
    (sarcelle tangent)

Courant 2020, quelques exemplaires de
TI-84 Plus CE
dans des coloris encore jamais vus sont apparus à la revente en
loose
sur
eBay
.

Pas de numéro de série gravé au dos mais par contre une mention
NOT FOR SALE
que le vendeur s'est empressé d'ignorer, il s'agissait donc de prototypes, et plus précisément de prototypes de nouveaux coloris conçus pour la rentrée 2020.

2 coloris saumon différant de par la face arrière noire ou blanche : :bj:



Un nouveau coloris rouge. :D

Deux variantes du
Tangent Teal
avec cette fois-ci une nuance au niveau du cadre écran, et différant de par le couvercle plus ou moins foncé : :favorite:




Et enfin un étrange coloris tricolore avec du bleu pour le clavier, du blanc pour le cadre écran, et du vert pour le couvercle.

Mais nous ignorions lesquels de ces coloris seraient effectivement proposés à la rentrée 2020, il est bien évident que les concepteurs de
TI
font plusieurs propositions en interne chaque année. Et nous ignorions de plus leurs noms.

Rentrée 2020 donc, ce sont ces 2 derniers coloris que
Texas Instruments
a finalement retenus et nous rajoute sous les noms suivants :
  • Totally Teal
    (totalement sarcelle - brillant)
  • Trifecta
    (trissectrice)
Reconduisant de plus 8 anciens coloris,
Texas Instruments
nous offre donc cette rentrée 10 coloris différents.

 
Classic
Denim
Lightning
Plum Pi
Positively Pink
Radical Red
Silver Linings
True Blue
Bright White
Golden Ratio
Bionic Blue
Count on Coral
Galaxy Grey
Measure Mint
Rose Curve Gold
Matte-matic Black
Tangent Teal
Totally Teal
Trifecta
TOTAL
2015









 
 
 
 
 
 
 
 
 


8
2016











 
 
 
 
 
 
 


10
2017


 
 


 
 
 






 
 
 


9
2018


 
 


 
 
 

 





 
 


9
2019


 
 
 


 
 



 







11
2020


 
 
 


 
 



 







10




Et toi, quelle est ta
TI-84 Plus CE
préférée ? Viens le dire en commentaire ! :D
Et si tu hésites,
TI
se propose même ci-dessous de t'aider à calculer ta couleur préférée. ;)


Lien
:
Calcule ta couleur

Sources
:

Link to topic: 2 nouveaux coloris TI-84 Plus CE rentrée 2020 (Comments: 12)

TI-Nspire Sortie/test TI-Nspire CX II 5.2 Python + QCC 2020 épilogue

New postby critor » 09 Sep 2020, 18:05

12980
Texas Instruments
nous sort enfin aujourd'hui sa tant attendue mise à jour de rentrée
TI-Nspire CX II
, la version
5.2
. :D

Il s'agit plus précisément d'une version
5.2.0.771
compilée le
15 août 2020
à
4h52
.

Cette mise à jour apporte une grande nouveauté, une application
Python
, que nous allons nous empresser de découvrir avec toi, et qui reste entièrement accessible en mode examen. :bj:


Sommaire :





1) Editeur et modèles de script :

Go to top

Sur
TI-Nspire CX II
, le
Python
n'est pas une application ayant l'honneur d'être directement disponible à l'écran d'accueil de la calculatrice. Il te faut créér un document et ensuite le
Python
sera listé en tant que 10ème type d'application rajoutable sur chaque page. L'application peut de plus être rajoutée sous deux formes différentes dont on nous propose le choix :
  • éditeur de script
    (nouveau ou ouvrir)
  • console
    (shell)

Commençons donc par l'éditeur avec un nouveau script. Afin de pouvoir démarrer très vite dans nombre de situations au lycée,
Texas Instruments
t'a conçu sur-mesure pas moins de 9 modèles de scripts prédéfinis :
Code: Select all
# Math Calculations
#================================
from math import *
#================================
Code: Select all
# Random Simulations
#================================
from math import *
from random import *
#================================
Code: Select all
# Geometry Graphics
#================================
from ti_draw import *
#================================
Code: Select all
# Image Processing
#================================
from ti_image import *
from ti_draw import get_screen_dim
#================================
Code: Select all
# Plotting (x,y) & Text
#================================
import ti_plotlib as plt
#================================
plt.window(,,,)
plt.grid(1,1,"dotted")
plt.axes("on")
Code: Select all
# Data Sharing
#================================
from ti_system import *
#================================
Code: Select all
# Hub Project
#================================
from ti_hub import *
from math import *
from time import sleep
from ti_plotlib import text_at,cls
from ti_system import get_key
#================================
Code: Select all
# Rover Coding
#================================
import ti_rover as rv
from math import *
import ti_plotlib as plt
from ti_system import *
from time import *
#================================


Nous accédons donc à un très bel éditeur. Notons en passant que
TI
a même pensé à nous rajouter une petite icône
Python
dans l'interface en question, histoire qu'on ne la confonde avec celle de l'éditeur de programmes.

Il bénéficie de la coloration syntaxique, de l'indentation automatique, peut afficher simultanément jusqu'à 11 lignes, et le numéro de la ligne courante étant reporté en haut à droite, fort utile pour corriger les éventuelles erreurs d'exécution.

Un éditeur très complet, on peut y réaliser des sélections en maintenant enfoncée la touche
shift
comme sur ordinateur, couper-copier-coller-effacer la sélection courante à l'aide des racourcis
ctrl
X
,
ctrl
C
,
ctrl
V
et
del
. La touche
menu
donnera accès à d'autres fonctionnalités tout en en rappelant les raccourcis clavier : aller en début/fin de ligne, en début/fin de script, aller à un numéro de ligne, rechercher, remplacer. :)

Gros avantage par rapport à la concurrence, on y trouve également un vérificateur syntaxique qui te permettra de gagner du temps en anticipant nombre d'erreurs qui t'auraient embêté(e) à l'exécution. En prime contrairement aux erreurs d'exécution dans la console
Python
qui habituellement n'indiquent qu'un numéro de ligne, la vérification syntaxique depuis l'éditeur t'amènera directement sur la ou les lignes à corriger ! :bj:




2) 1er script et console - nombres flottants et complexes :

Go to top

Bon, maintenant que nous savons utiliser l'éditeur, tentons de premiers tests simples histoire de se mettre en jambe. Etudions un petit peu le moteur de calcul numérique du
Python
en question.

Commençons par les nombres en virgule flottante dits flottants. Ce type de donnée utile pour les nombres non entiers sous la forme
$mathjax$M\times 2^{E-E_{min}}$mathjax$
, avec :
  • M
    , un nombre entier relatif dit mantisse
  • Emin
    , nombre entier négatif indique l'exposant minimal pouvant être codé
  • E
    , nombre entier naturel codant l'exposant

Voici donc nos toutes premières fonctions
Python
sur
TI-Nspire CX II
:
Code: Select all
def precm(b):
  k,b=0,float(b)
  while 1+b**-k-1>0:
    k+=1
  return k

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]


Pour exécuter tout ça on peut certes recommencer comme plus haut et insérer une application
Python
cette fois-ci format console
(shell)
sur une nouvelle page, console dans laquelle il faudra donc importer manuellement notre script.

Mais on peut également utiliser la touche
menu
pour demander directement l'exécution du script depuis l'éditeur, auquel cas ce dernier sera importé automatiquement.

Notons la touche
var
qui te permet de lister et saisir rapidement les noms de fonctions et variables globales définies dans le script.

L'appel precm(2) nous répond que le moteur travaille en virgule flottante avec des mantisses dont la précision est codée sur
53
bits, permettant environ
16
chiffres significatifs en écriture décimale
(precm(10))
, et auxquels il faut bien évidemment rajouter 1 bit de signe.
L'appel prece() nous indique pour sa part que les valeurs codables pour les exposants dans la formule vont de
-1075
à
+1023
.
Il s'agit du standard double précison du
Python
, un excellent choix pour le contexte scientifique du lycée, et à ce jour toutes les calculatrices concurrentes disposant d'une véritable implémentation
Python
répondent la même chose.

Notons au passage avec la saisie 1j la gestion des nombres complexes dits imaginaires
(Option Maths Expertes + série STI2D)
.




3) Modules importables et modules standard :

Go to top

Tentons maintenant de réaliser ensemble une première esquisse de l'étendue de la solution
Python
TI-Nspire CX II
, avec l'éventail de modules disponibles.

Pour explorer, nous allons commencer par aller dans la console, ici encore flanquée du logo
Python
histoire qu'on ne le confonde pas avec l'application calculs.

La touche
menu
nous donne alors un accès très rapide à une sélection de différentes fonctions
Python
classées par catégories correspondant justement à des modules.

Outre le module
builtins
(intégrés)
, nous notons donc la disponibilité des modules :
  • math
  • random
    pour les fonctions aléatoires
  • ti_plotlib
    , module de tracé par coordonnées
  • ti_hub
    pour les projets d'objets connectés avec l'interface
    TI-Innovator Hub
  • ti_rover
    pour les projets de robotique avec le robot
    TI-Innovator Rover


Une sélection complémentaire de modules est également accessible via un sous-menu :
  • cmath
    pour les fonctions relatives aux nombres imaginaires/complexes
    (Option Maths Expertes + série STI2D)
  • time
  • ti_system
  • ti_draw
    , module de tracé par pixels
  • ti_image
    , autre module de tracé par pixels


Mais nous savons par expérience que tous les modules disponibles ne sont pas forcément au menu. Tentons donc d'en demander une liste via la fonction
help()
, et plus précisément help('modules').

Nous obtenons alors une liste qui n'est pas complète, reprenant certains des modules précédents mais pas tous. Par contre, elle nous en annonce d'autres que voici :
  • array
  • binascii
  • collections
  • ctypes
  • errno
  • gc
  • hashlib
  • heapq
  • micropython
  • re
  • sys
  • ti_picture
  • ti_st

Commençons par traiter les modules
Python
standard. Nous indiquerons en rouge les modules qui ne sont utilisables qu'hors examen.

La solution
Python
de la
TI-Nspire CX II
semble être excellente niveau standard avec pas moins de
16
modules, de loin la meilleure sélection officielle sur ce critère, aussi bien en examen qu'en classe ! :bj:
TI-
83PCE
TI-
Python
TI-
83PCE
Edition
Python
TI-
84+CE-T
Python
Edition
TI-
Nspire
CX II
Casio
Graph
90+E
35+E II
Num
Works
HP
Prime

α
TI-
83PCE
TI-
Python

tiers
TI-
Nspire
CX


Casio
Graph
35/75+E
35+E II

Num
Works

Num
Works


builtins
array
(u)binascii
board
cmath
(u)collections
(u)ctypes
(u)errno
gc
(u)hashlib
(u)heapq
(u)io
(u)json
linalg
math
matplotlib
.pyplot
micropython
numpy
os
(u)random
(u)re
storage
(u)struct
sys
time
(u)timeq
turtle
(u)zlib
TOTAL


.
.
.

.
.

.
.
.
.
.

.
.
.
.
.

.
.
.


.
.
.
8


.
.
.

.
.

.
.
.
.
.

.
.
.
.
.

.
.
.


.
.
.
8


.
.
.

.
.

.
.
.
.
.

.
.
.
.
.

.
.
.


.
.
.
8



.







.
.
.

.
.

.
.


.
.


.
.
.
16

.
.
.
.
.
.
.
.
.
.
.
.
.

.

.
.
.

.
.
.
.
.
.

.
3-
5

.
.
.

.
.
.
.
.
.
.
.
.




.
.

.
.
.
.

.

.
9


.
.

.
.


.
.
.
.
.

.
.

.
.
.
.
.
.

.
.
.
.
8


.



.
.

.
.
.
.
.

.
.

.


.

.


.
.
.
13


.
.

.
.
.

.
.
.
.
.

.
.

.
.
.
.
.
.

.
.
.
.
7

.

.











.






.


.
.


23


.
.

.
.
.

.
.
.
.
.

.
.

.
.

.
.
.

.
.
.
.
8

.
.
.

.
.
.
.
.
.
.
.
.




.


.
.
.
.

.

.
10

.

.



.







.






.


.



23


Passons maintenant aux modules propriétaires lorsque disponibles :
TI-
83PCE
Edition
Python
TI-
84+CE-T
Python
Edition
TI-
Nspire
CX II
Casio
Graph
90+E
35+E II
Num
Works
HP
Prime

α
TI-
Nspire
CX


Num
Works

Num
Works


analogin
analogout
bbport
brightns
ce_box
ce_chart
ce_quivr
ce_turtl

color
colorinp
conservo
dht
digital
led
light
lightlvl
loudness
magnetic
mb_butns
mb_disp
mb_grove
mb_music
mb_neopx
mb_pins
mb_radio
mb_sensr
microbit

moisture
potentio
power
ranger
relay
rgb
rgb_arr
sound
squarewv
temperat
thermist
ti_graphics
ti_hub
ti_plotlib
ti_rover
ti_system
speaker
timer
vernier
vibmotor
analogin
analogout
bbport
brightns
ce_box
ce_chart
ce_quivr
ce_turtl
color
colorinp
conservo
dht
digital
led
light
lightlvl
loudness
magnetic
mb_butns
mb_disp
mb_grove
mb_music
mb_neopx
mb_pins
mb_radio
mb_sensr
microbit
moisture
potentio
power
ranger
relay
rgb
rgb_arr
sound
squarewv
temperat
thermist
ti_graphics
ti_hub
ti_plotlib
ti_rover
ti_system
speaker
timer
vernier
vibmotor
ti_draw
ti_hub
ti_image
ti_innovator
ti_picture
ti_plotlib
ti_rover
ti_st
ti_system
casioplot
ion
kandinsky
prime
nsp
arit
cas
graphic
nsp
ion
kandinsky
arit
cas
graphic
nsp
34-
47
47
9
1
2
1
1
4
2
4


Il ne nous semble pas pertinent de baser un classement comparatif sur les modules propriétaires, un unique module sur un modèle haut de gamme pouvant apparemment être éclaté en plein de petits modules différents sur un modèle disposant de moins de mémoire. Il faudrait en fait regarder le contenu, ce que nous ferons plus loin. En attendant, voici donc un classement donnant la priorité aux modules standard :
  1. 16
    modules standard +
    9
    modules propriétaires
    :
    TI-Nspire CX II
  2. 9
    modules standard +
    2
    modules propriétaires
    :
    NumWorks
  3. 8
    modules standard +
    34
    modules propriétaires
    :
    TI-83 Premium CE Edition Python
  4. 8
    modules standard +
    1
    module propriétaire
    :
    HP Prime
    (version alpha)
  5. 3
    modules standard +
    1
    module propriétaire
    :
    Casio Graph 90+E / 35+E II
  1. 23
    modules standard +
    4
    modules propriétaires
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  2. 16
    modules standard +
    9
    modules propriétaires
    :
    TI-Nspire CX II
  3. 10
    modules standard +
    2
    modules propriétaires
    :
    NumWorks
    (firmware Omega)
  4. 9
    modules standard +
    2
    modules propriétaires
    :
    NumWorks
  5. 8
    modules standard +
    34
    modules propriétaires
    :
    TI-83 Premium CE Edition Python
  6. 8
    modules standard +
    1
    module propriétaire
    :
    HP Prime
    (version alpha)
  7. 3
    modules standard +
    1
    module propriétaire
    :
    Casio Graph 90+E / 35+E II
  1. 16
    modules standard +
    9
    modules propriétaires
    :
    TI-Nspire CX II
  2. 9
    modules standard +
    2
    modules propriétaires
    :
    NumWorks
  3. 8
    modules standard +
    47
    modules propriétaires
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
  4. 8
    modules standard +
    1
    module propriétaire
    :
    HP Prime
    (version alpha)
  5. 8
    modules standard :
    TI-83 Premium CE + TI-Python
  6. 5
    modules standard +
    1
    module propriétaire
    :
    Casio Graph 90+E / 35+E II
  1. 23
    modules standard +
    4
    modules propriétaires
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
    +
    TI-Nspire CX
  2. 16
    modules standard +
    9
    modules propriétaires
    :
    TI-Nspire CX II
  3. 13
    modules standard :
    TI-83 Premium CE + TI-Python
  4. 10
    modules standard +
    2
    modules propriétaires
    :
    NumWorks
    (firmware Omega)
  5. 9
    modules standard +
    2
    modules propriétaires
    :
    NumWorks
  6. 8
    modules standard +
    47
    modules propriétaires
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
  7. 8
    modules standard +
    1
    module propriétaire
    :
    HP Prime
    (version alpha)
  8. 8
    modules standard :
    TI-83 Premium CE + TI-Python
    +
    Casio Graph 35/75+E
    (appli CasioPython)
  9. 7
    modules standard +
    1
    module propriétaire
    :
    TI-Nspire
  10. 5
    modules standard +
    1
    module propriétaire
    :
    Casio Graph 90+E / 35+E II




4) Saisie et assistant d'aide à la saisie :

Go to top

Exclusivité de la solution
Python
TI-Nspire CX II
à ce jour, nous y disposons d'un formidable assistant d'aide à la saisie, à un niveau jusqu'à présent jamais vu.

L'assistant est fonctionnel aussi bien dans l'éditeur que dans la console, dans le contexte des saisies effectuées via un menu.

Par exemple ci-contre avec l'insertion via le menu de blocs d'instructions
if
et
for
.

Les différents éléments que tu te dois de compléter dans la saisie te sont notés en gris clair, avec même une inscription indicative. C'est un peu comme un texte à trous. :)

Si ton curseur se trouve dans l'une des zones en question son affichage passe en inversé. Pas besoin non plus de t'acharner sur les touches fléchées pour aller rejoindre les différents bouts à compléter, tu peux passer instantanément au prochain élément à compléter à l'aide de la touche
tab
! :bj:

Cette formidable assistance à la saisie marche de façon similaire avec les paramètres d'appels de fonction insérés via les menus ! :bj:

D'ailleurs sur certaines fonctions, l'activation d'un des paramètres à compléter pourra même t'afficher des explications ou indications complémentaires sur la saisie attendue ! :bj:


Sur d'autres paramètres ne pouvant prendre qu'un nombre fini de valeurs, l'activation de leur zone de saisie affichera automatiquement un menu contextuel à partir duquel tu pourras saisir instantanément l'une des valeurs autorisées ! :bj:

Dans le cas où les valeurs autorisées sont trop nombreuses, tu pourras à la place obtenir ici encore une indication fort utile sous forme d'info bulle.

Enfin, précisons que la saisie d'un point à la suite d'un objet de type prédéfini proposant des méthodes ou sous objets, pourra t'afficher automatiquement un menu contextuel avec les choix en question, et que tu bénéficieras encore dans ce contexte de toutes les fonctionnalités de l'assistant ! :bj:

Cet assistant d'aide à la saisie
TI-Nspire CX II
est véritablement exceptionnel et va te permettre d'être encore plus efficace et autonome, minimisant les besoins d'aller recourir à une quelconque documentation ! :favorite:




5) Mémoire pile/stack :

Go to top

Les interpréteurs
MicroPython
ou similaires qui tournent sur calculatrices font appel à différents types de mémoires. La pile
(stack)
référence, à l'exécution, les objets
Python
créés. Sa capacité limite donc le nombre d'objets
Python
pouvant coexister simultanément en mémoire.

Tentons donc de déclencher une consommation massive de
stack
, afin de pouvoir comparer et voir comment s'en sortent la
TI-Nspire CX II
et les autres. Une situation très simple qui peut être grand consommatrice de stack c'est la récursivité, soit les fonctions qui se rappellent elles-mêmes. Prenons le script suivant, issu du
QCC 2020
:
Code: Select all
def compte_r(n):
  return n>0 and 1 + compte_r(n-1)

def test(f):
  n = 0
  try:
    while 1:
      n = f(n) + 1
  except Exception as e:
    print(e)
  return n

Nous atteignons donc sur
TI-Nspire CX II
un maximum de
202
niveaux de récursion avant erreur. C'est extraordinaire, à la fois le record de toutes les solutions officielles, et le record de toutes les solutions compatibles avec une utilisation mode examen ! :bj:

D'où le classement des solutions
Python
niveau
stack
:
  1. 202
    :
    TI-Nspire CX II
  2. 129
    :
    NumWorks
  3. 82
    :
    Casio Graph 90+E / 35+E II
  4. 77
    :
    HP Prime
    (version alpha)
  5. 28
    :
    TI-83 Premium CE Edition Python
  1. 202
    :
    TI-Nspire CX II
  2. 129
    :
    NumWorks
  3. 126
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  4. 82
    :
    Casio Graph 90+E / 35+E II
  5. 77
    :
    HP Prime
    (version alpha)
  6. 28
    :
    TI-83 Premium CE Edition Python
  1. 202
    :
    TI-Nspire CX II
  2. 129
    :
    NumWorks
  3. 82
    :
    Casio Graph 90+E / 35+E II
  4. 77
    :
    HP Prime
    (version alpha)
  5. 28
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
  6. 20
    (
    45,74%
    contigu)
    :
    TI-83 Premium CE + TI-Python
  1. 5362
    :
    Casio Graph 35/75+E
    (appli CasioPython)
  2. 655
    :
    Casio Graph 35+E II
    (appli CasioPython)
  3. 202
    :
    TI-Nspire CX II
  4. 155
    :
    TI-Nspire CX
  5. 130
    :
    TI-Nspire
  6. 129
    :
    NumWorks
  7. 126
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  8. 82
    :
    Casio Graph 90+E / 35+E II
  9. 77
    :
    HP Prime
    (version alpha)
  10. 28
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
  11. 20
    :
    TI-83 Premium CE + TI-Python
  12. 15
    :
    TI-83 Premium CE + TI-Python



6) Mémoire tas/heap :

Go to top

Les interpréteurs
MicroPython
ou similaires qui tournent sur calculatrices font appel à différents types de mémoires. Le tas
(heap)
stocke, à l'exécution, le contenu des objets
Python
créés. Il limite donc la taille globale utilisée pour les données de ces différents objets.

Nous avons justement la chance ici de disposer du module
gc
, avec plusieurs fonctions bien utiles :
  • gc.collect() pour nettoyer le
    heap
    en supprimant les valeurs d'objets
    Python
    qui ne sont plus référencées
  • gc.mem_alloc() pour connaître la consommation du
    heap
    en octets
  • gc.mem_free() pour connaître l'espace
    heap
    disponible en octets
Appelons donc le petit script suivant afin d'enfin découvrir la tant attendue taille de
heap
Python
TI-Nspire CX II
:
Code: Select all
import gc
a, f = mem_alloc(), mem_free()
(a, f, a + g)

Nous disposons donc ici d'un
heap
d'une capacité impressionnante, la plus grand actuellement parmi toutes les solutions concurrentes officielles,
2,073 Mo
, de quoi a priori te lancer dans des projets
Python
très ambitieux ! :#tritop#:
Plus précisément nous avons ici
2,072 Mo
de libres, mais auxquels il faut ajouter la taille consommée par l'importation du module
gc
.

Toutefois, toutes les calculatrices
Python
ne disposent pas du module
gc
. Afin de pouvoir faire des comparaisons équitables, nous allons construire notre propre script de test d'estimation de la capacité
heap
à partir des informations suivantes sur les tailles des objets
Python
, du moins sur les plateformes 32 bits que sont à ce jour nos calculatrices :
  • pour un entier nul :
    24
    octets déjà...
  • pour un entier court non nul
    (codable sur 31 bits + 1 bit de signe)
    :
    28
    octets
  • pour un entier long :
    • 28
      octets
    • +
      4
      octets pour chaque groupe de 30 bits utilisé par son écriture binaire au-delà des 31 bits précédents
  • pour une chaîne :
    • 49
      octets
    • +
      1
      octet par caractère
  • pour une liste :
    • 64
      octets
    • +
      8
      octets par élément
    • + les tailles de chaque élément
Nous allons donc tenter de remplir le
heap
avec plusieurs objets que nous allons faire grandir chacun son tour jusqu'à déclenchement d'une erreur, et retourner la capacité maximale que nous avons réussi à consommer.
Nous récupérerons de plus la plus grand taille d'objet que nous avons réussi à utiliser lors de ce test, on t'explique de suite.

Voici donc le script, toujours issu du
QCC 2020
:
Code: Select all
def size(o):
  t = type(o)
  s = t == str and 49 + len(o)
  if t == int:
    s = 24
    while o:
      s += 4
      o >>= 30
  elif t == list:
    s = 64 + 8*len(o)
    for so in o:
      s += size(so)
  return s

def mem(v=1):
  try:
    l=[]
    try:
      l.append(0)
      l.append(0)
      l.append("")
      l[2] += "x"
      l.append(0)
      l.append(0)
      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[3], l[4] = mem(v)
      except:
        pass
      return l[0] + l[3], max(l[0], l[4])
  except:
    return 0, 0

def testmem():
  m1, m2 = 0, 0
  while 1:
    t1, t2 = mem(0)
    if t1 > m1 or t2 > m2:
      m1 = max(t1, m1)
      m2 = max(t2, m2)
      input(str((m1,m2)))

On trouve bien sur
TI-Nspire CX II
une capacité
heap
de
2,067 Mo
proche de la mesure précédente, à laquelle bien sûr il faut rajouter la consommation du script que nous estimons à 1,056 Ko.
Nous avons ici en prime une autre valeur de
683,256 Ko
, correspondant à la taille du plus gros objet qui a pu être créé au cours du test et donc au plus grand espace libre disponible de façon contiguë dans le
heap
.

D'où le classement des solutions
Python
niveau
heap
:
  1. 2,068 Mo
    (
    33,36%
    contigu)
    :
    TI-Nspire CX II
  2. 1,033 Mo
    (
    38,18%
    contigu)
    :
    Casio Graph 90+E
  3. 1,014 Mo
    (
    38,91%
    contigu)
    :
    HP Prime
    (version alpha)
  4. 101,262 Ko
    (
    41,74%
    contigu)
    :
    Casio Graph 35+E II
  5. 33,545 Ko
    (
    40,58%
    contigu)
    :
    NumWorks
  6. 18,354 Ko
    (
    40,70%
    contigu)
    :
    TI-83 Premium CE Edition Python
  1. 2,068 Mo
    (
    33,36%
    contigu)
    :
    TI-Nspire CX II
  2. 1,033 Mo
    (
    38,18%
    contigu)
    :
    Casio Graph 90+E
  3. 1,014 Mo
    (
    38,91%
    contigu)
    :
    HP Prime
    (version alpha)
  4. 101,262 Ko
    (
    41,74%
    contigu)
    :
    Casio Graph 35+E II
  5. 64,954 Ko
    (
    33,69%
    contigu)
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  6. 33,545 Ko
    (
    40,58%
    contigu)
    :
    NumWorks
  7. 18,354 Ko
    (
    40,70%
    contigu)
    :
    TI-83 Premium CE Edition Python
  1. 2,068 Mo
    (
    33,36%
    contigu)
    :
    TI-Nspire CX II
  2. 1,033 Mo
    (
    38,18%
    contigu)
    :
    Casio Graph 90+E
  3. 1,014 Mo
    (
    38,91%
    contigu)
    :
    HP Prime
    (version alpha)
  4. 101,262 Ko
    (
    41,74%
    contigu)
    :
    Casio Graph 35+E II
  5. 33,545 Ko
    (
    40,58%
    contigu)
    :
    NumWorks
  6. 20,839 Ko
    (
    45,74%
    contigu)
    :
    TI-83 Premium CE + TI-Python
  7. 18,354 Ko
    (
    40,70%
    contigu)
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
  1. 4,100 Mo
    (
    38,40%
    contigu)
    :
    TI-Nspire CX
  2. 2,068 Mo
    (
    33,36%
    contigu)
    :
    TI-Nspire CX II
  3. 2,050 Mo
    (
    32,35%
    contigu)
    :
    TI-Nspire
  4. 1,033 Mo
    (
    38,18%
    contigu)
    :
    Casio Graph 90+E
  5. 1,014 Mo
    (
    38,91%
    contigu)
    :
    HP Prime
    (version alpha)
  6. 258,766 Ko
    (
    38,51%
    contigu)
    :
    Casio Graph 35/75+E
    (appli CasioPython)
  7. 101,262 Ko
    (
    41,74%
    contigu)
    :
    Casio Graph 35+E II
  8. 64,954 Ko
    (
    33,69%
    contigu)
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  9. 33,545 Ko
    (
    40,58%
    contigu)
    :
    NumWorks
  10. 32,648 Ko
    (
    41,70%
    contigu)
    :
    Casio Graph 35+E II
    (appli CasioPython)
  11. 23,685 Ko
    (
    40,24%
    contigu)
    :
    TI-83 Premium CE + TI-Python
  12. 20,839 Ko
    (
    45,74%
    contigu)
    :
    TI-83 Premium CE + TI-Python
  13. 18,354 Ko
    (
    40,70%
    contigu)
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python

En examen ou parmi les solutions officielles, la
TI-Nspire CX II
est la meilleure niveau
heap
! :bj:




7) Module sys - implémentation et entiers :

Go to top

Un module très intéressant à explorer pour découvrir des choses, c'est le module standard
sys
. Il n'est certes pas au menu, mais on peut quand même obtenir la liste des différents éléments qu'il permet d'appeler via un simple dir(sys).

sys.platform == 'TI-Nspire' sera par exemple une astuce de test bien utile pour tes scripts en ayant besoin d'identifier la plateforme sur laquelle ils tournent.

Comme on pouvait s'en douter sys.implementation nous confirme que nous sommes sur un
Micropython
, en précisant qu'il s'agit d'une version
1.11.0
, et implémentant lui-même le
Python 3.4.0
comme l'indique sys.version.

sys.maxsize pour sa part indique le plus grand entier pouvant être codé nativement sur la plateforme utilisée, avec ici une organisation
little endian
comme l'indique sys.byteorder. sys.maxsize détermine la taille maximale de nombre de structures telles les listes. Les variables peuvent quand même prendre des valeurs entières supérieures qui sont alors gérées logiciellement en tant qu'entiers longs.

Sur toute la concurrence nous avions jusqu'à présent sys.maxsize == 2**31 -1, valeur habituelle pour les plateformes 32 bits, 1 bit étant réservé pour le signe.

Nous sommes donc très surpris ici de constater un sys.maxsize == 2**63 -1 plutôt caractérique des plateformes 64 bits, alors que le processeur des
TI-Nspire CX II
est un 32 bits, un
ARM9/ARMv5
.




8) Module ti_system - intégration, clavier et souris :

Go to top

Tentons maintenant d'en apprendre davantage sur la valeur ajoutée apportée par
Texas Instruments
à la solution
Python
de la
TI-Nspire CX II
. Nous allons pour cela explorer les modules propriétaires ; commençons par regarder du côté du module système de
Texas Instruments
, le
ti_system
, et nous évoquerons le module du même nom sur
TI-83 Premium CE Edition Python
.

Chez la concurrence à ce jour, l'application
Python
a le défaut de tourner en vase clos dans son coin. Elle ne permet pas de partager des données avec le reste des applications de la calculatrice, et ne s'intègre donc pas naturellement dans la démarche de résolution d'un problème.

Texas Instruments
avait déjà proposé un début d'intégration du
Python
à l'environnement mathématique de la calculatrice avec le module de la
TI-83 Premium CE Edition Python
. Au menu la possibilité de faire rentrer et sortir des données de l'application
Python
:
  • importation dans l'application
    Python
    de variables de type liste existant dans l'environnement de la calculatrice
  • exportation depuis l'application
    Python
    de variables de type liste vers l'environnement de la calculatrice
Listes de nombres réels uniquement, les nombres complexes étant exclus. Les mêmes données devenaient ainsi traitables sous différentes applications pour une bien meilleure recherche et résolution de problème, faisant intervenir diverses représentations et compétences.

Une fonctionnalité toujours exclusive à
Texas Instruments
à ce jour et que nous avons le grand plaisir de retrouver ici avec les fonctions
store_list()
et
recall_list()
. :bj:

Texas Instruments
en profite même pour étendre la chose.
store_value()
et
recall_value()
te permettront la même chose mais cette fois-ci avec des variables numériques
(réelles)
.

Texas Instruments
va même beaucoup plus loin que ça avec
eval_function()
. Cette fonction permet à tes scripts
Python
de faire appel à une fonction définie dans ton classeur courant, fonctions à une variable uniquement mais c'est déjà un très bon début ! :bj:

Autre bonne nouvelle, nous avons de quoi tester la pression sur les touches clavier. Non pas une fonction
wait_key()
blocante ne permettant pas de coder autre chose que des menus et jeux tour par tour comme sur
TI-83 Premium CE
, mais un véritable
get_key()
non blocant qui te donnera une totale liberté pour tes projets d'interfaces et jeux ! :bj:
La fonction
get_key()
renvoie une chaîne de caractères, identifiant la touche ou combinaison de touches pressée, et en voici une petite carte afin de t'y retrouver :
esc
up
home
scratchpad
left
center
right
doc
tab
down
menu
var
del

=
trig
7
8
9
template
cat
^
square
4
5
6
*
/
exp
10power
1
2
3
+
-
(
)
0
.
enter

E
A/a
B/b
C/c
D/d
E/e
F/f
G/g
?!
pi
H/h
I/i
J/j
K/k
L/l
M/m
N/n
,
O/o
P/p
Q/q
R/r
S/s
T/t
U/u
return
V/v
W/w
X/x
Y/y
Z/z
/_


Enfin tu vas ici pouvoir donner une toute nouvelle dimension à tes projets d'interfaces en
Python
, car tu disposes même d'une fonction
get_mouse()
pour tester la position du pointeur souris ! :bj:




9) Module de tracé par pixels ti_draw :

Go to top

ti_draw
est donc le module de tracé par pixels de la
TI-Nspire CX II
. Avec un nom différant du
ti_graphics
de la
TI-83 Premium CE Edition Python
nous ne nous attendons certes pas à de la compatibilité, mais également pas au même fonctionnement.

Déjà à la différence de ce dernier, nous notons ici la possibilité d'utiliser du
double-buffering
.

get_screen_dim()
nous apprend que la zone graphique que l'on contrôle fait
318×212
pixels, comme pour les scripts
Lua
supportés depuis la version
3.0
.
A la différence près que pour les scripts
Lua
la zone graphique était liée aux dimensions de l'application concernée. Ici cela semble être indépendant. L'affichage graphique ne semble pas être redimensionnable et se fait toujours sur une fenêtre
popup
plein écran offrant donc
318×212
pixels.

set_pen("épaisseur", "style") permet de régler la plume du stylo. La fonction accepte les paramètres listés ci-contre par l'assistant de saisie, mais également des numéros selon les équivalences suivantes :
  • 0 = thin
  • 1 = medium
  • 2 = thick
  • 0 = solid
  • 1 = dotted
  • 2 = dashed

Nous allons t'illustrer de suite ce que les différentes combinaisons de réglages signifient :
Code: Select all
import ti_draw as scr

sw, sh = scr.get_screen_dim()
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, sw - 1, th, sh - 1

nta, nty = 3, 3
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)

for i in range(nty):
  scr.draw_text(xmin-tw, ly[i*2], str(i))
  for j in range(nta):
    scr.draw_text(lx[j*2], ymin+th, str(j))
    scr.set_pen(j, i)
    scr.draw_line(lx[j*2], ly[i*2], lx[j*2 + 1], ly[i*2])


Nous notons donc diverses fonctions de tracé de primitives :
  • draw_line(x1, y1, x2, y2) : segment
  • draw_rect(x, y, largeur, hauteur) : rectangle
  • fill_rect(x, y, largeur, hauteur) : rectangle plein
  • draw_circle(x, y, rayon) : cercle
  • draw_arc(x, y, largeur, hauteur, angle_initial, angle_de_l_arc) : arc d'ellipse
  • fill_arc(x, y, largeur, hauteur, angle_initial, angle_de_l_arc) : secteur d'ellipse
  • draw_poly(x_liste, y_liste) : polygone
  • fill_poly(x_liste, y_liste) : polygone plein
  • plot_xy(x, y, figure)
  • draw_text(x, y, ...)

La fonction
draw_poly()
permet donc de tracer une ligne brisée.
La fonction
fill_poly()
permet quant à elle de colorier le polygone obtenu en fermant cette ligne brisée.
Code: Select all
import ti_draw as scr

sw, sh = scr.get_screen_dim()
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, sw - 1, th, sh - 1

nta, nty = 3, 3
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)

for i in range(nty):
  scr.draw_text(xmin-tw, ly[i*2], str(i))
  for j in range(nta):
    scr.draw_text(lx[j*2], ymin+th, str(j))
    scr.set_pen(j, i)
    scr.set_color((255,0,0))
    scr.fill_poly([lx[j*2], lx[j*2 + 1], lx[j * 2], lx[j*2 + 1]], [ly[i*2], ly[i*2], ly[i*2+1], ly[i*2+1]])
    scr.set_color((0,0,0))
    scr.draw_poly([lx[j*2], lx[j*2 + 1], lx[j * 2], lx[j*2 + 1]], [ly[i*2], ly[i*2], ly[i*2+1], ly[i*2+1]])


drawRect(x, y, w, h) permet donc de tracer un rectangle :
  • de dimensions
    w
    et
    h
    données en pixels
  • aux côtés parallèles aux bords de l'écran
  • et en utilisant le point de coordonnées
    (x, y)
    comme sommet supérieur gauche
La fonction
fillRect()
quant à elle permet de colorier le rectangle en question.
Code: Select all
import ti_draw as scr

sw, sh = scr.get_screen_dim()
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, sw - 1, th, sh - 1

nta, nty = 3, 3
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)

for i in range(nty):
  scr.draw_text(xmin-tw, ly[i*2], str(i))
  for j in range(nta):
    scr.draw_text(lx[j*2], ymin+th, str(j))
    scr.set_pen(j, i)
    scr.set_color((255,0,0))
    scr.fill_rect(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2])
    scr.set_color((0,0,0))
    scr.draw_rect(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2])


Voici maintenant du lourd avec drawArc(x, y, w, h, t1, t2) et fillArc(x, y, w, h, t1, t2) :
Code: Select all
import ti_draw as scr

sw, sh = scr.get_screen_dim()
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, sw - 1, th, sh - 1

nta, nty = 3, 3
lx = [xmin + k*(xmax-xmin)/(2*nta+1) for k in range(1, 2*nta+1)]
ly = [ymin + k*(ymax-ymin)/(2*nty+1) for k in range(1, 2*nty+1)]
l = (xmax-xmin+1) / (2*nta+1)

for i in range(nty):
  scr.draw_text(xmin-tw, ly[i*2], str(i))
  for j in range(nta):
    scr.draw_text(lx[j*2], ymin+th, str(j))
    scr.set_pen(j, i)
    scr.set_color((255,0,0))
    scr.fill_arc(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2], 0, 315)
    scr.set_color((0,0,0))
    scr.draw_arc(lx[j*2], ly[i*2], lx[j*2+1]-lx[j*2], ly[i*2+1]-ly[i*2], 0, 315)

La fonction drawArc(x, y, dx, dy, t1, t2) permet donc de tracer un arc d'une ellipse elle-même inscrite dans un rectangle :
  • de dimensions
    w
    et
    h
    données en pixels
  • aux côtés parallèles aux bords de l'écran
  • et en utilisant le point de coordonnées
    (x, y)
    comme sommet supérieur gauche
t1
et
t2
sont les angles au centre orientés délimitant l'arc en question, exprimés en degrés.

Et la fonction
fillArc()
permet quant à elle de colorier le secteur d'ellipse obtenu par balayage de l'arc en question.

draw_text(x, y, 'texte') écrit bien évidemment du texte en prenant les coordonnées spécifiées comme coin supérieur gauche :
Code: Select all
import ti_draw as scr

sw, sh = scr.get_screen_dim()
tw = 10
s = 'Thank you TI'
xmin, xmax, ymin, ymax = 0, sw - 1, 0, sh - 1
x, y, dx, dy = xmin, ymin, 1, 9

while x <= xmax - tw*len(s):
  scr.draw_text(x, y, s)
  y += dy
  x += dx
  dx += 1


Enfin,
plot_xy(x, y, style)
te permet d'allumer un point, et selon pas moins de 13 formes prédéfinies selon l'assistant de saisie ! :o

Tentons donc de découvrir tout cela :
Code: Select all
import ti_draw as scr

sw, sh = scr.get_screen_dim()
tw, th = 8, 15
xmin, xmax, ymin, ymax = tw, sw - 1, th, sh - 1

n = 13
lx = [xmin + k*(xmax-xmin)/(2*n+1) for k in range(1, 2*n+1)]
y = ymin + (ymax-ymin)/2
l = (xmax-xmin+1) / (2*n+1)

for j in range(n):
  scr.draw_text(lx[j*2], ymin+th, str(j + 1))
  scr.plot_xy(lx[j*2+1], y ,j + 1)

Si l'on souhaite allumer un simple pixel, c'est donc la forme numéro 7.

Petit classement déjà en terme de zone graphique :
  1. 320×240
    =
    76800
    pixels :
    HP Prime
    (version alpha)
  2. 384×192
    =
    73728
    pixels :
    Casio Graph 90+E
  3. 320×222
    =
    71040
    pixels :
    NumWorks
  4. 318×212
    =
    67416
    pixels :
    TI-Nspire CX II
  5. 320×210
    =
    67200
    pixels :
    TI-83 Premium CE Edition Python
  6. 128×64
    =
    8192
    pixels :
    Casio Graph 35+E II
  1. 320×240
    =
    76800
    pixels :
    HP Prime
    (version alpha)
  2. 384×192
    =
    73728
    pixels :
    Casio Graph 90+E
  3. 320×222
    =
    71040
    pixels :
    NumWorks
  4. 318×212
    =
    67416
    pixels :
    TI-Nspire CX II
  5. 320×210
    =
    67200
    pixels :
    TI-83 Premium CE Edition Python
  6. 128×64
    =
    8192
    pixels :
    Casio Graph 35+E II
  1. 320×240
    =
    76800
    pixels :
    HP Prime
    (version alpha)
  2. 384×192
    =
    73728
    pixels :
    Casio Graph 90+E
  3. 320×222
    =
    71040
    pixels :
    NumWorks
  4. 318×212
    =
    67416
    pixels :
    TI-Nspire CX II
  5. 320×210
    =
    67200
    pixels :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
  6. 128×64
    =
    8192
    pixels :
    Casio Graph 35+E II
  1. 320×240
    =
    76800
    pixels :
    TI-Nspire
    +
    HP Prime
    (version alpha)
  2. 384×192
    =
    73728
    pixels :
    Casio Graph 90+E
  3. 320×222
    =
    71040
    pixels :
    NumWorks
    +
    TI-Nspire CX
  4. 318×212
    =
    67416
    pixels :
    TI-Nspire CX II
  5. 320×210
    =
    67200
    pixels :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
  6. 128×64
    =
    8192
    pixels :
    Casio Graph 35+E II


Mais si donc nous venons de terminer avec une fonction permettant d'allumer un pixel, nous n'avons pas vu de trace de fonction permettant de tester l'état d'un pixel.
C'est en fait que nous n'en avons pas terminé avec les modules de tracé par pixels... ;)




10) Module de tracé par pixels ti_image :

Go to top

ti_image
est donc un module de tracé par pixels complémentaire du précédent, avec a priori pas beaucoup de fonctions.

Comme son nom l'indique, il permet de charger et afficher des images. Il s'agit ici d'images insérées en tant que ressources dans ton classeur, il te faudra pour cela utiliser le logiciel
TI-Nspire
et l'éditeur de script
Lua
.

L'objet image
Python
correspondant est ensuite créé d'un simple img = load_image(n), mais pas affiché.

En fait c'est l'objet image ainsi créé qui apporte les fonctions utiles, dont ici le img.show_image(x, y).

Une gestion des images qui a ici le gros avantage de ne nécessiter que 2 lignes de code en
Python
, de ne pas inclure les données des images dans ton script
Python
, et donc d'économiser grandement la consommation du
heap
! :bj:

Par contre, il n'y aurait pas comme un petit
bug
, non ?

Le module
ti_image
semble afficher les ressources images du classeur à l'envers... alors que l'image en question avait un aperçu correct dans l'éditeur montré précédemment, et que la même ressource est visiblement affichée correctement ci-contre par un script
Lua
.
Code: Select all
img = image.new(_R.IMG.g200)

function on.paint(gc)
  gc:drawImage(img, 0, 0)
end


Mais
ti_image
est très loin de ne servir qu'aux images... ;)

En réalité il s'agit d'un module qui permet en fait de travailler en pixels sur des calques hors écran, autant de calques que tu veux. Un calque se crée dans la couleur que tu souhaites d'un simple layer = new_image(w, h, (r, g, b)), et tu disposes ensuite de méthodes
set_pixel()
et enfin
get_pixel()
pour faire tout ce que tu veux avec ! :bj:

Très pratique ces deux dernières fonctions également pour faire du traitement d'image en SNT. ;)




11) Module de tracé par pixels ti_picture :

Go to top

ti_picture
est donc quant à lui un module de tracé par pixels secret, puisque n'étant pas au menu.

On peut l'interroger sur son contenu d'un dir(ti_picture).

Il semble bizarrement offrir quasiment les mêmes possibités que le module
ti_image
précédent...

A une petite différence près, c'est qu'ici les données des calques sont stockés sous le type standard
bytearray
au format
RGB
24 bits.

Selon comment tu souhaites travailler sur tes calques et images
(par pixels ou par octets)
, ainsi que le degré de compatibilité que tu souhaites te laisser avec d'autres plateformes,
ti_picture
pourra donc parfois être un meilleur choix que
ti_image
.




13) Bilan modules :

Go to top

Plus haut nous avions donc évalué la richesse de la plateforme en nous basant sur le nombre de modules standard disponibles. Nous avions exclu les modules propriétaires du classement, car cela n'avait pas de sens : un gros module propriétaire sur
TI-Nspire CX II
se voit découpé en plein de petits modules propriétaires sur
TI-83 Premium CE Edition Python
.

Tentons une autre approche incluant cette fois-ci les modules propriétaires avec le script suivant, initialement conçu pour notre classement
QCC 2020
. Et comme nous n'avions justement pas traité ce point publiquement dans ce contexte, c'est maintenant l'occasion :
Code: Select all
from autopfrm import *

pf = get_pf()
sh_inf = shell_infos(pf)

unsafe = ()
if pf == 4: #HP Prime
  unsafe = ('count','encode','endswith','find','format','index','islower','lstrip','replace','rfind','rindex','rsplit','rstrip','split','splitlines','startswith','strip','from_bytes','to_bytes','fromkeys','get','pop','setdefault','update','values','sort','__enter__','__exit__','read','readinto','readline','seek','write')
if pf == 5 or pf == 7 or pf == 9: #CasioPython / Nspire+NumWorks KhiCAS MicroPython
  unsafe = ('sys.argv', 'sys.path')

if pf >= 0:
  curline=0
  _p = print
  def print(*ls):
    global curline
    st=""
    for s in ls:
      if not(isinstance(s,str)):
        s=str(s)
      st=st+s
    stlines=1
    if sh_inf[1]:
        stlines += sh_inf[2]*int(len(st)/sh_inf[1])
    if curline+stlines>=sh_inf[0]:
      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):
  if str(obj).startswith("<module"): return False
  l = ()
  try: l = dir(obj)
  except: pass
  return len(l)

def explmodr(pitm, pitm_name_l=[], pitm_str_l=[], pitm_val_l=[], reset=True):
  global curline, found
  pitm_name=sstr(pitm)
  if(reset):
    curline=0
    found = []
    pitm_name_l=[pitm_name]
    pitm_str_l=[str(pitm)]
    pitm_val_l=[pitm]
  hd="."*(len(pitm_name_l)-1)
  c = 0
  l = sorted(dir(pitm))
  for i in range(len(l)):
    l[i] = (l[i], getattr(pitm, l[i]), str(l[i]))
  try:
    if not isinstanceof(pitm, str):
      for i in range(len(pitm)):
        l.append((pitm_name+'['+str(i)+']',pitm[i],str(pitm[i])))
  except: pass
  for itm in l:
    isFound = itm[0] in found
    c += not isFound
    isUnsafe = '.'.join(pitm_name_l + [itm[0]]) in unsafe or itm[0] in unsafe
    try:
      if isUnsafe: raise Exception
      print(hd+itm[0]+"="+str(itm[1]))
    except:
      print(hd+itm[0])
    if not isFound:
      found.append(itm[0])
    if not isUnsafe and isExplorable(itm[1]) and itm[1] not in pitm_val_l and itm[2] not in pitm_str_l:
      pitm_name_l2, pitm_val_l2, pitm_str_l2 = pitm_name_l.copy(), pitm_val_l.copy(), pitm_str_l.copy()
      pitm_name_l2.append(itm[0])
      pitm_val_l2.append(itm[1])
      pitm_str_l2.append(itm[2])
      c += explmodr(itm[1], pitm_name_l2, pitm_str_l2, pitm_val_l2, False)
  return c

def explmod(s):
  global found
  module = __import__(s)
  found = []
  return explmodr(module)
Code: Select all
# detects calculator Python platform
def get_pf():
  c256 = True
  try:
    if chr(256)==chr(0):
      # Xcas/KhiCAS Python compatibility
      if "HP" in version():
        return 13 # HP Prime
      else:
        if not white:
          return 12 # Graph 35+E II
        elif "Numworks" in version():
          return 10 # NumWorks
        elif "Nspire" in version():
          return 8 # Nspire
        else: # Graph 90+E
          return 11
  except:
    c256 = False
  try:
    import sys
    try:
      if sys.platform == "nspire":
        try: # Nspire Ndless
          import graphic
          return 7 # KhiCAS Micropython
        except: # MicroPython
          return 6
      elif sys.platform == "TI-Nspire":
        return 3 # Nspire CX II
      elif sys.platform == "numworks":
        return 9 # NumWorks KhiCAS Micropython
      elif sys.platform.startswith('TI-Python'):
        return 2 # 83P/84+ CE
    except: # Graph 35+E/USB / 75/85/95
      return 5
  except:
    pass
  if not c256:
    return 1 # Graph 90/35+E II
  try:
    import kandinsky
    return 0 # NumWorks
  except:
    try: # HP Prime
      import hpprime
      return 4
    except:
      pass
  return -1

#return get_pixel and set_pixel functions for the platform
gp_prime = lambda x, y: GETPIX_P(x, y)
sp_prime = lambda x, y, c: PIXON_P(x, y, c)
def get_pixel_functions(pf):
  gp, sp = lambda: None, lambda: None
  if pf == 0: # NumWorks
    import kandinsky
    gp, sp = kandinsky.get_pixel, kandinsky.set_pixel
  elif pf == 1: # Graph 90/35+E II
    import casioplot
    gp, sp = casioplot.get_pixel, casioplot.set_pixel
  elif pf == 2: # 83P/84+ CE
    import ti_graphics
    gp, sp = ti_graphics.getPixel, ti_graphics.setPixel
  elif pf == 3: # Nspire CX II
    pass
  elif pf == 4: # HP Prime
    import hpprime
    sp = hpprime.pixon
  elif pf == 6: # Nspire: Ndless MicroPython
    from nsp import Texture
    canvas = Texture(320, 240, 0)
    gp, sp = canvas.getPx, canvas.setPx
  elif pf == 7 or pf == 9: # Nspire/NumWorks: KhiCAS-MicroPython
    import graphic
    gp, sp = graphic.get_pixel, graphic.set_pixel
  elif pf == 13: # HP Prime
    gp, sp = gp_prime, sp_prime
  return gp, sp

#returns platform shell infos : visible lines, visible columns, if larger strings are displayed on several lines or not
def shell_infos(pf):
  #NW small: [00] 12.5x30 -> 16   x 42
  #HP small: [03] 11.5x39 -> 15.5 x 45 [12] 14  x39 -> 18.5 x 45
  #HP big  : [03] 11.5x39 -> 09   x 35 [12] 14  x39 -> 11   x 35
  #                                       uPy     uPy
  #               G352            CPy uPy KhiCAS--------------->  CAS
  #           NW  G90 CE  CX2 HP  GXX NS  NS  NS  NW  NW  G90 G352HP
  l_vlines = (12, 07, 11, 11, 12, 09, 29, 11, 11, 11, 11, 09, 07, 14)
  l_vcols =  (30, 21, 32, 00, 39, 32, 53, 32, 32, 29, 29, 30, 19, 39)
  b_vcr = 0b1111100
  if pf >= 0:
    return l_vlines[pf], l_vcols[pf], b_vcr // 2**pf % 2
  else:
    return max(l_vlines), max(l_vcols), 1


L'appel explmod('nom_module') explore le module en question et en compte les différents éléments internes, en évitant les doublons :
TI-
83PCE
TI-
Python
TI-
83PCE
Edition
Python
TI-
84+CE-T
Python
Edition
TI-
Nspire
CX II
Casio
Graph
90+E
35+E II
Num
Works
HP
Prime

α
TI-
83PCE
TI-
Python

tiers
TI-
Nspire
CX


Casio
Graph
35/75+E
35+E II

Num
Works

Num
Works


builtins
array
(u)binascii
board
cmath
(u)collections
(u)ctypes
(u)errno
gc
(u)hashlib
(u)heapq
(u)io
(u)json
linalg
math
matplotlib
.pyplot
micropython
numpy
os
(u)random
(u)re
storage
(u)struct
sys
time
(u)timeq
turtle
(u)zlib
TOTAL
152
26
.
.
.
24
.
.
29
.
.
.
.
.
50
.
.
.
.
.
30
.
.
.
68
26
.
.
.
405
153
26
.
.
.
24
.
.
29
.
.
.
.
.
50
.
.
.
.
.
30
.
.
.
68
26
.
.
.
406
153
26
.
.
.
24
.
.
29
.
.
.
.
.
50
.
.
.
.
.
30
.
.
.
68
28
.
.
.
406
166
33
33
.
40
48
60
68
36
32
32
.
.
.
69
.
.
41
.
.
36
35
.
.
80
40
.
.
.
849
141
.
.
.
.
.
.
.
.
.
.
.
.
.
47
.
58

.
.
.
30
.
.
.
.
.
.
112

.
218-
388
146
.
.
.
34
.
.
.
.
.
.
.
.
.
63
25
22
29
.
.
31
.
.
.
.
25
.
62
.
437
165
32
.
.
40
.
.
68
36
.
.
.
.
.
69
.
.
37
.
.
.
.
.
.
80
.
.
.
.
527
154
27
.
22
35
25
.
.
30
.
.
.
.
.
64
.
.
29
.
38
31
.
45
.
71
31
.
.
.
602
160
30
.
.
38
.
.
.
33
.
.
.
.
.
67
.
.
29
.
.
.
.
.
.
62
.
.
.
.
419
165
.
31
.
38
46
66
66
34
30
30
45
31
67
69
.
44
34
81
28
34
34
.
32
73
.
.
82
32
1192
155
30
.
.
38
.
.
.
33
.
.
.
.
.
67
.
.
32
.
.
34
.
.
.
55
.
.
.
.
444
146
.
.
.
34
.
.
.
.
.
.
.
.
.
63
25
22
29
.
27
31
.
.
.
.
25
.
62
.
472
168
.
34
.
41
49
69
.
37
30
33
48
34
70
72
.
47
38
46
31
37
37
.
35
77
.
34
85
35
1187


Passons maintenant aux modules propriétaires lorsque disponibles :
TI-
83PCE
Edition
Python
TI-
84+CE-T
Python
Edition
TI-
Nspire
CX II
Casio
Graph
90+E
35+E II
Num
Works
HP
Prime

α
TI-
Nspire
CX


Num
Works

Num
Works


analogin:44
analogout:46
bbport:40
brightns:29
ce_box:32
ce_chart:58
ce_quivr:41
ce_turtl:65

color:30
colorinp:39
conservo:45
dht:45
digital:46
led:45
light:30
lightlvl:44
loudness:44
magnetic:46
mb_butns:38
mb_disp:40
mb_grove:51
mb_music:37
mb_neopx:54
mb_pins:48
mb_radio:40
mb_sensr:54
microbit:28

moisture:44
potentio:44
power:45
ranger:43
relay:45
rgb:45
rgb_arr:51
sound:29
squarewv:44
temperat:43
thermist:44
ti_graphics:67
ti_hub:42
ti_plotlib:78
ti_rover:79
ti_system:34
speaker:35
timer:35
vernier:44
vibmotor:45
analogin:44
analogout:46
bbport:40
brightns:29
ce_box:32
ce_chart:58
ce_quivr:41
ce_turtl:65
color:30
colorinp:39
conservo:45
dht:45
digital:46
led:45
light:30
lightlvl:44
loudness:44
magnetic:46
mb_butns:38
mb_disp:40
mb_grove:51
mb_music:37
mb_neopx:54
mb_pins:48
mb_radio:40
mb_sensr:54
microbit:28
moisture:44
potentio:44
power:45
ranger:43
relay:45
rgb:45
rgb_arr:51
sound:29
squarewv:44
temperat:43
thermist:44
ti_graphics:67
ti_hub:42
ti_plotlib:78
ti_rover:79
ti_system:34
speaker:35
timer:35
vernier:44
vibmotor:45
ti_draw:54
ti_hub:193
ti_image:53
ti_innovator:48
ti_picture:35
ti_plotlib:90
ti_rover:142
ti_st:41
ti_system:83
casioplot
ion:72
kandinsky:28
prime:30
nsp:10
arit:38
cas:28
graphic:55
nsp:37
ion:72
kandinsky:28
arit:41
cas:31
graphic:58
nsp:32
1509-
2095
2095
739
28
100
30
10
158
100
162


En comptant donc les modules non standard la
TI-Nspire CX II
reste parmi les meilleures solutions
Python
et c'est toujours
Texas Instruments
qui majore la promotion : :bj:

  1. 1915
    éléments +
    (dont
    406
    éléments standard)
    :
    TI-83 Premium CE Edition Python
  2. 1588
    éléments +
    (dont
    849
    éléments standard)
    :
    TI-Nspire CX II
  3. 557
    éléments +
    (dont
    527
    éléments standard)
    :
    HP Prime
    (version alpha)
  4. 537
    éléments +
    (dont
    437
    éléments standard)
    :
    NumWorks
  5. 246
    éléments +
    (dont
    218
    éléments standard)
    :
    Casio Graph 90+E / 35+E II
  1. 1915
    éléments +
    (dont
    406
    éléments standard)
    :
    TI-83 Premium CE Edition Python
  2. 1588
    éléments +
    (dont
    849
    éléments standard)
    :
    TI-Nspire CX II
  3. 1349
    éléments +
    (dont
    1187
    éléments standard)
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  4. 578
    éléments +
    (dont
    472
    éléments standard)
    :
    NumWorks
    (firmware Omega)
  5. 557
    éléments +
    (dont
    527
    éléments standard)
    :
    HP Prime
    (version alpha)
  6. 537
    éléments +
    (dont
    437
    éléments standard)
    :
    NumWorks
  7. 246
    éléments +
    (dont
    218
    éléments standard)
    :
    Casio Graph 90+E / 35+E II
  1. 2501
    éléments +
    (dont
    406
    éléments standard)
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
  2. 1588
    éléments +
    (dont
    849
    éléments standard)
    :
    TI-Nspire CX II
  3. 557
    éléments +
    (dont
    527
    éléments standard)
    :
    HP Prime
    (version alpha)
  4. 537
    éléments +
    (dont
    437
    éléments standard)
    :
    NumWorks
  5. 405
    éléments :
    TI-83 Premium CE + TI-Python
  6. 416
    éléments +
    (dont
    388
    éléments standard)
    :
    Casio Graph 90+E / 35+E II
  1. 2501
    éléments +
    (dont
    406
    éléments standard)
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
  2. 1588
    éléments +
    (dont
    849
    éléments standard)
    :
    TI-Nspire CX II
  3. 1350
    éléments +
    (dont
    1192
    éléments standard)
    :
    TI-Nspire CX
  4. 1349
    éléments +
    (dont
    1187
    éléments standard)
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  5. 602
    éléments :
    TI-83 Premium CE + TI-Python
  6. 578
    éléments +
    (dont
    472
    éléments standard)
    :
    NumWorks
    (firmware Omega)
  7. 557
    éléments +
    (dont
    527
    éléments standard)
    :
    HP Prime
    (version alpha)
  8. 537
    éléments +
    (dont
    437
    éléments standard)
    :
    NumWorks
  9. 429
    éléments +
    (dont
    419
    éléments standard)
    :
    TI-Nspire
  10. 416
    éléments +
    (dont
    388
    éléments standard)
    :
    Casio Graph 90+E / 35+E II
  11. 405
    éléments :
    TI-83 Premium CE + TI-Python
    +
    Casio Graph 35/75+E
    (appli CasioPython)




14) Performances en virgule flottante :

Go to top

Autre point très attendu, les performances du
Python
TI-Nspire CX II
. ;)

Commençons par les évaluer dans le contexte des calculs en virgule flottante à l'aide du script suivant, développé et utilisé pour le même si nous n'avons pas eu le temps de faire un compte-rendu public des résultats. Petit algorithme de seuil dans le contexte d'une suite récurrente, niveau Première :
Code: Select all
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]

Pour un appel de seuil(0.008), la
TI-Nspire CX II
te répond au quart de tour en seulement
0,24s
! :bj:

La
TI-Nspire CX II
est vraiment extraordinaire en calcul flottant
Python
écrasant toute concurrence de sa toute puissance, même en comptant les solutions
Python
tierces, et même en dopant la concurrence avec un
overclocking
au max ! :#tritop#:
  1. 0,24s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  2. 0,325s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  3. 0,376s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    compatibilité
    Python
    )
  4. 0,498s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  5. 0,785s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  6. 1,61s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    compatibilité
    Python
    )
  7. 3,27s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  8. 3,93s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  9. 9,21s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  1. 0,24s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  2. 0,325s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  3. 0,376s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    compatibilité
    Python
    )
  4. 0,498s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  5. 0,785s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  6. 1,61s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    compatibilité
    Python
    )
  7. 3,27s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  8. 3,93s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  9. 6,69s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité
    Python
    )
  10. 9,21s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  11. 33,41s
    :
    NumWorks N0110
    (Omega + KhiCAS
    Micropython
    )
  1. 0,24s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  2. 0,325s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  3. 0,376s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    compatibilité
    Python
    )
  4. 0,498s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  5. 0,785s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  6. 1,61s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    compatibilité
    Python
    )
  7. 3,27s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  8. 3,73s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  9. 3,93s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  10. 9,21s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  1. 0,24s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  2. 0,27s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz overclocké @
    222MHz
    Nover - + MicroPython)
  3. 0,325s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  4. 0,376s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    compatibilité
    Python
    )
  5. 0,38s
    :
    TI-Nspire
    (32 bits : ARM9/ARMv5 overclocké @120MHz @
    150MHz
    Nover - + MicroPython)
  6. 0,396s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz overclocké @
    222MHz
    Nover - + KhiCAS CX
    Micropython
    )
  7. 0,47s
    :
    TI-Nspire
    (32 bits : ARM9/ARMv5 @
    120MHz
    - + MicroPython)
  8. 0,48s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - + MicroPython)
  9. 0,498s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  10. 0,53s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz overclocké @
    216MHz
    Nover - + MicroPython)
  11. 0,59s
    :
    Casio Graph 35/75+E
    (32 bits : SH4 @29,49MHz overclocké @
    267,78MHz
    Ftune2 - CasioPython)
  12. 0,609s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - + KhiCAS CX
    Micropython
    )
  13. 0,65s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz overclocké @
    216MHz
    Nover - + KhiCAS CX
    Micropython
    )
  14. 0,68s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - + MicroPython)
  15. 0,785s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  16. 0,79s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @58,98MHz overclocké @
    274,91MHz
    Ftune3 - CasioPython)
  17. 0,868s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - + KhiCAS CX
    Micropython
    )
  18. 1,61s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    compatibilité
    Python
    )
  19. 1,86s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @58,98MHz overclocké @
    274,91MHz
    Ftune3)
  20. 2,15s
    :
    Casio Graph 90+E
    (32 bits : SH4 @117,96MHz overclocké @
    270,77MHz
    Ptune3)
  21. 2,96s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @58,98MHz overclocké @
    274,91MHz
    Ftune3 - KhiCAS)
  22. 3,27s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  23. 3,65s
    :
    Casio Graph 90+E
    (32 bits : SH4 @117,96MHz overclocké @
    270,77MHz
    Ptune3 - KhiCAS)
  24. 3,73s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  25. 3,9s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98
    - CasioPython)
  26. 3,93s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  27. 4s
    :
    Casio Graph 35/75+E
    (32 bits : SH4 @
    29,49MHz
    - CasioPython)
  28. 4,13s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz overclocké @
    222MHz
    Nover - + KhiCAS CX compatibilité
    Python
    )
  29. 4,4s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    CircuitPython)
  30. 5,45s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - + KhiCAS CX compatibilité
    Python
    )
  31. 5,48s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    - KhiCAS)
  32. 6,69s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité
    Python
    )
  33. 7,19s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz overclocké @
    216MHz
    Nover - + KhiCAS CX compatibilité
    Python
    )
  34. 7,63s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - + KhiCAS CX compatibilité
    Python
    )
  35. 9,21s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  36. 13,93s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    - KhiCAS)
  37. 33,41s
    :
    NumWorks N0110
    (Omega + KhiCAS
    Micropython
    )




15) Performances en calcul entier :

Go to top

Mais contrairement aux langages historiques de nos calculatrices, le
Python
distingue les nombres entiers des nombres flottants.

Pousuivons donc les tests de performances dans le contexte des nombres entiers, afin de voir si la
TI-Nspire CX II
s'en sort toujours aussi bien. Voici donc un script réalisant un test de primalité :
Code: Select all
try:from time import monotonic
except:pass

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

def nodivisorin(n,l):
  for k in l:
    if n//k*k==n:
      return False
  return True

def isprimep(n):
  t=hastime()
  s,l,k=0 or t and monotonic(),[3],7
  if n==2 or n==5:return True
  if int(n)!=n or n//2*2==n or n//5*5==5:
    return False
  if n<k:return n in l
  while k*k<n:
    if nodivisorin(k,l):l.append(k)
    k+=2+2*((k+2)//5*5==k+2)
  r=nodivisorin(n,l)
  return (t and monotonic() or 1)-s,r


La
TI-Nspire CX II
répond ici à l'appel isprimep(10000019) en
0,56s
! :bj:


  1. 0,56s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  2. 0,581s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  3. 0,974s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  4. 1,17s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  5. 1,58s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  6. 4,39s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  7. 4,42s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    )
  8. 9s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  9. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    )
  1. 0,56s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  2. 0,581s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  3. 0,974s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  4. 1,17s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  5. 1,58s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  6. 4,39s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  7. 4,42s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    )
  8. 9s
    :
    TI-83 Premium CE Edition Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  9. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    )
  10. 33,41s
    :
    NumWorks N0110
    (Omega + KhiCAS
    Micropython
    )
  11. 42,75s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité
    Python
    )
  1. 0,56s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  2. 0,581s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  3. 0,974s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  4. 1,17s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  5. 1,58s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  6. 4,39s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  7. 4,42s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    )
  8. 9s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  9. 11,26s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    CircuitPython)
  10. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    )
  1. 0,42s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz overclocké @
    222MHz
    Nover - + MicroPython)
  2. 0,511s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz overclocké @
    222MHz
    Nover - + KhiCAS CX
    Micropython
    )
  3. 0,56s
    :
    TI-Nspire CX II
    (32 bits : ARM9/ARMv5 @
    396MHz
    )
  4. 0,57s
    :
    TI-Nspire
    (32 bits : ARM9/ARMv5 overclocké @120MHz @
    150MHz
    Nover - + MicroPython)
  5. 0,58s
    :
    Casio Graph 35/75+E
    (32 bits : SH4 @29,49MHz overclocké @
    267,78MHz
    Ftune2 - CasioPython)
  6. 0,581s
    :
    NumWorks N0110
    (32 bits : Cortex-M7/ARMv7 @
    216MHz
    )
  7. 0,59s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @58,98MHz overclocké @
    274,91MHz
    Ftune3 - CasioPython)
  8. 0,62s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - + MicroPython)
  9. 0,63s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz overclocké @
    216MHz
    Nover - + MicroPython)
  10. 0,67s
    :
    TI-Nspire
    (32 bits : ARM9/ARMv5 @
    120MHz
    - + MicroPython)
  11. 0,794s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - + KhiCAS CX
    Micropython
    )
  12. 0,86s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @58,98MHz overclocké @
    274,91MHz
    Ftune3)
  13. 0,821s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz overclocké @
    216MHz
    Nover - + KhiCAS CX
    Micropython
    )
  14. 0,974s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    alpha)
  15. 0,99s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - + MicroPython)
  16. 1,08s
    :
    Casio Graph 90+E
    (32 bits : SH4 @117,96MHz overclocké @
    270,77MHz
    Ptune3)
  17. 1,17s
    :
    NumWorks N0100
    (32 bits : Cortex-M4/ARMv7 @
    100MHz
    )
  18. 1,18s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - + KhiCAS CX
    Micropython
    )
  19. 1,58s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    )
  20. 3,02s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98
    - CasioPython)
  21. 4,39s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    )
  22. 4,42s
    :
    HP Prime G2
    (32 bits : Cortex-A7/ARMv7 @
    528MHz
    )
  23. 4,98s
    :
    Casio Graph 35/75+E
    (32 bits : SH4 @
    29,49MHz
    - CasioPython)
  24. 8,1s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  25. 9s
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Python Edition
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    )
  26. 11,26s
    :
    TI-83 Premium CE
    +
    TI-Python
    (8 + 32 bits : eZ80 @
    48MHz
    + Cortex-M0+/ARMv6 @
    48MHz
    CircuitPython)
  27. 16,05s
    :
    HP Prime G1
    (32 bits : ARM9/ARMv5 @
    400MHz
    )
  28. 19,06s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @58,98MHz overclocké @
    274,91MHz
    Ftune3 - KhiCAS)
  29. 22,77s
    :
    Casio Graph 90+E
    (32 bits : SH4 @117,96MHz overclocké @
    270,77MHz
    Ptune3 - KhiCAS)
  30. 29,20s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @132MHz overclocké @
    222MHz
    Nover - + KhiCAS CX compatibilité
    Python
    )
  31. 32,76s
    :
    Casio Graph 90+E
    (32 bits : SH4 @
    117,96MHz
    - KhiCAS)
  32. 33,41s
    :
    NumWorks N0110
    (Omega + KhiCAS
    Micropython
    )
  33. 36,26s
    :
    TI-Nspire CX
    (révisions A-V)
    (32 bits : ARM9/ARMv5 @
    132MHz
    - + KhiCAS CX compatibilité
    Python
    )
  34. 42,75s
    :
    NumWorks N0110
    (Omega + KhiCAS compatibilité
    Python
    )
  35. 45,34s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @156MHz overclocké @
    216MHz
    Nover - + KhiCAS CX compatibilité
    Python
    )
  36. 53,24s
    :
    TI-Nspire CX CR4+
    (révisions W+)
    (32 bits : ARM9/ARMv5 @
    156MHz
    - + KhiCAS CX compatibilité
    Python
    )
  37. 91,71s
    :
    Casio Graph 35+E II
    (32 bits : SH4 @
    58,98MHz
    - KhiCAS)




16) Conclusion :

Go to top

Last but not least...
Texas Instruments
ne publie habituellement qu'1 à 2 mises à jour par an, mais alors quelle mise à jour cette fois-ci ! :#roll#:
"Gute Dinge brauchen Zeit..."
comme dit le proverbe allemand,
"... and better things even longer"
complète-t-on sans doute à Dallas. ;)

Cela valait vraiment le coup d'attendre le
Python
TI-Nspire CX II
, une solution supérieure sur nombre de points à tout ce qui a pu se faire sur calculatrices concurrentes jusqu'à présent ! :bj:

Texas Instruments
semble avoir fait appel à des experts en
Python
et en pédagogie, l'assistant d'aide à la saisie, à ce jour une exclusivité à un tel niveau, est un fidèle compagnon qui devrait permettre de commencer à coder très rapidement et en grande autonomie, ravissant petits et grands, lycéens comme enseignants ! :favorite:

Texas Instruments
semble également avoir été présent sur tous les fronts, on retient :
  • la meilleure implémentation
    Python
    officielle pour le nombre de modules standard disponibles :bj:
  • une capacité de
    tas / heap
    offert à la hauteur des grandes capacités de la machine, le plus grand
    tas / heap
    en mode examen, ce qui te permettra d'aborder sans contrainte des projets conséquents
    (interfaces, jeux, ...)
    :bj:
  • également la plus grande capacité de
    stack / pile
    en mode examen :bj:
  • de loin la plus grande bibliothèque de fonctions de tracé à ce jour, que ce soit par pixels ou par coordonnées, quoi que tu veuilles tracer il y a une solution ! :bj:
  • cerise sur le gâteau la gestion fort bienvenue dans ce contexte du
    double buffering
    , des calques hors écran, ainsi que des images
  • des images pour ceux qui le veulent affichables sans effort et quasiment sans consommation mémoire d'une simple ligne, permettant à ceux qui le souhaitent de choisir d'avancer sur les graphismes d'un projet sans se casser la tête à coder des fonctions annexes - bref plusieurs niveaux d'entrée matière à différenciation pédagogique, mettant la réalisation de chefs-d'oeuvre à la portée de chacun et œuvrant pour la réussite de tous, de grands pédagogues chez TI ;)
  • la solution
    Python
    la plus performante en mode examen, une fois encore à la mesure du matériel offert :bj:
Tout petit bémol, en espérant être entendu, nous regrettons par contre le non respect d'un standard comme
matplotlib.pyplot
pour le module de tracé dans un repère.
C'est la bibliothèque mise en avant aux concours de recrutement des enseignants ; nous craignons que peu d'enseignants se lancent dans l'utilisation d'un
ti_plotlib
propriétaire qui sera incompatible avec les scripts des livres ainsi qu'avec la solution
Python
tournant en classe sur la tablette ou l'ordi, nuisant ainsi à l'interopérabilité.
Autant sur le matériel limité de la
TI-83 Premium CE Edition Python
on pouvait comprendre ce choix, autant ici ce n'est pas le cas.

Il n'empêche que c'est une très belle mise à jour, le fruit doré d'un immense travail construit méticuleusement dès le départ autour des besoins des enseignants et des élèves, merci
TI
! :favorite:




Téléchargements
:


TI-z80 Cauldron Boot patcher: contrôle définitif OS 83PCE/84+CE A-L

New postby critor » 08 Sep 2020, 14:43

Un petit peu d'historique...

  • Rentrée 1992,
    Texas Instruments
    sort la , sa 2nde calculatrice graphique avec laquelle j'entretiens un lien affectif tout particulier puisqu'il s'agit de ma première calculatrice graphique, initialement programmable en langage interprété dit
    TI-Basic
    .
  • Novembre 1994, , et entrent dans l'Histoire en tant que pionniers en sortant , un outil qui permettait :
    1. sur ton ordinateur de programmer en langage assembleur pour le processeur
      z80
      de la
      TI-85
    2. de compiler le code en question en langage machine
    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
    Contrairement au langage interprété assez limité de la
    TI-85
    , le langage assembleur permettait d'exploiter le plein potentiel du matériel de la calculatrice, ouvrant ainsi la voie à nombre de créations d'un tout autre niveau. En seulement quelques mois sont sortis des 10aines de formidables jeux et outils révolutionnaires à l'époque
    (affichage d'images, sortie audio sur le port série mini-Jack 2.5 de la calculatrice, ...)
    : https://www.ticalc.org/pub/85/asm/
  • Rentrée 1996,
    Texas Instruments
    sort la , dont le matériel et le logiciel seront repris après mise à jour pour les futurs modèles d'entrée de gamme
    TI-82 STATS
    (2004)
    ,
    TI-82 Stats.fr
    (2006)
    et
    TI-76.fr
    (2009)
    . Impressionné de tout ce que la communauté avait pu réaliser sur la
    TI-85
    (et ensuite
    TI-92
    )
    , l'ingénieur ayant codé le logiciel en question avait réussi à faire accepter à des fins de tests l'intégration d'une commande cachée Send(9prgm... permettant de lancer des programmes écrits en langage machine improprement appelés assembleur ou ASM à partir de cette époque.
  • Rentrée 1997,
    Texas Instruments
    sort la . Le constructeur étant satisfait de l'expérimentation précédente, avait cette fois-ci réussi à faire passer l'idée d'une commande parfaitement officielle, le Asm(prgm listé au catalogue que nous connaissions jusqu'à nos jours.
  • Rentrée 2015,
    Texas Instruments
    lance ses formidables
    TI-83 Premium CE
    et
    TI-84 Plus CE
    , des calculatrices graphiques couleur de milieu de gamme munies du mode examen et toujours de la commande magique Asm(prgm. Un véritable coup de foudre pour nombre d'utilisateurs, de développeurs et pour nous-mêmes.
    Suite aux travaux de , , , et notamment avec son , il n'y avait plus besoin de connaître le langage assembleur
    eZ80
    pour réaliser de grands projets. Les programmes en langage machine pouvaient également être compilés à partir de code source écrit en langage
    C
    ou même
    C++
    . Une démocratisation du développement qui a attiré un nouveau genre de développeurs. La communauté de développement ainsi réunie autour du projet hautement formateur de tester, expérimenter, créer et repousser les limites a atteint un tout autre niveau de développement jamais vu jusqu'alors, avec des réalisations de qualité professionnelle dépassant de loin en quantité et en téléchargements tout ce qui avait pu être réalisé pour les anciens modèles.
    Une activité que nous mettions en avant dans un but pédagogique, incitant fortement et avec succès à partager également le code source des projets afin que chacun puisse l'étudier, le réutiliser, s'en inspirer et apprendre. Combien d'étudiants ou même ingénieurs aujourd'hui ont fait leurs premiers pas sur
    TI-83 Premium CE
    ? ;)
    Texas Instruments
    et sa communauté de développeurs ont ainsi cheminé ensemble main dans la main pendant 5 ans, unis autour de la mise en avant des formidables
    TI-83 Premium CE
    et
    TI-84 Plus CE
    et de la promotion des carrières en informatique et développement à travers de premiers pas sur les modèles en question. :favorite:
    On peut citer nombre de projets fantastiques : le
    mario-like
    , , , , l'émulateur Nintendo Game Boy , et bien d'autres... tous avec code source.
  • Et le 28 juin 2016,
    Texas Instruments
    signe sa mise à jour
    5.2.0
    , remplaçant l'effacement des programmes personnels en mode examen par un simple verrouillage, les programmes pouvant donc être récupérés après l'épreuve, une fois le mode examen désactivé.
Sauf que la chose en question avait été mal codée par
Texas Instruments
. Le menu programmes disposait d'un bug permettant d'accéder en mode examen à l'ensemble des programmes préchargés censés être verrouillés, bug qui a donc persisté de la version
5.2.0
à la version
5.3.0
. Nous signalons le bug auprès de
Texas Instruments
après l'avoir effectivement découvert, le 4 février 2018.

Conscient de la mise en danger des examens,
Texas Instruments
développe et sort alors en vitesse la mise à jour
5.3.1
, datée du même mois, 22 février 2018, et bien évidemment interdisant tout retour à une version inférieure. Le problème était réglé.

Hélas le 12 février 2020, un enseignant-vidéaste français très populaire, a l'idée étrange de sortir sur sa chaîne grand public à l'attention des élèves/candidats, une vidéo publique montrant en détails la réalisation de la manipulation permettant d'accéder à ses programmes en mode examen. La calculatrice ainsi filmée faisait tourner la version
5.2.2
lourdement obsolète, sans préciser la chose, et sans indiquer non plus que le problème était réglé depuis longtemps, qu'il suffisait juste de mettre à jour, et que la version en question était déjà en voie de disparition.

Nous pensions initialement de façon bien naïve à une simple maladresse, sous le coup de l'émotion de la découverte de la chose...

Donc une vidéo déséquilibrée qui par défaut d'information sur le contexte et la portée de la chose devenait anxiogène. La communauté dont nous-mêmes ne manquons pas de lui apporter des précisions en réponse à la vidéo et ses divers tweets liés, sans le moindre retour de sa part.
Pire, le 17 février, le même enseignant persiste et signe la même communication non corrigée dans l'Alsace.
Aucune inflexion du discours donc, malgré les précisions apportées. Le but était-il vraiment d'informer ou bien plutôt de désinformer, générer de la peur et faire le buzz, dans un engagement certes respectable contre la réforme du lycée ? La popularité sur YouTube ferait-elle perdre tout sens des réalités ?

En tous cas cela n'a pas manqué, 100000 vues en deux jours, 170000 vues à la fin de la semaine en plein congés d'Hiver, 240000 vues aujourd'hui... Une vidéo sans doute visionnée jusqu'au plus haut sommet de l'Etat ainsi que par une part très significative de candidats au Baccalauréat 2020, ce qui a relancé l'intérêt pour les anciennes versions et les outils permettant de les installer, pas toujours avec succès certes. C'est triste à dire mais les examens 2020 ont été mis en très grave danger, dans un sens heureusement que le confinement et l'annulation des épreuves ont brutalement mis fin à l'escalade...
Texas Instruments
, alerté par nos soins le jour même de la sortie de la vidéo dans l'espoir d'en minimiser les conséquences désagréables pour les utilisateurs, n'a pas tardé à réagir, ne manquant pas de prendre la pire décision possible pour ces mêmes utilisateurs, interdisant l'utilisation de programmes ASM :
  • à compter de la mise à jour
    5.5.1
    du 12 mai 2020 sur
    TI-83 Premium CE
  • à compter de la mise à jour
    5.6.0
    du 30 juillet 2020 sur
    TI-84 Plus CE
Des mises à jour interdisant bien évidemment tout retour à une version inférieure, le constructeur plaçait ainsi le développement tiers en voie d'extinction. Comme quoi c'était bien la peine que l'on se dépêche de signaler, la prochaine fois nous irons nous promener...

Un coup dur pour la communauté, 5 années de fichiers servis gratuitement sur Internet désormais totalement inutilisables. Des 100aines de jeux et programmes cumulant plusieurs 100aines de milliers de téléchargements rien que chez nous jetés aux oubliettes de l'Histoire, des 10aines de niveaux perso bons pour la poubelle, des 1000iers d'heures de travail passionné parties en fumée... ce que l'on peut opposer à
NumWorks
qui cible d'une attaque hostile envers son mode examen courant 2019-2020, attaque sur laquelle une certaine personne n'est heureusement pas tombée, a au moins fait semblant de prendre l'avis de sa communauté et nous t'en dirons davantage en temps voulu.

Mais quel est le rapport entre les programmes ASM contribués par des tiers et un bug de codage introduit par le constructeur dans un menu parfaitement officiel ? Ben aucun, nous sommes incapables de saisir le lien logique, le bug était déjà corrigé depuis 2018, il suffisait déjà d'installer l'une des nombreuses mise à jour
5.3.1
à
5.4.0
disponibles... Si certains examens exigent l'installation d'une version spécifique et bien souvent la dernière
(Baccalauréat International, Pays-Bas...)
, ce n'est pas le cas en France et les mises à jour
5.5.1
et supérieures n'y changent rien.

La communauté, particulièrement celle des développeurs anglophones, était déjà extrêmement remontée contre cette action des plus injustes, sans la moindre volonté de rechercher le compromis puisque sans le moindre échange préalable.

Texas Instruments
a fait ensuite preuve d'une communication très étrange qui n'a fait que jeter de l'huile sur le feu pendant toute la période estivale, à un point tel que l'on se demande a posteriori si c'était possible sans le faire exprès.
A l'exception du dernier, tous les points suivants ont été relevés sur
Cemetech
, le lieu communautaire où il y a eu le plus de virulence de la part des membres, du moins en public :
  • Promotion de la mise à jour
    5.5
    sans avertir les utilisateurs qu'il s'agissait d'une régression en fonctionnalités sans possibilité de retour en arrière, fonctionnalité de plus à l'époque toujours annoncée sur les pages officielles du produit. Volonté de prendre au piège les utilisateurs ?
  • La communication officielle d'abord partagée de façon informelle parlait de
    "prioriser l'apprentissage" (prioritize learning)
    , des mots perçus comme particulièrement insultants et méprisants envers le travail bénévole et passionné accompli en ce sens au sein de la communauté pendant 5 ans. Parce que des choses sont codées dans un langage autre que le
    Python
    choisi entre temps au lycée français elles n'auraient soudainement plus aucun intérêt pédagogique, scolaire ou formateur ? :#roll#:
    TI-France wrote:Chez TI, nous travaillons constamment sur des moyens d'améliorer nos produits pour donner aux étudiants plus d'occasions d'apprendre, d'explorer et d'étudier les mathématiques et les sciences. Après un examen attentif, nous avons pris la décision de supprimer la fonctionnalité ASM dans notre dernière mise à jour du système d'exploitation pour prioriser l'apprentissage et minimiser les risques de sécurité. Nous pensons que cela aidera également les élèves à se concentrer sur l'apprentissage des mathématiques et des sciences. Une fois que vous aurez mis à jour la version 5.5 du système d'exploitation pour la TI-83 Premium CE, vous ne pourrez pas passer à une version antérieure.

    TI-Dallas wrote:At TI, we’re constantly working on ways to improve our products to give students more opportunities to learn, explore and study math and science. After careful consideration, we’ve made the decision to remove ASM functionality in our latest OS update to prioritize learning and minimize security risks. We believe it will also help students focus on learning math and science. After you update the operating system version to 5.6 on the TI-84 Plus CE graphing calculator, you will not be able to downgrade.

  • Des utilisateurs contactant le support technique au sujet de leurs jeux qui ne marchaient plus se sont fait répondre que de toutes façons l'utilisation de jeux annulait la garantie de la calculatrice.
  • Une communication informelle a proposé de sortir une
    TI-84 Plus CE Developer Edition
    bien évidemment interdite aux examens... Décidément
    Texas Instruments
    semble ne pas comprendre sa communauté malgré une décennie d'échanges...
    L'intérêt de développer pour
    TI-83 Premium CE
    et
    TI-84 Plus CE
    était justement de pouvoir partager ses créations auprès de la formidable base d'utilisateurs scolaires tout autour de la planète - quel intérêt à développer pour une machine interdite aux examens, machine que les scolaires n'achèteront donc pas, créant ainsi des programmes ASM qui ne fonctionneront pas sur les
    TI-84 Plus CE
    normales ? Une
    Developer Edition
    ne serait a priori achetée que par une petite niche de développeurs qui ne pourront donc que se partager des choses entre eux dans le plus total anonymat et l'indifférence générale, rien à voir avec ce qu'a été l'esprit de la communauté pendant des décennies... :#roll#:
  • La même communication informelle conseillait de passer au
    Python
    pour poursuivre nos superbes créations - était-ce se moquer du monde ? :#roll#:
    Le
    Python
    de la
    TI-83 Premium CE
    ne dispose pas d'une fonction pour tester l'appui sur une touche, mais d'une fonction
    wait_key()
    bloquante. Autrement dit, à chaque fois qu'un jeu
    Python
    par exemple sera en train de tester une touche son affichage sera figé. Cela réduit déjà le champ des possibles aux seuls jeux pouvant se ramener à du tour par tour, extrêmement rares sur calculatrices où l'on ne joue pas souvent à plusieurs. :mj:
    A croire que
    Texas Instruments
    ne connaît même pas les réalisations de sa propre communauté... :#roll#:
  • Enfin lors de ses formations en ligne en ce moment à l'attention des enseignants dont la toute dernière à ce jour, nous avons pu constater une communication spontanée assez étrange à ce sujet... ce n'est pas au mot près car l'enregistrement de la session en question n'est pas encore disponible, mais ça donnait à peu près ça :
    TI-France wrote:suite à une vidéo d'alerte, la mise à jour
    5.5
    supprime l'ASM et donc toute faille possible

    Euh pardon ? Faille et bug ce n'est déjà pas la même chose... Mais en établissement un lien logique avec l'ASM et donc les développements tiers dans l'histoire, le constructeur ne serait-il pas en train de tenter de faire passer auprès des enseignants, qui pour la plupart ne s'y connaissent pas, sa propre erreur qu'il a lui-même introduite dans un de ses menus officiels en tant que faille forcée par des tiers ? C'est-à-dire de préserver son image en rejetant la faute sur sa communauté ?
    La communauté a bon dos... Il nous semble qu'après des années de dévouement bénévole, elle mériterait mieux que ça. Nous comprenons parfaitement la situation critique, elle n'est toutefois en rien une raison valable pour jeter en pâture auprès du corps enseignant des tiers de bonne volonté parfaitement innocents et étrangers à l'histoire en question.
    L'union fait pourtant la force, particulièrement dans la tourmente...

La vengeance est un plat qui se mange froid et hier sortait
arTIfiCE
, un outil visiblement ruminé discrètement, soigneusement et méticuleusement pendant toute la période estivale.

Partagé anonymement par un certain ,
arTIfiCE
, qui peut être vu comme le
Ndless
des
TI-83 Premium CE
et
TI-84 Plus CE
, te permet de lancer tes programmes ASM, en exploitant un bug dans l'application intégrée
CabriJr
.

Tu récupères ainsi une fonctionnalité légitime pour laquelle tu avais payé lors de l'achat de ta calculatrice.

Avec le degré de ressentiment et même de haine que les actions et communications de
Texas Instruments
ont allumé et attisé au sein de sa communauté de développement, pour nous c'était très loin d'être la fin de l'histoire... Nous craignions en conséquence des attaques contre le mode examen, mais plus tard dans l'année scolaire... Nous étions loin de nous douter que cela continuerait dès aujourd'hui.

Certains objectaient notamment que
arTIfiCE
ne serait qu'un feu de paille, que
Texas Instruments
allait rapidement sortir une mise à jour... ce denier point est sans doute vrai, même si nous pouvons objecter à notre tour :
  • que c'est en période de rentrée que les utilisateurs sont le plus vulnérables
  • que les mises à jour publiées en cours d'année scolaire ont beaucoup moins de succès, surtout quand elles n'apportent rien d'utile, les utilisateurs n'étant pas autant à l'affût des dernières nouveautés qu'en période de rentrée et donc de découverte de leur nouveau joujou
  • que les stocks de machines préchargées avec la nouvelle version n'arriveront pas avant de longs mois, sans doute lors de l'approvisionnement pour la rentrée 2021 au printemps
Donc en gros, les utilisateurs sont à peu près tranquilles pour toute l'année scolaire 2020-2021 selon nous.

Bref, dès ce matin donc suite surprise et inattendue de l'histoire, nouvelle attaque contre
Texas Instruments
, parmi les plus graves qu'il n'y ait jamais eu, il nous faut revenir une décennie en arrière à l'époque de
Brandon Wilson
pour trouver des choses comparables.

Texas Instruments
est donc dès maintenant assiégé avec
Cauldron
, une publication tout aussi anonyme de cette fois-ci.

Cauldron
ne s'attaque finalement pas au mode examen comme nous le prédisions hier, mais porte un coup d'estoc d'une rare violence à la sécurité codée par
Texas Instruments
sur ses
TI-83 Premium CE
et
TI-84 Plus CE
.

634243534946En effet
Cauldron
patche le code amorce
(
Boot
)
des calculatrices, que nous pensions pourtant non reprogrammable sur les modèles de production, qui selon le menu de diagnostic ont leurs premiers secteurs de la
Flash
protégés contre l'écriture contrairement aux prototypes de 2014-2015. :o

Visiblement,
Texas Instruments
a raté quelque chose ici aussi...


Le
Boot
est le code lancé au démarrage de la machine, s'occupant de lancer le système d'exploitation, et ayant également la charge d'en installer les éventuelles mises à jour. Dans ce contexte il effectue nombre de vérifications :
  • depuis le début, vérification d'une signature électronique de 2048 bits à chaque installation de mise à jour, afin d'interdire l'installation d'un système modifié
  • depuis la version , inscription et vérification d'un numéro de version minimale autorisée dans une zone de la mémoire
    Flash
    ne pouvant être réinitialisée par aucun menu officiel
  • depuis la version sur calculatrice physique
    (et
    5.3.0
    sur l'émulateur
    TI-SmartView CE
    )
    , vérification d'une signature électronique de 1024 bits à chaque redémarrage de la calculatrice, afin d'interdire l'utilisation d'un système qui aurait été modifié après installation sur la calculatrice, ce qui te rajoute quelques secondes au démarrage avec le message
Bien évidemment à chaque cas, en cas d'échec du test le système en question est refusé et/ou détruit.

Tu peux vérifier ta version en tapant
mode
alpha
S
.

Et bien
Cauldron
modifie le
Boot
afin d'altérer définitivement deux de ces sécurités si présentes :
  • Boot 5.3.1
    : la vérification de la signature 1024 bits au démarrage est désactivée, ce qui permettra à ta calculatrice de démarrer plus rapidement, et te permettra désormais d'utiliser librement des systèmes modifiés
  • Boot 5.1.5
    et
    5.3.1
    : l'inscription du numéro de version minimale autorisée est bloqué en dur sur
    5.3.1
    , ce qui te permettra à tout moment de pouvoir réinstaller une ancienne version jusqu'à
    5.3.1
    , et donc de retrouver la gestion des programmes ASM
Malgré le contexte, louons sur ce cernier point la responsabilité et la modération de l'attaquant, les versions
5.3.0
et inférieures souffrant du mode examen défectueux restent dans tous les cas interdites. Simple volonté donc de récupérer ce qui est légitime, et absolument pas de frauder.
Si seulement
Texas Instruments
pouvait en tenir compte...

Cauldron
exploite donc une ancienne faille matérielle déjà corrigée, et ne cible que les révisions matérielles
L
et inférieures, assemblées jusqu'en
Mai 2019
. C'est-à-dire que :
  • sont exclues l'intégralité des
    TI-83 Premium CE Edition Python
    :#non#:
  • sont gérées l'intégralité des simples
    TI-83 Premium CE
  • sont exclues l'intégralité des
    TI-84 Plus CE-T Python Edition
    :#non#:
  • sont exclues les simples
    TI-84 Plus CE
    et
    TI-84 Plus CE-T
    en révision matérielle
    M
    à
    O
    , assemblées de
    Mai 2019
    à
    Mai 2020
    :#non#:
  • sont gérées les simples
    TI-84 Plus CE
    et
    TI-84 Plus CE-T
    en révision matérielle
    L
    et inférieure, assemblées jusqu'en
    Mai 2019

Si tu es donc muni(e) d'une machine compatible avec
Cauldron
tu en prends ainsi le contrôle total et possiblement pour toujours ; tu n'auras plus à craindre les mises à jour de
Texas Instruments
. Tu pourras
patcher
le système comme tu voudras, mettre à jour et tant que tu le voudras toujours revenir à une version inférieure supportant l'ASM d'origine ! :bj:
En théorie, il serait possible qu'une mise à jour système future de
Texas Instruments
s'occupe de réparer le
Boot
. En pratique cela nous semble extrêmement difficile, coûteux et donc peu probable :
  • Déjà le
    Boot
    n'est pas censé être réinscriptible, et il y a sans doute nombre de contraintes...
  • Contrairement aux
    TI-Nspire
    , les
    Boot
    TI-83 Premium CE
    et
    TI-84 Plus CE
    n'ont pas été conçus pour pouvoir être mis à jour - ils sont liés à des révisions matérielles spécifiques, une version plus récente risque tout simplement de ne pas marcher et donc bloquer définitivement la machine en question
  • Le moindre incident lors de la programmation du nouveau
    Boot
    ou de son exécution, et la machine concernée sera définitivement morte, et c'est déjà arrivé lors de mises à jour
    TI-Nspire
    - mais après, possible que
    Texas Instruments
    juge le remplacement des machines accidentellement détruites par une telle mise à jour moins coûteux que le risque de perdre le maché français des calculatrices graphiques, le 2ème ou 3ème au monde à notre connaissance en terme de volume

Avec la possibilité désormais de modifier le système comme on veut sur toutes les
TI-83 Premium CE
assemblées jusqu'en
mai 2019
, la tenue apaisée des examens 2021 avec calculatrice nous semble aujourd'hui fortement compromise, à peine une semaine après la rentrée.

Ce n'est certes pas une possibilité exceptionnelle ni scandaleuse. Modifier le système d'exploitation de sa calculatrice :
  • était déjà faisable sur les calculatrices
    Casio Graph 35+E / 35+E II / 75+E / 90+E
    et
    fx-CP400+E
    bien que la manipulation soit technique et pas vraiment documentée publiquement
  • était déjà réalisable chez
    NumWorks
    de façon officielle et bien plus accessible
Quelle différence alors ? Nous y venons de suite en conclusion.

Texas Instruments
avait la chance exclusive contrairement aux autres constructeurs de disposer d'une communauté non enseignante interconnectée tout autour de la planète, avec une communication régulière contre les attaques ciblant la sécurité ou pire le mode examen, mettant en avant l'argument que tout-le-monde serait puni en cas de sortie d'un outil en ce genre. La communauté faisait elle-même sa propre police, tapant sur les doigts de ceux qui se permettaient des écarts, et avec efficacité puisque depuis l'annonce du mode examen en 2015 ce dernier n'avait fait l'objet d'aucune attaque sur les calculatrices
Texas Instruments
. On ne peut pas en dire autant de la concurrence particulièrement en 2019-2020, même si une certaine personne n'est heureusement pas tombée dessus pour en faire une vidéo publicitaire, conduisant à la disparition naturelle des outils hostiles en question.

L'argument que nous avions coutume d'opposer n'est donc plus valable aujourd'hui, nous avons tous déjà été punis pour ce que nous n'avons même pas fait. :mj:

Texas Instruments
a tout gâché en seulement quelques mois, arrivant à écœurer nombre de fans
'bricoleurs'
qu'une certaine concurrence accueille à bras ouverts, et si des attaques contre le mode examen doivent sortir il nous semble aujourd'hui hautement plus probable que ce soit chez
Texas Instruments
que chez la concurrence. Que ce soit en exploitant
arTIfiCE
,
Cauldron
, ou même autre chose.

Nous déplorons la situation, mais au vu des éléments précédents nous ne pouvons pas rejeter le fait que
Texas Instruments
a lourdement cherché la chose.

Il ne faut pas vendre la peau de l'ours avant de l'avoir tué.

Peut-être y a-t-il eu chez
Texas Instruments
un excès de confiance suite à l'apparente éradication de
Ndless
... Le constructeur devrait au minimum revoir sa communication pour être davantage compatible/inclusive, et envoyer un signal fort d'apaisement...
Sinon, avec des attaques aussi graves publiées dès la rentrée, où en serons-nous d'ici les examens 2021 avec la poursuite d'une telle escalade ?...

C'est quoi qui va sortir demain maintenant ?...

En aucun cas un outil de fraude ne sera hébergé chez nous ni n'y fera l'objet d'une quelconque aide, car nous protégeons les candidats qui en seraient les premières victimes si jamais ils se faisaient attraper, y compris contre eux-mêmes. :#non#:

D'ailleurs rien à voir avec la fraude, mais dans l'immédiat nous te déconseillons l'utilisation de
Cauldron
. /!
L'outil nous semble avoir été codé rapidement de façon assez brouillon, ne dispose même pas d'interface aidant à son utilisation, et n'a fait l'objet que de peu de tests pour le moment.
La reprogrammation du
Boot
est une opération extrêmement dangereuse, toute erreur pendant une reprogrammation rendra ta calculatrice définitivement inutilisable.
Nous ignorons pour le moment le comportement de
Cauldron
dans nombre de cas particuliers : batterie déchargée, version
Boot
inconnue, version
Boot
déjà patchée...


Téléchargements
:

  • Cauldron
    (publication initiale, semble désormais indisponible)
  • Cauldron
    (fork en cours d'amélioration par
    TheMachine02
    )

Sources
:

  1. https://www.cemetech.net/forum/viewtopic.php?p=287750#287750
  2. https://tiplanet.org/forum/viewtopic.php?t=23858&p=255666#p255666

TI-z80 arTIfiCE jailbreak: ASM sur TI-83 Premium CE 5.5 / 84+CE 5.6

New postby critor » 06 Sep 2020, 23:31

Dans une actualité précédente, nous t'informions que
Texas Instruments
avait décidé de mettre fin au support des programmes dits
ASM
sur ses célèbres calculatrices
TI-83 Premium CE
et
TI-84 Plus CE
. Les mises à jour
5.5.1
(et ultérieures)
interdisaient ainsi le lancement des programmes compilés ou assemblés en langage machine à partir d'un code écrit en langage assembleur, C, ou autres, une fonctionnalité historique présente depuis 1996 sur les calculatrices de la marque, véritable signature du constructeur. :'(

Un coup dur pour la communauté avec une grande part des fichiers servis gratuitement sur Internet désormais totalement inutilisables. Des 100aines de jeux et programmes cumulant plusieurs 100aines de milliers de téléchargements rien que chez nous jetés aux oubliettes de l'Histoire, des 10aines de niveaux perso bons pour la poubelle, des 1000iers d'heures de travail passionné parties en fumée, le tout bien évidemment sans aucune discussion préalable ! :mj:

On peut citer le
mario-like
, , , , l'émulateur Nintendo Game Boy , et bien d'autres...

Selon l'assemblage des éléments que nous avons cette décision découle d'une bêtise monumentale d'un certaine personne que nous appellerons Yvan, enseignant-vidéaste français très populaire, qui a publié le 12 février 2020 une vidéo montrant pas à pas en direct comment exploiter un bug sur
TI-83 Premium CE
en version
5.2.2
à des fins de fraude, bien que prétendant paradoxalement le contraire en introduction.

La méthode illustrée exploitait un très vieux bug présent dans des mises à jour
TI-83 Premium CE
, les versions
5.2.0
à
5.3.0
sorties entre
juin 2016
et
juillet 2017
, versions obsolètes qui étaient depuis longtemps en voie de disparition, information qu'elle ne précisait pas.
Ce bug concernant un menu permettait de continuer à accéder à ses programmes une fois passé en mode examen, avait été signalé à
Texas Instruments
par nos soins à l’époque, et corrigé dans la mise à jour suivante
5.3.1
de
février 2018
soit il y a déjà bien longtemps, information également omise dans le vidéo, induisant le spectateur institutionnel en erreur.

Une vidéo ainsi déséquilibrée, trop complète sur certaines choses qu'il n'était absolument pas nécessaire de montrer et très incomplète sur le reste, était hautement anxiogène, semblant conçue exprès pour désinformer, pour faire peur, pour faire le buzz, ce qui d'ailleurs n'a pas manqué avec des 10aines de milliers de vues engrangées jour après jour malgré les congés d'hiver.

Sur une chaîne grand public
(et non en privé auprès du constructeur concerné ou par la voie hiérarchique)
et seulement quelques semaines avant les examens, cette vidéo irresponsable ne contribuait qu'à une seule chose, informer les candidats sur la façon de frauder.

Conservée chez nous à de simples fins historiques d'archivage tout comme les versions remontant au siècle dernier, l'antique version
5.2.2
n'intéressait quasiment plus personne de par ses faibles fonctionnalités. Et bien justement, les téléchargements en ont bondi dans les jours qui ont suivi avec un double pic.
Dans un certain sens, heureusement que les épreuves d'examen 2020 ont été annulées...


La vidéo liait également chez nous une page avec un outil permettant de réinstaller d'anciennes versions, outil subissant donc le même double pic. Ici encore sans préciser que l'outil en question ne marchait absolument pas sur les nouvelles
TI-83 Premium CE Edition Python
, ce qui est toujours le cas à ce jour. Il ne marche d'ailleurs actuellement pas davantage sur les nouvelles versions
5.5
, même si visiblement on peut constater que les nouveaux utilisateurs découvrant la mauvaise surprise en cette période de rentrée tentent quand même leur chance.

Dans tous les cas nous avons mis en place des "garde-fous" et avertissements divers sur les pages des fichiers concernés
(et juste avant de lancer le téléchargement)
, notamment rappelant les dangers de la fraude.

Avec a posteriori des 100aines de milliers de vues passé les 3 zones de congés d'hiver soit une part très significative des candidats au Baccalauréat, la vidéo, très probablement visionnée jusqu'au plus haut sommet des instances de l'E.N. et peut-être même de l’Etat, a sans doute mis
Texas Instruments
dans une situation hautement inconfortable, et le constructeur a cru
(voire s'est vu obligé de...)
devoir envoyer un signal fort.

Le constructeur communique d'ailleurs en ce sens en ce moment dans ses formations de rentrée :
la mise à jour
5.5
bloque l’asm et donc tout faille possible
.

Le rapport entre tout ça et l'interdiction des programmes ASM contribués bénévolement par des tiers ? Ben justement c'est là le problème : aucun. Il s'agissait d'un erreur de codage de TI dans un menu des plus officiels, rien à voir avec l'installation de programmes tiers sur la calculatrice. Ce n'est pas l'interdiction des programmes ASM qui va réellement améliorer la sécurité des calculatrices.

La décision a été perçue par les membres de la communauté, ainsi que par nous-mêmes, comme extrêmement injuste. :mj:

Surtout dans un contexte où cela fait des années que nous cherchons et reportons bénévolement chaque bug trouvé aux différents constructeurs, particulièrement dans le contexte du mode examen, et signalons au plus tôt tout incident hors de notre contrôle, afin justement d’en minimiser les conséquences dans l’intérêt de l’ensemble des utilisateurs. La vidéo problématique a été signalée auprès de
Texas Instruments
le jour même de sa sortie, on pouvait difficilement faire mieux, et ce dernier nous remercie visiblement avec la pire décision possible.


Et bien surprise
(ou pas ?)
, aujourd'hui c’est un autre Yvan,
(Serait-ce pour "Yvan The Terrible" ? :p)
qui vient réparer les dégâts et tous nous sauver. YvanTT vient d'écrire un post ici et sur d'autres sites communautaires, qui mentionne la sortie de son "jailbreak" pour calculatrices CE, nommé "
arTIfiCE
".

arTIfiCE
dispose d'une page web avec téléchargement et instructions d'utilisation. D'après son tutoriel, son utilisation est très simple. L’outil exploite un bug dans l'application
Cabri Jr.
de ta calculatrice. Il te suffira juste de transférer le fichier
arTIfiCE.8xv
fourni et de l’ouvrir dans
Cabri Jr.
exactement comme si c’était une simple sauvegarde de figure géométrique. Tu accèderas ainsi immédiatement à un
"shell"
te listant les programmes ASM disponibles sur ta calculatrice, il n'y aura plus qu’à choisir celui que tu souhaites lancer ! :bj:

Certes, les manipulations avec le passage par
Cabri Jr
et ses menus sont un peu longues, surtout si tu dois faire ça pour chaque lancement d’un programme ASM. Aussi petite astuce complémentaire, maintenant que tu peux de nouveau lancer des programmes ASM, il te suffira juste d’installer
Cesium
(la toute dernière version est requise, tout spécialement mise à jour pour les OS
5.5
et
5.6
)
, qui à son tour te permettra un lancement bien plus rapide, notamment grâce au raccourci
on
+
prgm
. ;)

Selon les tests que nous nous sommes empressés de faire,
arTIfiCE
est bel et bien compatible avec toutes les versions
5.5.1
à
5.6.0
, aussi bien sur
TI-83 Premium CE
, que
TI-83 Premium CE Edition Python
,
TI-84 Plus CE
,
TI-84 Plus CE-T
ou bien
TI-84 Plus CE-T Python Edition
.


Texas Instruments
avait la chance exclusive de bénéficier d'une communauté francophone et anglophone particulièrement responsable, soudée et unie. Malgré l'opposition générale au mode examen aucune attaque n'était sortie depuis son annonce en 2015, et nous y avons particulièrement veillé.

D'autres constructeurs n'ont pas cette chance, avec des communautés bien plus éclatées où chacun suit davantage ses propres intérêts, pouvant aller à l'encontre de l'intérêt général. Il y a eu à la différence de véritables attaques contre les modes examen de
Casio
et
NumWorks
en 2019-2020, avec ici publication d'outils tiers destinés à altérer le bon fonctionnement du mode examen. Nous n'en avons pas parlé car :
  • leur publication est resté relativement anonyme et n'a à notre connaissance pas fait l'actualité nulle-part
  • dans le cas spécifique des outils en question nous n'avions pas de parade collective et simple à proposer aux surveillants d'épreuves, la vérification individuelle systématique de chaque calculatrice n'étant bien évidemment pas envisageable
Heureusement cette fois-ci que quelqu'un n'est pas tombé dessus pour en faire une vidéo publicitaire... Nous avons remonté et/ou suivi la chose en privé auprès des constructeurs concernés, visiblement de façon bien plus efficace, les éléments en question ayant fini par disparaître dans l'anonymat le plus total et l'indifférence générale, situation idéale donc pour les épreuves de remplacement du BAC 2020 imminentes.

Bref,
Texas Instruments
bénéficiait donc d'une situation exceptionnellement privilégiée et a tout gâché. :mj:

Le constructeur croyait donc sa
TI-83 Premium CE
en danger pour l'autorisation aux examens. Eh bien, ironiquement, le véritable danger c'est maintenant. TI n'a jamais été aussi en danger que maintenant, ce n'est pas un rembobinage vers la situation de l'année dernière : l'ASM est de retour, mais à la différence avec un ressentiment énorme que le constructeur a lui-même généré au sein de sa propre communauté. Nombre de personnes estimant qu'elles n'ont de toutes façons plus rien à perdre, et ayant parfaitement compris qu'elles n'étaient visiblement pour le constructeur que la cinquième roue du carrosse, il ne serait pas surprenant que des attaques contre le mode examen se mettent à sortir pour de vrai cette année.

En tous cas comme nous l'avons déjà dit, aucun outil de fraude si il en sort effectivement cette année ne sera hébergé chez nous ni fera l'objet d'une quelconque aide à l'utilisation. :#non#:
Ce serait irresponsable de notre part, nos lecteurs en étant les premières victimes si jamais ils se font attraper. Cependant, bien entendu, nous ne pouvons empêcher l'hébergement de tels outils et de documentations correspondantes à des endroits que nous ne contrôlons pas.


Téléchargements
:


Lien
:
page du projet
arTIfiCE


Références
:


Sources
:

  1. https://www.cemetech.net/forum/viewtopic.php?p=287720#287720
  2. https://tiplanet.org/forum/viewtopic.php?p=255618#p255618
  3. https://codewalr.us/index.php?msg=62051
  4. https://www.ticalc.org/archives/news/articles/14/149/149342.html

-
Search
-
Featured topics
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Découvre les nouvelles fonctionnalités en Python de l'OS 5.2 pour les Nspire CX II
Découvre les nouvelles fonctionnalités en Python de l'OS 5.5 pour la 83PCE/84+C-T Python Edition
Omega, le fork étendant les capacités de ta NumWorks, même en mode examen !
1234
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...

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.
721 utilisateurs:
>708 invités
>8 membres
>5 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)