π
<-
Chat plein-écran
[^]

TI-z80 Animation mise à jour Windows 10 dans ta TI-83 Premium CE !

Nouveau messagede critor » 26 Jan 2021, 14:41

7530En 2016 te proposait de faire une petite farce à tes camarades, leur faisant croire que tu avais
Windows XP
d'installé sur ta
TI-83 Premium CE
.

Son programme reproduisait en effet l'animation d'écran de veille par défaut de ce système.

Mais voilà, l'effet n'est plus le même de nos jours,
Windows XP
ça fait tellement vieux et désuet désormais... :'(

13466Heureusement
Candledark
reprend aujourd'hui le flambeau, pour faire croire à tes camarades que ta
TI-83 Premium CE
fait cette fois-ci tourner
Windows 10
! :D

Son programme
WINUPDTE
reproduit en effet soigneusement l'animation de mise à jour de ce système.

Pour faire encore plus vrai, l'animation ne peut être quittée normalement. ;)
Deux versions sont au choix, et il te faudra en fait :
  • pour la version 1, patienter 20 secondes puis taper une touche
  • pour la version 2, maintenir simultanément les 3 touches :f84: :f61: :f65:
    (devineras-tu pourquoi ? ;))

WINUPDTE
est écrit en langage
C
et le code source est inclus. :)

Attention,
WINUPDTE
rentre donc dans la catégorie des programmes en langage machine dits
ASM
. /!
Si ta calculatrice fait tourner une version système
5.5.1
ou supérieure c'est compliqué ;
Texas Instruments
combattant farouchement l'exécution de code tiers sur la
TI-83 Premium CE
depuis un acte absolument irresponsable d'un enseignant français de Mathématiques dans le contexte de ses gesticulations visiblement aveugles contre la réforme du lycée. :mj:

Il te faut :
  1. installer
    arTIfiCE
    pour remettre la possibilité de lancer des programmes
    ASM
  2. de préférence installer
    Cesium
    pour pouvoir lancer les programmes
    ASM
    facilement, ou même
    AsmHook
    pour pouvoir les lancer comme avant

Téléchargements
:

Lien vers le sujet sur le forum: Animation mise à jour Windows 10 dans ta TI-83 Premium CE ! (Commentaires: 2)

TI-z80 RainCode, l'animation à la Matrix sur ta TI-83 Premium CE

Nouveau messagede critor » 24 Jan 2021, 15:03

Connais-tu donc
Matrix
?

C'est une série de trois films américano-australiens initiée en 1999 par ceux qui étaient alors les frères Wachowski. Elle se passe autour d'un univers virtuel dont l'état est consultable sur écran sous la forme d'une
"pluie de code"
, animation introduisant justement les trois films dans un thème vert.

13465
Candledark
te propose aujourd'hui avec
CodeRain
, son nouveau programme
TI-83 Premium CE
, non pas de te mettre dans la matrice, mais de mettre la matrice dans ta
TI-83 Premium CE
! ;)

CodeRain
apporte en effet l'animation mythique sur l'écran de ta calculatrice, une reproduction déjà très fidèle et très fluide. :bj:

Mais ici en prime, tu peux choisir différents thèmes pour ta pluie de code à l'aide des touches numériques du clavier : :D
  1. rouge
  2. vert
    (par défaut)
  3. jaune
  4. bleu
  5. violet
  6. sarcelle
  7. magenta
  8. orange
  9. et même multicolore ! 😻


CodeRain
est écrit en langage
C
et le code source est inclus. :)

Attention,
CodeRain
rentre donc dans la catégorie des programmes en langage machine dit
ASM
. /!
Si ta calculatrice fait tourner une version système
5.5.1
ou supérieure c'est compliqué ;
Texas Instruments
combattant farouchement l'exécution de code tiers sur la
TI-83 Premium CE
depuis un acte absolument irresponsable d'un enseignant de Mathématiques français dans le contexte de ses gesticulations visiblement aveugles contre la réforme du lycée. :mj:

Il te faut :
  1. installer
    arTIfiCE
    pour remettre la possibilité de lancer des programmes
    ASM
  2. de préférence installer
    Cesium
    pour pouvoir lancer les programmes
    ASM
    facilement, ou même
    AsmHook
    pour pouvoir les lancer comme avant

Téléchargements
:

Lien vers le sujet sur le forum: RainCode, l'animation à la Matrix sur ta TI-83 Premium CE (Commentaires: 1)

TI-z80 TI-Keyboard CE, clavier USB personnalisé pour 83 Premium CE

Nouveau messagede critor » 23 Jan 2021, 19:41

Si il y a un point sur lequel les calculatrices
Texas Instruments
surpassent incontestablement la concurrence, c'est bien par leurs grandes possibilités
USB
. En effet leur port
mini-USB
est complètement câblé, ce qui leur permet de se comporter en hôte
USB
et donc d'accueillir et alimenter des périphériques
USB
, pourvu que la calculatrice les supporte.
Il existe plusieurs périphériques officiels munis d'un port
mini-USB
pour un branchement immédiat sur ta calculatrice
Texas Instruments
, et qui fonctionneront avec l'ensemble de la gamme couleur actuelle
(à l'exclusion donc de la
TI-82 Advanced
d'entrée de gamme)
:

12277Rien ne t'empêche toutefois de connecter d'autres périphériques
USB
, pourvu bien sûr qu'ils soient correctement gérés. Les périphériques disposant d'une connectivité
mini-USB
étant toutefois très rares, il te faudra probablement un adaptateur au choix :
6525Tu l'ignorais peut-être, mais tes fantastiques
TI-Nspire CX II
et
TI-83 Premium CE
(ou à l'international
TI-84 Plus CE
)
disposent dans ce cadre de possibilités encore plus exclusives à ce jour. :D
En effet même si il ne l'a toujours pas annoncé et encore moins exploité depuis, le constructeur a introduit la gestion des claviers
USB
à compter des versions
5.1.5
sur
TI-83 Premium CE
et
5.0
sur
TI-Nspire CX II
.

Oui, les
TI-Nspire CX II
et
TI-83 Premium CE
(ou
TI-84 Plus CE
)
sont à ce jour les seuls modèles te permettant de brancher et utiliser un clavier
USB
pour une saisie encore plus facile et rapide de tes programmes et scripts
Python
! :#tritop#:

En prime ton expérience de saisie sur
TI-83 Premium CE
s'enrichit considérablement dans ce contexte avec :
  • la touche d'effacement arrière, parfaitement fonctionnelle bien qu'inexistante sur la calculatrice ! :bj:
  • si la touche
    annul
    de la calculatrice a pour équivalent
    verr num
    sur les claviers, nous avons en prime la touche
    esc
    qui permet à la différence une annulation sans effacement, petite nuance :)
  • saisie de caractères minuscules ce qui n'était pas possible en dehors de l'application
    Python
    , du moins pas sans ajout d'un utilitaire :bj:
  • saisie directe de caractères non présents au clavier de la calculatrice et qu'il fallait aller chercher dans des menus ! :bj:
  • et même saisie de caractères n'étant même pas dans les menus de la calculatrice ! :bj:

12283Les équivalences de touches et fonctionnalités étaient certes logiques.

Par exemple la touche
3
de la calculatrice permet également de saisir
L3
ou
θ
via les modificateurs
2nde
et
alpha
.
On retrouvait donc ces mêmes possibilités sur le clavier externe via les modificateurs
ctrl
et
alt
, ainsi que la possibilité supplémentaire de sortir un caractère spécial avec le modificateur
shift
.

Toutefois voilà, ces saisies secondaires n'étaient absolument pas indiquées sur un clavier
USB
standard, et avec une organisation de touches complètement différente ces équivalences n'étaient pas aisées à retenir non plus.

Il fallait donc personnaliser les inscriptions de son clavier...

Dans l'optique de l'expédition des lots de notre concours de rentrée 2020, nous sommes justement en train de produire 5 claviers
USB
uniques, entièrement personnalisés pour une expérience de saisie révolutionnaire sur ta
TI-83 Premium CE
! :bj:
Trop tard pour participer, mais si tu n'as pas gagné nous te partageons quand même ici l'intégralité des détails de leur conception. ;)

13459Pour compléter la sérigraphie de ton clavier
USB
, il te faut donc du papier autocollant transparent, que tu pourras trouver dans le commerce dans des kits destinés à la fabrication de
stickers
transparents.
Conformément aux spécifications du papier précédent, nous utilisons une imprimante jet d'encre.

12278Mais attention au choix de ton clavier
USB
, il te faut de préférence un clavier
Qwerty
filaire avec des touches de couleur blanche ou claire. Nous optons pour notre part pour un mini-clavier
USB Qwerty
filaire blanc à peine plus grand que la calculatrice que nous jugeons plus convenable pour le transport et l'usage scolaire, également très fin et léger. :)
En effet :
  • Ta calculatrice ne gère que la disposition de touches
    Qwerty
    . Trouver/commander un clavier
    Qwerty
    te permettra des modifications beaucoup moins lourdes de sa sérigraphie. :)
  • Notre imprimante étant ici une jet d'encre fonctionnant de façon totalement normale en quadrichromie soustractive, il lui est impossible d'imprimer quelque chose de plus clair que le support qui lui est fourni. Mais ça tombe bien ce sera assorti à ta
    TI-83 Premium CE
    comme ça. ;)
Attention, les claviers
USB
sans fil à la différence ne fonctionnent pas toujours avec la calculatrice, leur émetteur-récepteur pouvant sans doute générer une consommation trop importante.


