Please refresh your CSS cache ! It has changed a little bit and makes you unable to display correctly the website =)

Tentons pour le moment un autodiagnostic plus général des différences entres les ancienne et nouvelle bibliothèques

turtle

de

KhiCAS

, c'est-à-dire la vérification de tout ce qui peut différer du standard.

Voici des scripts en ce sens, une amélioration majeure de ceux développés dans le code de notre test de rentrée

QCC 2021

:

ttl_chk.py

ttl_diags.py

Code: Select all: _turtle_errors = 0 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 color argument types _color_types = 0 try: pencolor([0, 0, 0]) _color_types |= 1 << 0 except: _turtle_error(4) try: pencolor((0, 0, 0)) _color_types |= 1 << 1 except: _turtle_error(5) try: pencolor(0, 0, 0) _color_types |= 1 << 2 except: _turtle_error(6) try: pencolor("black") _color_types |= 1 << 3 except: _turtle_error(7) # 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) try: turtle.position() except: try: turtle.pos() except: _turtle_error(10)

Code: Select all: from ttl_chk import * from ttl_chk import _fix_turtle, _turtle_errors, _colors_fix, _missing_fct, _missing_alias def turtle_diags(): print("Type: " + str(type(turtle))) print("Patchable: " + (_fix_turtle and "yes" or "no")) errors_msg = ( "No <import turtle>", "No pencolor()", "No color()", "No colormode()", "No color as list", "No color as tuple", "No color as args", "No color as string", "Missing colors strings: ", "No circle(,angle)", "Can't get position()", "No heading()", "No fill", "No clear()", "No reset()", "No towards()", "Other missing: ", "Missing aliases: ", ) errors = 0 for k in range(len(errors_msg)): if _turtle_errors & 1 << k: errors += 1 msg = "Err " + str(k) + ": " + errors_msg[k] if k == 8: msg += str(len(_colors_fix)) + " " + str(tuple(_colors_fix.keys())) if k == 16: msg += str(len(_missing_fct)) + " " + " ".join(_missing_fct) if k == 17: l = [] for v in _missing_alias: l.extend(v[1:]) msg += str(len(l)) + " " + " ".join(l) print(msg) print(str(errors) + " error" + ((errors > 1) and "s" or "")) turtle_diags()

Voici ce que nous racontent les scripts sur les différentes solutions

turtle

:

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

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 :

Code: Select all: from ttl_chk import * from ttl_chk import _color_types, _turtle_errors, _colors_fix, _missing_fct, _missing_alias _fix_turtle = True def nop(*argv): return None idty = lambda c: c try: # can turtle be patched ? turtle._fixcolorlist = idty turtle._fixcolorval = idty turtle._fixcolorstring = idty turtle._fixcolorargs = idty turtle._fixcolor = lambda c: turtle._fixcolorlist(turtle._fixcolorval(turtle._fixcolorstring(turtle._fixcolorargs(c)))) except: _fix_turtle = False if _fix_turtle: # fix color() + pencolor() if _turtle_errors & 0x1000: turtle.fillcolor, turtle.begin_fill, turtle.end_fill = idty, nop, nop if _turtle_errors & 2: def _pencolor_(*argv): if len(argv): turtle.color(argv) else: return turtle.color()[0] turtle.pencolor = _pencolor_ if _turtle_errors & 4: def _color_(*argv): if len(argv) == 2: turtle.pencolor(argv[0]) turtle.fillcolor(argv[1]) elif len(argv): turtle.pencolor(argv) else: return (turtle.pencolor(), turtle.fillcolor()) turtle.color = _color_ _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 # fix circle(,) if _turtle_errors & 0x200: turtle._circle = turtle.circle def _circle(r, a=360): turtle._circle(r) turtle.circle = _circle 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

B) 4 exemples comparatifs améliorés

#LesMathématiquesSontBelles

Maintenant que nous avons de quoi faire tourner une unique version de chaque script sur l'ensemble des machines, poursuivons donc l'exploration de l'ensemble des solutions

turtle

avec quelques exemples de script.

Nous allons en profiter pour nous en donner à cœur joie avec les formidables fonctions de remplissage rajoutées dans l'avant-dernière version de

KhiCAS

, sur le thème de

.

C'est donc l'occasion de voir si il y avait d'autres problèmes qui n'ont pas pu être détectés automatiquement, et si ils sont toujours présents dans la dernière version.

Plusieurs des exemples qui vont suivre sont inspirés de publications de

Bert Wikkerink

pour

TI-Nspire CX II

et très librement et fortement adaptés pour être fonctionnels dans le contexte du

heap

Python

bien plus restreint des

TI-83 Premium CE

et compatibles.

Commençons par quelques exemples sur lesquels la dernière version de

KhiCAS

progresse :

Le défilé automobile
Les flocons de Koch
La linea
Pavage d'une lagogne
♫ Le tournesol, le tournesol, ... ♫

Exemple B1 : Le défilé automobile

Nous t'emmenons maintenant au défilé avec les logos de plusieurs grands constructeurs... automobiles :

Code: Select all: from ttl_fix import * 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) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

Amélioration fantastique,

KhiCAS

rattrape le gros retard qu'il avait ici par rapport à la concurrence, et trace maintenant correctement les différents logos des constructeurs !

Exemple B2 : Les flocons de Koch

Encore une fois si tu es dans le Sud de la France, tu n'a pas dû voir de neige depuis des années... Faison donc neiger dans ta calculatrice maintenant, faisons neiger des

flocons de Koch

:

Code: Select all: from ttl_fix import * def rotate_list(l): l[1:],l[0] = l[0:-1],l[-1] def koch(n, l): if n<=0: turtle.forward(l) else: koch(n - 1, l / 3) turtle.left(60) koch(n - 1, l / 3) turtle.right(120) koch(n - 1, l / 3) turtle.left(60) koch(n - 1, l / 3) def flock(n, l): koch(n, l) turtle.right(120) koch(n, l) turtle.right(120) koch(n, l) turtle.speed(0) turtle.colormode(255) 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: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

Beau progrès ici aussi, le flocon en haut à droite est enfin tracé de la bonne couleur comme chez la concurrence.

Exemple B3 : La linea

Code: Select all: try: #TI-83 Premium CE from ti_system import disp_clr disp_clr() except: pass from ttl_fix import * def spiral(k,a,l): x0, y0 = turtle.pos() h0 = turtle.heading() while True: for s in l: turtle.forward(s*k) turtle.left(180-a) x, y = turtle.pos() if abs(x - x0) + abs(y - y0) + abs(turtle.heading() - h0) <= 1: break turtle.speed(0) turtle.pensize(1) turtle.colormode(255) turtle.color((0,0,0),(255,255,0)) 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) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

Belle amélioration ici aussi,

KhiCAS

remplit enfin correctement la forme de droite magré sa complexité !

Exemple B4 : Pavage d'une lagogne

Partons maintenant à la pêche avec un script très hautement impressionnant par rapport aux contraintes de

heap

des

TI-83 Premium CE

et compatibles ; ici nous sommes vraiment sur le fil de la limite des possibilités concernant ces modèles.

Voici donc une lagogne littéralement pavée de poissons :

Code: Select all: from math import sqrt from ttl_fix import * turtle.speed(0) turtle.pensize(1) turtle.colormode(255) turtle.pencolor((0,0,0)) a=16 try: j = 0 while -5 < j < 4: col = ((0,0,255),(255,0,0),(255,180,0))[j%3] i = 0 while -2 + (j % 2) < i < 2: for c in range(3): turtle.penup() turtle.goto(sqrt(3)*3*a*(i*2-(j%2)), 3*a*j) turtle.setheading(-30 + 120*c) turtle.pendown() turtle.fillcolor(col) turtle.begin_fill() for k in range(-17, 18): l = a*sqrt(7) tf = ((1,141.787), (0,l), (1,-100.893), (0,a), (1,120), (0,a/2), [1,-120], [0,-a], [0,a], [1,120], (0,a/2), (1,60), (0,a), (1,-120), (0,a), (1,100.893), (0,l), [1,-40.893])[abs(k)] if k==6 or k==9 or k==17: tf[1] -= 180 elif k==7 or k==8: tf[1] *= -1 (turtle.forward, turtle.left)[tf[0]](tf[1]) turtle.end_fill() turtle.forward(6*a) turtle.backward(5*a) turtle.penup() turtle.right(90) l = a*sqrt(3)/6 for k in range(2): turtle.forward(l) turtle.pencolor((255,255,255)) turtle.dot(a//4) turtle.pencolor((0,0,0)) turtle.dot(a//8) turtle.backward(l) turtle.left(180) i = -i + (i <= 0) j = -j - (j >= 0) except Exception as e: print(e) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

Formidable ici aussi, les poissons se comportent enfin correctement sous

KhiCAS

pour réaliser la pavage !

Petits détails toutefois non spécifiques à cet exemple, lorsque l'on fait défiler le tracé obtenu :

les affichages effectués sur la barre de titre/état en haut d'écran
(18 premières lignes de pixels)
ne sont pas nettoyés correctement lors des rafraichissements
les formes ne sont bizarrement pas remplies correctement dans une bande correspondant aux 42 premières lignes de pixels

Exemple B4 : ♫ Le tournesol, le tournesol, ... ♫

Terminons enfin avec un exemple absolument bluffant de réalisme pour du

turtle

, nous allons faire pousser un tournesol devant toi :

Code: Select all: from math import pi, sin, cos, sqrt from ttl_fix import * def spiral(): phi = (1+sqrt(5))/2 a =0 r = 0 dr = 0.15 turtle.penup() for i in range(300): turtle.forward(r) turtle.pencolor((0,0,0)) try: turtle.dot(3) except: pass turtle.pencolor((205,133,63)) try: turtle.dot(2) except: pass turtle.goto(0,0) turtle.setheading(0) a+=360/phi turtle.right(a) if a>=360: r+=dr a-=360 def feuille(core,a): try: turtle.begin_fill() except: pass turtle.right(a/2) turtle.forward(core) turtle.left(a) turtle.forward(core) turtle.left(180-a) turtle.forward(core) turtle.left(a) turtle.forward(core) try: turtle.end_fill() except: pass turtle.speed(0) turtle.colormode(255) turtle.pencolor((30,144,255)) try: turtle.dot(320) except: pass d=25 core=40 turtle.pencolor((160,82,45)) try: turtle.dot(40) except: pass c=((255,215,0),(255,255,0)) 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) spiral() try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

Excellent, les graines dans le cœur sont enfin délimitées correctement sous

KhiCAS

!

C) 13 autres exemples comparatifs

Et voici quelques autres exemples sur lesquels

KhiCAS

ne bouge pas, juste pour comparaison avec les solutions officielles concurrentes :

La dalle aux ammonites
L'escargot de lumière
Le triangle de Penrose
La courtepointe de Mamie
Les vitraux rhombiques
Les roses par 12
Les triangles de Sierpiński
Sous le soleil exactement
Le labyrinthe du Minotaure
Le carreau de carreaux
Les étoiles jumelles
La toile de l'araignée

Exemple C1 : La dalle aux ammonites

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 :

Code: Select all: from ttl_fix import * from math import pi turtle.speed(0) turtle.pencolor((0,0,0)) turtle.pendown() turtle.pensize(1) turtle.goto(0,-8) x,y = turtle.pos() turtle.left(115) for i in range(132): turtle.forward(10) try: h = turtle.towards(x,y) turtle.setheading(h) except: pass d=10*pi turtle.forward(d) turtle.backward(d) turtle.right(90) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple C2 : L'escargot de lumière

Si tu es dans le Sud de la France tu sais qu'il ne pleut pas souvent

(par contre, quand il pleut... il pleut !)

. Alors voici pour toi un escargot bariolé :

Code: Select all: from math import exp from ttl_fix import * turtle.speed(0) turtle.pensize(1) turtle.colormode(1.0) 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) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple C3 : Le triangle de Penrose

Tu n'as jamais touché à un triangle de

Penrose

? Et bien voici de quoi en afficher le plan dans ta calculatrice, tu n'auras plus qu'à l'imprimer en 3D, si tu arrives à comprendre où est le devant et l'arrière :

