TI-Planet | News

de **critor** » 08 Déc 2020, 00:00

Le mode examen des calculatrices graphiques désormais en application en France est un véritable scandale.
Avant tu pouvais améliorer gratuitement les capacités de n'importe quel modèle de calculatrice, même de milieu ou d'entrée de gamme, en lui rajoutant des programmes ou applications téléchargés chez nous ou ailleurs.
Nous n'allons pas retracer ici plusieurs décennies de création bénévole bien souvent avec code source ouvert et libre, mais on peut citer parmi les dernières pépites KhiCAS pour TI-Nspire, NumWorks, Casio Graph 35+E II et Graph 90+E.
Maintenant seules les fonctionnalités du constructeur de la machine sont utilisables en examen et l'unique façon d'en avoir davantage si tu trouves qu'il te manque quelque chose est de payer, payer pour le modèle plus cher.

Une grave atteinte aux droits des utilisateurs et des développeurs, mais également à l'égalité des candidats devant l'examen.

Curieuse chose que de vouloir ainsi tout contrôler et interdire au pays de la liberté et de l'égalité, surtout lorsque la réglementation en question génère encore plus d'inégalités...

Dans l'État d'Australie-Méridionale (SA - South Australia), l'institution scolaire s'est déjà penchée sur la question des données dans les calculatrices, et a montré que la réponse pouvait être autre chose qu'un mode examen punissant tout-le-monde.
La réglementation du certificat d'éducation de l'Australie du Sud (SACE - South Australian Certificate of Education) qui est même suivie par d'autres états australiens ainsi que des écoles dans d'autres pays, n'autorise que certains modèles de calculatrices graphiques, reproduits ci-contre depuis la session 2011.

Les calculatrices autorisées y sont choisies selon plusieurs critères, entre autres :

pas de capacités de calcul formel (CAS - Computer Algebra System)
pas de connecteur dédié à la connexion d'une mémoire externe (lecteur de carte SD)

Mais surtout, tu peux remarquer que les modèles Casio autorisés aujourd'hui sont spécifiques à l'Australie.

La fx-9860G AU sortie en 2006 est comparable au modèle international fx-9860G de 2005 (Graph 85 en France).
Seule différence, sa mémoire de stockage en Flash n'a pas 1,5 Mio de capacité mais seulement 800 Kio.

En effet, la réglementation du SACE autorise parfaitement l'utilisation de la mémoire de la calculatrice par les candidats. Mais afin de gommer les inégalités, elle fixe une capacité maximale.
La limite se situant visiblement à l'époque entre 800 Kio et 1,5 Mio, Casio a donc sorti pour l'Australie la fx-9860G AU avec ainsi une mémoire de stockage de capacité réduite.

Tous les candidats disposent de la sorte du même espace mémoire qu'il leur appartient de remplir comme bon leur semble. A eux de décider si il vaut mieux y mettre des programmes et applications rajoutant des fonctionnalités, ou bien des formulaires et documents PDF. Une façon très saine de les responsabiliser.

Cette limite a depuis été revue à la hausse pour passer à 5 Mio.

Casio en profite donc pour sortir en 2006 la fx-9860G AU Plus, cette fois-ci offrant bien 1,5 Mio de capacité de mémoire de stockage comme le modèle international fx-9860GII (Graph 75 en France).

En 2016, Casio sort la fx-CG20AU. Ici le modèle international fx-CG20 offre 16 Mio de capacité de stockage. C'est donc ce point qui diffère sur la fx-CG20 AU, avec seulement 4,5 Mio.

En 2018, Casio sort la fx-CG50AU. Même différence ici avec le modèle international fx-CG50 (Graph 90+E en France), on passe de 16 Mio à 4,5 Mio d'espace de stockage.

Mais pourquoi Casio s'est-il contenté d'offrir 4,5 Mio d'espace de stockage sur sa fx-CG50 AU et non le maximum autorisé de 5 Mio ?

Nous avions déjà vu que les Graph 90+E et fx-CG50 utilisaient une puce S99-50272 de chez Spansion offrant une mémoire Flash de 32 Mio.

Sur cette Flash nous avions donc 2 partitions :

une de 16 Mio pour l'espace de stockage
et une de 16 Mio réservée au système d'exploitation ainsi qu'à son code amorce

Or, les images de mise à jour contenant le système d'exploitation et le code amorce envoyées à la calculatrice, ne font que 11,3 Mio une fois décompressées.
Et 11,3+4,5 = 15,8 Mio, soit un peu moins de 16 Mio, alors que 11,3+5 = 16,3 Mio.

Nous pensions donc que Casio avait souhaité que l'ensemble puisse tenir dans une puce Flash de 16 Mio de capacité, afin d'économiser un petit peu sur l'assemblage des fx-CG50 AU.

MajesticFalcon35 a creusé la question avec sa fx-CG50 AU.

Grosse surprise, un logiciel de partitionnement détecte 11,5 Mio d'espace inutilisé et autorise le redimensionnement l'espace de stockage de 4,5 Mio à 16 Mio de capacité.

En pratique tricher avec la réglementation australienne n'est bien évidemment pas aussi simple, la calculatrice signalant après l'opération une erreur de système de fichier et réinitialisant le tout aux capacités d'origine.

Mais le fait que l'opération soit détectée comme réalisable semble indiquer que la fx-CG50AU utilise finalement une puce Flash de 32 Mio, exactement comme les fx-CG50 et Graph 90+E.

Nous en aurons le coeur net, nous avons demandé à MajesticFalcon35 d'ouvrir sa calculatrice. Et effectivement, on y trouve bien la même puce Spansion S99-50272 de 32 Mio de capacité !

La fx-CG50AU dispose finalement donc de 32 Mio de mémoire Flash, et est donc matériellement parlant elle aussi parfaitement capable d'exploiter un espace de stockage de 16 Mio. C'est un autre verrou logiciel ou matériel qui bride artificiellement sa capacité à 4,5 Mio.

Source : https://www.casiopeia.net/forum/viewtop ... 140#p21116

de **critor** » 09 Déc 2020, 03:16

Enseignant de matière scientifique en collège ou lycée, Casio t'a préparé un superbe concours pour fêter malgré tout Noël 2020.

