π
<-

NumWorks Abandon du projet Omega, le firmware tiers pour NumWorks

New postby Admin » 30 Aug 2021, 10:02

Pour la rentrée 2017 sortait la calculatrice graphique NumWorks, initialement un projet absolument génial, cassant complètement les codes du marché, à l'opposé des habitudes des constructeurs historiques Casio, Hewlett Packard et Texas Instruments.

Le constructeur NumWorks affichait fièrement ses convictions dans une formulation qui n'est hélas plus consultable que dans les archives du web.

D'une part, le constructeur mettait en avant la possibilité de fabriquer toi-même ta propre calculatrice à partir des plans techniques, et de pouvoir ainsi la modifier ou réparer de tes propres mains : :favorite:
NumWorks wrote:Devenez bricoleur
Les plans de fabrication de la calculatrice NumWorks sont publics. Muni de quelques composants électroniques, vous avez donc la possibilité de fabriquer votre propre calculatrice en impression 3D. En cas de problème technique, vous pouvez aussi réparer vous-même votre matériel.


De plus, le code source d'Epsilon, le firmware de la calculatrice, était ouvert et libre d'utilisation (licence Creative Commons BY-NC-SA 4.0), extraordinaire : :favorite:
NumWorks wrote:Un projet collaboratif
Par conviction et parce que les besoins évoluent sans cesse, NumWorks est la première calculatrice ouverte : toutes les connaissances que nous avons développées sont disponibles en ligne sous licence Creative Commons.


Enfin, le constructeur mettait ainsi en avant la possibilité pour toi de contribuer au code, et dans tous les cas d'ajouter directement tes corrections ou fonctionnalités à ta propre calculatrice sans avoir à attendre pendant des semaines ou mois une hypothétique validation et intégration à une future mise à jour officielle ! :favorite:
NumWorks wrote:Chaque utilisateur a ainsi la possibilité d’ajouter lui-même ses propres fonctionnalités et la communauté peut proposer des améliorations qui seront intégrées à nos futures mises à jour.

En pratique toutefois, il était très rare que les contributions tierces proposées au code source d'Epsilon soient acceptées, surtout dès lors qu'elles osaient toucher à la sacro-sainte interface.

La plupart du temps les contributions en question traînaient pendant des mois sans intégration, jusqu'à ne plus se compiler correctement, le code d'Epsilon ayant changé entre temps sans en tenir compte. :'(

L'illustre Quentin Guidee et ses non moins illustres collaborateurs avaient toutefois pris le constructeur au mot sur ce dernier point.

Ils avaient lancé Omega, un firmware alternatif pour ta calculatrice NumWorks. Basé sur le code source d'Epsilon comme la licence l'autorisait, Omega avait pour but de regrouper et mettre en avant les meilleures contributions au code d'Epsilon, en incluant cette fois-ci celles laissées de côté par le constructeur.

Difficile de tout citer ici mais voici déjà par exemple un des fantastiques ajouts d'Omega. La NumWorks travaille en interne sur des arbres de calcul, mais n'accepte que des valeurs numériques. Omega étendait ces arbres en autorisant également des lettres / inconnues, ce qui nous donnait ainsi un moteur de calcul littéral. De quoi même dériver, du jamais vu à seulement 80€ ! :bj:
Il y avait aussi un tableau périodique des éléments.

12024Outre ce qu'il intégrait, Omega offrait également l'avantage de pouvoir installer à chaud des applications. Plusieurs applications de très haute facture furent développées, on peut citer entre autres : :D
  • KhiCAS, une formidable application intégrée de Mathématiques et de Sciences par Bernard Parisse, enseignant-chercheur à l'Université de Grenoble, qui étendait gratuitement les capacités de ta calculatrice au niveau d'une HP Prime. L'application intégrait le moteur de calcul formel GIAC développé pour le logiciel Xcas du même auteur pour des possibilités en calcul encore plus étendues. Étaient également inclus un tableur, une bibliothèque de constantes physiques, un convertisseur d'unités, un tableau périodique des éléments et bien d'autres choses encore. Le tout était en prime programmable en Python, avec une collection de modules importables bien plus étoffée que celle de l'application Python officielle, et surtout ici de façon intégrée, tes scripts Python pouvant en effet faire appel au moteur de calcul formel GIAC par l'intermédiaire du module cas.
  • Nofrendo, un émulateur de console de jeux Nintendo NES par zardam
  • Peanut-GB, un émulateur de console de jeux Nintendo GameBoy par M4x1m3
  • Periodic, un tableau périodique des éléments par M4x1m3
Un gros avantage de plus était ici que KhiCAS et l'ensemble des fonctionnalités rajoutées restaient accessibles en mode examen, de façon parfaitement légale et légitime en France, puisque ces fonctionnalités venaient directement intégrées à des modèles concurrents haut de gamme parfaitement autorisés. :bj:

Comme nous te l'avons déjà annoncé, c'est hélas terminé. :'(

L'installation de la dernière version 16.3.0 du firmware officiel Epsilon verrouille définitivement ta calculatrice contre toute installation de firmware non officiel. :mj:

De plus, la licence Creative Commons est abandonnée. Tu n'as donc plus le droit :
  • de réutiliser du code d'Epsilon dans tes projets :#non#:
  • de distribuer Epsilon ou tes versions modifiées d'Epsilon, aussi bien sous forme de code source que sous forme binaire compilée :#non#:
Bref c'est simple, même si le code source reste public (encore que il semble que ce qui concerne le verrouillage n'ait pas été intégralement publié à ce jour), tu ne peux plus rien en faire. En plus de les interdire d'installation, voilà donc qui tue également la possibilité de créer des firmwares modifiés. :mj:

L'esprit NumWorks tel que tu as pu le connaître depuis la rentrée 2017 n'existe clairement plus pour cette rentrée 2021. :#non#:

