Page 1 of 1

Exploration module Python ti_system TI-83 Premium CE 5.5

Unread postPosted: 29 Mar 2020, 16:30
by critor
12382Dans sa prochaine mise à jour 5.5 gratuite prévue pour Mai 2020, Texas Instruments va rajouter de formidables possibilités à l'application Python de ta TI-83 Premium CE Édition Python.

Nous sommes honorés aujourd'hui de pouvoir t'en tester une préversion, la 5.5.0031 compilée le 12 Mars 2020.

Cette mise à jour système s'accompagne d'une mise à jour de l'application Python, également en version 5.5.0031.

Toutefois pas de mise à jour de l'application PyAdaptr, sans doute suite à la décision d'interdire le module externe TI-Python aux examens français. Aussi, les anciens modèles TI-83 Premium CE ne sont-ils hélas pas concernés par les nouveautés Python que nous allons aborder. :#non#:


Rien que sur le Python il s'agit d'une mise à jour fonctionnelle majeure, et nous ne pourrons pas tout traiter aujourd'hui. Nous n'en allons pas moins te faire déjà découvrir une partie des formidables nouveautés. :)





1) Menus et complexes

Go to top

Une première piste pour découvrir les nouveautés, c'est d'accéder aux menus avec
F1
depuis la console ou l'éditeur de script. Ces menus ne présentent pas la totalité des fonctionnalités, mais une sélection que Texas Instruments a choisi de mettre en avant pour une saisie rapide.

Fonctionnellement ce ne sont pas des nouveautés, mais on peut déjà noter quelques ajouts dans les onglets List et E/S, avec donc l'avantage désormais d'une saisie facilitée :
  • la fonction de classe list.count()
  • la fonction de classe str.format()

Dans l'onglet Type par contre, on note :
  • certes la mise au menu de la fonction type()
  • mais surtout une nouvelle fonction complex(real,imag)

Cette fonction complexe(real,imag) à la différence n'était pas simplement non listée sur l'ancienne version mais inexistante. En effet, les nombres complexes n'étaient même pas gérés, contrairement à l'ensemble de la concurrence. Cela voudrait-il dire que c'est le cas désormais ?

Et bien oui les nombres complexes sont maintenant gérés ! :bj:

Ta TI-83 Premium CE Édition Python devient donc optimale aussi bien pour le programme de Mathématiques Terminales S, STI2D et STL spécialé SPCL pour le BAC 2020, ainsi que le programme de Mathématiques Expertes de Terminale G et Maths-Physique-Chimie de Terminale STI2D pour le BAC 2021 ! :D



2) Modules importables et module time

Go to top

Passons maintenant à l'onglet Modul pour consulter la sélection de modules importables. Outre math et random qui était déjà listés, nous avons maintenant :
  • time
  • ti_system
  • ti_plotlib
  • ti_hub
  • ti_rover

En réalité, le menu ne liste qu'une sélection et non tous les modules disponibles. Pour cela, on peut appeler help('modules').

Les véritables nouveautés sont donc les seuls modules suivants :
  • ti_plotlib, une bibliothèque graphique conformément aux programmes de Physique-Chimie, SNT et NSI, tout en permettant également nombre d'applications en Mathématiques ! :bj:
  • ti_system, pour enfin pouvoir interagir avec les variables hors application Python; enfin l'application Python pourra véritable servir à résoudre des problèmes et non plus à coder un truc dans un coin ! :bj:
  • ti_hub, pour les projets d'objects connectés à l'aide de l'interface TI-Innovator Hub :)
  • ti_rover, pour les projets de robotique à l'aide du TI-Innovator Rover :)
  • ainsi qu'un mystérieux ti_graphics, pour sa part non listé au menu

Le module time était quant à lui déjà présent, même si on apprécie désormais sa présence au menu et donc la possibilité de lister et accéder rapidement son contenu. :bj:
Cela signifie aussi qu'il est désormais officiel et ne risque plus de disparaître lors d'une prochaine mise à jour - tu peux donc l'utiliser sans crainte ! :D

