π
<-
Chat plein-écran
[^]

Découverte ce_turtl 83 Premium CE 5.5 + tests compatibilité

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

Découverte ce_turtl 83 Premium CE 5.5 + tests compatibilité

Unread postby critor » 18 May 2020, 20:26

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
  • , avec diverses possibilités :
    • détection des simples pressions de touches clavier
      (sans validation donc)
      par l'utilisateur, avec même l'éventuel modificateur actif
      (
      2nde
      ou
      alpha
      )
      , et ça marche aussi avec un clavier
      USB
      !
    • affichage dans la console à la ligne que tu veux
    • exportation de listes de nombres
      (entiers, flottants ou complexes)
      existant dans le contexte
      Python
      vers l'environnement de la calculatrice, pour traitement à l'aide d'autres applications
    • importation depuis le contexte
      Python
      de listes ou équation de régression existant dans l'environnement de la calculatrice
    • et donc plus généralement un début d'intégration du
      Python
      à l'environnement mathématique de la calculatrice, enfin l'application
      Python
      va pouvoir servir non plus seulement à coder un truc déconnecté dans un coin, mais à traiter des problèmes et tâches complexes dans leur globalité !
  • , 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
  • 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_rover
    , pour les projets de robotique à l'aide du
Mais ce n'est pas tout car
Python 5.5
gère également la possibilité inédite de rajouter des modules
Python
complémentaires :
  • , comparable à
    turtle
  • pour les diagrammes en boîte
  • pour les histogrammes et aires entre courbes
  • pour les diagrammes utilisant des champs de vecteurs

Aujourd'hui nous poursuivons notre exploration du module complémentaire
ce_turtl
, donc voici enfin ci-dessous le détail des menus :

Comme tu peux le voir, nous disposons à priori de tout ce qu'il faut pour une faire aussi bien qu'avec le module
turtle
standard.

Le module
ce_turtl
semble comporter lui-même un sous-module
turtle
.

Une même script pourrait même tourner a priori aussi bien avec
ce_turtl
que le
turtle
standard sur ordinateur, à condition de tenir compte de tout cela à l'importation. Nous pouvons faire au choix :
Code: Select all
try: from ce_turtl.turtle import *
except ImportError: from turtle import *

Code: Select all
try: from ce_turtl import *
except ImportError: import turtle

Notons que la saisie via les menus
ce_turtl
préfixe toutes les commandes d'un turtle. et n'est donc adaptée qu'à ce dernier point.

Nous allons donc maintenant tester la compatibilité de
ce_turtl
avec les solutions concurrentes, ainsi que sa conformité au standard
turtle
.
Précisons que nous ne disposons pas à ce jour du fichier permettant de rajouter
ce_turtl
à la calculatrice, et sommes donc limités aux exemples fournis par
Texas Instruments
.


Pour cela nous allons commencer doucement en y allant fonction par fonction, avant d'aborder des exemples plus poussés.

Démarrons donc avec un tracé de polygone tout simple:
Code: Select all
try: from ce_turtl import *
except ImportError: import turtle

def polyg(l,n):
  for i in range(n):
    turtle.forward(l)
    turtle.left(360/n)

polyg(100,4)

Ainsi que tu peux voir, comme avec
ti_plotlib
et
ti_graphics
, les tracés
ce_turtl
sont effectués directement sur l'écran d'affichage de la console
Python
.

D'où la nécessité de commencer par effacer l'écran avec ici non pas le
turtle.clearscreen()
standard, mais
turtle.clear()
.

De plus, comme les affichages sortent sur la console, ils sont nettoyés et perdus dès que ton script rend la main. Il faut donc insérer une boucle d'attente en fin de script, ici fournie par l'appel non standard
turtle.show()
. Contrairement à ce que son nom indique, cette fonction n'affiche rien par elle-même et ne fait qu'attendre l'appui sur une touche d'interruption par l'utilisateur. Elle est donc équivalente aux appels
ti_plotlib.show_plot()
et
ti_system.disp_wait()
, ainsi qu'au code suivante :
Code: Select all
while not ti_system.escape():
  pass

