π
<-
Chat plein-écran
[^]

Exploration module Python ti_rover TI-83 Premium CE 5.5

:32ti73: :32ti73e: :32ti73e2: :32ti76f: :32ti80: :32ti81: :32ti82: :32ti85: :32ti86: :32ti82s: :32ti82sf: :32ti82sfn: :32ti83: :32ti83p: :32ti83pb: :32ti83pr: :32ti83pfr: :32ti83pse: :32ti84p: :32ti84pse: :32ti84ppse: :32ti84pfr: :32ti84pcse: :32ti83pfrusb: :32ti82p: :32ti82a: :32ti84pce: :32ti83pce:

Exploration module Python ti_rover TI-83 Premium CE 5.5

Message non lude critor » 20 Mai 2020, 01:33

12382Dans 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 :




1) menus ti_rover et langage

Go to top

9049Dans 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 1er 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 ! :o

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 ! :bj:

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: Tout sélectionner
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: Tout sélectionner
# 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 ! :bj:
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: Tout sélectionner
# 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: Tout sélectionner
# 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 ! :bj:




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: Tout sélectionner
#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 :
Casio Graph
35+E II
90+E
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écifiquecasioplot:6-28prime:3-368ion:48-162
kandinsky:8-30
ti_graphics:30-75
ti_hub:?
ti_plotlib:49-84
ti_system:12-34
ti_rover:66-92
Modules491113
Eléments123-302219-6042267-701315-772

Classement en terme de richesse :
  1. 315-772 éléments : TI-83 Premium CE Edition Python
  2. 267-701 éléments : NumWorks
  3. 219-6042 éléments : HP Prime (version alpha)
  4. 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
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écifiquecasioplot:6-28
matplotl:25-68
nsp:3-10board:22
storage:7-47
Modules698913
Eléments217-496203-608176-509158-488238-692

Classement en terme de richesse :
  1. 315-772 éléments : TI-83 Premium CE Edition Python
  2. 267-701 éléments : NumWorks
  3. 238-692 éléments : TI-83 Premium CE + TI-Python (firmware tiers)
  4. 219-6042 éléments : HP Prime (version alpha)
  5. 217-496 éléments : Casio Graph 90+E / 35+E II / fx-CG50 / fx-9750/9860GIII
  6. 203-608 éléments : Casio Graph 75/85/95 / 35+E/USB / 35+E II / fx-9750GII/GIII / fx-9860G/GII/GIII (appli CasioPython)
  7. 176-509 éléments : TI-Nspire (appli MicroPython)
  8. 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 ! :D




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 ! :bj:

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 ! :D

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 :
Image
Avatar de l’utilisateur
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Prochain niv.: 41.8%
 
Messages: 41465
Images: 14479
Inscription: 25 Oct 2008, 00:00
Localisation: Montpellier
Genre: Homme
Calculatrice(s):
MyCalcs profile
YouTube: critor3000
Twitter/X: critor2000
GitHub: critor

Re: Exploration module Python ti_rover TI-83 Premium CE 5.5

Message non lude Fabien59 » 26 Aoû 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
Avatar de l’utilisateur
Fabien59
Niveau 7: EP (Espèce Protégée: geek)
Niveau 7: EP (Espèce Protégée: geek)
Prochain niv.: 14.1%
 
Messages: 51
Inscription: 16 Juil 2020, 21:34
Genre: Non spécifié
Calculatrice(s):
MyCalcs profile


Retourner vers News TI-z80 (TI-73, 76, 80, 81, 82, 83, 84, 85, 86)

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 65 invités

-
Rechercher
-
Social TI-Planet
-
Sujets à la une
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Aidez la communauté à documenter les révisions matérielles en listant vos calculatrices graphiques !
Phi NumWorks jailbreak
123
-
Faire un don / Premium
Pour plus de concours, de lots, de tests, nous aider à payer le serveur et les domaines...
Faire un don
Découvrez les avantages d'un compte donateur !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partenaires et pub
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
974 utilisateurs:
>960 invités
>9 membres
>5 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)
-
Autres sites intéressants
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)