Nous nous proposons donc aujourd'hui de découvrir avec toi les possibilités d'un premier des nouveaux modules, ti_system.




3) Menu ti_system et assistant de saisie

Go to top

On remarque ici plusieurs choses essentielles.

On note une fonction sleep() qui fait apparemment doublon avec celle du module time, même comportement.
Au moins cela évitera d'avoir à importer les deux modules dans certains cas. :)

Nous avons donc une fonction escape() qui en pratique indique si les touches
annul
ou
on
sont pressées.
C'est bienvenu, cela permettra d'afficher des informations et d'attendre une confirmation de lecture par l'utlisateur avant de passer à la suite. :)
Si l'on pense conception de menus, interfaces et jeux c'est toutefois insuffisant, et en attendant mieux il y aura la possibilité d'utiliser la bibliothèque tierce TIKEYLIB de CaptainLuigi, qui tente de son mieux de fournir des fonctions utilisables en exploitant le flux d'entrée sys.stdin.

Des fonctions recall…() permettent d'importer des informations depuis les variables des autres applications de la calculatrice, et store…() inversement d'en exporter.

Des fonctions disp…() permettent quant à elles d'afficher des caractères à l'écran.

Notons à ce sujet le fonction disp_at(ligne,'txt','align'), qui est suffixée au menu d'un petit triangle vert orienté vers la droite.
Non il ne t'invite pas à taper
comme on pourrait le croire, mais t'indique que la validation de ce choix va ouvrir un assistant illustré ci-contre.
En effet, cette fonction attend ici comme dernier paramètre une chaîne avec comme seules valeurs autorisées 'left', 'center' ou 'right', pénibles à saisir.
L'assistant est donc là pour te lister les valeurs autorisées pour ce genre de paramètres, et t'en faciliter la saisie. :)

Nous explorerons plus en détails ces deux dernières catégories de fonctions ci-après.




4) Exploration ti_system et touches clavier

Go to top

Et si le module ti_system contenait des choses non listées au menu ?

Réalisons-en une exploration complète à l'aide du script suivant :
Code: Select all
#platforms:
#0: MicroPython / TI-Nspire
#1: MicroPython / NumWorks
#2: MicroPython / G90+E / G35+E II
#3: MicroPython / G35+E/USB / G75/85/95
#4: CircuitPython / TI-Python / 83PCE / Trinket M0
#5: Xcas / HP Prime
#6: KhiCAS / Graph 90+E
def getplatform():
  id=-1
  try:
    import sys
    try:
      if sys.platform=='nspire':id=0
      if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':id=4
    except:id=3
  except:
    try:
      import kandinsky
      id=1
    except:
      try:
        if chr(256)==chr(0):id=5+(not ('HP' in version()))
      except:
        id=2
  return id

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

nlines=plines[platform]
ncols=pcols[platform]
curline=0

def mprint(*ls):
  global curline
  st=''
  for s in ls:
    if not(isinstance(s,str)):
      s=str(s)
    st=st+s
  stlines=1+int(len(st)/ncols)
  if curline+stlines>=nlines:
    input('Input to continue:')
    curline=0
  print(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):
  s=str(obj)
  return s.startswith('<') and s.find(' ')>=0

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

Un import ti_system suivi d'un appel explmod(ti_system) nous révèle effectivement plusieurs fonctions cachées :
  • wait()
  • et wait_key()

La fonction wait() semble se comporter exactement comme sleep().

Et bien finalement non, pas besoin d'aller chercher une bibliothèque tierce de détection des touches pressées pour tes menus, interfaces et jeux, la fonction wait_key() semble être exactement ce qu'il nous fait.
Comme le getKey du TI-Basic, elle renvoie toujours un même code numérique pour chaque touche pressée.

Quelques différences toutefois :
  • ce ne sont, bizarrement, pas les mêmes codes qu'en TI-Basic
  • ici la fonction attend la pression d'une touche avant de renvoyer une valeur
  • les touches modificatrices
    2nde
    et
    alpha
    ne sont pas gérées

Ah ben en fait voilà qui explique l'utilisation de codes touches différents; lorsque précédant l'appui sur une touche,
2nde
et
alpha
modifient le code retourné.

