[critor]

Quelle Calculatrice programmable Choisir 2020
(index des épisodes)

Episode 10 - Modules Python et modules de tracé

Dans les programmes actuels du lycée, le langage de programmation Python est donc essentiel, transversal à l'ensemble des enseignements scientifiques, qu'ils soient communs, de spécialité ou en option. Mais toutes les implémentations Python ne se valent pas pour autant. Aujourd'hui nous allons nous intéresser à l'éventail de modules Python offert pas les différentes calculatrices. Nous préciserons de plus leur caractère de standard à propriétaire, ainsi que la présence de modules de tracé (par pixels, coordonnées ou tortue).

Commençons par mettre de côté les modèles n'offrant aucune solution Python à ce jour :

• Esquisse GCEXFR
• Lexibook GC3000FR
• Casio fx-92+ Spéciale Collège
• Casio Graph 25+E
• Casio Graph 25+E II
• Casio fx-CP400+E
• TI-82 Advanced
• TI-84 Plus T
• TI-84 Plus CE-T

Correctement mise à jour, ta Casio Graph 90+E ou Graph 35+E II t'offre 4 modules :

• 3 modules standard :
  
  • builtins
  • math
  • random
• 1 module propriétaire : casioplot, module de tracé par pixels

De plus, tu as la possibilité de rajouter 2 modules standard supplémentaires :

• turtle (pour Graph 90+E ou Graph 35+E II), module de tracé à la tortue
• matplotlib.pyplot sous le nom matplotl (pour Graph 90+E ou Graph 35+E II), module de tracé par coordonnées

Toutefois attention, l'accès à ces modules rajoutés te sera interdit en mode examen.

Sur Graph 35+E II et Graph 75+E, il t'est possible de rajouter l'application CasioPython, avec 8 modules :

• 7 modules standard :
  
  • builtins
  • array
  • cmath
  • gc
  • math
  • random
  • sys
• 1 module relatif à l'implémentation : micropython

Attention, cette application restera hélas inaccessible en mode examen.

Les TI-83 Premium CE Edition Python et TI-84 Plus CE-T Python Edition si correctement mises à jour, t'offrent pour leur part 42 modules :

• 8 modules standard :
  
  • builtins
  • array
  • collections
  • gc
  • math
  • random
  • sys
  • time
• 34 modules propriétaires :
  
  • analogin
  • analogout
  • bbport
  • brightns
  • color
  • colorinp
  • conservo
  • dht
  • digital
  • led
  • light
  • lightlvl
  • loudness
  • magnetic
  • moisture
  • potentio
  • power
  • ranger
  • relay
  • rgb
  • rgb_arr
  • sound
  • squarewv
  • temperat
  • thermist
  • ti_graphics : module de tracé par pixels
  • ti_hub
  • ti_plotlib : module de tracé par coordonnées
  • ti_rover
  • ti_system
  • speaker
  • timer
  • vernier
  • vibmotor
  De plus, tu as la possibilité de rajouter 4 modules propriétaires supplémentaires :
  

  • ce_box : module de tracé par coordonnées (diagrammes en boîte)
  • ce_chart : module de tracé par coordonnées (histogrammes)
  • ce_quivr : module de tracé par coordonnées (flèches/vecteurs)
  • ce_turtl : module de tracé à la tortue

  Attention toutefois, l'accès à ces modules rajoutés te sera interdit une fois la calculatrice passée en mode examen.
  
  
  Si tu disposes d'une ancienne TI-83 Premium CE, tu as la possibilité de lui rajouter des capacités Python plus modestes en la connectant au TI-Python, un module externe lui apportant un coprocesseur 32 bits. Au menu les seuls 8 modules standard :
  

  • builtins
  • array
  • collections
  • gc
  • math
  • random
  • sys
  • time

  
  

  Un firmware tiers est également disponible pour ce module externe, et lui rajoutera 5 modules importables :
  

  • 1 module standard : cmath
  • 4 modules relatifs à l'interpréteur Python utilisé, ici CircuitPython :
    
    • board
    • micropython
    • os
    • storage

  Le TI-Python reste fonctionnel en mode examen.
  
  Mais attention toutefois, en France en tant que module externe, l'utilisation de cet appareil est strictement interdite aux épreuves d'examens.

Les TI-Nspire CX II pourront disposer du Python par simple installation d'une mise à jour qui sera disponible gratuitement d'ici quelques semaines.

Nous en disposons d'une préversion, mais n'avons hélas pas l'autorisation de te faire des révélations à son sujet. Si l'on s'en tient donc aux informations déjà montrées par Texas Instruments sur son site ou lors des formations en ligne, notamment les menus, tu pourras y exploiter au minimum 11 modules :

• 5+ modules standard :
  
  • builtins
  • cmath
  • math
  • random
  • time
  • ...
