Exploration module Python ti_rover TI-83 Premium CE 5.5

→ **MyCalcs** profile · by **critor** » 20 May 2020, 01:33

Dans sa prochaine mise à jour 5.5 gratuite prévue pour Mai 2020, Texas Instruments va rajouter de formidables possibilités historiques à ta TI-83 Premium CE :

mise à jour en 5.5 de l'application SciTools
mise à jour en 5.5 de l'application Periodic
mise à jour en 5.5 de l'application Python (TI-83 Premium CE Édition Python uniquement)

Python 5.5 offre de nouveaux modules intégrés pour tes scripts Python :

time, certes déjà présent mais maintenant listé au menu et donc officiel
ti_system, avec diverses possibilités :
- détection des simples pressions de touches clavier, y compris avec un clavier USB externe !
- affichage dans la console à la ligne que tu veux
- exportation de listes de nombres du contexte Python vers l'environnement de la calculatrice
- importation dans le contexte Python de listes existant dans l'environnement de la calculatrice vers
- et donc plus généralement un début d'intégration du Python à l'environnement mathématique de la calculatrice; plus besoin de traiter les tâches numériques à part, l'application Python 5.5 va enfin pouvoir servir s'articulier naturellement au sein de la résolution de problèmes et tâches complexes !
ti_plotlib, une bibliothèque graphique pour tracer dans un repère othogonal, conformément aux programmes de Mathématiques et Physique-Chimie, comparable à matplotl chez Casio ou encore matplotlib.pyplot, et gérant ici les diagrammes suivants :
- nuage de points
- diagramme en ligne brisée
- droite de régression linéaire
ti_graphics pour contrôler directement les pixels de l'écran, comparable à kandinsky chez NumWorks ou encore casioplot
ti_hub, pour les projets d'objects connectés à l'aide de l'interface TI-Innovator Hub
ti_rover, pour les projets de robotique à l'aide du TI-Innovator Rover

Mais ce n'est pas tout car Python 5.5 gère également la possibilité inédite de rajouter des modules Python complémentaires :

ce_turtl, comparable à turtle
ce_box pour les diagrammes en boîte
ce_chart pour les histogrammes et aires entre courbes
ce_quivr pour les diagrammes utilisant des champs de vecteurs

Nous nous proposons aujourd'hui d'explorer le module de robotique ti_rover.

Sommaire :

menus ti_rover et langage
importation et taille ti_rover
ti_rover et projets
exploration ti_rover
conclusion

1) menus ti_rover et langage

Go to top

Dans le langage historique TI-Basic, les fonctions relatives au robot TI-Innovator Rover étaient extrêmement limitées :

send() pour envoyer une commande au robot
et get() pour récupérer un éventuel retour d'information

En effet, le TI-Innovator Rover disposait de son propre langage de script, utilisé donc en paramètre de la fonction send().

Une difficulté pour aborder des projets en classe était donc la nécessité pour les élèves de connaître et utiliser simulatnément deux langages :

le langage historique TI-Basic de la TI-83 Premium CE
le langage de script du TI-Innovator Rover

Et bien dès l'arrivée dans le 1^er onglet de menus du module ti_rover, on se rend compte que Texas Instruments a entièrement repensé son langage TI-Rover dans l'esprit du langage Python !

Finis les send() et get() qui devaient être pensés différemment, nous disposons ici directement de fonctions Python pour chaque action du TI-Innovator Rover !

L'onglet Commandes nous met également à portée de main quelques éléments bien pratiques du module ti_system.

L'ongler Réglages comporte de quoi saisir rapidement les unités à fournir en paramètres de divers commandes.

Le TI-Innovator Rover est bien plus qu'une voiture, il a tout ce qu'il faut pour devenir une voiture intelligente si tu codes bien.

Il dispose d'une part en entrée de plusieurs capteurs dont on découvre ici les fonctions d'accès dans l'onglet E/S :

sonar frontal
détecteur de couleur sur sa face inférieure

En sortie il dispose également d'une diode RVB dont on trouve ici encore les fonctions d'accès.

Tu peux même si tu le souhaites directement contrôler ses deux moteurs latéraux de façon indépendante, et en régler la vitesse.