Il te suffit de réaliser un superbe dessin de Noël sur ta calculatrice Casio ou son émulateur associé que nous remettons si besoin à ta disposition en fin d'annonce.

Tu peux participer au choix dans les 2 catégories suivantes :

fx-92+ Spéciale Collège avec son application Algorithmique t'offrant un langage de tracé à la Scratch/Logo
Casio Graph 35+E II ou Graph 90+E avec son application Python

Attention pour pouvoir bénéficier des tracés en Python (module casioplot), ta calculatrice doit faire tourner une version suffisamment récente :

Graph 35+E II versions 3.30+
Graph 90+E versions 3.40+

Si ce n'est pas le cas nous te remettons de quoi mettre à jour gratuitement dans nos ressources en fin d'annonce.

Dans chacune des 2 catégories, le meilleur dessin gagne le superbe lot suivant d'une valeur d'environ 180€ :

1 disque dur externe SSD de 1 To de capacité + 1 calculatrice graphique Casio au choix

Le 2^ème meilleur dessin gagne pour sa part le non moins superbe lot suivant d'une valeur d'environ 150€ :

1 enceinte bluetooth + 1 calculatrice graphique Casio au choix

La calculatrice graphique au choix pourra être une Graph 35+E II ou Graph 90+E.

Mais ce n'est pas tout, avec Casio pas de perdant. Tous les autres participants recevront un lot de participation :

1 batterie externe + 1 clé USB

Tu as jusqu'au mardi 15 décembre inclus pour envoyer par courriel à education-france@casio.fr :

la capture d'écran de ton dessin
ainsi que le script associé

Tu peux participer en ton nom, ou soumettre le sujet à ta classe et envoyer ensuite la production que tu estimes être la meilleure.

Et si tu sièges du mauvais coté du bureau en classe, rien ne t'empêche de créer ton dessin de Noël de ton côté, puis de demander à ton prof d'envoyer ta participation.

Tu manques d'inspiration ? Tu ne connais pas assez la calculatrice ?

Casio se propose même de t'aider à gagner en t'accompagnant ce mercredi 9 décembre au cours de 2 ateliers en ligne au choix tout spécialement dédiés aux dessins de Noël sur ses calculatrices :

14h-14h45 : appli Algorithmique sur fx-92+ Spéciale Collège
15h-15h45 : appli Python sur Graph 35+E II et Graph 90+E

Ils correspondant donc bien aux 2 catégories de participations, et en voici même un petit aperçu :

Peut-être te demandes-tu en passant comment joindre le script de ta fx-92+ Spéciale Collège alors que la machine ne dispose pas de port de communication ?... mais en fait rien de plus simple !

Que tu utilises la calculatrice ou son émulateur il te suffira juste d'en exporter le contenu à l'aide d'un QR Code :