Voici donc ci-contre nos autocollants destinés à en compléter ou corriger la sérigraphie de chaque touche, aussi bien pour
TI-83 Premium CE
que pour
TI-84 Plus CE
. Tu en retrouveras gratuitement en fin d'article une version directement imprimable, ainsi qu'une version modifiable.

13458De façon similaire à la calculatrice, nous adoptons donc un code couleur vert-bleu pour les fonctions secondaires. Nous utilisons ensuite 3 colorations de touches différentes :
  • Sur fond blanc et donc transparent une fois imprimé, les simples précisions sur les fonctions secondaires de la touche concernée. Cela concerne les touches dont la fonction principale telle que sérigraphiée ne change pas lorsqu'utilisée avec la calculatrice, une majorité comme déjà dit pour un clavier
    Qwerty
    .
  • Sur fond noir et donc masquant la sérigraphie d'origine une fois imprimé, les rares touches qui avec la calculatrice ne se comportent pas comme indiqué pour leur fonction principale.
1346113462Nous ne sommes pas certains qu'une impression jet d'encre sur laquelle tu vas poser les doigts sans arrêt soit très durable. Nous ne savons pas ce que ça vaut, tu nous diras, mais nous appliquons donc une couche de vernis.
Tu peux pour cela piquer le tube de vernis à ongles de Maman, grande sœur ou petite sœur, ça marche très bien. :)

1346413463Et voilà, il n'y a plus qu'à imprimer puis découper et coller. Impression bien évidemment en qualité optimale en sélectionnant un type de papier
brillant épais
ou à défaut
brillant
tout court.

Voici donc enfin notre périphérique légendaire
TI-Keyboard CE édition 84
dans toute sa splendeur, nous voici fin prêts pour une saisie turbo ! :bj:

Téléchargement
:
autocollants
TI-83 Premium CE
/
TI-84 Plus CE
pour clavier
Qwerty
Lien vers le sujet sur le forum: TI-Keyboard CE, clavier USB personnalisé pour 83 Premium CE (Commentaires: 6)

HP Applis HP Prime pour Android supprimées du Google Play Store

Nouveau messagede critor » 22 Jan 2021, 18:07

11694Rentrée 2013 sortait la formidable calculatrice
HP Prime
.
Hewlett Packard
avait dès le début fait le choix de se distinguer de la concurrence de l'époque, avec un logiciel d'émulation
HP Prime
pour ordinateurs complet et entièrement gratuit, à l'époque pour
Windows
.

L'écosystème logiciel n'a eu de cesse de s'étoffer depuis. On peut citer :

Les logiciels d'émulation sont tous gratuits.

13457Pour les applications d'émulation par contre, les versions intégrales sont payantes.

Les versions gratuites des applications
HP Prime
sont quant à elles limitées à l'utilisation de seulement 9 des applications de la calculatrice :
  • Fonction
  • Graphiques avancés
  • Stats 1Var
  • Stats 2Var
  • Inférence
  • Résoudre
  • Paramétrique
  • Polaire
  • Suite

Les versions gratuites des applications n'en restent pas moins fort utiles si ton enseignant t'autorise le
smartphone
en devoir surveillé, chaque application de la calculatrice pouvant être basculée dans sa vue
CAS
autorisant le calcul formel ! :bj:

Et puis, comme tu l'as peut-etre remarqué,
Google
a fait un mauvais coup à
Hewlett Packard
en pleine période de rentrée 2020. Les deux applications
HP Prime
ont été supprimées du
Play Store
.

L'un des développeurs de la
HP Prime
,
Tim Wessman
, avait rapidement communiqué à ce sujet dès le 17 septembre 2020 :
Tim Wessman a écrit:it got pulled automatically due to needing a small tweak to an openFile api. Kind of a surprise to us as well


On pouvait donc s'attendre à un retour rapide de l'application après une très légère correction.

Hélas, cela fait maintenant plus de 4 mois et toujours rien.

Quelques infos complémentaires,
Cyrille de Brébisson
, autre développeur de la
HP Prime
, vient tout juste de revenir sur ce sujet dans le contexte de la conférence virtuelle
HPCC 2021
. Deux passages à ce sujet :
  • de 8:21 à 8:49
  • de 13:27 à 17:41


Pour résumer, tu as pu noter que la dernière mise à jour
HP Prime
remonte à janvier 2020 et qu'elle était bien mineure, la dernière mise à jour véritablement significative remontant à janvier 2018.

Ben c'est ça le problème, comme peu de choses ont bougé depuis maintenant plus de 3 ans, du moins dans les versions de production, ben les applications
HP Prime
n'ont plus été mises à jour.
Et
Google
supprime automatiquement du
Play Store
les applications qui ne sont plus mises à jour depuis un certain temps.

Les applications
HP Prime
doivent être recompilées, sauf que depuis tout ce temps le
SDK
a pas mal bougé et en gros la compilation échoue. :'(

Histoire donc de te dépanner, nous hébergeons l'application gratuite
HP Prime Lite
pour
Android
.

Pour l'installer il te suffira tout simplement d'ouvrir le fichier
.apk
téléchargé ci-dessous sur ton
smartphone
.

Par contre désolé, nous n'avons hélas aucune solution pour te redonner accès à l'application intégrale
HP Prime Pro
sur
Android
. :'(


Téléchargements
:

Lien vers le sujet sur le forum: Applis HP Prime pour Android supprimées du Google Play Store (Commentaires: 5)

TI-z80 BBC micro:bit v2 + mise à jour pour TI-83 Premium CE Python

Nouveau messagede critor » 21 Jan 2021, 15:43

12212Depuis des années maintenant,
Texas Instruments
réalise de gros efforts pour rendre la programmation de ses calculatrices accessible à tous et toutes. Le constructeur a prêté une attention toute particulière aux plus jeunes et non initiés, souhaitant leur permettre de créer tous les projets imaginables sans avoir à se concentrer sur des difficultés annexes. :)

Nous pouvions déjà citer l'interface , le robot pilotable , la grille programmable ou encore l'adaptateur
TI-SensorLink
pour capteurs analogiques
Vernier
.
Tous ces éléments ont de plus l'avantage d'être utilisables directement avec le langage
Python
des calculatrices concernées, faisant de l'écosystème
Texas Instruments
le seul
Python
connecté ! :bj:

Un superbe support pour les enseignements scientifiques au lycée surtout maintenant que tous partagent le même langage de programmation, notamment en
SNT
, spécialité
NSI
,
SI
et
Physique-Chimie
, avec le gros avantage de la mobilité. En effet, les programmes produits et données collectées restent présents dans la calculatrice apportée par chaque élève à chaque cours, ce qui allège la charge logistique de l'enseignant. Données et algorithmes pourront donc être traités / travaillés à la prochaine séance, en devoir à la maison ou même de façon transdisciplinaire en collaboration avec un autre enseignant ! :D

129591295812957Et depuis la rentrée 2020 dernière grande révolution en date, plus besoin de t'équiper en
TI-Innovator
pour bénéficier de ces formidables avantages. En effet, la
TI-83 Premium CE Edition Python
s'est vu rajouter la gestion du nanoordinateur programmable en
Python
dont tu étais peut-être déjà équipé·e ! :bj:
Attention, cela nécessite obligatoirement que ta calculatrice fasse tourner une version
5.5.1
ou supérieure.


La carte
micro:bit
est initialement un projet lancé par la
BBC
(
B
ritish
B
roadcasting
C
orporation)
, le groupe audiovisuel public britannique, accompagné de nombre de partenaires dont
ARM
,
Microsoft
et
Samsung
. Elle fut distribuée gratuitement à un million d'élèves britanniques de 11 et 12 ans.

Le nom rend hommage au précédent succès du groupe dans ce domaine, le microordinateur à vocation pédagogique
BBC Micro
des années 1980, l'équivalent britannique de par son adoption à nos microordinateurs
Thomson MO5
et
TO7
inondant écoles, collèges et lycées à la fin de cette décennie dans le cadre du plan
IPT
(
I
nformatique
P
our
T
ous)
.

129621296112960La carte
micro:bit
dans sa version 1 inclut :
  • un afficheur, grille programmable de 5×5= 25 diodes rouges adressables, bien adapté pour l'affichage de motifs éventuellement animés ou encore de texte défilant
  • nombre de capteurs intégrés :
    • capteur de luminosité
      (lié aux diodes)
    • capteur de température
      (sur le processeur)
    • 2 boutons poussoirs
      A
      et
      B
      programmables de part et d'autre, comme sur les premières manettes et consoles de jeux portables de chez
      Nintendo
    • accéléromètre 3D, permettant de détecter les variations d'accélération et par conséquence diverses actions : secouer, pencher, chute libre, ...
    • boussole magnétique 3D, pour détecter cette fois-ci les champs magnétiques
  • connectivité
    Bluetooth 4.0
    basse énergie 2,4 GHz maître/esclave


12277La carte
micro:bit
utilise un connecteur
micro-USB
et ta calculatrice un
mini-USB
.

Pour relier les deux une solution est d'adjoindre un adaptateur
USB A
femelle ↔
USB mini-B OTG
mâle
au câble
micro-USB
venant avec ta carte
micro:bit
, testée avec succès.

1296512964Pour moins d'encombrement, tu as aussi la solution d'utiliser un câble direct, un
USB micro-B
mâle ↔
USB mini-A
mâle, disponible par exemple chez
StarTech
et que nous avons testé avec succès.

