Forum TI-Planet.org

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.

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 !

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, maclasseti.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

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 !

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.

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.

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

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 touches
• ti_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…

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.

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 !

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 :

• ti_draw
• ti_image

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 ?...

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.

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 !

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)

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()

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 !

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 T³.

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.