[critor]

Pour la rentrée 1990, Texas Instruments démarrait sa formidable odyssée dans le monde des calculatrices graphiques avec son tout premier modèle TI-81, muni d'un processeur Zilog z80 8 bits et dépourvu d'un port de communication.

Ce modèle était programmable dans une première version de ce qu'on appelle aujourd'hui le langage TI-Basic. Les premiers fans Texas Instruments furent rapidement confrontés aux limites de ce langage. D'une part il s'agit d'un langage interprété, c'est-à-dire que les lignes sont lues une par une à l'exécution et alors seulement traduites en instructions machine pour exécution. Un langage donc assez lent, peu adapté aux jeux notamment. D'autre part tu étais limité(e) aux seules instructions prévues par Texas Instruments, à l'époque peu nombreuses. Pas de gestion des chaînes de caractères, matrices ou images, et bien qu'il y ait eu des progrès c'est encore assez rudimentaire sur ces dernières aujourd'hui.

Pour la rentrée 1992, Texas Instruments récidive avec la TI-85, munie d'un langage similaire étendu avec les matrices, et cette fois-ci d'un port de communication, dans la version normale de la calculatrice. Mais Texas Instruments allait ici avoir quelques surprises...

Car en novembre 1994 Dan Eble, Magnus Hagander et Rob Taylor sont entrés dans l'histoire en tant que pionniers avec ZShell. Premier shell assembleur pour la TI-85, ZShell est un outil qui permettait :

1. de programmer en langage assembleur z80 sur ton ordinateur
2. de compiler le code en question en langage machine TI-85
3. d'encapsuler le code machine obtenu dans un format de variable transférable sur TI-85, ici des chaînes de caractères
4. et enfin d'exécuter les variables en question une fois transférées sur la TI-85