Graph
35+E II
Graph
90+E
TI-83 Premium CE
Edition Python
Num
Works
ordi
Code: Select all
try:
  from ce_turtl import *
  turtle.clear()
except ImportError: import turtle

def polyg(l,n):
  for i in range(n):
    turtle.forward(l)
    turtle.left(360/n)

polyg(100,4)
try: turtle.show()
except: pass

Mettons maintenant de la couleur, par exemple du bleu. Et voici les ennuis de compatibilité arriver.

Déjà, les différentes plateformes n'utilisent même pas les mêmes systèmes de coordonnées pour les composantes RVB de couleurs :
  • nombre flottant de 0.0 à 1.0 sur
    Casio
    et ordinateur
  • nombre entier de 0 à 255 sur
    NumWorks
    et
    TI-83 Premium CE Edition Python
De plus, le standard
turtle
offre deux fonctions pour régler la couleur :
  • turtle.pencolor()
    qui contrôle la couleur du stylo, ici absente sur
    TI-83 Premium CE Edition Python
  • turtle.color()
    qui règle à la fois la couleur du stylo et du pinceau
    (remplissage)
    , absente cette fois-ci chez
    Casio
On pourrait penser régler proprement et définitivement ce dernier problème de compatibilité dès l'importation pour n'avoir plus rien à faire par la suite, en rajoutant la fonction manquante. Si l'on importe directement le contenu de
turtle
, on peut faire :
Code: Select all
try:
  from ce_turtl.turtle import *
  pencolor = color
except ImportError:
  from turtle import *
  try:
    color
  except:
    color = pencolor

Mais traitons maintenant du cas d'importation adapté à la saisie via les menus; on pourrait faire :
Code: Select all
try:
  from ce_turtl import *
  ce_turtl.pencolor = ce_turtl.color
except ImportError:
  import turtle
  try:
    turtle.color
  except:
    turtle.color = turtle.pencolor