Code: Select all: from math import sqrt from ttl_fix import * def hook(a, c): turtle.penup() turtle.goto(0,-15) turtle.setheading(a) turtle.forward((l - 4*b) / sqrt(3)) turtle.right(150) turtle.pendown() lf = ((turtle.left, 60),[turtle.forward,b],(turtle.left,120),(turtle.forward,l-b),[turtle.right,120],[turtle.forward,l-3*b]) try: turtle.fillcolor(c) turtle.begin_fill() except: pass for k in range(-len(lf) + 1, len(lf)): tf = lf[abs(k)] if k == 1: tf[1] = l elif k == 4: tf[0] = turtle.left elif k == 5: tf[1] = b tf[0](tf[1]) try: turtle.end_fill() except: pass turtle.speed(0) turtle.pensize(2) turtle.colormode(255) l=180 b=23 for i in range(112): turtle.pencolor(232 - int(i * 23 / 11), 249 - int(i * 29 / 55), 255) turtle.penup() turtle.goto(-192, 111 - 2*i) turtle.pendown() turtle.forward(384) turtle.pencolor((0,0,0)) turtle.pensize(1) hook(330, (255,255,0)) hook(90, (0,0,255)) hook(210, (255,0,0)) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple C4 : La courtepointe de Mamie

Voici maintenant la courtepointe brodée avec amour et soin par Mamie :

Code: Select all: from ttl_fix import * def rotate_list(l): l[1:],l[0] = l[0:-1],l[-1] 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 = [191, 127, 0] cf = [127, 255, 0] i = 0 while i > -3: j = 0 while j > -2: turtle.penup() turtle.goto((i - 1)*88, (j - 1)*85 + 28) turtle.pendown() turtle.color(c, cf) try: turtle.begin_fill() except: pass poly_reg_a(80, 140) try: turtle.end_fill() except: pass rotate_list(c) rotate_list(cf) j = -j + (j <= 0) i = -i + (i <= 0) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple C5 : Les vitraux rhombiques

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 :

Code: Select all: from ttl_fix import * 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) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Par rapport au fond bleu, notons que c'est bel et bien

KhiCAS

qui adopte le comportement correct. Selon le standard

turtle

, la méthode

.dot()

attend en paramètre le diamètre du disque à tracer. Ce sont les modèles

Texas Instruments

qui le considèrent à tort comme un rayon et remplissent alors tout l'écran.

Exemple C6 : Les roses par 12

Voici maintenant une rose, cette fois-ci sur un fond d'écran en dégradé radial. Nous utiliserons pour cela cette fois-ci une boucle de

.dot()

:

Code: Select all: from math import pi, sin, cos, sqrt from ttl_fix import * def rpoly(c, n): a=360/n for k in range(n): turtle.forward(c) turtle.left(a) def carre(c): rpoly(c, 4) turtle.speed(0) turtle.colormode(255) turtle.penup() r=80 alpha=(15 * pi / 180) for i in range(320): c=int(255/320*i) turtle.pencolor(c,c,c) try: turtle.dot(320-i) except: pass turtle.goto(20,-76) turtle.color((255,255,255),(0,0,0)) 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 try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Sur la taille du disque de fond d'écran et comme déjà dit, c'est ici encore

KhiCAS

qui fait comme il faut.

Exemple C7 : Les triangles de Sierpiński

Revenons aux fractales et à la récursivité avec les

triangles de Sierpiński

. As-tu déjà réussi à les compter ? Et bien voici de quoi commencer sur ta calculatrice :

Code: Select all: from ttl_fix import * 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) turtle.colormode(255) turtle.speed(0) turtle.pensize(1) turtle.penup() turtle.goto(-110, -95) turtle.pendown() turtle.pencolor((255,0,0)) sierp(6, 220) turtle.penup() turtle.forward(400) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple C8 : Sous le soleil exactement

Plaçons-nous maintenant

sous le soleil exactement

, profitant ainsi de toutes les couleurs de la lumière blanche :

Code: Select all: from math import exp from ttl_fix import * def rpoly(c, n): a=360/n for k in range(n): turtle.forward(c) turtle.left(a) def carre(c): rpoly(c, 4) turtle.speed(0) turtle.pensize(1) turtle.colormode(1.0) n = 36 for i in range(n): k=.4 + 4*i/255 cp = [.7*exp(-.5 * ((n - i - k) / (n / 3))**2) for k in (6, 18, 30)] turtle.pencolor(cp) try: turtle.fillcolor((k,k,0)) turtle.begin_fill() except: pass carre(60) try: turtle.end_fill() except: pass turtle.right(360 / n) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple C9 : Le labyrinthe du Minotaure

Explorons maintenant dans la labyrinthe du Minotaure :

Code: Select all: from ttl_fix import * turtle.speed(0) turtle.colormode(255) turtle.pendown() turtle.right(48) turtle.pencolor((0,0,0)) for i in range(98): turtle.forward(2*i) turtle.left(90.5) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple C10 : Le carreau de carreaux

Code: Select all: from math import sqrt from ttl_fix import * def rotate_list(l): l[1:],l[0] = l[0:-1],l[-1] def reg_poly(l, n): for i in range(n): turtle.forward(l) turtle.left(360/n) def square(l): reg_poly(l, 4) turtle.colormode(255) turtle.pencolor(0,0,0) turtle.speed(0) turtle.pensize(3) d=190 c=[0,255,127] turtle.penup() turtle.goto(-d/2,-d/2) turtle.setheading(0) turtle.pendown() for i in range(8): try: turtle.fillcolor(tuple(c)) turtle.begin_fill() except: pass square(d) try: turtle.end_fill() except: pass turtle.penup() turtle.forward(d/2) turtle.left(45) turtle.pendown() d/=sqrt(2) rotate_list(c) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple C11 : Les étoiles jumelles

Code: Select all: 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) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Sur la taille du disque de fond d'écran, c'est à nouveau ici

KhiCAS

qui a raison et pas

TI

.

Exemple C12 : La toile de l'araignée

Suivons maintenant le fil de l'araignée :

Code: Select all: from ttl_fix import * 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 turtle.speed(0) turtle.colormode(255) turtle.pensize(1) a=17 b=194 spiral(a,b) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Conclusion

Selon notre outil de tests,

KhiCAS

pour

TI-Nspire CX

et

NumWorks N0110

est bien mieux conforme au standard

Python-turtle

que l'ensemble des solutions

turtle

officielles, et semble en conséquence bien mieux se comporter en pratique sur une majorité de nos exemples. nous semble offrir à ce jour la meilleure bibliothèque

Python turtle

toutes solutions confondues.

Les méthodes de remplissage, absentes des implémentations officielles de

Casio

et

NumWorks

t'ouvrent la porte à de formidables progrès.

Les progrès témoignent d'un soin minutieux apporté par

Bernard Parisse

, et vu que tout semble parfait maintenant il va nous falloir tenter d'inventer de nouveaux exemples piégeux...

Téléchargements

Téléchargement / installation

:

by **critor** » 18 Apr 2022, 17:10

Depuis des années maintenant,

Texas Instruments

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.

Nous pouvions déjà citer l'interface

TI-Innovator Hub

, le robot pilotable

TI-Innovator Rover

, la grille programmable

TI-RGB Array

ou encore l'adaptateur

TI-SensorLink

pour capteurs analogiques

Vernier

.
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

BBC micro:bit

programmable en

Python

dont tu étais peut-être déjà équipé·e !

La carte

micro:bit

est initialement un projet lancé par la

BBC

(

B

ritish

B

roadcasting

C

orporation)

, le groupe audiovisuel public britannique, accompagné de nombre de partenaires dont

ARM

,

Microsoft

et

Samsung

. Elle fut distribuée gratuitement à un million d'élèves britanniques de 11 et 12 ans.

Le nom rend hommage au précédent succès du groupe dans ce domaine, le microordinateur à vocation pédagogique

BBC Micro

des années 1980, l'équivalent britannique de par son adoption à nos microordinateurs

Thomson MO5

et

TO7

inondant écoles, collèges et lycées à la fin de cette décennie dans le cadre du plan

IPT

(

I

nformatique

P

our

T

ous)

.

Les cartes

micro:bit

utilisent un connecteur

micro-USB

et ta calculatrice un

mini-USB

.

Pour relier les deux une solution est d'adjoindre un adaptateur

mini-USB

.

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

mb_run()

en ce sens :

Code: Select all: from ti_hub import * def mb_run(code): send('\x05') # enter paste mode (Ctrl-E) send(code) send('\x04') # exit paste mode (Ctrl-D)

Pour afficher par exemple

Pac-Man

, il te suffit d'appeler mb_run("display.show(Image.PACMAN)"), conformément à la documentation du

Python micro:bit

.

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

Python micro:bit

:

microbit

(générale, permet d'accéder aux menus des autres bibliothèques)
mb_audio
→
microbit.audio

(effets sonores - accessible via le menu
Audio
)
mb_butns
→
microbit.buttons

(boutons
A
,
B
et tactile intégrés - accessible via le menu
Buttons
ou
Boutons
)
mb_disp
→
microbit.display

(afficheur à 5×5=25 LEDs rouges intégré - accessible via le menu
Display
ou
Affichage
)
mb_grove

(capteurs et actionneurs
Grove
à rajouter - accessible via le menu
Grove Devices
)
mb_log

(enregistrement de données - accessible via le menu
Data logging
ou
Enregistrement de données
)
mb_mic

microbit.microphone

(micro intégré - accessible via le menu
Microphone
)
mb_music
→
microbit.music

(haut-parleur à rajouter sur
micro:bit v1
ou intégré sur
micro:bit v2
- accessible via le menu
Music
ou
Musique
)
mb_neopx
→
microbit.neopixel

(rubans de LEDs programmables à rajouter - accessible via le menu
NeoPixel
)
mb_notes

(notes de musique - accessible via le menu
Music
ou
Musique
)
mb_pins

(contacts programmables intégrés - accessible via le menu
Input/output pins
ou
Broches entrée/sortie
)
mb_radio
→
microbit.radio

(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.

Dès le début du siècle

Texas Instruments

nous faisait rêver de faire débarquer des

rovers

sur

Mars

et les piloter à l'aide de nos calculatrices.

Si nous avons enfin le

TI-Innovator Rover

pilotable par calculatrice aujourd'hui, fallait-il déjà commencer par décoller avant d'espérer pouvoir un jour atteindre

Mars

.

Or lors de la dernière mise à jour en fouillant le

TI-Runtime 2.4.0

, nous avions découvert des traces de fonctions destinées à la configuration d'un drone

.

Ces fonctions n'étaient toutefois pas exposées et n'étaient donc a priori pas utilisables depuis la calculatrice.

Et bien voici aujourd'hui le grand jour.

Texas Instruments

te fait l'honneur de t'inviter à un bêta-test public de la prochaine mise à jour de sa solution

micro:bit

pour

TI-83 Premium CE Edition Python

et compatibles, avec support du drone

!

Eléments et versions
Changements TI-Runtime
Nouvelle bibliothèque TELLO et premier script
Matériel nécessaire et premiers branchements
Lancement et tutoriel de décollage
Conclusion et téléchargements

1) Eléments et versions

Le pack d'aujourd'hui nous apporte deux éléments:

D'une part, nous avons une mise à jour en version
2.5.1
du
TI-Runtime
pour les
micro:bit v2
. Toutefois en pratique, en interrogeant la carte
micro:bit
avec microbit.runtime_version() après mise à jour cette dernière continue à rétourner l'ancienne version
2.4.0
.
D'autre nous avons une nouvelle bibliothèques
Python

tello
, en version
2.5
.

Nous allons de suite creuser le nouveau

TI-Runtime

pour vérifier qu'il n'y a pas eu d'erreur, et ensuite te présenter la bibliothèque

TELLO

.

2) Changements TI-Runtime

https://python.microbit.org/v/2

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

pour pouvoir lire son code source :

2.4.0

2.5.1