Sur calculatrice, l'installation de ZShell exploitait une faille dans une fonctionnalité officielle, la possibilité de transférer et recevoir des backups (sauvegardes), et donc de réécrire intégralement le contenu de la mémoire RAM avec tout ce que l'on voulait. Un fichier backup tout spécialement trafiqué était ainsi fourni pour l'installation de ZShell sur calculatrice. Ce fut pour la communauté Texas Instruments alors naissante une formidable révolution. Des dizaines de programmes codés en assembleur sont sortis en quelques mois pour ZShell et d'autres shells s'en inspirant. De formidables jeux, des outils révolutionnaires à l'époque (affichage d'images, sortie son sur le port série mini-Jack 2.5 de la calculatrice, ...). ZShell aura, pour un temps, contribué à changer la face du monde.
https://www.ticalc.org/pub/85/asm/

La TI-92 sort pour la rentrée 1995 avec cette fois-ci un processeur Motorola 68k 16 bits, un modèle alors révolutionnaire avec le calcul formel issu du logiciel Derive, ainsi qu'une application de géométrie dynamique. Le langage de programmation toujours appelé TI-Basic n'avait rien à voir avec les précédents, étant cette fois-ci construit autour de la définition et l'appel de fonctions. Il n'en restait toutefois pas moins un langage interprété avec donc les mêmes défauts de vitesse et dans une moindre mesure de puissance.

10 Novembre 1995 soit à peine quelques semaines après la disponibilité du modèle, David Ellsworth apporte sa pierre à l'édifice avec Fargo, un shell assembleur pour la TI-92, exploitant la même famille de failles avec le transfert d'un fichier backup trafiqué. La communauté s'empressa de s'engouffrer dans les possibilités inédites offertes ainsi par le contrôle total de ce processeur très supérieur.
https://www.ticalc.org/pub/92/asm/

La TI-82 était entre temps sortie pour la rentrée 1993, bien évidemment à l'époque sans support assembleur officiel pour sa part.

Cette lacune ne sera partiellement comblée que bien plus tard le 7 août 1997, par Jason Todd et Andy Selle qui sortent OShell-82, le premier shell assembleur pour TI-82, toujours la même méthode s'appuyant sur le transfert d'un fichier backup trafiqué. Toutefois ce dernier avait le défaut de ne pas offrir de relocation mémoire, et c'est en fait un autre shell que l'histoire retiendra, Ash du 26 août 1997 par Dines Justesen et Mattias Lindqvist.
https://www.ticalc.org/pub/82/asm/

Niveau matériel, Texas Instruments introduisait avec les premières TI-82 une architecture à 4 puces, ce qui témoignait déjà d'une bien meilleure intégration que sur les TI-81 et TI-85 précédentes :

• Toshiba T84C00AM-8 : processeur 8 bits z80 cadencé à 6 MHz
• Sharp LH531ARH ou Macronix MX J9533 : mémoire ROM de 128 Kio de capacité
• Suwa Seikosha / Sharp SRM20256 ou SRM2A256 : mémoire RAM de 32 Kio de capacité
• Toshiba TC14L010AF : ASIC

On avance à la rentrée 1996, Texas Instruments sort la TI-83, dont le système d'exploitation sera réutilisé après mise à jour pour les futurs modèles d'entrée de gamme reprenant la technologie matérielle de cette machine : TI-82 STATS (2004), TI-82 Stats.fr (2006) et TI-76.fr (2009).

Chez Texas Instruments, l'un des ingénieurs derrière l'écriture de ce système d'exploitation, Pat Milheron, fut particulièrement impressionné par le formidable travail communautaire déjà effectué donc autour de l'assembleur des TI-85 et TI-92, et défendit l'idée d'intégrer un moyen d'exécuter du code assembleur pour les utilisateurs les plus passionnées et exigeants. Le projet fut a priori validé mais dans un premier temps à de simples fins de test : la TI-83 et ses modèles dérivés dissimulent une instruction initialement secrète pour exécuter des programmes contenant du code assembleur, Send(9prgm.... Oui, c'est l'instruction de transfert de fichier qui n'a en apparence rien à voir qui servait via un paramètre spécial à exécuter un programme assembleur, digne d'un easter egg (œuf de Pâques). Les programmes assembleur étaient donc cette fois-ci facilement utilisables par tout-le-monde puisque la fonctionnalité n'avait pas à être installée via des manipulations plus ou moins complexes. La communauté entra en véritable ébullition et battit rapidement en quantité l'exploit TI-85 précédent :
https://www.ticalc.org/pub/83/asm/

La rumeur dit que Pat Milheron aurait ajouté l'instruction Send(9prgm... secrète dans le dos de Texas Instruments, sans que l'entreprise soit au courant ni ait donné son accord, et aurait été licencié pour cela. Nous ignorons si c'est vrai, par absence de sources publiques à croiser.

Niveau matériel, on reste sur l'architecture à 4 puces introduite avec la TI-82 précédente :

• Toshiba T84C00AM-8 : processeur 8 bits z80 cadencé à 6 MHz
• Atmel AT27C020 : mémoire ROM de 256 Kio de capacité
• Suwa Seikosha / Sharp SRM2A256 : mémoire RAM de 32 Kio de capacité
• Toshiba TC14L010AF : ASIC

Les toutes premières TI-83 de production assemblées pour la rentrée 1996 à compter de Mars 1996, étaient munies d'une carte mère de référence 9T883MB-30D, carte qui continua à être utilisée jusqu'en Juin 1996 avec la révision matérielle F.

La ROM incluait donc un logiciel que l'on ne pouvait pas mettre à jour, et dont on pouvait consulter la version via la combinaison de touches

MODE

ALPHA

LN

. À partir donc de ce lancement, les versions du logiciel programmé en usine ont été successivement :

• 1.010
• 1.0200
• 1.0300
• 1.0400
• 1.0500
• 1.0600
• 1.07000
• 1.08000
• 1.10
• 1.10001 (commune TI-83 et premières TI-82 STATS)
• 1.11 (TI-82 STATS uniquement)
• 1.11fr7 (TI-82 Stats.fr uniquement)
• 1.00fr5 (TI-76.fr uniquement)

Et bien grande nouvelle, LogicalJoe vient de trouver et s'acheter un prototype de TI-83, estampillé de façon non finale TI-XX. Pas de numéro de série au dos. Contrairement à d'autres modèles les prototypes de TI-83 sont extrêmement rares, nous ne t'en avions jamais présenté jusqu'à présent.

Le numéro de version logiciel consultable via

MODE

ALPHA

LN

est 0.01013, inférieur donc à tout ce que nous avons connu jusqu'à présent.

Un prototype d'un intérêt historique exceptionnel, car selon LogicalJoe l'instruction Send(9prgm... n'y fonctionne pas. Cela signifie soit que Pat Milheron ne l'avait pas encore codée, soit qu'il avait travaillé sur une branche distincte pour la coder et l'a injectée au tout dernier moment juste avant la mise en production de masse.
L'inconvénient, c'est que sans support des programmes assembleur, la sauvegarde de cette version ROM va être nettement plus compliquée.

Matériellement, la référence de la carte mère est légèrement inférieure à ce que nous connaissions : 9T883MB-30C. Sinon, nous sommes sans surprise sur l'architecture à 4 puces attendue pour quelque chose d'intermédiaire entre les TI-82 et TI-83 :

• Toshiba T84C00AM-8 : processeur 8 bits z80 cadencé à 6 MHz
• Atmel AT27C020 : mémoire ROM de 256 Kio de capacité
• Suwa Seikosha / Sharp SRM2A256 : mémoire RAM de 32 Kio de capacité
• Toshiba TC14L010AF : ASIC

Petite remarque toutefois par rapport à l'ASIC, en-dessous de sa référence se trouve un numéro qui est semble croissant en fonction du temps, et avait toujours été suffixé d'un EAI sur les modèles de production présentés jusqu'à présent. Ici surprise, il est suffixé d'un -ES, peut-être pour Engineering Sample.

Crédits images :

• prototype TI-XX - LogicialJoe
• cartes mère TI-82 et TI-83 de production - musée Datamath

[critor]

Comme nous te l'avons déjà annoncé pour cette année scolaire 2021-2022, l'ensemble de la gamme Texas Instruments passe progressivement aux emballages carton. Fini les emballages historiques à coque blister rigide très difficiles à ouvrir proprement, quasiment impossibles à réutiliser une fois ouverts, pénibles et encombrants à ranger, et n'ayant donc dans la plupart des cas que la poubelle comme seule destination possible après ouverture !

À ce sujet nous t'avons déjà présenté les nouveaux emballages :

• TI-82 Advanced Edition Python
• TI-83 Premium CE Edition Python
• TI-84 Plus CE
• TI-Nspire CX II CAS

Pour cette année 2021-2022 tu peux donc encore te retrouver en rayon avec un même modèle de calculatrice à la fois sous emballage carton et blister, exactement au même prix puisque utilisant le même code barre.

Rappelons que pour les TI-83 Premium CE Edition Python il est dans ton intérêt de choisir l'emballage carton, et pas seulement pour l'écologie et la planète.

Choisir le tout nouvel emballage carton c'est certes également la garantie d'avoir une machine assemblée ces derniers mois, alors qu'un emballage blister peut avoir traîné dans le stock de ton magasin pendant des années.

Mais surtout, grande nouveauté de la rentrée 2021, pour le même prix le nouvel emballage carton a l'avantage exclusif d'intégrer également le logiciel d'émulation sous la forme d'une licence d'utilisation de 3 ans, ce qui n'est pas le cas des anciens emballages blister.

Aujourd'hui, Adriweb vient enfin de nous trouver et acheter une TI-82 Advanced sous le nouvel emballage carton.
On peut voir sur sa tranche qu'il est daté du 2 février 2021.

Comme les autres nouveaux emballages carton français du constructeur, il est très sobre sur sa face avant.

C'est au dos que les fonctionnalités sont mises en avant : mode examen, calcul exact sur les fractions, application PolySimult pour la recherche des racines de polynômes et la résolution de systèmes d'équations linéaires, ...

C'est l'occasion pour nous de récupérer une TI-82 Advanced parmi les plus récentes, et de découvrir qu'il s'est passé des choses.

Sortie pour la rentrée 2015, la TI-82 Advanced avait bénéficié d'une révision matérielle A pour les machines assemblées à partir de Juin 2017.

Ici grâce au timbre à date au dos de la calculatrice, nous notons que cette machine assemblée en Juillet 2018 présente à son tour une nouvelle révision matérielle B inconnue jusqu'à ce jour.

Reste encore à la démonter pour peut-être découvrir ce que Texas Insruments a bien pu changer. À bientôt...

Crédits images : TI-82 Advanced - Adriweb

[critor]

Pour la rentrée 2015 sortait la TI-82 Advanced, l'entrée de gamme monochrome par Texas Instruments dans le contexte de la réforme du mode examen tout juste annoncée.

La carte électronique avait pour référence SG82F-10-1.

Le matériel de ce modèle d'entrée de gamme reprenait celui de l'ancien modèle de milieu de gamme TI-84 Plus :

• écran monochrome 96×32 pixels
• processeur z80 cadencé à 15 MHz (ou 6 MHz pour le mode de compatibilité TI-83 Plus)
• mémoire RAM de 48 Kio de capacité
• mémoire Flash de 1 Mio de capacité, dont 480 Kio d'espace de stockage

La seule différence concerne le port de communication mini-Jack 2.5mm historique qui disparaît ici, son circuit étant réutilisé pour la diode examen.

Or, Texas Instruments effectue régulièrement des révisions du matériel de ses calculatrices. Cela permet de s'adapter à la disponibilité des composants électroniques, de réduire les coûts de fabrication, et parfois même d'améliorer les performances ou capacités.

Nous avions omis de t'en parler, mais les TI-82 Advanced assemblées à partir de Juin 2017 ont bénéficier d'une première révision du matériel, la révision A.

La référence de la carte change et surtout se complexifie, devenant SG82F/T-14. Il s'agit en fait d'une référence hybride. En effet afin d'optimiser les coûts de production, Texas Instruments a eu l'idée de mutualiser la chaîne de production de la carte pour 2 modèles différents à diode examen :

• la TI-82 Advanced pour la France, basée sur le matériel TI-84 Plus
• la TI-84 Plus T pour les Pays-Bas, basée sur le matériel TI-84 Plus Silver Edition

Les cartes bifurquent ainsi en aval de la chaîne :

• TI-82 Advanced : on soude sur la carte une puce Flash de 1 Mio, et alors on barre le T pour donner SG82F-14
• TI-84 Plus T : on soude sur la carte une puce Flash de 2 Mio, et alors on barre le F pour donner SG82T-14

Rappelons au passage que les examens néerlandais utilisent une liste officielle de modèles autorisés mise à jour chaque année, et qu'il a déjà été annoncé que la TI-84 Plus T en serait retirée après la session d'examens 2022. La production de ce modèle a donc peut-être déjà cessé.

Au-delà de ce changement de référence, on note :

• un changement du format des 2 gros condensateurs, qui deviennent plus compacts et peuvent ainsi être soudés sans avoir besoin d'être couchés
• un changement du format de l'oscillateur quartz X02D, qui devient également beaucoup plus compact
• des modifications sur le circuit du contrôleur écran qui amènent nombre de petits composants à bouger

Image 1 vs. Image 2

Ce week-end Adriweb nous permettait de découvrir l'existence d'une nouvelle révision matérielle B, concernant les TI-82 Advanced assemblées depuis Juillet 2018.

La révision B utilise à nouveau une nouvelle carte électronique de référence hybride SG82F/T-15.

Rien de gros cette fois-ci, mais on note une fois encore une fois des changements de circuits :

• des modifications sur le circuit du port mini-USB qui amènent plusieurs composants à bouger
• des modifications sur le circuit d'alimentation amenant ici encore plusieurs composants à bouger
• des modifications sur le circuit de la diode examen, amenant plusieurs composants à changer d'orientation

Image 1 vs. Image 2

Voilà, les modifications sont cette fois-ci moins flagrantes, mais peut-être bien plus majeures car générales.

Crédits images :

• TI-82 Advanced révision A - musée Datamath
• TI-82 Advanced révision B - Adriweb

[critor]

Depuis des années maintenant, Texas Instruments réalise de gros efforts pour rendre la programmation de ses calculatrices accessible à tous et toutes. Le constructeur a prêté une attention toute particulière aux plus jeunes et non initiés, souhaitant leur permettre de créer tous les projets imaginables sans avoir à se concentrer sur des difficultés annexes.

Nous pouvions déjà citer l'interface TI-Innovator Hub, le robot pilotable TI-Innovator Rover, la grille programmable TI-RGB Array ou encore l'adaptateur TI-SensorLink pour capteurs analogiques Vernier.
Tous ces éléments ont de plus l'avantage d'être utilisables directement avec le langage Python des calculatrices concernées, faisant de l'écosystème Texas Instruments le seul Python connecté !

Un superbe support pour les enseignements scientifiques au lycée surtout maintenant que tous partagent le même langage de programmation, notamment en SNT, spécialité NSI, SI et Physique-Chimie, avec le gros avantage de la mobilité. En effet, les programmes produits et données collectées restent présents dans la calculatrice apportée par chaque élève à chaque cours, ce qui allège la charge logistique de l'enseignant. Données et algorithmes pourront donc être traités / travaillés à la prochaine séance, en devoir à la maison ou même de façon transdisciplinaire en collaboration avec un autre enseignant !

Et depuis la rentrée 2020 dernière grande révolution en date, plus besoin de t'équiper en TI-Innovator pour bénéficier de ces formidables avantages. En effet, la TI-83 Premium CE Edition Python française s'est vu rajouter la gestion du nanoordinateur BBC micro:bit programmable en Python dont tu étais peut-être déjà équipé·e !

La carte micro:bit est initialement un projet lancé par la BBC (British Broadcasting Corporation), 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 (Informatique Pour Tous).

Les cartes micro:bit utilisent un connecteur micro-USB et ta calculatrice un mini-USB.

Pour relier les deux une solution est d'adjoindre un adaptateur mini-USB.

Pour moins d'encombrement, tu as aussi la solution d'utiliser un câble direct, au choix :

• USB micro-B mâle ↔ USB mini-A mâle
• USB micro-B mâle ↔ USB mini-B OTG mâle

La carte micro:bit dans ses versions 1 est programmable en Python et présentait initialement les caractéristiques et capacités suivantes :

• processeur 32 bits ARM Cortex-M0 cadencé à 16 MHz
• mémoire de stockage Flash d'une capacité de 256 Kio
• mémoire de travail RAM d'une capacité de 16 Kio permettant un heap (tas) Python de 10,048 Ko
• un afficheur, grille programmable de 5×5= 25 diodes rouges adressables, bien adapté pour l'affichage de motifs éventuellement animés ou encore de texte défilant
• nombre de capteurs intégrés :
  
  • capteur de luminosité (lié aux diodes)
  • capteur de température (sur le processeur)
  • 2 boutons poussoirs

    A

    et

    B

    programmables de part et d'autre, comme sur les premières manettes et consoles de jeux portables de chez Nintendo
  • accéléromètre 3D, permettant de détecter les variations d'accélération et par conséquence diverses actions : secouer, pencher, chute libre, ...
  • boussole magnétique 3D, pour détecter cette fois-ci les champs magnétiques
• connectivité Bluetooth 4.0 basse énergie 2,4 GHz maître/esclave

Depuis début 2021 est disponible la nouvelle carte micro:bit v2.

Elle utilise un tout nouveau microcontrôleur, le nRF52833, toujours de chez Nordic Semiconductor. Cette fois-ci nous avons des spécifications qui devraient nous permettre de respirer :

• processeur 32 bits ARM Cortex-M0 cadencé à 64 MHz au lieu de 16 MHz soit 4 fois plus rapide !
• mémoire de stockage Flash d'une capacité de 512 Kio au lieu de 256 Kio soit 2 fois plus grande !
• mémoire de travail RAM d'une capacité de 128 Kio au lieu de 16 Kio soit 8 fois plus grande, permettant un heap (tas) Python de 64,512 Ko !

Elle apporte sur cette même face plusieurs nouveautés ou changements :

• ajout d'un haut-parleur
• ajout d'un microphone MEMs
• bouton poussoir qui ne sert plus seulement à la réinitialisation (reset), mais permet désormais également d'éteindre la carte (appui long) et de la rallumer (appui court)
• l'antenne Bluetooth qui devient compatible BLE Bluetooth 5.0, contre seulement 4.0 auparavant

D'autres nouveautés ou changements sont également présents sur l'autre face :

• ajout d'une diode DEL indiquant l'état du microphone
• ajout d'un bouton tactile sur le logo micro:bit, voici pourquoi il perd sa couleur au profit de contacts métalliques

Expliquons brièvement la composition de la solution de connectivité BBC micro:bit de Texas Instruments, ainsi que son fonctionnement.

Le solution se compose d'une part d'un fichier TI-Runtime unique à copier sur la carte micro:bit v1 ou v2 et qui lui permet d'être pilotée par la calculatrice. La bonne installation du fichier est aisément vérifiable, puisque faisant afficher à la carte le logo Texas Instruments.

La solution a un principe de fonctionnement très simple, mais non moins ingénieux pour autant. La carte micro:bit étant justement programmable en Python, une fois le TI-Runtime installé elle se met alors à écouter les commandes Python envoyées depuis la calculatrice et à les exécuter.

Depuis ta calculatrice, tu peux envoyer n'importe quelle commande Python à ta carte micro:bit et profiter pleinement de ses capacités grâce à la fonction ti_hub.send(), à condition d'encadrer la commande des bons caractères de contrôle. Voici une fonction mb_run() en ce sens :

Code: Tout sélectionner

from ti_hub import *

def mb_run(code):
  send('\x05') # enter paste mode (Ctrl-E)
  send(code)
  send('\x04') # exit paste mode (Ctrl-D)

Pour afficher par exemple Pac-Man, il te suffit d'appeler mb_run("display.show(Image.PACMAN)"), conformément à la documentation du Python micro:bit.

Toutefois en pratique dans le contexte scolaire, cette façon de faire n'était pas idéale. Elle rajoutait un niveau d'imbrication : tu devais produire du code Python qui lui-même devait construire le code Python à envoyer et exécuter par la carte micro:bit, une marche sans doute un peu haute pour bien des élèves débutants.

Et bien justement, Texas Instruments est loin de s'être arrêté là. Sa solution de connectivité comporte également des bibliothèques Python additionnelles à charger sur ta calculatrice, au choix en Français ou Anglais, et rajoutant alors des menus permettant de faire appel plus simplement aux éléments correspondants sur la carte micro:bit. 9 bibliothèques étaient initialement disponibles, facilitant ainsi l'utilisation de certaines bibliothèques du Python micro:bit :

• microbit (générale, permet d'accéder aux menus des autres bibliothèques)
• mb_butns → microbit.buttons (boutons A et B intégrés - importée/accessible via le menu Buttons ou Boutons)
• mb_disp → microbit.display (afficheur à 5×5=25 LEDs rouges intégré - importée/accessible via le menu Display ou Affichage)
• mb_grove (capteurs et actionneurs Grove à rajouter - importée/accessible via le menu Grove)
• mb_music → microbit.music (haut-parleur à rajouter sur micro:bit v1 ou intégré sur micro:bit v2 - importée/accessible via le menu Music ou Musique)
• mb_neopx → microbit.neopixel (rubans de LEDs programmables à rajouter - importée/accessible via le menu NeoPixel)
• mb_pins (contacts programmables intégrés - importée/accessible via le menu Input/output pins ou Broches entrée/sortie)
• mb_radio → microbit.radio (communication radio intégrée - importée/accessible via le menu Radio)
• mb_sensr (capteurs intégrés : boussole, accéléromètre, température - importée/accessible via le menu Sensors ou Capteurs)

La mise à jour 2.4 du TI-Runtime avait rajouté la compatibilité avec la nouvelle carte micro:bit v2, mais hélas rien concernant ses nouvelles capacités.

On pouvait juste noter que le code écrit avec la bibliothèque mb_music et ciblant donc initialement un haut-parleur externe connecté sur micro:bit v1, marchait sans le moindre changement directement avec le haut-parleur interne de la micro:bit v2.

Mais mis à part cela, tous les autres nouveaux éléments de la micro:bit v2 t'étaient inaccessibles, du moins via les menus de la calculatrice.

Il y a quelques semaines, Texas Instruments nous sortait une mise à jour majeure de sa solution de connectivité micro:bit pour TI-83 Premium CE Edition Python, TI-84 Plus CE-T Python Edition et TI-84 Plus CE Python, en double version 1.0 et 2.1.

La publication comprenait les éléments suivants :

• TI-Runtime 2.1.0 pour les micro:bit v2
• TI-Runtime 1.0.0 pour les micro:bit v1
• menus anglais 2.1.0 avec une micro:bit v2
• menus anglais 1.0.0 avec une micro:bit v1 (menus allégés ne comprenant pas les éléments spécifiques aux micro:bit v2)

Aujourd'hui Texas Instruments commence enfin à diffuser une version française de ces nouveaux menus. Découvrons donc les nouveautés par rapport aux menus français précédents.

1. Eléments et versions
2. Nouveautés toutes BBC micro:bit
   
   1. Changements mb_disp
   2. Changements mb_grove
   3. Changements mb_neopx
   4. Changements mb_pins
   5. Changements mb_sensr
   6. Nouveau mb_log
   7. Nouveau mb_notes
3. Nouveautés BBC micro:bit v2
   
   1. Ajouts mb_butns
   2. Ajouts mb_grove
   3. Ajouts mb_music
   4. Nouveau mb_audio
   5. Nouveau mb_mic
4. Téléchargements

A) Eléments et versions

Go to top

Texas Instruments a donc fait le choix de scinder sa solution de connectivité micro:bit en deux. En effet à compter d'aujourd'hui tu devras choisir entre 2 packs de fichiers différents selon la carte micro:bit que tu utilises :

• un pack avec des fichiers en version 1 pour une micro:bit v1
• un pack avec des fichiers en version 2 pour une micro:bit v2

La numérotation est donc sans lien logique avec les versions déjà diffusées.

Les packs français d'aujourd'hui comportent les éléments suivants :

• TI-Runtime 1.0.0 pour les micro:bit v1
• TI-Runtime 2.0.0 pour les micro:bit v2 (oui, version bizarrement inférieure à celle du pack anglais)
• menus français 2.1.0 avec une micro:bit v2

Contrairement aux packs anglais, ici donc pas de menus allégés si tu utilises une micro:bit v1. Peut-être s'agit-il d'une erreur de publication, en fait les fichiers de menus du pack spécifique à la micro:bit v1 sont bizarrement identiques à ceux du pack pour microl:bit v2. Mais ce n'est pas bien grave, tu peux quand même les utiliser dans tous les cas, il te suffira juste d'ignorer les menus concernant des spécificités de la micro:bit v2.

Attention, les nouvelles nouvelles bibliothèques Python ne fonctionneront pas correctement avec les cartes micro:bit munies d'une ancienne version du TI-Runtime.

Dans ce cas tu obtiendras une erreur de connexion dès l'importation de la bibliothèque.

Chose très pénible avec les bibliothèques microbit des versions précédentes pour ta calculatrice, elles n'étaient pas par défaut au menu.

Elles n'étaient présentes au menu que lorsque tu éditais un script contenant une ligne les important, par exemple from microbit import *. Et donc pour un nouveau script, tu devrais saisir cette ligne intégralement à la main, caractère par caractère, au clavier de ta calculatrice, opération très fastidieuse...

Et bien excellente chose, les nouvelles bibliothèques codées par TI ont cette fois-ci été converties en fichiers pour ta calculatrice avec le tout dernier py2appvar 1.2.1, et peuvent ainsi être reconnues en tant que bibliothèques complémentaires par la dernière version 5.7 de l'application Python de ta calculatrice (nécessitant elle-même la mise à jour système 5.7).

C'est justement le cas de la bibliothèque micropython. À partir de la liste des bibliothèques intégrées, l'onglet de bas d'écran Compl. lié à la touche

F4

te permet de saisir le from microbit import * d'une seule touche pour activer le menu microbit !

B) Nouveautés toutes BBC micro:bit

Go to top

Commençons par les nouveautés communes à toutes les cartes micro:bit.

Le menu disponible suite à l'importation de la bibliothèque microbit fait apparaître non plus 8 mais 11 bibliothèques, dont 9 utilisables à la fois avec les micro:bit v1 et v2.

La nouveauté est Enregistrement de données à la bibliothèque mb_log.

Il y a également une autre nouvelle bibliothèque. Le choix Music (Musique) importe désormais non seulement la bibliothèque mb_music, mais également une nouvelle bibliothèque mb_notes.

Nouveauté également au menu, un nouvel onglet Commands (Commandes).

Il nous permet d'avoir directement sous la main différentes méthodes bien utiles en provenance d'autres bibliothèques :

• sleep() pour patienter (builtins)
• escape() pour attendre l'appui sur la touche

  annul

  ou

  clear

  (ti_system)
• disp_clr() pour effacer l'écran (ti_system)
• store_list() pour enregistrer une liste de nombres dans l'environnement de la calculatrice (ti_system)
• et bizarrement temperature()

temperature() était jusqu'à présent fourni par la bibliothèque mb_sensr dédié à l'interrogation des capteurs intégrés à la micro:bit, et c'est ainsi curieux qu'il se retrouve tout seul ici. Mais c'est un capteur à part, puisque c'est le seul qui n'effectue par une mesure externe mais interne. En effet ce n'est pas la température de l'environnement qu'il retourne, mais la températeur du processeur de la micro:bit.

Nous regarderons les nouvelles bibliothèques plus loin, commençons pour le moment par les changements apportés aux bibliothèques par rapport à la version précédente.

1. Changements mb_disp
2. Changements mb_grove
3. Changements mb_neopx
4. Changements mb_pins
5. Changements mb_sensr
6. Nouveau mb_log
7. Nouveau mb_notes

B1) Changements mb_disp