La page des convictions a justement été complètement saccagée dès juin 2021. Plus rien des 3 points initiaux n'y a survécu. :'(
La disponibilité sous licence libre disparaît, la possibilité d'installer ses propres améliorations n'est plus mentionnée, et la possibilité d'assembler/réparer soi-même sa calculatrice n'est plus mise en avant bien que les plans restent (pour l'instant ?...) disponibles en ligne. À la place nous n'avons plus que ce qui ne semble n'être que du blabla de communication passe-partout, absolument quelconque et sans la moindre conviction.

Pourquoi ? Nous ne disposons probablement pas de tous les éléments, mais il semble y avoir :
  • un très grave incident aux Pays-Bas :
    En Février 2020, la NumWorks était acceptée dans la dernière mise à jour de la liste des calculatrices autorisées aux examens, valide à compter de la session 2022. Un étudiant anti-libre avait alors la formidable idée d'abuser du caractère ouvert d'Epsilon pour modifier le mode examen afin qu'il n'efface plus les données, de filmer la chose, et d'envoyer la vidéo à l'institution nationale, le tout à peine quelques semaines après la publication de la liste.
  • un camouflet monumental au Portugal :
    NumWorks prend contact avec l'institution nationale puisqu'ici aussi il y a une liste de calculatrices approuvées. Tout va bien a priori, NumWorks annonce dans la presse Portugaise dès la rentrée 2020 sa prochaine autorisation. Sauf qu'à la publication de la mise à jour de la liste en Mars 2021, la NumWorks n'y figure pas. Sans la nommer, les motivations accompagnant la liste incriminent la possibilité d'installer des fonctionnalités de calcul formel sur certains des nouveaux modèles testés, sans aucun doute possible puisque les derniers modèles non formels des constructeurs historiques y étaient déjà présents.
  • Il semble y avoir une volonté de NumWorks de s'exporter à l'étranger (Pays-Bas et Portugal donc, mais aussi Italie, Royaume-Uni et États-Unis).
    C'est peut-être dû au probable effondrement à venir de l'usage de la calculatrice graphique en France, suite à la suppression il y a à peine quelques semaines des épreuves d'E3C/EC du BAC, toutes dernières épreuves encore régies par le cadre national (calculatrice en mode examen comme seul outil numérique autorisé) à concerner l'ensemble des élèves rentrant en Seconde.
  • En dehors de la France, nombre d'examens ou pays interdisent le calcul formel (Italie, Portugal, Pays-Bas, Royaume-Uni, ...).
  • NumWorks semble particulièrement tenir aux États-Unis en fait, avec l'ouverture sur place d'un nouveau studio de développement, et l'expédition de packs enseignants gratuits avec calculatrice + goodies par centaines cet été pour ce que nous avons pu voir sur leurs comptes sociaux, possiblement par milliers en réalité.
  • Chat échaudé craint l'eau froide, il y a donc possiblement la volonté de ne pas se ridiculiser à nouveau comme au Portugal ou aux Pays-Bas, surtout sur un marché de la taille des États-Unis.
Face à un tel virage à 180°, nous n'avons qu'une seule interrogation. NumWorks a-t-il jamais cru en ses convictions initiales, ou le projet était-il dès le départ de retourner sa veste dès que les finances auraient été suffisamment consolidées ?... :#roll#:

Quoi qu'il en soit, suite à l'absence de la part du constructeur de volonté d'échanger depuis ainsi que de la moindre inflexion, et ce malgré une pétition ayant réussi l'exploit de réunir plus de 250 signatures sur un sujet aussi technique en période estivale, l'équipe Omega jette aujourd'hui l'éponge.

Il n'était plus viable de développer des firmwares tiers pour la NumWorks, c'est certes sans surprise mais avec une profonde tristesse que nous apprenons aujourd'hui la fin du firmware Omega, l'abandon du projet venant tout juste d'être annoncé.

L'équipe Omega se propose toutefois de laisser l'ensemble des éléments développés en ligne, et d'évoluer en tant que communauté d'aide générale à l'utilisation de la calculatrice NumWorks, munie donc de plus en plus souvent à l'avenir de son seul firmware officiel Epsilon :
Omega wrote:Depuis le 13 août 2021, NumWorks a définitivement mis fin aux développements communautaires via sa mise à jour Epsilon 16. Celle-ci installe un kernel dans votre NumWorks qu’il est impossible de retirer et qui empêche toute installation tierce telles qu’Omega, Delta ou variantes d’Epsilon.

De plus, Epsilon est désormais passé à une licence stricte (strong copyright). Il est désormais totalement interdit de créer une variante d’Epsilon 16 sur GitHub sous peine de se faire attaquer en justice par le constructeur.

C’est donc avec regret que nous annonçons ce lundi 30 août 2021, et ce après 2 ans d’activité, la fin et l’archivage du fork Omega.

Cependant, nous voulons conserver la communauté qui s’est forgée autour du projet, et c’est pourquoi la communauté Discord restera sur pied sous le nouveau nom d’Omega Community. Le serveur ne sera donc plus exclusivement réservé à Omega mais à tout ce qui touche à NumWorks.

Pour finir sur Epsilon, nous continuerons de vous déconseiller sa dernière mise à jour Epsilon 16. Rassurez-vous aussi, nous garderons l'installateur Omega en ligne, et les binaires toujours disponibles. Nous vous conseillons aussi l'excellent kit de connectivité de Bernard Parisse disponible ici : https://www-fourier.univ-grenoble-alpes ... e/nws.html

Nous tenons à terminer en remerciant chacun d’entre vous pour l’intérêt que vous avez porté à Omega. Nous remercions aussi tous les contributeurs, que vous pouvez en partie retrouver dans les crédits d’Omega. En particulier, un grand merci à Zardam pour le système d’applications externes, Bernard Parisse pour son logiciel KhiCAS incontournable, Boricj pour son application RPN, toute l’équipe TI-Planet pour la visibilité apportée, et Critor pour ses articles et son expérience plus que vitale au projet.

À très vite sur Omega Community,

Quentin Guidée, Maxime Friess et Joachim Le Fournis.
Omega wrote:As a reminder, since August 13, 2021, NumWorks has definitively put an end to community developments with its Epsilon 16 update. This installs a kernel in your Numworks that it is impossible to remove and which prevents any third-party firmware such as Omega, Delta or Epsilon variants.

In addition, Epsilon has now switched to a strong copyright license. It is now completely forbidden to create a variant of Epsilon 16 on GitHub under penalty of being sued by the manufacturer.

It is therefore with regret that we announce this Monday, August 30, 2021, and after 2 years of activity, the end and archiving of the Omega fork.

However, we want to keep the community that has grown around the project, and that’s why the Discord community will stay alive under the new name of Omega Community. The server will thus no longer be exclusively reserved for Omega but for everything NumWorks-related.

Finally, about Epsilon, we will continue to advise against its latest Epsilon 16 update. Rest assured, we will keep the Omega installer online, and the binaries still available. We also recommend the excellent connectivity kit from Bernard Parisse available here: https://www-fourier.univ-grenoble-alpes ... e/nws.html

We would like to close by thanking each of you for your interest in Omega. We also thank all the contributors, which you can partly find in Omega’s credits. In particular, a big thank you to Zardam for the external application system, Bernard Parisse for his essential KhiCAS software, Boricj for his RPN application, the entire TI-Planet team for the visibility provided, and Critor for his articles and his experience. more than vital to the project.

See you soon on Omega Community,

Quentin Guidée, Maxime Friess and Joachim Le Fournis.

14554Quentin Guidee, Joachim Le Fournis / redgl0w, Maxime Friess / M4x1m3, Jean-Baptiste Boric, Sandra Simmons / MixedMatch, David / 0b101, Damien Nicolet / zardam, Evann Dreumont / LeGmask, Venceslas Duet / citorva, Charlotte Thomas / coco33920, Antonin Loubière, A2drien, Timéo Arnouts / Dogm, Julie C. / windows9x95, Lélahel Hideux / Lelahelry, Madil / le-grand-mannitout, Hilaire Le Roux / 0Babass2, Hector N. / Sycorax, Raphaël Dyda / Trixciel et Thibaut C., vous avez été absolument formidables dans ce projet bénévole de haute qualité, vous n'avez pas compté vos heures, vous n'avez pas cherché à gagner un seul centime, vous nous avez offert le meilleur de vous-mêmes et de la NumWorks, repoussant au passage les limites des calculatrices de milieu de gamme comme jamais vu auparavant. Nous ne vous oublierons pas, nos pensées vous accompagnent où que vous alliez. :favorite: :'(


Référence : https://twitter.com/omega_fork/status/1 ... 3165265920

NumWorks Coque NumWorks édition limitée Septembre 2021 à gagner

New postby Admin » 27 Aug 2021, 21:10

13036Pour la rentrée 2019, NumWorks te sortait une coque collector en édition limitée pour ta calculatrice, la Macaremaths, illustrée tout en humour et talent sur le thème des Mathématiques. :bj:

Dans le même genre NumWorks a renouvelé l'expérience en mieux avec une coque en édition limitée chaque mois depuis le rentrée 2020. Tu as déjà eu nombre d'occasions d'habiller ta calculatrice de façon unique au monde :
1323013229
13573

Pour cette rentrée 2021 NumWorks garde les bonnes habitudes, nouvelle chance pour toi de compléter ta collection avec la coque en édition limitée du mois de Septembre 2021.

Tu peux dès maintenant tenter de gagner la coque de rentrée sur les différents comptes sociaux du constructeur :

Pour participer et peut-être gagner, c'est très simple. Il te suffit d'ici le 30 Septembre 2021 de :
  1. suivre, aimer ou t'abonner au compte du constructeur
  2. taguer ou identifier un ami ou une amie

Tirage au sort d'un ou d'une gagnante sur chaque compte social le 30 Septembre. N'hésite donc pas à participer sur les différents comptes sociaux, afin de maximiser tes chances. ;)

NumWorks Mise à jour application NumWorks Android/iOS v. 16.3.0

New postby Admin » 27 Aug 2021, 08:51

14499La dernière mise à jour 16.3.0 d'Epsilon, le firmware officiel de la calculatrice NumWorks est sorti il y a quelques semaines. La page de mise à jour de la calculatrice se garde bien de t'en avertir, mais l'installation de cette version verrouille les calculatrices NumWorks N0110 contre toute installation de firmware non officiel. :mj:

Un verrouillage à ce jour définitif sans aucun retour en arrière possible ; tu ne pourras plus installer le firmware Omega (fini donc le calcul littéral et le tableau périodique des éléments), ni ses applications additionnelles compatibles (fini donc le calcul formel avec KhiCAS, le tableur / feuille de calcul, ou encore les émulateurs Nintendo Game Boy et Nintendo NES). :'(

Pour cette rentrée 2021 la NumWorks N0110 perd donc ce qu'elle avait de plus génial, de plus intéressant et de plus cool, et ce sans aucune baisse de prix en contrepartie. :mj:

10889La NumWorks ce n'est pas juste une calculatrice, c'est aussi une application pour Android et iPhone / iPad. :)

Oui chez NumWorks a priori tu pourrais croire n'avoir aucune obligation de dépenser pour l'achat d'une calculatrice. Tu peux apparemment retrouver la totalité de ses fonctionnalités sur ton smartphone ou ta tablette, et même l'utiliser aux évaluations si ton enseignant te le permet. Ce n'est que peut-être pour les évaluations communes ou examens blancs si l'ensemble des enseignants du lycée ne sont pas du même avis, et épreuves terminales écrites sous le cadre national n'autorisant comme outil numérique que la seule calculatrice en mode examen, que tu n'auras besoin d'acheter la calculatrice.
En réalité ce n'est pas tout à fait exact, et opter pour l'application NumWorks à la place de la calculatrice NumWorks est même un très mauvais choix. L'application NumWorks pour Android et iPhone / iPad est justement très lourdement bridée sur des capacités particulièrement embêtantes pour une utilisation scolaire, chose bien trop souvent passée sous silence :
  • Aucune persistance de la mémoire : tout ce que tu as saisi sera perdu à la moindre fermeture de l'application ! :mj:
  • Pas de gestion directe du clavier virtuel de ton smartphone ou tablette dans l'application NumWorks. Pour la saisie de tes scripts Python, tu auras le choix entre utiliser le clavier affiché de la calculatrice, et copier-coller le texte d'un script saisi/ouvert dans une autre application.
  • Aucune possibilité de sauvegarder le contenu mémoire si tu effectues des saisies ou modifications dans l'application NumWorks :mj:
  • Aucune gestion du tactile, tu ne peux pas cliquer sur l'écran, juste sur le clavier, et donc aucun raccourci possible pour éviter d'avoir à cliquer les diverses combinaisons de touches clavier

Après, tu restes parfaitement libre de tes choix, nous les respectons tant qu'ils sont pris en connaissance de cause.

Nous t'annonçons donc la mise à jour aujourd'hui en version 16.3.0 de l'application NumWorks pour Android et iPhone / iPad.

Tu peux donc dès maintenant bénéficier sur ton smartphone ou ta tablette des dernières nouveautés apportées au logiciel NumWorks.

Liens :
Référence : https://www.numworks.com/fr/blog/logiciel-securise/

TI-Nspire CCC 2021 épisode 9: TI-Nspire CX rév≤N (batterie avec câble)

New postby critor » 26 Aug 2021, 19:20

Combien Consomme ma Calculatrice 2021

Épisode 9 - TI-Nspire CX révision ≤N (batterie avec câble)

index des épisodes

5409Nous sommes en plein QCC 2021 Universel, événement au cours duquel nous te publions et alimentons la base de données intégrale de nos classements de rentrée QCC organisés depuis la rentrée 2015.

Nous t'avons également lancé un événement dans l'événement, le CCC 2021, pour Combien Consomme ma Calculatrice.

1452314518Nous nous étions d'abord occupés de mesurer l'intensité tirée par les modèles à piles AAA. Pour cela nous avions ouvert le circuit en utilisant une fausse pile, bricolée à cette fin.

Puis nous étions passés aux modèles à batterie. Nous ne pouvions bien évidemment pas utiliser le même protocole. Nous avions retenu un testeur USB. Afin d'espérer éliminer la consommation due au circuit de recharge de la batterie, nous avions réalisé les mesures avec la batterie retirée, la calculatrice étant donc intégralement alimentée via son port USB.

Pour des intensités très faibles, calculatrices éteintes, vu les mesures obtenues nous doutions de la précision et donc fiabilité de ce testeur USB.
On pouvait toutefois supposer que les mesures avec calculatrice allumée était bien plus correctes, et probablement comparables d'un modèle à un autre.

Restait toutefois une inconnue. Même avec batterie déconnectée, le circuit de recharge ne viendrait-il pas perturber les mesures en question ?

1452514524Aujourd'hui donc, nous reprenons les mesures concernant les TI-Nspire CX de révision matérielle N ou inférieure (produites jusqu'en octobre 2015), c'est-à-dire celles utilisant une batterie avec câble.

