[critor]

Quelle Calculatrice programmable Choisir 2020
(index des épisodes)

Episode 8 - Classification périodique des éléments

Outre pour répondre aux questions de cours de Seconde, la classification périodique des éléments est un formidable outil de référence salvateur dans nombre de situations une fois que l'on a compris la périodicité des propriétés chimiques. Un doute sur la formule du fluorure de béryllium ? Sur la charge de l'ion phosphore ? Un simple coup d’œil à la classification, une simple addition/soustraction selon la règle de l'octet, et ton problème sera résolu !

Nombre de calculatrices graphiques t'offrent une application de classification périodique des éléments chimiques, et nous avons quelques nouveautés à te présenter cette année.
Attention toutefois, l'application en question ne reste pas toujours disponible en mode examen, ça dépend du modèle, et nous te le préciserons à chaque fois.

Nous ignorons certes encore l'esprit de l'épreuve de Physique-Chimie du BAC 2021 faute de sujet zéro disponible, mais rappelons que l'épreuve en question avait nettement changé d'orientation à partir de 2013.
Jusqu'en 2012 il y avait pas mal de Mathématiques appliquées essentiellement de niveau Première ; il s'agissait d'évaluer des raisonnements calculatoires conséquents (dérivation, primitives, coordonnées, vecteurs...) et où le sujet fournissait donc l'ensemble des données nécessaires afin que tous les candidats puissent entamer la démarche.
Depuis 2013 le lien entre ces deux disciplines scientifiques a été coupé dans les programmes ; il s'agit de plus en plus d'études de documents laissant le candidat prendre des initiatives, notamment lors de questions de synthèses de documents.
Si l'on reste sur ce genre d'épreuve, faire appel de façon pertinente à des connaissances non fournies dans le sujet comme celles issues de la classification périodique des éléments pourra être fortement valorisé.

Déjà, commençons par énoncer les modèles dépourvus d'une telle application, et sans aucune solution à ce jour :

• l'Esquisse GCEXFR
• la Lexibook GC3000FR
• la Casio Graph 25+E
• la Casio Graph 25+E II

La TI-83 Premium CE dispose d'une application Periodic préchargée et restant accessible en mode examen, offrant une superbe classification périodique des éléments en couleurs avec les 118 éléments chimiques découverts à ce jour, chacun accompagné de 16 propriétés.

Il est possible de rechercher un élément par numéro, nom ou symbole.

Si jamais cette application a été effacée, il suffit juste de la retélécharger et réinstaller gratuitement.

Les différentes propriétés numériques de l'ensemble des éléments chimiques peuvent être exportées vers des listes qui pourront ensuite être affichées sous forme de diagrammes, ou traitées par des programmes ou scripts Python.

L'application t'offre de plus en option une vue étendue intégrant de façon logique les lanthanides et actinides (bloc f) au tableau.

La dernière mise à jour 5.5 disponible pour cette rentrée rafraîchit ou complète les données des derniers éléments chimiques découverts avec entre autres leurs noms finaux, beau travail de veille scientifique du constructeur.

Candidats scolarisés hors de France, attention.

La TI-84 Plus CE-T distribuée dans le reste des pays européens interdira l'accès à l'application Periodic une fois passée en mode examen !

Plutôt que d'acheter dans tes magasins locaux, tu auras donc grand intérêt à acheter le modèle français en ligne ou via une commande groupée de ton enseignant ou établissement.

La TI-82 Advanced offre une édition monochrome de cette même application restant disponible en mode examen. Cette application est ici intégrée et non effaçable.

Mais attention ce modèle n'a jamais bénéficié de la moindre mise à jour depuis sa sortie pour la rentrée 2015, et intègre en fait à l'identique l'application Periodic des TI-82+/83+/84+ mise à jour pour la dernière fois pour la rentrée 1999... En conséquence l'application n'est ici pas du tout à jour, ne connaissant que 109 éléments chimiques.

Candidats scolarisés hors de France, attention.

La TI-84 Plus T reprend cette même application monochrome, mais ici à nouveau t'y interdira l'accès une fois passée en mode examen.

L'application est ici effaçable. Pour la remettre si besoin, il te faudra réinstaller le système d'exploitation au complet.

La formidable Casio Graph 90+E vient préchargée avec l'extraordinaire application Physium, exploitant avec pertinence et talent son écran couleur. Les 118 éléments chimiques sont même ici joliment illustrés.

Il est possible de rechercher un élément non seulement par numéro, nom ou symbole, mais également par masse molaire.

Il est même possible de modifier les masses molaires des éléments chimiques et de les réinitialiser, que ce soit pour mettre à jour les valeurs ou pour utiliser temporairement la valeur fournie dans un énoncé.

En cas d'effacement l'application peut-être retéléchargée et réinstallée totalement gratuitement.

Les données des différents éléments sont ici encore exportables, soit de façon individuelle vers une variable à partir de l'élément, soit de façon globale vers une feuille de calcul pouvant être ouverte avec l'application Tableur intégrée et dont tu feras ensuite tout ce que tu voudras.

Hélas, l'accès à cette superbe application te sera interdit en mode examen.

Sur Casio fx-CP400+E nous retrouvons une application Physium très similaire à celle de la Graph 90+E, mais adaptée au grand écran de la machine.

Par contre ici, pas d'exportation globale des données.

De plus les données ne sont pas tout-à-fait à jour, plusieurs des derniers éléments chimiques utilisant encore leur dénomination systématique temporaire.
Et pas de possibilité ici de modifier les valeurs.