Go to top

Le choix Affichage permet d'importer la bibliothèque mb_disp et activer son menu. Cette bibliothèque te permet de contrôler facilement la grille de diodes adressables.

Tu pouvais au choix :

• afficher des images prédéfinies
• créer tes propres images à afficher au format micro:bit
• contrôler individuellement chaque pixel

Pour afficher par exemple Pac-man, le menu te permettait de construire facilement l'appel display.show("Image.PACMAN").

35 noms d'images prédéfinies pouvaient être saisis très facilement grâce à l'onglet Images

Toutefois la carte micro:bit connaît bien davantage d'images que ça. Il nous manquait :

• 12 images d'horloge CLOCK
• 8 images de flèches ARROW
• BUTTERFLY, STICKFIGURE, GHOST, SWORD, GIRAFFE, SKULL, UMBRELLA et SNAKE

Pourquoi ? Texas Instruments limite volontairement à 36 le nombre d'éléments dans les menus, afin qu'ils soient tous accessibles via un raccourci clavier à 1 touche. Or, nous ne disposons que de 10 chiffres et 26 lettres.

Tu pouvais parfaitement utiliser les images non listées au menu, mais il te fallait en connaître le nom et le saisir manuellement.

Pour afficher le papillon par exemple, tu devais donc saisir ou corriger ta saisie en display.show("Image.BUTTERFLY").

Nouveauté donc, Texas Instruments nous déplace la commande permettant de créer tes propres images de l'onglet Images vers l'onglet Display (Affichage).

À la place, Texas Instruments te rajoute un 36^ème nom d'image prédéfinie dans l'onglet Images, justement le BUTTEFLY (papillon) !

Code: Tout sélectionner

from microbit import *
from mb_disp import *

boat = Image("05050:""05050:""05050:""99999:""09990")

spin1 = Image("00900:""00900:""00900:""00900:""00900")
spin2 = Image("00090:""00000:""00900:""00000:""09000")
spin3 = Image("00009:""00090:""00900:""09000:""90000")
spin4 = Image("00000:""00009:""00900:""90000:""00000")
spin5 = Image("00000:""00000:""99999:""00000:""00000")
spin6 = Image("00000:""90000:""00900:""00009:""00000")
spin7 = Image("90000:""09000:""00900:""00090:""00009")
spin8 = Image("09000:""00000:""00900:""00000:""00090")
spinner=[spin1,spin2,spin3,spin4,spin5,spin6,spin7,spin8]

flash = [Image().invert(i) for i in range(9, -1, -1)]

disp_clr()
print("Display and Image Test")
print("display.clr")
display.clear()
print("display.show('Image.HEART, delay = 3000, wait = True')")
display.show("Image.HEART",delay=3000, wait = True)
print("display.show(1.4142)")
display.show(1.4142)
print("brightness =",display.read_light_level())
print("display.scroll('Fast as a Fox', delay = 50)")
display.scroll("Fast as a Fox",delay=50,wait=True)
print("display.scroll('Slow as Molasses', delay = 200)")
display.scroll("Slow as Molasses",delay=200,wait=True)
print("display.set_pixel(x,y,i)")
display.set_pixel(1,0,9)
display.set_pixel(3,0,9)
display.set_pixel(0,1,9)
display.set_pixel(2,1,9)
display.set_pixel(4,1,9)
display.set_pixel(1,2,9)
display.set_pixel(3,2,9)
display.set_pixel(0,3,9)
display.set_pixel(2,3,9)
display.set_pixel(4,3,9)
display.set_pixel(1,4,9)
display.set_pixel(3,4,9)
sleep(2000)
print ("display.show(boat, delay = 3000)")
display.show(boat,delay=3000)
print ("display.show(spinner, delay = 50)")
for i in range(5):
  display.show(spinner,delay=50)
print ("display.show(flash, delay = 100)")
for i in range (5):
  display.show(flash, delay=100)

B2) Changements mb_grove

Go to top

Le choix Grove est renommé Grove Devices. Il permet toujours d'importer les bibliothèques mb_grove et mb_pins, et d'activer leurs menus respectifs : grove et broches entrée/sortie.

Nous nous concentrerons ici sur la seule bibliothèque mb_grove. Elle permet pour sa part de contrôler des capteurs et actionneurs Grove connectés à ta carte micro:bit.

Son menu subit ici une régression par rapport à la version précédente : les broches pin14 et pin15 y sont faussement intitulées pin16, bien que la saisie reste correcte.

C'est pourtant un bug que nous avions déjà signalé sur une version anglaise précédente, et qui avait été corrigé.

Puisque le bug revient à l'identique, il faut croire que Texas Instruments maintient en parallèle différentes branches des fichiers source, et s'est ici mélangé...

Dans l'onglet Sortie, nous remarquons la disparition du commentaire indiquant que le besoin d'une alimentation externe.

Code: Tout sélectionner

from microbit import *
from mb_grove import *
from mb_pins import *

disp_clr()

while not escape():
  T = grove.read_temperature(pin0)
  print("Temperature = %.1f\u00b0C"%round(T,1))
  p = 50
  print("Pump On at %.1f"%round(p,1)+"% power")
  grove.power(pin8,p)
  sleep(2000)
  p = 0
  print("Pump On at %.1f"%round(p,1)+" % power")
  grove.power(pin8,p)
  disp_clr()
grove.power(pin8,0)

B3) Changements mb_neopx

Go to top

Le choix NeoPixel est renommé NeoPixel et Couleur. Il permet d'importer la bibliothèque mb_neopx et d'activer son menu.

Cette bibliothèque permet de piloter les rubans de diodes adressables à connecter à ta carte micro:bit.

On peut noter justement l'ajout au menu d'un nouvel onglet Color, histoire que tu aies directement sous la main de quoi manipuler les couleurs.

Regardons dans l'onglet setup, désormais correctement traduit en Configuration. Nous remarquons la disparition du commentaire indiquant que le rubans ont besoin d'une alimentation externe.

Nous notons également la disparition de l'onglets pins, le renommage de l'onglet setup en Configuration semblant ne plus laisser suffisamment de place pour cet onglet.

Code: Tout sélectionner

from microbit import *
from mb_neopx import *
from random import *

np = NeoPixel(pin0, 16)

while not escape():
  for id in range(len(np)):
    red = randint(0,255)
    green =randint(0,255)
    blue =randint(0,255)
    np[id]=(red, green, blue)
    np.show()
    sleep(100)
np.clear()

B4) Changements mb_pins

Go to top

Le choix Broches entrée/sortie permet d'importer la bibliothèque mb_pins et d'activer son menu.

Cette bibliothèque permet de contrôler les broches programmables de ta carte micro:bit, aussi bien en entrée qu'en sortie, et aussi bien en analogique qu'en digital.

Regardons dans l'onglet pins maintenant correctement traduit en Broches. Nous notons l'ajout de nouvelles broches au menu :

• pin13
• pin_speaker

Code: Tout sélectionner

from microbit import *
from mb_pins import *

while not escape():
  disp_clr()
  print("Analog/Digital Input")
  print("digital0.read =",pin0.read_digital())
  print("digital1.read =",pin1.read_digital())
  print("digital2.read =",pin2.read_digital())
 
  print("analog0.read =",pin0.read_analog())
  print("analog1.read =",pin1.read_analog())
  print("analog2.read =",pin2.read_analog())
 
  sleep(3000)
  disp_clr()
  print("Analog/Digital Output Test")
  print("digital0.write(1)",pin0.write_digital(1))
  sleep(1000)
  print("digital0.write(0)",pin0.write_digital(0))
  sleep(1000) 
  print("digital1.write(1)",pin1.write_digital(1))
  sleep(1000)
  print("digital1.write(0)",pin1.write_digital(0))
  sleep(1000)
  print("digital2.write(1)",pin2.write_digital(1))
  sleep(1000)
  print("digital2.write(0)",pin2.write_digital(0))
  sleep(1000)
  print("analog0.write(50)",pin0.write_analog(50))
  sleep(1000)
  print("analog0.write(0)",pin0.write_analog(0))
  sleep(1000)
  print("analog1.write(50)",pin1.write_analog(50))
  sleep(1000)
  print("analog1.write(0)",pin1.write_analog(0))
  sleep(1000)
  print("analog2.write(50)",pin2.write_analog(50))
  sleep(1000)
  print("analog2.write(0)",pin2.write_analog(0))
  sleep (1000)

B5) Changements mb_sensr

Go to top

Le choix capteurs est renommé Capteurs et gestes. Il permet d'importer la bibliothèque mb_sensr et d'activer son menu, affiché par erreur en tant que capteurs et estes (sic).

Cette bibliothèque permet d'interroger les capteurs intégrés à ta carte micro:bit.

L'onglet tempé disparaît, mais à la place un nouvel onglet Geste nous permet enfin d'interroger directement et facilement les accéléromètre et boussole de la carte au sujet de différents types de mouvements :

7 types de mouvements/positions sont ici directement au menu :

• up
• down
• left
• right
• face up
• face down
• shake

D'autres mouvements sont également reconnues pas la carte micro:bit, et tu devras ici corriger les saisies au clavier alphabétique pour y accéder :

• freefall
• 3g
• 6g
• 8g

Voici par exemple de quoi interroger et afficher les mouvements en boucle :

Code: Tout sélectionner

from microbit import *
from mb_sensr import *

while not escape():
  print(accelerometer.current_gesture())
  #print(accelerometer.is_gesture('face up'))
  #print(accelerometer.was_gesture("face down"))

Nous perdons l'onglet tempé. Ce n'est pas grave, puisque nous avons vu plus haut que l'appel temperature() était désormais directement disponible au menu de la bibliothèque microbit. Et comme déjà dit, c'est peut-être plus logique ainsi, puisque le capteur de température de la micro:bit est lié au processeur, effectuant donc contrairement à tous les autres une mesure interne et non une mesure de l'environnement.

Mais que bien que n'étant plus mis en avant au menu, remarquons que Texas Instruments a pris le soin de laisser l'appel mb_sensr.temperature() fonctionnel. Ceci garantit ainsi malgré le changement la compatibilité avec les scripts déjà produits !

B6) Nouveau mb_log

Go to top

Le choix Enregistrement de données permet d'importer la bibliothèque mb_log et d'activer son menu.

Cette bibliothèque permet de représenter en direct sous la forme d'un diagramme en ligne brisée, les valeurs retournées par le capteur micro:bit de ton choix, ou plus généralement par n'importe quel appel Python.

Voici de suite un exemple interrogeant et traçant en boucle la composante X de l'accéléromètre :

Code: Tout sélectionner

from microbit import *
from mb_log import *
from mb_sensr import *

data_log.set_duration(10)
data_log.set_sensor('accelerometer.get_x()')
data_log.set_range(-1200,1200)
data_log.start()

B7) Nouveau mb_notes

Go to top

Le choix Music (Musique) permet d'importer les bibliothèques mb_music et également désormais mb_notes, et d'activer leurs menus respectifs : music (musique) et notes.

Nous nous concentrerons ici sur la nouveauté : la bibliothèque mb_notes. Elle permet d'accélérer la saisie de notes au format micro:bit, pour tes mélodies à jour avec la bibliothèque mb_music. La saisie clavier te sera ainsi beaucoup plus aisée et rapide !

Les 7 notes de la gamme ainsi que le silence te sont directement accessibles sur les octaves n°1 à 6 (la micro:bit reconnaissant les octaves n°0 à 8), avec par défaut une durée de 4.

Rappelons que notre outil en ligne midi2calc te permet de convertir tes mélodies au format MIDI en scripts Python à jouer avec ta calculatrice sur micro:bit ou TI-Innovator Hub.

Code: Tout sélectionner

from microbit import *
from mb_music import *

notes = ['c4:1', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5', 'c4', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5','c4', 'd', 'a', 'd5', 'f5', 'a4', 'd5', 'f5', 'c4', 'd', 'a', 'd5', 'f5', 'a4', 'd5', 'f5','b3', 'd4', 'g', 'd5', 'f5', 'g4', 'd5', 'f5', 'b3', 'd4', 'g', 'd5', 'f5', 'g4', 'd5', 'f5','c4', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5', 'c4', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5','c4', 'e', 'a', 'e5', 'a5', 'a4', 'e5', 'a5', 'c4', 'e', 'a', 'e5', 'a5', 'a4', 'e5', 'a5','c4', 'd', 'f#', 'a', 'd5', 'f#4', 'a', 'd5', 'c4', 'd', 'f#', 'a', 'd5', 'f#4', 'a', 'd5','b3', 'd4', 'g', 'd5', 'g5', 'g4', 'd5', 'g5', 'b3', 'd4', 'g', 'd5', 'g5', 'g4', 'd5', 'g5','b3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5', 'b3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5','a3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5', 'a3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5','d3', 'a', 'd4', 'f#', 'c5', 'd4', 'f#', 'c5', 'd3', 'a', 'd4', 'f#', 'c5']

disp_clr()
print("Music and Tone Test")

print("music.play('A4:8')")
music.play('A4:8')

print("music.set_tempo(4,120)")
music.set_tempo(4,120)

print("music.play(music.ODE)")
music.play('music.ODE', wait=True)

print("music.set_tempo(8,360)")
music.set_tempo(8,360)

print("music.play(music.ODE)")
music.play('music.ODE', wait=True)

print("music.pitch(261,1000,wait=True)")
music.pitch(261,1000,wait=True)

print("Play an octave")
for i in range (13):
  note = int(440*2**(i/12))
  print('note = ',note)
  music.pitch(note,500,wait=True)

print("music.set_tempo(4,200)")
music.set_tempo(4,200)

print("music.play(notes)")
music.play(notes, wait=True)

music.set_tempo(4,120)
print("music.play('music.POWER_DOWN')")
music.play('music.POWER_DOWN')

C) Nouveautés BBC micro:bit v2

Go to top

Nous arrivons enfin aux nouveautés concernant la carte micro:bit v2.

2 choix supplémentaires spécifiques sont ici au menu de la bibliothèque microbit : Audio et Microphone.

Nous les regarderons bien évidemment plus loin, mais commençons pour le moment par les ajouts apportés aux bibliothèques déjà existantes.

1. Ajouts mb_butns
2. Ajouts mb_grove
3. Ajouts mb_music
4. Nouveau mb_audio
5. Nouveau mb_mic

C1) Ajouts mb_butns

Go to top

Le choix Boutons est renommé ici Boutons et Logo. Il permet d'importer la bibliothèques mb_butns et d'activer son menu.

Cette bibliothèque se spécialise dans l'interrogation des boutons présents sur la carte micro:bit :

• bouton A
• bouton B
• et justement, spécificité de la micro:bit v2, bouton tactile sur le logo de la carte

Nous avons donc ici un onglet supplémentaire dédié au bouton tactile.

Code: Tout sélectionner