Pour pouvoir contrôler ta carte
micro:bit
à partir de tes scripts,
Texas Instruments
te propose des modules
Python
complémentaires à installer sur ta calculatrice. Le constructeur en met 9 à ta disposition, et ces modules te permettent chacun d'accéder à tout ou partie des modules ou classes correspondants dans le :
  • mb_butns → microbit.buttons
  • mb_disp → microbit.display
  • mb_grove
  • mb_music → music
  • mb_neopx → neopixel
  • mb_pins
  • mb_radio → radio
  • mb_sensr

Nous avions même vu qu'il était parfaitement possible depuis ta
TI-83 Premium CE Edition Python
de faire exécuter du code
Python
totalement arbitraire à la carte
micro:bit
, permettant ainsi d'accéder à des fonctions
Python
non exposées par les modules de
Texas Instruments
, ou même d'y définir ses propres fonctions.

Voici justement une fonction exécutant directement sur la carte
micro:bit
connectée le code
Python
passé en paramètre sous forme de chaîne de caractère, ainsi que de quoi en récupérer le résultat éventuel :
Code: Tout sélectionner
from ti_hub import *

def mb_run(code):
  send('\x05') # enter paste mode (Ctrl-E)
  send(code)
  send('\x04') # exit paste mode (Ctrl-D)

def mb_get():
  return get().split("\r\n")[-3]

C'était justement l'occasion d'explorer un peu plus profondément les possibilités de la
micro:bit
, et ce fut hélas extrêmement décevant.

Rappelons que les interpréteurs
MicroPython
ou similaires font appel à 3 types de mémoires avec les rôles suivants :
  • la mémoire de stockage qui accueille et conserve tes scripts
  • le stack
    (pile)
    qui, à l'exécution, accueille les références vers les objets créés
  • le heap
    (tas)
    qui, à l'exécution, accueille le contenu de ces objets
En gros le
stack
limite donc le nombre d'objets différents pouvant exister simultanément en mémoire, alors que le
heap
limite la taille globale occupée par le contenu de ces objets.

Le langage
Python
a toutefois le gros défaut d'être très gourmand en mémoire, le moindre petit objet de rien du tout créé gaspillant une place énorme. Voici quelques références de tailles pour les plateformes 32 bits :
  • pour un entier nul :
    24
    octets déjà...
  • pour un entier court non nul
    (codable sur 31 bits + 1 bit de signe)
    :
    28
    octets
  • pour un entier long :
    • 28
      octets
    • +
      4
      octets pour chaque groupe de 30 bits utilisé par son écriture binaire au-delà des 31 bits précédents
  • pour une chaîne:
    • 49
      octets
    • +
      1
      octet par caractère
  • pour une liste :
    • 64
      octets
    • +
      8
      octets par élément
    • + les tailles de chaque élément

En pratique, le
heap
est donc bien souvent le facteur limitant. Nous l'avions donc testé en priorité sur
BBC micro:bit
:
Code: Tout sélectionner
mb_run("import gc")
mb_run("a,f=gc.mem_alloc(),gc.mem_free")
mb_run("a")
a=int(mb_get())
mb_run("f")
b=int(mb_get())
[a,f,a+f]


Et voilà, nous constations en effet que l'interpréteur de la
micro:bit
offrait un
heap (tas)
Python
de seulement
10 Ko
de capacité, avec en pratique juste
8 Ko
et quelques de libres... :#roll#:

Une capacité absolument ridicule, inférieure à ce qu'offrent les interpréteurs
Python
des calculatrices graphiques :
  1. 4,100 Mo
    :
    TI-Nspire CX II
    +
    TI-Nspire CX
  2. 2,068 Mo
    :
    TI-Nspire CX II
  3. 2,050 Mo
    :
    TI-Nspire CX II
    +
    TI-Nspire CX
    +
    TI-Nspire
  4. 1,033 Mo
    :
    Casio Graph 90+E
  5. 1,014 Mo
    :
    HP Prime
    (version alpha)
  6. 258,766 Ko
    :
    Casio Graph 35/75+E
    (appli CasioPython)
  7. 101,262 Ko
    :
    Casio Graph 35+E II
  8. 64,954 Ko
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  9. 33,545 Ko
    :
    NumWorks
  10. 32,648 Ko
    :
    Casio Graph 35+E II
    (appli CasioPython)
  11. 23,685 Ko
    :
    TI-83 Premium CE + TI-Python
  12. 20,839 Ko
    :
    TI-83 Premium CE + TI-Python
  13. 18,354 Ko
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
  14. 8,240 Ko
    :
    BBC micro:bit


La
micro:bit
permettait sans aucun doute un large éventail de projets grâce à ses capteurs et actionneurs, mais chaque projet pris individuellement ne pouvait pas aller bien loin, devant sans doute se limiter essentiellement à de l'utilisation très légère des fonctions fournies. Tout élève suffisamment intéressé pour avoir envie d'approfondir sera rapidement confronté à des erreurs de mémoire de plus en plus difficiles et ennuyantes à contourner, et peut-être même pire dégoûté de toute poursuite dans cette branche. :mj:

Mais rien de surprenant lorsque l'on sait que la
micro:bit
utilise un microcontrôleur
nRF51822
de chez
Nordic Semiconductor
, avec les spécifications suivantes :
  • processeur
    32 bits ARM Cortex-M0
    cadencé à
    16 MHz
  • mémoire de stockage
    Flash
    d'une capacité de
    256 Kio
  • mémoire de travail
    RAM
    d'une capacité de
    16 Kio
    , et voilà qui explique tout... :'(

13451Mais pour cette année 2021 arrive la nouvelle carte
micro:bit v2
.

Dépêchons-nous de voir ce qu'elle vaut. ;)

1345012961Et bien justement, comme tu peux le constater ci-contre elle utilise un tout nouveau microcontrôleur, le
nRF52833
, toujours de chez
Nordic Semiconductor
. Cette fois-ci nous avons des spécifications qui devraient nous permettre de respirer :
  • processeur
    32 bits ARM Cortex-M0
    cadencé à
    64 MHz
    au lieu de
    16 MHz
    soit 4 fois plus rapide ! :bj:
  • mémoire de stockage
    Flash
    d'une capacité de
    512 Kio
    au lieu de
    256 Kio
    soit 2 fois plus grande ! :bj:
  • mémoire de travail
    RAM
    d'une capacité de
    128 Kio
    au lieu de
    16 Kio
    soit 8 fois plus grande :bj:

Et ce n'est pas tout, nous constatons d'autres nouveautés sur cette face :
  • ajout d'un haut-parleur
  • ajout d'un microphone MEMs
  • bouton poussoir qui ne sert plus seulement à la réinitialisation
    (reset)
    , mais permet désormais également d'éteindre la carte
    (appui long)
    et de la rallumer
    (appui court)
  • l'antenne
    Bluetooth
    qui devient compatible
    BLE Bluetooth 5.0
    , contre seulement
    4.0
    auparavant

1344912962

Passons maintenant à l'autre face, car les nouveautés ne sont pas terminées. Ici nous avons donc en prime :
  • ajout d'une diode DEL indiquant l'état du microphone
  • ajout d'un bouton tactile sur le logo
    micro:bit
    , voici pourquoi il perd sa couleur au profit de contacts métalliques


Reste-t-il encore à confirmer en pratique que la capacité
RAM
accrue sert bien entre autres à augmenter le
heap
Python
, et dans quelle mesure.

Première chose absolument indispensable à faire, tu dois commencer par reprogrammer ta carte
micro:bit
avec le fichier
firmware
.hex
dédié fourni par
Texas Instruments
.

Ce
firmware
est conçu pour rajouter à ta carte
micro:bit
la capacité de communiquer via son port
micro-USB
avec ta calculatrice
TI-83 Premium CE Edition Python
ou
TI-84 Plus CE-T Python Edition
.

Normalement rien de bien compliqué, il te suffit juste de connecter ta carte à un ordinateur pour y copier le fichier en question, la carte redémarrant automatiquement en fin de copie pour exécuter le nouveau
firmware
.

13452
Sauf qu'ici ça ne marche pas. Le fichier
.hex
distribué par
Texas Instruments
n'est apparemment pas compatible
micro:bit v2
, nous obtenons l'émoticône d'erreur accompagnée du code
529
. :'(

Mais ne baissons pas les bras. Rendons-nous sur l'éditeur
Python
en ligne des cartes
micro:bit
, et importons-y le fichier
.hex
de
Texas Instruments
.

Déjà bonne nouvelle, le fichier est reconnu par l'éditeur, nous y obtenons en clair le code
Python
d'initialisation :
Code: Tout sélectionner
# version history
# 1.0 python functionality
# 1.1 Added TI LOGO and grove ranger
# 1.2 added handshake
# 1.3 added get_version
# 2.0 removed handshake and changed version to 2.0 for release in france

from microbit import *
from machine import time_pulse_us

ti = Image("07700:""07797:""77777:""07770:""00700")

def ranger(pin=pin0):
  pin.write_digital(1)
  pin.write_digital(0)
  pin.read_digital()
  t = time_pulse_us(pin,1,35000)
  print(t)

def get_version():
  print ("TI-Runtime Version 2.0")
 
display.show(ti,delay=10,wait=False)

1345413453Demandons donc à l'éditeur de nous générer un nouveau fichier
.hex
à partir de ce code.

Il y a espoir, cette fois sa copie sur
micro:bit v2
ne déclenche plus d'erreur, et affiche bien le logo de
Texas Instruments
. :)

Très bon signe, la
micro:bit v2
semble correctement se comporter, l'importation du module
microbit
ne déclenchant aucune erreur.

13455Mais confirmons en lui faisant faire quelque chose, comme afficher l'icône de Pac-man... bingo, ça marche ! :bj:
Code: Tout sélectionner
from microbit import *
from mb_disp import *
display.show("Image.PACMAN",delay=400,wait=True)