Sur les Casio Graph 35+E II et Graph 75+E, nous avons une édition monochrome de l'application Physium, très similaire à celle de la Graph 90+E mais sans les illustrations à la différence. La dernière mise à jour 1.13 en rafraîchit de plus les données, avec les noms définitifs des derniers éléments.

Ici aucune possibilité d'exporter les données ni même de rechercher un élément.

L'ancienne Graph 35+E peut également en bénéficier après avoir été reprogrammée avec le système Graph 75+E, mais cela ne changera rien pour le mode examen.

Sur NumWorks il est possible d'installer le firmware tiers Omega, qui intègre directement une application Atome qui restera même disponible en mode examen.

Pas besoin d'exporter ici, les masses molaires sont directement disponibles dans la boîte à outils accessible depuis toute application, listables au choix par numéro atomique ou par nom de l'élément.

Sur les TI-Nspire il est possible d'installer le classeur MultiPeriodic.

De grandes qualités graphiques ainsi que sur le nombre de propriétés disponibles.

Toutefois, on peut regretter ici l'absence de possibilité de rechercher un élément, ou encore d'exporter les données.

Et bien évidemment, ce classeur sera inaccessible en mode examen.

Sur HP Prime il est possible d'installer l'application Eléments.

Ici encore de grandes qualités graphiques mais on regrettera l'absence apparente de travail sur l'intégration à l'écosystème de la calculatrice ainsi que dans la démarche de résolution d'un problème : aucun moyen prévu pour rechercher un élément ou exporter les données.

Et ici encore, tristement, plus rien de tout ça en mode examen.

Résumé des données, avec :

• en bas les fonctionnalités officielles présentes à l'achat et persistant en mode examen
• en haut l'ensemble des possibilités hors mode examen et/ou en installant les éléments mentionnés précédemment

[critor]

Quelle Calculatrice programmable Choisir 2020
(index des épisodes)

Episode 9 - Ecrans et profondeurs

L'écran est décidément un élément incontournable de ta calculatrice graphique. Après avoir couvert dans des épisodes précédents ses dimensions, définition et zone graphique, nous allons aujourd'hui traiter de sa profondeur, c'est-à-dire du nombre de couleurs différentes qu'il peut afficher.

Commençons par enfoncer les portes ouvertes, avec les modèles dont le contrôleur écran ne gère que 1 bit de profondeur, ne permettant donc que 2¹= 2 couleurs différentes.

D'une part, voici les modèles à cristaux liquides bleus, affichant donc en bleu et blanc :

• Esquisse GCEXFR
• Lexibook GC3000FR
• Casio Graph 25+E

Et voici les modèles à cristaux liquides noirs, affichant en noir et blanc :

• Casio Graph 25+E II
• Casio Graph 35+E
• Casio Graph 35+E II
• Casio Graph 75+E
• TI-82 Advanced
• TI-84 Plus T
• Casio fx-92+ Spéciale Collège

Passons maintenant aux choses sérieuses ; nous allons te présenter notre protocole de test.

Notre idée est donc d'afficher une mire avec des dégradés des composantes primaires rouge-vert-bleu, afin de déterminer le nombre de bits utilisés par chacune.

Histoire d'avoir un script de test aussi universel que possible, commençons par ressortir nos fonctions Python magiques que nous t'avons déjà présentées :

• get_pf() pour récupérer un code identifiant la plateforme détectée
• get_pixel_functions(pf) pour récupérer les fonctions de lecture/écriture des pixels correspondant à la plateforme en question

Code: Select all

# detects calculator Python platform
def get_pf():
  c256 = True
  try:
    if chr(256)==chr(0):
      # Xcas/KhiCAS Python compatibility
      if "HP" in version():
        return 13 # HP Prime
      else:
        if not white:
          return 12 # Graph 35+E II
        elif "Numworks" in version():
          return 10 # NumWorks
        elif "Nspire" in version():
          return 8 # Nspire
        else: # Graph 90+E
          return 11
  except:
    c256 = False
  try:
    import sys
    try:
      if sys.platform == "nspire":
        try: # Nspire Ndless
          import graphic
          return 7 # KhiCAS Micropython
        except: # MicroPython
          return 6
      elif sys.platform == "TI-Nspire":
        return 3 # Nspire CX II
      elif sys.platform == "numworks":
        return 9 # NumWorks KhiCAS Micropython
      elif sys.platform.startswith('TI-Python'):
        return 2 # 83P/84+ CE
    except: # Graph 35+E/USB / 75/85/95
      return 5
  except:
    pass
  if not c256:
    return 1 # Graph 90/35+E II
  try:
    import kandinsky
    return 0 # NumWorks
  except:
    try: # HP Prime
      import hpprime
      return 4
    except:
      pass
  return -1

#return get_pixel and set_pixel functions for the platform
gp_prime = lambda x, y: GETPIX_P(x, y)
sp_prime = lambda x, y, c: PIXON_P(x, y, c)
def get_pixel_functions(pf):
  gp, sp = lambda: None, lambda: None
  if pf == 0: # NumWorks
    import kandinsky
    gp, sp = kandinsky.get_pixel, kandinsky.set_pixel
  elif pf == 1: # Graph 90/35+E II
    import casioplot
    gp, sp = casioplot.get_pixel, casioplot.set_pixel
  elif pf == 2: # 83P/84+ CE
    import ti_graphics
    gp, sp = ti_graphics.getPixel, ti_graphics.setPixel
  elif pf == 3: # Nspire CX II
    pass
  elif pf == 4: # HP Prime
    import hpprime
    sp = hpprime.pixon
  elif pf == 6: # Nspire: Ndless MicroPython
    from nsp import Texture
    canvas = Texture(320, 240, 0)
    gp, sp = canvas.getPx, canvas.setPx
  elif pf == 7 or pf == 9: # Nspire/NumWorks: KhiCAS-MicroPython
    import graphic
    gp, sp = graphic.get_pixel, graphic.set_pixel
  elif pf == 13: # HP Prime
    gp, sp = gp_prime, sp_prime
  return gp, sp