from microbit import *
from mb_butns import *

while not escape():
  disp_clr()
  print ("Buttons A and B Test")
  print("A.is_pressed",button_a.is_pressed())
  print("A.was_pressed",button_a.was_pressed())
  print("A.get_presses",button_a.get_presses())
  print("B.is_pressed",button_b.is_pressed())
  print("B.was_pressed",button_b.was_pressed())
  print("b.get_presses",button_b.get_presses())
  print("pin_logo.is_touched",pin_logo.is_touched())
  sleep(2000)

C2) Ajouts mb_grove

Go to top

Le choix Grove Devices permet toujours d'importer les bibliothèques mb_grove et mb_pins, et d'activer leurs menus respectifs : grove et broches entrée/sortie.

Nous nous concentrerons ici sur la seule bibliothèque mb_grove. Elle permet pour sa part de contrôler des capteurs et actionneurs Grove connectés à ta carte micro:bit.

Une fonction additionnelle read_bme280() nous permet ici de récupérer d'un seul coup les 3 mesures retournées par un capteur BME280, capteur Grove de pression barométrique, température et humidité.

C3) Ajouts mb_music

Go to top

Le choix Musique permet toujours d'importer les bibliothèques mb_music et mb_notes, et d'activer leurs menus respectifs : musique et notes.

Nous nous concentrerons sur la bibliothèque mb_music. Elle permet de jouer des notes et donc par extension mélodies, sur le haut parleur directement intégré à la carte micro:bit v2.

Spécificité donc ici de la micro:bit v2, nous avons ici au menu une nouvelle fonction set_volume() permettant de régler le volume de la sortie audio sur une valeur allant de 0 à 255.

Code: Tout sélectionner

from microbit import *
from mb_music import *

notes = ['c4:1', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5', 'c4', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5','c4', 'd', 'a', 'd5', 'f5', 'a4', 'd5', 'f5', 'c4', 'd', 'a', 'd5', 'f5', 'a4', 'd5', 'f5','b3', 'd4', 'g', 'd5', 'f5', 'g4', 'd5', 'f5', 'b3', 'd4', 'g', 'd5', 'f5', 'g4', 'd5', 'f5','c4', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5', 'c4', 'e', 'g', 'c5', 'e5', 'g4', 'c5', 'e5','c4', 'e', 'a', 'e5', 'a5', 'a4', 'e5', 'a5', 'c4', 'e', 'a', 'e5', 'a5', 'a4', 'e5', 'a5','c4', 'd', 'f#', 'a', 'd5', 'f#4', 'a', 'd5', 'c4', 'd', 'f#', 'a', 'd5', 'f#4', 'a', 'd5','b3', 'd4', 'g', 'd5', 'g5', 'g4', 'd5', 'g5', 'b3', 'd4', 'g', 'd5', 'g5', 'g4', 'd5', 'g5','b3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5', 'b3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5','a3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5', 'a3', 'c4', 'e', 'g', 'c5', 'e4', 'g', 'c5','d3', 'a', 'd4', 'f#', 'c5', 'd4', 'f#', 'c5', 'd3', 'a', 'd4', 'f#', 'c5', 'd4', 'f#', 'c5','g3', 'b', 'd4', 'g']

disp_clr()
print("Music and Tone Test")

print("music.play('A4:8')")
music.play('A4:8')

print("music.set_tempo(4,120)")
music.set_tempo(4,120)

print("music.play(music.ODE)")
music.play('music.ODE', wait=True)

print("music.set_tempo(8,360)")
music.set_tempo(8,360)

print("music.play(music.ODE)")
music.play('music.ODE', wait=True)

print("music.pitch(261,1000,wait=True)")
music.pitch(261,1000,wait=True)

print("Play an octave")
for i in range (13):
  note = int(440*2**(i/12))
  print('note = ',note)
  music.pitch(note,500,wait=True)

print("music.set_tempo(4,200)")
music.set_tempo(4,200)

print("music.play(notes)")
music.play(notes, wait=True)

print("Testing volume")

for n in range (0,250,25):
  music.set_volume(n)
  print (n)
  music.pitch(440,500,wait=True)
for n in range (250,0,-25):
  music.set_volume(n)
  print (n)
  music.pitch(440,500,wait=True)

music.set_volume(255)
music.set_tempo(4,120)
print("music.play('music.POWER_DOWN')")
music.play('music.POWER_DOWN')

C4) Nouveau mb_audio

Go to top

Le choix Audio permet d'importer la nouvelle bibliothèque mb_audio et d'activer son menu.

Cette bibliothèque te permet d'exploiter les nouvelles possibilités de synthèse sonore de la carte micro:bit v2. En effet cette dernière peut gère bien davantage que de simples notes, tu peux lui faire produire des effets sonores ou même la faire parler.

L'onglet Sons te donne accès à 10 effets sonores prédéfinis.

Code: Tout sélectionner

from microbit import *
from mb_audio import *

disp_clr()
print("GIGGLE")
audio.play("Sound.GIGGLE",wait=True,)
sleep(1000)

print("HAPPY")
audio.play("Sound.HAPPY",wait=True,)
sleep(1000)

print("HELLO")
audio.play("Sound.HELLO",wait=True,)
sleep(1000)

print("MYSTERIOUS")
audio.play("Sound.MYSTERIOUS",wait=True,)
sleep(1000)

print("SAD")
audio.play("Sound.SAD",wait=True,)
sleep(1000)

print("SLIDE")
audio.play("Sound.SLIDE",wait=True,)
sleep(1000)

print("SOARING")
audio.play("Sound.SOARING",wait=True,)
sleep(1000)

print("SPRING")
audio.play("Sound.SPRING",wait=True,)
sleep(1000)

print("TWINKLE")
audio.play("Sound.TWINKLE",wait=True,)
sleep(1000)

print("YAWN")
audio.play("Sound.YAWN",wait=True,)
sleep(1000)

C5) Nouveau mb_mic

Go to top

Enfin, le choix Microphone permet d'importer la nouvelle bibliothèque mb_micro et d'activer son menu.

Cette bibliothèque te permet d'accéder au microphone intégré à la carte micro:bit v2.

Code: Tout sélectionner

from microbit import *
from mb_mic import *

microphone.set_threshold(SoundEvent.LOUD,200)
while not escape():
  print(microphone.sound_level())
  print(microphone.current_event())
 
  print(microphone.is_event(SoundEvent.LOUD))
  print(microphone.was_event(SoundEvent.LOUD))

D) Téléchargements

Go to top

• TI-Runtime :
  
  • 2.1.0 pour BBC microbit v2
  • 2.0.0 pour BBC microbit v2
  • 1.0.0 pour BBC microbit v1
• bibliothèques Python complémentaires :
  
  • 2.1.0 Français pour TI-83 Premium CE Edition Python, TI-84 Plus CE-T Python Edition ou TI-84 Plus CE Python avec BBC microbit v1/v2
  • 2.1.0 English pour TI-83 Premium CE Edition Python, TI-84 Plus CE-T Python Edition ou TI-84 Plus CE Python avec BBC microbit v2
  • 1.0.0 English pour TI-83 Premium CE Edition Python, TI-84 Plus CE-T Python Edition ou TI-84 Plus CE Python avec BBC microbit v1
  • 2.34 Français English pour TI-Nspire CX II avec BBC microbit v1/v2

Source : https://resources.t3france.fr/t3france?resource_id=3086

[critor]

Aux épreuves orales du concours de recrutement des enseignants de Mathématiques (CAPES), la forme adoptée pour l'évaluation des compétences numériques a déjà subi plusieurs évolutions techniques majeures en ce siècle.

On peut découper la chose en 3 phases :

1. Jusqu'à la session 2010 incluse, les candidats souhaitant exposer leurs compétences numériques dans le cadre du sujet, le faisaient sur calculatrices graphiques. La calculatrice personnelle n'était pas autorisée, mais différents modèles de calculatrices étaient mis à disposition des candidats dans la salle de préparation, et des tablettes de rétropojection adaptées à chaque modèle étaient disponibles dans la salle du jury. Les grands constructeurs de calculatrices graphiques faisaient livrer gracieusement le matériel (calculatrices et tablettes) par camions entiers sur le site des épreuves, de façon très assidue chaque année dans le cas de Casio et Texas Instruments, de façon plus épisodique concernant Hewlett Packard.
2. À compter de la session 2011, plus de calculatrice graphique. Les candidats disposaient directement d'un ordinateur sous Windows dans la salle de préparation, avec un ensemble de logiciels préinstallés. Un ordinateur disposant du même ensemble de logiciels et connecté à un vidéoprojecteur était disponible dans la salle du jury, et les fichiers conçus par le candidat y étaient transférées par le réseau en fin de préparation.
3. Nouveau gros changement à partir de la session 2018, les candidats ne travaillent plus sous Windows mais sur CAPESOS, un système d'exploitation Linux embarqué sur clé USB, clé USB que les candidats recevaient en début de préparation et emportaient eux-mêmes dans la salle du jury.

Les modèles de calculatrices puis logiciels mis à la disposition des candidats ont varié avec les années, et sont résumés ci-contre depuis la session 2004.

Il est toutefois à noter que, dans un premier temps, les calculatrices n'ont pas disparu suite à la session 2011. En effet les logiciels d'émulation de calculatrices des différents constructeurs ont pris le relais et étaient installés sur chaque ordinateur.

Suite à la session 2016, le site du jury s'est mis à afficher une information fort étrange à la fin de la liste des logiciels :

NB : algobox et les émulateurs de calculatrices ne seront plus proposés à partir de la session 2018

2018 c'était certes la première session à se passer sous Linux avec CAPESOS, mais ce n'était pas un obstacle technique suffisant pour expliquer cette suppression :

• Algobox est un logiciel multiplateforme et est donc entre autres parfaitement disponible sous Linux
• l'émulateur HP Prime est disponible pour Linux
• et Texas Instruments avait déjà fourni des versions Linux de ses logiciels dans le cadre de l'Agrégation de Mathématiques

Non, le jury du CAPES de Mathématiques semblait tout simplement vouloir faire le ménage, et retirer des logiciels pour forcer les candidats à en utiliser d'autres. Pourquoi pas, nous n'avons pas à juger.

Cela n'a absolument pas été présenté en ce sens, mais après coup on peut se dire que la suppression d'Algobox semblait répondre à la volonté de n'offrir que Scratch et Python comme langages de programmation, conformément aux nouveaux programmes du lycée. À l'époque les modèles de calculatrices avaient également le défaut chacun de n'être programmable que dans un langage Basic spécifique au constructeur.

Rentrée 2017, est publiée une première version de la liste de logiciels pour la session 2018. Elle s'accompagne à la fin d'une mention :

NB : algobox et les émulateurs de calculatrices ne sont plus proposés.

