Fxlib.h

Article en cours de rédaction !

La librairie "fxlib.h" est la librairie qui contient toutes les fonctions de bases du kit de développement de Casio pour Graph 75/85/95 (SD). Il existe d'autres librairies communautaires bien plus simples et puissantes, mais certaines fonctions de "fxlib.h" sont nécessaires, et n'ont pas d'équivalent dans les librairies non-officielles.

Fonctions d'affichage

Bdisp_PutDisp_DD

prototype : void Bdisp_PutDisp_DD(void);

Affiche à l'écran le contenu de la VRAM (buffer stockant le contenu de l'écran virtuel). Ne prend aucun argument et ne renvoie aucune valeur.

Bdisp_AllClr_DD/ Bdisp_AllClr_VRAM/ Bdisp_AllClr_DDVRAM

prototypes :

void Bdisp_AllClr_DD(void);

void Bdisp_AllClr_VRAM(void);

void Bdisp_AllClr_DDVRAM(void);

Ne prend aucun argument et ne renvoie aucune valeur.

Bdisp_AllClr_DDVRAM() efface l'écran et la VRAM. Pour effacer uniquement l'écran, utiliser Bdisp_AllClr_DD(). Pour effacer uniquement la VRAM, utiliser Bdisp_AllClr_VRAM().

Bdisp_AreaClr_DD/ Bdisp_AreaClr_VRAM/ Bdisp_AreaClr_DDVRAM

prototypes :

void Bdisp_AreaClr_DD(const DISPBOX *pArea);

void Bdisp_AreaClr_VRAM(const DISPBOX *pArea);

void Bdisp_AreaClr_DDVRAM(const DISPBOX *pArea);

La fonction ne renvoie aucune valeur.

Efface une partie de l'écran. L'argument à passer (par pointeur) à cette fonction est une structure de la forme :

typedef struct tag_DISPBOX{ // Déclarée dans dispbios.h

int left; // 0~127

int top; // 0~63

int right; // 0~127

int bottom; // 0~63

} DISPBOX;

Bdisp_AreaReverseVRAM

prototype :

void Bdisp_AreaReverseVRAM(

int x1, // coordonnée x à gauche

int y1, // coordonnée y en haut

int x2, // coordonnée x à droite

int y2 // coordonnée y en bas

);

La fonction ne renvoie aucune valeur. Inverse une zone de l'écran (pixel éteint en allumé et allumé en éteint). Passez-lui en argument les coordonnées de la zone à inverser, comme indiqué ci-dessus).

Bdisp_GetDisp_DD/ Bdisp_GetDisp_VRAM

prototypes :

void Bdisp_GetDisp_DD(unsigned char * pData);

void Bdisp_GetDisp_VRAM(unsigned char * pData);

La fonction ne renvoie aucune valeur. Elle permet de stocker dans un tableau le bitmap des écrans de la VRAM (écran virtuel) ou du DD (écran graphique). On lui passe en argument (par pointeur) le tableau où le bitmap sera stocké.

La documentation ne précise rien de plus à propos de cette fonction, si ce n'est que le tableau sur lequel est stocké le bitmap doit avoir une taille de 1024 octets. On peut donc penser que la méthode de codage utilisée par Casio est : on regroupe les pixels par groupe de 8 (un octet), où chaque bit prend la valeur d'un pixel (allumé : 1, éteint : 0). Si l'on fait le calcul : (128*64)/8 = 1024.

Bdisp_PutDispArea_DD

prototype : void Bdisp_PutDispArea_DD(const DISPBOX *pArea);

Une des plus belles erreurs de la documentation de Casio ! Dans la doc ils ont mis les explications d'une autre fonction... Cette fonction permet d'afficher à l'écran graphique une zone de l'écran virtuel. On peut tout de même deviner que cette fonction demande en argument une structure (passage par pointeur) de la forme :

typedef struct tag_DISPBOX{ // Déclarée dans dispbios.h

int left; // 0~127

int top; // 0~63

int right; // 0~127

int bottom; // 0~63

} DISPBOX;

Bdisp_SetPoint_DD/ Bdisp_SetPoint_VRAM/ Bdisp_SetPoint_DDVRAM

prototypes :

void Bdisp_SetPoint_DD(int x,int y,unsigned char point);

void Bdisp_SetPoint_VRAM(int x,int y,unsigned char point);

void Bdisp_SetPoint_DDVRAM(int x,int y,unsigned char point);

