π
<-
Chat plein-écran
[^]

News 2022

News 2021
August (5)
July (1)
June (1)
May (3)
April (12)
March (4)

News 2020
August (1)
July (3)
June (2)
May (2)
April (7)
March (4)

News 2019
August (1)
June (1)
May (3)
April (7)
March (10)

News 2018
August (3)
July (7)
June (3)
May (8)
April (13)
March (5)

News 2017
August (1)
July (1)
May (10)
April (3)
March (4)

News 2016
August (12)
July (3)
June (8)
May (12)
April (7)
March (9)

News 2015
August (11)
July (7)
June (6)
May (10)
April (2)
March (6)

News 2014
October (12)
August (4)
July (3)
June (13)
May (14)
April (12)
March (15)

News 2013
October (30)
August (14)
July (8)
June (27)
May (12)
April (29)
March (19)
January (27)

News 2012
October (37)
August (40)
July (27)
June (19)
May (35)
April (34)
March (42)
January (46)

News 2011
October (22)
August (23)
July (14)
June (29)
May (44)
April (24)
March (27)

News 2010
August (6)
July (10)
June (4)
May (1)
April (2)
March (1)

News 2009
June (1)

Magic Light v1.0 pour nSpire CX(-II) et Casio Graph 90+E

New postby SlyVTT » 14 Jan 2022, 22:32

Lors d'une news précédente, nous vous informions de la réalisation en cours d'un puzzle game intitulé
Magic Light
sur
Casio Graph 90+E
par SlyVTT en remerciement du gain de cette machine lors du concours de rentrée 2021.

L'idée du jeu étant aussi fortement liée au thème du concours d'Automne de Planète Casio CPC #28 qui se résumait en un simple mot :
GLACIAL
et pour lequel un prototype de test avait été implémenté.

Le développement de
Magic Light
est désormais terminé, et nous sommes heureux de vous en faire une brève présentation, accompagnée de quelques infos supplémentaires.


En effet, depuis la précédente information, de l'eau a coulé sous les ponts, et le développement de la version 1.0 de Magic Light s'est accompagné de la réécriture du jeu pour le rendre compatible avec les TI nSpire CX/CX-II.

Ce n'est donc pas
une
release que nous annonçons aujourd'hui, mais
deux
. Oui Madame, vous avez bien entendu, deux versions pour le prix d'une seule.


Magic Light est un puzzle game et pour le coup une création originale tirant pleinement profit des écrans couleurs de la Graph 90+E et de la TI nSpire CX/CX-II comme nous allons le voir ensemble. Après un menu d'accueil stylé et animé, entrons donc dans le vif du sujet.

Une démo du gameplay sur Graph 90+E est disponible via cette petite vidéo capturé sur l'émulateur :


En tant que héro du jeu, tu te dois ici d'arpenter les différentes salles d'un donjon ... à la recherche des fragments de lumière dérobés aux villageois par le Sorcier Noir et ses 4 Magiciennes de Filles ... afin de ramener couleurs et joie disparues au village. Pour cela, tu dois te rendre dans le chateau forteresse du Magicien où il a caché son butin.

Mais les portes sont fermées et ne peuvent s'ouvrir que si tu résous le puzzle de lumière que te posera chaque salle. Autour de chaque salle sont donc disposés des portes ainsi que des capteurs réagissant à certaines couleurs. Chaque porte est connectée à un certain nombre de capteurs, de 1 à 3, et ne s'ouvre que si ils sont tous éclairés simultanément par les bonnes couleurs.

Pour cela tu disposes dans chaque salle de plusieurs éléments déplaçables avec les touches fléchées du clavier, après les avoir sélectionnés avec les touches ad-hoc correspondant au menu de bas d'écran :
  • le personnage à faire sortir de la salle
  • une boule de cristal émettant une lumière blanche, initialement au centre
  • les blocs filtrant la lumière et ne laissant passer que certaines couleurs : les blocs rouge, vert, bleu et noir

Image

Pour savoir quels capteurs sont associés à une porte, il te faut les éclairer. Un indicateur s'allumera alors au-dessus des portes concernées.

Image

Bien entendu, le château grouille de monstres en tout genre et le Sorcier ainsi que les Magiciennes feront tout pour te dissuader de reprendre leur butin et le ramener au village. Il te faudra donc faire preuve de prudence et de dextérité en plus de jugeote pour traverser cette épreuve.

Le moteur physique codé pour le jeu permet de projeter la forme correcte des faisceaux lumineux sur les murs et les obstacles, mais pas seulement :
  • selon les niveaux, des blocs fixes peuvent également être présents et bloquer le passage de la lumière
  • et les blocs filtrant la lumière peuvent être combinés pour former de nouvelles couleurs par synthèse additive

Il vous faudra donc réfléchir à deux fois pour positionner tout ce petit monde à la bonne place, sachant les monstres sont là pour vous embêter et ne vous veulent pas forcément que du bien.
Et il ne faudra pas oublier de ramasser les trésors, vous y trouverez des points de vie pour récupérer de la santé, mais aussi des points pour augmenter votre score, et surtout, n'oublions pas le plus important, les fragments de couleurs à récupérer pour sauver le village ...

Image

Les menus devraient être assez clairs pour vous permettre de jouer simplement.

Le jeu offre 3 niveaux de difficulté :
  • facile : avec 5 points de vie, permet de ne pas galérer
  • normal : avec 3 points de vie, permet de mieux ressentir la pression des monstres
  • hardcore : c'est simple, t'es touché ... t'es mort !!

Image


Il vous faudra donc réussir à parcourir les
33 niveaux
du jeu et affronter 1000 dangers afin de retrouver les
5 fragments du "Jewel of Colors"
et ainsi rapporter la lumière et les couleurs aux villageois.


Bien entendu les deux versions ne sont pas strictement similaires, les machines ayant des spécificité techniques très différentes. Néanmoins, comme visible sur les captures suivantes d'écran issues de la version nSpire, le design a été ajusté au mieux pour adapter le jeu le plus fidèlement possible à la TI nSpire.

Image Image
Image Image
Image


Nous vous souhaitons un très bon moment sur
Magic Light
, en espèrant que vous saurez rapporter la couleur au village.

Crafti, clone Minecraft TI-Nspire, porté sur Xbox

New postby critor » 13 Jan 2022, 12:10

Depuis plusieurs années, est le principal dévelopeur de , le
jailbreak
te permettant de lancer du code machine tiers sur les
TI-Nspire
.

Pour la rentrée 2015 justement
Vogtinator
t'avait sorti
Crafti
, un très impressionnant clone de
Minecraft
pour
Ndless
.

Te souviens-tu également de notre cher et très prolifique ? Il t'avait porté des émulateurs de consoles de jeux par 10aines pour
TI-Nspire CX
et
Ndless
, t'ouvrant ainsi la porte à plusieurs milliers de jeux sur ta calculatrice ! :favorite:

De façon générale, nombre de jeux pour nos calculatrices sont des adaptations ou portages de jeux sortis pour ordinateurs et consoles.

Et bien aujourd'hui
gameblabla
nous emmène pour une fois sur le chemin inverse ; il vient de réaliser un portage de
Crafti
pour la console de jeux
Microsoft Xbox
! :D

Ndless
ayant hélas cessé d'être adapté aux nouvelles mises à jour
TI-Nspire CX
depuis bientôt une année, retrouve donc maintenant sur ta
Xbox
les joies et plaisirs des
TI-Nspire Ndlessées
:

Téléchargements
:


Mise à jour TI-Nspire CX II 5.4.0

New postby critor » 07 Jan 2022, 00:00

15069Pour bien démarrer l'année 2022,
Texas Instruments
nous sort aujourd'hui une nouvelle mise à jour
5.4
pour ses calculatrices
TI-Nspire CX II
.

Le numéro de version complet est
5.4.0.257
, et la compilation a eu lieu le
11 novembre 2021
.

Elle fait donc suite à la version précédente compilée le
29 juin 2021
.
Attention, comme la version précédente
5.3.2
, cette nouvelle version
5.4
n'est pas compatible avec
Ndless r2018
, et son installation est comme à l'habitude bien évidemment sans aucun retour possible. Toute tentative de réinstaller une version inférieure te sera par la suite refusée.

Si tu choisis de mettre à jour ta calculatrice avec l'une de ces versions, tu renonces donc à
Ndless
pour une durée indéterminée, des jours, semaines, mois ou même années comme c'est déjà arrivé, nous l'ignorons.

Entre le changement de numérotation majeur de la version
5.4
et le fait que la publication
(et donc les tests de validation)
ont pris près de 2 mois, nous aurions pu nous attendre à de grandes nouveautés.

Cela ne semble toutefois pas être le cas. Le
changelog
officiel n'évoque vaguement que 2 choses :
Texas Instruments wrote:
  • améliorations des fonctionnalités « Mode examen »
  • diverses corrections de bugs mineurs

Nous avons cherché pendant plusieurs heures, aussi bien niveau mode examen que niveau bugs déjà rencontrés, mais n'avons strictement rien réussi à trouver comme nouveauté ou amélioration.

Il y a toujours les problèmes avec les images-ressources que tu importes dans tes documents via l'éditeur
Lua
du logiciel
TI-Nspire
.

Elles sont affichées correctement par les scripts
Lua
, mais sont inversées verticalement lors d'un affichage par les scripts
Python
via le module
ti_image
.

Pire, sur certaines images nous avons même avec une distorsion horizontale en prime... :(

Niveau
Python
, il y a toujours un
bug
bien violent avec la fonction
set_color()
de la bibliothèque
ti_draw
. Si jamais tu commets l'erreur de lui passer le paramètre de couleur sous la forme d'une liste au lieu d'un tuple, la calculatrice redémarre instantanément :
Code: Select all
from ti_draw import *
set_color(255, 0, 0) # ok

c = (255, 0, 0)
set_color(c) # ok

c = [255, 0, 0]
set_color(c) # reset



Téléchargements
:

Link to topic: Mise à jour TI-Nspire CX II 5.4.0 (Comments: 10)

Lib nSpireLTE (LiTe Engine) pour faciliter le dév natif

New postby SlyVTT » 03 Jan 2022, 13:30

Développer sur calculatrice est une activité passionnante et permet à de nombreux étudiants de mettre un pied dans le monde de la programmation. Très souvent le premier contact est réalisé via des langages de haut niveau directement intégrés aux machines, historiquement basés sur le langage BASIC, mais désormais très souvent via le langage PYTHON qui est intégré aux dernières générations de calculatrice de manière native.

Ces langages interprétés à l'exécution offrent comme principal avantage d'être relativement simples à approcher et ont souvent une courbe d'apprentissage adaptée aux débutants. Ils sont donc parfaits pour de la programmation simple dans le cadre scolaire ou pour développer de petits programmes rapidement. Un second avantage de ces langages est la mise à disposition d'un certain nombre de routines adaptées à la machine hôte afin de réaliser les opérations classiques dans un programme (vérifier si une touche est appuyée, créer un fichier et écrire dedans, lire les coordonnées de la souris ou du curseur, ...). Hélas, très souvent cette simplicité va de pair avec une relative lenteur du langage (car interprété, par opposition à compilé) et une certaine limitation dans les fonctions disponibles ou dans leur comportement. Apparaît donc très rapidement pour les plus passionnés une envie de plus d'ouverture pour des projets plus ambitieux tels que des jeux.

Une possibilité offerte sur un grand nombre de machines est de passer à la programmation dite "native", de plus bas niveau en langages compilés/assemblés tels que l'Assembleur (ou ASM) ou le C/C++. Ces langages offrent pour principaux avantages d'être particulièrement bien adaptés pour parler directement au matériel en présence. A cela s'ajouter qu'ils sont compilés, c'est à dire traduits directement en code interprétable par le processeur, sans de multiples couches logicielles intermédiaires, donnant très souvent un code nettement plus rapide et permettant de programmer à peu près tout ce que l'on veut, du moment que le matériel suit.


Malheureusement, ces langages ont un côté rebutant pour la simple et bonne raison que pour réaliser les opérations simples décrites précédemment, il n'y a généralement rien de prévu (ou le strict minimum), et il faut donc développer tout un panel de "fonctions de base" pour créer un programme utilisable. C'est très souvent ce point qui limite la percée de ces langages très puissants. Bien entendu, une fois ces fonctions disponibles, elles seront réutilisables dans le futur dans d'autres programmes, mais l'effort initial à fournir est considéré comme conséquent et en décourage plus d'un.


Heureusement, il existe des bibliothèques de fonctions développées par des passionnés qui permettent de créer beaucoup plus rapidement de beaux programmes en s'affranchissant de la partie "mains dans le cambouis". Nous pouvons par exemple citer la bibliothèque SDL supportée par de nombreuses architectures (PC/MAC/PS3/TI nSpire ...) et dont le but est d'offrir un panel de fonctions permettant de créer des jeux et/ou des programmes divers et variés.


SDL est une magnifique librairie, permettant de faire de nombreuses choses, mais est parfois un peu vécue comme le marteau pour tuer la mouche. Avoir à disposition un panel réduit de fonctions permettant de réaliser seulement quelques opérations simples nécessaires à tout programme qui se respecte, sans fioritures, permettrait de combiner la simplicité d’un langage de plus haut niveau sans alourdir inutilement le poids de l’exécutable généré en incorporant tout un lot de fonctions dont seulement 1 ou 2% seront utilisées par le programme en cours de développement.


Posons-nous quelques instants et soyons plein de compassion pour ce jeune développeur voulant mettre à profit sa belle calculatrice flambant neuve et ne sachant que faire. Quelle solution pour lui ?

Et bien, jeune (ou moins jeune d’ailleurs) possesseur de TI nSpire, sache qu’en lisant les lignes suivantes, ton avenir de développeur en langage natif va se dégager de ces gros nuages noirs et que le soleil rayonnera rapidement sur toi …

En effet, dans le cadre du développement de la bibliothèque GUI Toolkit NF pour TI nSpire, un certain nombre de ces fonctions de base ont été codées afin de créer les fondations du Toolkit (NF signifiant d’ailleurs au passage « New Foundation »). Ces fonctions sont intégrées dans l’ensemble de la bibliothèque mais peuvent être utilisées indépendamment du GUI Toolkit NF.

Il a donc été choisi de créer une variante légère de cette bibliothèque (appelée nSpireLTE avec LTE pour LiTe Engine) et offrant les fonctions de base pour créer des petits programmes en C++.

Cette bibliothèque LTE se compose de 4 modules :
-
KeyManagerLTE
: contenant les fonctions de bas niveau permettant de lire l’état du clavier de la TI nSpire
-
MouseManagerLTE
: contenant les fonctions de bas niveau permettant de lire l’état du touchpad de la TI nSpire (mouvement du curseur, click central et gestion des flèches)
-
TimeManagerLTE
: permettant de gérer les fonctions liées au temps sur la nSpire (timer, sleep, heure actuelle)
-
DebuggerLTE
: permettant de debugger des programmes en offrant un panel de fonctions pour réaliser des sorties de logs dans un fichier et tracker impitoyablement les bugs et plantages.



1) Installation :