Mais fort bizarrement, le jury allait bien au-delà de ce qu'il avait annoncé dans sa purge. En effet le logiciel TI-Nspire CAS avait été supprimé de la liste lui aussi. Or, il ne s'agit absolument pas d'un émulateur de calculatrice, mais d'un véritable logiciel intégré de Mathématiques, issu historiquement d'une fusion du logiciel de calcul formel Derive et du logiciel de géométrie dynamique Cabri. Le seul rapport avec la calculatrice est que le logiciel permet entre autres de choisir d'afficher les documents au format calculatrice (notamment pour prendre des captures d'écran comme sur calculatrice sans avoir à connecter cette dernière), et également entre autres l'enregistrement des documents dans un format pouvant être ouvert sur calculatrice.

Par contre quand on annonce des critères et va jusqu'à se montrer extrêmement pointilleux dans leur application avec certains, faut-il encore savoir se montrer cohérent, constant et équitable.

Dans le contexte précédent quelle ne fut pas notre indignation de découvrir dès décembre 2017 une mise à jour de la liste rajoutant l'émulateur de calculatrice NumWorks.

La mention de fin de liste indiquant qu'il n'y avait plus d'émulateur de calcultarice avait comme par hasard été retirée lors de cet ajout. Cela empêchait certes la page de se contredire elle-même dans l'instant, mais pas de se contredire dans le temps puisque nous disposons de toutes les sauvegardes et te les lions à chaque fois.

Etait-ce tout simplement parce que la NumWorks était programmable en Python, contrairement à toutes ses concurrentes à l'époque ?

Quoi qu'il en soit, nous étions également fort surpris niveau pertinence de cet ajout. L'émulateur NumWorks a l'énorme défaut de ne pas retenir la saisie : tout ce que le candidat y saisit pendant son temps de préparation sera perdu lors de sa fermeture, notamment lors de l'extinction du système pour se rendre dans la salle du jury. Il n'y a aucune possibilité d'en sauvegarder ou recharger un état, et c'est même un piège pour les candidats qui ne seraient pas au courant. À quoi cet émulateur pouvait-il donc bien servir ?...

Nous comprenions parfaitement que le constructeur bride cet émulateur par rapport à la calculatrice physique, c'est totalement légitime. Sinon les élèves utiliseraient directement cet émulateur gratuit sur leur tablette/smartphone sans jamais avoir à acheter de calculatrice.

Mais maintenant que la licence NumWorks a changé et n'autorise plus la redistribution par des tiers du code compilé, il serait peut-être grand temps de reconsidérer la question.

Juillet 2019, une mise à jour de la liste annonce la suppression de Xcas pour la session 2020.

C'est fort étrange, une fois de plus. Xcas est un logiciel de mathématiques intégré par Bernard Parisse, enseignant-chercheur à l'Université de Grenoble, comportant entre bien d'autres choses un moteur de calcul formel, et programmable dans une syntaxe Python.

Des éditions sont de plus disponibles pour différents modèles de calculatrices (TI-Nspire CX II, TI-Nspire CX, NumWorks, Casio Graph 35+E II et Graph 90+E), permettant ainsi de réunir les utilisateurs devant une interface unique et des fonctionnalités haut de gamme communes, peu importe le prix d'achat de leur machine.

À la rigueur pourrait-on reprocher à Xcas de n'être pas véritablement programmable en Python mais juste dans une syntaxe proche du Python. Le code Python devait être adapté dans nombre de cas. Mais ce serait ici encore une application bien extrême des règles que nous supposons... avec certains.

Xcas fut finalement réintégré à la liste dès la session 2020 suite aux protestations.

Sessions 2018, 2019 et 2020 donc, l'émulateur NumWorks est ainsi le seul émulateur de calculatrice graphique utilisable par les candidats aux épreuves orales du CAPES de Mathématiques.

Nous doutons que beaucoup de candidats aient fait appel à cet émulateur lors de leur oral suite au gros problème évoqué plus haut, les derniers rapports du jury ne faisant d'ailleurs strictement aucune mention au sujet de cet outil.

Par contre il n'en offrait pas moins une mise en avant exclusive de la seule calculatrice NumWorks auprès des futurs enseignants.

Nous étions tout heureux suite à cela de t'annoncer enfin le retour de l'émulateur TI-83 pour la session 2021 après 4 ans d'absence, Texas Instruments en ayant en effet développé une version compatible Linux acceptée dans la liste, cette fois-ci dans son édition couleur TI-83 Premium CE.

Un gros avantage par rapport à l'émulateur NumWorks était ici la possibilité sur demande de sauvegarder et recharger l'état de l'émulateur !

Toutefois petit problème, ce logiciel n'émulait que l'ancien modèle TI-83 Premium CE, et pas la nouvelle TI-83 Premium CE Edition Python.

Cet émulateur n'était donc pas programmable en Python mais uniquement dans le langage Basic propriétaire de Texas Instruments, critère qui semblait avoir suffi à exclure bien d'autres logiciels avant lui.

Et nous y sommes, la liste des logiciels offerts lors des épreuves orales du CAPES de Mathématiques vient d'être mise à jour pour la session 2022. Au menu, une nouvelle purge :

• Geogebra
• LibreOffice
• émulateur NumWorks
• Python (bibliothèques matplotlib, numpy et scipy) via Pyzo
• Scratch
• émulateur TI-83 Premium CE
• Xcas
• Jupyter

Une nouvelle fois, le jury du CAPES de Mathématiques annonce la suppression de Xcas, alors que ce logiciel est presque programmable en Python. Décidément, ils y tiennent dur comme fer.

Ou bien le but serait-il d'empêcher les candidats d'avoir accès à un moteur de calcul formel ? Dans ce cas, nous signalons que pour être cohérent, il faudrait également supprimer Geogebra qui en intègre un, même si à la différence ce n'est pas mis en avant dans le nom du logiciel.

Et également, nous apprenons avec stupeur la disparition pour la session 2022 de l'émulateur TI-83 Premium CE, et ce alors que l'émulateur NumWorks est pour sa part conservé.

Est-ce parce que ce premier n'est pas programmable en Python ?

Malgré des membres de jury de plus en plus compétents dans le domaine numérique, l'offre logicielle au CAPES de Mathématiques est en plein effondrement. Plus que 5 éléments quand elle a pu en compter jusqu'à 13, on peut la résumer à la suite bureautique, Geogebra, et pour la programmation Scratch ou Python selon le niveau sur lequel le candidat est interrogé, à croire qu'il n'existe qu'une seule bonne façon de faire du numérique en Mathématiques.

Le jury n'a bien évidemment absolument pas à se justifier et nul doute qu'il agit pour le plus grand bien des futurs enseignants et de leurs futurs élèves, mais il n'empêche que la logique selon laquelle les logiciels rentrent et sortent de la liste nous est totalement inaccessible, et qu'en l'absence d'explication logique la seule alternative pour l'observateur extérieur est le pire.

Source : https://capes-math.org/index.php?id=epreuves-orales

[critor]

En janvier 2017, c'est tout un monument du jeu vidéo qui débarquait sur calculatrices TI-83 Premium CE et TI-84 Plus CE, j'ai nommé Oiram CE par MateoconLechuga.

Oiram CE est un moteur de jeu Mario-like reprenant partiellement le gameplay ainsi que les sprites de jeu Super Mario Bros 3 sorti en 1988 pour la console de jeu japonaise Nintendo Famicom puis en 1990 pour sa déclinaison internationale Nintendo NES.

Outre les niveaux intégrés, tu peux rajouter pléthore de packs de niveaux additionnels, et même en créer toi-même très facilement grâce à un éditeur dédié pour Windows ou Mac.

Grâce à Oiram CE, ta TI-83 Premium CE se transforme en formidable console de jeux portable.

En août 2020, Thomas Williamson portait Oiram CE pour calculatrices Casio Graph 90+E et fx-CG10/20/50.

Le portage avait comme gros point fort le fait d'accepter directement d'ouvrir les fichiers de niveaux au format .8xv de Texas Instruments.

Mais la version Casio bénéficiait également d'avantages spécifiques, comme celui de tirer profit de la puissance supérieure du matériel pour nous offrir une hauteur d'affichage bien plus grande. Tu peux comparer toi-même, rien à voir avec le demi-écran de la TI-83 Premium CE :

Aujourd'hui pour bien commencer l'année, nouveau pack de 6 niveaux par Sky, surnommé donc fort logiquement le Sky's Levelpack.

Les Koopa ont envahi le château dans le ciel, et c'est une nouvelle fois à toi de les déloger dans un nouveau pack de 6 niveaux.

Un pack conçu tout en talent et humour comme on le note aux messages très loin hors écran et ainsi invisibles pour le simple joueur, ainsi que plusieurs énormes tableaux de portraits au mur à la Mario 64 :

Attention, Oiram CE rentre dans la catégorie des programmes en langage machine dits ASM.

Sur Casio, aucun problème.

Mais par contre chez Texas Instruments, suite à un acte irresponsable d'un enseignant de Mathématiques français avec ses gesticulations aveugles dans le contexte de la réforme du lycée, le constructeur a réagi en supprimant la gestion de tels programmes depuis la mise à jour 5.5.1.

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

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

Téléchargements :

• Oiram pour TI-83PCE/84+CE Casio Graph 90+E / fx-CG10/20/50
• Sky's Levelpack
• autres packs de niveaux Oiram
• éditeur de niveaux Oiram (Windows + Mac)
• spécificités TI-83PCE/84+CE :
  
  • bibliothèques C
  • arTIfiCE
  • Cesium
  • AsmHook

[critor]

Pour accompagner en douceur la transition du Scratch au Python en Seconde, la plupart des solutions Python sur calculatrices graphiques offrent turtle, une bibliothèque permettant du tracé relatif comme en Scratch. On peut citer :

• la NumWorks dont l'application Python intègre directement turtle
• les Casio Graph 35+E II et Graph 90+E dont l'application Python intègre directement turtle
• les TI-Nspire CX II sur lesquelles on peut rajouter une bibliothèque turtle officielle à l'environnement Python
• et sur les TI-83 Premium CE Edition Python (France), TI-84 Plus CE-T Python Edition (Europe) et TI-84 Plus CE Python (Amérique du Nord), on pouvait jusqu'ici rajouter une bibliothèque officielle à l'application Python : ce_turtl

L'utilisation de ce_turtl sur TI-83 Premium CE Edition Python et compatible n'était jusqu'à présent pas de tout repos, loin de là. En effet énorme problème, les bibliothèques complémentaires comme ce_turtl n'étaient par défaut pas disponibles au menu.

Ils apparaissaient au menu uniquement lorsque l'on était en train d'éditer un script comportant une ligne les important (dans notre cas forcément sous la forme from ce_turtl import, et pas un simple import ce_turtl).

Lors de la création d'un script, afin d'obtenir le menu te permettant de saisir facilement et rapidement les appels aux différentes méthodes de ce_turtl, tu devrais donc commencer par te taper la saisie lettre par lettre au clavier de sa ligne d'importation, avec en prime le caractère tiret bas qui n'est pas au clavier et était donc à aller chercher dans un menu.

Mais attends car le pire, c'est que c'était encore loin d'être le pire...

Mais surtout bien pire que cela, ce_turtl était une véritable catastrophe ambulante !

Aucun effort ne semblait avoir été fait pour coller au standard : des méthodes essentielles manquantes, des noms de méthodes fantaisistes, des arguments attendus différant du standard dans leur nombre, leur ordre ou leur type... et ne parlons même pas encore du comportement attendu.

Si tu ne faisais pas l'effort d'adapter ton code, il t'était fort probable d'obtenir n'importe quoi. Voici ci-contre ce que donne un escargot sur ordinateur et l'ensemble de la concurrence, et sur TI-83 Premium CE Edition Python et compatibles avec ce_turtl...

Quel professeur allait perdre du temps à faire apprendre un sous-dialecte du turtle ne fonctionnant que sur calculatrices TI-83 Premium CE Edition Python et compatibles, risquant ainsi de mélanger les élèves par rapport aux documents, ouvrages ou autres autres plateformes auxquels ils ont accès (ordinateur, tablette, smartphone, calculatrice d'un autre modèle) ?...

Nous savons parfaitement que la mémoire de tas (heap) du Python des TI-83 Premium CE Edition Python et compatibles est extrêmement limitée, seulement 19,968 Ko de capacité, et en pratique souvent bien moins de disponible car les bibliothèques importées prennent de la place.

Dans ce contexte nous comprenons parfaitement qu'il faille se limiter et faire des choix.

Mais nous persistons à penser que l'on pouvait faire largement mieux niveau compatibilité et conformité que ce que nous a offert ce_turtl, et ce sans augmenter la consommation de heap à l'exécution.

Dans le cadre de sa mise à jour 5.7 pour TI-83 Premium CE Edition Python et compatibles, Texas Instruments avait publié une nouvelle bibliothèque complémentaire turtle 2.00. Le changement majeur de numéro de version suggérait des nouveautés significatives, et le changement de nom en turtle pour sa part un bien meilleur respect du standard.

Cette nouvelle bibliothèque turtle pouvait être installée indépendamment de la mise à jour ; elle fonctionnait tout aussi bien sur les versions précédentes selon nos tests.

Mais si tu mettais à jour en version 5.7 tu bénificiais d'un formidable avantage : un nouvel onglet de bas d'écran te permet enfin de lister les bibliothèques complémentaires importables et turtle en faisait partie !

Donc plus de saisie fastidieuse, une seule touche suffisait à coller la ligne d'importation et alors faire apparaître tout le contenu de la nouvelle bibliothèque turtle au menu !

La bibliothèque prédécesseure ce_turtle avait été publiée dans deux versions (Français et Anglais).

Problème par contre, la nouvelle bibliothèque turtle était intégralement en Anglais.

Et bien bonne nouvelle aujourd'hui, Texas Instruments nous publie une nouvelle bibliothèque turtle 2.01 cette fois-ci en Français !

Maintenant que les utilisateurs français sont à leur tour invités à passer à la nouvelle bibliothèque turtle, nous allons te présenter son fonctionnement, tester sa conformité au standard turtle, puis te montrer ce qu'elle donne par rapport à la concurrence sur quelques exemples.

1. Informations et fonctionnement
2. Le tour des menus
3. Premier script comparatif (ce_turtl + turtle)
4. Tests de conformité comparatifs (tous modèles)
5. 17 exemples comparatifs (tous modèles)
   
   1. La dalle aux ammonites
   2. Le défilé automobile
   3. L'escargot de lumière
   4. Les flocons de Koch
   5. La linea
   6. Pavage d'une lagogne
   7. Le triangle de Penrose
   8. La courtepointe de Mamie
   9. Les vitraux rhombiques
   10. Les roses par 12
   11. Les triangles de Sierpiński
   12. Sous le soleil exactement
   13. Le labyrinthe du Minotaure
   14. Le carreau de carreaux
   15. Les étoiles jumelles
   16. La toile de l'araignée
   17. ♫ Le tournesol, le tournesol, ... ♫

A) Informations et fonctionnement

Go to top

La publication de Texas Instruments consiste en 2 fichiers de variables d'application pour calculatrice :

• TURTLE.8xv
• GRID.8xv

TURTLE.8xv est la bibliothèque Python complémentaire en question, ici en version 2.0.0. Soit cela signifie qu'il y a eu des versions inférieures de test auxquelles nous n'avons pas eu accès, soit ce changement de numérotation majeure est pour noter une différence significative par rapport à ce_turtle.

Le fichier TURTLE.8xv a été généré par Texas Instruments à l'aide de py2appvar, un outil non public de Texas Instruments permettant à partir d'un fichier source Python :

• la conversion du cose source Python en bytecode Python
• l'énumération des éléments à mettre au menu à partir de lignes de commentaires spécialement formatées à cette fin dans le code source

Contrairement à CE_TURTL.8xv, TURTLE.8xv a été généré à l'aide d'une version plus récente de l'outil py2appvar, non plus la 1.2.0 mais la 1.2.1. Nous supposons que py2appvar 1.2.1 ajoute la gestion de la nouvelle ligne de commentaire permettant de spécifier l'ajout de la commande d'importation au menu des bibliothèques complémentaires.

GRID.8xv quant à lui n'est rien d'autre qu'une image 320×210 pixels au format IM8C directement affichable par les scripts Python de la calculatrice et que voici justement ci-contre ; il s'agit donc d'une grille.

Code: Tout sélectionner

from ti_image import *
load_image("GRID")
show_image(0, 0)
show_screen()

Cette image sera affichée automatiquement à chaque début d'appel à des fonctions de tracé turtle, se comportant donc comme une sorte de fond d'écran.

Code: Tout sélectionner

from turtle import *
t = Turtle()
t.circle(52)
t.done()

Tu peux très bien te passer de GRID, soit ne pas transférer ou effacer la variable en question. Dans ce cas cela ne déclenche pas d'erreur, mais rappelons que le Python sur TI-83 Premium CE Edition Python et compatible ne dispose pas d'un calque dédié aux affichages graphiques, ces derniers étant effectués par-dessus la console. Ne trouvant alors rien à afficher, l'écran ne sera pas nettoyé et il te faudra alors rajouter du code en ce sens.

Tu peux également t'amuser à remplacer le fond d'écran de la bibliothèque turtle comme bon te semble. Notre outil en ligne img2calc te permet de convertir n'importe quelle image au format IM8C de Texas Instruments, et il te suffira alors juste de choisir le nom GRID pour la calculatrice.

Rappelons que comme le buffer d'affichage est ici unique, tu dois effectuer une pause en fin de script sous peine de voir ton tracé une fois terminé être immédiatement écrasé par l'affichage de la console. La bibliothèque turtle t'offre pour cela la méthode .done() qui attend l'appui sur la touche

annul

(ou

clear

sur les TI-84 Plus CE), mais tu es libre d'utiliser n'importe quel autre code générant une attente.

À noter que la bibliothèque turtle t'offre la possibilité de désactiver l'affichage de la grille. Il te suffira d'appeler la méthode .hidegrid() avant ta première instruction d'affichage.

En pratique la méthode .hidegrid() efface simplement l'écran en blanc.

B) Le tour des menus

Go to top

Les méthodes au menu sont réparties sous 5 onglets différents:

• Move : pour les déplacements de la tortue
• Draw : pour les tracés autres que des segments (cercle, texte, remplissage, ...)
• Pen : pour tout ce qui concerne le stylo (levé, baissé, couleur, taille)
• Settings : pour différents réglages (effacement du tracé, cacher/montrer la tortue, désactiver l'affichage de la grille comme déjà vu, vitesse)
• State : pour interroger l'état de la tortue (position, orientation)

Les noms d'onglets ne sont donc pas traduits ici. Sans doute parce qu'avec des noms en Français il aurait été bien difficile de continuer à afficher ces 5 onglets sur un même écran.

La traduction en Français concerne en fait les noms de paramètres des fonctions au menu, ainsi que les éventuelles indications les accompagnant :

Mais ce qui est extraordinaire ici et à ce jour une exclusivité toute concurrence confondue, c'est la présence des méthodes de remplissage de formes, et nous allons nous régaler dans les exemples qui vont suivre !

De quoi a priori étendre très largement les possibilités et facilités de tracé pour les élèves !

C) Premier script comparatif (ce_turtl + turtle)