Voici de quoi récupérer tout ça :

Code: Select all

gp, sp = get_pixel_functions(pf)
sw, sh, sy0 = scr_infos(pf)

Maintenant que nous connaissons les positions et tailles des zones graphiques contrôlables par les scripts Python, faisons une fonction permettant de les récupérer rapidement cette fois-ci sans avoir à tester l'écran :

Code: Select all

#returns platform screen infos : width, height, color_mode/bits
def scr_infos(pf):
  #                                              uPy       uPy
  #                G352                CPy  uPy  KhiCAS--------------------->  CAS
  #           NW   G90  CE   CX2  HP   GXX  NS   NS   NS   NW   NW   G90  G352 HP
  l_vlines = (222, 192, 210, 212, 240, 064, 240, 222, 222, 222, 222, 192, 064, 240)
  l_vcols  = (320, 384, 320, 318, 320, 128, 320, 320, 320, 320, 320, 384, 128, 320)
  l_y0     = (000, 000, 030, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000, 000)
  l_modes  = (000, 000, 000, 016, 032, 000, 016, 000, 016, 000, 016, 016, 001, 032)
  return l_vcols[pf], l_vlines[pf], l_y0[pf], l_modes[pf]

Il y a 2 façons de coder les couleurs dans le contexte des pixels en Python :

• soit avec un tuple (r,g,b) décrivant les valeurs de chaque composante primaire rouge-vert-bleu par un entier de 0 à 255
• soit par un nombre entier qui sera directement la valeur fournie au contrôleur écran

Prévoyons une fonction pour tester le codage utilisé, par simple vérification du type de retour d'une lecture de pixel.
Dans le cas d'un retour de type entier, tentons de plus en passant de détecter le nombre de bits gérés par le contrôleur écran, en écrivant des valeurs de pixels de plus en plus grandes et vérifiant à chaque fois si le pixel concerné a bien pris la valeur en question.

Code: Select all

#0: (R,G,B) >0: RGB-bits
def get_color_mode():
  c = gp(0, 0)
  try:
    c[2]
    return 0
  except:
    b, v = 0, 1
    x, y = 0, sy0
    sp(x, y, v)
    while gp(x, y) == v:
      b += 1
      v *= 2
      sp(x, y, v)
    return b

Un appel color_mode = get_color_mode() pourra donc renvoyer par exemple :

• 0 : pour un codage des couleurs par des tuples (r,g,b)
• 15 : pour un codage des couleurs sur des entiers de 15 bits
• 16 : pour un codage des couleurs sur des entiers de 16 bits
• 24 : pour un codage des couleurs sur des entiers de 24 bits
• ...

Pour notre script universel il faudra bien choisir un codage plutôt qu'un autre, alors prévoyons une fonction de conversion :

Code: Select all

def fixcolor(c, bits=16):
  try:
    if not color_mode:
      return c
    r, g, b = c[0], c[1], c[2]
  except:
    if color_mode == bits:
      return c
    if bits == 16:
      br, bg, bb = 5, 6, 5
    else:
      br, bg, bb = 8, 8, 8
    r, g, b = c & (2**br - 1) * 2**(8 - br), c & ((2**bg - 1) * 2**br) // 2**br * 2**(8 - bg), c & ((2**bb - 1) * 2**(br + bg)) // 2**(br + bg) * 2**(8 - bb)
  if not color_mode:
    return (r, g, b)
  else:
    if color_mode == 16:
      br, bg, bb = 5, 6, 5
    else:
      br, bg, bb = 8, 8, 8
    r, g, b = r // 2**(8 - br), g // 2**(8 - bg) * 2**br, b // 2 **(8 - bb) * 2**(br + bg)
    c = r + g - (r & g)
    return c + b - (c & b)

Voici de quoi tracer des lignes verticales et horizontales :

Code: Select all

def draw_vline(x, y1, y2, c):
  for j in range(y2 - y1 + 1):
    sp(x, y1 + j, c)

def draw_hline(y, x1, x2, c):
  for j in range(x2 - x1 + 1):
    sp(x1 + j, y, c)

Et voici enfin notre code de tracé de la mire :

Code: Select all

