χ\chiCAS pour Numworks N0110, N0115, N0120

Bernard.Parisse@univ-grenoble-alpes.fr

Novembre 2022, mai 2026

English version

Table des matières

1  Préambule : du calcul formel en examen pour tous!

Le calcul formel est autorisé aux examens en France. Un élève équipé d’une calculatrice haut de gamme (TI Nspire CX2 CAS, HP Prime, Casio Classpad) peut s’en servir par exemple au bac, mais un élève équipé d’une Numworks récente ne peut utiliser χ\chiCAS qu’en dehors des examens, sauf s’il ouvre sa calculatrice pour la déverrouiller (cf. la section 3.1) car à ce jour, Numworks refuse d’authentifier χ\chiCAS. En mai 2025, χ\chiCAS a été rendu compatible avec le mode examen des calculatrices graphiques milieu de gamme concurrentes TI83 et Casio Graph (90e et 35eii) pour rendre accessible les mêmes fonctionnalités aux élèves modestes qu’à ceux plus fortunés qui peuvent se payer une calculatrice haut de gamme. Mais la libre concurrence ne s’applique pas sur le marché des calculatrices, l’élève acheteur n’a en général pas le choix du modèle qui est imposé par les enseignants de leur lycée. Enesignant qui travaillent dans des conditions difficiles et dont le choix se fait souvent d’abord sur la facilité d’utilisation en classe de seconde générale avec une partie du public qui ne fera pas (ou peu) de maths, plutôt que sur les fonctionnalités qui seront utiles aux élèves qui souhaitent poursuivre des études scientifiques.

Les constructeurs de calculatrices empêchent l’exécution de χ\chiCAS en mode examen pour diverses raisons : soit parce que cela fait concurrence à leur modèle haut de gamme qui rapporte plus, soit parce qu’ils craignent (ou prétextent craindre) être interdits aux examens dans certains pays. Techniquement, Numworks pourrait très facilement authentifier χ\chiCAS et le laisser accessible en mode examen en France, bien plus facilement que nous l’avons fait sur les Casio ou TI. J’ai contacté à plusieurs reprises Numworks à ce sujet mais sans effet pour l’instant.
Est-il légitime de laisser une entreprise privée décider, en fonction de ses intérêts économiques à l’étranger, des outils autorisés ou non dans des examens publics de l’Education Nationale ? L’égalité est un principe constitutionnel, il devrait avoir priorité sur d’autres considérations.
Chers lecteurs, vous êtes nombreux à consulter ce document (environ 15 000 consultations en 2025), alors si vous vous mobilisez pour que cela change, nous pouvons faire évoluer les choses. Déverrouillez votre calculatrice et celles de vos camarades comme expliqué à la section 3.1. Contactez Numworks et demandez-leur de rendre χ\chiCAS utilisable en mode examen en France. Ou contactez le ministère de l’Education Nationale et demandez l’abolition du mode examen inégalitaire.

2  Introduction

Ce document explique comment prendre en main et utiliser efficacement le système de calcul formel χ\chiCAS, une version adaptée du logiciel Xcas pour les calculatrices Numworks N0110, N0115 ou N0120.
N.B. : Ce document est interactif, vous pouvez modifier les commandes et voir le résultat de l’exécution des commandes proposées en exemple en cliquant sur le bouton exe.

2.1  χ\chiCAS, qu’est-ce que c’est ?

χ\chiCAS permet de transformer votre calculatrice graphique en calculatrice graphique formelle (CAS) pour faire du calcul littéral (développer, factoriser, calculer une limite, une dérivée, une primitive, résoudre des équations, faire du calcul matriciel exact ou approché, ...) et de la géométrie analytique dans le plan et l’espace (exclusivité χ\chiCAS), fort utile pour vérifier ses calculs en spécialité maths en terminale, cf. les sections 3.1.2 et 11.3. χ\chiCAS ajoute aussi des fonctionnalités pour les élèves qui envisagent une poursuite d’études en sciences ou en maths : grande variété de représentations graphiques (champ de tangentes et solution d’une équation différentielle, lignes de niveau, graphes 3d cf. la section 21), géométrie analytique (2d et 3d), arithmétique et cryptographie (corps finis premiers et extensions, polynômes, etc.), algèbre, algèbre linéaire, analyse numérique, calcul flottant multi-précision et certifié (arithmétique d’intervalle), etc.

χ\chiCAS propose aussi une application tableur et une application de géométrie interactive (2d/3d), qui permet de combler l’absence de ces fonctionnalités dans le système Epsilon fourni par Numworks. Enfin, un interpréteur MicroPython est maintenant inclus dans χ\chiCAS pour les programmes qui nécessitent une compatibilité stricte avec Python que le mode de compatibilité de Xcas n’apporte pas. Ce MicroPython est plus complet que celui de Numworks, il comprend un module permettant de faire du calcul formel, un module d’arithmétique (test de primalité, PGCD, identité de Bézout), deux modules pour faire du calcul vectoriel et matriciel et trouver des racines de polynome et un module graphique plus complet (polygones, cercles, formes remplies).

Toutes les fonctionnalités de χ\chiCAS sont intégrées, on peut représenter sur un même graphique un histogramme et un graphe de fonction et une droite, on peut écrire un programme pour faire une simulation et représenter les résultats graphiquement, ou utiliser les fonctions mathématiques dans un programme en syntaxe Python ou utiliser un programme en syntaxe Python dans le tableur.

La philosophie de χ\chiCAS est très éloignée de celle du système Epsilon de la Numworks qui a des applications ciblées, conçues pour être faciles à utiliser en début de lycée mais au risque de favoriser la paresse intellectuelle (“pas besoin de lire un manuel” disait le fondateur de Numworks), et le désintérêt des élèves curieux, les limites des fonctionnalités mathématiques étant très vite atteintes. Avec χ\chiCAS, programmé par un passionné de mathématiques assistées par ordinateur, les élèves devraient avoir largement de quoi susciter leur curiosité intellectuelle. Bien sur, cela suppose de faire un effort pour apprendre comment utiliser le shell et les outils d’édition pour ensuite les faire travailler harmonieusement ensemble, sans autres limites que la mémoire (malheureusement trop vite remplie, et ce par choix délibéré de bridage de Numworks sur les modèles les plus récents!, cf. la section 3.1.2) et la vitesse de la Numworks (tout à fait raisonnable pour une calculatrice).
Il est donc fortement recommandé de conserver ce manuel dans vos signets et de s’y référer pour une utilisation optimale de χ\chicas pour faire des mathématiques, à l’exception des sections 23 et 24 qui s’adressent aux programmeurs qui souhaitent programmer leur calculatrice en C ou C++.

2.2  Remarques importantes avant d’installer

Le calcul formel est autorisé dans les examens organisés par l’éducation nationale en France, par exemple au bac. Mais, à l’étranger ou pour certains concours ou examens spécifiques (par exemple l’IB), l’utilisation de calculatrices formelles est interdite en examen. Il est de la responsabilité de l’utilisateur de vérifier que les calculatrices formelles sont autorisées avant d’utiliser χ\chiCAS dans un examen ou concours. Les auteurs ne sauraient être tenus pour responsables en cas d’utilisation non autorisée.

L’installation optimale de χ\chiCAS dépend de votre modèle précis de calculatrice et du numéro de version d’Epsilon que vous utilisez. Le numéro de votre modèle de calculatrice Numworks est inscrit à l’arrière de votre calculatrice et le numéro de version d’Epsilon se lit dans l’applications Paramètre, A propos.

Afin de satisfaire certaines réglementations d’examens à l’étranger, depuis 2021, Numworks a décidé de verrouiller ses calculatrices, ce qui rend les applications développées par des auteurs indépendants de Numworks nettement moins intéressantes sur ces calculatrices : elles sont plus difficiles à installer, doivent être réinstallées ou réactivées après un crash ou/et un RESET et elles ne sont pas utilisables en mode examen, même lorsque c’est légitime (plus de détails en section 3.1.2).
Une Numworks verrouillée peut être déverrouillée par une ou deux méthodes :

Si votre calculatrice est déverrouillée (par exemple en suivant le mode d’emploi de la section 3.1), passez à la section 3.3. Si vous ne souhaitez pas ouvrir votre calculatrice pour la déverrouiller, passez à la section 4.1.

3  Déverrouillage et installation sur Numworks déverrouillée.

3.1  Le déverrouillage pour tous : comment transformer votre “Numlocked” en “CASworks”!

Le titre de cette section est un petit jeu de mot sur le nom de la calculatrice Numworks, ici l’abréviations Numlocked désigne une calculatrice numérique verrouillée (locked), et CASworks une calculatrice CAS, assistant portable pour vos travaux en mathématiques.
χ\chiCAS est aussi un petit jeu de mot, d’écriture proche de Xcas, avec une prononciation proche de kick ass, qui signifie “d’enfer” ou “qui déchire”, et littéralement “botter le cul”

Avertissement : le déverrouillage est une opération qui doit être menée minutieusement pour éviter de rendre votre calculatrice inutilisable (temporairement en principe), faites-le uniquement lorsque vous êtes bien réveillé! (On peut toujours débloquer une Numworks avec un STLink, sauf si un hasard astronomiquement improbable vous a fait passer en mode RDP2 ce qui verrouille irréversiblement le CPU).
Faites bien les étapes de vérification indiquées avant de passer à l’étape suivante et revenez en arrière si nécessaire. Une fois votre calculatrice déverrouillée, je vous déconseille de vous connecter sur le site de Numworks lorsque votre calculatrice est connectée.

Si vous êtes impatients, passez tout de suite à la section 3.1.1 puis aux sections 3.1.8 et 3.1.9.
La section 3.1.2 explique pourquoi c’est important de déverrouiller sa calculatrice pour utiliser χ\chiCAS, la section 3.1.3 liste le matériel nécessaire. Les sections 3.1.5 et 3.1.7 expliquent comment générer les firmwares patchés bootloader_patched.bin pour la flash interne et epsilonkernel_patched.bin pour la flash externe de la calculatrice. Si vous les avez obtenu par un autre moyen vous pouvez sauter directement aux sections 3.1.8 et 3.1.9.

Aspect juridique :
Les informations données ici pour réaliser le déverrouillage matériel d’une calculatrice Numworks sont nécessaires pour permettre l’interopérabilité de χ\chiCAS en mode examen, elles sont diffusées conformément à l’article L.122-6-1 du code de la propriété intellectuelle et en accord avec l’article L111-1 du code de l’éducation : “Le service public de l’éducation est conçu et organisé en fonction des élèves et des étudiants. Il contribue à l’égalité des chances et à lutter contre les inégalités sociales et territoriales en matière de réussite scolaire et éducative”.
Les manipulations ci-dessous ont été testées plusieurs fois sur des calculatrices différentes, mais je ne peux pas garantir l’exactitude pour toutes les calculatrices, en particulier je n’ai pas de N0115 donc je n’ai pas pu tester sur N0115, en conséquence l’auteur décline toute responsabilité.

N.B. :
Le code de patch du bootloader a été créé par Ayabusa. C’est le premier a avoir indiqué et expliqué comment effectuer le déverrouillage matériel d’une N0120.

3.1.1  Préparation, version abrégée pour les impatients.

Matériel : il faut un PC sous Linux, un ST-Link ou un Raspberry Pi, 3 (ou parfois 4) fils Dupont male-femelle, un tournevis torx, un trombone, une enveloppe, cf. la section 3.1.3 pour plus de détails.
Logiciel : il faut récupérer les fichiers à installer et éventuellement les modifier selon votre modèle de calculatrice comme indiqué ci-dessous (pour les personnes voulant connaitre les détails techniques, se référer aux sections 3.1.5 et 3.1.7).

  1. Récupérez l’archive unlock.zip, décompressez l’archive, cela crée 3 répertoires boot, kernel et unlock.
  2. Installez les logiciels nécessaires (openocd, dfu-util, hexedit, bsdiff, crc32) sur le PC, sur Debian ou Ubuntu avec le script
    boot/install_tools.sh
    adaptez selon votre distribution (N.B. le nom du package pour crc32 n’est pas intuitif sur Debian/Ubuntu, c’est libarchive-zip-perl...). Optionnel, compilez le programme boot/nwcrc.cc
    g++ boot/nwcrc.cc -o nwcrc
  3. Sauvegardez votre flash interne et externe, par exemple depuis le webDFU de tiplanet (dump internal et dump slot A).
  4. Pour les N0110 et peut-être pour le N0115, récupérer le bootloader d’Upsilon et passez à la section 3.1.8.
    N0120/N0115 : si vous possédez par ailleurs des images binaires du bootloader patché et pour les N0120 du kernel patché, vous pouvez aussi passer à la section 3.1.8.
  5. N0120/N0115 1ère méthode, allez sur la page qui permet de patcher votre bootloader (N0120/N0115) et votre noyau (N0120), compatible avec Epsilon 20 à 25.
  6. N0120/N0115 2ème méthode (sous réserve que Numworks ne la rende pas incompatible)
    Connectez-vous sur le site de Numworks, récupérez l’archive n0120 (ou n0115 si l’item précédent ne fonctionne pas), sauvegardez sous le nom n0120.dfu (ou n0115.dfu) dans le répertoire boot. Ouvrez un terminal. Pour patcher le fichier de la flash interne, allez dans le répertoire boot
    cd boot
    exécutez le script correspondant à votre calculatrice :
    ./extract120.sh
    ./extract115.sh
    Appliquez le patch qui permet de transformer le bootloader 25.2 en 24.10, sur n0120
    bspatch epsiloninternal.bin boot120_2410 patchboot120_25.2to24.10
    sur n0115
    bspatch epsiloninternal.bin boot115_2410 patchboot115_25.2to24.10
    Vérifiez sur n0120 avec crc32 boot120_2410, vous devez trouver 60e48692, sur n0115crc32 boot115_2410 doit renvoyer 00864807.
    Sur n0120 lancez
    bspatch boot120_2410 bootloader_patched.bin patchboot120_24.10toyes
    Sur n0120, il faut encore patcher le noyau
    bspatch kernel kernel2410 patchkernel120_25.2to24.10
    bspatch kernel2410 epsilonkernel_patched.bin patchkernel120_24.10took
    Sur n0115, on patche le bootloader uniquement avec
    bspatch boot115_2410 bootloader_patched.bin patchboot115_24.10toyes
    Vous pouvez passer à la section 3.1.8.
  7. N0120/N0115, si aucune des deux méthodes précédentes ne s’applique, il faut consulter la section 3.1.5 et les suivantes.

Si tout s’est bien passé, vous pouvez maintenant passer à la section 3.1.8.

3.1.2  Pourquoi déverrouiller, le DPE calculatrice.

Pour pouvoir utiliser réellement χ\chiCAS, il est vivement conseillé de déverrouiller sa calculatrice. C’est en particulier nécessaire pour utilisation en examen lorsque le mode examen est mis en oeuvre. Mais même sans mode examen, le moindre appui sur reset nécessite une réinstallation partielle de χ\chiCAS sur une calculatrice verrouillée, car, depuis la version 20, Numworks sabote au lancement d’Epsilon le secteur de lancement de toutes les applications externes donc de χ\chiCAS (et c’est également le cas lors d’un crash sur les versions 20 à 24). De plus sur les N0120, vous pourrez doubler la quantité de mémoire vive disponible! (presque 300K disponible pour χ\chiCAS au lieu de 120K, 128K de tas Python au lieu de 64K) et récupérer vos données en cas de crash.
Comme la garantie constructeur est de 2 ans, si vous avez acheté en début de lycée, je vous conseille de déverrouiller en début d’année de terminale, au moment où cesse votre garantie et où χ\chiCAS apporte de plus en plus de fonctionnalités absentes de la Numworks (calcul formel bien sûr, y compris l’arithmétique et le calcul matriciel exact, mais aussi géométrie analytique et dans l’espace).

Le DPE, Diagnostic Perfomance Examen
Voici les performances de quelques calculatrices en fonction des sujets de bac de spé maths terminale de 2025. Un + désigne une fonctionnalité présente, un - présente mais peu confortable.

CalculatriceGraph 90Graph Math+Graph 35eiiGraph LightFX92Numworks unlockedNumworks lockedTI83CETI82AEPTI36XPRO
observationχ\chiCAS χ\chiCAS  déverrouillée, χ\chiCASverrouilléeχ\chiCAS 
prix rentréeoccas (≈\approx60?)70-90503515-20occas ou 83+0..208380-906020
DPEA+CBDEACBCD
proba-stats++++++++++
binomial_cdf+-++++++++
graphe suite+++  ++++ 
premiers termes+++--++++-
rsolve+ +  +    
limit+ +  + +  
solve+ +  + +  
fsolve++++ +++++
analytique 3D+    +    
tests 3D+    +    
géométrie 3D+    +    
linsolve++++-+++++
graphe fct++++ ++++ 
dérivée+ +  + +  
primitive+ +  + +  
aire/courbe++++ +++ +
tableau var.+ +  + +  
mémoire RAM8M8M512K24K24K256K ou 560K (N0120)256K256K256KN.A.
stockage flash13M/324.7M/321M/80/512K0/512K2M/85M/8192K/4M/4M0/128K

Voir aussi le QCC de tiplanet qui établit une comparaison beaucoup plus complète, celui-ci est adapté au programme de spé maths de terminale. Pour les prix de calculatrices neuves, cf. le comparateur de tiplanet.

Remarques :

La longueur de la documentation ci-dessous ne doit pas vous faire peur, c’est précisément parce que j’étais moi-même effrayé par l’idée d’ouvrir ma calculatrice, que j’ai bien détaillé les étapes. Si j’y suis arrivé alors que je ne suis pas du tout bricoleur, vous pourrez certainement y arriver! Si certaines étapes ne vous paraissent pas claires, vous pouvez demander des renseignements sur tiplanet.

3.1.3  Matériel nécessaire

Pour déverrouiller une Numworks, voici ci-dessous le matériel que j’utilise. Un même matériel peut bien sur servir pour déverrouiller plusieurs calculatrices, par exemple tous ceux des élèves intéressés d’une même classe. Un enseignant ou un lycée peut ainsi en acheter un ou deux exemplaires, ramenant le cout du déverrouillage à moins de 1 euro par calculatrice. Il faut donc :

3.1.4  Sauvegarde et patch (version courte)

Commencez par sauvegarder la flash de votre calculatrice. Depuis votre navigateur, vous pouvez le faire sur le webDFU de tiplanet en deux actions (Dump internal et Dump slot A). Ensuite, pour séparer le noyau de l’userland, faire sur N0120 

dd if=flash_externe.bin of=epsilonkernel.bin bs=65536 count=1
dd if=flash_externe.bin of=epsilonuserland.bin bs=65536 skip=2

sur N0110/N0115, remplacer skip=2 par skip=1. En ligne de commande avec dfu-utils (Mac/Linux), faire pour N0120 

/bin/rm -f epsilonkernel.bin
dfu-util -i 0 -a 0 -s 0x90000000:0x10000:force -U epsilonkernel.bin
/bin/rm -f epsilonuserland.bin
dfu-util -i 0 -a 0 -s 0x90020000:0x200000:force -U epsilonuserland.bin
/bin/rm -f epsiloninternal.bin
dfu-util -i 0 -a 0 -s 0x8000000:0x80000:force -U epsiloninternal.bin

Sur N0110/N0115 les commandes ci-dessus doivent être remplacées par 

/bin/rm -f epsilonkernel.bin
dfu-util -i 0 -a 0 -s 0x90000000:0x10000:force -U epsilonkernel.bin
/bin/rm -f epsilonuserland.bin
dfu-util -i 0 -a 0 -s 0x90010000:0x200000:force -U epsilonuserland.bin
/bin/rm -f epsiloninternal.bin
dfu-util -i 0 -a 0 -s 0x200000:0x10000:force -U epsiloninternal.bin

Ensuite

Si tout s’est bien passé, passez à la section 3.1.8, sinon lisez la suite.

3.1.5  Patcher un bootloader (version longue)

Cette étape n’est pas nécessaire pour les N0110 (et peut-être pour les N0115), vous pouvez utiliser le bootloader d’Upsilon et le noyau installé sur votre calculatrice et passer à la section 3.1.8.

Sur N0120, si vous avez déjà un bootloader patché en votre possession, passez à l’étape patcher le noyau section 3.1.7.

Si vous lisez ceci, c’est que la version courte de patch n’a pas fonctionné ou que vous voulez en savoir plus. Pour identifier un bootloader, on ne peut pas se fier à la version d’Epsilon installée, car celle-ci change lors des mises à jour, alors que le bootloader ne change pas. On pourrait utiliser la commande crc32 mais il faut prendre garde au fait que le numéro de PCB et le niveau de sécurité sont inscrits dans la flash interne et vont donc modifier le crc du fichier récupéré sur la calculatrice. Il vaut mieux reconstituer le crc que Numworks affiche dans Paramètre, à propos, version du logiciel (appuyer sur OK 4 fois). Le programme suivant permet de le faire sur l’image firmware que vous avez récupérée : 

#include <stdio.h>

void swap(unsigned char &a,unsigned char &b){
  unsigned char c=a;
  a=b;
  b=c;
}

int main(int argc,char ** argv){
  if (argc<2){
    printf("Syntaxe %s filename\n",argv[0]);
    return 0;
  }
  FILE * f=fopen(argv[1],"rb");
  if (!f){
    printf("Fichier non trouvé\n");
    return 0;
  }
  const int s=0x7fa00;
  unsigned char buf[s];
  int sreal=fread(buf,1,s,f);
  if (sreal!=s){
    printf("Fichier trop court\n");
    return 0;
  }
  fclose(f);
  const unsigned p= 0x4C11DB7; // polynome utilisé par Ethernet
  unsigned res=0xffffffff; // crc32 init
  for (int i=0;i<s;i+=4){
    unsigned c= * (unsigned *) &buf[i];
    res ^= c;
    for (int j=0;j<32;j++){
      // on multiplie par x et on regarde s'il faut diviser par le polynome
      if (res&0x80000000)
        res = ((res<<1) ^ p);
      else
        res = (res<<1);
    }
  }
  printf("crc 0x%x\n",res);
  if (res==0xbd422db0 || res==0x8b36995b || res==0xaba59e0d)
    printf("!!! crc32 -> update !!!");
}

Voici une liste de NWCRC sur des firmwares récupérés sur le site de Numworks

Si vous avez une N0120 et si la commande
nwcrc epsiloninternal.bin
renvoie 0xfd4cd4ad, vous pouvez exécuter
bspatch epsiloninternal.bin bootloader_patched.bin patchboot120_24.10toyes
et sauter directement à la vérification. De même sur une N0115 avec crc32 et 0x00864807
bspatch epsiloninternal.bin bootloader_patched.bin patchboot115_24.10toyes
Procédure simplifiée pour se ramener au cas précédent : attention cela ne fonctionne peut-être plus si Numworks l’a rendu incompatible. Connectez-vous sur le site de Numworks, récupérez l’archive n0120 ou n0115, sauvegardez sous le nom n0120.dfu ou n0115.dfu dans le répertoire boot. Ouvrez un terminal. Pour patcher le fichier de la flash interne, allez dans le répertoire boot
cd boot
exécutez l’un des deux scripts
./extract120.sh
./extract115.sh
Appliquez le patch qui permet de transformer le bootloader 25.2 en 24.10
bspatch epsiloninternal.bin boot120_2410 patchboot120_25.2to24.10
bspatch epsiloninternal.bin boot115_2410 patchboot115_25.2to24.10
Vérifiez avec nwcrc boot1?0_2410, si vous trouvez bien 0xfd4cd4ad sur n0120 ou 00864807 sur n0115, lancez
bspatch boot120_2410 bootloader_patched.bin patchboot120_24.10toyes
bspatch boot115_2410 bootloader_patched.bin patchboot115_24.10toyes

Si la procédure simplifiée échoue, commencez par copier le bootloader vers un fichier qu’on va patcher
cp epsiloninternal.bin bootloader_patched.bin
Créez un fichier nop.bin de 2 octets contenant le code assembleur de l’instruction nop
truncate -s 2 nop.bin && hexedit nop.bin
et taper les 2 octets 00 BF, puis Ctrl-X et confirmez la sauvegarde.
Dans la suite, on suppose que le bootloader pour N0120/N0115 est celui récupéré sur le site de Numworks en décembre 2025. Attention celui récupéré depuis ce printemps 2026 est différent (voir plus bas l’analyse ghidra du bootloader 25.2 et les commandes à effectuer sur N0120). Pour le vérifier, taper
nwcrc epsiloninternal.bin
La réponse attendue est 0xfd4cd4ad pour les n0120, Pour les n0115 la commande crc32 epsiloninternal.bin doit renvoyer 00864807.. Si ce n’est pas le cas, on fait une recherche de l’offset du 1er verrouillage du bootloader
hexdump -v -e '/1 "%02X "' epsiloninternal.bin | grep -b -o "30 62 00 21 F2 6B 07 20"
Vous devez voir une sortie analogue à
115770:30 62 00 21
Il suffit alors de diviser par 3 l’entier avant le : pour avoir l’offset du premier octet à modifier. Ici 115770/3=38590 en décimal, ssoit 0x96be en hexa. Si la commande ci-dessus ne renvoie rien ou renvoie plusieurs valeurs, il faudra faire une analyse du bootloader avec ghidra, de manière analogue à ce qui est détaillé ci-dessous pour patcher un noyau. Quelques valeurs de ce premier offset qui remplace 38590 (0x96be) ci-dessous

Rajouter 12 pour le 2ème offset. Epsilon 19.5 et 20 (nwcrc 0xf60e99be) n’utilisent pas le même régistre, il faut donc adapter
hexdump -v -e '/1 "%02X "' epsiloninternal.bin | grep -b -o "20 62 00 21 E2 6B 07 20"
et on trouve 60048/3=20016 (0x4E30) pour Epsilon 20 et 62070/3=20690 (0x50D2) pour Epsilon 19.5.

Sur n0120, on désactive le verrouillage aux offset 0x96BE et 0x96CA (offsets déterminés en cherchant un accès aux régistres 0x52002020 et 0x5200203c) par : 

echo N0120 Bootloader Disable RDP lock and internal flash protection
dd if=nop.bin of=bootloader_patched.bin bs=1 seek=38590 conv=notrunc
dd if=nop.bin of=bootloader_patched.bin bs=1 seek=38602 conv=notrunc

Sur n0115, il faut désactiver l’écriture sur le régistre 0x40023c14 aux offset 0x7806 et 0x7818 en version 24.10 (il y a 4 octets à patcher, donc 2 écritures de nop pour un offset) : 

echo N0115 24.10 Bootloader Disable RDP lock and internal flash protection
dd if=nop.bin of=bootloader_patched.bin bs=1 seek=30726 conv=notrunc
dd if=nop.bin of=bootloader_patched.bin bs=1 seek=30728 conv=notrunc
dd if=nop.bin of=bootloader_patched.bin bs=1 seek=30744 conv=notrunc
dd if=nop.bin of=bootloader_patched.bin bs=1 seek=30746 conv=notrunc

Sur d’autres versions du bootloader n0115, on peut chercher avec le script suivant 

#! /bin/bash
hexdump -v -e '/1 "%02X "' $1 | grep -b -o "C5 F8 14 0C 10 21 D5 F8"

Quelques valeurs :

Pour vérifier rapidement sans lancer ghidra, vous pouvez utiliser le script disasm suivant 

#!/bin/bash

# On s'assure que l'adresse a bien été fournie
if [ -z "$1" ]; then
    echo "Usage: $0 <adresse_hexa> fichier (exemple d'adresse: $0 a000)"
    exit 1
fi

# On ajoute le préfixe 0x à l'adresse fournie (ex: a000 -> 0xa000)
start_hex="0x$1"

# On calcule l'adresse de fin (+4 octets) en disant à Bash de calculer en hexa
# $(( ... )) gère l'hexa nativement si la variable commence par 0x
stop_hex=$(printf "0x%x" $(($start_hex + 100)))

# Exécution de la commande
arm-none-eabi-objdump -b binary -D -m arm -M force-thumb \
    --start-address="$start_hex" \
    --stop-address="$stop_hex" \
    $2

Ainsi disasm 7806 bootloader_patched.bin renvoie avant patch 