Remercions cent20 qui a grandement contribué à la faisabilité de ce test. Il nous a en effet fort gracieusement envoyé une de ces batteries jamais utilisée et donc entièrement neuve, l'idéal pour le test. :favorite:

Nous nous munissons d'éléments permettant de lui adjoindre une rallonge. Il suffit pour cela de chercher de la connectique pour batteries LiPo à 4 câbles.

145291452814527
Rajoutons sur la voie d'alimentation de la rallonge en question un interrupteur inverseur :
  • position I pour une alimentation normale de la calculatrice
  • position II pour la connexion d'un ampèremètre sur les bornes externes

14531Et voici donc le protocole de mesure final.

Le même style de protocole serait réalisable pour les NumWorks, mais nous ne disposons pas encore des références de connectique batterie les concernant.

Pour les HP Prime et TI-Nspire CX plus récentes utilisant une batterie format smartphone Samsung, impossible de procéder de cette façon puisqu'elles sont dépourvues de câble. :#non#:
Il nous faudra trouver autre chose...

1451414513Les mesures sont effectuées à l'aide d'une TI-Nspire CX II. Nous utiliserons un capteur d'intensité Vernier, muni d'une prise BT-A (le standard historique de téléphonie analogique chez British Telecom). Nous le relions donc à la TI-Nspire CX II à l'aide de l'interface Vernier EasyLink.