Mais ce n'est pas tout, le TI-Innovator Rover est bardé de capteurs internes (gyroscope entre autres) lui permettant dans certains cas de corriger lui-même sa trajectoire, et dont l'accès t'est également offert ici.

2) importation et taille ti_rover

Go to top

La commande d'importation mise en avant par les menus est donc import ti_rover as rv. Nulle obligation de la suivre, mais les menus supposent que c'est celle-ci qui est utilisée et préfixent automatiquement les différentes saisies d'un rv.. À défaut tes saisies via les menus devront être corrigées.

Rappelons que le tas (heap) Python a ici une capacité de 19,968 Ko, mais seulement entre 17 Ko et 17,5 Ko d'espace libre à vide.

Utilisons le script suivant pour déterminer la taille consommée sur le tas (heap) Python par l'importation du ti_rover :

Code: Select all: from gc import mem_free as mf smod = input('Module : ') mf1, mf2 = 0, 0 scmd = 'from ' + s + ' import *' mf1 = mf() exec(scmd) mf2 = mf() print(mf1 - mf2)

4,848 Ko de consommés donc sur nos 17 Ko et quelques, ce n'est pas négligeable, c'est quand même déjà plus du quart alors que nous n'avons encore rien codé.

3) ti_rover et projets

Go to top

Avant de creuser plus profondément, abordons quelques exemples de projets pour te montrer comme il est maintenant simple de coder en Python de grandes choses pour le TI-Innovator Rover.

Commençons avec un petit tracé de polygone régulier.

Code: Select all: # TI-Rover from time import * from ti_system import * import ti_rover as rv import ti_plotlib as plt def polygone(l,c): plt.cls() plt.axes("on") plt.pen("medium", "solid") plt.color(255, 0, 0) plt.grid(1, 1, "dot") plt.title("polygone regulier a " + str(c) + " cotes") x = 0 y = 0 b = 360 / c for i in range(c): rv.forward(l) rv.right(b) rv.wait_until_done() X = rv.waypoint_x() Y = rv.waypoint_y() plt.line(x, y, X, Y, "arrow") x = X y = Y plt.show_plot() rv.disconnect_rv()

L'appel polygone(2, 5) nous permet ici de tracer un pentagone régulier de 20 cm de côté.

De plus nous avons ici un tracé simultané sur l'écran de la calculatrice. Il ne s'agit pas d'un affichage du tracé théorique, mais bien d'un retour en temps réel sur le tracé effectivement réalisé par le robot, grâce à ses capteurs internes que l'on interroge ici !

D'ailleurs, si l'on s'amuse à embêter le robot dans ses déplacements de façon tellement insistante qu'il n'arrive plus à les corriger correctement, on note bien que le tracé obtenu sur écran est alors faux, et ton programme pourrait éventuellement en tenir compte.

Après ce petit amusement, on passe maintenant aux choses sérieuses avec le park assist.

Demandons donc au TI-Innovator Rover de parcourir une rue et de se garer en créneau dans la première place libre trouvée. Cela nécessite l'ajout d'un sonar latéral, ici à droite :

Code: Select all: # TI-Rover from time import * from ti_system import * import ti_rover as rv from ranger import * b = 0 a = ranger("IN 1") p = 0 while p == 0: rv.forward(50) while b<=0.2: b=a.measurement() print(b) rv.stop() rv.path_clear() rv.forward(50) while b>0.2: b = a.measurement() print(b) d = rv.waypoint_distance() print("d=", d) rv.stop() if d > 0.3: p = 1 rv.color_rgb(0, 255, 0) wait(1) rv.backward(0.5) wait(1) rv.left(45) wait(1) rv.backward(2) wait(1) rv.right(45) wait(1) rv.forward(0.5) wait(1) rv.disconnect_rv()

Et passons maintenant à la voiture autonome, celle qui sauve des vies en freinant toute seule devant les piétons :

Code: Select all: # TI-Rover from time import * from ti_system import * import ti_rover as rv def voiture(): disp_clr() disp_at(8, "appuyer sur annul ou arreter", "left") rv.forward(6) rv.left(90) rv.forward(1) while not escape(): a = rv.ranger_measurement() if a < 0.2: rv.color_rgb(255, 0, 0) rv.stop() else: rv.color_off() rv.resume()

