Forum TI-Planet.org

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.

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.

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

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

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 :