Welcome to Squalenet.Net ! - We are the 16/07/2019 ; time is 23:31
Connecté : 1 inconnu
Your Account

Login :
Password :

RegisterPassword Forgotten
Language
Statistics

Chapter 5

Clearing the Screen ; Printing a Message on Quitting

Chapter 4 Imprimer Chapter 6
This page is being translated.
Translated by Spectras ; Many thanks to him/her! - Website: http://www.tiwiki.org/

Now we can draw onto the screen, we will see how to erase the screen at the beginning of our program, and why the screen gets restored automatically at the end of our program.

 

I: \ Erasing the screen contents

Erasing the screen contents is very easy, as AMS provides a simple romcall taking no parameters. ClrScr, standing for 'Clear Screen', blanks all pixels. We can then make nice drawings without the ugly AMS home screen in the background.

Here is an example that draws a single line and waits for a keypress:

#include <tigcclib.h>         // Include All Header Files

// Main Function
void _main(void)
{
    ClrScr();
    DrawLine(10, 30, 70, 50, A_NORMAL);
    ngetchx();
}

This program runs as it should. Also, you will notice that the screen contents get restored automatically after you press a key, despite the absence of any instruction to do so in your source code. Actually, your binary program does contain the code that does this. Tigcc generates it for you automatically because most program need it, for AMS does not redraw the screen by itself.

 

II : \ Manual control of the screen save and restore operations

Screensaving code generation is triggered by the definition of a specific symbol, SAVE_SCREEN. The compiler detects its presence and generates the additional instructions accordingly. There are two ways to define this symbol : either in the compiler options or with a special preprocessor directive.

You can try unckecking the box, compile your program again, and make sure your program leaves a garbled screen. Well not completely, since parts of the screen are redrawn, and one can restore almost all the other parts by using the calculator a bit. Still, it is not very satisfying for the user (and the bottom line separating the status bar from the command line editor cannot be restored this way).

So, you are wondering why one would want to disable the automatic screen restore. Well, there are quite a lot of reasons. Suppose you want to exit your program and leave an error message in the status line, for instance under critical error conditions. The message will not be visible, since the automatic screen restore will overwrite it. You could wait for a keypress, but it is not as practical. Here is the solution.

Firstly, the automatic screen restore must be disabled, since we are going to handle it by ourselves. So we have to save the screen ourselves and restore it before we write our message. We will use a LCD_BUFFER variable for this purpose. We declare it thusly:

LCD_BUFFER saved_screen;

This line tells the compiler we want a new variable that will fit a screen capture, and that it shall be named saved_screen. Therefore, any further reference to saved_screen will be interpreted as references to this variable. Variables will be explained in another chapter. We then use the LCD_save function to dump the screen contents into our variable, this way:

LCD_save(saved_screen);

At this point, the original screen contents is safe, and we can draw anything we like onto the screen. Once we are done, we restore the original screen contents from our variable using LCD_restore this way:

LCD_restore(saved_screen);

At this point, our program will work exactly the way it used to when we let the compiler generate the code that saves and restores the contents of the screen. Except we can add other instructions after we restore it. For instance, we can display a message in the status line, and it will remain visible even after our program exits. We do this using the usual function:

ST_helpMsg("Goodbye");

And finally, a complete program you can try on your own calculator:


#include <tigcclib.h>

// Main Function
void _main(void) 
{ 
    LCD_BUFFER saved_screen; 
    LCD_save(saved_screen); 
    ClrScr(); 
    DrawLine(10, 30, 70, 50, A_NORMAL); 
    ngetchx(); 
    LCD_restore(saved_screen); 
    ST_helpMsg("Goodbye"); 
} 

When run, this program saves the screen contents, then draws a line on a blank screen and waits for a keypress. When it comes, it restores the original screen contents, and leave a message for the user to see after the program exits. Status line messages disappear as soon as the user presses a key.

 

III:\ A word on someLes commandes inclues par TIGCC avec les options par défaut

Pour terminer ce chapitre, nous allons parler des commandes inclues par TIGCC au début de notre code : les lignes commençant par un caractère #. Nous n'examinerons que celles qui sont incluses avec les options par défaut ; c'est-à-dire celles que nous avons utilisées dans nos codes sources, jusqu'à présent sans réellement se soucier de ce qu'elles faisaient.
Dans cette partie, la plupart des commandes ont été remplacées par des cases à cocher dans les options du projet lors de la sortie de TIGCC 0.95... en fait, seule la dernière "commande", le #include, n'a pas été remplacé de la sorte. Cela dit, vous serez probablement amené à rencontrer ces options si vous lisez des codes sources écrits par d'autres que vous ; je vous encourage donc à ne pas ignorer cette partie de ce chapitre...