L’installation et l’utilisation est on ne peut plus simple, il suffit de télécharger l’archive et de décompresser le fichier nSpireLTE.zip dans votre projet de manière à avoir un répertoire nSpireLTE dans l’arborescence de votre projet de développement.

Ensuite, il suffit d’inclure la librairie dans votre fichier contenant la fonction main() via une directive :

Code: Select all
#include "./nSpireLTE/nSpireLTE.hpp"
et le tour est joué. Piece of Cake !! Comme dirait nos amis outre Manche :-)


2) Les modules :



Comme précédemment annoncé, la nSpireLTE est composée de 4 modules dont le rôle est de couvrir 4 besoins très classiques en programmation. Chacun des modules sera détaillé par la suite.

Tous les modules fonctionnent de la même manière, on commence par les initialiser :
Code: Select all
   ...
    Module::Initialize();
   ...

puis on peut ensuite accéder à ses fonctions via :
Code: Select all
   ...
    Module::Fonction( parametres_fonctions ... );
   ...

Une fois l'utilisation du module terminée (généralement en fin de programme), on clos le module via:
Code: Select all
   ...
    Module::Close();
   ...

Vraiment facile à utiliser.


A) KeyManager


La gestion des événements liés au clavier est présent dans tous les programmes (ou presque) sur la TI nSpire. Il faut dire qu'avec toutes ces touches disponibles, il serait dommage de ne pas les utiliser.

Chaque touche possède un keycode selon l'image suivante Image

Le module KeyManager reprend à son compte la gestion de toutes les touches avec un marquage rouge. La nSpire étant une machine complexe, le module MouseManager (que nous détaillerons dans le prochain paragraphe) s'occupera quant à lui des touches marquées en bleu et en vert, toutes en rapport avec la zone du TouchPad.


Chaque touche possède 3 fonctions dédiées (par exemple pour la touche kbESC):
- KeyManager::kbESC() vaudra true (=1) si la touche est appuyée et false (=0) sinon.
- KeyManager::kbESC_Press_Event() vaudra true (=1) si la touche a été pressée depuis le dernier tour de KeyManager::Logic() et false (=0) sinon.
- KeyManager::kbESC_Release_Event() vaudra true (=1) si la touche a été relâchée depuis le dernier tour de KeyManager::Logic() et false (=0) sinon.

L'état du clavier est mis à jour via la fonction KeyManager::Logic() qu'il convient d'inclure dans la boucle de gestion des évènements.

A ces fonctions individuelles se rajoutent des fonctions plus globales :
- KeyManager::IsKeyPressEvent() vaudra true (=1) si une touche du clavier a été pressée depuis le dernier tour de KeyManager::Logic() et false (=0) sinon.
- KeyManager::IsAnyKeyPressed() vaudra true (=1) si une touche du clavier est pressée et false (=0) sinon.

Il est possible de réinitialiser l'état du driver avec un appel à KeyManager::ResetState();

Voici un exemple simple d'utilisation.

Code: Select all
#include <stdlib.h>
#include "./nSpireLTE/nSpireLTE.hpp"

int main(int argc, char **argv)
{
    KeyManager::Initialize();

   bool done = false;
   
   while (!done)
   {
      KeyManager::Logic();
      
      if (KeyManager::kbCTRL() && KeyManager::kbESC())
      {
         done = true;
      }
      
      if (KeyManager::kb8_Press_Event())
        {
            printf( " La touche [8] a ete pressee.\n" );
        }

        if (KeyManager::kb8_Release_Event())
        {
            printf( " La touche [8] a ete relachee.\n" );
        }
      
      if (KeyManager::kbDOT_Press_Event())
        {
            printf( " La touche [.] a ete pressee.\n" );
        }

        if (KeyManager::kbDOT_Release_Event())
        {
            printf( " La touche [.] a ete relachee.\n" );
        }
   }

    KeyManager::Close();

    return 0;
}



B) MouseManager


Le module MouseManager est très similaire au module KeyManager.

Pour les touches avec les keycodes "bleus", l'utilisation est strictement identique, seul l'appel se fait via MouseManager::kb.. au lieu de KeyManager::kb..

Les événements sont du même type, par exemple pour la touche flèche droite :
- MouseManager::kbRIGHT() vaudra true (=1) si la touche est appuyée et false (=0) sinon.
- MouseManager::kbRIGHT_Press_Event() vaudra true (=1) si la touche a été pressée depuis le dernier tour de MouseManager::Logic() et false (=0) sinon.
- MouseManager::kbRIGHT_Release_Event() vaudra true (=1) si la touche a été relâchée depuis le dernier tour de MouseManager::Logic() et false (=0) sinon.

Mais le rôle de MouseManager est aussi de gérer le TouchPad lorsque il est utilisé comme une souris (c'est à dire en passant le doigt dessus et en cliquant la partie centrale) :
- MouseManager::GetX() retourne la position X du curseur de souris (sans gestion de sa représentation graphique, valeur entre 0 et 320 pixels)
- MouseManager::GetY() retourne la position Y du curseur de souris (sans gestion de sa représentation graphique, valeur entre 0 et 240 pixels)
- MouseManager::GetB() retourne l'état du bouton de souris (true si cliqué et false sinon)

Il est possible de gérer la sensibilité du TouchPad via la fonction MouseManager::SetSensibility( valeur ) avec
valeur
comprise entre entre 0.1 et 10.
10 étant très (très) rapide et 0.1 très (très) lent. 3 est une bonne valeur a priori.

Encore une fois rien de mieux qu'un exemple simple.

Code: Select all
#include <stdlib.h>
#include "./nSpireLTE/nSpireLTE.hpp"

int main(int argc, char **argv)
{
    KeyManager::Initialize();
    MouseManager::Initialize();

   bool done = false;
   unsigned int MX;
   unsigned int MY;
   bool MB;
   
   MouseManager::SetSensibility( 3 );
   
   
   while (!done)
   {
      KeyManager::Logic();
      MouseManager::Logic();
      
      if (KeyManager::kbCTRL() && KeyManager::kbESC())
      {
         done = true;
      }
      
      MX = MouseManager::GetX();
      MY = MouseManager::GetY();
      MB = MouseManager::GetB();
      
      if (MB)
      {
         printf( " Mouse position is (%d, %d) - Button Clicked.\n", MX, MY );
      }
      else
      {
         printf( " Mouse position is (%d, %d).\n", MX, MY );
      }         
      
   }

    KeyManager::Close();
    MouseManager::Close();
   
    return 0;
}



C) TimeManager


TimeManager est le module responsable de la gestion des timers et du temps.

Si vous voulez bloquer le programme, TimeManager::Delay( valeur ) vous permettra de bloquer durant
valeur
millisecondes.
Si vous voulez avoir l'heure courante, TimeManager::GetCurrentTime( ) vous donnera toutes les informations nécessaires.