Toutefois, tant que ce n'est pas au menu, ce n'est pas officiel et ça peut être retiré à tout moment.

Voici ici documenté les codes de chacune des touches, suivis à chaque fois des codes obtenus en combinaison avec les modificateurs
2nde
puis
alpha
si différents :
f(x)

73
48
fenêtre

72
75
zoom

46
87
trace

90
59
graphe

68
74
2nde
mode

69
64
suppr

10
11

2
14

3
alpha
X,T,θ,n

180
65
stats

49
58

4

1
15
math

50
51
154
matrice

55
182
155
prgm

45
47
156
var

53
56
annul

9
◄►

64018
57
157
trig

64017
181
158
résol

64020
44
159
□/□

64458
64016
160
^

132

161

189
190
162
,

139
152
163
(

133
236
164
)

134
237
165
/

131
239
166
log

193
194
167
7

149
249
168
8

150
250
169
9

151
251
170
×

130
135
171
ln

191
192
172
4

146
246
173
5

147
247
174
6

148
248
175
-

129
136
176
sto→

138
12
177
1

143
243
178
2

144
244
179
3

145
245
204
+

128
54
203
on

0
0

142
153
62
.

141
238
198
(-)

140
197
202
entrée

5
13


Ah ben en fait, nous avons beau y regarder ces codes nous sont totalement obscurs. Nous n'y voyons aucune logique globale.

C'est donc en effet un travail inachevé; si ces codes sont conservés en l'état il faudra concevoir un menu dédié pour faciliter leur utilisation.




5) ti_system et fonctions disp…

Go to top

Contrairement à la fonction Python print() qui ne permet d'afficher qu'à la fin de la console et te pousse donc à la gymnastique pour des affichages multilignes, les fonctions d'affichage fournis par le module ti_system tiennent compte de la géométrie écran de la calculatrice pour t'offrir le choix d'afficher une chaîne où tu veux et quand tu veux, dans le même esprit que le langage de programmation historique TI-Basic.

disp_cursor(0) et disp_cursor(1) permettant respectivement de désactiver et réactiver l'affichage du curseur de texte pendant l'exécution de tes scripts Python.

disp_clr() quant à elle efface l'écran de la console et ramène le curseur tout en haut à gauche pour le prochain affichage.

disp_wait() attend l'appui sur une touche d'annulation puis efface l'écran, semblant être équivalent au code suivant :
Code: Select all
while not escape():
  pass
disp_clr()


Enfin nous arrivons à la fonction principale, disp_at(ligne,'txt','align'), et allons tenter d'en comprendre le fonctionnement. On peut l'illustrer ci-contre à l'aide du code suivant :
Code: Select all
from ti_system import *

for k in range(1, 12):
  disp_at(k,('Ligne {:02d} ' + '*'*23).format(k),'left')
disp_at(6,'left','left')
disp_at(8,'center','center')
disp_at(10,'right','right')
disp_at(3,'123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ','left')


Tu peux donc afficher tes caractères à largeur fixe où tu veux sur 11 lignes numérotées de 1 à 11, et 32 colonnes.
Pour tout affichage la fonction disp_at() n'efface pas le début de ligne, écrase les caractères déjà affichés au même endroit si il y en a, et va automatiquement à la ligne au-delà de la 32ème colonne.
En ce sens, elle est comparable à la fonction Output() du langage TI-Basic historique, et te permettra donc de réaliser des interfaces et menus textuels mais cette fois-ci en Python. :bj:


Toutefois, précisons que la fonction disp_at() diffère également de Output() de plusieurs façons.
  • pour tout affichage effectué, si elle n'efface pas le début de ligne elle efface quand même systématiquement la fin de la ligne
  • si elle te permet de choisir la ligne de ton affichage elle ne te permet que très peu d'en contrôler la colonne, ne te donnant que le choix d'afficher ton texte aligné à gauche, droite ou centré
Porter tes programmes TI-Basic fonctionnant en mode texte nécessitera donc d'en adapter la logique d'affichage.