Place ou supprime un pixel aux coordonnées x et y passées en argument. Ne renvoie aucune valeur. La troisième valeur passée en argument est le type de point : 1 pour mettre un pixel, 0 pour en enlever un. La première fonction permet d'agir sur l'écran graphique, la seconde dans la VRAM, et la troisième dans les deux.

Bdisp_GetPoint_VRAM

prototype : int Bdisp_GetPoint_VRAM(int x,int y);

Retourne la couleur du pixel dont les coordonnées sont passées en argument (1 pour un pixel allumé, 0 pour un pixel éteint).

Bdisp_WriteGraph_DD/ Bdisp_WriteGraph_VRAM/ Bdisp_WriteGraph_DDVRAM

prototypes :

void Bdisp_WriteGraph_DD(const DISPGRAPH *WriteGraph);

void Bdisp_WriteGraph_VRAM(const DISPGRAPH *WriteGraph);

void Bdisp_WriteGraph_DDVRAM(const DISPGRAPH *WriteGraph);

Affiche un bitmap sur la VRAM ou l'écran (ou les deux). Ne renvoie aucune valeur. Les arguments sont passés (par pointeur) dans une structure de la forme :

typedef struct tag_DISPGRAPH { // Déclarée dans dispbios.h

int x; // coordonnée x à gauche

int y; // coordonnée y à gauche

GRAPHDATA GraphData; // pointeur sur la structure contenant les données du bitmap (voir en dessous)

WRITEMODIFY WriteModify; // type d'écriture du graphe (IMB_WRITEMODIFY_NORMAL : écriture normale et IMB_WRITEMODIFY_REVERSE : écriture inverse).

WRITEKIND WriteKind; // mode d'écriture

} DISPGRAPH;

Le mode d'écriture peut être :

OR = allumé si le pixel de l'écran OU le pixel du bitmap sont allumés

AND = allumé si le pixel de l'écran ET le pixel du bitmap sont allumés

XOR = allumé si le pixel de l'écran OU le pixel du bitmap sont allumés, MAIS PAS LES DEUX

La structure contenant les données du bitmap prend cette forme :

typedef struct tag_GRAPHDATA{ // Déclarée dans dispbios.h

int width; // largeur du bitmap

int height; // hauteur du bitmap

unsigned char *pBitmap; // pointeur sur les données du bitmap

} GRAPHDATA;

Le bitmap est codé de la manière suivante : on regroupe les pixels par groupe de 8 (un octet), où chaque bit prend la valeur d'un pixel (allumé : 1, éteint : 0).

On peut s'interroger sur l'utilité de faire des fonctions avec passage d'arguments aussi complexe, mais n'oubliez pas que nous sommes chez Casio.

Bdisp_ReadArea_DD / Bdisp_ReadArea_VRAM

prototypes :

void Bdisp_ReadArea_DD (const DISPBOX *ReadArea,unsigned char *ReadData); void Bdisp_ReadArea_VRAM (const DISPBOX *ReadArea,unsigned char *ReadData);

Cette fonction permet de stocker une zone de l'écran graphique (DD) ou de l'écran virtuel (VRAM) sur un tableau, codé de la manière suivante : on regroupe les pixels par groupe de 8 (un octet), où chaque bit prend la valeur d'un pixel (allumé : 1, éteint : 0). La fonction ne retourne rien. On lui passe en argument (par pointeur) le tableau récepteur du bitmap et une structure de la forme :

typedef struct tag_DISPBOX { // Déclarée dans dispbios.h

int left; // 0~127

int top; // 0~63

int right; // 0~127

int bottom; // 0~63

} DISPBOX;

Bdisp_DrawLineVRAM

prototype :

void Bdisp_DrawLineVRAM(int x1,int y1,int x2,int y2);

La fonction trace une ligne entre deux points dont les coordonnées sont entières et de la forme : (0~127;0~63). Elle ne retourne rien.

Bdisp_ClearLineVRAM

prototype :

void Bdisp_ClearLineVRAM(int x1,int y1,int x2,int y2);

La fonction efface une ligne entre deux points dont les coordonnées sont entières et de la forme : (0~127;0~63). Elle ne retourne rien.

locate

prototype : void locate(int x,int y);

La fonction déplace le curseur à la position spécifiée par les arguments x et y de la forme (1~21;1~8).

Chaque "case" de l'écran correspond à un rectangle de 6*8 pixels.

