π
<-

Casio Découverte et comparaison emballages fx-CG100 UK et USA

New postby critor » 24 Apr 2025, 22:54

203062164320096Pour la rentrée 2024 en France, Casio a renouvelé son milieu de gamme graphique couleur. La Graph 90+E de rentrée 2017 a ainsi été remplacée par la Graph Math+.

Si la France a eu droit à la primeur avec ce premier modèle de famille CG Classwiz, le reste du monde ne sera pas oublié mais pour la rentrée 2025. De façon similaire :
  • en Australie, la fx-CG50AU de rentrée 2018 va être remplacée par la fx-1AU Graph
  • dans le reste du monde, la fx-CG50 de rentrée 2017 va être remplacée par la fx-CG100
La fx-CG100 vient tout juste de sortir en Amérique du Nord et d'être annoncée comme bientôt disponible au Royaume-Uni de Grande Bretagne et d'Irlande du Nord.

22226Casio a envoyé des échantillons à certains enseignants, et nous avons donc le plaisir de découvrir les emballages…

Une première photo nous provient d'AdamCreenUK. L'emballage, visiblement spécifique au Royaume-Uni, nous met en avant les nouveaux modes examens pour le Royaume-Uni et le Baccalauréat International, nous annonce 3 ans de garantie, et nous apprend que Casio est la première marque de calculatrices dans le pays.

22227L'emballage américain est donc évidemment différent, avec une photo qui nous provient ici de TheCalcLife. Ici l'emballage met en avant l'autorisation aux examens américains (AP, SAT, PSAT/NMSQT, ATC et ici encore Baccalauréat International), l'écran couleur, les graphes 3D, la programmation Python

L'emballage t'indique de plus que la fx-CG100 se positionne en tant que concurrente de la TI-84 Plus CE Python, t'invitant à les comparer, ce que nous te permettons justement de faire en ligne.

Sources : https://www.youtube.com/shorts/wzikyqApkC8 + https://old.reddit.com/r/calculators/co ... row_42425/

Casio Annonce fx-CG100 au Royaume-Uni et premier prix

New postby critor » 24 Apr 2025, 18:11

203062164320096Pour la rentrée 2024 en France, Casio a renouvelé son milieu de gamme graphique couleur. La Graph 90+E de rentrée 2017 a ainsi été remplacée par la Graph Math+.

Si la France a eu droit à la primeur avec ce premier modèle de famille CG Classwiz, le reste du monde ne sera pas oublié mais pour la rentrée 2025. De façon similaire :
  • en Australie, la fx-CG50AU de rentrée 2018 va être remplacée par la fx-1AU Graph
  • dans le reste du monde, la fx-CG50 de rentrée 2017 va être remplacée par la fx-CG100
Après des mois d'annonces, la fx-CG100 vient tout juste d'être lancée en Amérique du Nord.

Fort étrangement, la fx-CG100 a jusqu'ici fait l'objet de communications de la part de Casio uniquement en Amérique du Nord.