#o: 0=horizontal, 1=vertical
#s: 0=no_shadow, 1=shadow left/up, -1=shadow right/down
def mire(s=1, o=0, w=sw, h=sh, y0=sy0):
  if o:
    l1, l2, f, i1, i2 = h, w, draw_hline, y0, 0
  else:
    l1, l2, f, i1, i2 = w, h, draw_vline, 0, y0
  n = 8
  for m in range(l1):
    v = 255
    if s != 0:
      v =  v * (s*m % l1) // (l1 - 1)
    for j in range(n):
      f(m + i1, j * l2 // n + i2, (j + 1) * l2 // n - 1 + i2, fixcolor(color8(j, v)))

def color8(j, v):
  c = [0, 0, 0]
  for b in range(3):
    if j & 2**b:
      c[b] = v
  return c

Tu vas vite comprendre tout ça avec notre premier exemple.

Commençons donc par les TI-83 Premium CE Edition Python et TI-84 Plus CE-T Python Edition que nous allons tester en Python.
Nous considérerons que c'est pareil sur les anciennes TI-83 Premium CE et TI-84 Plus CE.

Cela ne t'apprendra sans doute rien mais histoire de vérifier que ça marche, d'après get_color_mode() sur TI-83 Premium CE Edition Python et TI-84 Plus CE Python Edition les couleurs de pixels sont codées en Python par des tuples (r,g,b).

On peut noter ci-contre que le vert ainsi que les couleurs composées de vert (cyan, jaune et blanc) ont un dégradé beaucoup moins saccadé, beaucoup plus fluide. En effet si tu regardes bien elles utilisent 2 fois plus de teintes intermédiaires, très exactement 64 teintes contre 32 pour les autres :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Voici maintenant la Casio Graph 90+E et son superbe écran.

Ici encore les paramètres de couleur sont passés sous forme de tuples (r,g,b).

Même constat ici, nous notons 2 fois plus de teintes intermédiaires pour les dégradés de vert et de couleurs incluant du vert :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Arrive maintenant la NumWorks.

Avec l'application Python officielle, les paramètres de couleur prennent toujours la forme de tuples (r,g,b).

Encore pareil, 2 fois plus de teintes intermédiaires dans le vert :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Tu peux installer le firmware tiers Omega et ensuite, si tu disposes du dernier modèle NumWorks N0110, l'application KhiCAS, une adaptation pour ta calculatrice du logiciel intégré de Mathématiques Xcas par Bernard Parisse, enseignant-chercheur à l'université de Grenoble, et programmable grâce à son interpréteur MicroPython intégré.

Pas de raison que la mire soit différente, mais précisons tout de même au passage que cette édition de KhiCAS fonctionne elle aussi avec des tuples (r,g,b).

Passons donc aux TI-Nspire. Nous disposons d'une préversion de la prochaine mise à jour 5.2 rajoutant Python aux TI-Nspire CX II, mais hélas nous n'avons pas à ce jour l'autorisation de te faire de nouvelles révélations à son sujet.

Donc tant pis, adaptons notre script de mire dans le langage orienté fonction historique de la machine.
Et nous considérerons que c'est pareil sur les anciennes TI-Nspire CX.

Code: Select all

Define mire(s,o,w,h)=
Prgm
  Local l1,l2,f,c,j,m,n,v
  If o≠0 Then
    l1:=h
    l2:=w
    Define f(y,x1,x2,c)=Prgm
      SetColor c[1],c[2],c[3]
      DrawLine x1,y,x2,y
    EndPrgm
  Else
    l1:=w
    l2:=h
    Define f(x,y1,y2,c)=Prgm
      SetColor c[1],c[2],c[3]
      DrawLine x,y1,x,y2
    EndPrgm
  EndIf
  n:=8
  For m,0,l1-1
    v:=int(255*when(s=0,1,((mod(s*m,l1))/(l1-1))))
    For j,0,n-1
      f(m,((j*l2)/(n)),(((j+1)*l2)/(n))-1,color8(j,v))
      EndFor
  EndFor
EndPrgm

Define color8(j,v)=
Func
  Local l,k
  l:=newList(3)
  For k,1,dim(l)
    If mod(int(((j)/(2^(k-1)))),2)≠0 Then
      l[k]:=v
    EndIf
  EndFor
  Return l
EndFunc

Toujours 2 fois plus de teintes intermédiaires tirant sur le vert :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

Sur les anciennes TI-Nspire CX et TI-Nspire monochromes soit donc avant la version 5.0, le langage interprété ne dispose hélas pas des fonctions de tracé.

Adaptons donc notre mire dans le langage de script Lua :

Code: Select all

o = false
s = 1

function on.charIn(c)
  print(c)
  olds, oldo = s, o
  if c == "−" or c == "-" then
    s = -1
  elseif c == "+" then
    s = 1
  elseif c == "0" then
    s = 0
  elseif c == "*" or c == "/" then
    o = not o
  end
  if s ~= olds or o ~= oldo then
    platform.window.invalidate()
  end
end

function on.resize(w, h)
  platform.window.invalidate()
end

function color8(j, v)
  l={0, 0, 0}
  for k = 1, #l do
    if math.floor(j / 2^(k - 1)) % 2 ~= 0 then
      l[k] = v
    end
  end
  return l
end

function on.paint(gc)
  pw = platform.window
  w, h = pw.width(), pw.height()
  if o then
    l1, l2 = h, w
    function f(gc, y, x1, x2, c)
      gc:setColorRGB(c[1], c[2], c[3])
      gc:drawRect(x1, y, x2, y)
    end
  else
    l1, l2 = w, h
    function f(gc, x, y1, y2, c)
      gc:setColorRGB(c[1], c[2], c[3])
      gc:drawRect(x, y1, x, y2)
    end
  end
  n = 8
  for m = 0, l1 - 1 do
    v = 255
    if s ~=0 then
      v = v * (s * m % l1) / (l1 - 1)
    end
    for j = 0, n - 1 do
      f(gc, m, j * l2 / n, (j + 1)*l2/n - 1, color8(j, v))
    end
  end
end

Sur les TI-Nspire monochromes nous avons donc 4 bits pour 2⁴= 16 niveaux de gris.

Cela ne changera rien au résultat, mais précisons que sur les anciennes TI-Nspire monochromes et TI-Nspire CX si munie d'une version 4.5.0 ou inférieure, tu peux installer Ndless puis MicroPython. Dans ce cas les paramètres de couleur ne sont pas des tuples, mais des entiers sur 16 bits. Heureusement que nous avions prévu notre fonction de conversion automatique.

Sur les anciennes TI-Nspire CX, il est de plus possible dans ce cas d'installer la version de KhiCAS en cours de développement, avec son propre interpréteur MicroPython intégré.

Ici on retrouve la spécification des couleurs sous forme de tuples (r,g,b).

Sur Casio fx-CP400+E nous ne pouvons hélas pas te programmer de mire.
En effet dans le langage interprété historique de la machine et seul langage qui nous est accessible, le paramètre de couleur des fonctions graphiques ne peut prendre que 7 valeurs différentes.

Alors plan B, générons et enregistrons notre mire sous forme d'image, et convertissons-la en image .c2p pour la calculatrice à l'aide de notre convertisseur en ligne.

Toujours le même résultat avec 2 fois plus de teintes intermédiaires dans les tons de vert :

• canal rouge sur 5 bits pour 2⁵= 32 teintes
• canal vert sur 6 bits pour 2⁶= 64 teintes
• canal bleu sur 5 bits pour 2⁵= 32 teintes

Total donc 16 bits pour 2¹⁶= 65536 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 565.

On peut remarquer un petit bug d'affichage dans le dégradé de bleu, comme si la teinte la plus claire avait été marquée en tant que couleur transparente.

Mais ce n'est pas un bug lié à notre convertisseur, nous obtenons exactement le même défaut en utilisant le logiciel de conversion officiel de Casio. Le problème se situe donc ou dans le format, ou dans la calculatrice...

Et enfin nous arrive la HP Prime. Une version alpha très préliminaire incluant une application Python a été diffusée en octobre 2019.

Toutefois hélas, son module graphique n'offre de fonction que pour écrire les pixels, pas pour les lire. Impossible donc ici d'y détecter automatiquement le format de couleur.

Revenons donc sur une version plus stable, et passons la calculatrice en mode CAS afin d'y exploiter la compatibilité syntaxique Python.
Grosse surprise, les paramètres de couleur sont ici détectés comme étant des entiers codés sur 24 bits !

Ici c'est ainsi fantastique, des dégradés extrêmement fluides et ce peu importe la teinte !

• canal rouge sur 8 bits pour 2⁸= 256 teintes
• canal vert sur 8 bits pour 2⁸= 256 teintes
• canal bleu sur 8 bits pour 2⁸= 256 teintes

Total donc 24 bits pour 2²⁴= 16777216 couleurs affichables, et un contrôleur écran fonctionnant donc au format RGB 888 !

Résumé donc des données collectées jusqu'à présent sur les écrans, avec :

• en bas les capacités officielles de la machine en mode examen
• en haut les possibilités hors mode examen

[critor]

Quelle Calculatrice programmable Choisir 2020
(index des épisodes)

Episode 10 - Modules Python et modules de tracé

Dans les programmes actuels du lycée, le langage de programmation Python est donc essentiel, transversal à l'ensemble des enseignements scientifiques, qu'ils soient communs, de spécialité ou en option. Mais toutes les implémentations Python ne se valent pas pour autant. Aujourd'hui nous allons nous intéresser à l'éventail de modules Python offert pas les différentes calculatrices. Nous préciserons de plus leur caractère de standard à propriétaire, ainsi que la présence de modules de tracé (par pixels, coordonnées ou tortue).

Commençons par mettre de côté les modèles n'offrant aucune solution Python à ce jour :

• Esquisse GCEXFR
• Lexibook GC3000FR
• Casio fx-92+ Spéciale Collège
• Casio Graph 25+E
• Casio Graph 25+E II
• Casio fx-CP400+E
• TI-82 Advanced
• TI-84 Plus T
• TI-84 Plus CE-T

Correctement mise à jour, ta Casio Graph 90+E ou Graph 35+E II t'offre 4 modules :

• 3 modules standard :
  
  • builtins
  • math
  • random
• 1 module propriétaire : casioplot, module de tracé par pixels

De plus, tu as la possibilité de rajouter 2 modules standard supplémentaires :

• turtle (pour Graph 90+E ou Graph 35+E II), module de tracé à la tortue
• matplotlib.pyplot sous le nom matplotl (pour Graph 90+E ou Graph 35+E II), module de tracé par coordonnées

Toutefois attention, l'accès à ces modules rajoutés te sera interdit en mode examen.

Sur Graph 35+E II et Graph 75+E, il t'est possible de rajouter l'application CasioPython, avec 8 modules :

• 7 modules standard :
  
  • builtins
  • array
  • cmath
  • gc
  • math
  • random
  • sys
• 1 module relatif à l'implémentation : micropython

Attention, cette application restera hélas inaccessible en mode examen.

Les TI-83 Premium CE Edition Python et TI-84 Plus CE-T Python Edition si correctement mises à jour, t'offrent pour leur part 42 modules :

• 8 modules standard :
  
  • builtins
  • array
  • collections
  • gc
  • math
  • random
  • sys
  • time
• 34 modules propriétaires :
  
  • analogin
  • analogout
  • bbport
  • brightns
  • color
  • colorinp
  • conservo
  • dht
  • digital
  • led
  • light
  • lightlvl
  • loudness
  • magnetic
  • moisture
  • potentio
  • power
  • ranger
  • relay
  • rgb
  • rgb_arr
  • sound
  • squarewv
  • temperat
  • thermist
  • ti_graphics : module de tracé par pixels
  • ti_hub
  • ti_plotlib : module de tracé par coordonnées
  • ti_rover
  • ti_system
  • speaker
  • timer
  • vernier
  • vibmotor
  De plus, tu as la possibilité de rajouter 4 modules propriétaires supplémentaires :
  

  • ce_box : module de tracé par coordonnées (diagrammes en boîte)
  • ce_chart : module de tracé par coordonnées (histogrammes)
  • ce_quivr : module de tracé par coordonnées (flèches/vecteurs)
  • ce_turtl : module de tracé à la tortue

  Attention toutefois, l'accès à ces modules rajoutés te sera interdit une fois la calculatrice passée en mode examen.
  
  
  Si tu disposes d'une ancienne TI-83 Premium CE, tu as la possibilité de lui rajouter des capacités Python plus modestes en la connectant au TI-Python, un module externe lui apportant un coprocesseur 32 bits. Au menu les seuls 8 modules standard :
  

  • builtins
  • array
  • collections
  • gc
  • math
  • random
  • sys
  • time

  
  

  Un firmware tiers est également disponible pour ce module externe, et lui rajoutera 5 modules importables :
  

  • 1 module standard : cmath
  • 4 modules relatifs à l'interpréteur Python utilisé, ici CircuitPython :
    
    • board
    • micropython
    • os
    • storage

  Le TI-Python reste fonctionnel en mode examen.
  
  Mais attention toutefois, en France en tant que module externe, l'utilisation de cet appareil est strictement interdite aux épreuves d'examens.

Les TI-Nspire CX II pourront disposer du Python par simple installation d'une mise à jour qui sera disponible gratuitement d'ici quelques semaines.

Nous en disposons d'une préversion, mais n'avons hélas pas l'autorisation de te faire des révélations à son sujet. Si l'on s'en tient donc aux informations déjà montrées par Texas Instruments sur son site ou lors des formations en ligne, notamment les menus, tu pourras y exploiter au minimum 11 modules :

• 5+ modules standard :
  
  • builtins
  • cmath
  • math
  • random
  • time
  • ...
• 6+ modules propriétaires :
  
  • ti_plotlib, module de tracé par coordonnées
  • ti_hub
  • ti_rover
  • ti_system
  • ti_draw : module de tracé par pixels
  • ti_image : module de tracé par pixels (images)
  • ...
  
  
  Si tu disposes d'une TI-Nspire monochrome, il t'est possible d'installer Ndless puis MicroPython. Sont apportés 8 modules :
  

  • 6 modules standard :
    
    • builtins
    • array
    • cmath
    • math
    • sys
    • 1 module spécifique à l'implémentation : micropython
    • 1 module propriétaire : nsp, module de tracé par pixels entre autres
    Attention, MicroPython sera inaccessible en mode examen.
  
  
  Sur les anciennes TI-Nspire CX, tu ne pourras installer Ndless que si ta calculatrice n'a pas été mise à jour, faisant tourner une version 4.5.0 ou inférieure. Et dans ce cas tu peux installer beaucoup mieux que MicroPython.
  KhiCAS, adaptation pour ta calculatrice du logiciel de Mathématiques intégré Xcas par Bernard Parisse, enseignant-chercheur à l'Université de Grenoble, a en effet le gros avantage d'être programmable grâce à son interpréteur Python intégré, un MicroPython beaucoup plus étendu que le précédent avec pas moins de 26 modules :
  

  • 20 modules standard :
    
    • builtins
    • ubinascii
    • cmath
    • ucollections
    • uctypes
    • uerrno
    • gc
    • uhashlib
    • uheapq
    • linalg
    • math
    • matplotlib.pyplot sous le nom matplotl et les alias matplotlib, matplotlib_dot_pyplot et pylab : module de tracé par coordonnées
    • random
    • ure
    • sys
    • turtle, module de tracé à la tortue
    • uio
    • ujson
    • ustruct
    • uzlib
  • 2 modules relatifs à l'implémentation :
    
    • micropython
    • _os
  • 4 modules propriétaires :
    
    • arit
    • cas
    • graphic également sous les alias casioplot et kandinsky : module de tracé par pixels, compatible scripts Casio et NumWorks
    • nsp, module de tracé par pixels, compatible scripts MicroPython précédent
    Attention, KhiCAS sera hélas tout autant inaccessible en mode examen.

Sur NumWorks tu profites de 11 modules Python :

• 8 modules standard :
  
  • builtins
  • cmath
  • math
  • matplotlib, module de tracé par coordonnées
  • matplotlib.pyplot, module de tracé par coordonnées
  • random
  • time
  • turtle, module de tracé à la tortue
• 1 module spécifique à l'implémentation : micropython
• 2 modules propriétaires :
  
  • ion
  • kandinsky, module de tracé par pixels

Tu as de plus la possibilité d'installer le firmware tiers Omega et ensuite l'application KhiCAS, programmable via un interpréteur MicroPython intégré beaucoup plus complet. Au menu 26 modules :

• 20 modules standard :
  
  • builtins
  • ubinascii
  • cmath
  • ucollections
  • uctypes
  • gc
  • uhashlib
  • uheapq
  • linalg
  • math
  • matplotlib.pyplot sous le nom matplotl et les alias matplotlib et pylab : module de tracé par coordonnées
  • random
  • ure
  • sys
  • turtle, module de tracé à la tortue
  • uio
  • ujson
  • ustruct
  • utimeq
  • uzlib
• 2 modules relatifs à l'implémentation :
  
  • micropython
  • _os
• 4 modules propriétaires :
  
  • arit
  • cas
  • graphic également sous les alias casioplot et kandinsky : module de tracé par pixels, compatible scripts Casio et NumWorks
  • nsp, module de tracé par pixels, compatible scripts MicroPython pour TI-Nspire Ndless

Ici tout ceci restera accessible en mode examen !

Sur HP Prime une mise à jour rajoutant Python est en préparation, mais nous ignorons totalement quand est-ce qu'elle sortira. Rien ne semble bouger pour le moment pour cette rentrée 2020.
Une version alpha incluant l'application Python a été publiée par erreur en octobre 2019.

A titre informatif, nous allons donc te dire à quoi t'attendre au minimum, car bien évidemment la version a dû évoluer depuis.

Dans tous les cas nous te déconseillons très fortement d'installer la version alpha si tu dois passer des évaluations ou épreuves.

Cette version n'est absolument pas stable, avec des inconvénients qui hélas sortent du cadre de la seule application Python.

A venir donc au moins 9 modules :

• 7+ modules standard :
  
  • builtins
  • array
  • cmath
  • uerrno
  • gc
  • math
  • sys
• 1+ modules relatifs à l'implémentation : micropython
• 1+ modules propriétaires : prime, module de tracé par pixels et par coordonnées entre autres

Résumé des données, avec :

• en bas les seules capacités officielles d'origine utilisables en mode examen et en examen
• en haut l'ensemble des possibilités

[critor]

Quelle Calculatrice programmable Choisir 2020
(index des épisodes)

Episode 11 - Ecrans et luminosités

Sur une suggestion de cent20, nous terminons aujourd'hui l'évaluation des écrans de calculatrices avec un test de luminosité, du moins pour les écrans disposant d'un éclairage.

C'est aujourd'hui la TI-83 Premium CE Edition Python qui va travailler pour nous. Nous allons en effet utiliser le TI-Innovator Hub, un périphérique pour calculatrices TI ayant le gros avantage d'être interrogeable et programmable en Python. Les valeurs seront donc certifiées Texas Instruments.

Le TI-Innovator Hub dispose justement d'un capteur de luminosité intégré, interrogeable via brightns.measurement() et retournant une valeur décimale comprise entre 0 et 100.

Niveau protocole de test nous poserons donc le TI-Innovator Hub sur la calculatrice testée comme illustré ci-contre, c'est-à-dire côté capteur de luminosité avec ce dernier centré le plus possible sur l'écran en question, et bien évidemment dans une pièce obscure.

Nous afficherons de plus un écran blanc sur la calculatrice testée.

Voici un script de mesure pour TI-83 Premium CE Edition Python :

Code: Select all

from ti_system import *
import brightns

def brightns_measurements():
  l = []
  while not escape():
    l.append(brightns.measurement())
  return l

L'appel brightns_measurements() effectue une série de mesures de luminosité en rafale jusqu'à-ce que l'on tape la touche

annul

, et les retourne sous forme de liste.

On peut alors représenter cette liste sous forme de diagramme, et on se rend compte que les valeurs récupérées pourtant sans rien déplacer pendant la mesure sont tout sauf constantes, avec des pics réguliers loin d'être négligeables.

Que garder dans tout ça ? Nous faisons le choix de retenir la valeur moyenne :

Code: Select all

l = brightns_measurements()
sum(l) / len(l)

Nous effectuerons jusqu'à 4 séries de mesures par calculatrice testée :

• avec luminosité par défaut
• avec luminosité réglée au maximum
• avec luminosité réglée au minimum
• une fois la calculatrice passée en mode économie d'énergie, c'est-à-dire quand on la laisse allumée sans rien toucher pendant un délai variant de une à plusieurs minutes selon les modèles

Commençons par mesurer une autre TI-83 Premium CE Edition Python. La luminosité y est réglable au clavier avec

2nde

↑

et

2nde

↓

. Nous obtenons :

• 0,905 avec la luminosité par défaut
• 1,441 avec la luminosité réglée au maximum
• 0,421 avec la luminosité réglée au minimum
• 0,297 une fois la calculatrice passée dans le mode d'économie d'énergie, après un délai de 1min30 d'inutilisation

Nous retiendrons ces mêmes valeurs pour la TI-84 Plus CE-T Python Edition ainsi que pour les anciennes TI-83 Premium CE et TI-84 Plus CE-T.

Voici maintenant la TI-Nspire CX II CAS. La luminosité est ici ajustable au clavier avec

⌂

+

et

⌂

-

. Nous ignorons hélas la luminosité par défaut car il ne semble pas y avoir de moyen de la réinitialiser, la dernière valeur réglée étant conservée après redémarrage de la calculatrice. Il aurait fallu avoir une machine neuve jamais utilisée sous la main. Sur le reste nous avons donc :

• 1,708 avec la luminosité réglée au maximum
• 0,431 avec la luminosité réglée au minimum
• 0,365 une fois la calculatrice passée en mode d'économie d'énergie, par défaut après un délai de 5 minutes également réglable sur 1, 3, 10 ou encore 30 minutes

Globalement c'est donc un peu plus lumineux ici.

Nous retiendrons ces mêmes valeurs pour les autres modèles TI-Nspire CX II ainsi que pour les anciennes TI-Nspire CX.

La Casio Graph 75+E dispose d'un éclairage manuel de l'écran, activable via

SHIFT

OPTN

.

La luminosité n'est ici pas réglable, nous obtenons une unique valeur faiblarde de 0,357, sans doute suffisante pour un écran monochrome.

Voici maintenant la Casio Graph 90+E. La luminosité est ici réglable dans l'application Système sur des valeurs allant de 1/5 à 5/5. Nous mesurons :

• 0,680 avec la luminosité par défaut (3/5)
• 1,258 avec la luminosité réglée au maximum (5/5)
• 0,403 avec la luminosité réglée au minimum (1/5)
• 0,289 une fois la calculatrice passée en mode économie d'énergie, par défaut après un délai de 30 secondes également réglable sur 1 ou 3 minutes (compté en interne comme un réglage de la luminosité à 0/5)
  A noter qu'en mode examen le comportement de ce mode économie d'énergie est différent, réglant la luminosité non pas à 0/5 mais 1/5, peut-être pour que l'écran soit davantage visible et donc plus facilement vérifiable pour les surveillants.

Bref, un écran qui malgré ses remarquables qualités (dimensions, définition, ...) a le défaut d'être bien peu lumineux, ce que nous avions déjà remarqué avec davantage de difficultés à le prendre correctement en photo pour illustrer nos actualités.

Passons à la Casio fx-CP400+E. La luminosité est ici ajustable dans l'application Système sur des valeurs allant de 1/13 à 13/13. Nous obtenons :

• 0,760 avec la luminosité par défaut (7/13)
• 1,223 avec la luminosité réglée au maximum (13/13)
• 0,404 avec la luminosité réglée au minimum (1/13)
• 0,308 une fois la calculatrice passée en mode économie d'énergie après 30 secondes également réglable sur 1, 3 ou même 10 minutes (compté en interne comme un réglage à 0/13)

C'est donc ici à peu près pareil, malgré ses énormes qualités (dimensions, définition, tactile, ...) cet écran n'est franchement pas une lumière.

Quant à la HP Prime, la luminosité s'y règle au clavier avec

On

+

et

On

-

. Ici à nouveau nous ignorons la valeur par défaut, le redémarrage de la calculatrice conservant la dernière valeur réglée. Nous avons :

• 1,134 avec la luminosité réglée au maximum
• 0,382 aussi bien avec la luminosité réglée au minimum qu'en mode économie d'énergie, activé après 30 secondes

Nous passons ici clairement du côté obscur...

Et enfin arrive la NumWorks. La luminosité y est ajustable dans l'application Paramètres sur 13 valeurs différentes avec le firmware officiel. Nous ne sommes pas sûrs de la valeur par défaut, le réglage étant ici encore persistant.

L'ancienne édition matérielle NumWorks N0100, nous donne :

• 3,019 avec la luminosité réglée au maximum
• 0,424 aussi bien avec la luminosité réglée au minimum qu'en mode économie d'énergie, activé après 30 secondes

C'est déjà pas mal du tout, le jour après la nuit.

Sur la dernière édition matérielle NumWorks N0110, c'est encore plus extraordinaire :

• 3,900 avec la luminosité réglée au maximum
• 0,496 aussi bien avec la luminosité réglée au minimum qu'en mode économie d'énergie, activé après 30 secondes

Précisons qu'avec le firmware tiers Omega tu auras le choix entre 17 valeurs de réglages, et qu'en prime la luminosité sera réglable à tout moment au clavier via

shift

+

et

shift

-

.

Après, avoir une meilleure luminosité n'est pas forcément qu'un avantage, pouvant avoir des conséquences négatives sur l'autonomie, ce que nous tenterons de voir.

Résumé comparatif des données écrans, avec :

• en bas les seules capacités officielles d'origine utilisables en mode examen
• en haut l'ensemble des possibilités

Afin de pouvoir classer les modèles équitablement, nous excluons la luminosité par défaut (pas toujours mesurée), ainsi que la luminosité minimale (selon les modèles parfois confondue avec le mode économie d'énergie, parfois distincte). Nous retenons donc la luminosité maximale.

[critor]

Pour tes achats individuels ou commandes groupées de calculatrices scolaires en ligne, en France tu avais historiquement le choix entre les distributeurs scolaires suivants :

• Jarrety pour Texas Instruments
• TS Promotion avec ses 3 boutiques distinctes : Casio, Hewlett Packard et Texas Instruments

Pour cette rentrée 2020 se rajoute également Calcuso avec sa boutique unifiée Casio / Hewlett Packard / NumWorks / Sharp / Texas Instruments, agrémentée de toute une offre de services et accessoires !

Face à cette concurrence nouvelle, Jarrety avait commencé à totalement se réinventer pour cette rentrée 2020, avec tout ce qui n'avait jamais été tenté jusqu'à présent.
D'une part, comme déjà annoncé, Jarrety inaugure lui aussi une toute nouvelle offre de services pour ses calculatrices, te proposant dorénavant une extension de garantie 5 ans en option pour ta TI-83 Premium CE à 9,88€.
D'autre part, comme également annoncé, Jarrety se diversifie et distribue désormais également les calculatrices Casio et NumWorks.
Enfin, Jarrety passe aux accessoires tiers, avec une housse de protection molletonnée pour protéger ton précieux écran contre les rayures et chocs.

Jarrety poursuit aujourd'hui en ce sens, avec désormais une housse rigide en nylon.

De quoi gâter ta fidèle calculatrice !

Lien : https://jarrety.fr/home/71-housse-rigid ... trice.html