• 6+ modules propriétaires :
  
  • ti_plotlib, module de tracé par coordonnées
  • ti_hub
  • ti_rover
  • ti_system
  • ti_draw : module de tracé par pixels
  • ti_image : module de tracé par pixels (images)
  • ...
  
  
  Si tu disposes d'une TI-Nspire monochrome, il t'est possible d'installer Ndless puis MicroPython. Sont apportés 8 modules :
  

  • 6 modules standard :
    
    • builtins
    • array
    • cmath
    • math
    • sys
    • 1 module spécifique à l'implémentation : micropython
    • 1 module propriétaire : nsp, module de tracé par pixels entre autres
    Attention, MicroPython sera inaccessible en mode examen.
  
  
  Sur les anciennes TI-Nspire CX, tu ne pourras installer Ndless que si ta calculatrice n'a pas été mise à jour, faisant tourner une version 4.5.0 ou inférieure. Et dans ce cas tu peux installer beaucoup mieux que MicroPython.
  KhiCAS, adaptation pour ta calculatrice du logiciel de Mathématiques intégré Xcas par Bernard Parisse, enseignant-chercheur à l'Université de Grenoble, a en effet le gros avantage d'être programmable grâce à son interpréteur Python intégré, un MicroPython beaucoup plus étendu que le précédent avec pas moins de 26 modules :
  

  • 20 modules standard :
    
    • builtins
    • ubinascii
    • cmath
    • ucollections
    • uctypes
    • uerrno
    • gc
    • uhashlib
    • uheapq
    • linalg
    • math
    • matplotlib.pyplot sous le nom matplotl et les alias matplotlib, matplotlib_dot_pyplot et pylab : module de tracé par coordonnées
    • random
    • ure
    • sys
    • turtle, module de tracé à la tortue
    • uio
    • ujson
    • ustruct
    • uzlib
  • 2 modules relatifs à l'implémentation :
    
    • micropython
    • _os
  • 4 modules propriétaires :
    
    • arit
    • cas
    • graphic également sous les alias casioplot et kandinsky : module de tracé par pixels, compatible scripts Casio et NumWorks
    • nsp, module de tracé par pixels, compatible scripts MicroPython précédent
    Attention, KhiCAS sera hélas tout autant inaccessible en mode examen.

Sur NumWorks tu profites de 11 modules Python :

• 8 modules standard :
  
  • builtins
  • cmath
  • math
  • matplotlib, module de tracé par coordonnées
  • matplotlib.pyplot, module de tracé par coordonnées
  • random
  • time
  • turtle, module de tracé à la tortue
• 1 module spécifique à l'implémentation : micropython
• 2 modules propriétaires :
  
  • ion
  • kandinsky, module de tracé par pixels

Tu as de plus la possibilité d'installer le firmware tiers Omega et ensuite l'application KhiCAS, programmable via un interpréteur MicroPython intégré beaucoup plus complet. Au menu 26 modules :

• 20 modules standard :
  
  • builtins
  • ubinascii
  • cmath
  • ucollections
  • uctypes
  • gc
  • uhashlib
  • uheapq
  • linalg
  • math
  • matplotlib.pyplot sous le nom matplotl et les alias matplotlib et pylab : module de tracé par coordonnées
  • random
  • ure
  • sys
  • turtle, module de tracé à la tortue
  • uio
  • ujson
  • ustruct
  • utimeq
  • uzlib
• 2 modules relatifs à l'implémentation :
  
  • micropython
  • _os
• 4 modules propriétaires :
  
  • arit
  • cas
  • graphic également sous les alias casioplot et kandinsky : module de tracé par pixels, compatible scripts Casio et NumWorks
  • nsp, module de tracé par pixels, compatible scripts MicroPython pour TI-Nspire Ndless

Ici tout ceci restera accessible en mode examen !

Sur HP Prime une mise à jour rajoutant Python est en préparation, mais nous ignorons totalement quand est-ce qu'elle sortira. Rien ne semble bouger pour le moment pour cette rentrée 2020.
Une version alpha incluant l'application Python a été publiée par erreur en octobre 2019.

A titre informatif, nous allons donc te dire à quoi t'attendre au minimum, car bien évidemment la version a dû évoluer depuis.

Dans tous les cas nous te déconseillons très fortement d'installer la version alpha si tu dois passer des évaluations ou épreuves.

Cette version n'est absolument pas stable, avec des inconvénients qui hélas sortent du cadre de la seule application Python.

A venir donc au moins 9 modules :

• 7+ modules standard :
  
  • builtins
  • array
  • cmath
  • uerrno
  • gc
  • math
  • sys
• 1+ modules relatifs à l'implémentation : micropython
• 1+ modules propriétaires : prime, module de tracé par pixels et par coordonnées entre autres

Résumé des données, avec :

• en bas les seules capacités officielles d'origine utilisables en mode examen et en examen
• en haut l'ensemble des possibilités

[critor]

Grâce à la formidable ludothèque que sa communauté a su lui concocter depuis 2015, la TI-83 Premium CE est rapidement devenue la calculatrice couleur n°1 au lycée français. Une calculatrice cool et appréciée de ses utilisateurs, tout contents d'avoir à la fois un compagnon de travail, de réussite et de divertissement.

Avec plus de 108000 téléchargements, Oiram CE est chez nous le 2^ème jeu le plus populaire pour TI-83 Premium CE, et également le 2^ème fichier le plus téléchargé pour calculatrices. Publié en janvier 2017 par MateoConLechuga, il s'agit d'un moteur de jeu Mario-like aux sprites et gameplay très inspirés de Super Mario Bros 3.
De plus Oiram CE accepte des packs de niveaux pouvant être créés de façon totalement intuitive grâce à un éditeur, c'est toute une sous-communauté qui s'est formée au sein de la communauté avec à ce jour plus de 80 packs de niveaux perso !

La création de jeux de qualité professionnelle dans le genre d'Oiram ne se fait pas en Python mais en langage machine vulgairement appelé assembleur dans la communauté, un langage accessible officiellement depuis 1996 sur les calculatrices Texas Instruments. Ces jeux sont compilés sur-mesure vers le langage machine de la calculatrice, à partir de code source écrit en langage C ou assembleur.

Hélas, avec la mise à jour 5.5, Texas Instruments a brutalement décidé de sonner la fin de la récré. Toute installation d'une version 5.5 ou supérieure bloquera la capacité de la machine à exécuter des programmes en langage machine. Et bien évidemment, une fois une telle version installée c'est définitif, une inscription dans une zone non réinitialisable de ta machine refusera toute installation ultérieure d'une version inférieure.