Code: Select all: from microbit import * from machine import freq, reset, time_pulse_us from time import ticks_us, sleep_ms from utime import sleep_us # ------------------------------------------- Tello Drone ----------------------------------------------------------- #tello="TELLO-9EF498" TX_pin = 'pin1' # yellow grove wire RX_pin = 'pin15' # white grove wire is_connected = False def tello_read(cmd,TX=TX_pin,RX=RX_pin): try: uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin) uart.read() udp_len=len(cmd) uart.write('AT+CIPSEND=0,' + str(udp_len) + ',"192.168.10.1",8889\r\n') sleep (100) uart.read() udp = bytes(cmd, 'utf-8') uart.write(udp+"\r\n") sleep(100) timeout = 1 timer = 0 while not(uart.any()): sleep(1) timer += .001 if timer > timeout: status = 'Error: timeout' break msg = str(uart.read()) start=msg.find(':') end = msg.find('\\r\\n',start) msg = msg[start+1:end] if msg.find('Non')!=-1: msg = '0' uart.init(baudrate=115200) return(msg) except: uart.init(baudrate=115200) return(False) def tello_control(cmd,TX=TX_pin,RX=RX_pin): try: timeout = 10 uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin) uart.read() udp_len=len(cmd) uart.write('AT+CIPSEND=0,' + str(udp_len) + ',"192.168.10.1",8889\r\n') sleep(100) uart.read() udp = bytes(cmd, 'utf-8') uart.write(udp) timer = 0 sleep(100) while not(uart.any()): sleep(1) timer += .001 if timer > timeout: status ='Error: timeout' break msg = str(uart.read()) if msg.find('SEND OK')==-1: uart.init(baudrate=115200) return (False) sleep(100) uart.read() timer = 0 while not(uart.any()): sleep(1) timer += .001 if timer > timeout: status = 'Error: timeout' break sleep(100) msg = str(uart.read()) start=msg.find('\\r\\n+IPD') if msg.find('ok',start)!=-1: status = "ok" uart.init(baudrate=115200) #print("ok") #sleep(100) #print("ok") #sleep(100) return(status) except: uart.init(baudrate=115200) return(False) def tello_connect(ssid,pswd="",TX=TX_pin,RX=RX_pin): #display.show(ti) try: timeout = 30 global TX_pin global RX_pin TX_pin=locals()[TX] RX_pin=locals()[RX] uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin) #uart.write('AT+CWQAP\r\n') uart.write('AT+RST\r\n') #uart.write('AT+RESTORE\r\n') uart.write('AT+RFPOWER=30\r\n') uart.write('AT+CWMODE=3\r\n') uart.read() #sleep(100) the_ap ='AT+CWJAP=' + '"' + ssid +'"' + "," + '"' + pswd +'"\r\n' uart.write(the_ap + '\r\n') is_connected = False timer = 0 sleep(100) while is_connected == False: timer = 0 while not(uart.any()): sleep(1) timer += .002 if timer > timeout: tello_AT('AT+RST\r\n') reset() msg = str(uart.read()) if msg.find("WIFI GOT IP") !=-1: is_connected = True uart.write('AT+CIFSR\r\n') sleep(100) timer = 0 while not(uart.any()): sleep(1) timer >.002 if timer == timeout: tello_AT('AT+RST') reset() msg = str(uart.read()) if msg.find("192.168.10") !=-1: status = 'got IP' uart.write('AT+CIPMUX=1\r\n') sleep(100) msg = uart.read() uart.write('AT+CIPSTART=0,"UDP","192.168.10.1",8889,8889,2\r\n') sleep(100) msg = uart.read() sleep(100) cmd='command' udp_len=len(cmd) uart.write('AT+CIPSEND=0,' + str(udp_len) + ',"192.168.10.1",8889\r\n') sleep(200) uart.read() udp = bytes(cmd, 'utf-8') uart.write(udp) msg = str(uart.read()) if msg.find('SEND OK')==-1 and status =='got IP': status = "Tello Connected" display.show(Image.HAPPY) else: status = "Tello not responding" display.show(Image.SAD) uart.init(baudrate=115200) return (False) uart.init(baudrate=115200) #print(status) return(status) except: uart.init(baudrate=115200) display.show(Image.SAD) return(False) def discover_tello(TX_pin,RX_pin): count = 0 uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin) uart.write('AT+CWLAPOPT=1,2\r\n') while count < 15: uart.write('AT+CWLAP\r\n') while not(uart.any()): sleep(10) uart.read() sleep(1000) msg = str(uart.read()) start=msg.find('TELLO') if start != -1: end = msg.find('"',start) msg = msg[start:end] uart.init(baudrate=115200) return(msg) else: count += 1 uart.init(baudrate=115200) return(False) def write_tello_setup(ssid,tx,rx,number): try: cfg=open('tello.cfg','w') cfg.write(ssid + "@" + tx + "$" + rx + "%" + number) cfg.close() return(True) except: print (False) def read_tello_setup(): cfg=open('tello.cfg','r') msg = cfg.read() d1 = msg.find('@') d2 = msg.find('$') d3 = msg.find('%') ssid = msg[:d1] tx = msg[d1+1:d2] rx = msg[d2+1:d3] number = msg[d3+1:] display.show(number) return ssid, tx,rx, number # ------------------------------------------- ultrasonic ranger ----------------------------------------------------------- def ranger(pin=pin0,time = True): timeout_us=30000 pin.write_digital(0) sleep_us(2) pin.write_digital(1) sleep_us(10) pin.write_digital(0) pin.read_digital() duration = time_pulse_us(pin, 1, timeout_us)/1e6 # t_echo in seconds distance = 343 * duration/2 * 100 if time: return duration else: return distance # ------------------------------------------- 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)) # -------------------------------------------BME280 Barometric Pressure ----------------------------------------------------------- class BME280(): def __init__(self): self.ready = False self.IDRegister = 0xD0 self.CTRL_HUM = 0xF2 self.CTRL_MEAS = 0xF4 self.CONFIG = 0xF5 self.t_fine = 0 self.dig_T1 = 0 self.dig_T2 = 0 self.dig_T3 = 0 self.dig_P1 = 0 self.dig_P2 = 0 self.dig_P3 = 0 self.dig_P4 = 0 self.dig_P5 = 0 self.dig_P6 = 0 self.dig_P7 = 0 self.dig_P8 = 0 self.dig_P9 = 0 self.dig_H1 = 0 self.dig_H2 = 0 self.dig_H3 = 0 self.dig_H4 = 0 self.dig_H5 = 0 self.dig_H6 = 0 self.TRAW = 0 self.PRAW = 0 self.HRAW = 0 self.ConfigurationData = bytearray(6) self.CalData00_25 = bytearray(25) self.CalData00_25BaseAddress = bytearray(1) self.CalData00_25BaseAddress[0] = 0x88 self.CalData26_41 = bytearray(7) self.CalData26_41BaseAddress = bytearray(1) self.CalData26_41BaseAddress[0] = 0xE1 self.RawSensorData = bytearray(8) self.RawSensorDataBaseAddress = bytearray(1) self.RawSensorDataBaseAddress[0] = 0xF7 def init(self): try: IDAddress = bytearray(1) IDAddress[0] = self.IDRegister i2c.write(0x76, IDAddress, repeat = False) id = i2c.read(0x76, 1, repeat = False) i2c.write(0x76, self.CalData00_25BaseAddress, repeat = False) self.CalData00_25 = i2c.read(0x76, 25, repeat = False) i2c.write(0x76, self.CalData26_41BaseAddress, repeat = False) self.CalData26_41 = i2c.read(0x76, 7, repeat = False) self.dig_T1 = self.BuildU16(self.CalData00_25[1], self.CalData00_25[0]) self.dig_T2 = self.BuildS16(self.CalData00_25[3], self.CalData00_25[2]) self.dig_T3 = self.BuildS16(self.CalData00_25[5], self.CalData00_25[4]) self.dig_P1 = self.BuildU16(self.CalData00_25[7], self.CalData00_25[6]) self.dig_P2 = self.BuildS16(self.CalData00_25[9], self.CalData00_25[8]) self.dig_P3 = self.BuildS16(self.CalData00_25[11], self.CalData00_25[10]) self.dig_P4 = self.BuildS16(self.CalData00_25[13], self.CalData00_25[12]) self.dig_P5 = self.BuildS16(self.CalData00_25[15], self.CalData00_25[14]) self.dig_P6 = self.BuildS16(self.CalData00_25[17], self.CalData00_25[16]) self.dig_P7 = self.BuildS16(self.CalData00_25[19], self.CalData00_25[18]) self.dig_P8 = self.BuildS16(self.CalData00_25[21], self.CalData00_25[20]) self.dig_P9 = self.BuildS16(self.CalData00_25[23], self.CalData00_25[22]) self.dig_H1 = self.CalData00_25[24] self.dig_H2 = self.BuildS16(self.CalData26_41[1],self.CalData26_41[0]) self.dig_H3 = self.CalData26_41[2] self.dig_H4 = (self.BuildS8(self.CalData26_41[3]) << 4) | (self.CalData26_41[4] & 0x0F) self.dig_H5 = (self.BuildS8(self.CalData26_41[5]) << 4) | ((self.CalData26_41[4] >> 4) & 0x0F) self.dig_H6 = self.BuildS8(self.CalData26_41[6]) self.ConfigurationData[0] = self.CTRL_HUM self.ConfigurationData[1] = 0b00000101 self.ConfigurationData[2] = self.CTRL_MEAS self.ConfigurationData[3] = 0b10110111 self.ConfigurationData[4] = self.CONFIG self.ConfigurationData[5] = 0b01000000 i2c.write(0x76,self.ConfigurationData, repeat=False) sleep(100) self.ready = True except: pass def BuildS16(self,msb, lsb): sval = ((msb << 8) | lsb) if sval > 32767: sval -= 65536 return sval def BuildU16(self,msb, lsb): return ((msb << 8) |lsb) def BuildS8(self,b): if b > 127: return (b-256) else: return b def CalculateTemperature(self): self.t_fine Traw = float(self.TRAW) v1 = (Traw/ 16384.0 - float(self.dig_T1) / 1024.0) * float(self.dig_T2) v2 = ((Traw / 131072.0 - float(self.dig_T1) / 8192.0) * ( Traw / 131072.0 - float(self.dig_T1) / 8192.0)) * float(self.dig_T3) self.t_fine = int(v1 + v2) T = (v1 + v2) / 5120.0 return T def CalculatePressure(self): Praw = float(self.PRAW) v1 = float(self.t_fine) / 2.0 - 64000.0 v2 = v1 * v1 * float(self.dig_P6) / 32768.0 v2 = v2 + v1 * float(self.dig_P5) * 2.0 v2 = v2 / 4.0 + float(self.dig_P4) * 65536.0 v1 = (float(self.dig_P3) * v1 * v1 / 524288.0 + float(self.dig_P2) * v1) / 524288.0 v1 = (1.0 + v1 / 32768.0) * float(self.dig_P1) if v1 == 0: return 0 p = 1048576.0 - Praw p = ((p - v2 / 4096.0) * 6250.0) / v1 v1 = float(self.dig_P9) * p * p / 2147483648.0 v2 = p * float(self.dig_P8) / 32768.0 p = p + (v1 + v2 + float(self.dig_P7)) / 16.0 return p def CalculateHumidity(self): self.t_fine Hraw = float(self.HRAW) h = float(self.t_fine) - 76800.0 h = (Hraw - (float(self.dig_H4) * 64.0 + float(self.dig_H5) / 16384.0 * h)) * ( float(self.dig_H2) / 65536.0 * (1.0 + float(self.dig_H6) / 67108864.0 * h * ( 1.0 + float(self.dig_H3) / 67108864.0 * h))) h = h * (1.0 - float(self.dig_H1) * h / 524288.0) if h > 100: h = 100 elif h < 0: h = 0 return h def read(self): if self.ready: try: i2c.write(0x76, self.RawSensorDataBaseAddress, repeat = False) sleep(100) self.RawSensorData = i2c.read(0x76, 8, repeat = False) sleep(100) self.TRAW = ((self.RawSensorData[3] << 16) | (self.RawSensorData[4] << 8) | self.RawSensorData[5]) >> 4 self.PRAW = ((self.RawSensorData[0] << 16) | (self.RawSensorData[1] << 8) | self.RawSensorData[2]) >> 4 self.HRAW = (self.RawSensorData[6] << 8) | self.RawSensorData[7] return self.CalculateTemperature(),self.CalculatePressure(),self.CalculateHumidity() except: pass else: self.init() if self.ready: return (self.read()) else: return None # -------------------------------------------DHT20 Temperature and Humidity ----------------------------------------------------------- class DHT20(): def __init__(self): self.ready = False def init(self): try: i2c.write(0x38, bytes([0xa8,0x00,0x00])) sleep_ms(100) i2c.write(0x38, bytes([0xbe,0x08,0x00])) sleep(100) self.ready = True except: pass def read(self): if self.ready: try: i2c.write(0x38, bytes([0xac,0x33,0x00])) sleep(100) raw = i2c.read(0x38, 7, True) sleep(100) data = [] for i in raw[:]: data.append(i) temperature = 0 temperature = (temperature | data[3]) << 8 temperature = (temperature | data[4]) << 8 temperature = temperature | data[5] temperature = temperature & 0xfffff temperature = (temperature * 200 * 10 / 1024 / 1024 - 500)/10 humidity = 0 humidity = (humidity | data[1]) << 8 humidity = (humidity | data[2]) << 8 humidity = humidity | data[3] humidity = humidity >> 4 humidity = (humidity * 100 * 10 / 1024 / 1024)/10 return temperature, humidity except: pass else: self.init() if self.ready: return (self.read()) else: return None # -------------------------------------------SGP30 VOC and CO2 ----------------------------------------------------------- class SGP30: def __init__(self): self.ready = False def init(self): try: i2c.write(0x58,bytes([0x36, 0x82])) self.iaq_init() self.ready = True except: pass def TVOC(self): return self.iaq_measure()[1] def baseline_TVOC(self): return self.get_iaq_baseline()[1] def eCO2(self): return self.iaq_measure()[0] def baseline_eCO2(self): return self.get_iaq_baseline()[0] def iaq_init(self): self.run(['iaq_init',[0x20,0x03],0,10]) def iaq_measure(self): return self.run(['iaq_measure',[0x20,0x08],2,50]) def get_iaq_baseline(self): return self.run(['iaq_get_baseline',[0x20,0x15],2,10]) 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 run(self,profile): n,cmd,s,d=profile return self.get(cmd,d,s) 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") bme280 = BME280() dht20 = DHT20() sgp30 = SGP30() ti = Image("05500:""05595:""55555:""05550:""00500") display.show(ti)

