Forum TI-Planet.org

La première calculatrice graphique française fut la LibreCalc en 2014. Il s'agissait d'un projet de calculatrice graphique visant à avoir un matériel ouvert et un code source libre, développé par deux ingénieurs Rennais.

Le projet fut abandonné brutalement contre l'avis de la communauté début 2015, dès les premières rumeurs d'introduction du mode examen, évoquant un manque d'intérêt de la part des enseignants, ainsi qu'une soi-disante impossibilité de rester sur un projet ouvert dans le contexte du mode examen. Deux arguments que la NumWorks a largement infirmés depuis.

A notre avis ce qui plombait réellement fin 2014 encore toute chance de succès de la LibreCalc, c'est qu'au-delà de son matériel et de son système d'exploitation Linux, elle n'avait rien à offrir, n'apportant strictement rien à l'enseignement. Les vidéos de démo mettaient tristement en avant ce qui était présenté comme un "simulateur de TI-82 Stats", mais qui bizarrement reproduisait au pixel près l'interface très inférieure de la TI-81, son ainée de 14 ans... C'était bien la pleine de se donner le mal de passer sur du matériel ouvert et du code libre, pour reproduire en moins bien ce que faisait déjà Texas Instruments. Sans compter que dans le contexte d'une commercialisation, le constructeur historique n'aurait certainement jamais laissé passer ça.

Nous voici donc enfin à l'ENS de Lyon afin de découvrir la nouvelle calculatrice graphique française Symbolibre que nous t'avions déjà présentée.

Nous en profitons pour remercier l'équipe Symbolibre d'avoir bien voulu s'adapter à nos disponibilités en nous permettant de découvrir la calculatrice Symbolibre en avant-première, soit avant la présentation publique du projet.

Une fois dans le bâtiment de l'ENS, nous croisons une vitrine exposant une sélection d'innovations technologiques du XX^è siècle, entre autres des calculatrices justement :

• une calculatrice électronique Pocket Computer PC-1430 de 1985 par le constructeur Sharp, plus précisément une calculatrice scientifique programmable en Basic
• une calculatrice mécanique manuelle Curta par le constructeur liechtensteinois Continenta AG Mauren, plus précisément la Curta type II de 1954 puisque l'on y note la possibilité d'entrer des nombres ayant jusqu'à 11 chiffres significatifs au lieu de 8 sur la Curta type I
• une calculatrice mécanique électrique C116/2 de 1957 par le constructeur allemand Olympia Werke AG

De quoi nous mettre en bonne condition pour ce qui va suivre.

Même jusque dans l'ascenseur nous trouvons de quoi nous mettre l'eau à la bouche.

Quelle émotion, mon coeur bat la chamade. Cela me rappelle quand j'enseignais encore en collège jusqu'en 2011, avec les petits Sixièmes qui après leurs recherches Internet racontaient que j'avais inventé une calculatrice. C'était mignon... Mais là pour le coup c'est une véritable invention, et nous sommes tout excités à l'idée d'assister pour la première fois à une telle naissance.

Et nous voici maintenant enfin arrivés auprès de la bête, nous allons donc pouvoir voir quels enseignements l'équipe a tirés de l'échec du projet LibreCalc, et ce qu'elle a à nous proposer avec Symbolibre.

Commençons par le clavier. Le prototype accédé ici en avant-première n'était pas encore muni de ses 45 touches clavier, puisqu'elles venaient tout juste d'être reçues.

Mais il reste parfaitement fonctionnel, et en cas de besoin tu pourras revenir te référer aux images d'illustration ci-dessous :

Notons juste que l'on commence très fort niveau adéquation à l'enseignement scolaire français, puisque le clavier dispose enfin de touches dédiées aux instructions de programmation les plus courantes. Plus besoin de s'embêter à aller les chercher dans des sous-menus !

Le boîtier non définitif à ce jour est un petit peu encombrant par rapport aux calculatrices de poche auxquelles tu es habitué(e), et les larges bordures entourant l'écran qui apparaît alors tout petit ne sont pas du meilleur effet.

Le boîtier est aussi assez épais.

