Pour les calculatrices scientifiques, nos magasins sont inondés de clones de calculatrices Casio.
Avec l'accord du constructeur ou pas, les fabricants reprennent ce qui leur plaît dans les éléments matériels, logiciels et de design de Casio.
On peut citer aussi bien des marques poubelles comme Lexibook, Auchan, des constructeurs qui perdent de leur superbe en s'abaissant à cela comme HP, des contrefaçons de Citizen en Gtttzen, ...
Lorsque conçus sans son accord, parfois Casio arrive même à faire condamner le constructeur concerné, comme avec la EATES fc-991CN+.
Ces clones pouvaient parfois se révéler intéressants, car utilisant souvent des matériel et même processeur différents de ceux de Casio.
Toutefois jusqu'à présent si l'on s'en tient aux modèles récents, ce phénomène de clonage ne concernait que les calculatrices scientifiques.
Dans le cadre des calculatrices graphiques on ne trouvait jusqu'à présent essentiellement que des clones plus ou moins bien réussis de très vieilles calculatrices Casio du siècle dernier. Aux capacités nullissimes dans le contexte actuel, elles concernaient davantage l'Asie et l'Afrique. La non conformité aux modes examen français ou européens terminait de plus d'expliquer leur quasi inexistence chez nous.
Mais les choses sont peut-être sur le point de changer sur la scène des Etats-Unis. Pour le contexte rappelons que la TI-84 Plus CE(version internationale de notre TI-83 Premium CE française) y est la référence, et que NumWorks est actuellement en train de tenter de pénétrer le marché nord-américain pour la rentrée 2022, avec son nouveau modèle N0120.
Or un tout nouveau clone de calculatrice graphique est actuellement en préparation pour la rentrée 2022, la Zero, et pourrait bien venir contrecarrer ses plans.
En effet comme tu devrais le remarquer malgré l'évolution du design dans le temps, la Zero ne s'inspire pas d'une antiquité mais de la TI-84 Plus CE au succès planétaire ! Tu y retrouves ainsi entre autres exactement le même clavier et n'auras donc rien à apprendre de spécifique pour utiliser la Zero.
La toute dernière version du design a certes un peu évolué depuis, et la ressemblance est moins flagrante en dehors du clavier.
Chose remarquable ici, nous avons une protection antichoc sous la forme d'une bande de caoutchouc d'un bleu très esthétique faisant le tour du boîtier ; un excellent choix dans le contexte du cadre scolaire que l'on sait être très hostile pour les appareils électroniques.
Sur le matériel par contre, la Zero s'affranchit totalement de son modèle, et pour le meilleur comme nous allons voir. Outre l'écran couleur 2,8", on nous annonce plusieurs bonnes nouvelles :
non plus un processeur 8 bits eZ80 à 48 MHz, mais un 32 bits à 100 MHz !
une connectivité USB enfin contemporaine et facile avec un port USB-C, première calculatrice graphique au monde à nous proposer cette évolution tant attendue !
20% de stockage supplémentaire, ce qui par rapport aux 4 Mio de Flash des TI-84 Plus CE nous amène donc à supposer 5 Mio(sans doute répartis sur 2 puces de capacités respectives 4 Mio et 1 Mio, règle binaire des puissances de 2 oblige)
Imagine ce que pourraient donner tes programmes TI-Basic et assembleur favoris à 100 MHz...
Nous mourrons d'envie de pouvoir te la tester, mais pour te faire patienter en attendant voici un petit unboxing de la part d'un des testeurs et par Zero eux-même en vidéo :
Notons le clin d'œil sur la boîte, "this box contains Zero calculators".
Cassant complètement les codes et habitudes des cloneurs de calculatrices, la Zero pourrait bien venir jouer les trouble-fêtes à la rentrée 2022 et damer le pion à NumWorks sur le marché américain. Surtout que de plus se baser sur la TI-84 Plus CE, le modèle local largement plébiscité par les petits américains, est sans doute un énorme avantage.
Aujourd'hui nous allons parler TI-80, la calculatrice graphique Texas Instruments la plus mystérieuse jamais produite.
Mais plantons dabord le décor. En 1990 Texas Instruments rentrait dans la formidable aventure des calculatrices graphiques avec son tout premier modèle, la TI-81, équipé d'un processeur 8 bits z80 cadencé à 5 MHz.
Dans un premier temps jusqu'en 1992, différentes versions du logiciel gravé en ROM ont défilé et sont consultables via la combinaison de touches
2nd
MATH
ALPHA
LN
: 1.0, 1.1, 1.1K, 1.5K, 1.6K et 1.8K.
Avec la sortie des TI-85 et TI-82 en 1992 puis 1993, la TI-81 devint l'entrée de la gamme graphique Texas Instruments.
Justement les TI-81 assemblées à compter de 1993 ont subi une révision matérielle majeure. Pour mutualiser les éléments de production et ainsi économiser, Texas Instruments leur a fait utiliser les mêmes cartes électroniques que les TI-82 qui venaient de sortir . Quelques petites différences toutefois :
les composants relatifs au circuit de communication étaient absents sur les cartes destinées à équiper des TI-81, puisque ce modèle était dépourvu de tout port de communication
la puce ROM soudée sur les cartes destinées aux TI-81 conservait la capacité de 64K suffisante pour le logiciel, au lieu des 128K des TI-82
le processeur par contre passait à 6 MHz comme sur les TI-82, et permettait donc à ces dernières TI-81 d'être un peu plus rapides
Pour gérer correctement ce matériel sensiblement différent, le logiciel TI-81 a lui-même dû subir des adaptations majeures, distribuées sous les numéros de version V2.00 et V2.0V.
Et voilà nous y sommes déjà. En 1995 Texas Instruments arrête la production des TI-81 et les remplace par un tout nouveau modèle d'entrée de gamme, la TI-80.
Fort logiquement les versions du logiciel ici consultables via la combinaison via la combinaison de touches
MODE
ALPHA
LN
poursuivent la numérotation : 3.0 et 4.0. Comme pour la TI-81 pas de port de communication, à l'exception des très rares modèles enseigants dits TI-80 ViewScreen munis d'un port mini-Jack 2.5mm dédié aux captures d'écran.
La TI-80 avait la particularité d'être nettement plus légère et petite que la TI-81. Sans couvercle, on passait :
d'un poids de 206g à seulement 110g, à peine plus de la moitié !
d'une épaisseur de 2,22cm à seulement 1,60cm
d'une hauteur de 17,36cm à seulement 16,18cm
d'une largeur de 8,09cm à seulement 7,25cm
Mais tout ceci impliquait également des sacrifices :
au lieu de 4 piles AAA, la TI-80 s'alimentait avec 2 piles boutons CR2032 nettement plus chères
d'une définition de 96×64 pixels sur les TI-81, l'écran ne faisait plus que 64×48 pixels sur les TI-80
en taille également, l'écran se réduisait de 2,48" à seulement 1,85"
Un modèle extrêmement mystérieux qui continue à nous résister à ce jour depuis plus de 25 ans. Nombre d'étapes clé ont pris beaucoup plus de temps que sur les autres modèles TI de l'époque :
2010 : dumping partiel de 32K du logiciel en version 3.0 et 4.0, à partir de la puce ROM externe
2010 : dumping du logiciel en version 4.0 complété avec les 16K manquant sur une ROM interne à la puce du processeur
2012 : support des TI-80 ViewScreen par le logiciel de connectivité TiLP
2021 : récupération enfin du logiciel de connectivité dédié officiel TI-Graph Link 80
Et toujours aucune possibilité d'exécuter des programmes assembleur à ce jour.
En fait comme vu plus haut, il semble qu'un des objectifs de Texas Instruments lors de la conception de la TI-80 ait été de minimiser le plus possible les coûts de production. Et dans ce cadre il y a juste quelque chose que nous ne t'avons pas encore dit, le processeur enfermé dans la puce Toshiba T6M53A n'est pas même pas un z80.
Impensable de nos jours, sans doute qu'à l'époque le code encore relativement modeste du logiciel graphique Texas Instruments permettait encore un portage pas trop coûteux pour un tout autre processeur.
Cette puce Toshiba n'a hélas pas de datasheet public. Une ancienne page du site Texas Instruments donnait toutefois des informations sur les processeurs des calculatrices. À la place de z80 pour les autres modèles elle indiquait ici qu'il s'agissait d'un processeur propriétaire, et précisait qu'il était cadencé à 980 KHz, soit beaucoup moins que la TI-81 précédente.
Une hypothèse à partir des images récupérées de la ROM en version 4.0, basée sur l'alignement des instructions, était qu'il s'agissait d'un processeur 16 bits. Mais ce n'était absolument pas une preuve, et pouvait être une conséquence de bien d'autres contraintes lors de la conception.
Le processeur de la TI-80 nous restent donc encore fort mystérieux...
Une méthode populaire permettant d'identifier les calculatrices utilisant des processeurs similaires, est le test dit de la signature trigonométrique. Il suffit de calculer en mode décimal et degrés
Le résultat mathématique est de 9, mais le moteur de calcul flottant de nos calculatrices répond normalement une valeur approchante.
Plus précisément, le résultat dépend du cœur de calcul utilisé, qu'il soit logiciel ou matériel. Nos calculatrices récentes permettent parfois d'accueillir plusieurs logiciels de calcul, mais généralement plus une calculatrice est simple, plus les algorithmes de calcul reposeront sur les capacités précâblées dans le processeur, ce qui est notamment le cas des calculatrices scientifiques entre autres.
Et justement, la TI-80 répond 8.999999007884, alors que les TI-81 trouvent 8.999999616566.
Or le logiciel TI-80 en version 3.0 étant une évolution directe du logiciel TI-81 en version 2.0, il semble donc ici que la différence soit due au matériel.
Et justement, la TI-80 n'est pas la seule calculatrice à répondre 8.999999007884 au test.
Or selon le musée Datamath, le processeur de la TI Galaxy 67 nous est connu. Sa puce Toshiba TMP0620F utilise un cœur Toshiba TMC17C, une architecture 4 bits.
Réutiliser un cœur 4 bits de calculatrice scientifique dans le contexte des économies drastiques qui semblent avoir été au cahier des charges de la TI-80, avec comme conséquence entre autres un écran matriciel de définition bien plus modeste, cela nous paraît en effet très plausible a posteriori.
En conclusion voici donc enfin la réponse à l'énigme après près de 27 ans de mystères ; le processeur de la TI-80 serait un 4 bits TMC17C de chez Toshiba, cadencé à 980 KHz.
Elimination est un jeu de type RPG, une création originale par Hot_Dog initialement sortie en novembre 2021 pour calculatriaces TI-82 Plus, TI-83 Plus et TI-84 Plus monochromes, prenant la forme d'une application.
Le gameplay est comparable à ce que tu as peut-être connu avec Final Fantasy, Pokemon, Earthbound ou encore Super Mario RPG. Tu enchaînes des phases d'exploration et de combat au tour par tour.
En 2050, les terriens sont en guerre avec une étrange race extraterreste insectiforme venue de la galaxie Whirlpool(tourbillon). Mais toute ressemblance avec d'autres histoires de science fiction s'arrête là, car les terriens avaient l'avantage.
Notre aventure démarre avec quatre enfants : Ryan, Jamie, Collin et Megan, qui par curiosité s'amusent à monter à bord d'une soucoupe volante écrasée. Malheureusement pendant qu'ils sont encore à bord, la soucoupe est récupérée et ramenée dans la galaxie Whirlpool. Bien évidemment, aucun d'eux ne sachant piloter une soucoupe volante alien, ce moyen de retour est a priori inenvisageable. Sauf qu'une autre race extraterrestre, les Tosonians et leur leaderJaslin, sont prêts à aider nos quatre explorateurs à retrouver le chemin de la voie lactée.
C'est le début d'une formidable aventure sur calculatrices. Pour aider à la construction du vaisseau spatial Tosonian, ton équipe va devoir explorer des planètes, progresser en expérience et niveau, et accumuler des ressources (or, cuivre, lithium, ...).
Aujourd'hui Hot_Dog nous fait l'immense plaisir d'une version couleur d'Elimination pour TI-83 Premium CE et TI-84 Plus CE !
11 niveaux t'attendent sur 8 planètes peuplées de plus de 70 ennemis dont des boss ; mais qu'attends-tu ?
Attention, Elimination rentre dans la catégorie des programmes en langage machine dits ASM.
Or, suite à un acte hautement maladroit d'un enseignant de Mathématiques français avec ses gesticulations certes compréhensibles mais 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 :
installer arTIfiCE pour remettre la possibilité de lancer des programmes ASM
ensuite de préférence installer Cesium pour pouvoir lancer les programmes ASM plus facilement, ou même AsmHook pour pouvoir les lancer comme avant
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)
Ta calculatrice TI-83 Premium CE ou TI-84 Plus CE dispose d'une application de tableau périodique des éléments appelée Periodic.
Periodic est normalement préinstallé en usine, et est ensuite mis à jour ou réinstallé avec les fichiers de packs de mises à jour diffusés par Texas Instruments chaque année. L'application est alors accessible via la combinaison
2nde
résol
sur TI-83 Premium CE ou via la touche
apps
sur TI-84 Plus CE. Sur TI-83 Premium CE, cette application a même le gros avantage de rester disponible en mode examen, contrairement aux modèles concurrents de chez Casio.
La dernière version de Periodic est la 5.5.0.0038 compilée le 12 mai 2020, et accompagne donc les packs de mises à jour depuis la mise à jour système 5.5 de rentrée 2020.
C'est une très belle application, disposant d'une superbe interface justement en forme de tableau périodique et tirant profit de l'écran couleur pour distinguer différentes familles d'éléments.
Mais c'est loin d'être tout. Pour accéder à un élément ciblé, tu as le choix entre parcourir le tableau périodique évoqué ou bien une liste d'éléments. Pour te faciliter les choses cette liste peut justement être triée aussi bien par numéro atomique que nom ou symbole.
Rajoutons la possibilité d'exporter les valeurs numériques de propriétés d'élément pour les réutiliser hors de l'application, ainsi que celle de construire des diagrammes qui pourront entre autres mettre en évidence le caractère périodique des propriétés chimiques !
Nous en sommes donc à bientôt 2 ans sans mise à jour de l'application Periodic.
Et Texas Instruments ferait peut-être mieux de se méfier car le concurrent français NumWorks a annoncé fin 2021 être en train de travailler sur une application de tableau péridodique pour une future mise à jour, un des plus gros manques de sa calculatrice, et a l'habitude pour chaque nouveauté d'innover grandement sur l'interface...
Frédéric Desautels alias mr womp womp vient donc de sauter sur l'occasion et de te programmer en langage C sa propre vision d'un tableau périodique amélioré pour TI-83 Premium CE et compatibles.
Son programme est bien évidemment loin d'égaler l'application officielle. On peut déplorer :
l'impossibilité d'accéder aux éléments par liste
l'impossibilité d'exporter ou représenter graphiquement les propriétés numériques
la précision décimale inférieure à l'affichage des propriétés numériques
la non prise en compte de la langue de la calculatrice, l'affichage étant ici toujours en Anglais
un tout petit peu moins de propriétés que Texas Instruments, 13 au lieu de 15
Mais ce qui nous intéresse aujourd'hui ce ne sont pas les manques, mais les différences. Frédéric nous offre en effet quelques évolutions sur l'interface qu'il a tout particulièrement soignée, avec :
les symboles des éléments directement affichés sur le tableau périodique et facilitant donc d'une part au plus grand nombre la recherche sur cette interface, et permettant de plus de lister rapidement les éléments appartenant à une même famille ou période
un thème sombre moins agressif pour les yeux
un affichage des propriétés en petite police permettant de tout faire rentrer sur un même écran, au lieu d'avoir à faire défiler sur 3 écrans comme avec Texas Instruments
sur l'affichage des propriétés, possibilité de passer directement à l'élément suivante/précédent avec les touches fléchées sans avoir à repasser par la vue en tableau
Mais bien sûr à la différence de l'application officielle, ce programme ne restera malheureusement pas disponible en mode examen, les réglementation et spécifications associées semblant avoir été conçues de façon trop complaisante avec les constructeurs ; ce genre de programme parfaitement légitime en France n'aurait jamais dû être bloqué par le mode examen en France. Donc pour t'en servir en évaluation, pas d'autre choix qu'attendre que Texas Instruments accepte de faire quelque chose de similaire, ou à défaut un de ses concurrents.
Attention, ce programme rentre dans la catégorie des programmes en langage machine dits ASM.
Or, suite à un acte hautement maladroit d'un enseignant de Mathématiques français avec ses gesticulations certes compréhensibles mais maladroites et à courte vue 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 :
installer arTIfiCE pour remettre la possibilité de lancer des programmes ASM
ensuite de préférence installer Cesium pour pouvoir lancer les programmes ASM plus facilement, ou même AsmHook pour pouvoir les lancer comme avant
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)
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 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:bitv1 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 :
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. 11 bibliothèques étaient disponibles dans la dernière version, 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_audio → microbit.audio(effets sonores - accessible via le menu Audio)
mb_butns → microbit.buttons(boutons A, B et tactile intégrés - accessible via le menu Buttons ou Boutons)
mb_disp → microbit.display(afficheur à 5×5=25 LEDs rouges intégré - accessible via le menu Display ou Affichage)
mb_grove(capteurs et actionneurs Grove à rajouter - accessible via le menu Grove Devices)
mb_log(enregistrement de données - accessible via le menu Data logging ou Enregistrement de données)
mb_micmicrobit.microphone(micro intégré - accessible via le menu Microphone)
mb_music → microbit.music(haut-parleur à rajouter sur micro:bit v1 ou intégré sur micro:bit v2 - accessible via le menu Music ou Musique)
mb_neopx → microbit.neopixel(rubans de LEDs programmables à rajouter - accessible via le menu NeoPixel)
mb_notes(notes de musique - accessible via le menu Music ou Musique)
mb_pins(contacts programmables intégrés - accessible via le menu Input/output pins ou Broches entrée/sortie)
mb_radio → microbit.radio(communication radio intégrée - accessible via le menu Radio)
mb_sensr(capteurs intégrés : boussole, accéléromètre, température - accessible via le menu Sensors and gestures ou Capteurs et gestes)
Texas Instruments et l'espace, c'est une grande histoire qui ne date pas d'hier. Outre les calculatrices qui ont accompagné les missions spatiales, on peut citer une collaboration de longue date avec la Nasa, l'agence spatiale américaine, et nombre de projets et événements ont été conçus dans ce cadre.
Dès le début du siècle Texas Instruments nous faisait rêver de faire débarquer des rovers sur Mars et les piloter à l'aide de nos calculatrices.
Si nous avons enfin le TI-Innovator Rover pilotable par calculatrice aujourd'hui, fallait-il déjà commencer par décoller avant d'espérer pouvoir un jour atteindre Mars.
Or lors de la dernière mise à jour en fouillant le TI-Runtime 2.4.0, nous avions découvert des traces de fonctions destinées à la configuration d'un drone Tello.
Ces fonctions n'étaient toutefois pas exposées et n'étaient donc a priori pas utilisables depuis la calculatrice.
Et bien voici aujourd'hui le grand jour.
Texas Instruments te fait l'honneur de t'inviter à un bêta-test public de la prochaine mise à jour de sa solution micro:bit pour TI-83 Premium CE Edition Python et compatibles, avec support du drone Tello !
D'une part, nous avons une mise à jour en version 2.5.1 du TI-Runtime pour les micro:bit v2. Toutefois en pratique, en interrogeant la carte micro:bit avec microbit.runtime_version() après mise à jour cette dernière continue à rétourner l'ancienne version 2.4.0.
D'autre nous avons une nouvelle bibliothèques Pythontello, en version 2.5.
Nous allons de suite creuser le nouveau TI-Runtime pour vérifier qu'il n'y a pas eu d'erreur, et ensuite te présenter la bibliothèque TELLO.
Ici pas de menu fouillable depuis la calculatrice pour connaître les fonctions utilisables, mais on peut procéder autrement. On peut en effet ouvrir directement le fichier sur https://python.microbit.org/v/2 pour pouvoir lire son code source :
# ------------------------------------------- pulse timer ---------------------------------------------------------------- def time_pulses(pin,pulses): try: pin.read_digital() # wait for one trigger pulse while not pin.read_digital(): pass while pin.read_digital(): pass while not pin.read_digital(): pass # begin timing pulses t0=ticks_us() for n in range(pulses-1): while (not pin.read_digital()): pass while pin.read_digital(): pass tf=ticks_us() pulses_time = (tf-t0)/1000000 return(str(pulses_time)) except: pass
def time_H_to_L(pin): pin.read_digital() while (pin.read_digital()): pass t0=ticks_us() while not (pin.read_digital()): pass tf=ticks_us() pulse_time = (tf-t0)/1000000 return(str(pulse_time))
def time_L_to_H(pin): pin.read_digital() while not (pin0.read_digital()): pass t0=ticks_us() while (pin.read_digital()): pass tf=ticks_us() pulse_time = (tf-t0)/1000000 return(str(pulse_time))
def set_iaq_baseline(self,eCO2,TVOC): if eCO2==0 and TVOC==0:raise RuntimeError('Invalid baseline') b=[] for i in [TVOC,eCO2]: a=[i>>8,i&0xFF] a.append(self.g_crc(a)) b+=a self.run(['iaq_set_baseline',[0x20,0x1e]+b,0,10])
def set_iaq_humidity(self,PM3): b=[] for i in [int(PM3*256)]: a=[i>>8,i&0xFF] a.append(self.g_crc(a)) b+=a self.run(['iaq_set_humidity',[0x20,0x61]+b,0,10])
def get(self,cmd,d,rs): i2c.write(0x58,bytearray(cmd)) sleep(d) if not rs:return None cr=i2c.read(0x58,rs*3) o=[] for i in range(rs): w=[cr[3*i],cr[3*i+1]] c=cr[3*i+2] if self.g_crc(w)!=c:raise RuntimeError('CRC Error') o.append(w[0]<<8|w[1]) return o
def g_crc(self,data): c=0xFF for byte in data: c^=byte for _ in range(8): if c&0x80:c=(c<<1)^0x31 else:c<<=1 return c&0xFF
def read(self): if self.ready: try: return self.eCO2(), self.TVOC() except: pass else: self.init() if self.ready: return (self.read()) else: return None
# ------------------------------------------- start up -----------------------------------------------------------
def ismb(): return(True)
def get_version(): print ("TI-Runtime Version 2.4.0")
# ------------------------------------------- pulse timer ---------------------------------------------------------------- def time_pulses(pin,pulses): try: pin.read_digital() # wait for one trigger pulse while not pin.read_digital(): pass while pin.read_digital(): pass while not pin.read_digital(): pass # begin timing pulses t0=ticks_us() for n in range(pulses-1): while (not pin.read_digital()): pass while pin.read_digital(): pass tf=ticks_us() pulses_time = (tf-t0)/1000000 return(str(pulses_time)) except: pass
def time_H_to_L(pin): pin.read_digital() while (pin.read_digital()): pass t0=ticks_us() while not (pin.read_digital()): pass tf=ticks_us() pulse_time = (tf-t0)/1000000 return(str(pulse_time))
def time_L_to_H(pin): pin.read_digital() while not (pin0.read_digital()): pass t0=ticks_us() while (pin.read_digital()): pass tf=ticks_us() pulse_time = (tf-t0)/1000000 return(str(pulse_time))
def set_iaq_baseline(self,eCO2,TVOC): if eCO2==0 and TVOC==0:raise RuntimeError('Invalid baseline') b=[] for i in [TVOC,eCO2]: a=[i>>8,i&0xFF] a.append(self.g_crc(a)) b+=a self.run(['iaq_set_baseline',[0x20,0x1e]+b,0,10])
def set_iaq_humidity(self,PM3): b=[] for i in [int(PM3*256)]: a=[i>>8,i&0xFF] a.append(self.g_crc(a)) b+=a self.run(['iaq_set_humidity',[0x20,0x61]+b,0,10])
def get(self,cmd,d,rs): i2c.write(0x58,bytearray(cmd)) sleep(d) if not rs:return None cr=i2c.read(0x58,rs*3) o=[] for i in range(rs): w=[cr[3*i],cr[3*i+1]] c=cr[3*i+2] if self.g_crc(w)!=c:raise RuntimeError('CRC Error') o.append(w[0]<<8|w[1]) return o
def g_crc(self,data): c=0xFF for byte in data: c^=byte for _ in range(8): if c&0x80:c=(c<<1)^0x31 else:c<<=1 return c&0xFF
def read(self): if self.ready: try: return self.eCO2(), self.TVOC() except: pass else: self.init() if self.ready: return (self.read()) else: return None
# ------------------------------------------- start up -----------------------------------------------------------
def ismb(): return(True)
def get_version(): print ("TI-Runtime Version 2.4.0")
La bibliothèque TELLO une fois chargée sur ta calculatrice, est importable dans des scripts Python en passant par le menu des modules complémentaires. Cela t'active alors un nouveau menu tello drone.
Nous y retrouvons alors plusieurs onglets :
Fly pour tout ce qui concerne les contrôles dans le cadre d'un vol
Data pour interroger les capteurs intégrés au drone Tello
Maneuver pour quelques figures acrobatiques
EDU pour les plans de vol
Settings pour les réglages
Cela a l'air super simple non, enfantin même ? Voici donc déjà un premier script :
Tu as tout le matériel entre les mains ? C'est parti pour les manipulations :
Commençons par enregistrer ton drone Tello si c'est sa première utilisation, étape qui ne peut se faire avec la calculatrice :
Télécharge l'application de vol Tello sur ton téléphone.
Allume ton drone Tello.
Sur ton téléphone, recherche les points d'accès WiFi.
Connecte-toi au point d'accès Tello qui devrait apparaître.
Ouvre l'application et accepte l'enregistrement.
Ferme l'application et déconnecte ton téléphone du point d'accès Tello. (attention à ce que ton téléphone n'y reste pas connecté ou ne s'y reconnecte pas tout seul, ce qui risque de perturber la communication avec la calculatrice)
Voici maintenant pour les connexions :
Insère le nanoordinateur micro:bit v2 dans la carte d'extension, en faisant attention au sens.
Connecte la batterie USB à la carte d'extension.
Connecte le module Grove WiFi au port P1 de la carte d'extension.
Assure-toi que la batterie USB est chargée et allumée si disposant d'un bouton.
Allume la carte d'extension si disposant d'un bouton. (les DELs sur les micro:bit, carte d'extension et module WiFi doivent s'allumer)
Connecte enfin la micro:bit à la calculatrice, puis allume cette dernière si nécessaire.
Assure-toi que le drone Tello est chargé et allumé. Il va clignoter sous différentes couleurs puis se fixer sur du jaune clignotant lorsque prêt.
Et voilà, paré à décoller, tu peux enfin écrire et lancer ton premier script.
Dernière chose avant de te laisser voler de tes propres ailes, quand tu lances un script important le module tello, la calculatrice n'est pas capable de détecter la carte d'extension utilisée (Grove ou bitmaker) et va donc te demander de préciser.
Si tu préfères bricoler tes propres branchements, tu disposes également si tu préfères d'un écran de configuration avancé.
Si nécessaire, voici pour résumer tout cela un tuto-vidéo officiel en Anglais:
Décidément Texas Instruments, déjà leader incontesté des projets scientifiques sur calculatrices graphiques, se permet d'innover de façon encore plus formidable. En conséquence pour toi une toute nouvelle dimension à explorer pour des projets encore plus fantastiques !
by 
Pour les calculatrices scientifiques, nos magasins sont inondés de clones de calculatrices Casio.
Mais les choses sont peut-être sur le point de changer sur la scène des Etats-Unis. Pour le contexte rappelons que la TI-84 Plus CE (version internationale de notre TI-83 Premium CE française) y est la référence, et que NumWorks est actuellement en train de tenter de pénétrer le marché nord-américain pour la rentrée 2022, avec son nouveau modèle N0120.
La toute dernière version du design a certes un peu évolué depuis, et la ressemblance est moins flagrante en dehors du clavier.
by 
