La calculatrice NumWorks était initialement un formidable projet de machine ouverte.
Le développement tiers a pu s'y hisser à un niveau jamais atteint sur la concurrence, et permettant l'émergence d'un projet formidable, Omega par Quentin Guidee et ses non moins illustres collaborateurs.
Il s'agissait d'un firmware alternatif pour ta calculatrice NumWorks. Basé sur le code source d'Epsilon comme la licence libre l'y autorisait, Omega avait pour but de regrouper et mettre en avant les meilleures contributions au code d'Epsilon, en incluant cette fois-ci celles laissées de côté par le constructeur.
Difficile de tout citer ici mais voici déjà par exemple un des fantastiques ajouts d'Omega. La NumWorks travaille en interne sur des arbres de calcul, mais les bridait donc artificiellement pour n'accepter que des valeurs numériques. Omega ré-autorisait à nouveau ces arbres à utiliser des lettres / inconnues, ce qui nous redonnait ainsi un moteur de calcul littéral. De quoi même dériver, du jamais vu à seulement 80€ ! Citons aussi un tableau périodique des éléments, ou encore la possibilité d'avoir une bibliothèque de constantes physiques avec unités bien avant que ce ne soit disponible dans le firmware officiel.
Outre ce qu'il intégrait, Omega offrait également l'avantage de pouvoir installer à chaud des applications, fonctionnalité jusqu'alors absente du firmware officiel Epsilon. Plusieurs applications de très haute facture furent développées, on peut citer entre autres :
KhiCAS, une formidable application intégrée de Mathématiques et de Sciences par Bernard Parisse, enseignant-chercheur à l'Université de Grenoble, qui étendait gratuitement les capacités de ta calculatrice au niveau d'une HP Prime. L'application intégrait le moteur de calcul formel GIAC développé pour le logiciel Xcas du même auteur pour des possibilités en calcul encore plus étendues. Étaient également inclus un tableur, une bibliothèque de constantes physiques, un convertisseur d'unités, un tableau périodique des éléments et bien d'autres choses encore. Le tout était en prime programmable en Python, avec une collection de modules importables bien plus étoffée que celle de l'application Python officielle, et surtout ici de façon intégrée, tes scripts Python pouvant en effet faire appel au moteur de calcul formel GIAC par l'intermédiaire du module cas.
Nofrendo, un émulateur de console de jeux Nintendo NES par zardam
Peanut-GB, un émulateur de console de jeux Nintendo GameBoy par M4x1m3
Les fonctionnalités du firmwareOmega ont été reprises par la suite pour plusieurs forks, les firmwaresUpsilon et Khi, ce dernier par nul autre que Bernard Parisse en personne.
Un gros avantage de plus était ici que KhiCAS et l'ensemble des fonctionnalités rajoutées restaient accessibles en mode examen, de façon parfaitement légale et légitime en France, puisque ces fonctionnalités ne sont pas des données et venaient de plus directement intégrées à des modèles concurrents haut de gamme parfaitement autorisés.
Mais voilà, à la rentrée 2021 la mise à jour 16.3 d'Epsilon, le firmware officiel des calculatrices NumWorks, a introduit un verrouillage des modèles N0110.
Toute N0110 mise à jour ou venant préchargée d'une version 16.3 ou supérieure, comprend un chargeur de démarrage censé être non effaçable, et empêchant entre autres :
l'installation de tout firmware non correctement signé par le constructeur, c'est-à-dire entre autres de tout firmware tiers (Omega, Upsilon, Khi, ...)
l'installation d'applications persistantes en mémoire Flash(logiciel intégré de Mathématiques avec moteur ce calcul formel KhiCAS, émulateurs Nintendo Game Boy et NES, tableau périodique des éléments, ...)
Les utilisateurs informés avaient certes le choix mais étaient face à un cruel dilemme :
soit utiliser le firmwareEpsilon pour bénéficier de toutes les dernières nouveautés officielles, mais en contrepartie renoncer définitivement aux firmwares tiers
soit utiliser un firmware tiers, mais en contrepartie renoncer aux nouveautés officielles car NumWorks a profité de l'occasion du verrouillage pour révoquer sa licence libre, et interdire ainsi la réutilisation de tout code introduit à partir de la version 16
Dans une actualité précédente, nous t'annoncions la sortie de Phi pour le firmwareOmega. Phi est un chargeur de démarrage avec lequel il suffit d'écraser le chargeur officiel, grâce à une faille présente dans les firmwaresEpsilon officiels.
Après plus de 6 mois d'attente Phi te permettait enfin de déverrouiller ta calculatrice, étant ensuite capable de lancer aussi bien les firmwares officiels Epsilon que les firmware tiers, à la seule condition que ces derniers aient été mis à jour pour supporter ce nouvel amorçage.
Encore mieux que ça, avec Phi tu n'avais même pas à choisir entre fonctionnalités officielles et tierces, tu peux avoir les deux en même temps. Depuis le verrouillage la mémoire Flash des N0110 est partitionnée en deux moitiés égales de 4 Mio, et pouvant chacune accueillir un firmware. Le raccourci reset+
4
permet de consulter l'état de la mémoire Flash et de mettre la calculatrice dans un mode de mise à jour protégé car interdisant la réécriture du chargeur de démarrage. La mémoire Flash de 8 Mio est découpé en 2 slotsA et B de 4 Mio chacun. Les raccourcis reset+
1
et reset+
2
te permettent alors de basculer entre l'amorçage des deux firmwares situés dans chacun de ces 2 slots.
Les firmwares tiers Khi puis Upsilon ont été mis à jour par la suite pour pouvoir être amorcés de cette façon, et leurs pages d'installation intègrent également leur propre version du bootloaderPhi.
Khi pour sa part découpait la mémoire Flash de 3 slots :
slot1 de presque 4 Mio, correspondant au slotA
slot2 intermédiaire pour pouvoir accueillir un firmware minimaliste
slot3 de 4 Mio, correspondant au slotB
L'intérêt de ce changement était de pouvoir à la fois installer et utiliser l'application KhiCAS nécessitant beaucoup de place, et bénéficier du multiboot du firmware officiel Epsilon.
Aujourd'hui à la veille des épreuves de spécialité, Bernard Parisse continue à penser à toi et vient de sortir une mise à jour de son firmwareKhi ainsi que du bootloader qu'il utilise.
Comme tu pouvais le remarquer à son écran d'information accessible via reset+
4
, le bootloader de Khi n'était pas capable de distinguer les firmwaresOmega et Khi.
C'est maintenant corrigé avec le nouveau bootloader !
Autre chose, pour basculer entre les firmwares installés tu devais utiliser les raccourcis reset+
1
, reset+
2
ou reset+
3
.
Cela pouvait être embêtant si tu n'avais pas de portemine sous la main, ou plus de mine dedans. Sans compter les traces peu esthétiques que tu laissais alors sur le bouton reset au dos.
Nouveauté justement donc, le firmwareKhi te permet désormais de basculer sur un autre firmware sans avoir à utiliser le bouton reset.
Il te suffit d'appuyer sur le bouton d'extinction de la calculatrice pour obtenir un message t'invitant à taper
1
,
2
ou
3
pour redémarrer la calculatrice sur le firmware du slot associé !
Sans réaction de ta part la calculatrice s'éteindra après 2 secondes, ou sinon tu peux également réappuyer sur la touche d'extinction pour l'éteindre de suite.
Par contre, notons bien que cette fonctionnalité n'est disponible que dans le firmwareKhi. C'est-à-dire qu'une fois la machine redémarrée sur l'autre firmware, tu n'auras pas d'autre choix que d'utiliser le raccourci avec le bouton reset pour revenir sur le firmwareKhi.
Dernière chose. Nous avons vu récemment qu'une méthode enfantine de fraude au mode examen, consistait à mettre la machine sur un menu de démarrage/diagnostic, comme le reset+
4
introduit par les bootloaders de firmwares tiers.
En effet cela éteint la diode même si la calculatrice est en mode examen.
Cela pouvait donc en théorie permettre de tromper le surveillant, lui faisant croire que le mode examen n'est pas activé, et donc d'introduire en salle d'examen une calculatrice dont on n'aura pas à effacer le contenu mémoire.
Et même si tu n'avais aucune intention de frauder, passer par ce menu pendant ton épreuve n'en éteignait pas moins la diode, et pouvait donc faire réagir négativement un surveillant.
Bonne nouvelle, Bernard Parisse a ici encore fait preuve d'une extrême bienveillance envers toi : le bootloader une fois mis à jour n'interrompra plus le clignotement de la diode examen sur cet écran !
Si tu as déjà installé un firmware tiers avec bootloader sur ta calculatrice, pour profiter de l'ensemble des nouveautés de cette mise à jour il te faudra autoriser la réécriture du bootloader, c'est-à-dire utiliser le mode de récupération avec le raccourci reset+
Les modèles haut de gamme TI-Nspire, HP Prime et Casio fx-CP400 sont tous capables de te réprésenter graphiquement en 3D des fonctions à 2 variables.
Problème, si tu as acheté un modèle moins onéreux de milieu de gamme, cette fonctionnalité n'était pas intégrée. C'est notamment un des derniers manques majeurs de la calculatrice NumWorks selon notre comparatif de rentrée 2021.
Il t'était parfois possible de rajouter cette fonctionnalité via un programme ou une application, mais cela t'était alors inaccessible en mode examen.
Mais c'est sans compter sur 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 fonctionnalités. Une amélioration très significative des capacités de ta NumWorks N0110 et TI-Nspire CX numérique de milieu de gamme, mais également une amélioration loin d'être vide de ta TI-Nspire CX CAS de haut de gamme. Nous pouvons citer :
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, avec en prime les méthodes de remplissage de formes et la possibilité de faire défiler l'affichage obtenu
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
KhiCAS n'apportant pas des données mais des fonctionnalités, son usage en situation d'examen est parfaitement légitime selon les spécifications officielles du mode examen.
Cela ne contente bien évidemment pas les constructeurs, mais plusieurs contournements légitimes du mode examen ont été codés en conséquence dans le cadre de KhiCAS sans l'accord des constructeurs en question. Ils sont soigneusement surveillés afin de ne permettre aucune fraude, du moins en France. Nous pouvons citer :
Sur NumWorks N0110, l'installation de l'application KhiCAS nécessite elle-même l'installation d'un firmware tiers (Khi, Omega ou Upsilon). Ces firmwares tiers te permettront justement de conserver l'accès à KhiCAS en mode examen.
Sur les TI-Nspire CX, KhiCAS nécessite l'installation du jailbreakNdless. Il te sera alors possible d'activer le mode examen directement depuis KhiCAS. Seule différence avec l'activation officielle du mode examen, dans ce cas Ndless et KhiCAS seront conservés et utilisables en mode examen. Attention toutefois, cette astuce ne fonctionne pas à ce jour sur les derniers modèles TI-Nspire CX II
Et bien justement, grosse nouveauté de la dernière version stable de KhiCAS, nous disposons maintenant des fonctions plot3d() et graphe3d() pour tracer des représentations graphiques 3D de fonctions à 2 variables !
La fonction attend 3 paramètres avec dans l'ordre l'expression et les noms de ses deux variables. Voici par exemple ci-contre le résultat de l'appel plot3d(x*x*y,x,y).
Sur TI-Nspire c'était certes déjà disponible officiellement, mais on peut apprécier l'affichage sur fond sombre visuellement moins fatigant, ainsi que les nombreuses touches clavier permettant de contrôler la vue (certes les touches fléchées pour les rotations selon 2 axes,
+
et
-
pour le zoom, mais également l'ensemble des touches numériques pour encore plus de possibilités de déplacements).
La commande est utilisable directement si ton environnement KhiCAS est réglé en langage Xcas, y compris avec la compatibilité syntaxique Python. Si tu as réglé ton environnement KhiCAS sur l'interpréteur Micropyton, il te faudra passer par les fonctions d'évaluation du module cas ou xcas à importer, fonctions te permettant d'appeler le moteur GIAC de Xcas. Tu peux utiliser au choix une des commandes suivantes :
Pour la rentrée 2017, NumWorks venait bouleverser le marché des calculatrices graphiques avec sa N0100, premier modèle de calculatrice à être officiellement programmable en Python conformément aux derniers programmes scolaires qui venaient de sortir pour le lycée. Le matériel articulé autour d'un microcontrôleur STM32F412 apportait :
écran couleur 16 bits de 320×240 pixels
processeur 32 bitsCortex-M4 / ARMv7 cadencé à 100 MHz
1 Mio de mémoire Flash
256 Kio de mémoire RAM
connectivité USB micro-B
batterie de 1820 mAh
Pour la rentée 2019, NumWorks sortait une nouvelle édition de sa calculatrice, la N0110. Il s'agissait d'une révision matérielle majeure désormais articulée autour du microcontrôleur STM32F730 et apportant quelques changements que voici :
processeur 32 bitsCortex-M7 / ARMv7 cadencé à 216 MHz
8,0625 Mio de mémoire Flash(8 Mio externes + 64 Kio internes au microcontrôleur)
batterie de 1450 mAh
Pour la rentrée 2022 NumWorks va sortir un nouvelle déclinaison de sa calculatrice, la N0120 EX au Portugal, et peut-être N0120 tout court pour les autres zones de distribution.
Suite aux péripéties toute récentes du projet de calculatrice Zero, la NumWorks N0120 semble être bien partie pour être la star de la rentrée 2022, seule nouveauté matérielle prévue à notre connaissance toute concurrence confondue.
Nous nous attendions justement à une autre révision majeure du matériel.
M4x1m3 a fouillé le ficher de mise à jour dédié en version 16.3.5 déjà servi par le site de NumWorks, et en a déduit l'utilisation d'un microcontrôleur de la famille STM32H7. Ce n'est toutefois pas encore suffisamment précis pour en déduire les spécifications exactes.
Même si il y a peu d'informations publiques, le développement de la N0120 continue. Selon le botTwitter@Numpdate, le site NumWorks vient tout juste de se mettre à servir une nouvelle mise à jour à l'attention des utilisateurs ayant l'insigne honneur de tester la nouvelle N0120 en avant-première, la version 16.4.4.
Nous en ignorons les changements ; le constructeur ne nous les a pas communiqués.
Et nous ignorons également pourquoi les derniers firmwares N0120 sont à ce jour coincés en version 16 alors que les firmwares pour N0100 et N0110 sont en version 18 depuis des mois, même si il y a sûrement une raison derrière.
Depuis la rentrée 2020, NumWorks te sort chaque mois une coque collector en édition limitée pour ta calculatrice. Si tu es chanceux(se) et as su te montrer assidu(e), alors tu devrais avoir pu te constituer une formidable collection. Par ordre chronologique :
Voici pour ce mois de Mai 2022 la toute dernière édition limitée de la coque NumWorks à ajouter à ta collection, t'illustrant avec talent l'arrivée du Printemps.
Tu peux dès maintenant tenter de gagner la coque sur les différents comptes sociaux du constructeur :
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...
by 
La calculatrice NumWorks était initialement un formidable projet de machine ouverte.
Il s'agissait d'un firmware alternatif pour ta calculatrice NumWorks. Basé sur le code source d'Epsilon comme la licence libre l'y autorisait, Omega avait pour but de regrouper et mettre en avant les meilleures contributions au code d'Epsilon, en incluant cette fois-ci celles laissées de côté par le constructeur.
Outre ce qu'il intégrait, Omega offrait également l'avantage de pouvoir installer à chaud des applications, fonctionnalité jusqu'alors absente du firmware officiel Epsilon. Plusieurs applications de très haute facture furent développées, on peut citer entre autres : 
Mais voilà, à la rentrée 2021 la mise à jour 16.3 d'Epsilon, le firmware officiel des calculatrices NumWorks, a introduit un verrouillage des modèles N0110.
Dans une actualité précédente, nous t'annoncions la sortie de Phi pour le firmware Omega. Phi est un chargeur de démarrage avec lequel il suffit d'écraser le chargeur officiel, grâce à une faille présente dans les firmwares Epsilon officiels.
Encore mieux que ça, avec Phi tu n'avais même pas à choisir entre fonctionnalités officielles et tierces, tu peux avoir les deux en même temps. Depuis le verrouillage la mémoire Flash des N0110 est partitionnée en deux moitiés égales de 4 Mio, et pouvant chacune accueillir un firmware.
Les firmwares tiers Khi puis Upsilon ont été mis à jour par la suite pour pouvoir être amorcés de cette façon, et leurs pages d'installation intègrent également leur propre version du bootloader Phi.
Nouveauté justement donc, le firmware Khi te permet désormais de basculer sur un autre firmware sans avoir à utiliser le bouton reset.
by 