Code: Select all: from microbit import * from machine import freq, reset, time_pulse_us from time import ticks_us, sleep_ms from utime import sleep_us tello="TELLO-9EF498" TX_pin = pin2 # white grove wire RX_pin = pin1 # yellow grove wire ssid = "3227 Ridge Road" pswd="7209909589" # ------------------------------------------- Tello Drone ----------------------------------------------------------- is_connected = False def tello_read(cmd,TX=TX_pin,RX=RX_pin): try: uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin) uart.read() udp_len=len(cmd) uart.write('AT+CIPSEND=0,' + str(udp_len) + ',"192.168.10.1",8889\r\n') sleep (100) uart.read() udp = bytes(cmd, 'utf-8') uart.write(udp+"\r\n") sleep(100) timeout = 1 timer = 0 while not(uart.any()): sleep(1) timer += .001 if timer > timeout: status = 'Error: timeout' break msg = str(uart.read()) start=msg.find(':') end = msg.find('\\r\\n',start) msg = msg[start+1:end] if msg.find('Non')!=-1: msg = '0' uart.init(baudrate=115200) return(msg) except: uart.init(baudrate=115200) return(False) def tello_control(cmd,TX=TX_pin,RX=RX_pin): try: timeout = 10 uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin) uart.read() udp_len=len(cmd) uart.write('AT+CIPSEND=0,' + str(udp_len) + ',"192.168.10.1",8889\r\n') sleep(100) uart.read() udp = bytes(cmd, 'utf-8') uart.write(udp) timer = 0 sleep(100) while not(uart.any()): sleep(1) timer += .001 if timer > timeout: status ='Error: timeout' break msg = str(uart.read()) if msg.find('SEND OK')==-1: uart.init(baudrate=115200) return (False) sleep(100) uart.read() timer = 0 while not(uart.any()): sleep(1) timer += .001 if timer > timeout: status = 'Error: timeout' break sleep(100) msg = str(uart.read()) start=msg.find('\\r\\n+IPD') if msg.find('ok',start)!=-1: status = "ok" uart.init(baudrate=115200) #print("ok") #sleep(100) #print("ok") #sleep(100) return(status) except: uart.init(baudrate=115200) return(False) def tello_connect(ssid,pswd="",TX=TX_pin,RX=RX_pin): #display.show(ti) # when the configuration is read, global TX and RX should be updated try: timeout = 30 global TX_pin global RX_pin TX_pin=locals()[TX] RX_pin=locals()[RX] uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin) #uart.write('AT+CWQAP\r\n') uart.write('AT+RST\r\n') #uart.write('AT+RESTORE\r\n') uart.write('AT+RFPOWER=30\r\n') uart.write('AT+CWMODE=3\r\n') uart.read() #sleep(100) the_ap ='AT+CWJAP=' + '"' + ssid +'"' + "," + '"' + pswd +'"\r\n' uart.write(the_ap + '\r\n') is_connected = False timer = 0 sleep(100) while is_connected == False: timer = 0 while not(uart.any()): sleep(1) timer += .002 if timer > timeout: tello_AT('AT+RST\r\n') reset() msg = str(uart.read()) if msg.find("WIFI GOT IP") !=-1: is_connected = True uart.write('AT+CIFSR\r\n') sleep(100) timer = 0 while not(uart.any()): sleep(1) timer >.002 if timer == timeout: tello_AT('AT+RST') reset() msg = str(uart.read()) if msg.find("192.168.10") !=-1: status = 'got IP' uart.write('AT+CIPMUX=1\r\n') sleep(100) msg = uart.read() uart.write('AT+CIPSTART=0,"UDP","192.168.10.1",8889,8889,2\r\n') sleep(100) msg = uart.read() sleep(100) cmd='command' udp_len=len(cmd) uart.write('AT+CIPSEND=0,' + str(udp_len) + ',"192.168.10.1",8889\r\n') sleep(200) uart.read() udp = bytes(cmd, 'utf-8') uart.write(udp) msg = str(uart.read()) if msg.find('SEND OK')==-1 and status =='got IP': status = "Tello Connected" display.show(Image.YES) else: status = "Tello not responding" display.show(Image.NO) uart.init(baudrate=115200) return (False) uart.init(baudrate=115200) #print(status) return(status) except: uart.init(baudrate=115200) display.show(Image.NO) return(False) def discover_tello(TX_pin,RX_pin): count = 0 uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin) uart.write('AT+CWLAPOPT=1,2\r\n') while count < 30: uart.write('AT+CWLAP\r\n') while not(uart.any()): sleep(10) uart.read() sleep(1000) msg = str(uart.read()) start=msg.find('TELLO') if start != -1: end = msg.find('"',start) msg = msg[start:end] uart.init(baudrate=115200) return(msg) else: count += 1 uart.init(baudrate=115200) return(False) def write_tello_setup(ssid,tx,rx,number): try: cfg=open('tello.cfg','w') cfg.write(ssid + "@" + tx + "$" + rx + "%" + number) cfg.close() return(True) except: print (False) def read_tello_setup(): try: cfg=open('tello.cfg','r') msg = cfg.read() d1 = msg.find('@') d2 = msg.find('$') d3 = msg.find('%') ssid = msg[:d1] tx = msg[d1+1:d2] rx = msg[d2+1:d3] number = msg[d3+1:] display.show(number) return ssid, tx,rx, number except: return False # ------------------------------------------- ultrasonic ranger ----------------------------------------------------------- def ranger(pin=pin0,time = True): timeout_us=30000 pin.write_digital(0) sleep_us(2) pin.write_digital(1) sleep_us(10) pin.write_digital(0) pin.read_digital() duration = time_pulse_us(pin, 1, timeout_us)/1e6 # t_echo in seconds distance = 343 * duration/2 * 100 if time: return duration else: return distance # ------------------------------------------- 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)) # -------------------------------------------BME280 Barometric Pressure ----------------------------------------------------------- class BME280(): def __init__(self): self.ready = False self.IDRegister = 0xD0 self.CTRL_HUM = 0xF2 self.CTRL_MEAS = 0xF4 self.CONFIG = 0xF5 self.t_fine = 0 self.dig_T1 = 0 self.dig_T2 = 0 self.dig_T3 = 0 self.dig_P1 = 0 self.dig_P2 = 0 self.dig_P3 = 0 self.dig_P4 = 0 self.dig_P5 = 0 self.dig_P6 = 0 self.dig_P7 = 0 self.dig_P8 = 0 self.dig_P9 = 0 self.dig_H1 = 0 self.dig_H2 = 0 self.dig_H3 = 0 self.dig_H4 = 0 self.dig_H5 = 0 self.dig_H6 = 0 self.TRAW = 0 self.PRAW = 0 self.HRAW = 0 self.ConfigurationData = bytearray(6) self.CalData00_25 = bytearray(25) self.CalData00_25BaseAddress = bytearray(1) self.CalData00_25BaseAddress[0] = 0x88 self.CalData26_41 = bytearray(7) self.CalData26_41BaseAddress = bytearray(1) self.CalData26_41BaseAddress[0] = 0xE1 self.RawSensorData = bytearray(8) self.RawSensorDataBaseAddress = bytearray(1) self.RawSensorDataBaseAddress[0] = 0xF7 def init(self): try: IDAddress = bytearray(1) IDAddress[0] = self.IDRegister i2c.write(0x76, IDAddress, repeat = False) id = i2c.read(0x76, 1, repeat = False) i2c.write(0x76, self.CalData00_25BaseAddress, repeat = False) self.CalData00_25 = i2c.read(0x76, 25, repeat = False) i2c.write(0x76, self.CalData26_41BaseAddress, repeat = False) self.CalData26_41 = i2c.read(0x76, 7, repeat = False) self.dig_T1 = self.BuildU16(self.CalData00_25[1], self.CalData00_25[0]) self.dig_T2 = self.BuildS16(self.CalData00_25[3], self.CalData00_25[2]) self.dig_T3 = self.BuildS16(self.CalData00_25[5], self.CalData00_25[4]) self.dig_P1 = self.BuildU16(self.CalData00_25[7], self.CalData00_25[6]) self.dig_P2 = self.BuildS16(self.CalData00_25[9], self.CalData00_25[8]) self.dig_P3 = self.BuildS16(self.CalData00_25[11], self.CalData00_25[10]) self.dig_P4 = self.BuildS16(self.CalData00_25[13], self.CalData00_25[12]) self.dig_P5 = self.BuildS16(self.CalData00_25[15], self.CalData00_25[14]) self.dig_P6 = self.BuildS16(self.CalData00_25[17], self.CalData00_25[16]) self.dig_P7 = self.BuildS16(self.CalData00_25[19], self.CalData00_25[18]) self.dig_P8 = self.BuildS16(self.CalData00_25[21], self.CalData00_25[20]) self.dig_P9 = self.BuildS16(self.CalData00_25[23], self.CalData00_25[22]) self.dig_H1 = self.CalData00_25[24] self.dig_H2 = self.BuildS16(self.CalData26_41[1],self.CalData26_41[0]) self.dig_H3 = self.CalData26_41[2] self.dig_H4 = (self.BuildS8(self.CalData26_41[3]) << 4) | (self.CalData26_41[4] & 0x0F) self.dig_H5 = (self.BuildS8(self.CalData26_41[5]) << 4) | ((self.CalData26_41[4] >> 4) & 0x0F) self.dig_H6 = self.BuildS8(self.CalData26_41[6]) self.ConfigurationData[0] = self.CTRL_HUM self.ConfigurationData[1] = 0b00000101 self.ConfigurationData[2] = self.CTRL_MEAS self.ConfigurationData[3] = 0b10110111 self.ConfigurationData[4] = self.CONFIG self.ConfigurationData[5] = 0b01000000 i2c.write(0x76,self.ConfigurationData, repeat=False) sleep(100) self.ready = True except: pass def BuildS16(self,msb, lsb): sval = ((msb << 8) | lsb) if sval > 32767: sval -= 65536 return sval def BuildU16(self,msb, lsb): return ((msb << 8) |lsb) def BuildS8(self,b): if b > 127: return (b-256) else: return b def CalculateTemperature(self): self.t_fine Traw = float(self.TRAW) v1 = (Traw/ 16384.0 - float(self.dig_T1) / 1024.0) * float(self.dig_T2) v2 = ((Traw / 131072.0 - float(self.dig_T1) / 8192.0) * ( Traw / 131072.0 - float(self.dig_T1) / 8192.0)) * float(self.dig_T3) self.t_fine = int(v1 + v2) T = (v1 + v2) / 5120.0 return T def CalculatePressure(self): Praw = float(self.PRAW) v1 = float(self.t_fine) / 2.0 - 64000.0 v2 = v1 * v1 * float(self.dig_P6) / 32768.0 v2 = v2 + v1 * float(self.dig_P5) * 2.0 v2 = v2 / 4.0 + float(self.dig_P4) * 65536.0 v1 = (float(self.dig_P3) * v1 * v1 / 524288.0 + float(self.dig_P2) * v1) / 524288.0 v1 = (1.0 + v1 / 32768.0) * float(self.dig_P1) if v1 == 0: return 0 p = 1048576.0 - Praw p = ((p - v2 / 4096.0) * 6250.0) / v1 v1 = float(self.dig_P9) * p * p / 2147483648.0 v2 = p * float(self.dig_P8) / 32768.0 p = p + (v1 + v2 + float(self.dig_P7)) / 16.0 return p def CalculateHumidity(self): self.t_fine Hraw = float(self.HRAW) h = float(self.t_fine) - 76800.0 h = (Hraw - (float(self.dig_H4) * 64.0 + float(self.dig_H5) / 16384.0 * h)) * ( float(self.dig_H2) / 65536.0 * (1.0 + float(self.dig_H6) / 67108864.0 * h * ( 1.0 + float(self.dig_H3) / 67108864.0 * h))) h = h * (1.0 - float(self.dig_H1) * h / 524288.0) if h > 100: h = 100 elif h < 0: h = 0 return h def read(self): if self.ready: try: i2c.write(0x76, self.RawSensorDataBaseAddress, repeat = False) sleep(100) self.RawSensorData = i2c.read(0x76, 8, repeat = False) sleep(100) self.TRAW = ((self.RawSensorData[3] << 16) | (self.RawSensorData[4] << 8) | self.RawSensorData[5]) >> 4 self.PRAW = ((self.RawSensorData[0] << 16) | (self.RawSensorData[1] << 8) | self.RawSensorData[2]) >> 4 self.HRAW = (self.RawSensorData[6] << 8) | self.RawSensorData[7] return self.CalculateTemperature(),self.CalculatePressure(),self.CalculateHumidity() except: pass else: self.init() if self.ready: return (self.read()) else: return None # -------------------------------------------DHT20 Temperature and Humidity ----------------------------------------------------------- class DHT20(): def __init__(self): self.ready = False def init(self): try: i2c.write(0x38, bytes([0xa8,0x00,0x00])) sleep_ms(100) i2c.write(0x38, bytes([0xbe,0x08,0x00])) sleep(100) self.ready = True except: pass def read(self): if self.ready: try: i2c.write(0x38, bytes([0xac,0x33,0x00])) sleep(100) raw = i2c.read(0x38, 7, True) sleep(100) data = [] for i in raw[:]: data.append(i) temperature = 0 temperature = (temperature | data[3]) << 8 temperature = (temperature | data[4]) << 8 temperature = temperature | data[5] temperature = temperature & 0xfffff temperature = (temperature * 200 * 10 / 1024 / 1024 - 500)/10 humidity = 0 humidity = (humidity | data[1]) << 8 humidity = (humidity | data[2]) << 8 humidity = humidity | data[3] humidity = humidity >> 4 humidity = (humidity * 100 * 10 / 1024 / 1024)/10 return temperature, humidity except: pass else: self.init() if self.ready: return (self.read()) else: return None # -------------------------------------------SGP30 VOC and CO2 ----------------------------------------------------------- class SGP30: def __init__(self): self.ready = False def init(self): try: i2c.write(0x58,bytes([0x36, 0x82])) self.iaq_init() self.ready = True except: pass def TVOC(self): return self.iaq_measure()[1] def eCO2(self): return self.iaq_measure()[0] def iaq_init(self): self.run(['iaq_init',[0x20,0x03],0,10]) def iaq_measure(self): return self.run(['iaq_measure',[0x20,0x08],2,50]) def baseline_TVOC(self): return self.get_iaq_baseline()[1] def baseline_eCO2(self): return self.get_iaq_baseline()[0] def get_iaq_baseline(self): return self.run(['iaq_get_baseline',[0x20,0x15],2,10]) 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 run(self,profile): n,cmd,s,d=profile return self.get(cmd,d,s) 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") bme280 = BME280() dht20 = DHT20() sgp30 = SGP30() ti = Image("05500:""05595:""55555:""05550:""00500") display.show(ti)