Ce dernier code marche parfaitement sur
Casio
et sur ordi
(standard)
, mais hélas pas sur
NumWorks
qui refuse à la différence que l'on rajoute après importation une fonction à un module. :'(
Tant pis, le code de compatibilité sera donc moins propre en attendant que l'on trouve mieux.

Nous réglerons de plus l'épaisseur de crayon à 1.
Graph
35+E II
Graph
90+E
TI-83 Premium CE
Edition Python
Num
Works
ordi
Code: Select all
try:
  from ce_turtl import *
  turtle.clear()
except ImportError: import turtle

def my_turtle_pencolor(t):
  cmax = 255
  try:
    turtle.pencolor((0,0,0))
    fc = turtle.pencolor
  except:
    fc = turtle.color
  try: fc((2,2,2))
  except: cmax = 1
  if(cmax == 1 and max(t)>1):
    t = tuple(u/255 for u in t)
  elif(cmax == 255 and any(isinstance(u, float) for u in t)):
    t=tuple(int(255*u) for u in t)
  fc(t)

def polyg(l,n):
  for i in range(n):
    turtle.forward(l)
    turtle.left(360/n)

turtle.pensize(1)
my_turtle_pencolor((0,0,255))
polyg(100,4)
try: turtle.show()
except: pass

Autre divergence ici sur
TI-83 Premium CE Edition Python
, où le turtle.pensize(1) produit des traits de plus d'1 pixel d'épaisseur contrairement à toutes les autres plateformes.

Tentons maintenant de commencer le tracé ailleurs :
Graph
35+E II
Graph
90+E
TI-83 Premium CE
Edition Python
Num
Works
ordi
Code: Select all
try:
  from ce_turtl import *
  turtle.clear()
except ImportError: import turtle

def my_turtle_pencolor(t):
  cmax = 255
  try:
    turtle.pencolor((0,0,0))
    fc = turtle.pencolor
  except:
    fc = turtle.color
  try: fc((2,2,2))
  except: cmax = 1
  if(cmax == 1 and max(t)>1):
    t = tuple(u/255 for u in t)
  elif(cmax == 255 and any(isinstance(u, float) for u in t)):
    t=tuple(int(255*u) for u in t)
  fc(t)

def polyg(l,n):
  for i in range(n):
    turtle.forward(l)
    turtle.left(360/n)

turtle.pensize(1)
my_turtle_pencolor((0,0,255))
turtle.goto(-70,-70)
polyg(100,4)
try: turtle.show()
except: pass

Recommençons maintenant en levant le stylo afin d'éviter le tracé parasite au départ :
Graph
35+E II
Graph
90+E
TI-83 Premium CE
Edition Python
Num
Works
ordi
Code: Select all
try:
  from ce_turtl import *
  turtle.clear()
except ImportError: import turtle

def my_turtle_pencolor(t):
  cmax = 255
  try:
    turtle.pencolor((0,0,0))
    fc = turtle.pencolor
  except:
    fc = turtle.color
  try: fc((2,2,2))
  except: cmax = 1
  if(cmax == 1 and max(t)>1):
    t = tuple(u/255 for u in t)
  elif(cmax == 255 and any(isinstance(u, float) for u in t)):
    t=tuple(int(255*u) for u in t)
  fc(t)

def polyg(l,n):
  for i in range(n):
    turtle.forward(l)
    turtle.left(360/n)

turtle.penup()
turtle.pensize(1)
my_turtle_pencolor((0,0,255))
turtle.goto(-70,-70)
turtle.pendown()
polyg(100,4)
try: turtle.show()
except: pass

Passons maintenant à un hexagone :
Graph
35+E II
Graph
90+E
TI-83 Premium CE
Edition Python
Num
Works
ordi
Code: Select all
try:
  from ce_turtl import *
  turtle.clear()
except ImportError: import turtle

def my_turtle_pencolor(t):
  cmax = 255
  try:
    turtle.pencolor((0,0,0))
    fc = turtle.pencolor
  except:
    fc = turtle.color
  try: fc((2,2,2))
  except: cmax = 1
  if(cmax == 1 and max(t)>1):
    t = tuple(u/255 for u in t)
  elif(cmax == 255 and any(isinstance(u, float) for u in t)):
    t=tuple(int(255*u) for u in t)
  fc(t)

def polyg(l,n):
  for i in range(n):
    turtle.forward(l)
    turtle.left(360/n)

turtle.penup()
turtle.pensize(1)
my_turtle_pencolor((0,0,255))
turtle.goto(-70,-70)
turtle.pendown()
polyg(100,6)
try: turtle.show()
except: pass

Voici maintenant les
flocons de Koch
:
Graph
35+E II
Graph
90+E
TI-83 Premium CE
Edition Python
Num
Works
ordi
Code: Select all
try:
  from ce_turtl import *
  turtle.clear()
except ImportError: import turtle

def my_turtle_pencolor(t):
  cmax = 255
  try:
    turtle.pencolor((0,0,0))
    fc = turtle.pencolor
  except:
    fc = turtle.color
  try: fc((2,2,2))
  except: cmax = 1
  if(cmax == 1 and max(t)>1):
    t = tuple(u/255 for u in t)
  elif(cmax == 255 and any(isinstance(u, float) for u in t)):
    t=tuple(int(255*u) for u in t)
  fc(t)
 
def koch(n, l):
  if n<=0:
    turtle.forward(l)
  else:
    koch(n-1, l/3)
    turtle.left(60)
    koch(n-1, l/3)
    turtle.right(120)
    koch(n-1, l/3)
    turtle.left(60)
    koch(n-1, l/3)

def flock(n, l):
  koch(n, l)
  turtle.right(120)
  koch(n, l)
  turtle.right(120)
  koch(n, l)

l=80

turtle.penup()
turtle.goto(105,3)
turtle.left(120)
turtle.pendown()
my_turtle_pencolor((0, 0, 0))
flock(3, l)
turtle.left(120)

turtle.penup()
turtle.goto(105,-10)
turtle.right(60)
turtle.pendown()
my_turtle_pencolor((255, 127, 0))
flock(4, l)
turtle.right(60)

turtle.pensize(1)

turtle.penup()
turtle.goto(5,45)
turtle.right(60)
turtle.pendown()
my_turtle_pencolor((0, 0, 255))
flock(2, l)
turtle.right(60)

turtle.penup()
turtle.goto(-100,17)
turtle.left(120)
turtle.pendown()
my_turtle_pencolor((255, 0, 0))
flock(0, l)
turtle.left(120)

turtle.pensize(2)

turtle.penup()
turtle.goto(-100,-5)
turtle.right(60)
turtle.pendown()
my_turtle_pencolor((0, 255, 0))
flock(1, l)
turtle.right(60)

turtle.penup()
turtle.forward(400)
try: turtle.show()
except: pass

Evidemment, le code utilisant les paramètres
turtle.pensize()
non standard de la
TI-83 Premium CE Edition Python
, il ne produit pas le même effet sur la concurrence.
Notons toutefois en passant que les réglages
turtle.pensize()
semblent totalement ignorés chez
Casio
.

Et maintenant les
triangles de Sierpiński
:
Graph
35+E II
Graph
90+E
TI-83 Premium CE
Edition Python
Num
Works
ordi
Code: Select all
try:
  from ce_turtl import *
  turtle.clear()
except ImportError: import turtle

def my_turtle_pencolor(t):
  cmax = 255
  try:
    turtle.pencolor((0,0,0))
    fc = turtle.pencolor
  except:
    fc = turtle.color
  try: fc((2,2,2))
  except: cmax = 1
  if(cmax == 1 and max(t)>1):
    t = tuple(u/255 for u in t)
  elif(cmax == 255 and any(isinstance(u, float) for u in t)):
    t=tuple(int(255*u) for u in t)
  fc(t)

def sierp(n, l):
    if n == 0:
        for i in range (0, 3):
            turtle.fd(l)
            turtle.left(120)
    if n > 0:
        sierp(n-1, l/2)
        turtle.fd(l/2)
        sierp(n-1, l/2)
        turtle.bk(l/2)
        turtle.left(60)
        turtle.fd(l/2)
        turtle.right(60)
        sierp(n-1, l/2)
        turtle.left(60)
        turtle.bk(l/2)
        turtle.right(60)

turtle.penup()
turtle.backward(109)
turtle.left(90)
turtle.backward(100)
turtle.right(90)
turtle.pendown()
my_turtle_pencolor((255, 0, 0))
sierp(6, 217)
turtle.penup()
turtle.forward(400)
try: turtle.show()
except: pass

Bien que non parfaite, les bibliothèques
turtle
de
Casio
et
NumWorks
jouissaient d'une très bonne conformité au standard, ce qui permettait quasiment sans aucune modification d'utiliser les mêmes scripts
turtle
sur ces modèles différents.

Ici avec
ce_turtle
sur
TI-83 Premium CE Edition Python
la compatibilité semble nettement inférieure, et le nombre à gérer de cas particuliers connus à ce jour suffisamment important. A priori une bibliothèque compatibilité
turtle
va donc malgré tout être nécessaire si l'on souhaite que les scripts
turtle
standard qui tournent déjà sur
Casio
/
NumWorks
puissent également fonctionner sur
TI-83 Premium CE Edition Python
, et inversement.

Tuto-vidéo
:
utilisation du module complémentaire
ce_turtl
Image
User avatar
critorAdmin
Niveau 19: CU (Créateur Universel)
Niveau 19: CU (Créateur Universel)
Level up: 6%
 
Posts: 35498
Images: 9483
Joined: 25 Oct 2008, 00:00
Location: Montpellier
Gender: Male
Calculator(s):
Class: Lycée
YouTube: critor3000
Twitter: critor2000
Facebook: critor.ti

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

Who is online

Users browsing this forum: No registered users and 23 guests

-
Search
-
Featured topics
L'OS 5.5 de la TI-83 Premium CE / 84 Plus CE supprime l'assembleur - la plupart des jeux et certains programme ne fonctionneront plus
Omega, le fork étendant les capacités de ta NumWorks, même en mode examen !
Découvre les nouvelles fonctionnalités en Python de l'OS 5.5 pour la 83PCE/84+C-T Python Edition
Comparaisons des meilleurs prix pour acheter sa calculatrice !
1234
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...

Discover the the advantages of a donor account !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partner and ad
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
630 utilisateurs:
>623 invités
>2 membres
>5 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)
-
Other interesting websites
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)