TI-Planet

by **critor** » 22 Jan 2020, 15:17

Suite aux bêta-tests ouverts au public depuis Octobre 2019, Hewlett Packard vient de pousser sur son site les nouvelles versions 2.1.14424 et 2.1.14425 datées des 16 et 20 Janvier 2020. L'ensemble de l'écosystème est concerné :

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

Attention, si tu disposes d'une HP Prime G2 tu ne dois pas mettre à jour sans avoir pris connaissance de ce qui suit.

Le contrôleur d'écran tactile GT5688 utilisé à la fois pour les HP Prime G1 et G2 n'est plus fabriqué. Ci-contre, le menu de diagnostics obtenu avec la combinaison de reset

sur notre HP Prime G2 détecte bien ce contrôleur, plus précisément un GT5688-281 même si d'autres versions sont parfaitement possibles comme GT5688-516.

En conséquence des HP Prime G2 munies d'un nouveau contrôleur ilitek vont bientôt être approvisionnées.

Les derniers firmwares HP Prime G2 14424 et 2.1.14425 anticipent la chose en incluant en conséquence 2 pilotes d'écran tactile.

Mais sur certaines actuelles HP Prime G2 pourtant toujours munies de l'ancien contrôleur, ces nouveaux firmwares les détectent à tord comme de nouvelles révisions matérielles, et se mettent après mise à jour à utiliser le nouveau pilote ilitek-00. En conséquence l'écran tactile cesse de fonctionner.

Tout ce que l'on peut dire, c'est que notre HP Prime G2 n'est pas concernée. La combinaison de reset

Symb

y affiche bien une révision matérielle 3.1, aussi bien avec les anciens firmwares que les nouveaux. Mais sur certaines HP Prime G2 la révision matérielle détectée est 3.2 ou même 3.3.

Si tu as déjà installé un de ces nouveaux firmwares et que ton écran tactile a cessé de fonctionner, il te suffira de réinstaller une ancienne version.

Une grande nouveauté des firmwares 2.1.14424 et 2.1.14425, est qu'ils corrigent une faille du mode examen que se partagent les candidats français.

En effet sur HP Prime comme sur la quasi totalité des modèles de milieu et haut de gamme, le bouton de réinitialisation reset au dos ne supprime pas les données.

Mais il se trouve que contrairement à la concurrence, la HP Prime enregistrait l'activation du mode examen avant de vider la mémoire.

Comme nous l'avons découvert suite aux indices laissés par un utilisateur se faisant justement appelé Prolotis, il suffisait de presser le bouton reset juste après la validation de l'activation du mode examen pour empêcher cette dernière étape, et se retrouver ainsi en mode examen avec une diode clignotante et l'ensemble de ses données accessibles.