Nous configurons la TI-Nspire CX II pour effectuer :
  • 50 mesures par seconde
  • pendant une durée de 29 secondes

Les mesures sont effectuées avec la batterie chargée à 100%

Nous allons effectuer les mesures sous différentes conditions :
  • Calculatrice éteinte (hors mode examen + en mode examen)
  • Calculatrice allumée mais inoccupée (hors mode examen + en mode examen)
  • Calculatrice en train d'effectuer un calcul suffisamment long (hors mode examen + en mode examen)
    Nous choisissons en mode degrés :
    $mathjax$\sum{\sqrt[3]{e^{sin\left(Arctan\left(x\right)\right)}}}$mathjax$

De plus, nous effectuerons les mesures sous différents réglages de la luminosité de l'écran :
  • maximal
  • minimal

Enfin, les mesures seront effectuées sur 4 calculatrices différentes, et nous retiendrons la moyenne :
  • TI-Nspire CX en révision matérielle C
  • TI-Nspire CX CAS en révision matérielle C
  • TI-Nspire CX CAS en révision matérielle D
  • TI-Nspire CX CAS en révision matérielle J

Bien meilleure précision ici (ou absence d'élément perturbateur), les mesures relevées sont comme tu peux le constater ci-contre extrêmement proches d'une calculatrice à une autre, confirmant la pertinence du regroupement de toutes les machines de révision N ou inférieure.

Éteintes, ces TI-Nspire CX tirent donc en moyenne 0,726 mA.

Une fois le mode examen activé, la diode examen s'active toutes les 2 secondes avec un double flash, ce qui génère des pics de consommation comme illustré sur le diagramme ci-contre. Cela fait monter l'intensité moyenne mesurée à 1,107 mA.

Voici le reste des mesures :
TI-Nspire CX rév. ≤N
hors
mode examen
en
mode examen
éclairage
écran
éteinte
0,829 mA
1,093 mA (+31,75%)
inoccupée
24,468 mA
73,163 mA
24,851 mA (+1,56%)
73,567 mA (+0,55%)
minimal
maximal
calcul
39,873 mA
89,189 mA
40,232 mA (+0,90%)
89,671 mA (+0,54%)
minimal
maximal

Comme sur certains modèles à écran couleur, nous n'avons pas moyen de rerégler la luminosité par défaut, nous retenons pour les comparaisons les mesures effectuées sous la luminosité maximale.

Tableau comparatif :
Accès QCC 2021 Universel

TI-Nspire QCC 2021 Universel épisode 10: Python turtle + compatibilité

New postby critor » 25 Aug 2021, 20:15

Quelle Calculatrice Choisir 2021 édition Universelle

Épisode 10 - Python turtle + compatibilité

5409Pour fêter les 10 ans de TI-Planet en cette rentrée 2021, nous te publions la base de données intégrale de nos classements de rentrée QCC organisés depuis la rentrée 2015.

Nous en profitons de plus pour te réaliser le travail titanesque d'étendre les tests aux modèles plus anciens :
  • toutes les calculatrices graphiques Texas Instruments (depuis la première TI-81 de 1990)
  • les calculatrices graphiques Casio de la génération Icon Menu Power Graphic (depuis 1996)
Ce qui donne pas moins de 163 modèles différents testés sous toutes leurs coutures, 10 ans de tests et découvertes à portée de clic ! :D

14526Aujourd'hui restons sur le Python et parlons turtle. Il y a justement du nouveau à ce sujet, puisque Texas Instruments vient tout juste de sortir un module turtle additionnel pour ses TI-Nspire CX II.

Mais qu'est-ce que c'est que turtle ? Les interpréteurs Python sur nos calculatrices peuvent offrir usuellement jusqu'à 3 types de modules de tracé :
  • tracé par pixels, habituellement propriétaire au constructeur
  • tracé dans un repère, plus ou moins proche du standard matplotlib.pyplot
  • et tracé relatif à la tortue, plus ou moins proche du standard turtle, le plus proche de ce qui a été pratiqué au collège avec le langage Scratch

Nous allons profiter de l'occasion pour faire d'une pierre deux coup. Nous allons à la fois découvrir ensemble le nouveau turtle des TI-Nspire CX II, et directement le comparer à ce qui existe déjà chez la concurrence, à savoir :
  • turtle pour TI-Nspire CX II
  • turtle sur Casio Graph 35+E II et Graph 90+E
  • turtle sur NumWorks
  • turtle via KhiCAS sur NumWorks et TI-Nspire CX
  • ce_turtl sur TI-83 Premium CE Edition Python, TI-84 Plus CE-T Python Edition et TI-84 Plus CE Python

Nous allons donc exécuter quelques scripts turtle et comparer leurs affichages à ce que donne le turtle Python standard sur ordinateur, et donc la plus ou moins grande facilité que tu auras à exécuter des scripts Python turtle conçus pour d'autres plateformes. ce_turtl était particulièrement mauvais sur ce dernier point ; nous allons donc voir si Texas Instruments a apporté davantage de soin à son module turtle pour TI-Nspire CX II.

Commençons déjà par détecter quelques problèmes bloquants avant l'exécution, et peut-être même les corriger. Voici notre tout nouveau Turtle Doctor : ;)
Code: Select all
_turtle_errors = 0

def _turtle_error(k):
  global _turtle_errors
  _turtle_errors |= 1 << k

# import turtle
try: #TI-83 Premium CE
  from ce_turtl import turtle
  turtle.clear()
  _turtle_error(0)
except ImportError:
  import turtle
  if not "forward" in dir(turtle):
    turtle = turtle.Turtle()

# can turtle be patched ?
_fix_turtle = True
try:
  def _fixcolorlist(c): return c
  def _fixcolorval(c): return c
  def _fixcolorstring(c): return c
  def _fixcolor(c): return turtle._fixcolorlist(turtle._fixcolorval(turtle._fixcolorstring(c)))
  turtle._fixcolorlist = _fixcolorlist
  turtle._fixcolorval = _fixcolorval
  turtle._fixcolorstring = _fixcolorstring
  turtle._fixcolor = _fixcolor
except:
  _fix_turtle = False

# test/fix color() + pencolor()
if not "pencolor" in dir(turtle):
  _turtle_error(1)
  if _fix_turtle: turtle.pencolor = turtle.color
if not "color" in dir(turtle):
  _turtle_error(2)
  if _fix_turtle: turtle.color = turtle.pencolor

# test color argument types
_color_types = 0
try:
  turtle.pencolor([0, 0, 0])
  _color_types |= 1 << 0
except: _turtle_error(4)
try:
  turtle.pencolor((0, 0, 0))
  _color_types |= 1 << 1
except: _turtle_error(5)
try:
  turtle.pencolor(0, 0, 0)
  _color_types |= 1 << 2
except: pass
try:
  turtle.pencolor("black")
  _color_types |= 1 << 3
except: _turtle_error(6)
_fix_color = not _color_types & 1 << 0 or not _color_types & 1 << 1 or not "colormode" in dir(turtle)

# fix list/tuple color argument
if _fix_turtle:
  if not _color_types & 1 << 0 and _color_types & 1 << 1:
    def _fixcolorlist(c): return type(c) is list and tuple(c) or c
    turtle._fixcolorlist = _fixcolorlist
  if not _color_types & 1 << 1 and _color_types & 1 << 0:
    def _fixcolorlist(c): return type(c) is list and list(c) or c
    turtle._fixcolorlist = _fixcolorlist

# fix color() + pencolor()
if _fix_turtle and _fix_color:
    turtle._color = turtle.color
    turtle._pencolor = turtle.pencolor
    if _color_types & 1 << 0 or _color_types & 1 << 1:
      def _color(*argv):
        if not(len(argv)): return turtle._color()
        turtle._color(turtle._fixcolor(argv[0]))
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        turtle._pencolor(turtle._fixcolor(argv[0]))
    else:
      def _color(*argv):
        if not(len(argv)): return turtle._color()
        c = turtle._fixcolor(argv[0])
        turtle._color(c[0], c[1], c[2])
      def _pencolor(*argv):
        if not(len(argv)): return turtle._pencolor()
        c = turtle._fixcolor(argv[0])
        turtle._pencolor(c[0], c[1], c[2])
    turtle.color = _color
    turtle.pencolor = _pencolor

# test/fix colormode()
_color_mode = 0
if not "colormode" in dir(turtle):
  _turtle_error(3)
  # test color mode
  try:
    turtle.pencolor([255, 0, 0])
    _color_mode = 255
  except: _color_mode = 1.0
  if _fix_turtle:
    turtle._color_mode = _color_mode
    def _colormode(*argv):
      if not(len(argv)): return turtle._color_mode
      if int(argv[0]) in (1, 255):
        turtle._color_mode = int(argv[0]) == 255 and 255 or 1.0
    turtle.colormode = _colormode
    if _color_mode == 255:
      def _fixcolorval(c): return int(turtle._color_mode) == 1 and type(c) in (list, tuple) and [int(c[k] * 255) for k in range(3)] or c
    else:
      def _fixcolorval(c):
        return turtle._color_mode == 255 and type(c) in (list, tuple) and [int(c[k] / 255) for k in range(3)] or c
    turtle._fixcolorval = _fixcolorval

# test/fix color strings
_colors_fix={"black":(0,0,0),"blue":(0,0,1),"green":(0,1,0),"red":(1,0,0),"cyan":(0,1,1),"yellow":(1,1,0),"magenta":(1,0,1),"white":(1,1,1),"orange":(1,0.65,0),"purple":(0.66,0,0.66),"brown":(0.75,0.25,0.25),"pink":(1,0.75,0.8),"grey":(0.66,0.66,0.66)}
for c in list(_colors_fix.keys()):
  try:
    turtle.pencolor(c)
    _colors_fix.pop(c)
  except: pass
turtle.pencolor((0, 0, 0))
if len(_colors_fix):
  if _color_types & 1 << 3:
    _turtle_error(7)
  if _fix_turtle:
    def _fixcolorstring(c):
      if type(c) is str and c in _colors_fix:
        c = _colors_fix[c]
        if turtle.colormode() == 255:
          c = [int(c[k] * 255) for k in range(3)]
      return c
    turtle._fixcolorstring = _fixcolorstring

# test/fix circle(,)
try: turtle.circle(0,0)
except:
  _turtle_error(8)
  if _fix_turtle:
    turtle._circle = turtle.circle
    def _circle(r, a=360): turtle._circle(r)
    turtle.circle = _circle

if not "write" in dir(turtle):
  _turtle_error(9)
  if _fix_turtle:
    def _write(s): pass
    turtle.write = _write

if not "pensize" in dir(turtle):
  _turtle_error(10)
  if _fix_turtle:
    def _pensize(s): pass
    turtle.pensize = _pensize

def turtle_diags():
  print("Type: " + str(type(turtle)))
  print("Patchable: " + (_fix_turtle and "yes" or "no"))
  errors_msg = (
    "No <import turtle>",
    "No pencolor()",
    "No color()",
    "No colormode(): " + str(_color_mode),
    "No color as list",
    "No color as tuple",
    "No color as string",
    "Missing colors strings: ",
    "No circle(,angle)",
    "No write()",
    "No pensize()",
  )
  errors = 0
  for k in range(len(errors_msg)):
    if _turtle_errors & 1 << k:
      errors += 1
      msg = "Err " + str(k) + ": " + errors_msg[k]
      if k == 7:
        msg += str(len(_colors_fix)) + " " + str(tuple(_colors_fix.keys()))
      print(msg)
  print(str(errors) + " error" + ((errors > 1) and "s" or ""))

Le but de Turtle Doctor et donc d'anticiper les erreurs, afin que les scripts qui vont suivre puissent bien afficher quelque chose d'utile.

Par exemple, Turtle Doctor ne détecte a priori strictement aucun problème bloquant sur la NumWorks :bj:

Aucun problème non plus avec KhiCAS pour NumWorks et TI-Nspire CX ! :bj:

Sur Casio Graph 35+E II et Graph 90+E, quelques détails :
  • absence de la méthode .color()
  • absence de la méthode .colormode()
Mais ici, Turtle Doctor détecte que le module turtle est modifiable : on peut le patcher à chaud (à chaque exécution) afin de corriger. :D

Le but des corrections n'est pour le moment pas d'obtenir quelque chose d'identique au standard, mais juste de permettre l'exécution des scripts qui vont suivre :
  • Nous choisissons de créer une méthode .color() synonyme de .pencolor()
  • Et pour .colormode(), outre la création de la méthode, il nous faut détecter le format de coordonnées de couleurs attendu par le module, afin de convertir le cas échéant. La méthode .colormode() lorsque présente permet de basculer entre les 2 systèmes de coordonnées suivants :
    • mode 255 : couleurs RGB avec chaque composante prenant une valeur entière de 0 à 255
    • mode 1.0 : couleurs RGB avec chaque composante prenant une valeur flottante de 0 à 1
    Le module turtle travaille en fait en format 1.0, mode qu'il est donc impossible de modifier ici.

Voici maintenant donc enfin turtle pour TI-Nspire CX II.

Une fois installé correctement dans le dossier /PyLib/ comme expliqué, les fonctions offertes par turtle sont alors rajoutées au menu.

Attention toutefois, comme tout module présent dans le dossier /PyLib/, turtle ne sera pas disponible en mode examen. :#non#:

Le module s'importe de la façon suivante, qui est bien une des façons standard :
Code: Select all
from turtle import Turtle
turtle = Turtle()


Si jusqu'à présent les quelques écarts avec le standard pouvaient être qualifiés de quelques détails de cas particuliers, ici cela commence à faire beaucoup. Pas moins de 4 problèmes sont détectés dont un majeur :
  • absence de la méthode .colormode(), avec un fonctionnement bloqué en mode 255
  • absence de gestion du 2ème argument de la méthode .circle() pour tracer un arc de cercle
  • et pire, pour les paramètres de couleur :
    • refus des paramètres de type liste, n'accepte que des tuples - est-ce un bug ?... :(
    • accepte les paramètres de type chaîne de caractères, mais ignore plusieurs codes de couleur usuels : "pink", "grey", "brown", "purple"
Heureusement ici, le module turtle importé est modifiable à chaud et peut donc être librement modifié et donc corrigé. En approfondissant la chose, la méthode Turtle Doctor devrait même permettre de pouvoir atteindre une conformité quasi parfaite au standard.

Et enfin nous avons le ce_turtl pour les éditions Python des TI-83 Premium CE et TI-84 Plus CE. Comme annoncé hélas, c'est une véritable catastrophe niveau conformité au standard. Pas moins de 8 erreurs sont anticipées :
  • déjà, de par son nom il ne s'importe pas de façon standard, c'est-à-dire qu'aucune des 3 méthode suivantes ne fonctionne :
    import turtle, from turtle import *, ou encore
    Code: Select all
    from turtle import Turtle
    turtle = Turtle()
  • absence de la méthode .pencolor(), qui est remplacée ici par .color()
  • absence de la méthode .colormode(), avec un fonctionnement bloqué en mode 255
  • absence de la méthode .write() pour écrire du texte
  • absence de gestion du 2ème argument de la méthode .circle() pour tracer un arc de cercle
  • et pire, pour les paramètres de couleur, refus de toute les formes standard : aussi bien liste que tuple ou chaîne de caractère. La méthode color() attend non pas 1 mais 3 arguments, soit un argument par composante. :mj:
Le module turtle importé est certes modifiable à chaud et la méthode Turtle Doctor va fonctionner pour débloquer l'exécution. Toutefois pour une conformité au standard il manquerait encore beaucoup de code, et malheureusement comme nous avons déjà vu nous sommes extrêmement à l'étroit niveau mémoire de tas (heap) Python sur ces calculatrices. Nous sommes déjà à peine à quelques lignes de l'erreur de mémoire, aller plus loin dans cette voie n'est pas envisageable sur ces modèles. :'(

Pour comparer, il y a malgré tout moyen d'avoir du code d'importation fonctionnant à la fois sur l'ensemble de ces plateformes et sur ordinateur. Par exemple :
Code: Select all
try: # TI-83PCE/84+CE
  from ce_turtl import turtle
  turtle.clear()
except ImportError:
  import turtle # multiplateformes
  if not "forward" in dir(turtle): # TI-Nspire CX II
    turtle = turtle.Turtle()

1107511073Voilà, c'est parti pour les tests de conformité du module turtle standard, ainsi que la compatibilité entre différentes calculatrices graphiques.

Nous allons pour cela prendre plusieurs exemples et lancerons le même code sur différents modèles.

On commence par une petite rosace ; tout possesseur de Graph 35+E II sait que Casio adore ça : ;)
ordi
NumWorks
Graph 90+E
Graph 35+E II
TI-Nspire CX II
turtle
TI-83PCE/84+CE
ce_turtl