Il est à noter que le module TimeManager ne demande pas d'appel cyclique à une fonction Logic() pour fonctionner.

Code: Select all
#include <stdlib.h>
#include "./nSpireLTE/nSpireLTE.hpp"

int main(int argc, char **argv)
{
    KeyManager::Initialize();
    MouseManager::Initialize();
   TimeManager::Initialize();

   bool done = false;
   
   int Heure, Minute, Seconde;
   
   while (!done)
   {
      KeyManager::Logic();
      MouseManager::Logic();
      
      if (KeyManager::kbCTRL() && KeyManager::kbESC())
      {
         done = true;
      }
      
      TimeManager::GetCurrentTime( &Heure, &Minute, &Seconde );
      
      if (KeyManager::IsKeyPressEvent() || MouseManager::IsKeyArrowPressEvent())
      {
         printf( " [Pause for the next 5s]\n" );
         TimeManager::Delay( 5000 );
         printf( " [OK, Done end of the 5s]\n" );
      }
      
      printf( " Hello : current time is %d:%d:%d\n", Heure, Minute, Seconde );
   }

    KeyManager::Close();
    MouseManager::Close();
   TimeManager::Close();
   
    return 0;
}



D) Debugger


Le module Debugger est un peu particulier, mais tellement nécessaire. Programmer revient toujours à un moment où à un autre à chercher désespérément un bug et à essayer de comprendre pourquoi telle ou telle partie du code ne fonctionne pas comme prévu ou pis, fait crasher la machine.

Le module Debugger vise à proposer quelques routines pour aider à la résolution de ces soucis.

Le module Debugger permet de créer des fichiers dits de "Logs" afin de tracer les fonctions. Il est intimement lié au module TimeManager vu précédemment.

Par exemple, afin de savoir si un plantage se produit avant ou après une fonction, il suffit d'ajouter dans le code source :
Code: Select all
   ...
    Debugger::Log( "J'arrive juste avant la fonction à tester\n" );
   
   fonction_a_tester();
   
   Debugger::Log( "Je suis juste après la fonction à tester\n" );
   ...


Si dans le fichier de log vous avez bien les deux lignes inscrites, alors cette fonction n'est pas incriminée dans le plantage, sinon, il vous faudra analyser cette fonction plus finement, par exemple en y incorporant des lignes de logs supplémentaires, possiblement en y incluant des valeurs utiles.

Le module contient deux familles de fonctions:
- Debugger::Log( ...) : les fonctions de log sans horodatage
- Debugger::TimerLog( ...) : les fonctions de log avec horodatage permettant de garder une trace du temps écoulé depuis l'initialisation du module

Les fonctions se rapprochent des classiques "printf()" du C et permettent de multiples sorties de valeurs via les traditionnels "%d", "%l", "%s" et toutes les options de formatage de chaines.

Par défaut, le fichier log se nomme "DebugDefOut.txt.tns" et est situé à la racine de la nSpire, mais ce fichier peut être changé via un appel à la fonction : Debugger::SetDebuggerFile( nomdufichier )

Voici un exemple simple d'utilisation.

Code: Select all
#include <stdlib.h>
#include "./nSpireLTE/nSpireLTE.hpp"

int main(int argc, char **argv)
{
    KeyManager::Initialize();
   TimeManager::Initialize();
   Debugger::Initialize();

   bool done = false;
   
   int Heure, Minute, Seconde;
   
   MouseManager::SetSensibility( 3 );
   
   Debugger::Log( "Hello Dear Programmer\n" );   
   Debugger::TimerLog( "We will enter the Main Loop\n" );
   Debugger::TimerLog( "and start logging the actions.\n" );   
   
   while (!done)
   {
      KeyManager::Logic();
      MouseManager::Logic();
      
      if (KeyManager::kbCTRL() && KeyManager::kbESC())
      {
         done = true;
         Debugger::TimerLog( "CTRL+ESC pressed : ask for closure\n" );   
      }
      
      if (KeyManager::kb7_Press_Event())
      {
         Debugger::TimerLog( "[7] pressed\n" );
      }
      if (KeyManager::kb8_Press_Event())
      {
         Debugger::TimerLog( "[8] pressed\n" );
      }
      if (KeyManager::kb9_Press_Event())
      {
         Debugger::TimerLog( "[9] pressed\n" );
      }
      
      if (KeyManager::kb7_Release_Event())
      {
         Debugger::TimerLog( "[7] released\n" );
      }
      if (KeyManager::kb8_Release_Event())
      {
         Debugger::TimerLog( "[8] released\n" );
      }
      if (KeyManager::kb9_Release_Event())
      {
         Debugger::TimerLog( "[9] released\n" );
      }
   }

   Debugger::TimerLog( "We quit the Main Loop\n" );
   Debugger::TimerLog( "and will return to the OS.\n" );
   Debugger::Log( "Bye bye, and see you soon\n" );   

    KeyManager::Close();
   TimeManager::Close();
   Debugger::Close();
   
    return 0;
}



3) Conclusion :



La librairie nSpireLTE vise à offrir les fonctions de base nécessaires à l'écriture et au débogage de programmes pour la nSpire. Ce court article vise à expliquer les grandes lignes d'utilisation de chacun des 4 modules de la librairie, mais n'est aucunement exhaustif. Chacun des modules contient des fonctionnalités supplémentaires. Nous ne pouvons que vous inviter à regarder dans les fichiers
.hpp
si vous êtes intéressés et à découvrir l'ensemble des fonctions de chacun des modules.

En vous souhaitant un bon code et plein de beaux programmes pour la nSpire.
Last edited by SlyVTT on 14 Jan 2022, 21:49, edited 1 time in total.

Concours de l'Avent 2021 "l'énigme des 3 portes" : jour 29

New postby critor » 29 Dec 2021, 14:00

Concours
TI-Planet
de l'
Avent 2021

L'énigme des 3 portes
:
jour n°29



Viens rassembler les indices et bouts de code
Python
chaque jour de l'Avent ; sois parmi les premiers à passer l'une des portes pour gagner de superbes cadeaux de Noël ! :favorite:

15058La porte
NumWorks
s'ouvrira 2 fois. Dernier indice
NumWorks
ce
30 décembre
. Rendez-vous à partir de
14 heures
.
Code: Select all
from math import ceil

platform = ''
try: from sys import platform
except: pass

def nop(*argv): pass
show, wait = nop, nop
neg_fill_rect = False
has_color = True

try: # NumWorks, NumWorks + KhiCAS, TI-Nspire CX + KhiCAS
  import kandinsky
  fill_rect = kandinsky.fill_rect
  screen_w, screen_h = 320, 222
  neg_fill_rect = platform!='nspire' and platform!='numworks'