Nous te mettons ci-dessous dans les ressources directement le fichier
.hex
corrigé, désormais compatible à la fois
micro:bit v1
et
micro:bit v2
. :D

13456Finissons-en donc avec le test de la capacité
heap
Python
.

Pour l'exécution des scripts
Python
sur
micro:bit v2
nous bénéficions donc apparemment de
63 Ko
libres, pour une capacité totale de
64 Kio
.
Fantastique c'est 8 fois plus que les pauvres
8 Ko
de l'ancienne carte ! :bj:
  1. 4,100 Mo
    :
    TI-Nspire CX II
    +
    TI-Nspire CX
  2. 2,068 Mo
    :
    TI-Nspire CX II
  3. 2,050 Mo
    :
    TI-Nspire CX II
    +
    TI-Nspire CX
    +
    TI-Nspire
  4. 1,033 Mo
    :
    Casio Graph 90+E
  5. 1,014 Mo
    :
    HP Prime
    (version alpha)
  6. 258,766 Ko
    :
    Casio Graph 35/75+E
    (appli CasioPython)
  7. 101,262 Ko
    :
    Casio Graph 35+E II
  8. 64,954 Ko
    :
    NumWorks
    (firmware Omega + appli KhiCAS)
  9. 63,024 Ko
    :
    BBC micro:bit v2
  10. 33,545 Ko
    :
    NumWorks
  11. 32,648 Ko
    :
    Casio Graph 35+E II
    (appli CasioPython)
  12. 23,685 Ko
    :
    TI-83 Premium CE + TI-Python
  13. 20,839 Ko
    :
    TI-83 Premium CE + TI-Python
  14. 18,354 Ko
    :
    TI-83 Premium CE Edition Python / TI-84 Plus CE-T Edition Python
  15. 8,240 Ko
    :
    BBC micro:bit v1

63 Ko
c'est quasiment le double de ce qu'offre la
NumWorks
, et également 3,5 fois plus que ce qu'offre la
TI-83 Premium CE Edition Python
, tu te rends compte ? :D

La capacité du
heap
Python
de la
TI-83 Premium CE Edition Python
est en effet un gros point faible. Mais ici en lui adjoignant une
BBC micro:bit v2
tu multiplies la taille de
heap
utilisable par 4,5 ! :bj:
De quoi approfondir des projets
Python
sur cette machine, à condition de distribuer correctement les différents objets
Python
créés entre le
heap
interne de la calculatrice et le
heap
externe de la carte, et bien sûr les faire interagir correctement. ;)

Malheureusement, à la différence nous n'avons à ce jour pas accès au code source des modules
micro:bit
additionnels de la
TI-83 Premium CE Edition Python
, ni à aucun outil permettant de générer ce genre de module, et ne pouvons donc ni corriger, ni améliorer, ni étendre ces modules. :'(

Nous sommes donc hélas dans l'incapacité de faciliter ton utilisation des nouveaux éléments de la
micro:bit v2
depuis ta calculatrice, notamment les microphone, haut-parleur et bouton tactile. La seule façon de les exploiter à ce jour sera de faire appel à la fonction
mb_run()
partagée plus haut, et lui passer en paramètre le code
Python
brut à exécuter par la carte.
Avec les difficultés que cela implique, ton script comportant alors à la fois du code
Python
qui sera exécuté dans le contexte de la calculatrice, et du code
Python
qui sera exécuté dans le contexte de la carte
BBC micro:bit
. Il ne faudra surtout pas confondre, les contextes des deux interpréteurs
Python
étant très différents. Pas le meilleur cadre, du moins pour débuter... :#roll#:



Téléchargements
:


Ressource
:
activités vidéo
micro:bit
pour
TI-83 Premimum CE
Lien vers le sujet sur le forum: BBC micro:bit v2 + mise à jour pour TI-83 Premium CE Python (Commentaires: 0)

Casio Concours dessin de Printemps Casio Graph Python et fx-92+SC

Nouveau messagede critor » 20 Jan 2021, 10:02

En décembre 2020,
Casio France
avait organisé à l'attention des enseignants un concours de Noël fort intéressant et joliment doté.
Il fallait programmer un dessin de Noël sur au choix sur
fx-92+ Spéciale Collège
ou en
Python
sur
Graph 35+E II
et
Graph 90+E
.
Un événement réussi qui a incité à la création de très beaux scripts ! :bj:

Plusieurs enseignants avaient comme nous réagi à l'événement en mentionnant qu'une ouverture des participations aux élèves aurait été très pertinente sur ce genre de concours.

Message visiblement reçu cinq sur cinq en un temps record,
Casio
nous lance déjà un tout nouveau concours du même genre,
Comme un air de Printemps
, mais cette fois-ci justement ouvert aux seuls :
  • collégiens et collégiennes
  • lycéens et lycéennes, aussi bien en voie générale que technologique ou professionnelle
    (2nde, 1ère, Tle, CAP, BEP)

Il te suffit de réaliser un dessin sur le thème de la nature avec ta calculatrice
Casio
préférée.
Cela peut donc être une fleur, un arbre, un animal...

Aucune obligation d'achat puisque tu peux parfaitement utiliser également l'émulateur de la calculatrice que nous te remettons si besoin en ressource gratuite en fin d'annonce. ;)

9798Tu peux participer au choix dans les 2 catégories suivantes :
  • fx-92+ Spéciale Collège
    avec son application
    Algorithmique
    t'offrant un langage de tracé à la
    Scratch
  • Graph 35+E II
    ou
    Graph 90+E
    avec leur application
    Python
Attention dans ce dernier cas, pour pouvoir bénéficier des tracés en
Python
(module
casioplot
)
, et éventuellement du module de tracés relatifs
turtle
, ta calculatrice doit faire tourner la dernière version :
  • Graph 35+E II
    version
    3.40
  • Graph 90+E
    version
    3.50
Si ce n'est pas le cas nous te remettons ici aussi de quoi mettre à jour gratuitement ta calculatrice en fin d'annonce. :)

13248Un jury composé de professeurs de Mathématiques désignera dans chaque catégorie 3 grands gagnants.

Dans chacune des 2 catégories donc, le meilleur dessin gagne le superbe lot suivant d'une valeur d'environ
180€
: :bj:
1
disque dur externe
SSD
de
1 To
de capacité
+ 1
calculatrice graphique
Casio Graph
au choix

13244Le 2ème meilleur dessin gagne pour sa part le non moins superbe lot suivant d'une valeur d'environ
180€
: :D
1
enceinte
bluetooth
+ 1
calculatrice graphique
Casio Graph
au choix

Le 3ème meilleur dessin gagne quant à lui le lot suivant d'une valeur d'environ
140€
: :D
1
montre
Casio vintage
or
+ 1
calculatrice graphique
Casio Graph
au choix

9668La calculatrice graphique au choix pourra être une
Graph 35+E II
ou
Graph 90+E
.


1324612987Mais ce n'est pas tout. Dans chaque catégorie, les 10 premières participations reçues et n'ayant pas remporté un des gros lots précédents recevront un lot de participation : un sac en toile
Casio
rempli de cadeaux
(batterie USB externe, stylo, clé USB, ...)
, alors vite dépêche-toi ! :favorite:

Les participations sont ouvertes à compter du
mercredi 27 janvier
. Tu auras jusqu'au
lundi 8 mars 2021
inclus pour envoyer par courriel à
education-france@casio.fr
:
  1. une photo ou capture d'écran de ton dessin
  2. le script qui le réalise
  3. un justificatif de scolarité
    (photo/scan de ton carnet de correspondance, de ta carte de collégien/lycéen, ou de tout autre document que tu juges pertinent)

Tu manques d'inspiration ? Tu ne connais pas suffisamment ta calculatrice ?
Casio
se propose même de t'aider à gagner en t'accompagnant ce
mercredi 27 janvier
au cours de 2 ateliers en ligne au choix tout spécialement dédiés aux dessins de printemps sur ses calculatrices :
  • 14h-15h :
    appli
    Algorithmique
    sur
    fx-92+ Spéciale Collège

  • 15h-16h :
    appli
    Python
    sur
    Graph 35+E II
    et
    Graph 90+E
Ils correspondant donc bien aux 2 catégories de participations, petits aperçus ci-contre. :D

Tu peux également aller consulter les scripts des dessins d'enseignants pour le concours de Noël sur
fx-92+ Spéciale Collège
ainsi que sur
Graph 90+E
et
Graph 35+E II
, avec des arbres
(sapins)
et animaux
(cerfs et rennes)
rentrant parfaitement dans le thème. :)

Si tu préfères les fleurs nous en avons également tout un champ sur
fx-92+ Spéciale Collège
suite à notre concours de rentrée 2018. ;)

Bonne chance à toi ! :bj:

Peut-être te demandes-tu en passant comment joindre le script de ta
fx-92+ Spéciale Collège
alors que la machine ne dispose pas de port de communication ?... mais en fait rien de plus simple ! :bj:

