Clone logiciel de la calculatrice HP 41C

[lerautal]

Bonjour,
1.
Avant 1981, la SAF (société astronomique de France) avait publié dans sa revue "l'Astronomie" une succession d'articles sur le thème des calculs astronomiques réalisables avec les calculatrices scientifiques accessibles depuis peu au grand public.
L'auteur en était Jean MEEUS, personnalité reconnue pour sa compétence.
Le sujet étant peu traité en France, il y eut une demande de réédition, ce qui se fit dans un petit fascicule, vite épuisé, et réédité depuis : Voir https://boutique.saf-astronomie.fr/prod ... onomiques/
Cet ouvrage fut une incitation forte pour réaliser de petits programmes avec la HP 41 C pourvue du lecteur de cartes magnétiques. Conséquence heureuse : les compétences acquises ainsi m'ont permis une évolution de carrière inespérée.
2.
Faute de disposer d'une calculatrice en état de marche, on peut rechercher des émulations logicielles.
La page http://www.hp41.org/Emulation.cfm recense, système par système, les émulateurs connus de l'auteur.
Curiosité : une version pour PalmOS.
À l'essai sur mon smartphone : la version go41c
Alain

[lerautal]

Le manuel en anglais au format PDF est consultable, mais pas téléchargeable à l'adresse :
https://www.modesdemploi.fr/hp/41c/mode-d-emploi
Un PDF en français est téléchargeable à l'adresse : https://literature.hpcalc.org/community ... hpg-fr.pdf
Il comporte moins de pages que le précédent, mais semble identique au manuel de mon ancien appareil.
Remarque : étant passé par Forth entre temps, je cherchais la touche Drop et, finalement ai retrouvé Clx/A
(le A pour effacer le registre ALPHA)

[lerautal]

1.
Les nombres astronomiques sont longs - c'est d'ailleurs passé dans le langage courant - et plus il y a de chiffres, plus le résultat est précis.
Quelle est la précision de la HP, et celle des langages Forth acceptant les flottants ?
2.
Avec une HP 41, taper successivement :
bouton jaune Fix 9 ENTER (pour n'afficher qu'une décimale)
0.1234567 ENTER affiche 0.1234567
0.12345678 ENTER affiche 0.12345678
0.123456789 ENTER affiche 0.123456789
1234567891 ENTER : le 1 disparaît, parce que le nombre est trop long.

Avec un Forth acceptant les flottants comme rtf cité dans le sujet "Un forth codé en rust", effectuons les mêmes essais
0.12345678e f. affiche 0.12345678 ok
Mais 0.123456789e f. affiche 0.12345678 ok
Le 9 disparaît : la précision de calcul sur les flottants est inférieure à celle des HP.

Si l'on effectue les mêmes tests avec gforth, on peut poursuivre les essais jusqu'à
0.1234567890123456e f. 0.123456789012346 soit 15 chiffres après la virgule.
gforth est un bien meilleur outil pour cet usage.

3.
Gforth est une déclinaison, libre et gratuite, de la norme 2012 du langage.
https://gforth.org/
La commande words affiche une liste très longue mais les mots sont documentés dans le words-index https://net2o.de/gforth/Word-Index.html
gforth existe pour processeur arm et on peut l'exécuter dans Raspberry Pi OS.

4.
Remarque : en utilisant Python via l'interface idle, on retrouve la même précision.
Celle-ci est liée aux processeurs de la machine et aux normes définies pour les calculs "admissibles" (sans bibliothèques spécialisées).

En guise de conclusion.
Si l'on veut reprendre les calculs astronomiques du livre cité, en remplaçant la HP41 par un langage "à piles", la version gforth semble la plus adaptée.

[lerautal]

Dans le sujet portant sur les clones matériels de la HP41 C, j'ai défini un premier projet utilisant ce que je possède et qui n'est pas utilisé actuellement :
Une carte Raspberry pi 3B+, une écran tactile officiel de 7 pouces, un mini clavier.
Partant de cette base matérielle, diverses tentatives peuvent être imaginées, en utilisant divers langages de programmation.

