Salut à tous j'ai commencé récemment à programmer la TI89. J'ai lu qu'on pouvait utiliser différents niveaux de gris à l'aide de librairies telles que gray4lib cependant je n'ai rien trouvé concernant son utilisation. Si quelqu'un aurait des informations à m'apporter...

c'est du C sur la Ti89  

oui oui en C avec TICC

Il y a 7 niveaux de gris. cependant, ils clignotent sur HW2.
il vaut mieux en utiliser 4, le noir, le blanc et deux niveaux intermédiaires.
 
Commençons par un peu de théorie :
 
Nos TIs disposent d'un contrôleur, qui est capable d'afficher des images en noir et blanc. Les images affichées sur l'écran sont mémorisées dans une partie de la RAM de la TI, sous forme de bits : chaque bit correspond à un pixels de l'écran. Si le bit est armé, le pixel est allumé (il sera alors noir), et si le bit ne l'est pas, le pixel sera éteint (il sera alors blanc).
Le TIOS (le "système d'exploitation" de la TI) utilise toujours la même partie de la RAM pour stocker les informations correspondant à l'image à afficher. Mais, heureusement, TIGCC nous permet de reprogrammer cet emplacement, et même d'en utiliser plusieurs alternativement, ce qui est à la base de l'utilisation des niveaux de gris.
Pour pouvoir utiliser des niveaux de gris, il faut que que nous utilisions deux emplacements différents dans la RAM. (Ces emplacements sont nommés Plane dans TIGCC).
Avec ces deux plans, nous pouvons construire deux niveaux de gris différents :
    * Gris clair (en utilisant le plan LIGHT_PLANE). Dans ce cas, c'est le bit correspondant du Plane2 qui est armé
    * Gris foncé (en utilisant DARK_PLANE). Et dans ce cas, c'est celui du Plane1 qui est armé.
Mais, ici, on ne voit que deux niveaux de gris... C'est normal : les deux autres sont :
    * Blanc : dans ce cas, les deux Planes sont éteints : aucun des bits correspondants au pixels ne sont armés dans les deux emplacements réservés à la mémoire de l'écran.
    * Noir : dans ce cas, les deux Planes sont allumés : les deux bits correspondants au pixel sont armés.
Donc, pour afficher des niveaux de gris, il faudrait arriver à afficher les deux plans à la fois... Malheureusement, ceci n'est pas possible !!!
    Il va donc falloir utiliser une autre technique, basée sur la vitesse de réaction de l'œil humain : les deux plans sont affiché en noir et blanc alternativement, et on a l'impression de voir les deux à la fois...  
    Mais, me direz vous, si on affiche alternativement deux images en noir et blanc, le résultat devrait aussi être en noir et blanc ! Pour éviter ceci, les plan correspondant au gris foncé est affiché deux fois plus longtemps que celui correspondant au gris clair. Ainsi, si on prend une unité arbitraire de 3, on aura l'affichage suivant :
    * Blanc : 3/3 : pas de pixels allumés en plan1, ni en plan2.
    * Gris clair : 1/3 : les pixels sont allumés pendant un tiers du temps.
    * Gris foncé : 2/3 : les pixels sont allumés pendant les deux tiers du temps.
    * Noir : 3/3 : les pixels sont toujours allumés.
Le plan DARK_GRAY est donc affiché pendant environ 66% du temps, alors que le plan LIGHT_GRAY est affiché pendant environ 33% du temps.
 
les TI avec HW2 sont dotés d'un contrôleur supplémentaire pour l'affichage des graphismes, équipé de sa propre RAM intégrée... L'affichage donc plus lent, c'est pourquoi avec 7 niveaux de gris on risque de voir un clignotement très désagréable
 

Comment utiliser les niveaux de gris :
 
Pour pouvoir utiliser les 4 niveaux de gris (appelés "grayscales" en anglais) sous TIGCC, il faut tout d'abord les activer. Pour cela, il faut utiliser l'instruction suivante :
        GrayOn();
Cette instruction permettra d'utiliser les niveaux de gris dans la suite du programme. Elle renvoie un short, qui a pour valeur TRUE si les 4 niveaux de gris ont bien été activés, et FALSE s'ils ne l'ont pas été.
 
Il ne faudra pas oublier de désactiver les niveaux de gris à la fin du programme, sinon l'affichage risque de bugger (le TIOS n'utilise pas de niveaux de gris) :
        GrayOff();
 
 Il existe une fonction qui permet de savoir si les niveaux de gris sont activés ou non. Sa syntaxe est la suivante :
        IsGrayMode();
Cette fonction renvoie une valeur de type short, qui est égale à TRUE si les niveaux de gris sont actifs, et à FALSE dans le cas contraire.
 
J'ai dit précédemment qu'il fallait utiliser deux plans : LIGHT_PLANE pour le gris clair, et DARK_PLANE pour le gris foncé. Pour sélectionner le plan actif, il convient d'utiliser la fonction suivante :
        SetPlane(nom_du_plan);
 
Si l'écran clignote, on peut modifier la fréquence de rafraîchissement. Pour cela, il faut utiliser la fonction suivante :
        GrayAdjust( valeur );
Cette fonction prend en argument un short, dont la valeur va de -28 à 127 sur TI-89, et de 0 à 127 sur TI-92plus. La valeur par défaut est de 0, ce qui correspond aux réglages d'usine. Les valeurs inférieures à 0 permettent d'augmenter la fréquence de rafraîchissement, tandis que celles positives permettent de la diminuer. La fréquence restera la même jusqu'à ce que la TI soit éteinte. La valeur sera réinitialisée à l'allumage.
 
Maintenant, il vaut mieux que je donne un exemple (pour TI-GCC) :
 

 
ce programme dessine quatre rectangles, ou 3 selon le point de vue    
Vous remarquerez qu'il n'est pas très optimisé, mais on le comprend mieux.
 
Ce programme est en nostub : on n'a pas besoin d'une librairie particulière comme gray4lib pour qu'il fonctionne.
Toutes les fonctions de dessin sont utilisables, il suffit d'afficher sur le bon plan.
 
pour afficher peu de choses en noir, il vaut mieux dessiner sur les 2 plans que de désactiver les niveaux de gris, l'activation/désactivation est assez lente.