Voyons voir si nous pouvons remédier à ces derniers points, et te proposer quelque chose d'un peu plus proche de la fonction Output() du TI-Basic.

Voici par exemple une fonction outputl() qui te permet de choisir en prime le numéro de colonne de 1 à 32, et utilise l'alignement à gauche :
Code: Select all
from ti_system import *

def outputl(l, c, s):
  s = ' ' * (c-1) + s
  disp_at(l, s, 'left')

for k in range(1, 12):
  disp_at(k, '*' * 32, 'left')

outputl(3, 6, 'test1')

while not espace():
  pass

La fonction outputl() préfixe ici ta chaîne d'autant d'espaces que nécessaires pour l'afficher à la colonne de ton choix.
Toutefois elle a le défaut d'afficher non seulement la fin de ligne mais également le début de ligne, te contraignant donc à construire ton affichage en réalisant un unique affichage par ligne.

Changeons de méthode, voici une fonction outputr() qui utilise pour sa part l'alignement à droite :
Code: Select all
from ti_system import *

def outputr(l, c, s):
  s += ' ' * (32-len(s)-c+1)
  disp_at(l, s, 'right')

for k in range(1, 12):
  disp_at(k, '*' * 32, 'left')

outputr(3, 6, 'test2')

while not espace():
  pass

Ici la fonction affiche la chaîne en alignement à droite en la suffixant d'autant d'espaces que nécessaire pour atteindre la position demandée, avec l'avantage de ne pas effacer le début de ligne.
Même si elle efface quand même la fin de ligne, tu pourras à la différence avec cette fonction réaliser plusieurs affichages par ligne pour tes scripts, à la condition de les effectuer dans l'ordre du plus à gauche au plus à droite.

Et si on tentait avec un alignement au centre ? Ici l'avantage serait d'avoir à rajouter beaucoup moins d'espaces.
A priori cela n'empêchera certes pas l'effacement de la fin de ligne, mais et si on tenter de suffixer le tout d'un caractère retour à la ligne ?
Code: Select all
from ti_system import *

def outputc(l, c, s):
  s += ' ' * (32-2*c-len(s))
  s += '\n'
  disp_at(l, s, 'center')

for k in range(1, 12):
  disp_at(k, '*' * 32, 'left')

outputr(3, 6, 'test3')

while not espace():
  pass

Ici donc pas d'effacement du début de ligne, et la fin de ligne n'est que partiellement effacée.
Toutefois la fonction a l'inconvénient d'effacer la ligne suivante, et c'est donc ici dans l'ordre de haut en bas que tu devras effectuer tes affichages.

Pour afficher tes interfaces multilignes, le meilleur choix semble donc être entre ces deux dernières fonctions, outputr() et outputc(), avec chacune des avantages et des inconvénients. Tu es libre de les reprendre pour tes futurs scripts TI-83 Premium CE Édition Python. :)




6) ti_system et importation/exportation de données

Go to top

Grâce au module ti_system, on peut désormais importer dans l'application Python des données provenant des autres applications de la calculatrice.

recall_RegEQ() par exemple récupère sous forme de chaine le membre de droite l'expression réduite
$mathjax$y=f(x)$mathjax$
trouvée lors de la dernière régression statistique effectuée sur la calculatrice.

recall_list("nom") quant à elle permet de récuperer en Python l'une des listes créées dans le contexte des autres applications de la calculatrice.

Exemple de suite sur ce dernier point, utilisation l'application ProbSim pour lancer simulatanément 3 dés, et ce 100 fois de suite.

L'application permet alors d'exporter les données générées dans des listes aux noms prédéfinis.


Comme le menu de l'application Python nous y invitait, on peut alors mettre le contenu d'une de ces listes, par example ⌊SOMME, dans l'une des listes prédéfinies L1 à L6, par exemple L1.


On peut alors récupérer les données brutes de la somme des dés en Python en utilisant recall_list('1') et commencer à les exploiter, par exemple en les convertissant en données de modalités et effectifs ou encore en en demandant les paramètres statistiques à l'aide des fonctions suivantes.

