Syscall

Les syscalls (abréviation de system call, c'est-à-dire appel système) sont des fonctions fournies par le système d'exploitation. L'exécution d'un syscall utilise normalement les interruptions du processeur, mais CASIO n'a pas fait dans autant de finesse et laisse les add-ins appeler les syscalls comme des fonctions sur la seule base d'un numéro unique qui leur est associé.

Les propriétés des syscalls, leurs paramètres, leurs buts et leur nombre n'ont jamais été documentés par CASIO. C'est le travail de Simon Lothar and Andreas Bertheussen qui a révélé leur existence et leur organisation. Nous connaissons aujourd'hui la procédure pour les appeler et une description partielle de leurs rôles. Une partie de la documentation existante est disponible sur Planète Casio.

Les fonctionnalités offertes par les syscalls couvrent l'ensemble des rôles du système d'exploitation et s'étendent bien plus loin que ne le permet fxlib, avec la gestion des timers, de l'horloge, l'accès aux messages du système, le lancement croisé de plusieurs applications ou la communication série et USB.

Intérêts

Les avantages de ces syscalls sont nombreux. Ils incluent notamment :

• L'accès à des outils non présents dans fxlib, comme le système RTC (Real-Time Clock, l'horloge du processeur) qui permet de gérer l'horloge de la machine (active même quand la calculatrice est éteinte) ;
• Le contournement de fxlib, en réécrivant des procédures parfois significativement plus rapides (Monochrome Lib en est un bon exemple).

Liste des sycalls connus

Voici quelques exemples de ce que permettent les syscalls.

Contrôle du curseur

int  Cursor_SetPosition   (char column, char row);
int  Cursor_GetFlashStyle (void);
void Cursor_EnableFlash   (void);
void Cursor_DisableFlash  (void);

Pour déplacer le curseur et utiliser le clignotement (champs de saisie).

Affichage de texte

void Print_Generic    (int mode, char *string, int maxcol);
void Print_AtCursor   (char *string, int type);
void Print_AtLocation (char *string, int column, int row);

Des fonctions de texte utilisées par les fonctions habituelles du SDK mais ne faisant pas partie de fxlib.

Gestion du clavier

int Kbd_GetKeyWait (int *col, int *row, int waittype, int timeout, int menu, ushort *keycode);

Un GetKeyWait fonctionnel, contrairement à celui de fxlib.

Gestion de l'affichage

char *Disp_GetVRAMPtr (void);
char *Disp_Manage     (int pageID, int action);

Permettent d'utiliser directement la VRAM et les buffers de sauvegarde de SaveDisp() et RestoreDisp().

Applications intégrées

void App_CONICS  (int isAppli, unsigned short optionNum);
void App_DYNA    (int isAppli, unsigned short optionNum);
void App_EACT    (int isAppli, unsigned short optionNum);
void App_EQUA    (int isAppli, unsigned short optionNum);
void App_PRGM    (int isAppli, unsigned short optionNum);
void App_FINANCE (int isAppli, unsigned short optionNum);
void App_GRAPH   (int isAppli, unsigned short optionNum);
void App_LINK    (int isAppli, unsigned short optionNum);
void App_MEMORY  (int isAppli, unsigned short optionNum);
void App_RECUR   (int isAppli, unsigned short optionNum);
void App_RUNMAT  (int isAppli, unsigned short optionNum);
void App_STAT    (int isAppli, unsigned short optionNum);
void App_SYSTEM  (int isAppli, unsigned short optionNum);

Ces syscalls permettent de lancer n'importe quelle application déjà existante de l'OS.

int App_RefreshAddInTable  (void);
int App_GetIntegratedCount (void);
int App_Run                (int R4, int R4, int index, int allow_recursion);

Ces derniers donnent la possibilité de lancer également des application ajoutées par l'utilisateur.

Utilisation de l'interface Serial

int Serial_ReadByte                (unsigned char *dest);
int Serial_ReadBytes               (unsigned char *dest, int max, short *size);
int Serial_WriteByte               (unsigned char byte);
int Serial_WriteBytes              (unsigned char *src, int size);
int Serial_GetRxBufferSize         (void);
int Serial_GetTxBufferFreeCapacity (void);
int Serial_ClearReceiveBuffer      (void);
int Serial_ClearTransmitBuffer     (void);
int Serial_Open                    (unsigned char *conf);
int Serial_Close                   (int mode);
int Serial_Peek                    (int index, unsigned char *dest);
int Serial_IsOpen                  (void);

L'utilisation de l'interface Serial est à la base de toute communication entre calculatrices/composants électroniques.

Utilisation du système RTC

void ResetRTC          (uint mode);
void RTC_GetTime       (uint *hours, uint *mins, uint *secs, uint *msecs);
int  RTC_GetTicks      (void);
int  RTC_HasElapsed_ms (int start_value, int duration);
void RTC_SetDateTime   (uchar **data);

L'ensemble de ces syscalls permet d'accéder au système RTC (Real Time Clock ou Horloge Temps Réel) de la calculatrice et de le manipuler. Cela permet d'utiliser des compteurs de temps ou autres horloges dans les programmes.

Les Timers

int Timer_Install   (int TimerID, void (*handler)(void), int delay);
int Timer_Uninstall (int TimerID);
int Timer_Start     (int TimerID);
int Timer_Stop      (int TimerID);

Ces quatre syscalls permettent d'utiliser les timers du système.

Accès aux variables de configuration

char Setup_GetEntry     (unsigned int index);
char *Setup_SetEntry    (unsigned int index, char value);
char *Setup_GetEntryPtr (unsigned int index);

On peut modifier les entrées du menu SET UP, partout accessible avec la combinaison de touches [SHIFT]+[MENU].

Variables de la mémoire Alpha

char *Alpha_GetData   (char variable, char *dest);
char Alpha_SetData    (char variable, char *src);
void Alpha_ClearAlpha (void);
void Alpha_ClearAll   (void);

Les variables de la mémoire Alpha sont A~Z, ainsi que r, têta et Ans.

Manipulation des chaînes de caractères étendus

int       MB_IsLead            (char character):
int       MB_ElementCount      (char *str);
int       MB_ByteCount         (char *str);
char      *MB_strcat           (char *dest, char *src);
char      *MB_strncat          (char *dest, char *src, int bytes);
char      *MB_strcpy           (char *dest, char *src);
char      *MB_GetSecondElemPtr (char *str);
short int MB_GetElement        (char *str);

Les caractères étendus sont stockés sur plus d'un octet, car la table de la calculatrice en est longue. La plupart de ces fonctions sont des adaptations des fonctions standard de manipulation des chaînes de caractères.