La gestion des programmes en langage machine sur les calculatrices Texas Instruments vient donc d'être placée en voie d'extinction, un coup dur pour la communauté avec une grande part des fichiers servis gratuitement sur Internet désormais inutilisables. Des 100aines de jeux jetés aux oubliettes de l'histoire, des 10aines de niveaux perso bons pour la poubelle, des 1000iers d'heures de travail de passionnés parties en fumée, le tout bien évidemment sans aucune discussion préalable !

Il sera désormais énormément plus difficile sinon impossible de concevoir des créations de qualité professionnelle pour TI-83 Premium CE, seul le constructeur le pourra, et uniquement quand il en aura envie.

Nous n'avons aucune raison de te cacher la vérité, selon l'assemblage des éléments que nous avons cette décision découle de la lourde irresponsabilité d'un enseignant-vidéaste français très populaire qui, avec une vidéo anxiogène induisant en erreur sur certaines choses et trop complète sur d'autres, a de par sa visibilité gravement mis en danger le déroulement des épreuves d'examens ('heureusement' annulées cette année 2020 vu le contexte sanitaire) ainsi que l'image de Texas Instruments auprès des institutions réglementant ces mêmes examens. Pour le constructeur il s'agissait donc d'envoyer un signal fort aux institutions en question, quitte à taper sur des innocents n'ayant pourtant strictement rien à voir avec l'incident initial.

La communication du constructeur diffère bien évidemment de cela, car oui pour les utilisateurs qui téléchargent leurs mises à jour sur le site officiel l'information est bel et bien présente au sein d'un paragraphe sur les pages en question, un paragraphe peut-être un peu trop long vu le public ciblé, pouvant de plus être pris de par sa position comme un résumé des contrats de licence de logiciels que pas grand monde ne lit :

Chez TI, nous travaillons constamment sur des moyens d'améliorer nos produits pour donner aux étudiants plus d'occasions d'apprendre, d'explorer et d'étudier les mathématiques et les sciences. Après un examen attentif, nous avons pris la décision de supprimer la fonctionnalité ASM dans notre dernière mise à jour du système d'exploitation pour prioriser l'apprentissage et minimiser les risques de sécurité. Nous pensons que cela aidera également les élèves à se concentrer sur l'apprentissage des mathématiques et des sciences. Une fois que vous aurez mis à jour la version 5.5 du système d'exploitation pour la TI-83 Premium CE, vous ne pourrez pas passer à une version antérieure.

Nous ignorons la part de vérité là-dedans, peut-être s'agit-il juste d'une façon de présenter la chose tout en s'assurant l'approbation et la sympathie de certains enseignants.

Nous ignorons si il y a vraiment des enseignants psychorigides qui ont été capables de se plaindre d'avoir des élèves qui jouent sur leur TI-83 Premium CE. Car si c'est le cas, enseignants concernés et constructeurs vont totalement à l'encontre des nouveaux programmes du collège qui préconisent de concevoir des jeux, et donc par extension des nouveaux programmes du lycée.

De nos jours où le smartphone est de plus en plus discret et difficile à interdire, il vaut largement mieux que la soupape de sécurité soit la calculatrice plutôt que le smartphone.

Sur smartphone la gratuité des applis n'est bien souvent qu'apparente, bombardant l'utilisateur de publicités pour l'amener à micro-consommer au sein de l'appli ou même consommer tout court. Et imaginez jusqu'où peuvent aller les responsabilités si une transaction finalement pas si micro que ça est enregistrée sur un horaire de cours...
Sur calculatrices il n'y a rien de tout ça, nous avions un environnement totalement sain. Cela faisait trois décennies que des générations de passionnés se relayaient à partager leurs créations totalement gratuites.

Sur smartphone la quasi totalité des applis enferment l'utilisateur dans son rôle de simple utilisateur ou pire consommateur, aucune possibilité de contribuer.
Sur calculatrices nous nous battions sans relâche et avec succès depuis des années pour que le code source des créations soit disponible sous licence ouverte, permettant à l'utilisateur une fois le jeu pris en main de franchir le pas vers un rôle plus actif de créateur ou développeur, pouvant consulter le code source pour le comprendre, s'en inspirer ou le réutiliser.

A vouloir tout contrôler on finit par ne plus rien contrôler. Et si il est impossible d'interrompre l'écoulement d'une rivière, on peut par contre facilement en dévier le cours.

Il n'y a pas à s'inquiéter d'avoir un élève en situation de réussite différée qui joue sur sa calculatrice. Contrairement au smartphone où la marche à franchir est bien plus haute, il y a, enfin avait, la chance extraordinaire de pouvoir s'appuyer sur son intérêt pour l'amener à comprendre le fonctionnement de son jeu, les algorithmes mathématiques qu'il y a derrière, et l'amener progressivement vers un rôle plus actif de créateur et donc vers la réussite, conformément aux programmes scolaires.
Il y a différentes façons d'arriver à la réussite sinon les marchés du périscolaire et soutien scolaire n'existeraient pas ; nous déplorons que notre valeur ajoutée, contribuée de façon totalement bénévole et désintéressée depuis des années, ait pu être niée à ce point.

Et justement sèche tes larmes, grâce à l'ouverture du code source, Oiram CE n'est pas mort. Thomas Williamson vient en effet de le porter pour calculatrices Casio couleur Graph 90+E et fx-CG10/20/50, avec l'aide et la bénédiction de MateoConLechuga !

Le temps de te laisser quelques secondes pour assimiler tout ce que cela implique, notons une icône d'application animée avec humour et talent lorsqu'on la sélectionne.