00007806 <.data+0x7806>:
    7806: f8c5 0c14  str.w r0, [r5, #3092] ; 0xc14
    780a: 2110       movs r1, #16
    780c: f8d5 2c14  ldr.w r2, [r5, #3092] ; 0xc14
    7810: 2017       movs r0, #23
    7812: f7f8 fcec  bl 0x1ee
    7816: 2300       movs r3, #0
    7818: f8c5 0c14  str.w r0, [r5, #3092] ; 0xc14
    781c: 2007       movs r0, #7
    781e: f8d5 2c1c  ldr.w r2, [r5, #3100] ; 0xc1c
    7822: 4619       mov r1, r3
    7824: f7f8 fce3  bl 0x1ee
    7828: f8c5 0c1c  str.w r0, [r5, #3100] ; 0xc1c

on voit bien l’écriture avec str (store) à l’offset 0xc14 (3092 en décimal) au-delà du régistre r5. Une fois le patch fait les écritures sont remplacées par des nop.

On pourrait ensuite se contenter de désactiver le controle de signature un peu plus loin. Ayabusa nous propose une solution plus complète, qui permet également de booter sur le bootloader ST, ce qui permettra de mettre à jour ultérieurement le bootloader lui-même sans avoir besoin d’ouvrir à nouveau la calculatrice. Pour cela, après le test de reset+6 effectué par le code de Numworks pour pouvoir flasher la flash externe, on teste si la touche 1 est pressée pendant le reset. Si oui, on lance le bootloader ST, sinon on lance le slot A en 0x90000000. Voici le le code compilé pour n0120 (code source assembleur n0120 correspondant), le le code compilé pour n0115 (code source assembleur n0115 correspondant) et deux ressources graphiques image.bin et about.bin prêts à être patché aux offsets 0xbc00, 0xC0C0, 0xC730 
dd if=image.bin of=bootloader_patched.bin bs=1 seek=49344 conv=notrunc
dd if=about.bin of=bootloader_patched.bin bs=1 seek=50992 conv=notrunc
Puis sur n0120 faire
dd if=main.bin of=bootloader_patched.bin bs=1 seek=48128 conv=notrunc
et ssur n0115
dd if=main115.bin of=bootloader_patched.bin bs=1 seek=48128 conv=notrunc
Il faut maintenant que ce code assembleur soit lancé depuis le code du bootloader. Sur les n0120 internal 24.10, on crée un fichier de jump par
truncate -s 4 jump_new.bin && hexedit jump_new.bin
on écrit les octets 03 F0 89 FB, puis Ctrl-X et on confirme la sauvegarde. On détourne alors un saut à l’offset 0x84EA sur les n0120 internal 24.10 (l’appel initial effectuait un affichage par pushrectuniform) par
dd if=jump_new.bin of=bootloader_patched.bin bs=1 seek=34026 conv=notrunc
Sur les n115 en internal 24.10 ou 24.11: le saut équivalent est à l’offset 0x79b6, saut à faire vers offset bc00, code assembleur 04 F0 23 F9 à placer dans
truncate -s 4 jump_115.bin && hexedit jump_115.bin
Détournement du saut :
dd if=jump_115.bin of=bootloader_patched.bin bs=1 seek=31158 conv=notrunc
Passez alors à la vérification en section 3.1.6.
Pour une autre version de bootloader, vous pouvez localiser l’offset à détourner avec la commande
hexdump -v -e '/1 "%02X "' $1 | grep -b -o "6B 46 10 68 51 68"
par exemple sur n0120 en 25.2, on obtient 101928, on divise l’offset par 3: 101928/3=33976 (0x84B8) et on ajoute 12 (0xc), 16 (0x10) ou 20 (0x14) ou 22 (0x16) ce qui donne 33988 (0x84c4) ou ... ou 33998 (0x84CE), c’est là. On vérifie au désasssembleur 

./disasm 84b8 boot120_25.2
000084b8 <.data+0x84b8>:
    84b8: 466b       mov r3, sp
    84ba: 6810       ldr r0, [r2, #0]
    84bc: 6851       ldr r1, [r2, #4]
    84be: c303       stmia r3!, {r0, r1}
    84c0: 4b5b       ldr r3, [pc, #364] ; (0x8630)
    84c2: 881a       ldrh r2, [r3, #0]
    84c4: f7f7 ff64  bl 0x390
    84c8: f7fe fae4  bl 0x6a94
    84cc: 2f00       cmp r7, #0
    84ce: f000 809c  beq.w 0x860a

Reste à calculer le saut vers 0xbc00, le plus simple est d’utiliser l’assembleur et objdump. 

@ Fichier source pour ARM32 Thumb-2, compilation avec arm-none-eabi-as -mthumb -o jump.o jump.s, ensuite faire arm-none-eabi-objdump -D jump.o
.syntax unified
.cpu cortex-m4        @ Ou un autre processeur supportant le Thumb-2
.thumb

.section .text
.org 0x0000          @ On commence à l'offset 0 du fichier

@ On remplit le fichier jusqu'à l'offset 0x84EA
@ pour simuler le positionnement dans votre binaire
@ .space 0x84ea
.space 0x84ce
 
.global _start
_start:
    bl target_address @ L'assembleur calculera 03 f0 89 fb

@ On remplit l'espace entre le saut et la cible
.org 0xbc00
target_address:
 nop               @ Destination du saut

Si votre bootloader n’est pas celui listé et qu’il faut le rendre inoffensif avec ghidra, voici des pistes pour l’analyser. Importer (I) epsiloninternal.bin, en choisissant comme langage cortex dans filtre puis little endian, cliquer sur options, adresse de début 0x200000 pour N0110/N0115 et 0x8000000 pour N0120, lancer le fichier, puis valider pour l’analyser par ghidra. Rajouter depuis le menu Window/Memory avec le bouton vert + une plage d’adresses pour les régistres début 40000000 (hexa), longueur 0x40000000, sauvegardez et fermez. Recherchez (touche G) les références vers 52002020 et 5200203c sur N0120, 40023c14 sur N0110/N0115 pour éviter le verrouillage en RDP1 et laisser la flash interne accessible en écriture. Sur n0120 Epsilon 25.2, l’offset de début de setoptionbytes est 0x9678 au lieu de 0x9694 en 24.8, donc il faut décaler de 28 (0x1c) octets, le patch nop.bin s’écrit en 38590-28=38562 (0x96a2=0x96be-0x1c) et en 38602-28=38574 (0x96ae=0x96ca-0x1c).

Eventuellement chercher aussi 40023c18 pour les modifications des adresses de boot sur N0110/N0115 ou 52002044 sur N0120 (utilisé par une fonction appelée deux fois avec paramètre 0 et 1 pour gérer les adresses de boot0 et boot1), pas vraiment utile sauf si on veut tester le bootloader d’une N0115 sur une N0110 en conservant l’adresse de boot1 pour reset+6 en remplaçant l’appel de cette fonction par des nop.

On peut alors simplement annuler les vérifications signatures en cherchant depuis la fonction main du bootloader (aller en offset 4 du firmware avec G 200004 sur n0110/n0115 ou G 8000004 sur n0120, taper P puis double-cliquer sur l’adresse). La fonction main du bootloader commence par configurer la mémoire (MPU, écritures en 0xe000eda0...), puis d’autres périphériques, puis la flash externe (écritures en 52004000 sur n0120, a0000000 sur n0110), puis le LCD (60000000). Les vérification de signature sont dans un appel de fonction situé presque à la fin de cette fonction main, fonction que l’on pourrait nommer chkslots_run. Pour la repérer, partez de la fin de la fonction, cherchez dans la fenêtre de décompilation à droite l’instruction setMainStackPointer en rouge. L’instruction suivante (hors du test) est normalement un appel à la fonction aléatoire, puis un appel de l’instruction de copie mémoire du bootloader, puis c’est l’appel à la fonction chkslots_run qui appelle une fonction setboot0boot1 qui modifie les adresses de boot (il y a 2 appels consécutifs de cette fonction pour boot0 et boot1), assez au début, et peut donc aussi se repérer parce qu’il référence 52002044 sur n0120 ou 40023c18 sur n110/115 : taper G puis 52002044 ou 40023c18, cliquer sur la fonction qui référence ce régistre, remonter au début de cette fonction, cliquer sur la fonction appelante, c’est chkslots_run.
Si on veut un bootloader permettant de lancer le bootloader ST comme c’est fait dans main.s ou main115.s, il faut ensuite analyser un peu le code du bootloader Numworks pour rajouter les appels vers l’activation de l’écran. Les deux régistres permettant de communiquer avec le LCD sont 60000000 et 60020000, cela permet de localiser où détourner le code pour aller à la fonction de boot/main.s (n0120) ou boot/main115.s (n0115).
Reste à trouver un endroit où détourner un saut vers l’offset 0xbc00, juste avant la vérification des signatures. La fonction chkslots est à l’offset 0x82fc sur 25.2 (n0120) et 0x8318 sur 24.8 et 24.10, avec le même décalage de 0x1c octets, et l’offset 0x84ea (qui effectue un beq.w sur 24.8) correspond à l’offset 0x84ce sur 25.2, donc jumpnew.bin doit être légèrement modifié (saut de 28 octets de plus) en 03 f0 97 fb et écrit en offset 33998=34026-28=0x84ce
Sur Epsilon 20.4 (nwcrc 0xf0df039a), l’adresse équivalente pour le détournement est 0x08007F6E.
Si vous avez réussi, conservez le bsdiff du bootloader initial et bootloader patché, pour pouvoir le communiquer à d’autres personnes ayant le même bootloader que le votre
bsdiff epsiloninternal.bin bootloader_patched.bin boot.bsdiff

Donc, les commandes pour le bootloader 25.2 sur n0120

echo N0120 Bootloader Disable RDP lock and internal flash protection
dd if=nop.bin of=bootloader_patched.bin bs=1 seek=38562 conv=notrunc
dd if=nop.bin of=bootloader_patched.bin bs=1 seek=38574 conv=notrunc
echo add code to bc00
dd if=main.bin of=bootloader_patched.bin bs=1 seek=48128 conv=notrunc
dd if=image.bin of=bootloader_patched.bin bs=1 seek=49344 conv=notrunc
dd if=about.bin of=bootloader_patched.bin bs=1 seek=50992 conv=notrunc
echo Jump to bc00
truncate -s 4 jump_new.bin && hexedit jump_new.bin

écrire les 4 octets 03 f0 97 fb, Ctrl-X, confirmer la sauvegarde, puis 

dd if=jump_new.bin of=bootloader_patched.bin bs=1 seek=33998 conv=notrunc

On vérifie avec ghidra ou avec un désassembleur
arm-none-eabi-objdump -b binary -D -m arm -M force-thumb --start-address=38562 --stop-address=38564 bootloader_patched.bin
arm-none-eabi-objdump -b binary -D -m arm -M force-thumb --start-address=38574 --stop-address=38576 bootloader_patched.bin
arm-none-eabi-objdump -b binary -D -m arm -M force-thumb --start-address=33998 --stop-address=34002 bootloader_patched.bin
avant les commandes dd de patch on a deux commande de stockage (str) et un branchement conditionnel beq.w, après on a deux instructions nop et un saut inconditionnel bl en 0xbc00.

Pour N0115, Epsilon 25.2, il y a un décalage de 140 octets (recul) 

echo N0115 25.2 Bootloader Disable RDP lock and internal flash protection, 0x777a, 0x777c, 0x778c, 0x778e
dd if=nop.bin of=bootloader_patched.bin bs=1 seek=30586 conv=notrunc
dd if=nop.bin of=bootloader_patched.bin bs=1 seek=30588 conv=notrunc
dd if=nop.bin of=bootloader_patched.bin bs=1 seek=30604 conv=notrunc
dd if=nop.bin of=bootloader_patched.bin bs=1 seek=30606 conv=notrunc

Les ajouts
dd if=main115.bin of=bootloader_patched.bin bs=1 seek=48128 conv=notrunc
dd if=image.bin of=bootloader_patched.bin bs=1 seek=49344 conv=notrunc
dd if=about.bin of=bootloader_patched.bin bs=1 seek=50992 conv=notrunc
Enfin, le saut à détourner est à l’offset 0x792a. Le fichier de saut se crée avec
truncate -s 4 jump_new.bin && hexedit jump_new.bin
où l’on met les 4 octets 04 f0 69 f9, puis 

dd if=jump_new.bin of=bootloader_patched.bin bs=1 seek=31018 conv=notrunc

On vérifie avec
arm-none-eabi-objdump -b binary -D -m arm -M force-thumb --start-address=31018 --stop-address=31022 bootloader_patched.bin
le saut conditionnel devient un branchement bl vers 0xbc00.

3.1.6  Vérification du bootloader patché

Pour vérifier, exécutez la commande hexedit bootloader_patched.bin, tapez la touche entrée suivie des offsets à vérifier.
Sur les n0120 en version 24.10, vérifiez les offsets 84ea, 96be, 96ca, bc00 

000084E0   F7 F7 56 FF  FE F7 62 F9  00 2F 03 F0  89 FB 58 4C  ..V...b../....XL
...
000096B0   2B 46 08 21  32 6A 0F 20  FC F7 2A F9  23 46 00 BF  +F.!2j. ..*.#F..
000096C0   00 21 F2 6B  07 20 FC F7  23 F9 00 BF  BD E8 70 40  .!.k. ..#.....p@
...
0000BC00   FF B5 00 27  79 4C A0 47  4F F0 00 00  78 49 41 F2  ...'yL.GO...xIA.
...

Si tout va bien, passez à la section suivante 3.1.7

Sur les n0115, vérifiez en 7806, 7818, 79b6, bc00 

00007800   F8 F7 F5 FC  00 23 00 BF  00 BF 10 21  D5 F8 14 2C  .....#.....!...,
00007810   17 20 F8 F7  EC FC 00 23  00 BF 00 BF  07 20 D5 F8  . .....#..... ..
...
000079B0   F8 F7 84 FE  00 2F 04 F0  23 B9 56 4C  1E 21 01 23  ...../..#.VL.!.#
...
0000BC00   FF B5 00 27  76 4C A0 47  4F F0 00 00  75 49 41 F2  ...'vL.GO...uIA.

Si tout va bien, passez à la section 3.1.8

3.1.7  Patcher le noyau (version longue)

Cette étape n’est pas nécessaire si vous avez un noyau patché ou sur N0110/N0115, dans ce cas passez à l’étape Ouverture de la calculatrice, section 3.1.8.

Pour connaitre le numéro de version de votre noyau, vous pouvez regarder dans l’application Paramètres ou taper
hexedit epsilonkernel.bin
et regarder à partir de l’offset 0xc (si hexedit n’est pas installé, il s’installe comme tous les paquets standards de votre distribution Linux, par exemple sur Debian ou Ubuntu avec sudo apt install hexedit).

Procédure simplifiée pour noyau 24.10 (sur N0120)
bsdiff epsilonkernel.bin epsilonkernel_patched.bin patchkernel120_24.10took
Pour Epsilon 25.2 (récupéré avec le bootloader précédemment), on convertit le bootloader en 24.10 puis on le patche comme ci-dessus
bspatch epsiloninternal.bin kernel2410 patchkernel120_25.2to24.10
bspatch kernel2410 epsilonkernel_patched.bin patchkernel120_24.10took
Vérifiez.

Patcher un noyau 24.10 ou 24.11 pour N0120, version courte
Si vous avez le noyau 24.10 ou 24.11 de Numworks (ils sont identiques sauf pour le numéro et identifiant de version), vous pouvez le patcher à l’aide du script kernel/patch_2410.sh. Avec un noyau 24.8, exécutez kernel/patch_2408.sh.
Vérifiez sur 24.10/11 avec hexedit epsilonkernel_patched.bin : 

00000000   00 00 00 00  98 44 16 00  F0 0D C0 DE  32 34 2E 31  .....D......24.1
00000010   30 2E 30 00  63 63 37 39  36 62 37 00  F0 0D C0 DE  0.0.cc796b7.....
...
00001D80   11 46 FE F7  97 FB 00 28  36 D1 00 BF  33 46 08 21  .F.....(6...3F.!
00001D90   0F 20 FE F7  63 FB 2B 46  20 62 00 21  00 BF 07 20  . ..c.+F b.!...
...
00004920   00 60 05 F1  00 65 00 BF  00 BF 3F 48  32 46 38 49  .`...e....?H2F8I
...
00004D00   D4 F8 98 2D  FB F7 AA FB  C4 F8 98 0D  4F F0 00 50  ...-........O..P
00004D10   FD F7 1A F8  D4 F8 A0 2D  1C 23 01 21  05 20 FB F7  .......-.#.!. ..

Votre noyau est prêt, avec une protection anti-crash (voir explications en fin de cette section), vous pouvez passer à la section suivante 3.1.8 Ouvrir la calculatrice,

Si vous lisez ceci, vous être sur une n0120 et vous n’avez pas un noyau 24.10/11 ou vous voulez des détails. On souhaite donc rendre le noyau inoffensif et on va également autoriser l’accès à presque toute la RAM de votre calculatrice (on passe de 256 à 500K de RAM). Sur les n0110/n0115, les noyaux sont en principe inoffensifs, et il n’y a (essentiellement) pas de RAM supplémentaire utilisable. L’étape qui suit est donc inutile sur n0110/n0115 ou si vous disposez déjà d’une manière ou d’une autre d’un noyau inoffensif pour n0120, dans ce cas sautez directement à Ouverture de la calculatrice. La rediffusion publique d’un noyau inoffensif est très probablement couverte par l’article L122-6-1 du code de la propriété intellectuelle sur l’interopérabilité, mais ne souhaitant pas être importuné, je préfère donner les informations qui permettent de rendre un noyau inoffensif.

Astuce : pour s’assurer de ne pas reflasher un bootloader qui verrouille la calculatrice sur n0120, vous pouvez ajouter une copie de votre bootloader patché après votre noyau patché
cp epsilonkernel.bin kernel && cat kernel bootloader_patched.bin > epsilonkernel.bin
ainsi si votre patch du noyau a manqué un code de reflashage du bootloader, c’est votre bootloader libre qui s’exécutera.

Rendre inoffensif un noyau 24.8 pour N0120
On crée d’abord un fichier nop.bin pour patcher le noyau
truncate -s 2 nop.bin && hexedit nop.bin
on met les 2 octets 00 BF, puis Ctrl-X, confirmer. Puis un deuxième fichier
truncate -s 1 mpusize.bin && hexedit mpusize.bin
on met l’octet 1C, puis Ctrl-X, confirmer. 

echo Patching kernel...
cp epsilonkernel.bin epsilonkernel_patched.bin
echo Kernel 24.8 disable RDP lock and internal flash protection
# 0x1ddc 0x1de8 -> nop
dd if=nop.bin of=epsilonkernel_patched.bin bs=1 seek=7644 conv=notrunc
dd if=nop.bin of=epsilonkernel_patched.bin bs=1 seek=7656 conv=notrunc
echo Kernel 24.8 Do not rewrite extra bytes to internal flash
# 0x491a 0x491c -> nop
dd if=nop.bin of=epsilonkernel_patched.bin bs=1 seek=18714 conv=notrunc
dd if=nop.bin of=epsilonkernel_patched.bin bs=1 seek=18716 conv=notrunc
echo
# 0x4d02 00 instead of 0x10, MPU start at 0x20000000 instead of 0x24000000
# 0x4d0c 0x1c instead of 0x11, MPU ram region increase size to 0x20000000
truncate -s 1 zero.bin
dd if=zero.bin of=epsilonkernel_patched.bin bs=1 seek=19714 conv=notrunc
dd if=mpusize.bin of=epsilonkernel_patched.bin bs=1 seek=19724 conv=notrunc

Vérifiez avec hexedit epsilonkernel_patched.bin le numéro de version et les changements aux offsets 1ddc, 1de8, 491a, 491c, 4d02, 4d0c. 

00000000   00 00 00 00  68 3E 16 00  F0 0D C0 DE  32 34 2E 38  ....h>......24.8
00000010   2E 30 00 00  62 65 61 34  38 38 36 00  F0 0D C0 DE  .0..bea4886.....
...
00001DD0   33 46 08 21  0F 20 FE F7  41 FB 2B 46  00 BF 00 21  3F.!. ..A.+F...!
00001DE0   E2 6B 07 20  FE F7 3A FB  00 BF BF F3  4F 8F 01 23  .k. ..:.....O..#
...
00004910   3D 49 4F F0  00 60 05 F1  00 65 00 BF  00 BF 3F 48  =IO..`...e....?H
...
00004D00   4F F0 00 50  FD F7 42 F8  D4 F8 A0 2D  1C 23 01 21  O..P..B....-.#.!

Si vous voulez utiliser ce noyau avec des versions de userland dont le numéro de version diffère, vous pouvez le changer (offsets 0xc à 0x13).

Rendre inoffensif un noyau 24.10/11 sur N0120
On utilise la même procédure que précédemment avec des adresses qui diffèrent un peu : 

echo Patching kernel...
cp epsilonkernel.bin epsilonkernel_patched.bin
echo Kernel 24.10 disable RDP lock and internal flash protection
# 0x1d8a 0x1d9c -> nop
dd if=nop.bin of=epsilonkernel_patched.bin bs=1 seek=7562 conv=notrunc
dd if=nop.bin of=epsilonkernel_patched.bin bs=1 seek=7580 conv=notrunc
echo Kernel 24.10 Do not rewrite extra bytes to internal flash
# 0x4926 0x4928 -> nop
dd if=nop.bin of=epsilonkernel_patched.bin bs=1 seek=18726 conv=notrunc
dd if=nop.bin of=epsilonkernel_patched.bin bs=1 seek=18728 conv=notrunc
# 0x4d0e 00 instead of 0x10, MPU start at 0x20000000 instead of 0x24000000
# 0x4d18 0x1c instead of 0x11, MPU ram region increase size to 0x20000000
truncate -s 1 zero.bin
dd if=zero.bin of=epsilonkernel_patched.bin bs=1 seek=19726 conv=notrunc
dd if=mpusize.bin of=epsilonkernel_patched.bin bs=1 seek=19736 conv=notrunc

Vérifiez (voir ci-dessus le hexedit pour 24.10/11).

Rendre inoffensif un autre noyau N0120
Méthode 1 : sans ghidra.
On commence par désactiver le verrouillage avec
./findboot120offset1 epsilonkernel.bin
qui exécute la commande
hexdump -v -e '/1 "%02X "' $1 | grep -b -o "20 62 00 21 E2 6B 07 20"
La commande semble fonctionner depuis Epsilon 20, elle affiche un entier, à diviser par 3 pour avoir le premier offset où le noyau écrit les options bytes. Par exemple avec Epsilon 24.10 sur n0120 on obtient
22932:20 62 00 21 E2 6B 07 20
il faut donc écrire 00 BF à l’offset 7644 (0x1ddc) et aussi 12 (0xc) octets plus loin en 7656 (0x1de8). On confirme avec
disasm 1ddc epsilonkernel.bin 

    1ddc: 6220       str r0, [r4, #32]
    1dde: 2100       movs r1, #0
    1de0: 6be2       ldr r2, [r4, #60] ; 0x3c
    1de2: 2007       movs r0, #7
    1de4: f7fe fb3a  bl 0x45c
    1de8: 63e0       str r0, [r4, #60] ; 0x3c
    1dea: f3bf 8f4f  dsb sy
    1dee: 2301       movs r3, #1

Pour annuler la réécriture de la flash interne, on utilise
hexdump -v -e '/1 "%02X "' $1 | grep -b -o "4F F0 00 60 05 F1 00 65"
l’offset à neutraliser se situe 8 octets plus loin. Par exemple avec un kernel 20.2, on obtient 32136/3 soit 0x29d8, on ajoute 8, on trouve 0x29e0. Et au désassemblage on a
./disasm 29d8 kernel120_20.2 

000029d8 <.data+0x29d8>:
    29d8: f04f 6000  mov.w r0, #134217728 ; 0x8000000
    29dc: f105 6500  add.w r5, r5, #134217728 ; 0x8000000
    29e0: f7fe fa94  bl 0xf0c

on écrit donc 00 BF 00 BF à l’offset 0x29e0.
Pour augmenter la RAM disponible, on part de la fonction main du kernel, qu’on lit à l’offset 0x24, apr exemple 0x90004bd8 pour le kernel 24.10 (en fait on lit d9 4b 00 90 car le processeur est little endian et ajoute 1 pour indiquer le mode thumb). On ajoute 0x100, et on déssassemble
disasm 4cd8 epsilonkernel.bin
jusqu’à trouver
... f04f 5010 mov.w r0, #603979776 ; 0x2400000
il faut modifier l’octet 10 et mettre 0 à la place. Localissation par script
hexdump -v -e '/1 "%02X "' $1 | grep -b -o "C4 F8 98 0D 4F F0 10 50"
remplacer le 10 à l’offset (entier avant : divisé par 3 plus 6) par 0.

Méthode 2; avec ghidra.

Patch optionnel pour la gestion de crashes sur N0120
La table VTOR contient à l’offset 0x2c du noyau (offset 0xc depuis le début de la table VTOR) le pointeur appelé en cas de hard fault. Sur les noyaux Numworks, c’est un reset avec perte de toutes les données. On peut arranger cela en changeant cette adresse par exemple en 0x9000a000 vers un gestionnaire qui sauvegarde le scriptstore en cas de crash pour ne pas perdre de données (c’est souvent possible, il faut juste que le scriptstore ne soit pas corrompu). Entrer avec hexedit les octets 01 0A 00 90 à l’offset 0x2c (le décalage de 1 signale au CPU qu’on est en mode Thumb). Ma routine de gestion de crash fault2410.bin est créée à partir du source fault2410.c compilé avec 

arm-none-eabi-gcc -c -mcpu=cortex-m7 -mthumb fault2410.c -o fault2410.o
arm-none-eabi-objcopy -O binary --only-section=.text fault2410.o fault2410.bin

se patche sur le kernel avec la commande
dd if=fault2410.bin of=epsilonkernel_patched.bin bs=1 seek=40960 conv=notrunc
Elle utilise la zone mémoire de 64K en 0x24040000 pour faire une copie du scriptstore. La table des pointeurs SVC est à l’offset 0x892c sur noyau 25.2, 0x8948 sur le noyau 24.10/11, 0x893c sur le noyau 24.8, le pointeur SVC 40 à l’offset 0x89cc sur noyau 25.2, 0x89e8 sur le noyau 24.10/11, 0x89dc sur le noyau 24.8, on doit voir 00 00 00 00 à cette adresse et à la suivante. Il faut remplacer par 01 A0 00 90. pour gérer la copie du scriptstore depuis un userland en ajoutant dans la table des appels SVC à la position 40 actuellement inutilisée la même adresse 0x9000a000 (codée par 01 0A 00 90 en little endian), en ajoutant un code d’appel de la fonction SVC 40. Vérifiez avec hexedit epsilonkernel_patched.bin, en version 24.10/11 on doit voir : 

00000020   F8 F3 03 24  D9 4B 00 90  00 00 00 00  01 A0 00 90  ...$.K..........
...
000089E0   81 2B 00 90  89 06 00 90  01 A0 00 90  00 00 00 00  .+..............
...
0000A000   80 B5 A2 B0  00 AF 78 60  00 23 BB 64  EF F3 03 83  ......x`.#.d....
0000A010   BB 64 BB 6C  C3 F3 08 03  BB 64 BB 6C  0B 2B 02 D0  .d.l.....d.l.+..
...

Il reste à modifier la fonction handleEvent du fichier du source d’Epsilon 24 apps/home/controler.cpp de la manière suivante : 

#define SVC_ATTRIBUTES __attribute__((noinline, externally_visible))

#define SVC_RETURNING_VOID(code)    \
  asm volatile("svc %[immediate]" : : [immediate] "I"(code));
#define SVC_RETURNING_SINGLE_REGISTER(code, returnType, instruction) \
  returnType returnValue;                                            \
  asm volatile(instruction                                           \
               : [returnValue] "=r"(returnValue)                     \
               : [immediate] "I"(code)                               \
               : "r0", "r1", "r2", "r3");                            \
  return returnValue;

#define SVC_RETURNING_R0(code, returnType)        \
  SVC_RETURNING_SINGLE_REGISTER(code, returnType, \
                                "svc %[immediate] ; mov %[returnValue], r0")

#define SVC_BACKUP_RESET 40 // not used anymore by kernels
#define SVC_TEST 41 // not used anymore by kernels
unsigned SVC_ATTRIBUTES svc_backup_reset(unsigned r) {
  SVC_RETURNING_R0(SVC_BACKUP_RESET,unsigned)
}

// insure r is stored in R0
unsigned backup_reset(unsigned arg){
asm volatile (
    "mov r0, %[input]"      // Copie la valeur dans R0
    :                       // Pas de sorties
    : [input] "r" (arg) // Entrée : n'importe quel registre "r"
    : "r0"                  // Liste de "clobber" : prévient que R0 est modifié
);
 svc_backup_reset(arg);
}

  void watch(unsigned r){
#if 0 // enabled : display the result of SVC 40
      char buf[3]={0};
      buf[0]='0'+r/10; buf[1]='0'+r%10;
      extapp_drawTextSmall(buf,100,120,65535,0,false);
      Ion::Timing::msleep(500);
#endif
  }

// ...

bool Controller::handleEvent(Ion::Events::Event event) {
  if (event == Ion::Events::OK || event == Ion::Events::EXE) {
    switchToSelectedApp();
    return true;
  }
  if (event == Ion::Events::Power || event == Ion::Events::Var) { // dbg, calls code at 9000A000 (using svc 40)
    unsigned tmp=0;
    unsigned * stack = &tmp;
    if ( //(unsigned) stack>>24 == 0x24 &&
  confirm("OK: Save backup")){ // N0120 only
      unsigned r=0;
      r=backup_reset(r);
      watch(r);
      //m_view.selectableTableView()->selectCellAtLocation(r%3, r/3);
    }
    m_view.reload();
    return true;
    //test(0xff,0,0xff);
  }
  if (event == Ion::Events::Toolbox){ // Paste
    unsigned tmp=0;
    unsigned * stack = &tmp;
    if ( //(unsigned) stack>>24 == 0x24 &&
  confirm("OK: Backup -> scriptstore")){ // N0120 only
      unsigned r=1;
      r=backup_reset(r);
      watch(r);
    }
    m_view.reload();
    return true;
  }
  if (event == Ion::Events::XNT){
    // Cut: erase crash backup
    unsigned tmp=0;
    unsigned * stack = &tmp;
    if ( // (unsigned) stack>>24 == 0x24 &&
  confirm("OK: erase backup")){ // N0120 only
      unsigned r=2;
      r=backup_reset(r);
      watch(r);
    }
    m_view.reload();
    return true;
  }
  if (event == Ion::Events::Backspace ){
    // erase crash backup
    unsigned tmp=0;
    unsigned * stack = &tmp;
    if ( //(unsigned) stack>>24 == 0x24 &&
  confirm("OK: erase backup + reset")){ // N0120 only
      unsigned r=3;
      r=backup_reset(r);
      watch(r);
    }
    m_view.reload();
    return true;
  }
  if ( event == Ion::Events::Plus) { // 1st external app
    m_view.selectableTableView()->selectCellAtLocation(12%3, 12/3);
    return true;
  }
  if (event == Ion::Events::Home || event == Ion::Events::Back){
    m_view.selectableTableView()->selectCellAtLocation(0, 0);
    return true;
  }
  ...

Depuis Home, la touche Power permet alors de sauvegarder le scriptstore courant (j’ai choisi cette touche parce qu’en shift il y a →\rightarrow la touche de stockage), La touche Toolbox (paste) permet de remplacer le scriptstore actuel par la sauvegarde (attention, cela efface les données courantes). La touche x,n,t (cut) permet d’effacer le backup. La touche del permet d’effacer et de faire suivre par un reset. La touche + permet d’accéder à la première application externe.

3.1.8  Ouverture de la calculatrice

  1. Avant d’ouvrir la calculatrice, faire reset+6 sur la calculatrice et installez le noyau modifié depuis le site webdfu de tiplanet ou avec la commande
    dfu-util -i 0 -a 0 -s 0x90000000 -D epsilonkernel_patched.bin
    Comme cela au premier boot avec la calculatrice déverrouillée, vous ne risquez pas de lancer un noyau qui reflashe le bootloader et reverrouille la calculatrice.
  2. Notez que si vous avez une N0120 achetée en 2022, le déverrouillage matériel est potentiellement plus difficile à réaliser (il faut faire un “connect under reset”). Pour le savoir, aller dans Paramètres, A propos, version du logiciel, appuyer 4 fois sur OK, s’il apparait 67E9399C vous êtes probablement concerné. Profitez de la manipulation pour prendre note du numéro de PCB, affiché après le 2ème OK, par exemple 4.19 pour pouvoir éventuellement le reporter dans le bootloader patché.
  3. Retourner la calculatrice, enlever les 6 petits patins ronds anti-dérapant blancs, en vous aidant d’un des petits triangles orange OPENER si vous en avez. Les vis doivent devenir apparentes, dévissez-les avec le tournevis torx t6. Mettez dans l’enveloppe les patins et les vis pour ne pas les perdre :
  4. Placez un des triangles oranges OPENER au milieu de la partie gauche de la calculatrice comme ci-dessus pour vous aider à déclipser la calculatrice. Commencez par déclipser entièrement à gauche (orientation gauche par rapport au mot RESET écrit à l’endroit). Puis faites doucement une rotation de la partie supérieure gauche de la calculatrice (on fait donc tourner la face arrière de la calculatrice en utilisation normale, par rapport à un axe de rotation situé à droite de la calculatrice ouverte), pour vous assurer de ne pas arracher le cable de la batterie. Lorsque vous avez tourné à angle droit la partie supérieure de la calculatrice, décalez la légèrement vers la gauche et continuez jusqu’à ouverture complète. Sur une de mes N0120, il n’y avait pas de soucis, car la batterie était du même coté que toute l’électronique (dans la partie inférieure), mais sur toutes les autres calculatrices que j’ai ouvertes, la batterie était de l’autre côté, il faut faire attention

    Vous pouvez aussi mettre de coté le bouton reset et le morceau noir qui a la forme d’un petit disque accolé à un rectangle pour ne pas les perdre. En les remettant, prenez garde à bien les replacer (il y a deux petits reliefs blancs pour les maintenir).
  5. Optionnel : notez le numéro du PCB en bas à droite (à droite du contenant de la vis inférieure droite, ce numéro est écrit tourné d’un angle droit). Ce numéro peut servir pour remplir les octets 0x807fa00 et 0x807fa01 de la flash interne, par exemple si votre PCB est 4.15, on fait le calcul suivant avec une calculatrice permettant d’afficher le résultat en hexadécimal, par exemple dans KhICAS: 
    16=>=>
0xffff-415
    le résultat est ici 0xfe60, on édite alors
    hexedit bootloader_patched.bin
    Entrée puis on tape 7fa00, entrée et on entre 60 fe, on voit alors 
    0007FA00   60 FE FF FF  FF FF FF FF  FF FF FF FF  FF FF FF FF  `...............
---  epsilon120internal       --0x7FA00/0x80000--100 %--------------------------
    on tape Ctrl-X pour quitter puis Y pour sauvegarder.

Connexions ST-Link ou Raspberry Pi 3 :

  1. Il faut positionner les 3 cables SWIO SWCLK GND selon le schéma de votre ST-Link, chez moi cela donne

    la terre GND en noir est sur la rangée du haut du STLink sur la broche complètement à droite, et sur la terre du "shield" connecteur USB de la calculatrice. Au moment du déverrouillage, je maintiens le cable sur l’USB avec l’auriculaire de la main droite. Les broches SWDIO et SWCLK sont chez moi sur la rangée du bas du stlink respectivement les broches 4 et 5 en partant de la gauche de la rangée basse.
  2. Le cable (en rouge ici) SWDIO se connecte sur le connecteur en haut à droite du cortex debug, le cable (orange ici) SWCLK juste en-dessous (j’ai choisi les couleurs pour être compatible avec la photo de ce post de tiplanet pour les N0110). Sur une N0110/N0115, c’est assez semblable. En général l’orientation du Cortex Debug est définie par le petit point blanc au-dessus à gauche qui marque la colonne des broches impaires du Cortex Debug (voir la liste ci-dessous).

    Pour éviter toute erreur, je remets une photo où on voit mieux le branchement du cable SWCLK (orange)

    Lors du déverrouillage je maintiens le cable rouge entre le pouce et l’index de la main droite (le cable noir est maintenu sur le shield USB avec l’auriculaire de la main droite), et l’orange avec la main gauche.
    Si vous êtes deux, ce sera plus facile de maintenir les contacts!
    Ci-dessous le schéma de cablage des broches du Cortex Debug, les numéros impairs sont en-dessous du point blanc, les pairs sur l’autre colonne 
    Broche Signal Fonction
1 VTRef Tension de Référence Cible (Alimentation VCC du microcontrôleur).
2 SWDIO/TMS Données Bidirectionnelles SWD / Signal JTAG TMS.
3 GND Masse (Ground) du système.
4 SWCLK/TCK Horloge SWD / Signal JTAG TCK.
5 GND Masse.
6 SWO/TDO Sortie de Traçage (Trace) SWV / Signal JTAG TDO.
7 KEY Détrompeur (Pas de broche/Pin retirée).
8 NC/TDI Non Connecté (ou JTAG TDI si JTAG est utilisé).
9 GND Masse (peut parfois être GND Detect).
10 nRESET Signal de Réinitialisation du microcontrôleur (actif bas).
  3. Voici des photos et le schéma de cablage pour Raspberry Pi 3 (crédits : Yannis)

3.1.9  Déverrouillage

Les fichiers ci-dessous se trouvent dans le répertoire unlock de l’archive unlock.zip. Il nous faut

  1. le fichier de configuration openocd
    • stlinkh.cfg (N0120 pour STLink) 
      source [find interface/stlink.cfg]
source [find target/stm32h7x.cfg]
reset_config none separate
    • stlinkf.cfg (N0110/N0115 pour ST-Link) 
      source [find interface/stlink.cfg]
source [find target/stm32f7x.cfg]
reset_config none separate
    ou le fichier raspyh.cfg ou raspyf.cfg pour Raspberry obtenu en remplaçant la ligne interface par
    source [find interface/raspberrypi-native.cfg]
    transport select swd
  2. selon le modèle de calculatrice un fichier de commande
    • unlock120.run pour N0120 
      init
halt
stm32h7x option_write 0 0x44 0x1ff01ff0
stm32h7x option_write 0 0x3C 0xFF
stm32h7x unlock 0
    • unlock115.run pour les n0115 
      init
mww 0x40023C08 0x08192A3B
mww 0x40023C08 0x4C5D6E7F
mww 0x40023C18 0x00400040
mww 0x40023C14 0xC0FFAAFE
exit
    • unlock110.run pour les N0110 
      init
mww 0x40023C08 0x08192A3B
mww 0x40023C08 0x4C5D6E7F
mww 0x40023C18 0x00400080
mww 0x40023C14 0xC0FFAAFE
exit
    Explications N0115/N0110 : on commence par lancer une séquence de déverrouillage des “option bytes” (ce sont les deux premières commandes après init ci-dessous), puis on modifie l’adresse de boot et le mode RDP du CPU. La seule différence entre N0115 et N0110, c’est que sur la N0110 on a une connexion physique directe du bouton 6 pour que combiné avec le bouton reset, on démarre sur l’adresse BOOT1, que l’on configure alors vers le bootloader ST qui permettra de reflasher la flash interne de la calculatrice. Sur les N0115, il n’y a pas de moyen simple de rebooter sur BOOT1 (matériellement cela peut se faire en reliant la broche légéndée BOOT1 près de la fibre reliant la LED au boitier extérieur avec la tension 3.3V au moment du reset), on reconfigure donc BOOT0 vers le bootloader ST, il faudra après reflashage de la flash interne reconfigurer BOOT0 vers la flash interne. Dans les 3 cas, la dernière commande va faire passer le CPU du mode verrouillé RDP1 au mode non verrouillé RDP0, ce qui provoquera automatiquement un effacement de la flash interne (protection matérielle de la flash du CPU).
    Remarque : si vous pensez que la connexion avec le ST-Link n’est pas fiable et risque de verrouiller le CPU en RDP2, enlevez la ligne correspondante du fichier de commandes openocd (stm32h7x unlock 0 ou mww 0x40023C14 0xC0FFAAFE), ceci permet de booter sur le bootloader ST, vous pourrez ensuite effectuer l’opération d’unlock avec le logiciel STM32 Cube Programmer en connexion USB.
    Le risque d’erreur de transmission est objectivement faible, il faudrait qu’un octet 0xAA se transforme en 0xCC, or la distance de Hamming est de 4 sans décalage et reste élevé en cas de décalage de 1 bit (5 ou 6 si décalage de 1 à gauche, 4 ou 3 si décalage de 1 à droite).
  3. le shell script unlock120.sh ou unlock115.sh ou unlock110.sh qui permettra de lancer openocd plusieurs fois sans avoir à manipuler le PC, dont le contenu est par exemple pour les N0120 : 
    #!/bin/bash
while true; do
 openocd -f ./stlinkh.cfg -f "unlock120.run"
 sleep 0.5
done
    Si vous utilisez un Raspberry Pi, éditez le fichier correspondant à votre calculatrice et remplacez stlinkh.cfg par raspyh.cfg ou stlinkf.cfg par raspyf.cfg.
  4. Faire reset sur la calculatrice, pour cela appuyer avec un trombone au centre de la partie circulaire dorée qui serait située en face du bouton reset si la calculatrice était refermée. Vous devez voir la led en vert/jaune. Sinon, c’est que vous n’avez pas reflashé le kernel, faites reset+6 pour forcer la Numworks en mode reflashage et flashez le kernel avant d’oublier!
  5. Brancher sur le PC le stlink (vous devez voir apparaitre une led rouge sur le STLink) ou le raspberry, lancer le shell script correspondant à votre calculatrice :
    • N0120 : sudo ./unlock120.sh >& log
    • N0115 : sudo ./unlock115.sh >& log
    • N0110 : sudo ./unlock110.sh >& log
    et maintenez les connexions quelques secondes, vous devez voir la led du stlink changer de couleur par moments. Faire Ctrl-C sur le PC pour arrêter le script, si tout s’est bien passé vous devriez voir à un endroit dans le fichier log sur le PC que la flash interne de la calculatrice a été effacée.
  6. Si la led du stlink ne s’est pas brièvement allumée en vert, réessayez.
    Ensuite faites reset sur la calculatrice (ou reset+6 sur la N0110), la modification des options bytes doit faire booter sur le ST Micro bootloader, l’écran doit être éteint et la led doit être allumée en rouge. Sur le PC linux, la commande
    sudo dmesg
    doit faire apparaitre le bootloader ST. Sinon recommencez l’étape précédente.
  7. Si cela ne fonctionne toujours pas (la méthode semble ne pas fonctionner pour les premières N0120), il est peut-être nécessaire de faire un “connect under reset”. Pour cela, il faut effectuer une 4ème connexion entre la petite pastille dorée située immédiatement à droite du bas de la colonne de droite du Cortex Debug de la calculatrice et la broche reset du ST-Link (sur mon ST-link c’est la 3ème broche à partir de la droite de la rangée du bas, donc à droite du fil orange en laissant 2 broches libres et à gauche du fil noir sur l’autre rangée en laissant 1 colonne libre). Il faut alors utiliser le script unlock120reset.sh à la place de unlock120.sh. L’opération nécessite 2 personnes pour tenir chacun 2 fils, et même ainsi c’est assez difficile de maintenir les connexions correctement. Vérifiez que la led du ST-Link est passée au vert pendant un court moment au moins et que le reset de la calculatrice affiche la led en rouge.
    Vous pouvez consulter le compte-rendu de l’opération dans le fichier log pour savoir ce qui s’est passé. Branchez le cable USB de la calculatrice et vérifiez avec sudo dmesg que le bootloader système ST de la calculatrice apparait.
    Si le bootloader ST n’est pas visible avec dmesg, vérifiez avec le logiciel STM32 Cube Programmer en se connectant en USB (au lieu de UART affiché par défaut en haut à droite) et en cochant l’option connect under protection comme indiqué par le logiciel. Si la connexion USB avec STM32 Cube Programmer échoue alors que la led rouge est allumée au reset, ne paniquez pas, il est probable que l’adresse de BOOT0/1 ait été mal transmise par openocd, dans ce cas refaites un connect under reset.
  8. Vous pouvez maintenant transférer le bootloader modifié bootloader_patched.bin en flash interne depuis le site webdfu de tiplanet ou avec la commande
    dfu-util -i 0 -a 0 -s 0x80000000 -D bootloader_patched.bin
    Attention ne vous trompez pas, utilisez le bootloader modifié, pas l’original!!!
    N.B., pour les N0110 (et peut-être aussi les N0115), vous pouvez utiliser le fichier bootloader d’Upsilon.
    Si vous observez une erreur à cette étape, cela signifie que les contacts n’ont pas été stable assez longtemps, les options bytes ont été modifiés, mais pas la commande de déverrouillage RDP1 vers RDP0, il faut alors recommencer l’étape 5 ou bien lancer le logiciel STM32 Cube Programmer, se connecter en USB et enlever la protection.
  9. Vous pouvez vérifier la flash interne,
    • sur les N0120, taper ./getn120internal ou
      dfu-util -i 0 -a 0 -s 0x8000000:0x80000:force -U epsilon120internal
      cela doit être identique à bootloader_patched.bin
      diff -q epsilon120internal bootloader_patched.bin
    • Sur les N0110/N0115, taper ./getn110internal ou
      dfu-util -i 0 -a 0 -s 0x8000000:0x10000:force -U epsilon110internal
      diff -q epsilon110internal bootloader_patched.bin
  10. Sur les N0115 et N0120, il reste à remettre le boot sur la flash interne (c’est inutile sur N0110 ou reset et reset+6 permettent de booter sur flash interne ou sur le bootloader ST).
    Si vous êtes confiants, le plus simple est d’utiliser le fait que lancer le bootloader de Numworks va remettre le boot sur la flash interne, il suffit d’exécuter le script reboot.sh qui contient la commande
    dfu-util -a 0 -s 0x8000000:leave
    Si vous préférez tout bien controler avant de booter
    • Pour les n0120
      ./sendoption120normal
      Vous pouvez vérifier avec
      ./getoptionbytes120 && hexedit optionbytes120
      à l’offset 0x28 (qui correspond au régistre 0x52002044, il y a un décalage de 0x1c sur les offsets), vous devriez voir 00 08 00 08.
    • Pour les n0115 (testé sur n0110), tapez simplement depuis le répertoire boot
      ./sendoption110normal
      Vous pouvez vérifier avec
      ./getoptionbytes110 && hexedit optionbytes110
      à l’offset 10 on doit voir
      00000010 80 00 7F FF 80 00 7F FF 40 00 BF FF 40 00 BF FF
  11. Si tout s’est bien passé, au prochain reset vous redémarrez sur Epsilon, mais vous pourrez modifier librement le noyau et l’userland, il n’y a plus de vérification de la signature de Numworks.
    Sur les N0120 et N0115, il faudra faire reset+6 pour flasher les slots (comme avant), reset+1 pour ouvrir le bootloader ST (si vous voulez modifier le bootloader ou les options bytes). Sur les N0110, le bootloader d’Upsilon affiche un menu permettant de flasher les slots ou de lancer le bootloader ST.
    Vous pouvez refermer la calculatrice et à vous la liberté! Vous pouvez installer χ\chiCAS depuis la page Numworks du site de Xcas.
    Si on vous demande de justifier que votre calculatrice est conforme à la réglementation du mode examen, vous pouvez vous connecter avec un navigateur webUSB compatible sur la page Numworks de Xcas.
  12. Si la calculatrice ne redémarre pas normalement (par exemple reboote en boucle avec un bref flash écran), ne paniquez pas, il y a surement un moyen de la débloquer.
    Essayez de faire reset+1.
    • Si la led rouge s’allume avec écran noir et que ST Micro apparait dans les devices USB, cela signifie que le bootloader patché est bien installé mais que le kernel patché/userland ne se lance pas correctement. Faites reset+6 pour passer en mode rescue et reflashez un kernel patché et un userland de la même version. Si cela ne fonctionne toujours pas, je vous conseille de récupérer la version 24.10 d’Epsilon (par exemple en récupérant la 25.2 d’Epsilon sur le site de Numworks puis en exécutant les patchs pour redescendre le kernel/bootloader en 24.10 comme expliqué en 2ème méthode de la section 3.1.1), exécutez les patchs sur 24.10 puis reflashez bootloader/kernel 24.10 et un un userland 24.10 recompilé
      git clone https://github.com/parisseb/epsilon/ -b version-24
      make userland.A.allow3rdparty.bin MODEL=n0115
      make userland.A.allow3rdparty.bin MODEL=n0120
    • Si reset+1 n’a aucun effet, c’est que le bootloader n’a pas été patché, recommencez l’opération de déverrouillage matériel.

3.1.10  Donner un nom à votre calculatrice

Il suffit de changer la valeur des premiers octets à l’adresse 0x90003f00. Par exemple avec dfu-util et hexedit, on récupère le secteur 

/bin/rm sector3f.bin
dfu-util -i 0 -a 0 -s 0x903f0000:force:0x10000 -U sector3f.bin

Puis
hexedit sector3f.bin
taper la touche de tabulation (normalement à gauche de A sur un clavier français), taper votre nom, taper à nouveau la touche de tabulation, puis 00, vous devez voir quelque chose qui ressemble à : 

00000000   42 65 72 6E  61 72 64 20  50 61 72 69  73 73 65 00  Bernard Parisse.
00000010   FF FF FF FF  FF FF FF FF  FF FF FF FF  FF FF FF FF  ................

attention, il faut absolument un 00 à la fin du nom. Taper Ctrl-X pour quitter puis confirmer en tapant Y. Puis
dfu-util -i 0 -a 0 -s 0x903f0000 -D sector3f.bin

3.2  Installation/mise à jour de χ\chiCAS sur Numworks non verrouillée avec Delta (Upsilon...)

Si votre Numworks est déverrouillée (cf. la section 3.1), le plus simple est d’installer Khi, Omega, Upsilon ou Delta sur une N0110 ou Delta sur une N0115/N0120. Ce sont des firmwares dérivés d’Epsilon 15.5, Delta est une version d’Upsilon modifié pour fonctionner avec un noyau Epsilon déjà installé (il n’y a actuellement pas d’autre solution pour fonctionner sur n0120). La version qui nous intéresse pour une Numworks non verrouillée s’installe immédiatement après le noyau, en 0x90010000 sur une N0110/N0115 ou en 0x90020000 sur une N0120. (Crédits image ChatGPT)
Ci-dessous une archive d’une image flash complète, à l’exception du noyau :

Si vous préférez installer chaque composant séparément, on commence par Delta :

On installe ensuite un paquet d’applications externes dont KhiCAS

Vous pouvez sauvegarder votre flash externe depuis le webDFU de tiplanet, ou par 

#! /bin/bash
/bin/rm flash.bin
dfu-util -i 0 -a 0 -s 0x90000000:force:0x800000 -U flash.bin

et cloner votre installation sur d’autres machines identiques en mode récupération, soit depuis le site de TI Planet, soit par la commande 

#! /bin/bash
dfu-util -i 0 -a 0 -s 0x90000000 -D flash.bin

Vous pouvez maintenant passer à la section 6.

3.3  Installation/mise à jour de χ\chiCAS sur Numworks non verrouillée avec Epsilon en version ≥\geq16

Si votre calculatrice est déverrouillée (cf. la section 3.1), et si vous avez également besoin des fonctionnalités récentes d’Epsilon, vous pouvez modifier et recompiler une version d’Epsilon interopérable avec KhiCAS. (la redistribution de versions modifiées d’Epsilon est dans une zone un peu floue des licences d’utilisation de github). Il vous faudra supprimer le sabotage des applications externes en cas de reset, dans le fichier ion/src/device/userland/drivers/external_apps.cpp, rechercher la fonction App::eraseMagicCode() { et mettre au début 

   return; // do not erase magic code

Il faut ensuite autoriser le lancement de KhiCAS dans apps/home/controler.cpp, dans la fonction void Controller::switchToSelectedApp() {.

Vous pouvez alors installer ou mettre à jour χ\chiCAS depuis la page Numworks du site de Xcas en utilisant un navigateur webUSB compatible (Chromium, Chrome, Edge...).

Il existe deux sous-versions : la version courte occupe presque la moitié de l’espace flash de la calculatrice, la version longue environ les deux tiers, la différence est que la version courte ne contient pas l’aide complète en ligne dans plusieurs langues, mais uniquement l’aide sur les principales commandes en français et en anglais. Je vous recommande l’installation complète! Vous pouvez maintenant passer à la section 6.

3.4  Numworks N0110 non verrouillée avec Epsilon au plus 15.5

Cette section est destinée aux rares personnes qui possèdent une Numworks N0110 achetée avant 2021 et qui n’a pas été mise à jour depuis.

Avant d’installer ou mettre à jour χ\chiCAS, pensez à sauvegarder vos données, car elles pourraient être effacées. Si vous faites une mise à jour, il pourra être nécessaire de faire reset+4 sur votre calculatrice pour accéder à la flash (i.e. appuyer sur la touche 4, puis enfoncer une pointe à l’arrière sur reset, relacher la touche 4). Puis choisir une des méthodes :

  1. Via Internet avec un navigateur compatible avec webUSB
    Cliquez sur ce lien en utilisant un navigateur supportant web USB tel que Chromium ou Edge ou Google Chrome. Connectez la calculatrice et cliquez sur le bouton Installer ou mettre à jour χ\chiCAS.
  2. Depuis Xcas (Windows et Linux)
    C’est une méthode d’installation locale (une fois Xcas installé) N.B. :sous Linux, vérifiez que dfu-util est bien installé et que le fichier 50-numworks-calculator.rules a été copié dans /etc/udev/rules.d.
    Connecter la calculatrice, ouvrez Xcas, puis dans le menu Fich, sous-menu Numworks, sélectionner Installer $\chi$CAS sur la calculatrice. Lorsqu’on vous demande de faire un reset de la calculatrice, appuyez sur le bouton RESET à l’arrière de la calculatrice.
  3. Depuis le site d’Upsilon ou d’Omega, suivre les instructions de ces sites et installer χ\chiCAS comme application externe. Notez que le support du clavier depuis χ\chiCAS est moins bien optimisé qu’avec les autres méthodes d’installation décrites ici. Par contre les bootloader d’Upsilon et Omega ont du support pour lancer des versions plus récentes du système d’exploitation Epsilon de Numworks.
  4. Installation manuelle
    Pour installer ou mettre à jour χ\chiCAS sur votre Numworks N0110 : récupérez sur votre ordinateur le fichier khi.zip.
    • Si nécessaire, installez dfu-util
      • sur Mac, installez brew si nécessaire puis depuis un Terminal (dans Utilitaires) faire
        brew install dfu-util
      • sous Linux debian compatible, ouvrir un Terminal et faire
        sudo apt-get install dfu-util
        Vous pouvez aussi compilez et installer à partir du source.
        Récupérez ce fichier et copiez le dans /etc/udev/rules.d. Si vous avez installé un package debian, cela peut se faire par la commande
        sudo cp /usr/share/giac/doc/50-numworks-calculator.rules /etc/udev/rules.d Vous pouvez aussi créer un fichier /etc/udev/rules.d/50-numworks-calculator.rules de contenu : 
        SUBSYSTEM=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="a291", TAG+="uaccess"
SUBSYSTEM=="usb", ATTR{idVendor}=="0483", ATTR{idProduct}=="df11", TAG+="uaccess"
      • sous Windows, téléchargez et installez la version 64 bits ou 32 bits (provenance). L’exécutable s’appelle dfu-util-static.exe. Si nécessaire éditez le fichier updaten110.bat (64 bits) ou updaten110_32.bat (32 bits) pour adapter les chemins d’installation. Le fichier actuel suppose que l’on a desarchivé khi.zip et dfu-util-0.9-win64.zip depuis le même répertoire racine (par exemple c:\temp) et qu’on lance updaten110.bat (64 bits) ou updaten110_32.bat (32 bits) en cliquant sur le fichier dans l’explorateur de fichiers.
    • Tapez la commande ./updaten110 (Linux/Mac) ou exécutez updaten110.bat (Windows 64 bits) ou updaten110_32.bat (Windows 32 bits). Les commandes dfu-util sont les suivantes 
      dfu-util -i 0 -a 0 -s 0x08000000 -D bootloader.bin -R
dfu-util -i 0 -a 0 -s 0x90000000 -D khi.A.bin -R
dfu-util -i 0 -a 0 -s 0x90180000 -D khi.B.bin -R
dfu-util -i 0 -a 0 -s 0x90200000:force -D apps.tar
      Vous pouvez ajouter des fichiers scripts Python ou sessions Xcas (ou même des programmes) à l’archive apps.tar avec la commande tar rvf apps.tar <filenames>. Ils seront alors visibles depuis χ\chiCAS hors mode examen (et l’ajout est compatible avec la certification du firmware disponible depuis le kit de connexion Numworks).

Après installation, redémarrez la calculatrice par appui sur le bouton RESET si nécessaire.

Multi-boot
Si vous avez installé une version récente de χ\chiCAS, votre calculatrice peut dorénavant lancer deux firmwares :

Pour vérifier l’état des slots de votre calculatrice, maintenez la touche 4 enfoncée et en appuyant sur le bouton RESET à l’arrière, puis relachez la touche 4. Cela lance le multi-boot et affiche le contenu des slots. Notez que le slot 3 est incompatible avec χ\chiCAS (il s’agit du slot B du multi-boot φ\varphi).

Pour passer du slot 1 au slot 2, appuyez sur la touche 1 ou 2, faites simultanément RESET à l’arrière, puis relachez la touche 1 ou 2.

Protection contre des sites potentiellement malveillants
Si vous ne l’avez pas déjà fait, mettez à jour χ\chi et χ\chiCAS afin de bénéficier d’un minimum de protection si vous naviguez sur Internet avec votre calculatrice branchée. Une fois cela fait, en fonctionnement normal, il est impossible à un site d’écrire dans la flash de la calculatrice. Vous ne pourrez modifier la flash qu’en activant le multi-boot (par reset+4) ou le mode de récupération (reset+6). Soyez particulièrement vigilants avant de faire reset+4 ou reset+6. En particulier, si vous voulez conserver le controle de votre calculatrice (éviter un verrouillage) et la compatibilité avec χ\chiCAS, ne faites jamais reset+4 ou reset+6 depuis les sites de Numowrks même si on vous le demande. Si votre calculatrice est bloquée ou pour échanger des scripts, rendez-vous sur mon kit de connexion Numworks.

Mode examen
L’installation de χ\chiCAS et χ\chi dans les slots 1 et 2 est conforme à la réglementation française du mode examen. Un surveillant d’examen qui souhaite s’assurer qu’une calculatrice Numworks n’a pas subi de modifications pour frauder peut le certifier depuis mon kit de connexion Numworks.

Lancement de χ\chiCAS
Tapez sur la touche Back puis Entree pour lancer χ\chiCAS.

Licences d’utilisation :
la licence choisie par Numworks pour son système d’exploitation rend impossible la publication d’un firmware binaire unique contenant également un logiciel libre. Le logiciel est donc décomposé en deux parties, khi.*, sous licence Creative Commons Attribution-NonCommercial- ShareAlike 4.0 International Public License et apps.tar sous licence GPL2.

3.5  Certification des calculatrices non verrouillées en examen.

Contrairement à certaines rumeurs, utiliser des logiciels à source ouvert non installés par le constructeur sur sa calculatrice n’est pas synonyme de fraude, dès l’instant où ce logiciel respecte la réglementation en vigueur, qui à ce jour est ici, complétée par le cahier des charges. C’est d’ailleurs le cas de KhiCAS sur des calculatrices graphiques d’autres marques.

De plus ici, il est possible de vérifier qu’une calculatrice non verrouillée fait tourner un firmware et une version de χ\chiCAS n’ont pas été modifiés et sont conformes à la réglementation française du mode examen depuis la page Numworks du site de Xcas. Le test peut se faire en moins de 30 secondes en connectant un ordinateur (avec le cable fourni avec la calculatrice) ou une tablette ou un smartphone avec la calculatrice (avec un cable USB-C vers cable USB-C ou USB-micro qu’on peut se procurer pour un prix entre 5 et 10 euros).

Le code de la page web extrait la flash externe de la calculatrice et compare la signature sha256 du firmware transmis et de l’application χ\chiCAS avec une base de données d’installations conformes. Me contacter pour plus d’informations.

4  Installation sur Numworks verrouillée.

Si vous ne vous sentez pas d’ouvrir votre calculatrice ou ne voulez pas investir dans le matériel nécessaire, cette section est pour vous!

4.1  Installation de base sur Numworks verrouillée,

Si votre calculatrice est verrouillée et si vous ne voulez pas la déverrouiller, vous pouvez quand même installer χ\chiCAS depuis la page Numworks du site de Xcas en utilisant un navigateur webUSB compatible (Chromium, Chrome, Edge...).

Mais cette version de χ\chiCAS n’est pas accessible en mode examen, alors que la réglementation française autorise le calcul formel aux examens et que Numworks propose un mode examen spécifique à la France. Ceci défavorise les élèves qui possèdent une Numworks verrouillée par rapport à leurs camarades qui peuvent se payer une calculatrice CAS constructeur (environ deux fois plus chère), Numworks porte avec les décideurs qui imposent le mode examen l’entière responsabilité de cette inégalité.

De plus les applications externes sont désactivées en cas de reset (et en cas de crash sur Epsilon 20 à 24), il faut alors réinstaller en cliquant sur le bouton lanceur ou réactiver avec un ordinateur le lanceur de χ\chiCAS, dans le premier cas cela pourrait engendrer une usure prématurée du secteur correspondant de la mémoire flash (en particulier pour les développeurs d’applications externes pour qui il peut être nécessaire de faire plusieurs dizaines de tests par jour avant de localiser et corriger des erreurs). Numworks est au courant de ces problèmes, mais ne donne pour l’instant aucun signe de vouloir les résoudre. La section 4.2 explique comment atténuer cet inconvénient sur N0110 et N0115 de manière purement logicielle. Si vous êtes pressé vous pouvez passer tout de suite à la section 6 et y revenir plus tard.

4.2  Installation optimisée sur N0110 verrouillée et sur N0115.

Cette section s’adresse aux personnes ne souhaitant pas ouvrir leur calculatrice pour procéder à un déverrouillage matériel comme expliqué à la section 3.1 mais qui veulent (un peu) optimiser leur installation de χ\chiCAS, en l’installant sur Epsilon 19.5. Cette section ne vous concerne pas si vous possédez :

Cette section vous concerne si vous possédez une N0110 non déverrouillée ou une N0115 et arrivez à vous procurer une image binaire signée d’Epsilon 19.5, je vous conseille alors de l’utiliser pour installer χ\chiCAS. En effet, avec Epsilon 19.5, les applications externes sont automatiquement réactivées en sortie de mode examen et en cas de crash ou reset, on peut réactiver toutes les applications externes simultanément, par exemple en cliquant sur le bouton rendre visibles les apps externes de ma page Numworks ou par la commande
dfu-util -i 0 -a 0 -s 0x90200000:leave
avec un avantage important, cette commande ne réécrit rien sur la flash de la calculatrice, ce qui évite une usure prématurée (on peut déplorer que Numworks n’ait pas eu ce souci en tête pour les applications externes sur les versions ultérieures d’Epsilon, alors que pour le mode examen, il en tiennent compte).

Pour installer une version d’Epsilon, faire reset+6 sur la calculatrice (maintenir appuyé la touche 6 tout en enfonçant puis relachant la touche reset), allez sur le site webdfu de tiplanet et choisissez Flash Slot A (0x90000000). Si vous arrivez à booter Epsilon 18.2 sur une N0110, rendez-vous ici pour la déverrouiller, installez le bootloader d’Upsilon puis installez χ\chiCAS comme expliqué en section 3.4 ou 3.3.

La suite de cette section est un peu technique, mais je ne vois pas comment l’éviter. Elle explique comment générer un firmware 18.2, pourquoi la fourniture à un tiers d’un patch de firmware Epsilon 19.5 est très probablement légale en vertu des lois sur l’interopérabilité, et comment faire tourner une version plus récente d’Epsilon sur Epsilon 19.5. Pour effectuer les manipulations techniques, on suppose que le lecteur a accès à une machine Linux debian ou ubuntu ou compatible (par exemple dans une machine virtuelle, ou depuis WSL sous Windows).

Sur les versions d’Epsilon ≥\geq 20, à chaque reset (et crash jusqu’en version 24), sous prétexte de sécurité, Epsilon sabote les applications externes installées en mettant à 0 le 1er octet du secteur de flash, sans rien demander à l’utilisateur. Ceci nécessite une réinstallation de l’application externe à chaque fois, ce qui décourage fortement l’utilisation d’applications externes (surtout si on en a plusieurs), et cela risque de diminuer inutilement la durée de vie de la flash de la calculatrice (le nombre de cycles d’effacement et écriture de la flash est limité). Aucun des constructeurs concurrents (TI, Casio) n’agit ainsi.

Dans cette section, on explique comment générer un firmare Epsilon 18.2 qui permet de déverrouiller logiciellement la calculatrice dans certains cas, ou comment utiliser Epsilon 19.5. Il est essentiel ici de comprendre que l’amorçage de la calculatrice autorise l’exécution d’un firmware en flash externe uniquement s’il est signé par Numworks. La version 18.2 d’Epsilon est la dernière version pour laquelle le code source complet du firmware exécuté en flash externe est disponible.

4.2.1  Générer un firmware 18.2 pour tenter le déverrouillage d’une N0110 sans l’ouvrir.

Cette section est à destination des personnes qui ont une Numworks N0110 qui a été verrouillée par mise à jour vers Epsilon ≥\geq16 entre 2021 et fin 2022, et qui n’ont pas réussi à se procurer un firmware 18.2 par d’autres moyens.

On peut reproduire un firmware 18.2 non signé identique à Epsilon de la manière suivante sur un système Linux 

  apt-get install build-essential git imagemagick libx11-dev libxext-dev libfreetype6-dev libpng-dev libjpeg-dev pkg-config python3 python3-pip dfu-util bsdiff
  pip3 install lz4 pypng stringcase
  cd ~/Downloads
  wget https://developer.arm.com/-/media/Files/downloads/gnu-rm/10-2020q4/gcc-arm-none-eabi-10-2020-q4-major-x86_64-linux.tar.bz2
  cd /usr/local
  sudo tar xfa ~/Downloads/gcc-arm-none-eabi-10-2020-q4-major-x86_64-linux.tar.bz2
  export PATH=/usr/local/gcc-arm-none-eabi-10-2020-q4-major/bin:$PATH
  cd
  git clone https://github.com/parisseb/epsilon
  mv epsilon epsilon18
  cd epsilon18
  git checkout 6f231d531fa74574e00f6b266ed4d9c86a9d5ab3
  make kernel.A.bin
  make userland.onboarding.A.bin

Il suffit de concaténer le kernel et l’userland 

  cp output/release/device/n0110/kernel/kernel.A.bin kernel18.bin
  truncate -s 65536 kernel18.bin
  cp output/release/device/n0110/userland/userland.onboarding.A.bin userland18.bin
  cat kernel18.bin userland18.bin > epsilon18.bin

et d’ajouter la signature pour obtenir un firmware signé 18.2, par exemple avec hexedit :
hexedit epsilon18.bin
Cette signature n’est pas soumise au copyright, car obtenue par un procédé algorithmique complètement déterministe, ce n’est donc pas une oeuvre originale de l’esprit, elle n’a de plus jamais été secrète (puisque le firmware 18.2 a été diffusé publiquement par Numworks pendant plusieurs mois en 2022), il s’agit d’une information au sens de l’article L122-6-1 IV pour permettre le déverrouillage des calculatrices qui ont été verrouillées avant la sortie d’Epsilon 19 et l’utilisation de tous les logiciels rendus incompatibles avec Epsilon 16 (Omega, Upsilon, Khi...), sa diffusion est donc légale. Elle se décompose en deux parties

Sur certaines calculatrices verrouillées, vous pourrez installer ce firmware en maintenant appuyé la touche 6 tout en appuyant sur la touche reset au dos de la calculatrice, puis relâchez reset puis 6. Vous pouvez maintenant flasher la calculatrice depuis le le site webdfu de tiplanet ou par la commande :
dfu-util -i 0 -a 0 -s 0x90000000 -D epsilon18.bin
Après reset, si le firmware démarre, félicitations, vous pouvez maintenant déverrouiller votre calculatrice avec le jailbreak Phi, puis installer le bootlodaer d’Upsilon ou de Khi ou de Omega et passer à la section 3.3 ou 3.4.

4.2.2  Utiliser un firmware 19.5 (n0110/n0115)

Malheureusement, il n’est pas possible d’utiliser Epsilon 18.2 directement sur la plupart des machines verrouillées, car les bootloaders plus récents de Numworks interdisent le downgrade vers la version 18.2 vulnérable au jailbreak Phi. Techniquement parlant, Numworks a ajouté une 2ème signature, distincte de la précédente, et qui couvre également les 8 premiers octets du noyau, et le bootloader utilise cette signature si il a été installé après le printemps 2022. Les firmwares à partir de la version 19 contiennent les deux signatures, permettant l’utilisation sur les deux versions de bootloader. Attention, en mars 2026, Numworks a incrémenté le niveau de sécurité de ses firmwares. Si vous avez fait une mise à jour vers Epsilon 25 (ou 24.11), il est trop tard, vous ne pourrez plus redescendre vers des version antérieures, donc pas vers Epsilon 19.5. Vous pouvez vérifier la version d’Epsilon dans Paramètres, A propos.

Le point critique est donc de se procurer une version signée du firmware 19.5 pour N0110 ou N0115. Le plus simple est évidemment d’en obtenir une copie depuis une calculatrice installée avec Epsilon 19.5, en extrayant le firmware par exemple depuis le webDFU de tiplanet ou avec dfu-utils 

dfu-util -i 0 -a 0 -s 0x90000000:0x200000:force -U epsilon19.5.bin

Remarque : une grosse partie du source de ce firmware (l’userland, un peu plus de 1M) est disponible sur github, et peut donc être recompilé à l’identique. 

  git clone -b version-19 https://github.com/parisseb/epsilon
  mv epsilon epsilon19
  cd epsilon19
  make userland.onboarding.A.bin

Une petite partie, le kernel (32K environ), n’est plus disponible en code source depuis la version 18.2, elle est soumise au copyright de Numworks qui empêche sa rediffusion sans autorisation. Ce noyau n’apporte aucune fonctionnalité originale par rapport au noyau de la version 18.2, il a pour seule fonction d’interfacer avec le matériel physique de la calculatrice. Sans protection au démarrage, on pourrait interfacer le kernel 18.2 et l’userland 19.5. Mais ici il est indispensable d’avoir un kernel 19.5 avec l’userland 19.5, car ils sont combinés dans la signature. Sans être juriste, il me semble donc que la rediffusion d’un patch permettant de passer du kernel 18.2 au kernel 19.5 est conforme à l’esprit de l’article L122-6-1 du code de la propriété intellectuelle, pour assurer l’interopérabilité des applications externes de manière normale (sans usure prématurée de la flash, et avec réactivation des applications externes simultanément), mais je conseille plutôt le déverrouillage matériel. Muni du kernel et du userland, il faudra encore rajouter la 2ème signature pour pouvoir booter ce firmware. Le script mk19.5 permet de générer un firmware 19.5 à l’aide de 2 fichiers de patch (kernel 18.2 vers 19.5 et signature 19.5).

Pour installer Epsilon 19.5, faire reset+6 sur la calculatrice puis envoyer le firmware depuis le site webdfu de tiplanet ou avec une commande du type
dfu-util -i 0 -a 0 -s 0x90000000 -D epsilon19.5.bin
Une fois Epsilon 19.5 installé, vous pouvez ajouter des applications externes, et en cas de cycle d’activation/désactivation du mode examen, elles seront automatiquement réactivées, en cas de crash/reset, il suffit de rendre visible les applications externes depuis Epsilon 19.5, avec la commande
dfu-util -i 0 -a 0 -s 0x90200000:leave
ou depuis le bouton rendre visible les apps externes de ma page Numworks

4.2.3  Epsilon sur Epsilon 19.5

Si vous avez besoin de fonctionnalités des versions plus récentes de Epsilon, il est possible d’installer un lanceur de firmware en tant qu’application externe, et de recompiler un firmware, ici Epsilon 23.2.3 ou 24.10/11, à partir du source disponible sur github et de modifications pour

Commencez par cloner la branche du dépot Epsilon (24)
git clone -b backup24 https://github.com/parisseb/epsilon
ou pour la version 23
git clone -b version-23 https://github.com/parisseb/epsilon
Modifications à apporter à ion/src/device/include/n0110/config/board.h pour “shifter” l’userland de 0x160000 octets, aux lignes 69, 75, 88 : 

69c69
< constexpr uint32_t SlotAOffset = 0x00160000;
--- au lieu de
> constexpr uint32_t SlotAOffset = 0;
75c75
< constexpr uint32_t PersistingBytesVirtualOrigin = ExternalFlashOrigin + ExternalFlashLength / 2 - PersistingBytesLength - SlotAOffset;
--- au lieu de
> constexpr uint32_t PersistingBytesVirtualOrigin = ExternalFlashOrigin + ExternalFlashLength / 2 - PersistingBytesLength;
88c88
< constexpr uint32_t UserlandLength = 0x280000; // ExternalFlashLength / 2 - KernelLength - ExtraDataLength - PersistingBytesLength;
--- au lieu de
> constexpr uint32_t UserlandLength = ExternalFlashLength / 2 - KernelLength - ExtraDataLength - PersistingBytesLength;

Modification pour éviter l’écrasement du secteur de lancement des apps externes, fichier ion/src/device/userland/drivers/external_apps.cpp, rechercher la fonction App::eraseMagicCode() { et mettre au début 

   return; // do not erase magic code

On compile avec
make userland.A.allow3rdparty.bin # V=1
Puis selon la version d’Epsilon faire, pour Epsilon 23 

truncate -s 1572864 output/release/device/n0110/userland/userland.A.allow3rdparty.bin
cp output/release/device/n0110/userland/userland.A.bin userland23.bin
objdump  -C -t output/release/device/n0110/userland/userland.A.elf | sort > dump110_t

et pour Epsilon 24 

cp output/release/n0110/userland.A.allow3rdparty.bin userland24.bin
truncate -s 1441792 userland24.bin
objdump  -C -t output/release/n0110/userland.A.allow3rdparty.elf | sort > dump110_t

Puis on envoie ce userland, qui commence en 0x90170000, avec une des deux commandes
dfu-util -i 0 -a 0 -s 0x90170000 -D userland23.bin
dfu-util -i 0 -a 0 -s 0x90170000 -D userland24.bin
Pour pouvoir accéder à Epsilon 23.2.3 ou 24.10/11 depuis Epsilon 19.5, on envoie le lanceur de firmware avec la commande
dfu-util -i 0 -a 0 -s 0x90150000 -D run.bin
Le source de ce lanceur de firmware est disponible ici, il détecte un firmware à lancer sur les secteurs de flash 0x17 à 0x1f.

On peut maintenant profiter de Epsilon 23.2.3 ou 24.10/11 avec des contraintes de réinstallation d’applications externes allégées. En cas de crash/reset, il suffit de rendre visible les applications externes d’Epsilon 19.5, avec la commande
dfu-util -i 0 -a 0 -s 0x90200000:leave
ou depuis le bouton rendre visibles les apps externes de ma page Numworks, puis on relance l’application lanceur du firmware 23.2.3/24.10/11.

4.3  Installation optimisée sur N0120/N0115/N0110 avec Delta sur Epsilon

Delta est un dérivé d’Epsilon 15.5 avec les améliorations d’Upsilon, qui a été modifié pour pouvoir s’exécuter sur un noyau Epsilon (≥19\geq 19). Sur une machine verrouillée, il est possible de lancer Delta depuis une application externe installée sur l’OS officiel (Epsilon) de la calculatrice : installation de Delta. C’est une construction à plusieurs étages :

Si vous ne voulez pas installer via le navigateur, ci-dessous des binaires précompilés.

  1. pour n0110/n0115. Vérifiez (dans Paramètre, A propos) votre version d’Epsilon et passez en mode recovery (reset+6) puis
    • version 19.5 lancer le script sendn110redist19 pour la 1ère installation. Lancer le script activate19 à chaque reset/crash.
    • autres versions lancer le script sendn110redist pour la 1ère installation. Lancer le script senddelta_sector1? à chaque reset, en remplaçant le ? par 7 pour Epsilon 24/25, 8 pour Epsilon 21, 22 et 9 pour Epsilon 23. Si vous n’avez pas besoin des nouvelles fonctionnalités d’Epsilon 20 ou plus récentes, je vous conseille vivement de passer en Epsilon 19.5, car la réactivation de l’application externe lanceur ne nécessite pas de formatter le secteur de la flash de la calculatrice qui le lance.
  2. pour n0120. Passer en mode recovery (reset+6) et lancer le script sendn120redist pour la 1ère installation. Lancer le script senddelta120_sector1? à chaque reset, en remplaçant le ? par 7 pour Epsilon 24/, 8 pour Epsilon 21, 22, 25 et 9 pour Epsilon 23. Comme pour les n0110, cela use le secteur de lancement, mais il n’existe pas à ma connaissance de version 19.5 pour n0120 autorisant les applications externes.

Si vous préférez recompiler, les sources sont Delta (depuis le répertoire ion avec un des shells scripts mk110, mk120, link*, et en adaptant les fichiers ld flash et n0120.ld ou n0110.ld) et l’application lanceur (exécuter ./addr avec la Numworks branchée, pour générer le fichier ram.ld, puis make clean; make qui génère app.bin à envoyer par ./sendapp). Les applications externes ne sont pas spécifiques à un firmware, voici le source des apps externes qu’on compile avec mkarm110b ou mkarm120b du répertoire khiext.

Une fois l’installation effectuée, vous pouvez sauvegarder votre flash externe depuis le webDFU de tiplanet, ou par 

#! /bin/bash
/bin/rm flash.bin
dfu-util -i 0 -a 0 -s 0x90000000:force:0x800000 -U flash.bin

et cloner votre installation sur d’autres machines identiques en mode récupération, soit depuis le site de TI Planet, soit par la commande 

#! /bin/bash
dfu-util -i 0 -a 0 -s 0x90000000 -D flash.bin

5  Simulateur de Numworks avec χ\chiCAS (smartphone, tablette, vidéoprojection...)

Pour des questions de licences logicielles, il semble actuellement nécessaire de compiler soi-même le simulateur si on veut utiliser une version d’Epsilon récente, dont la license est maintenant "All rights reserved". Si c’est plutôt Xcas (ou Python) qui vous intéresse, vous pouvez utiliser le simulateur d’Upsilon, basé sur Epsilon 15.5, avec Xcas. Il est entièrement compatible avec l’installation de Delta sur calculatrice déverrouillée (section 3.2).

  1. Version sans installation, utilisable depuis un navigateur compatible (Firefox, Chrome,...).
    Pour lancer Xcas depuis le menu principal de la Numworks simulée, appuyez/cliquez sur la touche Back de la calculatrice simulée.
    Cette version permet de partager facilement une session de calculs Xcas éventuellement accompagné d’un programme, en affichant un QR-code qu’on peut flasher avec un smartphone ou une tablette. Pour afficher le QR-code de la session, tapez sur la touche Power du simulateur. Sur une calculatrice, il suffit de sauvegarder la session : taper shift EXE, puis choisir 2 ou 3. Appuyez sur la touche Back pour revenir au shell.
    Si vous êtes enseignant, vous pouvez préparer une session avec le simulateur ou avec Xcas et vidéo-projeter le QR-code, vos élèves peuvent alors le flasher avec un smartphone ou une tablette.
    Les versions à jour de Xcas pour calculatrices Numworks et Casio permettent également d’afficher un QR-code pour partager une session. Mais les calculatrices n’ont pas de lecteur de QR-code donc ne permettent pas de charger une session de cette manière.
  2. PC avec Windows : téléchargez upsilon.zip, ouvrez l’archive et exécutez upsilon.exe
  3. Mac version stable (testé avec OS 14.4 et 12.7.1) : téléchargez Upsilon.dmg, ouvrir l’image disque Upsilon.dmg et installez.
    Remerciements à Adrien Bertrand qui m’a aidé pour ce portage et a signé ce package.
  4. Linux ou compilation depuis le source : 
    wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/upsilon.tar.bz2
tar xfj upsilon.tar.bz2
cd Upsilon
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/ext.tar.bz2
tar xfj ext.tar.bz2
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/upsilon_cas_full.tgz
tar xfz upsilon_cas_full.tgz
    puis exécuter mksimu (Linux) ou mkmac (Mac) ou mkwin (Windows). La compilation de la version javascript fonctionne avec emscripten 1.40 et le script mkw, elle nécessite des versions des librairies GMP, MPFR et MPFI compilées avec -fPIC, ces libraries se trouvent dans l’archive emgiac3, ce répertoire contient aussi une copie de emscripten 1.40.1 installée sous Ubuntu 20 pour architecture x86_64.

Voici maintenant une procédure de compilation semi-automatisée pour Epsilon 22+Xcas (si vous souhaitez savoir ce qui se passe sous le capot, rendez-vous à la section 23.1.2)

  1. PC avec Windows
    1. Installez msys2/mingw64
    2. Ouvrir un terminal mingw64 depuis le menu principal de toutes les applications windows, msys2. Dans le menu Options de la fenêtre mingw64 (coin en haut à gauche), sélectionner Keys, puis cocher Ctrl-shift-letter shortcut, ceci vous permettra de coller avec Ctrl-shift-V.
    3. copiez-collez dans le terminal (Ctrl-C puis Ctrl-shift-V)
      pacman -S wget
      wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/nwwin
      ./nwwin
      Patientez, le temps que le compilateur fasse le travail. Si tout va bien le simulateur epsilon.exe va s’ouvrir. L’exécutable du simulateur est c:\msys64\home\username\epsilon\epsilon.exe où username est votre nom d’utilisateur. Vous pouvez le recopier dans un autre répertoire ou sur un autre PC.
      Attention, les licences ne permettent pas la publication de cet exécutable.
  2. Mac :
    1. Depuis le launchpad, tapez Terminal dans le champ de recherche, ceci vous permet d’ouvrir un Terminal
    2. Téléchargez le fichier nwmac, vérifiez qu’il se trouve dans votre répertoire Téléchargements (Downloads)
    3. Copiez-collez (command-c et command-v) la commande
      ~/Downloads/nwmac
      Patientez, le temps que le compilateur fasse le travail. Si tout va bien le simulateur va s’ouvrir. Il a été automatiquement recopié dans le répertoire /Applications et peut donc se lancer comme n’importe quelle autre application.
    4. Optionnel : si vous souhaitez faire une installation sur un autre Mac dans un cadre d’utilisation privée
      Un package Khicasnw.pkg a été créé dans le répertoire Téléchargements. Vous pouvez faire une image disque en lançant l’utilitaire de disque Mac puis menu Fichier, nouvelle image. Recopiez le package dans l’image disque, éjectez l’image disque du Finder puis recopiez l’image disque vers l’autre Mac (par le réseau ou avec une clef USB), et ouvrez-là avec le Finder de l’autre Mac puis cliquez sur le package en maintenant la touche Control enfoncée.
      Attention, les licences ne permettent pas la publication de cette image disque.
  3. Linux : cf. la section 23.1.2

Pour lancer le simulateur, tapez ./simu (Linux) ou cliquez sur upsilon.exe (windows) ou ouvrir upsilon.app dans Applications (mac) (ou epsilon.app depuis le répertoire epsilon si vous compilez la version Epsilon 22). Ensuite pour lancer χ\chiCAS, vous pouvez utiliser le raccourci Esc depuis le menu principal de la Numworks simulée. Attention, la touche shift du clavier ne simule pas la touche shift de la calculatrice, afin de pouvoir composer les caractères tels que 1 à 9 ou 0 sur un clavier français. Il faut taper la touche Alt gauche du PC ou Opt gauche du Mac pour simuler un appui sur shift. Pour faire une copie d’écran du simulateur, tapez Ctrl-P, sous Linux la copie est sauvegardée sous le nom /numworks/epsilon.png, pensez à le renommer avant une nouvelle capture écran. Le source du simulateur prévoit de pouvoir faire shift-Ctrl-P pour copier dans le presse-papier, mais ce n’est pas encore fonctionnel avec Linux/Windows, seulement sur Mac.

Le simulateur simule la flash utilisateur avec un fichier nommé scripts.tar. Vous pouvez le créer avec l’utilitaire d’achivage tar en y mettant des sessions Xcas (sauvegardées dans Xcas depuis le menu Fichier, Exporter comme, HP/Casio) et des scripts Python. Vous pouvez utiliser comme exemple le fichier khi92.tar dont l’installation est proposée en même temps que χ\chiCAS sur les calculatrices, il suffit de le renommer scripts.tar et de le copier dans le répertoire Documents sur Mac ou dans le répertoire courant sur Linux/Windows.

6  Premiers pas

N.B. : vous pouvez aussi consulter ce Tutoriel par fmOOmf et Yaya.Cout.

Depuis le menu principal de la Numworks, déplacez le curseur jusqu’à l’icone χ\chiCAS puis tapez EXE (raccourci clavier, selon la version de χ\chiCAS + ou Back, puis EXE). Ceci ouvre un “shell” dans lequel vous pouvez taper la plupart des commandes de calcul formel de Xcas. Au premier lancement, vous avez le choix de l’évaluateur entre Xcas et MicroPython, on suppose ici que vous choisissez Xcas en tapant OK ou EXE. Si vous avez choisi MicroPython, lisez la section correspondante 17. Pour passer à Xcas (respectivement Python), depuis une ligne de commande vide, taper les touches shift ) 8 OK.

Par exemple, tapez 1/2+1/6 puis EXE, vous devriez voir le résultat 2/3 s’afficher sur la ligne du dessous.

Vous pouvez recopier dans la ligne de commande une commande de l’historique en utilisant le curseur vers le haut ou vers le bas puis EXE, puis vous pouvez modifier la commande et l’exécuter. Par exemple, taper sur la touche curseur vers le haut, EXE et remplacez 1/6 par 1/3.

Vous pouvez utiliser le résultat de la dernière commande avec la touche Ans de la calculatrice. Il vaut en général mieux définir une variable comme résultat d’une commande si on souhaite la réutiliser. Pour cela, on utilise une des deux instructions d’affectation :

Pour vous aider à saisir les commandes Xcas les plus utiles, χ\chiCAS dispose d’un catalogue d’une centaine de commandes, avec une courte description et le plus souvent un exemple d’exécution facile à recopier. Appuyez sur la touche Toolbox, choisissez une catégorie avec le curseur, par exemple Algebre, tapez EXE, puis choisissez une commande avec le curseur, par exemple factor. Un deuxième appui sur la touche Toolbox vous affiche une courte description de la commande, en général avec un exemple. En tapant sur Ans (ou EXE), vous recopiez l’exemple en ligne de commande. Vous pouvez alors valider (EXE) ou modifier la commande et valider (EXE) pour factoriser un autre polynôme que celui donné en exemple. Essayez avec factor (touche Toolbox, puis Algebre).

Parmi ces commandes, celles qui sont le plus utilisées sont accessibles par des menus rapides activés par la touche shift suivi d’un chiffre, de ., de 10^x, de ( ou de ), comme le rappelle la ligne en bas de l’écran, par exemple shift suivi de 1 affiche un menu d’algèbre où on retrouve la commande factor.

Lorsqu’une commande est entrée sans arguments, un “tooltip” (petit rectangle sur fonds jaune) affiche une courte description de ce que fait la commande et la syntaxe, pour voir en entier l’aide sur la commande il suffit de taper sur la touche flèche vers le bas (ou sur la touche var). Taper sur Ans pour entrer les arguments du premier exemple de l’aide. Taper sur la touche Back (à droite de OK) pour effacer le tooltip.

Lorsque vous exécutez une commande et qu’elle renvoie une expression, celle-ci est affichée en écriture naturelle (affichage 2-d). Vous pouvez faire défiler l’affichage avec les touches du curseur lorsque l’expression est grande. Tapez sur Back (à droite de OK) pour revenir au shell.

Maintenant essayez de taper la commande plot(sin(x)). Indication: tapez Toolboox, puis sélectionner Courbes, ou utilisez le menu rapide shift 3.

Lorsqu’une commande renvoie un graphe, celui-ci est affiché. Vous pouvez modifier la fenêtre graphique d’affichage avec les touches + ou - (zoom in ou out), les touches du curseur, orthonormaliser le repère (touche /) ou faire une recherche automatique de l’échelle (autoscale touche *). Pour enlever ou remettre les axes et graduations, tapez sur var. Tapez sur Back pour revenir au shell.

Vous pouvez effacer l’historique des calculs et les variables pour commencer un nouvel exercice : ouvrez le menu principal taper shift puis EXE, sélectionnez 9 Effacer historique. Vous avez ensuite le choix entre effacer l’écran en conservant les variables (OK) ou en les effaçant (Back). Vous pouvez visualiser la place occupée par les variables en tapant sur la touche var. Pour effacer une variable pour faire de la place en mémoire, sélectionnez la commande purge dans ce menu, puis taper le nom de variable à effacer (ou sélectionnez la variable depuis le menu var).

Pour revenir au menu principal de la Numworks, il faut taper HOME. Sur la plupart des installations, la touche HOME renvoie directement au menu principal de la Numworks, pour accéder au menu de χ\chiCAS, il faut taper les touches shift puis EXE. Sur les N0110 non verrouillées avec Omega/Upsilon/Khi, la touche HOME ouvre le menu de χ\chiCAS, pour revenir au menu de la Numworks, il faut taper HOME plusieurs fois (2 fois depuis le shell).

Lorsque vous quittez χ\chiCAS, les variables et l’historique des calculs sont sauvegardés, ils seront restaurés lorsque vous reviendrez dans χ\chiCAS.

Remarques :

7  Sauvegarde et échange de données.

Remarque : Si votre session n’est pas trop grande, vous pouvez l’afficher sous forme de QR code sur la calculatrice. Depuis le shell, ouvrir le menu Fichier (touches shift EXE ou touche HOME selon la version de χ\chiCAS), choisir Enregistrer session, mettre le cas échéant un nom de session. Le QR code s’affiche, vous pouvez le scanner avec un smartphone et obtenir un clone de votre session sur votre smartphone. Le QR code s’affiche également si vous quittez χ\chiCAS depuis le menu principal (shift EXE ou HOME deux fois de uite).

Si vous disposez du cable adéquat, vous pouvez connecter le smartphone à une autre Numworks et y recopier la session (cf. section suivante). Si vous n’avez pas de cable adéquat, vous pouvez appuyer avec le doigt sur l’icone d’enveloppe en haut et envoyer la session par email, puis depuis un PC vous pourrez recopier la session sur une autre calculatrice.

7.1  Depuis un navigateur webusb (Chromium ou Chrome ...)

7.2  Depuis Xcas pour Windows, Linux

Vérifiez que Xcas. est en version 1.7.0-31 ou ultérieure, si nécessaire installez ou mettez à jour.

Sous Linux, vérifiez que dfu-util est bien installé et que le fichier 50-numworks-calculator.rules a été copié dans /etc/udev/rules.d. Si vous avez installé un package debian, cela peut se faire par la commande
sudo cp /usr/share/giac/doc/50-numworks-calculator.rules /etc/udev/rules.d

Les outils pour se connecter avec la Numworks se trouvent dans le menu Fich, sous-menu Numworks. Vous pouvez :

Sur Mac, il est recommandé d’utiliser le kit de connectivité web Numworks de la section précédente.

7.3  Gestion de la mémoire flash sur la calculatrice

Depuis la version du 14 octobre 2021, vous pouvez lancer un mini-gestionnaire de fichiers en flash depuis le menu Applications de χ\chiCAS (touches shift Ans puis valider puis avant-avant-dernier item). Ce gestionnaire permet

Attention, si vous faites des modifications, cela écrit en flash, or on ne peut pas écrire indéfiniment sur le même secteur en flash (pour la flash externe, Numworks a assigne une taille de 64K aux secteurs). Pour augmenter la durée de vie de la mémoire flash, il est conseillé de ne vider la corbeille que lorsqu’il est vraiment nécessaire de faire de la place. En effet, si on ne vide pas la corbeille, les nouveaux fichiers ajoutés en flash vont progressivement être écrits dans de nouveaux secteurs, ce qui répartira mieux l’usure de la flash. (Un “vrai” système de fichiers fait normalement cela automatiquement). Si vous n’avez pas besoin de beaucoup de place pour stocker des fichiers par rapport à la place disponible (6*64K à 1M selon la version de χ\chiCAS), vous pouvez aussi ajouter un gros fichier inerte de taille un multiple de 64K vers le début de l’archive (à partir du fichier d’indice 10 si vous voulez conserver la certification sur les N0110 non verrouillées), que vous changez de temps en temps.

Par ailleurs, lorsque vous lancez le mode examen sur les N0110 non verrouillées utilisant Khi, l’état de la calculatrice est automatiquement sauvegardé dans le dernier secteur de la mémoire flash (sauf s’il n’y a aucun script Python). Plus tard, lorsque vous avez quitté le mode examen (en branchant la calculatrice), vous pouvez restaurer l’état de la calculatrice depuis le menu shift EXE (ou HOME), Configuration/mode examen.

8  Commandes usuelles de calcul formel

8.1  Développer et factoriser

Depuis le catalogue, sélectionner le sous-menu Algebre (2) ou le menu rapide shift-1

8.2  Analyse

Depuis le catalogue (Toolbox), sélectionner le sous-menu Analyse (4) ou le menu rapide shift-2

8.3  Résoudre

Depuis le catalogue, sélectionner le sous-menu Resoudre (Toolbox puis touche ln)

8.4  Arithmétique

Lorsque cela est nécessaire, on distingue l’arithmétique des entiers de celle des polynômes par l’existence du préfixe i (comme integer) dans un nom de commande, par exemple ifactor factorise un entier (pas trop grand) alors que factor factorise un polynôme (et cfactor factorise un polynôme sur les complexes). Certaines commandes fonctionnent à la fois pour les entiers et les polynômes, par exemple gcd et lcm.

8.4.1  Entiers

Depuis le catalogue, sélectionner le sous-menu Arithmetic, Crypto (Toolbox 5)

Les commandes asc et char permettent de convertir une chaine de caractères en liste d’entiers (entre 0 et 255) et réciproquement, ce qui permet de faire facilement de la cryptographie avec des messages sous forme de chaines de caractères.

8.4.2  Polynômes

Depuis le catalogue, sélectionner le sous-menu Polynomes (8). La variable est par défaut xx, sinon il faut la spécifier en général en dernier argument, par exemple degree(x^2*y) ou degree(x^2*y,x) renvoient 2, alors que degree(x^2*y,y) renvoie 1

8.4.3  ℤ/nℤ\mathbb{Z}/n\mathbb{Z} et corps finis

Pour travailler avec des classes modulo nn, utiliser la notation a mod n, par exemple sqrt(2 mod 7). Ceci s’applique aussi pour travailler sur des corps finis premiers ℤ/pℤ\mathbb{Z}/p\mathbb{Z}. Pour travailler sur des corps finis non premiers, il faut d’abord définir le corps avec GF, puis on utilise un polynôme en le générateur du corps.

8.5  Algèbre linéaire, vecteurs, matrices

Xcas ne fait pas de différence entre vecteur et liste. Par exemple pour faire le produit scalaire de deux vecteurs, on peut saisir : 

v:=[1,2]; w:=[3,4]

onload

Pour saisir une matrice élément par élément, taper sur shift-7 (touche M comme matrice) puis matrix( ou selon le modèle shift EXE i ou HOME i (editer matrice). Vous pouvez ensuite créer une nouvelle matrice ou éditer une matrice existante parmi la liste de variables proposées. Pour de petites matrices, vous pouvez aussi entrer en ligne de commandes une liste de listes de même taille. Par exemple pour définir la matrice A=(1 2 3 4)A=\left(\begin{array}{cc} 1 & 2 \\ 3 & 4 \end{array}\right) on tape 

A:=[[1,2],[3,4]]

onload
ou

Il est fortement conseillé de stocker les matrices dans des variables pour éviter de les saisir plusieurs fois.

Pour entrer une matrice dont les coefficients sont donnés par une formule, on peut utiliser la commande matrix, par exemple

renvoie la matrice dont le coefficient ligne jj et colonne kk vaut 1j+k+1\frac{1}{j+k+1} (attention les indices commencent à 0).

La matrice identité de taille nn est renvoyée par la commande idn(n), alors que ranm(n,m,loi,[parametres]) renvoie une matrice à coefficients aléatoires de taille n,mn,m. Par exemple



Pour exécuter une commande sur des matrices, s’il s’agit d’arithmétique de base (+,-,* inverse), on utilise les opérations au clavier. Pour les autres commandes. depuis le catalogue, sélectionner le sous-menu Matrices (Toolbox sin)

9  Probabilités et statistiques

9.1  Tirages aléatoires

Depuis le catalogue, sélectionner le sous-menu Probabilites (Toolbox 9) puis sélectionnez
(réel selon la loi uniforme dans [0,1][0,1]) ou
(entier entre 1 et nn). De nombreuses autres fonctions aléatoires existent, avec comme préfixe rand, suivi par le nom de la loi, par exemple randbinomial(n,p) renvoie un entier aléatoire selon la loi binomiale de paramètres n,pn,p. Pour créer un vecteur ou une matrice aléatoire, utiliser la commande ranv ou ranm (menu Alglin, Matrice), par exemple pour un vecteur de 10 composantes selon la loi normale centrée réduite

9.2  Lois de probabilités

Depuis le catalogue, sélectionner le sous-menu Probabilites (9). Les lois proposées dans le catalogue sont la loi binomiale, la loi normale, la loi exponentielle et la loi uniforme. D’autres lois sont disponibles depuis Tout : chisquared, geometric, multinomial studentd, fisherd, poisson.

Pour obtenir la distribution cumulée d’une loi, on saisit le nom de la loi et le suffixe _cdf (sélectionner cdf dans le catalogue sous-menu Probabilités et taper Ans). Pour obtenir la distribution cumulée inverse, on saisit le nom de la loi et le suffixe _icdf (sélectionner cdf dans le catalogue sous-menu Probabilités et taper EXE).

Exemple : calcul de l’intervalle centré II pour la loi normale de moyenne 5000 et d’écart-type 200 tel que la probabilité d’être en-dehors de II soit de 5% :

9.3  Statistiques descriptives 1-d

Ces fonctions agissent sur des listes par exemple 

l:=[9,11,6,13,17,10]

onload
Depuis le catalogue, sélectionner le sous-menu Statistiques (Toolbox log)

Pour les statistiques 1-d de listes avec effectifs, on remplace l par deux listes de même longueur, la 1ère liste est la liste des valeurs de la série statistique, la 2ème liste est la liste des effectifs. Voir aussi les commandes du menu shift-3 histogram et barplot.

9.4  Statistiques descriptives 2-d, régressions.

Voir aussi la section 19 expliquant le tableur.

Entrez les deux listes de données dans deux variables, par exemple X:=[1,2,3,4,5] et Y:=[3,5,6,8,11], ou dans une variable matrice ayant 2 colonnes, depuis le shell avec le menu shift-6 8 matrix(.
Depuis le catalogue, sélectionner le sous-menu Statistiques (touches Toolbox log), pour les régressions, depuis le shell, tapez shift-6.

Ainsi pour afficher la droite de régression linéaire correspondant aux données X=[1,2,3,4,5] et Y=[3,5,6,8,11], tapez les deux commandes ci-dessus ou éditez une matrice ayant 2 colonnes avec le raccourci shift-6 8. Puis shift-6 EXE (ou Toolbox log puis sélectionnez la commande linear_regression_plot() complétez la commande par X,Y) ou par le nom de variable de la matrice puis EXE.

Remarque : si vos données sont dans une matrice m ayant 2 lignes au lieu de 2 colonnes, vous pouvez utiliser m^* pour transposer (en fait cela transconjugue, ce qui est identique pour des données réelles).

10  Courbes et autres représentations graphiques.

Pour obtenir une représentation graphique, on saisit une commande de tracé (ou plusieurs commandes séparées par ;). Depuis le catalogue, sélectionner le sous-menu Courbes (accès rapide par Toolbox 7, ou shift-3 depuis le shell).

Lorsqu’un graphique comporte des tracés de courbes (graphes de fonction, courbes en paramétriques ou en polaires), le mode “trace” est activé par défaut. Dans ce mode, l’appui sur la touche curseur vers la droite ou la gauche permet de déplacer un pointeur sur la courbe active, en affichant les coordonnées du pointeur (et du paramètre pour une courbe en paramétriques) et d’un vecteur tangent. S’il y a plusieurs arcs de courbe, les touches de curseur haut et bas permettent de changer l’arc d’étude. L’appui sur shift-2 permet d’afficher les informations sur la courbe courante, si on confirme par OK ou EXE on accède à un tableau de valeurs.

Le menu Toolbox item 2 étude de courbes (raccourci touche x,n,t) permet d’ajouter un vecteur normal pointant vers le centre de courbure (raccourci shift-4), ou/et le cercle osculateur (shift-5) et le rayon de courbure. On peut aussi à partir de ce menu déplacer le pointeur vers une position déterminée, ou vers un point remarquable: racine, tangente horizontale ou verticale, point d’inflexion, intersection avec un autre arc de courbe. On peut enfin calculer une longueur d’arc ou l’aire sous la courbe entre le pointeur et la marque.

Lorsque vous faites une étude de courbe, les variables x0,x1,x2,y0,y1,y2 sont automatiquement affectées avec l’expression de la position, vitesse et accélération sur la courbe étudiée. Lors de la recherche d’une racine, tangente horizontale, inflexion, longueur d’arc, aire sous la courbe, des variables contenant la dernière recherche sont crées.

Le menu Options (Toolbox ,) vous permet de spécifier certaines options graphiques :

Les versions récentes de χ\chiCAS permettent de représenter en 3d ou 4d des fonctions de 2 variables à valeur réelle ou complexe, par exemple plot(x^2-y^2) pour représenter la fonction de ℝ 2→mahtbbR\mathbb{R}^2 \rightarrow \mahtbb{R} ou plot((x+i*y)^2-9) pour représenter la fonction de ℂ→mahtbbC\mathbb{C} \rightarrow \mahtbb{C} qui à zz associe z 2−9z^2-9. Dans ce dernier cas, le module est représenté selon l’axe OzOz et l’argument par une couleur de l’arc en ciel, de −π-\pi en bleu violet à 0 en vert (en passant par jaune et orange) et de 0 à π\pi en passant par cyan.

Pour préciser des options en 3d/4d, il faut utiliser la commande plotfunc, par exemple
plotfunc((x+i*y)^3-1,[x=-2..2,y=-2..2],nstep=500)
pour tracer z→z 3−1z \rightarrow z^3-1 depuis le carré du plan complexe centré en l’origine de coté 4, avec une discrétisation utilisant 500 petits rectangles.

11  Géométrie analytique 2d/3d.

Les commandes de géométrie analytique permettent de créer des objets géométriques et de calculer les caractéristiques d’objets géométriques, par exemple créer une droite passant par deux points, trouver les coordonnées de points d’intersection, l’équation cartésienne ou les équations paramétriques d’une droite, de plans, cercles, ... Elles sont par exemple utiles pour vérifier les calculs de géométrie dans l’espace en spécialité maths en Terminale. Ces commandes ne sont pas limitées à de la géométrie “pure” mais permettent également de gérer des courbes et d’effectuer des calculs (par exemple longueur de courbe, courbure, repère de Frénet...). Les commandes les plus utilisées se trouvent dans le menu Toolbox vers la fin, raccourcis claviers depuis le menu Toolbox x 2x^2 et ( pour la géométrie dans le plan et dans l’espace respectivement.

Ces commandes peuvent s’utiliser directement dans le shell de χ\chiCAS, depuis l’éditeur de programmes, ou dans l’application de géométrie interactive décrite à la section 12. L’utilisation dans le shell est particulièrement bien adaptée à de petites constructions, pour lesquelles la visualisation des objets géométriques n’apporte pas énormément, comme on en trouve actuellement dans les exercices de géométrie 3d en Terminale spécialité maths (il s’agit en fait d’exercices d’algèbre linéaire déguisés). Lorsqu’on veut créer et visualiser des constructions géométriques avec beaucoup d’objets, il vaut mieux apprendre à utiliser l’application de géométrie interactive (section 12).

11.1  Construction d’objets géométriques.

Un objet géométrique se construit avec une commande, par exemple


permet de créer le point du plan de coordonnées (1,2), A:=point(1,2,3) le point 3d de coordonnées (1,2,3). Un droite se construit avec 2 points en argument, ou un point et un vecteur directeur, ou avec une équation cartésienne, ou pour une droite du plan avec un point et une pente.

Les commandes de géométrie du plan acceptent l’affixe complexe d’un point comme argument équivalent à un point, par exemple


crée la droite passant par les points d’affixe 1+2i1+2i et 2−i2-i (donc les points de coordonnées (1,2) et (2,-1)).

Lorsqu’une commande du shell renvoie un objet géométrique, on en voit la représentation graphique 2d ou 3d. Cette représentation affiche uniquement les objets présents dans la commande. Pour voir tous les objets géométriques créés, il suffit de taper une commande contenant les noms de variable de tous les objets. Par exemple tapez successivement (en vous aidant du menu Toolbox x 2x^2








Si vous ne voulez pas avoir l’affichage d’un objet géométrique, il suffit de terminer votre commande par :;. Par exemple


stocke dans la variable M la médiatrice du segment ABAB sans l’afficher.

Exemple hors géométrie “pure”









11.2  Propriétés d’objets géométriques

Il s’agit de commandes qui renvoient des données numériques ou symboliques caractéristiques d’un objet géométrique, par exemple les coordonnées d’un point


l’équation cartésienne d’une droite


On peut chainer ces commandes, par exemple pour avoir le rayon du cercle circonscrit aux 3 points A,B,CA,B,C préalablement définis dans les variables de même nom, on tape



11.3  Exemples au bac

11.3.1  2025 métropole jour 1, exercice 3

Voici des indications pour vérifier l’exercice 3 du sujet 2025 de métropole jour 1. Construction initiale : 

A=point(-1,0,5)
B=point(3,2,-1)
O=point(0,0,0)

affirmation 1 : VRAIE
B-A renvoie les coordonnées du vecteur directeur de ABAB et on compare avec celui de l’équation paramétrique, qui passe en t=0t=0 par BB. Attention une droite admet plusieurs représentations paramétriques, parameq(droite(A,B)) ne donne pas la même équation que celle de l’énoncé.

affirmation 2 : FAUSSE
eq:=equation(plan(O,A,B)) renvoie −10*x+14*y−2*z=0-10*x+14*y-2*z=0 donc un vecteur normal au plan est (-10,14,-2), qui n’est pas colinéaire au vecteur nn

affirmation 3 : VRAIE
on voit que les 2 droites ne sont pas parallèles (vecteurs directeurs non colinéaires) on teste si elles sont sécantes
solve([15+k=1+4s,8-k=2+4s,-6+2],[k,s]) renvoie [[-4,5/2]] donc sécantes, donc coplanaires

affirmation 4 : VRAIE
C=point(2,-1,2)
distance(plan(x-y+z+1=0),C) renvoie 232\sqrt{3}. on peut aussi le faire de tête en remplaçant les coordonnées de CC dans l’équation du plan et en divisant par la racine carrée de la somme des carrés des coefficients de x,y,zx,y,z (c’est la norme du vecteur normal, 3\sqrt{3})
(2-(-1)+2+1)/sqrt(1+1+1)

11.3.2  2025, métropole, jour 2, exercice 2

Ci-dessous des indications pour vérifier l’exercice 2 du sujet de métropole 2025 jour 2.

Partie A

  1. solve([3/2+2t=s,2+t=3/2+s,3-t=3-2s],[t,s])
    renvoie [[-1,-1/2]] donc t=−1t=-1 (et s=−1/2s=-1/2), les droites sont bien sécantes et
    S0=subst([3/2+2t,2+t,3-t],t=-1)
    S=point(S0)
    Attention S0S0 n’est pas un point géométrique mais la liste des coordonnées de SS.
  2. A=point(-1,2,1)
    B=point(1,-1,2)
    C=point(1,1,1)
    n=[1,2,4]
    La différence de 2 points est le vecteur les reliant, et * entre 2 vecteurs calcule leur produit scalaire (B-A)*n renvoie 0, de même pour (C-A)*n donc nn est normal au plan.
    subst(x+2y+4z,[x,y,z],coordonnees(A)) renvoie 7, c’est la bonne constante pour l’équation du plan.
  3. subst(x+2y+4z,[x,y,z],S0) renvoie 35/2 donc SS n’est pas dans le plan ABCABC.
  4. a/ H=point(-1,0,2), H-S renvoie [-1/2,-1,-2] soit −n/2-n/2 et subst(x+2y+4z,[x,y,z],H) renvoie 7
    b/ distance(H,S) renvoie (sqrt(21))/2, c’est la distance de S à son projeté, donc la distance minimale entre un point de ABCABC et SS.

Partie B
On paramètre le segment CSCS avec un réel k∈[0,1]k \in [0,1]
M=C+k*(S-C)
coordonnees(M)

Le triangle est rectangle en MM si le produit scalaire des vecteurs AMAM et BMBM est nul
eq=(M-A)*(M-B)
sol=solve(eq=0,k) renvoie list[(-6*sqrt(14)+12)/45,(6*sqrt(14)+12)/45], evalf(sol) met en évidence une solution dans l’intervalle [0,1]
Ou numériquement
fsolve(eq=0,k)
il y a une solution sur le segment (k=0.76...k=0.76...).

Autre méthode, on cherche si le segment CSCS intersecte la sphère de centre le milieu de ABAB passant par AA et BB :
I=inter(segment(C,S),sphere(milieu(A,B),distance(A,B)/2))
coordonnees(I)
renvoie [[-(sqrt(14)-3)/5,1,-(-2*sqrt(14)-9)/5]]

11.3.3  Indications pour les autres sujets de Terminale 2025 1ère sessios

Vous pouvez trouver d’autres exemples dans les indications de correction des sujets de Terminale spécialité maths de 1ère session du bac 2025 pour Casio Graph 90 sur le forum de Xcas. Les commandes sont identiques, les raccourcis claviers principaux de la Casio se traduisent de la manière suivante sur la Numworks :

12  Application de géométrie interactive 2d/3d.

L’application de géométrie permet de construire des figures dans le plan ou dans l’espace, et de faire bouger un point et tout ce qui en dépend pour illustrer certaines propriétés (géométrie dynamique). On peut faire des constructions de géométrie euclidienne pure, mais aussi avec des graphes de fonction, des coniques, etc. L’application possède deux “vues”: la vue graphique et la vue symbolique qui contient les commandes Xcas permettant de créer la figure (la philosophie de cette application est proche de celle du logiciel Geogebra, avec les commandes de Xcas).

12.1  Modes, vue graphique et symbolique.

Taper shift-Ans pour afficher la liste des applications additionnelles, puis OK puis sélectionnez soit une nouvelle figure 2d ou 3d soit une figure existante. Vous pouvez aussi ouvrir l’application de géométrie depuis un graphe (par exemple après avoir tapé plot(sin(x))) en tapant shift EXE ou Home selon le modèle puis Sauvegarder figure.

Au lancement on est dans la vue graphique en mode repère, les touches de curseur permettent de changer de point de vue. Pour changer le mode, utiliser la touche Toolbox, pour passer en vue symbolique et vice-versa taper OK. Par exemple tapez Toolbox 3 pour passer en mode point qui permet de construire des points en déplaçant le pointeur et en tapant OK ou tapez Toolbox 5 pour passer en mode triangle qui permet de construire un triangle à partir de ses 3 sommets, on déplace le pointeur et on tape OK trois fois. Pour déplacer le pointeur, utiliser les touches de déplacement, pour se déplacer plus rapidement, faire shift touche de curseur. Si on est proche d’un point existant, son nom apparait en bas. Pour déplacer le pointeur vers un point existant, vous pouvez aussi taper le nom du point (par exemple touche alpha A).

Le mode pointeur permet de sélectionner un point et de le déplacer pour observer comment la construction varie, ce qui permet de mettre en évidence des propriétés de la figure, par exemple concurrence de 3 droites.

Si vous tapez sur la touche Back depuis la vue graphique de l’application, vous revenez au mode repère ou si vous y étiez vous passez en vue symbolique. Vous pouvez ajouter des objets à la construction depuis cette vue, en mettant une commande par ligne. Tapez EXE pour passer à la ligne. Tapez OK pour revenir à la vue graphique. Dans la vue symbolique, vous pouvez sauvegarder la construction géométrique au format texte (avec une extension .py, même s’il ne s’agit pas d’un script Python). Tapez Back pour quitter l’application de géométrie.

Lorsque vous quittez l’application de géométrie, la figure est automatiquement sauvegardée dans une variable Xcas qui a le même nom que celui du nom de fichier affiché dans la vue symbolique. Vous pouvez purger la variable Xcas si vous voulez effacer la figure de la session.

12.2  Exemples

12.2.1  Exemple 2d : cercle circonscrit.

Depuis le shell, taper shift-Ans sélectionner nouvelle figure 2d et valider OK. Puis Toolbox 5 Triangle, OK pour créer le premier sommet du triangle puis déplacer le pointeur avec les touches de déplacement, OK pour créer le 2ème sommet du triangle, déplacer le pointeur à nouveau et OK pour créer le triangle.

Version longue en construisant le centre : Taper Toolbox 7, sélectionner 8 Mediatrice, déplacer le pointeur de sorte que seul un segment du triangle soit sélectionné (affichage en bas à droite perpen_bisector D5,D), taper OK pour créer la médiatrice du segment, déplacer le curseur sur une autre arête du triangle et OK pour créer la 2ème médiatrice, optionnellement sur le 3ème segment pour avoir les 3 médiatrices. Puis Toolbox 6 et 4 Intersection unique. Déplacer le curseur vers une des médiatrices, taper OK puis vers une autre médiatrice, taper OK, ceci crée le centre du cercle circonscrit. Pour tracer le cercle, taper Toolbox 4, déplacer le curseur au centre du cercle (vous pouvez utiliser les touches de déplacement ou juste taper alpha H ou la bonne lettre si le centre du cercle s’appelle autrement), puis OK puis sur un des sommets et OK.

Version courte avec la commande circonscrit : taper Toolbox 9 puis circonscrit puis sélectionner chaque sommet avec OK (alpha A OK alpha B OK alpha C OK, remplacez A, B, C par les lettres du sommet du triangle).

Version en vue symbolique : taper Back puis en fin de script sur une ligne vide (taper EXE s’il faut en créer une), taper
c:=circonscrit(A,B,C) OK

12.2.2  Exemple 3d: bac septembre 2019 

On considère un cube ABCDEFGHABCDEFGH et on vérifie que le segment DEDE est perpendiculaire au plan ABGABG
Taper shift Ans pour lancer l’application de géométrie puis nouvelle figure 3d.

La construction est donc la suivante: 

c=cube([0,0,0],[1,0,0],[0,1,0])
A,B,C,D,E,F,G,H=sommets(c)
P=plan(A,B,G,display=filled+green)
S=segment(D,E,display=cyan)

Vous pouvez taper OK pour la visualiser et utiliser les flèches de déplacement pour changer de point de vue. Taper OK ou Back pour revenir en vue symbolique. Pour quitter l’application taper Back. Taper OK pour sauvegarder la figure si nécessaire.

Vous pouvez depuis le shell de χ\chiCAS accéder à de nombreuses informations de géométrie analytique, par exemple equation(P) (menu Toolbox Géométrie) vous donnera l’équation cartésienne du plan PP ou is_orthogonal(P,S) (à saisir depuis le catalogue complet Toolbox OK) vous confirmera que le plan PP est orthogonal au segment SS.

13  Unités et constantes physiques.

Le menu Toolbox permet d’ouvrir un sous-menu constantes physiques (raccourci Toolbox pi) et unités physiques (raccourci Toolbox sqrt) avec

Exemples de commandes :
60_(km/h) => _(m/s)
mksa(_hbar_)
usimplify(1_W*1_s)
ufactor(1_W,1_J)

14  Éditeur d’expressions

Lorsqu’un calcul renvoie une expression, elle est affichée en plein écran dans l’éditeur d’expression 2d. Depuis l’historique des calculs, si le niveau sélectionné est une expression, l’appui sur shift-5 (2d) affiche l’expression dans l’éditeur 2d. En ligne de commande, l’appui sur shift-5 ouvre aussi l’éditeur 2d, soit avec 0 si la ligne de commande était vide, ou avec le contenu de la ligne de commande si celle-ci est syntaxiquement correcte.

Lorsque l’éditeur 2d est ouvert, l’expression est affichée en plein écran et une partie de l’expression est sélectionnée. On peut alors agir sur la sélection en exécutant des commandes saisies via les menus ou le clavier, on peut aussi éditer la sélection (en mode de saisie 1d). Ceci permet de retravailler des sous-expressions ou d’éditer une expression en écriture naturelle.

Vous pouvez annuler la dernière modification effectuée en tapant sur shift-3 (undo).

Taper OK pour quitter l’éditeur 2d et copier l’expression en ligne de commande, taper Back pour quitter sans recopier l’expression.

Exemple 1 : nous allons saisir lim x→0sin(x)x\lim_{x \rightarrow 0} \frac{\sin(x)}{x} Depuis une ligne de commande vide, taper shift-5 (2d), vous devez voir 0 sélectionné. Tapez sur la touche x et EXE, maintenant c’est x qui est en surbrillance. Tapez sur la touche sin, c’est sin(x)\sin(x) qui est en surbrillance. Tapez sur la touche de division (au-dessus de -), vous devez voir sin(x)0\frac{\sin(x)}{0} avec 0 en surbrillance, tapez x puis EXE, vous devez voir sin(x)x\frac{\sin(x)}{x} avec x au dénominateur en surbrillance. Tapez sur le curseur flèche vers le haut pour mettre sin(x)x\frac{\sin(x)}{x} en surbrillance, puis shift-2 4 (pour limit). L’expression est correcte, vous pouvez taper OK pour la recopier en ligne de commande et OK à nouveau pour exécuter le calcul. Si on avait voulu une limite en +∞+\infty, il aurait fallu déplacer la sélection avec curseur vers la droite, puis faire shift-1 7 (oo) OK.

Exemple 2 : nous allons saisir ∫ 0 +∞1x 4+1dx\int_0^{+\infty} \frac{1}{x^4+1} \ dx Depuis une ligne de commande vide, taper shift-5 (2d), puis shift-2 3 (integrate), vous devez voir ∫ 0 10dx\int_0^1 0 \ dx avec xx sélectionné. Il faut donc changer le 1 de la borne supérieure et le 0 à intégrer. Pour modifier le 0, curseur vers la gauche pour le sélectionner puis 1/(x^4+1) EXE, puis curseur vers la gauche shift-1 7 EXE. Taper sur OK pour recopier vers la ligne de commande puis OK pour effectuer le calcul, le résultat s’affiche dans l’éditeur 2d, OK quitte l’éditeur avec dans l’historique l’intégrale et sa valeur (en syntaxe algébrique 1d).

Exemple 3 : nous allons calculer et simplifier ∫1x 4+1dx\int \frac{1}{x^4+1} \ dx Depuis une ligne de commande vide, taper shift-5 (2d), puis shift-2 3 (integrate), vous devez voir ∫ 0 10dx\int_0^1 0 \ dx Déplacez le curseur sur le 0 de la borne inférieure de l’intégrale et tapez sur la touche DEL, vous devez voir ∫0dx\int 0 \ dx avec le tout sélectionné. Utilisez le curseur vers le bas pour sélectionner 0 et tapez 1/(x^4+1) EXE puis OK pour recopier en ligne de commande puis OK pour exécuter le calcul, le résultat s’affiche maintenant dans l’éditeur 2d.
On peut alors sélectionner avec les touches du curseur par exemple l’argument d’un des arctangentes et exécuter shift-1 EXE (simplify) pour effectuer une simplification partielle du résultat, puis recommencer avec l’autre arctangente.
On peut simplifier encore plus, en rassemblant les logarithmes. Pour cela il faut d’abord échanger deux des arguments de la somme. Sélectionnez un des logarithmes avec des déplacements du curseur, puis tapez shift-curseur droit ou gauche, cela échange l’argument sélectionné avec son frère de droite ou de gauche. Tapez ensuite alpha curseur vers la droite ou vers la gauche, ceci augmente la sélection en ajoutant le frère de droite ou de gauche. Une fois les deux logarithmes sélectionnés, menu shift-1 2 EXE (factor), puis descendez la sélection sur la somme ou différence de logarithmes, allez dans le menu Toolbox puis EXE (Tout), tapez les lettres l, n, c ce qui déplace à la première commande commençant par lnc, sélectionnez lncollect, validez et tapez enfin sur EXE (eval).

15  Sessions de calculs

15.1  Edition de l’historique.

En utilisant la touche curseur vers le haut/bas, on se déplace dans l’historique des calculs, le niveau courant est en surbrillance.

Pour modifier l’ordre des niveaux dans l’historique des calculs, tapez alpha-curseur vers le haut ou vers le bas. Pour effacer un niveau, appuyez sur la touche DEL (le niveau est recopié dans le presse-papiers).

Pour modifier un niveau existant, on tape sur shift-5 ou sur shift-4. Dans le premier cas, c’est l’éditeur 2d qui est appelé si le niveau est une expression, dans le deuxième cas, c’est l’éditeur texte qui est appelé. Taper Back pour annuler les modifications ou EXE pour valider. Si les modifications sont validées, les lignes de commande situées en-dessous de la ligne modifiée seront automatiquement calculées, tenant compte des modifications, par exemple si vous modifiez un niveau comme A:=1, les lignes situées en-dessous dépendant de A seront actualisées.

Ce processus peut être automatisé en utilisant un curseur, que l’on peut créer avec un assistant, depuis le menu principal (shift EXE ou HOME), Parameter. Une fois créé, vous pouvez modifier un curseur en tapant sur les touches + ou - lorsque le niveau contenant la commande assume ou parameter est sélectionné (tapez * ou / pour une modification plus rapide).

15.2  Variables

En appuyant sur la touche var vous affichez la liste des variables qui ont une valeur, ainsi que des commandes de gestion de variables. Déplacez le curseur vers une variable puis EXE pour la recopier en ligne de commande, DEL copie en ligne de commande la commande d’effacement de la variable (confirmez ensuite avec EXE). La commande restart permet d’effacer toutes les variables. La commande assume permet de faire une hypothèse sur une variable, par exemple assume(x>5) (> se trouve dans le menu shift-PRGM).

16  Programmation

L’environnement de programmation de χ\chicas est assez complet: un éditeur, l’interpréteur de Xcas avec toutes ses commandes (compatibilité partielle avec les modules Python math, cmath, random, turtle, numpy, scipy, giacpy, matplotlib et un sur-ensemble du module kandinsky), avec un outil de mise au point permttant l’exécution en pas à pas.

Vous pouvez programmer en utilisant les structures de commande en français de Xcas ou en utilisant la compatibilité de syntaxe Python. Les programmes très courts (en une ligne) peuvent être saisis directement en ligne de commande. Les programmes plus longs ou que l’on souhaite sauvegarder seront saisis dans l’éditeur de programmes sur la calculatrice, ou bien transférés depuis un PC ou une autre calculatrice.

Plusieurs programmes sont installés après un reset de la calculatrice (des polygones avec la tortue, la fractale de Mandelbrot, le calcul des racines d’un polynôme de degré 2). Vous pouvez les visualiser depuis le shell en tapant shift-EXE ou Home selon le modèle de calculatrice, puis Ouvrir script, les interpréter avec la touche OK et les exécuter depuis le shell (Back puis var pour sélectionner la fonction).

16.1  Prise en main (programmation)

Un premier exemple en ligne de commande :
une fonction définie par une expression algébrique. On saisit nom_fonction(parametres):=expression Par exemple, pour définir le périmètre d’un cercle de rayon rr, on peut taper
puis on peut calculer
.

Autre exemple, pour calculer l’intervalle de confiance de seconde connaissant une fréquence pp et un effectif nn, on tape


puis on teste

Autre exemple : avec la tortue de Xcas
La tortue de Xcas est un petit robot qui se déplace selon des ordres qui lui sont donnés en laissant une trace de son passage. Les commandes de la tortue sont accessibles depuis le dernier item du menu Toolbox, par le raccourci Toolbox x 2x^2. Saisir la commande avance dans ce menu puis valider, vous devez voir la tortue (symbolisée par un triangle) avancer de 10 pixels. Taper Back pour revenir en ligne de commande. Saisir la commande tourne_gauche et valider, la tortue a tourné de 90 degrés. Répéter 3 fois ces deux commandes pour afficher un carré.
Pour effacer le dessin et ramener la tortue à l’origine, saisir la commande efface. Pour faire des dessins tortue, il est conseillé d’utiliser l’éditeur de programmes (cf. ci-dessous).

Autre exemple : une boucle “oneliner” en syntaxe Xcas.
Ouvrez le menu Programmes (Toolbox cos), puis sélectionnez l’exemple de pour (curseur sur pour puis Ans)

tapez sur EXE, vous devez voir les carrés des entiers de 1 à 10.

Exercice : faire faire un carré à la tortue en utilisant une boucle.

Utilisation de l’éditeur
Modifions cet exemple pour faire afficher les carrés de 1 à nn en utilisant la syntaxe compatible Python et l’éditeur de programmes. Tapez sur Back pour passer du shell à l’éditeur de programmes. Si on vous demande programme ou Tortue faites OK. Ceci ouvre l’éditeur avec une maquette de fonction def f(x): Vérifiez que la syntaxe Python est activée (menu principal shift EXE ou HOME), sinon activez-la (8). Remplacez x par n, puis déplacez le curseur en fin de ligne et passez à la ligne (EXE). Tapez Shift-2 puis EXE (for), placez un j entre for et in range( puis un n entre les parenthèses de range(). À la ligne suivante, tapez shift-3 7 (print) et validez (EXE), puis tapez j,j^2). Vous devriez avoir le programme suivant : 

def f(n):
  for j in range(1,n+1):
    print(j,j^2)
  return x


Remplacez x par n dans return (ou effacez la ligne). N.B.: pour la puissance, on peut utiliser ^ ou ** dans χ\chiCAS (il faut utiliser ** en Python).

Maintenant, tapez OK. Si tout va bien, vous devez voir Success dans la ligne d’état. Sinon, le numéro de ligne de la première erreur est indiqué ainsi que le mot qui a provoqué l’erreur. Le curseur est positionné sur la ligne où l’erreur a été détectée (il peut arriver que l’erreur soit située avant mais détectée un peu plus loin seulement). Si vous utilisez la syntaxe en Python, notez que les structures de programmation sont traduites en langage Xcas, les erreurs affichées le sont par rapport à cette traduction (donc des mots-clefs de fin de structure comme end peuvent avoir été ajoutées).

Si le programme est syntaxiquement correct, vous pouvez le sauvegarder depuis le menu principal (shift EXE ou HOME). Pour l’exécuter, revenez à la ligne de commande en tapant la touche Back, tapez par exemple f(10), vous devriez voir s’afficher les carrés de 1 à 10.

3ième exemple : Calcul de l’intervalle de confiance de terminale S
En syntaxe Xcas. On peut le saisir en ligne de commande
On peut éviter les calculs redondants en utilisant une variable locale (utiliser Toolbox Programmes pour saisir fonction, local, return et ffonction)

fonction F(P,N) 
  local D; 
  D:=1.96*sqrt(P*(1-P)/N); 
  return [P-D,P+D]; 
ffonction;


Exercice  Créez un fichier carre.py contenant un script pour afficher un carré avec la tortue. Créez un fichier carren.py pour afficher un carré de nn pixels, en utilisant une fonction d’argument nn et l’instruction repete.

Solution  Depuis l’éditeur de script, faire shift EXE ou HOME puis 5 (Effacer). Puis shift-4 efface. Ajouter 4 fois avance; tourne_gauche;. Appuyer sur OK pour tester. Sauvegardez (shift EXE ou HOME puis 3 Sauvegarder comme).

Effacer à nouveau (shift EXE ou HOME 5 effacer) Puis shift-4 efface. Ajouter avant la ligne efface 

def f(n):
  for j in range(4):
    avance(n)
    tourne_gauche

puis après la ligne efface; tapez par exemple f(40) puis OK. Ensuite faire shift EXE ou HOME 3 (Sauvegardez comme).

Un exemple de fonction non algébrique : le calcul du PGCD de 2 entiers.
Utiliser EXE pour passer à la ligne. En syntaxe Xcas 

fonction pgcd(a,b)
  tantque b!=0 faire
    a,b:=b,irem(a,b);
  ftantque;
  return a;
ffonction


Le même en syntaxe Python 

def pgcd(a,b):
  while b!=0:
    a,b=b,a % b
  return a


On vérifie

Mise au point
La commande debug permet d’exécuter une fonction en mode pas-à-pas, i.e. visualiser l’évolution des variables instruction par instruction, par exemple
debug(pgcd(12345,3425))

16.2  Quelques exemples

Le répertoire prog de l’archive khicasio.zip contient quelques exemples de TP pour classes de seconde de l’IREM de Grenoble :

ainsi que quelques autres programmes (avec fréquemment une représentation graphique) :

16.3  Commandes utilisables

Contrairement aux adaptations de MicroPython proposées par les constructeurs (dont celui de la Numworks N0110), la programmation en (simili-)Python dans χ\chiCAS n’est pas une application indépendante. Vous pouvez donc utiliser tous les types de Xcas (par exemple les rationnels) et appliquer toutes les commandes de Xcas dans vos programmes. Ceci correspond plus ou moins à un environnement Python avec les modules math, cmath, random (plus complet que le module urandom fourni par les constructeurs), scipy, numpy, un petit module de graphiques pixelisé (set_pixel(x,y,c), set_pixel() pour synchroniser l’affichage, clear(), draw_line(x1,y1,x2,y2,c), draw_polygon([[x1,y1],[x2,y2],...],c), draw_rectangle(x,y,w,h,c), draw_circle(x,y,r,c), la couleur+epaisseur+remplissage c est un paramètre optionnel, draw_arc(x,y,rx,ry,t1,t2,c) permet de tracer un arc d’ellipse). et pour remplacer matplotlib on peut utiliser les commande graphiques dans un repère de χ\chiCAS (point, line, segment, circle, barplot, histogram et les commandes plot...). De plus, vous pouvez travailler avec des expressions et faire du calcul formel dessus. Pour la liste complète des commandes et une présentation détaillée, on renvoie à la documentation de Xcas.

17  Interpréteur MicroPython intégré

χ\chiCAS est maintenant fourni avec son propre interpréteur MicroPython (qui n’est pas identique à celui fourni par Numworks). Pour passer dans χ\chiCAS de l’interpréteur Xcas à MicroPython et réciproquement vous pouvez taper la commande python ou xcas dans le shell sur une ligne vide. Ces commandes sont accessibles dans le menu rapide shift ).

Attention, si vous lancez MicroPython après avoir travaillé avec Xcas ou/et avec le tableur, il peut ne pas y avoir assez de mémoire pour le tas MicroPython, dans ce cas vous risquez de perdre votre session de travail, pensez à la sauvegarder. Par défaut, 40K sont réservés pour MicroPython. Vous pouvez modifier cette valeur jusqu’à 64K dans la configuration (shift EXE ou Home puis touche ln). Si vous choisissez une valeur haute, il peut être nécessaire de quitter χ\chiCAS et de le réouvrir pour que le tas puisse être alloué dans une zone mémoire contiguë (problème de fragmentation du tas sinon).

Remarque : lorsque l’interpréteur Xcas est actif, si vous passez en argument à la commande xcas ou python le nom de variable d’une fonction que vous avez programmée, cela affiche son texte source sous forme d’une chaine de caractères en syntaxe Xcas ou Python. Vous pouvez donc programmer en syntaxe Xcas et traduire ensuite en Python si vous devez vous conformer à des règles qui imposent ce langage.

17.1  Les modules math, cmath, random

Ce sont les modules natifs fournis par MicroPython (urandom a été renommé random), et qui sont conforme au standard. D’autres modules MicroPython standard qui ne sont pas destinés à faire des maths sont disponibles.

17.2  Le module graphic

Il s’agit d’un module natif MicroPython qui exporte de Xcas des fonctions de tracé pixelisés. Une partie des commandes est accessible depuis le menu rapide shift 0. Ce module a des synonymes, kandinsky et casioplot afin de faciliter l’utilisation de scripts Python pour calculatrices Numworks (Epsilon) et Casio.

17.3  Le module matplotl

Il s’agit d’un module natif MicroPython qui exporte de Xcas des fonctions de tracé repéré et vise à une certaine compatibilité avec le module matplotlib (ou un de ses sous-modules) sur PC. Une partie des commandes est accessible depuis le menu rapide shift .

17.4  Le module arit

C’est un module natif qui exporte de Xcas des fonctions d’arithmétique entière : test de primalité et prochain nombre premier (par Miller-Rabin), factorisation d’entiers pas trop gros (détection par Pollard-rho du plus petit facteur premier, donc jusqu’à environ 9 chiffres), pgcd et identité de Bèzout, indicatrice d’Euler (si on sait factoriser). J’y ai aussi inclus deux fonctions de conversion liste vers chaine de caractères pour faciliter l’enseignement d’un peu de cryptographie.

17.5  Le module linalg

Il permet de manipuler les listes comme des vecteurs et les listes de listes comme des matrices. Contrairement à Xcas, Python n’est pas un langage spécifiquement adapté aux maths, il faut utiliser des commandes préfixées add, sub, mul pour effectuer les opérations arithmétiques de base + - * sur les vecteurs et matrices représentés par des listes.

Le module linalg est un module natif, qui utilise Xcas pour effectuer la quasi-totalité des calculs.

17.6  Le module numpy

C’est une surcouche du module linalg qui définit une classe array pour représenter les vecteurs et les matrices. On peut alors utiliser + - * pour faire les opérations de base sur vecteurs et matrices.

Le module numpy n’est pas un module natif, c’est un texte source écrit en Python. Son importation consomme donc de la mémoire RAM. Vous pouvez écrire votre propre version de numpy.py et la stocker dans le scriptstore, elle prendra alors la précédence sur la version utilisée par défaut. Cette dernière vise à assurer un minimum de compatibilité avec le module du même nom sur PC. Bien que non natif, ce module est disponible en mode examen (le texte source par défaut est intégré au code source de l’interpréteur MicroPython). 

import linalg
import math
class array: 
    def __init__(self, a): 
        self.a = a 
  
    def __add__(self, other): 
        return array(linalg.add(self.a , other.a))
  
    def __sub__(self, other): 
        return array(linalg.sub(self.a , other.a))
  
    def __mul__(self, other):
        if type(self)==array:
            if type(other)==array:
                return array(linalg.mul(self.a , other.a))
            return array(linalg.mul(self.a,other))
        return array(linalg.mul(self,other.a))
    
    def __rmul__(self, other): 
        if type(self)==array:
            if type(other)==array:
                return array(linalg.mul(self.a , other.a))
            return array(linalg.mul(self.a,other))
        return array(linalg.mul(self,other.a))

    def __matmul__(self, other):
        return __mul(self,other)

    def __getitem__(self,key):
        r=(self.a)[key]
        if type(r)==list or type(r)==tuple:
            return array(r)
        return r

    def __setitem__(self, key, value):
        if (type(value)==array):
            (self.a)[key]=value.a
        else:
            (self.a)[key]=value
        return None

    def __len__(self):
        return len(self.a)
    
    def __str__(self): 
        return 'array('+str(self.a)+')'
  
    def __repr__(self): 
        return 'array('+str(self.a)+')'
  
    def __neg__(self):
        return array(-self.a)

    def __pos__(self):
        return self
    
    def __abs__(self):
        return array(linalg.abs(self.a))

    def __round__(self):
        return array(linalg.apply(round,self.a,linalg.matrix))

    def __trunc__(self):
        return array(linalg.apply(trunc,self.a,linalg.matrix))

    def __floor__(self):
        return array(linalg.apply(floor,self.a,linalg.matrix))

    def __ceil__(self):
        return array(linalg.apply(ceil,self.a,linalg.matrix))

    def T(self):
        return array(linalg.transpose(self.a))
            
def real(x):
    if type(x)==array:
        return array(linalg.re(x.a))
    return x.real

def imag(x):
    if type(x)==array:
        return array(linalg.im(x.a))
    return x.imag

def conj(x):
    if type(x)==array:
        return array(linalg.conj(x.a))
    return linalg.conj(x)

def sin(x):
    if type(x)==array:
        return array(linalg.apply(math.sin,x.a,linalg.matrix))
    return math.sin(x)

def cos(x):
    if type(x)==array:
        return array(linalg.apply(math.cos,x.a,linalg.matrix))
    return math.cos(x)

def tan(x):
    if type(x)==array:
        return array(linalg.apply(math.tan,x.a,linalg.matrix))
    return math.tan(x)

def asin(x):
    if type(x)==array:
        return array(linalg.apply(math.asin,x.a,linalg.matrix))
    return math.asin(x)

def acos(x):
    if type(x)==array:
        return array(linalg.apply(math.acos,x.a,linalg.matrix))
    return math.acos(x)

def atan(x):
    if type(x)==array:
        return array(linalg.apply(math.atan,x.a,linalg.matrix))
    return math.atan(x)

def sinh(x):
    if type(x)==array:
        return array(linalg.apply(math.sinh,x.a,linalg.matrix))
    return math.sinh(x)

def cosh(x):
    if type(x)==array:
        return array(linalg.apply(math.cosh,x.a,linalg.matrix))
    return math.cosh(x)

def tanh(x):
    if type(x)==array:
        return array(linalg.apply(math.tanh,x.a,linalg.matrix))
    return math.tanh(x)

def exp(x):
    if type(x)==array:
        return array(linalg.apply(math.exp,x.a,linalg.matrix))
    return math.exp(x)

def log(x):
    if type(x)==array:
        return array(linalg.apply(math.log,x.a,linalg.matrix))
    return math.log(x)

def size(x):
    if type(x)==array:
        return linalg.size(x.a)
    return linalg.size(x)

def shape(x):
    if type(x)==array:
        return linalg.shape(x.a)

def dot(a,b):
    return a*b

def transpose(a):
    if type(x)==array:
        return array(linalg.transpose(x.a))

def trn(a):
    if type(x)==array:
        return array(linalg.conj(linalg.transpose(x.a)))
    return linalg.conj(linalg.transpose(x.a))

def zeros(n,m=0):
    return array(linalg.zeros(n,m))

def ones(n,m=0):
    return array(linalg.ones(n,m))

def eye(n):
    return array(linalg.eye(n))

def det(x):
    if type(x)==array:
        return linalg.det(x.a)
    return linalg.det(x)

def inv(x):
    if type(x)==array:
        return array(linalg.inv(x.a))
    return linalg.inv(x)

def solve(a,b):
    if type(a)==array:
        if type(b)==array:
            return array(linalg.solve(a.a,b.a))
        return array(linalg.solve(a.a,b))
    if type(b)==array:
        return array(linalg.solve(a,b.a))
    return linalg.solve(a,b)

def eig(a):
    if type(a)==array:
        r=linalg.eig(a.a)
        return array(r[0]),array(r[1])
    return linalg.eig(a)

def linspace(a,b,c):
    return array(linalg.linspace(a,b,c))

def arange(a,b,c=1):
    return array(linalg.arange(a,b,c))

def reshape(a,n,m=0):
    if type(n)==tuple:
        m=n[1]
        n=n[0]
    if type(a)==array:
        return array(linalg.matrix(n,m,a.a))
    return linalg.matrix(n,m,a)

18  Applications additionnelles

Les applications additionnelles sont accessibles en tapant shift Ans. Il y a actuellement un tableur, le tableau périodique des éléments (d’après Maxime Friess), et trois exemples d’addin qui peuvent servir de modèle aux programmeurs : la suite de Syracuse (très simple), la fractale de Mandelbrot et les bassins d’attraction de la méthode de Newton, et un jeu de mastermind (qui peut aussi servir de passe-temps).

19  Tableur

Au lancement, vous avez un tableau de 14 lignes et 4 colonnes remplies de 0. Vous pouvez changer la dimension depuis la configuration du tableur (shift EXE ou Home puis configuration), mais attention, chaque cellule utilise de la mémoire, un peu moins de 100 octets pour une cellule remplie d’un nombre, plusieurs centaines d’octets si elle est remplie par une formule, et la mémoire de la Numworks est très limitée, s’il n’y a pas assez de mémoire lors d’une allocation, vous perdrez votre session de travail. Pensez à faire une sauvegarde de votre session de temps en temps!

La syntaxe pour créer une formule est identique à celle d’un tableur classique, on tape sur shift = puis on entre la formule, avec des références relatives (par exemple =a1+1) ou absolues (=$a$1+1). Pour saisir une cellule après avoir tapé =, on peut déplacer le curseur vers la cellule cible, à condition de commencer par un déplacement de curseur vers le haut ou vers le bas (sinon le déplacement vers la droite ou la gauche déplace dans la ligne de commande, pas dans le tableur). On peut utiliser les commandes de Xcas ainsi que des fonctions qu’on a programmées.

Il y a des assistants de saisie spécifiques au tableur dans les menus rapides shift 1, 2 et 3. Par exemple pour générer des entiers consécutifs, taper shift 3 puis OK ce qui crée une ligne de commande contenant range(, il suffit de mettre un entier aa ou deux entiers aa et bb en arguments pour créer la liste des entiers entre 0 et a−1a-1 ou entre aa et b−1b-1 et la dispatcher sur la colonne.

Autre exemple, pour avoir un tableau de valeurs de fonctions, se placer au début d’une colonne vide dont la colonne à droite est aussi vide et taper shift 3, sélectionner tablefunc puis passer en argument l’expression, par exemple sin(x) (ou f(x) si vous avez défini une fonction f). Vous pouvez ensuite régler la valeur de début et le pas dans le tableur. Pour une suite récurrente, se placer en haut d’une colonne vide et utiliser la commande tableseq du menu rapide shift 3.

Pour sélectionner une plage de cellules, taper simultanément sur shift et une touche de direction, vous pouvez ensuite relacher shift et déplacer le curseur en fin de sélection. Tapez OK pour valider (si vous la passez en argument d’une formule saisie dans une cellule du tableur), ou shift copy si vous voulez copier la sélection dans le presse-papier pour par exemple la recopier dans le shell avec shift paste.

Si vous utilisez un des assistants de statistiques 2d, faites la sélection des 2 colonnes avant de choisir la commande. Par exemple, en 1ère ligne, 1ère colonne, tapez shift 3 sélectionnez range puis complétez en range(6) comme valeurs de X puis en face en 2ème colonne entrez des valeurs et Y. Déplacez le curseur en 1ère ligne et en 1ère colonne, puis shift-curseur vers le base puis déplacements du curseur pour rejoindre l’autre extrémité de la sélection, puis shift 2, puis par exemple polygonscatterplot. Pour voir le graphique, tapez shift 6. Pour voir sur le même graphique la droite de régression linéaire correspondante, vous pouvez recommencer la procédure ou bien recopier la cellule contenant la formule de polygonscatterplot avec shift-copy shift-copy et la coller avec shift paste en-dessous, puis la modifier (shift 4 OK) en remplaçant polygonscatterplot par linear_regression_plot

Lorsqu’on utilise une plage de cellule en argument d’une commande, la plage de cellule est aplatie en une seule liste. Si on souhaite utiliser une matrice comme argument d’une commande, il faut reconstruire la matrice à partir de la liste en utilisant la commande matrix(l,c,liste) où l,c sont les dimensions de la matrice (c’est ce que fait l’assistant scatterplot du menu rapide de statistiques 2d (shift 2) si on sélectionne la plage de cellules auparavant).

Dans le menu accessible depuis la touche shift EXE ou HOME, vous pouvez insérer ou effacer une ligne ou une colonne, vous pouvez aussi donner un nom de variable au tableur, la matrice des valeurs sera alors automatiquement sauvegardée dans cette variable, que vous pouvez utiliser ensuite depuis le shell.

Si vous entrez dans une cellule une formule donnant un résultat vecteur ou matrice, celle-ci sera dispatchée par défaut dans plusieurs cellules. On peut modifier cela dans la configuration du tableur.

20  Raccourcis claviers.

Dans l’éditeur de programmes :

21  Moteur de rendu 3d et géométrie.

La dernière version de χ\chiCAS pour Numworks fournit un moteur de rendu de graphique 3d, inspiré au départ par le script Python 3d de Eric Schrafstetter.

Ce moteur de rendu apparait si vous créez une figure 3d ou si vous entrez dans le shell ou l’éditeur de programmes une commande renvoyant un graphe dans l’espace, par exemple depuis le menu Toolbox, sous-menu 3d (raccourci () :

Depuis le moteur, appuyez sur sur shift EXE ou HOME (ou sur Toolbox sauf depuis l’application de géométrie 3d) pour modifier les réglages numériquement et pour voir la liste des raccourcis clavier, dont voici les plus importants :

Il est possible de créer des figures géométriques 2d ou 3d, et de faire des calculs de géométrie analytique. Ouvrez l’éditeur de programmes, effacez si nécessaire le patron def ... ou efface ..., puis entrez une instruction par ligne. Pour passer à la ligne, utilisez la touche EXE, pour afficher la construction utilisez la touche OK. Les principales commandes de géométrie se trouvent dans le menu Toolbox. Le menu rapide shift + affiche les commandes de géométrie les plus fréquentes, le menu shift * permet de donner facilement des couleurs aux objets géométriques créés.

22  Copyright, licences et remerciements

23  Développement en C/C++.

Cette section s’adresse aux utilisateurs avancés qui souhaitent programmer leur calcultrice en exploitant toute sa puissance, donc sans être limité par la faible quantité de mémoire disponible pour des scripts Python et la lenteur relative du langage interprété. Le système non modifié de la Numworks permet de le faire, mais il est difficile de le maitriser, au-delà de modifications simples du code existant (par exemple modifier la valeur de certains paramètres), il faut bien connaitre C++, la programmation orienté objet et se limiter à une librairie standard très spartiate. Cela limite à mon avis le nombre de développeurs et la vitesse de développement sur cette plateforme, encore plus si on est habitué à un environement de développement frugal, personnellement j’utilise emacs comme éditeur de texte et un terminal, les arborescences à plusieurs niveaux et les espaces de noms imbriqués d’Epsilon sont un cauchemar. Le temps nécessaire à la compilation d’Epsilon est d’ailleurs un indicateur de cette complexité.

Un autre problème est que modifier Epsilon nécessite d’utiliser la même licence de logiciel, on ne peut donc pas développer du logiciel libre.

Damien Nicolet et moi-même avons développé des modifications autour de Epsilon, qui permettent de lancer un firmware d’extensions à partir de Epsilon. C’est le projet Delta/Khi, qui permet d’utiliser la newlib, une implémentation complète de la libc et de la libstdc++, et offre un SDK en langage C et en C– (i.e. avec un paradigme de programmation impératif très proche du C donc beaucoup plus accessible, avec les avantages que procurent la librairie standard C++). Ainsi ajouter une application toute simple comme la suite de Syracuse nécessite une dizaine de lignes de code, programmer la fractale de Mandelbrot et les bassins d’attraction ou le jeu de mastermind font une bonne centaine de lignes (ces trois exemples se trouvent dans le fichier kadd.cc du source de giac) et l’interface du tableur de χ\chiCAS de l’ordre d’un millier de lignes.

Licences
L’utilisation du SDK de base de l’OS (23.4) vous impose de choisir une licence permettant d’utiliser les services de base d’un OS propriétaire, ce que toute licence de logiciel raisonnable devrait permettre, c’est le cas en particulier de la GPL. L’utilisation des autres fonctions du SDK impose une licence compatible avec la GPL.

23.1  Installation de l’environnement de développement.

Je décris l’installation sous Linux debian/ubuntu compatible depuis un terminal avec comme shell bash. On peut programmer sur d’autres OS, mais c’est plus facile sous Linux (en tout cas c’est plus facile pour moi d’expliquer comment faire!). Si vous travaillez habituellement sur Mac ou Windows, vous pouvez installer une machine virtuelle, par exemple avec Virtualbox et y mettre une distribution Linux debian-compatible, par exemple xubuntu.

On installe les packages nécessaires pour compiler giac et pour cross-compiler pour le processeur ARM : 

sudo apt-get install wget gdb gcc g++ libgmp-dev libmpfr-dev libmpfi-dev libpari-dev libgsl0-dev libxext-dev libpng-dev libjpeg-dev libreadline-dev libncurses5-dev mesa-common-dev libx11-dev libxt-dev libxft-dev libntl-dev libgl1-mesa-dev libgl-dev libao-dev hevea debhelper libfltk1.3-dev
sudo apt-get install build-essential git imagemagick libx11-dev libxext-dev libfreetype6-dev libpng-dev libjpeg-dev pkg-config gcc-arm-none-eabi binutils-arm-none-eabi dfu-util

23.1.1  Epsilon 15.3.1/Khi (calculatrice), 12.3 (simulateur)

Simulateur Delta
Pour récupérar les sources du simulateur, faire 

wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/delta_simu.tar.bz2
tar xvfj delta_simu.tar.bz2

Pour compiler le simulateur, vous pouvez lancer le script delta/mksimu ou vous pouvez exécuter les instructions suivantes 

cd delta/ext/giac-1.6.0/src
ln -sf config.h.numworks.gmp config.h
make -f Makefile.numworks.simulator
/bin/cp simu/libgiac.a ../../simulator/lib
cd ../../..
/bin/rm output/simulator/debug/epsilon.elf
make V=1 DEBUG=1 PLATFORM=simulator
ln -sf output/simulator/debug/epsilon.elf simu

Essayez mantenant de taper ./simu puis de lancer χ\chiCAS sur le simulateur en tapant \ ou $ selon le clavier (cette touche permet de simuler l’appui sur la touche HOME).

Attention, le support de MicroPython et de l’exécution en mode pas à pas n’est pas compatible, à cause du code assembleur de certaines fonctions situées dans les fichiers delta/python/src/py/nlr*. En conséquence si vous sélectionnez MicroPython pour évaluer dans χ\chiCAS, le simulateur plantera dès la première évaluation. Pour contourner ce problème, il faut compiler ces fichiers nlr* en mode release puis copier les fichiers objets obtenus dans le répertoire debug d’Epsilon/Delta. Pour faire cela, vous pouvez lancer le script delta/mksimu, puis le script delta/cpnlr. La prochaine exécution de delta/mksimu devrait alors donner un exécutable simu qui permet d’activer simultanément l’évaluation MicroPython et la mise au point.

Version du source calculatrice avec le multi-boot Khi : faites 

wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/khi2.tgz
tar xvfz khi2.tgz
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/khi18.tgz
tar xvfz khi18.tgz
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/khiext.tgz
tar xvfz khiext.tgz

khi2 est pour le slot 1, khi18 pour le slot 2 (et contient le bootloader avec slot 2 en 0x90180000 et slot 3 en 0x90400000).

Il y a donc quatre arborescences distinctes, trois pour la calculatrice (khi18, khi2 et khiext), une (delta) pour avoir un environnement de développement avec possibilité d’exécuter le code pas à pas. Cela pour deux raisons

Le répertoire khi2 contient l’arborescence pour compiler pour l’OS calculatrice, khiext pour les extensions. Les librairies nécessaires sont précompilées dans le répertoire khiext/apps. 

cd khi2
make MODEL=bootloader epsilon.A.bin  
cd ../khiext
make

Si vous voyez des messages tels que ... switch -mcpu=cortex-m7 conflicts..., c’est que le cross-compilateur ARM de votre distribution Linux est trop ancien. Allez sur le site du ARM SDK, descendez jusqu’à faire apparaitre la version 9 (vous pouvez essayer une version plus récente si votre distribution Linux est récente), téléchargez pour Linux x64 et exécutez la commande
cd && tar xvfj Downloads/gcc-arm-none-eabi-9-2020-q2-update-linux.tar.bz2
puis ajoutez dans votre fichier ~/.bashrc la ligne
export PATH=~/gcc-arm-none-eabi-9-2020-q2-update/bin:$PATH
sauvegardez, puis tapez les commandes
source ~/.bashrc
cd chemin_vers_khi2
make
cd ../khiext
make
cd ../
Vous pouvez aussi éditer les scripts mkarm des répertoires khi2 et khiext et les exécuter à la place de make

Le fichier firmware de la version modifiée de Epsilon, epsilon.A.bin est dans le sous-répertoire output/release/device/bootloader de khi2, le fichier contenant les applications externes est apps.tar dans le répertoire khiext. Pour les flasher sur la calculatrice, faire reset+4 sur la calculatrice et 

dfu-util -i0 -a0 -s 0x90000000 -D khi2/output/release/device/bootloader/epsilon.A.bin -R
dfu-util -i0 -a0 -D khiext/apps.tar -s 0x90200000:force

Le premier fichier est le firmware Epsilon avec les modifications des projet Delta/Omega/Khi. Ce projet fournit une interface pour programmer la calculatrice en C et permet d’exécuter du code contenu dans un fichier apps.tar qui est stocké dans le deuxième firmware.

Le répertoire khi18 contient une version allégée de Epsilon pour fournir un firmware de lancement minimal, qui permet d’accéder à plus de mémoire RAM dans χ\chiCAS. La compilation est quasi-identique à celle dans khi2
make MODEL=bootloader epsilon.B.bin
ou éditer et exécuter le script mkarm.

χ\chiCAS
Si vous modifiez le source de giac, il faut recompiler la librairie libgiac.a et la copier dans ../../lib, pour cela vous pouvez utiliser le script mkarm dans le répertoire khiext. N’oubliez pas de répercuter la modification dans le code source du simulateur.

23.1.2  Epsilon 19.5 à 23, compiler χ\chiCAS pour N0110/N0115/N0120.

  1. Sur un Mac, l’installation est un peu compliquée, car il faut construire un binaire pour les deux architectures Intel et ARM64, il y a donc plusieurs shells scripts spécifiques mkmac, mkarm, mkx86 qui appellent 2 fichiers Makefile, un pour chaque architecture. Pour pouvoir compiler, il faut installer homebrew et les dépendances pour les deux architectures, sur un Mac récent arm64, cela se fait depuis un Terminal (tapez Terminal depuis le launchpad) avec les commandes ci-dessous (taper command-C et command-V pour faire du copier-coller) 
    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install numworks/tap/epsilon-sdk
brew install libpng gmp mpfr mpfi
arch -x86_64 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
arch -x86_64 /usr/local/bin/brew install libpng gmp mpfr mpfi
    Ensuite on tape 
    git clone -b version-23 https://github.com/parisseb/epsilon
cd epsilon
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/ext.tar.bz2
tar xfj ext.tar.bz2
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/nwsimu.tgz
tar xfz nwsimu.tgz
./mkmac
mv output/release/simulator/macos/epsilon.app /Applications
open /Applications/epsilon.app
  2. Procédure de compilation sous Linux. Pour installer le simulateur avec χ\chiCAS, vérifiez que vous avez installé l’environnement de développement (gcc, sdl, etc.) pour votre PC. Si ce n’est pas le cas ouvrez un terminal, et copiez-collez les commandes ci-dessous (raccourci shift-Ctrl-V pour copier dans le terminal) 
    sudo apt-get install wget build-essential git imagemagick libx11-dev libxext-dev libfreetype6-dev libpng-dev libjpeg-dev pkg-config python3 python3-pip
sudo apt-get gcc g++ libgmp-dev libmpfr-dev libmpfi-dev libpari-dev libgsl0-dev libxext-dev libpng-dev libjpeg-dev libreadline-dev libncurses5-dev mesa-common-dev libx11-dev libxt-dev libxft-dev libntl-dev libgl1-mesa-dev libgl-dev libao-dev hevea debhelper libecm1-dev libnauty2-dev libcliquer-dev libresample1-dev libxinerama-dev libsamplerate0-dev libfltk1.3-dev
pip3 install lz4 pypng stringcase
    puis exécutez toujours depuis un terminal les commandes 
    git clone -b version-23 https://github.com/parisseb/epsilon
cd epsilon
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/ext.tar.bz2
tar xfj ext.tar.bz2
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/nwsimu.tgz
tar xfz nwsimu.tgz
./mk
ln -sf output/release/simulator/linux/epsilon.bin simu
./simu
    Notez que la compilation par le script mk se fait en deux temps, d’abord la compilation normale d’Epsilon mais qui renvoie des erreurs car elle ne linke pas avec les librairies contenant Xcas et ses dépendances, puis une édition de liens avec ce qui est nécessaire, et qui elle ne doit pas renvoyer d’erreurs.
  3. Sur un PC Windows
    Première méthode : on peut installer une distribution Linux en utilisant WSL ou dans une machine virtuelle avec un logiciel de virtualisation comme VirtualBox et suivre les indications Linux ci-dessus.
    Deuxième méthode : installer Msys2/mingw64. Ensuite ouvrir depuis le menu principal Windows, dans Msys2 un terminal mingw64. Dans le menu Options de la fenêtre, sélectionner Keys, puis cocher Ctrl-shift-letter shortcut, ceci vous permettra de coller avec Ctrl-shift-V. Copier-coller la commande ci-dessous et exécutez-là : 
    pacman -S git wget mingw-w64-x86_64-gcc mingw-w64-x86_64-freetype mingw-w64-x86_64-pkg-config mingw-w64-x86_64-libusb make mingw-w64-x86_64-python3 mingw-w64-x86_64-libjpeg-turbo mingw-w64-x86_64-libpng mingw-w64-x86_64-imagemagick mingw-w64-x86_64-librsvg mingw-w64-x86_64-inkscape mingw-w64-x86_64-python3-pip mingw-w64-x86_64-python-lz4 mingw-w64-x86_64-libpng gmp mpfr
echo "export PATH=/mingw64/bin:$PATH" >> .bashrc
pip3 install pypng stringcase
    Vérifiez que vous pouvez compiler Epsilon sans KhICAS 
    git clone -b version-23 https://github.com/parisseb/epsilon
cd epsilon
make PLATFORM=simulator
    Si tout va bien, ajoutez les modifications permettant d’utiliser χ\chiCAS 
    wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/ext.tar.bz2
tar xfj ext.tar.bz2
wget https://www-fourier.univ-grenoble-alpes.fr/~parisse/numworks/nwsimu.tgz
tar xfz nwsimu.tgz
    Il faut ensuite
    • soit compiler et installer MPFI dans /usr/lib, on le désarchive tar xfj /chemin/vers/mpfi-1.5.4.tar.bz2 on le configure avec ./configure --prefix=/usr puis make puis make install,
    • soit enlever -lmpfi dans le script mkwin
    puis on exécute le script
    ./mkwin
    (au lieu de mk).

Cf. la section 2.2 pour une rapide description de l’utilisation du simulateur.

Pour pouvoir utiliser le débugger, il faut échanger les # lignes 22 et 23 de build/defaults.mak. Attention, Python ne fonctionne pas avec la compilation en mode debug (-g), il faut compiler les fichiers nlr* sans ce flag (par exemple on compile tout en mode debug, puis on change defaults.mak, on fait touch pypthon/port/mpconfigport.h, et on compile).

Le code source pour la calculatrice physique est disponible dans les deux archives version lanceur indépendante (ou version lanceur NWA) et version de χ\chiCAS.

  1. Normalement il n’y a pas de raison de modifier le lanceur d’application externe. Si nécessaire, il faut lire la section 24 si on utilise le lanceur indépendant ou sinon installer l’EADK de Numworks et compiler avec make et génère un fichier output/khicas.nwa qui s’installe depuis le site des applications externes de Numworks. Il est lié à l’EADK de Numworks, avec quelques ajouts pour les fonctions manquantes, afin de donner accès à la même API que l’application External des N0110 non verrouillées. 
      extern "C" void (* const apiPointers[])(void) = {
    (void (*)(void)) extapp_millis,
    (void (*)(void)) extapp_msleep,
    (void (*)(void)) extapp_scanKeyboard,
    (void (*)(void)) extapp_pushRect,
    (void (*)(void)) extapp_pushRectUniform, // 4
    (void (*)(void)) extapp_pullRect,
    (void (*)(void)) extapp_drawTextLarge,
    (void (*)(void)) extapp_drawTextSmall,
    (void (*)(void)) extapp_waitForVBlank, // 8
    (void (*)(void)) extapp_clipboardStore,
    (void (*)(void)) extapp_clipboardText,
    (void (*)(void)) extapp_fileListWithExtension,
    (void (*)(void)) extapp_fileExists, // 12
    (void (*)(void)) extapp_fileErase,
    (void (*)(void)) extapp_fileRead,
    (void (*)(void)) extapp_fileWrite,
    (void (*)(void)) extapp_lockAlpha, // 16
    (void (*)(void)) extapp_resetKeyboard,
    (void (*)(void)) extapp_getKey,
    (void (*)(void)) extapp_restorebackup,
    (void (*)(void)) extapp_erasesector, // 20
    (void (*)(void)) extapp_writememory,
    (void (*)(void)) extapp_inexammode,
    (void (*)(void)) extapp_isalphaactive, 
    (void (*)(void)) extapp_kbdstatus,  // 24
    (void (*)(void)) nullptr,
  };
    L’adresse de ce tableau est ensuite passé en paramètre à la fonction extapp_start de khib/startup.c
    uint32_t _extapp_start(const uint32_t api_version, const void * api_base, void * heap, const uint32_t heap_size);
    qui va copier ces paramètres, en particulier le tableau apiPointers qui sert à faire fonctionner le SDK C dans khib/api.c, initialiser la RAM statique, puis appeler extapp_main dans khib/main.c, qui appelle ext_main qui appelle caseval("*") ce qui est une convention de la librairie Giac/Xcas pour lancer le shell de χ\chiCAS.
  2. χ\chiCAS peut se compiler en deux versions: une version allégée sans l’aide complète qui tient dans le 2ème slot Numworks (commençant à 0x90400000) ou en version complète qui génère alors deux fichiers binaires, un commençant en 0x90260000 et finissant en 0x903f0000 (les données read only), le deuxième commençant en 0x90400000, il se présente comme une archive tar à laquelle on peut ajouter des fichiers de données/scripts qui seront accessibles en lecture seule sur la calculatrice. On utilise l’une des commandes ./mkb ou ./mkab. On peut envoyer à la calculatrice une autre archive tar en 0x90200000 qui contient des données/scripts accessible en lecture/écriture depuis la calculatrice. Il y a donc 4 versions de fichiers de link (*.ld) selon le modèle de calculatrice cible et la version allégée ou non de χ\chiCAS: n01?0.ld, n01?0ab.ld. On compile par paires, en choisissant comme cible khi110b.tar khi120b.tar ou khi110ab.tar khi120ab.tar avec comme define en ligne de compilation de g++ -DNUMWORKS_SLOTB ou -DNUMWORKS_SLOTAB. La RAM statique est située en début de RAM pour les apps externes (236 octets sont utilisés actuellement), et le lanceur crée le tas de χ\chiCAS par un malloc la RAM disponible pour les apps externes moins 13K pour ne pas toucher la ram statique de χ\chiCAS
  3. Le modèle actuel est donc le suivant:
    • RAM statique du lanceur (qui fait un peu plus de 200 octets) au début de la ram des apps externes
    • le tas du lanceur commence juste après, l’appel à malloc renvoie alors un pointeur vers une zone terminant avant la RAM statique de χ\chiCAS
    • RAM statique de χ\chiCAS: 0x2?034000 (12K, actuellement un peu plus de 256 octets sont encore disponibles)
    • flash tar file R/W: 0x90200000 (6*64K disponible)
    • flash .rodata 0x90260000-0x903f0000: fichier khia, pour la version longue de χ\chiCAS
    • flash .text 0x90400000-0x907f0000 (dont environ 0.5M disponible pour tar file RO en version longue), fichier khi1?0ab.tar, ou fichier khi1?0b.tar (version courte).
  4. Les commandes dfu pour flasher sans accès Internet 
    dfu-util -i 0 -a 0 -s 0x90400000 -D khi120b.tar
    (version courte) ou (version longue)
dfu-util -i 0 -a 0 -s 0x90400000 -D khi120ab.tar
dfu-util -i 0 -a 0 -s 0x90260000 -D khia
    exemples de scripts:
dfu-util -i 0 -a 0 -s 0x90200000 -D khi92
    Pour reflasher le secteur de lancement de l’application sans accès Internet, commencer par récupérer une fois pour toutes la version du secteur qui correspond à votre firmware/calculatrice depuis ici, sauvegardez-là sous un nom tel que sector puis 
    #! /bin/bash
dfu-util -i 0 -a 0 -s 0x90190000:0x10000:force -U sector

Remarques :

23.2  Utilisation du débuggueur

Le simulateur peut se lancer avec le débuggueur en tapant gdb ./simu ou depuis votre éditeur de texte ou votre environnement de développement. Par exemple si vous utilisez emacs, tapez Esc x gdb, valider, mettre simu comme nom d’exécutable, valider. Voir par exemple ici un guide de prise en main d’utilisation du débuggueur avec emacs. Vous pouvez exécuter la commande
cp delta/ext/giac-1.6.0/src/.gdbinit delta
ou télécharger le fichier .gdbinit pour définir la macro v de gdb qui vous permettra de visualiser les variables de type giac::gen de manière plus parlante qu’avec la commande p.

Par exemple, si vous faites dans la console gdb la commande b khicas_addins_menu (breakpoint, i.e. point d’arrêt à cette fonction), puis r pour lancer le programme, il s’interrompra dans le menu d’affichage des applications tierces (shift-Ans), vous pouvez alors exécuter ligne après ligne avec la commande n, en visualisant le contenu des variables avec la commande p ou v pour des variables Xcas de type gen.

23.3  Intégration avec le shell χ\chiCAS

Pour ajouter une application au menu shift-Ans des applications ajoutées dans χ\chiCAS, il faut modifier la fonction khicas_addins_menu() dans kadd.cc. Incrémentez smallmenu.numitems, définissez smallmenuitems[j].text pour la première valeur de j disponible, puis dans la boucle while(1) {...}, ajoutez la définition de votre fonction ou un appel vers votre fonction avec if (smallmenu.selection==j+1). Pour compiler et tester, cf. la fin de la section 23.1.1.

L’exemple de la suite de Syracuse vous montre comment faire entrer une valeur, afficher un graphique repéré, et entrer quelque chose en ligne de commande. L’exemple de la fractale de Mandelbrot montre comment afficher un graphique pixelisé pixel par pixel. L’exemple du jeu de Mastermind montre comment afficher un graphique pixelisé avec des formes plus complexes et interagir avec l’utilisateur lorsqu’il appuie sur une touche.

Conseils :

Les paragraphes qui suivent décrivent brièvement le SDK. Pour plus de détails, il faut ensuite se référer à k_csdk.h et kdisplay.h/kdisplay.cc pour l’interface et aux fichiers headers de giac pour toutes les fonctions de giac.

23.4  Fonctions de base de l’OS.

Les fonctions de bas niveau de Epsilon sont déclarées dans k_csdk.h et sont utilisables depuis un programme C et tout langage qui s’interface avec C (donc quasiment tout langage).

Si vous voulez créer une extension indépendante de χ\chiCAS, vous pouvez vous inspirer d’une des applications de final/nw-external-apps, définissez votre propre fonction int main() et linkez avec votre fichier objet à la place de -lgiac, dans ce cas vous pouvez choisir n’importe quelle licence de logiciel qui peut se lier avec une licence d’OS propriétaire.

Le clavier :

Les affichages.
Notez que y=0y=0 correspond à la première ligne en-dessous de la ligne d’état (18 pixels de hauteur), on a donc 0≤y<2220 \leq y&lt;222 et 0≤x<3200\leq x &lt;320
Les couleurs utilisent un entier 16 bits au format RGB 565, on peut convertir depuis RGB888 par 

int rgb888to565(int c){
  int r=(c>>16)&0xff,g=(c>>8)&0xff,b=c&0xff;
  return (((r*32)/256)<<11) | (((g*64)/256)<<5) | (b*32/256);
}

Le système de fichiers.

Gestion du temps

23.5  Commandes graphiques complémentaires

23.6  Interaction avec l’UI χ\chiCAS

Certaines fonctions utilisent un pointeur vers le contexte du moteur de calcul (qui contient les variables assignées, le mode radian/degré, etc.), de type giac::context *, et dont la valeur est en général stockée dans la variable contextptr dans les fonctions d’interface de χ\chiCAS de kdisplay.cc (on peut aussi passer un pointeur nul).

L’internationalisation est gérée par la commande
const char * gettext(const char *)
Pour ajouter une chaine en plusieurs langues, par exemple Hello, mettez dans votre code gettext("Hello"), et ajoutez au fichier numworks_translate.h, dans l’ordre alphabétique une ligne du type
{"Hello",0,0/* zt */,"Bonjour" /* fr */,"Guten Tag" /* de */,0 /* es */,0 /* nl */,0 /* pt */,0},
Attention, l’utilisation du fichier numworks_translate.h ne peut se faire qu’avec du code GPL qui est linké avec χ\chiCAS (mais rien ne vous empêche d’utiliser gettext dans un programme compatible avec la GPL avec un autre fichier de traductions en repartant de zéro).

23.7  Interaction avec giac

Le type giac::gen permet de travailler avec tous les types de Xcas : entier, flottant, fraction, nom de variable, expression, fonction... On peut construire un gen avec les types de base C 

gen g(1.2),h(3);

ou avec l’interpréteur (avec une chaine de caractères), dans ce dernier cas il faut évaluer le gen avec un appel à eval, par exemple 

gen g("x^4-1",contextptr);
g=eval(g,1,contextptr);

En général une fonction de Xcas a un équivalent C++ avec le même nom précédé par _, et deux arguments, un de type giac::gen et un deuxième qui est un pointeur sur le contexte d’évaluation. Lorsqu’une commande Xcas prend plusieurs arguments, il faut les grouper en un gen de type vecteur, en utilisant une commande makesequence. Par exemple _randNorm(makesequence(0.0,2.0),contextptr) équivaut à la commande randNorm(0.0,2.0) de Xcas. Notez que les fonctions usuelles n’ont pas de préfixe _.

23.8  Sauvegardes et restauration (N0110 non verrouillée)

Il est possible de sauvegarder l’ensemble des données de votre calculatrice en local sur votre PC, i.e. sans connexion Internet. Xcas le permet depuis le menu Numworks. On peut aussi appeler dfu-util directement, cf. la section 2.2. Il faut ensuite récupérer les informations sur la calculatrice avec la commande
dfu-util -i0 -a0 -s 0x080001c4:0x20 -U platform.info
ce qui place dans le fichier binaire platform.info (de taille 32 octets) des informations sur la Numworks (cf. ion/src/shared/platform_info.cpp)

Ensuite en remplaçant A et T par leur valeur dans la commande
dfu-util -i0 -a0 -s A:T:force -U numworks.storage
vous pouvez archiver l’ensemble des données de votre calculatrice dans le fichier numworks.storage. A devrait valoir 0x20000b60, et T 0x8014 (dont 4 octets valant 0xEE0BDDBA puis 32K de data puis à nouveau les 4 octets du début, et 3 pointeurs) ce qui donne la commande
rm -f numworks.storage &&dfu-util -i0 -a0 -s 0x20000b60:0x8014:force -U numworks.storage

Vous pourrez ensuite restaurer l’archive par la commande
dfu-util -i0 -a0 -s A:T:force -D numworks.storage
avec Khi
dfu-util -i0 -a0 -s 0x20000b60:0x8014:force -D numworks.storage

24  Développement indépendant sur Numworks verrouillées.

Lors du verrouillage des Numworks en 2021, Numworks en a discuté avec la communauté Numworks, principalement avec les développeurs du firmware tiers Omega, mais en me laissant délibérement à l’écart (j’ai appris le verrouillage sur tiplanet lors de la sortie de la version 16 beta d’Epsilon). Ces discussions n’ont probablement pas servi à grand chose, Numworks semble n’avoir tenu aucun compte des suggestions faites, si on lit les messages du sujet sur tiplanet.

L’environnement de développement sur Numworks est aujourd’hui hostile, comme on a pu le voir à la section 4.2. Il y a 8M de flash externe découpé en 2 slots de 4M chacun, un des slots doit commencer par un firmware officiel Numworks, il n’y a pas de système de fichiers, il y a peu de RAM disponible : sur 256K, 36K sont réservés pour le noyau et la pile, 42K pour le scriptstore, il ne reste qu’un peu plus de 128K pour une application externe. La N0120 a même des zones de RAM supplémentaires actuellement inutilisées, mais qui sont rendues inaccessibles par le kernel (à date du 3/11/2025). Ce dernier point semble bien être une conséquence de la politique commerciale de Numworks, il s’agissait de vendre au même moment et au même prix que les N0120 des N0110 ou N0115 moins puissantes sans que cela ne se voit pour ce qui concerne la RAM disponible. On verra si cela évolue prochainement.

On peut soit développer un firmware tiers qui sera placé dans l’autre slot, soit développer une application externe dans le même slot que le firmware officiel.

Dans cette section, on va voir qu’il est possible de développer, des applications externes sans dépendre du site web de Numworks. Il suffit en effet de créer un fichier d’édition de lien ram.ld (inclus par app.ld) adapté à la calculatrice cible et au firmware qui y tourne. La compilation et les tests sont alors plus rapides et peuvent se faire sans être connecté à Internet. L’indépendance a toutefois un prix : il faudra une version de l’application externe pour chaque version de firmware ciblée (c’est ce que je fais pour le lanceur de χ\chiCAS pour une sélection de versions de firmware) ou il faudra la recompiler pour la calculatrice cible.

Les informations nécessaires pour constituer le fichier ram.ld sont contenues dans le header du userland :

Exemple avec le header du userland 23.2.3 (dernière version dont le source est public au 2/11/2025) pour N0120: 

00020000   FE ED C0 DE  32 33 2E 32  2E 33 00 00  9C 77 00 24  ....23.2.3...w.$
00020010   00 A8 00 00  00 00 19 90  00 00 3F 90  40 2A 01 24  ..........?.@*.$
00020020   00 70 03 24  00 00 3F 90  00 04 3F 90  FE ED C0 DE  .p.$..?...?.....
00020030   F8 EF 03 24  61 6D 08 90  55 96 10 90  00 00 00 00  ...$am..U.......

et le fichier ram.ld associé : 

MEMORY {
  FLASH (rx) : ORIGIN = 0x90190000, LENGTH = 0x260000
  RAM (rwx) : ORIGIN = 0x24012a40, LENGTH = 0x245c0
}

_userland_trampoline_address = 0x90109655;

Pour la version 22.2.1, on obtient un début de RAM en 0x240129a8, le fichier pour la 23.2.3 conviendrait donc pour la 22.2.1, il est très légèrement sous-optimal d’une centaine d’octets. On peut donc mutualiser les lanceurs, sous réserve que le 1er secteur des applications flash soit identique et qu’on n’utilise pas la variable _userland_trampoline_address, mais qu’on code la recherche, ce qui est fait dans le fichier eadk_userland.c.

Voici une liste de secteurs, adresse de début de RAM et longueurs :

Si on n’a pas besoin de toute la mémoire disponible, on peut utiliser une configuration mémoire RAM ram120.ld quasi-universelle (jusqu’à présent), et juste changer l’origine : 

MEMORY {
  FLASH (rx) : ORIGIN = 0x90180000, LENGTH = 0x270000
  RAM (rwx) : ORIGIN = 0x2401490c, LENGTH = 0x226f4
}

et pour les n0110/n0115 

MEMORY {
  FLASH (rx) : ORIGIN = 0x90150000, LENGTH = 0x2a0000
  RAM (rwx) : ORIGIN = 0x20014a9c, LENGTH = 0x22564
}

On observe au passage que la version 24 économise 2 secteurs de flash par rapport à la version 23, le moteur de calcul a été recodé pour tenir dans la ROM de la Numworks scientifique collège, en gagnant environ 140K de code.

Et pour finir trois exemples :

A  Opinions

A.1  Quelques mots sur les calculatrices.

La calculatrice est devenue incontournable dans les enseignements de mathématique au lycée, avec trop souvent une utilisation presse-boutons, alors qu’elle est sous-utilisée dans les études scientifiques, partiellement en réaction. De ce fait, les constructeurs mettent l’accent sur le développement de fonctionnalités pour le lycée, en faisant apprendre des séquences de touches à effectuer pour certaines taches bien précises, plutot qu’une méthode plus générale, un peu moins conviviale pour ces taches, mais plus adaptable. C’est par exemple ce qu’on retrouve dans la philosophie des applications de Numworks, si on veut effectuer une tache pour laquelle elles sont prévues, c’est facile et en général intuitif, mais il devient vite difficile de faire quelque chose qui n’est pas prévu (par exemple simuler des données avec un programme et les utiliser dans une des applis de statistiques, représenter graphiquement une fonction définie par un programme, utiliser dans Calculs ou dans Python certaines fonctions des applications probabilité ou statistiques, ...).

Je pense que ce n’est pas adapté pour les élèves qui doivent pouvoir expérimenter des choses que le constructeur n’a pas implémenté parce que cela ne correspond pas aux programmes (c’est particulièrement vrai pour les bons élèves si on ne veut pas qu’ils s’ennuient!). À court terme, c’est plus facile pour enseigner d’utiliser une application comme Fonctions, mais à long terme, c’est plus formateur pour de futurs étudiants (au moins en sciences et en maths) d’apprendre à utiliser un shell puissant en y tapant des commandes (N.B. : on peut d’ailleurs sérieusement se demander à quoi cela rime d’apprendre un peu de programmation en Python sans avoir au préalable un minimum de maitrise dans l’écriture d’une ligne de commande simple). Bien sur, les deux approches doivent se compléter. Or les élèves sont souvent tributaires du choix de modèle demandé par leur enseignant de seconde, ils n’ont pas encore de recul pour choisir un autre modèle que celui demandé par l’enseignant et comprendre toutes les conséquences du choix, en particulier si la calculatrice ne permet pas d’y installer ou/et utiliser un shell puissant. Il est donc important de pouvoir proposer pour le plus possible de modèles populaires une alternative à la calculatrice officielle, permettant aussi aux bons élèves d’exploiter toutes les possibilités de leur calculatrice et de favoriser leur curiosité. Pour moi, une calculatrice qui fait aimer les maths, c’est une calculatrice qui va donner envie à un élève d’expérimenter sur sa calculatrice des questions en prolongement du programme scolaire. À coté d’applications intuitives, il faut un espace de liberté qui ne soit pas limité aux quelques fonctionnalités d’une interface d’application. C’est le sens de χ\chiCAS, pour Numworks ici, disponible également pour d’autres modèles (Casio Graph 90/35eii, TI Nspire).

Il faut aussi que les enseignants qui conseillent un modèle de calculatrices en seconde prennent bien conscience que le choix ne se limite pas à une utilisation pendant une année ou même pendant les 3 années de lycée mais impacte toutes les années d’études, en particulier pour les élèves bons en sciences et en maths. La Numworks non verrouillée réalise d’une certaine manière un bon équilibre entre la facilité d’utilisation pour tous en seconde (Epsilon 15 ici) et les possibilités ensuite pour les bons élèves qui auront des maths ensuite (χ\chiCAS ici). Mais le passage à une version plus récente d’Espilon casse cet équilibre, un enseignant soucieux de ses bons élèves devrait les mettre en garde pour qu’ils ne mettent pas à jour!

A.2  Mes relations compliquées avec Numworks.

C’est en mai 2016 que j’ai entendu parler pour la première fois de Numworks. Romain Goyet, qui démarrait son projet, m’a contacté pour me sonder un peu dans le domaine des calculatrices. La recommandation principale que je lui avais faite était la suivante : il ne faut pas chercher à faire des économies sur la mémoire, car on le regrette. Ensuite, je n’ai plus eu aucune nouvelle avant d’apprendre par tiplanet le lancement de la calculatrice en aout 2017, en particulier je n’ai pas participé au programme de beta-tests. Cette attitude a sans doute contribué à ce que j’exprime sans retenue mon scepticisme vis-à-vis de la Numworks dans plusieurs posts sur tiplanet : à propos de la mémoire, des fonctionnalités et de la communication à mon avis trompeuse sur le caractère open-source. Ce qui m’a sans doute valu d’être considéré comme un anti-Numworks par Goyet, alors que l’accueil du reste de la communauté était à l’époque très (trop?) enthousiaste. Mais je ne regrette pas du tout d’avoir exprimé publiquement mes réserves, si tout le monde était resté sans rien dire, il n’y aurait pas eu de changement dans la licence d’Epsilon, et les firmwares Omega, Upsilon, Delta (et Khi leur héritier direct) n’auraient pas pu exister.

Je ne sais pas si ma recommandation de 2016 sur la mémoire a eu un quelconque effet, peut-être que sans elle, les premières Numworks auraient encore eu moins de mémoire. En tout cas, la mémoire disponible était et reste encore vraiment très limitée, même s’il y a eu un progrès pour le stockage en flash avec le passage de 1M à 8M en 2019, probablement parce que Numworks s’est rendu compte que la taille des firmwares successifs atteindrait plus vite que prévu la taille de 1M. Il me semble qu’il y aurait des marges de progression peu onéreuses sur la RAM. Et je continue à penser que Numworks a perdu et perd toujours beaucoup de temps de développement avec la gestion de la très faible quantité de RAM (256K).

Les relations avec Numworks se sont ensuite améliorées en 2018, lors d’une rencontre à l’APMEP de Bordeaux, où je leur avais montré mon module de tortue logo sur les calculatrices Casio (J.B. Boric avait aussi implementé un module turtle pour la Numworks). Numworks comprend alors l’intérêt d’avoir un module officiellement supporté pour faire la transition avec le collège. À cette occasion, ils me donnent une N0100. J’apprécie le geste, même si je n’en ai pas l’usage pour y porter Giac (à cette époque, Damien Nicolet, alias zardam, avait réussi à porter Giac sur sa Numworks N0100 mais en modifiant le hardware ce dont je suis personnellement incapable). En mai 2019, Numworks me contacte pour me proposer de signer un accord de confidentialité, ce que j’interprète comme le signe qu’un nouveau modèle allait sortir permettant de porter Giac (sans modification hardware). Mais certaines clauses de l’accord ne me convenaient pas : je voulais m’assurer que rien n’entrave le développement de Giac/Xcas. Numworks refusant de modifier les clauses en question, je ne signe pas l’accord de confidentialité. Le nouveau modèle de Numworks (N0110) est annoncé deux mois plus tard, et j’en achète un. À la rentrée 2019, avec l’aide de J.B. Boric et Damien Nicolet, j’arrive à faire tourner sur ma N0110 un prototype logiciel qui permet d’utilise le moteur de calcul de Giac dans l’appli Calculs. Se pose alors la question de l’incompatibilité des licences entre Giac sous licence GPL et Epsilon, qui n’est pas un logiciel libre. Mais Numworks est inflexible sur la licence d’Epsilon. Ce qui conduit Damien Nicolet à développer un système permettant de compiler deux firmwares à installer séparément, l’un dérivé d’Epsilon (sous sa licence) et l’autre sous licence GPL (le deuxième sera remplacé plus tard par la gestion des applications externes dans Delta/Omega/Upsilon/Khi). En novembre 2019, nous informons Numworks de ce succès et leur demandons s’ils voient encore des problèmes juridiques. Fin 2019, n’ayant pas reçu de réponse, nous publions alors la première version de Delta/χ\chiCAS. Je n’ai pas de statistiques du nombre de personnes qui ont installé χ\chiCAS sur leur Numworks, j’ai par contre le nombre de personnes qui ont consulté la documentation, pour l’année 2020/21 cela dépasse un peu les 5000 et pour 2021/22 on dépasse les 9000, ce qui n’est pas négligeable du tout comparé aux chiffres de ventes estimés. Pour l’année 2023, on est encore un peu au-dessus de 8000, alors qu’il devient de plus en plus difficile de se procurer une Numworks non verrouillée.

En 2017/2018, les ventes de calculatrices Numworks en France ont du être confidentielles : avec une sortie fin aout 2017, ce ne sont pas des scolaires qui ont acheté, uniquement des passionés et des profs (avec le soutien de L. Chéno de l’inspection générale). En 2018/19, quelques profs enthousiastes (en particulier par le module de programmation en Python) ont commencé à recommander la Numworks à leurs élèves, mais les ventes étaient certainement encore faibles (j’estime à quelques milliers d’unités). Le succès en France s’est dessiné à la rentrée 2019 (j’estime qu’ils ont vendu 10 à 15 000 calculatrices en 2019/20) et encore plus en 2020 (probablement le double). À la rentrée 2022, j’estime que Numworks possède environ la moitié du marché des calculatrices couleurs avec de l’ordre de 40 000 calculatrices vendues par an. Je pense que c’est en voyant les ventes décoller à la rentrée 2019, que Numworks a décidé de tourner le dos au calcul formel sur leurs calculatrices, par crainte de ne pas pouvoir se développer à l’étranger, alors qu’en mai 2019, ils envisagaient encore la chose en se disant que cela pouvait aider à booster les ventes en France (sinon ils ne m’auraient pas proposé de signer un accord de confidentialité). Ils ont dû être très désagréablement surpris de la solution technique réalisée par zardam (et qui est sans équivalent de leur coté à ce jour!), alors qu’ils espéraient sans doute pouvoir bloquer la diffusion par des questions de licence. La suite n’a fait que confirmer cette tendance : ils ont commencé par cacher les (maigres) capacités de calcul symbolique d’Epsilon (on peut les retrouver dans Omega et Khi), puis décidé de verrouiller leurs calculatrices et modifié la licence d’Epsilon.

En 2023, les chiffres de vente d’amazon sont disponibles, on peut estimer les ventes (probablement mondiales) à 30 000 unités via ce distributeur. Pas d’estimations aussi précise sur les autres canaux de vente, on sait juste qu’à la rentrée 2023 la TI83 et la Numworks se disputaient la 1ère place à la fnac. Probablement un peu plus de 80 000 unités vendues dans le monde en 2023, dont au moins 4/5èmes en France, et des parts de marché qui continuent à progresser en France, précipitant l’annonce par Casio de nouveaux modèles de calculatrices graphiques pour la rentrée 2024 en France.

L’objectif de Numworks, c’est maintenant le marché américain. On verra si ils réussissent aussi bien qu’en France, où les conditions étaient bien plus favorables : maintenant ils ne peuvent plus communiquer sur l’open-source, le chauvinisme ne va pas dans le bon sens (vis-à-vis de Texas Instruments en particulier) et il n’y a probablement pas d’équivalent à un inspecteur général qui vous soutient parce que vous allez dans le sens de sa réforme Python. Pour le moment, le décollage aux US semble plus lent qu’anticipé par Numworks. C’est un pari pour Numworks, sans compter que TI est sans doute vacciné par ce qui s’est passé en France. Le choix fait par Numworks risque d’être perdant-perdant : malgré sa faible mémoire, la N0110 est (je devrais plutôt dire était) une calculatrice avec un excellent rapport qualité-prix pour installer χ\chiCAS (avec Xcas en parallèle), et coté Numworks, χ\chiCAS ouvrait le marché français des BTS et prépas scientifiques, et aux USA des tests autorisant le calcul formel.

En conclusion, c’est quand même dommage de ne pas chercher une solution qui permette aux élèves français équipés de Numworks de ne pas être défavorisés par rapport à ceux équipés de modèles CAS haut de gamme (TI Nspire CX2, HP Prime ou Casio Classpad), il y a pas mal de possibilités techniques (par exemple avoir deux modèles de calculatrices, avoir plusieurs modes examens, signer χ\chiCAS pour la France...). Il est d’ailleurs assez symptomatique que Numworks ait discuté du verrouillage pendant plusieurs mois avec beaucoup de monde dans la communauté ... mais jamais avec moi!

A.3  Développer pour Epsilon/Omega/Upsilon vs Giac/χ\chiCAS : une querelle ancien-moderne?

Epsilon (et ses dérivés) est écrit en C++ en utilisant des fonctionnalités avancées du langage, il est difficile de naviguer dans le code source avec des éditeurs comme emacs (il y a beaucoup de petits fichiers sources avec des arborescences profondes et des espaces de noms imbriqués) et pour compiler il faut une version récente de gcc (9). Giac est aussi écrit en C++ mais en fait c’est un style très proche du C, impératif, avec des noms de fonction courts, peu de fichiers sources dans un même répertoire et on peut compiler avec des versions anciennes de gcc (4).

Epsilon n’utilise pas les librairies standards (libc, libstdc++) contrairement à Giac. Il n’y a pratiquement pas de mémoire sur le tas pour allouer des structures de données avec malloc ou new. Je pense que ce choix, lié aux faibles capacités mémoire de la calculatrice, a fait et fait perdre pas mal de temps de développement, d’abord parce que dans les premières versions Epsilon utilisait le tas, ils a fallu réécrire ensuite autrement, ensuite parce qu’ils doivent rajouter manuellement des algorithmes standard des librairies standards lorsqu’ils en ont besoin, enfin parce que l’architecture du système est beaucoup plus complexe.

La complexité est parfois nécessaire, mais si on se laisse fasciner, on risque d’oublier l’objectif ou/et coder de manière inefficace ou renoncer devant des objectifs plus difficiles. Et surtout la marche est haute pour commencer à développer : ici il faut s’approprier une architecture complexe et compiler un firmware complet, voir par exemple un tutoriel ici. Très bien fait, mais on est déjà bien fatigué avant d’avoir pu écrire un algorithme un peu original! Pas étonnant finalement qu’il n’y ait que deux applications Omega (RPN et Atomic) qui ne sont pas de Numworks (trois si on y ajoute External qui permet d’utiliser χ\chiCAS, un éditeur hexa, des jeux), alors que les sources de l’OS sont disponibles depuis 5 ans. Upsilon, un fork du projet Omega, est de mon point de vue un peu meilleur sur cet aspect de développement original, avec une application liseuse de fichiers texte (support partiel de commandes LaTeX) et un support de MicroPython plus récent que celui de Numworks et avec des modules scientifiques complémentaires. On peut aussi observer que ni Epsilon ni ses forks ne proposent de tableur, plus de 5 ans après la sortie de la première version d’Epsilon. (alors qu’il existait plusieurs tableurs développés par la communauté pour les HP48 il y a 25 ans, bien sur, avec une interface plus rudimentaire, mais fonctionnels). Il y a des centaines de programmes disponibles pour les calculatrices concurrentes avec des communautés assez actives, on ne peut pas dire que c’est le cas pour la Numworks, l’activité récente de Omega et Upsilon consiste essentiellement à rester compatible avec les protections des dernières versions d’Epsilon.

On verra s’il y a d’autres développeurs qui se lancent pour créer des applications externes avec ce que propose Epsilon 16 ou supérieur, mais le squelette d’application exemple est aussi relativement complexe, cf. l’exemple, avec 21 fichiers sources pour 773 lignes de code. On peut comparer avec les exemples d’applications additionnelles dans χ\chiCAS de complexité croissante, allant de la suite de Syracuse (25 lignes) à la fractale de Mandelbrot (29 lignes), au mastermind (132 lignes) ou au tableau périodique (environ 400 lignes) jusqu’au tableur (un peu plus de 1000 lignes), le tout dans un ou deux fichiers source (kadd.cc, kdisplay.cc pour le tableau périodique).

Comme je l’écrivais en titre, c’est peut-être une querelle ancien-moderne. Mais peut-être aussi une question de culture. Le matheux que je suis voit vraiment l’informatique comme un outil pour calculer, et écrire des algorithmes, en général en lien avec les maths. Écrire du code d’interface ne m’intéresse pas, je le fais par obligation. L’inverse est certainement vrai pour beaucoup de passionés d’informatique, en tout cas c’est mon impression quand j’enseigne les maths en parcours informatique ou quand j’échange sur les forums. Lorsque Numworks dit que sa calculatrice va faire aimer les maths, cela n’a absolument pas le même sens pour eux que pour moi. Pour eux, cela veut visiblement dire proposer une belle interface qui donne aux élèves avec le moins d’effort possible les réponses aux problèmes types de maths donnés au lycée. Alors que moi je souhaite rendre les élèves autonomes pour être capable de résoudre des problèmes en-dehors des exercices types de lycée, et donner aux élèves motivés l’envie d’aller au-delà des programmes scolaires en utilisant toute la puissance de calcul à leur disposition sur la calculatrice pour explorer. Malheureusement, j’ai l’impression que de moins en moins de gens sont de mon avis, y compris chez certains profs de maths. La principale raison à mon avis, c’est le déclassement du métier de prof, qui a conduit à une crise de recrutement, et un niveau moyen en maths des étudiants au capes de plus en plus faible. Parallèlement, le mauvais usage des outils de calcul (en presse-boutons) conduit à une contre-réaction hostile parmi les profs de maths qui sont bons dans leur discipline.

Il y a aussi une controverse sur les outils de développement et collaboration. L’outil de synchronisation à la mode aujourd’hui est git avec un hébergement sur github et les jeunes ne jurent que par Discord. Personnellement, je travaille essentiellement seul et j’ai l’habitude d’utiliser des archives tar pour mes sauvegardes. Pour collaborer, j’ai l’habitude d’utiliser svn, que je trouve plus simple pour faire un commit que git (une étape et pas deux). Je n’aime pas du tout l’idée d’héberger des projets sur github, cela donne trop de controle à l’hébergeur (Microsoft ici) et c’est aussi bien trop centralisé à mon gout (le contraire de ce qui a donné naissance à Internet), sans compter que le cout en ressources doit être gigantesque. Si d’autres développeurs le font, je respecte leur choix, et je consulte ou utilise du code source indépendamment de la façon dont il est produit et publié, ce qui importe c’est le code lui-même. Je n’ai jamais essayé Discord et je n’ai pas l’intention d’essayer, c’est peut-être très convivial en particulier pour de la communication synchrone, mais c’est du logiciel propriétaire sur lequel on n’a aucun controle alors qu’il y a des logiciels libres qui permettent de gérer des forums, où on discute de manière asynchrone ce qui de plus me convient mieux. Bref, je ne vois pas au nom de quoi github+discord devrait être la seule et unique façon de développer et collaborer, surtout que cela pourrait être remplacé par d’autres outils dans quelques années (comme cvs par svn puis git, ou SourceForge). Il y a une forme d’intégrisme dans l’usage de l’outil informatique chez certains (y compris au plus haut niveau de l’éducation nationale avec l’imposition de Python comme unique langage de programmation au lycée), qui devient un peu comme une religion. Il serait souhaitable je pense qu’il y ait plus de tolérance, la diversité est une richesse.

Je travaille depuis 24 ans sur Giac et je programme du calcul formel depuis 30 ans, au début le web n’existait même pas, les échanges se faisaient via des newsgroup et des serveurs ftp. Je ne suis sur aucun réseau social, ni sur des systèmes d’échange synchrones et je n’en vois pas trop l’intérêt, la consultation asynchrone de forums et d’emails me semble bien plus approprié, on est dans sa bulle quand on code et on ne se laisse pas distraire par des notifications. Je ne me précipite pas sur la dernière mise à jour ou la dernière nouveauté, j’ai appris à mes dépens que quand quelque chose marche, il faut y réfléchir à deux fois avant de le modifier (et bien conserver une sauvegarde de ce qui marchait). J’ai aussi appris que le monde est complexe, il m’a fallu parfois plusieurs mois pour porter Giac et ses dépendances sur une calculatrice. Les erreurs de compilation ou d’édition de liens lors d’un nouveau portage sont normales et se comptent souvent par centaines. Si on ne travaille que sur des petits projets ou des projets récents, on risque de prendre des habitudes de confort où tout marche du premier coup et de renoncer à la première difficulté.

B  Équivalents dans χ\chiCAS de fonctionnalités mathématiques d’Epsilon ≥\geq 16.

Dans cette section on explique comment faire avec χ\chiCAS pour retrouver les fonctionnalités mathématiques récemment introduites par Numworks dans Epsilon. En effet χ\chiCAS s’utilise conjointement avec la version 15.5 d’Epsilon et il n’est pas commode ou pas possible d’installer une version plus récente d’Epsilon en parallèle.

  

Ce document a été traduit de LATEX par HEVEA