A: Modèles de calculatrices pour lesquels le programme doit être compilé

#define USE_TI89              // Compile for TI-89
#define USE_TI92PLUS          // Compile for TI-92 Plus
#define USE_V200              // Compile for V200

Ces trois lignes indiquent au compilateur pour quelles machines il doit créer le programme. Vous pouvez créer votre programme pour l'une, les deux, ou les trois machines.
Pour votre usage personnel, autant ne pas se fatiguer à créer des programmes compatibles entre les différentes calculatrices ; cela dit, si vous destinez votre programme à la diffusion, il peut être bon qu'il fonctionne sur chaque modèle de machine, afin de toucher le plus d'utilisateurs possible.

 

B: Optimisation des ROM_CALLs

#define OPTIMIZE_ROM_CALLS // Use ROM Call Optimization

Cette directive permet ordonne au compilateur d'optimiser les appels de ROM_CALLs. Cela dit, il faut quelques instructions pour que cette optimisation se fasse, ce qui explique que cette directive fasse grossir la taille du programme si peu d'appels aux fonctions inclues dans la ROM sont effectués.
Cette optimisation réserve aussi un registre, pour toute la durée du programme ; ce registre ne peut donc pas être utilisé pour les calculs. Les registres n'étant que très peu nombreux, et étant les mémoires les plus rapides de la machine, dans le cas d'un programme n'utilisant que peu de ROM_CALL (un jeu évolué, par exemple), on préférera souvent ne pas utiliser cette "optimisation", de façon à accélérer les calculs.

 

C: Version minimale d'AMS requise

#define MIN_AMS 100           // Compile for AMS 1.00 or higher

Chaque nouvelle ROM, c'est-à-dire chaque nouvelle version d'AMS (Advanced Mathematical Software, le "cerveau" logiciel de la calculatrice) sortie par Texas Instrument apporte de nouveaux ROM_CALLs ; il est donc des ROM_CALLs qui ne sont pas disponibles sur les anciennes ROMs...
Si vous utilisez certains de ceux-là, il vous faut préciser à partir de quelle version de ROM votre programme peut fonctionner, afin qu'il ne puisse pas être lancé sous des versions plus anciennes, où il aurait un comportement indéterminé.

Par exemple, si vous souhaitez utiliser le ROM_CALL AB_getGateArrayVersion, défini uniquement à partir de la ROM 2.00, d'après la documentation, il vous faudra définir ceci :

#define MIN_AMS 200

Si vous ne le définissez pas, en laissant, par exemple, la valeur par défaut de 100, le compilateur vous renverra un message d'erreur, disant qu'il ne connaît pas ce ROM_CALL.

Cela dit, je vous encourage fortement à n'utiliser que des ROM_CALL existant depuis le plus longtemps possible, afin que votre programme puisse fonctionner sur le maximum de versions de ROM !

 

D: Sauvegarde/Restauration automatique de l'écran

#define SAVE_SCREEN           // Save/Restore LCD Contents

Nous avons déjà vu ceci plus haut, puisque c'était le sujet primaire de ce chapitre ; nous ne reviendrons pas dessus.

 

E: Include standard

#include <tigcclib.h>         // Include All Header Files

Pour finir ce chapitre, parlons rapidement de la directive #include.
Elle permet, comme son nom l'indique, d'ordonner au compilateur d'inclure du texte, tel, par exemple, du code, depuis un fichier, pris dans le répertoire par défaut (c:\Program Files\TIGCC\Include\C si vous avez suivi l'installation par défaut) si le nom de ce fichier est écrit entre chevrons (entre le caractère '<' et le caractère '>'), ou dans le répertoire courant s'il est écrit entre guillemets doubles ('"').

Le fichier tigcclib.h contient les prototypes des ROM_CALLs, ainsi que de nombre autres fonctions. Le fait de l'inclure permet au compilateur de savoir quels paramètres les ROM_CALLs doivent recevoir, quelles sont leurs valeurs de retour, ...
Il est généralement nécessaire d'inclure ce fichier pour parvenir à compiler un programme sous TIGCC.

 

Nous voila parvenu à la fin de ce chapitre. Le prochain nous permettra de parler de la notion de variables, et d'apprendre comment en déclarer, ainsi que les bases de leur utilisation.

Chapter 4 Imprimer Chapter 6