except:
  try: # TI
    import ti_draw
    try: # TI-Nspire CX II
      ti_draw.use_buffer()
      show = ti_draw.paint_buffer
    except: # TI-83PCE/84+CE Python
      wait = ti_draw.show_draw
    screen_w, screen_h = ti_draw.get_screen_dim()
    try: # check TI-83PCE/84+CE ti_draw 1.0 fill_rect bug
      ti_draw.fill_rect(0,0,1,1)
      def fill_rect(x, y, w, h, c):
        ti_draw.set_color(c[0], c[1], c[2])
        ti_draw.fill_rect(x, y, w, h)
    except: # workaround
      def fill_rect(x, y, w, h, c):
        ti_draw.set_color(c[0], c[1], c[2])
        ti_draw.fill_rect(x - 1, y - 1, w + 2, h + 2)
  except:
    try: # Casio Graph 90/35+E II, fx-9750/9860GIII, fx-CG50
      import casioplot
      casioplot.set_pixel(0, 0, (0, 0, 255))
      col = casioplot.get_pixel(0, 0)
      has_color = col[0] != col[2]
      screen_w, screen_h = has_color and (384, 192) or (128, 64)
      show = casioplot.show_screen
      def fill_rect(x, y, w, h, c):
        for dy in range(h):
          for dx in range(w):
            casioplot.set_pixel(x + dx, y + dy, c)
    except:
      try: # HP Prime
        import hpprime
        screen_w, screen_h = hpprime.grobw(0), hpprime.grobh(0)
        hpprime.dimgrob(1, screen_w, screen_h, 0)
        def col3_2_rgb(c, bits=(8,8,8), bgr=1):
          return c[2*bgr]//2**(8 - bits[0]) + c[1]//2**(8 - bits[1])*2**bits[0] + c[2*(not(bgr))]//2**(8-bits[2])*2**(bits[0] + bits[1])
        def fill_rect(x, y, w, h, c):
          hpprime.fillrect(1, x, y, w, h, col3_2_rgb(c), col3_2_rgb(c))
        def show():
          hpprime.strblit(0, 0, 0, screen_w, screen_h, 1)
        def wait():
          while hpprime.keyboard(): pass
          while not(hpprime.keyboard()): pass
      except:
        pass
if not neg_fill_rect:
  _fill_rect = fill_rect
  def fill_rect(x, y, w, h, c):
    if w < 0:
      x += w
      w = -w
    if h < 0:
      y += h
      h = -h
    _fill_rect(x, y, w, h, c)

def draw_image(rle, x0, y0, w, pal, zoomx=1, zoomy=1, itransp=-1):
  if not has_color:
    pal = list(pal)
    g_min, g_max = 255, 0
    for k in range(len(pal)):
      c = pal[k]
      g = 0.299*c[0] + 0.587*c[1] + 0.114*c[2]
      g_min = min(g_min, g)
      g_max = max(g_max, g)
      pal[k] = g
    for k in range(len(pal)):
      pal[k] = pal[k]<(g_min + g_max) / 2 and (0,0,0) or (255,255,255)
  i, x = 0, 0
  x0, y0 = int(x0), int(y0)
  nvals = len(pal)
  nbits = 0
  nvals -= 1
  while(nvals):
    nvals >>= 1
    nbits += 1
  maskval = (1 << nbits) - 1
  maskcnt = (0xFF >> nbits >> 1) << nbits
  while i<len(rle):
    v = rle[i]
    mv = v & maskval
    c = (v & maskcnt) >> nbits
    if (v & 0b10000000 or nbits == 8):
      i += 1
      c |= rle[i] << (7 - nbits + (nbits == 8))
    c = (c + 1)
    while c:
      cw = min(c, w - x)
      if mv != itransp:
        fill_rect(x0 + x*zoomx, y0, cw*zoomx, zoomy, pal[mv])
      c -= cw
      x = (x + cw) % w
      y0 += x == 0 and zoomy
    i += 1

palettes = (
  (
    (247,176,36),(247,207,73),(231,89,0),(247,131,8),
  ),
)
images = (
  (
    b"\b\x05\n?\n\x05\x18\x05\n7\n\x05\x20\x05\n/\n\x05(\x05\n'\n\x050\x05\n\x1f\n\x058\x05\n\x17\n\x05@\x05\n\x0f\n\x05H\x05\n\a\n\x05P\x05\x16\x05X\x05\x0e\x05`\x05\x06\x05d\a\x06\a`\a\x02\x04\x02\aX\a\x02\x0c\x02\aP\a\x02\x04\a\x04\x02\aH\a\x02\x04"
    b"\x0f\x04\x02\a@\a\x02\x04\x17\x04\x02\a8\a\x02\x04\x1f\x04\x02\a0\a\x02\x04'\x04\x02\a(\a\x02\x04/\x04\x02\a\x20\a\x02\x047\x04\x02\a\x18\a\x02\x04?\x04\x02\a\x10\a\x02\x04G\x04\x02\a\b\a\x02\x04O\x04\x02\a\x00\a\x02\x04W\x04\x02\x0b\x02\x04_\x04"
    b"\x02\x03\x02\x04g\x04\x0eg\n\x01\n_\n\t\nW\n\x05\x00\x05\nO\n\x05\b\x05\nG\n\x05\x04"
  ),
)
for y in range(ceil(screen_h / 32)):
  for x in range(ceil(screen_w / 32)):
    draw_image(images[0], x*32, y*32, 32, palettes[0])
show()

palettes = (
  (
    (7,97,182),(55,139,223),(99,176,247),(141,216,247),
  ),
)
images = (
  (
    b"\x80\x01!\x14!\x18\x1e\x19\x1e\x19\x06\x17\x1a\x1f\x1a\x1f\x1a\x1f\x1a\x17\x06\x19\x1e\x19\x1e\x18!\x14!\x80\x01"
  ),
)
for x in range(ceil(screen_w / 16)):
  draw_image(images[0], x*16, screen_h-16, 16, palettes[0])
show()

palettes = (
  (
    (239,89,107),(247,207,81),(0,0,0),(182,26,36),(239,97,0),(0,0,0),
  ),
)
images = (
  (
    b"\xc0\x011\xc0\x01\x02)\xc0\x01\x03\x02!\xc0\x01\x0b\x02!\xc0\x01\x0b!\xc8\x011\xc0\x011\xb8\x01!\x021\x90\x01\x11\n\x03)\x02\x88\x01\t\n\x13!\x02\x03\x88\x01\n#\x19\x02\x0b\x88\x01+\x00\x19\x0b\x90\x01\x1b\x10!\x98\x01\x0b\x20!\xd0\x01\x02!\xc8\x01"
    b"\x03\n\x11\xc8\x01\x13\n\t\xc0\x01#\n\xe8\x01\x0b\xb8\x02\tX\x13p\t@+h\x19\x18Kh\x19[Pi#\x18C\x02Y\x02\x0b0K\x02I\x02\x03@S\x029\x02\x03(\xfb\x009\x03\x20\x1b\b3\x18I\x18\x13pI\b\x1b\x18\x03H!\n!\x1b\x18\x0bH\x11\n\x0b\n\x11\x13\x20\x03\x04@\t\n+\n"
    b"\t\x03\x20\x0b\x04@\nK\n(\x0b\x04@c(\x13\x04\x018[0\x0b\x0c\x01(c0\x13\x0c\t\x83\x010\x1b\x0c\ts@\x13\x141;H\x1b\x14)\x02+P\x1b\x1c!\x02\x1b`#\x1c\x19\x02\x0bp#\x1c\x05\x19\x80\x01+\x14\r!p+\x1c\r!h+\x1c\x15\x02!X+$\x15\x03\n\x11P+$\x1d\x13\n\t83,"
    b"\x1d#\n(;,%\x00+\x10K,-\x10\xfb\x00,5\x8b\x01,=\xfb\x004Ek<M[DUCT]#dm\xfc\x00\xfd\x00\x01d\x8d\x01\tL\x9d\x01\x04\t,\xb5\x01\x0c\t\x14\xc5\x01"
  ),
)
for x in range(ceil(screen_w / 64)):
  draw_image(images[0], x*64, 0, 32, palettes[0], 1, 1, 5)
  draw_image(images[0], (x+1)*64, 0, 32, palettes[0], -1, 1, 5)
