Après deux premières superbes éditions l'année dernière à Noël pour les enseignant(e)s puis au Printemps pour les élèves, voici enfin aujourd'hui le grand retour tant attendu des concours de dessin sur calculatrices par Casio !
Grande nouveauté par rapport à l'année dernière, cette fois-ci personne n'est privé : tout-le-monde peut participer, peu importe que tu sois collégien(ne), lycéen(ne) ou enseignant(e), la seule condition étant de résider en France !
Afin que cette large ouverture ne pénalise personne, les participations seront classées séparément selon 3 catégories entre lesquelles choisir lors de ton inscription :
catégorie étudiants : pour les participations individuelles d'élèves de collège ou lycée
catégorie professeurs : pour les participations individuelles des enseignant(e)s de matière scientifique en collège ou lycée
catégorie classe : pour les participations collectives de classes de collège ou lycée
Cette fois-ci il te suffit de dessiner ta liste au Père Noël sur ta calculatrice Casio ou son émulateur associé que nous remettons si besoin à ta disposition en fin d'annonce, et d'envoyer par courriel à education-france@casio.fr d'ici le lundi 31 janvier 2022 inclus ton script accompagné d'une photo ou capture d'écran de ce qu'il dessine.
Pour réaliser ton dessin, tu peux choisir entre les 2 technologies suivantes :
calculatrice scientifique fx-92+ Spéciale Collège avec son application Algorithmique t'offrant un langage de tracé à la Scratch/Logo
calculatrice graphique Graph 35+E II ou Graph 90+E avec son application Python
Qu'est-ce que tu gagnes ? 3 catégories et 2 technologies, si tu comptes bien cela fait 6 combinaisons de choix possibles. Et bien c'est très-simple, il y a 6 gros lots soit 1 pour chaque choix possible.
Pour chacune des 3 catégories sont à gagner 2 superbes gros lots ; 1 pour le meilleur dessin sur fx-92+ Spéciale Collège, et 1 pour le meilleur dessin sur Graph 90/35+E II :
catégorie étudiants : console de jeux Nintendo Switch d'une valeur de 269,99€
catégorie professeurs : trottinette électrique d'une valeur de 199,99€
catégorie classe : 5 calculatrices graphiques au choix + montre Casio pour le professeur et chacun des élèves (calculatrice Graph 35+E II ou Graph 90+E + montre G-Shock ou vintage dans la limite de 35 élèves)
Et en prime avec Casio, pas de perdant : tous les autres participants recevront un lot de goodiesCasio !
Un très beau concours et nous avons bien hâte de voir ce que tu vas être capable de faire, merci Casio !
Tu manques d'inspiration ? Tu ignores les techniques pour dessiner certaines formes ou plus généralement ne connais pas suffisamment ta calculatrice ?
Casio se propose même de t'aider à gagner en t'accompagnant ce mercredi 1er décembre au cours de 2 ateliers en ligne au choix tout spécialement dédiés aux dessins de Noël sur ses calculatrices :
14h-15h : appli Algorithmique sur fx-92+ Spéciale Collège
15h-16h : appli Python sur Graph 90/35+E II
Ils correspondant donc bien aux 2 technologies au choix, et ce sera également l'occasion de poser toutes les questions de ton choix sur les règles ou les lots.
Peut-être te demandes-tu en passant comment joindre le script de ta fx-92+ Spéciale Collège alors que la machine ne dispose pas de port de communication ?... mais en fait rien de plus simple !
Que tu utilises la calculatrice ou son émulateur il te suffira juste d'en exporter le contenu à l'aide d'un QR Code :
obtenir la sauvegarde du contenu sous forme de QR Code en tapant
SECONDE
OPTN
flasher le QR Code alors obtenu :
sur émulateur, il te suffit juste de cliquer le QR Code dans la fenêtre popup qui apparaît
sur calculatrice, si celle-ci génère 1 seul QR Code, il te suffit de le flasher avec l'outil de ton choix
sur calculatrice, si celle-ci génère une série de plusieurs QR Codes(au-delà d'une certaine taille de script), il te faudra les flasher avec l'appli Casio Edu+ dédiée que nous te mettons en fin d'annonce
dans la page web qui s'ouvre, cliquer sur l'icône d'envoi par courriel
Si besoin des tutoriels plus détaillés traitant séparément des 3 situations ici évoquées sont également disponibles dans les ressources en fin d'annonce.
Avant d'adopter le format calculatrice de poche, les futurs modèles de Texas Instruments prennent dans un premier temps la forme de cartes de développement.
Voici par exemple ci-contre un exemplaire de la carte de développement ayant servi à développer la légendaire TI-89 de 1998. Elle est ici connectée via une nappe à un boîtier TI-89 quasiment dépourvu de toute électronique interne, n'étant là que pour fournir le clavier et l'écran, soit de quoi tester malgré tout dans des conditions aussi proches que possible de celles de l'utilisateur final.
Cette pièce d'un intérêt historique exceptionnel, peut-être le dernier exemplaire sur Terre, a été dénichée par parrotgeek1 puis achetée par Brandon Wilson.
De passage à TI-Dallas en 2011, Adriweb nous avait brièvement photographié une carte de développement TI-Phoenix 1, ancien nom des prototypes TI-Nspire+ et TI-Nspire CAS+ de 2006-2007 sur processeur OMAP, photos reproduites avec autorisation de Texas Instruments.
Ici la carte était reliée à un boîtier TI-Nspire n'étant là que pour fournir le clavier, et Adriweb avait bien pris le temps de te montrer qu'il était complètement vide en dehors de ça :
Un peu plus récent, voici la carte de développement des TI-Nspire monochromes finalement très différentes de 2007, migrant du processeur OMAP à un ASIC.
Ici l'écran était directement intégré à la carte, mais une nappe servait quand même à avoir le clavier externe.
Probablement mise en public par erreur dans sa galerie photos par l'un des développeurs de la TI-Nspire, Zac Bowling.
Justement à ce sujet, parrotgeek1 et Brandon Wilson ont également déniché et acheté d'autres pièces intéressantes.
Ci-dessous plusieurs boîtiers TI-Nspire TouchPad destinés à être reliés via des nappes à une carte de développement TI-Nspire, ne fournissant ici encore comme tu peux le voir ci-contre que l'électronique minimale permettant d'avoir le clavier et l'écran.
Une grosse protubérance latérale permet de faire ici sortir du boîtier 4 connecteurs de nappe :
Toujours dans le même lot, voici maintenant un boîtier TI-Nspire TouchPad muni d'un écran couleur, et donc destiné à être utilisé avec une une carte de développement TI-Nspire CX :
Toujours dans ce domaine, nouvelle découverte historique très précieuse aujourd'hui par Frédéric Desautels alias mr womp womp. Il vient de dénicher et acheter des boîtiers encore différents pour carte de développement TI-Nspire.
Cette fois-ci il y a 2 protubérances latérales bien plus modestes de part et d'autre faisant sortir seulement 2 connecteurs de nappe au nombre de broches différent, sans doute un pour le clavier et un pour l'écran :
Ces boîtiers n'ont toutefois pas d'intérêt en dehors des personnes se sentant l'âme d'un conservateur ou d'un collectionneur. Dépourvus de tout élément interne actif, ils sont totalement inutilisables sans la carte de développement TI-Nspire sur laquelle les brancher. Quel dommage qu'elle ne soit toujours pas venue avec. Peut-être la prochaine fois ?...
Rien à voir avec la géniale mise à jour majeure du printemps dernier encore développée chez HP, ici nous étions sur quelque chose d'extrêmement mineur.
La seule correction apportée concernait un bug se produisant lorsque l'on travaillait sur une fonction LOGB() et effectuait un appel au moteur CAS.
Il paraît que c'est un cas d'utilisation fréquent aux Pays-Bas, l'un des principaux marchés ciblés par Moravia avec celui de l'Allemagne.
À côté de cela, d'autres bugs bien plus graves signalés au printemps dernier soit du temps où le développement était encore réalisé chez HP, n'étaient toujours pas corrigés.
On peut citer le mauvais affichage du terme de degré 0 dans les expressions de polynômes lorsque celui-ci vaut 1 ou -1, un affichage faux étant à notre sens bien plus grave qu'une absence de réponse, car induisant en erreur les utilisateurs les moins attentifs.
Ou encore l'interface de configuration de l'application Python qui bloque tout réglage de capacité heap supérieur à 16,384 Mio, et ce alors que la révision matérielle majeure HP Prime G2 de rentrée 2018 constitue maintenant la grande majorité des machines en service et a largement de quoi aller au-delà avec ses 256 Mio de RAM comme justement indiqué par la ligne juste en-dessous.
Ou encore les divers plantages plus ou moins aléatoires (freeze, reset, ou même écran bleu de crash) dans le contexte de l'application Python. Il est très fréquent d'avoir un reset lorsque l'on ouvre l'application, elle est clairement instable.
Et pour le coup ici, ces problèmes sont mondiaux.
Bref, des priorités de développement extrêmement discutables, et assez inquiétantes lorsque l'on voit les énormes efforts de mises à jour de la concurrence pour cette rentrée 2021. Nous avons classé la HP Prime 1ère lors de nos tests de rentrée QCC 2021, attention qu'à continuer comme cela à faire du sur place ou du quasi sur place maintenant plus de 6 mois après la mise à jour testée, la 1ère place ne durera pas éternellement...
L'application Python enfin rajoutée l'année dernière avec des années de retard sur la concurrence, c'est très bien. Mais il ne faut pas s'arrêter là. Où sont les modules turtle ou encore matplotlib que même une Casio Graph 35+E II d'entrée de gamme monochrome est capable de faire tourner ?
Les commandes permettant de gérer des périphériques USB également c'est très bien. Mais ici encore il faut les mettre en pratique ; où est la bibliothèque de connectivité BBC micro:bit ?
Aujourd'hui, Moravia nous sort une nouvelle mise à jour HP Prime compilée le 25 novembre 2021, cette fois-ci en version 2.1.14597.
Tu peux déjà t'en douter, avec une incrémentation d'une unique unité du numéro de build, c'est probablement quelque chose d'extrêmement mineur.
Contrairement aux bonnes habitudes des développeurs HP :
ici le changelog accompagnant les téléchargements n'a pas été mis à jour, il est toujours daté du 28 avril 2021 et décrit donc les seules anciennes nouveautés de la version 2.1.14566 de l'année dernière.
et aucune annonce n'a été faite sur HP Museum non plus
Donc nous avons dû chercher par nous-mêmes, pendant plusieurs heures. Il y a sûrement quelque chose quelque part, mais nous n'avons trouvé strictement aucune amélioration.
Par contre, nous pouvons hélas te confirmer que tous les bugs décrits ci-dessus sont toujours présents, et tous les gros manques également.
Téléchargements :
mise à jour 2.1.14597 pour calcularices HP PrimeG1G2
Pour accompagner en douceur la transition du Scratch au Python en Seconde, la plupart des solutions Python sur calculatrices graphiques offrent turtle, un module 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 un module turtle officiel à l'environnement Python
et sur 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), on pouvait jusqu'ici rajouter un module officiel ce_turtl à l'application Python
L'utilisation de ce_turtl sur TI-83 Premium CE Edition Python et compatible n'était jusqu'à présent pas de tout repos, loin de là. En effet énorme problème, les modules complémentaires comme ce_turtl n'étaient par défaut pas disponibles au menu.
Ils apparaissaient au menu uniquement lorsque l'on était en train d'éditer un script comportant une ligne les important (dans notre cas forcément sous la forme from ce_turtl import, et pas un simple import ce_turtl).
Lors de la création d'un script, afin d'obtenir le menu te permettant de saisir facilement et rapidement les appels aux différentes méthodes de ce_turtl, tu devrais donc commencer par te taper la saisie lettre par lettre au clavier de sa ligne d'importation, avec en prime le caractère tiret bas qui n'est pas au clavier et était donc à aller chercher dans un menu.
Mais attends car le pire, c'est que c'était encore loin d'être le pire...
Mais surtout bien pire que cela, ce_turtl était une véritable catastrophe ambulante !
Aucun effort ne semblait avoir été fait pour coller au standard : des méthodes essentielles manquantes, des noms de méthodes fantaisistes, des arguments attendus différant du standard dans leur nombre, leur ordre ou leur type... et ne parlons même pas encore du comportement attendu.
Si tu ne faisais pas l'effort d'adapter ton code, il t'était fort probable d'obtenir n'importe quoi. Voici ci-contre ce que donne un escargot sur ordinateur et l'ensemble de la concurrence, et sur TI-83 Premium CE Edition Python et compatibles avec ce_turtl...
Quel professeur allait perdre du temps à faire apprendre un sous-dialecte du turtle ne fonctionnant que sur calculatrice TI-83 Premium CE Edition Python, risquant ainsi de mélanger les élèves par rapport aux documents, ouvrages ou autres autres plateformes auxquels ils ont accès (ordinateur, tablette, smartphone, calculatrice d'un autre modèle) ?...
Nous savons parfaitement que la mémoire de tas (heap) du Python des TI-83 Premium CE Edition Python et compatibles est extrêmement limitée, seulement 19,968 Ko de capacité, et en pratique souvent bien moins de disponible car les modules importés prennent de la place.
Dans ce contexte nous comprenons parfaitement qu'il faille se limiter et faire des choix.
Mais nous persistons à penser que l'on pouvait faire largement mieux niveau compatibilité et conformité que ce que nous a offert ce_turtl, et ce sans augmenter la consommation de heap à l'exécution.
Dans le cadre de sa mise à jour 5.7 pour TI-83 Premium CE Edition Python et compatibles, Texas Instruments publie un nouveau module complémentaire s'appelant cette fois-ci turtle. On pourrait donc s'attendre à un meilleur respect du standard, mais cela va être à vérifier.
Ce nouveau module turtle peut être installé indépendamment de la mise à jour ; il fonctionne tout aussi bien sur les versions précédentes selon nos tests.
Mais si tu mets à jour en version 5.7 tu bénificieras d'un formidable avantage : un nouvel onglet de bas d'écran te permet enfin de lister les modules complémentaires importables et turtle en fait partie !
Donc plus de saisie fastidieuse, une seule touche suffit à coller la ligne d'importation et alors faire apparaître tout le contenu du nouveau module turtle au menu !
Mais reste à voir pour le reste. Découvrons donc maintenant ensemble si le nouveau module turtle est effectivement meilleur que ce_turtl.
La publication de Texas Instruments consiste en 2 fichiers de variables d'application pour calculatrice :
TURTLE.8xv
GRID.8xv
TURTLE.8xv est le module Python complémentaire en question, ici en version 2.0.0. Soit cela signifie qu'il y a eu des versions inférieures de test auxquelles nous n'avons pas eu accès, soit ce changement de numérotation majeure est pour noter une différence significative par rapport à ce_turtle.
Le fichier TURTLE.8xv a été généré par Texas Instruments à l'aide de py2appvar, un outil non public de Texas Instruments permettant à partir d'un fichier source Python :
la conversion du cose source Python en bytecodePython
l'énumération des éléments à mettre au menu à partir de lignes de commentaires spécialement formatées à cette fin dans le code source
Contrairement à CE_TURTL.8xv, TURTLE.8xv a été généré à l'aide d'une version plus récente de l'outil py2appvar, non plus la 1.2.0 mais la 1.2.1. Nous supposons que py2appvar 1.2.1 ajoute la gestion de la nouvelle ligne de commentaire permettant de spécifier l'ajout de la commande d'importation au menu des modules complémentaires.
GRID.8xv quant à lui n'est rien d'autre qu'une image 320×210 pixels au format IM8C directement affichable par les scripts Python de la calculatrice et que voici justement ci-contre ; il s'agit donc d'une grille.
from turtle import * t = Turtle() t.circle(52) t.done()
Tu peux très bien te passer de GRID, soit ne pas transférer ou effacer la variable en question. Dans ce cas cela ne déclenche pas d'erreur, mais rappelons que le Python sur TI-83 Premium CE Edition Python et compatible ne dispose pas d'un buffer dédié aux affichages graphiques, ces derniers étant effectués par-dessus la console. Ne trouvant alors rien à afficher, l'écran ne sera pas nettoyé et il te faudra alors rajouter du code en ce sens.
Tu peux également t'amuser à remplacer le fond d'écran du module turtle comme bon te semble. Notre outil en ligne img2calc te permet de convertir n'importe quelle image au format IM8C de Texas Instruments, et il te suffira alors juste de choisir le nom GRID pour la calculatrice.
Rappelons que comme le buffer d'affichage est ici unique, tu dois effectuer une pause en fin de script sous peine de voir ton tracé une fois terminé être immédiatement écrasé par l'affichage de la console. Le module turtle t'offre pour cela la méthode .done() qui attend l'appui sur la touche
annul
(ou
clear
sur les TI-84 Plus CE), mais tu es libre d'utiliser n'importe quel autre code générant une attente.
À noter que le module turtle t'offre la possibilité de désactiver l'affichage de la grille. Il te suffira d'appeler la méthode .hidegrid() avant ta première instruction d'affichage.
En pratique la méthode .hidegrid() efface simplement l'écran en blanc.
from turtle import * t = Turtle() t.goto(0,-95) s = 3 for r in range(0, 159, r): t.left(90) t.circle(r) t.right(90) t.done()
Déjà ce script met en évidence un bug en Python des TI-83 Premium CE Edition Python et compatibles : au-delà d'une certaine valeur de rayon les tracés de cercles se déforment très rapidement et tendent vers des carrés.
Le bug n'est en fait ni dans ce_turtl ni dans turtle, mais dans le module de tracé par pixels ti_graphics qu'ils utilisent tous les deux sur ces calculatrices, visiblement toujours pas corrigé en version 5.7.
Mais problème... Si tu regardes bien bien que la structure soit similaire, nous avons dû écrire 2 scripts différents pour ce_turtl et turtle.
Si en plus on fait rentrer la concurrence dans l'équation, il n'est pas envisageable pour nous de maintenir jusqu'à 7 versions différentes pour chaque script testé...
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 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(15)
_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(16)
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()", "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 == 15: msg += str(len(_missing_fct)) + " " + " ".join(_missing_fct) if k == 16: 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 calculatrices Texas Instruments :
Pas étonnant que ce_turtle fasse n'importe quoi, c'est une véritable calamité. Pas moins de 11 erreurs, et encore ce sont juste celles qui sont détectées. La grande majorité de ce qui est testé ne va pas :
ligne d'importation non standard (à cause du nom)
réglage non standard de la couleur du tracé, utilisant la méthode .color() au lieu de .pencolor()
absence de la méthode .colormode() et donc pas de possibilité de modifier le mode des coordonnées de couleurs (maximum de chaque composante à 1 ou à 255)
refus des paramètres de couleurs sous forme de tuple, liste ou chaîne de caractères, les fonctions concernée prennent obligatoirement 3 paramètres avec les valeurs de chaque composante
la méthode .circle() ne prend qu'un seul argument et ne gère donc pas les arcs de cercle
absence des méthodes de remplissage
absence de la méthode d'effacement et réinitialisation de la tortue .reset()
absence de la méthode d'écriture de texte .write()
absence de 18 alias courts pour les noms de méthodes
Avec le nouveau module turtle nous tombons à seulement 7 erreurs.
Son code source ne semblerait pas dériver de celui de ce_turtl, puisque certaines erreurs disparaissent alors qu'une autre apparaît.
Restent donc :
absence de la méthode .color()
absence de la méthode .colormode() et donc pas de possibilité de modifier le mode des coordonnées de couleurs (maximum de chaque composante à 1 ou à 255)
refus des paramètres de couleurs sous forme de liste ou chaîne de caractères, mais les tuples sont acceptés
la méthode .circle() ne prend qu'un seul argument et ne gère donc pas les arcs de cercle
absence de la méthode d'effacement et réinitialisation de la tortue .reset()
absence de 16 alias courts pour les noms de méthodes
Le turtle des TI-Nspire CX II pour sa part ne donne que 5 erreurs. Vu la grande similarité, on pourrait se demander si le nouveau module turtle des TI-83 Premium CE Edition Python et compatibles ne découlerait pas de celui des TI-Nspire CX II, avec juste la suppression des paramètres de couleurs sous forme de chaîne de caractères afin d'économiser un peu de place en heap.
Voici pour référence les résultats du même test chez la concurrence :
Un avantage des Texas Instruments et des Casio, c'est que le module turtle peut être modifié, et la plupart des erreurs sont ainsi corrigeables !
À nuancer toutefois, car vu la faible capacité du heap des TI-83 Premium CE Edition Python et compatibles, on ne peut pas non plus envisager de tout corriger.
Voici un script qu'il suffit d'importer à la place du module turtle de chaque machine, et lorsque autorisé corrige la plupart des erreurs détectées :
# fix color() + pencolor() if _turtle_errors & 2: turtle.pencolor = turtle.color if _turtle_errors & 4: turtle.color = turtle.pencolor if _turtle_errors & 0x1000: turtle.fillcolor, turtle.begin_fill, turtle.end_fill = idty, nop, nop
_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): if not(len(argv)): return turtle._color() turtle._color(turtle._fixcolor(len(argv) > 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): if not(len(argv)): return turtle._color() c = turtle._fixcolor(len(argv)>1 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
Nous pouvons envisager à partir de maintenant d'avoir une unique version de chaque script utilisable sur l'ensemble des machines.
Maintenant que nous avons de quoi faire tourner une unique version de chaque script sur l'ensemble des machines, poursuivons l'exploration de l'ensemble des modules turtle avec quelques exemples de script.
Cela va justement être l'occasion de voir si il y a d'autres problèmes qui n'ont pas pu être détectés automatiquement
C'est donc parti pour quelques exemples afin d'approfondir les améliorations du nouveau module 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.
Commençons par une petite rosace à la Casio ; tout possesseur de Graph 35+E II sait en effet que Casio aime bien ça :
C'est la base, tout-le-monde s'en sort à peu près, mais tu peux déjà constater quelques légers écarts.
Il y avait donc avec ce_turtl un problème d'écart par rapport au standard, un décalage d'une unité lors du réglage de l'épaisseur via la méthode turtle.pensize().
Ici l'appel turtle.pensize(1) produisait l'effet d'un turtle.pensize(2). Et plus généralement un appel turtle.pensize(s) produisait l'effet d'un turtle.pensize(s+1).
On peut noter que le problème disparaît avec le nouveau module turtle.
KhiCAS donne également l'impression d'avoir un problème d'épaisseur, mais si tu regardes bien c'est en fait un tout autre problème. L'épaisseur est correcte sur les segments horizontaux et verticaux, seuls les segments obliques sont plus épais qu'ils ne devraient. Cela découle de l'algorithme de tracé choisi dans ce cas.
L'écran de la Casio Graph 35+E II a une définition très inférieure de seulement 128×64 pixels, et bien évidemment le tracé est donc tronqué. Pour le coup, là cela aurait été particulièrement utile de pouvoir faire défiler le tracé...
Il y avait avec ce_turtl un décalage progressif du tracé, l'affichage obtenu dans la fenêtre n'étant pas symétrique alors que calculé pour.
Ici encore le problème disparaît avec le nouveau module turtle.
Le cas de KhiCAS est complètement différent et n'est à la différence pas un problème. La fenêtre obtenue défile automatiquement en fonction des mouvements de la tortue, et peut même être défilée au clavier une fois le tracé terminé, ce qui est d'ailleurs fort utile pour explorer des tracés débordant de la fenêtre graphique. Une exclusivité à ce jour sur calculatrices !
c = [127, 255, 0] turtle.speed(0) turtle.colormode(255) l = 80 for j in range(2): for i in range(3): n = j and 3 + i or 2 - i s = (7 - n) // 2 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)
turtle.speed(0) turtle.pensize(1) turtle.colormode(1.0) for i in range(36): turtle.pencolor([exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)]) for i in range(1, 5): turtle.forward(60) turtle.right(90) turtle.right(10)
turtle.speed(0) turtle.pensize(1) turtle.colormode(1.0) turtle.penup() turtle.goto(0, -20) turtle.pendown() for i in range(36): turtle.pencolor([exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)]) turtle.circle(50 - i) turtle.right(10)
De nouveau une véritable catastrophe avec ce_turtl qui semble tracer n'importe quoi et pas ce qui est demandé.
C'est que la méthode turtle.circle() de ce_turtl nous trace ici des cercles ayant pour centre la position actuelle de la tortue. Alors que dans le standard, le cercle tracé passe par la position de la tortue.
Heureusement, le nouveau module turtle pour sa part se comporte enfin correctement et conformément au standard.
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)
À nouveau un décalage avec ce_turtl qui nous trace bêtement une bonne partie de la figure hors fenêtre, un tracé de plus ici très grossier avec le problème déjà évoqué de l'épaisseur.
Heureusement, le nouveau module turtle trace quant à lui à la perfection.
De nouveau un problème de mémoire avec KhiCAS empêchant d'achever le tracé.
Là avec ce_turtl c'est un festival, la page de publicité se fait littéralement censurer. 3 problèmes essentiels :
Absence de la méthode turtle.write() permettant d'écrire du texte à la position de la tortue, et donc absence du mot CASIO sur le rendu.
La méthode standard turtle.circle(r, a=360) permet de préciser l'angle au centre en 2ème argument et ainsi de tracer des arcs de cercle, l'omission de ce paramètre donnant par défaut un angle au centre de 360° et donc un cercle. C'est utilisé ici pour tracer le pied du 9 en rouge. Sauf que l'implémentation dans ce_turtl ne respecte pas le standard et ne gère pas ce 2ème argument. Notre script correctif intercepte le cas et empêche l'interruption du rendu sur une erreur, mais trace alors un cercle complet à la place.
La méthode standard turtle.circle(r, a=360) accepte de plus une valeur de rayon négative, inversant dans ce cas le sens de tracé. C'est utilisé ici pour tracé le 0 en vert. Sauf que ce_turtl ne comprend pas ce cas et ne trace alors rien du tout.
Le nouveau module turtle corrige les 2 premiers points.
La TI-Nspire CX II fait un peu moins bien, ne gérant pas le tracé d'arcs de cercle.
Notons une divergence du standard chez une bonne partie des modèles concernant la méthode turtle.write(). La norme est d'écrire le texte dans un rectangle horizontal prenant la position courante de la tortue comme sommet inférieur gauche. Or beaucoup d'implémentations utilisent le sommet supérieur gauche : le nouveau turtle pour TI-83 Premium CE Edition Python et compatibles, ainsi que les Casio Graph 35+E II et Graph 90+E.
def triangle(t): for i in range(4): turtle.forward(t/(i%4 == 0 and 2 or sqrt(2))) turtle.left(i==1 and 90 or not(i%2) and 135)
def etoiles(): turtle.pencolor("yellow") turtle.pensize(2) for i in range(8): etoile(-60-30*(i%4)+(i>=4 and 220), (-80,10,-40,60)[i%4])
def etoile(x,y): turtle.up() turtle.goto(x,y) turtle.down() for i in range(12): turtle.forward(10) turtle.left(i%2 and -60 or 120)
turtle.up() turtle.goto(0,60) turtle.down() turtle.pencolor("green") turtle.pensize(5) for i in range(4): triangle(50+20*i) turtle.up() turtle.goto(0,30-40*i) turtle.down() turtle.pencolor("brown") turtle.backward(10) for i in range(4): turtle.forward(i%2 and 40 or 20) turtle.left(90)
Cette fois-ci sur KhiCAS cela ne va plus du tout, le sapin pousse complètement de travers...
Bizarrement ici aussi, La TI-Nspire CX II se met soudainement à ne plus respecter les instructions relatives à l'épaisseur du tracé, alors qu'elles marchaient plus haut...
Comme l'ensemble de la concurrence, le module ce_turtl ne gérait pas les méthodes de remplissage.
Et bien là nous sommes en plein sur ce qui fait à ce jour la supériorité et l'exclusivité de la solution turtle par Texas Instruments. Comme la TI-Nspire CX II le nouveau module turtle pour TI-83 Premium CE Edition Python et compatibles gère les méthodes de remplissage, un véritable régal pour les yeux et autant de stimulation supplémentaire pour inciter les élèves à approfondir leurs constructions !
Les méthodes de remplissage si manquantes étant directement interceptées dans le code du script, ici c'est pour une autre raison que le tracé échoue sur KhiCAS : l'absence de la possibilité d'interroger l'orientation de la tortue via turtle.heading().
def poly_reg_a(l, a): h0 = turtle.heading() while True: turtle.forward(l) turtle.left(a) if abs(h0 - turtle.heading()) < .1: break
turtle.hideturtle() turtle.speed(0) turtle.pensize(1) turtle.colormode(255) c = [255, 127, 0] for j in range(4): for i in range(4): turtle.penup() turtle.goto(i*88-172, j*85-142) turtle.pendown() turtle.pencolor(tuple(c)) poly_reg_a(80, 140) rotate_list(c)
Après l'accident ce_turtl qui était inutilisable en pratique, Texas Instruments nous opère un virage à 180° avec le nouveau module turtle pour TI-83 Premium CE Edition Python et compatibles.
La conformité au standard de turtle n'est certes pas parmi les meilleures, mais c'est sans comparaison avec ce que valait ce_turtl. La conformité est très proche de celle des TI-Nspire CX II, et de plus une bonne partie des défauts restants ne sont pas majeurs dans le sens où ils sont aisément contournables sans avoir à écrire de code conséquent.
Qui plus est Texas Instruments s'offre même le luxe d'aller jusqu'à inclure les méthodes de remplissage de formes, à ce jour une exclusivité toute concurrence confondue ! Des possibilités et facilités de tracés largement accrues en conséquence, de quoi inviter encore plus les élèves à tester et créer !
Nous nous devons toutefois de modérer légèrement ce dernier point.
Aucun problème sur TI-Nspire CX II, mais par contre sur TI-83 Premium CE Edition Python et compatibles la taille du heap fait qu'il ne faut pas abuser des méthodes de remplissage.
En effet à partir d'un appel .begin_fill(), l'ensemble des étapes intermédiaires de la tortue est stocké en mémoire afin de pouvoir en effectuer le remplissage suite au prochain appel .end_fill().
Des formes à remplir trop complexes ou trop nombreuses déclencheront une erreur de mémoire insuffisante, et les exemples précédents de remplissages les plus complexes n'en étaient pas bien loin.
C'est franchement dommage et rageant de devoir ainsi se brider dans l'exploitation de cette formidable possibilité...
Enseignant, as-tu raté l'occasion de rencontrer les constructeurs de calculatrices graphiques Casio et Texas Instruments ces dernières semaines aux journées APMEP à Bourges puis au congrès UdPPC à Nancy ?
Et bien bonne nouvelle il n'est pas trop tard. Tu as une chance de te rattraper à l'occasion du salon Educatec-Educatice à Paris de ce mercredi 24 novembre à ce vendredi 26 novembre inclus.
L'événement se passe au parc des expositions de la Porte de Versailles chaque jour de 9h à 18h, sauf pour le vendredi de 9h à 17h.
Tu pourras y retrouver le constructeur Casio en personne sur la partie Educatice, stand F44 - pavillon 7. L'occasion de les interroger sur leur projet de future plateforme mathématique en ligne avec gestion de classe Classpad Academy.
2 autres stands mettront également en avant entre autres la technologie Texas Instruments :
vittascience avec ses superbes interfaces de programmation en ligne, intégrant un éditeur pouvant fonctionner de façon synchronisée en Python ou en mode blocs, couplé avec un simulateur supportant entre autres les solutions Texas Instruments(TI-83 Premium CE, TI-Innovator Hub, TI-Innovator Rover, micro:bit, ...)
A4 Technologie qui développe plusieurs maquettes et accessoires pour les TI-Innovator Hub et TI-Innovator Rover
L'accès est gratuit, mais nécessite une inscription sur le lien ci-dessous.
Attention, contrairement aux précédents événements évoqués, l'accès est ici exclusivement réservé aux professionnels.
de 
Après deux premières superbes éditions l'année dernière à Noël pour les enseignant(e)s puis au Printemps pour les élèves, voici enfin aujourd'hui le grand retour tant attendu des concours de dessin sur calculatrices par Casio ! 
Pour réaliser ton dessin, tu peux choisir entre les 2 technologies suivantes :