Que tu utilises la calculatrice ou son émulateur il te suffira juste d'en exporter le contenu à l'aide d'un
QR Code
:
98039804
  1. obtenir la sauvegarde du contenu sous forme de
    QR Code
    en tapant
    SECONDE
    OPTN
  2. flasher le
    QR Code
    alors obtenu :
    • sur émulateur, il te suffit juste de cliquer le
      QR Code
      dans la fenêtre
      popup
      qui apparaît
    • sur calculatrice, si celle-ci génère 1 seul
      QR Code
      , il te suffit de le flasher avec l'outil de ton choix
    • sur calculatrice, si celle-ci génère une série de plusieurs
      QR Codes
      (au-delà d'une certaine taille de script)
      , il te faudra les flasher avec l'appli
      Casio Edu+
  3. dans la page web qui s'ouvre, de cliquer sur l'icône d'envoi par courriel
Si besoin des tutoriels plus détaillés traitant séparément des 3 situations ici évoquées sont disponibles dans les ressources en fin d'annonce.

Superbe événement, à la coloration thématique fort bienvenue en cette période difficile. :D

De quoi te distraire et t'amuser quand tu rentres dans ta cage chaque soir à 18 heures ou prochainement pendant tes vacances d'hiver, et t'aider à rêver au retour du printemps et on espère avec lui de la liberté, merci
Casio
! :favorite:

Nous avons hâte de voir si tu vas être capable de faire mieux que les enseignants à Noël... ;)



Lien
:
inscription ateliers
mercredi 27 janvier


Téléchargments
:


Ressources
:

Mise à jour calculatrice
:


Émulateurs
:

  • Graph 90+E / fx-CG50
    version
    3.50
    à installer sur
    Windows
    /
    Mac

    (période d'essai gratuite sans engagement de 90 jours, prolongeable gratuitement si besoin jusqu'au
    31 août 2021
    si déjà entamée ou épuisée)
  • Graph 90+E
    version
    3.50
    pour clé
    USB
    d'émulation officielle

Transfert de données
:

Mise à jour calculatrice
:


Émulateurs
:


Transfert de données
:

Emulateur
:


Transfert de données
:



Source
:
https://www.casio-education.fr/actualit ... mps-casio/
Lien vers le sujet sur le forum: Concours dessin de Printemps Casio Graph Python et fx-92+SC (Commentaires: 19)

TI-z80 Nouveau clavier TI-84 Plus CE pour saisie naturelle fraction

Nouveau messagede critor » 19 Jan 2021, 21:59

Rentrée 2015,
Texas Instruments
lance ses formidables
TI-83 Premium CE
pour la France et ses voisins francophones,
TI-84 Plus CE-T
pour le reste de l'Europe, et
TI-84 Plus CE
pour le reste du monde.

Comme détaillé ci-contre,
TI-83 Premium CE
et
TI-84 Plus CE
ne partageaient pas le même clavier.
Plusieurs différences, notamment sur la 5ème ligne en partant du haut :
  • la
    TI-83 Premium CE
    met en avant la saisie des fractions en écriture naturelle, de quoi basculer entre écritures exacte et décimale, la résolution d'équations et les matrices
  • les
    TI-84 Plus CE
    mettent quant à elles en avant les fonctions trigonométriques, la fonction inverse et les applications, reléguant ainsi tout ce qui précède à des fonctions secondaires ou menus

Saisir une fraction en écriture naturelle sur
TI-84 Plus CE
était donc beaucoup plus difficile que sur
TI-83 Premium CE
. Il fallait invoquer le menu déroulant de l'écran de calculs avec
alpha
y=
, puis choisir
1
.

Manipulation à 3 touches peu intuitive puisque rien au clavier n'indiquait la présence de ce menu, et un gros point faible également par rapport à la concurrence qui propose la fonctionnalité directement au clavier. :mj:

12711Avec le nouveau modèle européen de la rentrée 2020, la ,
Texas Instruments
s'attaquait enfin à ce problème. :)

Un nouveau raccourci
alpha
X,T,θ,n
était en effet indiqué au clavier, permettant donc en seulement 2 touches la saisie de fractions en écriture naturelle, raccourci géré par le système à compter de la version
5.3.0
. :D

Les raccourcis historiques
2nd
et
2nd
pour aller en début et fin de ligne devenaient eux aussi enfin indiqués au clavier.

L'Amérique du Nord et le reste du monde sont sur le point de bénéficier à leur tour de ces améliorations ; de nouvelles
TI-84 Plus CE
avec ces nouvelles indications de raccourcis au clavier commencent à apparaître ! :bj:

On peut noter que ces nouvelles
TI-84 Plus CE
viennent avec un tout nouveau format de numéro de série qui n'indique plus en clair le timbre à date ni la révision matérielle, ici
B27400A89
.
Voilà qui ne nous facilitera pas la vie à l'avenir... :#roll#:

Selon notre analyse très préliminaire de ce nouveau format, dont vous pouvez trouver plein d'exemples ici :
  • la lettre
    B
    initiale indique l'année d'assemblage, ici
    2020
    :
    • A=2019
    • B=2020
  • les 2 chiffres suivants
    27
    indiquent la semaine d'assemblage dans l'année, et donc ici 27ème semaine de 2020, soit en gros début juillet 2020
  • le caractère suivant
    4
    indique le type de calculatrice, ici une
    TI-84 Plus CE
    :
    • 4 ou T = TI-84 Plus CE
    • 5 = TI-84 Plus
    • 6 = TI-83 Plus
  • et les 5 caractères suivants constituent un numéro de série en hexadécimal


Crédits photos
:
https://www.ebay.com/itm/293962257591 (merci
mr womp womp
)
Lien vers le sujet sur le forum: Nouveau clavier TI-84 Plus CE pour saisie naturelle fraction (Commentaires: 6)

Casio Scripts concours dessin Noël Casio Graph Python

Nouveau messagede critor » 19 Jan 2021, 10:45

Du 9 au 15 Décembre 2020,
Casio France
avait organisé à l'attention des enseignants un concours de Noël fort intéressant et joliment doté.
Il fallait programmer un dessin de Noël au choix :
  • sur calculatrice
    fx-92+ Spéciale Collège
    ou son émulateur
    (langage à la
    Scratch/Logo
    )
  • en
    Python
    sur
    Graph 35+E II
    ,
    Graph 90+E
    ou leur émulateur

13237Nous t'avions partagé les scripts
Python
Graph 90+E
gracieusement fournis par 3 participants dont les 2 grands gagnants. :D

Florian Allard
alias , grand gagnant, utilisait le module de tracés relatifs
turtle
sur
Graph 90+E
.

Il nous dessinait une scène de
Noël
très complète. Tout y était, exploitant à fond le large écran de la
Graph 90+E
: :bj:
  • le sapin décoré de guirlandes et coiffé d'une étoile
  • le renne tirant un traineau recevant une pluie de cadeaux

Etaient tracés dans l'ordre par le code ci-après :
  1. le renne avec :
    1. sa patte arrière droite
    2. son dos
    3. ses oreilles
    4. ses bois
    5. sa tête
    6. son torse
    7. sa patte avant droite
    8. sa patte avant gauche
    9. son abdomen
    10. sa patte arrière gauche
  2. le traineau
  3. le harnais
  4. le sapin avec :
    1. son feuillage
    2. ses guirlandes
    3. ses boules
    4. son étoile
  5. les 4 paquets cadeaux avec pour chacun :
    1. la boîte
    2. le ruban

Remarquable, on ne repérait quasiment pas d'élément géométrique remarquable, témoin du soin et de la précision apportés au tracé ! :bj:

Code: Tout sélectionner
from turtle import *
hideturtle()
penup()
goto(-110,-50)
pendown()
#4  me patte
rt(40)
penup()
for i in range(30):
  fd(1/4)
  lt(1/2)
pendown()
for i in range(30):
  fd(1)
  rt(3-i/15)
for j in range(4):
  for i in range(10):
    fd(1/2)
    lt(3)
  lt(60)
lt(120)
for i in range(10):
  fd(1/2)
  rt(3)
lt(110)
for i in range(20):
  fd(1)
  rt(1.5)
#fd(30)
lt(50)
for i in range(25):
  fd(0.6)
  rt(2)
for i in range(15):
  fd(1)
  lt(3)
for i in range(30):
  rt(12)
  fd(1/2)
for i in range(15):
  fd(1)
  lt(4)
