[Admin]

Dans un article précédent nous découvrions la capacité de stockage de scripts Python de ta NumWorks, 4Kio.

Ces dernières semaines nous t'avons testé et présenté nombre de scripts publiés dans la bibliothèque NumWorks, dont pas mal de fonctions récursives dessinant des fractales.

En les testant nous avons pu nous rendre compte qu'il était très facile de générer des erreurs avec l'outil de visualisation en ligne, et que même si la vraie calculatrice s'en sortait nettement mieux ce n'était pas la panacée non plus.

Par exemple, une fonction factorielle(n) définie récursivement peut échouer à partir de n=9 pour la visualisation en ligne, et n=42 sur la calculatrice. Le premier cas est ridicule, et le deuxième reste problématique.

Devant ces limitations évidentes, une question se pose : mais quelle est donc la capacité de la mémoire de travail offerte par la NumWorks aux scripts Python ?
Mais nous n'avons pas ici de module permettant de récupérer des informations sur le matériel, alors comment faire ?

En arrivant à déclencher volontairement ces mêmes erreurs avec des scripts beaucoup plus simples, on peut noter que chaque entier Python utilise 4 octets mémoire (32 bits). Se basant sur cela, on peut alors développer un script remplissant la mémoire avec des tableaux d'entiers jusqu'à déclenchement d'une erreur à intercepter via une exception, et affichant ce à quoi on est arrivé.

Code: Select all

def mem():
  try:
    l = [0]
    while True:
      try:
        l = l + l[l[0]:]
      except:
        if l[0] < len(l)-1:
          l[0] = len(l)-1
        else:
          print("+", 4*len(l))
          l[0] = 4*len(l) + mem()
          break
  except:
    return 0
  return l[0]

Ci-contre, on note en effet que l'outil de visualisation en ligne ne dispose que de 6,5Kio de mémoire de travail, avec par ordre décroissant :

• un bloc contigu de 4Kio
• un bloc contigu de 2Kio
• ...

Aucune surprise donc aux problèmes rencontrés, il n'y a vraiment pas de quoi aller bien loin avec ça.

Mais passons à la vraie machine. Cela peut varier légèrement, mais en transférant et appelant notre script juste après un reset nous obtenons effectivement nettement mieux, dans les 13Kio, avec par ordre décroissant :

• deux blocs contigus dans les 4Kio chacun
• un bloc contigu dans les 2Kio
• ...

C'est effectivement mieux que le visualisateur en ligne, mais cela reste peu.
Aucune liste ne pourra donc à ce jour faire bien plus de 4Kio, et le volume total des données d'un script ne pourra excéder les 13Kio et quelques.

Notons qu'une image plein écran 16-bits (320x240x2) nécessite 150Kio. Même si cela pourrait être stocké de façon compressée, il faudra bien décompresser en mémoire à un moment ou à un autre.
Aussi la capacité offerte à ce jour nous semble assez insuffisante pour permettre le développement de projets de jeux et/ou retouche d'images, conformément à ce que promeuvent les derniers programmes scolaires sortis.

Nous avons donc 17Kio au total dédiés au Python, répartis en :

• 4Kio de mémoire de stockage des scripts
• 13Kio de mémoire de travail pour l'évaluation des scripts

C'est peu par rapport par exemple aux 28Kio de la TI-82 sortie en 1993, même si ils étaient certes partagés entre stockage et évaluation à la différence.

Mais rappelons que la puce STM32F412 de ta NumWorks offre :

• 1 Mio de mémoire Flash
• 256 Kio de mémoire RAM

Espérons que dans une prochaine version du système NumWorks le stockage des scripts Python pourra passer en mémoire Flash et donc survivre au reset ainsi qu'à l'activation puis désactivation du mode examen, et que l'espace de travail offert pour l'exécution des scripts pourra être augmenté en conséquence et de préférence encore davantage.

Lien : https://workshop.numworks.com/python/andreanx/mem

[Ti64CLi++]

As-tu vu le jeu de Pentomino, programmé en Python pour ta calculatrice Numworks? Ce jeu, sorti hier par jeclarim, est le premier jeu en Python pour cette calculatrice.