L'on constate en effet que la quasi totalité des changements concernent le support du drone

.

3) Nouvelle bibliothèque TELLO et premier script

La bibliothèque

TELLO

une fois chargée sur ta calculatrice, est importable dans des scripts

Python

en passant par le menu des modules complémentaires. Cela t'active alors un nouveau menu

tello drone

.

Nous y retrouvons alors plusieurs onglets :

Fly
pour tout ce qui concerne les contrôles dans le cadre d'un vol
Data
pour interroger les capteurs intégrés au drone
Tello
Maneuver
pour quelques figures acrobatiques
EDU
pour les plans de vol
Settings
pour les réglages

Cela a l'air super simple non, enfantin même ? Voici donc déjà un premier script :

Code: Select all: from tello import * tello.takeoff() tello.forward(50) d=tello.altitude() tello.turn_left(180) tello.forward(50) tello.land()

4) Matériel nécessaire et premiers branchements

Bref outre la calculatrice, que te faut-il maintenant niveau matériel pour piloter un drone

?

nanoordinateur
BBC micro:bit v2
câble
mini/micro-USB
direct pour
BBC micro:bit v2
et calculatrice
carte d'extension
Grove
ou
bitmaker
module
Grove

WiFi
+ cable
Grove
batterie externe
USB
+ câble
micro-USB
drone
Tello

Tu as tout le matériel entre les mains ? C'est parti pour les manipulations :

Commençons par enregistrer ton drone

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.

5) Lancement et tutoriel de décollage

Dernière chose avant de te laisser voler de tes propres ailes, quand tu lances un script important le module

tello

, la calculatrice n'est pas capable de détecter la carte d'extension utilisée

(

Grove

ou

bitmaker

)

et va donc te demander de préciser.

Si tu préfères bricoler tes propres branchements, tu disposes également si tu préfères d'un écran de configuration avancé.

Si nécessaire, voici pour résumer tout cela un tuto-vidéo officiel en Anglais:

Téléchargements

https://resources.t3europe.eu/t3europe- ... 50b9bcfffa

Décidément

Texas Instruments

, déjà

leader

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 !

Merci

TI

!

TI-Runtime

2.5.1
pour
BBC microbit v2
bibliothèque
Python
complémentaire
TELLO

Source

:

by **critor** » 17 Apr 2022, 17:49

La

NumWorks

était originellement un merveilleux projet de calculatrice graphique ouverte, rompant radicalement avec les usages des constructeurs historiques.

Le développement tiers a pu s'y hisser à un niveau jamais atteint sur la concurrence et permettre l'émergence d'un projet formidable,

Omega

par

Quentin Guidee

et ses non moins illustres collaborateurs.

Il s'agissait d'un

firmware

alternatif pour ta calculatrice

NumWorks

. Basé sur le code source du

firmware

officiel

Epsilon

comme la licence libre l'autorisait à l'époque,

Omega

avait pour but de regrouper et mettre en avant les meilleures contributions au code d'

Epsilon

, en incluant cette fois-ci celles laissées de côté par le constructeur.

Difficile de tout citer ici mais voici déjà par exemple 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 :

KhiCAS
, une formidable application intégrée de Mathématiques et de Sciences par
Bernard Parisse
, enseignant-chercheur à l'Université de Grenoble, qui étendait gratuitement les capacités de ta calculatrice au niveau d'une
HP Prime
. L'application intégrait le moteur de calcul formel
GIAC
développé pour le logiciel
Xcas
du même auteur pour des possibilités en calcul encore plus étendues. Étaient également inclus un tableur 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
GIAC
par l'intermédiaire de la bibliothèque
cas
.
Nofrendo
, un émulateur de console de jeux
Nintendo NES
par
zardam
Peanut-GB
, un émulateur de console de jeux
Nintendo GameBoy
par
M4x1m3
Periodic
, un autre tableau périodique des éléments par
M4x1m3

Un gros avantage de plus était ici que

KhiCAS

et l'ensemble des fonctionnalités rajoutées restaient accessibles en mode examen, de façon parfaitement légale et légitime en France, puisque ces fonctionnalités ne sont pas des données et venaient de plus directement intégrées à des modèles concurrents haut de gamme parfaitement autorisés.

Mais voilà, pour la rentrée 2021 la mise à jour

16.3

d'

Epsilon

, le

firmware

officiel des calculatrices

NumWorks

, a introduit un verrouillage des modèles

N0110

.

Toute

N0110

mise à jour ou venant préchargée d'une version

16.3

ou supérieure, comprend un chargeur de démarrage censé être non effaçable, et empêchant entre autres :

l'installation de tout
firmware
non correctement signé par le constructeur, c'est-à-dire entre autres de tout
firmware
antérieur à la version
16
ainsi que de tout
firmware
non officiel dont
Omega
l'installation d'applications persistantes en mémoire
Flash

(logiciel intégré de Mathématiques avec moteur ce calcul formel
KhiCAS
, émulateurs
Nintendo Game Boy
et
NES
, tableau périodique des éléments, ...)

NumWorks

a de plus profité de l'occasion pour révoquer sa licence libre, et interdire ainsi la réutilisation de tout code introduit à partir de la version

16

dans des

firmwares

non officiels ;

Omega

ne pouvait donc plus intégrer les dernières nouveautés.

La mort dans l'âme, nous t'annoncions donc à la rentrée 2021 l'abandon en conséquence du projet de

firmware

Omega

.
Toutefois 2

forks

en ont par la suite émergé successivement, les

firmwares

par

Bernard Parisse

, puis

.

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
16
,
17
puis
18

Dans une actualité précédente, nous t'annoncions la sortie de

Phi

par

M4x1m3

, un des anciens de l'équipe de développement

Omega

.

Phi

est un chargeur de démarrage avec lequel il suffit d'écraser le chargeur officiel, grâce à une faille présente dans les

firmwares

Epsilon

officiels 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

+

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

+

et

reset

+

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

+

et

reset

+

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

(2^ème calculatrice, ordinateur, smartphone, tablette, etc.)

.

Si tu introduisais

Phi

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, ...)

.

Les mises à jour suivantes de

puis

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

+

et

reset

+

.

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

+

et

reset

+

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

+

; 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

+

. 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 )
te rendre sur le site d'
Omega
cliquer sur le bouton
Recovery
pour charger et lancer le logiciel de récupération
normalement la calculatrice se rallume automatiquement après quelques secondes ; utiliser alors le bouton
Install Omega

Si par contre tu pars d'une calculatrice ne disposant pas encore d'un

bootloader

tiers, il suffit d'installer

Phi

qui a également été mis à jour de façon similaire à

Omega 2.0.2

.

Tutoriels d'installation

:

Installation

:

Phi
Omega
ou
Khi
ou
Upsilon

by **critor** » 16 Apr 2022, 20:26

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 !

Merci

Casio

!

Inscription

:

élèves enseignants

by **critor** » 14 Apr 2022, 20:51

La

NumWorks

était originellement un merveilleux projet de calculatrice graphique ouverte, rompant radicalement avec les usages des constructeurs historiques.

Le développement tiers a pu s'y hisser à un niveau jamais atteint sur la concurrence et permettre l'émergence d'un projet formidable,

Omega

par

Quentin Guidee

et ses non moins illustres collaborateurs.

Il s'agissait d'un

firmware

alternatif pour ta calculatrice

NumWorks

. Basé sur le code source du

firmware

officiel

Epsilon

comme la licence libre l'autorisait à l'époque,

Omega

avait pour but de regrouper et mettre en avant les meilleures contributions au code d'

Epsilon

, en incluant cette fois-ci celles laissées de côté par le constructeur.

Difficile de tout citer ici mais voici déjà par exemple 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 :

KhiCAS
, une formidable application intégrée de Mathématiques et de Sciences par
Bernard Parisse
, enseignant-chercheur à l'Université de Grenoble, qui étendait gratuitement les capacités de ta calculatrice au niveau d'une
HP Prime
. L'application intégrait le moteur de calcul formel
GIAC
développé pour le logiciel
Xcas
du même auteur pour des possibilités en calcul encore plus étendues. Étaient également inclus un tableur 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
GIAC
par l'intermédiaire de la bibliothèque
cas
.
Nofrendo
, un émulateur de console de jeux
Nintendo NES
par
zardam
Peanut-GB
, un émulateur de console de jeux
Nintendo GameBoy
par
M4x1m3
Periodic
, un autre tableau périodique des éléments par
M4x1m3

Un gros avantage de plus était ici que

KhiCAS

et l'ensemble des fonctionnalités rajoutées restaient accessibles en mode examen, de façon parfaitement légale et légitime en France, puisque ces fonctionnalités ne sont pas des données et venaient de plus directement intégrées à des modèles concurrents haut de gamme parfaitement autorisés.

Mais voilà, pour la rentrée 2021 la mise à jour

16.3

d'

Epsilon

, le

firmware

officiel des calculatrices

NumWorks

, a introduit un verrouillage des modèles

N0110

.

Toute

N0110

mise à jour ou venant préchargée d'une version

16.3

ou supérieure, comprend un chargeur de démarrage censé être non effaçable, et empêchant entre autres :

l'installation de tout
firmware
non correctement signé par le constructeur, c'est-à-dire entre autres de tout
firmware
antérieur à la version
16
ainsi que de tout
firmware
non officiel dont
Omega
l'installation d'applications persistantes en mémoire
Flash

(logiciel intégré de Mathématiques avec moteur ce calcul formel
KhiCAS
, émulateurs
Nintendo Game Boy
et
NES
, tableau périodique des éléments, ...)

NumWorks

a de plus profité de l'occasion pour révoquer sa licence libre, et interdire ainsi la réutilisation de tout code introduit à partir de la version

16

dans des

firmwares

non officiels ;