Note bien que hors du contexte Python, ta calculatrice ne travaille que sur des nombres flottants. Comme tu peux l'observer ci-contre tu récupères donc ici forcément une liste de flottants, il faudra éventuellement en tenir compte selon ce que tu comptes faire avec.

Code: Select all
from math import *

def brut2valeff(l):
  """ Prend en paramètre une liste de valeurs.
      Renvoie une liste de 2 liste :
      - les valeurs uniques
      - les effectifs associés
  """
  d=dict()
  for v in l:
    if not(v in d.keys()):
      d[v]=0
    d[v]+=1
  return [list(d.keys()),list(d.values())]

def stats1var(lv, lf=[]):
  """ Prend en paramètre :
      - une liste de valeurs
      - liste optionnelle des effectifs / fréquences associées
      Renvoie la liste des paramètres statisques correspondants :
      effectif total, moyenne, variance, écart-type, mode,
      minimum, maximum, quartile 1, médiane, quartile3
  """
  if(len(lf) == 0):
    lf = [1 for k in range(len(lv))]

  params = []
  lz = sorted(zip(lv, lf))

  params.append(sum(lf))
  print('Effect tot:', params[0])

  s, s2 = 0, 0
  for k in lz:
    s += k[0]*k[1]
    s2 += k[0]**2*k[1]
  params.append(s/params[0])
  params.append(s2/params[0]-params[1]**2)
  print('Moyenne   :', params[1])
  print('Variance  :', params[2])

  params.append(sqrt(params[2]))
  print('Ecart-type:', params[3])

  zmode, zmin, zmax = lz[0], lz[0], lz[0]
  for k in lz:
    if k[1]>zmode[1]:
      zmode = k
    if k[0]<zmin[0]:
      zmin = k
    if k[0]>zmax[0]:
      zmax = k
  params.extend([zmode[0], zmin[0], zmax[0]])
  print('Mode      :', params[4])
  print('Minimum   :', params[5])

  s, k = 0, -1
  while(s<params[0]/4):
    k += 1
    s += lz[k][1]
  params.append(lz[k][0])
  print('Quartile1:', params[7])

  while(s<params[0]/2):
    k += 1
    s += lz[k][1]
  if(2*s == params[0]):
    params.append((lz[k][0]+lz[k+1][0])/2)
  else:
    params.append(lz[k][0])
  print('Médiane  :', params[8])

  while(s<params[0]*3/4):
    k += 1
    s += lz[k][1]
  params.append(lz[k][0])
  print('Quartile3:', params[9])

  print('Maximum  :', params[6])

  return params


Petite limitation à ce jour, la liste importée ne doit pas comporter plus de 100 éléments, sans quoi l'importation sera refusée. C'est dommage, les programmes scolaire invitant à faire travailler les statistiques avec des données réelles notamment dans le contexte de l'outil numérique, données qui excéderont bien souvent les 100 éléments.

Remarque, contrairement à ce que nous suggérait le menu Python nous n'avions ici aucun besoin de passer par la liste prédéfinie L1.

Inversement maintenant, grâce à la fonction store_list("nom",var) on peut exporter les listes remplies dans le contexte Python vers des variables listes qui seront utilisables par les autres applications de la calculatrice.

Les nombres entiers sont alors convertis en nombres flottants comme l'on peut le constater en réimportant immédiatement les exportations.

A noter que la calculatrice hors du contexte Python gère deux types de listes :
  • les listes de nombres réels
  • les listes de nombres complexes

Si l'un des éléments de la liste exportée est de type complexe, ce sont tous les nombres de la liste qui seront convertis en type complexe comme l'on peut le constater à la réimportation.

Et puis c'est tout, la calculatrice ne gère hors Python que des listes de nombres. Tout élément non numérique interrompra l'exportation.

Mine de rien, il s'agit de fonctionnalités formidables, en parfaite adéquation avec les programmes scolaires. Ces derniers demandent en effet :
  • pour les statistiques, de travailler sur des données réelles, qui une fois transférées à la calculatrice seront donc maintenant récupérables dans l'application Python
  • d'enseigner le Python non pas dans le bête but de coder, compétence technique peu intéressante en soi, mais comme outil transversal de résolution de problèmes