Go to top

Tentons un premier script dessinant une cible :

ce_turtl	turtle
Code: Tout sélectionner from ce_turtl import * turtle.clear() turtle.goto(0,-95) s = 3 for r in range(0, 159, r):   turtle.circle(r) turtle.show()	Code: Tout sélectionner from turtle import * t = Turtle() t.goto(0,-95) s = 3 for r in range(0, 159, r):   t.left(90)   t.circle(r)   t.right(90) t.done()

Déjà ce script met en évidence un bug en Python des TI-83 Premium CE Edition Python et compatibles : au-delà d'une certaine valeur de rayon les tracés de cercles se déforment très rapidement et tendent vers des carrés.

Le bug n'est en fait ni dans ce_turtl ni dans turtle, mais dans le module de tracé par pixels ti_graphics qu'ils utilisent tous les deux sur ces calculatrices, visiblement toujours pas corrigé en version 5.7.

Mais problème... Si tu regardes bien bien que la structure soit similaire, nous avons dû écrire 2 scripts différents pour ce_turtl et turtle.

Si en plus on fait rentrer la concurrence dans l'équation, il n'est pas envisageable pour nous de maintenir jusqu'à 7 versions différentes pour chaque script testé...

D) Tests de conformité comparatifs (tous modèles)

Go to top

Tentons donc un autodiagnostic des différences entres tous les modules turtle, c'est-à-dire la vérification de tout ce qui peut différer du standard.

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

ttl_chk.py ttl_diags.py

Code: Tout sélectionner

_turtle_errors = 0

def _turtle_error(k):
  global _turtle_errors
  _turtle_errors |= 1 << k

# import turtle
try:
  import turtle
  if not "forward" in dir(turtle):
    turtle = turtle.Turtle()
except ImportError: #TI-83 Premium CE
  from ce_turtl import turtle
  _turtle_error(0)
try:
  turtle.clear()
except:
  turtle.reset()

# can turtle be patched ?
_fix_turtle = True
try:
  def _fixcolor(c): return c
  turtle._fixcolor = _fixcolor
except:
  _fix_turtle = False

# test color() + pencolor() + fillcolor()
if not "pencolor" in dir(turtle):
  pencolor = turtle.color
  _turtle_error(1)
else:
  pencolor = turtle.pencolor
if not "color" in dir(turtle):
  _turtle_error(2)
if not "fillcolor" in dir(turtle):
  _turtle_error(12)

if not "clear" in dir(turtle):
  _turtle_error(13)
if not "reset" in dir(turtle):
  _turtle_error(14)
if not "heading" in dir(turtle):
  _turtle_error(11)

# test color argument types
_color_types = 0
try:
  pencolor([0, 0, 0])
  _color_types |= 1 << 0
except: _turtle_error(4)
try:
  pencolor((0, 0, 0))
  _color_types |= 1 << 1
except: _turtle_error(5)
try:
  pencolor(0, 0, 0)
  _color_types |= 1 << 2
except: _turtle_error(6)
try:
  pencolor("black")
  _color_types |= 1 << 3
except: _turtle_error(7)

# test colormode()
if not "colormode" in dir(turtle):
  _turtle_error(3)

# test color strings
_colors_fix={
  "blue":(0,0,1),
  "green":(0,1,0),
  "red":(1,0,0),
  "cyan":(0,1,1),
  "yellow":(1,1,0),
  "magenta":(1,0,1),
  "white":(1,1,1),
  "orange":(1,0.65,0),
  "purple":(0.66,0,0.66),
  "brown":(0.75,0.25,0.25),
  "pink":(1,0.75,0.8),
  "grey":(0.66,0.66,0.66),
  "black":(0,0,0),
}
for c in tuple(_colors_fix.keys()):
  try:
    pencolor(c)
    _colors_fix.pop(c)
  except: pass
if len(_colors_fix):
  if _color_types & 1 << 3:
    _turtle_error(8)

# test circle(,)
try: turtle.circle(0,0)
except:
  _turtle_error(9)

#test towards
try: turtle.towards
except:
  _turtle_error(15)

# test for unfixable missing functions
_missing_fct=["write","pensize","dot"]
for f in tuple(_missing_fct):
  try:
    eval("turtle."+f)
    _missing_fct.remove(f)
  except: pass
if len(_missing_fct):
    _turtle_error(16)

_missing_alias=[
  ["backward","back","bk"],
  ["forward","fd"],
  ["right","rt"],
  ["left","lt"],
  ["position","pos"],
  ["goto","setpos","setposition"],
  ["setheading","seth"],
  ["pendown","pd","down"],
  ["penup","pu","up"],
  ["pensize","width"],
  ["showturtle","st"],
  ["hideturtle","ht"],
]
for aliases in tuple(_missing_alias):
  validf = None
  for f in tuple(aliases):
    try:
      eval("turtle."+f)
      validf = f
      aliases.remove(f)
      break
    except: pass
  for f in tuple(aliases):
    try:
      eval("turtle."+f)
      aliases.remove(f)
    except: pass
  if not len(aliases):
    _missing_alias.remove(aliases)
  else:
    aliases.insert(0, validf)
if len(_missing_alias):
    _turtle_error(17)

try:
  turtle.position()
except:
  try:
    turtle.pos()
  except:
    _turtle_error(10)

Code: Tout sélectionner

from ttl_chk import *
from ttl_chk import _fix_turtle, _turtle_errors, _colors_fix, _missing_fct, _missing_alias

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

turtle_diags()

Voici ce que nous racontent les scripts sur calculatrices Texas Instruments :

TI-83PCE/84+CE ce_turtl	TI-83PCE/84+CE turtle	TI-Nspire CX II turtle

Pas étonnant que ce_turtle fasse n'importe quoi, c'est une véritable calamité. Pas moins de 12 erreurs, et encore ce sont juste celles qui sont détectées. La grande majorité de ce qui est testé ne va pas :

• ligne d'importation non standard (à cause du nom)
• réglage non standard de la couleur du tracé, utilisant la méthode .color() au lieu de .pencolor()
• absence de la méthode .colormode() et donc pas de possibilité de modifier le mode des coordonnées de couleurs (maximum de chaque composante à 1 ou à 255)
• refus des paramètres de couleurs sous forme de tuple, liste ou chaîne de caractères, les fonctions concernée prennent obligatoirement 3 paramètres avec les valeurs de chaque composante
• la méthode .circle() ne prend qu'un seul argument et ne gère donc pas les arcs de cercle
• absence des méthodes de remplissage
• absence de la méthode d'effacement et réinitialisation de la tortue .reset()
• absence de la méthode d'écriture de texte .write()
• absence de 18 alias courts pour les noms de méthodes

Avec la nouvelle bibliothèque turtle nous tombons à seulement 8 erreurs.

Son code source ne semblerait pas dériver de celui de ce_turtl, puisque certains types d'erreurs disparaissent quand d'autres apparaissent.

Restent donc :

• absence de la méthode .color()
• absence de la méthode .colormode() et donc pas de possibilité de modifier le mode des coordonnées de couleurs (maximum de chaque composante à 1 ou à 255)
• refus des paramètres de couleurs sous forme de liste ou chaîne de caractères, mais les tuples sont acceptés
• la méthode .circle() ne prend qu'un seul argument et ne gère donc pas les arcs de cercle
• absence de la méthode d'effacement et réinitialisation de la tortue .reset()
• absence de la méthode .towards() pour orienter la tortue vers une cible de coordonnées données
• absence de 16 alias courts pour les noms de méthodes

Le turtle des TI-Nspire CX II pour sa part ne donne que 5 erreurs. Vu la grande similarité, on pourrait se demander si la nouvelle bibliothèque turtle des TI-83 Premium CE Edition Python et compatibles ne découlerait pas de celui des TI-Nspire CX II, avec juste la suppression des paramètres de couleurs sous forme de chaîne de caractères afin d'économiser un peu de place en heap.

Voici pour référence les résultats du même test chez la concurrence :

Casio Graph 90/35+E II	NumWorks	KhiCAS NumWorks TI-Nspire CX II CX

Un avantage des Texas Instruments et des Casio, c'est que le contenu de la bibliothèque turtle peut être altéré à l'exécution après importation, et la plupart des erreurs sont ainsi corrigeables !

À nuancer toutefois dans les cas des TI-83 Premium CE Edition Python et compatibles, car vu la faible capacité du heap on ne peut pas non plus envisager de tout corriger sauf à réduire drastiquement l'espace mémoire pour les instructions du script au-delà de l'importation.

Voici un script qu'il suffit d'importer à la place de la bibliothèque turtle de chaque machine, et qui lorsque celle-ci est modifiable corrige la plupart des erreurs détectées :

Code: Tout sélectionner

from ttl_chk import *
from ttl_chk import _color_types, _turtle_errors, _colors_fix, _missing_fct, _missing_alias

_fix_turtle = True

def nop(*argv): return None
idty = lambda c: c

try: # can turtle be patched ?
  turtle._fixcolorlist = idty
  turtle._fixcolorval = idty
  turtle._fixcolorstring = idty
  turtle._fixcolorargs = idty
  turtle._fixcolor = lambda c: turtle._fixcolorlist(turtle._fixcolorval(turtle._fixcolorstring(turtle._fixcolorargs(c))))
except:
  _fix_turtle = False

if _fix_turtle:

  # fix color() + pencolor()
  if _turtle_errors & 0x1000:
    turtle.fillcolor, turtle.begin_fill, turtle.end_fill = idty, nop, nop
  if _turtle_errors & 2:
    def _pencolor_(*argv):
      if len(argv): turtle.color(argv)
      else: return turtle.color()[0]
    turtle.pencolor = _pencolor_
  if _turtle_errors & 4:
    def _color_(*argv):
      if len(argv) == 2:
        turtle.pencolor(argv[0])
        turtle.fillcolor(argv[1])
      elif len(argv):
        turtle.pencolor(argv)
      else:
        return (turtle.pencolor(), turtle.fillcolor())
    turtle.color = _color_

  _fix_color = _color_types & 0b11 != 0b11 or not "colormode" in dir(turtle)

  # fix list/tuple color argument
  if _color_types & 0b11 == 0b10:
    def _fixcolorlist(c): return type(c) is list and tuple(c) or c
    turtle._fixcolorlist = _fixcolorlist
  if _color_types & 0b11 == 0b01:
    def _fixcolorlist(c): return type(c) is list and list(c) or c
    turtle._fixcolorlist = _fixcolorlist
  if not _color_types & 4:
    def _fixcolorargs(*argv):
      return len(argv) != 1 and argv or argv[0]

  if _fix_color:
    turtle._color = turtle.color
    turtle._pencolor = turtle.pencolor
    turtle._fillcolor = turtle.fillcolor
    if _color_types & 0b11:
      def _color(*argv):
        n = len(argv)
        if not(n): return turtle._color()
        elif n==2: turtle._color(argv[0], argv[1])
        else: turtle._color(n > 1 and argv or argv[0])
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        turtle._pencolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0]))
      def _fillcolor(*argv):
        if not(len(argv)): return turtle._fillcolor()
        turtle._fillcolor(turtle._fixcolor(len(argv) > 1 and argv or argv[0]))
    else:
      def _color(*argv):
        n = len(argv)
        if not(n): return turtle._color()
        c = turtle._fixcolor(n == 3 and argv or argv[0])
        turtle._color(c[0], c[1], c[2])
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        c = turtle._fixcolor(len(argv)>1 and argv or argv[0])
        turtle._pencolor(c[0], c[1], c[2])
      def _fillcolor(*argv):
        if not(len(argv)): return turtle._fillcolor()
        c = turtle._fixcolor(len(argv)>1 and argv or argv[0])
        turtle._fillcolor(c[0], c[1], c[2])
    turtle.color = _color
    turtle.pencolor = _pencolor
    turtle.fillcolor = _fillcolor

  # fix colormode()
  if _turtle_errors & 8:
    # test color mode
    try:
      turtle.pencolor([255, 0, 0])
      _color_mode = 255
    except: _color_mode = 1.0
    turtle._color_mode = _color_mode
    def _colormode(*argv):
      if not(len(argv)): return turtle._color_mode
      if int(argv[0]) in (1, 255):
        turtle._color_mode = int(argv[0]) == 255 and 255 or 1.0
    turtle.colormode = _colormode
    if _color_mode == 255:
      turtle._fixcolorval = lambda c: int(turtle._color_mode) == 1 and type(c) in (list, tuple) and [int(c[k] * 255) for k in range(3)] or c
    else:
      turtle._fixcolorval = lambda c: turtle._color_mode == 255 and type(c) in (list, tuple) and [c[k] / 255 for k in range(3)] or c

  # fix color strings
  if len(_colors_fix):
    def _fixcolorstring(c):
      if type(c) is str and c in _colors_fix:
        c = _colors_fix[c]
        if turtle.colormode() == 255:
          c = [int(c[k] * 255) for k in range(3)]
      return c
    turtle._fixcolorstring = _fixcolorstring

  # fix circle(,)
  if _turtle_errors & 0x200:
    turtle._circle = turtle.circle
    def _circle(r, a=360): turtle._circle(r)
    turtle.circle = _circle

  if len(_missing_fct):
    for f in _missing_fct:
      exec("turtle."+f+"=nop")

  if len(_missing_alias):
    for aliases in _missing_alias:
      validf = aliases[0]
      for f in aliases[1:]:
        exec(validf and "turtle."+f+"=turtle."+validf or "turtle."+f+"=nop")

  # fix clear()
  if _turtle_errors & 0x2000:
    turtle.clear = turtle.reset

  # fix reset()
  if _turtle_errors & 0x4000:
    turtle.reset = turtle.clear

  # fix towards()
  if _turtle_errors & 0x8000:
    from math import atan2, pi
    def _towards(x, y):
      x0, y0 = turtle.pos()
      return atan2(y - y0, x - x0) * 180 / pi
    turtle.towards = _towards

Nous pouvons envisager à partir de maintenant d'avoir une unique version de chaque script utilisable sur l'ensemble des machines.

E) 17 exemples comparatifs (tous modèles)

Go to top

Maintenant que nous avons de quoi faire tourner une unique version de chaque script sur l'ensemble des machines, poursuivons l'exploration de l'ensemble des modules turtle avec quelques exemples de script.

Nous allons en profiter pour nous en donner à cœur joie avec les formidables nouvelles fonctions de remplissage, sur le thème de #LesMathématiquesSontBelles.

Cela va justement être l'occasion de voir si il y a d'autres problèmes qui n'ont pas pu être détectés automatiquement.

Plusieurs des exemples qui vont suivre sont inspirés de publications de Bert Wikkerink pour TI-Nspire CX II et très librement et fortement adaptés pour être fonctionnels dans le contexte du heap Python bien plus restreint des TI-83 Premium CE et compatibles.

