Nous te parlons régulièrement sur nos calculatrices de jeux Doom-like, du nom du mythique jeu fps de 1993 par id Software avec affichage 3D (technique du raycasting étendu).
Si sur calculatrices il s'est souvent agi de créations de fans dans loin d'égaler l'original, signalons les TI-Nspire avec leur formidable processeur 32 bits ARM9(architecture ARMv5) qui sont les premières calculatrices à avoir bénéficié d'un véritable portage, nDoom par Mrakoplatz pour les TI-Nspire monochromes dès 2011, puis moi-même dès 2012 pour les TI-Nspire CX. C'est-à-dire qu'il s'agit d'une recompilation intégrale à partir du code source du jeu. Tu pouvais donc ici retrouver l'intégralité du jeu original ainsi que de ses extensions et évolutions compatibles (Ultimate Doom, Final Doom, Plutonia Experiment, TNT Evilution, Doom II, ...) Le code source de nDoom vient tout juste d'être repris cette année pour créer CGDoom, un portage compatible Casio Graph 90+E et fx-CG10/20/50.
Rappelons que sur les TI-Nspire la couche logicielle très lourde de l'environnement écrase littéralement les performances des programmes en langage interprété (Basic ou Python), que pour ce genre de projet il faut pouvoir exécuter du code machine et donc disposer du jailbreakNdless, que malheureusement Texas Instruments a toujours farouchement combatte le jailbreakNdless et que l'équipe de développement de ce dernier semble avoir baissé les bras, Ndless n'est plus adapté pour les dernières mises à jour de rentrée 2021 (TI-Nspire CX 4.5.5 et TI-Nspire CX II 5.3.1) qui bien évidemment interdisent le retour à une version inférieure.
Mais id Software n'a pas sorti que Doom dans ce style. Avant Doom il y a eu Wolfenstein 3D en 1992, et après Doom il y a eu Quake en 1996.
Quake a lui aussi bénéficié d'un portage pour TI-Nspire par Ralf Willenbacher alias rwillen 2015.
Par rapport à Doom, Quake apporte plusieurs évolutions significatives au moteur :
D'une part le moteur permet d'afficher l'ensemble des éléments en 3D. C'est-à-dire que les ennemis et items ne sont plus de simples sprites te présentant toujours la même face pour les items, ou un nombre limité de faces pour les ennemis.
D'autre part, tu peux désormais sauter et même dans certaines conditions voler. c'est-à-dire que la 3ème dimension passe d'une décoration à un véritable élément de jeu.
rwill nous ayant hélas quitté pour un temps, dans le cadre des dernières mises à jour de NdlessVogtinator s'était chargé de patchernQuake pour le rendre compatible avec les révisions majeures du matériel TI-Nspire CX sorties depuis :
les TI-Nspire CX CR4+(assemblées à partir d'octobre 2015) qui retournaient la géométrie du buffer l'écran, ce dernier passant de 320×240 pixels à 240×320 pixels
les TI-Nspire CX II(assemblées depuis novembre 2018)
Toutefois, il s'agissait d'un patch très rapide s'appuyant sur le mode de compatibilité alors introduit dans Ndless, un mode qui interceptait et corrigeait les affichages. L'activation de ce mode t'était indiquée par une fenêtre popup au lancement de nQuake, et dans ce cas les performances n'étaient pas au rendez-vous.
Et bien bonne nouvelle, rwill est de retour cette année !
Il vient de prendre le temps de nous signer une mise à jour nQuake de qualité, la version 1.03 :
gérant désormais directement les dernières révisions matérielles TI-Nspire, et n'utilisant donc plus le mode de compatibilité Ndless
et en prime nettement plus performante
Regarde un peu ces performances que nous avons mesurées, sans aucun overclocking :
Pour accompagner en douceur la transition du Scratch au Python en Seconde, la plupart des solutions Python sur calculatrices graphiques offrent turtle, une bibliothèque permettant du tracé relatif comme en Scratch. On peut citer :
la NumWorks dont l'application Python intègre directement turtle
les Casio Graph 35+E II et Graph 90+E dont l'application Python intègre directement turtle
les TI-Nspire CX II sur lesquelles on peut rajouter la bibliothèque officielle turtle(anciennement ce_turtl) à l'environnement Python
les TI-83 Premium CE Edition Python(France), TI-84 Plus CE-T Python Edition(Europe) et TI-84 Plus CE Python(Amérique du Nord), sur lesquelles on peut rajouter une bibliothèque turtle officielle
et KhiCAS
Aujourd'hui penchons-nous à nouveau sur le turtle de KhiCAS. Conçu par Bernard Parisse, enseignant-chercheur à l'Université de Grenoble, KhiCAS est la déclinaison sur calculatrices du logiciel de Mathématiques intégré Xcas. Disponible pour calculatrices NumWorks N0110, TI-Nspire CX, Casio Graph 35+E II et Graph 90+E, KhiCAS te donne donc accès à une interface unifiée ainsi qu'à des fonctionnalités haut de gamme peu importe la marque ou le modèle de ta calculatrice !
Ce formidable environnement de Mathématiques et de sciences t'apporte bien des choses. Nous pouvons citer dans tous les cas :
la reprise du moteur de calcul formel GIAC développé pour Xcas par le même auteur.
la possibilité de programmer dans 2 langages :
le langage Xcas historique
le langage Xcas avec une couche de compatibilité syntaxique Python
Dans ses éditions pour TI-Nspire CX et NumWorks N0110, KhiCAS apporte pas mal de compléments :
possibilité de composer et convertir ses unités
une bibliothèque de constantes physiques
plusieurs applications elles-même intégrées, dont entre autres :
tableur / feuille de calcul
tableau périodique des éléments
calcul financier
2 langages de programmation supplémentaires :
Python via un interpréteur Micropython
Javascript via un interpréteur QuickJS
L'environnement Python sur ces modèles est extrêmement riche, bien davantage que les solutions Python intégrées par les constructeurs. On peut citer nombre de bibliothèques :
cas et xcas pour appeler le moteur de calcul formel GIAC directement depuis tes scripts Python
cmath pour traiter directement tes calculs sur les nombres complexes en Python
linalg pour l'algèbre linéaire
arit pour l'arithmétique
ulab.scipy pour le calcul scientifique
ulab.numpy pour le calcul matriciel et vectoriel
plusieurs bibliothèque de tracés :
turtle pour les tracés relatifs à la Scratch
matplotlib pour les tracés dans un repère
graphic pour les tracés par pixels, accompagnée de casioplot pour la compatibilité avec les scripts graphiques Casio et kandinsky pour la compatibilité avec les scripts graphiques NumWorks
et bien d'autres : gc, math, micropython, nsp, pylab, random, sys, time, ubinascii, ucollections, uctypes, uerrno, uhashlib, uheapq, uio, ujson, ure, ustruct, uzlib
Un fantastique avantage du turtleKhiCAS, exclusif à ce jour, c'est qu'une fois que ton script Python-turtle a terminé de s'exécuter, il t'est possible d'en faire défiler l'affichage avec les flèches du clavier !
La dernière mise à jour alpha de KhiCAS améliore encore plus la fiabilité de la bibliothèque turtle. Elle est disponible à ce jour :
Tentons pour le moment un autodiagnostic plus général des différences entres les ancienne et nouvelle bibliothèques turtle de KhiCAS, c'est-à-dire la vérification de tout ce qui peut différer du standard.
Voici des scripts en ce sens, une amélioration majeure de ceux développés dans le code de notre test de rentrée QCC 2021 :
def _turtle_error(k): global _turtle_errors _turtle_errors |= 1 << k
# import turtle try: import turtle if not "forward" in dir(turtle): turtle = turtle.Turtle() except ImportError: #TI-83 Premium CE from ce_turtl import turtle _turtle_error(0) try: turtle.clear() except: turtle.reset()
# can turtle be patched ? _fix_turtle = True try: def _fixcolor(c): return c turtle._fixcolor = _fixcolor except: _fix_turtle = False
# test color() + pencolor() + fillcolor() if not "pencolor" in dir(turtle): pencolor = turtle.color _turtle_error(1) else: pencolor = turtle.pencolor if not "color" in dir(turtle): _turtle_error(2) if not "fillcolor" in dir(turtle): _turtle_error(12)
if not "clear" in dir(turtle): _turtle_error(13) if not "reset" in dir(turtle): _turtle_error(14) if not "heading" in dir(turtle): _turtle_error(11)
# test colormode() if not "colormode" in dir(turtle): _turtle_error(3)
# test color strings _colors_fix={ "blue":(0,0,1), "green":(0,1,0), "red":(1,0,0), "cyan":(0,1,1), "yellow":(1,1,0), "magenta":(1,0,1), "white":(1,1,1), "orange":(1,0.65,0), "purple":(0.66,0,0.66), "brown":(0.75,0.25,0.25), "pink":(1,0.75,0.8), "grey":(0.66,0.66,0.66), "black":(0,0,0), } for c in tuple(_colors_fix.keys()): try: pencolor(c) _colors_fix.pop(c) except: pass if len(_colors_fix): if _color_types & 1 << 3: _turtle_error(8)
# test circle(,) try: turtle.circle(0,0) except: _turtle_error(9)
#test towards try: turtle.towards except: _turtle_error(15)
# test for unfixable missing functions _missing_fct=["write","pensize","dot"] for f in tuple(_missing_fct): try: eval("turtle."+f) _missing_fct.remove(f) except: pass if len(_missing_fct): _turtle_error(16)
_missing_alias=[ ["backward","back","bk"], ["forward","fd"], ["right","rt"], ["left","lt"], ["position","pos"], ["goto","setpos","setposition"], ["setheading","seth"], ["pendown","pd","down"], ["penup","pu","up"], ["pensize","width"], ["showturtle","st"], ["hideturtle","ht"], ] for aliases in tuple(_missing_alias): validf = None for f in tuple(aliases): try: eval("turtle."+f) validf = f aliases.remove(f) break except: pass for f in tuple(aliases): try: eval("turtle."+f) aliases.remove(f) except: pass if not len(aliases): _missing_alias.remove(aliases) else: aliases.insert(0, validf) if len(_missing_alias): _turtle_error(17)
from ttl_chk import * from ttl_chk import _fix_turtle, _turtle_errors, _colors_fix, _missing_fct, _missing_alias
def turtle_diags(): print("Type: " + str(type(turtle))) print("Patchable: " + (_fix_turtle and "yes" or "no")) errors_msg = ( "No <import turtle>", "No pencolor()", "No color()", "No colormode()", "No color as list", "No color as tuple", "No color as args", "No color as string", "Missing colors strings: ", "No circle(,angle)", "Can't get position()", "No heading()", "No fill", "No clear()", "No reset()", "No towards()", "Other missing: ", "Missing aliases: ", ) errors = 0 for k in range(len(errors_msg)): if _turtle_errors & 1 << k: errors += 1 msg = "Err " + str(k) + ": " + errors_msg[k] if k == 8: msg += str(len(_colors_fix)) + " " + str(tuple(_colors_fix.keys())) if k == 16: msg += str(len(_missing_fct)) + " " + " ".join(_missing_fct) if k == 17: l = [] for v in _missing_alias: l.extend(v[1:]) msg += str(len(l)) + " " + " ".join(l) print(msg) print(str(errors) + " error" + ((errors > 1) and "s" or ""))
turtle_diags()
Voici ce que nous racontent les scripts sur les différentes solutions turtle :
Aucune erreur n'est détectée automatiquement autmatiquement par nos scripts avec KhiCAS, chose exceptionnelle si l'on compare aux solutions officielles, et signe d'un soin absolument minutieux !
Mais ça, c'est pour les problèmes détectables par des vérifications automatisées. Voyons maintenant d'éventuels écarts visuels sur quelques exemples de scripts.
Afin de pouvoir comparer équitablement avec les solutions officielles visiblement parfois bien moins conformes au standard turtle tout en conservant une unique version de chaque script utilisable sur l'ensemble des solutions, voici un script qu'il suffira d'importer à la place de chaque bibliothèque turtle et qui, lorsque celle-ci sera modifiable, corrigera la plupart des erreurs détectées :
_fix_color = _color_types & 0b11 != 0b11 or not "colormode" in dir(turtle)
# fix list/tuple color argument if _color_types & 0b11 == 0b10: def _fixcolorlist(c): return type(c) is list and tuple(c) or c turtle._fixcolorlist = _fixcolorlist if _color_types & 0b11 == 0b01: def _fixcolorlist(c): return type(c) is list and list(c) or c turtle._fixcolorlist = _fixcolorlist if not _color_types & 4: def _fixcolorargs(*argv): return len(argv) != 1 and argv or argv[0]
if _fix_color: turtle._color = turtle.color turtle._pencolor = turtle.pencolor turtle._fillcolor = turtle.fillcolor if _color_types & 0b11: def _color(*argv): n = len(argv) if not(n): return turtle._color() elif n==2: turtle._color(argv[0], argv[1]) else: turtle._color(n > 1 and argv or argv[0]) def _pencolor(*argv): if not(len(argv)): return turtle._pencolor() turtle._pencolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0])) def _fillcolor(*argv): if not(len(argv)): return turtle._fillcolor() turtle._fillcolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0])) else: def _color(*argv): n = len(argv) if not(n): return turtle._color() c = turtle._fixcolor(n == 3 and argv or argv[0]) turtle._color(c[0], c[1], c[2]) def _pencolor(*argv): if not(len(argv)): return turtle._pencolor() c = turtle._fixcolor(len(argv)>1 and argv or argv[0]) turtle._pencolor(c[0], c[1], c[2]) def _fillcolor(*argv): if not(len(argv)): return turtle._fillcolor() c = turtle._fixcolor(len(argv)>1 and argv or argv[0]) turtle._fillcolor(c[0], c[1], c[2]) turtle.color = _color turtle.pencolor = _pencolor turtle.fillcolor = _fillcolor
# fix colormode() if _turtle_errors & 8: # test color mode try: turtle.pencolor([255, 0, 0]) _color_mode = 255 except: _color_mode = 1.0 turtle._color_mode = _color_mode def _colormode(*argv): if not(len(argv)): return turtle._color_mode if int(argv[0]) in (1, 255): turtle._color_mode = int(argv[0]) == 255 and 255 or 1.0 turtle.colormode = _colormode if _color_mode == 255: turtle._fixcolorval = lambda c: int(turtle._color_mode) == 1 and type(c) in (list, tuple) and [int(c[k] * 255) for k in range(3)] or c else: turtle._fixcolorval = lambda c: turtle._color_mode == 255 and type(c) in (list, tuple) and [c[k] / 255 for k in range(3)] or c
# fix color strings if len(_colors_fix): def _fixcolorstring(c): if type(c) is str and c in _colors_fix: c = _colors_fix[c] if turtle.colormode() == 255: c = [int(c[k] * 255) for k in range(3)] return c turtle._fixcolorstring = _fixcolorstring
if len(_missing_fct): for f in _missing_fct: exec("turtle."+f+"=nop")
if len(_missing_alias): for aliases in _missing_alias: validf = aliases[0] for f in aliases[1:]: exec(validf and "turtle."+f+"=turtle."+validf or "turtle."+f+"=nop")
# fix clear() if _turtle_errors & 0x2000: turtle.clear = turtle.reset
# fix reset() if _turtle_errors & 0x4000: turtle.reset = turtle.clear
# fix towards() if _turtle_errors & 0x8000: from math import atan2, pi def _towards(x, y): x0, y0 = turtle.pos() return atan2(y - y0, x - x0) * 180 / pi turtle.towards = _towards
Maintenant que nous avons de quoi faire tourner une unique version de chaque script sur l'ensemble des machines, poursuivons donc l'exploration de l'ensemble des solutions turtle avec quelques exemples de script.
Nous allons en profiter pour nous en donner à cœur joie avec les formidables fonctions de remplissage rajoutées dans l'avant-dernière version de KhiCAS, sur le thème de #LesMathématiquesSontBelles.
C'est donc l'occasion de voir si il y avait d'autres problèmes qui n'ont pas pu être détectés automatiquement, et si ils sont toujours présents dans la dernière version.
Plusieurs des exemples qui vont suivre sont inspirés de publications de Bert Wikkerink pour TI-Nspire CX II et très librement et fortement adaptés pour être fonctionnels dans le contexte du heapPython bien plus restreint des TI-83 Premium CE et compatibles.
Commençons par quelques exemples sur lesquels la dernière version de KhiCAS progresse :
def rpoly(c, n): for k in range(n): turtle.forward(c) turtle.left(360 / n)
def audi(r): ir = 2 * r // 13 turtle.penup() turtle.left(90) turtle.forward(r//2 - 2*ir) turtle.right(90) turtle.forward(-ir) turtle.pendown() turtle.pensize(3) for i in range(4): turtle.penup() turtle.forward(3 * ir) turtle.pendown() turtle.circle(2 * ir)
def mercedez_benz(r): ir = r // 2 turtle.penup() turtle.forward(ir) turtle.left(90) turtle.forward(ir) turtle.pendown() turtle.pensize(2) x, y = turtle.pos() turtle.setheading(210) for i in range(3): turtle.goto(x,y) turtle.forward(ir) turtle.left(120) turtle.setheading(0) turtle.circle(-ir)
def citroen(r): x,y=turtle.pos() turtle.setheading(0) turtle.color((255,0,0), (255,0,0)) turtle.begin_fill() rpoly(r, 4) turtle.end_fill() turtle.fillcolor((255,255,255)) for i in range(2): turtle.setheading(45) turtle.begin_fill() for k in range(2): turtle.forward(.71 * r) turtle.left(k and 172 or -90) for k in range(2): turtle.forward(5 * r / 6) turtle.left(106) turtle.end_fill() y += r / 3 turtle.penup() turtle.goto(x,y) turtle.pendown()
def mitsubichi(r): ir = r // 3 turtle.penup() turtle.left(90) turtle.forward(ir) turtle.right(90) turtle.forward(r // 2) turtle.pendown() for i in range(3): turtle.setheading(60 + 120*i) turtle.color((255,0,0), (255,0,0)) turtle.begin_fill() for k in range(4): turtle.forward(ir) turtle.left((k%2) and 120 or 60) turtle.end_fill()
def jeep(r): a=54 ir = r/0.47552825814758/4 #sin(radians(a))/cos(radians(a)) a=ir/0.85 d=0.93*ir turtle.penup() turtle.forward(r//2) turtle.right(90) turtle.forward(ir - r) turtle.pendown() x, y = turtle.pos() turtle.setheading(234) turtle.forward(ir) turtle.left(126) turtle.fillcolor((180,180,180)) turtle.begin_fill() rpoly(a, 5) turtle.end_fill() for i in range(5): col = i < 3 and (0,0,0) or (255,255,255) for j in range(2): turn = j and turtle.left or turtle.right turtle.goto(x,y) turtle.setheading(90 + 72*i) turtle.fillcolor(col) turtle.begin_fill() turtle.forward(d) turn(172) turtle.forward(0.85*d) turn(44) turtle.forward(0.2*d) turtle.end_fill() col = [255 - col[k] for k in range(3)]
turtle.speed(0) turtle.colormode(255)
r = 92 for iy in range(2): for ix in range(3): i = iy*3+ix if i < 5: y, x = (2*iy - 1) * r//2 - 48, (ix - 1)*r - 50 turtle.penup() turtle.goto(x, y) turtle.setheading(0) turtle.pensize(1) turtle.pencolor((0,0,0)) turtle.pendown() (mercedez_benz,jeep,mitsubichi,citroen,audi)[i](r)
Amélioration fantastique, KhiCAS rattrape le gros retard qu'il avait ici par rapport à la concurrence, et trace maintenant correctement les différents logos des constructeurs !
Encore une fois si tu es dans le Sud de la France, tu n'a pas dû voir de neige depuis des années... Faison donc neiger dans ta calculatrice maintenant, faisons neiger des flocons de Koch :
c = [127, 255, 0] l = 80 for j in range(2): for i in range(3): n = j and 3 + i or 2 - i s = 5 - n turtle.penup() turtle.goto(i*117-157, j*95-25) turtle.pencolor(tuple(c)) turtle.pensize(s) turtle.setheading(0) turtle.pendown() flock(n, l) n += 1 rotate_list(c)
try: for i in range(-1, 2, 2): turtle.penup() turtle.goto(80*i - ((i > 0) and 40 or 50), 0) turtle.pendown() try: turtle.begin_fill() except: pass spiral((i > 0) and 9 or 30, (i > 0) and 90 or 36, (i > 0) and (1,2,3,4,5,6,7,8,9) or (1,2,3)) try: turtle.end_fill() except: pass except MemoryError as e: print(e)
Partons maintenant à la pêche avec un script très hautement impressionnant par rapport aux contraintes de heap des TI-83 Premium CE et compatibles ; ici nous sommes vraiment sur le fil de la limite des possibilités concernant ces modèles.
Voici donc une lagogne littéralement pavée de poissons :
Formidable ici aussi, les poissons se comportent enfin correctement sous KhiCAS pour réaliser la pavage !
Petits détails toutefois non spécifiques à cet exemple, lorsque l'on fait défiler le tracé obtenu :
les affichages effectués sur la barre de titre/état en haut d'écran (18 premières lignes de pixels) ne sont pas nettoyés correctement lors des rafraichissements
les formes ne sont bizarrement pas remplies correctement dans une bande correspondant aux 42 premières lignes de pixels
for i in range(2): turtle.color(c[0], c[i]) for h in range(10*i,370,20): r=h * pi / 180 x=d*cos(r) y=d*sin(r) turtle.penup() turtle.goto(x,y) turtle.pendown() turtle.setheading(h) feuille(core,32)
C'est donc parti pour quelques exemples afin d'approfondir les améliorations de la nouvelle bibliothèque turtle pour TI-83 Premium CE Edition Python et compatibles, ainsi que les points forts et faibles par rapport aux autres modèles de calculatrices.
Précisons que les problèmes récurrents ne seront pas systématiquement réévoqués sur chaque exemple.
Un petit peu au Nord de Digne-les-bains en rive droite de la Bléone se trouve la dalle aux ammonites. Comme il est strictement interdit d'en prélever, voici de quoi en reproduire une sur ta calculatrice :
Si tu es dans le Sud de la France tu sais qu'il ne pleut pas souvent (par contre, quand il pleut... il pleut !). Alors voici pour toi un escargot bariolé :
turtle.penup() turtle.goto(0, -20) turtle.pendown() turtle.right(90) for i in range(20): c = [exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)] cb = [v/2 for v in c] turtle.color(cb, c) try: turtle.begin_fill() except: pass turtle.circle(27 + i) try: turtle.end_fill() except: pass turtle.right(10)
Tu n'as jamais touché à un triangle de Penrose ? Et bien voici de quoi en afficher le plan dans ta calculatrice, tu n'auras plus qu'à l'imprimer en 3D, si tu arrives à comprendre où est le devant et l'arrière :
Voici maintenant une belle rosace rhombique pour décorer le bâtiment de ton choix.
Nous utilisons ici la méthode .dot() permettant de remplir un disque de diamètre donné, afin de générer de quoi avoir une couleur de fond d'écran sur nos calculatrices, suffit-il juste de lui spécifier un diamètre suffisamment grand :
turtle.speed(0) turtle.colormode(255) turtle.pencolor((0,0,255)) turtle.dot(320) turtle.pencolor((0,0,0)) turtle.pensize(2) col = ((255,0,0),(255,255,0),(0,255,0),(255,255,255),(255,0,255)) a=60
for i in range(10): c = col[i%5] turtle.color(c, c) turtle.begin_fill() for j in range(5): turtle.forward(a) turtle.right(72) turtle.end_fill() turtle.right(36)
for i in range(10): c = [v//3 for v in col[i%5]] turtle.pencolor(c) for j in range(5): turtle.forward(a) turtle.right(72) turtle.right(36)
Par rapport au fond bleu, notons que c'est bel et bien KhiCAS qui adopte le comportement correct. Selon le standard turtle, la méthode .dot() attend en paramètre le diamètre du disque à tracer. Ce sont les modèles Texas Instruments qui le considèrent à tort comme un rayon et remplissent alors tout l'écran.
for i in range(4): a=r*sin(alpha)*2 d=a/sqrt(2) turtle.pendown() for i in range(12): turtle.right(15) try: turtle.begin_fill() except: pass carre(d) try: turtle.end_fill() except: pass turtle.left(45) turtle.penup() turtle.forward(a) turtle.pendown() turtle.penup() turtle.left(75) turtle.forward(d) turtle.right(60) r=r*cos(alpha)-a/2
Revenons aux fractales et à la récursivité avec les triangles de Sierpiński. As-tu déjà réussi à les compter ? Et bien voici de quoi commencer sur ta calculatrice :
def sierp(n, l): if n == 0: for i in range (0, 3): turtle.forward(l) turtle.left(120) if n > 0: sierp(n - 1, l / 2) turtle.forward(l / 2) sierp(n - 1, l / 2) turtle.backward(l / 2) turtle.left(60) turtle.forward(l / 2) turtle.right(60) sierp(n - 1, l / 2) turtle.left(60) turtle.backward(l / 2) turtle.right(60)
try: # TI-83 Premium CE from ti_system import disp_clr disp_clr() except: pass from ttl_fix import *
def rpoly(c, n): a=360/n for k in range(n): turtle.forward(c) turtle.left(a)
def rosace(c, n1, a, n2): try: turtle.begin_fill() except: pass for i in range(n2): turtle.left(a) rpoly(c, n1) try: turtle.end_fill() except: pass
turtle.colormode(255) turtle.pencolor((0,0,0))
try: turtle.dot(320) except: pass turtle.color((255,255,255),(255,255,0)) turtle.speed(0) turtle.pensize(1) try: for i in range(-1, 2, 2): turtle.penup() turtle.goto(80*i, 0) turtle.pendown() rosace((i > 0) and 21 or 30, (i > 0) and 12 or 8, 30, 12) turtle.pensize(2) turtle.pencolor((0,0,255)) except MemoryError as e: print(e)
def spiral(a,b): turtle.pencolor((0,0,0)) try: turtle.dot(320) except: pass turtle.pencolor((255,255,0)) for i in range(189): for j in range(6): turtle.forward(i/a) turtle.left(23) turtle.left(b) try: turtle.dot(2) except: pass
Selon notre outil de tests, KhiCAS pour TI-Nspire CX et NumWorks N0110 est bien mieux conforme au standard Python-turtle que l'ensemble des solutions turtle officielles, et semble en conséquence bien mieux se comporter en pratique sur une majorité de nos exemples. nous semble offrir à ce jour la meilleure bibliothèque Python turtle toutes solutions confondues.
Les méthodes de remplissage, absentes des implémentations officielles de Casio et NumWorks t'ouvrent la porte à de formidables progrès.
Les progrès témoignent d'un soin minutieux apporté par Bernard Parisse, et vu que tout semble parfait maintenant il va nous falloir tenter d'inventer de nouveaux exemples piégeux...
Pour accompagner en douceur la transition du Scratch au Python en Seconde, la plupart des solutions Python sur calculatrices graphiques offrent turtle, une bibliothèque permettant du tracé relatif comme en Scratch. On peut citer :
la NumWorks dont l'application Python intègre directement turtle
les Casio Graph 35+E II et Graph 90+E dont l'application Python intègre directement turtle
les TI-Nspire CX II sur lesquelles on peut rajouter la bibliothèque officielle turtle(anciennement ce_turtl) à l'environnement Python
les TI-83 Premium CE Edition Python(France), TI-84 Plus CE-T Python Edition(Europe) et TI-84 Plus CE Python(Amérique du Nord), sur lesquelles on peut rajouter une bibliothèque turtle officielle
et KhiCAS
Aujourd'hui justement approfondissons ce dernier point, parlons du turtle de KhiCAS. Conçu par Bernard Parisse, enseignant-chercheur à l'Université de Grenoble, KhiCAS est la déclinaison sur calculatrices du logiciel de Mathématiques intégré Xcas. Disponible pour calculatrices NumWorks N0110, TI-Nspire CX, Casio Graph 35+E II et Graph 90+E, KhiCAS te donne donc accès à une interface unifiée ainsi qu'à des fonctionnalités haut de gamme peu importe la marque ou le modèle de ta calculatrice !
Ce formidable environnement de Mathématiques et de sciences t'apporte bien des choses. Nous pouvons citer dans tous les cas :
la reprise du moteur de calcul formel GIAC développé pour Xcas par le même auteur.
la possibilité de programmer dans 2 langages :
le langage Xcas historique
le langage Xcas avec une couche de compatibilité syntaxique Python
Dans ses éditions pour TI-Nspire CX et NumWorks N0110, KhiCAS apporte pas mal de compléments :
possibilité de composer et convertir ses unités
une bibliothèque de constantes physiques
plusieurs applications elles-même intégrées, dont entre autres :
tableur / feuille de calcul
tableau périodique des éléments
calcul financier
2 langages de programmation supplémentaires :
Python via un interpréteur Micropython
Javascript via un interpréteur QuickJS
L'environnement Python sur ces modèles est extrêmement riche, bien davantage que les solutions Python intégrées par les constructeurs. On peut citer nombre de bibliothèques :
cas et xcas pour appeler le moteur de calcul formel GIAC directement depuis tes scripts Python
cmath pour traiter directement tes calculs sur les nombres complexes en Python
linalg pour l'algèbre linéaire
arit pour l'arithmétique
ulab.scipy pour le calcul scientifique
ulab.numpy pour le calcul matriciel et vectoriel
plusieurs bibliothèque de tracés :
turtle pour les tracés relatifs à la Scratch
matplotlib pour les tracés dans un repère
graphic pour les tracés par pixels, accompagnée de casioplot pour la compatibilité avec les scripts graphiques Casio et kandinsky pour la compatibilité avec les scripts graphiques NumWorks
et bien d'autres : gc, math, micropython, nsp, pylab, random, sys, time, ubinascii, ucollections, uctypes, uerrno, uhashlib, uheapq, uio, ujson, ure, ustruct, uzlib
La dernière mise à jour de KhiCAS améliore justement les possibilités de la bibliothèque turtle. Elle est disponible à ce jour :
Effectivement il y a bien des nouveauté, nous passons de 66 à 69 éléments. Nous disposons de 3 nouvelles méthodes :
.clear() pour effacer l'affichage sans réinitialiser la position de la tortue
.pos(), un alias court de .position() que l'on avait déjà pour récupérer la position de la tortue
.towards(x, y) pour obtenir l'angle d'orientation permettant d'atteindre les coordonnées fournies
Cela peut certes te paraître peu, bien que .towards() permette déjà d'aborder facilement des scripts bien plus ambitieux comme nous verrons plus bas.
Mais ça c'est juste pour les méthodes rajoutées ; il va rester à voir si il y a eu des améliorations sur le fonctionnement des méthodes déjà présentes.
B) Tests de conformité comparatifs (toutes solutions turtle)
Tentons pour le moment un autodiagnostic plus général des différences entres les ancienne et nouvelle bibliothèques turtle de KhiCAS, c'est-à-dire la vérification de tout ce qui peut différer du standard.
Voici des scripts en ce sens, une amélioration majeure de ceux développés dans le code de notre test de rentrée QCC 2021 :
def _turtle_error(k): global _turtle_errors _turtle_errors |= 1 << k
# import turtle try: import turtle if not "forward" in dir(turtle): turtle = turtle.Turtle() except ImportError: #TI-83 Premium CE from ce_turtl import turtle _turtle_error(0) try: turtle.clear() except: turtle.reset()
# can turtle be patched ? _fix_turtle = True try: def _fixcolor(c): return c turtle._fixcolor = _fixcolor except: _fix_turtle = False
# test color() + pencolor() + fillcolor() if not "pencolor" in dir(turtle): pencolor = turtle.color _turtle_error(1) else: pencolor = turtle.pencolor if not "color" in dir(turtle): _turtle_error(2) if not "fillcolor" in dir(turtle): _turtle_error(12)
if not "clear" in dir(turtle): _turtle_error(13) if not "reset" in dir(turtle): _turtle_error(14) if not "heading" in dir(turtle): _turtle_error(11)
# test colormode() if not "colormode" in dir(turtle): _turtle_error(3)
# test color strings _colors_fix={ "blue":(0,0,1), "green":(0,1,0), "red":(1,0,0), "cyan":(0,1,1), "yellow":(1,1,0), "magenta":(1,0,1), "white":(1,1,1), "orange":(1,0.65,0), "purple":(0.66,0,0.66), "brown":(0.75,0.25,0.25), "pink":(1,0.75,0.8), "grey":(0.66,0.66,0.66), "black":(0,0,0), } for c in tuple(_colors_fix.keys()): try: pencolor(c) _colors_fix.pop(c) except: pass if len(_colors_fix): if _color_types & 1 << 3: _turtle_error(8)
# test circle(,) try: turtle.circle(0,0) except: _turtle_error(9)
#test towards try: turtle.towards except: _turtle_error(15)
# test for unfixable missing functions _missing_fct=["write","pensize","dot"] for f in tuple(_missing_fct): try: eval("turtle."+f) _missing_fct.remove(f) except: pass if len(_missing_fct): _turtle_error(16)
_missing_alias=[ ["backward","back","bk"], ["forward","fd"], ["right","rt"], ["left","lt"], ["position","pos"], ["goto","setpos","setposition"], ["setheading","seth"], ["pendown","pd","down"], ["penup","pu","up"], ["pensize","width"], ["showturtle","st"], ["hideturtle","ht"], ] for aliases in tuple(_missing_alias): validf = None for f in tuple(aliases): try: eval("turtle."+f) validf = f aliases.remove(f) break except: pass for f in tuple(aliases): try: eval("turtle."+f) aliases.remove(f) except: pass if not len(aliases): _missing_alias.remove(aliases) else: aliases.insert(0, validf) if len(_missing_alias): _turtle_error(17)
from ttl_chk import * from ttl_chk import _fix_turtle, _turtle_errors, _colors_fix, _missing_fct, _missing_alias
def turtle_diags(): print("Type: " + str(type(turtle))) print("Patchable: " + (_fix_turtle and "yes" or "no")) errors_msg = ( "No <import turtle>", "No pencolor()", "No color()", "No colormode()", "No color as list", "No color as tuple", "No color as args", "No color as string", "Missing colors strings: ", "No circle(,angle)", "Can't get position()", "No heading()", "No fill", "No clear()", "No reset()", "No towards()", "Other missing: ", "Missing aliases: ", ) errors = 0 for k in range(len(errors_msg)): if _turtle_errors & 1 << k: errors += 1 msg = "Err " + str(k) + ": " + errors_msg[k] if k == 8: msg += str(len(_colors_fix)) + " " + str(tuple(_colors_fix.keys())) if k == 16: msg += str(len(_missing_fct)) + " " + " ".join(_missing_fct) if k == 17: l = [] for v in _missing_alias: l.extend(v[1:]) msg += str(len(l)) + " " + " ".join(l) print(msg) print(str(errors) + " error" + ((errors > 1) and "s" or ""))
turtle_diags()
Voici ce que nous racontent les scripts sur les différentes solutions turtle :
On confirme donc avec la nouvelle version KhiCAS l'ajout des 3 méthodes jusqu'alors manquantes.
Mais surtout il n'y a donc dans l'état actuel des scripts plus aucune erreur détectée automatiquement, chose exceptionnelle si l'on compare aux solutions officielles, et signe d'un soin minutieux !
Mais ça, c'est pour les problèmes détectables par des vérifications automatisées. Voyons maintenant d'éventuels écarts visuels sur quelques exemples de scripts.
Afin de pouvoir comparer équitablement avec les solutions officielles visiblement parfois bien moins conformes au standard turtle tout en conservant une unique version de chaque script utilisable sur l'ensemble des solutions, voici un script qu'il suffira d'importer à la place de chaque bibliothèque turtle et qui, lorsque celle-ci sera modifiable, corrigera la plupart des erreurs détectées :
_fix_color = _color_types & 0b11 != 0b11 or not "colormode" in dir(turtle)
# fix list/tuple color argument if _color_types & 0b11 == 0b10: def _fixcolorlist(c): return type(c) is list and tuple(c) or c turtle._fixcolorlist = _fixcolorlist if _color_types & 0b11 == 0b01: def _fixcolorlist(c): return type(c) is list and list(c) or c turtle._fixcolorlist = _fixcolorlist if not _color_types & 4: def _fixcolorargs(*argv): return len(argv) != 1 and argv or argv[0]
if _fix_color: turtle._color = turtle.color turtle._pencolor = turtle.pencolor turtle._fillcolor = turtle.fillcolor if _color_types & 0b11: def _color(*argv): n = len(argv) if not(n): return turtle._color() elif n==2: turtle._color(argv[0], argv[1]) else: turtle._color(n > 1 and argv or argv[0]) def _pencolor(*argv): if not(len(argv)): return turtle._pencolor() turtle._pencolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0])) def _fillcolor(*argv): if not(len(argv)): return turtle._fillcolor() turtle._fillcolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0])) else: def _color(*argv): n = len(argv) if not(n): return turtle._color() c = turtle._fixcolor(n == 3 and argv or argv[0]) turtle._color(c[0], c[1], c[2]) def _pencolor(*argv): if not(len(argv)): return turtle._pencolor() c = turtle._fixcolor(len(argv)>1 and argv or argv[0]) turtle._pencolor(c[0], c[1], c[2]) def _fillcolor(*argv): if not(len(argv)): return turtle._fillcolor() c = turtle._fixcolor(len(argv)>1 and argv or argv[0]) turtle._fillcolor(c[0], c[1], c[2]) turtle.color = _color turtle.pencolor = _pencolor turtle.fillcolor = _fillcolor
# fix colormode() if _turtle_errors & 8: # test color mode try: turtle.pencolor([255, 0, 0]) _color_mode = 255 except: _color_mode = 1.0 turtle._color_mode = _color_mode def _colormode(*argv): if not(len(argv)): return turtle._color_mode if int(argv[0]) in (1, 255): turtle._color_mode = int(argv[0]) == 255 and 255 or 1.0 turtle.colormode = _colormode if _color_mode == 255: turtle._fixcolorval = lambda c: int(turtle._color_mode) == 1 and type(c) in (list, tuple) and [int(c[k] * 255) for k in range(3)] or c else: turtle._fixcolorval = lambda c: turtle._color_mode == 255 and type(c) in (list, tuple) and [c[k] / 255 for k in range(3)] or c
# fix color strings if len(_colors_fix): def _fixcolorstring(c): if type(c) is str and c in _colors_fix: c = _colors_fix[c] if turtle.colormode() == 255: c = [int(c[k] * 255) for k in range(3)] return c turtle._fixcolorstring = _fixcolorstring
if len(_missing_fct): for f in _missing_fct: exec("turtle."+f+"=nop")
if len(_missing_alias): for aliases in _missing_alias: validf = aliases[0] for f in aliases[1:]: exec(validf and "turtle."+f+"=turtle."+validf or "turtle."+f+"=nop")
# fix clear() if _turtle_errors & 0x2000: turtle.clear = turtle.reset
# fix reset() if _turtle_errors & 0x4000: turtle.reset = turtle.clear
# fix towards() if _turtle_errors & 0x8000: from math import atan2, pi def _towards(x, y): x0, y0 = turtle.pos() return atan2(y - y0, x - x0) * 180 / pi turtle.towards = _towards
C) 17 exemples comparatifs (toutes solutions turtle)
Maintenant que nous avons de quoi faire tourner une unique version de chaque script sur l'ensemble des machines, poursuivons donc l'exploration de l'ensemble des solutions turtle avec quelques exemples de script.
Nous allons en profiter pour nous en donner à cœur joie avec les formidables fonctions de remplissage rajoutées dans l'avant-dernière version de KhiCAS, sur le thème de #LesMathématiquesSontBelles.
C'est donc l'occasion de voir si il y avait d'autres problèmes qui n'ont pas pu être détectés automatiquement, et si ils sont toujours présents dans la dernière version.
Plusieurs des exemples qui vont suivre sont inspirés de publications de Bert Wikkerink pour TI-Nspire CX II et très librement et fortement adaptés pour être fonctionnels dans le contexte du heapPython bien plus restreint des TI-83 Premium CE et compatibles.
C'est donc parti pour quelques exemples afin d'approfondir les améliorations de la nouvelle bibliothèque turtle pour TI-83 Premium CE Edition Python et compatibles, ainsi que les points forts et faibles par rapport aux autres modèles de calculatrices.
Précisons que les problèmes récurrents ne seront pas systématiquement réévoqués sur chaque exemple.
Un petit peu au Nord de Digne-les-bains en rive droite de la Bléone se trouve la dalle aux ammonites. Comme il est strictement interdit d'en prélever, voici de quoi en reproduire une sur ta calculatrice :
KhiCAS ainsi que le turtle officiel de la NumWorks avaient un tracé incorrect ici, car la méthode .towards() était absente de leur implémentation de turtle. Et malheureusement, la bibliothèque turtle n'est dans ces deux cas pas altérable à l'exécution ce qui empêchait notre script de corriger.
Concernant KhiCAS ce manque est maintenant comblé, et visiblement parfaitement fonctionnel !
def rpoly(c, n): for k in range(n): turtle.forward(c) turtle.left(360 / n)
def audi(r): ir = 2 * r // 13 turtle.penup() turtle.left(90) turtle.forward(r//2 - 2*ir) turtle.right(90) turtle.forward(-ir) turtle.pendown() turtle.pensize(3) for i in range(4): turtle.penup() turtle.forward(3 * ir) turtle.pendown() turtle.circle(2 * ir)
def mercedez_benz(r): ir = r // 2 turtle.penup() turtle.forward(ir) turtle.left(90) turtle.forward(ir) turtle.pendown() turtle.pensize(2) x, y = turtle.pos() turtle.setheading(210) for i in range(3): turtle.goto(x,y) turtle.forward(ir) turtle.left(120) turtle.setheading(0) turtle.circle(-ir)
def citroen(r): x,y=turtle.pos() turtle.setheading(0) turtle.color((255,0,0), (255,0,0)) turtle.begin_fill() rpoly(r, 4) turtle.end_fill() turtle.fillcolor((255,255,255)) for i in range(2): turtle.setheading(45) turtle.begin_fill() for k in range(2): turtle.forward(.71 * r) turtle.left(k and 172 or -90) for k in range(2): turtle.forward(5 * r / 6) turtle.left(106) turtle.end_fill() y += r / 3 turtle.penup() turtle.goto(x,y) turtle.pendown()
def mitsubichi(r): ir = r // 3 turtle.penup() turtle.left(90) turtle.forward(ir) turtle.right(90) turtle.forward(r // 2) turtle.pendown() for i in range(3): turtle.setheading(60 + 120*i) turtle.color((255,0,0), (255,0,0)) turtle.begin_fill() for k in range(4): turtle.forward(ir) turtle.left((k%2) and 120 or 60) turtle.end_fill()
def jeep(r): a=54 ir = r/0.47552825814758/4 #sin(radians(a))/cos(radians(a)) a=ir/0.85 d=0.93*ir turtle.penup() turtle.forward(r//2) turtle.right(90) turtle.forward(ir - r) turtle.pendown() x, y = turtle.pos() turtle.setheading(234) turtle.forward(ir) turtle.left(126) turtle.fillcolor((180,180,180)) turtle.begin_fill() rpoly(a, 5) turtle.end_fill() for i in range(5): col = i < 3 and (0,0,0) or (255,255,255) for j in range(2): turn = j and turtle.left or turtle.right turtle.goto(x,y) turtle.setheading(90 + 72*i) turtle.fillcolor(col) turtle.begin_fill() turtle.forward(d) turn(172) turtle.forward(0.85*d) turn(44) turtle.forward(0.2*d) turtle.end_fill() col = [255 - col[k] for k in range(3)]
turtle.speed(0) turtle.colormode(255)
r = 92 for iy in range(2): for ix in range(3): i = iy*3+ix if i < 5: y, x = (2*iy - 1) * r//2 - 48, (ix - 1)*r - 50 turtle.penup() turtle.goto(x, y) turtle.setheading(0) turtle.pensize(1) turtle.pencolor((0,0,0)) turtle.pendown() (mercedez_benz,jeep,mitsubichi,citroen,audi)[i](r)
Sur cet exemple, KhiCAS reste l'une des solutions turtle qui s'en tire hélas le moins bien.
Toutefois on peut remarquer une petite amélioration depuis la dernière fois ; la couleur de remplissage passé en 2ème paramètre de la méthode .color(,) n'est plus ignorée et est maintenant gérée correctement.
Si tu es dans le Sud de la France tu sais qu'il ne pleut pas souvent (par contre, quand il pleut... il pleut !). Alors voici pour toi un escargot bariolé :
turtle.penup() turtle.goto(0, -20) turtle.pendown() turtle.right(90) for i in range(20): c = [exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)] cb = [v/2 for v in c] turtle.color(cb, c) try: turtle.begin_fill() except: pass turtle.circle(27 + i) try: turtle.end_fill() except: pass turtle.right(10)
Encore une fois si tu es dans le Sud de la France, tu n'a pas dû voir de neige depuis des années... Faison donc neiger dans ta calculatrice maintenant, faisons neiger des flocons de Koch :
c = [127, 255, 0] l = 80 for j in range(2): for i in range(3): n = j and 3 + i or 2 - i s = 5 - n turtle.penup() turtle.goto(i*117-157, j*95-25) turtle.pencolor(tuple(c)) turtle.pensize(s) turtle.setheading(0) turtle.pendown() flock(n, l) n += 1 rotate_list(c)
try: for i in range(-1, 2, 2): turtle.penup() turtle.goto(80*i - ((i > 0) and 40 or 50), 0) turtle.pendown() try: turtle.begin_fill() except: pass spiral((i > 0) and 9 or 30, (i > 0) and 90 or 36, (i > 0) and (1,2,3,4,5,6,7,8,9) or (1,2,3)) try: turtle.end_fill() except: pass except MemoryError as e: print(e)
Partons maintenant à la pêche avec un script très hautement impressionnant par rapport aux contraintes de heap des TI-83 Premium CE et compatibles ; ici nous sommes vraiment sur le fil de la limite des possibilités concernant ces modèles.
Voici donc une lagogne littéralement pavée de poissons :
Tu n'as jamais touché à un triangle de Penrose ? Et bien voici de quoi en afficher le plan dans ta calculatrice, tu n'auras plus qu'à l'imprimer en 3D, si tu arrives à comprendre où est le devant et l'arrière :
Voici maintenant une belle rosace rhombique pour décorer le bâtiment de ton choix.
Nous utilisons ici la méthode .dot() permettant de remplir un disque de diamètre donné, afin de générer de quoi avoir une couleur de fond d'écran sur nos calculatrices, suffit-il juste de lui spécifier un diamètre suffisamment grand :
turtle.speed(0) turtle.colormode(255) turtle.pencolor((0,0,255)) turtle.dot(320) turtle.pencolor((0,0,0)) turtle.pensize(2) col = ((255,0,0),(255,255,0),(0,255,0),(255,255,255),(255,0,255)) a=60
for i in range(10): c = col[i%5] turtle.color(c, c) turtle.begin_fill() for j in range(5): turtle.forward(a) turtle.right(72) turtle.end_fill() turtle.right(36)
for i in range(10): c = [v//3 for v in col[i%5]] turtle.pencolor(c) for j in range(5): turtle.forward(a) turtle.right(72) turtle.right(36)
Bonne nouvelle ici encore, KhiCAS nous peint enfin les vitraux de la bonne couleur !
Par rapport au fond bleu, notons que c'est cette nouvelle version de KhiCAS qui adopte le comportement correct. Selon le standard turtle, la méthode .dot() attend en paramètre le diamètre du disque à tracer. Ce sont les modèles Texas Instruments qui le considèrent à tort comme un rayon et remplissent alors tout l'écran.
for i in range(4): a=r*sin(alpha)*2 d=a/sqrt(2) turtle.pendown() for i in range(12): turtle.right(15) try: turtle.begin_fill() except: pass carre(d) try: turtle.end_fill() except: pass turtle.left(45) turtle.penup() turtle.forward(a) turtle.pendown() turtle.penup() turtle.left(75) turtle.forward(d) turtle.right(60) r=r*cos(alpha)-a/2
Revenons aux fractales et à la récursivité avec les triangles de Sierpiński. As-tu déjà réussi à les compter ? Et bien voici de quoi commencer sur ta calculatrice :
def sierp(n, l): if n == 0: for i in range (0, 3): turtle.forward(l) turtle.left(120) if n > 0: sierp(n - 1, l / 2) turtle.forward(l / 2) sierp(n - 1, l / 2) turtle.backward(l / 2) turtle.left(60) turtle.forward(l / 2) turtle.right(60) sierp(n - 1, l / 2) turtle.left(60) turtle.backward(l / 2) turtle.right(60)
try: # TI-83 Premium CE from ti_system import disp_clr disp_clr() except: pass from ttl_fix import *
def rpoly(c, n): a=360/n for k in range(n): turtle.forward(c) turtle.left(a)
def rosace(c, n1, a, n2): try: turtle.begin_fill() except: pass for i in range(n2): turtle.left(a) rpoly(c, n1) try: turtle.end_fill() except: pass
turtle.colormode(255) turtle.pencolor((0,0,0))
try: turtle.dot(320) except: pass turtle.color((255,255,255),(255,255,0)) turtle.speed(0) turtle.pensize(1) try: for i in range(-1, 2, 2): turtle.penup() turtle.goto(80*i, 0) turtle.pendown() rosace((i > 0) and 21 or 30, (i > 0) and 12 or 8, 30, 12) turtle.pensize(2) turtle.pencolor((0,0,255)) except MemoryError as e: print(e)
def spiral(a,b): turtle.pencolor((0,0,0)) try: turtle.dot(320) except: pass turtle.pencolor((255,255,0)) for i in range(189): for j in range(6): turtle.forward(i/a) turtle.left(23) turtle.left(b) try: turtle.dot(2) except: pass
for i in range(2): turtle.color(c[0], c[i]) for h in range(10*i,370,20): r=h * pi / 180 x=d*cos(r) y=d*sin(r) turtle.penup() turtle.goto(x,y) turtle.pendown() turtle.setheading(h) feuille(core,32)
Selon notre outil de tests, KhiCAS pour TI-Nspire CX et NumWorks N0110 est bien mieux conforme au standard Python-turtle que l'ensemble des solutions turtle officielles, et semble en conséquence bien mieux se comporter en pratique sur une majorité de nos exemples. nous semble offrir à ce jour la meilleure bibliothèque Python turtle toutes solutions confondues.
Les méthodes de remplissage, absentes des implémentations officielles de Casio et NumWorks t'ouvrent la porte à de formidables progrès.
Certes il y a encore quelques défauts et donc écarts par rapport au tracé obtenu avec la bibliothèque standard sur ordinateur, mais KhiCAS a l'avantage d'être régulièrement maintenu et de bénéficier de plusieurs mises à jour par an.
Les progrès sont déjà très significatifs par rapport à la version précédente, et nul doute qu'ils vont se poursuivre !
Les HP 48SX de 1990 et HP 48GX de 1993 ne disposaient pas de mémoire Flash. Pour installer des applications il fallait acheter des cartes ROM à insérer dans l'un des deux ports présents au dos.
De formidables applications de qualité professionnelle furent sorties par des éditeurs tiers, notamment chez Sparcom avec sa gamme The Pocket Professionnal.
Intéressons-nous aujourd'hui à un des nombreux titres de cette gamme, Spice48.
Spice48 est un logiciel dédié à la gestion de circuits électriques. Il te permettait :
de construire ton circuit avec ses nœuds, fils et composants
de spécifier les valeurs nominale et/ou initiale de chaque composant
de visualiser le circuit
pour cela, de définir toi-même les coordonnées à l'écran des nœuds et composants ou bien d'opter pour le mode de calcul automatique des coordonnées
de générer l'équation différentielle du circuit
de résoudre cette équation et en conséquence de représenter graphiquement l'évolution au cours du temps des grandeurs de ton choix (tension entre deux bornes, intensité...)
Fort malheureusement, en 1993 HP tente une délocalisation du développement des calculatrices, de Corvallis(Oregon, Etats-Unis) à Singapour, délocalisation ratée qui aura fait perdre pas moins de 6 ans au constructeur (6 ans sans nouveauté sérieuse, dont 5 ans sans la moindre nouveauté alors qu'en face sortait la TI-92 dès 1995).
Mais ni Spice48 ni même les autres formidables applications professionnelles sur cartes ROM ne furent rééditées pour les modèles haut de gamme ultérieurs HP 49G, HP 50G et HP Prime, et la communauté n'a pas davantage créé de programme adaptant les fonctionnalités de Spice48. Un énorme regret surtout dans le contexte des capacités de la HP Prime avec son écran couleur tactile, ce modèle méritait vraiment des applications professionnelles qu'il n'a hélas jamais eu.
Outre Sparcom qui avait hélas disparu en 1998, il semble que les contacts avec ces éditeurs tiers aient été perdus entre temps, ou bien que ces derniers se soient désintéressés des calculatrices HP suite à un tel délai. À moins qu'il y ait eu aussi des considérations par rapport à la copie illégale d'applications payantes, les modèles ultérieurs abandonnant en effet les ports d'extension en l'échange de l'ajout de mémoire Flash, rendant donc la manipulation de copie entièrement logicielle et donc en théorie plus accessible et facile.
Personnellement ce manque était mon plus grand regret qui m'avait toujours empêché d'adhérer pleinement aux modèles HP successeurs.
La vente pour la rentrée 2021 de toute la branche HP Calculatrices à Moravia, une obscure société tchèque, ultime erreur du management de chez HP après 30 ans de récidives de bêtises monumentales qui resteront dans l'histoire comme exemple de tout ce qu'il ne faut pas faire (ou inversement tout ce qu'il faut faire pour arriver à se saborder alors qu'on est au sommet), termine d'enterrer les minces espoir qu'il nous restait encore concernant la HP Prime. Bien que majeure, l'ultime mise à jour HP Prime 2.1.14575 sortie par HP juste avant la vente au printemps 2021 est d'une finition très inférieure aux précédentes. Sortie en effet dans l'urgence d'un changement de réglementation des examens 2021 aux Pays-Bas, les nouveautés ajoutées au passage s'accompagnent de nombreux bugs et d'une grave instabilité du système déclenchant très régulièrement des redémarrages ou même l'écran bleu d'erreur fatale, contrairement aux versions précédentes.
Nous ne pouvons que constater que depuis maintenant près d'un an, Moravia a été dans l'incapacité totale de corriger ces très graves problèmes alors que cela aurait dû être leur priorité numéro un, et en sommes donc réduits à considérer les HP Prime actuellement commercialisées comme des machines désormais défectueuses.
Regardons donc ailleurs, pas le choix.
Le logiciel intégré de Mathématiques TI-Nspire gère des documents de travail appelés classeurs, eux-mêmes constitués de pages, pouvant elles-mêmes accueillir chacune de 1 à 4 widgets.
Chaque widget pouvait alors être rempli au choix avec une des 9 applications intégrées, bien évidemment toutes liées dynamiquement entre elles au sein d'un même document (partageant les mêmes données : une modification effectuée dans une des applications étant automatiquement répercutée dans les autres, ce qui fait toute la puissance du logiciel TI-Nspire CX) :
Calculs
Graphiques
Géométrie
Tableur & Listes
Données & statistiques
Éditeur Mathématique
Vernier Dataquest™
Éditeur de programmes
Python
Depuis la mise à jour 4.4 de novembre 2016, les TI-Nspire CX te permettent enfin de rajouter tes propres applications appelées widgets. Il s'agit techniquement de classeurs à enregistrer dans le dossier /MyWidgets/ de la calculatrice, constitués d'une unique page, contenant un script codé dans le langage Lua. Plus exactement seule la première page de ces documents est prise en compte dans ce cadre.
Toutefois depuis maintenant plus de 5 ans, cette formidable possibilité n'avait pas été exploitée. Aucune application pouvant être qualifiée de professionnelle, quasiment rien en fait, juste quelques démos.
Et bien aujourd'hui est le grand jour. schoolstore.fi, le distributeur Texas Instruments en Finlande, vient de développer (en langage Lua) et sortir Physics Drawing. Téléchargeable gratuitement et une fois installée correctement dans le dossier /MyWidgets/, l'application Physics Drawing devient alors rajoutable à tout moment dans les différents widgets et pages de tes documents.
De qualité professionnelle, Physics Drawing te permet comme son nom l'indique de rajouter des schémas de Physique à tes documents. Les schémas entièrement dynamiques restent donc éditables à tout moment, avec des éléments que tu positionnes et édite avec le pointeur. On apprécie l'aide en ligne multilingue sur chaque objet pointé. Les menus eux aussi multilingues permettent de couvrir entre autres les domaines suivants de la Physique :
Circuits électriques (comme dans Spice48 donc, mais à ce jour ici sans les possibilités de résolution)
Systèmes mécaniques
Électromagnétisme
Ondes
Atomistique
Après près de 30 ans d'attente les schémas de circuits électriques (et bien plus encore) sont donc enfin de retour sur calculatrices !
Si l'avenir des calculatrices HP désormais entre les mains du mauvais acteur peut nous paraître hélas aujourd'hui très fortement compromis, l'esprit HP 48 quant à lui n'est pas mort pouvu que tu acceptes de regarder ailleurs.
Le logiciel de mathématiques intégré TI-Nspire est d'une immense complexité, faisant exister et interagir entre elles nombre d'applications interconnectées (tableur, géométrie dynamique, acquisition de données, ...). Un changement local à une application peut ainsi avoir des conséquences hors de l'application en question, et il est difficile de toujours tout anticiper.
C'est pour cela que Texas Instruments fait régulièrement appel à des développeurs et testeurs QA(Quality Assurance) externes, notamment de chez Hildebrando, une société au Mexique.
Nous te présentions un premier prototype passé par chez Hildebrando dans une actualité précédente, mais hélas son système de fichiers avait été nettoyé et était donc vide de toute trace de tests.
Pour la rentrée 2010 sortaient les TI-Nspire Touchpad, premières éditions avec pavé tactile des TI-Nspire.
Les prototypes conçus par Texas Instruments avant la commercialisation d'un nouveau produit suivent différentes phases successives :
PROTO : prototype (concept initial)
EVT : engineering validation tests (concernent plutôt le développement matériel)
DVT : developement validation tests (concernent plutôt le développement logiciel)
PVT : production validation tests (derniers tests avant le lancement de la production de masse)
MP : production de masse
Aujourd'hui, Frédéric Desautels alias mr womp womp nous a déniché un nouveau prototype TI-Nspire CAS Touchpad passé entre les mains d'Hildebrando.
Il s'agit bien d'un prototype, puisque nous notons au dos plusieurs mentions de la phase DVT(Developement Validation Tests):
dans le cadre à la place du numéro de série, une mention NOT FOR SALE DVT1-0909 002
une étiquette à code barre résumant justement la chose en Espagnol avec un DVT1-0909 002, adoptant justement le même format que celle du prototype Hildebrandodéjà présenté
Il s'agit donc d'un prototype DVT1 de numéro de série 002 assemblé en septembre 2009 dans l'usine de code P(usine d'Inventec à Pudong en Chine).
Sur un prototype de phase DVT nous ne nous attendons à rien de bien surprenant sur le matériel, mais Frédéric l'a quand même démonté pour nous. Nous avons :
une carte mère N1_MB_NKB_4420, malheureusement avec l'emplacement J04 du connecteur JTAG laissé vide contrairement à d'autres prototypes de la phase précédente EVT
une carte écran N1/N3_LB_PCR2_FPC_2410
Passons plutôt au logiciel qui peut habituellement réserver davantage de surprises sur un prototype de phase DVT.
Démarrer la calculatrice avec les touches
esc
menu
-
enfoncées nous permet d'accéder au logiciel de diagnostics. Nous notons une version 2.00.DEVBUILD compilée le 19 août 2009 inconnue jusqu'à ce jour, alors que les modèles de production sont dotés de la version 2.00.1183 compilée le 19 février 2010, un gros écart dans le temps.
Une fois la calculatrice redémarrée normalement rien de spécial avec les Boot1 et Boot2, mêmes versions respectives 1.1.8916 et 3.0.1.131 que sur les modèles de production.
Par contre le système d'exploitation est pour sa part intéressant. Il s'agit d'une version 2.0.0.900 jusqu'ici inconnue.
Mais nous en arrivons au véritable trésor que renferme ce prototype, les système de fichiers contient des fichiers de tests d'Hildebrando.
On peut noter entre autres :
plusieurs gros fichiers nommés en "My_seat_leon …", et contenant une vidéo de publicité automobile illustrée ci-contre
un dossier nommé "120 Files" et contenant justement exactement 120 petits fichiers, obtenus par copier-coller successifs d'un même fichier initial
un fichier nommé avec pas moins de 188 caractères
des documents TI-Nspire complexes (beaucoup d'onglets/applications)
...
Visiblement Hildebrando teste le logiciel TI-Nspire dans des conditions extrêmes, soit pour vérifier que son comportement reste conforme, soit pour explorer et signaler des failles éventuelles, soit les deux.
Une véritable mine d'informations qui pourrait être bien utile à l'équipe Ndless si elle voulait bien reprendre du service, que nous mettons à ta disposition ci-dessous.
Pour la rentrée 2007 sortaient les toutes premières TI-Nspire. Elles furent remplacées pour la rentrée 2010 par les TI-Nspire Touchpad, l'un des changements majeurs comme leur nom l'indiquait était l'ajout d'un pavé tactile.
Le logiciel de mathématiques intégré TI-Nspire est un véritable chef-d'œuvre d'horlogerie, faisant exister et interagir entre elles nombre d'applications interconnectées (tableur, géométrie dynamique, acquisition de données, ...). Un changement local à une application peut ainsi avoir des conséquences hors de l'application en question, et il est difficile de toujours tout anticiper.
C'est pour cela que Texas Instruments fait régulièrement appel à des développeurs et testeurs QA(Quality Assurance) externes, notamment de chez Hildebrando, une société au Mexique.
Aujourd'hui, Frédéric Desautels alias mr womp womp nous a déniché un prototype TI-Nspire CAS Touchpad apparemment passé entre les mains d'Hildebrando.
Les prototypes chez Texas Instruments suivent des phases successives :
PROTO : prototype (concept initial)
EVT : engineering validation tests (concernent plutôt le développement matériel)
DVT : developement validation tests (concernent plutôt le développement logiciel)
PVT : production validation tests (derniers tests avant le lancement de la production de masse)
MP : production de masse
Effectivement ici il s'agit bien d'un prototype, puisque nous notons au dos plusieurs mentions de la phase DVT :
dans le cadre à la place du numéro de série, une mention CAS RCB DVT1 NOT FOR SALE 188 P-1209
une étiquette à code barre résumant la chose de façon plus lisible en DVT1-188 P-1209
Il s'agit donc d'un prototype DVT1 de numéro de série 188 assemblé en décembre 2009 dans l'usine de code P(usine d'Inventec à Pudong en Chine).
Mais d'autre part, nous avons une autre étiquette DVT1-188 P-1209 mentionnant cette fois-ci HILDEBRANDO.
Sur du DVT nous ne nous attendons à rien de bien surprenant, mais Frédéric a quand même démonté le prototype pour nous. Nous avons :
une carte mère PCB-TG2995D-MB-4420, au lieu de PCB-TG2995D-MB-4420 pour les modèles de production
une carte écran TG2995-C-LB-2410 identique à celle des modèles de production
Non, ce qui devrait être intéressant sur ce prototype, c'est le logiciel.
Démarrer la calculatrice avec les touches
esc
menu
-
enfoncées nous permet d'accéder au logiciel de diagnostics. Nous notons une version 2.00.837 compilée le 1er décembre 2009 inconnue jusqu'à ce jour, alors que les modèles de production sont dotés de la version 2.00.1183 compilée le 19 février 2010, un gros écart.
Une fois la calculatrice redémarrée normalement rien de spécial avec les Boot1 et Boot2, mêmes versions respectives 1.1.8916 et 3.0.1.131 que sur les modèles de production.
Par contre le système d'exploitation est pour sa part intéressant. Il s'agit d'une version 3.9.0.450 jusqu'ici inconnue, compilée le 11 avril 2014. Une préversion donc de l'avant-dernier système d'exploitation sorti pour les TI-Nspire TouchPad, le 3.9.0.461 compilé le 16 mai 2014.
Bien qu'il s'agisse d'un prototype, l'OS a visiblement été signé avec les clés de production et peut donc être installé sur n'importe quelle calculatrice TI-Nspire CAS TouchPad commercialisée.
Frédéric l'a justement dumpé pour nous et tu peux dès maintenant l'installer sur ta calculatrice ou ton émulateur adéquat.
Outre l'intérêt historique de cette sauvegarde, les quelques différences entre les vieux OS 3.9.0.450 et 3.9.0.461 peuvent paraître sans enjeu maintenant 8 ans après.
Mais avoir accès à des prototypes testés chez Hildebrando pourrait se révéler particulièrement intéressant. Si les fichiers de tests sont toujours présent dans le système de fichiers, cela pourrait nous révéler la nature des tests ainsi que les bugs recherchés, et être fort utile à l'équipe Ndless si elle veut bien reprendre du service plutôt que de laisser mourir le projet comme elle le fait depuis maintenant 1 an (avec 4 mises à jour TI-Nspire depuis dont aucune suivie d'une mise à jour de Ndless).
Malheureusement ici le système de fichiers était quasiment vide, peut-être plus de chances la prochaine fois...
Après de longs mois de dur labeur, nous sommes fiers et heureux de vous annoncer la sortie ce jour du GUI Toolkit NF pour TI Nspire CX/CX II (CAS) et PC en version 1.0Alpha.
Le GUI Tool...Quoi ?!? GUI Toolkit NF ?!? Mais kézako ?!?
Et bien, c'est simple : il s'agit d'une bibliothèque de classes C++ permettant de développer très rapidement des applications graphiques sur Nspire (avec Ndless) et sur PC en utilisant des contrôles graphiques (Widgets), tels que des boutons, des listes déroulantes, des cases à cocher, des menus, etc. Soit en gros, être capable d'avoir ça en un minimum de temps fonctionnant à la fois sur une TI Nspire ou sur un PC, juste en recompilant le programme et sans intervenir dans le code, la librairie se chargeant de gérer la création de l'exécutable dédié à la plateforme ciblée à la compilation :
Les TI Nspire CX/CX II sont de formidables machines, mais force est de constater qu'elles souffrent d'une grosse limitation concernant les langages de programmation Basic/Python. En effet, les fonctions de création d'interfaces homme-machine sont totalement absentes et il donc est particulièrement laborieux de créer des outils avec une belle interface de manière rapide.
Partant de ce constat, le projet GUI Toolkit a été initié en Février 2021 et visait à créer une bibliothèque (from scratch) permettant de combler ce manque pour des programmes écrits en C/C++ avec Ndless.
Le cahier des charges initial était alors relativement simple :
Offrir au programmeur une collection de contrôles graphiques lui permettant de coder rapidement des logiciels graphiques
Etre le plus simple possible à utiliser, via des appels à des fonctions au nom évocateur (In english of course, pour ne pas être trop limitatif)
Etre écrite en C/C++ sur la base de la toolchain Ndless pour offrir une ouverture du projet et une bonne rapidité d'exécution.
Une première version prototype a été écrite durant les premiers mois du printemps 2021, mais souffrait elle aussi de quelques limites fonctionnelles, notamment du fait de l'impossibilité de débugguer facilement les programmes destinés aux Nspire CX-II (pas d'émulation type Firebird disponible pour la Nspire CX II).
Une réflexion a donc conduit à la refonte du projet pour devenir le projet GUI Toolkit NF, NF signifiant "New Foundation" (Nouvelle Fondation pour les non-anglophones), offrant en prime la possibilité de faire tourner les applications destinées à la TI Nspire (et écrites avec le Toolkit bien évidemment) sur PC par une simple re-compilation (pas ré-écriture, c'est important) du code. Les bibliothèques du GUI Toolkit NF se chargeant de faire la traduction au niveau du matériel de manière totalement transparente pour l'utilisateur (le programmeur).
Ainsi, il devient très aisé de créer un programme et de le debugguer efficacement sur un PC avec les outils classiques (GCC/GDB/SDL/Valgrind ...), puis une fois fonctionnel et validé, de recompiler le programme pour une Nspire sans changer une seule ligne de code.
Un petit exemple de programme démo réalisé avec le GUI Toolkit NF, ne faisant certes rien d'utile, mais illustrant les possibilités du Toolkit et fonctionnant sur PC fait l'objet d'une courte vidéo ici :
Mais quel contenu offre le Toolkit ? Et que peut-on faire avec ?
Le toolkit offre un ensemble de classes C++ (donc nécessitant Ndless fonctionnel sur Nspire, attention donc au Firmware installé sur la machine) permettant de coder des applications graphiques. Du point de vue de l'utilisateur, il s'agit de divers Widgets dont un certain nombre sont visibles dans les screenshots suivants et permettant d'interagir avec le programme :
Boutons et cases à cocher :
[o] Boutons textuel [o] Bouton avec icone [o] Case à cocher [o] Bouton Radio [o] Bouton "Slider" [o] ...
Entrée d'informations :
[o] InputBox pour entrée de valeurs/text [o] Multiline Text Box pour entrée d'un texte long [o] Multiline Rich Text Box pour entrée d'un texte long avec mise en forme [o] ...
Menus :
[o] Barre de menus avec possibilité de faire des sous-menus [o] Barre d'icones [o] ...
Fenêtres et dialogbox :
[o] Fenêtres redimensionnables/déplaçables [o] DialogBox non redimensionnables [o] FileDialogBox pour selectionner/naviguer dans les fichiers/répertoires [o] ...
Contexte graphique :
[o] visualisation d'images [o] dessins et rendu de primitives graphiques [o] SplashScreen pour le début d'un programme [o] ...
... et bien plus encore ...
Les applications peuvent contenir de multiples bureaux (correspondant chacun à un écran) et pouvant être facilement "switchés", il devient alors possible d'avoir des programmes avec de multiples fenêtres affichées simultanément soit sur le même bureau ou si cela est plus simple visuellement, d'avoir une fenêtre par bureau et de changer de bureau pour commuter l'affichage. Chaque bureau pouvant avoir son propre fond d'écran.
Le positionnement des Widgets dans une fenêtre par exemple ainsi que leur taille pouvant être statique, c'est à dire définis par le programmeur au départ et immuables, ou bien au contraire gérés dynamiquement par le Toolkit moyennant quelques contraintes (répartition homogène de l'espace ou taille imposée) afin de correctement se repositionner lors du redimensionnement de la dite fenêtre.
Mais le rôle du Toolkit ne s'arrête pas là, et du point de vue du Toolkit, beaucoup de choses supplémentaires sont intégrées. En effet le Toolkit embarque un certain nombre de fonctionnalités supplémentaires, dont certaines ont fait l'objet d'un Fork indépendant appelé lib nSpireLTE pour aider à programmer sur Nspire toute sorte d'applications.
Ces fonctionnalités supplémentaires sont constituées d'un ensemble de classes permettant de gérer le niveau d'abstraction matérielle pour permettre de fonctionner à la fois sur PC et sur Nspire sans avoir besoin de recoder quoi que ce soit :
KeyManager : contenant les fonctions de bas niveau permettant de lire l’état du clavier de la TI Nspire et/ou du PC (avec gestion de l'état des touches pressée ou non à un instant "t", venant d'être appuyée ou venant d'être relâchée )
MouseManager : contenant les fonctions de bas niveau permettant de lire l’état du touchpad de la TI Nspire (mouvement du curseur, click central et gestion des flèches) ou de la souris sur PC
TimeManager : permettant de gérer les fonctions liées au temps sur la Nspire (timer, sleep, heure actuelle)
Debugger : permettant de debugger des programmes en offrant un panel de fonctions pour réaliser des sorties de logs dans un fichier et tracker impitoyablement les bugs et plantages.
Ainsi qu'un "ramasse miettes" (ou GarbageCollector) permettant de contrôler l'absence de fuite de mémoire au niveau des Widgets gérés par le Toolkit. Cet élément étant totalement transparent, sans intervention de l'utilisateur, chaque Widget se déclare de manière autonome lors de sa création afin d'être effacé proprement à la fin du programme.
Mais il ne faut pas non plus oublier d'autres petits trucs sympas:
FontEngine : permettant de faire le rendu de polices de caractères (avec 6 polices intégrées et la possibilité d'avoir des polices utilisateurs supplémentaires)
ColorEngine : Permettant la gestion des couleurs des Widgets
ThemeEngine : Permettant d'avoir un thème graphique pour une application donnée (Fontes de caractères et couleurs de Widgets)
Toute la mécanique étant gérée par une "super classe" (appelée WidgetApplication) et permettant de faire office de chef d'orchestre et de gérer les divers événements (clicks sur les Widgets, mouvements de fenêtre, appuis des touches, ...).
Il devient alors très simple de récupérer l'information de réalisation d'un événement (par exemple savoir si on a cliqué sur un bouton, ou si une CheckBox est cochée) et d'ajuster le comportement du programme en conséquence.
Comme vous l'aurez compris, il est malheureusement compliqué de ne rien oublier, s'agissant d'un gros projet, qui plus est dont le développement n'est pas clos. Beaucoup de nouvelles fonctionnalités et de nouveaux Widgets seront notamment à développer, à ajuster et/ou à ajouter au fil du temps dans de futures révisions, nous ne pouvons donc qu'effleurer la surface des possibilités offertes à travers cette news de sortie ...
Mais ce n'est que partie remise, puisqu'il est prévu de créer un fil spécifique sous forme de mini-tutoriels (avec pourquoi pas des vidéos didactiques) permettant d'illustrer la réalisation d'applications avec le GUI Toolkit NF.
La version courante du GUI Toolkit NF fait très régulièrement l'objet de "commits" sur GitHub ici : GitHub GUI Toolkit NF.
La phase de développement du Toolkit étant désormais suffisamment avancée, une plus grosse quantité d'énergie pourra être consacrée à sa mise en pratique pour coder des applications pour Nspire ... La documentation détaillée est aussi en cours de réactualisation de manière à bien refléter l'avancement de la version NF. Il s'agit là encore d'un gros chantier qui va avancer dans les semaines à venir, un tel projet n'étant pas très utile sans une bonne documentation sur laquelle se baser pour coder des applications.
Alors surtout n'hésitez pas à faire remonter vos idées, vos bugs, vos tests via TI Planet ou via GitHub.
So stay tuned ... More to come (very) soon
Tutoriels vidéo de mise en pratique du GUI Toolkit NF
(Cette liste sera mise à jour au fur et à mesure de leurs sorties.)
Texas Instruments nous sort à nouveau aujourd'hui une mise à jour 5.4 pour ses calculatrices TI-Nspire CX II.
Le numéro de version complet est 5.4.0.259, et la compilation a eu lieu le 11 janvier 2022.
Cette mise à jour fait donc suite à la version précédente 5.4.0.257 compilée le 11 novembre 2021 mais publiée seulement le 6 janvier dernier.
Nous sommes très hautement surpris d'avoir une nouvelle mise à jour après seulement 3 semaines, compilée visiblement quelques jours après la sortie de la version précédente. Il faut croire qu'un défaut significatif a été identifié suite à la publication de la version 5.4.0.257, sans toutefois être trop complexe à corriger. Peut-être quelque chose touchant à la sécurité ou au mode examen, deux arguments de vente majeurs chez Texas Instruments.
Attention, comme toutes les versions précédentes depuis la 5.3.2 incluse, cette nouvelle version 5.4.0.259 n'est pas compatible avec Ndless r2018, et son installation est comme à l'habitude bien évidemment sans aucun retour possible. Toute tentative de réinstaller une version inférieure te sera par la suite refusée.
Si tu choisis de mettre à jour ta calculatrice avec l'une de ces versions, tu renonces donc à Ndless pour une durée indéterminée, des jours, semaines, mois ou même années comme c'est déjà arrivé, nous l'ignorons.
Le changelog officiel n'a pas été mis à jour, évoquant vaguement que les deux mêmes choses que pour la version précédente :
Texas Instruments a écrit:
améliorations des fonctionnalités « Mode examen »
diverses corrections de bugs mineurs
Nous avons cherché pendant plusieurs heures, aussi bien niveau mode examen que niveau bugs déjà rencontrés, mais n'avons strictement rien réussi à trouver comme nouveauté ou amélioration visible pour l'utilisateur.
Il y a toujours les problèmes avec les images-ressources que tu importes dans tes documents via l'éditeur Lua du logiciel TI-Nspire.
Elles sont affichées correctement par les scripts Lua, mais sont inversées verticalement lors d'un affichage par les scripts Python via le module ti_image.
Pire, sur certaines images nous avons même avec une distorsion horizontale en prime...
Niveau Python, il y a toujours un bug bien violent avec la fonction set_color() de la bibliothèque ti_draw. Si jamais tu commets l'erreur de lui passer le paramètre de couleur sous la forme d'une liste au lieu d'un tuple, la calculatrice redémarre instantanément :
Nous te parlons régulièrement sur nos calculatrices de jeux Doom-like, du nom du mythique jeu fps de 1993 par id Software avec affichage 3D (technique du raycasting étendu).
rwill nous ayant hélas quitté pour un temps, dans le cadre des dernières mises à jour de Ndless Vogtinator s'était chargé de patcher nQuake pour le rendre compatible avec les révisions majeures du matériel TI-Nspire CX sorties depuis :
Ca fait toujours plaisir 