(vidéo support non listée qui n'a absolument pas pour but de servir de tutoriel, aucune aide ou explication complémentaire ne sera apportée)

Ce n'est pas pour rien que notre protocole d'activation du mode examen précise aux surveillants que la procédure doit s'effectuer avec des calculatrices posées à plat sur la table; pas de manipulation du bouton reset ou du compartiment d'alimentation pendant l'activation !

En pratique, la HP Prime G2 étant beaucoup plus rapide que la HP Prime G1, réussir la manipulation y est très difficile. La fenêtre pendant laquelle le bouton reset peut être utilisé avec succès y est en effet réduite à une fraction de seconde après validation.

La faille est donc dès maintenant corrigée, juste à temps pour les épreuves d'E3C, ouf, grand merci Hewlett Packard et félicitations !

Si les candidats pourront certes se montrer réticents à mettre à jour surtout que rien ne les y oblige, sans doute qu'ils changeront d'avis lorsque l'application Python sera disponible.

En attendant, d'où l'intérêt de suivre scrupuleusement notre protocole d'activation en début d'épreuve, conçu pour empêcher un maximum d'exploitation de failles via de simples interventions collectives de la part surveillant - rien de lourd ni chronophage donc, et pas besoin d'être un expert dans chaque modèle non plus !

Plus cette phase sera effectuée de façon sérieuse et carrée, et moins il y aura d'incidents à traiter en cours d'épreuve.

Téléchargements :

HP Prime Virtual Calculator 2.1.14425 pour Windows 32-bits, Windows 64-bits ou Mac
HP Prime Connectivity Kit 2.1.14425 pour Windows 32-bits, Windows 64-bits ou Mac
Firmware HP Prime 2.1.14425 pour HP Prime G1 ou HP Prime G2
Firmware HP Prime 2.1.14424 pour HP Prime G2

Sources : ftp://ftp.hp.com/pub/calculators/Prime/ + https://www.hpcalc.org/prime/pc/ via https://www.hpmuseum.org/forum/thread-14373.html

by **critor** » 01 Dec 2019, 18:18

Dès 2014 nous te sortions PrimeCaster3D, un moteur 3D en raycasting étendu pour ta HP Prime, te permettant la visite d'un donjon fortifié et de ses corridors. Bien que fort optimisé, il était à l'époque un peu limite pour les capacités de la HP Prime G1, ce qui nous a notamment découragés d'y rajouter des textures.

Certains opposeront que contrairement au raytracing, le raycasting n'est pas un véritable moteur 3D, n'étant que l'affichage en relief d'un plan pouvant être intégralement décrit en deux dimensions. Les algorithmes de raycasting ne permettent d'ailleurs de rotations que selon 2 axes au mieux, au lieu de 3.

Quoi qu'il en soit, aujourd'hui les performances sont bien plus extraordinaires sur HP Prime G2, ce qui devrait permettre de pouvoir aller bien plus loin.

Et bien c'est déjà chose faite avec wsmslgh de la communauté chinoise cnCalc qui nous sort une horloge 3D. Avec tous les détails possibles, inscriptions horaires en relief, et même les aiguilles qui tournent !

Tu auras le grand plaisir de pouvoir examiner l'horloge sous toutes ses coutûres en la tournant dans tous les sens directement sur ton écran tactile !

Les gestes tactiles suivants sont gérés :

glissement simple
glissement avec vélocité
rotation à deux doigts

Clock3D prend la forme d'un unique programme écrit dans le langage interprété historique HPPPL de la HP Prime et donc très accessible, peut-être de quoi le modifier selon ton inspiration.

Un excellent outil pour remplacer ton smartphone interdit en examen et savoir l'heure qu'il est...

... ah ben non c'est vrai, cette saleté de mode examen si mal conçu sur 2012-2014 va bêtement t'effacer cet outil alors qu'il ne s'agit pourtant absolument pas d'"informations" comme ciblé par les spécifications de novembre 2014.

Pourtant, ce n'est pas comme si il n'y avait pas eu tout le temps d'en rediscuter depuis 2015 avec les multiples reports.

Bon ben pas de chance, cette année il faudra t'acheter une montre. Casio en fait justement de très belles; profites-en pendant que la réglementation n'en est pas encore à définir une liste de modèles de montres autorisés, ou pire un mode examen pour les montres.

Téléchargement : archives_voir.php?id=2467249
Source : https://www.cncalc.org/forum.php?mod=vi ... &tid=24282

by **critor** » 25 Nov 2019, 17:53

Processeur MCIMX6Y2 (un Cortex / ARMv7) de la famille i.MX 6ULL de chez NXP cadencé à 528 MHz, 512 Mio de mémoire Flash, 256 Mio de mémoire SDRAM... La HP Prime G2 dispose à ce jour des meilleures spécifications parmi les calculatrices graphiques.

Dans une actualité précédente, nous t'apprenions que zephray_wenting avait justement réussi à faire tourner Linux sur sa HP Prime G2.

Par contre contrairement au modèle HP Prime G1 précédent, précisions que l'installation de systèmes d'exploitation tiers sur HP Prime G2 n'est à ce jour pas à la portée de l'utilisateur lambda, nécessitant en effet une intervention électrique dans la machine.

Le 26 octobre dernier, le développeur et hacker Ben Imbushuo alias imbushuo chez nous, annonçait sur son compte Twitter @imbushuo que sa prochaine victime serait la HP Prime G2 et le voici dès le 1^er novembre en train d'y faire tourner comme son prédécesseur le chargeur de démarrage U-Boot. Mais que peut-il bien nous préparer ?

Dès le 2 novembre, Ben rajoute une couche en lui faisant lancer à son tour TianoCore, un chargeur de démarrage cette fois-ci UEFI et donc avec davantage de possibilités.
Avec initialement quelques difficultés pour lire et traiter les messages d'erreur, puisque le petit écran HP Prime 320x240 pixels ne tient pas le standard 80 colonnes.

Si tu n'as pas deviné jusqu'à présent et bien ça devrait maintenant être clair pour toi; comme révélé au monde le 6 novembre, Ben ne cherche ni plus ni moins qu'à faire tourner Windows 10 sur sa HP Prime G2 !

Mais pas n'importe quel Windows 10 et pas celui que tu utilises peut-être en ce moment... mais Windows 10 IoT (Internet of Things), l'édition légère dédiée aux objets connectés et plateformes embarquées.

Justement, Microsoft a un partenariat avec NXP concernant Windows 10 IoT sur ses puces iMX. En théorie, faire tourner Windows sur HP Prime G2 devrait donc être possible...

Bon pour l'instant, malgré le lancement de bootmgfw, Windows 10 ne démarre visiblement pas. Une fois de plus l'écran 320x240 pixels se révèle bien embêtant, ne permettant pas d'afficher les messages ou codes d'erreurs au complet, et donc de comprendre ce qui se passe. Ben travaille donc pour le 8 novembre pour que les écrans en question soient également correctement écrits et donc récupérables sur le port série UART interne de la HP Prime G2.

Suite à toutes ces péripéties, le 8 novembre, pour la première fois au monde et dans l'histoire, le logo Windows 10 s'affiche sur une HP Prime G2 !

On passe donc enfin la main à Windows, et une fois de plus ce dernier refuse de travailler sur un buffer écran de 320x240, nous laissant donc avec le logo précédent complètement figé, ce qui nécessite une fois de plus l'auscultation de ce qui peut bien se passer via la connectique UART.

20 novembre, Windows accepte enfin d'allumer ses premiers pixels sur l'écran HP Prime. Et voici enfin dès le 20 novembre le tout premier démarrage de Windows sur HP Prime, certes minimal !

Le démarrage prend certes environ 3min30s, la vidéo ci-contre étant accélérée.

23 novembre, cela va faire bientôt un mois. Ben nous complète le démarrage avec les différentes étapes...

23 novembre, après nous avoir une dernière fois demandé de patienter, voici enfin un Windows fonctionnel sur HP Prime.
Quelle aventure, quel exploit !

Seul bémol pour l'utilisateur à date, toutes les fenêtres n'acceptent pas de se redimensionner correctement pour l'écran 320x240 pixels.

Sources :

by **critor** » 24 Nov 2019, 01:03

Cette semaine, Hewlett Packard Calculatrices propose à sa communauté de poursuivre le bêta-test public de sa prochaine mise à jour HP Prime, avec cette fois-ci une release candidate, la version 2.1.14341 datée du 20 novembre 2019.

Cette mise à jour concerne :

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

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

Sans surprise, pas d'application Python. Nous avions bien dit que la version avec application Python publiée par erreur, bien que très prometteuse, ne pouvait être finalisée et validée en quelques semaines.

Changelog complet :

Show/Hide spoilerAfficher/Masquer le spoiler

MAIN:
https used for communication with update server for download (was http before)
ROUND and TRUNC now works on units
graphing of int(2*X,X,0,X) did not work...

CAS:
change for desolve(((y' = a*(b-y)^2-c)) AND (y(0) = 0),x,y)|a=3.1,b=5.2,c=7.3;
fix re/im on diff
fix solve 3rd order inequation solving
fix crash plotfunc on a function
fix for rootof in inequation solving

APPS:
SPACE and ENTER keys on external keyboards not working on android.
Android top button no longer dissapears on hide menu bar
iOS adv grapher using too much memory

Téléchargements :

HP Prime Virtual Calculator pour Windows 32-bits / Windows 64-bits / Mac
HP Prime Connectivity Kit pour Windows 32-bits / Windows 64-bits / Mac
Firmware HP Prime pour HP Prime G1 / HP Prime G2

Source : https://www.hpmuseum.org/forum/thread-14025.html

by **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 ?...

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

Premier contact et méthode de saisie
Mantisses et exposants en virgule flottante
Modules importables et aide en ligne
Exploration module sys et nombres entiers
Exploration autres modules
Mémoire de travail et récursivité
Performances
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: 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 !

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

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

13 modules : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
9 modules : Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII (application CasioPython)
8 modules : HP Prime + TI-83 Premium CE Edition Python + NumWorks + TI-Nspire (application MicroPython) + module externe TI-Python pour TI-83 Premium CE
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 !

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 :

216-581 éléments : HP Prime
213-354 éléments : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
185-310 éléments : TI-Nspire (application MicroPython)
202-302 éléments : NumWorks
181-294 éléments : Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII (application CasioPython)
159-258 éléments : TI-83 Premium CE Edition Python + module externe TI-Python pour TI-83 Premium CE
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 !

2,049276 Mo : TI-Nspire (application MicroPython)
1,032942 Mo : Casio Graph 90+E
1,022145 Mo : HP Prime
257,636 Ko : Casio Graph 35/75+E (application CasioPython)
100,560 Ko : Casio Graph 35+E II
31,899 Ko : Casio Graph 35+E II (application CasioPython)
22,605 Ko : TI-83 Premium CE & TI-Python (firmware tiers)
20,200 Ko : TI-83 Premium CE Edition Python
19,924 Ko : TI-83 Premium CE & TI-Python
16,109 Ko : NumWorks N0100
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.

5362 : Casio Graph 35/75+E (application CasioPython)
655 : Casio Graph 35+E II (application CasioPython)
130 : TI-Nspire (application MicroPython)
82 : Casio Graph 90+E + Casio Graph 35+E II
77 : HP Prime
29 : NumWorks
23 : TI-83 Premium CE Edition Python
20 : TI-83 Premium CE & TI-Python
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: 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.

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 !

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

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 :