1. La dalle aux ammonites
2. Le défilé automobile
3. L'escargot de lumière
4. Les flocons de Koch
5. La linea
6. Pavage d'une lagogne
7. Le triangle de Penrose
8. La courtepointe de Mamie
9. Les vitraux rhombiques
10. Les roses par 12
11. Les triangles de Sierpiński
12. Sous le soleil exactement
13. Le labyrinthe du Minotaure
14. Le carreau de carreaux
15. Les étoiles jumelles
16. La toile de l'araignée
17. ♫ Le tournesol, le tournesol, ... ♫

Exemple n°1 : La dalle aux ammonites

Go to top

C'est donc parti pour quelques exemples afin d'approfondir les améliorations de la nouvelle bibliothèque turtle pour TI-83 Premium CE Edition Python et compatibles, ainsi que les points forts et faibles par rapport aux autres modèles de calculatrices.

Précisons que les problèmes récurrents ne seront pas systématiquement réévoqués sur chaque exemple.

Un petit peu au Nord de Digne-les-bains en rive droite de la Bléone se trouve la dalle aux ammonites. Comme il est strictement interdit d'en prélever, voici de quoi en reproduire une sur ta calculatrice :

Code: Tout sélectionner

from ttl_fix import *
from math import pi

turtle.speed(0)
turtle.pencolor((0,0,0))
turtle.pendown()
turtle.pensize(1)

turtle.goto(0,-8)
x,y = turtle.pos()
turtle.left(115)
for i in range(132):
  turtle.forward(10)
  try:
    h = turtle.towards(x,y)
    turtle.setheading(h)
  except: pass
  d=10*pi
  turtle.forward(d)
  turtle.backward(d)
  turtle.right(90)

try: turtle.show() #TI-83 Premium CE
except: pass

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

Il y avait donc avec ce_turtl un problème d'écart par rapport au standard, un décalage d'une unité lors du réglage de l'épaisseur via la méthode turtle.pensize().
Ici l'appel turtle.pensize(1) produisait l'effet d'un turtle.pensize(2).
Et plus généralement un appel turtle.pensize(s) produisait l'effet d'un turtle.pensize(s+1).
On peut noter que le problème disparaît avec le nouveau module turtle.[/success][/warning]

KhiCAS et la NumWorks ont un tracé incorrect ici, car la méthode .towards() est absente de leur implémentation de turtle. Et malheureusement, le turtle n'est ici pas altérable à l'exécution ce qui nous empêche de corriger.

L'écran de la Casio Graph 35+E II a une définition très inférieure de seulement 128×64 pixels, et bien évidemment le tracé est donc tronqué. Bien dommage que contrairement à KhiCAS il ne soit ici pas possible de faire défiler le tracé en fin d'exécution...

Exemple n°2 : Le défilé automobile

Go to top

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

Code: Tout sélectionner

from ttl_fix import *

def rpoly(c, n):
  for k in range(n):
    turtle.forward(c)
    turtle.left(360 / n)

def audi(r):
  ir = 2 * r // 13
  turtle.penup()
  turtle.left(90)
  turtle.forward(r//2 - 2*ir)
  turtle.right(90)
  turtle.forward(-ir)
  turtle.pendown()
  turtle.pensize(3)
  for i in range(4):
    turtle.penup()
    turtle.forward(3 * ir)
    turtle.pendown()
    turtle.circle(2 * ir)

def mercedez_benz(r):
  ir = r // 2
  turtle.penup()
  turtle.forward(ir)
  turtle.left(90)
  turtle.forward(ir)
  turtle.pendown()
  turtle.pensize(2)
  x, y = turtle.pos()
  turtle.setheading(210)
  for i in range(3):
    turtle.goto(x,y)
    turtle.forward(ir)
    turtle.left(120)
  turtle.setheading(0)
  turtle.circle(-ir)

def citroen(r):
  x,y=turtle.pos()
  turtle.setheading(0)
  turtle.color((255,0,0), (255,0,0))
  turtle.begin_fill()
  rpoly(r, 4)
  turtle.end_fill()
  turtle.fillcolor((255,255,255))
  for i in range(2):
    turtle.setheading(45)
    turtle.begin_fill()
    for k in range(2):
      turtle.forward(.71 * r)
      turtle.left(k and 172 or -90)
    for k in range(2):
      turtle.forward(5 * r / 6)
      turtle.left(106)
    turtle.end_fill()
    y += r / 3
    turtle.penup()
    turtle.goto(x,y)
    turtle.pendown()

def mitsubichi(r):
  ir = r // 3
  turtle.penup()
  turtle.left(90)
  turtle.forward(ir)
  turtle.right(90)
  turtle.forward(r // 2)
  turtle.pendown()
  for i in range(3):
    turtle.setheading(60 + 120*i)
    turtle.color((255,0,0), (255,0,0))
    turtle.begin_fill()
    for k in range(4):
      turtle.forward(ir)
      turtle.left((k%2) and 120 or 60)
    turtle.end_fill()

def jeep(r):
  a=54
  ir = r/0.47552825814758/4 #sin(radians(a))/cos(radians(a))
  a=ir/0.85
  d=0.93*ir
  turtle.penup()
  turtle.forward(r//2)
  turtle.right(90)
  turtle.forward(ir - r)
  turtle.pendown()
  x, y = turtle.pos()
  turtle.setheading(234)
  turtle.forward(ir)
  turtle.left(126)
  turtle.fillcolor((180,180,180))
  turtle.begin_fill()
  rpoly(a, 5)
  turtle.end_fill()
  for i in range(5):
    col = i < 3 and (0,0,0) or (255,255,255)
    for j in range(2):
      turn =  j and turtle.left or turtle.right
      turtle.goto(x,y)
      turtle.setheading(90 + 72*i)
      turtle.fillcolor(col)
      turtle.begin_fill()
      turtle.forward(d)
      turn(172)
      turtle.forward(0.85*d)
      turn(44)
      turtle.forward(0.2*d)
      turtle.end_fill()
      col = [255 - col[k] for k in range(3)]

turtle.speed(0)
turtle.colormode(255)

r = 92
for iy in range(2):
  for ix in range(3):
    i = iy*3+ix
    if i < 5:
      y, x = (2*iy - 1) * r//2 - 48, (ix - 1)*r - 50
      turtle.penup()
      turtle.goto(x, y)
      turtle.setheading(0)
      turtle.pensize(1)
      turtle.pencolor((0,0,0))
      turtle.pendown()
      (mercedez_benz,jeep,mitsubichi,citroen,audi)[i](r)

try: turtle.show() #TI-83 Premium CE
except: pass

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

ce_turtl nous révélait ici nombre de problèmes :

• absence des méthodes de remplissage de formes
• contrairement au standard, les cercles sont tracés non pas en passant par la position de la tortue, mais en prenant pour centre la position de la tortue
• la méthode .circle(r) ne comprend pas les valeurs de rayons négatives pour contrôler le sens de tracé

Mis à part ce dernier point, tout le reste est corrigé avec le nouveau turtle !

Les Casio et NumWorks n'ont pas davantage les méthodes de remplissage de formes.
KhiCAS en dispose mais souffre hélas d'un autre bug bien gênant ici ; la couleur de remplissage passé en 2^ème paramètre de la méthode .color(,) est apparemment ignorée.

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

Go to top

Si tu es dans le Sud de la France tu sais qu'il ne pleut pas souvent (par contre, quand il pleut... il pleut !). Alors voici pour toi un escargot bariolé :

Code: Tout sélectionner

from math import exp
from ttl_fix import *

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(1.0)

turtle.penup()
turtle.goto(0, -20)
turtle.pendown()
turtle.right(90)
for i in range(20):
  c = [exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)]
  cb = [v/2 for v in c]
  turtle.color(cb, c)
  try: turtle.begin_fill()
  except: pass
  turtle.circle(27 + i)
  try: turtle.end_fill()
  except: pass
  turtle.right(10)

try: turtle.show() #TI-83 Premium CE
except: pass

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

De nouveau une véritable catastrophe avec ce_turtl qui semble tracer n'importe quoi et surtout pas ce qui est demandé. Toujours le problème du comportement non standard de la méthode .circle().
Heureusement, le nouveau turtle pour sa part se comporte enfin correctement et conformément au standard.

Par contre, dans le cas particulier du tracé de cercles via la méthode .circle(), le nouveau turtle des TI-83 Premium CE et compatibles semble être incapable de remplir l'intérieur de la forme.

Le turtle des TI-Nspire CX II colorie pour sa part bien l'intérieur des cercles avec la couleur de remplissage, mais oublie de tracer le périmètre avec la couleur du crayon.

Exemple n°4 : Les flocons de Koch

Go to top

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

Code: Tout sélectionner

from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def koch(n, l):
  if n<=0:
    turtle.forward(l)
  else:
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)
    turtle.right(120)
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)

def flock(n, l):
  koch(n, l)
  turtle.right(120)
  koch(n, l)
  turtle.right(120)
  koch(n, l)

turtle.speed(0)
turtle.colormode(255)

c = [127, 255, 0]
l = 80
for j in range(2):
  for i in range(3):
    n = j and 3 + i or 2 - i
    s = 5 - n
    turtle.penup()
    turtle.goto(i*117-157, j*95-25)
    turtle.pencolor(tuple(c))
    turtle.pensize(s)
    turtle.setheading(0)
    turtle.pendown()
    flock(n, l)
    n += 1
    rotate_list(c)

try: turtle.show() #TI-83 Premium CE
except: pass

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

Cette fois impossible de ne pas le voir, énorme décalage avec ce_turtl dont le tracé part littéralement dans le décor pour le flocon en haut à droite.
Heureusement, ce problème est corrigé avec le nouveau turtle.

Par contre, turtle introduit un nouveau problème : le réglage de l'épaisseur du crayon avec .pensize() semble ne pas gérer les valeurs 4 et supérieures, l'épaisseur du tracé retombant alors à 1.

Fort bizarrement les NumWorks et KhiCAS tracent le flocon en haut à droite de la mauvaise couleur, respectivement en noir et blanc.

Exemple n°5 : La linea

Go to top

Code: Tout sélectionner

try: #TI-83 Premium CE
  from ti_system import disp_clr
  disp_clr()
except: pass
from ttl_fix import *

def spiral(k,a,l):
  x0, y0 = turtle.pos()
  h0 = turtle.heading()
  while True:
    for s in l:
      turtle.forward(s*k)
      turtle.left(180-a)
    x, y = turtle.pos()
    if abs(x - x0) + abs(y - y0) + abs(turtle.heading() - h0) <= 1:
      break

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(255)
turtle.color((0,0,0),(255,255,0))

try:
  for i in range(-1, 2, 2):
    turtle.penup()
    turtle.goto(80*i - ((i > 0) and 40 or 50), 0)
    turtle.pendown()
    try: turtle.begin_fill()
    except: pass
    spiral((i > 0) and 9 or 30, (i > 0) and 90 or 36, (i > 0) and (1,2,3,4,5,6,7,8,9) or (1,2,3))
    try: turtle.end_fill()
    except: pass
except MemoryError as e: print(e)

try: turtle.show() #TI-83 Premium CE
except: pass

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

Dans le cas ici de polygones croisés, on peut remarquer que les turtle de KhiCAS, des TI-Nspire CX II ainsi que des TI-83 Premium CE et compatibles semblent partager le même algorithme de remplissage, un algorithme qui semble différer du standard dans le cas du remplissage de polygones croisés.

Le nouveau turtle des TI-83 Premium CE et compatibles ne termine pas le tracé par manque de mémoire de tas (heap), ne remplissant pas la figure de droite. En effet, à compter de l'appel .begin_fill() toutes les étapes de la tortue sont enregistrées dans une liste, liste qui donnera donc les sommets du polygone à remplir lors de l'appel .end_fill(). Sauf que nous avons extrêmement peu de heap sur les TI-83 Premium CE et compatibles, seulement dans les 17K, déjà lourgement consommés par les bibliothèques chargées ici. Cele fait donc beaucoup trop de sommets à enregistrer.

Exemple n°6 : Pavage d'une lagogne

Go to top

Partons maintenant à la pêche avec un script très hautement impressionnant par rapport aux contraintes de heap des TI-83 Premium CE et compatibles ; ici nous sommes vraiment sur le fil de la limite des possibilités.

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

Code: Tout sélectionner

from math import sqrt
from ttl_fix import *

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(255)
turtle.pencolor((0,0,0))

a=16

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

try: turtle.show() #TI-83 Premium CE
except: pass

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

KhiCAS semble être dans les choux ici, du moins niveau pavage. Par contre ici les couleurs de remplissage sont correctes, car on utilise la méthode .fillcolor() qui, à la différence de .color(), semble fonctionner correctement.

Les Casio et NumWorks se révèlent incapables de tracer les yeux, car ne disposant pas de la méthode .dot().

Exemple n°7 : Le triangle de Penrose

Go to top

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

Code: Tout sélectionner

from math import sqrt
from ttl_fix import *

def hook(a, c):
  turtle.penup()
  turtle.goto(0,-15)
  turtle.setheading(a)
  turtle.forward((l - 4*b) / sqrt(3))
  turtle.right(150)
  turtle.pendown()
  lf = ((turtle.left, 60),[turtle.forward,b],(turtle.left,120),(turtle.forward,l-b),[turtle.right,120],[turtle.forward,l-3*b])
  try:
    turtle.fillcolor(c)
    turtle.begin_fill()
  except: pass
  for k in range(-len(lf) + 1, len(lf)):
    tf = lf[abs(k)]
    if k == 1: tf[1] = l
    elif k == 4: tf[0] = turtle.left
    elif k == 5: tf[1] = b
    tf[0](tf[1])
  try: turtle.end_fill()
  except: pass
 
turtle.speed(0)
turtle.pensize(2)
turtle.colormode(255)

l=180
b=23

for i in range(112):
  turtle.pencolor(232 - int(i * 23 / 11), 249 - int(i * 29 / 55), 255)
  turtle.penup()
  turtle.goto(-192, 111 - 2*i)
  turtle.pendown()
  turtle.forward(384)

turtle.pencolor((0,0,0))
turtle.pensize(1)

hook(330, (255,255,0))
hook(90, (0,0,255))
hook(210, (255,0,0))

try: turtle.show() #TI-83 Premium CE
except: pass

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

C'est cette fois-ci ce_turtl dont le tracé ne ressemblait à rien d'attendu...
Heureusement, le problème est corrigé avec le nouveau turtle.

Exemple n°8 : La courtepointe de Mamie

Go to top

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

Code: Tout sélectionner

from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def poly_reg_a(l, a):
  h0 = turtle.heading()
  while True:
    turtle.forward(l)
    turtle.left(a)
    if abs(h0 - turtle.heading()) < .1:
      break