Print

prototype : void Print(const unsigned char *str);

La fonction affiche à la position du curseur la chaîne de caractères passée en arguments. Elle ne renvoie rien.

Attention les textes trop longs ne sont pas renvoyés à la ligne ! C'est à vous de découper votre chaîne et de déplacer le curseur via la fonction locate().

PrintRev

prototype : void PrintRev(const unsigned char *str);

La fonction affiche à la position du curseur la chaîne de caractères passée en arguments en couleurs inversées : pixels éteints sur fond de pixels allumés. Elle ne renvoie rien.

Attention les textes trop longs ne sont pas renvoyés à la ligne ! C'est à vous de découper votre chaîne et de déplacer le curseur via la fonction locate().

PrintC

prototype : void PrintC(const unsigned char *c);

Selon Casio cette fonction sert à afficher un unique caractère. On lui passe en argument la chaîne de caractères à afficher, et elle ne renvoie rien. Après, pourquoi une fonction spécifique qui produit le même résultat que la fonction Print() ?

PrintRevC

prototype : void PrintRevC(const unsigned char *c);

Cette fonction sert à afficher un caractère en couleurs inversées : pixels éteints sur fond de pixels allumés. On lui passe en argument la chaîne de caractères à afficher, et elle ne renvoie rien. Après, pourquoi une fonction spécifique qui produit le même résultat que la fonction PrintRev() ?

PrintLine

prototype : void PrintLine(const unsigned char *str,int max);

Cette fonction affiche une chaîne de caractère passée en premier argument à la position du curseur (définie par locate() ou positionnée de base en haut à gauche), mais la spécificité de cette fonction est que l'affichage de la chaîne s'arrête à l'abscisse passée en second argument.

PrintRLine

prototype : void PrintRLine(const unsigned char *str,int max);

Cette fonction affiche une chaîne de caractère passée en premier argument à la position du curseur (définie par locate() ou positionnée de base en haut à gauche) en couleurs inversées (pixels éteints sur fond de pixels allumés), mais la spécificité de cette fonction est que l'affichage de la chaîne s'arrête à l'abscisse passée en second argument.

PrintXY

prototype: void PrintXY(int x,int y,const unsigned char *str,int type);

Cette fonction est très importante : elle permet d'afficher un texte passé en troisième argument aux coordonnées x et y précisées EN PIXELS et non en cases, de la forme : (0~127;0~63).

L'argument type correspond à 0 pour affichage normal et 1 pour affichage en couleurs inversées (pixels éteints sur fond de pixels allumés). La fonction ne renvoie aucune valeur.

PrintMini

prototype : void PrintMini(int x,int y,const unsigned char *str,int type);

Cette fonction permet d'afficher à l'écran un texte plus petit (4*6 contre 6*8) aux coordonnées x et y passées en argument précisées en pixels, de la forme : (0~127;0~63).

L'argument type correspond à 0 pour affichage normal et 1 pour affichage en couleurs inversées (pixels éteints sur fond de pixels allumés). La fonction ne renvoie aucune valeur.

SaveDisp

prototype : void SaveDisp(unsigned char num);