Code: Select all
from turtldoc import *

turtle.speed(0)
turtle.pensize(1)
for i in range(12):
  turtle.left(30)
  for i in range(8):
    turtle.forward(30)
    turtle.left(45)

try: turtle.show() #TI-83 Premium CE
except: pass

Petit léger détail, le turtle.pensize(1) n'est respecté ni par KhiCAS ni par ce_turtl.

Ceci mis à part, le code passe ici sans problème. :)

Poursuivons avec la fractale de Koch :
ordi
NumWorks
Graph 90+E
Graph 35+E II
TI-Nspire CX II
turtle
TI-83PCE/84+CE
ce_turtl

Code: Select all
from turtldoc import *

def koch(n, l):
  if n==0:
    turtle.forward(l)
  else:
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)
    turtle.right(120)
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)

turtle.speed(0)
turtle.pensize(1)
turtle.pencolor("blue")
turtle.penup()
turtle.goto(-180, -50)
turtle.pendown()
koch(4, 360)

try: turtle.show() #TI-83 Premium CE
except: pass

Pas de nouveau problème ici. :)

Passons maintenant aux flocons de Koch :
ordi
NumWorks
Graph 90+E
Graph 35+E II
TI-Nspire CX II
turtle
TI-83PCE/84+CE
ce_turtl