1. Trois logiques d'interfaçage envisagées :
A - En mode textuel, et dans ce cas-là on peut se contenter d'une distribution Linux plus légère, sans serveur graphique. Mais que devient alors la gestion de l'écran tactile ?
B - En mode textuel, au sein d'un terminal ouvert dans un environnement graphique.
C - En mode graphique pur. Dans ce cas, et afin d'éviter de se frotter à Qt ou GTK, le plus simple serait d'utiliser un navigateur qui permet de paramétrer l'aspect de ce qui s'affiche de façon moins rebutante.
Remarque : cette façon de penser le problème peut être transposée à d'autres environnements tels que Riscos.

2. Menus textuels dans une interface graphique
Pas envie, ici, de reproduire l'aspect matériel de la HP41 : des clones logiciels existent, en particulier pour smartphone.
Ils sont beaux et fonctionnels et ce serait perdre du temps que de refaire ce qui est réussi par d'autres.
La solution imaginée comporte schématiquement deux zones :
- la zone d'introduction des nombres (ou du texte)
- des menus donnant accès aux fonctions

3. Choix B
On utilisera Python associé à la bibliothèque Tkinter.
La calculatrice fictive sera donc, pour le moment, la RP41 P.
(Raspberry Pi 41 avec Python)
Mais avec quels supports d'exemples démarrer ?
Celui-ci fournit des explication détaillées mais, malheureusement, on ne peut faire du copier coller du programme d'exemples.
https://www.educationdunumerique.fr/les-menus.php
Beaucoup plus riche, et permettant de copier les exemples, voici un ensemble de pages très utile :
https://www.oujood.com/tkinter/

