[critor]

Attention, le contenu de cet article se basant sur une version alpha/beta, les fonctionnalités
décrites ici peuvent totalement changer d'ici l'éventuelle version officielle comprenant l'application Python!

Dans une actualité précédente, Hewlett Packard Calculatrices t'invitait à tester les prochaines mises à jour de son écosystème HP Prime, avec les versions bêta du 22 octobre.

Plus précisément, la publication incluait :

• le firmware pour HP Prime G1 (version 2.1.14285) et HP Prime G2 (version 2.1.14284)
• le logiciel de connectivité HP Prime Connectivity Kit (version 2.1.14288) pour Windows et Mac
• le logiciel de simulation HP Prime Virtual Calculator (version 2.1.14288) pour Windows, Mac et Linux
• les applications HP Prime pour iOS

Aujourd'hui il y a plusieurs nouveautés par rapport à ce bêta-test. Déjà, les applications HP Prime pour Android sont maintenant également disponibles.

Mais surtout, le firmware HP Prime G1 est bizarrement le seul à avoir été remplacé par une nouvelle version 2.1.14298 du 28 octobre. Pourquoi ?...

En effet, le firmware 2.1.14285 pour HP Prime G1 était le seul à inclure quelque chose qui ne devait pas encore être prêt pour une annonce au grand public, une application Python, qui a été retirée pour la nouvelle version 2.1.14298.

Maintenant que c'est trop tard et qu'il en est question sur pas moins de 2 pages forum HP Museum, profitons-en pour voir ce que HP nous prépare.

Précisons que la HP Prime accepte depuis la version 13333 une écriture en syntaxe Python en mode CAS, héritée du développement du moteur formel GIAC du logiciel Xcas par Bernard Parisse.

L'écriture Python de la HP Prime dispose d'avantages remarquables par rapport aux solutions Python de la concurrence, comme :

• la possibilité d'obtenir les résultats numériques en valeur exact sans aucun artifice dans le code
• la possibilité de faire du calcul littéral et formel
• la possibilité de dessiner à l'écran, conformément au nouveau programme de Physique-Chimie Seconde depuis la rentrée 2019

Elle n'en reste pas moins très imparfaite avec nombre de scripts Python pourtant parfaitement corrects qui renverront une erreur ou autre chose que ce qui était prévu. A moins de les écrire d'une façon bien particulière ou spéciale... astuces d'écriture qui nécessitent donc paradoxalement en phase d'apprentissage/découverte une certaine compréhension du fonctionnement interne et des différences entre les langages Python et HP Prime CAS.

Pour le logiciel Xcas ainsi que ses déclinaisons delta pour NumWorks et KhiCAS pour Casio Graph 35+E II et Graph 90+E, ce n'est pas problématique puisque Bernard est très réactif et accomplit un travail formidable avec des mises à jour hebdomadaires !
Mais sur HP Prime avec à peine une mise à jour par an, les nombreux retours que nous avons faits ne sont donc pris en compte qu'à retardement. Par exemple là la dernière mise à jour remonte à novembre 2018, et pour notre concours de rentrée en Python nous avons dû littéralement nous arracher les cheveux à peu près autant que l'année dernière pour que notre script soit compatible HP Prime, vu qu'il n'y a eu aucune correction des nombreux problèmes.

Si la solution GIAC/Xcas/delta peut certes convenir pour les modèles Casio/NumWorks ainsi que les petits scripts d'initiation en Mathématiques au lycée, elle nous paraît en l'état actuel inadéquate sur HP Prime pour poursuivre avec des scripts plus sérieux ou projets en NSI par exemple, et avec un rythme de mises à jour qui se compte en années ce n'est hélas pas près de changer.

Qu'est-ce donc que la nouvelle application Python HP Prime ? Une interface pour utiliser plus facilement l'écriture Python du mode CAS, ou bien un véritable interpréteur Python ? Nous allons voir cela ensemble.

A mieux y regarder, cette version 2.1.14285 serait plutôt une version alpha que bêta selon nous. On se rend rapidement compte que certaines fonctionnalités sont cassées et qu'il y a plusieurs problèmes :

• les calculs en mode RPN ne fonctionnent plus
• la réception de programmes ne fonctionne plus, ne donnant que des programmes vides dont le nom est bizarrement suffixé d'un :Main(1) dans l'éditeur
• en cas de redémarrage la calculatrice s'amorce visiblement 2 fois, comme si elle plantait lors du 1^er amorçage
• en cas de redémarrage de la calculatrice, toutes les données saisies sont perdues

Voilà donc pourquoi elle a été aussi vite remplacée par HP.

Des conditions peu agréables pour découvrir la nouvelle application Python, mais nous allons quand même faire un effort pour toi.

Sommaire :Go to top

1. Premier contact et méthode de saisie
2. Mantisses et exposants en virgule flottante
3. Modules importables et aide en ligne
4. Exploration module sys et nombres entiers
5. Exploration autres modules
6. Mémoire de travail et récursivité
7. Performances
8. Récapitulatif et conclusion

1) Premier contact et méthode de saisie :

Go to top

L'ouverture de la nouvelle application Python nous amène à un écran comportant un avertissement sur le caractère non final de cette version, et acceptant des saisies en syntaxe Python. Il s'agit donc d'une console (shell).

L'interface rudimentaire ne semble pas encore avoir prévu de possibilité pour charger un script. Ce qui est particulièrement embêtant pour définir des fonctions et réaliser des tests plus poussés, vu que la saisie sur plusieurs lignes ne semble pas acceptée non plus, même en la précisant explicitement avec le caractère \.

Elle n'est d'ailleurs pas stabilisée, puisque la sortie de l'interface via les touches

Symb

,

Esc

ou le bouton tactile

OK

redémarre la calculatrice, avec perte totale des données comme vu plus haut.

Il va donc nous falloir ruser... On pourrait par exemple mettre nos scripts Python dans l'éditeur de programmes, puis en copier le contenu via

Shift

View

pour alors le coller dans l'application Python via

Shift

Menu

. Effectivement ça marche, mais cette solution n'est toujours pas satisfaisante. En effet, comme le transfert de programmes ne marche plus nous sommes obligés de saisir les scripts à la main sur la calculatrice, et avec une application Python qui plante très facilement avec perte intégrale de la saisie ce n'est pas la panacée.

Nous finissons par avoir l'idée de regarder non plus du côté de l'éditeur de programmes, mais du côté de l'éditeur de remarques (notes). On peut de même en faire des copiés/collés, et ici bonne nouvelle le transfert de données depuis un ordinateur fonctionne encore !

2) Mantisses et exposants en virgule flottante :

Go to top

Pour déterminer à quoi nous avons affaire, nous allons commencer par tester le moteur de calcul numérique de l'application Python. Voici donc notre toute première fonction Python sur HP Prime :

Code: Tout sélectionner

def precm(b):
  k,b=0,float(b)
  while 1+b**-k-1>0:
    k+=1
  return k

L'appel precm(2) nous indique que le moteur travaille en virgule flottante avec des mantisses de 53 bits, permettant environ 16 chiffres significatifs (precm(10)).

C'est le standard double précison du Python, un excellent choix pour le contexte scientifique du lycée !
Cela répond de plus déjà à notre question principale. Cette application Python n'est pas une simple interface pour l'écriture Python du mode CAS. En effet les virgules flottantes HP Prime sont calculées sur 38 bits en mode numérique, et 48 bits en mode CAS. Par élimination, la nouvelle application Python renfermerait donc a priori un véritable interpréteur Python, reste à savoir lequel !

Nous notons en passant l'affichage asiatique incorrect suivant la définition de la fonction. Et bien que notre fonction soit fonctionnelle, le problème semble plus profond qu'il n'y paraît, puisque nous n'arrivons pas à définir de deuxième fonction, ou du moins pas de deuxième fonction nécessitant une saisie sur plusieurs lignes. La fonction n'existe tout simplement pas après la nouvelle saisie par copié/collé. Peut-être y a-t-il un message d'erreur, mais comme c'est du chinois...

Nous réinitialisons donc l'interface pour notre deuxième fonction :

Code: Tout sélectionner

def prece():
  a=-1
  while 2.**a>0:
    a*=2
  while 2.**a==0:
    a+=1
  b=1
  while str(2.**b)[0:3]!='inf':
    b*=2
  while str(2.**b)[0:3]=='inf':
    b-=1
  return [a,b]

L'appel prece() nous indique que les exposants des virgules flottantes peuvent aller de -1074 à +1023, valeurs habituelles pour le standard double précision d'un véritable interpréteur Python.

3) Modules importables et aide en ligne :

Go to top

Puisque nous disposons donc apparemment d'un véritable interpréteur Python, continuons à explorer. Et la question suivante est de savoir de quels modules nous disposons. Malheureusement nous ne pouvons pas le demander via help("modules"), vu que HP n'a visiblement pas implémenté cette fonction Python pourtant standard.

Pour sa part, la touche d'aide en ligne de la calculatrice

Help

donne bien quelque chose, mais c'est très sommaire sans mention du moindre module. Par contre on y apprend que la touche

Symb

est prévue pour l'édition de scripts, même si nous avons vu plus haut qu'elle ne fonctionnait pas correctement.

Bon ben pas trop le choix... soit on tente à la main d'importer un maximum de modules Python au risque d'en rater quelques-uns... soit on fouille le firmware à l'éditeur hexadécimal.

Retenons cette dernière option. Nous trouvons facilement dans le firmware des occurences groupées avec math, cmath, mais aussi matplotlib, numpy, pylab, turtle et même kandinsky ! (coucou NumWorks ! )
C'est peut-être trop beau pour être vrai avec une version alpha aussi jeune, et effectivement à part les modules math et cmath, aucun autre ne marche.
A bien y repenser, il s'agit sans doute de ressources concernant non pas la nouvelle application Python, mais l'écriture Python du mode CAS qui à part pour turtle propose plusieurs fonctions équivalentes pour ces modules, et doit donc reconnaître les commandes d'importation correspondantes.

Mais nous ne désespérons pas et finissons par trouver le bon segment on ne peut plus excplicite avec des traces de commandes de compilation qui ont réussi à être incluses dans le firmware :

Code: Tout sélectionner