Omega

ne pouvait donc plus intégrer les dernières nouveautés.

La mort dans l'âme, nous t'annoncions donc à la rentrée 2021 l'abandon en conséquence du projet de

firmware

Omega

.
Toutefois 2

forks

en ont par la suite émergé successivement, les

firmwares

par

Bernard Parisse

, puis

.

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
16
,
17
puis
18

Dans une actualité précédente, nous t'annoncions la sortie de

Phi

par

M4x1m3

, un des anciens de l'équipe de développement

Omega

.

Phi

est un chargeur de démarrage avec lequel il suffit d'écraser le chargeur officiel, grâce à une faille présente dans les

firmwares

Epsilon

officiels 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

+

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

+

et

reset

+

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

+

et

reset

+

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

firmware

dédié à

KhiCAS

par

Bernard Parisse

, compatible avec le nouveau amorçage via un chargeur de démarrage, et incluant sa propre version de ce dernier.

Bernard

avait pris le soin de traiter les deux problèmes précédents :

d'une part,
Khi
était proposé dans une version allégée intégrant la seul application
Paramètres
, permettant de faire rentrer
KhiCAS
dans un unique
slot
et ainsi de profiter également en même temps d'un
multiboot
avec le
firmware
officiel
Epsilon
d'autre part, le mode examen était ici conservé lors de la bascule entre deux
firmwares
, comportement enfin conforme aux textes réglementaires français

Si pour ta part tu préférais le

firmware

, et bien c'est le grand jour pour toi !

Dernier mais non le moindre,

vient en effet enfin d'être à son tour mis à jour dans une version avec un

bootloader

permettant le

multiboot

!

En prime cette mise à reprend une des améliorations effectuées dans le cadre de la mise à jour de

: 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

ou

, et ce même si tu n'as pas d'examens cette année. En effet :

si tu attends à l'année prochaine tu risques d'oublier entre temps
et même si tu n'as pas du tout d'examen, tu pourrais très bien un jour prêter ou vendre ta calculatrice à quelqu'un qui serait concerné

Si tu souhaites installer ou migrer sur

, des mini-tutos sont inclus dans l'annonce associée.

Si tu souhaites installer ou migrer sur

, 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

ne te permettra pas de profiter à la fois de l'application

KhiCAS

et de la possibilité d'avoir un

multiboot

.

Supposons que tu dispose déjà d'une machine sous

Phi

avec un

multiboot

Omega 2.0

et

Epsilon

, voici comment migrer.

Comme le site web d'

Omega

n'installe ce dernier que dans le

slot

A

, c'est-à-dire que tu as normalement :

Omega 2.0
Epsilon

Pour remplacer

Phi

par le nouveau

bootloader

d'

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 )
te rendre sur le site d'
Upsilon
cliquer sur le bouton
Recovery
pour charger et lancer le logiciel de récupération
rafraîchir la page pour utiliser alors le bouton
Connect
, suivre les instructions, et lorsque proposé bien effectuer une installation dans le
slot

A

(choix par défaut à ce jour, et le slot
B
n'est pas proposé)

Si par contre tu pars d'une calculatrice ne disposant pas encore de

Phi

ou autre

bootloader

tiers, le plus simple est de commencer par l'installer pour ensuite suivre la procédure précédente de migration vers

.

Tutoriels d'installation

:

Installation

:

Phi
Khi
ou
Upsilon
ou
Omega

by **critor** » 14 Apr 2022, 10:51

Ta calculatrice

TI-83 Premium CE

ou

TI-84 Plus CE

dispose d'une application de tableau périodique des éléments appelée

Periodic

.

Periodic

est normalement préinstallé en usine, et est ensuite mis à jour ou réinstallé avec les fichiers de packs de mises à jour diffusés par

Texas Instruments

chaque année. L'application est alors accessible via la combinaison

2nde

résol

sur

TI-83 Premium CE

ou via la touche

apps

sur

TI-84 Plus CE

. Sur

TI-83 Premium CE

, cette application a même le gros avantage de rester disponible en mode examen, contrairement aux modèles concurrents de chez

Casio

.

La dernière version de

Periodic

est la

5.5.0.0038

compilée le

12 mai 2020

, et accompagne donc les packs de mises à jour depuis la mise à jour système

5.5

de rentrée 2020.

C'est une très belle application, disposant d'une superbe interface justement en forme de tableau périodique et tirant profit de l'écran couleur pour distinguer différentes familles d'éléments.

Mais c'est loin d'être tout. Pour accéder à un élément ciblé, tu as le choix entre parcourir le tableau périodique évoqué ou bien une liste d'éléments. Pour te faciliter les choses cette liste peut justement être triée aussi bien par numéro atomique que nom ou symbole.

Rajoutons la possibilité d'exporter les valeurs numériques de propriétés d'élément pour les réutiliser hors de l'application, ainsi que celle de construire des diagrammes qui pourront entre autres mettre en évidence le caractère périodique des propriétés chimiques !

Nous en sommes donc à bientôt 2 ans sans mise à jour de l'application

Periodic

.

Et

Texas Instruments

ferait peut-être mieux de se méfier car le concurrent français

NumWorks

a annoncé fin 2021 être en train de travailler sur une application de tableau péridodique pour une future mise à jour, un des plus gros manques de sa calculatrice, et a l'habitude pour chaque nouveauté d'innover grandement sur l'interface...

Frédéric Desautels

alias

mr womp womp

vient donc de sauter sur l'occasion et de te programmer en langage

C

sa propre vision d'un tableau périodique amélioré pour

TI-83 Premium CE

et compatibles.

Son programme est bien évidemment loin d'égaler l'application officielle. On peut déplorer :

l'impossibilité d'accéder aux éléments par liste
l'impossibilité d'exporter ou représenter graphiquement les propriétés numériques
la précision décimale inférieure à l'affichage des propriétés numériques
la non prise en compte de la langue de la calculatrice, l'affichage étant ici toujours en Anglais
un tout petit peu moins de propriétés que
Texas Instruments
, 13 au lieu de 15

Mais ce qui nous intéresse aujourd'hui ce ne sont pas les manques, mais les différences.

Frédéric

nous offre en effet quelques évolutions sur l'interface qu'il a tout particulièrement soignée, avec :

les symboles des éléments directement affichés sur le tableau périodique et facilitant donc d'une part au plus grand nombre la recherche sur cette interface, et permettant de plus de lister rapidement les éléments appartenant à une même famille ou période
un thème sombre moins agressif pour les yeux
un affichage des propriétés en petite police permettant de tout faire rentrer sur un même écran, au lieu d'avoir à faire défiler sur 3 écrans comme avec
Texas Instruments
sur l'affichage des propriétés, possibilité de passer directement à l'élément suivante/précédent avec les touches fléchées sans avoir à repasser par la vue en tableau

Mais bien sûr à la différence de l'application officielle, ce programme ne restera malheureusement pas disponible en mode examen, les réglementation et spécifications associées semblant avoir été conçues de façon trop complaisante avec les constructeurs ; ce genre de programme parfaitement légitime en France n'aurait jamais dû être bloqué par le mode examen en France.

Donc pour t'en servir en évaluation, pas d'autre choix qu'attendre que

Texas Instruments

accepte de faire quelque chose de similaire, ou à défaut un de ses concurrents.

Attention, ce programme rentre dans la catégorie des programmes en langage machine dits

ASM

.

Or, suite à un acte hautement maladroit d'un enseignant de Mathématiques français avec ses gesticulations certes compréhensibles mais maladroites et à courte vue dans le contexte de la réforme du lycée,

Texas Instruments

a réagi en supprimant la gestion de tels programmes depuis la mise à jour

5.5.1

.

Si tu es sur une des versions ainsi bridées, tu peux quand même jouer sans trop d'efforts. Il te faut :

installer
arTIfiCE
pour remettre la possibilité de lancer des programmes
ASM
ensuite de préférence installer
Cesium
pour pouvoir lancer les programmes
ASM
plus facilement, ou même
AsmHook
pour pouvoir les lancer comme avant
installer les bibliothèques
C
nécessaires au fonctionnement de certains jeux dont celui-ci
(mais rien de compliqué, juste à transférer le fichier et c'est tout)

Téléchargements

:

by **critor** » 13 Apr 2022, 14:38

Elimination

est un jeu de type

RPG

, une création originale par

Hot_Dog

initialement sortie en

novembre 2021

pour calculatriaces

TI-82 Plus

,

TI-83 Plus

et

TI-84 Plus

monochromes, prenant la forme d'une application.

Le

gameplay

est comparable à ce que tu as peut-être connu avec

Final Fantasy

,

Pokemon

,

Earthbound

ou encore

Super Mario RPG

. Tu enchaînes des phases d'exploration et de combat au tour par tour.

En 2050, les terriens sont en guerre avec une étrange race extraterreste insectiforme venue de la galaxie

Whirlpool

(tourbillon)

. Mais toute ressemblance avec d'autres histoires de science fiction s'arrête là, car les terriens avaient l'avantage.

Notre aventure démarre avec quatre enfants :

Ryan

,

Jamie

,

Collin

et

Megan

, qui par curiosité s'amusent à monter à bord d'une soucoupe volante écrasée. Malheureusement pendant qu'ils sont encore à bord, la soucoupe est récupérée et ramenée dans la galaxie

Whirlpool

. Bien évidemment, aucun d'eux ne sachant piloter une soucoupe volante alien, ce moyen de retour est a priori inenvisageable. Sauf qu'une autre race extraterrestre, les

Tosonians

et leur

leader

Jaslin

, sont prêts à aider nos quatre explorateurs à retrouver le chemin de la voie lactée.

C'est le début d'une formidable aventure sur calculatrices. Pour aider à la construction du vaisseau spatial

Tosonian

, ton équipe va devoir explorer des planètes, progresser en expérience et niveau, et accumuler des ressources

(or, cuivre, lithium, ...)

.

Aujourd'hui

Hot_Dog

nous fait l'immense plaisir d'une version couleur d'

Elimination

pour

TI-83 Premium CE

et

TI-84 Plus CE

!

11 niveaux t'attendent sur 8 planètes peuplées de plus de 70 ennemis dont des

boss

; mais qu'attends-tu ?

Attention,

Elimination

rentre dans la catégorie des programmes en langage machine dits

ASM

.

Or, suite à un acte hautement maladroit d'un enseignant de Mathématiques français avec ses gesticulations certes compréhensibles mais aveugles dans le contexte de la réforme du lycée,

Texas Instruments

a réagi en supprimant la gestion de tels programmes depuis la mise à jour

5.5.1

.

Si tu es sur une des versions ainsi bridées, tu peux quand même jouer sans trop d'efforts. Il te faut :

installer
arTIfiCE
pour remettre la possibilité de lancer des programmes
ASM
ensuite de préférence installer
Cesium
pour pouvoir lancer les programmes
ASM
plus facilement, ou même
AsmHook
pour pouvoir les lancer comme avant
installer les bibliothèques
C
nécessaires au fonctionnement de certains jeux dont celui-ci
(mais rien de compliqué, juste à transférer le fichier et c'est tout)

Téléchargements

:

Elimination
pour
TI-83 Premium CE / 84+CE

TI-82/83/84+
monochromes
Ressources pour
TI-83 Premium CE / 84+CE
:

by **critor** » 12 Apr 2022, 19:37

Pour accompagner en douceur la transition du

Scratch

au

Python

en Seconde, la plupart des solutions

Python

sur calculatrices graphiques offrent

turtle

, une bibliothèque permettant du tracé relatif comme en

Scratch

. On peut citer :

la
NumWorks
dont l'application
Python
intègre directement
turtle
les
Casio Graph 35+E II
et
Graph 90+E
dont l'application
Python
intègre directement
turtle
les
TI-Nspire CX II
sur lesquelles on peut rajouter la bibliothèque officielle
turtle

(anciennement
ce_turtl
)
à l'environnement
Python
les
TI-83 Premium CE Edition Python

(France)
,
TI-84 Plus CE-T Python Edition

(Europe)
et
TI-84 Plus CE Python

(Amérique du Nord)
, sur lesquelles on peut rajouter une bibliothèque
turtle
officielle
et
KhiCAS

Aujourd'hui justement approfondissons ce dernier point, parlons du

turtle

de

KhiCAS

. Conçu par

Bernard Parisse

, enseignant-chercheur à l'Université de Grenoble,

KhiCAS

est la déclinaison sur calculatrices du logiciel de Mathématiques intégré

Xcas

. Disponible pour calculatrices

NumWorks N0110

,

TI-Nspire CX

,

Casio Graph 35+E II

et

Graph 90+E

,

KhiCAS

te donne donc accès à une interface unifiée ainsi qu'à des fonctionnalités haut de gamme peu importe la marque ou le modèle de ta calculatrice !

Ce formidable environnement de Mathématiques et de sciences t'apporte bien des choses. Nous pouvons citer dans tous les cas :

la reprise du moteur de calcul formel
GIAC
développé pour
Xcas
par le même auteur.
la possibilité de programmer dans 2 langages :
- le langage
  Xcas
  historique
- le langage
  Xcas
  avec une couche de compatibilité syntaxique
  Python

Dans ses éditions pour

TI-Nspire CX

et

NumWorks N0110

,

KhiCAS

apporte pas mal de compléments :

possibilité de composer et convertir ses unités
une bibliothèque de constantes physiques
plusieurs applications elles-même intégrées, dont entre autres :
- tableur / feuille de calcul
- tableau périodique des éléments
- calcul financier
2 langages de programmation supplémentaires :
- Python
  via un interpréteur
  Micropython
- Javascript
  via un interpréteur
  QuickJS

L'environnement

Python

sur ces modèles est extrêmement riche, bien davantage que les solutions

Python

intégrées par les constructeurs. On peut citer nombre de bibliothèques :

cas
et
xcas
pour appeler le moteur de calcul formel
GIAC
directement depuis tes scripts
Python
cmath
pour traiter directement tes calculs sur les nombres complexes en
Python
linalg
pour l'algèbre linéaire
arit
pour l'arithmétique
ulab.scipy
pour le calcul scientifique
ulab.numpy
pour le calcul matriciel et vectoriel
plusieurs bibliothèque de tracés :
- turtle
  pour les tracés relatifs à la
  Scratch
- matplotlib
  pour les tracés dans un repère
- graphic
  pour les tracés par pixels, accompagnée de
  casioplot
  pour la compatibilité avec les scripts graphiques
  Casio
  et
  kandinsky
  pour la compatibilité avec les scripts graphiques
  NumWorks
et bien d'autres :
gc
,
math
,
micropython
,
nsp
,
pylab
,
random
,
sys
,
time
,
ubinascii
,
ucollections
,
uctypes
,
uerrno
,
uhashlib
,
uheapq
,
uio
,
ujson
,
ure
,
ustruct
,
uzlib

La dernière mise à jour de

KhiCAS

améliore justement les possibilités de la bibliothèque

turtle

. Elle est disponible à ce jour :

uniquement en version
alpha
pour
TI-Nspire CX
en version stable pour
NumWorks N0110

Découvrons ensemble les nouveautés.

A) Contenu bibliothèque

Commençons donc par explorer le contenu de la bibliothèque

turtle

:

Code: Select all: import turtle l = dir(turtle) l len(l)

Effectivement il y a bien des nouveauté, nous passons de 66 à 69 éléments. Nous disposons de 3 nouvelles méthodes :

.clear() pour effacer l'affichage sans réinitialiser la position de la tortue
.pos(), un alias court de .position() que l'on avait déjà pour récupérer la position de la tortue
.towards(x, y) pour obtenir l'angle d'orientation permettant d'atteindre les coordonnées fournies

Cela peut certes te paraître peu, bien que

.towards()

permette déjà d'aborder facilement des scripts bien plus ambitieux comme nous verrons plus bas.

Mais ça c'est juste pour les méthodes rajoutées ; il va rester à voir si il y a eu des améliorations sur le fonctionnement des méthodes déjà présentes.

B) Tests de conformité comparatifs
(toutes solutions turtle)

Tentons pour le moment un autodiagnostic plus général des différences entres les ancienne et nouvelle bibliothèques

turtle

de

KhiCAS

, c'est-à-dire la vérification de tout ce qui peut différer du standard.

Voici des scripts en ce sens, une amélioration majeure de ceux développés dans le code de notre test de rentrée

QCC 2021

:

ttl_chk.py

ttl_diags.py

Code: Select all: _turtle_errors = 0 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 color argument types _color_types = 0 try: pencolor([0, 0, 0]) _color_types |= 1 << 0 except: _turtle_error(4) try: pencolor((0, 0, 0)) _color_types |= 1 << 1 except: _turtle_error(5) try: pencolor(0, 0, 0) _color_types |= 1 << 2 except: _turtle_error(6) try: pencolor("black") _color_types |= 1 << 3 except: _turtle_error(7) # 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) try: turtle.position() except: try: turtle.pos() except: _turtle_error(10)

Code: Select all: from ttl_chk import * from ttl_chk import _fix_turtle, _turtle_errors, _colors_fix, _missing_fct, _missing_alias def turtle_diags(): print("Type: " + str(type(turtle))) print("Patchable: " + (_fix_turtle and "yes" or "no")) errors_msg = ( "No <import turtle>", "No pencolor()", "No color()", "No colormode()", "No color as list", "No color as tuple", "No color as args", "No color as string", "Missing colors strings: ", "No circle(,angle)", "Can't get position()", "No heading()", "No fill", "No clear()", "No reset()", "No towards()", "Other missing: ", "Missing aliases: ", ) errors = 0 for k in range(len(errors_msg)): if _turtle_errors & 1 << k: errors += 1 msg = "Err " + str(k) + ": " + errors_msg[k] if k == 8: msg += str(len(_colors_fix)) + " " + str(tuple(_colors_fix.keys())) if k == 16: msg += str(len(_missing_fct)) + " " + " ".join(_missing_fct) if k == 17: l = [] for v in _missing_alias: l.extend(v[1:]) msg += str(len(l)) + " " + " ".join(l) print(msg) print(str(errors) + " error" + ((errors > 1) and "s" or "")) turtle_diags()

Voici ce que nous racontent les scripts sur les différentes solutions

turtle

:

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

On confirme donc avec la nouvelle version

KhiCAS

l'ajout des 3 méthodes jusqu'alors manquantes.

Mais surtout il n'y a donc dans l'état actuel des scripts plus aucune erreur détectée automatiquement, chose exceptionnelle si l'on compare aux solutions officielles, et signe d'un soin minutieux !

Mais ça, c'est pour les problèmes détectables par des vérifications automatisées. Voyons maintenant d'éventuels écarts visuels sur quelques exemples de scripts.

Afin de pouvoir comparer équitablement avec les solutions officielles visiblement parfois bien moins conformes au standard

turtle

tout en conservant une unique version de chaque script utilisable sur l'ensemble des solutions, voici un script qu'il suffira d'importer à la place de chaque bibliothèque

turtle

et qui, lorsque celle-ci sera modifiable, corrigera la plupart des erreurs détectées :

Code: Select all: from ttl_chk import * from ttl_chk import _color_types, _turtle_errors, _colors_fix, _missing_fct, _missing_alias _fix_turtle = True def nop(*argv): return None idty = lambda c: c try: # can turtle be patched ? turtle._fixcolorlist = idty turtle._fixcolorval = idty turtle._fixcolorstring = idty turtle._fixcolorargs = idty turtle._fixcolor = lambda c: turtle._fixcolorlist(turtle._fixcolorval(turtle._fixcolorstring(turtle._fixcolorargs(c)))) except: _fix_turtle = False if _fix_turtle: # fix color() + pencolor() if _turtle_errors & 0x1000: turtle.fillcolor, turtle.begin_fill, turtle.end_fill = idty, nop, nop if _turtle_errors & 2: def _pencolor_(*argv): if len(argv): turtle.color(argv) else: return turtle.color()[0] turtle.pencolor = _pencolor_ if _turtle_errors & 4: def _color_(*argv): if len(argv) == 2: turtle.pencolor(argv[0]) turtle.fillcolor(argv[1]) elif len(argv): turtle.pencolor(argv) else: return (turtle.pencolor(), turtle.fillcolor()) turtle.color = _color_ _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 # fix circle(,) if _turtle_errors & 0x200: turtle._circle = turtle.circle def _circle(r, a=360): turtle._circle(r) turtle.circle = _circle if len(_missing_fct): for f in _missing_fct: exec("turtle."+f+"=nop") if len(_missing_alias): for aliases in _missing_alias: validf = aliases[0] for f in aliases[1:]: exec(validf and "turtle."+f+"=turtle."+validf or "turtle."+f+"=nop") # fix clear() if _turtle_errors & 0x2000: turtle.clear = turtle.reset # fix reset() if _turtle_errors & 0x4000: turtle.reset = turtle.clear # fix towards() if _turtle_errors & 0x8000: from math import atan2, pi def _towards(x, y): x0, y0 = turtle.pos() return atan2(y - y0, x - x0) * 180 / pi turtle.towards = _towards

C) 17 exemples comparatifs
(toutes solutions turtle)