show()

def draw_rect_z(x, y, w, h, c, z=1):
  for dy in (0, h - 1):
    fill_rect(x, y + dy*z, w*z, z, c)
  for dx in (0, w - 1):
    fill_rect(x + dx*z, y, z, h*z, c)

def qr_mark(x, y, s, c, z=1):
  draw_rect_z(x, y, s, s, c, z)
  fill_rect(x + 2*z, y + 2*z, (s - 4)*z, (s - 4)*z, c)

palettes = (
  (
    (0,0,0),(247,172,107),(133,71,73),(157,114,18),(207,147,55),(247,247,247),
  ),
  (
    (0,0,0),(36,35,36),(198,0,18),(247,26,55),(157,0,0),(231,97,81),(239,147,90),(247,183,133),(55,114,167),(247,247,247),(72,155,207),(36,71,133),(166,80,0),(239,199,45),(223,131,45),
  ),
  (
    (0,0,0),(0,0,0),(255,183,45),(255,255,247),(255,216,141),
  ),
  (
    (0,0,0),(0,0,0),(27,58,157),(157,172,215),(247,251,247),
  ),
  (
    (0,0,0),(223,41,45),
  ),
)
images = (
  (
    b"\x80\x01a\x02\b\x01[\x02\b\x01\x03\x19\x0b\x19\x03\x02\b\x01\x03\x01\x0b\x01\x0b\x01\x0b\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03"
    b"\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x19\x0b\x19\x03\x02\b\x01[\x02\b\x05Y\x02\b\x01\\\x02\b\x01\r\x03\x14\x01$\x02\b\x01\r\x02\x0c\x01\x0c\x01\x14\x02\b\x01\x03\n\x04\x01\x0c\x01\x1c\x02\b"
    b"\x01\x13\x04\x0b\x04#\x02\bj\b\x01[\x02\b\x01\x03\x19\x0b\x19\x03\x02\b\x01\x03\x01\x0b\x01\x0b\x01\x0b\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01"
    b"\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x01\x0c\x01\x0b\x01\x0c\x01\x03\x02\b\x01\x03\x19\x0b\x19\x03\x02\b\x01[\x02\bj\x80\x01"
  ),
  (
    b"\xe0\n1\x90\x01\x11\x02#\x01\xf0\x00\x01\x04\"\x13\x01`\x01\x04\"Q0\x01$\x81\x01\x20\x01\x14\x11E\x11\x20A\x05\x16\x01\x06\x110\x01\x16\x11\x05\x16\x01\x06!\x20\x01\x16!\x056\x17\x01\x10\x01\x05\x06\x05\x01\x05\x06\x01\x15&\x01\x20\x01%\x061\x15!"
    b"\x20\x11\x15\x16A0\x11\b\x01E\x01@\x01\x04\x02\x01\bAP\x01\x12\x03!\x04\x03\x11\x00\x01\x10\x01\x04\x02\x03\x01&\x01\x04\x03\x11\x06\x01\x00\x01\x04\x02\x01\x05\x06\x17\x06\x01\x04\x02\x01\x05\x01\x00\x01\x14\x01\x15&A\x10\x11\x14\x01%\x01\t\x1a\t"
    b"\x01\x20!\x0b!\x19\x1a\t\x01\x20\x01+\x18\n\b*\b\x010\x01\x0b\x18\n\b\x0b8\x11\x10\x01\x0c\x01\x0b\x18\x0b\x01\x1b\b\x01\r\x0e\x01\x00\x01\x0c\x01+\x01\x00\x01\x0b\x01\r\x0e\x0c\x01\x00\x01\x0c\x0e!\x20\x01\x1e\x0c\x01\x20\x01\x0c\x1e\x0c\x01\x10"
    b"\x01\x1c\x01@A\x20\x11\x20"
  ),
  (
    b"\x80\x01i\x00\x01j\tj\t\x12\x03\x04\x1a\x04\x03\x12\t\x12\x0b\x04\x12\x04\x03\x12\t\x12\x13\x12\x04\x03\x12\t\x12\x03\x04\x0b\n\x04\x03\x12\t\x12\x03\x0c\x03\x04\x02\x04\x03\x12\t\x12\x03\x04\x02\x04\x03\x0c\x03\x12\t\x12\x03\x04\n\x0b\x04\x03\x12"
    b"\t\x12\x03\x04\x12\x13\x12\t\x12\x03\x04\x12\x04\x0b\x12\t\x12\x03\x04\x1a\x04\x03\x12\tj\tj\x01"
  ),
  (
    b"\x80\x01i\x00\x01j\t\n\x0b,\x0b\n\t\x02\x03T\x02\t\x02\\\x03\t\x03\x14\x03\"\x14\x03\t\x03\x14J\t\x03\x14J\t\x03\x14J\t\x03\x14*\x14\x03\t\x02\x14+\x14\x03\t\x02\x03T\x03\t\n\x03D\x03\x02\t\x1a3\x12\tj\x01"
  ),
  (
    b"\x06\a\x16\a\x02\x03\x0e\a\x16\t\x00\x01\x00\x05\b\t\x00\x01\x00\x05\b\a\x00\x03\x02\x03\x00\r\x02\x03\x00\a\x00\r\x00\x01\x00\t\x02\x0b\x00\x01\x00\t\x02\x0b\x00\x01\x00\t\x04\x03\x00\x03\x06\x05\x0e\x01\x04\x03\x12\t\x16\a\x16\x05\x1a\x05\x06"
  ),
)
for j in range(-1, 2, 2):
  for i in range(1, 3):
    x = screen_w//2 - j*(screen_w * i // 6)
    if i+j != 3:
      qr_mark(x - 7, screen_h - 15, 7, [(k + 2) % 3 == i + j and 255 or 0 for k in range(3)], 2)
      show()
      draw_image(images[2 + i + j], x - 8, screen_h - 64, 16, palettes[2 + i + j], itransp=0)
      show()
    draw_image(images[i+j == 3], x - 8, screen_h - 48, 16, palettes[i+j == 3], itransp= i+j!=3 and -1)
    show()