modes.o
ARM C/C++ Compiler, 4.1 [Build 894]
ArmCC --cpp --whole_program --split_sections -c  --depend=.\obj\modes.d --cpu=ARM926EJ-S --fpmode=ieee_full --apcs=interwork//interwork -O3 --diag_suppress=1,9,111,161,177,185,191,368,514,550,611,1293,1299,1300,1464 -I..\ -I..\src -I..\..\Core -I..\..\Core\src -I..\..\Core\CAS\src -I..\..\Core\TomMath -I..\..\Core\napier -I..\..\Core\freetype\include\ -I..\..\Core\freetype\include\freetype\ -I..\..\_qt5\src -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -DUNICODE -D_UNICODE -DBESTA_OS -DBESTA_ARM_TARGET -DARM -DARM9 -DARM11 -DARM1176JZF -DSTANDALONE -DADS_COMPILER -DPDADEF -DKERNEL -DFULL_NAND_SYS -DFS_LONG_NAME_GET -DHAVE_AV_CONFIG_H -DEMULATE_FAST_INT -DEMULATE_INTTYPES -DFLASHLITEDLL -DFLASH_BESTARTOS -DFL31_STATICLIBRARY -D__STDC_LIMIT_MACROS -DFIR -DHAVE_CONFIG_H -DIN_GIAC -DUSE_GMP_REPLACEMENTS -DBCD -DNO_UNARY_FUNCTION_COMPOSE -DSTATIC_BUILTIN_LEXER_FUNCTIONS -DNO_STDEXCEPT -DNO_PHYSICAL_CONSTANTS -DGIAC_HAS_STO_38 -DCAS38 -DFT2_BUILD_LIBRARY -Dsprintf=__sprintf -D__cplusplus -DNDEBUG -D__USB_CONFIG__ -DUSBH0_ENABLE -DUSBH0_HC_IF -DUSBD_ENABLE -DUSBD_HID_ENABLE --loose_implicit_cast --remove_unneeded_entities
modfactor.o
ARM C/C++ Compiler, 4.1 [Build 894]
ArmCC --cpp --whole_program --split_sections -c  --depend=.\obj\modfactor.d --cpu=ARM926EJ-S --fpmode=ieee_full --apcs=interwork//interwork -O3 --diag_suppress=1,9,111,161,177,185,191,368,514,550,611,1293,1299,1300,1464 -I..\ -I..\src -I..\..\Core -I..\..\Core\src -I..\..\Core\CAS\src -I..\..\Core\TomMath -I..\..\Core\napier -I..\..\Core\freetype\include\ -I..\..\Core\freetype\include\freetype\ -I..\..\_qt5\src -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -DUNICODE -D_UNICODE -DBESTA_OS -DBESTA_ARM_TARGET -DARM -DARM9 -DARM11 -DARM1176JZF -DSTANDALONE -DADS_COMPILER -DPDADEF -DKERNEL -DFULL_NAND_SYS -DFS_LONG_NAME_GET -DHAVE_AV_CONFIG_H -DEMULATE_FAST_INT -DEMULATE_INTTYPES -DFLASHLITEDLL -DFLASH_BESTARTOS -DFL31_STATICLIBRARY -D__STDC_LIMIT_MACROS -DFIR -DHAVE_CONFIG_H -DIN_GIAC -DUSE_GMP_REPLACEMENTS -DBCD -DNO_UNARY_FUNCTION_COMPOSE -DSTATIC_BUILTIN_LEXER_FUNCTIONS -DNO_STDEXCEPT -DNO_PHYSICAL_CONSTANTS -DGIAC_HAS_STO_38 -DCAS38 -DFT2_BUILD_LIBRARY -Dsprintf=__sprintf -D__cplusplus -DNDEBUG -D__USB_CONFIG__ -DUSBH0_ENABLE -DUSBH0_HC_IF -DUSBD_ENABLE -DUSBD_HID_ENABLE --loose_implicit_cast --remove_unneeded_entities
modpoly.o
ARM C/C++ Compiler, 4.1 [Build 894]
ArmCC --cpp --whole_program --split_sections -c  --depend=.\obj\modpoly.d --cpu=ARM926EJ-S --fpmode=ieee_full --apcs=interwork//interwork -O3 --diag_suppress=1,9,111,161,177,185,191,368,514,550,611,1293,1299,1300,1464 -I..\ -I..\src -I..\..\Core -I..\..\Core\src -I..\..\Core\CAS\src -I..\..\Core\TomMath -I..\..\Core\napier -I..\..\Core\freetype\include\ -I..\..\Core\freetype\include\freetype\ -I..\..\_qt5\src -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -DUNICODE -D_UNICODE -DBESTA_OS -DBESTA_ARM_TARGET -DARM -DARM9 -DARM11 -DARM1176JZF -DSTANDALONE -DADS_COMPILER -DPDADEF -DKERNEL -DFULL_NAND_SYS -DFS_LONG_NAME_GET -DHAVE_AV_CONFIG_H -DEMULATE_FAST_INT -DEMULATE_INTTYPES -DFLASHLITEDLL -DFLASH_BESTARTOS -DFL31_STATICLIBRARY -D__STDC_LIMIT_MACROS -DFIR -DHAVE_CONFIG_H -DIN_GIAC -DUSE_GMP_REPLACEMENTS -DBCD -DNO_UNARY_FUNCTION_COMPOSE -DSTATIC_BUILTIN_LEXER_FUNCTIONS -DNO_STDEXCEPT -DNO_PHYSICAL_CONSTANTS -DGIAC_HAS_STO_38 -DCAS38 -DFT2_BUILD_LIBRARY -Dsprintf=__sprintf -D__cplusplus -DNDEBUG -D__USB_CONFIG__ -DUSBH0_ENABLE -DUSBH0_HC_IF -DUSBD_ENABLE -DUSBD_HID_ENABLE --loose_implicit_cast --remove_unneeded_entities
modmicropython.o
ARM C/C++ Compiler, 4.1 [Build 894]
ArmCC --cpp --whole_program --split_sections -c  --depend=.\obj\modmicropython.d --cpu=ARM926EJ-S --fpmode=ieee_full --apcs=interwork//interwork -O3 --diag_suppress=1,9,111,161,177,185,191,368,514,550,611,1293,1299,1300,1464 -I..\ -I..\src -I..\..\Core -I..\..\Core\src -I..\..\Core\CAS\src -I..\..\Core\TomMath -I..\..\Core\napier -I..\..\Core\freetype\include\ -I..\..\Core\freetype\include\freetype\ -I..\..\_qt5\src -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -DUNICODE -D_UNICODE -DBESTA_OS -DBESTA_ARM_TARGET -DARM -DARM9 -DARM11 -DARM1176JZF -DSTANDALONE -DADS_COMPILER -DPDADEF -DKERNEL -DFULL_NAND_SYS -DFS_LONG_NAME_GET -DHAVE_AV_CONFIG_H -DEMULATE_FAST_INT -DEMULATE_INTTYPES -DFLASHLITEDLL -DFLASH_BESTARTOS -DFL31_STATICLIBRARY -D__STDC_LIMIT_MACROS -DFIR -DHAVE_CONFIG_H -DIN_GIAC -DUSE_GMP_REPLACEMENTS -DBCD -DNO_UNARY_FUNCTION_COMPOSE -DSTATIC_BUILTIN_LEXER_FUNCTIONS -DNO_STDEXCEPT -DNO_PHYSICAL_CONSTANTS -DGIAC_HAS_STO_38 -DCAS38 -DFT2_BUILD_LIBRARY -Dsprintf=__sprintf -D__cplusplus -DNDEBUG -D__USB_CONFIG__ -DUSBH0_ENABLE -DUSBH0_HC_IF -DUSBD_ENABLE -DUSBD_HID_ENABLE --loose_implicit_cast --remove_unneeded_entities
modarray.o
ARM C/C++ Compiler, 4.1 [Build 894]
ArmCC --cpp --whole_program --split_sections -c  --depend=.\obj\modarray.d --cpu=ARM926EJ-S --fpmode=ieee_full --apcs=interwork//interwork -O3 --diag_suppress=1,9,111,161,177,185,191,368,514,550,611,1293,1299,1300,1464 -I..\ -I..\src -I..\..\Core -I..\..\Core\src -I..\..\Core\CAS\src -I..\..\Core\TomMath -I..\..\Core\napier -I..\..\Core\freetype\include\ -I..\..\Core\freetype\include\freetype\ -I..\..\_qt5\src -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -DUNICODE -D_UNICODE -DBESTA_OS -DBESTA_ARM_TARGET -DARM -DARM9 -DARM11 -DARM1176JZF -DSTANDALONE -DADS_COMPILER -DPDADEF -DKERNEL -DFULL_NAND_SYS -DFS_LONG_NAME_GET -DHAVE_AV_CONFIG_H -DEMULATE_FAST_INT -DEMULATE_INTTYPES -DFLASHLITEDLL -DFLASH_BESTARTOS -DFL31_STATICLIBRARY -D__STDC_LIMIT_MACROS -DFIR -DHAVE_CONFIG_H -DIN_GIAC -DUSE_GMP_REPLACEMENTS -DBCD -DNO_UNARY_FUNCTION_COMPOSE -DSTATIC_BUILTIN_LEXER_FUNCTIONS -DNO_STDEXCEPT -DNO_PHYSICAL_CONSTANTS -DGIAC_HAS_STO_38 -DCAS38 -DFT2_BUILD_LIBRARY -Dsprintf=__sprintf -D__cplusplus -DNDEBUG -D__USB_CONFIG__ -DUSBH0_ENABLE -DUSBH0_HC_IF -DUSBD_ENABLE -DUSBD_HID_ENABLE --loose_implicit_cast --remove_unneeded_entities
modbuiltins.o
ARM C/C++ Compiler, 4.1 [Build 894]
ArmCC --cpp --whole_program --split_sections -c  --depend=.\obj\modbuiltins.d --cpu=ARM926EJ-S --fpmode=ieee_full --apcs=interwork//interwork -O3 --diag_suppress=1,9,111,161,177,185,191,368,514,550,611,1293,1299,1300,1464 -I..\ -I..\src -I..\..\Core -I..\..\Core\src -I..\..\Core\CAS\src -I..\..\Core\TomMath -I..\..\Core\napier -I..\..\Core\freetype\include\ -I..\..\Core\freetype\include\freetype\ -I..\..\_qt5\src -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -DUNICODE -D_UNICODE -DBESTA_OS -DBESTA_ARM_TARGET -DARM -DARM9 -DARM11 -DARM1176JZF -DSTANDALONE -DADS_COMPILER -DPDADEF -DKERNEL -DFULL_NAND_SYS -DFS_LONG_NAME_GET -DHAVE_AV_CONFIG_H -DEMULATE_FAST_INT -DEMULATE_INTTYPES -DFLASHLITEDLL -DFLASH_BESTARTOS -DFL31_STATICLIBRARY -D__STDC_LIMIT_MACROS -DFIR -DHAVE_CONFIG_H -DIN_GIAC -DUSE_GMP_REPLACEMENTS -DBCD -DNO_UNARY_FUNCTION_COMPOSE -DSTATIC_BUILTIN_LEXER_FUNCTIONS -DNO_STDEXCEPT -DNO_PHYSICAL_CONSTANTS -DGIAC_HAS_STO_38 -DCAS38 -DFT2_BUILD_LIBRARY -Dsprintf=__sprintf -D__cplusplus -DNDEBUG -D__USB_CONFIG__ -DUSBH0_ENABLE -DUSBH0_HC_IF -DUSBD_ENABLE -DUSBD_HID_ENABLE --loose_implicit_cast --remove_unneeded_entities
modcmath.o
ARM C/C++ Compiler, 4.1 [Build 894]
ArmCC --cpp --whole_program --split_sections -c  --depend=.\obj\modcmath.d --cpu=ARM926EJ-S --fpmode=ieee_full --apcs=interwork//interwork -O3 --diag_suppress=1,9,111,161,177,185,191,368,514,550,611,1293,1299,1300,1464 -I..\ -I..\src -I..\..\Core -I..\..\Core\src -I..\..\Core\CAS\src -I..\..\Core\TomMath -I..\..\Core\napier -I..\..\Core\freetype\include\ -I..\..\Core\freetype\include\freetype\ -I..\..\_qt5\src -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -DUNICODE -D_UNICODE -DBESTA_OS -DBESTA_ARM_TARGET -DARM -DARM9 -DARM11 -DARM1176JZF -DSTANDALONE -DADS_COMPILER -DPDADEF -DKERNEL -DFULL_NAND_SYS -DFS_LONG_NAME_GET -DHAVE_AV_CONFIG_H -DEMULATE_FAST_INT -DEMULATE_INTTYPES -DFLASHLITEDLL -DFLASH_BESTARTOS -DFL31_STATICLIBRARY -D__STDC_LIMIT_MACROS -DFIR -DHAVE_CONFIG_H -DIN_GIAC -DUSE_GMP_REPLACEMENTS -DBCD -DNO_UNARY_FUNCTION_COMPOSE -DSTATIC_BUILTIN_LEXER_FUNCTIONS -DNO_STDEXCEPT -DNO_PHYSICAL_CONSTANTS -DGIAC_HAS_STO_38 -DCAS38 -DFT2_BUILD_LIBRARY -Dsprintf=__sprintf -D__cplusplus -DNDEBUG -D__USB_CONFIG__ -DUSBH0_ENABLE -DUSBH0_HC_IF -DUSBD_ENABLE -DUSBD_HID_ENABLE --loose_implicit_cast --remove_unneeded_entities
modcollections.o
ARM C/C++ Compiler, 4.1 [Build 894]
ArmCC --cpp --whole_program --split_sections -c  --depend=.\obj\modcollections.d --cpu=ARM926EJ-S --fpmode=ieee_full --apcs=interwork//interwork -O3 --diag_suppress=1,9,111,161,177,185,191,368,514,550,611,1293,1299,1300,1464 -I..\ -I..\src -I..\..\Core -I..\..\Core\src -I..\..\Core\CAS\src -I..\..\Core\TomMath -I..\..\Core\napier -I..\..\Core\freetype\include\ -I..\..\Core\freetype\include\freetype\ -I..\..\_qt5\src -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -DUNICODE -D_UNICODE -DBESTA_OS -DBESTA_ARM_TARGET -DARM -DARM9 -DARM11 -DARM1176JZF -DSTANDALONE -DADS_COMPILER -DPDADEF -DKERNEL -DFULL_NAND_SYS -DFS_LONG_NAME_GET -DHAVE_AV_CONFIG_H -DEMULATE_FAST_INT -DEMULATE_INTTYPES -DFLASHLITEDLL -DFLASH_BESTARTOS -DFL31_STATICLIBRARY -D__STDC_LIMIT_MACROS -DFIR -DHAVE_CONFIG_H -DIN_GIAC -DUSE_GMP_REPLACEMENTS -DBCD -DNO_UNARY_FUNCTION_COMPOSE -DSTATIC_BUILTIN_LEXER_FUNCTIONS -DNO_STDEXCEPT -DNO_PHYSICAL_CONSTANTS -DGIAC_HAS_STO_38 -DCAS38 -DFT2_BUILD_LIBRARY -Dsprintf=__sprintf -D__cplusplus -DNDEBUG -D__USB_CONFIG__ -DUSBH0_ENABLE -DUSBH0_HC_IF -DUSBD_ENABLE -DUSBD_HID_ENABLE --loose_implicit_cast --remove_unneeded_entities
modgc.o
ARM C/C++ Compiler, 4.1 [Build 894]
ArmCC --cpp --whole_program --split_sections -c  --depend=.\obj\modgc.d --cpu=ARM926EJ-S --fpmode=ieee_full --apcs=interwork//interwork -O3 --diag_suppress=1,9,111,161,177,185,191,368,514,550,611,1293,1299,1300,1464 -I..\ -I..\src -I..\..\Core -I..\..\Core\src -I..\..\Core\CAS\src -I..\..\Core\TomMath -I..\..\Core\napier -I..\..\Core\freetype\include\ -I..\..\Core\freetype\include\freetype\ -I..\..\_qt5\src -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -DUNICODE -D_UNICODE -DBESTA_OS -DBESTA_ARM_TARGET -DARM -DARM9 -DARM11 -DARM1176JZF -DSTANDALONE -DADS_COMPILER -DPDADEF -DKERNEL -DFULL_NAND_SYS -DFS_LONG_NAME_GET -DHAVE_AV_CONFIG_H -DEMULATE_FAST_INT -DEMULATE_INTTYPES -DFLASHLITEDLL -DFLASH_BESTARTOS -DFL31_STATICLIBRARY -D__STDC_LIMIT_MACROS -DFIR -DHAVE_CONFIG_H -DIN_GIAC -DUSE_GMP_REPLACEMENTS -DBCD -DNO_UNARY_FUNCTION_COMPOSE -DSTATIC_BUILTIN_LEXER_FUNCTIONS -DNO_STDEXCEPT -DNO_PHYSICAL_CONSTANTS -DGIAC_HAS_STO_38 -DCAS38 -DFT2_BUILD_LIBRARY -Dsprintf=__sprintf -D__cplusplus -DNDEBUG -D__USB_CONFIG__ -DUSBH0_ENABLE -DUSBH0_HC_IF -DUSBD_ENABLE -DUSBD_HID_ENABLE --loose_implicit_cast --remove_unneeded_entities
modio.o
ARM C/C++ Compiler, 4.1 [Build 894]
ArmCC --cpp --whole_program --split_sections -c  --depend=.\obj\modio.d --cpu=ARM926EJ-S --fpmode=ieee_full --apcs=interwork//interwork -O3 --diag_suppress=1,9,111,161,177,185,191,368,514,550,611,1293,1299,1300,1464 -I..\ -I..\src -I..\..\Core -I..\..\Core\src -I..\..\Core\CAS\src -I..\..\Core\TomMath -I..\..\Core\napier -I..\..\Core\freetype\include\ -I..\..\Core\freetype\include\freetype\ -I..\..\_qt5\src -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -DUNICODE -D_UNICODE -DBESTA_OS -DBESTA_ARM_TARGET -DARM -DARM9 -DARM11 -DARM1176JZF -DSTANDALONE -DADS_COMPILER -DPDADEF -DKERNEL -DFULL_NAND_SYS -DFS_LONG_NAME_GET -DHAVE_AV_CONFIG_H -DEMULATE_FAST_INT -DEMULATE_INTTYPES -DFLASHLITEDLL -DFLASH_BESTARTOS -DFL31_STATICLIBRARY -D__STDC_LIMIT_MACROS -DFIR -DHAVE_CONFIG_H -DIN_GIAC -DUSE_GMP_REPLACEMENTS -DBCD -DNO_UNARY_FUNCTION_COMPOSE -DSTATIC_BUILTIN_LEXER_FUNCTIONS -DNO_STDEXCEPT -DNO_PHYSICAL_CONSTANTS -DGIAC_HAS_STO_38 -DCAS38 -DFT2_BUILD_LIBRARY -Dsprintf=__sprintf -D__cplusplus -DNDEBUG -D__USB_CONFIG__ -DUSBH0_ENABLE -DUSBH0_HC_IF -DUSBD_ENABLE -DUSBD_HID_ENABLE --loose_implicit_cast --remove_unneeded_entities
modmath.o
ARM C/C++ Compiler, 4.1 [Build 894]
ArmCC --cpp --whole_program --split_sections -c  --depend=.\obj\modmath.d --cpu=ARM926EJ-S --fpmode=ieee_full --apcs=interwork//interwork -O3 --diag_suppress=1,9,111,161,177,185,191,368,514,550,611,1293,1299,1300,1464 -I..\ -I..\src -I..\..\Core -I..\..\Core\src -I..\..\Core\CAS\src -I..\..\Core\TomMath -I..\..\Core\napier -I..\..\Core\freetype\include\ -I..\..\Core\freetype\include\freetype\ -I..\..\_qt5\src -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -DUNICODE -D_UNICODE -DBESTA_OS -DBESTA_ARM_TARGET -DARM -DARM9 -DARM11 -DARM1176JZF -DSTANDALONE -DADS_COMPILER -DPDADEF -DKERNEL -DFULL_NAND_SYS -DFS_LONG_NAME_GET -DHAVE_AV_CONFIG_H -DEMULATE_FAST_INT -DEMULATE_INTTYPES -DFLASHLITEDLL -DFLASH_BESTARTOS -DFL31_STATICLIBRARY -D__STDC_LIMIT_MACROS -DFIR -DHAVE_CONFIG_H -DIN_GIAC -DUSE_GMP_REPLACEMENTS -DBCD -DNO_UNARY_FUNCTION_COMPOSE -DSTATIC_BUILTIN_LEXER_FUNCTIONS -DNO_STDEXCEPT -DNO_PHYSICAL_CONSTANTS -DGIAC_HAS_STO_38 -DCAS38 -DFT2_BUILD_LIBRARY -Dsprintf=__sprintf -D__cplusplus -DNDEBUG -D__USB_CONFIG__ -DUSBH0_ENABLE -DUSBH0_HC_IF -DUSBD_ENABLE -DUSBD_HID_ENABLE --loose_implicit_cast --remove_unneeded_entities
modstruct.o
ARM C/C++ Compiler, 4.1 [Build 894]
ArmCC --cpp --whole_program --split_sections -c  --depend=.\obj\modstruct.d --cpu=ARM926EJ-S --fpmode=ieee_full --apcs=interwork//interwork -O3 --diag_suppress=1,9,111,161,177,185,191,368,514,550,611,1293,1299,1300,1464 -I..\ -I..\src -I..\..\Core -I..\..\Core\src -I..\..\Core\CAS\src -I..\..\Core\TomMath -I..\..\Core\napier -I..\..\Core\freetype\include\ -I..\..\Core\freetype\include\freetype\ -I..\..\_qt5\src -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -DUNICODE -D_UNICODE -DBESTA_OS -DBESTA_ARM_TARGET -DARM -DARM9 -DARM11 -DARM1176JZF -DSTANDALONE -DADS_COMPILER -DPDADEF -DKERNEL -DFULL_NAND_SYS -DFS_LONG_NAME_GET -DHAVE_AV_CONFIG_H -DEMULATE_FAST_INT -DEMULATE_INTTYPES -DFLASHLITEDLL -DFLASH_BESTARTOS -DFL31_STATICLIBRARY -D__STDC_LIMIT_MACROS -DFIR -DHAVE_CONFIG_H -DIN_GIAC -DUSE_GMP_REPLACEMENTS -DBCD -DNO_UNARY_FUNCTION_COMPOSE -DSTATIC_BUILTIN_LEXER_FUNCTIONS -DNO_STDEXCEPT -DNO_PHYSICAL_CONSTANTS -DGIAC_HAS_STO_38 -DCAS38 -DFT2_BUILD_LIBRARY -Dsprintf=__sprintf -D__cplusplus -DNDEBUG -D__USB_CONFIG__ -DUSBH0_ENABLE -DUSBH0_HC_IF -DUSBD_ENABLE -DUSBD_HID_ENABLE --loose_implicit_cast --remove_unneeded_entities
modsys.o
ARM C/C++ Compiler, 4.1 [Build 894]
ArmCC --cpp --whole_program --split_sections -c  --depend=.\obj\modsys.d --cpu=ARM926EJ-S --fpmode=ieee_full --apcs=interwork//interwork -O3 --diag_suppress=1,9,111,161,177,185,191,368,514,550,611,1293,1299,1300,1464 -I..\ -I..\src -I..\..\Core -I..\..\Core\src -I..\..\Core\CAS\src -I..\..\Core\TomMath -I..\..\Core\napier -I..\..\Core\freetype\include\ -I..\..\Core\freetype\include\freetype\ -I..\..\_qt5\src -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -DUNICODE -D_UNICODE -DBESTA_OS -DBESTA_ARM_TARGET -DARM -DARM9 -DARM11 -DARM1176JZF -DSTANDALONE -DADS_COMPILER -DPDADEF -DKERNEL -DFULL_NAND_SYS -DFS_LONG_NAME_GET -DHAVE_AV_CONFIG_H -DEMULATE_FAST_INT -DEMULATE_INTTYPES -DFLASHLITEDLL -DFLASH_BESTARTOS -DFL31_STATICLIBRARY -D__STDC_LIMIT_MACROS -DFIR -DHAVE_CONFIG_H -DIN_GIAC -DUSE_GMP_REPLACEMENTS -DBCD -DNO_UNARY_FUNCTION_COMPOSE -DSTATIC_BUILTIN_LEXER_FUNCTIONS -DNO_STDEXCEPT -DNO_PHYSICAL_CONSTANTS -DGIAC_HAS_STO_38 -DCAS38 -DFT2_BUILD_LIBRARY -Dsprintf=__sprintf -D__cplusplus -DNDEBUG -D__USB_CONFIG__ -DUSBH0_ENABLE -DUSBH0_HC_IF -DUSBD_ENABLE -DUSBD_HID_ENABLE --loose_implicit_cast --remove_unneeded_entities
modthread.o
ARM C/C++ Compiler, 4.1 [Build 894]
ArmCC --cpp --whole_program --split_sections -c  --depend=.\obj\modthread.d --cpu=ARM926EJ-S --fpmode=ieee_full --apcs=interwork//interwork -O3 --diag_suppress=1,9,111,161,177,185,191,368,514,550,611,1293,1299,1300,1464 -I..\ -I..\src -I..\..\Core -I..\..\Core\src -I..\..\Core\CAS\src -I..\..\Core\TomMath -I..\..\Core\napier -I..\..\Core\freetype\include\ -I..\..\Core\freetype\include\freetype\ -I..\..\_qt5\src -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -DUNICODE -D_UNICODE -DBESTA_OS -DBESTA_ARM_TARGET -DARM -DARM9 -DARM11 -DARM1176JZF -DSTANDALONE -DADS_COMPILER -DPDADEF -DKERNEL -DFULL_NAND_SYS -DFS_LONG_NAME_GET -DHAVE_AV_CONFIG_H -DEMULATE_FAST_INT -DEMULATE_INTTYPES -DFLASHLITEDLL -DFLASH_BESTARTOS -DFL31_STATICLIBRARY -D__STDC_LIMIT_MACROS -DFIR -DHAVE_CONFIG_H -DIN_GIAC -DUSE_GMP_REPLACEMENTS -DBCD -DNO_UNARY_FUNCTION_COMPOSE -DSTATIC_BUILTIN_LEXER_FUNCTIONS -DNO_STDEXCEPT -DNO_PHYSICAL_CONSTANTS -DGIAC_HAS_STO_38 -DCAS38 -DFT2_BUILD_LIBRARY -Dsprintf=__sprintf -D__cplusplus -DNDEBUG -D__USB_CONFIG__ -DUSBH0_ENABLE -DUSBH0_HC_IF -DUSBD_ENABLE -DUSBD_HID_ENABLE --loose_implicit_cast --remove_unneeded_entities
moduerrno.o
ARM C/C++ Compiler, 4.1 [Build 894]
ArmCC --cpp --whole_program --split_sections -c  --depend=.\obj\moduerrno.d --cpu=ARM926EJ-S --fpmode=ieee_full --apcs=interwork//interwork -O3 --diag_suppress=1,9,111,161,177,185,191,368,514,550,611,1293,1299,1300,1464 -I..\ -I..\src -I..\..\Core -I..\..\Core\src -I..\..\Core\CAS\src -I..\..\Core\TomMath -I..\..\Core\napier -I..\..\Core\freetype\include\ -I..\..\Core\freetype\include\freetype\ -I..\..\_qt5\src -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -DUNICODE -D_UNICODE -DBESTA_OS -DBESTA_ARM_TARGET -DARM -DARM9 -DARM11 -DARM1176JZF -DSTANDALONE -DADS_COMPILER -DPDADEF -DKERNEL -DFULL_NAND_SYS -DFS_LONG_NAME_GET -DHAVE_AV_CONFIG_H -DEMULATE_FAST_INT -DEMULATE_INTTYPES -DFLASHLITEDLL -DFLASH_BESTARTOS -DFL31_STATICLIBRARY -D__STDC_LIMIT_MACROS -DFIR -DHAVE_CONFIG_H -DIN_GIAC -DUSE_GMP_REPLACEMENTS -DBCD -DNO_UNARY_FUNCTION_COMPOSE -DSTATIC_BUILTIN_LEXER_FUNCTIONS -DNO_STDEXCEPT -DNO_PHYSICAL_CONSTANTS -DGIAC_HAS_STO_38 -DCAS38 -DFT2_BUILD_LIBRARY -Dsprintf=__sprintf -D__cplusplus -DNDEBUG -D__USB_CONFIG__ -DUSBH0_ENABLE -DUSBH0_HC_IF -DUSBD_ENABLE -DUSBD_HID_ENABLE --loose_implicit_cast --remove_unneeded_entities