Jusqu'à présent la TI-83 Premium CE Édition Python avait le défaut d'avoir son application Python qui tournait en vase clos, sans aucun échange possible avec le reste des applications du logiciel de Mathématiques intégré de la calculatrice. Elle ne permettait donc bêtement que de coder dans son coin et pas de résoudre des problèmes, c'est-à-dire de faire appel à plusieurs applications de la calculatrice pour traiter différemment les mêmes données. Et d'ailleurs, même reproche à ce jour pour l'ensemble de la concurrence. :mj:

Texas Instruments est donc le premier constructeur à s'attaquer à ce défaut et à nous proposer quelque chose d'innovant, le Python de ta TI-83 Premium CE Édition Python va enfin pouvoir te servir à faire des Maths/Sciences et non plus seulement du code, félicitations ! :bj:

De plus, rappelons que TI-Connect CE te permet d'importer des fichiers de données .csv que tu peux notamment exporter à partir de feuilles de calculs, de quoi travailler encore plus facilement et rapidement sur des données réelles ! :bj:

Tutos TI-83 Premium CE Édition Python 5.5 :

Re: Exploration module Python ti_system TI-83 Premium CE 5.5

Unread postPosted: 30 Mar 2020, 11:45
by critor
La logique des codes claviers n'a visiblement rien à voir avec le clavier, que ce soit sa géométrie ou ses modificateurs
2nde
et
alpha
.

Je me demande si la logique interne ne serait pas basée sur les caractères envoyés par les touches dans sys.stdin, un peu comme ce qu'avait fait CaptainLuigi.

En effet, il y a une logique pour les caractères consécutifs :
  • codes 143 à 151 pour les caractères 1 à 9
  • codes 154 à 179 pour les caractères A à Z
  • ...
Sauf que ce ne serait clairement pas de l'ASCII.

Re: Exploration module Python ti_system TI-83 Premium CE 5.5

Unread postPosted: 30 Mar 2020, 13:49
by critor
Première tentative d'une fonction destinée à rendre plus facilement utilisable la fonction secrète wait_key() pour tes scripts. Prend en paramètre :
  • la ligne de la touche, même numérotation qu'en TI-Basic (de 1 à 10 de haut en bas)
  • la colonne de la touche, même numérotation qu'en TI-Basic (de 1 à 5 de gauche à droite)
  • l'éventuel modificateur utilisé (0 = aucun par défaut, 1 =
    2nde
    , 2=
    alpha
    )