Code: Select all
from turtldoc import *

def koch(n, l):
  if n<=0:
    turtle.forward(l)
  else:
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)
    turtle.right(120)
    koch(n - 1, l / 3)
    turtle.left(60)
    koch(n - 1, l / 3)

def flock(n, l):
  koch(n, l)
  turtle.right(120)
  koch(n, l)
  turtle.right(120)
  koch(n, l)

turtle.speed(0)
l=80
turtle.pensize(1)
turtle.penup()
turtle.goto(105,3)
turtle.left(120)
turtle.pendown()
flock(3, l)
turtle.left(120)

turtle.penup()
turtle.goto(105,-10)
turtle.right(60)
turtle.pendown()
turtle.pencolor("orange")
flock(4, l)
turtle.right(60)

turtle.pensize(2)
turtle.penup()
turtle.goto(5,45)
turtle.right(60)
turtle.pendown()
turtle.pencolor("blue")
flock(2, l)
turtle.right(60)

turtle.penup()
turtle.goto(-100,17)
turtle.left(120)
turtle.pendown()
turtle.pencolor("red")
flock(0, l)
turtle.left(120)

turtle.pensize(3)
turtle.penup()
turtle.goto(-100,-5)
turtle.right(60)
turtle.pendown()
turtle.pencolor("green")
flock(1, l)
turtle.right(60)