Déjà, la présence du module micropython nous indique que l'interpréteur retenu pour la HP Prime est MicroPython, comme sur Casio, NumWorks et TI-Nspire.

De façon générale, si l'on en croit le nommage des fichiers, nous pourrions donc avoir des modules es, factor, poly, micropython, array, builtins, cmath, collections, gc, io, math, struct, sys, thread et uerrno.
En plus de builtins qui est importé par défaut, seulement 7 autres modules additionnels sont réellement importables : array, cmath, gc, math, micropython, sys et uerrno.

	MicroPython TI-Nspire	NumWorks	Casio Graph 35+E II Graph 90+E	CasioPython Graph 35+E II Graph 35+E/USB Graph 75/85/95	TI-83PCE Ed. Python TI-Python / TI-83PCE	firmware tiers TI-Python / TI-83PCE	HP Prime
builtins array collections cmath gc math micropython os random sys time turtle uerrno	✓ ✓   ✓ ✓ ✓ ✓     ✓	✓     ✓   ✓ ✓   ✓   ✓ ✓	✓         ✓     ✓	✓ ✓   ✓ ✓ ✓ ✓   ✓ ✓     ✓	✓ ✓ ✓   ✓ ✓   ✓ ✓ ✓	✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓	✓ ✓ ✓ ✓ ✓ ✓ ✓ ✓
spécifique	nsp	kandinsky				board storage
Total	8	8	3	9	8	13	8