C'était d'autant plus étonnant, sachant que nous avions remarqué lors du test de son émulateur que, par rapport à la Graph Math+ française, la fx-CG100 avait fait l'objet de développements spécifiques à certains de nos voisins européens :
  • nouveaux réglages régionaux et modes examen dédiés pour le Royaume-Uni et le Portugal
  • réglage régional et mode examen prévu pour les Pays-Bas (mentions rajoutées dans l'image système, mais non encore accessible dans les menus)
  • langue Allemande prévue (ensemble des messages en Allemand rajoutés dans l'image système, mais non encore activables par le menu)
C'était au point où nous nous demandions si la fx-CG100 allait bien sortir en Europe pour la rentrée 2025...

21643Et bien il y a du nouveau. Ce n'est pas encore l'Union Européenne, mais la fx-CG100 va bien arriver en Europe.

Casio vient en effet tout juste de l'annoncer comme bientôt disponible pour le Royaume-Uni de Grande Bretagne et d'Irlande du Nord.

La chaîne YouTube officielle Casio Education UK vient d'une part de publier deux playlists dédiées, traitant entre autres du réglage régional que nous t'avions déjà présenté.

D'autre part la boutique officielle de Casio vient tout juste de rajouter la page produit de la fx-CG100. Même si la calculatrice ne peut pas encore être commandée, un premier prix de 140£ nous y est indiqué (ou précisément 139.99£).

Casio Lancement officiel fx-CG100 et premier prix aux USA

New postby critor » 24 Apr 2025, 17:19

203062164320096Pour la rentrée 2024 en France, Casio a renouvelé son milieu de gamme graphique couleur. La Graph 90+E de rentrée 2017 a ainsi été remplacée par la Graph Math+.

Si la France a eu droit à la primeur avec ce premier modèle de famille CG Classwiz, le reste du monde ne sera pas oublié mais pour la rentrée 2025 :
  • en Australie, la fx-CG50AU équivalente de rentrée 2018 va être remplacée par la fx-1AU Graph ;
  • dans le reste du monde, la fx-CG50 équivalente de rentrée 2017 va être remplacée par la fx-CG100
La disponibilité de ces nouveaux modèles CG Classwiz serait donc désormais imminente…

21643Et bien aujourd'hui c'est le grand jour du lancement officiel, du moins pour l'Amérique du Nord !

Casio America vient de rajouter la page produit de la fx-CG100 à sa boutique officielle. Le nouveau modèle peut dès maintenant être acheté et nous avons un premier prix grand public, 120$ (ou plus précisément 119.99$).

Cela peut paraître beaucoup vu de France mais c'est à remettre dans le contexte du pays ; pour une calculatrice couleur de milieu de gamme comme sa concurrente TI-84 Plus CE Python, ce n'est pas délirant en Amérique du Nord.
Une remise en perspective permet en passant de mieux saisir comment nous sommes privilégiés en France, avec la chance d'avoir de superbes calculatrices graphiques couleur accessibles à des prix à seulement deux chiffres !

Source : https://www.casio.com/us/scientific-cal ... e=tiplanet

TI-z80 KhiCAS, appli intégrée Maths-Science pour TI-83PCE/84+CE

New postby critor » 24 Apr 2025, 08:43

22175Nous fêtons cette année les 25 ans de Xcas. Xcas est un logiciel libre (licence GPL) et gratuit développé en France par Bernard Parisse, enseignant-chercheur à l'Institut Fourrier, dépendant de l'Université Grenoble Alpes. Il s'agit d'un logiciel intégré de Mathématiques et de Sciences, s'appuyant sur le moteur de calcul formel Giac du même auteur.

Disponible dans des versions pour ordinateurs Windows, macOS et Linux, Xcas bénéficie également d'une version en ligne tournant directement dans le navigateur Internet et utilisable ainsi entre autres sur smartphones et tablettes.

Mais ce n'est pas tout, Xcas bénéficie également d'éditions spéciales tout aussi gratuites pour de nombreuses calculatrices graphiques, sous le nom de KhiCAS :
Un formidable geste pour l'égalité, permettant notamment aux élèves et étudiant(e)s ayant opté pour des modèles de milieu de gamme de bénéficier gratuitement entre bien d'autres choses des mêmes fonctionnalités de calcul littéral et formel que les constructeurs réservent habituellement aux seuls modèles haut de gamme avec des prix à 3 chiffres ! Un geste remarquable également pour l'accessibilité et la démocratisation du calcul formel dès le lycée !
20925Mais cette année nous fêtons également les 10 ans de la TI-83 Premium CE, un modèle disruptif ayant complètement changé l'image dans la calculatrice graphique au lycée, offrant en effet l'écran couleur 16 bits pour la toute première fois à des prix abordables à seulement 2 chiffres !

Grâce à Texas Instruments, ce sont des milliers de lycéens et lycéennes qui ont ainsi pu s'initier à la programmation graphique couleur sur TI-83 Premium CE à partir de la rentrée 2015 !
22145Pour fêter ce double anniversaire hautement symbolique, Bernard Parisse t'a préparé pour cette année quelque chose d'exceptionnel, une édition de KhiCAS pour TI-83 Premium CE (et TI-84 Plus CE hors de France), en bêta-test depuis quelques mois.

KhiCAS CE constitue un double exploit technique majeur :
  • d'une part c'est de loin le projet le plus conséquent jamais créé pour les calculatrices TI CE, ayant nécessité nombre d'astuces techniques côté Toolchain CE
  • d'autre part, il s'agit de la toute première adaptation du code Xcas pour un processeur (Zilog eZ80) 8 bits (au lieu des 32/64 bits habituels)

KhiCAS n'est pas le premier programme sur CE à proposer du calcul symbolique (il existe par exemple PineappleCAS et CASymba), mais c'est clairement le plus complet et puissant à ce jour. Explorons ça en détails…




A) Prérequis :

Go to top

2214622147Avant d'installer KhiCAS CE, commençons déjà par les prérequis.

Dans l'intention fort louable de ne pas perturber le déroulement des examens 2025 ni mettre Texas Instruments en difficulté, notamment hors de France sur TI-84 Plus CE où les fonctionnalités de calcul exact, littéral et formel sont souvent strictement interdites, précisons que KhiCAS CE ne se lancera pas sur les TI-84 Plus CE munies de la dernière version système (actuellement 5.8.2). Il te faut donc à ce jour :
  • soit une TI-83 Premium CE sur n'importe quelle version
  • soit une TI-84 Plus CE faisant tourner une version 5.8.1 ou inférieure

Les institutions qui pour certains examens étrangers ou internationaux exigent systématiquement la mise à jour des calculatrices vers la dernière version disponible peuvent ainsi être tranquilles, l'installation de la dernière mise à jour sur TI-84 Plus CE empêche l'utilisation de KhiCAS CE.


B) Installation :

Go to top

KhiCAS CE n'adopte pas le format programme assembleur (le type de variable programme étant limité à 64Ko de contenu ce qui est hautement insuffisant), mais le format application, une énorme application de 2,8 Mo, un record absolu !
Et rappelons que la capacité maximale de la mémoire de stockage (dite d'archive) est juste de 3,014 Mo sur TI-84 Plus CE et pire 2,948 Mo sur TI-83 Premium CE.

De plus, si l'on peut certes créer des applications via quelques péripéties techniques, il n'est pas possible de les signer, car nous ne disposons pas de la clé privée de Texas Instruments. C'est-à-dire que la calculatrice n'en acceptera pas l'installation si on procède comme avec les applications officielles. Il faut donc t'attendre à une procédure un peu inhabituelle, mais tout a été fait pour te la simplifier au maximum.

221502214922148
  1. 👉 Donc, première chose à faire, tu dois effacer tout le contenu de la mémoire d'archive :
    2nd
    +
    7
    3
    2

    (si tu as des données importantes sur ta calculatrice, veille bien à les sauvegarder avant)

    2215522154Problème après ça, normalement tu n'atteins pas tout à fait les 2,8 Mo d'espace libre nécessaire en mémoire d'archive.

    En effet, apparemment aucun des menus de réinitialisation de la calculatrice n'efface les langues.

  2. 2215722156👉 Il te faut donc aller dans le gestionnaire de mémoire avec
    2nd
    +
    2
    1
    et les effacer manuellement une par une via la touche
    suppr
    ou
    del
    .
    Et maintenant, niveau espace libre, c'est bon !

  3. 2215822159👉 C'est le moment de récupérer l'unique fichier d'installation de KhiCAS CE, et de l'envoyer à la calculatrice à l'aide du logiciel TI-Connect CE pour Windows ou pour Mac. Au choix :

  4. 2216022161👉 INST est le programme assembleur d'installation de KhiCAS qu'il va te falloir lancer. Si ta calculatrice fait tourner une version système 5.5.1 ou supérieure, cela se fait via "arTIfiCE" dans l'application CabriJr qu'il te suffit de rajouter maintenant dans le tout petit espace restant.

  5. 221742217322172👉 Si tu dois donc passer par l'application CabriJr, il te suffit d'y appeler le menu F1 via la touche
    f(x)
    ou
    y=
    , puis d'y choisir d'ouvrir ARTIFICE. Et dans le menu qui s'affiche alors, tu choisis de lancer INST.

  6. 22165👉 Le programme INST t'invite alors à taper
    entrer
    ou
    enter
    pour démarrer l'installation, qui dure quelques dizaines de secondes. Un compte à rebours t'en indique alors la progression.
    22166221672216822169


  7. 221762214822170👉 Une fois l'installation terminée, comme l'écran t'y invite tu dois :
    • appuyer sur une touche pour redémarrer la calculatrice
    • puis vider intégralement la mémoire RAM via
      2nd
      +
      7
      1
      2

  8. 👉 Enfin, l'installateur ne nettoie pas tout à fait l'ensemble des variables utilisées pour l'installation. Déjà qu'il ne te reste plus beaucoup d'espace, n'aggravons pas les choses... Rends-toi dans dans le gestionnaire de mémoire avec avec
    2nd
    +
    2
    1
    pour y supprimer manuellement à l'aide de la touche
    suppr
    ou
    del
    les éventuelles variables AppIns restantes :
    2216222163
    2217722178

Si ta calculatrice fait tourner une version 5.5.1 ou supérieure, et que tu as besoin de pouvoir lancer des programmes assembleur, tu as maintenant suffisamment de place pour réinstaller CabriJr (100K) puis ensuite arTIfiCE. Enfin, entre Cesium et AsmHook, tu devrais peut-être choisir ce dernier qui occupe beaucoup moins de place.

Quant aux autres applications officielle de Texas Instruments il est clair que tout ne rentrera pas, mais bonne nouvelle l'application KhiCAS CE va te permettre d'en remplacer la plupart avec des possibilités supérieures


C1) Interface et horloge :

