. Lancée pour la rentrée 2003, cette gamme se caractérise par des modèles munis d'un écran tactile à stylet de
160×240
pixels ainsi que d'un moteur de calcul formel.
Se sont succédées les :
Classpad 300
(rentrée 2003)
Classpad 300+
(rentrée 2005)
qui rajoutait une connexion USB standard
Classpad 330
(rentrée 2007)
Classpad 330+
(rentrée 2012)
qui remplaçait le processeur
Renesas SH3
historique par un
SH4
, mais également hélas fermait l'écosystème en retirant la possibilité d'installer et lancer des applications tierces, limitation qui persiste à ce jour et nuit grandement à la popularité de cette gamme au sein de nos communautés de passionnés et développeurs
Depuis la gamme est passée à une nouvelle génération matérielle dite
Classpad II
, accélérant le processeur
SH4
à
117,96 MHz
tout en passant à un écran couleur en
320×528
pixels. Cette fois-ci, les modèles sont distints selon la zone de distribution :
la
fx-CP400
, modèle international sorti à la rentrée 2013
la
fx-CP400+E
qui remplace la
fx-CP400
en France à la rentrée 2016, lui rajoutant une diode examen conformément à la nouvelle réglementation
la
fx-CG500
pour l'Amérique du Nord à la rentrée 2017, déclinaison conçue pour être autorisée aux examens en retirant diverses choses interdites : dispositions non alphabétiques du clavier virtuel
(Qwerty, Qwertz, Azerty)
, mentions de la gamme
Classpad
car nommément interdite à cause de cela dans plusieurs réglementations d'examens
Mais
Casio
te permet également de retrouver l'intégralité des capacités de son logiciel de Mathématiques intégré
nous sort aujourd'hui pour la rentrée 2022 une mise à jour de l'ensemble de ces applications, la version
1.0.10
.
Datée du
20 avril 2022
, elle continue apparemment à utiliser le même logiciel de Mathématiques intégré
Classpad
en version
2.01.7000
, ce qui suggère donc déjà qu'il n'y a aucune nouveauté niveau capacités après pourtant près de 2 ans, et peut-être même qu'il n'y en aurait pas davantage pour calculatrices d'ici la rentrée 2022.
Les pages des applications indiquent la correction d'un bug mineur sans plus de précisions, que l'on peut par élimination supposer être spécifique à la gestion de l'appareil hôte ou de son système d'exploitation.
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
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.
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
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
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
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)
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
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)
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 :
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)
? 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)
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
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
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...
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
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
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
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)
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
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)
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 :
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)
? 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)
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
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
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...
réalise de gros efforts pour rendre la programmation de ses calculatrices accessible à tous et toutes. Le constructeur a prêté une attention toute particulière aux plus jeunes et non initiés, souhaitant leur permettre de créer tous les projets imaginables sans avoir à se concentrer sur des difficultés annexes.
. Tous ces éléments ont de plus l'avantage d'être utilisables directement avec le langage
Python
des calculatrices concernées, faisant de l'écosystème
Texas Instruments
le seul
Python
connecté !
Un superbe support pour les enseignements scientifiques au lycée surtout maintenant que tous partagent le même langage de programmation, notamment en
SNT
, spécialité
NSI
,
SI
et
Physique-Chimie
, avec le gros avantage de la mobilité. En effet, les programmes produits et données collectées restent présents dans la calculatrice apportée par chaque élève à chaque cours, ce qui allège la charge logistique de l'enseignant. Données et algorithmes pourront donc être traités / travaillés à la prochaine séance, en devoir à la maison ou même de façon transdisciplinaire en collaboration avec un autre enseignant !
Et depuis la rentrée 2020 dernière grande révolution en date, plus besoin de t'équiper en
TI-Innovator
pour bénéficier de ces formidables avantages. En effet, la
TI-83 Premium CE Edition Python
française s'est vu rajouter la gestion du nanoordinateur
Pour moins d'encombrement, tu as aussi la solution d'utiliser un câble direct, au choix :
USB micro-B
mâle ↔
USB mini-A
mâle
USB micro-B
mâle ↔
USB mini-B OTG
mâle
La carte
micro:bit
dans ses versions 1 est programmable en
Python
et présentait initialement les caractéristiques et capacités suivantes :
processeur
32 bits ARM Cortex-M0
cadencé à
16 MHz
mémoire de stockage
Flash
d'une capacité de
256 Kio
mémoire de travail
RAM
d'une capacité de
16 Kio
permettant un
heap (tas)
Python
de
10,048 Ko
un afficheur, grille programmable de 5×5= 25 diodes rouges adressables, bien adapté pour l'affichage de motifs éventuellement animés ou encore de texte défilant
nombre de capteurs intégrés :
capteur de luminosité
(lié aux diodes)
capteur de température
(sur le processeur)
2 boutons poussoirs
A
et
B
programmables de part et d'autre, comme sur les premières manettes et consoles de jeux portables de chez
Nintendo
accéléromètre 3D, permettant de détecter les variations d'accélération et par conséquence diverses actions : secouer, pencher, chute libre, ...
boussole magnétique 3D, pour détecter cette fois-ci les champs magnétiques
connectivité
Bluetooth 4.0
basse énergie 2,4 GHz maître/esclave
Depuis début 2021 est disponible la nouvelle carte
micro:bit v2
.
Elle utilise un tout nouveau microcontrôleur, le
nRF52833
, toujours de chez
Nordic Semiconductor
. Cette fois-ci nous avons des spécifications qui devraient nous permettre de respirer :
processeur
32 bits ARM Cortex-M0
cadencé à
64 MHz
au lieu de
16 MHz
soit 4 fois plus rapide !
mémoire de stockage
Flash
d'une capacité de
512 Kio
au lieu de
256 Kio
soit 2 fois plus grande !
mémoire de travail
RAM
d'une capacité de
128 Kio
au lieu de
16 Kio
soit 8 fois plus grande, permettant un
heap (tas)
Python
de
64,512 Ko
!
Elle apporte sur cette même face plusieurs nouveautés ou changements :
ajout d'un haut-parleur
ajout d'un microphone MEMs
bouton poussoir qui ne sert plus seulement à la réinitialisation
(reset)
, mais permet désormais également d'éteindre la carte
(appui long)
et de la rallumer
(appui court)
l'antenne
Bluetooth
qui devient compatible
BLE Bluetooth 5.0
, contre seulement
4.0
auparavant
D'autres nouveautés ou changements sont également présents sur l'autre face :
ajout d'une diode DEL indiquant l'état du microphone
ajout d'un bouton tactile sur le logo
micro:bit
, voici pourquoi il perd sa couleur au profit de contacts métalliques
Expliquons brièvement la composition de la solution de connectivité
BBC micro:bit
de
Texas Instruments
, ainsi que son fonctionnement.
Le solution se compose d'une part d'un fichier
TI-Runtime
unique à copier sur la carte
micro:bit
v1
ou
v2
et qui lui permet d'être pilotée par la calculatrice. La bonne installation du fichier est aisément vérifiable, puisque faisant afficher à la carte le logo
Texas Instruments
.
La solution a un principe de fonctionnement très simple, mais non moins ingénieux pour autant. La carte
micro:bit
étant justement programmable en
Python
, une fois le
TI-Runtime
installé elle se met alors à écouter les commandes
Python
envoyées depuis la calculatrice et à les exécuter.
Depuis ta calculatrice, tu peux envoyer n'importe quelle commande
Python
à ta carte
micro:bit
et profiter pleinement de ses capacités grâce à la fonction
ti_hub.send()
, à condition d'encadrer la commande des bons caractères de contrôle. Voici une fonction
Toutefois en pratique dans le contexte scolaire, cette façon de faire n'était pas idéale. Elle rajoutait un niveau d'imbrication : tu devais produire du code
Python
qui lui-même devait construire le code
Python
à envoyer et exécuter par la carte
micro:bit
, une marche sans doute un peu haute pour bien des élèves débutants.
Et bien justement,
Texas Instruments
est loin de s'être arrêté là. Sa solution de connectivité comporte également des bibliothèques
Python
additionnelles à charger sur ta calculatrice, au choix en Français ou Anglais, et rajoutant alors des menus permettant de faire appel plus simplement aux éléments correspondants sur la carte
micro:bit
. 11 bibliothèques étaient disponibles dans la dernière version, facilitant ainsi l'utilisation de certaines bibliothèques du
(communication radio intégrée - accessible via le menu
Radio
)
mb_sensr
(capteurs intégrés : boussole, accéléromètre, température - accessible via le menu
Sensors and gestures
ou
Capteurs et gestes
)
Texas Instruments
et l'espace, c'est une grande histoire qui ne date pas d'hier. Outre les calculatrices qui ont accompagné les missions spatiales, on peut citer une collaboration de longue date avec la
Nasa
, l'agence spatiale américaine, et nombre de projets et événements ont été conçus dans ce cadre.
Ici pas de menu fouillable depuis la calculatrice pour connaître les fonctions utilisables, mais on peut procéder autrement. On peut en effet ouvrir directement le fichier sur
# ------------------------------------------- pulse timer ---------------------------------------------------------------- def time_pulses(pin,pulses): try: pin.read_digital() # wait for one trigger pulse while not pin.read_digital(): pass while pin.read_digital(): pass while not pin.read_digital(): pass # begin timing pulses t0=ticks_us() for n in range(pulses-1): while (not pin.read_digital()): pass while pin.read_digital(): pass tf=ticks_us() pulses_time = (tf-t0)/1000000 return(str(pulses_time)) except: pass
def time_H_to_L(pin): pin.read_digital() while (pin.read_digital()): pass t0=ticks_us() while not (pin.read_digital()): pass tf=ticks_us() pulse_time = (tf-t0)/1000000 return(str(pulse_time))
def time_L_to_H(pin): pin.read_digital() while not (pin0.read_digital()): pass t0=ticks_us() while (pin.read_digital()): pass tf=ticks_us() pulse_time = (tf-t0)/1000000 return(str(pulse_time))
def set_iaq_baseline(self,eCO2,TVOC): if eCO2==0 and TVOC==0:raise RuntimeError('Invalid baseline') b=[] for i in [TVOC,eCO2]: a=[i>>8,i&0xFF] a.append(self.g_crc(a)) b+=a self.run(['iaq_set_baseline',[0x20,0x1e]+b,0,10])
def set_iaq_humidity(self,PM3): b=[] for i in [int(PM3*256)]: a=[i>>8,i&0xFF] a.append(self.g_crc(a)) b+=a self.run(['iaq_set_humidity',[0x20,0x61]+b,0,10])
def get(self,cmd,d,rs): i2c.write(0x58,bytearray(cmd)) sleep(d) if not rs:return None cr=i2c.read(0x58,rs*3) o=[] for i in range(rs): w=[cr[3*i],cr[3*i+1]] c=cr[3*i+2] if self.g_crc(w)!=c:raise RuntimeError('CRC Error') o.append(w[0]<<8|w[1]) return o
def g_crc(self,data): c=0xFF for byte in data: c^=byte for _ in range(8): if c&0x80:c=(c<<1)^0x31 else:c<<=1 return c&0xFF
def read(self): if self.ready: try: return self.eCO2(), self.TVOC() except: pass else: self.init() if self.ready: return (self.read()) else: return None
# ------------------------------------------- start up -----------------------------------------------------------
def ismb(): return(True)
def get_version(): print ("TI-Runtime Version 2.4.0")
# ------------------------------------------- pulse timer ---------------------------------------------------------------- def time_pulses(pin,pulses): try: pin.read_digital() # wait for one trigger pulse while not pin.read_digital(): pass while pin.read_digital(): pass while not pin.read_digital(): pass # begin timing pulses t0=ticks_us() for n in range(pulses-1): while (not pin.read_digital()): pass while pin.read_digital(): pass tf=ticks_us() pulses_time = (tf-t0)/1000000 return(str(pulses_time)) except: pass
def time_H_to_L(pin): pin.read_digital() while (pin.read_digital()): pass t0=ticks_us() while not (pin.read_digital()): pass tf=ticks_us() pulse_time = (tf-t0)/1000000 return(str(pulse_time))
def time_L_to_H(pin): pin.read_digital() while not (pin0.read_digital()): pass t0=ticks_us() while (pin.read_digital()): pass tf=ticks_us() pulse_time = (tf-t0)/1000000 return(str(pulse_time))
def set_iaq_baseline(self,eCO2,TVOC): if eCO2==0 and TVOC==0:raise RuntimeError('Invalid baseline') b=[] for i in [TVOC,eCO2]: a=[i>>8,i&0xFF] a.append(self.g_crc(a)) b+=a self.run(['iaq_set_baseline',[0x20,0x1e]+b,0,10])
def set_iaq_humidity(self,PM3): b=[] for i in [int(PM3*256)]: a=[i>>8,i&0xFF] a.append(self.g_crc(a)) b+=a self.run(['iaq_set_humidity',[0x20,0x61]+b,0,10])
def get(self,cmd,d,rs): i2c.write(0x58,bytearray(cmd)) sleep(d) if not rs:return None cr=i2c.read(0x58,rs*3) o=[] for i in range(rs): w=[cr[3*i],cr[3*i+1]] c=cr[3*i+2] if self.g_crc(w)!=c:raise RuntimeError('CRC Error') o.append(w[0]<<8|w[1]) return o
def g_crc(self,data): c=0xFF for byte in data: c^=byte for _ in range(8): if c&0x80:c=(c<<1)^0x31 else:c<<=1 return c&0xFF
def read(self): if self.ready: try: return self.eCO2(), self.TVOC() except: pass else: self.init() if self.ready: return (self.read()) else: return None
# ------------------------------------------- start up -----------------------------------------------------------
def ismb(): return(True)
def get_version(): print ("TI-Runtime Version 2.4.0")
si c'est sa première utilisation, étape qui ne peut se faire avec la calculatrice :
Télécharge l'application de vol
Tello
sur ton téléphone.
Allume ton drone
Tello
.
Sur ton téléphone, recherche les points d'accès
WiFi
.
Connecte-toi au point d'accès
Tello
qui devrait apparaître.
Ouvre l'application et accepte l'enregistrement.
Ferme l'application et déconnecte ton téléphone du point d'accès
Tello
.
(attention à ce que ton téléphone n'y reste pas connecté ou ne s'y reconnecte pas tout seul, ce qui risque de perturber la communication avec la calculatrice)
Voici maintenant pour les connexions :
Insère le nanoordinateur
micro:bit v2
dans la carte d'extension, en faisant attention au sens.
Connecte la batterie
USB
à la carte d'extension.
Connecte le module
Grove WiFi
au port
P1
de la carte d'extension.
Assure-toi que la batterie
USB
est chargée et allumée si disposant d'un bouton.
Allume la carte d'extension si disposant d'un bouton.
(les DELs sur les
micro:bit
, carte d'extension et module
WiFi
doivent s'allumer)
Connecte enfin la
micro:bit
à la calculatrice, puis allume cette dernière si nécessaire.
Assure-toi que le drone
Tello
est chargé et allumé. Il va clignoter sous différentes couleurs puis se fixer sur du jaune clignotant lorsque prêt.
Et voilà, paré à décoller, tu peux enfin écrire et lancer ton premier script.
incontesté des projets scientifiques sur calculatrices graphiques, se permet d'innover de façon encore plus formidable. En conséquence pour toi une toute nouvelle dimension à explorer pour des projets encore plus fantastiques !
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 quelques-uns 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€
! On peut aussi citer 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 :
, 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 ainsi qu'un un tableau périodique des éléments
(deux applications faisant toujours à ce jour cruellement défaut au firmware officiel
Epsilon
)
, ainsi qu'une bibliothèque de constantes physiques, un convertisseur d'unités, et bien d'autres choses encore. Le tout était en prime programmable en
Python
, avec une collection de bibliothèques importables bien plus étoffée que celle de l'application du
firmware
officiel, et surtout ici de façon intégrée, tes scripts
Python
pouvant même ici faire appel au moteur de calcul formel
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.
Les utilisateurs informés qui avaient la chance d'avoir entre leurs mains des calculatrices non encore verrouillées avaient certes le choix mais restaient face à un très cruel dilemme :
soit mettre à jour vers le
firmware
Epsilon
pour bénéficier de toutes les dernières nouveautés officielles, mais en contrepartie renoncer définitivement aux formidables ajouts des
firmwares
tiers
soit utiliser un
firmware
tiers, mais en contrepartie se priver des nouveautés officielles apportées à ce jour avec les versions
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 jusqu'à la version
18.2.0
.
Après plus de 6 mois d'attente
Phi
te permettait donc enfin de déverrouiller ta calculatrice. Mieux que ça, le nouveau chargeur de démarrage
Phi
était ensuite capable de lancer aussi bien les
firmwares
officiels
Epsilon
(à partir de la version
16
)
que les
firmware
tiers, à la seule condition que ces derniers aient été mis à jour pour supporter ce nouvel amorçage.
Le projet
Omega
profita justement de l'occasion pour renaître de ses cendres avec une mise à jour compatible en version
2.0.0
.
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 !
Phi
rajoute un 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. Rappelons que 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
. Justement à cet écran
Phi
présente la mémoire
Flash
comme découpée en 2
slots
A
et
B
de
4 Mio
chacun. Les nouveaux raccourcis
reset
+
1
et
reset
+
2
te permettent alors de basculer entre l'amorçage des deux
firmwares
présents dans chacun de ces 2
slots
. Du
multiboot
sur une calculatrice, c'est absolument sensationnel !
Sauf qu'il y avait un problème extrêmement grave avec
Phi
et
Omega 2.0.0
.
Phi
n'était pas conforme à la réglementation française du mode examen et était donc strictement interdit d'utilisation à tout examen exigeant l'activation de ce mode en France. Le problème était que les raccourcis
reset
+
1
et
reset
+
2
permettant de basculer entre les deux
firmwares
présents en mémoire désactivaient le mode examen et éteignaient donc la diode examen, chose aisément et rapidement détectable par les surveillants.
Certes, cela ne permettait a priori pas de tricher, vu qu'il s'agissait d'un
reset
et que cela vidait donc le contenu mémoire. Le problème est ailleurs ; c'est strictement interdit par les spécifications officielles du mode examen français. En effet le mode examen ne doit pas pouvoir être désactivé de façon autonome par les candidats, c'est-à-dire que la désactivation doit obligatoirement nécessiter un outil extérieur non présent sur leur table de composition car interdit en examen
dans une salle d'examen en France et te faisais prendre
(parce que tu auras basculé entre deux firmwares pendant l'épreuve et oublié de réactiver immédiatement le mode examen)
, tu risquais l'ensemble des désagréments possiblement dramatiques associés à une tentative de fraude
(non fixé sur ta réussite à l'examen à la veille de l'été comme les camarades et donc rien à fêter avec eux, le jugement nécessitant du temps alors qu'en prime les rectorats sont fermés une bonne partie de l'été risque de perdre ton inscription dans l'enseignement supérieur et donc une année, jusqu'à 5 ans d'interdiction de passer tout examen y compris le permis de conduire de quoi bien te gâcher la vie, ...)
migrant vers ce nouveau mode de fonctionnement avec chargeur de démarrage, en ont profité pour traiter ce problème.
Le fonctionnement retenu était de dupliquer la configuration du mode examen dans les différents
slots
lors du basculement de
firmware
via les raccourcis
reset
+
1
et
reset
+
2
.
En théorie donc, le mode examen n'était donc plus désactivé et tu n'étais donc plus en danger.
En pratique toutefois ce n'était pas parfait.
D'une part ce n'était pas fiable à 100%. Il nous est arrivé que le mode examen se désactive lors d'une bascule entre les
firmwares
, plus précisément à la première activation suivant l'installation du
bootloader
associé. Pas réussi à date à reproduire le problème autrement ; mais comme les développeurs n'ont pas réussi à l'expliquer rien ne prouve que c'est impossible.
D'autre part, ce n'était pas gênant pour la France où seule le verrouillage du contenu mémoire préexistant est demandé en mode examen, mais dans d'autres pays le mode examen est également censé bloquer certaines fonctionnalités. Et là, la configuration dupliquée du mode examen n'était pas toujours comprise de la même façon lors du basculement entre les
firmwares
.
Aujourd'hui c'est enfin au tour du
firmware
Omega
d'être mis à jour afin d'améliorer la conformité avec le mode examen, mais cette fois-ci aussi bien en France que dans le monde !
La solution retenue avec
Omega 2.0.2
diffère donc de celle de
Khi
et
Upsilon
.
Le
bootloader
est maintenant capable de détecter si l'un des
firmwares
installés a été passé en mode examen.
La solution est beaucoup plus radicale ; dans ce cas les raccourcis
reset
+
1
et
reset
+
2
deviennent sans effet : c'est obligatoirement le
firmware
passé en mode examen qui sera amorcé.
Tu ne peux donc plus, en mode examen, disposer à la fois :
des dernières fonctionnalités d'
Epsilon
des fonctionnalités
Omega
Il te faudra donc bien choisir en début d'épreuve dans quel
firmware
tu actives le mode examen.
Si tu as installé
Phi + Omega 2.0.0
sur ta machine, dans ton propre intérêt ainsi qu'afin d'éviter toute mise en danger d'un utilisateur futur à qui tu vendrais/prêterais ta calculatrice, nous te conseillons très fortement d'accepter cette restriction en mode examen et de mettre à jour vers
Omega 2.0.2
, vu que de toutes façons la vulnérabilité corrigée ne permettait déjà pas de tricher.
Attention, la vulnérabilité faisant partie du
bootloader
, il te faut obligatoirement effectuer la mise à jour avec le mode de récupération accessible via le raccourci
reset
+
6
; les mini-tutos suivent ci-dessous.
Supposons que tu dispose déjà d'une machine faisant tourner
Phi + Omega 2.0.0
ou encore les versions avec
bootloader
de
Khi
ou
Upsilon
.
C'est facile à vérifier ; il te suffit de faire
reset
+
4
. L'aspect visuel ainsi que le logo peuvent varier, mais dans tous les cas tu obtiens un écran te listant le contenu des différents
slots
.
Pour remplacer le
bootloader
par le nouveau c'est extrêmement simple. Il te faut :
mettre la machine en mode de récupération autorisant la réécriture du
bootloader
avec le raccourci
reset
+
6
(raccourci à ne plus jamais utiliser sur le site officiel si tu ne veux pas te retrouver à nouveau coincé, et peut-être cette fois-ci sans retour possible )
Bientôt l'épreuve écrite de spécialité Mathématiques du Baccalauréat Général, très rapidement après le retour des vacances suite à la nouvelle organisation imposée par la réforme du lycée et du Baccalauréat. Il faut donc préparer cela dès maintenant, et avec les vacances et le beau temps printanier qui arrivent simultanément, cela va peut-être être difficile.
Mais que tu sois lycéen(ne) ou enseignant(e),
Casio
se propose de t'aider en t'accompagner avec un stage de préparation en ligne, que nous t'avons déjà annoncé avant le départ de la première zone en vacances de printemps afin que le moins de personnes possible ratent l'information. Et bien nous sommes enfin aujourd'hui à la veille du grand lancement de cet événement.
Entièrement gratuit, le stage adopte différents objectifs selon si tu es élève ou enseignant(e) :
pour les enseignants : comment aborder les différents thèmes mathématiques de manière simple et rapide à l’aide de la calculatrice
pour les élèves : se préparer avec l'aide d'un des professeurs de Mathématiques partenaires de
Casio
sur les principaux thèmes du programme, s'exercer avec des cas concrets issus des annales, et tu es bien évidemment bienvenu(e) peu importe ton équipement
Des journées ce mois d'avril vont être dédiées à chacun des thèmes, avec le déroulement suivant :
atelier pour les enseignants : 1 heure en fin de matinée, de
10h30
à
11h30
atelier pour les élèves : 1 heure en tout début d'après-midi de
13h30
à
14h30
, afin de ne pas impacter ce que tu avais prévu pour ton après-midi
Afin de maximiser tes possibilités de participer, chaque thème sera de plus proposé sur 2 journées tombant sur différentes zones de vacances scolaires, du moins en Métropole. En voici le calendrier :
Fonctions & Probabilités
:
Mardi 19 avril
(zones A et B Métropole + Guyane + Saint-Martin + Saint-Barthélémy)
Mardi 26 avril
(zones A et C Métropole + Guyane + Corse)
Programmation Python & Suites
:
Jeudi 21 avril
(zones A et B Métropole + Guyane + Saint-Martin + Saint-Barthélémy)
Jeudi 28 avril
(zones A et C Métropole + Guyane + Corse)
Activation et désactivation du mode examen Casio
:
Mercredi 4 mai
Une organisation méticuleuse afin que tout-le-monde puisse participer, et que nous ne pouvons que féliciter !
Le stage est sur inscription, mais précisons que tu n'as aucune obligation de suivre l'intégralité du stage : tu as toute liberté de sélectionner les journées auxquelles tu souhaites participer, même une seule si tu le veux !
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 quelques-uns 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€
! On peut aussi citer 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 :
, 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 ainsi qu'un un tableau périodique des éléments
(deux applications faisant toujours à ce jour cruellement défaut au firmware officiel
Epsilon
)
, ainsi qu'une bibliothèque de constantes physiques, un convertisseur d'unités, et bien d'autres choses encore. Le tout était en prime programmable en
Python
, avec une collection de bibliothèques importables bien plus étoffée que celle de l'application du
firmware
officiel, et surtout ici de façon intégrée, tes scripts
Python
pouvant même ici faire appel au moteur de calcul formel
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.
Les utilisateurs informés qui avaient la chance d'avoir entre leurs mains des calculatrices non encore verrouillées avaient certes le choix mais restaient face à un très cruel dilemme :
soit mettre à jour vers le
firmware
Epsilon
pour bénéficier de toutes les dernières nouveautés officielles, mais en contrepartie renoncer définitivement aux formidables ajouts des
firmwares
tiers
soit utiliser un
firmware
tiers, mais en contrepartie se priver des nouveautés officielles apportées à ce jour avec les versions
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 jusqu'à la version
18.2.0
.
Après plus de 6 mois d'attente
Phi
te permettait donc enfin de déverrouiller ta calculatrice. Mieux que ça, le nouveau chargeur de démarrage
Phi
était ensuite capable de lancer aussi bien les
firmwares
officiels
Epsilon
(à partir de la version
16
)
que les
firmware
tiers, à la seule condition que ces derniers aient été mis à jour pour supporter ce nouvel amorçage.
Le projet
Omega
profita justement de l'occasion pour renaître de ses cendres avec une mise à jour compatible en version
2
.
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 !
Phi
rajoute un 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. Rappelons que 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
. Justement à cet écran
Phi
présente la mémoire
Flash
comme découpée en 2
slots
A
et
B
de
4 Mio
chacun. Les nouveaux raccourcis
reset
+
1
et
reset
+
2
te permettent alors de basculer entre l'amorçage des deux
firmwares
présents dans chacun de ces 2
slots
. Du
multiboot
sur une calculatrice, c'est absolument sensationnel !
Sauf qu'il y avait deux problèmes majeurs avec
Phi
et
Omega 2
.
D'une part, le découpage de la mémoire
Flash
en 2
slots
égaux de
4 Mio
faisait qu'il n'était pas possible de profiter à la fois :
de la possibilité d'avoir 2
firmwares
entre lesquels basculer au choix
et de la formidable application
KhiCAS
, cette dernière occupant trop de place et débordant donc sur le 2ème
slot
D'autre part, et là c'était extrêmement grave,
Phi
n'est pas conforme à la réglementation française du mode examen et est donc strictement interdit d'utilisation à tout examen exigeant l'activation de ce mode en France. Le problème est que les raccourcis
reset
+
1
et
reset
+
2
permettant de basculer entre les deux
firmwares
présents en mémoire désactivent le mode examen. Or c'est strictement interdit par les spécifications officielles du mode examen français ; le mode examen ne doit pas pouvoir être désactivé de façon autonome par les candidats, c'est-à-dire que la désactivation doit nécessiter un outil extérieur non présent sur leur table de composition car interdit en examen
(2ème calculatrice, ordinateur, etc.)
. Un outil interdit étant frauduleux, si tu introduis
Phi
dans une salle d'examen en France et te fais prendre
(parce que tu auras basculé entre deux firmwares pendant l'épreuve et peut-être même oublié de réactiver immédiatement le mode examen)
, tu risquais l'ensemble des désagréments possiblement dramatiques
(non fixé sur ta réussite à l'examen à la veille de l'été comme les camarades et donc rien à fêter avec eux, le jugement nécessitant du temps alors qu'en prime les rectorats sont fermés une bonne partie de l'été risque de perdre ton inscription dans l'enseignement supérieur et donc une année, jusqu'à 5 ans d'interdiction de passer tout examen y compris le permis de conduire de quoi bien te gâcher la vie, ...)
.
Malgré sa gravité et ses conséquences éventuelles hautement désagréables, ce problème rapidement signalé n'avait malheureusement pas fait l'objet de corrections de la part de l'équipe
Omega
.
Nous t'annoncions par la suite une première mise à jour du
: le mode examen sera conservé lorsque tu changeras de
firmware
conformément la réglementation française !
Si tu es en France et as installé
Phi
ou
Omega 2
sur ta machine, il est urgent pour toi de migrer vers une solution conforme à la réglementation des examens aussitôt que possible, c'est-à-dire à ce jour uniquement
, voici maintenant quelques mini-tutos à adapter selon ta situation. Attention, contrairement à la solution précédente et comme déjà dit, le chargeur de démarrage
mettre la machine en mode de récupération autorisant la réécriture du
bootloader
avec le raccourci
reset
+
6
(raccourci à ne plus jamais utiliser sur le site officiel si tu ne veux pas te retrouver à nouveau coincé, et peut-être cette fois-ci sans retour possible )
Mais 
Suprise 