On pourra regretter à date l'absence des modules random et time.

D'où le classement suivant en terme d'éventail de modules :

1. 13 modules : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
2. 9 modules : Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII (application CasioPython)
3. 8 modules : HP Prime + TI-83 Premium CE Edition Python + NumWorks + TI-Nspire (application MicroPython) + module externe TI-Python pour TI-83 Premium CE
4. 3 modules : Casio Graph 35+E II / 90+E / fx-CG50

4) Exploration module sys et nombres entiers :

Go to top

Bien, abordons maintenant l'exploration de modules. Comme nous avons vu plus haut que définir plusieurs fonctions non triviales était problématique, nous allons réécrire exceptionnellement notre script d'exploration habituel sous la forme d'une unique fonction :

Code: Tout sélectionner

def explmod(pitm,pitmsl=[],reset=True):
  if(reset):
    try:
      s=pitm.__name__
    except:
      s=str(pitm)
      a=s.find("'")
      b=s.rfind("'")
      if a>=0 and b!=a:
        s=s[a+1:b]
    pitmsl=[s]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c,c2=0,0
  for itms in sorted(dir(pitm)):
    c,c2=c+1,c2+1
    try:
      itm=eval(spath+"."+itms)
      sitm=str(itm)
      print(hd+itms+"="+str(itm))
      if (sitm.startswith("<module '") or sitm.startswith("<class '")) and itm!=pitm:
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c2=c2+explmod(itm,pitmsl2,False)[1]
    except:
      print(hd+itms)
  if c>0 and reset:
    s="Total: "
    s+=str(c)+" 1st level item(s)"
    if c2>0 and c2!=c:
      s+=" - "+str(c2)+" item(s)"
    print(s)
  return [c,c2]

L'appel explmod(sys) nous révèle de 17 à 21 éléments, selon que l'on en reste aux éléments du premier niveau ou compte également les sous-éléments.

Plusieurs éléments sont à remarquer :