turtle.penup()
turtle.forward(400)

try: turtle.show() #TI-83 Premium CE
except: pass

Pour ce que l'on obtient pas de problème de tracé avec le module turtle de KhiCAS, le problème vient d'autre chose. Ce module turtle a l'air d'être extrêmement gourmand, arrivant à déclencher une erreur de mémoire en cours d'exécution alors que d'autres modèles avec un heap Python absolument ridicule en comparaison s'en sortent parfaitement.

On comprend mieux ici le problème du .pensize() sur ce_turtl et KhiCAS. Malgré les réglages différents tous les flocons sont ici trop épais d'1 pixel, il y a visiblement un décalage.
Mais notons justement par rapport à ce_turtl, que notre script Turtle Doctor a visiblement correctement injecté l'interception des paramètres de couleurs passés sous la forme de chaînes de caractères.

Nous arrivons maintenant à un soleil :
ordi
NumWorks
Graph 90+E
Graph 35+E II
TI-Nspire CX II
turtle
TI-83PCE/84+CE
ce_turtl

Code: Select all
from turtldoc import *

from math import exp

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(1.0)
for i in range(36):
  turtle.pencolor([exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)])
  for i in range(1, 5):
    turtle.forward(60)
    turtle.right(90)
  turtle.right(10)

try: turtle.show() #TI-83 Premium CE
except: pass

Notons que Turtle Doctor a réussi à parfaitement corriger les paramètres de couleurs sur ce_turtl, tuples et listes étant maintenant utilisables ! :bj:

Poursuivons avec une coquille d'escargot :
ordi
NumWorks
Graph 90+E
Graph 35+E II
TI-Nspire CX II
turtle
TI-83PCE/84+CE
ce_turtl