Et ce n'est pas tout car Thomas fait rarement les choses à moitié ; les fichiers de niveaux perso sont également gérés, après un tel désespoir nous avons les larmes aux yeux de voir qu'ils vont eux aussi pouvoir survivre !

Rien de compliqué, il te suffit de copier directement les fichiers de niveaux .8xv de ta TI-83 Premium CE sur ta Casio Graph 90+E ou compatible, et le nouvel Oiram se charge de tout, c'est magique !

C'est même plus qu'un portage, il faudrait plutôt parler d'adaptation, ce qui est loin d'être un défaut.

Ce n'est certes pas ce que l'on retenait, mais pour t'offrir un gameplay fluide et dynamique malgré les performances très modestes de la TI-83 Premium CE, Oiram CE se jouait sur un demi-écran, 320×128 pixels au lieu de 320×240, soit 53,33%.

Sur ta superbe Casio Graph 90+E ou compatible au matériel très supérieur, l'affichage du niveau en cours remplit bien mieux la hauteur de l'écran avec désormais 320×176 pixels pour une toute nouvelle dimension de jeu ; tu pourras mieux anticiper grâce à une meilleure vision des éléments et notamment bonus présents au-dessus et en-dessous de Mario !

La communauté Texas Instruments aujourd'hui en miettes fait ainsi don de Oiram CE, sa plus grande création, à la communauté Casio. Qu'elle continue à le faire vivre et évoluer, et tant mieux si il lui apporte succès et prospérité, les milliers d'heures de travail passées là-dessus n'auront alors pas été en vain, que le projet ne soit pas oublié c'est tout ce qui compte.

La Casio Graph 90+E est désormais la nouvelle calculatrice la plus cool au lycée, la meilleure plateforme nomade scolaire pour les jeux et le développement de jeux ; Oiram CE nous te souhaitons bon voyage et bon vent, nous t'avons tant aimé !

Téléchargements :

• Oiram (pour Casio Graph 90+E et fx-CG10/20/50)
• Oiram CE (pour TI-83 Premium CE et TI-84 Plus CE)
• bibliothèques C (pour TI-83 Premium CE et TI-84 Plus CE)
• packs de niveaux perso Oiram CE / Oiram
• éditeur de niveaux Oiram CE (Windows + Mac)

Référence : https://www.planet-casio.com/Fr/forums/ ... 412--.html

[critor]

Aujourd'hui juste à temps pour la rentrée, Texas Instruments nous sort la nouvelle version 5.6 de TI-Connect CE, son logiciel de connectivité pour les TI-83 Premium CE, TI-82 Advanced et leurs équivalents hors de France TI-84 Plus CE et TI-84 Plus T. Il s'agit plus précisément de la version 5.6.0.2082.

Notons au passage le respect dont Texas Instruments fait maintenant preuve envers ses utilisateurs, les avertissant sur la page du logiciel, ou du moins ceux qui se donnent la peine de lire, que toute installation de la mise à jour 5.5 avec ce logiciel supprimera la capacité de la calculatrice à exécuter des programmes en langage machine, et qu'une fois effectuée il sera impossible de revenir en arrière :

Chez TI, nous travaillons constamment sur des moyens d'améliorer nos produits pour donner aux étudiants plus d'occasions d'apprendre, d'explorer et d'étudier les mathématiques et les sciences. Après un examen attentif, nous avons pris la décision de supprimer la fonctionnalité ASM dans notre dernière mise à jour du système d'exploitation pour prioriser l'apprentissage et minimiser les risques de sécurité. Nous pensons que cela aidera également les élèves à se concentrer sur l'apprentissage des mathématiques et des sciences. Une fois que vous aurez mis à jour la version 5.5 du système d'exploitation pour la TI-83 Premium CE, vous ne pourrez pas passer à une version antérieure.

Bref, survolons ensemble les améliorations de TI-Connect CE 5.6.

Avec la version précédente, toute TI-83 Premium CE connectée était décrite en tant que TI-83 Premium CE, même les TI-83 Premium CE Edition Python.

Ce qui pouvait induire en erreur les utilisateurs notamment enseignants connectant différents modèles, les conduisant à de fausses manipulations.

Première nouveauté qui saute aux yeux, TI-Connect CE nous distingue enfin visuellement les TI-83 Premium CE Edition Python des anciennes TI-83 Premium CE. En effet maintenant, les TI-83 Premium CE Edition Python connectées sont clairement indiquées comme telles !

Précisons toutefois que les TI-84 Plus CE-T Python Edition à la différence ne disposent apparemment toujours pas d'une mention spécifique en ce sens.

Dans le contexte du Python, TI-Connect CE 5.4 avait commencé à introduire des interdictions de transfert de fichiers incompatibles :

• application PyAdaptr interdite de transfert sur TI-83 Premium CE Edition Python
• application Python interdite de transfert sur les anciennes TI-83 Premium CE

Il s'agit bien d'un refus du transfert au niveau de TI-Connect CE, puisque des logiciels de connectivité tiers comme TiLP l'effectuent sans problème.

Toutefois, les deux applications pouvaient paradoxalement toujours être transférées sans problème sur les TI-84 Plus CE, bien que n'ayant aucune chance d'y fonctionner.

Non pas que cela nous dérange, mais ce n'était absolument pas logique.

De façon logique, TI-Connect CE 5.6 rafraîchit ses interdictions d'applications en tenant compte des TI-84 Plus CE, même si la formulation des messages d'erreur diffère :

• application PyAdaptr interdite de transfert sur TI-83 Premium CE Edition Python et TI-84 Plus CE-T Python Edition
• application Python interdite de transfert sur les anciennes TI-83 Premium CE, anciennes TI-84 Plus CE-T et TI-84 Plus CE