palettes = (
  (
    (0,0,0),(0,0,0),(190,232,247),(190,97,0),(231,139,18),(157,199,239),(247,247,247),(247,176,64),(149,54,0),(133,172,207),
  ),
)
images = (
  (
    b"Q\x061\x05\xc1\x02\x19\x01\t\x01\x16\x11\x02\x05\x01\t\x01\x19\x01\t\x01\x89\x01\x01\t\x11\x15\x01\x05\x01\x16\x11\x02\x05\x01\x05\x01\x15\x01\x05\x01\x85\x01\x01\x05\x11\x12!\x16\x11\x02\x05!\x12\x01\x05\xa1\x01\x05\x11\x12\x01\b\x01B\x05\x01\b\x01\x12"
    b"\x01\x05\x01\x88\x01\x01\x05\x11\x16\x01\x18Q\x18\x01\x16\x01\x05\x01\x88\x01\x01\x05\x11\x12\x01\b\x03h\x04\x01\x12\x01\x05\x01\x88\x01\x01\x05\x11\x16\x01\bc\x14\x01\x16\x01\x05\x01h\x03\b\x01\x05\x11\x16\x01\bS$\x01\x16\x01\x05\x01X\x13\b\x01\x05\x11"
    b"\x12\x01\bC$\x03\x01\x12\x01\x05\x01H#\b\x01\x05\x11\x16\x01\b3$\x13\x01\x16\x01\x05\x018#\x18\x01\x05\x11\x12\x01\x98\x01\x01\x12\x01\x05\x01\x88\x01\x01\x05\x11\x12\xb1\x01\x12\x01\x05\xa1\x01\x05\x11\x12\x01\x19\x05b\x01\x12\x01\x05\x01e\x19\x01\x05"
    b"\x11\x12\x01\x19\x05b\x01\x12\x01\x05\x01e\x19\x01\x05\x81\x04"
  ),
  (
    b"P\xb1\x02\x90\x01\x11\x12\x11\xf4\x00\x01\x12\x11%\x11`\x01\x16\x11\x04\xf7\x00\x01\x16\x01\x15!\x15\x01@\x01\x16\x01\x04\x87\x01\x01\x16\x01\x05\x11(\x11\x05\x010\x01\x16\x01\x04\x87\x01\x01\x16\x01\x05\x01H\x01\x05\x01\x20\x01\x16\x01\x03\x84\x01\x01"
    b"\x16\x01\x05\x01h\x01\x05\x01\x10\x01\x16\x01\x03\x84\x01\x01\x16\x01\x05\x01h\x01\x05\x01\x10\x01\x16\x01\x03\x84\x01\x01\x16\x01\x05\x01h\x01\x05\x01\x00\x01\x12\x01\b\x83\x01\x01\x12\x01\x05\x01h\x03\b\x01\x05\x11\x16\x01\b\x83\x01\x01\x16\x01\x05"
    b"\x01X\x13\b\x01\x05\x11\x16\x01\b\x83\x01\x01\x16\x01\x05\x01H#\b\x01\x05\x11\x12\x01\b\x83\x01\x01\x12\x01\x05\x018#\x18\x01\x05\x11\x16\x01\b\x03Q\b\x03\x01\x16\x01\x05\x01(#(\x01\x05\x11\x12\x01\b\x01&\x12\x05\x01\b\x01\x12\x01\x05\x01\x18#8\x01\x05"
    b"\x11\x12\x01\b\x01\x16\x11\x02\x05\x01\b\x01\x12\x01\x05\x01\b#(\x03\b\x01\x05\x11\x15\x01\b\x01\x061\x05\x01\b\x01\x15\x01\x05\x01\x88\x01\x01\x05\x01"
  ),
  (
    b"P\xc1\x02\x80\x01\x11\x12\x01\x03\x84\x01\x01\x12\x11%\x11P\x01\x16\x01\x14\x87\x01\x01\x16\x01\x15!\x15\x01@\x01\x16\x01\x04\x97\x01\x01\x16\x01\x05\x01(\x01\x05\x010\x01\x16\x01\x04\x97\x01\x01\x16\x01\x05\x01H\x01\x05\x01\x20\x01\x16\x01\x03\x94\x01"
    b"\x01\x16\x01\x05\x01H\x01\x05\x01\x20\x01\x12\x01\x03\x94\x01\x01\x12\x01\x05\x01H\x01\x05\x01\x20\xa1\x02\x05\x01X\x01\x05\x01\x20\x01\x89\x02\x11X\x01\x05\x010\x01\t\xe1\x01\t\x11H\x01\x05\x01@\x01\t\xe1\x01\t\x118\x01\x05\x01P\x01\t\xe1\x01\t\x11("
    b"\x01\x05\x01P\x91\x02\t\x11\x18\x01\x05\x01@\x01&\x12\x05\xc1\x01\t\x11\b\x01\x05\x01@\x01\x16\x11\x02\x05\xd1\x01\t!\x05\x01@\x01\x061\x05\xe1\x01\t\x11\x05\x01"
  ),
)
for i in range(2):
  draw_image(images[-i], screen_w//2-16, screen_h-32-16*i, 32, palettes[0], itransp=0)
show()

def qr_size(v):
  return 17 + 4*v

qr_ver = 3
qr_margin = 4
qr_size_code = qr_size(qr_ver)
qr_size_code_margin = qr_size_code + 2*qr_margin + 4
qr_zoom = max(1, min(screen_w // qr_size_code_margin, (screen_h - 128) // qr_size_code_margin))
qr_size_code_margin -= 4
qr_width = qr_size_code_margin * qr_zoom
x_qr = (screen_w - qr_width) // 2
y_qr = (screen_h - qr_width) // 2
for k in range(1, 3):
  draw_rect_z(x_qr - k*qr_zoom, y_qr - k*qr_zoom, qr_size_code_margin + 2*k, qr_size_code_margin + 2*k, k > 1 and (0, 0, 0) or (255, 255, 255), qr_zoom)
qr_margin *= qr_zoom
fill_rect(x_qr, y_qr, qr_width, qr_width, (0,64,64))

def qr_alignments(v):
  s = qr_size(v)
  positions = []
  n = v // 7 + 2
  first = 4
  positions.append(first)
  last = s - 5 - first
  step = last - ((first + last*(n - 2) + (n - 1)//2) // (n - 1) & -2)
  second = last - (n - 2) * step
  positions.extend(range(second, last + 1, step))
  return positions

def qr_frame(v, x, y, c, z=1):
  s = qr_size(v)
  l = (0, s - 7)
  for dy in l:
    for dx in l:
      if not dx or not dy:
        qr_mark(x + dx*z, y + dy*z, 7, c, z)
  for i in range(8, s-8, 2):
    fill_rect(x + i*z, y + 6*z, z, z, c)
    fill_rect(x + 6*z, y + i*z, z, z, c)
  l = qr_alignments(v)
  for dy in l:
    for dx in l:
      if not (dy < 8 and (dx < 8  or dx > s - 10) or dx < 8 and dy > s - 10):
        qr_mark(x + (dx - 0)*z, y + (dy - 0)*z, 5, c, z)

qr_frame(qr_ver, x_qr + qr_margin, y_qr + qr_margin, (255,255,255), qr_zoom)

palettes = (
  (
    (0,0,0),(255,255,255),
  ),
  (
    (0,0,0),(255,255,255),
  ),
  (
    (0,0,0),(0,0,255),
  ),
  (
    (0,0,0),(255,0,0),(255,0,255),
  ),
)
images = (
  (
    b"\x1e\x01\x02\x03,\x05\x02\x012\x014\x014\x01\x00\x056\x01n\x030\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x20\a\x00\a\x04\x01\x1a\a\x02\x03\x02\x01\"\x01\x00\x01\x00\x05\x02\x01\x00\x01\x00\x01\x1c\x01\x00\x03\x0c\x03\x1e\x05\x02\x0b\x04\x01\x1c"
    b"\x01\n\x01\x00\x05&\x03\x00\x03\x00\x01\x02\x01$\x01\x00\x01\x02\x01\x00\x03\"\x01\x02\x0b\x00\x01\x00\x01\x1c\x03\x00\x01\x00\x01\x02\x03\x00\x01\"\x01\x00\x05\n\x01\x1c\x01\x00\x01\x00\x03\n\x05\x1c\x03\x0e\a\x1c\x01\x02\x03\b\x03$\x05\x0c\x032"
    b"\x05\x1c\x01\x00\x03\x00\x01\x06\x03\x20\x01\x00\a\x00\x0b\x1e\x03\x00\x01\x00\x01\x04\x03\x00\x01\x1e\x03\x00\x01\x02\x01\x00\a\x02"
  ),
  (
    b"\x16\x01\x00\x01*\x01\x04\x038\x01*\x01\x06\x01f\x01\n\x01n\x01\x1a\t\x02\x03\b\x01$\x01\x02\x01:\x01^\x01\x0c\x01(\x01<\x01\x00\x01\b\x01\"\x01\x0c\x01:\x01\x00\x01\x18\x01\x02\x01\x00\x01\x04\x01\x02\x01\x1e\x01\x14\x01\x1e\x016\x01\n\x018\x01"
    b"\x02\x01\x00\x01,\x03\x02\x016\x01.\x01\x06\x03*\x01\x06\x01,\x016\x016\x01\x00\x01\""
  ),
  (
    b"J\x018\x01\x00\x01\x02\x01*\x03\x04\x030\x03.\x01\x00\x01\x06\x01f\x012\x03\x00\x03\x00\x01\x18\x01\x0e\x03\x00\x03&\x01\x04\x01\x04\x01$\x01\x06\x01\x00\x03\"\x01\x02\x01\x02\x01\x04\x01,\x03\x04\x03\x1c\x01\x02\x01\x06\x01\x00\x01\x04\x01$\x01"
    b"\x06\x01\x04\x010\x03,\x01.\x05\x04\x01(\x05\x04\x01\x00\x01&\x01\x00\x03\n\x012\x01\x04\x010\x01\x00\x01\x02\x01(\x03\x02\x05*\x01\x02\x010\x01\x02\x01\x00\x01,\a\x00\x01,\x058\x01\x1e"
  ),
  (
    b"\x20\x01\x00\x01\x00\x01\x00\x01h\x01`\x01\b\x02T\x02\x04\x01`\x01\x0c\x01X\x02\x01\x00\x01\x00\x01\xcc\x01\x05\x0c\x05P\x02\x04\x02\x04\x02\x010\x05\x00\x01\x14\x01\x04\x014\t\x00\x01\x14\x05<\x05$\x02D\x02\x05\x04\x01\x04\x01\x00\x02\x01H\x01\x04"
    b"\x06L\x02\x18\x02\x01\x00\x01@\x01\x00\x01\x10\x01\b\x01<\x01\x04\t\x00\x01\x00\x05\x06\b\x014\x01l\x01\x18\x01L\x02\x04\x01\x14\x01H\x01\x02\x0c\x01\b\x01\\\x01\x04\x01\x00\x02\\\x01\b\x01\x00\x02P\x02\x10\x02`\x02l\x02`\x06p\x02\tX\x01\x04\x02<"
  ),
)

for k in range(len(images)):
  draw_image(images[k], x_qr + qr_margin, y_qr + qr_margin, qr_size_code, palettes[k], zoomx=qr_zoom, zoomy=qr_zoom, itransp=0)
show()
wait()

Lien
:
lots et ressources

Nouveaux boîtiers pour carte développement TI-Nspire

New postby critor » 29 Nov 2021, 15:02

Avant d'adopter le format calculatrice de poche, les futurs modèles de
Texas Instruments
prennent dans un premier temps la forme de cartes de développement.

Voici par exemple ci-contre un exemplaire de la carte de développement ayant servi à développer la légendaire
TI-89
de 1998. Elle est ici connectée via une nappe à un boîtier
TI-89
quasiment dépourvu de toute électronique interne, n'étant là que pour fournir le clavier et l'écran, soit de quoi tester malgré tout dans des conditions aussi proches que possible de celles de l'utilisateur final.

Cette pièce d'un intérêt historique exceptionnel, peut-être le dernier exemplaire sur Terre, a été dénichée par puis achetée par
Brandon Wilson
.

397De passage à
TI-Dallas
en 2011, nous avait brièvement photographié une carte de développement
TI-Phoenix 1
, ancien nom des prototypes
TI-Nspire+
et
TI-Nspire CAS+
de 2006-2007 sur processeur
OMAP
, photos reproduites avec autorisation de
Texas Instruments
.

Ici la carte était reliée à un boîtier
TI-Nspire
n'étant là que pour fournir le clavier, et avait bien pris le temps de te montrer qu'il était complètement vide en dehors de ça :
456458447452457450

2Un peu plus récent, voici la carte de développement des
TI-Nspire
monochromes finalement très différentes de 2007, migrant du processeur
OMAP
à un
ASIC
.

Ici l'écran était directement intégré à la carte, mais une nappe servait quand même à avoir le clavier externe.

Probablement mise en public par erreur dans sa galerie photos par l'un des développeurs de la
TI-Nspire
,
Zac Bowling
.

8389Justement à ce sujet, et
Brandon Wilson
ont également déniché et acheté d'autres pièces intéressantes.

Ci-dessous plusieurs boîtiers
TI-Nspire TouchPad
destinés à être reliés via des nappes à une carte de développement
TI-Nspire
, ne fournissant ici encore comme tu peux le voir ci-contre que l'électronique minimale permettant d'avoir le clavier et l'écran.

Une grosse protubérance latérale permet de faire ici sortir du boîtier 4 connecteurs de nappe :

Toujours dans le même lot, voici maintenant un boîtier
TI-Nspire TouchPad
muni d'un écran couleur, et donc destiné à être utilisé avec une une carte de développement
TI-Nspire CX
:

Toujours dans ce domaine, nouvelle découverte historique très précieuse aujourd'hui par alias
mr womp womp
. Il vient de dénicher et acheter des boîtiers encore différents pour carte de développement
TI-Nspire
.

Cette fois-ci il y a 2 protubérances latérales bien plus modestes de part et d'autre faisant sortir seulement 2 connecteurs de nappe au nombre de broches différent, sans doute un pour le clavier et un pour l'écran :


Ces boîtiers n'ont toutefois pas d'intérêt en dehors des personnes se sentant l'âme d'un conservateur ou d'un collectionneur. Dépourvus de tout élément interne actif, ils sont totalement inutilisables sans la carte de développement
TI-Nspire
sur laquelle les brancher. Quel dommage qu'elle ne soit toujours pas venue avec. Peut-être la prochaine fois ?... ;)

-
Search
-
Social
-
Featured topics
Concours de dessin de Noël 2021 Jusqu'au 31 janvier 2022 inclus par Casio. Dessine ta liste au Père Noël sur calculatrice/émulateur Graph 90/35+E II en Python ou fx-92+ Spéciale Collège. Ouvert aux élèves et enseignants, classement séparé. À gagner 2 consoles Nintendo Switch pour les élèves, 2 trottinettes électriques pour les enseignants, 10 calculatrices Graph 90/35+E II au choix, 72 montres Casio G-Shock ou Vintage. Pas de perdant, goodies Casio pour tous les autres !
Coque NumWorks édition limitée Janvier 2022 à gagner.
Comparaisons des meilleurs prix pour acheter sa calculatrice !
123
-
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.
518 utilisateurs:
>501 invités
>12 membres
>5 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)