Permet de stocker l'image affichée à l'écran dans la RAM (mémoire vive, donc détruite à la fin de l'exécution du programme). L'argument num spécifie sur quelle image on doit la stocker : SAVEDISP_PAGE1, SAVEDISP_PAGE2, SAVEDISP_PAGE3. La fonction ne renvoie aucune valeur. Pour ressortir l'image, voir RestoreDisp().

RestoreDisp

prototype : void RestoreDisp(unsigned char num);

Permet de ressortir une image enregistrée à l'écran. L'argument num spécifie l'image source : SAVEDISP_PAGE1, SAVEDISP_PAGE2, SAVEDISP_PAGE3. La fonction ne renvoie aucune valeur. Pour stocker l'image, voir SaveDisp().

PopUpWin

prototype : void PopUpWin(int n);

Cette fonction affiche une fenêtre système, comme celles affichées par la calto lors d'une erreur. Vous lui donnez en argument la taille, en lignes, de la fenêtre (de 1 à 5 lignes en théorie, mais j'ai déjà utilisé la fonction avec l'argument 7 sans erreur). La fonction ne retourne rien.

Fonctions de manipulation des fichiers

Bfile_OpenFile

prototype : int Bfile_OpenFile(const FONTCHARACTER *filename,int mode);

Ouvre le fichier dont le nom est passé en argument, sous forme d'une chaîne de caractère de type FONTCHARACTER. La forme de cette chaîne de caractère est :

FONTCHARACTER PathName[]={'\\','\\','f','l','s','0','\\','f','i','l','e','n','a','m','e','.','e','x','t',0};

Si votre fichier se trouve dans la mémoire de stockage, choisissez comme répertoire "fls", pour la carte SD choisissez "crd". Le nom de fichier fait maximum 8 caractères, plus le point et votre extension (choisissez celle que vous voulez, cela ne change rien au codage du fichier). La chaîne est terminée par un 0.

L'argument mode correspond à :

_OPENMODE_READ : lecture seule.

_OPENMODE_WRITE : écriture seule.

_OPENMODE_READWRITE : lecture et écriture.

_OPENMODE_READWRITE_SHARE : lecture et écriture exclusives à ce programme (si un autre programme y touche, il aura uniquement un code d'erreur).

La valeur retournée est un handle. Il est ESSENTIEL de conserver ce handle tout au long de la lecture ou de l'écriture du fichier, il permet en effet d'accéder au fichier et de le fermer ! Si il y a erreur à l'ouverture du fichier, le handle retourné aura une valeur négative.

Bfile_OpenMainMemory

prototype : int Bfile_OpenMainMemory(const unsigned char *name);

Ouvre un fichier dans la mémoire principale. Le nom de fichier est de la forme :

unsigned char name[]={“filename”};

Vous n'avez à préciser que le nom, dont la taille est inférieure à 8 caractères, sans extension ni répertoire.

La valeur retournée est un handle. Il est ESSENTIEL de conserver ce handle tout au long de la lecture ou de l'écriture du fichier, il permet en effet d'accéder au fichier et de le fermer ! Si il y a erreur à l'ouverture du fichier, le handle retourné aura une valeur négative.

Bfile_ReadFile

prototype : int Bfile_ReadFile(int HANDLE,void *buf,int size,int readpos);

Le premier argument est le handle récupéré à l'ouverture du fichier. Le second est le buffer qui reçoit les données (passage par pointeur), c'est-à-dire un tableau dont vous aurez bien prévu la taille afin d'éviter que les données soient perdues dans la RAM. L'argument size est la longueur (en octets) à lire. Le dernier argument est la positon à laquelle va commencer la lecture. Si elle vaut -1, la lecture commencera à la position indiquée par le curseur du fichier, que l'on peut modifier grâce à la fonction Bfile_SeekFile(); sinon la lecture commence à la position indiquée en argument.

La fonction retourne le nombre d'octets lus. Si la fonction échoue, la valeur retournée est un code d'erreur, une valeur négative.

Bfile_WriteFile

prototype : int Bfile_WriteFile(int HANDLE,const void *buf,int size);

Cette fonction est compliquée à utiliser, puisqu'elle ne marche pas comme il le faudrait... La fonction prend en premier paramètre le handle du fichier ouvert, en second le buffer à écrire (un tableau sur lequel sont stockées les données à enregistrer) et enfin le nombre d'octets à écrire.

Mais dans la mémoire de stockage, si on fait plusieurs appels à Bfile_WriteFile() consécutifs, seul le premier aura une action. Si le fichier existe déjà et qu'on essaye de surécrire, ça donne des caractères inattendus. Dans la carte SD, on peut faire plusieurs appels consécutifs à Bfile_WriteFile(), tout sera écrit à la suite. Mais Bfile_SeekFile() ne change pas la position du curseur d'écriture, et si le fichier existe déjà, on écrit toujours à la suite de ce qu'il contient déjà.

En conclusion, la seule manière d'écrire sans risque dans les fichiers est d'effacer et recréer le fichier à chaque fois, et de tout écrire d'une seule traite.

- merci à pierrotll pour ces explications -

La fonction retourne la position du curseur de fichier, oou un code d'erreur, une valeur négative.

Bfile_SeekFile

prototype : int Bfile_SeekFile(int HANDLE,int pos);

Cette fonction positionne le curseur du fichier dont le handle d'ouverture est passé en premier argument à la position indiquée par le second argument. Encore une fois, méfiez-vous : cette fonction ne produit pas toujours les résultats attendus, il arrive qu'elle n'ait aucun effet !

La fonction retourne le nombre d'octets pouvant être lus. En cas d'erreur, elle retourne un code d'erreur, qui est une valeur négative.