obtenir la sauvegarde du contenu sous forme de QR Code en tapant
```
SECONDE
```
```
OPTN
```
flasher le QR Code alors obtenu :
- sur émulateur, il te suffit juste de cliquer le QR Code dans la fenêtre popup qui apparaît
- sur calculatrice, si celle-ci génère 1 seul QR Code, il te suffit de le flasher avec l'outil de ton choix
- sur calculatrice, si celle-ci génère une série de plusieurs QR Codes (au-delà d'une certaine taille de script), il te faudra les flasher avec l'appli Casio Edu+
dans la page web qui s'ouvre, de cliquer sur l'icône d'envoi par courriel

Si besoin des tutoriels plus détaillés traitant séparément des 3 situations ici évoquées sont disponibles dans les ressources en fin d'annonce.

Lien : inscription ateliers

Ressources :

Graph
90+E Graph
35+E II fx-92+ Spéciale
Collège

Mise à jour calculatrice :

3.50 pour Graph 90+E / fx-CG50 avec Windows / Mac

Émulateurs :

Graph 90+E / fx-CG50 version 3.50 à installer sur Windows / Mac
(période d'essai gratuite sans engagement de 90 jours, prolongeable gratuitement si besoin jusqu'au 31 décembre 2020 si déjà entamée)
Graph 90+E version 3.50 pour clé USB d'émulation officielle

Transfert de données :

tutoriel transfert de données

Mise à jour calculatrice :

Mise à jour 3.40 pour Graph 35+E II / fx-9750/9860GIII avec Windows

Émulateurs :

Graph 35+E II version 3.40 à installer sur Windows
(période d'essai gratuite sans engagement de 90 jours, prolongeable gratuitement si besoin jusqu'au 31 décembre 2020 si déjà entamée)
Graph 35+E II version 3.40 pour clé USB d'émulation officielle

Transfert de données :

tutoriel transfert de données

Emulateur :

fx-92+ Spéciale Collège à installer sur Windows
(période d'essai gratuite sans engagement de 90 jours, prolongeable gratuitement si besoin jusqu'au 31 décembre 2020 si déjà entamée)
fx-92+ Spéciale Collège pour clé USB d'émulation officielle

Transfert de données :

Sources : https://www.casio-education.fr/actualit ... noel-2020/ + https://twitter.com/CasioFrance/status/ ... 6127195142

de **critor** » 11 Déc 2020, 15:26

As-tu déjà pensé à personnaliser ta calculatrice préférée pour la rendre unique au monde ?

Voici plusieurs œuvres d'art que nous t'avions déjà présentées par The_Andy! et Persalteas :

Aujourd'hui, c'est au tour de la Casio Graph 25+E se se faire personnaliser avec talent par Laurine Harteloire.

Laurine te choisit ici pour le couvercle et le boîtier un superbe motif façon lignes de niveau, tout s'adaptant au relief statique déjà imposé par Casio (gravures, touches, patins, écran, etc.).

N'hésite pas à partager toi aussi tes créations.

Source : https://twitter.com/LHarteloire/status/ ... 7053429761

de **critor** » 16 Déc 2020, 13:39

Au début des années 2000, Casio et Texas Instruments supportaient encore activement le développement tiers pour leurs calculatrices.

Les constructeurs diffusaient de véritables SDK pour leurs modèles de l'époque.

Chez Texas Instruments on peut citer :

le TI-83 Plus / TI-84 Plus / TI-73 Explorer SDK
le TI-Flash Studio pour TI-89 et TI-92 Plus

Chez Casio nous avions le fx-9860G SDK, qui en France concernait donc les Graph 85.

Ces logiciels couplaient :

un assembleur éventuellement accompagné d'un compilateur
avec un émulateur tout spécialement adapté au développement, avec de quoi contrôler en direct l'état mémoire ou processeur, et même changer la version du système d'exploitation émulé

Mais les choses ont bien changé depuis. Casio et Texas Instruments ne publient plus de mise à jour de ces outils depuis maintenant une 15aine d'années, et ils sont totalement obsolètes car non adaptés aux modèles actuellement commercialisés.

Ne sont plus diffusés par les constructeurs que des émulateurs orientés utilisateurs, notamment pour la vidéoprojection en classe. Ils ne permettent pas de connaître l'état mémoire/processeur, encore moins de changer la version du système, et ne sont ainsi absolument pas adapté au développement de programmes ou applications en langage machine. Sans compter qu'ils ne sont pas toujours parfaitement fidèles au matériel.

Ce n'est pas (encore ?...) le cas chez Casio, mais chez Texas Instruments le développement tiers est même désormais farouchement combattu.

Du côté de Texas Instruments, la communauté des développeurs a pris le relais, réinventant ses propres émulateurs pour les machines récentes puis les adaptant progressivement aux besoins des développeurs.

On peut citer CEmu pour les TI-83 Premium CE et TI-84 Plus CE, ou encore Firebird pour les TI-Nspire.

Du côté de Casio hélas, aucun émulateur tiers n'est jamais sorti. Nous ne disposons que émulateurs officiels orientés pour l'enseignement et sur lesquels nous n'avons aucun contrôle.

Le développement d'applications était donc peu confortable, nécessitant dans tous les cas des tests sur machine et donc d'avoir en permanence la calculatrice et les câbles sous la main.

Mais surtout dans le cas de développement d'utilitaires système avec du code touchant à des zones sensibles, en cas de bugs cela pouvait potentiellement détruire définitivement la calculatrice.

C'est peut-être justement pour ça qu'il existe peu d'utilitaires système pour Casio par rapport aux modèles concurrents.

C'est donc une autre piste qu'explore aujourd'hui Redoste sur Planète Casio, dans le contexte de la Graph 90+E (ou fx-CG50 hors de France).

En effet si c'est apparemment trop difficile de réinventer notre propre émulateur, pourquoi ne pas tout simplement modifier l'émulateur officiel ?

Redoste révolutionne aujourd'hui la face du monde du développement Casio, en rajoutant un serveur GDB à ton émulateur, de quoi pouvoir pleinement tester et déboguer tes applications aussi ambitieuses soient-elles sans avoir à connecter ni risquer ta calculatrice !

Il devient même possible d'utiliser GDB pour analyser le firmware de Casio !

La méthode Redoste ne concerne que l'émulateur de Graph 90+E / fx-CG50 installable sur Windows.

Il te suffira tout simplement de remplacer dans le dossier d'installation la bibliothèque .dll d'émulation du processeur SH4 (fichier CPU73050.dll) par la version modifiée de Redoste.

Attention, cette manipulation n'est pas compatible avec l'émulateur Mac, ni avec l'émulateur sur clé USB.

Lien : https://github.com/redoste/fx-CG50_Mana ... -gdbserver

Téléchargement : Emulateur Graph 90+E / fx-CG50 version 3.50 à installer sur Windows
(période d'essai gratuite sans engagement de 90 jours, prolongeable gratuitement en cas de besoin jusqu'au 31 décembre 2020 si déjà entamée ou épuisée)

Source : https://www.planet-casio.com/Fr/forums/ ... iowin.html

de **critor** » 17 Déc 2020, 14:33

Enseignant de matière scientifique en collège ou lycée, jusqu'à ce mardi 15 décembre Casio t'a permis de participer à un superbe concours de Noël 2020.

Il te suffisait de programmer et envoyer un superbe dessin de Noël sur ta calculatrice Casio ou son émulateur, avec 2 catégories au choix :

fx-92+ Spéciale Collège (langage de programmation orienté tracé à la Scratch/Logo)
Casio Graph 35+E II ou Graph 90+E avec l'application Python

A gagner dans chacune des 2 catégories :

pour le meilleur dessin, un superbe lot de 180€ de valeur médiane : 1 disque dur externe SSD de 1 To de capacité + 1 calculatrice graphique Casio Graph 90+E ou Graph 35+E II au choix
pour le 2^ème meilleur dessin, un non moins superbe lot de 150€ de valeur médiane : 1 enceinte bluetooth + 1 calculatrice graphique Casio Graph 90+E ou Graph 35+E II au choix
pour tous les autres pas de perdant avec un superbe lot de participation : 1 batterie externe + 1 clé USB

Les gagnants ont maintenant été choisis par Casio, et l'ensemble des participants prévenus de leur lot par courriel.

Plusieurs participants ont partagé leurs scripts Python et nous allons te les présenter ci-dessous, ainsi que de façon tout à fait officieuse les résultats du concours puisque par pur hasard les meilleurs dessins choisis par Casio en font partie !

Voici ci-contre ma propre participation, une forêt de Noël, envoyée juste pour le plaisir.

Je ne souhaitais piquer de lot à personne et je l'ai bien dit, et c'est parfait puisque je gagne bien le seul lot de participation.

Ce script dispose d'un mode monochrome, et est compatible à la fois Graph 35+E II et Graph 90+E, même si c'est sur cette dernière qu'il révèle son plein potentiel.

Voici l'astuce utilisée pour détecter le type d'écran :

Code: Tout sélectionner: def init_casioplot(): global color_screen, screen_w, screen_h set_pixel(0, 0, (0, 0, 255)) col = get_pixel(0, 0) color_screen = col[0] != col[2] screen_w, screen_h = color_screen and (384, 192) or (128, 64)

Dans l'ordre, mon script utilisant la bibliothèque de tracé par pixels casioplot :

fait tomber la nuit : Il utilise ici 2 dégradés dans les tons de bleu pour représenter le sol et le ciel.
allume les étoiles (pixels blancs)
plante une forêt de sapins - nous allons y revenir
décore mon plus beau sapin : des disques de rayon 2 selon 3 couleurs de remplissage alternées, avec une couleur voisine pour la bordure rajoutant un peu de relief
saupoudre le tout de neige : des disques de rayon 1

La bibliothèque casioplot offre un nombre assez restreint de fonctions de tracé :

clear_screen() pour effacer l'écran en blanc
set_pixel(x,y,couleur) pour allumer un pixel dans une couleur (R,G,B) au choix
draw_string(x,y,string,couleur,taille) pour écrire du texte dans une couleur RGB et selon une taille de police au choix ("small", "medium" ou "large")

Ce n'est absolument pas un défaut, au contraire cela permet un travail absolument passionnant : la construction et optimisation de fonctions pour tracer chaque primitive. J'ai donc rajouté de quoi tracer des cercles, disques, mais également segments pour les sapins :

Code: Tout sélectionner: def draw_line(x1, y1, x2, y2, c): m, a1, b1, a2, b2 = 0, int(x1), int(y1), int(x2), int(y2) if (x2 - x1) ** 2 < (y2 - y1) ** 2: m, a1, a2, b1, b2 = 1, b1, b2, a1, a2 if min(a1, a2) != a1: a1, b1, a2, b2 = a2, b2, a1, b1 for k in range(a2 - a1 + 1): a, b = a1 + k, int(b1 + (b2 - b1) * k / ((a2 - a1) or 1)) set_pixel((a, b)[m], (b, a)[m], c) def draw_ellipse(x, y, rx, ry, c): for h in range(-int(ry), int(ry)+1): w = sqrt(max(0, rx*rx*(1-h*h/ry/ry))) x1, x2 = int(x - w), int(x + w) yc = int(y + h) set_pixel(x1, yc, c) set_pixel(x2, yc, c) for w in range(-int(rx), int(rx)+1): h = sqrt(max(0, ry*ry*(1-w*w/rx/rx))) y1, y2 = int(y - h), int(y + h) xc = int(x + w) set_pixel(xc, y1, c) set_pixel(xc, y2, c) def fill_ellipse(x, y, rx, ry, c): for h in range(-int(ry), int(ry)+1): w = sqrt(max(0, rx*rx*(1-h*h/ry/ry))) x1, x2 = int(x - w), int(x + w) yc = int(y + h) draw_line(x1, yc, x2, yc, c) def draw_circle(x, y, r, c): draw_ellipse(x, y, r, r, c) def fill_circle(x, y, r, c): fill_ellipse(x, y, r, r, c)

La construction des sapins utilise des similitudes, transformations géométriques conservant les rapports de distances.
Une similitude peut se décomposer en une isométrie (transformation conservant les distances : translation, rotation, ...) la plupart du temps suivie d'une homothétie (agrandissement ou réduction).

Plus précisément, en partant d'un couple de seulement 2 points que l'on va appeler le tronc, 5 similitudes sont appliquées pour créer 5 branches (en bas à gauche, à gauche, en haut, à droite, en bas à droite).

En itérant le même processus sur chacune de ces branches, on fait ainsi pousser l'arbre, le développant dans ces 5 directions.

Par exemple, sur la capture couleur ci-contre, nous avons de gauche à droite des arbres avec :

1 itération
3 itérations
5 itérations (profitant pleinement des 1 Mio de mémoire de tas Python )
4 itérations
3 itérations

Pour l'exécution sur Graph 35+E II nous avons dû limiter le nombre d'itérations afin de ne pas exploser la mémoire de tas Python (heap) ici limitée à 100 Kio. Nous avons ici de gauche à droite :

0 itération (donc le tronc initial nu)
1 itération (donc le tronc avec ses 5 branches initiales)
3 itérations
2 itérations
0 itération

Code: Tout sélectionner: from math import pi, sin, cos, exp, sqrt import matplotlib.pyplot as plt from random import * from casioplot import * def init_casioplot(): global color_screen, screen_w, screen_h set_pixel(0, 0, (0, 0, 255)) col = get_pixel(0, 0) color_screen = col[0] != col[2] screen_w, screen_h = color_screen and (384, 192) or (128, 64) def transform(x, y): f = screen_h * 45 // 64 return (x*f,screen_h-1-y*f) def draw_line(x1, y1, x2, y2, c): m, a1, b1, a2, b2 = 0, int(x1), int(y1), int(x2), int(y2) if (x2 - x1) ** 2 < (y2 - y1) ** 2: m, a1, a2, b1, b2 = 1, b1, b2, a1, a2 if min(a1, a2) != a1: a1, b1, a2, b2 = a2, b2, a1, b1 for k in range(a2 - a1 + 1): a, b = a1 + k, int(b1 + (b2 - b1) * k / ((a2 - a1) or 1)) set_pixel((a, b)[m], (b, a)[m], c) def draw_ellipse(x, y, rx, ry, c): for h in range(-int(ry), int(ry)+1): w = sqrt(max(0, rx*rx*(1-h*h/ry/ry))) x1, x2 = int(x - w), int(x + w) yc = int(y + h) set_pixel(x1, yc, c) set_pixel(x2, yc, c) for w in range(-int(rx), int(rx)+1): h = sqrt(max(0, ry*ry*(1-w*w/rx/rx))) y1, y2 = int(y - h), int(y + h) xc = int(x + w) set_pixel(xc, y1, c) set_pixel(xc, y2, c) def fill_ellipse(x, y, rx, ry, c): for h in range(-int(ry), int(ry)+1): w = sqrt(max(0, rx*rx*(1-h*h/ry/ry))) x1, x2 = int(x - w), int(x + w) yc = int(y + h) draw_line(x1, yc, x2, yc, c) def draw_circle(x, y, r, c): draw_ellipse(x, y, r, r, c) def fill_circle(x, y, r, c): fill_ellipse(x, y, r, r, c) def horiz_gradient(x, y, w, h, col1, col2): for k in range(h): draw_line(x, y + k, x + w - 1, y + k, [col1[i] + (col2[i] - col1[i])*k//(h-1) for i in range(3)]) def cmath_exp(a): return exp(a.real) * (cos(a.imag) + 1j*sin(a.imag)) def similitude(u, v): v = 1j * (u - v) return lambda z: v*z + u def generer_arbre(n): lf = ( similitude(.2j, .2j + .5*cmath_exp(1j * pi / 7)), similitude(.22j, .22j + .45j*cmath_exp(1j * pi / 3)), similitude(.55j, .55j + .35*cmath_exp(1j * pi / 6)), similitude(.57j, .57j + .3j*cmath_exp(1j * pi / 3)), similitude(.7j, 1.2j - .01) ) lz = [0j, 0.7j] lz1 = lz[:] for _ in range(n): lz2 = [] for f in lf: lz2.extend([f(z) for z in lz1]) lz.extend(lz2) lz1 = lz2 return lz def rotate_color(c): return (c[1], c[2], c[0]) def trace(d, nb_trees, nb_balls, nb_stars, nb_flakes): color_black = (0,) * 3 color = color_screen and (255,) * 3 or color_black # fait tomber la nuit colors = (color_black, (0, 0, 127), (0, 127, 255)) dy = screen_h / (len(colors)) if color_screen: for k in range(len(colors) - 1): horiz_gradient(0, round(dy*k), screen_w, round(dy), colors[k], colors[k + 1]) horiz_gradient(0, screen_h - 1 - round(dy), screen_w, round(dy), (0, 63, 127), color_black) dx = (screen_w - 1) / 2 / (nb_trees - 1) # allume les etoiles for k in range(nb_stars): set_pixel(randint(0, screen_w - 1), randint(0, screen_h - 1 - round(dy)), color) # plante une foret de sapins for p in range(d - nb_trees, d + 1): x0 = screen_w // 2 + (p < d and dx * ((d - p) % 2 and d + 1 - p or p - d)) dy = screen_h / (len(colors)) * (d - p) / nb_trees lz = generer_arbre(p) for k in range(0, len(lz), 2): x1, y1 = transform(lz[k].real, lz[k].imag) x2, y2 = transform(lz[k+1].real, lz[k+1].imag) x1 += x0 x2 += x0 draw_line(x1, y1 - dy, x2, y2 - dy, (0, 160 * (1 - (d - p)//(nb_trees - 1)), 0)) # decore mon plus beau sapin if color_screen: lz, r, color_in, color_out = lz[1::max(1, len(lz)//nb_balls)], 2, (0, 255, 255), (0, 0, 255) for z in lz: x, y = transform(z.real, z.imag) x += x0 fill_circle(x, y, r, color_in) draw_circle(x, y, r, color_out) color_in, color_out = rotate_color(color_in), rotate_color(color_out) # saupoudre de neige if color_screen: for k in range(nb_flakes): fill_circle(randint(0, screen_w - 1), randint(0, screen_h - 1), 1, color) init_casioplot() trace(color_screen and 5 or 3, 5, 30, 100, 40) show_screen()

Nous retrouvons maintenant Thomas Fontaine qui s'était déjà illustré au 3^ème défi de notre concours de rentrée 2019.

On passe aux choses sérieuses, puisque Thomas nous annonce que Casio a classé son dessin en 2^ème position !

Thomas utilise ici le module de tracés relatifs turtle sur Graph 90+E pour nous dessiner un buste de renne.

Un tracé façon 3D fil de fer, décomposant très artistiquement le tout en triangles et quadrilatères telle une sculpture sur bois.

Le script profite avantageusement en taille de la symétrie verticale, n'ayant donc à décrire que le demi-buste qui sera itéré 2 fois.

Le plus remarquable c'est qu'une fois le tracé de chaque demi-buste commencé après un goto() et un couple penup/pendown() initial, à aucun moment la tortue ne se téléporte ou ne lève le stylo, superbe arabesque !

Sur chaque demi-buste, sont tracés dans l'ordre par le code reproduit ci-après:

tête
oreille
cou
poitrail
bois

Toutes nos félicitations Thomas !

Code: Tout sélectionner: from turtle import * pensize(2) for k in [-1,1]: penup() goto(0,-50) pendown() hideturtle() setheading(90-90*k+30*k) fd(19) lt(90*k) fd(10) lt(60*k) fd(10) fd(-10) lt(40*k) fd(12) fd(-12) rt(100*k) rt(15*k) fd(10) rt(15*k) fd(10) rt(40*k) fd(15) lt(140*k) fd(17) fd(-17) rt(40*k) fd(20) fd(-20) rt(100*k) #oreille lt(15*k) fd(10) lt(60*k) fd(7) lt(100*k) fd(7) fd(-7) rt(210*k) fd(25) rt(163*k) fd(25) fd(-25) lt(48*k) fd(8) rt(65*k) fd(20) fd(-20) lt(50*k) fd(20) rt(115*k) fd(15) fd(-15) lt(30*k) fd(16) fd(-16) lt(30*k) fd(13) lt(90*k) fd(5) rt(110*k) fd(10) lt(30*k) fd(10) fd(-10) rt(30*k) fd(-10) lt(90*k) fd(20) rt(120*k) fd(7) lt(10*k) fd(12) fd(-12) rt(10*k) fd(-7) lt(130*k) fd(9) rt(60*k) fd(5) lt(45*k) fd(50) rt(165*k) fd(52) fd(-52) lt(165*k) #cou lt(140*k) fd(35) lt(70*k) fd(42) fd(-42) rt(30*k) fd(29) lt(45*k) fd(32) rt(40*k) fd(5) lt(22*k) fd(13) lt(20*k) fd(15) lt(40*k) fd(11) lt(108*k) fd(49) fd(-49) # on est en haut de la tete #bois rt(108*k) fd(-13) #debut des bois rt(110*k) fd(10) lt(90*k) fd(6) fd(-6) rt(130*k) fd(30) lt(90*k) fd(5) fd(-5) rt(60*k) fd(20) lt(90*k) fd(5) fd(-5) rt(40*k) fd(25) lt(165*k) fd(25) rt(43*k) fd(15) rt(24*k) fd(20) fd(-20) rt(120*k) fd(15) lt(90*k) fd(5) fd(-5) rt(45*k) fd(25) lt(165*k) fd(25) rt(45*k) fd(15) rt(45*k) fd(5) rt(90*k) fd(10) lt(90*k) fd(4) fd(-4) rt(120*k) fd(15) lt(165*k) fd(15) lt(30*k) fd(15) rt(75*k) fd(15) fd(-5) rt(70*k) fd(12) lt(160*k) fd(12) rt(30*k) fd(10)

Voici maintenant notre cher Afyu, qui utilise également le module turtle sur Graph 90+E.

Afyu nous apprend que c'est sa participation qui a été retenue par Casio en tant que meilleur dessin de Noël !

Afyu nous dessine ici toute une scène de Noël. Nous y retrouvons plusieurs éléments des participations précédentes :

le sapin
ses boules
une étoile
le renne, ici en entier

Mais c'est surtout la scène de Noël la plus complète. Afyu profite en effet ici de l'écran large de la Casio Graph 90+E pour nous rajouter en prime un traineau recevant une pluie de cadeaux.

Sont tracés dans l'ordre par le code ci-après :

le renne avec :
1. sa patte arrière droite
2. son dos
3. ses oreilles
4. ses bois
5. sa tête
6. son torse
7. sa patte avant droite
8. sa patte avant gauche
9. son abdomen
10. sa patte arrière gauche
le traineau
le harnais
le sapin avec :
1. son feuillage
2. ses guirlandes
3. ses boules
4. son étoile
les 4 paquets cadeaux avec pour chacun :
1. la boîte
2. le ruban

Et ce qu'il y a de remarquable ici c'est que l'on ne repère quasiment pas d'élément géométrique remarquable, témoin du soin et de la précision apportés au tracé !

Bravo Afyu, nous sommes très fiers de toi !

Code: Tout sélectionner: from turtle import * hideturtle() penup() goto(-110,-50) pendown() #4 me patte rt(40) penup() for i in range(30): fd(1/4) lt(1/2) pendown() for i in range(30): fd(1) rt(3-i/15) for j in range(4): for i in range(10): fd(1/2) lt(3) lt(60) lt(120) for i in range(10): fd(1/2) rt(3) lt(110) for i in range(20): fd(1) rt(1.5) #fd(30) lt(50) for i in range(25): fd(0.6) rt(2) for i in range(15): fd(1) lt(3) for i in range(30): rt(12) fd(1/2) for i in range(15): fd(1) lt(4) for i in range(30): fd(1) rt(i//10) lt(30) for i in range(40): fd(1/2) rt(i//10) setheading(0) penup() fd(-15/2) pendown()#les oreilles for i in range(40): fd(((400-10*i)//160)/2) lt(4) lt(290) #for i in range(42): #fd((10*i)//160) #lt(4.2) #penup() #for i in range(42): #fd(-(10*(28-i))//160) #lt(-4.2) #pendown() for i in range(40): fd(((10*i)//160)/2) lt(4) penup() rt(90) #fd(5) lt(90) fd(-5/2) pendown() #les bois #penup() rt(110) fd(1) #pendown() rt(90) for i in range(20): fd(1) rt(1) lt(20) for j in range(3): rt(90) #for i in range(20): #fd(3) #lt(2+20-2*i) for i in range(10): fd(3/2) lt(2+10-i) for i in range(4): fd(1/2) lt(36) lt(10) for i in range(9): fd(1) rt(1+2*i) lt(40) for i in range(80): fd(1/2) rt(2) for i in range(10): fd(1/2) lt(18) for i in range(30): fd(1/2) lt(1) for i in range(20): fd(1/2) rt(3) #fin des bois penup() setheading(-90) fd(15/2) lt(90) fd(1) pendown() setheading(240) pensize(2) for j in range(2): for i in range(40): fd(1/12) rt(3) rt(60) pensize(1) setheading(90) penup() fd(15/2) lt(90) fd(1) lt(75) pendown() rt(60) for i in range(20): fd(1/2) lt(2) lt(40) for i in range(30): fd(1/2) rt((30-i)//7) lt(70) for j in range(4): for i in range(10): fd(1/2) lt(5) lt(40) rt(0) #for j in [1,-1]: #for i in range(30): #fd(j) #lt(4*j) fd(5/2) rt(50) fd(1) lt(70) for i in range(25): fd(1) lt((50-5*i)/3.7) lt(70) for j in range(2): for i in range(10): fd(1) rt(2) lt(40) rt(50) fd(7/2) fd(-7/2) rt(40) #1 re patte for j in range(2): for i in range(30): fd(1/2) rt(1) lt(70) lt(20) fd(5) rt(200) for j in range(4): for i in range(10): fd(1/2) lt(3) lt(60) lt(100) for j in range(2): for i in range(30): fd(-1/2) rt(-1) rt(70) penup() #2 me patte #lt(90) fd(15/2) #pendown() lt(100) pendown() for j in range(2): for i in range(30): fd(1/2) rt(1) lt(50) lt(30) fd(5) rt(190) for j in range(4): for i in range(10): fd(1/2) lt(3) lt(60) lt(100) for j in range(2): for i in range(30): fd(-1/2) rt(-1) rt(60) #bas du corps rt(90) fd(5/2) fd(-5/2) rt(120) for i in range(50): fd(1/2) lt(1/4) lt(90) penup() fd(15/2) pendown() rt(190) #3 me patte for i in range(40): fd(1/2) lt(2-i/20) rt(0) for i in range(30): fd(1/2) rt((100-3*i)/30) lt(0) for j in range(4): for i in range(10): fd(1/2) lt(3) lt(60) lt(120) for i in range(10): fd(1/2) rt(3) lt(90) for i in range(30): fd(1/2) lt(1) lt(10) for i in range(30): fd(1/2) rt(1+i//15) rt(20) for i in range(30): fd(1/2) lt(1+i//15) from turtle import * hideturtle() penup() setheading(0) pencolor([120/255,60/255,0]) pensize(3) goto(-80,-40) pendown() rt(35) for i in range(45): fd(1/2) rt(1) rt(90) #bois pensize(3) pencolor([120/255,60/255,0]) for i in range(30): fd(1) lt(6) rt(10) fd(5) lt(90) for i in range(4): fd(10) rt(90) fd(3.5) rt(90) fd(10) lt(90) fd(20) lt(90) rt(90) for i in range(10): fd(0.6) rt(18) fd(47*2+5) for i in range(28): fd(1.45) rt(6) rt(84) for i in range(20): fd(1/2) rt(1) fd(7/2) setheading(0) fd(90) #arri re lt(90) for i in range(30): fd(3/2) rt(i//10) setheading(0) for i in range(17): fd(1/2) lt(10) fd(3/2) penup() fd(-3/2) for i in range(17): fd(-1/2) lt(-10) pendown() setheading(160) for i in range(38): fd(3) lt((15-i)/2) for i in range(40): fd(1/2) lt((15-i)) penup() setheading(0) fd(105) lt(90) fd(20) pendown() setheading(160) for i in range(38): fd(3) lt((15-i)/2) for i in range(42): fd(1/2) lt((15-i)) lt(70) fd(15/2) pensize(2) setheading(203) for i in range(34): fd(3) rt(2-i/40) from turtle import * setheading(-30) penup() goto(110,-80) hideturtle() #pendown() pencolor([0,205/255,0]) pensize(2) for k in [-1,1]: penup() goto(110,-80) setheading(90) fd(15) setheading(90-120*k) fd(16) pendown() for j in range(4): for i in range(30): fd(1-j/5) lt(k*(1+i//20)) rt(50*k) for i in range(10): fd(-1+j/5) lt(k*(-1-i//20)) lt(50*k) for i in range(50): fd(1-j/5) lt(k*(i/30)) rt(40*k) for i in range(40): fd(-1+j/5) lt(k*(-i//20)) lt(70*k) for i in range(10): fd(1-j/5) lt(k*(1+i//20)) rt(30*k) for i in range(40): fd(-1+j/5) lt(k*(-1-i//30)) setheading(90-90*k-30*k+30*j*k) setheading(90-50*k) for i in range(30): fd(1/2) lt(k*(1+i//20)) rt(40*k) for i in range(20): fd(-1/3) lt(k*(-1-i//20)) lt(50*k) for i in range(30): fd(1/2) lt(k*(i/10)) rt(60*k) for i in range(30): fd(-1/3) lt(k*(i/20)) lt(20*k) for i in range(30): fd(1/2) lt(k*(1+i//20)) #guirlandes penup() goto(120,50) pendown() pencolor([1,0,0]) setheading(-140) for i in range(6): pensize(5) fd(3) pensize(2) fd(3) rt(5) setheading(-50) for i in range(10): pensize(5) fd(3) pensize(2) fd(3) lt(6) setheading(-150) for i in range(12): pensize(5) fd(3) pensize(2) fd(3) rt(4) setheading(-60) for i in range(13): pensize(5) fd(3) pensize(2) fd(3) lt(6) setheading(-120) for i in range(15): pensize(5) fd(3) pensize(2) fd(3) rt(6) setheading(-50) for i in range(13): pensize(5) fd(3) pensize(2) fd(3) lt(6) #boules from random import randint for coord in [(17,32),(-17,24),(-60,-10),(15,0),(-30,-40),(40,-50)]: penup() goto(coord[0]+110,coord[1]-10) pensize(20) pencolor([randint(1,10)/10,randint(1,10)/10,randint(1,10)/10]) pendown() fd(1) #etoile penup() goto(100,80) pendown() pencolor([220/255,220/255,40/255]) pensize(5) setheading(0) for i in range(5): fd(20) rt(72*2) #paquets from random import randint for coord in [(0,20),(-30,-10),(-70,10),(-30,50)]: penup() goto(coord[0],coord[1]) pendown() pensize(7/2) pencolor([randint(1,10)/10,randint(1,10)/10,randint(1,10)/10]) setheading(randint(1,60)-30) for i in range(4): fd(20) lt(90) fd(20) lt(45) fd(15/2) lt(45) fd(20) lt(135) fd(15/2) fd(-15/2) rt(45) fd(20) lt(45) fd(15/2) penup() lt(45) pencolor([randint(1,10)/10,randint(1,10)/10,randint(1,10)/10]) pensize(7/2) fd(10) #pendown() lt(90) fd(20) lt(45) fd(15/2) fd(-7/2) pendown() pensize(5/2) lt(45) fd(-10) fd(20) lt(90) fd(20) fd(-20) rt(90) fd(-10) rt(45) pensize(7/2) penup() fd(-4) rt(45) fd(-10) pendown() lt(90) fd(-10) fd(20) #ruban rt(45) fd(7/2) rt(15) for j in range(2): for i in range(30): fd(1/2) lt(2) lt(120) for i in range(30): fd(1/2) lt(2) rt(180)

Un grand merci également à Casio pour ce concours absolument remarquable invitant les participants à véritablement produire quelque chose sur leur calculatrice ou son émulateur, une grande première il nous semble, et réussie si on se fie aux dessins présentés.

Un concours de plus à la dotation fort appréciée. On aime la présence de plusieurs gros lots, la possibilité pour les gagnants de personnaliser en partie leur gros lot (choix de la calculatrice), l'absence de perdant, et justement en lot de participation les goodies exclusifs !

Merci Casio d'avoir égayé notre mois de décembre avec un peu de magie de Noël en cette période difficile.

Du grand art, reproduire un tel événement en ouvrant la participation aux élèves pourra être une excellente idée bien sûr en des temps plus propices.

Téléchargements :

de **critor** » 18 Déc 2020, 15:03

Enseignant de matière scientifique en collège ou lycée, jusqu'à ce mardi 15 décembre Casio t'a permis de participer à un superbe concours de Noël 2020.

Il te suffisait de programmer et envoyer un superbe dessin de Noël sur ta calculatrice Casio ou son émulateur, avec 2 catégories au choix :

fx-92+ Spéciale Collège (langage de programmation orienté tracé à la Scratch/Logo)
Casio Graph 35+E II ou Graph 90+E avec l'application Python

A gagner dans chacune des 2 catégories :

pour le meilleur dessin, un superbe lot de 180€ de valeur médiane : 1 disque dur externe SSD de 1 To de capacité + 1 calculatrice graphique Casio Graph 90+E ou Graph 35+E II au choix
pour le 2^ème meilleur dessin, un non moins superbe lot de 150€ de valeur médiane : 1 enceinte bluetooth + 1 calculatrice graphique Casio Graph 90+E ou Graph 35+E II au choix
pour tous les autres pas de perdant avec un superbe lot de participation : 1 batterie externe + 1 clé USB

Les gagnants ont maintenant été choisis par Casio, et l'ensemble des participants prévenus de leur lot par courriel.

Dans une actualité précédente nous te présentions les dessins de Noël sur Graph 90+E gentiment partagés par plusieurs candidats.

De façon tout à fait officieuse nous te partagions les résultats du concours, deux personnes parmi notre petit échantillon de candidats ayant par chance affirmé avoir gagné :

Florian Allard alias Afyu
Thomas Fontaine

Félicitations à tous les deux, nous sommes fiers de vous !

Retourne donc à l'actualité précédente pour consulter les diverses explications apportées sur chacun de ces scripts.

Casio vient de publier les résultats officiels, avec donc désormais en prime les dessins gagnants sur fx-92+ Spéciale Collège :

Alain Ladiesse
Amélie Roy

Félicitations à eux aussi !

Nous regrettons toutefois ici de ne pas disposer d'un partage des scripts correspondant aux dessins en question. Dommage, vu le tracé extrêmement bien fourni sur l'écran large de la fx-92+ Spéciale Collège, ils auraient sûrement été eux aussi fort intéressant à étudier.

Téléchargements :

Source : https://twitter.com/CasioFrance/status/ ... 3852988416

de **critor** » 20 Déc 2020, 00:00

Enseignant de matière scientifique en collège ou lycée, jusqu'à mardi 15 décembre Casio t'a permis de participer à un superbe concours de Noël 2020.

Il te suffisait de programmer et envoyer un superbe dessin de Noël sur ta calculatrice Casio ou son émulateur, avec 2 catégories au choix :

fx-92+ Spéciale Collège (langage de programmation orienté tracé à la Scratch/Logo)
Casio Graph 35+E II ou Graph 90+E avec l'application Python

Les gagnants ont été choisis par Casio et l'ensemble des participants prévenus de leur lot par courriel. Les lots ont maintenant été expédiés et commencent déjà pour partie à être livrés, mais quelle rapidité et efficacité chez Casio !

Plusieurs gagnants ayant spontanément partagé des photos de leur cadeau de Noël anticipé, découvrons-les ensemble.

Déjà, pas de perdant. Toutes les participations validées reçoivent un lot de participation illustré ci-contre avec plein de goodies exclusifs :

1 sac en toile Casio
1 batterie USB Casio
1 stylo bille Casio
1 clé USB Casio (3,74 Go de capacité, un tout nouveau modèle)
1 catalogue calculatrices Casio (l'édition de rentrée 2020 quasiment introuvable suite à l'annulation de tous les événements cette année)

En plus des goodies, Amélie Roy et Thomas Fontaine reçoivent :

1 enceinte Bluetooth Braven 705
1 calculatrice graphique Graph 90+E ou Graph 35+E II au choix (Graph 90+E dans le cas du lot de Thomas présenté ci-contre)

En plus des goodies, Alain Ladiesse et Florian Allard (alias Afyu) reçoivent pour leur part :

1 disque dur externe SSD EMTEC X200 (1 To de capacité)
1 calculatrice graphique Graph 90+E ou Graph 35+E II au choix (Graph 90+E dans le cas du lot de Florian présenté ci-contre)

De superbes cadeaux de Noël ô combien mérités, félicitations à vous et merci Casio !

Téléchargements :

de **critor** » 20 Déc 2020, 14:59

Amazon te propose un classement des ventes de calculatrices graphiques réactualisé chaque heure :
https://www.amazon.fr/gp/bestsellers/of ... _205449031

Toutefois les familles optant pour des modèles peu ambitieux comme les Casio Graph 25+E, TI-82 Advanced ou pire Lexibook GC3000FR et Esquisse GCEXFR ne sont habituellement pas celles qui passent par Amazon. Le classement est ainsi biaisé et non représentatif.

Un autre indicateur bien plus large est celui développé initialement par l'institut Nielsen depuis absorbé par Gfk.

Jusqu'en 2011 par exemple, la TI-82 Stats.fr était le modèle numéro 1 au lycée, comme fièrement affiché sur son emballage (merci cent20).

Pour la rentrée 2009, Casio révolutionnait le monde en ajoutant un moteur de calcul exact QPiRac à son entrée de gamme Graph 35, avec le nouveau modèle Graph 35+USB.

En seulement quelques années, la Graph 35 devient le nouveau modèle de référence au lycée, dépassant la TI-82 Stats à compter de 2012.

Nous avons pu te rendre compte de la formidable aventure de la gamme Graph 35 grâce aux indicateurs Gfk communiqués chaque année par Casio dans ses catalogues ou interviews.

Une belle dynamique jusqu'à l'année civile 2016, où la Graph 35+E culmine à 38,6% de parts de marché valeur !

Depuis, suite sans doute à la sortie de modèles couleur à peine plus chers (TI-83 Premium CE à la rentrée 2015, puis NumWorks à la rentrée 2017), la tendance était à la baisse :

chute brutale à 37,1% sur l'année civile 2017
dégringolade à 33,4% sur l'année civile 2018

Tous les événements étant annulés ou reportés en cette période épidémique, nous n'avions jusqu'à présent pu te récupérer le nouveau catalogue Casio de rentrée 2020, et n'avions donc pas pu te rendre compte de la suite.

Nous ignorions donc si la tendance à la baisse s'était poursuivie ou même si la Graph 35 était toujours numéro 1 au lycée, ou bien si la nouvelle Graph 35+E II avec Python de la rentrée 2019 avait pu commencer à inverser la tendance.

Et bien nous venons tout juste d'enfin récupérer ce catalogue, alors découvrons vite ensemble.

Et bien bonne nouvelle, la Graph 35+E II est toujours numéro 1 au lycée sur l'année civile 2019. Pour la 9^ème année consécutive la gamme Graph 35 l'emporte donc au classement des ventes Gfk, félicitations !

Attention toutefois, l'information est à prendre avec des pincettes.

Pour la première fois cette année, Casio a soudainement fait le choix de ne plus communiquer le pourcentage de parts de marché.

Et surtout, il y a bizarrement un changement de mesure selon le renvoi en bas de page. Il ne s'agit plus de parts de marché valeur comme toute cette dernière décennie, mais de parts de marché volume...

Lien : catalogue des calculatrices Casio - rentrée 2020