Egalement nous avions un problème très gênant depuis l'année dernière, que tu avais peut-être remarqué.
Il se produit lorsque l'on met à jour un modèle non-Python (ancienne TI-83 Premium CE, ancienne TI-84 Plus CE-T ou TI-84 Plus CE) avec une version supportant Python. Plus précisément lorsque l'on utilise non pas le fichier de mise à jour du système (.8pu ou .8eu) mais un pack de mise à jour (fichiers .b83 ou .b84 dits bundles).
Ces packs de mise à jour sont en fait des archives PKZip contenant plusieurs fichiers :

• le fichier de mise à jour du système (.8pu ou .8eu) qui sera envoyé en premier
• les fichiers des différents éléments officiels préchargés sur les machines neuves (applications, images, ...) et qui seront envoyés à la suite, après redémarrage et reconnexion automatique de la calculatrice en fin de transfert du nouveau système

Problème, les versions récentes de ces packs contiennent des éléments Python incompatibles avec les anciens modèles, ce qui donnait lieu à un message d'erreur.
Et même 4 messages d'erreur en fait, puisqu'il y avait 4 éléments Python incompatibles : GRAPH.8xv, LINREG.8xv, TISTEMEN.8xv et TISTEMFR.8xv.

Message d'erreur bloquant que tu devais donc valider 4 fois afin que la mise à jour puisse se poursuivre. Et pas 4 fois de suite non plus, car les fichiers concernés n'étaient en prime pas les uns à la suite des autres dans l'archive, tu étais donc bloqué(e) pendant une bonne partie du processus de mise à jour.

Très lourd pour un enseignant mettant à jour un lot de calculatrices... Très embêtant aussi car il suffisait d'aller faire autre chose pendant le processus pour se retrouver avec une mise à jour incomplète, le nouveau système mais avec les anciennes applications.

Et ben tu peux enfin souffler, Texas Instruments a enfin corrigé ce problème.

Dans le cas d'envoi d'un pack de mise à jour, TI-Connect CE 5.6 a la bonne idée de ne plus s'interrompre pour te signaler les éléments incompatibles qu'il ne transfère pas, il les saute dorénavant de façon totalement silencieuse et non bloquante !

Ah et petit détail, Texas Instruments a rajouté un lien vers son parcours en ligne de prise en main des fonctionnalités Python, le TI Code Python.

Source: https://education.ti.com/fr/software/de ... cesoftware
Téléchargement : TI-Connect CE 5.6 pour Windows / Mac

[critor]

La solution Python de la TI-83 Premium CE Edition Python dispose d'un formidable avantage, la gestion officielle des images.

Contrairement à la concurrence ici c'est ultra simple, une seule ligne de Python te suffira à afficher l'image de ton choix, ti_graphics.drawImage('nom_image', x, y) !
Pas besoin donc d'inclure les données de ton image dans ton script, ce qui économise la mémoire de tas (heap) du Python.
Et aucun besoin non plus de t'embêter à réinventer la roue à coder une fonction d'affichage d'image !

De plus comme tu le remarqueras ci-contre, le format d'image en question est très loin d'être rudimentaire, gérant jusqu'à 256 couleurs différentes avec éventuellement 1 couleur transparente.

De quoi démarrer très rapidement des activités ou projets Python ambitieux sans avoir à buter sur des difficultés secondaires.
Des possibilités formidables aussi bien pour l'élève que l'enseignant, notamment en SNT ainsi qu'en spécialité NSI.

Et justement pour cette rentrée 2020, Texas Insruments t'apporte de quoi agrémenter tes futurs projets, avec l'ouverture de sa banque d'images déjà converties au format IM8C de la calculatrice.

Frederick Fotsch de TI-Dallas t'a concocté un assortiment de pas moins de 13 images, toutes sous licence CC BY-NC et donc librement utilisables pour les activités et projets scolaires.

Rappelons en passant que l'écran de ta TI-83 Premium CE Edition Python fait 320×240 pixels, mais que la barre de statut de 30 pixels de hauteur en haut d'écran ne peut être masquée.
Pour l'affichage de tes images tu disposes donc d'une zone de 320×210 pixels, ou 320×190 pixels si tu ne souhaites pas masquer la barre de menu de 20 pixels de hauteur en bas d'écran.

Au menu donc :

• la charmante SuperGirl en 3 tailles différentes :
  
  • 200 pixels de hauteur
  • 150 pixels de hauteur
  • 100 pixels de hauteur
  
• son compagnon SuperBoy en 3 versions différentes :
  
  • 200 pixels de hauteur
  • 150 pixels de hauteur
  • 100 pixels de hauteur, avec fond transparent
  
• dans un autre registre SuperDupont dessiné par Jean Solé
• un requin
• une cible, avec fond transparent
  
  
• une fleur de tournesol en 2 versions différentes :
  
  • 320×210 pixels plein écran
  • 320×190 pixels préservant la barre de menu de bas d'écran
  
• panneau de départ GO
• panneau d'arrêt STOP, avec fond transparent

Nous avons hâte de voir ce que tu vas être capable d'imaginer comme projets et activités avec tout ça, n'hésite pas à partager tes créations !

Téléchargements :

• SuperGirl (200, 150 et 100 pixels de hauteur)
• SuperBoy (200, 150 et 100 pixels de hauteur)
• SuperDupont
• SunFlower / tournesol (320×210 et 320×190 pixels)
• Shark180 / requin
• board / cible
• GO / départ
• STOP / arrêt

Source : https://resources.t3europe.eu/t3europe- ... ce_id=3059

[critor]

Quelle Calculatrice programmable Choisir 2020
(index des épisodes)

Episode 9 - Ecrans et profondeurs

