Nombre de jeux sortant pour smartphones, tablettes, ordinateurs et consoles de jeux, se retrouvent plusieurs années plus tard disponibles sur calculatrices graphiques.
Ta TI-83 Premium CE(ou TI-84 Plus CE hors de France) permet de jouer directement à l'ensemble des jeux compatibles avec la console Nintendo Game Boy monochrome (1989), grâce à l'émulateur dédié TI-Boy CE par calc84maniac.
Pour les consoles de jeux et plus généralement plateformes ne disposant pas encore d'un émulateur dédié sur TI-83 Premium CE ou compatible, les jeux doivent être adaptés au cas par cas. Parmi ces adaptations souvent très réussies de jeux sortis pour d'autres plateformes, on peut citer entre autres :
Spaze Invaders(d'après Space Invaders sur bornes d'arcade - 1978)
PacMan CE(d'après le jeu sur bornes d'arcade - 1980)
Donkey Kong CE(d'après le jeu sur bornes d'arcade - 1981)
Mais il existe encore bien d'autres consoles de jeux, comme par exemple la Nintendo Wii sortie en 2006. Dès 2006 au Japon et en Europe puis 2007 en Amérique du Nord, sort Wii Play, un jeu constitué de plusieurs mini-jeux.
Mais désormais, grâce à commandblockguy, tu te vois offrir une adaptation d'un de ces mini-jeux pour TI-83 Premium CE et compatibles (84+CE...), Tanks! CE.
Le but du jeu est de détruire le ou les chars adverses présents sur le terrain et contrôlés par une IA. Tu pilotes pour ta part ton char à l'aide des touches suivantes :
touches fléchées pour te déplacer
touche
mode
pour tourner la tourelle
touche
2nde
pour faire feu
touche
alpha
pour déposer une mine
touche
suppr
ou
del
pour passer directement au niveau suivant
touche
+
pour faire pause et obtenir le menu
touche
annul
ou
clear
pour quitter
Que ce soit pour toi ou tes ennemis, un seul tir au but suffit à détruire un tank. 20 niveaux sont disponibles.
Tu démarres le jeu en disposant de 3 tanks, histoire donc de remplacer 2 fois un tank détruit. Tu obtiendras par la suite un tank bonus après avoir gagné aux niveaux 5 puis 10 et 15.
Attention, Tanks 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 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)
Pour la rentrée 2007 sortaient les toutes premières TI-Nspire. Elles furent remplacées pour la rentrée 2010 par les TI-Nspire Touchpad, l'un des changements majeurs comme leur nom l'indiquait était l'ajout d'un pavé tactile.
Le logiciel de mathématiques intégré TI-Nspire est un véritable chef-d'œuvre d'horlogerie, faisant exister et interagir entre elles nombre d'applications interconnectées (tableur, géométrie dynamique, acquisition de données, ...). Un changement local à une application peut ainsi avoir des conséquences hors de l'application en question, et il est difficile de toujours tout anticiper.
C'est pour cela que Texas Instruments fait régulièrement appel à des développeurs et testeurs QA(Quality Assurance) externes, notamment de chez Hildebrando, une société au Mexique.
Aujourd'hui, Frédéric Desautels alias mr womp womp nous a déniché un prototype TI-Nspire CAS Touchpad apparemment passé entre les mains d'Hildebrando.
Les prototypes chez Texas Instruments suivent des phases successives :
PROTO : prototype (concept initial)
EVT : engineering validation tests (concernent plutôt le développement matériel)
DVT : developement validation tests (concernent plutôt le développement logiciel)
PVT : production validation tests (derniers tests avant le lancement de la production de masse)
MP : production de masse
Effectivement ici il s'agit bien d'un prototype, puisque nous notons au dos plusieurs mentions de la phase DVT :
dans le cadre à la place du numéro de série, une mention CAS RCB DVT1 NOT FOR SALE 188 P-1209
une étiquette à code barre résumant la chose de façon plus lisible en DVT1-188 P-1209
Il s'agit donc d'un prototype DVT1 de numéro de série 188 assemblé en décembre 2009 dans l'usine de code P(usine d'Inventec à Pudong en Chine).
Mais d'autre part, nous avons une autre étiquette DVT1-188 P-1209 mentionnant cette fois-ci HILDEBRANDO.
Sur du DVT nous ne nous attendons à rien de bien surprenant, mais Frédéric a quand même démonté le prototype pour nous. Nous avons :
une carte mère PCB-TG2995D-MB-4420, au lieu de PCB-TG2995D-MB-4420 pour les modèles de production
une carte écran TG2995-C-LB-2410 identique à celle des modèles de production
Non, ce qui devrait être intéressant sur ce prototype, c'est le logiciel.
Démarrer la calculatrice avec les touches
esc
menu
-
enfoncées nous permet d'accéder au logiciel de diagnostics. Nous notons une version 2.00.837 compilée le 1er décembre 2009 inconnue jusqu'à ce jour, alors que les modèles de production sont dotés de la version 2.00.1183 compilée le 19 février 2010, un gros écart.
Une fois la calculatrice redémarrée normalement rien de spécial avec les Boot1 et Boot2, mêmes versions respectives 1.1.8916 et 3.0.1.131 que sur les modèles de production.
Par contre le système d'exploitation est pour sa part intéressant. Il s'agit d'une version 3.9.0.450 jusqu'ici inconnue, compilée le 11 avril 2014. Une préversion donc de l'avant-dernier système d'exploitation sorti pour les TI-Nspire TouchPad, le 3.9.0.461 compilé le 16 mai 2014.
Bien qu'il s'agisse d'un prototype, l'OS a visiblement été signé avec les clés de production et peut donc être installé sur n'importe quelle calculatrice TI-Nspire CAS TouchPad commercialisée.
Frédéric l'a justement dumpé pour nous et tu peux dès maintenant l'installer sur ta calculatrice ou ton émulateur adéquat.
Outre l'intérêt historique de cette sauvegarde, les quelques différences entre les vieux OS 3.9.0.450 et 3.9.0.461 peuvent paraître sans enjeu maintenant 8 ans après.
Mais avoir accès à des prototypes testés chez Hildebrando pourrait se révéler particulièrement intéressant. Si les fichiers de tests sont toujours présent dans le système de fichiers, cela pourrait nous révéler la nature des tests ainsi que les bugs recherchés, et être fort utile à l'équipe Ndless si elle veut bien reprendre du service plutôt que de laisser mourir le projet comme elle le fait depuis maintenant 1 an (avec 4 mises à jour TI-Nspire depuis dont aucune suivie d'une mise à jour de Ndless).
Malheureusement ici le système de fichiers était quasiment vide, peut-être plus de chances la prochaine fois...
Depuis la rentrée 2020, NumWorks te sort chaque fois une coque collector en édition limitée pour ta calculatrice. Si tu es chanceux(se) et a su te montrer assidu(e), alors tu devrais avoir pu te constituer une formidable collection :
Voici pour ce mois de Mars 2022 la toute dernière édition limitée de la coque NumWorks à ajouter à ta collection, dédiée cette fois-ci à l'exploration de la planète Mars.
Tu peux dès maintenant tenter de gagner la coque sur les différents comptes sociaux du constructeur :
Le logiciel de mathématiques intégré TI-Nspire est d'une immense complexité, faisant exister et interagir entre elles nombre d'applications interconnectées (tableur, géométrie dynamique, acquisition de données, ...). Un changement local à une application peut ainsi avoir des conséquences hors de l'application en question, et il est difficile de toujours tout anticiper.
C'est pour cela que Texas Instruments fait régulièrement appel à des développeurs et testeurs QA(Quality Assurance) externes, notamment de chez Hildebrando, une société au Mexique.
Nous te présentions un premier prototype passé par chez Hildebrando dans une actualité précédente, mais hélas son système de fichiers avait été nettoyé et était donc vide de toute trace de tests.
Pour la rentrée 2010 sortaient les TI-Nspire Touchpad, premières éditions avec pavé tactile des TI-Nspire.
Les prototypes conçus par Texas Instruments avant la commercialisation d'un nouveau produit suivent différentes phases successives :
PROTO : prototype (concept initial)
EVT : engineering validation tests (concernent plutôt le développement matériel)
DVT : developement validation tests (concernent plutôt le développement logiciel)
PVT : production validation tests (derniers tests avant le lancement de la production de masse)
MP : production de masse
Aujourd'hui, Frédéric Desautels alias mr womp womp nous a déniché un nouveau prototype TI-Nspire CAS Touchpad passé entre les mains d'Hildebrando.
Il s'agit bien d'un prototype, puisque nous notons au dos plusieurs mentions de la phase DVT(Developement Validation Tests):
dans le cadre à la place du numéro de série, une mention NOT FOR SALE DVT1-0909 002
une étiquette à code barre résumant justement la chose en Espagnol avec un DVT1-0909 002, adoptant justement le même format que celle du prototype Hildebrandodéjà présenté
Il s'agit donc d'un prototype DVT1 de numéro de série 002 assemblé en septembre 2009 dans l'usine de code P(usine d'Inventec à Pudong en Chine).
Sur un prototype de phase DVT nous ne nous attendons à rien de bien surprenant sur le matériel, mais Frédéric l'a quand même démonté pour nous. Nous avons :
une carte mère N1_MB_NKB_4420, malheureusement avec l'emplacement J04 du connecteur JTAG laissé vide contrairement à d'autres prototypes de la phase précédente EVT
une carte écran N1/N3_LB_PCR2_FPC_2410
Passons plutôt au logiciel qui peut habituellement réserver davantage de surprises sur un prototype de phase DVT.
Démarrer la calculatrice avec les touches
esc
menu
-
enfoncées nous permet d'accéder au logiciel de diagnostics. Nous notons une version 2.00.DEVBUILD compilée le 19 août 2009 inconnue jusqu'à ce jour, alors que les modèles de production sont dotés de la version 2.00.1183 compilée le 19 février 2010, un gros écart dans le temps.
Une fois la calculatrice redémarrée normalement rien de spécial avec les Boot1 et Boot2, mêmes versions respectives 1.1.8916 et 3.0.1.131 que sur les modèles de production.
Par contre le système d'exploitation est pour sa part intéressant. Il s'agit d'une version 2.0.0.900 jusqu'ici inconnue.
Mais nous en arrivons au véritable trésor que renferme ce prototype, les système de fichiers contient des fichiers de tests d'Hildebrando.
On peut noter entre autres :
plusieurs gros fichiers nommés en "My_seat_leon …", et contenant une vidéo de publicité automobile illustrée ci-contre
un dossier nommé "120 Files" et contenant justement exactement 120 petits fichiers, obtenus par copier-coller successifs d'un même fichier initial
un fichier nommé avec pas moins de 188 caractères
des documents TI-Nspire complexes (beaucoup d'onglets/applications)
...
Visiblement Hildebrando teste le logiciel TI-Nspire dans des conditions extrêmes, soit pour vérifier que son comportement reste conforme, soit pour explorer et signaler des failles éventuelles, soit les deux.
Une véritable mine d'informations qui pourrait être bien utile à l'équipe Ndless si elle voulait bien reprendre du service, que nous mettons à ta disposition ci-dessous.
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 nous sort aujourd'hui une nouvelle mise à jour de l'édition française de cette solution, découvrons-la ensemble.
Le pack d'aujourd'hui nous apporte une double mise à jour :
D'une part, le TI-Runtime pour les micro:bit v2 passe de la version 2.1.0 à la version 2.4.0, comme on constate en interrogeant la carte micro:bit avec microbit.runtime_version() après mise à jour
D'autre part les bibliothèques Python et menus en Français associés pour les micro:bit v2 passent de la version 2.1.0 à la version 2.3.0
Nous allons commencer par te présenter les changements exposés par les différentes bibliothèques, puis nous pencherons sur cette mystérieuse mise à jour du TI-Runtime, majeure si on en croit l'écart de numérotation.
Comme déjà expliqué, microbit est la bibliothèque principale apportant un menu permettant d'accéder aux autres bibliothèques liées à certaines fonctionnalités de la carte micro:bit.
Dans la dernière version, l'entrée liée à la bibliothèque mb_grove pour les capteurs Grove n'avait pas été traduite et était restée intitulée en Anglais : Grove Devices.
C'est maintenant corrigé, l'entrée à été renommée en Capteurs Grove.
Justement, commençons donc par le choix Capteurs Grove.
Il permet toujours d'importer les bibliothèques mb_grove et mb_pins, et d'activer leurs menus respectifs.
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.
Et justement autre petit changement d'intitulé, le menu associé à mb_grove une fois activé est renommé de grove en capteurs grove.
Dans l'onglet Entrée nous constatons 2 changements.
D'une part, l'entrée .read_sht() disparaît. Elle permettait d'interroger un capteur Grove de température et humidité et appelait en fait la méthode grove.read_sht35(), qui est supprimée dans cette nouvelle version. En effet les puces des capteurs compatibles SHT35 et DHT11 ont été placées en fin de vie par leurs fabricants et ne sont plus recommandées pour de nouveaux projets.
À la place nous obtenons une nouvelle méthode grove.read_dht20 pour interroger le capteur DHT20 les remplaçant.
Nous avons également un ajout, la méthode grove.read_sgp30() permettant d'interroger un capteur SGP30.
Le capteur SGP30 effectue deux types de mesures de gaz différentes : le TVOC / COVT(Composés Organiques Volatils comme les hydrocarbures) et le CO2(dioxyde de carbone équivalent). Plein d'applications pratiques pour des projets dans le contexte actuel. Voici un exemple d'utilisation de cette bibliothèque :
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)
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.
Cette bibliothèque a bien été modifiée dans le cadre de cette mise à jour, mais nous ignorons la finalité des changements apportés.
Aucun changement au menu, par contre si l'on fouille le contenu de la bibliothèque on note la disparition de la méthode Data_Log.set_rate(). Voici un exemple interrogeant et traçant en boucle la composante X de l'accéléromètre :
Le choix NeoPixel et Couleur permet d'importer la bibliothèque mb_neopx et d'activer son menu.
Cette bibliothèque permet de piloter des rubans de diodes adressables à connecter à ta carte micro:bit.
Dans l'édition anglaise, les noms de broches (pin0, pin1, ...) étaient accessibles pour saisie rapide sous l'onglet dédié pins.
Malheureusement dans l'édition française précédente avec le renommage de l'onglet setup en Configuration, il n'y avait plus suffisamment de place en largeur à l'écran pour ce 4ème onglet.
Problème corrigé avec cette mise à jour.
Plutôt qu'un 4ème onglet, les noms de broches nous sont ici rajoutés sous l'onglet Configuration, et en prime nous en avons beaucoup plus !
Peut-être également une correction ou contournement de bug, car on se rend compte que l'entrée np=NeoPixel(pin,pixels) de ce même onglet Configuration ne saisit plus np=NeoPixel('pin0',16) mais np=NeoPixel('pin1',20). Texas Insturments pousse donc soudainement à l'usage d'une broche différente, ce n'est pas anodin.
Voici un exemple d'utilisation de cette bibliothèque :
from microbit import * from mb_neopx import * from random import *
np = NeoPixel(pin1, 20)
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()
Le choix Capteurs et gestes permet d'importer la bibliothèque mb_sensr et d'activer son menu.
Cette bibliothèque permet d'interroger les capteurs intégrés à ta carte micro:bit, dont notamment l'accéléromètre et la boussole.
Petit problème dans la version précédente, l'intitulé du menu associé à mb_sensr une fois activé souffrait d'une erreur de typographie : capteurs et estes.
L'intitulé est corrigé avec cette dernière mise à jour : capteurs et gestes.
Autre léger problème, la traduction française n'était pas complète. Pour les fonctions attendant un nom de geste en paramètre, le menu suggérait en Anglais "gesture".
C'est ici aussi corrigé avec cette dernière mise à jour, le menu indique maintenant correctement "geste"
Et passons donc enfin au TI-Runtime pour BBC micro:bit v2. Avec un saut de version de 2.1.0 à 2.4.0, il pourrait bien apporter des changements majeurs. Mais surtout, avec une version 2.4.0 supérieure à la 2.3.0 des bibliothèque Python pour ta calculatrice, il pourrait bien inclure des fonctionnalités futures non encore présentes aux menus...
Ici pas de menu à fouiller, 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 :
from microbit import * from machine import freq, reset, time_pulse_us from time import ticks_us from utime import sleep_us #from time import sleep_ms, sleep
if msg.find('ok',start)!=-1: status = "ok" uart.init(baudrate=115200) return(status) except: uart.init(baudrate=115200) return("Error: communication link")
def tello_connect(ssid,pswd="",TX=TX_pin,RX=RX_pin): display.show(ti) try: timeout = 30 global TX_pin global RX_pin TX_pin=locals()[TX] RX_pin=locals()[RX] uart.init(baudrate=115200,tx=TX_pin,rx=RX_pin) uart.write('AT+CWQAP\r\n') uart.write('AT+RST\r\n') #uart.write('AT+RFPOWER=0\r\n') uart.write('AT+CWMODE=3\r\n') uart.read() sleep(100) the_ap ='AT+CWJAP=' + '"' + ssid +'"' + "," + '"' + pswd +'"\r\n' uart.write(the_ap + '\r\n') is_connected = False timer = 0 sleep(100) while is_connected == False: timer = 0 while not(uart.any()): sleep(1) timer += .002 if timer > timeout: tello_AT('AT+RST') reset() msg = str(uart.read()) if msg.find("WIFI GOT IP") !=-1: is_connected = True uart.write('AT+CIFSR\r\n') sleep(100) timer = 0 while not(uart.any()): sleep(1) timer >.002 if timer == timeout: tello_AT('AT+RST') reset() msg = str(uart.read()) if msg.find("192.168.10") !=-1: status = 'got IP' uart.write('AT+CIPMUX=1\r\n') sleep(100) msg = uart.read() uart.write('AT+CIPSTART=0,"UDP","192.168.10.1",8889,8889,2\r\n') sleep(100) msg = uart.read() sleep(100) cmd='command' udp_len=len(cmd) uart.write('AT+CIPSEND=0,' + str(udp_len) + ',"192.168.10.1",8889\r\n') sleep(200) uart.read() udp = bytes(cmd, 'utf-8') uart.write(udp) msg = str(uart.read()) if msg.find('SEND OK')==-1 and status =='got IP': status = "Tello Connected" display.show(Image.HAPPY) else: status = "Tello not responding" display.show(Image.SAD) uart.init(baudrate=115200) return (False) uart.init(baudrate=115200) #print(status) return(status) except: uart.init(baudrate=115200) display.show(Image.SAD) return("Error: communication link")
# this function only works on V2 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))
IDRegister = 0xD0 # ID holds 0x60, always readable RESET = 0xE0 # Reset only executed by writing 0xB6 CTRL_HUM = 0xF2 # Selects humidity measurement and oversampling STATUS = 0xF3 # Indicates data availability CTRL_MEAS = 0xF4 # Temperature, pressure oversampling, selects normal, forced or sleep mode CONFIG = 0xF5 # Controls normal mode standby time, IRR filter, SPI mode t_fine = 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")
Dans sa version précédente 2.1.0, le TI-Runtime contenait 2 images pour l'afficheur de la carte BBC micro:bit :
le logo Texas Instruments : Image("05500:""05595:""55555:""05550:""00500")
et une coche qui n'était pas utilisée puisque laissée en commentaire : Image("00000:""00009:""00090:""90900:""09000")
En tous cas tu ne reverras plus cette dernière car son code a été supprimé dans la nouvelle version.
On peut remarquer effectivement l'ajout du support des capteurs SGP30 et DHT20 évoqués plus haut, mais également pas mal de changements concernant le capteur BME280. Peut-être une amélioration du support de ce dernier.
Mais surtout, grande découverte. Nous l'avions raté, mais la version 2.1.0 précédente comportait 3 fonctions partageant le nom tello :
tello_connect(ssid,pswd="",TX=TX_pin,RX=RX_pin)
tello_control(cmd,TX=TX_pin,RX=RX_pin)
tello_read(cmd,TX=TX_pin,RX=RX_pin)
Et bien cette nouvelle version 2.4.0 ajoute 3 nouvelles fonctions très conséquentes nommées en tello :
read_tello_setup()
write_tello_setup(ssid,tx,rx,number)
discover_tello(TX_pin,RX_pin)
Qu'est-ce que ça signifie ? Et bien c'est une découverte absolument fantastique ; Texas Instruments avait visiblement commencé à ajouter le support du drone Tello et serait donc maintenant sur le codage de fonctions te permettant de le configurer.
Dans une prochaine mise à jour tu devrais donc pouvoir piloter le drone Tello en Python directement depuis ta calculatrice Texas Instruments via la carte BBC micro:bit, pour des projets encore plus extraordinaires et ambitieux !
by 
Nombre de jeux sortant pour smartphones, tablettes, ordinateurs et consoles de jeux, se retrouvent plusieurs années plus tard disponibles sur calculatrices graphiques.
Mais il existe encore bien d'autres consoles de jeux, comme par exemple la Nintendo Wii sortie en 2006. Dès 2006 au Japon et en Europe puis 2007 en Amérique du Nord, sort Wii Play, un jeu constitué de plusieurs mini-jeux.