• sys.implementation.name qui nous confirme là encore que l'interpréteur Python est basé sur MicroPython
• sys.implementation.version qui précise la version MicroPython concernée, ici 1.9.4 comme chez Casio et NumWorks
• sys.version qui nous précise la version de Python implémentée, ici 3.4.0
• sys.platform qui vaut "HP Prime" et pourra servir de vérification pour les scripts Python souhaitant par exemple optimiser leur affichage pour HP Prime, la console étant ici contrainte par l'écran 320x240 pixels
• sys.maxsize qui nous indique l'entier maximum codable nativement sur le matériel HP Prime, ici 2147483647==2**31-1

Sans surprise les entiers natifs sont donc codés sur 32 bits (avec le bit de signe), ce qui nous permet de réaliser un petit test en tentant d'aller au-delà, avec par exemple sys.maxsize+1. Visiblement pas d'erreur, ce qui veut dire que l'équipe HP a activé la gestion des entiers longs, là encore un excellent choix !

5) Exploration autres modules :

Go to top

Le même script nous permet d'explorer les autres modules :

• array avec 3 à 13 éléments
• cmath avec 13 à 17 éléments
• gc avec 9 à 13 éléments
• math avec 42 à 46 éléments
• micropython avec 10 à 14 éléments
• uerrno avec 25 à 29 éléments
• builtins avec 97 à 428 éléments

D'où le bilan tous modules confondus :

	MicroPython TI-Nspire	NumWorks	Casio Graph 35+E II Graph 90+E	CasioPython Graph 35+E II Graph 35+E/USB Graph 75/85/95	TI-83PCE Ed. Python TI-Python / TI-83PCE	firmware tiers TI-Python / TI-83PCE	HP Prime
builtins array collections cmath gc math micropython os random sys time turtle uerrno	93-218 4   12 7 41 3     15	88-188     12   41 6   8   3 38	84-175         25     8	91-204 4   12 7 41 6   8 12     24	91-190 4 2   7 28   8 15 4	93-191 4 2 12 7 41 6 15 8 15 10	97-428 3-13   13-17 9-13 42-46 10-14     17-21     25-29
spécifique	10(nsp)	6(kandinsky)				22(board) 21(storage)
Total	185-310	202-302	117-208	181-294	159-258	213-354	216-581

D'où le classement suivant en terme de richesse des modules Python :

1. 216-581 éléments : HP Prime
2. 213-354 éléments : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
3. 185-310 éléments : TI-Nspire (application MicroPython)
4. 202-302 éléments : NumWorks
5. 181-294 éléments : Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII (application CasioPython)
6. 159-258 éléments : TI-83 Premium CE Edition Python + module externe TI-Python pour TI-83 Premium CE
7. 117-208 éléments : Casio Graph 35+E II / 90+E / fx-CG50

6) Mémoire de travail et récursivité:

Go to top

Passons maintenant à la détermination de la mémoire de travail accessible à l'interpréteur Python. Pour palier les limites de l'actuelle version alpha, nous allons là encore devoir réécrire notre script de recherche habituel sous la forme d'une fonction unique :

Code: Tout sélectionner

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

L'appel mem() tente d'allouer un maximum de blocs mémoire, de plus en plus petits pour remplir au mieux cette dernière, et nous indique donc un total impressionnant de 1,022145 Mo, de quoi coder confortablement nombre de projets !

1. 2,049276 Mo : TI-Nspire (application MicroPython)
2. 1,032942 Mo : Casio Graph 90+E
3. 1,022145 Mo : HP Prime
4. 257,636 Ko : Casio Graph 35/75+E (application CasioPython)
5. 100,560 Ko : Casio Graph 35+E II
6. 31,899 Ko : Casio Graph 35+E II (application CasioPython)
7. 22,605 Ko : TI-83 Premium CE & TI-Python (firmware tiers)
8. 20,200 Ko : TI-83 Premium CE Edition Python
9. 19,924 Ko : TI-83 Premium CE & TI-Python
10. 16,109 Ko : NumWorks N0100
11. 15,984 Ko : NumWorks N0110

Mais il n'y a pas que la mémoire dans la vie d'un script Python, il y a aussi la pile (stack). Nous allons maintenant partir sur un test de récursivité avec le script suivant :

Code: Tout sélectionner

def maxr(fct):
  n=0
  try:
    while True:
      fct(n)
      n=n+1
  except Exception as e:print(e)
  return n

def sumr(n):return n>0 and n+sumr(n-1)

Avec une deuxième fonction dont la définition tient ici sur une seule ligne, nous n'avons apparemment pas de problème.

L'application HP Prime nous permet donc actuellement jusqu'à 77 niveaux de récursion, une limite a priori bien positionnée pour les projets.

1. 5362 : Casio Graph 35/75+E (application CasioPython)
2. 655 : Casio Graph 35+E II (application CasioPython)
3. 130 : TI-Nspire (application MicroPython)
4. 82 : Casio Graph 90+E + Casio Graph 35+E II
5. 77 : HP Prime
6. 29 : NumWorks
7. 23 : TI-83 Premium CE Edition Python
8. 20 : TI-83 Premium CE & TI-Python
9. 15 : TI-83 Premium CE & TI-Python (firmware tiers)

7) Performances :

Go to top

Terminons avec un test de performances de l'application Python. Il faudra le relativiser, puisqu'il ne peut donc être effectué que sur l'ancien modèle HP Prime G1.
Notre script de test en virgule flottante peut être réécrit en une seule fonction sans modifications lourdes, et resterait donc valide pour des comparaisons :

Code: Tout sélectionner

def seuil(d):
  n=0
  u=2.
  d=d**2
  while (u-1)**2>=d:
    u=1+1/((1-u)*(n+1))
    n=n+1
  return [n,u]

L'absence du module time nous oblige à l'itérer plusieurs fois de suite et à faire une moyenne du temps chronométré. L'appel seuil(0.008) prendrait environ 0,283s.
Finalement non, même pas besoin de relativiser, avec l'application Python les calculs en virgule flottante de la HP Prime G1 sont beaucoup plus rapides, et on se demande bien ce que ça pourrait donner sur HP Prime G2 !