Décidément pas besoin d'attendre, avec le TI-Innovator Rover ta future voiture est déjà entre tes mains !

4) exploration ti_rover

Go to top

Enfin, terminons par une exploration intégrale du contenu du module ti_rover, à l'aide du script suivant :

Code: Select all: #platforms: #0: MicroPython / TI-Nspire #1: MicroPython / NumWorks #2: MicroPython / G90+E / G35+E II #3: MicroPython / G35+E/USB / G75/85/95 #4: CircuitPython / TI-Python / 83PCE / Trinket M0 #5: Xcas / HP Prime #6: KhiCAS / Graph 90+E def getplatform(): id=-1 try: import sys try: if sys.platform=='nspire':id=0 if sys.platform.startswith('TI-Python') or sys.platform=='Atmel SAMD21':id=4 except:id=3 except: try: import kandinsky id=1 except: try: if chr(256)==chr(0):id=5+(not ("HP" in version())) except: id=2 return id platform=getplatform() #lines shown on screen #plines=[29,12, 7, 9,11,0,0] plines=[29,16, 7, 9,11,0,0] #max chars per line #(error or CR if exceeded) pcols =[53,99,509,32,32,0,0] unsafe = ((), (), (), ('sys.argv', 'sys.path'), (), (), ()) if platform>=0: curline=0 _p = print nlines=plines[platform] ncols=pcols[platform] def print(*ls): global curline st="" for s in ls: if not(isinstance(s,str)): s=str(s) st=st+s stlines=1+int(len(st)/ncols) if curline+stlines>=nlines: input("Input to continue:") curline=0 _p(st) curline+=stlines def sstr(obj): try: s=obj.__name__ except: s=str(obj) a=s.find("'") b=s.rfind("'") if a>=0 and b!=a: s=s[a+1:b] return s def isExplorable(obj): for k in done: try: if isinstance(obj, eval(k)): t, done[k] = done[k], True return not t except: pass if str(obj).startswith("<module"): return False l = () try: l = dir(obj) except: pass return len(l) done = {'str':False, 'list':False, 'tuple':False, 'dict':False, 'complex':False, 'set':False, 'frozenset': False} def explmod(pitm, pitmsl=[], reset=True): global curline spitm=sstr(pitm) if(reset): curline=0 pitmsl=[spitm] for k in done: done[k] = False hd="."*(len(pitmsl)-1) c,c2=0,0 l = sorted(dir(pitm)) for i in range(len(l)): l[i] = (l[i], getattr(pitm, l[i])) try: if not isinstanceof(pitm, str): for i in range(len(pitm)): l.append((spitm+'['+str(i)+']',pitm[i])) except: pass for itm in l: c,c2=c+1,c2+1 isUnsafe = platform >= 0 and '.'.join(pitmsl + [itm[0]]) in unsafe[platform] try: if isUnsafe: raise Exception print(hd+itm[0]+"="+str(itm[1])) except: print(hd+itm[0]) if not isUnsafe and isExplorable(itm) and itm[1] != pitm and itm[0] not in pitmsl: pitmsl2=pitmsl.copy() pitmsl2.append(itm[0]) c2=c2+explmod(itm[1], pitmsl2, False)[1] if c>0 and reset: print(hd+"Total: "+str(c)+" 1st level item(s)") if c2>0 and c2!=c: print(hd+" "+str(c2)+" item(s)") return [c,c2]

Le module ti_rover offre donc 66 éléments au premier niveau, et jusqu'à 92 en comptant les sous-éléments.

De quoi mettre à jour notre comparatif de la richesse des différentes solutions Python sur calculatrices :

aux examens
français hors
examens

	Casio Graph 35+E II 90+E	version alpha HP Prime	NumWorks	TI-83PCE Ed. Python