Avant de poursuivre, expérimentons à partir des liens proposés (ou d'autres).

[lerautal]

1.Recherche d'exemples pédagogiques d'une calculatrice simple avec Python3 et Tkinter.
On trouve de nombreux exemples, proposés par des gens plus ou moins bien intentionnés ou maladroits... ou les deux.
Erreurs de codage, aboutissant à un échec, code fourni complet mais non formaté,...
Attention ici : on peut perdre beaucoup de temps et se décourager.
J'ai retenu cet exemple qui s'exécute sur ma machine sous Linux:
https://github.com/WilliamsLenkeu/CalculatriceGraphique

2. Attention : il faut installer une bibliothèque complémentaire
Celle-ci s'appelle Simpy et on n'en dira rien pour le moment : simplement si elle n'est pas présente, le programme ne s'exécutera pas.
Cela génère une complication : il fut un temps ou Python était très permissif et où on pouvait installer tout et n'importe quoi, n'importe où. Avec, au bout, un bazar immonde.
La logique d'installation adoptée pour Python3 est plus rigide, et j'en connais deux :
- Installer avec le gestionnaire de paquets de ma distribution Linux. Avantage de la cohérence, mais certains paquets spécifiques ne font pas partie des distributions LInux standard.
- Utiliser un gestionnaire de bibliothèques Python appelé Pip qui contraint à créer des environnements (répertoires) cohérents dédiés à un projet. Cette solution est préférable si l'on programme souvent en Python avec des thèmes différents : les bibliothèques financières, statistiques, graphiques ou astronomiques correspondant à des centres d'intérêts différents, il est sain de séparer logiquement les "environnements" des thèmes choisis.
Mais Ici, on va au plus simple : sous Debian :

Code : Tout sélectionner

 sudo apt install python3-sympy

3. Exécution du programme
D'abord, télécharger le fichier .zip contenu dans la page Github.
Créer un répertoire pour le désarchiver. Désarchiver le zip.
Il contient deux fichiers : main.py et README.md. Le programme Python est main.py
Pour lancer l'exécution, ouvrir un terminal et se déplacer dans le répertoire créé.
Taper :

Code : Tout sélectionner

python3 main.py

Vous obtiendrez une petite calculatrice, fonctionnelle en plus.



4. Remarques sur le code
Il ne totalise que 76 lignes et, si l'on n'est pas rétif à la syntaxe de Python, son organisation est claire.
Ce code est astucieux. À titre d'exemple, l'auteur utilise une boucle for pour positionner les boutons pour les chiffres, ce qui donne un code beaucoup plus court que si l'on positionnait chacun à la main.

Code : Tout sélectionner

  
# Boutons pour les chiffres
chiffres = "7894561230"
row_val = 1
col_val = 0f
for chiffre in chiffres:
            tk.Button(fenetre, text=chiffre, command=lambda c=chiffre: self.ajouter_caractere(c)).grid(row=row_val, column=col_val, sticky="nsew")
            col_val += 1
            if col_val > 2:
                col_val = 0
                row_val += 1

5. En attendant la suite
À partir de l'exemple fourni il devient possible de se passer d'un clavier annexe et de n'utiliser que l'écran tactile.
En dehors du fait que l'on élimine tous les problèmes liés à un objet communicant (dongle égaré, recharges à prévoir...), cela permet de simplifier les tests sur les valeurs introduites : seules celles qui sont présentes sur l'écran seront saisies.
Dans une étape suivante, il faudra passer de la saisie des calculs en mode infixe :

Code : Tout sélectionner

exemple : 14 + 78 =

à celle utilisée par la hP41, en mode postfixé, avec gestion d'une pile.

Code : Tout sélectionner

Exemple : 14  ENTER  78  +

[lerautal]

Tourner 7 fois sa langue et ne faire confiance à personne.
Avec pour conséquences de se retrouver à bougonner seul dans son coin avec les maxillaires endoloris.

1. Encore un code mal fichu
À regarder la petite calculatrice, j'ai réalisé qu'il manquait deux choses :
- le zéro
- le signe de la division
Bizarre.
La boucle for signalée plus haut utilise une liste de signes où figure le zéro :

Code : Tout sélectionner

chiffres = "7894561230"
...
for chiffre in chiffres:
            afficher les boutons

Tout se passe comme si cet affichage était effacé par ce qui suit.
Mais quelle est cette suite ?

Code : Tout sélectionner

# Bouton égal
tk.Button(fenetre, text="=", command=self.evaluer_expression).grid(row=4, column=3, sticky="nsew")

Ce qui est important, c'est row = 4 : affichage sur la 4 ligne. Or la quatrième ligne est justement celle qui affiche ce que l'on ne voit pas.
Une correction à la main par row=5 rétablit les choses.

Code : Tout sélectionner

# Bouton égal
tk.Button(fenetre, text="=", command=self.evaluer_expression).grid(row=5, column=3, sticky="nsew
# Bouton Clear
tk.Button(fenetre, text="C", command=self.clear).grid(row=5, column=0, columnspan=2, sticky="nsew")
# Bouton Backspace
tk.Button(fenetre, text="←", command=self.backspace).grid(row=5, column=2, sticky="nsew")

Ce qui donne une calculatrice plus complète, même si la barre de titre est incomplète.


2. Le retour de Simpy
Le code paraît court pour faire "tout ça" et ce qui se passe après la saisie est bien mystérieux.
Une modification de la fonction d'évaluation va pouvoir nous aider à comprendre.

Code : Tout sélectionner

def evaluer_expression(self):
        try:
            expression = self.expression_var.get()
            print(expression) # ajouté pour test
          ...

J'ai ajouté print(expression) de façon à provoquer le listage, dans la fenêtre du terminal, de ce qui est capturé.
Exemple, après avoir entré 45*12=
La calculatrice affiche 540 et dans le terminal apparaît
45*12
... qui est envoyé à Simpy avant d'afficher le résultat.

Code : Tout sélectionner

            
resultat = sympify(expression)
self.resultat_var.set(resultat)
self.expression_var.set(resultat)

3. Une suite possible
En remplaçant la bibliothèque Simpy par un ensemble de fonctions effectuant l'adaptation à la logique HP 41, il devrait être possible de progresser à moindre coût.

[Hèlene]

Bonjour,
1.
Avant 1981, la SAF (société astronomique de France) avait publié dans sa revue "l'Astronomie" une succession d'articles sur le thème des calculs astronomiques réalisables avec les calculatrices scientifiques accessibles depuis peu au grand public.
L'auteur en était Jean MEEUS, personnalité reconnue pour sa compétence.
Le sujet étant peu traité en France, il y eut une demande de réédition, ce qui se fit dans un petit fascicule, vite épuisé, et réédité depuis : Voir https://boutique.saf-astronomie.fr/prod ... onomiques/
Cet ouvrage fut une incitation forte pour réaliser de petits programmes avec la HP 41 C pourvue du lecteur de cartes magnétiques. Conséquence heureuse : les compétences acquises ainsi m'ont permis une évolution de carrière inespérée.
2.
Faute de disposer d'une calculatrice en état de marche, on peut rechercher des émulations logicielles.
La page http://www.hp41.org/Emulation.cfm recense, système par système, les émulateurs connus de l'auteur.
Curiosité : une version pour PalmOS.
À l'essai sur mon smartphone : la version go41c
Alain

Super démarche. Je dois avouer que depuis que je suis sur le forum, je ne m'ennuie pas. Utiliser tkinter pour coder une petite interface tactile sur raspberry pi, c'est vraiment le bon réflexe je trouve. Je ne sais pas pour vous mais je trouve cela léger, natif avec python et ça évite de se prendre la tête avec des frameworks graphiques trop lourds pour une petite machine.
Je trouve aussi que tu as bien fait de pointer les incohérences dans le code du repo github (row=4 au lieu de row=5), c’est le piège classique des exemples mal nettoyés avant d'être publiés.
Pour la transition vers la logique RPN de la HP41, se passer de SymPy pour gérer soi même une structure de pile (stack) en Python se fait très bien avec une simple liste (append pour empiler et pop pour dépiler). Cela va rendre ton code encore plus léger et autonome sur le Pi. Perso j'ai hâte de voir la suite du projet

[lerautal]

En réponse à Hélène (mais pas que...)

1.
La rentrée, les foras (pédant ?) d'associations, le redémarrage et trop de choses à faire, en particulier un aide-mémoire bridge qui tienne la route pour la reprise des tournois.
À propos de Python, j'ai signalé sur la liste riscos une page sur la gestion des dépendances.
(Voir https://www.stat4decision.com/fr/compre ... ts-python/ )
Dans mes loisirs intellectuels, les projets reviennent de façon cyclique : chacun obtenant l'attention nécessaire, le temps d'avancer. Puis l'urgence change de camp... et la roue tourne.

2.
Cela me fait penser au multitâche et à la gestion des processus.
Voir par exemple : https://repo.zenk-security.com/Linux%20 ... cessus.pdf
Page 45 , les philosophes :
"Un philosophe passe son temps à manger et à penser. Lorsqu’un
philosophe a faim, il tente de s’emparer des deux fourchettes qui
sont à sa droite et à sa gauche, une après l’autre. L’ordre n’importe
pas. S’il obtient les deux fourchettes, il mange pendant un certain
temps, puis repose les fourchettes et se remet à penser..."

3.
Pour l'image du labeur qui se répète associée à celle de la roue (ce qui est cyclique et qui se répète), voici une représentation symbolique.
Celle de la cage d'écureuil.

(image prise dans l'article wikipedia suivant : https://fr.wikipedia.org/wiki/Cage_d%27%C3%A9cureuil )

4.
Je m'amuse, je m'amuse... et le travail n'avance pas.
Remboursez !