Go to top

22206Commençons par faire connaissance. Une fois lancée, l'interface de l'application KhiCAS s'organise en 3 zones. De haut en bas, nous avons :
  • Une barre d'état en haut d'écran
  • La vue affichée (par défaut l'historique des calculs)
  • Un menu contextuel en bas d'écran, relatif à la vue affichée, et dont les onglets se déroulent intuitivement avec les 5 touches
    F1
    à
    F5
    en haut du clavier

2220922210Gros avantage par rapport à l'interface officielle, particulièrement lors d'un devoir ou d'une épreuve en temps limité, tu as droit à l'affichage de l'heure dans la barre d'état. Il te suffit si besoin de la régler une seule fois avec la touche
mode
. C'est particulièrement utile dans un contexte où les montres sont de plus en plus suspectées d'être connectées, et ainsi de plus en plus interdites.


C2) Algèbre et analyse :

Go to top

221822218022179Pour le calcul littéral de niveau lycée, tu trouveras l'essentiel des fonctions dans les menus algèbre (
F1
) et analyse (
F2
).

Alternativement, tu peux également saisir les noms de fonctions directement au clavier. Dans ce cadre, si jamais tu avais besoin de caractères spéciaux non présents au clavier, tu peux y avoir accès via le menu chartab (
F4
).

2219722208Tu trouves donc entre autres de quoi développer/factoriser tes expressions, ou encore résoudre des équations.

Comme tu peux le voir, KhiCAS CE fonctionne en écriture ligne. Toutefois, tu peux sur demande consulter l'écriture naturelle d'une expression, aussi bien pour une saisie qu'un résultat. Il te suffit tout simplement de remonter dans l'historique de calcul avec la touche
, puis une fois la bonne expression sélectionnée de taper
.

En passant donc aucun besoin de remettre l'application officielle PlySmlt2 pour les polynômes et systèmes d'équations, la fonction solve() de KhiCAS fait tout ça, en mieux, et même bien plus encore !

2220122200Concernant les fonctions, tu peux en obtenir très facilement dérivées, primitives, intégrales et limites.

22204222022220322205Encore mieux, la fonction tabvar() te permet d'obtenir l'étude d'une fonction avec production d'un tableau de variations ! 👍


C3) Représentations graphiques :

Go to top

22181Si tu as besoin maintenant de représentations graphiques de fonctions ou séries statistiques, cela se passe dans le menu graphes (
F3
)
.
Cela te fournit les fonctionnalités des applications officielles Inequalz, Transfrm et Conics et bien plus encore !
2221122212222132221422215


C4) Menus de fonctions :

Go to top

En réalité les menus de bas d'écran ne te présentent qu'une toute petite sélection de fonctions offertes par KhiCAS CE, les onglets étant forcément limités à 5 catégories vu la conception du clavier.

2221622188Mais tu peux avoir accès à un éventail beaucoup plus large de fonctions via le menu
math
, organisé par catégories. Et tu peux avoir la liste de l'intégralité des fonctions disponibles en accédant au menu catalogue via
2nd
0
.


C5) Bibliothèque de constantes physiques :

Go to top

22189Dans le menu
math
justement, on trouve une bibliothèque de 27 constantes physiques dont tu peux récupérer les valeurs accompagnées de leurs unités pour tes calculs. Bien mieux donc que les 15 constantes de l'application officielle SciTools.
221902219122192


C6) Unités :

Go to top

221952219422193On trouve également au menu
math
une catégorie dédiée aux unités. Précisons que l'application SciTools ne supportait que 91 unités. Ici, même si le menu de KhiCAS ne liste que 56 unités, en fait bien davantage d'unités sont supportées, le menu ne constituant qu'un tout petit échantillon à titre d'exemple. En effet il y a une véritable gestion des unités en tant qu'objet par le moteur de calcul :
  • tu es libre de préfixer (système SI) chaque unité comme bon te semble
  • et de composer librement une unité en faisant intervenir d'autres unités
… et ce, même si l'unité obtenue n'était pas listée au menu ! 👍


C7) Principe des sessions :

Go to top