L'écran est décidément un élément incontournable de ta calculatrice graphique. Après avoir couvert dans des épisodes précédents ses dimensions, définition et zone graphique, nous allons aujourd'hui traiter de sa profondeur, c'est-à-dire du nombre de couleurs différentes qu'il peut afficher.

Commençons par enfoncer les portes ouvertes, avec les modèles dont le contrôleur écran ne gère que 1 bit de profondeur, ne permettant donc que 2¹= 2 couleurs différentes.

D'une part, voici les modèles à cristaux liquides bleus, affichant donc en bleu et blanc :

• Esquisse GCEXFR
• Lexibook GC3000FR
• Casio Graph 25+E

Et voici les modèles à cristaux liquides noirs, affichant en noir et blanc :

• Casio Graph 25+E II
• Casio Graph 35+E
• Casio Graph 35+E II
• Casio Graph 75+E
• TI-82 Advanced
• TI-84 Plus T
• Casio fx-92+ Spéciale Collège

Passons maintenant aux choses sérieuses ; nous allons te présenter notre protocole de test.

Notre idée est donc d'afficher une mire avec des dégradés des composantes primaires rouge-vert-bleu, afin de déterminer le nombre de bits utilisés par chacune.

Histoire d'avoir un script de test aussi universel que possible, commençons par ressortir nos fonctions Python magiques que nous t'avons déjà présentées :

• get_pf() pour récupérer un code identifiant la plateforme détectée
• get_pixel_functions(pf) pour récupérer les fonctions de lecture/écriture des pixels correspondant à la plateforme en question

Code: Select all

# detects calculator Python platform
def get_pf():
  c256 = True
  try:
    if chr(256)==chr(0):
      # Xcas/KhiCAS Python compatibility
      if "HP" in version():
        return 13 # HP Prime
      else:
        if not white:
          return 12 # Graph 35+E II
        elif "Numworks" in version():
          return 10 # NumWorks
        elif "Nspire" in version():
          return 8 # Nspire
        else: # Graph 90+E
          return 11
  except:
    c256 = False
  try:
    import sys
    try:
      if sys.platform == "nspire":
        try: # Nspire Ndless
          import graphic
          return 7 # KhiCAS Micropython
        except: # MicroPython
          return 6
      elif sys.platform == "TI-Nspire":
        return 3 # Nspire CX II
      elif sys.platform == "numworks":
        return 9 # NumWorks KhiCAS Micropython
      elif sys.platform.startswith('TI-Python'):
        return 2 # 83P/84+ CE
    except: # Graph 35+E/USB / 75/85/95
      return 5
  except:
    pass
  if not c256:
    return 1 # Graph 90/35+E II
  try:
    import kandinsky
    return 0 # NumWorks
  except:
    try: # HP Prime
      import hpprime
      return 4
    except:
      pass
  return -1

#return get_pixel and set_pixel functions for the platform
gp_prime = lambda x, y: GETPIX_P(x, y)
sp_prime = lambda x, y, c: PIXON_P(x, y, c)
def get_pixel_functions(pf):
  gp, sp = lambda: None, lambda: None
  if pf == 0: # NumWorks
    import kandinsky
    gp, sp = kandinsky.get_pixel, kandinsky.set_pixel
  elif pf == 1: # Graph 90/35+E II
    import casioplot
    gp, sp = casioplot.get_pixel, casioplot.set_pixel
  elif pf == 2: # 83P/84+ CE
    import ti_graphics
    gp, sp = ti_graphics.getPixel, ti_graphics.setPixel
  elif pf == 3: # Nspire CX II
    pass
  elif pf == 4: # HP Prime
    import hpprime
    sp = hpprime.pixon
  elif pf == 6: # Nspire: Ndless MicroPython
    from nsp import Texture
    canvas = Texture(320, 240, 0)
    gp, sp = canvas.getPx, canvas.setPx
  elif pf == 7 or pf == 9: # Nspire/NumWorks: KhiCAS-MicroPython
    import graphic
    gp, sp = graphic.get_pixel, graphic.set_pixel
  elif pf == 13: # HP Prime
    gp, sp = gp_prime, sp_prime
  return gp, sp

Voici de quoi récupérer tout ça :

Code: Select all

gp, sp = get_pixel_functions(pf)
sw, sh, sy0 = scr_infos(pf)

Maintenant que nous connaissons les positions et tailles des zones graphiques contrôlables par les scripts Python, faisons une fonction permettant de les récupérer rapidement cette fois-ci sans avoir à tester l'écran :

Code: Select all

#returns platform screen infos : width, height, color_mode/bits
def scr_infos(pf):
  #                                              uPy       uPy
  #                G352                CPy  uPy  KhiCAS--------------------->  CAS
  #           NW   G90  CE   CX2  HP   GXX  NS   NS   NS   NW   NW   G90  G352 HP
  l_vlines = (222, 192, 210, 212, 240, 064, 240, 222, 222, 222, 222, 192, 064, 240)
  l_vcols  = (320, 384, 320, 318, 320, 128, 320, 320, 320, 320, 320, 384, 128, 320)
  l_y0     = (000, 000, 030, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000)
  l_modes  = (000, 000, 000, 016, 032, 000, 016, 000, 016, 000, 016, 016, 001, 032)
  return l_vcols[pf], l_vlines[pf], l_y0[pf], l_modes[pf]

Il y a 2 façons de coder les couleurs dans le contexte des pixels en Python :

• soit avec un tuple (r,g,b) décrivant les valeurs de chaque composante primaire rouge-vert-bleu par un entier de 0 à 255
• soit par un nombre entier qui sera directement la valeur fournie au contrôleur écran