Code: Select all
from turtldoc import *

from math import exp

turtle.speed(0)
turtle.pensize(1)
turtle.colormode(1.0)
turtle.penup()
turtle.goto(0, -20)
turtle.pendown()
for i in range(36):
  turtle.pencolor([exp(-.5 * ((i - k) / 12)**2) for k in (6, 18, 30)])
  turtle.circle(50 - i)
  turtle.right(10)

try: turtle.show() #TI-83 Premium CE
except: pass

ce_turtl nous fait ici une véritable catastrophe. Le problème vient de la méthode .circle() qui ne respecte pas du tout le standard. Au lieu de tracer un cercle qui passe par la position de la tortue, elle trace un cercle qui prend pour centre la position de la tortue. :mj:

Passons maintenant aux triangles de Sierpiński :
ordi
NumWorks
Graph 90+E
Graph 35+E II
TI-Nspire CX II
turtle
TI-83PCE/84+CE
ce_turtl

Code: Select all
from turtldoc import *

def sierp(n, l):
  if n == 0:
    for i in range (0, 3):
      turtle.forward(l)
      turtle.left(120)
  if n > 0:
    sierp(n - 1, l / 2)
    turtle.forward(l / 2)
    sierp(n - 1, l / 2)
    turtle.backward(l / 2)
    turtle.left(60)
    turtle.forward(l / 2)
    turtle.right(60)
    sierp(n - 1, l / 2)
    turtle.left(60)
    turtle.backward(l / 2)
    turtle.right(60)

turtle.speed(0)
turtle.pensize(1)
turtle.penup()
turtle.backward(109)
turtle.left(90)
turtle.backward(100)
turtle.right(90)
turtle.pendown()
turtle.pencolor("red")
sierp(6, 217)
turtle.penup()
turtle.forward(400)

try: turtle.show() #TI-83 Premium CE
except: pass

Et mince, c'est justement le piège qui fait trébucher pas mal de modèles.
Ici encore, après avoir commencé un tracé parfait, KhiCAS se met à manquer de mémoire.

La Casio Graph 90+E s'en sort fort honorablement jusqu'à présent, non ? Dédions-lui un tableau :
ordi
NumWorks
Graph 90+E
Graph 35+E II
TI-Nspire CX II
turtle
TI-83PCE/84+CE
ce_turtl

Code: Select all
from turtldoc import *

turtle.speed(0)
turtle.forward(40)
turtle.backward(100)
turtle.left(90)
turtle.forward(30)
turtle.right(60)
turtle.forward(60)
turtle.right(30)
turtle.forward(30)
turtle.penup()
turtle.forward(18)
turtle.right(90)
turtle.forward(60)
turtle.pendown()
turtle.right(30)
turtle.backward(30)
turtle.right(60)
turtle.forward(60)
turtle.pencolor("red")
turtle.penup()
turtle.goto(80,40)
turtle.right(140)
turtle.pendown()
turtle.circle(30)
turtle.penup()
turtle.goto(105,50)
turtle.pencolor("green")
turtle.pendown()
turtle.circle(-50)
turtle.penup()
turtle.pencolor("red")
turtle.right(21)
turtle.goto(60,20)
turtle.pendown()
turtle.circle(40,60)
turtle.penup()
turtle.pencolor("blue")
turtle.goto(-50,15)
turtle.setheading(0)
turtle.pendown()
turtle.write("CASIO")

try: turtle.show() #TI-83 Premium CE
except: pass

Et mince, c'est justement le piège qui fait trébucher pas mal de modèles.
Rapidement, très léger détail sur les Casio Graph 35+E II et Graph 90+E. La méthode .write() prend les coordonnées indiquées comme coin supérieur gauche du texte affiché, alors que le standard est de les prendre comme coin inférieur gauche.

Pour les modules qui ne gèrent pas l'appel .circle(rayon, angle) les arcs de cercles sont ici remplacés par des cercles, ce qui naturellement perturbe le reste du tracé.

Le cas KhiCAS est toutefois plus surprenant, cet appel étant bien géré... :#roll#:

Le nouveau turtle TI-Nspire CX II est une superbe réalisation. On apprécie particulièrement la grille et le repère entièrement configurables, une véritable valeur ajoutée ! :bj:

Sur la conformité au standard turtle ce n'est certes pas le meilleur, même si cela reste honorable. Il y a bien pire et plus grave que cela. Texas Instruments a déjà fait un fort bel effort relativement à la catastrophe qu'était ce_turtl. :)

Nous ignorons si Texas Instruments poursuivra ses efforts, mais à défaut nous avons quand même une excellente nouvelle. Bien que l'on n'ait pas accès au code source du module turtle TI-Nspire CX II celui-ci a le gros avantage de nous présenter des éléments modifiables à chaud. Comme de plus nous bénéficions ici d'un heap Python extrêmement généreux, pas moins de 2 Mo soit l'un des plus larges tous modèles concurrents confondus, une conformité parfaite au standard est bel et bien envisageable, pourvu que quelqu'un se donne le temps de creuser la question. :bj:

En attendant donc mieux, les différentes solutions Python turtle disposent désormais dans nos tableaux d'un indice de compatibilité / conformité au standard, basé sur les tests précédents :

-
Search
-
Social TI-Planet
-
Featured topics
Grand Concours 2024-2025 - Programmation Python
Comparaisons des meilleurs prix pour acheter sa calculatrice !
"1 calculatrice pour tous", le programme solidaire de Texas Instruments. Reçois gratuitement et sans aucune obligation d'achat, 5 calculatrices couleur programmables en Python à donner aux élèves les plus nécessiteux de ton lycée. Tu peux recevoir au choix 5 TI-82 Advanced Edition Python ou bien 5 TI-83 Premium CE Edition Python.
Enseignant(e), reçois gratuitement 1 exemplaire de test de la TI-82 Advanced Edition Python. À demander d'ici le 31 décembre 2024.
Aidez la communauté à documenter les révisions matérielles en listant vos calculatrices graphiques !
12345
-
Donations / Premium
For more contests, prizes, reviews, helping us pay the server and domains...
Donate
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 Calculatrices à acheter chez Calcuso
-
Stats.
1055 utilisateurs:
>1013 invités
>33 membres
>9 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)