22183Précisons que par défaut, comme indiqué dans la barre de titre, KhiCAS CE utilise la variable session pour charger et sauvegarder la session en cours (c'est-à-dire tout ce que tu fais : historique de calcul, variables et fonctions définies, etc.).
Mais le menu Fichier (
F6
) te permet si tu le souhaites d'utiliser d'autres noms de variables.
Cela te permet de pouvoir basculer à tout moment sur ta calculatrice entre plusieurs sessions KhiCAS.
Une formidable possibilité permettant d'avancer en parallèle dans la résolution d'exercices différents (exercices indépendants d'un sujet, devoirs données par plusieurs professeurs ou bien pour des dates différentes, etc.). Ici aucun besoin de tout redéfinir quand tu changes d'exercice ! 👍


C8) Programmation à la Python :

Go to top

2221822217Précisons de plus que KhiCAS CE est programmable. La touche
prgm
te permet d'accéder à un éditeur de script te permettant de définir variables et fonctions en utilisant une syntaxe "à la Python". Techniquement ce n'est ni du Python ni même du Micropython, mais pour les habituelles questions Python de niveau Baccalauréat en Mathématiques ce sera largement suffisant. Et tant mieux vu que l'application Python officielle, elle-même assez grosse, n'a ici aucune chance de rentrer dans le petit espace qu'il nous reste. Le menu Fichier te permet de sauvegarder le script saisi sous le nom de ton choix, ou encore d'ouvrir un script précédemment saisi.

2222022219Pour exécuter ton script sauvegardé, il te faut déjà quitter l'éditeur comme indiqué au clavier via
2nd
mode
. De retour alors à l'historique de calcul, le menu Fichier te permet d'exécuter des scripts. Une fois ceci fait, pour une saisie immédiate, la touche
var
te listera directement l'ensemble des fonctions définies par les scripts exécutés.


C9) Tableur / feuille de calcul :

Go to top

2218722184L'application KhiCAS CE dispose elle-même de sorte de sous-applications que l'on trouve à la fin du menu Fichier (
F5
).

L'une d'entre elles est un véritable tableur intégré, en remplacement donc de l'appli CelSheet officielle.


C10) Classification périodique des éléments chimiques :

Go to top

2218622185Autre sous-application que l'on trouve à la fin du menu Fichier (
F5
), le tableau périodique des éléments.

Il est bien évidemment lui aussi intégré à l'environnement KhiCAS, permettant de récupérer sur simple validation la liste des propriétés d'un élément dans l'historique de calcul.


Conclusion :

Go to top

KhiCAS CE constitue une application intégrée de Mathématiques et de Sciences extrêmement complète. Entièrement gratuite, open source et qui plus est française, elle offre à ta TI-83 Premium CE ou TI-84 Plus CE des fonctionnalités te mettant en théorie à égalité de chances avec ceux qui ont fait le choix de modèles haut de gamme.

Pouvoir manipuler un moteur de calcul littéral et formel sur sa calculatrice est une formidable possibilité d'explorations permettant de mieux comprendre l'algèbre !
En pratique toutefois pour la France, l'outil d'intérêt pédagogique exceptionnel que constitue KhiCAS CE sera effacé à l'activation du mode examen.

Le problème vient de la réglementation du mode examen de 2014, fort mal conçue et cadrée.

Cette réglementation exige de rendre inaccessibles les données et informations préchargées (antisèches, formulaires, résumés de cours, corrections d'exercices d'annales…), KhiCAS CE n'étant bien évidemment pas concerné.

Mais en pratique la réglementation laisse pour cela toute liberté aux constructeurs, et ces derniers ont tous choisi de faire au plus simple : effacer ou bloquer tout le contenu mémoire, peu importe qu'il s'agisse de données frauduleuses ou d'autre chose.

La réglementation du mode examen grave ainsi dans le marbre une inégalité entre candidats ayant acheté des modèles de prix différents et donc avec des fonctionnalités différentes, désormais non extensibles par ajout de programmes ou applications.

Malheureusement depuis maintenant plus de 10 ans que nous l'interpellons, la mission de pilotage des examens n'a jamais accepté d'ouvrir des échanges au sujet de ce problème fort préoccupant, nos sollicitations étant toujours restées sans réponse.


Téléchargements :

Référence : page officielle, avec davantage de documentation/explications/infos… pour TI-83 Premium CE et TI-84 Plus CE