for i in range(30):
  fd(1)
  rt(i//10)
lt(30)
for i in range(40):
  fd(1/2)
  rt(i//10)
setheading(0)
penup()
fd(-15/2)
pendown()#les oreilles
for i in range(40):
  fd(((400-10*i)//160)/2)
  lt(4)
lt(290)
#for i in range(42):
  #fd((10*i)//160)
  #lt(4.2)
#penup()
#for i in range(42):
  #fd(-(10*(28-i))//160)
  #lt(-4.2)
#pendown()
for i in range(40):
  fd(((10*i)//160)/2)
  lt(4)
penup()
rt(90)
#fd(5)
lt(90)
fd(-5/2)
pendown()
#les bois
#penup()
rt(110)
fd(1)
#pendown()
rt(90)
for i in range(20):
  fd(1)
  rt(1)
lt(20)
for j in range(3):
  rt(90)
  #for i in range(20):
    #fd(3)
    #lt(2+20-2*i)
  for i in range(10):
    fd(3/2)
    lt(2+10-i)
  for i in range(4):
    fd(1/2)
    lt(36)
  lt(10)
  for i in range(9):
    fd(1)
    rt(1+2*i)
lt(40)   
for i in range(80):
  fd(1/2)
  rt(2)
for i in range(10):
  fd(1/2)
  lt(18)
for i in range(30):
  fd(1/2)
  lt(1)
for i in range(20):
  fd(1/2)
  rt(3)
#fin des bois
penup()
setheading(-90)
fd(15/2)
lt(90)
fd(1)
pendown()
setheading(240)
pensize(2)
for j in range(2):
  for i in range(40):
    fd(1/12)
    rt(3)
  rt(60)
pensize(1)
setheading(90)
penup()
fd(15/2)
lt(90)
fd(1)
lt(75)

pendown()
rt(60)
for i in range(20):
  fd(1/2)
  lt(2)
lt(40)
for i in range(30):
  fd(1/2)
  rt((30-i)//7)
lt(70)
for j in range(4):
  for i in range(10):
    fd(1/2)
    lt(5)
  lt(40)
rt(0)
#for j in [1,-1]:
  #for i in range(30):
    #fd(j)
    #lt(4*j)
fd(5/2)
rt(50)
fd(1)
lt(70)
for i in range(25):
  fd(1)
  lt((50-5*i)/3.7)
lt(70)
for j in range(2):
  for i in range(10):
    fd(1)
    rt(2)
  lt(40)
rt(50)
fd(7/2)
fd(-7/2)
rt(40)
#1  re patte
for j in range(2):
  for i in range(30):
    fd(1/2)
    rt(1)
  lt(70)
lt(20)
fd(5)
rt(200)
for j in range(4):
  for i in range(10):
    fd(1/2)
    lt(3)
  lt(60)
lt(100)
for j in range(2):
  for i in range(30):
    fd(-1/2)
    rt(-1)
  rt(70)
  penup()
#2  me patte
#lt(90)
fd(15/2)
#pendown()
lt(100)
pendown()
for j in range(2):
  for i in range(30):
    fd(1/2)
    rt(1)
  lt(50)
lt(30)
fd(5)
rt(190)
for j in range(4):
  for i in range(10):
    fd(1/2)
    lt(3)
  lt(60)
lt(100)
for j in range(2):
  for i in range(30):
    fd(-1/2)
    rt(-1)
  rt(60)
#bas du corps
rt(90)
fd(5/2)
fd(-5/2)
rt(120)
for i in range(50):
  fd(1/2)
  lt(1/4)
lt(90)
penup()
fd(15/2)
pendown()
rt(190)
#3  me patte
for i in range(40):
  fd(1/2)
  lt(2-i/20)
rt(0)
for i in range(30):
  fd(1/2)
  rt((100-3*i)/30)
lt(0)
for j in range(4):
  for i in range(10):
    fd(1/2)
    lt(3)
  lt(60)
lt(120)
for i in range(10):
  fd(1/2)
  rt(3)
lt(90)
for i in range(30):
  fd(1/2)
  lt(1)
lt(10)
for i in range(30):
  fd(1/2)
  rt(1+i//15)
rt(20)
for i in range(30):
  fd(1/2)
  lt(1+i//15)



from turtle import *
hideturtle()
penup()
setheading(0)
pencolor([120/255,60/255,0])
pensize(3)
goto(-80,-40)
pendown()
rt(35)
for i in range(45):
  fd(1/2)
  rt(1)
rt(90)
#bois
pensize(3)
pencolor([120/255,60/255,0])
for i in range(30):
  fd(1)
  lt(6)
rt(10)
fd(5)
lt(90)

for i in range(4):
  fd(10)
  rt(90)
  fd(3.5)
  rt(90)
  fd(10)
  lt(90)
  fd(20)
  lt(90)

rt(90)
for i in range(10):
  fd(0.6)
  rt(18)

fd(47*2+5)

for i in range(28):
  fd(1.45)
  rt(6)

rt(84)
for i in range(20):
  fd(1/2)
  rt(1)
fd(7/2)

setheading(0)
fd(90)

#arri  re
lt(90)
for i in range(30):
  fd(3/2)
  rt(i//10)

setheading(0)
for i in range(17):
  fd(1/2)
  lt(10)
fd(3/2)
penup()
fd(-3/2)
for i in range(17):
  fd(-1/2)
  lt(-10)
pendown()
setheading(160)
for i in range(38):
  fd(3)
  lt((15-i)/2)
for i in range(40):
  fd(1/2)
  lt((15-i))
 
penup()
setheading(0)
fd(105)
lt(90)
fd(20)
pendown()

setheading(160)
for i in range(38):
  fd(3)
  lt((15-i)/2)
for i in range(42):
  fd(1/2)
  lt((15-i))

lt(70)
fd(15/2)

pensize(2)
setheading(203)
for i in range(34):
  fd(3)
  rt(2-i/40)



from turtle import *
setheading(-30)
penup()
goto(110,-80)
hideturtle()
#pendown()
pencolor([0,205/255,0])
pensize(2)
for k in [-1,1]:
  penup()
  goto(110,-80)
  setheading(90)
  fd(15)
  setheading(90-120*k)
  fd(16)
  pendown()
  for j in range(4):
    for i in range(30):
      fd(1-j/5)
      lt(k*(1+i//20))
    rt(50*k)
    for i in range(10):
      fd(-1+j/5)
      lt(k*(-1-i//20))

    lt(50*k)
    for i in range(50):
      fd(1-j/5)
      lt(k*(i/30))
    rt(40*k)
    for i in range(40):
      fd(-1+j/5)
      lt(k*(-i//20))

    lt(70*k)
    for i in range(10):
      fd(1-j/5)
      lt(k*(1+i//20))
    rt(30*k)
    for i in range(40):
      fd(-1+j/5)
      lt(k*(-1-i//30))
    setheading(90-90*k-30*k+30*j*k)
  setheading(90-50*k)
  for i in range(30):
    fd(1/2)
    lt(k*(1+i//20))
  rt(40*k)
  for i in range(20):
    fd(-1/3)
    lt(k*(-1-i//20))

  lt(50*k)
  for i in range(30):
    fd(1/2)
    lt(k*(i/10))
  rt(60*k)
  for i in range(30):
    fd(-1/3)
    lt(k*(i/20))

  lt(20*k)
  for i in range(30):
    fd(1/2)
    lt(k*(1+i//20))
#guirlandes
penup()
goto(120,50)
pendown()
pencolor([1,0,0])

setheading(-140)
for i in range(6):
  pensize(5)
  fd(3)
  pensize(2)
  fd(3)
  rt(5)

setheading(-50)
for i in range(10):
  pensize(5)
  fd(3)
  pensize(2)
  fd(3)
  lt(6)
 
setheading(-150)
for i in range(12):
  pensize(5)
  fd(3)
  pensize(2)
  fd(3)
  rt(4)
 
setheading(-60)
for i in range(13):
  pensize(5)
  fd(3)
  pensize(2)
  fd(3)
  lt(6)
 
setheading(-120)
for i in range(15):
  pensize(5)
  fd(3)
  pensize(2)
  fd(3)
  rt(6)
 
setheading(-50)
for i in range(13):
  pensize(5)
  fd(3)
  pensize(2)
  fd(3)
  lt(6)

#boules
from random import randint
for coord in [(17,32),(-17,24),(-60,-10),(15,0),(-30,-40),(40,-50)]:
  penup()
  goto(coord[0]+110,coord[1]-10)
  pensize(20)
  pencolor([randint(1,10)/10,randint(1,10)/10,randint(1,10)/10])
  pendown()
  fd(1)

#etoile
penup()
goto(100,80)
pendown()
pencolor([220/255,220/255,40/255])
pensize(5)
setheading(0)
for i in range(5):
  fd(20)
  rt(72*2)




#paquets
from random import randint
for coord in [(0,20),(-30,-10),(-70,10),(-30,50)]:
  penup()
  goto(coord[0],coord[1])
  pendown()
  pensize(7/2)
  pencolor([randint(1,10)/10,randint(1,10)/10,randint(1,10)/10])
  setheading(randint(1,60)-30)
  for i in range(4):
    fd(20)
    lt(90)
  fd(20)
  lt(45)
  fd(15/2)
  lt(45)
  fd(20)
  lt(135)
  fd(15/2)
  fd(-15/2)
  rt(45)
  fd(20)
  lt(45)
  fd(15/2)
 
 
  penup()
  lt(45)
  pencolor([randint(1,10)/10,randint(1,10)/10,randint(1,10)/10])
  pensize(7/2)
  fd(10)
  #pendown()
  lt(90)
  fd(20)
  lt(45)
  fd(15/2)
 
  fd(-7/2)
  pendown()
  pensize(5/2)
  lt(45)
  fd(-10)
  fd(20)
  lt(90)
  fd(20)
  fd(-20)
  rt(90)
  fd(-10)
  rt(45)
  pensize(7/2)
  penup()
  fd(-4)
  rt(45)
  fd(-10)
  pendown()
  lt(90)
  fd(-10)
  fd(20)
  #ruban
  rt(45)
  fd(7/2)
  rt(15)
  for j in range(2):
    for i in range(30):
      fd(1/2)
      lt(2)
    lt(120)
    for i in range(30):
      fd(1/2)
      lt(2)
    rt(180)

13236
Thomas Fontaine
, 2ème grand gagnant qui s'était déjà illustré au 3ème défi de notre concours de rentrée 2019, utilise également le module
turtle
sur
Graph 90+E
.

Il nous dessinait cette fois-ci un buste de renne.

Un tracé façon 3D fil de fer, décomposant très artistiquement le tout en triangles et quadrilatères telle une sculpture sur bois.

Le script profitait avantageusement en taille de la symétrie verticale, n'ayant donc à décrire que le demi-buste qui sera itéré 2 fois.

Le plus remarquable était qu'une fois le tracé de chaque demi-buste commencé après un
goto()
et un couple
penup/pendown()
initial, à aucun moment la tortue ne se téléportait ou ne levait le stylo, superbe arabesque ! :D

Sur chaque demi-buste, étaient tracés dans l'ordre par le code reproduit ci-après:
  1. tête
  2. oreille
  3. cou
  4. poitrail
  5. bois

Code: Tout sélectionner
from turtle import *
pensize(2)
for k in [-1,1]:
  penup()
  goto(0,-50)
  pendown()
  hideturtle()

  setheading(90-90*k+30*k)
  fd(19)
  lt(90*k)
  fd(10)

  lt(60*k)
  fd(10)
  fd(-10)
  lt(40*k)
  fd(12)
  fd(-12)
  rt(100*k)

  rt(15*k)
  fd(10)
  rt(15*k)
  fd(10)
  rt(40*k)
  fd(15)
  lt(140*k)
  fd(17)
  fd(-17)
  rt(40*k)
  fd(20)
  fd(-20)
  rt(100*k)
  #oreille
  lt(15*k)
  fd(10)
  lt(60*k)
  fd(7)
  lt(100*k)
  fd(7)
  fd(-7)
  rt(210*k)
  fd(25)
  rt(163*k)
  fd(25)
  fd(-25)
  lt(48*k)
  fd(8)
  rt(65*k)
  fd(20)
  fd(-20)
  lt(50*k)
  fd(20)
  rt(115*k)
  fd(15)
  fd(-15)
  lt(30*k)
  fd(16)
  fd(-16)
  lt(30*k)
  fd(13)

  lt(90*k)
  fd(5)
  rt(110*k)
  fd(10)
  lt(30*k)
  fd(10)
  fd(-10)
  rt(30*k)
  fd(-10)
  lt(90*k)
  fd(20)
  rt(120*k)
  fd(7)
  lt(10*k)
  fd(12)
  fd(-12)
  rt(10*k)
  fd(-7)
  lt(130*k)
  fd(9)

  rt(60*k)
  fd(5)
  lt(45*k)
  fd(50)

  rt(165*k)
  fd(52)
  fd(-52)
  lt(165*k)
  #cou
  lt(140*k)
  fd(35)
  lt(70*k)
  fd(42)
  fd(-42)
  rt(30*k)
  fd(29)
  lt(45*k)
  fd(32)

  rt(40*k)
  fd(5)
  lt(22*k)
  fd(13)
  lt(20*k)
  fd(15)
  lt(40*k)
  fd(11)
  lt(108*k)
  fd(49)
  fd(-49)
# on est en haut de la tete
#bois
  rt(108*k)
  fd(-13)
  #debut des bois
  rt(110*k)
  fd(10)
  lt(90*k)
  fd(6)
  fd(-6)
  rt(130*k)
  fd(30)
  lt(90*k)
  fd(5)
  fd(-5)
  rt(60*k)
  fd(20)
  lt(90*k)
  fd(5)
  fd(-5)
  rt(40*k)
  fd(25)
  lt(165*k)
  fd(25)
  rt(43*k)
  fd(15)
  rt(24*k)
  fd(20)
  fd(-20)
  rt(120*k)
  fd(15)
  lt(90*k)
  fd(5)
  fd(-5)
  rt(45*k)
  fd(25)
  lt(165*k)
  fd(25)
  rt(45*k)
  fd(15)
  rt(45*k)
  fd(5)
  rt(90*k)
  fd(10)
  lt(90*k)
  fd(4)
  fd(-4)
  rt(120*k)
  fd(15)
  lt(165*k)
  fd(15)
  lt(30*k)
  fd(15)
  rt(75*k)
  fd(15)
  fd(-5)
  rt(70*k)
  fd(12)
  lt(160*k)
  fd(12)
  rt(30*k)
  fd(10)

1323413235Voici ci-contre ma propre participation, une forêt de
Noël
, envoyée juste pour le plaisir. ;)
Je ne souhaitais piquer de lot à personne et je l'ai bien dit, et c'est parfait puisque je gagne bien le seul lot de participation. :)

Ce script disposait d'un mode monochrome, et était compatible à la fois
Graph 35+E II
et
Graph 90+E
, même si c'était sur cette dernière qu'il révélait son plein potentiel.

Voici l'astuce utilisée pour détecter le type d'écran :
Code: Tout sélectionner
def init_casioplot():
  global color_screen, screen_w, screen_h
  set_pixel(0, 0, (0, 0, 255))
  col = get_pixel(0, 0)
  color_screen = col[0] != col[2]
  screen_w, screen_h = color_screen and (384, 192) or (128, 64)


Dans l'ordre, mon script utilisant la bibliothèque de tracé par pixels
casioplot
:
  1. faisait tomber la nuit :
    Il utilise ici 2 dégradés dans les tons de bleu pour représenter le sol et le ciel.
  2. allumait les étoiles
    (pixels blancs)
  3. plantait une forêt de sapins
    - nous allons y revenir
  4. décorait mon plus beau sapin :
    des disques de rayon 2 selon 3 couleurs de remplissage alternées, avec une couleur voisine pour la bordure rajoutant un peu de relief
  5. saupoudrait le tout de neige :
    des disques de rayon 1

La bibliothèque
casioplot
offre un nombre assez restreint de fonctions de tracé :
  • clear_screen()
    pour effacer l'écran en blanc
  • set_pixel(x,y,couleur)
    pour allumer un pixel dans une couleur
    (R,G,B)
    au choix
  • draw_string(x,y,string,couleur,taille)
    pour écrire du texte dans une couleur
    RGB
    et selon une taille de police au choix
    ("small", "medium" ou "large")

Ce n'est absolument pas un défaut, au contraire cela permet un travail absolument passionnant : la construction et optimisation de fonctions pour tracer chaque primitive. J'avais donc rajouté de quoi tracer des cercles, disques, mais également segments pour les sapins :
Code: Tout sélectionner
def draw_line(x1, y1, x2, y2, c):
  m, a1, b1, a2, b2 = 0, int(x1), int(y1), int(x2), int(y2)
  if (x2 - x1) ** 2 < (y2 - y1) ** 2:
    m, a1, a2, b1, b2 = 1, b1, b2, a1, a2
  if min(a1, a2) != a1: a1, b1, a2, b2 = a2, b2, a1, b1
  for k in range(a2 - a1 + 1):
    a, b = a1 + k, int(b1 + (b2 - b1) * k / ((a2 - a1) or 1))
    set_pixel((a, b)[m], (b, a)[m], c)

def draw_ellipse(x, y, rx, ry, c):
  for h in range(-int(ry), int(ry)+1):
    w = sqrt(max(0, rx*rx*(1-h*h/ry/ry)))
    x1, x2 = int(x - w), int(x + w)
    yc = int(y + h)
    set_pixel(x1, yc, c)
    set_pixel(x2, yc, c)
  for w in range(-int(rx), int(rx)+1):
    h = sqrt(max(0, ry*ry*(1-w*w/rx/rx)))
    y1, y2 = int(y - h), int(y + h)
    xc = int(x + w)
    set_pixel(xc, y1, c)
    set_pixel(xc, y2, c)

def fill_ellipse(x, y, rx, ry, c):
  for h in range(-int(ry), int(ry)+1):
    w = sqrt(max(0, rx*rx*(1-h*h/ry/ry)))
    x1, x2 = int(x - w), int(x + w)
    yc = int(y + h)
    draw_line(x1, yc, x2, yc, c)

def draw_circle(x, y, r, c):
  draw_ellipse(x, y, r, r, c)

def fill_circle(x, y, r, c):
  fill_ellipse(x, y, r, r, c)


La construction des sapins utilisait des similitudes, transformations géométriques conservant les rapports de distances.
Une similitude peut se décomposer en une isométrie
(transformation conservant les distances : translation, rotation, ...)
la plupart du temps suivie d'une homothétie
(agrandissement ou réduction)
.

Plus précisément, en partant d'un couple de seulement 2 points que l'on va appeler le tronc, 5 similitudes étaient appliquées pour créer 5 branches
(en bas à gauche, à gauche, en haut, à droite, en bas à droite)
.

En itérant le même processus sur chacune de ces branches, on faisait ainsi pousser l'arbre, le développant dans ces 5 directions.

Par exemple, sur la capture couleur ci-contre, nous avons de gauche à droite des arbres avec :
  • 1 itération
  • 3 itérations
  • 5 itérations
    (profitant pleinement des
    1 Mio
    de mémoire de tas
    Python
    ;) )
  • 4 itérations
  • 3 itérations

Pour l'exécution sur
Graph 35+E II
nous avions dû limiter le nombre d'itérations afin de ne pas exploser la mémoire de tas
Python
(heap)
ici limitée à
100 Kio
. Nous avons ici de gauche à droite :
  • 0 itération
    (donc le tronc initial nu)
  • 1 itération
    (donc le tronc avec ses 5 branches initiales)
  • 3 itérations
  • 2 itérations
  • 0 itération

Code: Tout sélectionner
from math import pi, sin, cos, exp, sqrt
import matplotlib.pyplot as plt
from random import *
from casioplot import *

def init_casioplot():
  global color_screen, screen_w, screen_h
  set_pixel(0, 0, (0, 0, 255))
  col = get_pixel(0, 0)
  color_screen = col[0] != col[2]
  screen_w, screen_h = color_screen and (384, 192) or (128, 64)

def transform(x, y):
  f = screen_h * 45 // 64
  return (x*f,screen_h-1-y*f)

def draw_line(x1, y1, x2, y2, c):
  m, a1, b1, a2, b2 = 0, int(x1), int(y1), int(x2), int(y2)
  if (x2 - x1) ** 2 < (y2 - y1) ** 2:
    m, a1, a2, b1, b2 = 1, b1, b2, a1, a2
  if min(a1, a2) != a1: a1, b1, a2, b2 = a2, b2, a1, b1
  for k in range(a2 - a1 + 1):
    a, b = a1 + k, int(b1 + (b2 - b1) * k / ((a2 - a1) or 1))
    set_pixel((a, b)[m], (b, a)[m], c)

def draw_ellipse(x, y, rx, ry, c):
  for h in range(-int(ry), int(ry)+1):
    w = sqrt(max(0, rx*rx*(1-h*h/ry/ry)))
    x1, x2 = int(x - w), int(x + w)
    yc = int(y + h)
    set_pixel(x1, yc, c)
    set_pixel(x2, yc, c)
  for w in range(-int(rx), int(rx)+1):
    h = sqrt(max(0, ry*ry*(1-w*w/rx/rx)))
    y1, y2 = int(y - h), int(y + h)
    xc = int(x + w)
    set_pixel(xc, y1, c)
    set_pixel(xc, y2, c)

def fill_ellipse(x, y, rx, ry, c):
  for h in range(-int(ry), int(ry)+1):
    w = sqrt(max(0, rx*rx*(1-h*h/ry/ry)))
    x1, x2 = int(x - w), int(x + w)
    yc = int(y + h)
    draw_line(x1, yc, x2, yc, c)

def draw_circle(x, y, r, c):
  draw_ellipse(x, y, r, r, c)

def fill_circle(x, y, r, c):
  fill_ellipse(x, y, r, r, c)

def horiz_gradient(x, y, w, h, col1, col2):
  for k in range(h):
    draw_line(x, y + k, x + w - 1, y + k, [col1[i] + (col2[i] - col1[i])*k//(h-1) for i in range(3)])

def cmath_exp(a):
  return exp(a.real) * (cos(a.imag) + 1j*sin(a.imag))

def similitude(u, v):
    v = 1j * (u - v)
    return lambda z: v*z + u

def generer_arbre(n):
  lf = (
    similitude(.2j, .2j + .5*cmath_exp(1j * pi / 7)),
    similitude(.22j, .22j + .45j*cmath_exp(1j * pi / 3)),
    similitude(.55j, .55j + .35*cmath_exp(1j * pi / 6)),
    similitude(.57j, .57j + .3j*cmath_exp(1j * pi / 3)),
    similitude(.7j, 1.2j - .01)
  )
  lz = [0j, 0.7j]
  lz1 = lz[:]
  for _ in range(n):
    lz2 = []
    for f in lf:
      lz2.extend([f(z) for z in lz1])
    lz.extend(lz2)
    lz1 = lz2
  return lz

def rotate_color(c):
  return (c[1], c[2], c[0])
   
def trace(d, nb_trees, nb_balls, nb_stars, nb_flakes):

  color_black = (0,) * 3
  color = color_screen and (255,) * 3 or color_black

  # fait tomber la nuit
  colors = (color_black, (0, 0, 127), (0, 127, 255))
  dy = screen_h / (len(colors))
  if color_screen:
    for k in range(len(colors) - 1):
      horiz_gradient(0, round(dy*k), screen_w, round(dy), colors[k], colors[k + 1])
    horiz_gradient(0, screen_h - 1 - round(dy), screen_w, round(dy), (0, 63, 127), color_black)
  dx = (screen_w - 1) / 2 / (nb_trees - 1)

  # allume les etoiles
  for k in range(nb_stars):
    set_pixel(randint(0, screen_w - 1), randint(0, screen_h - 1 - round(dy)), color)

  # plante une foret de sapins
  for p in range(d - nb_trees, d + 1):
    x0 = screen_w // 2 + (p < d and dx * ((d - p) % 2 and d + 1 - p or p - d))
    dy = screen_h / (len(colors)) * (d - p) / nb_trees
    lz = generer_arbre(p)
    for k in range(0, len(lz), 2):
      x1, y1 = transform(lz[k].real, lz[k].imag)
      x2, y2 = transform(lz[k+1].real, lz[k+1].imag)
      x1 += x0
      x2 += x0
      draw_line(x1, y1 - dy, x2, y2 - dy, (0, 160 * (1 - (d - p)//(nb_trees - 1)), 0))

  # decore mon plus beau sapin
  if color_screen:
    lz, r, color_in, color_out = lz[1::max(1, len(lz)//nb_balls)], 2, (0, 255, 255), (0, 0, 255)
    for z in lz:
      x, y = transform(z.real, z.imag)
      x += x0
      fill_circle(x, y, r, color_in)
      draw_circle(x, y, r, color_out)
      color_in, color_out = rotate_color(color_in), rotate_color(color_out)

  # saupoudre de neige
  if color_screen:
    for k in range(nb_flakes):
      fill_circle(randint(0, screen_w - 1), randint(0, screen_h - 1), 1, color)

init_casioplot()
trace(color_screen and 5 or 3, 5, 30, 100, 40)
show_screen()

Et puis c'était tout. Nous supposions qu'il y avait eu plus que 3 participants, mais les autres ne nous avaient à la différence et à notre connaissance rien partagé, ni en public ni en privé. :'(

13442Et bien tu n'attendras pas plus longtemps,
Casio
nous publie enfin aujourd'hui les scripts
Python
du concours. Et voici donc de suite ceux qui nous manquaient. :)

Isabelle Vanacker
retourne à l'utilisation du module
turtle
et nous dresse un sapin sous une nuit étoilée.

On note la répétition de motifs identiques ou similaires
(étoiles et triangles du sapin)
.

Mais c'est codé proprement puisque les répétitions sont tracées par appels d'une même fonction.

Voici par exemple la fonction pour les triangles du feuillage du sapin, en fait des triangles rectangles isocèles :
Code: Tout sélectionner
def triangle(t):
  forward(t/2)
  left(135)
  forward(sqrt((t*t)/2))
  left(90)
  forward(sqrt((t*t)/2))
  left(135)
  forward(t/2)


Ou encore la fonction pour les étoiles :
Code: Tout sélectionner
def etoile(x,y):
  up()
  goto(x,y)
  down() 
  for i in range(6):
    forward(10)
    left(120)
    forward(10)
    left(-60)



Le script suivant trace donc dans l'ordre :
  1. le sapin avec :
    1. les triangles de son feuillage, de haut en bas
    2. son tronc
  2. les étoiles

Code: Tout sélectionner
from turtle import *

pencolor("green")
pensize(5)

def triangle(t):
  forward(t/2)
  left(135)
  forward(sqrt((t*t)/2))
  left(90)
  forward(sqrt((t*t)/2))
  left(135)
  forward(t/2)

def arbre():
  pencolor("green")
  pensize(5)
  for i in range(4):
    triangle(50+20*i)
    up()
    goto(0,30-40*i)
    down()
  pencolor("brown")
  forward(10)
  left(90)
  forward(40)
  left(90)
  forward(20)
  left(90)
  forward(40)
  left(90)
  forward(10)

def etoiles():
  pencolor("yellow")
  pensize(2)
  etoile(-150,60)
  etoile(-100,10)
  etoile(-120,-40)
  etoile(-60,-80)
  etoile(100,50)
  etoile(140,30)
  etoile(160,-30)
  etoile(100,-70)
   
def etoile(x,y):
  up()
  goto(x,y)
  down() 
  for i in range(6):
    forward(10)
    left(120)
    forward(10)
    left(-60)

up()
goto(0,60)
down()
arbre()

up()
goto(-50,20)
down()
etoiles()

13441Et voici enfin le cadeau offert par
Isabelle Duval
, toujours tracé avec le module
turtle
sur
Graph 90+E
.

Son script suivant trace dans l'ordre :
  1. la boîte
  2. le ruban avec :
    1. son noeud
    2. le reste

Code: Tout sélectionner
from turtle import *

for i in range(4):
  forward(50)
  right(90)
forward(25)
circle(10)
right(90)
forward(25)
for j in range(3):
  right(90)
  forward(25)
  right(180)
  forward(25)
right(90)

Merci à tous et merci
Casio
, un concours très réussi qui a encouragé la création de très beaux scripts. :favorite:
A quand un concours similaire ouvert aux élèves, que l'on voit si ils sont capables de faire mieux ? ;)


Téléchargements
:

  1. script de
    Florian Allard / Afyu
  2. script de
    Thomas Fontaine
  3. script de
    Xavier Andréani / Critor
  4. script d'
    Isabelle Vanacker
  5. script d'
    Isabelle Duval

Source
:
https://www.casio-education.fr/contenus ... -plus-loin
Lien vers le sujet sur le forum: Scripts concours dessin Noël Casio Graph Python (Commentaires: 0)

-
Rechercher
-
Social
-
Sujets à la une
Comparaisons des meilleurs prix pour acheter sa calculatrice !
Découvre les nouvelles fonctionnalités en Python de l'OS 5.2 pour les Nspire CX II
Découvre les nouvelles fonctionnalités en Python de l'OS 5.5 pour la 83PCE/84+C-T Python Edition
Omega, le fork étendant les capacités de ta NumWorks, même en mode examen !
1234
-
Faire un don / Premium
Pour plus de concours, de lots, de tests, nous aider à payer le serveur et les domaines...
Faire un don
Découvrez les avantages d'un compte donateur !
JoinRejoignez the donors and/or premium!les donateurs et/ou premium !


Partenaires et pub
Notre partenaire Jarrety Calculatrices à acheter chez Calcuso
-
Stats.
711 utilisateurs:
>700 invités
>5 membres
>6 robots
Record simultané (sur 6 mois):
6892 utilisateurs (le 07/06/2017)

-
Autres sites intéressants
Texas Instruments Education
Global | France
 (English / Français)
Banque de programmes TI
ticalc.org
 (English)
La communauté TI-82
tout82.free.fr
 (Français)