Nous n'avons pas emporté notre balance, mais l'ensemble nous paraît relativement léger, donc il doit y avoir belle une marge d'amélioration possible. Il faudra juste doser le tout correctement afin de conserver aussi bas que possible le risque de casse dans le contexte scolaire hostile. Une autre possibilité serait aussi d'opter pour un écran plus grand.

Nous notons sur la tranche supérieure un interrupteur d'alimentation, ainsi qu'un port micro-USB.

Dès l'actionnement de l'interrupteur d'alimentation, la calculatrice commence à démarrer son système Linux embarqué. Cela lui demande un certain temps, une 40aine de secondes. C'est déjà un peu moins que ce qu'exigent les TI-Nspire CX. Notons l'écran de démarrage graphique de Plymooth qui, de façon fort bienvenue, nous fait patienter pendant le chargement en animant le symbole mathématique de l'infini.

On peut aussi si tu préfères maintenir une touche pendant le démarrage pour réobtenir l'écran texte et voir un petit peu mieux ce qui se passe lors du démarrage de cette distribution Linux Gentoo choisie sous la direction de Nicolas :

Ce n'est pas du tout son mode de fonctionnement normal, mais une fois la machine démarrée on peut utiliser la combinaison permettant de basculer sur le terminal texte (à condition de trouver les bons équivalents des touches) et faire joujou directement avec Linux. Comme tu peux le voir ci-contre, la commande free nous précise que la calculatrice ne manque pas de mémoire de travail, avec pas moins de 430,36 Mio libres pour une capacité de 479,54 Mio.

Matériellement, on peut donc conjecturer 512 Mio de capacité RAM (mémoire vive).

Repassons en fonctionnement normal sur le terminal graphique. Nous voici donc à l'écran d'acccueil. Tu as peut-être eu l'impression en fin de démarrage sur la vidéo ci-dessus, plus précisément au lancement de l'environnement graphique sway, que la zone d'affichage se rétrécissait verticalement. Effectivement nous disposons d'un écran 320×240 pixels, mais l'écran d'accueil et les applications Symbolibre n'utilisent que 320×220 pixels. Les 20 premières lignes de l'écran sont en fait réservées pour l'affichage futur d'une barre d'état.

On apprécie la finesse du pixel. Niveau qualité de l'écran on regrettera par contre qu'il ne soit pas anti-reflets contrairement à certains excellents écrans de la concurrence.

L'écran d'accueil nous présente donc 5 applications que nous allons explorer ensemble :

1. Calcul
2. Graphique
3. IDE
4. Paramètres
5. Éteindre

Un bon début, même si manqueront encore à ce jour pour la France quelques essentiels, comme statistiques, probabilités et suites numériques.

Première application d'importance pour une calculatrice, Calcul est déjà très évoluée. Développée sous la supervision d'Aymeric Walch, elle interface GIAC, le moteur de calcul formel du logiciel libre Xcas par Bernard Parisse. Tu peux donc déjà faire du calcul exact, littéral et même formel comme tu le confirmeras ci-contre!

Mais cela ne veut pas dire pour autant qu'il n'y a pas eu du travail conséquent. Notons en effet que nous y disposons déjà d'un historique des calculs, que les expressions et leur simplification sont affichées en écriture naturelle ce qui n'est pas un problème simple, et même la saisie des expressions à évaluer s'effectue déjà en écriture naturelle ce qui est encore moins simple !

Autre application d'importance pour une calculatrice graphique, Graphique, là encore développée en Qt sous la supervision d'Aymeric, adopte une interface par onglets très intuitive comparable à la NumWorks.

On peut toutefois regretter que l'onglet actif ne soit pas toujours visuellement évident avec les couleurs choisies.

Les différents onglets nous permettent donc de définir jusqu'à 3 fonctions, de configurer la fenêtre graphique puis de l'afficher.

Ce dernier onglet affichant la fenêtre graphique est codé autour du widget Qt QCustomPlot, avec plusieurs qualités remarquables par rapport à la concurrence.

Par exemple nous avons des étiquettes numériques venant expliciter les graduations tout le long de chaque axe.