#LesMathématiquesSontBelles

Maintenant que nous avons de quoi faire tourner une unique version de chaque script sur l'ensemble des machines, poursuivons donc l'exploration de l'ensemble des solutions

turtle

avec quelques exemples de script.

Nous allons en profiter pour nous en donner à cœur joie avec les formidables fonctions de remplissage rajoutées dans l'avant-dernière version de

KhiCAS

, sur le thème de

.

C'est donc l'occasion de voir si il y avait d'autres problèmes qui n'ont pas pu être détectés automatiquement, et si ils sont toujours présents dans la dernière version.

Plusieurs des exemples qui vont suivre sont inspirés de publications de

Bert Wikkerink

pour

TI-Nspire CX II

et très librement et fortement adaptés pour être fonctionnels dans le contexte du

heap

Python

bien plus restreint des

TI-83 Premium CE

et compatibles.

La dalle aux ammonites
Le défilé automobile
L'escargot de lumière
Les flocons de Koch
La linea
Pavage d'une lagogne
Le triangle de Penrose
La courtepointe de Mamie
Les vitraux rhombiques
Les roses par 12
Les triangles de Sierpiński
Sous le soleil exactement
Le labyrinthe du Minotaure
Le carreau de carreaux
Les étoiles jumelles
La toile de l'araignée
♫ Le tournesol, le tournesol, ... ♫

Exemple n°1 : La dalle aux ammonites

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 :

Code: Select all: from ttl_fix import * from math import pi turtle.speed(0) turtle.pencolor((0,0,0)) turtle.pendown() turtle.pensize(1) turtle.goto(0,-8) x,y = turtle.pos() turtle.left(115) for i in range(132): turtle.forward(10) try: h = turtle.towards(x,y) turtle.setheading(h) except: pass d=10*pi turtle.forward(d) turtle.backward(d) turtle.right(90) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

KhiCAS

ainsi que le

turtle

officiel de la

NumWorks

avaient un tracé incorrect ici, car la méthode

.towards()

était absente de leur implémentation de

turtle

. Et malheureusement, la bibliothèque

turtle

n'est dans ces deux cas pas altérable à l'exécution ce qui empêchait notre script de corriger.

Concernant

KhiCAS

ce manque est maintenant comblé, et visiblement parfaitement fonctionnel !

Exemple n°2 : Le défilé automobile

Nous t'emmenons maintenant au défilé avec les logos de plusieurs grands constructeurs... automobiles :

Code: Select all: from ttl_fix import * 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) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

Sur cet exemple,

KhiCAS

reste l'une des solutions

turtle

qui s'en tire hélas le moins bien.

Toutefois on peut remarquer une petite amélioration depuis la dernière fois ; la couleur de remplissage passé en 2^ème paramètre de la méthode .color(,) n'est plus ignorée et est maintenant gérée correctement.

Exemple n°3 : L'escargot de lumière

Si tu es dans le Sud de la France tu sais qu'il ne pleut pas souvent

(par contre, quand il pleut... il pleut !)

. Alors voici pour toi un escargot bariolé :

Code: Select all: from math import exp from ttl_fix import * turtle.speed(0) turtle.pensize(1) turtle.colormode(1.0) 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) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

Ici pour la même raison,

KhiCAS

se range maintenant avec les meilleures solutions

turtle

!

Exemple n°4 : Les flocons de Koch

Encore une fois si tu es dans le Sud de la France, tu n'a pas dû voir de neige depuis des années... Faison donc neiger dans ta calculatrice maintenant, faisons neiger des

flocons de Koch

:

Code: Select all: from ttl_fix import * def rotate_list(l): l[1:],l[0] = l[0:-1],l[-1] def koch(n, l): if n<=0: turtle.forward(l) else: koch(n - 1, l / 3) turtle.left(60) koch(n - 1, l / 3) turtle.right(120) koch(n - 1, l / 3) turtle.left(60) koch(n - 1, l / 3) def flock(n, l): koch(n, l) turtle.right(120) koch(n, l) turtle.right(120) koch(n, l) turtle.speed(0) turtle.colormode(255) 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: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Ici par contre, toujours le problème de mauvaise couleur pour le dernier flocon tracé avec

KhiCAS

.

Mais cela reste malgré tout mieux que d'autres solutions officielles.