Prévoyons une fonction pour tester le codage utilisé, par simple vérification du type de retour d'une lecture de pixel.
Dans le cas d'un retour de type entier, tentons de plus en passant de détecter le nombre de bits gérés par le contrôleur écran, en écrivant des valeurs de pixels de plus en plus grandes et vérifiant à chaque fois si le pixel concerné a bien pris la valeur en question.

Code: Select all

#0: (R,G,B) >0: RGB-bits
def get_color_mode():
  c = gp(0, 0)
  try:
    c[2]
    return 0
  except:
    b, v = 0, 1
    x, y = 0, sy0
    sp(x, y, v)
    while gp(x, y) == v:
      b += 1
      v *= 2
      sp(x, y, v)
    return b

Un appel color_mode = get_color_mode() pourra donc renvoyer par exemple :

• 0 : pour un codage des couleurs par des tuples (r,g,b)
• 15 : pour un codage des couleurs sur des entiers de 15 bits
• 16 : pour un codage des couleurs sur des entiers de 16 bits
• 24 : pour un codage des couleurs sur des entiers de 24 bits
• ...

Pour notre script universel il faudra bien choisir un codage plutôt qu'un autre, alors prévoyons une fonction de conversion :

Code: Select all

def fixcolor(c, bits=16):
  try:
    if not color_mode:
      return c
    r, g, b = c[0], c[1], c[2]
  except:
    if color_mode == bits:
      return c
    if bits == 16:
      br, bg, bb = 5, 6, 5
    else:
      br, bg, bb = 8, 8, 8
    r, g, b = c & (2**br - 1) * 2**(8 - br), c & ((2**bg - 1) * 2**br) // 2**br * 2**(8 - bg), c & ((2**bb - 1) * 2**(br + bg)) // 2**(br + bg) * 2**(8 - bb)
  if not color_mode:
    return (r, g, b)
  else:
    if color_mode == 16:
      br, bg, bb = 5, 6, 5
    else:
      br, bg, bb = 8, 8, 8
    r, g, b = r // 2**(8 - br), g // 2**(8 - bg) * 2**br, b // 2 **(8 - bb) * 2**(br + bg)
    c = r + g - (r & g)
    return c + b - (c & b)

Voici de quoi tracer des lignes verticales et horizontales :

Code: Select all

def draw_vline(x, y1, y2, c):
  for j in range(y2 - y1 + 1):
    sp(x, y1 + j, c)

def draw_hline(y, x1, x2, c):
  for j in range(x2 - x1 + 1):
    sp(x1 + j, y, c)

Et voici enfin notre code de tracé de la mire :

Code: Select all