Code source (C, C++) : https://github.com/KhiCAS/ti-ce
(Ne pas hésiter à proposer des changements si vous pensez pouvoir le faire, que ce soit des améliorations d'interface, de performance, de taille…)

Zero Mise à jour Zero 2.23 avec bibliothèque graphique Python !

New postby critor » 20 Apr 2025, 09:54

22120Fan de la TI-83 Premium CE (ou hors de France de la TI-84 Plus CE), aujourd'hui nous te reparlons de la Zero ZGC4, le clone non officiel qui serait censé sortir pour la rentrée 2025.

Nous avons reçu une nouvelle mise à jour 2.23 pour la ZGC4, également compatible avec le prototype précédent ZGC3.

Plus précisément, nous passons donc de la version 2.22.0 du 11 décembre 2024 à la version 2.23.0 du 25 mars 2025.
Dans la dernière version, nous regrettions que la programmation Python qui devenait enfin fonctionnelle, n'offrait pas encore de bibliothèque graphique.

22130Et bien portons toute notre attention sur la programmation Python, car cela a visiblement bougé une nouvelle fois avec cette dernière mise à jour 2.23.

En effet l'interpréteur Micropython utilisé a été lui aussi mis à jour, passant de la version 1.22.0 sortie le 27 décembre 2023 à la version 1.23.0 sortie le 31 mai 2024.

2213121769Nous n'avons pas besoin de chercher bien loin, un simple appel help("modules") nous indique que le Python de la Zero dispose désormais d'une bibliothèque standard supplémentaire par rapport à la version précédente, lvgl, qui est justement une bibliothèque graphique !

Rappelons que niveau graphismes en Python, les calculatrices concurrents répartissent habituellement les fonctionnalités sur 3 bibliothèques :
  • une bibliothèque de tracé par pixels (habituellement propriétaire, c'est-à-dire spécifique à chaque marque ou pire modèle sans compatibilité du code entre les marques ou modèles)
  • une bibliothèque de tracé dans un repère (matplotlib, standard)
  • une bibliothèque de tracé à la tortue (turtle, standard)

Avec lvgl, la Zero nous offre déjà le gros avantage d'une bibliothèque de tracé par pixels standard !

À partir de l'objet écran lvgl.scr_act(), les méthodes .get_width() et .get_height() nous permettent de déterminer que nous contrôlons une zone graphique de 320×218 pixels, la barre de titre permanente occupant donc 22 pixels de hauteur.

Exemple 1 :
22122
Code: Select all
import lvgl as lv

scr = lv.scr_act()

# Height of persistent header on screen
header_height = lv.get_header_height()

print("Screen width: ", scr.get_width())
print("Screen height: ", scr.get_height())
print("Header height: ", header_height)

def draw_cb(obj, mask, mode):
    if mode == lv.DESIGN.DRAW_MAIN:
        objArea = lv.area_t()
        obj.get_coords(objArea)

        # Fill bg
        bgColor = lv.color_make(0xFF, 0xFF, 0xFF)
        lv.draw_fill(objArea, mask, bgColor, lv.OPA._100)

        styleLine = lv.style_t()
        styleLine.copy(lv.style_plain)
        styleLine.line.color = lv.color_make(0xFF, 0x00, 0x00)
        styleLine.line.width = 3
        styleLine.line.rounded = 1

        # Draw hor line (in coordinates of display (320x240))
        horLinePoint1 = { "x": objArea.x1, "y": objArea.y1 + int(objArea.get_height() / 2) }
        horLinePoint2 = { "x": objArea.x2, "y": objArea.y1 + int(objArea.get_height() / 2) }
        lv.draw_line(horLinePoint1, horLinePoint2, mask, styleLine, lv.OPA._100)

        # Draw ver line (in coordinates of display (320x240))
        verLinePoint1 = { "x": objArea.x1 + int(objArea.get_width() / 2), "y": objArea.y1 }
        verLinePoint2 = { "x": objArea.x1 + int(objArea.get_width() / 2), "y": objArea.y2 }
        lv.draw_line(verLinePoint1, verLinePoint2, mask, styleLine, lv.OPA._100)

        # Draw four pixels
        pxColor = lv.color_make(0x00, 0x00, 0x00)
        lv.draw_px(objArea.x1 + 50, objArea.y1 + 50, mask, pxColor, lv.OPA._100)
        lv.draw_px(objArea.x1 + 50, objArea.y2 - 50, mask, pxColor, lv.OPA._100)
        lv.draw_px(objArea.x2 - 50, objArea.y1 + 50, mask, pxColor, lv.OPA._100)
        lv.draw_px(objArea.x2 - 50, objArea.y2 - 50, mask, pxColor, lv.OPA._100)

        # Draw rectangle
        styleRect = lv.style_t()
        styleRect.copy(lv.style_plain)
        styleRect.body.main_color = lv.color_make(0x00, 0xFF, 0x00)
        styleRect.body.grad_color = lv.color_make(0x00, 0xFF, 0x00)
        styleRect.body.radius = 5

        rectArea = lv.area_t()
        rectArea.set(objArea.x1 + 60, objArea.y1 + 60, objArea.x1 + 100, objArea.y1 + 100)
        lv.draw_rect(rectArea, mask, styleRect, lv.OPA._100)

        # Draw label
        labelStyle = lv.style_t()
        labelStyle.copy(lv.style_plain)
        labelStyle.text.color = lv.color_make(0x00, 0xFF, 0xFF)

        labelOffset = {"x": 0, "y": 0}

        labelArea = lv.area_t()
        labelArea.set(objArea.x1 + 180, objArea.y1 + 60, objArea.x2, objArea.y1 + 80)
        lv.draw_label(labelArea, mask, labelStyle, lv.OPA._100, "Label", 0, labelOffset, None, None, lv.BIDI_DIR.LTR)

        # Draw triangle
        styleRect.body.main_color = lv.color_make(0xFF, 0x00, 0x00)
        trigPoints = [ {"x":200, "y":150},
                        {"x":240, "y":150},
                        {"x":240, "y":200}]
        lv.draw_triangle(trigPoints, mask, styleRect, lv.OPA._100)

        # Draw polygon
        styleRect.body.main_color = lv.color_make(0x00, 0x00, 0xFF)
        polyPoints = [ {"x":100, "y":150},
                        {"x":140, "y":150},
                        {"x":140, "y":200},
                        {"x":100, "y":220}]
        lv.draw_polygon(polyPoints, len(polyPoints), mask, styleRect, lv.OPA._100)

        return True
    else:
        return False

scr.set_design_cb(draw_cb)

print("Main draw finished")

lv.show()


Exemple 2:
22138
Code: Select all
import lvgl as lv

# Create an array for the points of the line
line_points = [ {"x":5, "y":5},
                {"x":70, "y":70},
                {"x":120, "y":10},
                {"x":180, "y":60},
                {"x":240, "y":10}]

# Create new style (thick dark blue)
style_line = lv.style_t()
style_line.copy(lv.style_plain)
style_line.line.color = lv.color_make(0x00, 0x3b, 0x75)
style_line.line.width = 3
style_line.line.rounded = 1

# Copy the previous line and apply the new style
line1 = lv.line(lv.scr_act(), None)
line1.set_points(line_points, len(line_points))      # Set the points
line1.set_style(lv.line.STYLE.MAIN, style_line)
line1.align(None, lv.ALIGN.CENTER, 0, 0)

lv.show()
lvgl se révèle être une bibliothèque de tracé par pixels hautement poussée, encore mieux que le double buffering des Casio et TI-Nspire CX II, nous manipulons hors écran autant de calques que nous voulons, comme sur HP Prime !

Exemple :
22121
Code: Select all
import lvgl as lv

CANVAS_WIDTH  = 200
CANVAS_HEIGHT = 150

style = lv.style_t()
style.copy(lv.style_plain)
style.body.main_color = lv.color_make(0xFF,0,0)
style.body.grad_color = lv.color_make(0x80,0,0)
style.body.radius = 4
style.body.border.width = 2
style.body.border.color = lv.color_make(0xFF,0xFF,0xFF)
style.body.shadow.color = lv.color_make(0xFF,0xFF,0xFF)
style.body.shadow.width = 4
style.line.width = 2
style.line.color = lv.color_make(0,0,0)
style.text.color = lv.color_make(0,0,0xFF)

# CF.TRUE_COLOR requires 4 bytes per pixel
cbuf = bytearray(CANVAS_WIDTH * CANVAS_HEIGHT * 4)

canvas = lv.canvas(lv.scr_act(), None)
canvas.set_buffer(cbuf, CANVAS_WIDTH, CANVAS_HEIGHT, lv.img.CF.TRUE_COLOR)
canvas.align(None, lv.ALIGN.CENTER, 0, 0)
canvas.fill_bg(lv.color_make(0xC0, 0xC0, 0xC0))

canvas.draw_rect(70, 60, 100, 70, style)

canvas.draw_text(40, 20, 100, style, "Some text on text canvas", lv.label.ALIGN.LEFT)

# Test the rotation. It requires an other buffer where the original image is stored.
# So copy the current image to buffer and rotate it to the canvas
img = lv.img_dsc_t()
img.data = cbuf[:]
img.header.cf = lv.img.CF.TRUE_COLOR
img.header.w = CANVAS_WIDTH
img.header.h = CANVAS_HEIGHT

canvas.fill_bg(lv.color_make(0xC0, 0xC0, 0xC0))
canvas.rotate(img, 30, 0, 0, CANVAS_WIDTH // 2, CANVAS_HEIGHT // 2)

lv.show()
Mais ce n'est pas tout… Nul besoin de changer de bibliothèque ici, deux en un, lvgl permet également les tracés dans un repère comme matplotlib !

Exemple :
22124
Code: Select all
import lvgl as lv

# Create a chart
chart = lv.chart(lv.scr_act(), None)
chart.set_size(200, 150)
chart.align(None, lv.ALIGN.CENTER, 0, 0)
chart.set_type(lv.chart.TYPE.POINT | lv.chart.TYPE.LINE)   # Show lines and points too
chart.set_series_opa(lv.OPA._70)                           # Opacity of the data series
chart.set_series_width(4)                                  # Line width and point radious

chart.set_range(0, 100)

# Add two data series
ser1 = chart.add_series(lv.color_make(0xFF, 0x00, 0x00))
ser2 = chart.add_series(lv.color_make(0x00, 0x80, 0x00))

# Set points on 'dl1'
chart.set_points(ser1, [10, 10, 10, 10, 10, 10, 10, 30, 70, 90])

# Set points on 'dl2'
chart.set_points(ser2, [90, 70, 65, 65, 65, 65, 65, 65, 65, 65])

lv.show()
print("LVGL drawing finished")
Mais lvgl c'est encore bien plus que cela, car il s'agit en fait d'une bibliothèque graphique orientée objet. Tu peux en quelques lignes créer nombre d'objets graphiques différents ! 👍

Exemple : boutons poussoir
22136
Code: Select all
import lvgl as lv

def event_handler(obj, event):
    if event == lv.EVENT.CLICKED:
        print("Button clicked")
   
btn1 = lv.btn(lv.scr_act(), None)
btn1.align(None, lv.ALIGN.CENTER, 0, -40)
btn1.set_event_cb(event_handler)
label = lv.label(btn1, None)
label.set_text("Button")

btn2 = lv.btn(lv.scr_act(), None)
# callback can be lambda:
btn2.set_event_cb(lambda obj, event: print("Toggled") if event == lv.EVENT.VALUE_CHANGED else None)
btn2.align(None, lv.ALIGN.CENTER, 0, 40)
btn2.set_toggle(True)
btn2.toggle()
btn2.set_fit2(lv.FIT.NONE, lv.FIT.TIGHT)

label = lv.label(btn2, None)
label.set_text("Toggled")

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for buttons
group = lv.group_create()
group.add_obj(btn1)
group.add_obj(btn2)
keyboard.set_group(group)

lv.show()
print("LVGL drawing finished")


Exemple : boîtes à cocher
2213522134
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

def event_handler(obj, event):
    if event == lv.EVENT.VALUE_CHANGED:
        print("State: %s" % ("Checked" if obj.is_checked() else "Unchecked"))

cb = lv.cb(lv.scr_act(), None)
cb.set_text("I agree to terms")
cb.align(None, lv.ALIGN.CENTER, 0, 0)
cb.set_event_cb(event_handler)

group.add_obj(cb)

lv.show()
print("LVGL drawing finished")


Exemple : interrupteurs à bascule
2214022139
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

def event_handler(obj, event):
    if event == lv.EVENT.VALUE_CHANGED:
        print("State: %s" % ("On" if obj.get_state() else "Off"))

# Create styles for the switch
bg_style = lv.style_t()
indic_style = lv.style_t()
knob_on_style = lv.style_t()
knob_off_style = lv.style_t()

bg_style.copy(lv.style_pretty)
bg_style.body.radius = 800
bg_style.body.padding.top = 6
bg_style.body.padding.bottom = 6

indic_style.copy(lv.style_pretty_color)
indic_style.body.radius = 800
indic_style.body.main_color = lv.color_hex(0x9fc8ef)
indic_style.body.grad_color = lv.color_hex(0x9fc8ef)
indic_style.body.padding.left = 0
indic_style.body.padding.right = 0
indic_style.body.padding.top = 0
indic_style.body.padding.bottom = 0

knob_off_style.copy(lv.style_pretty)
knob_off_style.body.radius = 800
knob_off_style.body.shadow.width = 4
knob_off_style.body.shadow.type = lv.SHADOW.BOTTOM

knob_on_style.copy(lv.style_pretty_color)
knob_on_style.body.radius = 800
knob_on_style.body.shadow.width = 4
knob_on_style.body.shadow.type = lv.SHADOW.BOTTOM

# Create a switch and apply the styles
sw1 = lv.sw(lv.scr_act(), None)
sw1.set_style(lv.sw.STYLE.BG, bg_style)
sw1.set_style(lv.sw.STYLE.INDIC, indic_style)
sw1.set_style(lv.sw.STYLE.KNOB_ON, knob_on_style)
sw1.set_style(lv.sw.STYLE.KNOB_OFF, knob_off_style)
sw1.align(None, lv.ALIGN.CENTER, 0, -50)
sw1.set_event_cb(event_handler)

# Copy the first switch and turn it ON
sw2 = lv.sw(lv.scr_act(), None)
sw2.set_style(lv.sw.STYLE.BG, bg_style)
sw2.set_style(lv.sw.STYLE.INDIC, indic_style)
sw2.set_style(lv.sw.STYLE.KNOB_ON, knob_on_style)
sw2.set_style(lv.sw.STYLE.KNOB_OFF, knob_off_style)
sw2.on(lv.ANIM.ON)
sw2.align(None, lv.ALIGN.CENTER, 0, 50)
sw2.set_event_cb(lambda o,e: None)

group.add_obj(sw1)
group.add_obj(sw2)

lv.show()


Exemple : barre de progression horizontale
22133
Code: Select all
import lvgl as lv

bar1 = lv.bar(lv.scr_act(), None)
bar1.set_size(200, 30)
bar1.align(None, lv.ALIGN.CENTER, 0, 0)
bar1.set_anim_time(2500)
bar1.set_value(100, lv.ANIM.ON)

lv.show()
print("LVGL drawing finished")


Exemple : barre de progression ou d'attente chargement circulaire
22132
Code: Select all
import lvgl as lv

# Create style for the Arcs
style = lv.style_t()
style.copy(lv.style_plain)
style.line.color = lv.color_make(0x00, 0xFF, 0xFF) # Arc color
style.line.width = 8                      # Arc width

# Create an Arc
arc = lv.arc(lv.scr_act(), None)
arc.set_style(lv.arc.STYLE.MAIN, style)   # Use the new style
arc.set_angles(90, 60)
arc.set_size(150, 150)
arc.align(None, lv.ALIGN.CENTER, 0, 0)

lv.show()
print("LVGL drawing finished")


Exemple : champ de saisie numérique
22128
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

def event_handler(obj, event):
    if event == lv.EVENT.VALUE_CHANGED:
        print("Value: %d" % obj.get_value())
    elif event == lv.EVENT.CLICKED:
        # For simple test: Click the spinbox to increment its value
        obj.increment()

spinbox = lv.spinbox(lv.scr_act(), None)
spinbox.set_digit_format(5, 3)
spinbox.step_prev()
spinbox.set_width(100)
spinbox.align(None, lv.ALIGN.CENTER, 0, 0)
spinbox.set_event_cb(event_handler)

group.add_obj(spinbox)

lv.show()


Exemple : jauge 1
22141
Code: Select all
import lvgl as lv

# Create a style
style = lv.style_t()
style.copy(lv.style_pretty_color)
style.body.main_color = lv.color_hex3(0x666)     # Line color at the beginning
style.body.grad_color =  lv.color_hex3(0x666)    # Line color at the end
style.body.padding.left = 10                     # Scale line length
style.body.padding.inner = 8                     # Scale label padding
style.body.border.color = lv.color_hex3(0x333)   # Needle middle circle color
style.line.width = 3
style.text.color = lv.color_hex3(0xFFFFFF)
style.line.color = lv.color_hex3(0xF00)          # Line color after the critical value

# Describe the color for the needles
needle_colors = [
    lv.color_make(0x00, 0x00, 0xFF),
    lv.color_make(0xFF, 0xA5, 0x00),
    lv.color_make(0x80, 0x00, 0x80)
]

# Create a gauge
gauge1 = lv.gauge(lv.scr_act(), None)
gauge1.set_style(lv.gauge.STYLE.MAIN, style)
gauge1.set_needle_count(len(needle_colors), needle_colors)
gauge1.set_size(150, 150)
gauge1.align(None, lv.ALIGN.CENTER, 0, 20)

# Set the values
gauge1.set_value(0, 10)
gauge1.set_value(1, 20)
gauge1.set_value(2, 30)

lv.show()
print("LVGL drawing finished")


Exemple : jauge 2
22142
Code: Select all
import lvgl as lv

# Create a style for the line meter
style_lmeter = lv.style_t()
style_lmeter.copy(lv.style_pretty_color)
style_lmeter.line.width = 2
style_lmeter.line.color = lv.color_hex(0xc0c0c0)              # Silver
style_lmeter.body.main_color = lv.color_hex(0x91bfed)         # Light blue
style_lmeter.body.grad_color = lv.color_hex(0x04386c)         # Dark blue
style_lmeter.body.padding.left = 16                           # Line length

# Create a line meter
lmeter = lv.lmeter(lv.scr_act(), None)
lmeter.set_range(0, 100)                    # Set the range
lmeter.set_value(80)                        # Set the current value
lmeter.set_scale(240, 31)                   # Set the angle and number of lines
lmeter.set_style(lv.lmeter.STYLE.MAIN, style_lmeter)          # Apply the new style
lmeter.set_size(150, 150)

lv.show()


Exemple : curseur
22143
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

# Create a label below the slider
slider_label = lv.label(lv.scr_act(), None)
slider_label.set_text("0")
slider_label.set_auto_realign(True)

def slider_event_cb(obj, event):
    if event == lv.EVENT.VALUE_CHANGED:
        slider_label.set_text("%u" % obj.get_value())

# Create a slider in the center of the display
slider = lv.slider(lv.scr_act(), None)
slider.set_width(200)
slider.align(None, lv.ALIGN.CENTER, 0, 0)
slider.set_event_cb(slider_event_cb)
slider.set_range(0, 100)

slider_label.align(slider, lv.ALIGN.OUT_BOTTOM_MID, 0, 10)

# Create an informative label
info = lv.label(lv.scr_act(), None)
info.set_text("""Welcome to the slider+label demo!
Move the slider and see that the label
updates to match it.""")
info.align(None, lv.ALIGN.IN_TOP_LEFT, 10, 10)

group.add_obj(slider)

lv.show()


Exemple : liste de choix
22127
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

def event_handler(obj, event):
    if event == lv.EVENT.VALUE_CHANGED:
        option = " "*10
        obj.get_selected_str(option, len(option))
        print("Selected month: %s" % option.strip())

roller1 = lv.roller(lv.scr_act(), None)
roller1.set_options("\n".join([
                    "January",
                    "February",
                    "March",
                    "April",
                    "May",
                    "June",
                    "July",
                    "August",
                    "September",
                    "October",
                    "November",
                    "December"]), lv.roller.MODE.INIFINITE)

roller1.set_visible_row_count(4)
roller1.align(None, lv.ALIGN.CENTER, 0, 0)
roller1.set_event_cb(event_handler)

group.add_obj(roller1)

lv.show()
Et bien évidemment, lvgl permet d'organiser nombre de ces objets graphiques de façon complexe et d'en gérer les différents événements ! 👍

Exemple : boîte de dialogue de confirmation ou annulation
22137
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

def event_handler(obj, event):
    if event == lv.EVENT.VALUE_CHANGED:
        print("Button: %s" % lv.mbox.get_active_btn_text(obj))

mbox1 = lv.mbox(lv.scr_act(), None)
mbox1.set_text("A message box with two buttons.")
mbox1.add_btns(["Apply", "Close", ""])
mbox1.set_width(200)
mbox1.set_event_cb(event_handler)
mbox1.align(None, lv.ALIGN.CENTER, 0, 0)  # Align to the corner

group.add_obj(mbox1)

lv.show()


Exemple : Grille de boutons poussoir
22125
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

def event_handler(obj, event):
    if event == lv.EVENT.VALUE_CHANGED:
        txt = obj.get_active_btn_text()
        print("%s was pressed" % txt)

btnm1 = lv.btnm(lv.scr_act(), None)
btnm1.set_map( ["1", "2", "3", "4", "5", "\n",
            "6", "7", "8", "9", "0", "\n",
            "Action1", "Action2", ""])
btnm1.set_btn_width(10, 2)        # Make "Action1" twice as wide as "Action2"
btnm1.align(None, lv.ALIGN.CENTER, 0, 0)
btnm1.set_event_cb(event_handler)

group.add_obj(btnm1)

lv.show()
print("LVGL drawing finished")


Exemple : Vues par onglets
22126
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

# Create a Tab view object
tabview = lv.tabview(lv.scr_act(), None)

# Add 3 tabs (the tabs are page (lv_page) and can be scrolled
tab1 = tabview.add_tab("Tab 1")
tab2 = tabview.add_tab("Tab 2")
tab3 = tabview.add_tab("Tab 3")

# Add content to the tabs
label = lv.label(tab1, None)
label.set_text("""This the first tab

If the content
of a tab
become too long
the it
automatically
become
scrollable.""")

label = lv.label(tab2, None)
label.set_text("Second tab")

label = lv.label(tab3, None)
label.set_text("Third tab")

group.add_obj(tabview)

lv.show()


Exemple : zone à défiler
22144
Code: Select all
import lvgl as lv

# Keyboard register
keyboardDriver = lv.indev_drv_t()
keyboardDriver.init()
keyboardDriver.type = lv.INDEV_TYPE.KEYPAD
keyboardDriver.read_cb = lv.keypad_read
keyboard = keyboardDriver.register()

# Create groupe for keyboard handled objects
group = lv.group_create()
keyboard.set_group(group)

valid_pos = [{"x":0, "y": 0}, {"x": 0, "y": 1}, {"x": 1,"y": 1}]

# resolution of the screen
HOR_RES = lv.scr_act().get_width()
VER_RES = lv.scr_act().get_height()

tileview = lv.tileview(lv.scr_act(), None)
tileview.set_valid_positions(valid_pos, len(valid_pos))
tileview.set_edge_flash(True)

# Tile1: just a label
tile1 = lv.obj(tileview, None)
tile1.set_size(HOR_RES, VER_RES)
tile1.set_style(lv.style_pretty)
tileview.add_element(tile1)

label = lv.label(tile1, None)
label.set_text("Tile 1")
label.align(None, lv.ALIGN.CENTER, 0, 0)

# Tile2: a list
lst = lv.list(tileview, None)
lst.set_size(HOR_RES, VER_RES)
lst.set_pos(0, VER_RES)
lst.set_scroll_propagation(True)
lst.set_sb_mode(lv.SB_MODE.OFF)
tileview.add_element(lst)

list_btn = lst.add_btn(None, "One")
tileview.add_element(list_btn)

list_btn = lst.add_btn(None, "Two")
tileview.add_element(list_btn)

list_btn = lst.add_btn(None, "Three")
tileview.add_element(list_btn)

list_btn = lst.add_btn(None, "Four")
tileview.add_element(list_btn)

list_btn = lst.add_btn(None, "Five")
tileview.add_element(list_btn)

list_btn = lst.add_btn(None, "Six")
tileview.add_element(list_btn)

list_btn = lst.add_btn(None, "Seven")
tileview.add_element(list_btn)

list_btn = lst.add_btn(None, "Eight")
tileview.add_element(list_btn)

# Tile3: a button
tile3 = lv.obj(tileview, None)
tile3.set_size(HOR_RES, VER_RES)
tile3.set_pos(HOR_RES, VER_RES)
tileview.add_element(tile3)

btn = lv.btn(tile3, None)
btn.align(None, lv.ALIGN.CENTER, 0, 0)

label = lv.label(btn, None)
label.set_text("Button")

group.add_obj(tileview)

lv.show()
Clairement niveau graphismes Python, dire que la Zero rattrape aujourd'hui les TI-83/84 serait un euphémisme. Bien au-delà, elle les dépasse et les laisse loin derrière ainsi que l'ensemble de la concurrence ! 🥳

-
Search
-
Social TI-Planet
-
Featured topics
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 !
1234
-
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.
1087 utilisateurs:
>1062 invités
>21 membres
>4 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)