builtins array collections cmath gc math matplotlib matplotlib.pyplot micropython os random sys time turtle uerrno	84-197 . . . . 25-47 . . . . 8-30 . . . .	97-1581 3-363 . 13-428 9-404 42-602 . . 10-410 . . 17-977 . . 25-1277	89-211 . . 12-34 . 41-63 3-25 11-33 6-28 . 9-31 . 3-25 38-60 .	92-211 2-24 2-24 . 7-29 28-50 . . . . 8-30 15-93 4-26 . .
spécifique	casioplot:6-28	prime:3-368	ion:48-162 kandinsky:8-30	ti_graphics:30-75 ti_hub:? ti_plotlib:49-84 ti_system:12-34 ti_rover:66-92
Modules	4	9	11	13
Eléments	123-302	219-6042	267-701	315-772

Classement en terme de richesse :

315-772 éléments : TI-83 Premium CE Edition Python
267-701 éléments : NumWorks
219-6042 éléments : HP Prime (version alpha)
123-302 éléments : Casio Graph 90+E / 35+E II

	Casio Graph 35+E II 90+E	CasioPython Casio Graph 35+E II 35+E/USB 75/85/95	MicroPython TI-Nspire	TI-Python	firmware tiers TI-Python
builtins array collections cmath gc math matplotlib matplotlib.pyplot micropython os random sys time turtle uerrno	84-197 . . . . 25-47 . . . . 8-30 . . 69-126 .	91-230 2-28 . 12-38 7-33 41-67 . . 6-32 . 8-34 12-38 . . 24-108	93-218 2-28 . 12-38 7-33 41-67 . . 3-29 . . 15-86 . . .	92-212 2-24 2-24 . 7-29 28-50 . . . . 8-30 15-93 4-26 . .	93-214 2-25 2-25 12-35 7-30 41-64 . . 6-29 15-38 8-31 15-99 8-33 . .
spécifique	casioplot:6-28 matplotl:25-68		nsp:3-10		board:22 storage:7-47
Modules	6	9	8	9	13
Eléments	217-496	203-608	176-509	158-488	238-692

Classement en terme de richesse :

315-772 éléments : TI-83 Premium CE Edition Python
267-701 éléments : NumWorks
238-692 éléments : TI-83 Premium CE + TI-Python (firmware tiers)
219-6042 éléments : HP Prime (version alpha)
217-496 éléments : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
203-608 éléments : Casio Graph 75/85/95 / 35+E/USB / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
176-509 éléments : TI-Nspire (appli MicroPython)
158-488 éléments : TI-83 Premium CE + TI-Python

Mine de rien le ti_rover a su faire la différence, pour la richesse de sa solution Python la TI-83 Premium CE Edition Python est à compter de maintenant classée dans tous les cas première, et ce alors que nous n'en avons même pas encore exploré tous les modules !

5) conclusion

Go to top

ti_rover, Texas Instruments nous apporte une fois de plus le fruit d'un travail formidable pour la mise à jour 5.5.

S'appuyant cette fois-ci intégralement sur le seul langage Python, la bibliothèque robotique ti_rover est conforme aux programmes scolaires aussi bien dans l'esprit que dans la forme !

Comme les autres bibliothèques Python apportées par la mise à jour 5.5 de la TI-83 Premium CE Edition Python, la bibliothèque ti_rover est extrêmement bien fournie, si bien que comme tu l'as vu il ne te suffit que de quelques lignes pour construire facilement des projets extraordinaires !

Les élèves et enseignants de SNT en Seconde puis spécialité NSI ont franchement de la chance, ils vont pouvoir se régaler !

Envie de te faire ta propre opinion ?

Rendez-vous ce Mercredi 20 Mai de 18h30 à 20h pour une vidéoconférence de présentation des modules ti_hub et ti_rover, dans le cadre de l'enseignement SNT en Seconde.

Pour t'inscrire, c'est par ici.

Tuto-vidéos ti_rover :

→ **MyCalcs** profile · by **Fabien59** » 26 Aug 2022, 16:04

Bonjour,

Pensez-vous qu'il soit possible d'obtenir un mouvement rectiligne et accéléré du Rover ?

Les fonctions forward_time(time,speed,"rate") ou forward(distance,"unit",speed,"rate") permettent bien de choisir une vitesse constante (entre 0,14 et 0,23 m/s).
Des appels successifs de cette fonction, pour des vitesses croissantes, donnera bien un mouvement accéléré mais par à-coups, puisque le Rover s'arrêtera brièvement entre chaque instruction.

Merci
Fabien