#o: 0=horizontal, 1=vertical
#s: 0=no_shadow, 1=shadow left/up, -1=shadow right/down
def mire(s=1, o=0, w=sw, h=sh, y0=sy0):
  if o:
    l1, l2, f, i1, i2 = h, w, draw_hline, y0, 0
  else:
    l1, l2, f, i1, i2 = w, h, draw_vline, 0, y0
  n = 8
  for m in range(l1):
    v = 255
    if s != 0:
      v =  v * (s*m % l1) // (l1 - 1)
    for j in range(n):
      f(m + i1, j * l2 // n + i2, (j + 1) * l2 // n - 1 + i2, fixcolor(color8(j, v)))

def color8(j, v):
  c = [0, 0, 0]
  for b in range(3):
    if j & 2**b:
      c[b] = v
  return c

Tu vas vite comprendre tout ça avec notre premier exemple.

Commençons donc par les TI-83 Premium CE Edition Python et TI-84 Plus CE-T Python Edition que nous allons tester en Python.
Nous considérerons que c'est pareil sur les anciennes TI-83 Premium CE et TI-84 Plus CE.

Cela ne t'apprendra sans doute rien mais histoire de vérifier que ça marche, d'après get_color_mode() sur TI-83 Premium CE Edition Python et TI-84 Plus CE Python Edition les couleurs de pixels sont codées en Python par des tuples (r,g,b).

On peut noter ci-contre que le vert ainsi que les couleurs composées de vert (cyan, jaune et blanc) ont un dégradé beaucoup moins saccadé, beaucoup plus fluide. En effet si tu regardes bien elles utilisent 2 fois plus de teintes intermédiaires, très exactement 64 teintes contre 32 pour les autres :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Voici maintenant la Casio Graph 90+E et son superbe écran.

Ici encore les paramètres de couleur sont passés sous forme de tuples (r,g,b).

Même constat ici, nous notons 2 fois plus de teintes intermédiaires pour les dégradés de vert et de couleurs incluant du vert :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Arrive maintenant la NumWorks.

Avec l'application Python officielle, les paramètres de couleur prennent toujours la forme de tuples (r,g,b).

Encore pareil, 2 fois plus de teintes intermédiaires dans le vert :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Tu peux installer le firmware tiers Omega et ensuite, si tu disposes du dernier modèle NumWorks N0110, l'application KhiCAS, une adaptation pour ta calculatrice du logiciel intégré de Mathématiques Xcas par Bernard Parisse, enseignant-chercheur à l'université de Grenoble, et programmable grâce à son interpréteur MicroPython intégré.

Pas de raison que la mire soit différente, mais précisons tout de même au passage que cette édition de KhiCAS fonctionne elle aussi avec des tuples (r,g,b).

Passons donc aux TI-Nspire. Nous disposons d'une préversion de la prochaine mise à jour 5.2 rajoutant Python aux TI-Nspire CX II, mais hélas nous n'avons pas à ce jour l'autorisation de te faire de nouvelles révélations à son sujet.

Donc tant pis, adaptons notre script de mire dans le langage orienté fonction historique de la machine.
Et nous considérerons que c'est pareil sur les anciennes TI-Nspire CX.

Code: Select all

Define mire(s,o,w,h)=
Prgm
  Local l1,l2,f,c,j,m,n,v
  If o≠0 Then
    l1:=h
    l2:=w
    Define f(y,x1,x2,c)=Prgm
      SetColor c[1],c[2],c[3]
      DrawLine x1,y,x2,y
    EndPrgm
  Else
    l1:=w
    l2:=h
    Define f(x,y1,y2,c)=Prgm
      SetColor c[1],c[2],c[3]
      DrawLine x,y1,x,y2
    EndPrgm
  EndIf
  n:=8
  For m,0,l1-1
    v:=int(255*when(s=0,1,((mod(s*m,l1))/(l1-1))))
    For j,0,n-1
      f(m,((j*l2)/(n)),(((j+1)*l2)/(n))-1,color8(j,v))
      EndFor
  EndFor
EndPrgm

Define color8(j,v)=
Func
  Local l,k
  l:=newList(3)
  For k,1,dim(l)
    If mod(int(((j)/(2^(k-1)))),2)≠0 Then
      l[k]:=v
    EndIf
  EndFor
  Return l
EndFunc

Toujours 2 fois plus de teintes intermédiaires tirant sur le vert :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Sur les anciennes TI-Nspire CX et TI-Nspire monochromes soit donc avant la version 5.0, le langage interprété ne dispose hélas pas des fonctions de tracé.

Adaptons donc notre mire dans le langage de script Lua :

Code: Select all

o = false
s = 1

function on.charIn(c)
  print(c)
  olds, oldo = s, o
  if c == "−" or c == "-" then
    s = -1
  elseif c == "+" then
    s = 1
  elseif c == "0" then
    s = 0
  elseif c == "*" or c == "/" then
    o = not o
  end
  if s ~= olds or o ~= oldo then
    platform.window.invalidate()
  end
end

function on.resize(w, h)
  platform.window.invalidate()
end

function color8(j, v)
  l={0, 0, 0}
  for k = 1, #l do
    if math.floor(j / 2^(k - 1)) % 2 ~= 0 then
      l[k] = v
    end
  end
  return l
end

function on.paint(gc)
  pw = platform.window
  w, h = pw.width(), pw.height()
  if o then
    l1, l2 = h, w
    function f(gc, y, x1, x2, c)
      gc:setColorRGB(c[1], c[2], c[3])
      gc:drawRect(x1, y, x2, y)
    end
  else
    l1, l2 = w, h
    function f(gc, x, y1, y2, c)
      gc:setColorRGB(c[1], c[2], c[3])
      gc:drawRect(x, y1, x, y2)
    end
  end
  n = 8
  for m = 0, l1 - 1 do
    v = 255
    if s ~=0 then
      v = v * (s * m % l1) / (l1 - 1)
    end
    for j = 0, n - 1 do
      f(gc, m, j * l2 / n, (j + 1)*l2/n - 1, color8(j, v))
    end
  end
end

Sur les TI-Nspire monochromes nous avons donc 4 bits pour 2⁴= 16 niveaux de gris.

Cela ne changera rien au résultat, mais précisons que sur les anciennes TI-Nspire monochromes et TI-Nspire CX si munie d'une version 4.5.0 ou inférieure, tu peux installer Ndless puis MicroPython. Dans ce cas les paramètres de couleur ne sont pas des tuples, mais des entiers sur 16 bits. Heureusement que nous avions prévu notre fonction de conversion automatique.

Sur les anciennes TI-Nspire CX, il est de plus possible dans ce cas d'installer la version de KhiCAS en cours de développement, avec son propre interpréteur MicroPython intégré.

Ici on retrouve la spécification des couleurs sous forme de tuples (r,g,b).

Sur Casio fx-CP400+E nous ne pouvons hélas pas te programmer de mire.
En effet dans le langage interprété historique de la machine et seul langage qui nous est accessible, le paramètre de couleur des fonctions graphiques ne peut prendre que 7 valeurs différentes.

Alors plan B, générons et enregistrons notre mire sous forme d'image, et convertissons-la en image .c2p pour la calculatrice à l'aide de notre convertisseur en ligne.

Toujours le même résultat avec 2 fois plus de teintes intermédiaires dans les tons de vert :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

On peut remarquer un petit bug d'affichage dans le dégradé de bleu, comme si la teinte la plus claire avait été marquée en tant que couleur transparente.

Mais ce n'est pas un bug lié à notre convertisseur, nous obtenons exactement le même défaut en utilisant le logiciel de conversion officiel de Casio. Le problème se situe donc ou dans le format, ou dans la calculatrice...

Et enfin nous arrive la HP Prime. Une version alpha très préliminaire incluant une application Python a été diffusée en octobre 2019.

Toutefois hélas, son module graphique n'offre de fonction que pour écrire les pixels, pas pour les lire. Impossible donc ici d'y détecter automatiquement le format de couleur.

Revenons donc sur une version plus stable, et passons la calculatrice en mode CAS afin d'y exploiter la compatibilité syntaxique Python.
Grosse surprise, les paramètres de couleur sont ici détectés comme étant des entiers codés sur 24 bits !

Ici c'est ainsi fantastique, des dégradés extrêmement fluides et ce peu importe la teinte !

• canal rouge sur 8 bits pour 2⁸= 256 teintes
• canal vert sur 8 bits pour 2⁸= 256 teintes
• canal bleu sur 8 bits pour 2⁸= 256 teintes

Total donc 24 bits pour 2²⁴= 16777216 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 888 !

Résumé donc des données collectées jusqu'à présent sur les écrans, avec :

• en bas les capacités officielles de la machine en mode examen
• en haut les possibilités hors mode examen