1. 0,27s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz overclocké @222MHz via Nover avec l'interpréteur MicroPython)
2. 0,283s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz avec l'application Python intégrée)
3. 0,376s : HP Prime G2 (32 bits : Cortex-A7/ARMv7 @528MHz avec l'écriture Python du mode CAS)
4. 0,38s : TI-Nspire (32 bits : ARM9/ARMv5 overclocké @120MHz @150MHz via Nover avec l'interpréteur MicroPython)
5. 0,47s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz avec l'interpréteur MicroPython)
6. 0,48s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz avec l'interpréteur MicroPython)
7. 0,498s : NumWorks N0110 (32 bits : Cortex-M7/ARMv7 @216MHz)
8. 0,53s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz overclocké @216MHz via Nover avec l'interpréteur MicroPython)
9. 0,59s : Casio Graph 35/75+E (32 bits : SH4 @29,49MHz overclocké @267,78MHz via Ftune2 avec l'interpréteur CasioPython)
10. 0,68s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz avec l'interpréteur MicroPython)
11. 0,785s : NumWorks N0100 (32 bits : Cortex-M4/ARMv7 @100MHz)
12. 0,79s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz overclocké @274,91MHz via Ftune3 avec l'interpréteur CasioPython)
13. 1,61s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz avec l'écriture Python du mode CAS)
14. 1,86s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz overclocké @274,91MHz via Ftune3 avec l'application Python intégrée)
15. 2,15s : Casio Graph 90+E (32 bits : SH4 @117,96MHz overclocké @270,77MHz via Ptune3 avec l'application Python intégrée)
16. 2,96s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz overclocké @274,91MHz via Ftune3 avec l'interpréteur KhiCAS)
17. 3,27s : Casio Graph 90+E (32 bits : SH4 @117,96MHz)
18. 3,65s : Casio Graph 90+E (32 bits : SH4 @117,96MHz overclocké @270,77MHz via Ptune3 avec l'interpréteur KhiCAS)
19. 3,73s : TI-83 Premium CE + module externe TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz avec l'application PyAdaptr)
20. 3,9s : Casio Graph 35+E II (32 bits : SH4 @58,98 avec l'interpréteur CasioPython)
21. 3,93s : TI-83 Premium CE Edition Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz avec l'application Python)
22. 4s : Casio Graph 35/75+E (32 bits : SH4 @29,49MHz avec l'interpréteur CasioPython)
23. 4,4s : TI-83 Premium CE + module externe TI-Python (8 + 32 bits : eZ80 @48MHz + Cortex-M0+/ARMv6 @48MHz avec firmware CircuitPython)
24. 5,48s : Casio Graph 90+E (32 bits : SH4 @117,96MHz avec l'interpréteur KhiCAS)
25. 9,21s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz avec l'application Python intégrée)
26. 13,93s : Casio Graph 35+E II (32 bits : SH4 @58,98MHz avec l'interpréteur KhiCAS)

8) Récapitulatif et conclusion :

Go to top

Bien qu'actuellement instable et encore en version alpha, le développement de l'application Python pour HP Prime semble être parti sur de très bons rails, l'équipe sachant éviter nombre de défauts encore présents chez la concurrence sur les préversions des salons ou même versions finales. On apprécie d'avoir déjà l'essentiel pour le programme du lycée : entiers longs, flottants en double précision, nombres complexes avec le module cmath qui va avec, une mémoire de travail suffisante pour faire tourner des scripts un minimum ambitieux... une application Python a priori très prometteuse et qui ne pourra évoluer que dans le bon sens !
Tu auras désormais libre choix entre la couche de traduction du mode CAS, et l'application Python standard !

Outre l'instabilité qui sera forcément corrigée, on pourra juste regretter à date l'absence des modules random et time. Précisons aussi qu'un module graphique serait fort bienvenu pour le programme de Physique-Chimie de Seconde.

Texas Instruments ayant apparemment tué Ndless et l'application MicroPython qui lui était dédié avec ses mises à jour 4.5.1 pour TI-Nspire CX I puis ses TI-Nspire CX II, la calculatrice HP Prime est partie pour être le premier modèle haut de gamme avec une application Python véritable et officielle, et en pratique le seul modèle haut de gamme avec une application Python utilisable.
Nous ne nous attendions pas à ce que Hewlett Packard nous prépare pour son modèle HP Prime international une mise à jour à ce point pertinente par rapport à l'évolution des programmes scolaires français, nous sommes fort agréablement surpris, bravo !

Le firmware HP Prime G1 avec application Python reste disponible ci-après. En dehors de la curiosité intellectuelle ou technique et à moins que le Python n'ait un intérêt vital pour toi au détriment des autres fonctionnaltés, nous te déconseillons fortement de l'installer, particulièrement dans le contexte d'évaluations !

Il va falloir aussi mettre un bémol à notre enthousiasme, en l'absence d'une annonce officielle. Dans son état actuel, il n'est pas envisageable qu'une mise à jour d'ici quelques semaines puisse inclure cette application Python. Et vu les délais de validation d'une nouvelle version, nous ne sommes même pas sûrs qu'une sortie d'une autre mise à jour incluant cet ajout majeur soit envisageable avant les examens 2020.

Aussi, ce n'est pas parce qu'une application Python est en développement pour HP Prime qu'elle sortira forcément un jour sur HP Prime.

Prenons l'exemple des émulateurs HP Prime pour Linux, ils ont fait partie du beta-testing de rentrée 2018 et ne sont toujours pas sortis à ce jour. Il sont de plus accompagnés de la mention suivante, qui pourrait parfaitement être adaptée à l'application Python à une reformulation près :

Beta version of the technical preview of an emulator of the HP Prime Graphing Calculator for Linux. Lets you do everything the calculator does, but with the full control of your keyboard and mouse and taking full advantage of your PC's computing power. This is a technical preview and does not indicate a supported Linux release will be forthcoming.

C'est donc encore loin d'être gagné pour une application Python sur HP Prime, chacun doit se donner la peine de communiquer son enthousiasme auprès de calcbeta@hp.com .

Téléchargements :

• HP Prime Virtual Calculator version 2.1.14288 pour Windows 32-bits / Windows 64-bits / Mac / Linux 32-bits / Linux 64-bits
• HP Prime Connectivity Kit version 2.1.14288 pour Windows 32-bits / Windows 64-bits / Mac
• Firmware version 2.1.14285 pour HP Prime G1 (avec application Python)
• Firmware version 2.1.14298 pour HP Prime G1
• Firmware version 2.1.14284 pour HP Prime G2
• applications iOS HP Prime Lite / Pro
• applications Android HP Prime Lite / Pro

Source : https://www.hpmuseum.org/forum/thread-1 ... #pid122692 et messages suivants

[critor]

Pour la rentrée 2018, Hewlett Packard sortait sa nouvelle HP Prime G2 matériellement révolutionnaire.

Hélas c'est assez mal tombé pour la France, vu que le grossiste HP français SMS (Solution Micro System) venait de fermer, emportant avec lui le site français www.calculatrices-hp.com.
Nombre de boutiques françaises sont donc restées en rupture de stock en 2018-2019, dont LDLC.

Il y avait certes la possibilité de commander chez nos voisins européens, mais ça impliquait donc pour chaque acheteur de payer le port, et ce n'était pas des plus pratiques avec des sites en langue étrangère pas toujours adaptés.

Toutefois Hewlett Packard a travaillé toute l'année 2018-2019 pour t'apporter des solutions.

Un nouveau site français a été conçu, www.hp-prime.fr.

L'approvisionnement de la France a pour sa part été confié à l'entreprise tchèque Moravia Europe qui avait déjà la charge de la distribution en Europe non francophone des calculatrices HP Prime et Sharp, si bien que la HP Prime G2 fut bien au rendez-vous pour la rentrée 2019 !

Si tu as envisagé l'acquisition d'une HP Prime G2 pour la rentrée 2019 et que le prix t'a fait reculer, et bien c'est maintenant l'occasion ou jamais pendant ces vacances de Toussaint !

Aujourd'hui la HP Prime G2 est en effet enfin de retour chez LDLC, et pour fêter cet événement la boutique te propose une promotion exceptionnelle jamais vue à seulement 109€95 !

Dépêche-toi, ça ne durera pas éternellement...

Lien : https://www.ldlc.com/fiche/PB00154309.html

[critor]

Cette semaine, Hewlett Packard Calculatrices propose à nouveau à sa communauté de contribuer au développement de sa calculatrice HP Prime et de son écosystème. Plus précisément, il t'est proposé de participer à un bêta-test public de la version 2.1.14288 datée du 22 octobre 2019.

Cette mise à jour donc toute fraîche concerne l'intégralité de la suite HP Prime :

• le firmware calcultrice
• le logiciel de connectivité HP Prime Connectivity Kit
• le logiciel de simulation HP Prime Virtual Calculator
• les applications HP Prime

Notons comme nouveautés essentielles :

• la correction du bug de la commande BREAK sur HP Prime G2
• le passage du moteur CAS en version 1.5 avec donc toutes les améliortions que Bernard Parisse a effectuées sur le code Xcas associé depuis la dernière version 2.1.14181 d'octobre 2018, ce qui inclut entre autres une meilleure gestion de la syntaxe Python avec les différents problèmes signalés depuis

C'est aussi une excellente nouvelle pour les utilisateurs Linux qui dans le cadre de cette bêta vont pouvoir bénéficier d'un logiciel à jour, le premier depuis la version 2.1.14091 de septembre 2018.

Tes retours sont à effectuer par courriel à calcbeta@hp.com.


Changelog complet :

Show/Hide spoilerAfficher/Masquer le spoiler

HP Prime – Release Notes
-------------------------

Date Released: 2019/10/22

Internal Versions
-----------------
Firmware Version: ~2.1.14290 (2019 10 23) BETA
Virtual Calculator Version: ~2.1.14290 (2019 10 23) BETA
Connectivity Kit: ~2.1.14290 (2019 10 23) BETA

Description
-----------
This BETA release of the Prime Calculator firmware and associated PC and Mobile software is a minor maintenance release. Only users willing to experiment with pre-release software and report issues to calcbeta@hp.com are invited to experiment with this release.

Please back up your calculator before the update. Any existing data on the device may be wiped during the update process.

Primary focus of this BETA release is upgrading the underlying build tools for all platforms (calculator hardware, windows, iOS, android, macOS). As such, there are few end user noticeable changes included. The goal here is to ensure that everything is "working just as before" to make sure that no problems have been introduced as a result of said tool change.


Windows Connectivity Kit and Virtual Calculator:
1. Fixed issue with prompts for upgrade being misidentified on 64 bit versions.

Mac Connectivity Kit and Virtual Calculator:
1. None

Linux Technical Preview Virtual Calculator:
1. Delivered in x86 and x64 versions
2. Built using Ubuntu 14.04 and packaged as an appimage with latest appimage/linuxdeployqt versions
3. Primarily, this is to test if application is able to be run on a wide range of systems and distros
4. There is a technical preview and does not indicate a supported Linux release will be forthcoming - however the 60 day limit on other platforms will not be checked.

New Functionality and Changes (Calculator Software)
1. Updated CAS to latest 1.5 release.
2. Corrected BREAK issue found on G2 hardware units only.

Téléchargements :

• HP Prime Virtual Calculator pour Windows 32-bits / Windows 64-bits / Mac / Linux 32-bits / Linux 64-bits
• HP Prime Connectivity Kit pour Windows 32-bits / Windows 64-bits / Mac
• Firmware HP Prime pour HP Prime G1 / HP Prime G2
• applications iOS HP Prime Lite / Pro
• applications Android HP Prime Lite / Pro

Source : https://www.hpmuseum.org/forum/thread-13855.html via viewtopic.php?f=69&t=23071&p=247185#p247185

[critor]

La HP Prime G1 sortie pour la rentrée 2013 avait bénéficié de plusieurs firmwares tiers :

• une première preuve de concept par Lionel Debroux
• Rip'em par jean-baptiste boric
• portage du firmware NumWorks par jean-baptiste boric

Hélas depuis la HP Prime G2 de la rentrée 2018, matériellement très différente et donc incompatible, nous n'avions plus rien eu de tel.

Mais zephray_wenting vient tout juste de recevoir sa nouvelle HP Prime G2 le 11 juillet dernier.

zephray_wenting est très loin d'être un nouveau venu dans le monde des calculatrices programmables. Issu de la communauté chinoise cnCalc.org et connu successivement sous les pseudonymes de zweb, ZephRay et maintenant Wenting / zephray_wenting, il s'est déjà brillamment illustré dans des domaines aussi pointus que variés :

• avec nPal / nPaladin, portage pour TI-Nspire Ndless du RPG chinois PAL (Legend of Sword and Fairy)
• émulateur de HP WP 34S pour TI-Nspire Ndless
• firmware d'émulation TI-86 pour HP 39gs
• ainsi que pour sa participation au projet ArithMax, dont le but était de concevoir intégralement une calculatrice scientifique, logiciel et matériel, et ce en exploitant les technologies d'aujourd'hui et non du siècle dernier comme c'est souvent le cas

En moins d'une semaine, zephray_wenting vient de réussir l'exploit surhumain, non pas juste de rattraper, mais même dépasser ce qui avait été réalisé pour HP Prime G1...

En effet il vient juste d'arriver à faire tourner un firmware non officiel sur sa HP Prime G2, et pas n'importe lequel puisqu'il s'agit de Linux !

Contrairement aux firmwares tiers pour HP Prime G1, l'installation de Linux sur HP Prime G2 n'est à ce jour pas à la portée de l'utilisateur lambda.

zephray_wenting a en effet dû modifier matériellement sa HP Prime G2, lui soudant et dessoudant 3 résistances afin de la basculer en mode de démarrage USB DFU (comme sur NumWorks), ce qui lui permet alors de recevoir les images à installer/lancer sans passer par les vérifications officielles.

L'image Linux est amorcée via U-Boot et n'est à ce jour installée qu'en RAM, de façon temporaire donc avec besoin de refaire la manipulation à chaque redémarrage, car il n'y a pas encore de pilote pour la Flash NAND de la HP Prime G2.

Le détail de son reverse engineering suit ci-après en chinois. Nous espérons pouvoir t'annoncer de grandes avancées sur ce projet très prochainement.

Lien : reverse engineering HP Prime G2 par zephray_wenting

Sources :

• https://twitter.com/zephray_wenting/status/1150558070302490625
• https://twitter.com/zephray_wenting/status/1149869801977843712
• https://twitter.com/zephray_wenting/status/1149079084619784197

[critor]

La HP Prime G2 est la nouvelle révision matérielle HP Prime sortie pour la rentrée 2018.

Comme tu as pu le constater, en France nous avons été privés de la HP Prime G2 en 2018-2019, tous les revendeurs Hewlett Packard nationaux étant en rupture de stock.

Nous n'avons pas tous les détails, mais il se trouve que le distributeur HP français, SMS (Solution Micro System), a rencontré des difficultés en 2018. La distribution en France a alors été confiée au sous-traitant Morovia Consulting, une entreprise tchèque qui s'occupait déjà de la distribution européenne des calculatrices graphiques Sharp, et visiblement fort mal concernant la France puisque cela fera bientôt 20 ans que nous n'en aurons plus vu une seule dans nos rayons.

Mais bonne nouvelle, après ce faux départ pour la rentrée 2018, cette fois-ci c'est enfin la bonne pour la rentrée 2019. Nous ignorons comment la situation a pu se débloquer, mais la légendaire calculatrice HP Prime G2 est enfin approvisionnée en France !

Il est donc grand temps de découvrir sans plus attendre toutes les titanesques nouveautés de la HP Prime G2 !

Sommaire :

1. Tour du propriétaire
2. Mémoires de travail et de stockage
3. Performances
4. Mise à jour
5. Diagnostic
6. Matériel
7. Conclusion

1) Tour du propriétaire :

Go to top

La HP Prime G2 que nous avons entre les mains aujourd'hui n'est pas tout-à-fait finale, provenant non pas de l'équipe marketing mais de l'équipe de développement. Elle réutilise à l'identique l'ancien boîtier des HP Prime G1 et ne dispose d'ailleurs pas de numéro de série.

On peut toutefois l'identifier clairement comme une HP Prime G2 à l'écran A propos qui indique une nouvelle version matérielle D, là où les versions matérielles C et inférieures correspondent aux anciennes HP Prime G1.

Les HP Prime G2 de production quant à elles ont une face arrière légèrement différente permettant de les identifier sans besoin de les allumer, un G2 étant inscrit dans un cercle sous le logo HP.

Une autre particularité sur notre HP Prime G2 de développement, c'est que la batterie est toute noire, ne comportant strictement aucune information. Cela pourrait suggérer l'usage d'une toute nouvelle batterie.

Tentons de creuser la chose.

Pesée en CNU (Conditions Normales d'Utilisation) la HP Prime G2 fait 203g, soit à peine plus que les 199g des anciennes HP Prime G1, une progression qui pourrait paraître négligeable.

Mais en fait non, cela cache deux évolutions contraires. La calculatrice HP Prime G2 en tant que telle est en fait un peu plus plus légère, et c'est la batterie qui compense en passant de 30g sur les HP Prime G1 à maintenant 38g sur la HP Prime G2.

Donc oui, la HP Prime G2 bénéficie bien d'une nouvelle batterie, a priori de capacité supérieure.

Plus précisément comme on le constate dans les HP Prime G2 de production, nous passons d'une batterie de 1500mAh de capacité à maintenant 2000mAh, tout en gardant le même format et donc la compatibilité selon nos tests !

Et parlant alimentation, ce n'est justement pas la seule nouveauté de la HP Prime G2. Hors mode examen il suffit d'éteindre la calculatrice en maintenant la touche

Shift

pour faire passer la calculatrice en hibernation, mode spécial minimisant la consommation de la batterie et lui permettant ainsi de conserver sa charge sur de bien plus longues périodes d'inutilisation !
Seule et unique contrepartie, la machine mettra environ 1 seconde supplémentaire pour sortir de ce mode au rallumage, franchement négligeable.

2) Mémoires de travail et de stockage :

Go to top

Voyons donc ce que vaut cette nouvelle HP Prime G2, en commençant par accéder au menu mémoire.

Réussissais-tu l'exploit de te sentir à l'étroit avec les ≈ 198 Mo de mémoire de stockage de la HP Prime G1 ? Tu risques d'avoir beaucoup de mal désormais...
La HP Prime G2 porte bien son nom en étendant la capacité de stockage à ≈ 462 Mo, ce qui suggère une capacité de mémoire Flash de 512 Mio !

Et là où la HP Prime G1 ne nous offrait que dans les ≈ 16 Mo de mémoire de travail, la HP Prime G2 nous met en orbite avec ≈ 247 Mo, ce qui suggère donc une capacité de mémoire RAM d'au moins 256 Mio !

3) Performances :

Go to top

La HP Prime G2 semble également beaucoup plus performante que les anciennes HP Prime G1.

Par exemple le jeu Tunnel lancé avec une graine aléatoire de 31 sans interaction utilisateur te fait perdre après 11s sur HP Prime G1 contre seulement 4s sur HP Prime G2 :

L'ensemble des programmes et applications ne tenant pas compte de l'horloge système sont accélérés de façon similaire, avec un facteur tournant autour de 3.

Voici par exemple ce que donne de façon similaire l'application de lecture de documents mViewer GX :

Quant aux programmes et applications tenant compte de l'horloge système, tout dépend de comment ils ont été codés.

Le moteur 3D de type raycasting PrimeCaster 3D par exemple te permet de régler le nombre de fps (images par seconde) que tu souhaites cibler. Et à fps identique, il met automatiquement à profit la puissance et donc le temps processeur supplémentaire de la HP Prime G2 pour améliorer la qualité du rendu 3D.

Tentons de chiffrer plus précisément cette amélioration des performances. Voici la transcription en Python pour lisibilité d'un programme codé dans le langage historique de la machine et que nous allons utiliser pour chiffrer les performances :

Code: Tout sélectionner

try:
  from time import *
except:
  pass

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

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

Voici le classement des calculatrices graphiques ou programmables à ce jour conformes 2020, pour un appel seuil(0.008) :

1. 0,688s : HP Prime G2 (32 bits : Cortex/ARMv7 @528MHz)
2. 0,785s : NumWorks (32 bits : Cortex/ARMv7 @100MHz)
3. 2,414s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
4. 8,93s : TI-Nspire CX II (32 bits : ARM9/ARMv5 @396MHz)
5. 12,24s : TI-Nspire (32 bits : ARM9/ARMv5 @120MHz)
6. 18,67s : TI-Nspire CX CR4+ (révisions W+) (32 bits : ARM9/ARMv5 @156MHz)
7. 20,92s : TI-Nspire CX (révisions A-V) (32 bits : ARM9/ARMv5 @132MHz)
8. 50,77s : Casio Graph 90+E (32 bits : SH4 @118MHz)
9. 81,03s : Casio Graph 35+E II (32 bits : SH4 @59MHz)
10. 101,1s : Casio Graph 35/75+E (32 bits : SH4 @29,5MHz)
11. 117,29s : Casio Graph 25+E (32 bits : SH4 @29,5MHz)
12. 120,51s : TI-83 Premium CE Edition Python (8 bits : eZ80 @48MHz)
13. 198,53s : TI-83 Premium CE / TI-84 Plus CE-T (8 bits : eZ80 @48MHz)
14. 260,41s : TI-82 Advanced / TI-84 Plus T (8 bits : z80 @15MHz)
15. 607,91s : Casio fx-CP400+E (32 bits : SH4 @118MHz)
16. 672,65s : Casio fx-92+ Spéciale Collège (8 bits : nX-U8/100 >1,5MHz - spécifications ancien modèle fx-92 Collège 2D+, non confirmées sur le nouveau)
17. ≈738,75s : Lexibook GC3000FR (non programmable, estimation relative par comparaison des performances en tracé de graphes avec le modèle le plus proche technologiquement, la TI-82 Advanced)

On confirme cette fois-ci de façon bien plus précise la progression en performances de la HP Prime G2 d'un facteur de 3 par rapport aux anciennes HP Prime G1, et l'on note ici encore que la HP Prime G2 domine technologiquement l'ensemble de la concurrence !

4) Mise à jour :

Go to top

Les mises à jour sont désormais déclinées en deux versions différentes ce qui suggère des différences matérielles suffisamment significatives pour être incompatibles niveau code machine.

Rappelons que les HP Prime G1 utilisaient un processeur ARM9/ARMv5 cadencé à 400 MHz.

Et justement, si l'on fouille ces images à l'éditeur hexadécimal, on note que la version G2 mentionne effectivement un tout nouveau processeur MCIMX6Y2. De la famille i.MX 6ULL de chez NXP, il s'agit en effet d'un Cortex / ARMv7 cadencé à 528 MHz.

Une progression en fréquence couplée au passage de l'architecture ARMv5 à l'architecture ARMv7, voilà qui explique la formidable progression en performances, la HP Prime rattrape enfin le retard technologique qu'elle avait pris par rapport à la NumWorks !

Puisque nous parlons de mise à jour, sur la HP Prime G2 les affichages concernés côté calculatrice ont été profondément modifiés, ce qui suggère l'utilisation d'un tout nouveau BOOT (code de démarrage). Le processus de mise à jour semble de plus avoir été davantage sécurisé, faisant maintenant apparaître 3 étapes successives :

1. Verifying
2. Preparing
3. Upgrading

Et effectivement on le confirme. Contrairement aux HP Prime G1, la HP Prime G2 n'accepte plus d'installer des images de système où nous avons modifié un des messages système. Il y a eu visiblement ajout d'une sécurité, somme de contrôle ou pire signature...

Mauvaise nouvelle donc pour la communauté HP Prime, les firmwares tiers développés pour HP Prime ne peuvent plus être installés.
Fini la NumWorks sur HP Prime, Rip'em, et jusqu'à preuve du contraire un point final au projet de portage d'un Linux...

5) Diagnostic :

Go to top

Afin de comprendre un petit peu mieux ce qui a changé, accédons au menu de diagnostic. Il suffit pour cela de maintenir les touches

F

C

O

tout en faisant un reset.

Effectivement, il nous confirme l'utilisation d'un tout nouveau BOOT, le ARMUboot V17 étant remplacé sur HP Prime G2 par un V2.060.650.

Il nous permet également de valider notre hypothèse du passage d'une capacité de mémoire Flash de 256 Mio pour la HP Prime G1 à 512 Mio pour la HP Prime G2 :

6) Matériel :

Go to top

Nous en aurons le coeur net, voyons donc ce que la HP Prime G2 cache sous le capot.

Nous y découvrons une nouvelle carte mère de référence EA656MB-6 avec juste au-dessus une indication de date, 2018.02.05.

En effet la carte utilise un tout nouveau coeur, un MCIMX6Y2DVM05AB de chez NXP, une puce renfermant justement un processeur i.MX 6ULL, un Cortex/ARMv7 cadencé à 528 MHz. La HP Prime passe donc d'un ARM9/ARMv5 à un Cortex/ARMv7, un rattrapage technologique fort bienvenu par rapport à ce qu'avait sorti NumWorks entre temps !

La puce RAM à côté fait également peau neuve, une H5TQ2G63GFR de chez SK Hynix.
Excellente surprise, la capacité est donc bien 256 Mio comme conjecturé plus haut - c'est multiplié donc par 8, rien que ça, par rapport aux anciennes HP Prime G1 ! Et qui plus est niveau technologie c'est de la DDR3 cette fois-ci !

Retirons l'étiquette dissimulant la 3^ème et dernière puce, la Flash.
Toujours de chez SK Hynix il s'agit cette fois-ci d'une H27U4G8F2D, faisant cette fois-ci bien 512 Mio comme conjecturé plus haut, capacité donc doublée par rapport aux anciennes HP Prime G1 !

Conclusion :

Go to top

La HP Prime G2 t'offre donc à ce jour pour la rentrée 2019 le processeur le plus puissant secondé de mémoires de stockage et de travail ridiculisant astronomiquement toute concurrence.

Véritable trésor pour toute personne ayant de forts besoins de puissance ou de capacité, la HP Prime G2 de par ses caractéristiques exceptionnelles offrira également tout un monde de possibilités aux programmeurs. Et contrairement à la concurrence, sur HP Prime G2 tu ne risqueras pas de te sentir limité dans ta créativité passé la phase d'initiation, autant de temps de gagné même pour les programmeurs débutants !

Pour la rentrée 2019 Hewlett Packard t'offre donc la "Rolls des calculatrices", tout ceci en réussissant l'exploit de ne pas lui faire prendre un seul centime ou gramme supplémentaire - merci HP !

Crédits images HP Prime G2 de production : https://www.hpmuseum.org/forum/thread-1 ... #pid102774

[critor]

mViewer GX est notre service en ligne permettant de convertir tes images et documents PDF pour nombre de calculatrices graphiques différentes, dont la HP Prime.

Deux formats sont gérés dans ce dernier cas :

• programmes avec mViewer GX1
• applications avec mViewer GX2

Toutefois, les utilisateurs de certaines zones géographiques rencontraient des problèmes, avec des applications et programmes générés qui refusaient obstinément de marcher une fois mis sur la calculatrice, alors que ces mêmes fichiers ne rencontraient strictement aucun problème lorsque testés sur d'autres calculatrices ou sur émulateur.

Les programmes montraient des erreurs de syntaxe à des lignes qui n'en comportaient pas, et les applications nous laissaient encore plus dans l'ignorance en substituant une interface par défaut.

Nous nous doutions qu'il devait y avoir une subtilité locale. Nous avions donc testé en changeant la langue, mais n'avions pas réussi à reproduire le problème.

Heureusement, Rafael_Reis nous a pointé ce qui clochait. Certains utilisateurs changent le format par défaut d'affichage des nombres, afin d'utiliser la virgule comme séparateur décimal.

En soit ce n'est pas gênant, mais ça a une autre conséquence. Dans ce contexte, la virgule ne peut alors plus être utilisée comme séparateur de paramètres dans le code des programmes et applications, et doit être remplacée par un point-virgule. Au lieu de fct(param1,param2,...) il faut donc écrire fct(param1;param2;...).

Enormément de programmes et applications HP Prime disponibles en ligne ne fonctionneront pas dans ce contexte pour cette raison.

Pas besoin toutefois de réécrire une deuxième version du code, il suffit de commencer ce dernier par la ligne magique spécifiant les séparateurs utilisés :

Code: Tout sélectionner

#pragma mode( separator(.,;) integer(h64) )

mViewer GX1 et mViewer GX2 sont dès maintenant tous deux corrigés avec cette ligne.

mViewer GX2 en profite pour passer en version 1.3, avec quelques petits ajustements de code.

Merci Rafael_Reis, et de même si tu veux d'autres corrections/améliorations, n'hésite pas toi aussi à t'exprimer.

Lien : mViewer GX

Source : https://h30487.www3.hp.com/t5/Outros-pr ... d-p/647893 via viewtopic.php?f=73&t=21314&p=241772#p241237

[critor]

La nouvelle HP Prime en révision matérielle D est sortie pour la rentrée 2018, mais n'est pas encore disponible dans tous les pays et en passant toujours pas en France.
Surnommée HP Prime G2, la machine succède aux révisions matérielles A à C et fait un véritable bond technologique en passant :

• d'un processeur ARM9/ARMv5 comme sur les TI-Nspire à un processeur i.MX 6ULL de chez NXP, un Cortex/ARMv7 comme chez NumWorks mais cadencé ici à 528 MHz !
• de 32Mio comme sur les TI-Nspire monochromes à 256Mio de SDRAM, et en DDR3 cette fois-ci !
• de 256Mio de mémoire Flash-NAND à 512Mio !

Sur les HP Prime G1, Lionel Debroux avait développé le tout premier firmware non officiel.

jean-baptiste boric s'était remarquablement illustré en prenant la suite avec :

• Rip'em, un autre firmware non officiel conçu à partir de rien et offrant quelques fonctionnalités
• ainsi qu'un portage du firmware NumWorks 1.6.0

Mais suite au changement de processeur, tout ce qui avait été développé en langage machine et donc notamment ces firmwares tiers, ne fonctionne plus.

Tout est donc à recommencer intégralement.

Une des méthodes qui a rendu possibles des tests qui ont à leur tour permis de tels développements sur les HP Prime G1, c'est la prise de contrôle du processeur via son interface JTAG.

Une piste pour trouver le JTAG était de chercher sur la carte électronique un groupe d'au moins 5 points de tests, à identifier par la suite en :

• TCK
• TDI
• TDO
• TMS
• TRST ou/et RESET (peuvent partager le même point de test)
• VCC (alimentation - peut être partagée avec d'autres choses que le JTAG, et donc éloignée des points de test précédents)
• GND (masse - peut être partagée avec d'autres choses que le JTAG, et donc éloignée des points de test précédents)
• RTCK (optionnel)

Problème sur HP Prime G2, la carte électronique ne présente apparemment rien de tel...

Notons que les HP Prime G1 identifiaient clairement deux points de tests pour une communication série (UART), points que l'on ne retrouve pas non plus ici.

Mais jean-baptiste boric ne se décourage pas pour autant, et a eu l'idée de décoller l'écran de l'autre face de la carte, révélant ainsi plein de points de tests supplémentaires, ici clairement identifiés. Ceux qui nous intéressent ici sont préfixés en JT_, mais sont plus dispersés cette fois-ci :

• JT_TCK
• JT_MOD
• JT_TMS
• JT_TDI
• JT_TDO
• JT_NTRST

On retrouve également les deux points de test du port série UART avec :

• UART1_RX
• UART1_TX

Notons aussi des points de test permettant apparemment le rajout d'un lecteur de carte mémoire SD comme sur les HP 49G+ et HP 50G :

• SD1_DATA0
• SD1_DATA1
• SD1_DATA2
• SD1_DATA3
• SD1_CMD
• SD1_CLK

C'est bien sympa de la part de HP de nous avoir ici identifié clairement les points de test qui nous intéressent.
Mais inversement, les avoir cette fois-ci cachés au dos et collé l'écran par-dessus les rend inaccessibles au commun des mortels ainsi qu'à nombre de bricoleurs du dimanche.

Laissons de côté la carte mémoire SD pour le moment, car même si elle est gérée matériellement il faudrait encore le code logiciel pour pouvoir l'exploiter, ce qui ne serait pas raisonnable pour de premières tentatives d'injection de code non officiel.

L'UART est quant à lui resté jusqu'à présent muet comme une carpe malgré les tentatives de jean-baptiste boric.

Par contre, la connexion via une interface JTAG FTDI MPSSE et OpenOCD est bien plus bavarde :

boricj@debian-boricj:~$ openocd -f Documents/hp-prime/G2/c232hm.cfg -f Documents/hp-prime/G2/imx6ull.cfg
Open On-Chip Debugger 0.9.0 (2018-01-21-13:43)
Licensed under GNU GPL v2
For bug reports, read
http://openocd.org/doc/doxygen/bugs.html
adapter speed: 100 kHz
Warn : imx6.sdma: nonstandard IR value
adapter speed: 1000 kHz
Info : clock speed 1000 kHz
Info : JTAG tap: imx6.dap tap/device found: 0x5ba00477 (mfg: 0x23b, part: 0xba00, ver: 0x5)
Info : TAP imx6.sdma does not have IDCODE
Info : JTAG tap: imx6.sjc tap/device found: 0x088c101d (mfg: 0x00e, part: 0x88c1, ver: 0x0)
Info : imx6.cpu.0: hardware has 6 breakpoints, 4 watchpoints
Info : accepting 'gdb' connection on tcp/3333
Info : ttbcr 0ttbr0 900009ttbr1 4a3d30f0
Info : imx6.cpu.0 rev 5, partnum c07, arch f, variant 0, implementor 41
Info : number of cache level 2
Error: cache l2 present :not supported
Info : imx6.cpu.0 cluster 0 core 0 multi core
target state: halted
target halted in Thumb state due to debug-request, current mode: System
cpsr: 0x200000ff pc: 0x8035afd8
MMU: enabled, D-Cache: enabled, I-Cache: enabled

Le processeur est maintenant entièrement à nos ordres, et voici déjà jean-baptiste boric en train de jouer via les commandes ci-dessous avec la partie censée être la plus sécurisée de la machine, les diodes du mode examen :

• diode rouge :
  
  • allumer : set GPIO1_DR[7] = 0
  • éteindre : set GPIO1_DR[7] = 1
• diode verte :
  
  • allumer : set GPIO1_DR[2] = 0
  • éteindre : set GPIO1_DR[2] = 1
• diode bleue :
  
  • allumer : set GPIO1_DR[9] = 0
  • éteindre : set GPIO1_DR[9] = 1

Téléchargement : configuration JTAG OpenOCD HP Prime G2
Source : viewtopic.php?f=69&t=22127#p238167

[critor]

Dans un article précédent, nous te dumpions la carte ROM Sparcom Spice48 pour calculatrices HP 48SX et HP 48GX.

L'image ainsi obtenue était en prime chargeable sur HP 48G+, même si toutes les fonctionnalités n'étaient pas utilisables dans ce cas, vu que cela occupait une grand partie de la mémoire interne (100K sur 128K) à la différence d'une carte RAM/ROM externe.

Spice48 est un gestionnaire de circuits électroniques, te permettant notamment :

• de construire ton circuit avec ses noeuds, fils et éléments
• de spécifier les valeurs nominale et/ou initiale de chaque élément
• de visualiser le circuit
• de représenter graphiquement l'évolution au cours du temps de grandeurs de ton choix (tension entre deux bornes, intensité...) grâce à la résolution de l'équation différentielle qui est construite silencieusement au fur et à mesur de tes différents ajouts

Une application de qualité professionnelle pour le lycée et les études supérieures !
Mais quel dommage qu'elle ne bénéficie à ce jour d'aucun équivalent sur les calculatrices graphiques récentes, pas même chez HP.

Pour te faciliter la découverte de ce petit bijou, F4HON vient en prime de partager un scan complet du manuel !

Grands mercis F4HON pour cette superbe pépite de Noël, et triplement si c'est toi qui as sacrifié je ne sais combien d'heures à scanner et donc sauver les 171 pages !

Téléchargements :

• Spice48
• Manuel

Source : viewtopic.php?f=55&t=22038&p=237869#p237869