Notons aussi que les graduations restent affichées en bordure si jamais l'origine tombe hors fenêtre, ce qui évite à l'utilisateur de se retrouver perdu comme sur d'autres modèles.

Mais ce n'est pas tout, il ne faut pas croire que tout ce qu'il y a de bon a déjà été inventé pour les calculatrices graphiques. Tu te souviens de l'aberration d'autres modèles où lorsque tu as le curseur sur un graphe, tu dois taper

↓

pour passer au graphe suivant, et ce même si le graphe suivant est au-dessus ? De façon ici beaucoup plus intuitive, les touches

↑

et

↓

te permettront de basculer le curseur non pas vers le graphe précédent ou suivant, mais vers le graphe qui se situe au-dessus ou en-dessous du graphe courant !

Et puisque nous y sommes, le curseur de graphe nous permet de constater la formidable puissance de la machine, le défilement de la fenêtre graphique étant parfaitement fluide, sans le moindre indice visible de retraçage des graphes lorsque le curseur sort de la fenêtre !

De même, la fenêtre graphique peut être défilée horizontalement ou verticalement et même zoomée en toute fluidité !

Voici donc maintenant IDE, l'application de programmation, thème transversal au lycée français, conçue par le groupe de Maxime Darrin.

Créons un nouveau fichier, l'application nous propose alors d'en choisir le type :

1. Texte
2. Python
3. OCaml
4. TI Basic
5. Casio Basic

Pas moins de 4 langages sont donc gérés par cette application, dont les langages interprétés TI / Casio historiques pour faciliter la transition des élèves vers le Python !

Le Python va fait l'objet d'un point séparé. A part cela, notons que l'éditeur dispose bien évidemment de tout ce qu'il faut, numérotation des lignes, coloration syntaxique et aide à la saisie des instructions !

Et enfin nous avons l'habituelle application Paramètres, permettant de choisir la langue, régler la luminosité de l'écran, le délai d'extinction, ainsi que de configurer le comportement du moteur de calcul (résultats exacts ou décimal, notation scientifique, écriture naturelle...).

Pour tester plus en profondeur le Python 3.6.6 de Symbolibre, nous allons repasser sur la console Linux.

Selon la commande help("modules"), nous avons droit à un Python exhaustif. Avec pléthore de modules ici illustrés seulement jusqu'à la la lettre G, il distance toute la concurrence avec au mieux sa petite 10aine de modules !

On pourra par contre regretter de ne trouver aucun module graphique, ce qui aurait été bien utile pour le nouveau programme de Physique-Chimie Seconde rentrée 2019.





Nous notons entre autres la présence essentielle du module cmath apportant les fonctions complexes, et donc la gestion des nombres complexes pour les actuelles Terminales S / STI2D / STL (SPCL) d'une part, futures option Maths expertes en série générale et spécialité Physique-Chimie-Maths en série STI2D.





Regardons maintenant plus précisément le contenu de ces différents modules, à l'aide du script suivant :

