te proposait de faire une petite farce à tes camarades, leur faisant croire que tu avais
Windows XP
d'installé sur ta
TI-83 Premium CE
.
Son programme reproduisait en effet l'animation d'écran de veille par défaut de ce système.
Mais voilà, l'effet n'est plus le même de nos jours,
Windows XP
ça fait tellement vieux et désuet désormais...
Heureusement
Candledark
reprend aujourd'hui le flambeau, pour faire croire à tes camarades que ta
TI-83 Premium CE
fait cette fois-ci tourner
Windows 10
!
Son programme
WINUPDTE
reproduit en effet soigneusement l'animation de mise à jour de ce système.
Pour faire encore plus vrai, l'animation ne peut être quittée normalement. Deux versions sont au choix, et il te faudra en fait :
pour la version 1, patienter 20 secondes puis taper une touche
pour la version 2, maintenir simultanément les 3 touches
(devineras-tu pourquoi ? )
WINUPDTE
est écrit en langage
C
et le code source est inclus.
Attention,
WINUPDTE
rentre donc dans la catégorie des programmes en langage machine dits
ASM
. Si ta calculatrice fait tourner une version système
5.5.1
ou supérieure c'est compliqué ;
Texas Instruments
combattant farouchement l'exécution de code tiers sur la
TI-83 Premium CE
depuis un acte absolument irresponsable d'un enseignant français de Mathématiques dans le contexte de ses gesticulations visiblement aveugles contre la réforme du lycée.
C'est une série de trois films américano-australiens initiée en 1999 par ceux qui étaient alors les frères Wachowski. Elle se passe autour d'un univers virtuel dont l'état est consultable sur écran sous la forme d'une
"pluie de code"
, animation introduisant justement les trois films dans un thème vert.
Candledark
te propose aujourd'hui avec
CodeRain
, son nouveau programme
TI-83 Premium CE
, non pas de te mettre dans la matrice, mais de mettre la matrice dans ta
TI-83 Premium CE
!
CodeRain
apporte en effet l'animation mythique sur l'écran de ta calculatrice, une reproduction déjà très fidèle et très fluide.
Mais ici en prime, tu peux choisir différents thèmes pour ta pluie de code à l'aide des touches numériques du clavier :
rouge
vert
(par défaut)
jaune
bleu
violet
sarcelle
magenta
orange
et même multicolore ! 😻
CodeRain
est écrit en langage
C
et le code source est inclus.
Attention,
CodeRain
rentre donc dans la catégorie des programmes en langage machine dit
ASM
. Si ta calculatrice fait tourner une version système
5.5.1
ou supérieure c'est compliqué ;
Texas Instruments
combattant farouchement l'exécution de code tiers sur la
TI-83 Premium CE
depuis un acte absolument irresponsable d'un enseignant de Mathématiques français dans le contexte de ses gesticulations visiblement aveugles contre la réforme du lycée.
disposent dans ce cadre de possibilités encore plus exclusives à ce jour. En effet même si il ne l'a toujours pas annoncé et encore moins exploité depuis, le constructeur a introduit la gestion des claviers
USB
à compter des versions
5.1.5
sur
TI-83 Premium CE
et
5.0
sur
TI-Nspire CX II
.
Oui, les
TI-Nspire CX II
et
TI-83 Premium CE
(ou
TI-84 Plus CE
)
sont à ce jour les seuls modèles te permettant de brancher et utiliser un clavier
USB
pour une saisie encore plus facile et rapide de tes programmes et scripts
Python
!
En prime ton expérience de saisie sur
TI-83 Premium CE
s'enrichit considérablement dans ce contexte avec :
la touche d'effacement arrière, parfaitement fonctionnelle bien qu'inexistante sur la calculatrice !
si la touche
annul
de la calculatrice a pour équivalent
verr num
sur les claviers, nous avons en prime la touche
esc
qui permet à la différence une annulation sans effacement, petite nuance
saisie de caractères minuscules ce qui n'était pas possible en dehors de l'application
Python
, du moins pas sans ajout d'un utilitaire
saisie directe de caractères non présents au clavier de la calculatrice et qu'il fallait aller chercher dans des menus !
et même saisie de caractères n'étant même pas dans les menus de la calculatrice !
Les équivalences de touches et fonctionnalités étaient certes logiques.
Par exemple la touche
3
de la calculatrice permet également de saisir
L3
ou
θ
via les modificateurs
2nde
et
alpha
. On retrouvait donc ces mêmes possibilités sur le clavier externe via les modificateurs
ctrl
et
alt
, ainsi que la possibilité supplémentaire de sortir un caractère spécial avec le modificateur
shift
.
Toutefois voilà, ces saisies secondaires n'étaient absolument pas indiquées sur un clavier
USB
standard, et avec une organisation de touches complètement différente ces équivalences n'étaient pas aisées à retenir non plus.
Il fallait donc personnaliser les inscriptions de son clavier...
Dans l'optique de l'expédition des lots de notre concours de rentrée 2020, nous sommes justement en train de produire 5 claviers
USB
uniques, entièrement personnalisés pour une expérience de saisie révolutionnaire sur ta
TI-83 Premium CE
! Trop tard pour participer, mais si tu n'as pas gagné nous te partageons quand même ici l'intégralité des détails de leur conception.
Pour compléter la sérigraphie de ton clavier
USB
, il te faut donc du papier autocollant transparent, que tu pourras trouver dans le commerce dans des kits destinés à la fabrication de
stickers
transparents. Conformément aux spécifications du papier précédent, nous utilisons une imprimante jet d'encre.
Mais attention au choix de ton clavier
USB
, il te faut de préférence un clavier
Qwerty
filaire avec des touches de couleur blanche ou claire. Nous optons pour notre part pour un mini-clavier
USB Qwerty
filaire blanc à peine plus grand que la calculatrice que nous jugeons plus convenable pour le transport et l'usage scolaire, également très fin et léger. En effet :
Ta calculatrice ne gère que la disposition de touches
Qwerty
. Trouver/commander un clavier
Qwerty
te permettra des modifications beaucoup moins lourdes de sa sérigraphie.
Notre imprimante étant ici une jet d'encre fonctionnant de façon totalement normale en quadrichromie soustractive, il lui est impossible d'imprimer quelque chose de plus clair que le support qui lui est fourni. Mais ça tombe bien ce sera assorti à ta
TI-83 Premium CE
comme ça.
Attention, les claviers
USB
sans fil à la différence ne fonctionnent pas toujours avec la calculatrice, leur émetteur-récepteur pouvant sans doute générer une consommation trop importante.
Voici donc ci-contre nos autocollants destinés à en compléter ou corriger la sérigraphie de chaque touche, aussi bien pour
TI-83 Premium CE
que pour
TI-84 Plus CE
. Tu en retrouveras gratuitement en fin d'article une version directement imprimable, ainsi qu'une version modifiable.
De façon similaire à la calculatrice, nous adoptons donc un code couleur vert-bleu pour les fonctions secondaires. Nous utilisons ensuite 3 colorations de touches différentes :
Sur fond blanc et donc transparent une fois imprimé, les simples précisions sur les fonctions secondaires de la touche concernée. Cela concerne les touches dont la fonction principale telle que sérigraphiée ne change pas lorsqu'utilisée avec la calculatrice, une majorité comme déjà dit pour un clavier
Qwerty
.
Sur fond noir et donc masquant la sérigraphie d'origine une fois imprimé, les rares touches qui avec la calculatrice ne se comportent pas comme indiqué pour leur fonction principale.
Nous ne sommes pas certains qu'une impression jet d'encre sur laquelle tu vas poser les doigts sans arrêt soit très durable. Nous ne savons pas ce que ça vaut, tu nous diras, mais nous appliquons donc une couche de vernis. Tu peux pour cela piquer le tube de vernis à ongles de Maman, grande sœur ou petite sœur, ça marche très bien.
Et voilà, il n'y a plus qu'à imprimer puis découper et coller. Impression bien évidemment en qualité optimale en sélectionnant un type de papier
brillant épais
ou à défaut
brillant
tout court.
Voici donc enfin notre périphérique légendaire
TI-Keyboard CE édition 84
dans toute sa splendeur, nous voici fin prêts pour une saisie turbo !
Pour les applications d'émulation par contre, les versions intégrales sont payantes.
Les versions gratuites des applications
HP Prime
sont quant à elles limitées à l'utilisation de seulement 9 des applications de la calculatrice :
Fonction
Graphiques avancés
Stats 1Var
Stats 2Var
Inférence
Résoudre
Paramétrique
Polaire
Suite
Les versions gratuites des applications n'en restent pas moins fort utiles si ton enseignant t'autorise le
smartphone
en devoir surveillé, chaque application de la calculatrice pouvant être basculée dans sa vue
CAS
autorisant le calcul formel !
Et puis, comme tu l'as peut-etre remarqué,
Google
a fait un mauvais coup à
Hewlett Packard
en pleine période de rentrée 2020. Les deux applications
HP Prime
ont été supprimées du
Play Store
.
L'un des développeurs de la
HP Prime
,
Tim Wessman
, avait rapidement communiqué à ce sujet dès le 17 septembre 2020 :
Tim Wessman a écrit:it got pulled automatically due to needing a small tweak to an openFile api. Kind of a surprise to us as well
On pouvait donc s'attendre à un retour rapide de l'application après une très légère correction.
Hélas, cela fait maintenant plus de 4 mois et toujours rien.
Quelques infos complémentaires,
Cyrille de Brébisson
, autre développeur de la
HP Prime
, vient tout juste de revenir sur ce sujet dans le contexte de la conférence virtuelle
HPCC 2021
. Deux passages à ce sujet :
de 8:21 à 8:49
de 13:27 à 17:41
Pour résumer, tu as pu noter que la dernière mise à jour
HP Prime
remonte à janvier 2020 et qu'elle était bien mineure, la dernière mise à jour véritablement significative remontant à janvier 2018.
Ben c'est ça le problème, comme peu de choses ont bougé depuis maintenant plus de 3 ans, du moins dans les versions de production, ben les applications
HP Prime
n'ont plus été mises à jour. Et
Google
supprime automatiquement du
Play Store
les applications qui ne sont plus mises à jour depuis un certain temps.
Les applications
HP Prime
doivent être recompilées, sauf que depuis tout ce temps le
SDK
a pas mal bougé et en gros la compilation échoue.
Histoire donc de te dépanner, nous hébergeons l'application gratuite
HP Prime Lite
pour
Android
.
Pour l'installer il te suffira tout simplement d'ouvrir le fichier
.apk
téléchargé ci-dessous sur ton
smartphone
.
Par contre désolé, nous n'avons hélas aucune solution pour te redonner accès à l'application intégrale
réalise de gros efforts pour rendre la programmation de ses calculatrices accessible à tous et toutes. Le constructeur a prêté une attention toute particulière aux plus jeunes et non initiés, souhaitant leur permettre de créer tous les projets imaginables sans avoir à se concentrer sur des difficultés annexes.
. Tous ces éléments ont de plus l'avantage d'être utilisables directement avec le langage
Python
des calculatrices concernées, faisant de l'écosystème
Texas Instruments
le seul
Python
connecté !
Un superbe support pour les enseignements scientifiques au lycée surtout maintenant que tous partagent le même langage de programmation, notamment en
SNT
, spécialité
NSI
,
SI
et
Physique-Chimie
, avec le gros avantage de la mobilité. En effet, les programmes produits et données collectées restent présents dans la calculatrice apportée par chaque élève à chaque cours, ce qui allège la charge logistique de l'enseignant. Données et algorithmes pourront donc être traités / travaillés à la prochaine séance, en devoir à la maison ou même de façon transdisciplinaire en collaboration avec un autre enseignant !
Et depuis la rentrée 2020 dernière grande révolution en date, plus besoin de t'équiper en
TI-Innovator
pour bénéficier de ces formidables avantages. En effet, la
Attention, cela nécessite obligatoirement que ta calculatrice fasse tourner une version
5.5.1
ou supérieure.
La carte
micro:bit
est initialement un projet lancé par la
BBC
(
B
ritish
B
roadcasting
C
orporation)
, le groupe audiovisuel public britannique, accompagné de nombre de partenaires dont
ARM
,
Microsoft
et
Samsung
. Elle fut distribuée gratuitement à un million d'élèves britanniques de 11 et 12 ans.
Le nom rend hommage au précédent succès du groupe dans ce domaine, le microordinateur à vocation pédagogique
BBC Micro
des années 1980, l'équivalent britannique de par son adoption à nos microordinateurs
Thomson MO5
et
TO7
inondant écoles, collèges et lycées à la fin de cette décennie dans le cadre du plan
IPT
(
I
nformatique
P
our
T
ous)
.
La carte
micro:bit
dans sa version 1 inclut :
un afficheur, grille programmable de 5×5= 25 diodes rouges adressables, bien adapté pour l'affichage de motifs éventuellement animés ou encore de texte défilant
nombre de capteurs intégrés :
capteur de luminosité
(lié aux diodes)
capteur de température
(sur le processeur)
2 boutons poussoirs
A
et
B
programmables de part et d'autre, comme sur les premières manettes et consoles de jeux portables de chez
Nintendo
accéléromètre 3D, permettant de détecter les variations d'accélération et par conséquence diverses actions : secouer, pencher, chute libre, ...
boussole magnétique 3D, pour détecter cette fois-ci les champs magnétiques
connectivité
Bluetooth 4.0
basse énergie 2,4 GHz maître/esclave
La carte
micro:bit
utilise un connecteur
micro-USB
et ta calculatrice un
mini-USB
.
Pour relier les deux une solution est d'adjoindre un adaptateur
complémentaires à installer sur ta calculatrice. Le constructeur en met 9 à ta disposition, et ces modules te permettent chacun d'accéder à tout ou partie des modules ou classes correspondants dans le
C'était justement l'occasion d'explorer un peu plus profondément les possibilités de la
micro:bit
, et ce fut hélas extrêmement décevant.
Rappelons que les interpréteurs
MicroPython
ou similaires font appel à 3 types de mémoires avec les rôles suivants :
la mémoire de stockage qui accueille et conserve tes scripts
le stack
(pile)
qui, à l'exécution, accueille les références vers les objets créés
le heap
(tas)
qui, à l'exécution, accueille le contenu de ces objets
En gros le
stack
limite donc le nombre d'objets différents pouvant exister simultanément en mémoire, alors que le
heap
limite la taille globale occupée par le contenu de ces objets.
Le langage
Python
a toutefois le gros défaut d'être très gourmand en mémoire, le moindre petit objet de rien du tout créé gaspillant une place énorme. Voici quelques références de tailles pour les plateformes 32 bits :
pour un entier nul :
24
octets déjà...
pour un entier court non nul
(codable sur 31 bits + 1 bit de signe)
:
28
octets
pour un entier long :
28
octets
+
4
octets pour chaque groupe de 30 bits utilisé par son écriture binaire au-delà des 31 bits précédents
pour une chaîne:
49
octets
+
1
octet par caractère
pour une liste :
64
octets
+
8
octets par élément
+ les tailles de chaque élément
En pratique, le
heap
est donc bien souvent le facteur limitant. Nous l'avions donc testé en priorité sur
TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
8,240 Ko
:
BBC micro:bit
La
micro:bit
permettait sans aucun doute un large éventail de projets grâce à ses capteurs et actionneurs, mais chaque projet pris individuellement ne pouvait pas aller bien loin, devant sans doute se limiter essentiellement à de l'utilisation très légère des fonctions fournies. Tout élève suffisamment intéressé pour avoir envie d'approfondir sera rapidement confronté à des erreurs de mémoire de plus en plus difficiles et ennuyantes à contourner, et peut-être même pire dégoûté de toute poursuite dans cette branche.
Mais rien de surprenant lorsque l'on sait que la
micro:bit
utilise un microcontrôleur
nRF51822
de chez
Nordic Semiconductor
, avec les spécifications suivantes :
processeur
32 bits ARM Cortex-M0
cadencé à
16 MHz
mémoire de stockage
Flash
d'une capacité de
256 Kio
mémoire de travail
RAM
d'une capacité de
16 Kio
, et voilà qui explique tout...
Mais pour cette année 2021 arrive la nouvelle carte
micro:bit v2
.
Dépêchons-nous de voir ce qu'elle vaut.
Et bien justement, comme tu peux le constater ci-contre elle utilise un tout nouveau microcontrôleur, le
nRF52833
, toujours de chez
Nordic Semiconductor
. Cette fois-ci nous avons des spécifications qui devraient nous permettre de respirer :
processeur
32 bits ARM Cortex-M0
cadencé à
64 MHz
au lieu de
16 MHz
soit 4 fois plus rapide !
mémoire de stockage
Flash
d'une capacité de
512 Kio
au lieu de
256 Kio
soit 2 fois plus grande !
mémoire de travail
RAM
d'une capacité de
128 Kio
au lieu de
16 Kio
soit 8 fois plus grande
Et ce n'est pas tout, nous constatons d'autres nouveautés sur cette face :
ajout d'un haut-parleur
ajout d'un microphone MEMs
bouton poussoir qui ne sert plus seulement à la réinitialisation
(reset)
, mais permet désormais également d'éteindre la carte
(appui long)
et de la rallumer
(appui court)
l'antenne
Bluetooth
qui devient compatible
BLE Bluetooth 5.0
, contre seulement
4.0
auparavant
Passons maintenant à l'autre face, car les nouveautés ne sont pas terminées. Ici nous avons donc en prime :
ajout d'une diode DEL indiquant l'état du microphone
ajout d'un bouton tactile sur le logo
micro:bit
, voici pourquoi il perd sa couleur au profit de contacts métalliques
Reste-t-il encore à confirmer en pratique que la capacité
RAM
accrue sert bien entre autres à augmenter le
heap
Python
, et dans quelle mesure.
Première chose absolument indispensable à faire, tu dois commencer par reprogrammer ta carte
micro:bit
avec le fichier
firmware
.hex
dédié fourni par
Texas Instruments
.
Ce
firmware
est conçu pour rajouter à ta carte
micro:bit
la capacité de communiquer via son port
micro-USB
avec ta calculatrice
TI-83 Premium CE Edition Python
ou
TI-84 Plus CE-T Python Edition
.
Normalement rien de bien compliqué, il te suffit juste de connecter ta carte à un ordinateur pour y copier le fichier en question, la carte redémarrant automatiquement en fin de copie pour exécuter le nouveau
firmware
.
Sauf qu'ici ça ne marche pas. Le fichier
.hex
distribué par
Texas Instruments
n'est apparemment pas compatible
micro:bit v2
, nous obtenons l'émoticône d'erreur accompagnée du code
529
.
Mais ne baissons pas les bras. Rendons-nous sur l'éditeur
# version history # 1.0 python functionality # 1.1 Added TI LOGO and grove ranger # 1.2 added handshake # 1.3 added get_version # 2.0 removed handshake and changed version to 2.0 for release in france
from microbit import * from machine import time_pulse_us
ti = Image("07700:""07797:""77777:""07770:""00700")
def ranger(pin=pin0): pin.write_digital(1) pin.write_digital(0) pin.read_digital() t = time_pulse_us(pin,1,35000) print(t)
def get_version(): print ("TI-Runtime Version 2.0")
display.show(ti,delay=10,wait=False)
Demandons donc à l'éditeur de nous générer un nouveau fichier
.hex
à partir de ce code.
Il y a espoir, cette fois sa copie sur
micro:bit v2
ne déclenche plus d'erreur, et affiche bien le logo de
Texas Instruments
.
Très bon signe, la
micro:bit v2
semble correctement se comporter, l'importation du module
microbit
ne déclenchant aucune erreur.
Mais confirmons en lui faisant faire quelque chose, comme afficher l'icône de Pac-man... bingo, ça marche !
TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
8,240 Ko
:
BBC micro:bit v1
63 Ko
c'est quasiment le double de ce qu'offre la
NumWorks
, et également 3,5 fois plus que ce qu'offre la
TI-83 Premium CE Edition Python
, tu te rends compte ?
La capacité du
heap
Python
de la
TI-83 Premium CE Edition Python
est en effet un gros point faible. Mais ici en lui adjoignant une
BBC micro:bit v2
tu multiplies la taille de
heap
utilisable par 4,5 ! De quoi approfondir des projets
Python
sur cette machine, à condition de distribuer correctement les différents objets
Python
créés entre le
heap
interne de la calculatrice et le
heap
externe de la carte, et bien sûr les faire interagir correctement.
Malheureusement, à la différence nous n'avons à ce jour pas accès au code source des modules
micro:bit
additionnels de la
TI-83 Premium CE Edition Python
, ni à aucun outil permettant de générer ce genre de module, et ne pouvons donc ni corriger, ni améliorer, ni étendre ces modules.
Nous sommes donc hélas dans l'incapacité de faciliter ton utilisation des nouveaux éléments de la
micro:bit v2
depuis ta calculatrice, notamment les microphone, haut-parleur et bouton tactile. La seule façon de les exploiter à ce jour sera de faire appel à la fonction
mb_run()
partagée plus haut, et lui passer en paramètre le code
Python
brut à exécuter par la carte. Avec les difficultés que cela implique, ton script comportant alors à la fois du code
Python
qui sera exécuté dans le contexte de la calculatrice, et du code
Python
qui sera exécuté dans le contexte de la carte
BBC micro:bit
. Il ne faudra surtout pas confondre, les contextes des deux interpréteurs
Python
étant très différents. Pas le meilleur cadre, du moins pour débuter...
avait organisé à l'attention des enseignants un concours de Noël fort intéressant et joliment doté. Il fallait programmer un dessin de Noël sur au choix sur
fx-92+ Spéciale Collège
ou en
Python
sur
Graph 35+E II
et
Graph 90+E
. Un événement réussi qui a incité à la création de très beaux scripts !
Plusieurs enseignants avaient comme nous réagi à l'événement en mentionnant qu'une ouverture des participations aux élèves aurait été très pertinente sur ce genre de concours.
Message visiblement reçu cinq sur cinq en un temps record,
Casio
nous lance déjà un tout nouveau concours du même genre,
Comme un air de Printemps
, mais cette fois-ci justement ouvert aux seuls :
collégiens et collégiennes
lycéens et lycéennes, aussi bien en voie générale que technologique ou professionnelle
(2nde, 1ère, Tle, CAP, BEP)
Il te suffit de réaliser un dessin sur le thème de la nature avec ta calculatrice
Casio
préférée. Cela peut donc être une fleur, un arbre, un animal...
Aucune obligation d'achat puisque tu peux parfaitement utiliser également l'émulateur de la calculatrice que nous te remettons si besoin en ressource gratuite 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
Graph 35+E II
ou
Graph 90+E
avec leur application
Python
Attention dans ce dernier cas, pour pouvoir bénéficier des tracés en
Python
(module
casioplot
)
, et éventuellement du module de tracés relatifs
turtle
, ta calculatrice doit faire tourner la dernière version :
Graph 35+E II
version
3.40
Graph 90+E
version
3.50
Si ce n'est pas le cas nous te remettons ici aussi de quoi mettre à jour gratuitement ta calculatrice en fin d'annonce.
Un jury composé de professeurs de Mathématiques désignera dans chaque catégorie 3 grands gagnants.
Dans chacune des 2 catégories donc, 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 Graph
au choix
Le 2ème meilleur dessin gagne pour sa part le non moins superbe lot suivant d'une valeur d'environ
180€
: 1
enceinte
bluetooth
+ 1
calculatrice graphique
Casio Graph
au choix
Le 3ème meilleur dessin gagne quant à lui le lot suivant d'une valeur d'environ
140€
: 1
montre
Casio vintage
or
+ 1
calculatrice graphique
Casio Graph
au choix
La calculatrice graphique au choix pourra être une
Graph 35+E II
ou
Graph 90+E
.
Mais ce n'est pas tout. Dans chaque catégorie, les 10 premières participations reçues et n'ayant pas remporté un des gros lots précédents recevront un lot de participation : un sac en toile
Casio
rempli de cadeaux
(batterie USB externe, stylo, clé USB, ...)
, alors vite dépêche-toi !
Les participations sont ouvertes à compter du
mercredi 27 janvier
. Tu auras jusqu'au
lundi 8 mars 2021
inclus pour envoyer par courriel à
education-france@casio.fr
:
une photo ou capture d'écran de ton dessin
le script qui le réalise
un justificatif de scolarité
(photo/scan de ton carnet de correspondance, de ta carte de collégien/lycéen, ou de tout autre document que tu juges pertinent)
Tu manques d'inspiration ? Tu ne connais pas suffisamment ta calculatrice ?
Casio
se propose même de t'aider à gagner en t'accompagnant ce
mercredi 27 janvier
au cours de 2 ateliers en ligne au choix tout spécialement dédiés aux dessins de printemps sur ses calculatrices :
14h-15h :
appli
Algorithmique
sur
fx-92+ Spéciale Collège
15h-16h :
appli
Python
sur
Graph 35+E II
et
Graph 90+E
Ils correspondant donc bien aux 2 catégories de participations, petits aperçus ci-contre.
Tu peux également aller consulter les scripts des dessins d'enseignants pour le concours de Noël sur
Si tu préfères les fleurs nous en avons également tout un champ sur
fx-92+ Spéciale Collège
suite à notre concours de rentrée 2018.
Bonne chance à toi !
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.
Superbe événement, à la coloration thématique fort bienvenue en cette période difficile.
De quoi te distraire et t'amuser quand tu rentres dans ta cage chaque soir à 18 heures ou prochainement pendant tes vacances d'hiver, et t'aider à rêver au retour du printemps et on espère avec lui de la liberté, merci
Casio
!
Nous avons hâte de voir si tu vas être capable de faire mieux que les enseignants à Noël...
ne partageaient pas le même clavier. Plusieurs différences, notamment sur la 5ème ligne en partant du haut :
la
TI-83 Premium CE
met en avant la saisie des fractions en écriture naturelle, de quoi basculer entre écritures exacte et décimale, la résolution d'équations et les matrices
les
TI-84 Plus CE
mettent quant à elles en avant les fonctions trigonométriques, la fonction inverse et les applications, reléguant ainsi tout ce qui précède à des fonctions secondaires ou menus
Saisir une fraction en écriture naturelle sur
TI-84 Plus CE
était donc beaucoup plus difficile que sur
TI-83 Premium CE
. Il fallait invoquer le menu déroulant de l'écran de calculs avec
alpha
y=
, puis choisir
1
.
Manipulation à 3 touches peu intuitive puisque rien au clavier n'indiquait la présence de ce menu, et un gros point faible également par rapport à la concurrence qui propose la fonctionnalité directement au clavier.
Avec le nouveau modèle européen de la rentrée 2020, la
était en effet indiqué au clavier, permettant donc en seulement 2 touches la saisie de fractions en écriture naturelle, raccourci géré par le système à compter de la version
5.3.0
.
Les raccourcis historiques
2nd
←
et
2nd
→
pour aller en début et fin de ligne devenaient eux aussi enfin indiqués au clavier.
L'Amérique du Nord et le reste du monde sont sur le point de bénéficier à leur tour de ces améliorations ; de nouvelles
TI-84 Plus CE
avec ces nouvelles indications de raccourcis au clavier commencent à apparaître !
On peut noter que ces nouvelles
TI-84 Plus CE
viennent avec un tout nouveau format de numéro de série qui n'indique plus en clair le timbre à date ni la révision matérielle, ici
B27400A89
. Voilà qui ne nous facilitera pas la vie à l'avenir...
Selon notre analyse très préliminaire de ce nouveau format, dont vous pouvez trouver plein d'exemples ici :
la lettre
B
initiale indique l'année d'assemblage, ici
2020
:
A=2019
B=2020
les 2 chiffres suivants
27
indiquent la semaine d'assemblage dans l'année, et donc ici 27ème semaine de 2020, soit en gros début juillet 2020
le caractère suivant
4
indique le type de calculatrice, ici une
TI-84 Plus CE
:
4 ou T = TI-84 Plus CE
5 = TI-84 Plus
6 = TI-83 Plus
et les 5 caractères suivants constituent un numéro de série en hexadécimal
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))
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)
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 disposait d'un mode monochrome, et était compatible à la fois
Graph 35+E II
et
Graph 90+E
, même si c'était sur cette dernière qu'il révélait son plein potentiel.
Voici l'astuce utilisée pour détecter le type d'écran :
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
:
faisait tomber la nuit :
Il utilise ici 2 dégradés dans les tons de bleu pour représenter le sol et le ciel.
allumait les étoiles
(pixels blancs)
plantait une forêt de sapins
- nous allons y revenir
décorait 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
saupoudrait 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'avais donc rajouté de quoi tracer des cercles, disques, mais également segments pour les sapins :
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 utilisait 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 étaient 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 faisait 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 avions dû limiter le nombre d'itérations afin de ne pas exploser la mémoire de tas
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)])
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()
Et puis c'était tout. Nous supposions qu'il y avait eu plus que 3 participants, mais les autres ne nous avaient à la différence et à notre connaissance rien partagé, ni en public ni en privé.
Et bien tu n'attendras pas plus longtemps,
Casio
nous publie enfin aujourd'hui les scripts
Python
du concours. Et voici donc de suite ceux qui nous manquaient.
Isabelle Vanacker
retourne à l'utilisation du module
turtle
et nous dresse un sapin sous une nuit étoilée.
On note la répétition de motifs identiques ou similaires
(étoiles et triangles du sapin)
.
Mais c'est codé proprement puisque les répétitions sont tracées par appels d'une même fonction.
Voici par exemple la fonction pour les triangles du feuillage du sapin, en fait des triangles rectangles isocèles :
for i in range(4): forward(50) right(90) forward(25) circle(10) right(90) forward(25) for j in range(3): right(90) forward(25) right(180) forward(25) right(90)
Merci à tous et merci
Casio
, un concours très réussi qui a encouragé la création de très beaux scripts. A quand un concours similaire ouvert aux élèves, que l'on voit si ils sont capables de faire mieux ?
(devineras-tu pourquoi ?