Et renvoie le code à utiliser dans ton script.
Code: Select all
def codeTouche(lgn,col,modif=0):
  def addChars(dico, char0, code0, nbr, pref=''):
    for k in range(nbr):
      dico[pref + chr(ord(char0) + k)] = code0 + k
  t = (
      (0, ('on', '->', '<-', '|^', '|v', 'enter')),
      (9, ('annul', 'del', 'ins', 'rcl', 'preced', 'home', 'end')),
      (44, ('apps', 'prgm', 'F3', 'draw', 'F6', 'stats', 'math', 'tests')),
      (53, ('var', 'mem', 'matrix', 'distrib', 'angle', 'lists', 'F9', ' ', 'quit', 'link', 'F5', 'mode')),
      (72, ('F2', 'F1', 'F10', 'F7')),
      (87, ('F8')),
      (90, ('F4')),
      (128, ('+', '-', '*', '/', '^', '(', ')', '[', ']')),
      (138, ('sto->', ',', '(-)', '.')),
      (152, ('EE', 'catalog')),
      (180, ('X,T,theta,n', 'pi', '^-1')),
      (189, ('^2', 'sqrt', 'ln', 'e^', 'log', '10^', 'rep')),
      (202, ('?', '"', 'theta')),
      (238, ('i', 'e')),
      (64016, ('integr', 'trig', '<>')),
      (64020, ('resol')),
      (64458, ('//')))
  dico=dict()
  for v in t:
    for k in range(len(v[1])):
      dico[v[1][k]] = v[0] + k
  addChars(dico, '0', 142, 10)
  addChars(dico, 'A', 154, 26)
  addChars(dico, '1', 243, 6, 'L')
  addChars(dico, 'u', 249, 3)
  keymap = (
          (('F1','F6')          ,('F2','F7')           ,('F3','F8')         ,('F4','F9')        ,('F5','F10')),
          (()                   ,('mode','quit')       ,('del','ins')       ,('<-','home')      ,('|^')),
          (()                   ,('X,T,theta,n','link'),('stats','lists')   ,('|v')             ,('->','end')),
          (('maths','tests','A'),('matrix','^-1','B')  ,('prgm','draw','C') ,('var','distrib')  ,('annul')),
          (('<>','angle','D')   ,('trig','pi','E')     ,('resol','apps','F'),('//','integr','G'),('^','','H')),
          (('^2','sqrt','I')    ,(',','EE','J')        ,('(','{','K')       ,(')','}','L')      ,('/','e','M')),
          (('log','10^','N')    ,('7','u','O')         ,('8','v','P')       ,('9','w','Q')      ,('*','[','R')),
          (('ln','e^','S')      ,('4','L4','T')        ,('5','L5','U')      ,('6','L6','V')     ,('-',']','W')),
          (('sto->','rcl','X')  ,('1','L1','Y')        ,('2','L2','Z')      ,('3','L3','theta') ,('+','mem','"')),
          (('on')               ,('0','catalog',' ')   ,('.','i',':')       ,('(-)','rep','?')  ,('enter','preced')))
  if(lgn == 2 and col == 6): lgn = 3; col = 5
  if(len(keymap[lgn-1][col-1])<=modif or len(keymap[lgn-1][col-1][modif])==0): modif=0
  return dico[keymap[lgn-1][col-1][modif]]

Et ça marche ! :D
Ci dessous dans l'ordre, les demandes de :
  • f(x)
  • entrer
  • 2nde
    maths
  • alpha
    maths
Image

Re: Exploration module Python ti_system TI-83 Premium CE 5.5

Unread postPosted: 30 Mar 2020, 20:35
by critor
Gros avantage de la fonction secrète wait_key() du Python par rapport au getKey du TI-Basic, à la différence wait_key() gère les claviers USB ! :bj:

Si si, la preuve on peut même obtenir des codes de retour pour des touches non présentes au clavier de la calculatrice, par exemple ici 10 pour la touche retour arrière : :D
12383

Bientôt tu pourras jouer à tes jeux Python TI-83 Premium CE avec un clavier de gaming ! :#tritop#:

Re: Exploration module Python ti_system TI-83 Premium CE 5.5

Unread postPosted: 30 Mar 2020, 20:44
by grosged
Super!! =D

Idée farfelue qui me traverse l'esprit : serait-il possible de "logiciellement" basculer en capslock ?..Si oui, ça ferait allumer/éteindre la led du clavier ?..

Re: Exploration module Python ti_system TI-83 Premium CE 5.5

Unread postPosted: 17 Jun 2020, 17:21
by Bobb
Peut on réaliser une action en même temps que d'attendre une touche ?

Re: Exploration module Python ti_system TI-83 Premium CE 5.5

Unread postPosted: 17 Jun 2020, 20:00
by critor
Non, désolé. Le wait_key() comme son nom l'indique est hélas bloquant.
Donc toute une série de jeux (ceux qui n'ont pas de notion de tour) sont à ce jour exclus en TI-Python.

Re: Exploration module Python ti_system TI-83 Premium CE 5.5

Unread postPosted: 02 Apr 2021, 15:35
by Fabien59
Bonjour,
Je découvre, grâce à vous, les fonctions cachées de la TI83 comme par exemple wait_key() pour le module ti_system.
Je vous en remercie :) Cette fonction me sera très pratique pour lancer des acquisitions de données depuis une carte à microcontrôleur.

Pouvez-vous m'expliquer pourquoi TI cache ces fonctions aux utilisateurs alors qu'elles sont si pratiques ?

Fabien