Mais savais-tu que ta calculatrice Numworks disposait de programme "natif" (codé en C ou C++) ?

En effet, il y a de cela six mois, jean-baptiste boric te sortait une adaptation du très célèbre jeu de TicTacToe, beaucoup plus connu sous le nom de Morpion.
Ce jeu est donc le premier à être codé en code "natif", ici C++.
Il se présente donc sous forme d'application, est accessible depuis le menu principal, et ne nécessite donc pas d'application tierce pour pouvoir être lancé

Le code source est disponible sur le repo github de Jean-Baptiste, ainsi que les informations pour la compilation et l’intégration de cette nouvelle application au menu du firmware de la Numworks

Jean-baptiste Boric l'a mis à jour très récemment, afin de le rendre compatible avec le dernier firmware Numworks en date.

[Admin]

loupiot nous signe aujourd'hui le tout premier véritable jeu Python pour ta calculatrice NumWorks, un jeu de morpion que tu lances tout simplement en tapant morpion().

Le jeu est prévu pour deux joueurs. Une fois lancé il vous suffit juste alternativement à toi et à ton camarade de jeu de taper le numéro de la case choisie tel qu'indiqué à l'écran, et de le valider avec

EXE

:
1 2 3
4 5 6
7 8 9

On peut regretter que la calculatrice ne dispose pas à ce jour de fonction permettant de récupérer/tester une touche pressée, obligeant donc de passer par la fonction input() et donc de valider systématiquement chaque entrée. C'est à priori handicapant pour certains types de jeux restant à coder à ce jour.

Petit bémol concernant maintenant spécifiquement ce jeu, même si cela n'enlève rien à l'exploit, il eut été beaucoup plus intuitif de numéroter les cases dans le même ordre que le pavé numérique, ce qui aurait permis de jouer les yeux fermés :
7 8 9
4 5 6
1 2 3

Lien : https://workshop.numworks.com/python/loupiot/morpion

[Admin]

Dans un article précédent, nous lancions l'idée d'une bibliothèque de fonctions graphiques pour ta NumWorks.

jamac nous sort la toute première, avec le tracé de cercles et de rectangles :

Au menu, 3 fonctions :

• grect(p,s,c), remplit un rectangle avec :
  
  • p : couple de coordonnées du sommet supérieur gauche
  • s : couple avec les longueur et largeur du rectangle
  • c, optionnel : triplet de couleurs rouge, vert et bleu, chacune étant un entier sur [0;255], (0,0,0) pour noir par défaut
  
• gcircle(p,r,c), remplit un cercle avec :
  
  • p : couple de coordonnées du centre du cercle
  • r : rayon du cercle
  • c, optionnel : triplet de couleurs rouge, vert et bleu, chacune étant un entier sur [0;255], (0,0,0) pour noir par défaut
• aacircle(p,r,c,g), remplit un cercle en utilisant de l'anti-aliasing (anticrénelage) comme tu peux voir ci-contre :
  
  • p : couple de coordonnées du centre du cercle
  • r : rayon du cercle
  • c, optionnel : triplet de couleurs rouge, vert et bleu, chacune étant un entier sur [0;255], (0,0,0) pour noir par défaut
  • g, optionnel : 1 par défaut

jamac te fournit même une petite démo démarrant automatiquement, un champ de tangentes (slope field) mais représenté avec des couleurs ce qui donne un joli dégradé.

Attention, le bon fonctionnement de cette bibliothèque nécessite le script utils.py fourni ci-dessous. Tu ne pourras pas obtenir d'aperçu sur le visualisateur en ligne qui ne gère pas à date les dépendances de scripts.

Liens :

• bibliothèque graphique graphics.py (nécessite utils.py)
• utils.py
• démo graphique graph_magic.py (nécessite graphics.py)

[Admin]

Aujourd'hui sur ta NumWorks, hawkinja te propose de faire dans le motif.

Le code est ici exécuté automatiquement.

Regarde les valeurs dans le script et tente de prendre le contrôle du motif comme si c'était un vieux bout de tissu, si t'es cap.

Lien : https://workshop.numworks.com/python/hawkinja/pattern