Exemple n°5 : La linea

Code: Select all: try: #TI-83 Premium CE from ti_system import disp_clr disp_clr() except: pass from ttl_fix import * def spiral(k,a,l): x0, y0 = turtle.pos() h0 = turtle.heading() while True: for s in l: turtle.forward(s*k) turtle.left(180-a) x, y = turtle.pos() if abs(x - x0) + abs(y - y0) + abs(turtle.heading() - h0) <= 1: break turtle.speed(0) turtle.pensize(1) turtle.colormode(255) turtle.color((0,0,0),(255,255,0)) 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) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

Certes cette fois-ci

KhiCAS

remplit la forme de gauche de la bonne couleur, mais ne remplit bizarrement plus correctement celle de droite...

Exemple n°6 : Pavage d'une lagogne

Partons maintenant à la pêche avec un script très hautement impressionnant par rapport aux contraintes de

heap

des

TI-83 Premium CE

et compatibles ; ici nous sommes vraiment sur le fil de la limite des possibilités concernant ces modèles.

Voici donc une lagogne littéralement pavée de poissons :

Code: Select all: from math import sqrt from ttl_fix import * turtle.speed(0) turtle.pensize(1) turtle.colormode(255) turtle.pencolor((0,0,0)) a=16 try: j = 0 while -5 < j < 4: col = ((0,0,255),(255,0,0),(255,180,0))[j%3] i = 0 while -2 + (j % 2) < i < 2: for c in range(3): turtle.penup() turtle.goto(sqrt(3)*3*a*(i*2-(j%2)), 3*a*j) turtle.setheading(-30 + 120*c) turtle.pendown() turtle.fillcolor(col) turtle.begin_fill() for k in range(-17, 18): l = a*sqrt(7) tf = ((1,141.787), (0,l), (1,-100.893), (0,a), (1,120), (0,a/2), [1,-120], [0,-a], [0,a], [1,120], (0,a/2), (1,60), (0,a), (1,-120), (0,a), (1,100.893), (0,l), [1,-40.893])[abs(k)] if k==6 or k==9 or k==17: tf[1] -= 180 elif k==7 or k==8: tf[1] *= -1 (turtle.forward, turtle.left)[tf[0]](tf[1]) turtle.end_fill() turtle.forward(6*a) turtle.backward(5*a) turtle.penup() turtle.right(90) l = a*sqrt(3)/6 for k in range(2): turtle.forward(l) turtle.pencolor((255,255,255)) turtle.dot(a//4) turtle.pencolor((0,0,0)) turtle.dot(a//8) turtle.backward(l) turtle.left(180) i = -i + (i <= 0) j = -j - (j >= 0) except Exception as e: print(e) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Malheureusement pas d'amélioration ici, les poissons continuent à ne pas se comporter correctement sous

KhiCAS

.

Exemple n°7 : Le triangle de Penrose

Tu n'as jamais touché à un triangle de

Penrose

? Et bien voici de quoi en afficher le plan dans ta calculatrice, tu n'auras plus qu'à l'imprimer en 3D, si tu arrives à comprendre où est le devant et l'arrière :

Code: Select all: from math import sqrt from ttl_fix import * def hook(a, c): turtle.penup() turtle.goto(0,-15) turtle.setheading(a) turtle.forward((l - 4*b) / sqrt(3)) turtle.right(150) turtle.pendown() lf = ((turtle.left, 60),[turtle.forward,b],(turtle.left,120),(turtle.forward,l-b),[turtle.right,120],[turtle.forward,l-3*b]) try: turtle.fillcolor(c) turtle.begin_fill() except: pass for k in range(-len(lf) + 1, len(lf)): tf = lf[abs(k)] if k == 1: tf[1] = l elif k == 4: tf[0] = turtle.left elif k == 5: tf[1] = b tf[0](tf[1]) try: turtle.end_fill() except: pass turtle.speed(0) turtle.pensize(2) turtle.colormode(255) l=180 b=23 for i in range(112): turtle.pencolor(232 - int(i * 23 / 11), 249 - int(i * 29 / 55), 255) turtle.penup() turtle.goto(-192, 111 - 2*i) turtle.pendown() turtle.forward(384) turtle.pencolor((0,0,0)) turtle.pensize(1) hook(330, (255,255,0)) hook(90, (0,0,255)) hook(210, (255,0,0)) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple n°8 : La courtepointe de Mamie

Voici maintenant la courtepointe brodée avec amour et soin par Mamie :

Code: Select all: from ttl_fix import * def rotate_list(l): l[1:],l[0] = l[0:-1],l[-1] 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 = [191, 127, 0] cf = [127, 255, 0] i = 0 while i > -3: j = 0 while j > -2: turtle.penup() turtle.goto((i - 1)*88, (j - 1)*85 + 28) turtle.pendown() turtle.color(c, cf) try: turtle.begin_fill() except: pass poly_reg_a(80, 140) try: turtle.end_fill() except: pass rotate_list(c) rotate_list(cf) j = -j + (j <= 0) i = -i + (i <= 0) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

C'est bon ici,

KhiCAS

choisit enfin des fils de la bonne couleur pour broder la courtepointe !

Exemple n°9 : Les vitraux rhombiques

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 :

Code: Select all: from ttl_fix import * 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) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

Bonne nouvelle ici encore,

KhiCAS

nous peint enfin les vitraux de la bonne couleur !

Par rapport au fond bleu, notons que c'est cette nouvelle version de

KhiCAS

qui adopte le comportement correct. Selon le standard

turtle

, la méthode

.dot()

attend en paramètre le diamètre du disque à tracer. Ce sont les modèles

Texas Instruments

qui le considèrent à tort comme un rayon et remplissent alors tout l'écran.

Exemple n°10 : Les roses par 12

Voici maintenant une rose, cette fois-ci sur un fond d'écran en dégradé radial. Nous utiliserons pour cela cette fois-ci une boucle de

.dot()

:

Code: Select all: from math import pi, sin, cos, sqrt from ttl_fix import * def rpoly(c, n): a=360/n for k in range(n): turtle.forward(c) turtle.left(a) def carre(c): rpoly(c, 4) turtle.speed(0) turtle.colormode(255) turtle.penup() r=80 alpha=(15 * pi / 180) for i in range(320): c=int(255/320*i) turtle.pencolor(c,c,c) try: turtle.dot(320-i) except: pass turtle.goto(20,-76) turtle.color((255,255,255),(0,0,0)) 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 try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

KhiCAS

nous colorie enfin les pétales correctement !

Et sur la taille du disque de fond d'écran, c'est

KhiCAS

qui fait comme il faut.

Exemple n°11 : Les triangles de Sierpiński

Revenons aux fractales et à la récursivité avec les

triangles de Sierpiński

. As-tu déjà réussi à les compter ? Et bien voici de quoi commencer sur ta calculatrice :

Code: Select all: from ttl_fix import * 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) turtle.colormode(255) turtle.speed(0) turtle.pensize(1) turtle.penup() turtle.goto(-110, -95) turtle.pendown() turtle.pencolor((255,0,0)) sierp(6, 220) turtle.penup() turtle.forward(400) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple n°12 : Sous le soleil exactement

Plaçons-nous maintenant

sous le soleil exactement

, profitant ainsi de toutes les couleurs de la lumière blanche :

Code: Select all: from math import exp from ttl_fix import * def rpoly(c, n): a=360/n for k in range(n): turtle.forward(c) turtle.left(a) def carre(c): rpoly(c, 4) turtle.speed(0) turtle.pensize(1) turtle.colormode(1.0) n = 36 for i in range(n): k=.4 + 4*i/255 cp = [.7*exp(-.5 * ((n - i - k) / (n / 3))**2) for k in (6, 18, 30)] turtle.pencolor(cp) try: turtle.fillcolor((k,k,0)) turtle.begin_fill() except: pass carre(60) try: turtle.end_fill() except: pass turtle.right(360 / n) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

Du changement ici encore sur

KhiCAS

, notre soleil émet maintenant dans les bonnes longueurs d'onde !

Exemple n°13 : Le labyrinthe du Minotaure

Explorons maintenant dans la labyrinthe du Minotaure :

Code: Select all: from ttl_fix import * turtle.speed(0) turtle.colormode(255) turtle.pendown() turtle.right(48) turtle.pencolor((0,0,0)) for i in range(98): turtle.forward(2*i) turtle.left(90.5) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

Ah c'est bon cette fois-ci, le labyrinthe se construit maintenant correctement sur

KhiCAS

Dédale et Minos seront contents.

Exemple n°14 : Le carreau de carreaux

Code: Select all: from math import sqrt from ttl_fix import * def rotate_list(l): l[1:],l[0] = l[0:-1],l[-1] def reg_poly(l, n): for i in range(n): turtle.forward(l) turtle.left(360/n) def square(l): reg_poly(l, 4) turtle.colormode(255) turtle.pencolor(0,0,0) turtle.speed(0) turtle.pensize(3) d=190 c=[0,255,127] turtle.penup() turtle.goto(-d/2,-d/2) turtle.setheading(0) turtle.pendown() for i in range(8): try: turtle.fillcolor(tuple(c)) turtle.begin_fill() except: pass square(d) try: turtle.end_fill() except: pass turtle.penup() turtle.forward(d/2) turtle.left(45) turtle.pendown() d/=sqrt(2) rotate_list(c) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple n°15 : Les étoiles jumelles

Code: Select all: 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) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

Enfin ici aussi

KhiCAS

nous colorie les étoiles de la bonne couleur.

Sur la taille du disque de fond d'écran c'est ici aussi

KhiCAS

qui a raison et pas

TI

.

Exemple n°16 : La toile de l'araignée

Suivons maintenant le fil de l'araignée :

Code: Select all: from ttl_fix import * 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 turtle.speed(0) turtle.colormode(255) turtle.pensize(1) a=17 b=194 spiral(a,b) try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II

Exemple n°17 : ♫ Le tournesol, le tournesol, ... ♫

Terminons enfin avec un exemple absolument bluffant de réalisme pour du

turtle

, nous allons faire pousser un tournesol devant toi :

Code: Select all: from math import pi, sin, cos, sqrt from ttl_fix import * def spiral(): phi = (1+sqrt(5))/2 a =0 r = 0 dr = 0.15 turtle.penup() for i in range(300): turtle.forward(r) turtle.pencolor((0,0,0)) try: turtle.dot(3) except: pass turtle.pencolor((205,133,63)) try: turtle.dot(2) except: pass turtle.goto(0,0) turtle.setheading(0) a+=360/phi turtle.right(a) if a>=360: r+=dr a-=360 def feuille(core,a): try: turtle.begin_fill() except: pass turtle.right(a/2) turtle.forward(core) turtle.left(a) turtle.forward(core) turtle.left(180-a) turtle.forward(core) turtle.left(a) turtle.forward(core) try: turtle.end_fill() except: pass turtle.speed(0) turtle.colormode(255) turtle.pencolor((30,144,255)) try: turtle.dot(320) except: pass d=25 core=40 turtle.pencolor((160,82,45)) try: turtle.dot(40) except: pass c=((255,215,0),(255,255,0)) 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) spiral() try: turtle.show() #TI-83 Premium CE except: pass

TI-83PCE/84+CE turtle	TI-Nspire CX II turtle	Casio Graph 90+E	nouveau KhiCAS NumWorks TI-Nspire CX II CX
TI-83PCE/84+CE ce_turtl	NumWorks	Casio Graph 35+E II	ancien KhiCAS NumWorks TI-Nspire CX II CX

Ah, enfin notre tournesol commence à ressembler à un tournesol sur

KhiCAS

.

Sur le disque de fond d'écran, rappelons que c'est

KhiCAS

qui a raison.

Par contre, on déplore encore la délimitation incorrecte des graines dans le cœur.

Conclusion

Selon notre outil de tests,

KhiCAS

pour

TI-Nspire CX

et

NumWorks N0110

est bien mieux conforme au standard

Python-turtle

que l'ensemble des solutions

turtle

officielles, et semble en conséquence bien mieux se comporter en pratique sur une majorité de nos exemples. nous semble offrir à ce jour la meilleure bibliothèque

Python turtle

toutes solutions confondues.

Les méthodes de remplissage, absentes des implémentations officielles de

Casio

et

NumWorks

t'ouvrent la porte à de formidables progrès.

Certes il y a encore quelques défauts et donc écarts par rapport au tracé obtenu avec la bibliothèque standard sur ordinateur, mais

KhiCAS

a l'avantage d'être régulièrement maintenu et de bénéficier de plusieurs mises à jour par an.

Les progrès sont déjà très significatifs par rapport à la version précédente, et nul doute qu'ils vont se poursuivre !

Téléchargements