turtle.hideturtle()
turtle.speed(0)
turtle.pensize(1)
turtle.colormode(255)

c = [191, 127, 0]
cf = [127, 255, 0]
i = 0
while i > -3:
  j = 0
  while j > -2:
    turtle.penup()
    turtle.goto((i - 1)*88, (j - 1)*85 + 28)
    turtle.pendown()
    turtle.color(c, cf)
    try: turtle.begin_fill()
    except: pass
    poly_reg_a(80, 140)
    try: turtle.end_fill()
    except: pass
    rotate_list(c)
    rotate_list(cf)
    j = -j + (j <= 0)
  i = -i + (i <= 0)

try: turtle.show() #TI-83 Premium CE
except: pass

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

Exemple n°9 : Les vitraux rhombiques

Go to top

Voici maintenant une belle rosace rhombique pour décorer le bâtiment de ton choix.

Nous utilisons ici la méthode .dot() permettant de remplir un disque, afin de générer de quoi avoir une couleur de fond d'écran sur nos calculatrices, suffit-il juste de lui spécifier un diamètre suffisamment grand pour remplir tout l'écran :

Code: Tout sélectionner

from ttl_fix import *

turtle.speed(0)
turtle.colormode(255)
turtle.pencolor((0,0,255))
turtle.dot(320)
turtle.pencolor((0,0,0))
turtle.pensize(2)
col = ((255,0,0),(255,255,0),(0,255,0),(255,255,255),(255,0,255))
a=60

for i in range(10):
  c = col[i%5]
  turtle.color(c, c)
  turtle.begin_fill()
  for j in range(5):
    turtle.forward(a)
    turtle.right(72)
  turtle.end_fill()
  turtle.right(36)

for i in range(10):
  c = [v//3 for v in col[i%5]]
  turtle.pencolor(c)
  for j in range(5):
    turtle.forward(a)
    turtle.right(72)
  turtle.right(36)

try: turtle.show() #TI-83 Premium CE
except: pass

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

Exemple n°10 : Les roses par 12

Go to top

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

Code: Tout sélectionner

from math import pi, sin, cos, sqrt
from ttl_fix import *

def rpoly(c, n):
  a=360/n
  for k in range(n):
    turtle.forward(c)
    turtle.left(a)
def carre(c): rpoly(c, 4)

turtle.speed(0)
turtle.colormode(255)
turtle.penup()

r=80
alpha=(15 * pi / 180)

for i in range(320):
  c=int(255/320*i)
  turtle.pencolor(c,c,c)
  try: turtle.dot(320-i)
  except: pass

turtle.goto(20,-76)
turtle.color((255,255,255),(0,0,0))

for i in range(4):
  a=r*sin(alpha)*2
  d=a/sqrt(2)
  turtle.pendown()
  for i in range(12):
    turtle.right(15)
    try: turtle.begin_fill()
    except: pass
    carre(d)
    try: turtle.end_fill()
    except: pass
    turtle.left(45)
    turtle.penup()
    turtle.forward(a)
    turtle.pendown()
  turtle.penup()
  turtle.left(75)
  turtle.forward(d)
  turtle.right(60)
  r=r*cos(alpha)-a/2

try: turtle.show() #TI-83 Premium CE
except: pass

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

Encore une fois, ce_turtl est complètement dans les choux...

Problème heureusement corrigé avec le nouveau turtle.

Par contre, on note avec la méthode .dot() de turtle le bug déjà évoqué plus haut pour .circle(), à savoir la déformation des disques pour de grands rayons.

Avec la méthode .dot(), les turtle de KhiCAS et des TI-Nspire CX II semblent aussi tracer des disques 2 fois trop grands.
Une erreur de codage sans doute, car il ne faut pas confondre. Dans le standard :

• .circle() attend le rayon du cercle à tracer
• .dot() attend le diamètre du disque à remplit

Exemple n°11 : Les triangles de Sierpiński

Go to top

Revenons aux fractales et à la récursivité avec les triangles de Sierpiński. As-tu déjà réussi à les compter ? Et bien voici de quoi commencer sur ta calculatrice :

Code: Tout sélectionner

from ttl_fix import *

def sierp(n, l):
  if n == 0:
    for i in range (0, 3):
      turtle.forward(l)
      turtle.left(120)
  if n > 0:
    sierp(n - 1, l / 2)
    turtle.forward(l / 2)
    sierp(n - 1, l / 2)
    turtle.backward(l / 2)
    turtle.left(60)
    turtle.forward(l / 2)
    turtle.right(60)
    sierp(n - 1, l / 2)
    turtle.left(60)
    turtle.backward(l / 2)
    turtle.right(60)

turtle.colormode(255)
turtle.speed(0)
turtle.pensize(1)

turtle.penup()
turtle.goto(-110, -95)
turtle.pendown()
turtle.pencolor((255,0,0))
sierp(6, 220)
turtle.penup()
turtle.forward(400)

try: turtle.show() #TI-83 Premium CE
except: pass

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

Exemple n°12 : Sous le soleil exactement

Go to top

Plaçons-nous maintenant sous le soleil exactement, profitant ainsi de toutes les couleurs de la lumière blanche :

Code: Tout sélectionner

from math import exp
from ttl_fix import *

def rpoly(c, n):
  a=360/n
  for k in range(n):
    turtle.forward(c)
    turtle.left(a)
def carre(c): rpoly(c, 4)

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(1.0)

n = 36
for i in range(n):
  k=.4 + 4*i/255
  cp = [.7*exp(-.5 * ((n - i - k) / (n / 3))**2) for k in (6, 18, 30)]
  turtle.pencolor(cp)
  try:
    turtle.fillcolor((k,k,0))
    turtle.begin_fill()
  except: pass
  carre(60)
  try: turtle.end_fill()
  except: pass
  turtle.right(360 / n)

try: turtle.show() #TI-83 Premium CE
except: pass

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

Exemple n°13 : Le labyrinthe du Minotaure

Go to top

Explorons maintenant dans la labyrinthe du Minotaure :

Code: Tout sélectionner

from ttl_fix import *

turtle.speed(0)
turtle.colormode(255)
turtle.pendown()

turtle.right(48)
turtle.pencolor((0,0,0))
for i in range(98):
  turtle.forward(2*i)
  turtle.left(90.5)

try: turtle.show() #TI-83 Premium CE
except: pass

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

Exemple n°14 : Le carreau de carreaux

Go to top

Code: Tout sélectionner

from math import sqrt
from ttl_fix import *

def rotate_list(l):
  l[1:],l[0] = l[0:-1],l[-1]

def reg_poly(l, n):
  for i in range(n):
    turtle.forward(l)
    turtle.left(360/n)

def square(l):
  reg_poly(l, 4)

turtle.colormode(255)
turtle.pencolor(0,0,0)
turtle.speed(0)

turtle.pensize(3)
d=190
c=[0,255,127]
turtle.penup()
turtle.goto(-d/2,-d/2)
turtle.setheading(0)
turtle.pendown()
for i in range(8):
  try:
    turtle.fillcolor(tuple(c))
    turtle.begin_fill()
  except: pass
  square(d)
  try:
    turtle.end_fill()
  except: pass
  turtle.penup()
  turtle.forward(d/2)
  turtle.left(45)
  turtle.pendown()
  d/=sqrt(2)
  rotate_list(c)

try: turtle.show() #TI-83 Premium CE
except: pass

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

Grosse erreur de tracé ici encore avec ce_turtle, heureusement corrigée avec le nouveau turtle.

Exemple n°15 : Les étoiles jumelles

Go to top

Code: Tout sélectionner

try: # TI-83 Premium CE
  from ti_system import disp_clr
  disp_clr()
except: pass
from ttl_fix import *

def rpoly(c, n):
  a=360/n
  for k in range(n):
    turtle.forward(c)
    turtle.left(a)

def rosace(c, n1, a, n2):
  try: turtle.begin_fill()
  except: pass
  for i in range(n2):
    turtle.left(a)
    rpoly(c, n1)
  try: turtle.end_fill()
  except: pass

turtle.colormode(255)
turtle.pencolor((0,0,0))

try: turtle.dot(320)
except: pass
turtle.color((255,255,255),(255,255,0))
turtle.speed(0)
turtle.pensize(1)
try:
  for i in range(-1, 2, 2):
    turtle.penup()
    turtle.goto(80*i, 0)
    turtle.pendown()
    rosace((i > 0) and 21 or 30, (i > 0) and 12 or 8, 30, 12)
    turtle.pensize(2)
    turtle.pencolor((0,0,255))
except MemoryError as e: print(e)

try: turtle.show() #TI-83 Premium CE
except: pass

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

À nouveau le heap TI-83 Premium CE et compatibles est insuffisant pour permettre le remplissage, le 1^er des 2 remplissages n'aboutissant même pas cette fois-ci.

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

Go to top

Suivons maintenant le fil de l'araignée :

Code: Tout sélectionner

from ttl_fix import *

def spiral(a,b):
  turtle.pencolor((0,0,0))
  try: turtle.dot(320)
  except: pass
  turtle.pencolor((255,255,0))
  for i in range(189):
    for j in range(6):
      turtle.forward(i/a)
      turtle.left(23)
    turtle.left(b)
    try: turtle.dot(2)
    except: pass
   
turtle.speed(0)
turtle.colormode(255)
turtle.pensize(1)

a=17
b=194

spiral(a,b)

try: turtle.show() #TI-83 Premium CE
except: pass

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

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

Go to top

Terminons enfin avec un exemple absolument bluffant de réalisme pour du turtle, faisons pousser un tournesol :

Code: Tout sélectionner

from math import pi, sin, cos, sqrt
from ttl_fix import *

def spiral():
  phi = (1+sqrt(5))/2
  a  =0
  r = 0
  dr = 0.15
  turtle.penup()
  for i in range(300):
    turtle.forward(r)
    turtle.pencolor((0,0,0))
    try: turtle.dot(3)
    except: pass
    turtle.pencolor((205,133,63))
    try: turtle.dot(2)
    except: pass
    turtle.goto(0,0)
    turtle.setheading(0)
    a+=360/phi
    turtle.right(a)
    if a>=360:
      r+=dr
      a-=360   

def feuille(core,a):
    try: turtle.begin_fill()
    except: pass
    turtle.right(a/2)
    turtle.forward(core)
    turtle.left(a)
    turtle.forward(core)
    turtle.left(180-a)
    turtle.forward(core)
    turtle.left(a)
    turtle.forward(core)
    try: turtle.end_fill()
    except: pass

turtle.speed(0)
turtle.colormode(255)
turtle.pencolor((30,144,255))
try: turtle.dot(320)
except: pass

d=25
core=40
turtle.pencolor((160,82,45))
try: turtle.dot(40)
except: pass

c=((255,215,0),(255,255,0))

for i in range(2):
  turtle.color(c[0], c[i])
  for h in range(10*i,370,20):
    r=h * pi / 180
    x=d*cos(r)
    y=d*sin(r)
    turtle.penup()
    turtle.goto(x,y)
    turtle.pendown()
    turtle.setheading(h)
    feuille(core,32)

spiral()

try: turtle.show() #TI-83 Premium CE
except: pass

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

Conclusion

Go to top

Après l'accident ce_turtl qui était inutilisable en pratique, Texas Instruments nous opère un virage à 180° avec le nouveau module turtle pour TI-83 Premium CE Edition Python et compatibles.
La conformité au standard de turtle n'est certes pas parmi les meilleures, mais c'est sans comparaison avec ce que valait ce_turtl. La conformité est très proche de celle des TI-Nspire CX II, et de plus une bonne partie des défauts restants ne sont pas majeurs dans le sens où ils sont aisément contournables sans avoir à écrire de code bien conséquent comme nous avons vu.

Qui plus est Texas Instruments s'offre même le luxe d'aller jusqu'à inclure les méthodes de remplissage de formes, à ce jour une exclusivité toute concurrence confondue. Des possibilités et facilités de tracés largement accrues en conséquence et très au-dessus de la concurrence, de quoi inviter encore plus les élèves à tester et créer !

Décidément #LesMathématiquesSontBelles certes, mais à ce jour particulièrement sur calculatrices Texas Instruments.

Téléchargements

Go to top

• turtle Français English
• pack de mises à jour 5.7 pour TI-83 Premium CE TI-84 Plus CE, ou séparément :
  
  • Système 5.7 pour TI-83 Premium CE TI-84 Plus CE
  • Application Python 5.7 (nécessite le système 5.7 pour fonctionner)
  • tracé par pixels ou dans un repère ti_draw ti_image

[critor]

Apparu le 3 avril 1860, le Pony Express était un service d'acheminement rapide du courrier en Amérique du Nord, de la Californie au Missouri et vice-versa. Le courrier jusqu'alors acheminé par diligence avec la côte ouest pouvait prendre jusqu'à 6 mois, alors que l'acheminement par les cavaliers solitaires du Pony Express à travers les plaines asséchées de l'ouest à une vitesse moyenne de 16 km/h, réduisait le délai à seulement 10 à 11 jours. Rapidement supplanté par le télégraphe, il cessa toute activité le 24 octobre 1861. Malgré sa courte histoire de 18 mois le Pony Express, emblématique de la conquête de l'Ouest, fait partie intégrante de la culture populaire américaine.

Le 3 avril 2015, c'était le 155^ème anniversaire du Pony Express et Google avait sorti un doodle tout spécialement dédié pour ses pages de recherche. Un clic sur le doodle activait un jeu te permettant de revivre l'aventure du Pony Express. À cheval sur ton propre destrier, tu te devrais de collecter 100 lettres à destination du Missouri, réparties à travers 3 niveaux couvrant tout l'ouest américain. Tu te devais d'éviter les nombreux obstacles et dangers (rochers, cactus, clôtures, arbres, rivières, lacs, falaises, chutes de neige, voleurs, ... tout un programme). Pour cela les flèches haut et bas te permettaient à tout moment de choisir entre 6 chemins différents pour ta monture.

Et bien justement aujourd'hui Candledark se propose de faire revivre ce doodle dans ta calculatrice TI-83 Premium CE ou TI-84 Plus CE.

Son jeu Pony Express CE se veut être une adaptation du doodle de Google et est toujours en phase de développement mais est déjà parfaitement jouable et très fluide (entre 30 et 40fps sur calculatrice), avec qui plus est des menus bilingues en Anglais et Français.

Le jeu est codé en langage C puis compilé en langage machine pour ta calculatrice.

Attention, Pony Express CE rentre dans la catégorie des programmes en langage machine dits ASM.

Or, suite à un acte irresponsable d'un enseignant de Mathématiques français avec ses gesticulations aveugles dans le contexte de la réforme du lycée, Texas Instruments a réagi en supprimant la gestion de tels programmes depuis la mise à jour 5.5.1.

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

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

Téléchargements :

• Pony Express CE
• bibliothèques C
• arTIfiCE
• Cesium
• AsmHook

Liens :

• Code source Pony Express CE
• archive jouable du doodle Pony Express original