La dernière réforme du lycée a commencé à être mise en place à partir de 2018 pour les nouveaux élèves de Seconde, et a débouché sur le Baccalauréat nouveau format pour la session 2021. Une réforme qui a complètement chamboulé le marché français de la calculatrice scolaire.
Rappelons que dans ce contexte, on distingue :
- les enseignements faisant toujours l'objet d'une évaluation terminale : Français (épreuve anticipée en Première), Philosophie, 2 enseignements de spécialité, grand oral
- les enseignements évalués en contrôle continu : le reste du tronc commun et les enseignements optionnels
Cela fait une différence importante en terme d'organisation de l'évaluation :
- les épreuves terminales, peu importe qu'elles soient écrites, pratiques ou orales, sont organisées sous le cadre réglementaire national, ne permettant que l'autorisation de la calculatrice comme seul outil numérique personnel, avec mode examen dans le cas d'une calculatrice graphique
- les évaluations pour le contrôle continu sont organisées selon des modalités librement choisies par l'enseignant ou établissement concerné, qui à la différence peuvent autoriser tout outil numérique qu'ils jugent pertinent pour l'évaluation (ordinateur, tablette, smartphone, ...)
Parlons spécialités. Les enseignements de spécialité à choisir sont au nombre de 3 pour la rentrée en Première. Une spécialité devant obligatoirement être abandonnée à la fin de la Première, seules 2 spécialités seront conservées en Terminale.
Le choix des enseignements de spécialité est totalement libre pour les élèves décidant de poursuivre en série générale. À ce jour, 13 spécialités sont possibles mais en pratique toutefois, le choix sera limité par les spécialités offertes par le ou les lycées accessibles.
Pour les élèves décidant de poursuivre en série technologique, l'organisation est similaire, à part que les élèves n'ont pas ou très peu de choix. Selon la série choisie, les enseignements de spécialités sont soit imposés, soit n'offrent qu'un nombre limité de choix spécifiques à la série en question.
Problème, en pratique, les seuls élèves à être concernés par une épreuve terminale autorisant la calculatrice ne sont désormais plus que ceux :
- faisant le choix de la série générale avec certains enseignements scientifiques en spécialité, et qui de plus les conservent jusqu'en Terminale : Mathématiques, Physique-Chimie et/ou Sciences de l'Ingénieur
- faisant le choix de certaines séries technologiques : STL, STI2D, STMG, ST2S, STHR ou STAV
Concentrons-nous sur la série générale qui reste la plus populaire. Effet pervers de la réforme qui n'a pas du tout été anticipé ; entre le choix d'une série et de spécialités à la fin de la Seconde et l'abandon d'une spécialité à la fin de la Première, la visibilité des élèves et familles niveau orientation est bien souvent réduite à moins d'une année. Un élève de Seconde ou même Première ne sait pas s'il passera une épreuve terminale avec calculatrice. Et comme nous venons de le voir, il ne suffit pas de faire des Mathématiques ou des sciences pour cela, ces enseignements ne faisant pas l'objet d'une épreuve terminale dans le cadre du tronc commun ou des options.
En conséquence :
- plutôt que de s'équiper dès la Seconde nombre de familles préfèrent différer l'achat d'une calculatrice graphique, en pratique à la Première ou même pire à la Terminale
- nombre d'enseignants ne se donnent même plus la peine de recommander cet achat en Seconde, et parfois même en Première
Cet équipement plus tardif a bien évidemment des conséquences regrettables, avec un temps réduit pour la prise en main l'outil, et une utilisation moins optimale aux épreuves terminales.
Les alternatives en attendant un éventuel équipement sont actuellement :
- utiliser la Casio fx-92+ Spéciale Collège héritée du Collège, certes excellente au Collège mais qui comme son nom l'indique n'est pas parfaitement adaptée aux exigences du lycée
- faire sur ordinateur portable, tablette ou smartphone avec des logiciels, applications ou plateformes bien souvent choisis par les enseignants, et l'énorme défaut que ces outils numériques auxquels ils habituent les élèves ne seront pas ceux autorisés aux épreuves terminales
Conscient de cette problématique,
Texas Instruments a travaillé très dur afin d'apporter une solution. Nous avons le plaisir aujourd'hui de t'annoncer le grand lancement de
MaClasseTI.fr, la nouvelle plateforme numérique de
Texas Instruments conçue sur-mesures pour l'apprentissage des Mathématiques et des Sciences au lycée français
Tournant dans le navigateur et donc utilisable aussi bien sur ordinateur que tablette ou smartphone et ce peu importe le système d'exploitation,
MaClasseTI.fr se compose de différents modules interconnectables que nous allons te présenter :
- Calculatrice en ligne
- Editeur Python
- Tutoriels
- Classe
Nous allons donc découvrir tout cela ensemble. Mais avant ceci, précisons que l'intégralité des fonctionnalités de la plateforme sont accessibles
gratuitement !
A) Calculatrice en ligne - un émulateur TI-83 Premium CE
La
calculatrice en ligne prend la forme d'un émulateur de
TI-83 Premium CE. Il fait actuellement tourner le système
5.7.2.0017 sur un
boot en version
5.6.1.0006, et est basé sur la même technologie que celle utilisée par TI-SmartView CE, ainsi que la solution
TI-84 Plus CE Online sortie en mi-2022.
Précisons que l'émulateur ne reproduit pas ici
totalement le dernier modèle
TI-83 Premium CE Edition Python : il n'y a pas de gestion du
Python ici, l'application dédiée étant justement absente des applications préchargées. Mais ne sois pas trop déçu(e), car nous allons reparler de
Python très vite.
Ceci donc mis à part, toutes les autres applications officielles sont bien présentes, et tu as donc accès à l'ensemble des autres fonctionnalités. L’émulateur, hors
Python, conviendra ainsi aussi bien aux utilisateurs de
TI-82 Advanced Edition Python que de
TI-83 Premium CE.
Précisons que l'émulateur ne permet pas d'importer ou exporter des données
(applications, programmes, feuilles de calcul, ...) et ne permet pas non plus de prendre de capture d'écran. Il semble ainsi cibler une simple utilisation des fonctionnalités officielles intégrées dans un contexte purement scolaire par des élèves.
Pari très audacieux de la part de
Texas Instruments, cet émulateur de
TI-83 Premium CE est donc entièrement gratuit et totalement libre d'accès pour tous et toutes, alors que le constructeur n'avait historiquement jamais proposé une telle offre à tous. Il n'y a besoin ni de payer ni même de s'inscrire sur la plateforme pour l'utiliser, et c'est bien apprécié : il est donc possible de mettre immédiatement les élèves dessus dès le premier cours de l'année, formidable !
On se rend compte donc que NumWorks n'est désormais plus le seul à avoir sa calculatrice en ligne gratuite directement sur son site !B) Python : éditeur, simulateur, et bibliothèques
B1) Editeur Python et bibliothèque de projets
Passons maintenant à l'
éditeur Python qui, pour le coup, est dédié aux fonctionnalités
Python.
Immédiatement ici encore sans besoin de la moindre inscription, tu peux soit créer un nouveau projet, soit ouvrir un projet déjà existant. Dans ce dernier cas tu peux :
- soit ouvrir des projets en ligne, maclassti.fr donnent en effet accès à une véritable bibliothèque - au choix :
- exemples de projets
- projets partagés en public par d'autres utilisateurs
- tes propres projets si enregistrés en ligne (leur sauvegarde en ligne nécessitant une inscription)
- soit ouvrir tes projets enregistrés en local (la sauvegarde locale étant dans tous les cas possible sans inscription)
Tu es libre de partager avec l'ensemble de la communauté d'utilisateurs aussi bien les projets que tu crées que ceux que tu modifies.
Choisissons de commencer un nouveau projet. Nous y trouvons donc un éditeur
Python en ligne comme il faut : numérotation des lignes, coloration syntaxique, et même quelques propositions d'auto-complétions lorsqu'on est en mode d'édition de code.
Précisons que la sauvegarde locale du projet utilise le format
.py, et y inclut sous forme de chaînes de documentation les informations spécifiques à la conception du projet, permettant ainsi leur récupération lorsque tu rouvriras ce fichier depuis la plateforme. Le bouton
"Télécharger pour la calculatrice" quant à lui te fera récupérer un fichier
.py allégé
(note : TI Connect CE, pour macOS et Windows, pourra directement convertir ce fichier à la volée en fichier .8xp compatible avec la calculatrice lors du transfert, mais si tu ne peux pas utiliser ce logiciel, il faudra donc que tu le convertisses par toi-même auparavant).
Par contre, apparemment l'éditeur ne gère qu'un seul et unique script, ce qui est dommage pour un outil mettant en avant la conception de projets. Certains projets gagneraient en effet beaucoup en organisation à pouvoir avoir leur code scindé en différents scripts, notamment pour la définition de bibliothèques personnelles ou de classes. C'est d'ailleurs un des avantages de notre outil en ligne
"Project Builder" qui gère depuis peu le Python pour CE
B2) Simulateur TI-83 Premium CE Edition Python
Commençons de suite un nouveau projet avec l'affichage du triangle de Pascal dans la console Python
(inspiré du sujet NSI 2023 n°17 exercice 2).
Le bouton lecture
►
de la barre d'outils permet d'ouvrir une visionneuse en ligne permettant de lancer le script
Python saisi, dans une interface proche de celle d'une
TI-83 Premium CE Edition Python. Elle n'est clairement pas identique pour autant
(différences dans les couleurs, icônes et polices de caractères comme tu peux le constater ci-après) ce qui nous indique que nous n'avons pas affaire à un émulateur mais à un simulateur. La différence est importante, car cela implique que le fonctionnement interne de la
TI-83 Premium CE Edition Python n'est pas reproduit à l'identique, ce qui ouvre la voie à des différences à l'utilisation qu'il va nous falloir creuser.
- Code: Select all
from math import log
def pascal(n):
triangle= [[1]]
for k in range(1, n):
ligne_k = [1]
for i in range(1,k):
ligne_k.append(triangle[k - 1][i-1]+triangle[k - 1][i])
ligne_k.append(1)
triangle.append(ligne_k)
return triangle
def print_pascal(n):
triangle = pascal(n)
lmax = [0] * len(triangle[-1])
for l in triangle:
for i in range(len(l)):
lmax[i] = max(lmax[i], l[i])
for l in triangle:
ligne = ""
for i in range(len(l)):
ligne += ("{:0" + str(1 + int(log(lmax[i], 10))) + "} ").format(l[i])
print(ligne)
print_pascal(9)
(lancer en ligne)Cet éditeur en ligne en passant nous le reconnaissons justement à ces différences d'interface
TI-83 Premium CE Edition Python, il s'agit très exactement de celui disponible
chez Vittascience, qui a en fait conçu la plateforme MaClasseTI avec Texas Instruments..
D'ailleurs, nous n'avons pas besoin de chercher bien loin, rien qu'en restant sur le formatage d'affichages dans la console nous trouvons des anomalies. Il y a clairement un problème à l'exécution si l'on compare avec la calculatrice :
- Code: Select all
LINES = 4
DELTA = 8
START = 4
def print_stars(i):
print(" "*(DELTA // 2)*(LINES - i - 1) + "*"*(DELTA*i + START))
for i in range(LINES):
print_stars(i)
print("Hello TI-World from inside !")
for i in range(LINES - 1, -1, -1):
print_stars(i)
(lancer en ligne)La fonction
print() semble ignorer les caractères espace lorsque présents au début d'une chaîne de caractères, correspondant ici au
" " en ligne 6 du script. Un contournement pour tes projets est de les remplacer par des espaces insécables
"\xA0". C'est bien dommage, car nous sommes en plein dans ce qui se pratique au lycée, le formatage dans la console pouvant être jugé plus facilement accessible que la manipulation de pixels.
Mais pas d'inquiétude, nous avons rapporté les bugs que nous avons trouvé à TI, qui a pu les constater ; espérons donc que ceci pourra être corrigé bientôt.
Par contre, il y a d'autres choses excellentes offertes par les boutons du simulateur :
- possibilité de faire défiler pas à pas l'exécution du script, avec à chaque étable rafraîchissement de l'écran de la calculatrice et surlignage de la prochaine ligne qui sera exécutée (en passant un beau moyen de comprendre le fonctionnement des boucles)
- possibilité de faire afficher l'état de l'ensemble des variables globales, et de le rafraîchir au fur et à mesure en cas d'une exécution pas à pas
Tout ceci est extrêmement sympathique dans le contexte du développement d'un projet !
Il est grand temps de savoir à quoi nous avons affaire. Regardons du côté de la bibliothèque intégrée
sys :
- Code: Select all
import sys
l = dir(sys)
print(l)
Pas de propriété
sys.platform, mais nous pouvons par contre regarder du côté de
sys.version et
sys.version_info.
- Code: Select all
import sys
print(sys.version_info)
print(sys.version)
Mystère résolu, la visionneuse
Python utilise
Skulpt, une implémentation de
Python pour navigateurs, et ici plus précisément une implémentation partielle
(ish) de
Python 3.7. Une implémentation qui plus est
open source dont tu es libre de contribuer à l'amélioration !
B3) Programmation par blocs et bibliothèques Python
La barre d'outils supérieure permet de basculer l'éditeur entre différents modes :
- le mode code, par défaut qui est celui illustré jusqu'à présent
- le mode blocs
- le mode hybride
Le mode
blocs permet de saisir le script par assemblage de blocs, exactement comme en
Scratch au Collège. Bien évidemment ce n'est pas le but au lycée.
Mais justement, le mode
hybride pour sa part juxtapose les deux vues :
blocs et
Python. Dans ce mode le script est toujours saisi par assemblage de blocs, mais tu en obtiens automatiquement une transcription en
Python qui est mise à jour au fur et à mesure. Il t'est même possible via un clic droit de désactiver/réactiver des blocs pour mieux comprendre quelles lignes
Python sont relatives à leur présence.
Un formidable outil pour faire participer l'ensemble des élèves de Seconde sans laisser personne de côté dans le cadre d'une transition progressive de
Scratch à
Python !
L'affichage et la gestion des blocs sont ici réalisés par
Blockly, encore une fois un projet
open source, par Google, auquel tu peux contribuer.
Les blocs sont saisis à l'aide de la barre d'outils latérale, qui nous donne par catégories les blocs disponibles. Commençons par les blocs que nous qualifierons de non spécifiques :
- Fonc : blocs relatifs aux définitions de fonctions et valeurs retournées
- Ctl : blocs de contrôle, ce sont ceux qui englobent d'autres blocs (boucles comme répéter, alternative si/alors/sinon, ...)
- Ops : blocs relatifs aux opérateurs de comparaison (égal, inférieur, supérieur, ...) et opérateurs logiques (et, ou, oui, non, ...)
- List : blocs relatifs aux manipulations de listes
- E/S : blocs relatifs aux opération d'entrée/sortie (print/afficher, input/saisir, ...)
- Var : blocs relatifs aux manipulations de variables (affecter, rappeler, incrémenter, ...)
- Text : blocs relatifs aux manipulations de chaînes de caractères
On peut noter en passant les info-bulles d'explication extrêmement complètes et dans un Français parfaitement correct disponibles sur chaque bloc.
Le reste des blocs concernent des fonctionnalités spécifiques au
Python, et commencent à nous donner un premier aperçu de la formidable étendue des bibliothèques disponibles :
- math (dans lequel un petit coquin a même casé un 42 comme valeur spécifiée par défaut pour le bloc de valeur numérique)
- random (relatif à l'aléatoire)
- time
- ti_system
- ti_plotlib (pour les représentations dans un repère dont les diagrammes)
- ti_hub (relatif à l'interface TI-Innovator Hub permettant de connecter des capteurs et actionneurs pour projets STEM)
- ti_rover (relatif au TI-Innovator Rover utilisable avec l'interface précédente)
- micro:bit (relatif à la carte de développement BBC micro:bit programmable en Python et permettant de connecter des capteurs et actionneurs pour projets STEM)
- ce
- turtle (pour les tracés relatifs dits à la tortue/turtle/Scratch)
- tello (relatif aux drones Tello)
Nous allons explorer tout cela.
B4) Interface personnalisable pour accessibilité
Avant d'aller plus loin, notons comment l'interface de l'éditeur
Python a été conçue pour s'adapter à un très large public scolaire.
Chacun ou chacune peut choisir selon ses capacités visuelles ou celles de son écran entre des thèmes clair et sombre, et même pour chacun activer un mode avec contraste élevé :
Plusieurs polices de caractères sont également au choix pour une meilleur lisibilité, dont
OpenDyslexic qui se veut adaptée aux élèves dyslexiques :
Enfin, spécificité de l'éditeur
Python par rapport au reste de la plateforme, plusieurs langues sont disponibles : Français, Anglais, Italien, Espagnol et Arabe :
Notons l'Arabe qui n'adapte pas seulement le contenu de l'interface mais également sa disposition, les différents éléments étant réorganisés pour une logique de lecture de droite à gauche !
On peut toutefois remarquer que la traduction est incomplète : certains éléments de l'éditeur restent en Français, et d'autres sont systématiquement affichés en Anglais pour toute autre langue.
B5) Bibliothèques Python standard non graphiques
Sur
TI-83 Premium CE Edition Python, on peut obtenir l'ensemble des bibliothèques disponibles en tapant
help("modules").
Malheureusement ici sur le simulateur de l'éditeur
Python, cet appel déclenche une exception
NotImplementedError. La fonction
help() n'a visiblement pas été implémentée.
La bibliothèque
importlib n'étant pas davantage présente, pour tester la présence ou l'absence d'éventuelles bibliothèques non mises en avant par la barre d'outil, nous allons devoir tester leur importation une par une.
En espérant ne rien rater, nous nous référerons pour cela :
- à la liste officielle des bibliothèques standard intégrées à Python
- à l'ensemble des bibliothèques officielles intégrées ou rajoutables sur TI-83 Premium CE Edition Python
Commençons pour le moment par les bibliothèques standard non graphiques. La
TI-83 Premium CE Edition Python en intègre 9 :
- __main__
- array
- builtins
- collections
- gc
- math
- random
- sys
- time
Toutes ne sont pas présentes ici dans le simulateur
Python. Nous constatons l'absence de
builtins et
gc et n'en retrouvons donc que 7.
Par contre, nous remarquons la disponibilité de 18 bibliothèques supplémentaires non présentes sur la calculatrice, de quoi aller bien plus loin dans tes projets :
- bisect
- copy
- datetime
- itertools
- keyword
- numbers
- operator
- platform
- re
- signal
- string
- test
- textwrap
- token
- types
- unittest
- urllib
- webbrowser
| calculatrice
TI-83 Premium CE
Edition Python | éditeur Python
en ligne |
| __main__ | ✔ | ✔ |
| array | ✔ | ✔ |
| bisect | | ✔ |
| builtins | ✔ | |
| collections | ✔ | ✔ |
| copy | | ✔ |
| datetime | | ✔ |
| itertools | | ✔ |
| gc | ✔ | |
| keyword | | ✔ |
| math | ✔ | ✔ |
| numbers | | ✔ |
| operator | | ✔ |
| platform | | ✔ |
| random | ✔ | ✔ |
| re | | ✔ |
| signal | | ✔ |
| string | | ✔ |
| sys | ✔ | ✔ |
| test | | ✔ |
| textwrap | | ✔ |
| time | ✔ | ✔ |
| token | | ✔ |
| types | | ✔ |
| unittest | | ✔ |
| urllib | | ✔ |
| webbrowser | | ✔ |
| total | 9 | 25 |
B6) Bibliothèque ti_system - clavier, caractères et console
La bibliothèque
ti_system est spécifique à la
TI-83 Premium CE Edition Python. Elle permet entre autres (cf.
notre article) :
- des affichages avancés dans la console (ligne au choix)
- d'effectuer une pause (délai en secondes)
- de tester l'appui sur une touche
- d'exporter/importer des données
L'intérêt est certes moindre dans le cadre d'un éditeur en ligne ici déconnecté de l'environnement
TI-83 Premium CE, mais il reste toutefois important que, malgré tout, cette bibliothèque se comporte le mieux possible et ne génère pas d'erreur, histoire de pouvoir développer et tester correctement ses projets en ligne avant de les charger sur la calculatrice.
Vérifions et comparons-en le contenu :
- Code: Select all
import ti_system
l = dir(ti_system)
l.sort()
print(l)
La calculatrice offre 2 méthodes à notre connaissance identiques pour effectuer une pause :
sleep(secondes) et
wait(secondes). Ici dans l'éditeur en ligne,
wait semble avoir été oublié et il faudra donc remplacer tous ses appels si utilisé.
Niveau importation/exportation de données, ça commence mal. Toutes les méthodes concernées
recall_list(),
store_list() et
recall_RegEQ() déclenchent une exception
NotImplementedError. Et ce de façon fort inattendue puisque l'ensemble de ces méthodes sont bien présentes et même documentées correctement via les info-bulles de la barre d'outils.
Testons un petit peu maintenant la méthode d'affichage
disp_at(numero_ligne, texte, alignement), avec :
- numero_ligne : la ligne où afficher, numérotée de 1 à 11 du haut vers le bas
- alignement : au choix "left", "right" ou "center" pour des affichages respectivement alignées à gauche, alignés à droite ou centrés
Tentons par exemple l'affichage en mode texte dans la console, d'une image binaire représentons le logo de
Texas Instruments, et faisant appel aux divers alignements possibles :
- Code: Select all
from ti_system import *
logo = [
["WWWWWWW WWW", "center"],
["WWWWWWW ", "center"],
["WWWWWWWWW WWW WWWWWW ", "right"],
["WWWWWWWWW WWW WWWWWWW ", "right"],
["WWWWWWWWWWWWWWW WWW WWWWWW", "left"],
["WWWWWWWWWWWWWW WWW WWWWWWWWWW", "right"],
["WWWWWWWWWWWW WWW WWWWWWWWWW", "right"],
["WW WWW WWWW", "center"],
[" WWWWWWWWWW", "center"],
[" WWWWWWWW", "center"],
[" WWWWW", "center"]
]
for i in range(len(logo)):
ligne = logo[i]
disp_at(i + 1, ligne[0], ligne[1])
disp_wait()
Et bien zut, quelque chose ne va clairement pas sur la plateforme en ligne. D'une part, nous constatons que les affichages via
disp_at() n'effacent pas le contenu de la console aux endroits affectés, mais s'effectuent par-dessus. À la rigueur, comme il s'agit ici d'une interface
web, nous pouvons comprendre que ce comportement de la calculatrice ne soit pas évident à reproduire selon la technologie choisie.
Mais il y a bien plus embêtant que cela ; les alignements ne sont pas bons. Tentons de vérifier ; la console faisant très exactement 32 colonnes sur calculatrice, numérotons chaque caractère affiché :
- Code: Select all
from ti_system import *
logo = [
["WWWWWWW WWW", "center"],
["WWWWWWW ", "center"],
["WWWWWWWWW WWW WWWWWW ", "right"],
["WWWWWWWWW WWW WWWWWWW ", "right"],
["WWWWWWWWWWWWWWW WWW WWWWWW", "left"],
["WWWWWWWWWWWWWW WWW WWWWWWWWWW", "right"],
["WWWWWWWWWWWW WWW WWWWWWWWWW", "right"],
["WW WWW WWWW", "center"],
[" WWWWWWWWWW", "center"],
[" WWWWWWWW", "center"],
[" WWWWW", "center"]
]
for i in range(len(logo)):
s_in = logo[i][0]
s_out = ""
c = {
"left": 1,
"right": 33 - len(s_in),
"center": (32 - len(s_in)) // 2 + (len(s_in) % 2)
}[logo[i][1]] % 10
for j in range(len(s_in)):
s_out += (s_in[j] != " " and str(c) or " ")
c = (c + 1) % 10
logo[i][0] = s_out
for i in range(len(logo)):
ligne = logo[i]
disp_at(i + 1, ligne[0], ligne[1])
disp_wait()
Effectivement :
- les alignements à gauche sont décalés d'un caractère par rapport aux alignements à droite
- lorsque affichant un nombre impair de caractères, les alignements centrés sont décalés d'un demi caractères par rapport aux alignements à droite
Il y a clairement eu une erreur. Pour les affichages en
disp_at(), l'interface en ligne utilise une console en 33 colonnes au lieu de 32 colonnes.
C'est d'ailleurs bien curieux cette erreur, car les affichages console avec
print() restent pour leur part sur 32 colonnes à la différence :
- Code: Select all
from ti_system import *
s = ""
for i in range(33):
s += str((i + 1) % 10)
for i in range(4):
print(s)
for i in range(1, 3):
disp_at(i, s, "left")
disp_wait()
Sur la technique utilisée pour obtenir
(mal) les alignements sur l'interface en ligne, on peut l'utilisation de polices différentes pour le contenu console et les affichages via
disp_at().
Dans tous les cas, nous avons là aussi informé TI de ce problème.
Poursuivons en consultant le contenu de la police de caractères, d'abord avec
print() :
- Code: Select all
def pchars(k, l=16):
print("\xA0\xA0|0123456789ABCDEF")
print("--+----------------")
for i in range(k * l, (k + 7) * l, l):
ligne = hex(int(i // l))[2:].upper() + "_|"
for j in range(l):
ligne += chr(i + j)
print(ligne)
pchars(2)
pchars(9)
Nous constatons l'affichage incorrect des 32 caractères de codes
0x80 à
0x9F. Parmi ceux-ci, rappelons que les 16 caractères de codes
0x80 à
0x8F sont spécifiques à la
TI-83 Premium CE.
Comme nous avons vu qu'il y avait utilisation de 2 polices différentes, vérifions également avec des affichages via
ti_system.disp_at(). Nous constatons en fait très exactement le même problème, ni plus ni moins :
- Code: Select all
from ti_system import *
disp_clr()
def pchars(k, l=16):
disp_at(1, "\xA0\xA0|0123456789ABCDEF", "left")
disp_at(2, "--+----------------", "left")
n = 3
for i in range(k * l, (k + 9) * l, l):
ligne = hex(int(i // l))[2:].upper() + "_|"
for j in range(l):
ligne += chr(i + j)
disp_at(n, ligne, "left")
n += 1
pchars(2)
disp_wait()
pchars(9)
disp_wait()
Peut-être que TI devrait fournir sa police spéciale complète, ou bien peut-être que VittaScience pourrait utiliser
la version communautaire, proposée dans le domaine public ?
Niveau touches clavier, nous ne disposons ici pas du clavier complet à 50 touches de la calculatrice, mais de 2 touches cliquables,
entrer
et
annul
, interrogeables par les méthodes suivantes :
ti_system.wait_key() et ti_system.disp_wait() attendent l'appui sur n'importe laquelle de ces touchesti_system.escape() teste l'appui sur la seule touche annul
Précisons que sur la calculatrice,
ti_system.wait_key() renvoie le code de la touche activée (cf.
ici), soit entre autres
5 pour
entrer
et
9 pour
annul
. Ici sur la plateforme c'est différent,
ti_system.wait_key() ne renvoie rien. Question de compatibilité, c'est une nouvelle fois dommage.
Dernière chose à évoquer avant de passer aux bibliothèques graphiques, si nous n'avons que 2 touches utilisables, comment se passent les saisies avec
input() ? Pour cela, voici un petit jeu repris de
chez nsi.xyz :
- Code: Select all
from random import randint
essais_max= 5 # nombre d'essais maximum
essais = 1 # nombre essais
nombre_joueur = 0 # nombre du joueur au départ
nombre_max_ordi = 25 # nombre maximum généré par l'ordinateur
nombre_ordi = randint(1,nombre_max_ordi) # nombre choisi par l'ordinateur
print("L'ordinateur a choisi un nombre entre 1 et",nombre_max_ordi, ".")
print("Vous devez le trouver en moins de 5 tentatives !")
while nombre_ordi != nombre_joueur and essais <= essais_max:
print("vous êtes au", essais, "essai.")
nombre_joueur = int(input("Choisissez un nombre :"))
if nombre_joueur < nombre_ordi:
print("Le nombre que vous avez choisi est trop petit")
elif nombre_joueur > nombre_ordi:
print("Le nombre que vous avez choisi est trop grand")
else:
print("Félicitations ! Vous avez trouvé le nombre de l'ordinateur ","en",essais,"essai(s)")
essais += 1
if essais>essais_max and nombre_joueur != nombre_ordi :
print("Désolé, vous avez utilisé tous vos essais.")
print("Vous êtes vraiment nul, réessayer jusqu'a ce que vous gagnez!")
print("L'ordinateur avais choisi le nombre",nombre_ordi,".")
(lancer en ligne)
Nous obtenons bien le message d'invite de saisie dans l'écran de la plateforme, sans pouvoir interagir avec. Mais la bonne nouvelle, c'est qu'en fait, il y a une seconde console non pas en mode graphique mais en mode texte que l'on trouve
sous l'éditeur. Les divers affichages via
print() et
input() y sont dupliqués, pouvant à la différence y être sélectionnés et copiés. Et dans cette console-ci, le message d'invite est accompagné d'une boîte de saisie.
En l'état, l'implémentation
ti_system de la plateforme nous semble fort peu satisfaisant. Entre le déclenchement d'erreurs, et son manque de fiabilité en l'absence d'erreur, nous ne sommes pas sûrs de son utilité, le voyant davantage comme un obstacle que comme une aide. Et c'est très curieux car plusieurs éléments nous indiquent qu'il y a eu des bases très soignées et très propres. C'est un peu comme si le développement avait été finalement scindé entre plusieurs entités, ou haché avec des pauses plus ou moins longues.
Mais bon, vu le travail colossal accompli sur tout le reste de cette plateforme, avec un peu de volonté et de temps, amener
ti_system à un niveau satisfaisant ne devrait être qu'un jeu d'enfant…
B7) Bibliothèques de tracé dans un repère
La
TI-83 Premium CE Edition Python bénéficie de plusieurs bibliothèques de tracé dans un repère, avec chacune leurs spécificités.
Il y a d'abord
ti_plotlib qui est intégré, et permet de tracer divers diagrammes :
- nuage de points
- diagramme en ligne brisée
- droite de régression linéaire
Plusieurs bibliothèques complémentaires officielles sont également rajoutables, et offrent d'autres types de diagrammes :
- ce_chart pour les diagrammes en barres
- ce_box pour les diagrammes en boîte dits à moustaches
- ce_quivr pour les champs vectoriels
Et bien c'est fantastique, l'ensemble de ces bibliothèques sont ici présentes sans avoir rien à charger :
ce_box | ce_chart |
ce_quivr |
- Code: Select all
from ce_box import *
d = (2, 3, 5, 7, 11)
b = box(d)
b.show()
 | - Code: Select all
from random import *
from ce_chart import *
seed(42)
n = 5
cx = [
randint(0, n ** 2)
for i in range(n + 1)
]
connex = [
("Me", cx[1] / n),
("Li", cx[2] / n),
("Si", cx[3] / n),
("Ja", cx[4] / n),
("Ck", cx[5] / n)
]
cht = chart()
cht.data(connex)
cht.title("Lorem ipsum")
cht.frequencies(2)
cht.show()
 | - Code: Select all
import ti_plotlib as plt
from ce_quivr import *
def fx(x):
val1 = x ** 3
val2 = 4 * x ** 2
val3 = 3 * x
return ((val1 - val2) + val3) - 2
def dx(x):
val1 = 3 * x ** 2
val2 = 8 * x
return (val1 - val2) + 3
def dx2(x):
val1 = 6 * x
return val1 - 8
def motion(min2, max2, n):
dt = (max2 + min2) / n
t = min2
for i in range(0, n, 1):
quiver(t, fx(t), t + dt, fx(t + dt), 1, 'blk', 'line')
if i % 7 == 0:
quiver(t, fx(t), 0, dx(t), 0.4, 'r', 'vector')
quiver(t, fx(t), 0, dx2(t), 0.4, 'b', 'vector')
t = t + dt
Y_MAX = 8
N_POINTS = 100
plt.window(-0.25, 4, -5, Y_MAX)
plt.cls()
plt.title('Motion in one Dimension')
plt.color(0, 0, 0)
plt.axes("on")
plt.labels('Time', ' X Position ', 7, 3)
motion(0, 4, N_POINTS)
plt.show_plot()
  |
On remarque en passant que la plateforme n'utilise pas le même générateur de nombre aléatoire que la calculatrice, le diagramme en barres différent malgré l'utilisation de la même graine (
seed).
L'implémentation de
ti_plotlib est certes fonctionnelle elle aussi...
- Code: Select all
import ti_plotlib as plt
import math
plt.cls()
def linspace(min2, max2, number):
time = []
space = round(max2) + math.fabs(min2)
step = space / number
point = min2
time.append(point)
for i in range(0, number, 1):
point = point + step
time.append(point)
return time
def Sinus(t):
sin = []
for i in range(0, len(t), 1):
sin.append(math.sin(t[int(i)] / 180.0 * math.pi))
return sin
NUMBER_OF_POINTS = 50
MINIMUM = -360
MAXIMUM = 360
Angle = linspace(MINIMUM, MAXIMUM, 50)
Sinus2 = Sinus(Angle)
print(str(Angle))
print(str(Sinus2))
plt.cls()
plt.auto_window(Angle, Sinus2)
plt.grid(90, 0.25, "dot")
plt.color(0, 0, 153)
plt.axes("on")
plt.color(0, 0, 0)
plt.labels('Angle (°)', '', 6, 1)
plt.title('f(x) = sin(x)')
plt.color(0, 153, 0)
plt.plot(Angle, Sinus2, "o")
plt.color(255, 0, 0)
plt.scatter(Angle, Sinus2, "o")
plt.show_plot()
... mais elle nous semble incomplète lorsque l'on interroge son contenu :
- Code: Select all
import ti_plotlib as plt
l = dir(plt)
l.sort()
print(l)
Si certains manques peuvent être jugés purement décoratifs, ce n'est pas toujours le cas. Par exemple, ne pas pouvoir consulter les bornes de la fenêtre nous semble problématique.
B8) Bibliothèques de tracé par déplacements - turtle
La
TI-83 Premium CE Edition Python permet de charger une bibliothèque complémentaire
turtle, bibliothèque de tracé par déplacements d'une tortue.
Nous avons le plaisir de constater qu'elle est présente directement sur la plateforme :
- Code: Select all
from turtle import *
import math
r, g, b = 0, 255, 127
t = Turtle()
t.penup()
longueur = 204
t.backward(longueur / 2)
t.left(90)
t.forward(longueur / 2)
t.right(90)
t.pendown()
for count2 in range(10):
t.fillcolor(r, g, b)
t.begin_fill()
for count in range(4):
t.forward(longueur)
t.right(90)
t.end_fill()
r, g, b = b, r, g
longueur = longueur * (math.sqrt(3) - 1)
t.forward(longueur / 2)
t.right(30)
Une implémentation de
turtle ici très complète avec les méthodes de remplissage, même si quelques bugs isolés à identifier sont encore capables de littéralement ravager certains tracés :
- Code: Select all
from math import pi, sin, cos, sqrt
from turtle import *
turtle = Turtle()
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)
turtle.dot(3)
turtle.pencolor(205,133,63)
turtle.dot(2)
turtle.goto(0,0)
turtle.setheading(0)
a+=360/phi
turtle.right(a)
if a>=360:
r+=dr
a-=360
def feuille(core,a):
turtle.begin_fill()
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)
turtle.end_fill()
turtle.speed(0)
turtle.pencolor(30,144,255)
turtle.dot(320)
d=25
core=40
turtle.pencolor(160,82,45)
turtle.dot(40)
c=((255,215,0),(255,255,0))
for i in range(2):
turtle.pencolor(c[0][0], c[0][1], c[0][2])
turtle.fillcolor(c[i][0], c[i][1], c[i][2])
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()
turtle.show()
Ici encore, nous avons espoir que l'implémentation de
turtle soit rapidement améliorée suite à nos
feedbacks, et rendue ainsi encore plus excellente !
B9) Bibliothèques de tracé par pixels
Sur la
TI-83 Premium CE Edition Python, plusieurs bibliothèques te permettent de prendre le contrôle de l'ensemble des pixels de la zone graphique.
Il y a
ti_graphics qui est intégré mais non mis en avant aux menus.
Se rajoutent deux bibliothèques additionnelles préchargées, mises en avant aux menus et appelant en pratique la précédente :
Aucune de ces bibliothèques n'est présente ici sur la plateforme, ce qui soulève un mystère.
En effet, sur la calculatrice, l'ensemble des bibliothèques de tracé dans un repère et tracé par déplacements fonctionnent en faisant appel aux bibliothèques de tracé par pixel ici absentes sur la plateforme.
Y aurait-t-il une autre bibliothèque de tracé par pixel ici utilisée et si oui serait-elle également directement appelable depuis les scripts de l'utilisateur ?...
B10) bibliothèques STEM TI-Innovator Hub
La
TI-83 Premium CE Edition Python est un formidable outil polyvalent intégrant plusieurs bibliothèques très utiles dans le cadre de la conception de projets
STEM. Ces bibliothèques ciblent divers périphériques pouvant être connectés à ta calculatrice, chacun avec leurs propres capteurs et actionneurs que tu pourras interroger ou commander depuis ton code.
La bibliothèque
ti_hub est dédiée
TI-Innovator Hub, brique programmable intégrant plusieurs capteurs/actionneurs et permettant d'en connecter d'autres via des ports
Grove et
breadboard.
Et bien miraculeux, non seulement la bibliothèque
ti_hub est présente, mais son importation déclenche l'ajout d'un
TI-Innovator Hub dans la partie simulation.
Mais encore mieux que ça, de façon fort intelligente la plateforme arrive à déterminer les différents types de capteurs et actionneurs invoqués par ton code et te les rajoute également, tout en te précisant si il s'agit d'éléments intégrés au
TI-Innovator Hub ou d'éléments rajoutés !
- Code: Select all
from ti_hub import *
import brightns
from analogout import *
# Analog Write on OUT 1
out1 = analog_out("OUT 1")
def ecl_affine(x):
k = 1 + x / 100
return 255 * 1
L = brightns.measurement()
while not L == 100:
P = ecl_affine(L)
out1.set(P)
L = brightns.measurement()
P = ecl_affine(L)
out1.set(P)
La valeur retournée par chaque capteur peut ici être ajustée, de quoi tester tes projets comme en vrai !
C'est de plus un formidable outil si tu souhaites faire développer des projets
STEM en classe car il te permet à chaque élève de disposer
(virtuellement) de ses propres éléments matériels, plutôt que de faire la queue pour tester avec les éléments matériels de la classe en nombre limité.
De ton côté tu n'as plus besoin de t'embêter avec la logistique, n'ayant pas besoin de prévoir et distribuer les éléments matériels en quantité suffisante pour les séances concernées. Tu peux réserver les éléments matériels pour les tests finaux et présentation du projet.
B11) bibliothèques STEM TI-Innovator Rover
Un périphérique remarquable qui peut lui-même être connecté sur la brique programmable
TI-Innovator Hub, c'est le robot sur roues
TI-Innovator Rover, invocable par la bibliothèque
ti_rover.
Ce périphérique intègre lui-même ses propres capteurs et actionneurs
(capteur de distance, capteur de couleur au sol, diode RVB, ...).
Et bien c'est fantastique ici, car non seulement le robot
TI-Innovator Rover, lorsque invoqué, est rajouté au simulateur, mais il est même accompagné d'un véritable tapis de tests !
- Code: Select all
import ti_rover as rv
def poly(n):
for i in range(n):
rv.forward(1)
rv.left(360//n)
for i in range(3, 6):
poly(i)
Hautement pertinent, tu pourras ainsi tester aisément comme en vrai tes projets utilisant les couleurs au sol pour influer sur le comportement du
TI-Innovator Rover !
Un tapis de plus notamment bien pensé pour le codage d'un projet de
"suivi de ligne".
Et en prime, les sens de rotation des deux servomoteurs et même distance restant à parcourir sont reportés en temps réel !
B12) bibliothèques STEM micro:bit
Autre périphérique utilisable avec ta
TI-83 Premium CE Edition Python pour tes projets
STEM, la carte de développement
BBC micro:bit, aussi bien en version 1 que 2.
Cette carte intègre ses propres capteurs et actionneurs
(dont un buzzer pour la v2 ainsi qu'un afficheur à 5x5 diodes adressables), et permet également d'en connecter d'autres.
Elle est invoquée en
Python par la bibliothèque
microbit dont nous avons le plaisir de constater la présence ici, avec une nouvelle une gestion dédiée et parfaitement fonctionnelle dans le simulateur !
- Code: Select all
from microbit import *
from mb_disp import *
display.show("Image.PACMAN",delay=400,wait=True)
B13) bibliothèques STEM drone tello
Autre périphérique remarquable utilisable avec ta
TI-83 Premium CE Edition Python pour tes projets
STEM, le drone
Tello, dont le
bêta-test avait été lancé l'année dernière.
Ici encore le drone
Tello est géré dans le simulateur avec un véritable terrain de test préchargé et report de l'altitude en temps réel, de quoi tester en toute sécurité !
- Code: Select all
from tello import *
tello.takeoff()
C) Tutoriels
3
è grande partie de la plateforme, nous arrivons aux tutoriels. Ils prennent la forme de vidéos avec toute une série de
playlists au choix, concernant l’utilisation des calculatrices
TI-83 Premium CE. Tu trouveras tout ce que tu veux de la prise en main jusqu’aux utilisations spécifiques à chaque partie du programme de Mathématiques :
- Prise en main de la TI-83 Premium CE
- Programmation en Python
- Suites et fonctions
- Algèbre et géométrie
- Statistiques
- Probabilités
Allons par exemple dans la
playlist Algèbre et géométrie regarder comment calculer avec les nombres complexes.
Et c’est ici que nous allons enfin commencer à parler de la formidable intégration qui fait la force de
MaClasseTI.fr.
En effet, à côté de chaque vidéo non orientée Python tu disposes d’un bouton te permettant de faire appel à l’émulateur de
TI-83 Premium CE. Tu peux alors tenter de reproduire en direct les manipulations, ce sont de véritables tuto-vidéos interactifs qui te sont ainsi proposés !
Il est juste dommage qu’à ce jour cette possibilité ne concerne pas les vidéos ciblant le
Python, l’émulateur étant en effet dépourvu de ces fonctionnalités comme nous avons vu.
Mais ce n’est pas tout. Chaque vidéo est également accompagnée d’un support téléchargeable, une trace écrite complètement repensée au format
.pdf !
De plus, pour te permettre de t’auto-évaluer certaines vidéos seront accompagnées d’un
QCM auto-correctif, avec des corrections d’excellente facture qui, bien loin de se contenter de te donner la réponse, te détailleront l’intégralité de la démarche !
D) Classe
La plateforme dispose donc également d’un module de gestion de classe. L’utilisation de cette partie nécessite une inscription mais reste elle aussi intégralement gratuite, aussi bien pour les élèves que les enseignants.
Tu peux donc t’y inscrire en tant qu’enseignant et rajouter tes élèves pour reconstituer tes classes ou groupes. Une intégration directement dans l’
ENT de l’établissement est également possible via le
service GAR, protégeant les données personnelles.
À partir de là c’est très simple, nous avons 3 onglets :
- Mes activités
- Mes classes
- Profil
Dans
Mes activités tu peux donc créer tes activités.
Tu peux le faire de deux façons, la première étant de partir d’une activité vide.
Il te faut alors choisir le type d’activité :
- Calculatrice
- Editeur Python
- Glisser-déposer
- Réponse libre
- Texte à trous
- QCM
- Exercice avec consigne
Calculatrice permet de créer une activité ciblant l’utilisation de la
TI-83 Premium CE (hors Python). Elle reprend l’émulateur couvert ci-dessus, en lui rajoutant une spécificité notable dans le cadre de l’usage en classe : la possibilité de bloquer l’utilisation de certaines touches, orientant donc la recherche des élèves dans le sens que tu souhaites.
De façon similaire,
Éditeur Python cible le codage en
Python pour
TI-83 Premium CE Edition Python et reprend le module exploré plus haut.
Passons maintenant au reste. Certaines de ces autres formes d’activités ont l’avantage de te permettre de bénéficier d’une correction automatisée
(notamment QCM, glisser-déposer, texte à trous, etc.).
Précisons que les émulateur et éditeur
Python sont parfaitement intégrables sur toutes les autres formes d’activités, c’est juste le statut de leur utilisation qui change, passant d’objet d’étude à outil d’étude.
Pour chacun de ces autres types d’activité tu peux donc choisir d’inclure ou pas l’émulateur
TI-83 Premium CE, et ici aussi d’en désactiver les touches de ton choix.
Nombres de choses sont intégrables à l’énoncé de ton activité :
- expressions à saisir en LaTeX
- images
- liens
- documents PDF
- éditeur Python
- vidéos youtube / peertube / vimeo
- documents bureautiques Google Docs (texte, tableur, …)
- illustrations des touches TI-83 Premium CE
- illustrations des écrans usuels TI-83 Premium CE à sélectionner dans une banque
L’autre façon de te créer une activité, c’est de partir de consulter celles disponibles dans la banque, alimentée par les enseignants du
réseau T3.
Tu pourras alors les importer dans ton compte puis les modifier librement.
Une fois que tu auras plusieurs activités, tu pourras, si tu le souhaites, les organiser en parcours
(activité 1, 2, etc.).
Maintenant que tu as tes activités, il te faut des classes et des élèves.
Une fois ceci-fait tu pourras leur attribuer des activités ou parcours d’activités, de façon individuelle ou collective, avec une date de remise, et activer la possibilité ou pas de rendre plusieurs fois l’activité
(c’est-à-dire effectuer plusieurs tentatives, la dernière remplaçant les précédentes).
L’onglet
Profil t’indique les corrections que tu as à faire, c’est-à-dire les activités ne bénéficiant pas d’une correction automatisée. Dans ce cas, tu pourras entre autres rejouer les éventuelles manipulations effectuées par l’élève sur l’émulateur, histoire de mieux pouvoir comprendre sa démarche ou ses éventuelles erreurs.
Tu peux même y passer en mode élève, histoire de vérifier si les différentes activités ainsi que leur contenu apparaissent correctement, et les résoudre avec l’élève de test
”demo_student” attribué à chaque classe :
Tu vois alors apparaître en temps réel la remise et la réussite des activités par les élèves de ta classe, et te vois alors offert la possibilité de leur rendre en rajoutant une appréciation à personnaliser !
Précisons qu’avec ce module de gestion de classe nous avons affaire à
OpenSTEAM-LMS, encore une fois une solution
open-source, et développée par Vittascience.E) Conclusion
La réforme du lycée et du Baccalauréat avait hélas complètement bouleversé l’utilisation de la calculatrice au lycée en entraînant, faute d’anticipation et de solutions, de nouveaux usages fort regrettables n’allant pas dans l’intérêt des élèves et de leur réussite :
- usages non optimaux en poursuivant avec les élèves l’utilisation de la Casio fx-92+ Spéciale Collège héritée du Collège
- usages néfastes en exerçant les élèves sur ordinateur/tablette/smartphone avec des applications ou plateformes, alors que ces outils ne sont pas autorisés aux épreuves terminales écrites et que les élèves en seront donc brutalement privés
Aujourd’hui fini de souffrir, fini les dilemmes et choix douloureux.
Texas Instruments accompagné de la formidable expertise de
VittaScience,
start-up française talentueuse deux fois
lauréate du prix Edu-up, te sort une plateforme en ligne conçue sur-mesures dans le cadre de la réforme du lycée et du Baccalauréat.
MaClasseTI.fr est une plateforme entièrement gratuite et comme nous avons pu le voir le long de cette présentation utilisant et interconnectant une majorité de modules
opensource !
Rappelons la disponibilité d’émulateurs
TI-83 Premium CE Edition Python, désormais utilisables gratuitement par tout-le-monde sans inscription, du jamais vu dans toute l’histoire de
Texas Instruments !
MaClasseTI.fr te permet ainsi de commencer à faire prendre en main les
TI-82 Advanced Edition Python et
TI-83 Premium CE à tes élèves, dès le premier jour de leur arrivée en Seconde !
Plus besoin de s’embêter à insister pour que les élèves s’équipent ; aucune urgence, ils pourront le faire plus tard lorsqu’ils seront sûrs de conserver une spécialité scientifique jusqu’au Baccalauréat, pendant l’année de Première ou même au début de l’année de Terminale !
C’est un pari extrêmement audacieux et généreux de
Texas Instruments que nous ne pouvons que saluer !
Encore quelques petits défauts pour ce lancement comme nous avons vu, mais ils sont bien mineurs devant l’étendue titanesque de ce projet ; nous les avons tous signalés et vu l’énergie phénoménale mobilisée là-dessus nous avons espoir qu’ils seront corrigés rapidement.
Le niveau colossal d’intégration des différentes briques de la plateforme est absolument remarquable :
- émulateur TI-83 Premium CE appelable depuis les tuto-vidéos
- émulateur TI-83 Premium CE intégrable aux activités de classe
- simulateur TI-83 Premium CE Edition Python intégrable aux activités classe
- vidéo et expressions LaTeX intégrables aux activités de classe
- périphériquesSTEM intégrables au simulateur TI-83 Premium CE Edition Python
- environnements virtuel de test 2D et 3D pour les TI-Innovator Rover et drone Tello
- ...
La possibilité de développer et tester ses projets
STEM sans avoir à s’embêter à mobiliser le matériel en quantité suffisante à chaque séance concernée est également géniale, un confort formidable pour l’enseignant !
Rappelons les bibliothèques de projets
Python et activités librement utilisables et même modifiables, permettant à la fois de gagner du temps et combler les débutants !
Mais qu’attends-tu pour venir
mettre la main à la pâte et concevoir des projets et activités géniales qui combleront tes élèves tout en les amenant à un usage optimal de leur calculatrice le jour de l’épreuve terminale, les conduisant ainsi à la réussite ?
by 
; et pour des distros Linux via OBS : 