Code: Select all

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):
  s=str(obj)
  return s.startswith("<module '") or s.startswith("<class '")

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c=0
  for itms in sorted(dir(pitm)):
    c=c+1
    try:
      itm=eval(spath+"."+itms)
      print(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      print(hd+itms)
  if c>0:
    print(hd+"Total: "+str(c)+" item(s)")
  return c

Si l'on explore par exemple le module math avec explmod(math), on obtient pas moins de 55 élements, soit nettement plus que les au mieux 41 de la concurrence !





Si par contre on explore maintenant le module builtins avec explmod(builtins), on ne trouve bizarrement que 152 éléments, soit nettement moins que la concurrence. Nous avons toutefois omis de prendre note de ce qui pouvait bien manquer.





Pour en apprendre davantage sur l'implémentation, explorons le module sys avec explmod(sys). Malheureusement la commande finit par partir en récursion infinie.

En allégeant un petit peu le script, on arrive à estimer 85 éléments, ce qui est déjà bien plus que ce qu'offre la concurrence.





Tant que nous avons le module sys sous la main, remarquons que sys.maxsize==2**31-1, les nombres entiers sont donc codés nativement sur 32 bits (1 bit de signe). Et que comme sys.maxsize+1 ne retourne pas d'erreur, le support des entiers longs est donc actif.



Intéressons-nous maintenant à la mémoire de travail à l'aide du script suivant :

Code: Select all

def sizeenv():
  s=0
  import __main__
  for o in dir(__main__):
    try:s+=size(eval(o))
    except:pass
  return s
def size(o):
  s,t=0,type(o)
  if t==str:s=49+len(o)
  if str(t)=="<class 'function'>":s=136
  if t==int:
    s=24
    while o:
      s+=4
      o>>=30
  if t==list:
    s+=64
    for so in o:s+=8+size(so)
  return s
def mem(v=1,r=1):
  try:
    l=[]
    try:
      l+=[r and 793+sizeenv()]
      if v*r:print(" ",l[0])
      l+=[0]
      l+=[""]
      l[2]+="x"
      while 1:
        try:l[2]+=l[2][l[1]:]
        except:
          if l[1]<len(l[2])-1:l[1]=len(l[2])-1
          else:raise(Exception)
    except:
      if v:print("+",size(l))
      try:l[0]+=size(l)
      except:pass
      try:l[0]+=mem(v,0)
      except:pass
      return l[0]
  except:return 0

Malheureusement, le processus Python se voit assassiné à peine terminée l'allocation de son premier bloc mémoire. Cela nous permet toutefois une estimation, nous disposons donc au moins de 268,435 Mo pour l'exécution de nos scripts, quantité astronomique par rapport à la concurrence !





Enfin, terminons en voyant les performances. Commençons dans le cadre des nombres entiers avec le script suivant :

Code: Select all

try:
  from time import *
except:
  pass

def hastime():
  try:
    monotonic()
    return True
  except:
    return False

def genseed(ndigits):
  nmax,s,k=5*10**(ndigits-1),0,1
  while s<nmax:
    s+=k
    k*=2
  return s

def genarr(ndigits):
  sd,arr=genseed(ndigits),[]
  for k in range(1,ndigits):
    for j in range(ndigits):
      t=sd%10**k
      arr.extend([t,-t,10**k-t,t-10**k])
      sd=sd//10+(sd%10)*10**(ndigits-1)
  arr.extend([sd,-sd])
  return arr

def sortarr(arr,sdiff):
  segs=[0,len(arr)-1]
  while len(segs):
    iref=segs[0]
    for k in range(segs[0],segs[1]+1):
      if sdiff*(arr[k]-arr[iref])>0:
        t=arr[iref]
        arr[iref]=arr[k]
        arr[k]=arr[iref+1]
        arr[iref+1]=t
        iref+=1
    if iref>=segs[0]+2:
      segs.extend([segs[0],iref-1])
    if iref<=segs[1]-2:
      segs.extend([iref+1,segs[1]])
    segs.pop(0)
    segs.pop(0)
  return arr

def test(l,n):
  timed=hastime()
  start,stop,sdiff,arr=0 or timed and monotonic(),1,-1,[]
  arr.extend(genarr(l))
  for k in range(n):
    arr.extend(sortarr(arr,sdiff))
    sdiff=-sdiff
  stop=timed and monotonic() or 1
  return stop-start,len(arr),arr[0],arr[len(arr)//2-1],arr[len(arr)//2],arr[len(arr)-1]

De façon absolument extraordinaire, la commande test(9,2) se termine en 2,04s et explose presque toute concurrence !





Passons maintenant aux nombres flottants avec le script suivant :

Code: Select all

try:
  from time import *
except:
  pass

def hastime():
  try:
    monotonic()
    return True
  except:
    return False

def seuil(d):
  timed=hastime()
  start,stop,n,u,l,d=0 or timed and monotonic(),1,0,2.,1,d**2
  while (u-l)**2>=d: u,n=1+(1/((1-u)*(n+1))),n+1
  stop=timed and monotonic() or 1
  return [stop-start,n,u]

La ligne d'appel seuil(0.005) se termine en seulement 0,815s, atomisant cette fois-ci toute concurrence !





L'équipe prévoit de rajouter le module giacpy afin de pouvoir faire également du calcul exact / littéral / formel en Python. Mais les conséquences vont bien au-delà de ça. En effet sur la concurrence actuelle, l'application Python est toujours cloisonnée dans son coin, incapable d'échanger la moindre information avec le reste des applications, et ne pouvant donc pas jouer pleinement sont rôle dans la résolution d'un problème. Cet ajout permettra donc au Python de sortir de sa bulle, faisant ainsi appel au moteur de calcul de l'application Calcul directement depuis l'application IDE !

Voici bientôt l'heure de notre train. Il est donc grand temps de voir ce que la calculatrice Symbolibre a dans le ventre. Mais en attendant petit interlude, commençons donc par l'éteindre complètement, ce qui prend une 15aine de secondes :

Nous voici donc maintenant parés pour la grande dissection et donc la découverte de l'oeuvre du groupe de Némo Fournier !

Plusieurs éléments nous apparaissent :

• une carte Raspberry
• une carte clavier
• une carte écran
• une carte Adafruit
• une batterie

Au coeur de la Symbolibre, nous avons donc la carte du nano-ordinateur Raspberry Pi Zero. Un choix fort bien calculé dans notre contexte, puisque c'est l'un des rares modèles Raspberry Pi à ne pas intégrer de capacités sans-fil interdites aux examens !

Nous disposons donc :

• d'un processeur ARM1176JZF-S cadencé à 1 GHz, un 32-bits de la famille ARM11/ARMv6, soit de génération supérieure aux ARM9/ARMv5 équipant encore de nos jours les TI-Nspire CX II !
• d'une mémoire RAM très confortable de 512 Mio, ce qui valide notre conjecture faite plus haut !
• d'un lecteur de carte mémoire microSD, permettant ici d'amorcer sur la carte de 8 Gio contenant le système d'exploitation Symbolibre
• de deux ports au format micro-USB, l'un des deux étant dédié à l'alimentation et l'autre étant un port OTG
• d'un port mini-HDMI

Les ports GPIO de l'ordinateur Raspberry Pi Zero permettent d'une part de le relier à la carte clavier, ici conçue sur mesures.


Ils permettent d'autre part de connecter la carte de l'écran, un 320×240 pixels comme déjà dit, plus précisément un 2,4 pouces de chez EastRising.




Le port micro-USB d'alimentation est quant à lui relié non pas à la batterie mais à une autre carte, une Adafruit PowerBoost 500C, carte qui expose alors son propre connecteur micro-USB sur la tranche supérieure de la calculatrice.


Cette carte est elle-même reliée à une batterie AdaFruit 3,7 Volts de 2000 mAh de capacité.


Le rôle de cette carte interface Adafruit PowerBoost 500C est en fait de gérer la recharge de la batterie.

Les calculatrices graphiques contemporaires ont perdu la quasi totalité de la riche connectivité dont disposaient leurs ancêtres des années 80, les "ordinateurs de poche". On ne peut y connecter qu'un nombre très restreint de périphériques, une rareté qui se paye cher.

Mais comme nous venons de le voir, la Symbolibre dispose d'un port micro-USB OTG standard. De quoi par exemple connecter un clavier USB une fois sorti le bon adaptateur.

Le clavier ainsi rajouté permet parfaitement de naviguer à travers les différentes interfaces de la calculatrice Symbolibre.

Il permet également de contrôler la console Linux ainsi que l'éditeur de l'application IDE tout en profitant de toutes les touches supplémentaires qu'il apporte, notamment la possibilité de sélectionner du texte !

Un superbe confort de saisie !

Mais ce n'est pas tout puisque la Symbolibre dispose également d'un port mini-HDMI. De façon encore plus exceptionnelle, avec utilisation de l'adaptateur adéquat, on peut donc connecter la calculatrice Symbolibre à un écran ou un vidéoprojecteur !


De quoi vidéoprojeter facilement la calculatrice en classe !
Même si avant ça, il faudra toutefois commencer par régler le problème de la résolution qui comme tu peux voir ne s'adapte pas au périphérique de sortie vidéo.