Il y a à peine deux semaines, NumWorks sortait sa mise à jour 17.2 qui métamorphosait littéralement l'application Fonctions et multipliait les possibilités de l'application Probabilités.
Mais chez NumWorks on ne chôme pas, tu es dès aujourd'hui invité(e) à un nouveau bêta-test public avec la version 18, plus exactement numérotée 18.0.0. Découvrons ensemble les nouveautés de cette version.
Difficile de passer à côté en fait, c'est visible dès l'écran d'accueil tel un pot aux roses, l'application Equations a été renommée en Solveur, ce qui suggère que NumWorks poursuit donc avec une nouvelle métamorphose.
Mais avant d'ouvrir la chose, plantons le contexte. Lors de la construction de notre tableau comparatif pour la rentrée 2021, nous avions noté que contrairement à la plupart de la concurrence, la NumWorks ne disposait pas des fonctionnalités de calcul financier.
Toutefois chez la concurrence, les fonctionnalités lorsque présentes n'étaient pas forcément irréprochables pour autant. On pouvait souvent déplorer un ou plusieurs des défauts suivants :
dans les menus de fonctions ou encore pour les noms de paramètres, utilisation sans explication d'abréviations anglophones, qui plus est changeant d'un modèle à un autre
selon les modèles et l'interface appelée, pas toujours de possibilité de résoudre pour l'ensemble des paramètres
Et bien voilà justement, l'application sous son nouveau nom de Solveur devient une application deux-en-un. Dès l'ouverture, un nouveau menu te donne le choix entre :
Equations pour résoudre des équations comme tu pouvais le faire jusqu'à présent
Finance pour résoudre des problèmes financiers
Finance te donne accès à 2 familles de problèmes :
Intérêts simples
Intérêts composés
En fait c'est logique d'avoir attaché ces fonctionnalités à l'application de résolution d'équations. En effet pour ces deux familles de problèmes, il s'agit de résoudre pour un de leurs paramètres des équations financières connues ici de l'application. Tu n'as pas à saisir les équations, mais le fonctionnement sous-jacent est le même.
Nous allons te tester cela sur un exemple de suite, dans le cadre des Intérêts simples. Pour information, cela fait travailler ta calculatrice en interne sur l'équation suivante :
jours_annee le nombre de jours dans l'année, car ce n'est pas forcément 365, le secteur bancaire a gardé l'habitude de l'année lombarde à 360 jours afin de simplifier les calculs
Exemple donc :
On emprunte 1 500 € sur 90 jours à un taux annuel de 7,25%. Quel sera le montant des intérêts ?
Et bien excellente surprise dès l'écran suivant, ici sur NumWorks on peut bien résoudre l'équation pour n'importe lequel de ses paramètres. C'est-à-dire que le choix Intérets simples permet de résoudre pas moins de 4 questions types différentes.
Au passage on reconnaît le soin habituel de NumWorks à réaliser des interfaces intuitives directement compréhensibles et utilisables par toutes et tous ; on apprécie en effet la description très claire accompagnant chaque nom de paramètre.
Ici nous choisissons donc I en tant que paramètre inconnu, et allons donc devoir préciser les valeurs de tous les autres à l'écran suivant, qui lui aussi rappelle de façon fort bienvenue les descriptions de chaque nom de paramètre.
Une entrée supplémentaire nous permet de plus de choisir entre l'année civile et l'année lombarde, pas besoin d'aller la trouver et configurer sur un autre écran contrairement à certains modèles concurrents.
Retenons ici l'année lombarde et c'est bon, nous trouvons bien le résultat attendu de 27,1875€, ici encore avec une description explicite.
Enfin, pour les problèmes d'Intérêts composés, la NumWorks est capable de résoudre 5 questions types.
Décidément, NumWorks semble s'évertuer cette année à combler chacun des trous présents dans notre tableau, du plus important au plus anecdotique, non sans chaque fois marquer la chose de sa griffe avec une interface intuitive.
Il va falloir que l'on retourne faire des petits trous comme dirait Serge, sinon ils n'auront bientôt plus de travail...
Mise à jour calculatrice(choisir la version bêta puis suivre les instructions - attention, verrouillage irréversible des calculatrices N0110 si celles-ci sont encore en version 15 ou inférieure)
Pour la rentrée 2019, NumWorks te sortait une coque collector en édition limitée pour ta calculatrice, la Macaremaths, illustrée tout en humour et talent sur le thème des Mathématiques.
Dans le même genre NumWorks a renouvelé l'expérience en mieux avec une coque en édition limitée chaque mois depuis la rentrée 2020, initiant toute une gamme d'accessoires en édition limitée à collectionner. Tu as déjà eu nombre d'occasions d'habiller ta calculatrice de façon unique au monde :
Voici pour ce mois de Février 2022 la toute dernière coque NumWorks en édition limitée à ajouter à ta collection, une coque tout spécialement dédiée à la Saint Valentin. Imagine offrir cette coque sans pareille au monde à ta moitié ; c'est un présent qu'elle n'oubliera sans nul doute jamais de sa vie.
Tu peux dès maintenant tenter de gagner la coque sur les différents comptes sociaux du constructeur :
Pour participer et peut-être gagner, c'est très simple. À partir des liens précédents, et d'ici la date limité indiquée au plus tard, il te suffit de :
suivre, aimer ou t'abonner au compte du constructeur
taguer ou identifier un ami ou une amie
N'hésite pas à participer sur les différents comptes sociaux, afin de maximiser tes chances.
Collègien(ne), lycéen(ne) ou enseignant(e) en matière scientifique, jusqu'à ce lundi 31 janvier Casio t'a permis de participer à son formidable concours de Noël 2021.
Il te suffisait de programmer sur ta calculatrice Casio ou son émulateur ta liste au Père Noël, avec 3 catégories au choix :
catégorie étudiants : pour les participations individuelles d'élèves de collège ou lycée uniquement malgré le nom
catégorie professeurs : pour les participations individuelles des enseignant(e)s de matière scientifique en collège ou lycée
catégorie classe : pour les participations collectives de classes de collège ou lycée
Pour réaliser ton dessin, tu pouvais choisir entre les 2 technologies suivantes :
calculatrice scientifique fx-92+ Spéciale Collège avec son application Algorithmique t'offrant un langage de tracé à la Scratch/Logo
calculatrice graphique Graph 35+E II ou Graph 90+E avec son application Python
Pour chacune des 3 catégories étaient à gagner 2 superbes gros lots ; 1 pour le meilleur dessin sur fx-92+ Spéciale Collège, et 1 pour le meilleur dessin sur Graph 90/35+E II :
catégorie étudiants : console de jeux Nintendo Switch d'une valeur de 269,99€
catégorie professeurs : trottinette électrique d'une valeur de 199,99€
catégorie classe : 5 calculatrices graphiques au choix + montre Casio pour le professeur et chacun des élèves (calculatrice Graph 35+E II ou Graph 90+E + montre G-Shock ou vintage dans la limite de 35 élèves)
Et en prime avec Casio, pas de perdant : lot de goodiesCasio pour tous les autres participants !
Un superbe concours, merci Casio !
Le concours devait initialement se terminer le 7 janvier, mais la période de participation a été prolongée au dernier moment jusqu'au 31 janvier.
Nous avions très hâte de pouvoir te présenter les productions réalisées que nous espérions à la mesure de l'événement. Plusieurs candidats nous les ont fort aimablement partagées, découvrons tout cela ensemble.
J'ai envoyé une participation pour représenter TI-Planet le soir de la date butoir initiale, en précisant bien que c'était pour le plaisir. Je ne souhaite en effet piquer de gros lots à personne ; même si il s'agit de très grots lots, il n'y en a que 6.
J'ai donc l'honneur et le plaisir de vous partager ma participation finale comme promis, préparée avec soin un petit peu chaque jour à compter de début décembre. Le script fait 1453 lignes et 73,717 Ko ; le script Python le plus gros jamais sorti sur machines Casio ! (et ce n'est pas demain la veille qu'il tournera sur les modèles de milieu de gamme concurrents... )
Il s'agit non pas d'un simple dessin mais d'une véritable animation qui prend 15 minutes environ sur simulateur USB avant de boucler indéfiniment. Elle est à la gloire d'un future modèle haut de gamme, la Casio Classpad III fx-CP600 qui, je l'espère, aura une application Python avec une fonction get_key() dedans.
"Dessiner sa liste au Père Noël" je trouver cette consigne un petit peu trop terre à terre, trop concrète ; j'ai pensé faire l'original en y répondant de façon meta(ou mise en abyme si tu préfères) : sur l'écran de Graph 90+E je dessine donc une calculatrice fx-CP600, et sur l'écran dessiné de cette fx-CP600 je dessine les anciennes application Classpad ainsi que la nouvelle application Classpad Python. Si j'avais su, attends de voir les participations qui vont suivre...
L'animation commence par présenter la frise chronologique des modèles Casio Classpad couleur, avant de faire intervenir le Père Noël pour la livraison de la fx-CP600 :
Pour les affichages, j'ai codé une classe qui me sert de calque et permet ainsi :
d'afficher un objet à différents endroits de l'écran
d'afficher un objet sous forme zoomée/dézoomée
d'afficher des rotations à 90° d'un objet
d'animer des déplacements
d'animer des zooms
Concernant les diverses images utilisées pour les calculatrices et leurs écrans, elles ont été conçues avec un logiciel de retouche d'images avant d'être converties en code Python pour Graph 90+E à l'aide de l'outil de conversion en ligne img2calc.
Concernant les inscriptions sous forme de texte, comme la méthode officielle casioplot.draw_string() ne permet ni les rotations ni les zooms j'ai dû tout refaire, c'est-à-dire recoder intégralement en Python la police de caractères. Ce fut d'ailleurs l'occasion d'inclure différentes tailles de polices, afin d'avoir un meilleur affichage en fonction du niveau de zoom. Il s'agit toutes de polices présentes sur Graph 35+E II ou Graph 90+E, extraites à l'aide d'un script Python à coups de get_pixel() :
5 pixels de hauteur (police "small/medium" Graph 35+E II)
7 pixels de hauteur (police "large" Graph 35+E II)
10 pixels de hauteur (police "small" Graph 90+E)
Maintenant que les données de polices sont directement dans notre script, on peut effectivement les afficher comme on veut, selon différents niveaux de zoom ou différentes orientations. Ces polices ont au passage été étendues de quelques caractères spéciaux absents qui étaient nécessaires ici.
Voici enfin une capture animée de ma participation ; ne pas hésiter à la jouer en vitesse x2 :
def cos90(a): a %= 4 return a==0 and 1 or a==2 and -1
def sin90(a): a %= 4 return a==1 and 1 or a==3 and -1
def nullbits(n): k = 0 while n and not (n % 2): n //= 2 k += 1 return k
################# # font functions ################# def blank_char(font_h): return [0 for k in range(font_h)]
def complete_font(font_bm, n, val): while(len(font_bm) < n): font_bm.append(val)
def shift_char_left(char_bm): kbits = -1 for v in char_bm: if v: kv = nullbits(v) if kbits < 0: kbits = kv else: kbits = min(kbits, kv) if kbits >= 0: k = 2 ** kbits if k > 1: for i in range(len(char_bm)): char_bm[i] //= k
def shift_font_left(font_bm): for char_bm in font_bm: shift_char_left(char_bm)
def gen_font_widths(font_bm): font_h = len(font_bm[0]) for char_bm in font_bm: if len(char_bm) <= font_h: char_w = 0 for row in char_bm: row_w = 0 while row: row_w += 1 row //= 2 if not char_w: char_w = 2 * FONT_INTERSPACE char_w = max(char_w, row_w) char_bm.append(char_w + FONT_INTERSPACE)
############################# # font data + initialization ############################# # most chars come from the Graph 35+E II or Graph 90+E
def fill_rect(x, y, w, h, c): if w and h: for dy in range(0, h, sign(h)): for dx in range(0, w, sign(w)): set_pixel(x + dx, y + dy, c)
def fill_ellipse(x, y, rx, ry, c): ry = abs(ry) for h in range(-int(ry), int(ry)+1): w = sqrt(max(0, rx*rx*(1-h*h/ry/ry))) fill_rect(int(x - w), int(y + h), int(2 * w), 1, c)
def fill_circle(x, y, r, c): if r: for h in range(int(r)+1): w = round(sqrt(max(0, r*r*(1-h*h/r/r)))) fill_rect(x, y + h, w, 1, c) fill_rect(x, y + h, -w, 1, c) fill_rect(x, y - h, w, 1, c) fill_rect(x, y - h, -w, 1, c) # fill_rect(int(x - w), int(y + h), int(2 * w), 1, c) # fill_rect(int(x - w), int(y - h), int(2 * w), 1, c) # for h in range(-int(r), int(r)+1): # w = sqrt(max(0, r*r*(1-h*h/r/r))) # fill_rect(int(x - w), int(y + h), int(2 * w), 1, c)
def fill_rect_4_circles(x, y, w, h, r, c): fill_rect(x + sign(w)*r, y, w - sign(w)*2*r, h, c) fill_rect(x, y + sign(h)*r, w, h - sign(h)*2*r, c) fill_circle(x + sign(w)*r, y + sign(h)*r, r, c) fill_circle(x + w - sign(w) - sign(w)*r, y + sign(h)*r, r, c) fill_circle(x + sign(w)*r, y + h - sign(h) - sign(h)*r, r, c) fill_circle(x + w - sign(w) - sign(w)*r, y + h - sign(h) - sign(h)*r, r, c)
def fill_rect_2_circles_left(x, y, w, h, r, c, rot): if rot % 2: fill_rect(x, y + r*sign(h), w, h - r*sign(h), c) fill_rect(x + r*sign(w), y, w - 2*r*sign(w), h - r*sign(h), c) fill_circle(x + w - sign(w) - r*sign(w), y + r*sign(h), r, c) fill_circle(x + r*sign(w), y + r*sign(h), r, c) else: fill_rect(x + r*sign(w), y, w - r*sign(w), h, c) fill_rect(x, y + r*sign(h), w, h - 2*r*sign(h), c) fill_circle(x + r*sign(w), y + r*sign(h), r, c) fill_circle(x + r*sign(w), y + h - sign(h) - r, r, c)
def fill_rect_2_circles_right(x, y, w, h, r, c, rot): if rot % 2: fill_rect(x, y, w, h - r*sign(h), c) fill_rect(x + r*sign(w), y, w - 2*r*sign(w), h - r*sign(h), c) fill_circle(x + w - sign(w) - r*sign(w), y + h - sign(h) - r*sign(h), r, c) fill_circle(x + r*sign(w), y + h - sign(h) - r*sign(h), r, c) else: fill_rect(x, y, w - cos90(rot)*r*sign(w), h, c) fill_rect(x, y + cos90(rot)*r*sign(h), w, h - cos90(rot)*2*r*sign(h), c) fill_circle(x + w - sign(w) - cos90(rot)*r*sign(w), y + cos90(rot)*r*sign(h), r, c) fill_circle(x + w - sign(w) - cos90(rot)*r*sign(w), y + h - sign(h) - cos90(rot)*r*sign(h), r, c)
def fill_rect_2_ellipses(x, y, w, h, r, c, rot): if rot % 2: rx, ry = w / 2, r fill_rect(x, y + sin90(rot)*r, w, h - sin90(rot)*2*r, c) fill_ellipse(x + (w - sign(w))//2, y + sin90(rot)*ry, int(rx), ry, c) fill_ellipse(x + (w - sign(w))//2, y + h - sign(h) - sin90(rot)*ry, int(rx), ry, c) else: rx, ry = r, h / 2 fill_rect(x + cos90(rot)*r, y, w - cos90(rot)*2*r, h, c) fill_ellipse(x + cos90(rot)*rx, y + (h - sign(h))//2, rx, int(ry), c) fill_ellipse(x + w - sign(w) - cos90(rot)*rx, y + (h - sign(h))//2, rx, int(ry), c)
def draw_char(x, y, st, c, rot, zoom=1, i_font = 0, sh=1): font_h = font_h_l[i_font] font_bm = font_bm_l[i_font] if rot % 2 and sh < 0: x -= 2 * sin90(rot) * font_h if rot % 2 == 0 and sh < 0: y += 2 * cos90(rot) * font_h bm = font_bm[ord(st[0])] for iy in range(font_h): row = bm[iy] ix = 0 while row: if row & 1: if rot%2: fill_rect(x - iy*zoom*sin90(rot)*sign(sh), y + ix*sin90(rot), zoom, zoom, c) else: fill_rect(x + ix*cos90(rot), y + iy*zoom*cos90(rot)*sign(sh), zoom, zoom, c) row //= 2 ix += zoom
def string_width(st, i_font = 0): font_h = font_h_l[i_font] font_bm = font_bm_l[i_font] stw = -FONT_INTERSPACE for ch in st: if ch == "\n": break stw += font_bm[ord(ch)][font_h] if ch == "\n": stw = max(string_width(st[st.index("\n")+1:], i_font), stw) return stw
def string_height(st, i_font = 0): font_h = font_h_l[i_font] font_bm = font_bm_l[i_font] sth = font_h for ch in st: if ch == "\n": sth += font_h + 1 return sth
def draw_string_rotated(x, y, lst, c, rot, w=0, h=0, centerw=True, sh=1): i_font = 0 font_h = font_h_l[i_font] font_bm = font_bm_l[i_font] if isinstance(lst, str): lst = (lst,) lst = sorted(lst, key=string_width, reverse=True) stw = rot % 2 and h + 1 or w + 1
while (stw > w and rot%2 == 0 or stw>h and rot%2) and len(lst): st, lst = lst[0], lst[1:] stw = string_width(st, i_font)
k_font = len(font_h_l) stw = rot % 2 and h + 1 or w + 1 while (stw > w and rot%2 == 0 or stw>h and rot%2) and k_font: k_font -= 1 stw = string_width(st, k_font) i_font = k_font font_h = font_h_l[i_font] font_bm = font_bm_l[i_font] sth = string_height(st, i_font) if rot % 2: zoomf = max(1, min(h // stw, w // sth)) zoom = int(zoomf) if centerw: y += sin90(rot) * (h - stw*zoomf) // 2 x -= sin90(rot) * (w - sth*zoomf) // 2 else: zoomf = max(1, min(w // stw, h // sth)) zoom = int(zoomf) if centerw: x += cos90(rot) * (w - stw*zoomf) // 2 y += cos90(rot) * (h - sth*zoomf) // 2 x0, y0 = x, y for ch in st: if ch == "\n": if rot % 2: y = y0 - sin90(rot) x -= sin90(rot) * (font_h + FONT_INTERSPACE) * zoom * sign(sh) else: x = x0 - cos90(rot) y += cos90(rot) * (font_h + FONT_INTERSPACE) * zoom * sign(sh) draw_char(x, y, ch, c, rot, zoom, i_font, sh) bm = font_bm[ord(ch)] if rot % 2: y += sin90(rot) * bm[font_h] * zoom else: x += cos90(rot) * bm[font_h] * zoom
def image_height(rle, w, pal): i, x, y = 0, 0, 0 nvals = len(pal) nbits = 0 nvals -= 1 while(nvals): nvals >>= 1 nbits += 1 maskval = (1 << nbits) - 1 maskcnt = (0xFF >> nbits >> 1) << nbits while i<len(rle): v = rle[i] mv = v & maskval c = (v & maskcnt) >> nbits if (v & 0b10000000 or nbits == 8): i += 1 c |= rle[i] << (7 - nbits + (nbits == 8)) c = (c + 1) while c: cw = min(c, w - x) c -= cw x = (x + cw) % w y += x == 0 i += 1 return y
def draw_image_rotated(data_l, x0, y0, pal, wr, hr, rot, itransp): f = lambda l: l[0] data_l = sorted(data_l, key=f, reverse=True) w = rot % 2 and hr + 1 or wr + 1 while (w > wr and rot%2 == 0 or w > hr and rot%2) and len(data_l): data, data_l = data_l[0], data_l[1:] w = data[0] rle = data[1] i, x, y = 0, 0, 0 x0, y0 = int(x0), int(y0) h = image_height(rle, w, pal) zoom_kx = sign(wr) wr = abs(wr) if rot % 2: zoomf = max(1, min(hr // w, wr // h)) zoom = int(zoomf) y0 += sin90(rot) * (hr - w*zoomf) // 2 x0 -= sin90(rot) * (wr - h*zoomf) // 2 else: zoomf = max(1, min(wr // w, hr // h)) zoom = int(zoomf) x0 += cos90(rot) * (wr - w*zoomf) // 2 y0 += cos90(rot) * (hr - h*zoomf) // 2 nvals = len(pal) nbits = 0 nvals -= 1 while(nvals): nvals >>= 1 nbits += 1 maskval = (1 << nbits) - 1 maskcnt = (0xFF >> nbits >> 1) << nbits while i<len(rle): v = rle[i] mv = v & maskval c = (v & maskcnt) >> nbits if (v & 0b10000000 or nbits == 8): i += 1 c |= rle[i] << (7 - nbits + (nbits == 8)) c = (c + 1) while c: cw = min(c, w - x) if mv != itransp: if rot%2: fill_rect(x0, y0 + x*zoom*sin90(rot)*zoom_kx, zoom, cw*zoom*sin90(rot)*zoom_kx, pal[mv]) else: fill_rect(x0 + x*zoom*cos90(rot)*zoom_kx, y0, cw*zoom*cos90(rot)*zoom_kx, zoom, pal[mv]) c -= cw x = (x + cw) % w if rot%2: x0 -= (x == 0) and zoom * sin90(rot) else: y0 += x == 0 and zoom * cos90(rot) i += 1
def slide_cp(x, y, dx, dy, n, w, h, rot, mode, page, clean_over_func=None, clean_under_funcs=None): if callable(clean_under_funcs): clean_under_funcs = tuple(clean_under_funcs) elif not clean_under_funcs: clean_under_funcs = [] for k in range(ceil(n / max(abs(dx), abs(dy))) + 1): for f in clean_under_funcs: f() draw_cp(x, y, w, h, rot, mode, page) if clean_over_func: clean_over_func() show_screen() x += dx y += dy return x - dx, y - dy
def slide_img(x, y, dx, dy, n, img, img_w, img_h, img_pal, rot=0, itransp=-1, clean_over_func=None, clean_under_funcs=None): if callable(clean_under_funcs): clean_under_funcs = tuple(clean_under_funcs) elif not clean_under_funcs: clean_under_funcs = [] for k in range(n): for f in clean_under_funcs: f() draw_image_rotated(((img_w,img),), x, y, img_pal, img_w, img_h, rot, itransp) if clean_over_func: clean_over_func() show_screen() x += dx y += dy return x - dx, y - dy
def slide_imgs_forx(y, dy, n, img, img_w, img_h, img_pal, rot=0, itransp=-1, half = False, clean_over_func=None, clean_under_funcs=None): if callable(clean_under_funcs): clean_under_funcs = tuple(clean_under_funcs) elif not clean_under_funcs: clean_under_funcs = [] if half: half = 2 for k in range(n): for f in clean_under_funcs: f() for x in range(0, screen_w, img_w): draw_image_rotated(((img_w,img),), x + (half % 2 and img_w - 1), y, img_pal, img_w * (half % 2 and -1 or 1), img_h, rot, itransp) if half: half += 1 if clean_over_func: clean_over_func() show_screen() y += dy return y - dy
def fill_rect(self, x, y, w, h, c): x, y = self.rescale_xy(x, y) w, h = self.rescale_wh(w, h) fill_rect(x, y, w, h, c)
def fill_rect_4_circles(self, x, y, w, h, r, c): x, y = self.rescale_xy(x, y) w, h = self.rescale_wh(w, h) r = self.rescale_l(r) fill_rect_4_circles(x, y, w, h, r, c)
def fill_rect_2_circles_left(self, x, y, w, h, r, c): x, y = self.rescale_xy(x, y) w, h = self.rescale_wh(w, h) r = self.rescale_l(r) fill_rect_2_circles_left(x, y, w, h, r, c, self.rot)
def fill_rect_2_circles_right(self, x, y, w, h, r, c): x, y = self.rescale_xy(x, y) w, h = self.rescale_wh(w, h) r = self.rescale_l(r) fill_rect_2_circles_right(x, y, w, h, r, c, self.rot)
def fill_rect_2_ellipses(self, x, y, w, h, r, c): x, y = self.rescale_xy(x, y) w, h = self.rescale_wh(w, h) r = self.rescale_l(r) fill_rect_2_ellipses(x, y, w, h, r, c, self.rot)
def draw_string_rotated(self, x, y, st, c, w=0, h=0, centerw=True): sh = h x, y = self.rescale_xy(x, y) w, h = self.rescale_wh(w, h) w, h = abs(w), abs(h) draw_string_rotated(x, y, st, c, self.rot, w, h, centerw, sign(sh))
def draw_floor(): for x in range(0, screen_w, floor_img_w): draw_image_rotated(((floor_img_w, floor_img),), x, floor_img_y, floor_img_pal, floor_img_w, floor_img_h, 0, -1)
def draw_back(): for y in range(ceil(screen_h / 32)): for x in range(ceil(screen_w / 32)): draw_image_rotated(((back_img_w, back_img),), x * back_img_w, y * back_img_h, back_img_pal, back_img_w, back_img_h, 0, -1)
def draw_cps(anim = False): for i in range(len(cp_imgs)): if cp_imgs[i][1] < screen_h: draw_cp(cp_imgs[i][0], cp_imgs[i][1], cp_imgs[i][2], cp_imgs[i][3], 0, i, cp_imgs[i][5]) if anim: cp_imgs[i][5] = (cp_imgs[i][5] + 1) % N_PAGES
line = [] if mode == MODE_FXCP600: line.append(app_physium) line.append(app_algy2) apps.append(line)
for iy in range(len(apps)): for ix in range(min(2, len(apps[iy]))): x, y = x0 + ix*318, 210 + iy*156 w, h = len(apps[iy]) == 1 and page == PAGE_MENU_1 and 612 or 294, 114 canvas.fill_rect_4_circles(x, y, w, h, 10, (156, 153, 156)) canvas.fill_rect_4_circles(x + 8, y + 10, w - 16, h - 16, 7, (205, 210, 213)) canvas.fill_rect_4_circles(x + 16, y + 16, w - 32, h - 32, 4, (231, 235, 232)) canvas.fill_rect_2_circles_left(x, y, h, h, 8, apps[iy][ix][1]) canvas.draw_image_rotated(apps[iy][ix][2], x, y, (BLACK, WHITE), h, h, 0) canvas.draw_string_rotated(x + h, y, apps[iy][ix][0], BLACK, w - 122, h, False) return canvas.w, canvas.h
data = ( (2013, "Classpad II fx-CP400"), (2016, "Classpad II fx-CP400+E"), (2017, "fx-CG500"), (2022, "Classpad III fx-CP600"), ) w, h = draw_cp(screen_w, 0, screen_w, screen_h, 3, MODE_FXCP400) fullw = w + sled_img_w for x in range(screen_w, -len(data)*fullw, -2): clear_screen() for mode in range(len(data)): x0 = x + fullw*mode if x0 < screen_w and x0 + w + sled_img_halfw> 0: c = ((127,0,0),(127,0,127),(127,127,0),(0,0,127))[mode] if mode == MODE_FXCP600: draw_image_rotated(((sled_img_w, sled_img),), x0, 0, (BLACK, c), sled_img_w, screen_h, 0, 0) draw_string_rotated(x0 + sled_img_halfw, 0, "?", c, 0, w, h) else: draw_image_rotated(((sled_img_w, sled_img),), x0, 0, (BLACK, c), sled_img_w, screen_h, 0, 0) draw_cp(x0 + sled_img_halfw + screen_w, 0, screen_w, screen_h, 1, mode, [PAGE_OFF, PAGE_LOGOBAT_ON, PAGE_MENU_1][mode]) draw_string_rotated(x0, 0, str(data[mode][0]) + ":", c, 0, sled_img_halfw, screen_h - h) draw_string_rotated(x0, h, "Casio", c, 0, sled_img_halfw, screen_h - h) draw_string_rotated(x0 + sled_img_halfw, h, data[mode][1], c, 0, screen_w, screen_h - h) show_screen()
# credits : # 5 pixels character font : based on the Casio Graph 35+E II / fx-9750/9850GIII Python application tiny/medium font # 7 pixels character font : based on the Casio Graph 35+E II / fx-9750/9850GIII Python application large font # 10 pixels character font : based on the Casio Graph 90+E / fx-CG50 Python application tiny font # fx-CP400 skin : based on the one used in the Casio Classpad II Manager software # fx-CG500 skin : based on the one used in the Casio fx-CG500 Manager software # Classpad screens : based on Casio fx-CP400 screen captures or pictures # back + floor sprites : Toad house sprites from the "Super Mario All-Stars: Super Mario Bros 3" Nintendo SNES game # curtain + floor : based on the Toad house sprite from the "Super Mario All-Stars: Super Mario Bros 3" Nintendo SNES game # Christmas sled image : http://clipart-library.com/clipart/1133395.htm (personal use license) # Christmas tree image : http://clipart-library.com/clip-art/christmas-tree-silhouette-vector-13.htm (personal use license)
Lephe a également envoyé quelque chose pour représenter Planète Casio. Participation hors concours puisque n'étant plus lycéen, et pas (encore ?...) enseignant.
Afficher ses cadeaux sur une Graph 90+E, Lephe semble avoir pensé comme moi : c'est trop simple, trop concret, pas suffisamment 'meta' à son goût, il faut trouver un moyen de tordre la consigne, de se distinguer... Voici donc sur l'écran Graph 90+E le dessin d'une Graph 90+E, dont l'écran dessiné affiche à son tour les cadeaux !
Ici encore une animation mais quelle animation, la Graph 90+E étant en effet affichée en 3D. Il s'agit d'un moteur semi-complet avec rastérization de triangles (par Ninestars), textures, z-buffer, et effet d'assombrissement avec la profondeur.
L'affichage est certes petit mais c'est fait exprès ; cela permet à l'animation de se jouer sur calculatrice en un temps raisonnable, contrairement à la participation précédente qui cible le simulateur beaucoup plus rapide sur clé USB.
Les données brutes (RGB-888) d'une image 43×90 pixels fournie par le script img.py sont plaquées sur un pavé droit qui se met ensuite à tourner sous nos yeux émervéillés :
for x in range(min_x, max_x+1): u0 = u0_start u1 = u1_start u2 = u2_start z_num = z_num_start z_div = z_div_start
for y in range(min_y, max_y+1): if (u0 | u1 | u2) > 0 and zbuf[y*WIDTH+x] > z_num: if color is None: w = int(((u0 * w0 + u1 * w1 + u2 * w2) // z_div) % TEX_WIDTH) h = int(((u0 * h0 + u1 * h1 + u2 * h2) // z_div) % TEX_HEIGHT) row = TEXTURE_GRAPH90[h] c = (row[3*w], row[3*w+1], row[3*w+2]) else: c = color
# Put pixel r = c[0] * (32768-z_num) >> 15 g = c[1] * (32768-z_num) >> 15 b = c[2] * (32768-z_num) >> 15 set_pixel(x, y, (r, g, b)) zbuf[y*WIDTH+x] = z_num
ptitjoz n'ayant lui plus le privilège d'être élève et pas encore celui d'être enseignant, a malgré tout fait l'effort d'adresser pour le plaisir à Casio une participation hors concours en Python sur Graph 90+E.
Il en profite pour leur transmettre un mystérieux message, GETKEY(). Les vrais savent...
Visiblement, je ne suis pas le seul à m'être retapé tout l'alphabet pour ce concours. En effet Afyu, enseignant en Mathématiques, a quant à lui conçu sa liste de Noël en écriture manuscrite pour la bibliothèque turtle de la Graph 90+E, et ici encore la chose est animée.
D'autant plus impressionnant que la tortue écrit et enchaîne les lettres littéralement sans lever le stylo, exactement comme si elle écrivait à la main, regarde bien la construction de l'animation :
from turtle import * from random import * from math import sin,cos,pi
taille_initiale=1 l_liste=215 h_liste=150
def tracer(lettre,x,y): global taille_initiale #hideturtle() if lettre == "a": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(4) rt(130) for i in range(30): fd(1) lt(18) setheading(-90) fd(-3) fd(4) for i in range(4): lt(18) fd(1)
if lettre == "b": penup() goto(x,y) pendown() setheading(-10) for i in range(10): lt(20-2*i) fd(2) #lt(6-i) for i in range(5): lt(30) fd(1) for i in range(9): fd(2) lt(2*i+4) for i in range(4): lt(25) fd(1) rt(95) fd(2) if lettre == "c": penup() goto(x,y) setheading(30) # vers la droite pendown() fd(5) lt(75) for i in range(8): fd(1) rt(18) rt(162) for i in range(15): fd(1) lt(18) if lettre == "d": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(4) rt(130) for i in range(30): fd(1) lt(18) setheading(-90) fd(-10) fd(11) for i in range(4): lt(18) fd(1) if lettre == "e": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(5) rt(90) for i in range(10): fd(1) lt(15) lt(30) for i in range(10): lt(25) fd(2) if lettre == "E": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(5) rt(90) for i in range(10): fd(1) lt(15) lt(30) for i in range(10): lt(25) fd(2) penup() goto(x+5,y+12) pendown() setheading(45) fd(5) if lettre == "W": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(5) rt(90) for i in range(10): fd(1) lt(15) lt(30) for i in range(10): lt(25) fd(2) penup() goto(x+2,y+13) pendown() setheading(0) fd(2) penup() fd(2) pendown() fd(2) if lettre == "f": penup() goto(x,y) setheading(-10) pendown() fd(2) for i in range(9): lt(20-2*i) fd(2) for i in range(9): lt(19) fd(1) fd(22) for i in range(9): fd(1) lt(21) for i in range(6): fd(2) lt(2*i) rt(150) for i in range(3): fd(2) lt(20) if lettre == "g": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(4) rt(130) for i in range(30): fd(1) lt(18) setheading(-90) fd(-3) fd(14) for i in range(9): rt(19) fd(1) for i in range(6): rt(20-2*i) fd(2) if lettre == "h": penup() goto(x,y+1) setheading(40) pendown() fd(1) rt(60) for i in range(10): lt(20-2*i) fd(1.7) for i in range(10): lt(18) fd(1) fd(14) lt(180) for i in range(7): fd(1.3) rt(25) for i in range(3): lt(30) fd(1) if lettre == "i": penup() goto(x,y) setheading(-15) pendown() for i in range(8): lt(14) fd(1.3) penup() fd(2) pendown() fd(1) penup() setheading(-90)#rt(180) fd(3) pendown() for i in range(6): fd(1.3) lt(15) if lettre == "j": penup() goto(x,y) setheading(-15) pendown() for i in range(8): lt(14) fd(1.3) penup() fd(2) pendown() fd(1) penup() setheading(-90)#rt(180) fd(3) pendown() fd(14) for i in range(8): rt(26) fd(1) for i in range(6): rt(2*i+4) fd(2) if lettre == "k": penup() goto(x,y+2) setheading(40) pendown() fd(1) rt(60) for i in range(10): lt(20-2*i) fd(1.7) for i in range(10): lt(18) fd(1) fd(15) lt(180) fd(3) for i in range(12): fd(1.3) rt(30) rt(90) for i in range(5): fd(1) rt(10) for i in range(4): lt(20) fd(1) if lettre == "l": penup() goto(x,y) pendown() setheading(-10) for i in range(10): lt(20-2*i) fd(2) #lt(6-i) for i in range(5): lt(30) fd(1) for i in range(11): fd(2) lt(2*i+4) if lettre == "m": penup() goto(x,y) pendown() setheading(-10) for i in range(3): fd(0.5) lt(34) fd(5) for j in range(3): for i in range(10): fd(0.4) rt(18) fd(6) lt(180) fd(6) fd(-7) rt(90) fd(2) if lettre == "n": penup() goto(x,y) pendown() setheading(-10) for i in range(3): fd(0.5) lt(33) fd(4) for j in range(2): for i in range(10): fd(0.6) rt(18) fd(5) lt(180) fd(5) fd(-5) rt(90) fd(1) if lettre == "N": penup() goto(x,y+3) setheading(-90) pendown() for i in range(10): fd(1) lt(18) fd(15) rt(145) fd(20) lt(145) fd(15) for i in range(10): fd(1) rt(18)
if lettre == "o": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(4) rt(130) for i in range(30): fd(1) lt(18) for i in range(7): fd(1) lt(35) fd(5) if lettre == "p": penup() goto(x,y) setheading(10) pendown() for i in range(6): fd(1.4) lt(15) setheading(-90) fd(15) fd(-15) lt(90) for i in range(7): fd(1) rt(30-10*i) if lettre == "q": penup() goto(x,y) setheading(60) # vers la droite pendown() fd(4) rt(130) for i in range(30): fd(1) lt(18) setheading(-90) fd(-4)/255 fd(18) fd(-11) lt(80) fd(2) if lettre == "r": penup() goto(x,y+1) setheading(0) pendown() for i in range(8): fd(1) lt(18) setheading(0) fd(5) rt(100) for i in range(7): fd(1) lt(13) if lettre == "s": penup() goto(x,y+1) setheading(0) pendown() for i in range(8): fd(1) lt(18) rt(150) for i in range(8): fd(1) rt(8) lt(30) fd(2) fd(-2) rt(90) for i in range(8): fd(1) rt(12) if lettre == "t": penup() goto(x,y) setheading(-15) pendown() for i in range(8): lt(13) fd(1) fd(9) fd(-3) rt(90) fd(5) fd(-7) fd(2) rt(90) fd(7) for i in range(7): lt(15) fd(1)
if lettre == "u": penup() goto(x,y) setheading(-10) pendown() for i in range(5): fd(1) lt(20) fd(4) rt(180) fd(3) for i in range(7): fd(1) lt(25) fd(5) rt(180) fd(3) for i in range(5): fd(1) lt(20) if lettre == "v": penup() goto(x,y) setheading(45) pendown() for i in range(3): fd(1) lt(15) fd(2) for i in range(5): fd(1) rt(36) fd(3) for i in range(5): fd(1) lt(36) fd(3) rt(110) fd(3) if lettre == "w": penup() goto(x,y) setheading(45) pendown() for i in range(3): fd(1) lt(15) fd(2) for i in range(4): fd(1) rt(45) fd(3) for i in range(4): fd(1) lt(45) fd(5) rt(180) fd(4) for i in range(5): fd(1) lt(36) fd(4) rt(110) fd(1) if lettre == "x": penup() goto(x,y) setheading(80) fd(5) pendown() for i in range(16): fd(1) rt(19) penup() rt(110) fd(9) pendown() rt(240) for i in range(13): fd(1) lt(19) if lettre == "y": penup() goto(x,y) setheading(45) pendown() for i in range(5): fd(1) lt(9) fd(2) for i in range(5): fd(1) rt(36) fd(3) for i in range(5): fd(1.3) lt(36) fd(4) rt(180) fd(14) for i in range(9): rt(19) fd(1) for i in range(5): rt(20-2*i) fd(2) if lettre == "z": penup() goto(x,y+1) setheading(0) pendown() for i in range(8): fd(1) lt(18) setheading(0) fd(6) rt(140) for i in range(6): fd(1) lt(10) rt(180) for i in range(10): fd(0.5) rt(19) fd(10) for i in range(9): rt(19) fd(1) for i in range(3): rt(20-2*i) fd(2) fd(6) if lettre == ".": penup() goto(x+5,y+5) pensize(5) pendown() rt(90) for i in range(5): fd(1) rt(72) pensize(taille_initiale)
def dessin(): hideturtle() penup() goto(-120,70) pensize(3) pencolor([170/255,60/255,60/255]) pendown() setheading(210) for i in range(50): fd(1) rt(6) fd(h_liste) for i in range(50): fd(1) lt(6) for i in range(5): rt(6) fd(-1) setheading(0) fd(l_liste) for i in range(30): fd(1) rt(6) fd(l_liste) fd(-l_liste) for i in range(30): lt(6) fd(-1) fd(-5) lt(90) fd(h_liste-10) for i in range(15): fd(1) lt(6) fd(l_liste)
def liste(): penup() pensize(2) mot="ma liste de N oWl" for rang in range(len(mot)): pencolor([12*rang/255,(255-12*rang)/255,(160+rang*5)/255]) tracer(mot[rang],-95+10*rang,55) pensize(1) #speed(1) mot=". un sapin dEcorE" for rang in range(len(mot)): pencolor([12*rang/255,(255-12*rang)/255,(160+rang*5)/255]) tracer(mot[rang],-100+10*rang,30) mot=". des jolis cadeaux" for rang in range(len(mot)): pencolor([(255-12*rang)/255,12*rang/255,(160+rang*5)/255]) tracer(mot[rang],-100+10*rang,10) mot=". un bon repas" for rang in range(len(mot)): pencolor([(160+5*rang)/255,5*rang/255,(160+rang*5)/255]) tracer(mot[rang],-100+10*rang,-10) mot=". de la neige" for rang in range(len(mot)): pencolor([12*rang/255,(255-12*rang)/255,(255-rang*12)/255]) tracer(mot[rang],-100+10*rang,-30) mot=". une trotinette" for rang in range(len(mot)): pencolor([(160+5*rang)/255,(100-5*rang)/255,(255-rang*12)/255]) tracer(mot[rang],-100+10*rang,-50) pensize(2) penup() goto(70,-40) pendown() setheading(0) fd(1) penup() fd(4) pendown() fd(1) penup() goto(70,-45) setheading(-60) pendown() for i in range(10): fd(1) lt(12)
def etoile(x,y,orientation): penup() goto(x,y) setheading(90+orientation) fd(36) pendown() pensize(2) pencolor([200/255,200/255,0])#jaune doré rt(30) for i in range(5): fd(8) lt(144)
def renne(x,y,orientation): penup() goto(x,y) setheading(orientation) pendown() for k in [-1,1]: penup() pensize(3) goto(x,y) pencolor([140/255,40/255,40/255])#marron setheading(90+orientation-90*k) pendown() for i in range(25): fd(1) lt(5*k) for i in range(3): fd(1) rt(20*k) for i in range(5): fd(1) lt(5*k) rt(70*k)#oreilles for i in range(10): fd(1) rt(5*k) rt(100*k) for i in range(10): fd(1) rt(5*k) rt(100*k) for i in range(10): fd(1) lt(5*k) rt(90*k) #début des bois for i in range(10): fd(1) rt(5*k) for i in range(10): fd(1) lt(10*k) rt(180*k) for i in range(10): rt(10*k) fd(1) rt(70*k) for i in range(5): fd(1) rt(5*k) for i in range(5): fd(1) lt(5*k) for i in range(5): rt(5*k) fd(-1) for i in range(5): lt(5*k) fd(-1) lt(70*k) for i in range(5): lt(5*k) fd(1) rt(90*k) fd(5) fd(-5) lt(90*k) for i in range(5): lt(5*k) fd(1) rt(90*k) for i in range(11): fd(1) lt(8*k) lt(90*k)#remplissage fd(5) pensize(5) lt(40*k) for i in range(6): fd(1) rt(20*k) for n in range(10): fd(1) lt(36*k) for i in range(8): fd(1) lt(10*k) for n in range(10): fd(1) lt(36*k) for i in range(13): fd(1) rt(10*k) for n in range(10): fd(1) lt(36*k) rt(90*k) fd(25) penup() goto(x,y) setheading(90+orientation-90*k) lt(85*k) fd(10) pendown() pensize(5) pencolor([200/255,140/255,140/255]) fd(6)#museau rt(90*k) for i in range(36): fd(1) rt(10*k) lt(90*k) penup() fd(-16) lt(5*k) fd(13) pensize(5) pencolor([255/255,0,0]) pendown() fd(2)#nez rt(90*k) for i in range(20): fd(1) rt(18*k) lt(90*k) penup() fd(9) rt(90*k) fd(4) pensize(3) pencolor([255/255,255/255,255/255]) pendown() lt(90*k) for i in range(3):#blanc oeil fd(1) for i in range(10): fd(1) rt(36*k) penup() pensize(5) pencolor([0,0,0]) fd(-1) pendown() fd(-1)#pupille penup() fd(-1) rt(90*k) fd(11) pencolor([200/255,140/255,140/255]) pensize(3) pendown() fd(1)#creux oreille
def nez_renne(x,y,orientation,couleur): penup() goto(x,y) setheading(orientation+90) fd(14) pensize(5) pencolor(couleur) pendown() rt(90) for i in range(15): fd(1) rt(24) for i in range(20): fd(1) rt(18)
def flocon(x,y,orientation,nb=6,etapes=4): k=5 penup() goto(x,y) setheading(orientation) pendown() pensize(2) pencolor([0,255/255,255/255]) for i in range(nb): for j in range(etapes): fd(k) lt(45) fd(k) fd(-k) rt(90) fd(k) fd(-k) lt(45) fd(-etapes*k) lt(360//nb)
def flocon2(x,y,orientation,nb=6,etapes=4): k=5 penup() goto(x,y) setheading(orientation) pendown() pensize(2) pencolor([0,255/255,255/255]) for i in range(nb): for j in range(etapes): fd(k) lt(45) fd(k) lt(90) fd(3) fd(-3) rt(90) fd(-k) rt(90) fd(k) rt(90) fd(3) fd(-3) lt(90) fd(-k) lt(45) fd(-etapes*k) lt(360//nb)
def flocon3(x,y,orientation,nb=6,etapes=4,angle=30): k=5 penup() goto(x,y) setheading(orientation) pendown() pensize(2) pencolor([0,255/255,255/255]) for i in range(nb): for j in range(etapes): fd(k) lt(45) fd(k) rt(angle) fd(3) fd(-3) lt(angle) fd(-k) rt(90) fd(k) lt(angle) fd(3) fd(-3) rt(angle) fd(-k) lt(45) fd(-etapes*k) lt(360//nb)
def guirlande(x,y,dx,dy,orientation): penup() goto(x,y) setheading(orientation+20) pensize(5) j=0 k=1 while j<dx+dy: for i in range(5): fd(10) rt(8*k) pencolor(choice([[255/255,0,0],[0,255/255,0],[0,0,255/255],[255/255,255/255,0],[255/255,0,255/255],[0,255/255,255/255]])) pendown() fd(1) penup() k=-k j+=12*5
def clignotement(n): for i in range(n): for (x,y,orientation) in [(133,-50,10),(130,60,-30),(-145,25,-30),(-137,-90,-10)]: boule(x,y,10*(2*randint(0,1)-1),5,orientation) nez_renne(175,0,20,[255/255,255/255,0]) guirlande(-117,90,h_liste,0,-90) for (x,y,orientation) in [(133,-50,10),(130,60,-30),(-145,25,-30),(-137,-90,-10)]: boule(x,y,-13,15,orientation) nez_renne(-170,-30,-15,[255/255,255/255,0]) guirlande(103,96,h_liste,0,-90) for (x,y,orientation) in [(133,-50,10),(130,60,-30),(-145,25,-30),(-137,-90,-10)]: boule(x,y,7,22,orientation) nez_renne(175,0,20,[255/255,0,0]) guirlande(-118,86,0,l_liste,0) for (x,y,orientation) in [(133,-50,10),(130,60,-30),(-145,25,-30),(-137,-90,-10)]: boule(x,y,-2*(2*randint(0,1)-1),30,orientation) nez_renne(-170,-30,-15,[255/255,0,0])
cent20, enseignant en Mathématiques et NSI au lycée privé catholique Louis Pasteur à Avignon, a brillamment oeuvré pour que la production de sa classe soit prête dès la date butoir initiale du 7 janvier. Il a en effet demandé à ses élèves de réaliser chacun un petit dessin en DM pendant les vacances de Noël, avec la contrainte qu'il soit compatible avec la bibliothèque turtle de la Graph 90+E. Une fois les DM remis, il lui a suffi de sélectionner les meilleures productions et les intégrer à un unique script. Un grand stratège que ce cent20 !
Ici encore du grand art à la mesure de l'investissement de Casio dans cet événement ; le dessin est encore une fois animé.
cent20 a écrit:Nous sommes le 25 décembre, il est précisément 10h42. Dehors il neige, d'ailleurs le bonhomme de Neige construit par les enfants la veille peut être aperçu à travers la fenêtre. Dans le salon, le feu a été attisé, il illumine la pièce pour permettre aux enfants d'ouvrir leurs cadeaux dans une ambiance chaleureuse. Le père noël, qui est passé la veille, a d'ailleurs oublié son bonnet à côté de la cheminée, mais heureusement il n'a pas oublié les cadeaux qui attendent d'être déballés au pied du sapin. Aujourd'hui, c'est Noël !
Voici pour le détail de la construction de l'animation :
Tout petit léger détail, plusieurs appels turtle.pensize() au sein du script utilisent une épaisseur de crayon supérieure à 5, taille non supportée chez Casio. Dans ce cas à l'exécution, la taille est automatiquement ramenée à 5.
# Participation au Jeu concours de Noël de Casio """ Catégorie Classe : Elèves du Lycée Louis Pasteur d'Avignon Professeurs : Vincent ROBERT, Raphaël CLEMENTE Elèves : 15 élèves citées dans ce document, sous la forme Prénom N. (Le listing complet avec les prénoms et photos des carnets vous sera communiqué sur demande, comme prévu à l'article 6 des modalités de participation.) https://www.casio-education.fr/actualites/jeu-concours-casio-de-noel/ """ # ------------------------------------------------------------
# Un projet de classe avec des objets paramétrables """ Ayant découvert ce concours par sur site tiplanet.org, que nous remercions de diffuser régulièrement les annonces des différents constructeurs de calculatrices, nous avons demandé à nos élèves de programmer en python des "cadeaux de Noël". Plus précisément, après la démonstration en classe de la construction d'un sapin de Noël, ils avaient pour consigne de créer une fonction pour rendre la construction de leur cadeau paramétrable afin que l'on puisse le positionner sur l'écran au coordonnées (x,y) et choisir la taille de l'objet. """ # ------------------------------------------------------------
# Importation des librairies nécessaires # ---------------------------------------------------- from turtle import * from math import *
# Une étoile par Rémi A. # ---------------------------------------------------- def etoile(x, y, longueur, epaisseur, couleur_1=(0.81, 0.06, 0.06), couleur_2=(0.98, 0.93, 0.18)): compteur = int(longueur * 1.1) if compteur > 0: if compteur % 2 == 0: coul = couleur_2 else: coul = couleur_1 penup() goto(x, y) pensize(epaisseur) pencolor(coul) pendown() left(8) speed(0) for repetition in range(5): forward(longueur) left(54) forward(longueur) right(126) right(8) etoile(x + 1.45 * epaisseur, y - 0.5 * epaisseur, longueur - epaisseur, epaisseur + 1, couleur_1, couleur_2)
# Un cadeau ouvert par Rémi A. # ---------------------------------------------------- def ruban(x, y, longueur, epaisseur, couleur=(1.0, 0.89, 0.08)): compteur = int(longueur * 0.2) if compteur > 0: penup() goto(x, y) pensize(epaisseur) pendown() speed(0) pencolor(couleur) for i in range(2): forward(4 * longueur) left(120) forward(longueur / 10) right(60) forward(longueur / 10) left(120) ruban(x + epaisseur, y, longueur - 0.5 * epaisseur, epaisseur, couleur)
# Un cadeau fermé par Raphaël C. """Presque un homonyme de l'enseignant, c'est néanmoins un élève""" # ----------------------------------------------------
def cadeauf(x, y, longueur, epaisseur, couleur_n=(0.44, 0.44, 0.44), couleur_fond=(0.94, 0.06, 0.06), couleur_contour=(0.81, 0.06, 0.06)): speed(0) fond(x, y, longueur, epaisseur, couleur_fond) contour(x, y, longueur, epaisseur, couleur_contour) noeud(x, y, longueur, epaisseur, couleur_n) heart(x, y, longueur) penup() right(225) setheading(0)
# Une bougie par Raphaël C. """Presque un homonyme de l'enseignant, c'est néanmoins un élève""" # ---------------------------------------------------- def rect(x, y, long, epai, couleur_r=(0.66, 0.02, 0.02)): penup() goto(x, y) pendown() long2 = 3 * long pencolor(couleur_r) pensize(epai) for i in range(long // 4): for j in range(4): if j % 2 == 0: forward(long) left(90) else: forward(long2) left(90) long -= 4 long2 -= 4
def c_beige(x, y, long, epai, couleur_c=(1, 0.96, 0.83)): c = long // 3.846 pensize(epai * (long / 67.5)) penup() goto(x + long // 2, y + long * 3.06) pendown() pencolor(couleur_c) while c > 1: circle(c) penup() goto(x + long // 2, y + long * 3.1) pendown() c -= 1
def bord_fla(x, y, long, epai, couleur_bf=(0.94, 0, 0.008)): pensize(epai * (long / 100)) penup() goto(x + long // 1.25, y + long * 3.38) pendown() pencolor(couleur_bf) left(90) circle(long / 0.7, long // 1.25) penup() goto(x + long // 5, y + long * 3.38) pendown() right(40) circle(-(long / 0.7), long // 1.25)
def int_fla(x, y, long, epai, couleur_if=(1, 0.54, 0.08)): penup() goto(x + long // 2, y + long * 3.64) pendown() pensize(epai * (long / 41.6)) pencolor(couleur_if) right(45) circle(long / 8.3)
def int_fla_bleu(x, y, long, epai, couleur_ifb=(0.31, 0.49, 0.82)): penup() goto(x + long // 2, y + long * 3.06) pendown() pensize(epai * (long / 41.6)) pencolor(couleur_ifb) circle(long / 16.67)
def mech(x, y, long, epai, couleur_m=(0, 0, 0)): penup() goto(x + long // 2, y + long * 3) pendown() pencolor(couleur_m) pensize(epai * (long // 250)) left(85) forward(long * 0.5)
def bougie_finale(x, y, long, epai): speed(0) rect(x, y, long, epai, couleur_r=(0.66, 0.02, 0.02)) c_beige(x, y, long, epai, couleur_c=(1, 0.96, 0.83)) bord_fla(x, y, long, epai, couleur_bf=(0.94, 0, 0.008)) int_fla(x, y, long, epai, couleur_if=(1, 0.54, 0.08)) int_fla_bleu(x, y, long, epai, couleur_ifb=(0.31, 0.49, 0.82)) mech(x, y, long, epai, couleur_m=(0, 0, 0)) penup() right(90)
# Un flocon par Ethan G. # ---------------------------------------------------- def flocon(x, y, longueur1, longueur2, epaisseur, angle, couleur): pencolor(couleur) pensize(epaisseur) for i in range(9): penup() goto(x, y) pendown() left(angle) forward(longueur1) left(20) forward(longueur2) backward(longueur2) right(40) forward(longueur2) left(60)
# Une cheminée par Aël D. # ---------------------------------------------------- def flamme(x=0, y=0, taille=100, angle=0, couleur="orange", epaisseur=5): right(angle) pensize(epaisseur) pencolor(couleur) penup() goto(x, y) pendown() for i in range(floor(taille / 2)): forward(i) forward(-i) penup() left(90) forward(1) right(90) pendown() for j in range(floor(taille)): forward(floor(taille / 2) - floor(j / 2)) forward(-(floor(taille / 2) - floor(j / 2))) penup() left(90) forward(1) right(90) pendown() penup() goto(0, 0) right(-angle)
# Une guirlande avec des boules par Gabin P. # ---------------------------------------------------- class Boule: def __init__(self, x, y, t, t_pen=1, col_boule="black", col_carre="black", col_triangle="black"): self.x_abs = x self.y_ord = y self.couleur_boule = col_boule self.couleur_carre = col_carre self.couleur_triangle = col_triangle self.taille = t self.taille_pen = t_pen
def affiche_guirlande(self): pendown() self.boule.affiche_boule() if type(self.boule_suiv) is not Guirlande: penup() else: self.boule_suiv.affiche_guirlande()
def clignotement_guirlande(self, couleur, repetition=2): pendown() sens = 0 temp_self = self while repetition != 0: if sens == 0: self.boule.allume_boule(couleur) temp_self = self self = self.boule_suiv for i in range(9999): pass elif sens == 1: self.boule.eteint_boule() temp_self = self self = self.boule_prec
if type(self) is not Guirlande and sens == 0: sens = 1 repetition -= 1 self = temp_self elif type(self) is not Guirlande and sens == 1: repetition -= 1 self = temp_self sens = 0
# Une fenêtre par le prof, les élèves ayant choisi des items plus complexes il me restait la fenêtre ! # ---------------------------------------------------- def fenetre(x, y, longueur=90, hauteur=80, epaisseur=5, couleur=(155 / 256, 114 / 256, 49 / 256)): penup() goto(x, y) pendown() pensize(epaisseur) pencolor(couleur) for _ in range(2): left(90) forward(hauteur) left(90) forward(longueur) left(180) forward(longueur // 2) right(90) forward(hauteur) setheading(0)
# Une haltère par Marius L. # ---------------------------------------------------- def poids(l, Largeur): for i in range(2): forward(l) left(90) forward(Largeur) left(90)
# Propositions non retenue # ---------------------------------------------------- """ Parfois les élèves ont rendu un dessin non paramétrable, que l'on ne peut pas redimensionner. Ils ont participé leur production n'a juste pas été sélectionné pour le dessin final. """ # Marie L. : Le doudou chien & Le sapin de Noël # Baptiste M : Des boules de noël et un bonhomme de Neige # Thomas V. : Une fleur, une voiture # Raphaël M : Une carte mère d'ordinateur # Margot S. : Des livres multicolores fermés # Maxence H. : Yin-Yang # Adam Y. : Une chausette de Noël
# Assemblage final # ---------------------------------------------------- """ Plusieurs secondes sont requises pour réaliser l'assemblage final. En plus du fichier .py, vous ont été fourni : - Une capture d'écran du rendu final - Une vidéo de la construction sur une calculatrice Casio Graph 90+E - Une vidéo de la scène finale """
_Orlando_ participe en tant qu'élève de collège sur fx-92+ Spéciale Collège. Il place la barre extrêmement haut. En effet :
il dessine pas moins de 7 images différentes, images non constituées de formes géométriques simples
et en prime il accompagne cela de quelques inscriptions
Or le langage ne fournit aucune instruction pour faire cela de façon simple, nous n'avons que les déplacements élémentaires de la tortue, même pas de quoi écrire. Qui plus est la taille maximale du script est de 900 octets, franchement pas beaucoup pour stocker les images, de quoi afficher les images, et de quoi afficher les inscriptions.
En pratique les images monochromes sont codées en binaire, et présentes donc sous la forme de gros nombres au sein même du script.
C'est très hautement impressionnant, aux âmes bien nées la valeur n'attend point le nombre des années, toutes nos félicitations !
Aller à x=-2; y=16 S'orienter à 180 degrés -10→E 54→M 73908999719→A 71030273809→B 7→C Répéter 9 39→D Si x=110 Alors Aller à x=-43; y=E 20→M 330302753020→A 5523528707→B 555001849→C Fin Si x=13 Alors Aller à x=-16; y=2E 189875800049→A 36479286949→B 4251023430→C Fin Si x=40 Alors Aller à x=11; y=E 219707870718→A 439093560256→B 2142255588→C Fin Si x=67 Alors Aller à x=38; y=2E 2097016270→A 138480215461→B 2261852748→C Fin Si x=94 Alors Aller à x=65; y=E 549629726467→A A－151674892→B 134415963→C Fin Si x=121 Alors Aller à x=94; y=2E 22→M 479650820087→A 139988187231→B 4262478351→C Fin Si x=150 Alors Aller à x=7E; y=2E 344638079224→A 274872652131→B 487935→C Fin x→F Répéter 117 Si D=0 Alors B→A C→B 39→D Fin D－1→D A÷2→A Si x<F－M＋2 Alors Aller à x=F; y=y＋2 Fin Avancer de ,6 pixels Si A≠Ent(A Alors Stylo écrit Ent(A→A Fin Aller à x=x; y=y＋1 Avancer de 1 pixels Aller à x=x－,4; y=y－1 Stylo relevé ⤴ Aller à x=F＋56; y=8(y－22 185247487863→A 335875282309→B 1→C ⤴
Et voici maintenant _aubin_ toujours sur fx-92+ Spéciale Collège, visiblement un concurrent très dangereux pour ce dernier.
Afficher des cadeaux sur sa calculatrice, c'est trop concret. Ici encore il nous fait ça à la 'meta' / mise en abyme. Il nous rajoute donc une couche intermédiaire en dessinant sur l'écran de la calculatrice une console Nintendo Switch qui affiche elle-même les cadeaux, sélectionnés tout en finesse pour pour faire plaisir à Casio : calculatrice et dictionnaire électronique EX-Word de la marque ; souhaitons-lui que ce soit remarqué et apprécié. Bon, si tout-le-monde a cru se distinguer pour pour finalement faire pareil, l'originalité commence à se discuter...
Ici encore des images sans formes géométriques simples, et visiblement beaucoup plus détaillées que pour la participation précédente. Mais comment est-ce possible alors que cette dernière frôlait déjà la limite mémoire de 900 octets ?
Comme tu peux le voir, le code est anormalement simple :
Aller à x=－96; y=23 Répéter 662 ? →A Répéter jusqu'à A=0 Si x=96 Alors Aller à x=－96; y=y－1 Fin Avancer de 1pixels A－1→A ⤴ ? →A Répéter jusqu'à A=0 Stylo écrit Si x=96 Alors Stylo relevé Aller à x=－96; y=y－1 Stylo écrit Fin Avancer de ,4pixels Stylo relevé Avancer de ,6pixels A－1→A ⤴ ⤴ Stylo relevé Avancer de 193pixels
C'est qu'_aubin_ s'est montré extrêmement malin pour contourner la limite de 900 octets, diabolique même, les données des images ne sont pas dans le script. Ce dernier demande en boucle à l'utilisateur de saisir les données (un fan de input(), cent20 devrait aimer) et c'est donc à Casio de saisir un par un les nombres de la liste communiquée avec la participation. Voici la liste de nombres qu'_aubin_ nous a communiquée :
Malgré une compression RLE sur 1 bit cela fait quand même pas moins de 1324 nombres différents à saisir un par un en attendant à chaque fois la fin du déplacement de la tortue, espérons pour Casio qu'ils ne sont pas nombreux à avoir usé de cette technique, sinon ils seront encore dessus le mois prochain...
Par contre, si c'est bien cette liste exacte qui a été communiquée à Casio, alors c'est extrêmement dommage car il semble y avoir selon nos tests 2 erreurs faisant différer l'affichage de la photo d'_aubin_ partagée plus haut :
une ligne de données semble manquante, réduisant la hauteur des touches haut/bas du pavé directionnel inférieur gauche de la Switch, ainsi que celle de la rangée de touches correspondante sur la calculatrice
un peu après il semble de plus y avoir un décalage des données d'1 pixel horizontal
C'est extrêmement dommage, et nous sommes bien tristes lorsque nous pensons au nombre d'heures qu'_aubin_ a dû passer là-dessus. Espérons que Casio ne le pénalisera pas trop pour ce détail n'enlevant rien au génie de sa participation...
Comme l'année dernière, le niveau sur fx-92+ Spéciale Collège reste très élevé ; c'est fantastique tout ce que l'on peut réaliser avec cette petite machine.
Mais mieux que l'année dernière, tous ceux qui ont bien voulu partager leurs créations sur Graph 90+E jusqu'à présent (et ça fait déjà beaucoup) se sont visiblement donné à fond, désintégrant littéralement les limites de ce qui avait pu être réalisé jusqu'alors en Python sur cette machine !
Nous trouvons que la chose est à la mesure des gros efforts consentis par Casio en dotation pour ce concours, et espérons que ces derniers sont également satisfaits de ce qu'ils ont reçu.
Après de longs mois de dur labeur, nous sommes fiers et heureux de vous annoncer la sortie ce jour du GUI Toolkit NF pour TI Nspire CX/CX II (CAS) et PC en version 1.0Alpha.
Le GUI Tool...Quoi ?!? GUI Toolkit NF ?!? Mais kézako ?!?
Et bien, c'est simple : il s'agit d'une bibliothèque de classes C++ permettant de développer très rapidement des applications graphiques sur Nspire (avec Ndless) et sur PC en utilisant des contrôles graphiques (Widgets), tels que des boutons, des listes déroulantes, des cases à cocher, des menus, etc. Soit en gros, être capable d'avoir ça en un minimum de temps fonctionnant à la fois sur une TI Nspire ou sur un PC, juste en recompilant le programme et sans intervenir dans le code, la librairie se chargeant de gérer la création de l'exécutable dédié à la plateforme ciblée à la compilation :
Les TI Nspire CX/CX II sont de formidables machines, mais force est de constater qu'elles souffrent d'une grosse limitation concernant les langages de programmation Basic/Python. En effet, les fonctions de création d'interfaces homme-machine sont totalement absentes et il donc est particulièrement laborieux de créer des outils avec une belle interface de manière rapide.
Partant de ce constat, le projet GUI Toolkit a été initié en Février 2021 et visait à créer une bibliothèque (from scratch) permettant de combler ce manque pour des programmes écrits en C/C++ avec Ndless.
Le cahier des charges initial était alors relativement simple :
Offrir au programmeur une collection de contrôles graphiques lui permettant de coder rapidement des logiciels graphiques
Etre le plus simple possible à utiliser, via des appels à des fonctions au nom évocateur (In english of course, pour ne pas être trop limitatif)
Etre écrite en C/C++ sur la base de la toolchain Ndless pour offrir une ouverture du projet et une bonne rapidité d'exécution.
Une première version prototype a été écrite durant les premiers mois du printemps 2021, mais souffrait elle aussi de quelques limites fonctionnelles, notamment du fait de l'impossibilité de débugguer facilement les programmes destinés aux Nspire CX-II (pas d'émulation type Firebird disponible pour la Nspire CX II).
Une réflexion a donc conduit à la refonte du projet pour devenir le projet GUI Toolkit NF, NF signifiant "New Foundation" (Nouvelle Fondation pour les non-anglophones), offrant en prime la possibilité de faire tourner les applications destinées à la TI Nspire (et écrites avec le Toolkit bien évidemment) sur PC par une simple re-compilation (pas ré-écriture, c'est important) du code. Les bibliothèques du GUI Toolkit NF se chargeant de faire la traduction au niveau du matériel de manière totalement transparente pour l'utilisateur (le programmeur).
Ainsi, il devient très aisé de créer un programme et de le debugguer efficacement sur un PC avec les outils classiques (GCC/GDB/SDL/Valgrind ...), puis une fois fonctionnel et validé, de recompiler le programme pour une Nspire sans changer une seule ligne de code.
Un petit exemple de programme démo réalisé avec le GUI Toolkit NF, ne faisant certes rien d'utile, mais illustrant les possibilités du Toolkit et fonctionnant sur PC fait l'objet d'une courte vidéo ici :
Mais quel contenu offre le Toolkit ? Et que peut-on faire avec ?
Le toolkit offre un ensemble de classes C++ (donc nécessitant Ndless fonctionnel sur Nspire, attention donc au Firmware installé sur la machine) permettant de coder des applications graphiques. Du point de vue de l'utilisateur, il s'agit de divers Widgets dont un certain nombre sont visibles dans les screenshots suivants et permettant d'interagir avec le programme :
Boutons et cases à cocher :
[o] Boutons textuel [o] Bouton avec icone [o] Case à cocher [o] Bouton Radio [o] Bouton "Slider" [o] ...
Entrée d'informations :
[o] InputBox pour entrée de valeurs/text [o] Multiline Text Box pour entrée d'un texte long [o] Multiline Rich Text Box pour entrée d'un texte long avec mise en forme [o] ...
Menus :
[o] Barre de menus avec possibilité de faire des sous-menus [o] Barre d'icones [o] ...
Fenêtres et dialogbox :
[o] Fenêtres redimensionnables/déplaçables [o] DialogBox non redimensionnables [o] FileDialogBox pour selectionner/naviguer dans les fichiers/répertoires [o] ...
Contexte graphique :
[o] visualisation d'images [o] dessins et rendu de primitives graphiques [o] SplashScreen pour le début d'un programme [o] ...
... et bien plus encore ...
Les applications peuvent contenir de multiples bureaux (correspondant chacun à un écran) et pouvant être facilement "switchés", il devient alors possible d'avoir des programmes avec de multiples fenêtres affichées simultanément soit sur le même bureau ou si cela est plus simple visuellement, d'avoir une fenêtre par bureau et de changer de bureau pour commuter l'affichage. Chaque bureau pouvant avoir son propre fond d'écran.
Le positionnement des Widgets dans une fenêtre par exemple ainsi que leur taille pouvant être statique, c'est à dire définis par le programmeur au départ et immuables, ou bien au contraire gérés dynamiquement par le Toolkit moyennant quelques contraintes (répartition homogène de l'espace ou taille imposée) afin de correctement se repositionner lors du redimensionnement de la dite fenêtre.
Mais le rôle du Toolkit ne s'arrête pas là, et du point de vue du Toolkit, beaucoup de choses supplémentaires sont intégrées. En effet le Toolkit embarque un certain nombre de fonctionnalités supplémentaires, dont certaines ont fait l'objet d'un Fork indépendant appelé lib nSpireLTE pour aider à programmer sur Nspire toute sorte d'applications.
Ces fonctionnalités supplémentaires sont constituées d'un ensemble de classes permettant de gérer le niveau d'abstraction matérielle pour permettre de fonctionner à la fois sur PC et sur Nspire sans avoir besoin de recoder quoi que ce soit :
KeyManager : contenant les fonctions de bas niveau permettant de lire l’état du clavier de la TI Nspire et/ou du PC (avec gestion de l'état des touches pressée ou non à un instant "t", venant d'être appuyée ou venant d'être relâchée )
MouseManager : contenant les fonctions de bas niveau permettant de lire l’état du touchpad de la TI Nspire (mouvement du curseur, click central et gestion des flèches) ou de la souris sur PC
TimeManager : permettant de gérer les fonctions liées au temps sur la Nspire (timer, sleep, heure actuelle)
Debugger : permettant de debugger des programmes en offrant un panel de fonctions pour réaliser des sorties de logs dans un fichier et tracker impitoyablement les bugs et plantages.
Ainsi qu'un "ramasse miettes" (ou GarbageCollector) permettant de contrôler l'absence de fuite de mémoire au niveau des Widgets gérés par le Toolkit. Cet élément étant totalement transparent, sans intervention de l'utilisateur, chaque Widget se déclare de manière autonome lors de sa création afin d'être effacé proprement à la fin du programme.
Mais il ne faut pas non plus oublier d'autres petits trucs sympas:
FontEngine : permettant de faire le rendu de polices de caractères (avec 6 polices intégrées et la possibilité d'avoir des polices utilisateurs supplémentaires)
ColorEngine : Permettant la gestion des couleurs des Widgets
ThemeEngine : Permettant d'avoir un thème graphique pour une application donnée (Fontes de caractères et couleurs de Widgets)
Toute la mécanique étant gérée par une "super classe" (appelée WidgetApplication) et permettant de faire office de chef d'orchestre et de gérer les divers événements (clicks sur les Widgets, mouvements de fenêtre, appuis des touches, ...).
Il devient alors très simple de récupérer l'information de réalisation d'un événement (par exemple savoir si on a cliqué sur un bouton, ou si une CheckBox est cochée) et d'ajuster le comportement du programme en conséquence.
Comme vous l'aurez compris, il est malheureusement compliqué de ne rien oublier, s'agissant d'un gros projet, qui plus est dont le développement n'est pas clos. Beaucoup de nouvelles fonctionnalités et de nouveaux Widgets seront notamment à développer, à ajuster et/ou à ajouter au fil du temps dans de futures révisions, nous ne pouvons donc qu'effleurer la surface des possibilités offertes à travers cette news de sortie ...
Mais ce n'est que partie remise, puisqu'il est prévu de créer un fil spécifique sous forme de mini-tutoriels (avec pourquoi pas des vidéos didactiques) permettant d'illustrer la réalisation d'applications avec le GUI Toolkit NF.
La version courante du GUI Toolkit NF fait très régulièrement l'objet de "commits" sur GitHub ici : GitHub GUI Toolkit NF.
La phase de développement du Toolkit étant désormais suffisamment avancée, une plus grosse quantité d'énergie pourra être consacrée à sa mise en pratique pour coder des applications pour Nspire ... La documentation détaillée est aussi en cours de réactualisation de manière à bien refléter l'avancement de la version NF. Il s'agit là encore d'un gros chantier qui va avancer dans les semaines à venir, un tel projet n'étant pas très utile sans une bonne documentation sur laquelle se baser pour coder des applications.
Alors surtout n'hésitez pas à faire remonter vos idées, vos bugs, vos tests via TI Planet ou via GitHub.
So stay tuned ... More to come (very) soon
Tutoriels vidéo de mise en pratique du GUI Toolkit NF
(Cette liste sera mise à jour au fur et à mesure de leurs sorties.)
Aux épreuves orales du concours de recrutement des enseignants de Mathématiques (CAPES), la forme adoptée pour l'évaluation des compétences numériques a déjà subi plusieurs évolutions techniques majeures cette dernière décennie.
On peut découper la chose en 3 phases :
Jusqu'à la session 2010 incluse, les candidats souhaitant exposer leurs compétences numériques dans le cadre du sujet, le faisaient sur calculatrices graphiques. La calculatrice personnelle n'était pas autorisée, mais différents modèles de calculatrices étaient mis à disposition des candidats dans la salle de préparation, et des tablettes de rétropojection adaptées à chaque modèle étaient disponibles dans la salle du jury. Les grands constructeurs de calculatrices graphiques faisaient livrer gracieusement le matériel (calculatrices et tablettes) par camions entiers sur le site des épreuves, de façon très assidue chaque année dans le cas de Casio et Texas Instruments, de façon plus épisodique concernant Hewlett Packard.
À compter de la session 2011, plus de calculatrice graphique. Les candidats disposaient directement d'un ordinateur sous Windows dans la salle de préparation, avec un ensemble de logiciels préinstallés. Un ordinateur disposant du même ensemble de logiciels et connecté à un vidéoprojecteur était disponible dans la salle du jury, et les fichiers conçus par le candidat y étaient transférées par le réseau en fin de préparation.
Nouveau gros changement à partir de la session 2018, les candidats ne travaillent plus sous Windows mais sur CAPESOS, un système d'exploitation Linux embarqué sur clé USB, clé USB que les candidats recevaient en début de préparation et emportaient eux-mêmes dans la salle du jury.
À noter que, dans un premier temps, les calculatrices n'ont pas disparu suite à la session 2011. En effet les logiciels d'émulation de calculatrices des différents constructeurs ont pris le relais et étaient installés sur chaque ordinateur.
Le jury effectuait et annonçait chaque année la sélection de logiciels mis à la disposition des candidats.
Nous avons bien de la sympathie envers le système embarqué libre CAPESOS, mais il nous faut bien remarquer que son introduction s'est accompagnée d'un appauvrissement très significatif de l'offre logicielle.
Pire encore, pour cette année 2022 le jury allait encore plus loin dans l'extrême et annonçait :
la suppression de Xcas, dernier logiciel de Mathématiques intégré de la liste, alors que décliné sur nombre de modèles de calculatrices graphiques (TI-Nspire CX II, TI-Nspire CX, NumWorks, Casio Graph 35+E II et Graph 90+E), permettant de réunir les utilisateurs de différents modèles et même marques devant une interface unifiée et des fonctionnalités haut de gamme, et devenant ainsi une référence pour de plus en plus d'enseignants, élèves et futurs enseignants en France et de par le monde
de façon absolument indéfendable, la suppression de l'émulateur TI-83 Premium CE alors que l'émulateur NumWorks était conservé, et ce alors que ce dernier ne conserve pas la saisie à la fermeture et est donc contrairement au premier d'une utilité extrêmement discutable pour les candidats
Aujourd'hui à 4 mois et demi du lancement des épreuves, la page du jury est mise à jour avec un changement majeur.
Pas de correction de la liste logicielle, mais par contre nous apprenons que pour la session 2022 les candidats seront à nouveau évalués sur environnement Windows, comme jusqu'à la session 2017 donc.
Jury a écrit:Ressources mises à disposition des candidats Pour l'épreuve de leçon, le candidat bénéficie pendant le temps de préparation et lors de l’interrogation du matériel informatique mis à sa disposition.
Les candidats ne sont pas autorisés à utiliser de calculatrice. Le transfert des données entre la salle de préparation et la salle d’interrogation se fait grâce au réseau de l'établissement ou éventuellement au moyen d’une clé USB fournie par le jury. L’utilisation de tout support numérique personnel est exclue. L’usage des téléphones mobiles et de toute forme d’accès à internet est interdit dans l’enceinte de l’établissement.
Pour la session 2022, les candidats bénéficieront des ressources suivantes sous environnement Windows.
Logiciels
LibreOffice
Emulateur de calculatrice numworks
Geogebra 5
Python 3 (éditeur Pyzo avec les bibliothèques numpy, scipy et matplotlib)
Scratch 3
Les documents suivants sont mis à disposition des candidats sous forme numérique :
réglementation du concours ;
référentiel des compétences professionnelles ;
programmes de Mathématiques (collège, lycée et sections de technicien supérieur) et documents ressources en ligne sur Eduscol.
Ce qui semble indiquer l'abandon du système embarqué CAPESOS. Peut-être que l'explication de ce retour en arrière ainsi qu'au passage de toutes les choquantes anomalies de ces dernières années, était tout simplement que le jury n'a pas pu disposer en quantité suffisante des ressources matérielles ou humaines permettant de faire vivre et évoluer correctement le système embarqué CAPESOS, et nous ne pouvons que trouver cela extrêmement dommage.
En tous cas, maintenant que l'on retourne sous Windows et devant l'imminence des épreuves, nous attendons une mise à jour correcte de la liste des logiciels au plus tôt ; il n'y a plus aucune raison technique de continuer à ne pas traiter les différents fournisseurs de logiciels à égalité, et ce tout particulièrement lorsqu'ils sont concurrents.
Dans une série d'articles précédents nous te présentions img2calc, notre service en ligne gratuit sur TI-Planet te permettant de convertir facilement tes images pour tes projets sur calculatrices.
Un large choix de formats cible t'était proposé :
fichiers à appeler depuis tes programmes en langage Basic :
ti_graphics(TI-83 Premium CE et TI-84 Plus CE éditions Python)
casioplot(Casio Graph 90/35+E II, fx-9750/9860GIII et fx-CG50)
hpprime(HP Prime)
kandinsky(NumWorks)
Nous allons revenir aujourd'hui sur la conversion en images .8ci pour tes programmes en langage TI-Basic sur calculatrices couleur TI-82 Advanced Edition Python, TI-83 Premium CE, TI-84 Plus CE et TI-84 Plus C Silver Edition.
Nous nous baserons le long de cet article sur les images d'exemple ci-contre.
Avant d'aborder la couleur, rappelons que le format d'image .8ci est une évolution des formats d'image monochromes. On pouvait distinguer :
les .85i et .86i en 128×63 pixels indexés pour les modèles à écran monochrome 128×64 pixels (TI-85 et TI-86)
les .73i, .82i, .83i et .8xi en 96×63 pixels indexés pour les modèles à écran monochrome 96×64 pixels (TI-73, TI-82, TI-83, TI-84)
Il s'agissait d'un format d'image indexé selon une palette fixe de 2 couleurs :
noir
transparent
Les images transparentes ainsi converties étaient donc des images de premier plan, c'est-à-dire que l'instruction RclPic(RappelPic en Français) les affichait devant la fenêtre graphique.
Des spécifications parfaitement respectées par img2calc comme illustré ci-contre.
Avec les modèles couleur à écran 320×240 pixels nous avions deux formats d'images à distinguer pour les programmes TI-Basic, tous deux supportés par img2calc :
.8ci, images de premier plan en 265×165 pixels indexés
.8ca, images d'arrière plan en 134×83 pixels RGB-565
Les images .8ca étaient donc des images d'arrière plan, c'est-à-dire affichées derrière la fenêtre graphique. À la particularité qu'elles étaient affichées avec un facteur zoom de 2 sur 265×165 pixels, la dernière colonne de pixels tout à droite de l'image étant ainsi invisible et laissée en blanc par img2calc.
Le format d'image .8ci était pour sa part l'évolution des formats monochromes précédemment décrits.
Il s'agissait d'un format d'image indexé selon une palette fixe de 16 couleurs :
bleu
rouge
noir
magenta
vert
orange
marron
bleu marine
bleu clair
jaune
blanc
gris clair
gris moyen
gris
gris foncé
transparent
Les affichages sur la fenêtre graphique des TI-83 Premium CE et compatibles étaient donc réalisés sur 3 calques ou couches :
l'arrière plan en 65536 couleurs mais peu précis à cause du zoom ×2
la couche intermédiaire en seulement 15 couleurs fixes pour le tracé des axes, graphiques et diagrammes
le premier plan en seulement 15 couleurs fixes pour le dessin de différents objets (images, segments, cercles, textes, points, pixels...)
Combiner avec talent ces différentes couches te permettait de réaliser en langage TI-Basic des projets graphiques hautement impressionnants, et ce malgré les limitations spécifiques à chacune des couches, la combinaison rendant justement ces limitations moins visibles.
Sauf que problème remarqué et signalé par DJ Omnimaga, légende vivante de la communauté des calculatrices TI. Bien que le cas était censé être supporté par img2calc, si tu fournissais des images transparentes à convertir en .8ci, la transparence était hélas perdue lors du processus et remplacée par du blanc.
Ce qui masquait donc systématiquement à l'affichage les couches intermédiaire et d'arrière plan, et t'empêchait d'exploiter toutes les possibilités graphiques du langage TI-Basic.
Aujourd'hui img2calc fait l'objet d'une mise à jour corrigeant ce bug.
Te voilà enfin capable d'exploiter avec img2calc toutes les possibilités des différentes couches graphiques de l'édition couleur du langage TI-Basic ! Nous avons hâte de découvrir tes créations...
Tous nos plus sincères remerciements à DJ Omnimaga sans qui cette mise à jour n'aurait pas été possible.
Quand Texas Instruments sort sa première calculatrice graphique TI-81 pour la rentrée 1990, celle-ci ne disposait pas d'un port de communication. Les programmes devaient être saisis intégralement à la main, et comme il n'y avait aucune possibilité de les sauvegarder tu devais tout retaper en cas de perte de mémoire. Pareil pour le modèle successeur TI-80 de la rentrée 1995.
Mais à compter de la rentrée 1992 avec la vénérable TI-85, tous les autres modèles ont disposé d'un port de communication série dérivé du mini-Jack 2.5mm, appelé aussi I/O "DBUS".
Texas Instruments a depuis amorcé un changement de connectique, adaptant progressivement ses modèles à la technologie USB.
Tout a donc commencé à la rentrée 2004 avec les nouvelles TI-84 Plus et TI-89 Titanium. Ces modèles reprenaient le port mini-Jack 2.5mm historique, mais disposaient également d'un 2ème port USB mini-AB.
Par la suite, Texas Instruments nous a donné plusieurs signes indiquant que le projet était à terme d'abandonner le port mini-Jack 2.5mm historique.
Du côté du haut de gamme nous arrivent à la rentrée 2007 les premières TI-Nspire. La TI-Nspire CAS ne disposait déjà plus de ce port.
La TI-Nspire par contre en disposait toujours mais uniquement via un clavier amovible pour le mode d'émulation TI-84 Plus.
Rentrée 2010 sort le successeur TI-Nspire TouchPad. Nouveau mauvais signe, le clavier amovible TI-84 Plus avec le port série n'était plus fourni avec la calculatrice, et les acheteurs devaient fait la démarche de le demander auprès de Texas Instruments.
Dès la rentrée 2011 arrivent les successeurs couleur TI-Nspire CX(TI-Nspire CM en Chine), qui pour le coup abandonnent définitivement l'émulation TI-84 Plus avec ce système de clavier amovible, et donc également le port série qui allait encore avec.
Du côté de l'entrée et du milieu de gamme maintenant, Texas Instruments sort à la rentrée 2015 de nouveaux modèles disposant d'un mode examen à diode.
Nous avons la TI-84 Plus CE(TI-83 Premium CE en France) avec un tout nouveau matériel ne dispose plus que du seul port mini-USB.
En France maintenant, nous avons un nouveau modèle d'entrée de gamme, la TI-82 Advanced. Celle-ci reprenait par contre le matériel TI-84 Plus mais sans le port série, ce dernier étant justement remplacé par la diode examen.
Rentrée 2016, Texas Instruments faisait exactement pareil aux Pays-Bas avec la nouvelle TI-84 Plus T.
N'étant désormais plus conformes à la réglementation, dans le même temps la commercialisation des TI-84 Plus a cessé dans ces pays.
Toutefois la TI-84 Plus est toujours fabriquée par Texas Instruments et reste commercialisée dans l'ensemble des pays n'exigeant pas (encore ?) de mode examen à diode, soit en gros dans tout le reste du monde.
La TI-84 Plus continue à évoluer et bénéficier de révisions matérielles régulières. On peut citer depuis sa disparition en France et aux Pays-Bas :
Z(octobre 2013)
AA(mars 2014)
AB(avril 2015)
AC(juin 2017)
AD(juillet 2018)
AE(novembre 2019)
Nous apprenons aujourd'hui la sortie d'une toute nouvelle révision matérielle AF de la TI-84 Plus.
Nous nous y attendions depuis un moment et nous y sommes enfin, cette révision supprime le port série mini-Jack 2.5mm historique. C'est-à-dire que l'ensemble des périphériques nécessitant ce port seront totalement inutilisables avec ces nouvelles TI-84 Plus(interfaces d'acquisition dont TI-CBL2 et Vernier LabPro, clavier TI-Keyboard, module vocal Orbit Research Orion, ...).
Une nouvelle révision matérielle qui supprime un élément et permet ainsi à Texas Instruments de réduire les coûts de production ; que l'on peut donc rapprocher de la suppression très récente de la diode de charge sur les TI-83 Premium CE et TI-84 Plus CE. Dans la crise économique mondiale qui succède actuellement à la crise sanitaire, voilà peut-être à nouveau de quoi permettre à Texas Instruments de ne pas trop augmenter ses prix.
Merci à Inkling pour le lien et mr womp womp pour nous avoir donné l'info
Problème, TI-Boy CE n'émule que la console de jeux Game Boy monochrome de 1989. Les jeux sortis pour son évolution Game Boy Color à compter de 1998, ne sont donc pas compatibles.
Et pour Mario Kart c'est encore pire, puisque sur consoles portables il a fallu attendre la Game Boy Advance de 2001.
Dans une actualité précédente, nous t'annoncions que tr1p1ea relevait malgré tout le défi de faire tourner Mario Kart sur ta calculatrice.
Ne pouvant passer par l'émulateur TI-Boy CE ni espérer un émulateur de Game Boy Advance pour le moment, l'idée était donc de reconstruire intégralement le jeu Mario Kart à partir de zéro !
Son jeu Mario Kart CE est compatible avec les TI-83 Premium CE(ainsi que leurs équivalents TI-84 Plus CE hors de France).
Attention, pas de compatibilité avec la TI-82 Advanced Edition Python, ne confonds pas si tu comptes t'équiper prochainement !
Tu affrontes donc 5 IAs (Intelligence Artificielle) pilotant les voitures concurrentes, et les touches sont les suivantes :
entrer
pour choisir entre les 8 personnages jouables issus de l'univers de Super Mario
alpha
pour lancer des carapaces sur tes adversaires
↓
pour freiner et reculer
←
→
pour tourner
2nde
pour accélérer
Des obstacles sont présents ainsi que des blocs bonus, mais pour ces derniers non encore fonctionnels.
Le circuit pour le moment unique adapte le 1er circuit de la Mushroom Cup du jeu pour Nintendo SuperNES, tu as ci-contre de quoi comparer.
Pour le moment le jeu n'a pas de fin.
Problème, Mario Kart CE n'était pas compatible avec la dernière mise à jour 5.7 des TI-83 Premium CE et TI-84 Plus CE sortie en novembre dernier. Et sur ces modèles, une fois une mise à jour effectuée, il ne t'est plus possible de revenir à une ancienne version.
Si tu avais mis à jour suite à cette nouvelle version, depuis maintenant 3 mois il t'était donc impossible de jouer à Mario Kart CE.
Plus précisément Mario Kart CE utilisait une faille unlock (tout comme Cesium) afin de pouvoir utiliser des zones mémoires plus rapides. Or, depuis la mise à jour système 5.5.1, à chaque fois qu'un programme exploitant une faille de type unlock est publié, Texas Instruments colmate la faille associée de façon systématique dans sa mise à jour système suivante.
Le problème était donc en fait bien plus conséquent : a priori toute future mise à jour du système allait nécessiter une mise à jour de Mario Kart CE, si tant est qu'il reste encore quelque faille de type unlock à exploiter, car à force d'en griller...
Et bien surprise. Pour t'offrir des vacances d'hiver des plus agréables, tr1p1ea te sort enfin aujourd'hui une mise à jour Mario Kart CE compatible avec la dernière version 5.7 !
Plus exactement il a réussi à se passer des failles unlock au prix de quelque compromis sur les performances, c'est-à-dire que le jeu n'aura a priori plus besoin d'être mis à jour pour chaque future version système de Texas Instruments !
Attention, Mario Kart CE rentre dans la catégorie des programmes en langage machine dits ASM.
Or, suite à un acte irresponsable d'un enseignant de Mathématiques français avec ses gesticulations aveugles dans le contexte de la réforme du lycée et aux conséquences qui auraient pu être extrêmement graves pour le constructeur, 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
Difficile de passer à côté en fait, c'est visible dès l'écran d'accueil tel un pot aux roses, l'application Equations a été renommée en Solveur, ce qui suggère que NumWorks poursuit donc avec une nouvelle métamorphose.
Et bien voilà justement, l'application sous son nouveau nom de Solveur devient une application deux-en-un. Dès l'ouverture, un nouveau menu te donne le choix entre :
Et bien excellente surprise dès l'écran suivant, ici sur NumWorks on peut bien résoudre l'équation pour n'importe lequel de ses paramètres. C'est-à-dire que le choix Intérets simples permet de résoudre pas moins de 4 questions types différentes.
Une entrée supplémentaire nous permet de plus de choisir entre l'année civile et l'année lombarde, pas besoin d'aller la trouver et configurer sur un autre écran contrairement à certains modèles concurrents.
Enfin, pour les problèmes d'Intérêts composés, la NumWorks est capable de résoudre 5 questions types.
Ca fait toujours plaisir 
