π
<-
Chat plein-écran
[^]

News 2019
July (2)
April (1)

News 2018
August (1)
July (1)
June (3)

News 2017
August (2)
July (2)
March (1)

News 2016
April (3)
March (3)

News 2015
August (2)
July (2)
June (1)
May (4)
March (1)

News 2014
August (2)
July (2)
June (1)
May (1)

News 2013
August (12)
July (1)
June (1)
May (5)
April (4)
March (1)

News 2012

Application Python officielle pour HP Prime G1 et bêta-test

New postby critor » 30 Oct 2019, 12:04

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 ?...
;)
11694En 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
. :o

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 :bj:
  • la possibilité de faire du calcul littéral et formel :bj:
  • la possibilité de dessiner à l'écran, conformément au nouveau programme de Physique-Chimie Seconde depuis la rentrée 2019 :bj:

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 pour
NumWorks
et
KhiCAS
pour et , ce n'est pas problématique puisque Bernard est très réactif et accomplit un travail formidable avec des mises à jour hebdomadaires ! :bj:
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 1er 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 :

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 ! :bj:



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: Select all
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 ! :bj:
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 ! :bj:

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: Select all
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
! :#roll#:
(coucou
NumWorks
! :p)

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: Select all
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
  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
    + 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: Select all
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 ! :bj:



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
  3. 185-310
    éléments :
    TI-Nspire
  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
  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: Select all
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 ! :bj:
  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
  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: Select all
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




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: Select all
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
. :o
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 ! :bj:
Tu auras désormais libre choix entre la couche de traduction du mode
CAS
, et l'application
Python
standard ! :D

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. :bj:
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 ! :D

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 ! :#non#:

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 :
HP wrote: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
:


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

HP Prime G2 de retour chez LDLC à moins de 110€ !

New postby critor » 28 Oct 2019, 12:35

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

Hélas c'est assez mal tombé pour la France, vu que le grossiste
HP
français
SMS
(
S
olution
M
icro
S
ystem)
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.


11688Toutefois
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 ! :bj:

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
! :#tritop#:

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

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

Bêta-test versions HP Prime 2.1.14288 Windows/Mac/Linux/iOS

New postby critor » 27 Oct 2019, 16:54

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 tout 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 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 :bj:

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
. :bj:

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


Changelog
complet :
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
:


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

Linux déjà sur HP Prime G2 !

New postby critor » 15 Jul 2019, 13:26

La
HP Prime G1
sortie pour la rentrée 2013 avait bénéficié de plusieurs
firmwares
tiers :
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 :

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
! :#tritop#:

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
:
Link to topic: Linux déjà sur HP Prime G2 ! (Comments: 7)

Rétro-test HP Prime G2 (révision D) rentrée 2019

New postby critor » 07 Jul 2019, 17:58

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,
(Solution Micro System)
, a rencontré des difficultés en 2018. La distribution en France a alors été confiée au sous-traitant , 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 ! :bj:

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


Sommaire :



1) Tour du propriétaire :

Go to top

97819780La
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
.

9782Une 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.

1137411371Pesé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.

1137311372Mais 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 ! :bj:

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 ! :bj:
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
! :bj:

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
! :#tritop#:




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
: :bj:


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. :#tritop#:

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
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
. :bj:

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: Select all
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 ! :bj:




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
! :bj:



97929788Puisque 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


9793Et 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. :mj:
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

1138611383Afin 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
: :)
1138211381
1138511384




6) Matériel :

Go to top

97849785Nous 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 ! :bj:

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 ! :bj:

9786Retirons 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
! :bj:




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. :bj:

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 ! :bj:

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
! :bj:


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

Mise à jour mViewer GX2 1.3 HP Prime

New postby critor » 22 Apr 2019, 21:46

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

11101Toutefois, 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. :mj:

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, 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.

11102Pas 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: Select all
#pragma mode( separator(.,;) integer(h64) )

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

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
Link to topic: Mise à jour mViewer GX2 1.3 HP Prime (Comments: 0)

Contrôle total HP Prime G2 via JTAG

New postby critor » 04 Jan 2019, 14:52

9783La 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
    ! :bj:
  • de
    32Mio
    comme sur les
    TI-Nspire
    monochromes à
    256Mio
    de
    SDRAM
    , et en
    DDR3
    cette fois-ci ! :bj:
  • de
    256Mio
    de mémoire
    Flash-NAND
    à
    512Mio
    ! :bj:

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

s'était remarquablement illustré en prenant la suite avec :

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)

9785Problè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 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 .

Par contre, la connexion via une interface
JTAG FTDI MPSSE
et
OpenOCD
est bien plus bavarde : :bj:
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à 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
Link to topic: Contrôle total HP Prime G2 via JTAG (Comments: 8)

-
Search
-
Featured topics
Concours TI-Planet-Casio de rentrée 2019. 3 défis pour plus d'une 15aine de calculatrices graphiques et nombre de goodies sortant de l'ordinaire ! :D
Comparaisons des meilleurs prix pour acheter sa calculatrice !
12
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...

Discover the the advantages of a donor account !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partner and ad
Notre partenaire Jarrety 
-
Stats.
501 utilisateurs:
>462 invités
>33 membres
>6 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)
-
Other interesting websites
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)