ATTENTION: cela fait plus de deux ans que je n'ai pas toucher à ma HP48 et je m'y remet là, puis je n'ai pas de doc ou de livre tout ce qui est écrit ici, ce sont mes souvenir:) donc si il existe des erreurs veuillez me le préciser ici: webmaster.

Sommaire:

• Origine du RPL
• Le RPN
• La pile
• Les objet
• Les types
• Structure d'un programme RPL
• Définitions par programme RPL
• Déboguer un programme RPL
• Les menus de la touche PRG
• Un premier programme de jeu (puissance 4)

• D'où viens la notion de RPL:

RPL signifie Reverse Polish Language (langage polonais inversé). C'est un langage de programmation utilisant une technologie de type RPN (Reverse polish notion) pour l'ordonnancement des instructions qui le compose. Le RPN est une manière de noter une relation algébrique. Au lieu de noté: arg1 func1 arg2 (ex: 2 + 3), on note: arg1 arg2 func1 (2 3 +)

• Principe du RPN:

En fait la notion de polonais inversé est facile à comprendre. Elle est issu du fait qu'en informatique on peut représenter une expression de type arg1 func1 arg2 sous forme d'un arbre avec au sommet func1 et comme feuilles: arg1 à gauche et arg2 à droite.

Sachant que pour un tel arbre il existe trois type de parcours: préfixé (le sommet d'abord) , infixé (le sommet après la feuille de gauche) et post fixé (le sommet après les feuilles) il existe donc trois écritures possibles de l'expression:

• func1 arg1 arg2
• arg1 func1 arg2 (langage naturel)
• arg1 arg2 func1 (RPN)

Le principale avantage du parcours post fixé donc du RPN c'est que l'on peut tester les arguments et leur types avant de les faire exécuter par la fonction. Cela permet une meilleur sécurisation du code que l'on crée. De plus, la HP48 travaillant avec une PILE FIFO ça augmente encore la puissance de l'utilisation du RPN.

• La pile:

Une pile est une structure de donnée, c'est comme une commode dans laquelle chaque tiroir stocke une donnée.
Il existe deux grand type de pile les pile FIFO (first-in first-out) et les piles FILO ou LIFO (first-in last-out)

• Pile FILO:

• Pile FIFO:

La pile de la HP est une pile FILO/LIFO c'est à dire que si on rentre un élément dans cette pile, c'est celui-ci qui sera traiter en premier par la prochaine fonction que l'on exécutera. La pile est visible sur l'écran de la HP, et en temps normal on peut voir le contenu des 5 premier niveau noté : 1: , 2:, 3:, 4: et 5:
Le premier niveau représente le sommet de la pile (elle a donc la tête en bas)

• Les objets:

Un objet est la description d'un élément d'un type donné, par exemple 2 est un objet, la chaîne "coucou" est un objet. Dans la HP48 tout est objet en réalité, les arguments chiffre, chaîne, équation, les programmes du menu VAR les librairies, les erreurs qui s'affiche quand on se trompe de touche...

C'est objets sont réutilisable et parfois modifiables.
Il existe pour tout ces objet un identifiant de sa catégorie qui est son TYPE.

• Les types d'objets:

Sur HP pour savoir de quel type est un objet il suffit de le placer dans la pile au niveau 1 et de faire TYPE. Ainsi on s'aperçoit que:

• un entier est de type: 0
• une équation de type: 6
• une chaîne de type: 2
• un dessin (grob) de type: 11
• ...

• Structures d'un programme RPL:

Un programme en RPL commence toujours par << et fin toujours par >>

A l'intérieur de << et >> on peut utilise n'importe quel fonction de la HP48.

Par ailleurs, il existe un moyen permettant de créer des variables globales à un programmes en utilisant:
-> VAR1 VAR2 VAR3 << sous programme >>
A l'intérieur d'un programme où VAR1 à 3 sont 3 variables globales réutilisable dans le sous programmes suivant. Remarque, on moins 1 variables globales et au plus c'est limité par la mémoire disponible. Par ailleurs, il faut se rappeler que la HP évalue le sous programme (l'exécute)

En général les variables sont en majuscules mais les écrire en minuscules et de manière significative (pas juste I, N, P mais compeur1, nb_element, port) c'est plus confortable pour relire le programme.
La HP différencie les majuscules et minuscule alors faites attention.

• Structures de test:
  • IF THEN ELSE:

Utilisation: IF condition THEN seq1 ELSE seq2 END
Les clauses seq1 et seq2 sont des suites d'instruction à exécuter. Le ELSE seq2 n'est pas obligatoire. Si condition est vrai alors seq1 est exécuté sinon c'est seq2.

• CASE:

Utilisation: var CASE cas1 THEN seq1 CASE cas2 THEN seq2 ... END
En fonction de la valeur de var si on est dans le cas1 (ceci est une expression vérifiant que var=cas1) alors on exécute seq1 sinon on vérifie var=cas2 et si oui on exécute seq2 sinon...

• Structures de boucles:
  • START:

Utilisation vala valb START seq NEXT step STEP
Réalise (valb-vala+1)/step tours de boucle et exécute la séquence seq utilisée à chaque tour de boucle.

• FOR:

Utilisation: vala valb FOR var seq NEXT step STEP
Fait varier la variable var de vala à valb par pas de la valeur de step.

• DO:

Utilisation: DO seq1 UNTIL condition END
Exécute seq1 tant que la condition est vrai.

• Opérateurs (conditions):

Utilisation: exp1 exp2 cond
Exp1 et 2 sont les deux expressions à comparer et cond est la condition parmi: { == , ≠ , <, >, ≤, ≥, AND, OR, XOR, NOT, SAME, TYPE, SF, CF, FS?, FC?, FS?C, FC?C, LININ}

• L'utilisation de DEF (définition):

Sur la HP il existe une touche DEF (alias STO) qui permet de créer une définition c'est un à dire un programme réalisant une fonction donnée. Exemple:
'F(N)=N^3+2' DEF

Cela va créer dans le répertoire courant un programme appelé F qui fera:
<< -> N 'N^3+2' >> Ici l'expression N^3+2 sera exécutée après avoir rempli N avec sa valeur stocké dans le niveau 1 de la pile.

• Déboguer une application RPL:

Pour pouvoir déboguer votre programme vous aurez besoin d'inclure la commande HALT dans votre programme. Lors de l'exécution de celui-ci quand il va rencontrer la commande HALT il va se mettre en mode debug avec écrit HALT en haut de l'écran. Remarque vous pouvez aussi charger votre programme au niveau 1 de la pile et dans le menu PRG, RUN lancer la commande DEBUG.

Une fois dans le mode DEBUG vous aurez plusieurs choix possible qui se regroupent dans les commandes: { SST, SST↓, NEXT, KILL }

Les commandes SST servent à effectué une instruction du programme, l'instruction NEXT sert à voir ce qu'il y a comme instruction après la prochaine qui va être traitée et KILL sert à terminer le programme.

• Le menu PRG:

Explication des commandes du menu PRG:

• BRCH
• TEST
• TYPE
• LIST
• GROB
• PICT
• IN
• OUT
• RUN
• ERROR

• Menu BRCH (branchement):

Nous avons déjà vu précédemment la plus part des fonctions de branchement il en reste cependant deux:

• IFT:

Equivalent de: cond IF THEN seq1.

• IFTE:

Equivalent de: cond IF THEN ELSE seq1 seq2
Si la condition cond est vrai c'est seq1 qui se fera sinon se sera seq2.

• Menu TEST:

Je pense que les 6 premiers test de la liste cité dans la partie des opérateurs se passe de commentaire donc attaquons le reste.

• Les fonctions booléennes:

Les fonctions booléennes servent à réaliser des combinaisons entre les BITS de deux éléments. Un bit étant l'élément composant la base 2 de numérotation (0 ou 1). Un octet est formé de 8 bits et un quartets de 4bits. Il existe aussi une base 8 (octale, 0 1 2 3 4 5 6 et 7) et une base 16 (hexadécimale, 0 1 2 3 4 5 6 7 8 9 A B C D E F). C'est 3 bases sont les plus utilisée en informatiques et convertir une base dans une autre n'est pas sorcier il faut se rappeler que:

Avec i le nombre de chiffre dans la base a.
Exemple : conversion hexa vers décimale de: A710

A*16^3+7*16^2+1*16^1+1*16^0=42768

La conversion en sens inverse se fait par division successive des puissance de la base (ici 16^i) pour i variant du nombre de chiffre maximum de la base vers 0. Remarque: 2^4=16 et 2^3=8 donc on peut facilement associé l'hexa et l'octal à une représentation binaire.

• AND:

Réalise un et logique entre deux variables : Soit a et b, le résultat de a b AND donne:

• OR:

Réalise un ou logique entre deux variables : Soit a et b, le résultat de a b OR donne:

• XOR:

Réalise un ou exclusif logique entre deux variables : Soit a et b, le résultat de a b XOR donne:

• NOT:

Réalise un non logique d'une variables : Soit a le résultat de a NOT donne:

• Les fonctions de type:

Les fonctions de types permettent de vérifier si deux éléments sont identiques ou de types similaire.

• SAME:

Utilisation: var1 var2 SAME
Si var1 et var2 sont identique SAME renvoie 1 sinon renvoie 0.

• TYPE:

Utilisation: var TYPE
Retourne le type sous forme numérique du type de variable passer en paramètre au niveau 1 de la pile.

• Les fonctions sur les flags:

La HP possède 64 flags modifiables par l'utilisateur pour spécifier tel ou tel fonctionnement de la HP par exemple il y a un flag qui détermine si elle est en mode RAD ou DEG ou encore un autre qui dit si les calculs sont symbolique ou numérique ou encore si on entend les BIPs ou pas... Remarque les flags sont modifiables dans le menu MODE -> FLAG mais quelques un d'entre eux ne le sont que par des commandes système. Remarque pour utiliser un flag on doit lui donner une valeur négative entre 0 et -63.

• SF:

Fonction SET FLAG qui initialise un flag à TRUE: flag SF

• CF:

Fonction CLEAR FLAG qui initialise un flag à FALSE: flag CF

• FS?:

Fonction FLAG SET? qui renvoie TRUE si le flag est TRUE: flag FS?

• FC?:

Fonction FLAG CLEAR? qui renvoie TRUE si le flag est FALSE: flag FC?

• FS?C:

Fonction FLAG SET? THEN CLEAR qui met le flag à FALSE si il était à TRUE: flag FS?C

• FC?C:

Fonction FLAG CLEAR? THEN CLEAR: qui met le flag à FALSE si il l'était déja: flag FC?

• Autre:

Il reste plus que LININ mais je ne sais plus à quoi cela sert:p

• Menu TYPE:

Ce menu sert principalement à faire des changements de TYPE d'objet sur la HP.

• OBJ->:

Cette fonction doit contenir l'objet à décomposé en élément simple au niveau 1 de la pile. Chaque élément qui compose l'objet (liste ou matrice par exemple) seront placés dans la pile et au niveau 1 on récupèrera la taille (un entier pour une liste et une liste de n entier pour une matrice).

• ->ARR:

Fonction qui transforme en une matrice, une suite d'entier stocké dans la pile et une liste contenant les dimensions n et m de cette matrice.

• ->LIST:

Fonction qui transforme en une liste, une suite d'objets stocké dans la pile et un entier définissent sa taille au niveau 1.

• ->STR:

Fonction qui stock l'objet de niveau 1 sous forme de chaîne de caractère.

• ->TAG:

Fonction qui rajoute un TAG à un objet, un TAG est un descriptif que l'on peut rajouter sous la forme: :DESC: VAR où VAR est la variable au niveau 2 et DESC la description au niveau 1.

• ->UNIT:

Converti l'élément de niveau 2 avec l'unité de niveau 1 en élément avec unité. Exemple: 2 3_m ->UNIT donne: 2_m

• C->R:

Converti un complexe en réel, prend au niveau 1 un complexe de la forme (réel, imaginaire) et renvoie au niveau 2 le réel et au niveau 1 l'imaginaire.

• R->C:

Fonction inverse de la précédente renvoie un complexe à partir du réel au niveau 2 et de l'imaginaire au niveau 1.

• NUM:

Renvoie la valeur numérique d'un caractère depuis la table ASCII.

• CHR:

Renvoie le caractère associé a un numéro dans la table ASCII.

• DTAG:

Enlève le TAG positionné par ->TAG

• EQ->:

Pour une équation de type 'F(x)=x+3' par exemple, renvoie 'F(x)' au niveau 2 et 'x+3' au niveau 1.

• TYPE:

Renvoie le type de l'objet au niveau 1.

• VTYPE:

• Menu LIST:

Dans ce menu on retrouve OBJ-> et ->LIST déjà décrit dans le menu TYPE. Par ailleurs on trouve aussi deux répertoire ELEM et PROC.

• ELEM:

Dans cette section se trouve toutes les instructions de manipulation d'un élément d'une liste.

• GET:

Fonction qui récupère l'élément d'indice i d'une liste donnée.
Utilisation: { e1 e2 e3} ind GET donne l'élément Ei d'indice i défini par ind.

• GETI:

Même chose que précédemment mais on garde au niveau 3 la liste et au niveau 2 l'indice i incrémenter de 1. Au premier niveau on à l'élément d'indice i.

• PUT:

Fonction inverse des précédentes qui permet de positionner un élément dans une liste à un indice donnée.
Utilisation: {e1 e2 e3} ind e4 PUT donne au niveau 1: {e1 e4 e3}.

• PUTI:

Idem que précédemment mais incrémente l'indice. On récupère la liste au niveau 2, l'indice incrémenté au niveau 1.

• SIZE:

Renvoie la taille de la liste passé au niveau 1.

• HEAD:

Renvoie la tête de la liste c'est à dire l'élément d'indice 1.

• POS:

Renvoie la position de la première instance de l'élément passer en paramètre de la liste donnée ou 0 si l'élément n'y est pas.
Utilisation: {e1 e2 e2 e3 } e2 POS renvoi 2.

• TAIL:

Renvoie la suite de la liste soustraite de la tête: TAIL=LIST/HEAD.
Utilisation: { e1 e2 e3 e4} TAIL renvoi: {e2 e3 e4}

• PROC:

Section qui offres des procédures de calcul sur les listes.

• DOLIST:

/*pas encore d'info dessus*/

• DOSUBS:

/*pas encore d'info dessus*/

• NSUB:

/*pas encore d'info dessus*/

• ENDSUB:

/*pas encore d'info dessus*/

• STREAM:

/*pas encore d'info dessus*/

• REVLIST:

Change le sens de la liste, place les éléments en sens inverse.
Utilisation: { e1 e2 e3} REVLIST donne :{e3 e2 e1}

• SORT:

Tris les éléments de la liste par ordre croissant.

• SEQ:

/*pas encore d'info dessus*/

• SUB:

/*pas encore d'info dessus*/

• REPL:

/*pas encore d'info dessus*/

• Menu GROB (graphic object):

Un GROB est un objet graphique représenter par Graphic x * y au niveau de la pile. En fait cela correspond à un ensemble de point formant un dessin. Un autre nom que l'on peut donner c'est celui de SPRITE ou LUTIN (en français pour SPRITE)

Dans ce menu vous aurez donc toutes les fonctions de manipulation de SPRITE pour créer vos animations par exemples (pratique pour les jeux:)

• ->GROB:

Utilisation: "chaîne" taille ->GROB
Cette fonction créer un objet graphique composé d'une chaîne de caractère. L'option taille permet de définir la taille du texte avec: 1-> petit, 2->normal, 3->grand au niveau du graphique.

• BLANK:

Utilisation: #tailleXd #tailleYd BLANK
Cette fonction créer un objet graphique vide de taille tailleX, tailleY. Les paramètres de tailles doivent être des valeurs binaires (décimale ou hexadécimale) exemple: #25d #24d BLANK renvoie : Graphic 25*24

• GOR:

Réalise une opération logique OU entre chaque bit de deux objet graphiques. Permet de concaténer deux graphiques.

• GXOR:

Réalise un OU exclusif entre deux objets graphiques, concatène les deux mais si un bit est présent dans les deux graphisme il est alors effacé du résultat. Très utiliser dans les animations voir technique de masquage dans la partie ASSEMBLEUR.

• SUB:

Récupère un graphique depuis un autre.
Utilisation : Graphic { #coordX #coordY} { #tailleX #tailleY } SUB

• REPL:

Remplace un graphique dans un autre.
Utilisation : Graphic {#coordX #coordY} REPL

• ->LCD:

Affiche le graphique au niveau 1 de la pile pendant un bref laps de temps par dessus celle-ci.

• LCD->:

Stocke le contenu de la pile dans un objet graphique.

• SIZE:

Donne la taille de l'objet graphique placé au niveau 1. Renvoie : la taille X sous forme binaire au niveau 2 et la taille Y sous forme binaire au niveau 1.

• ANIMATE:

Anime une suite de graphiques.
Utilisation 1: Graphic1 Graphic2 .. GraphicI I ANIMATE
Anime les I graphiques.

• Menu PICT (picture):

Dans ce menu on retrouve les fonctions de dessins qui servent à créer des objets graphiques.

• PICT:

Cette instruction est en fait l'objet graphique de la zone de dessin de la HP.

• PDIM:

Défini la taille de la zone graphique. Prend au niveau 2 de la pile la taille X et en niveau 1 la taille Y sous la forme: #tailleX #tailleY PDIM.

• LINE:

Dessine une ligne sur la zone graphique standard.
Utilisation: { #coordX1 #coordY1} { #coordX2 #coordY2 } LINE

• TLINE:

Trace une ligne depuis le dernier point placé.
Utilisation: { #coordX2 #coordY2 } TLINE

• BOX:

Trace un rectangle.
Utilisation: { #coordX1 #coordY1 } { #coordX2 #coordY2 } BOX

• ARC:

Trace un arc de cercle.
Utilisation:

• PIXON:

Affiche un point sur la zone graphique.
Utilisation: { #coordX #coordY } PIXON

• PIXOFF:

Efface un point de la zone graphique.
Utilisation: { #coordX #coordY } PIXOFF

• PIX?:

Cette fonction renvoie true si le point tester sur la zone graphique est affiché.
Utilisation: { #coordX #coordY } PIX?

• PVIEW:

Passage en mode graphique pour afficher l'écran à partir des coordonnées haut/gauche de la zone (view port) voulu.
Utilisation { #coordX #coordY } PVIEW

• PX->C:

Transforme les coordonnées du point en coordonnées cartésienne selon le "RANGE" spécifié. Prend { #coordX #coordY } et renvoie (x,y)

• C->PX:

Fonction inverse de la précédente.

• Menu IN:

Dans ce menu se trouve les fonctions de gestions d'informations au clavier.

• INFORM:

Cette fonction créer une menu d'affichage du même genre que le menu plot par exemple.

• NOVAL:

/*Pas encore d'information disponible*/

• CHOOSE:

Créer une choose box permettant de choisir l'option que l'on désire dans une liste donnée.
Utilisation: "Titre" { "Option1" "Option2" "Option3" } Nboption CHOOSE
Renvoi: Option2 2 par exemple où 2 est le numéro de l'option renvoyé dans la liste par rapport au choix effectué. Sinon renvoi 0 dans le cas où on est choisi: CANCEL

• INPUT:

Pose une question, affiche le titre de la question et récupère dans une chaîne la réponse.
Utilisation: "Question" "début de la réponse" INPUT
Renvoi: la réponse sous forme d'une chaîne.

• KEY:

Fonction de scrutation clavier. Si aucune touche n'est pressé pendant l'exécution de KEY, on retrouve 0 dans la pile au niveau 1 sinon le code de la touche au niveau 2 et 1 au niveau 1. (le 1 signifie qu'une touche à bien été pressée) Il faut mettre cette fonction dans une boucle.

• WAIT:

Utilisation: n WAIT
Attend n secondes avant de continuer l'exécution.

• PROMPT:

Stop l'exécution d'un programme et affiche un message.
Utilisation: "message" PROMPT

• Menu OUT:

Les fonctions de ce menu, sont des fonctions de gestion d'affichage et son.

• TEXT:

Cette fonction permet de repasser en mode TEXTE c'est à dire sur la pile et de sortir du mode graphique lancé par PVIEW vu précédemment.

• CLLCD:

Efface le contenu de l'écran.

• DISP:

Affiche un message.
Utilisation: "le message" DISP

• FREEZE:

Gèle l'écran jusqu'a pression d'une touche (nécessite un entier au niveau 1 de la pile).

• MSGBOX:

Affiche un message dans une boite de dialogue.
Utilisation: "message" MSGBOX

• BEEP:

Emet un son ou joue une mélodie.
Utilisation 1: Fréquence Durée_en_ms BEEP
Utilisation 2: { Fréquence } { Durée } BEEP

Remarque: un son émit à une fréquence correspond une note on calcul la fréquence comme suit: Freq= 440*2^(octave-(note-10)/12) où octave=0 et note=10 donne le LA international du diapason sachant qu'il y a 12 note de musique dans une porté avec les #.

• Menu RUN:

Voir le déboguage d'un programme plus haut.

• Menu ERROR:

Ce menu permet de gérer les erreurs quand elles surviennent et oui un programme parfait ca n'existe pas :)

• DOERR:

Génère une erreur du numéro donnée en niveau 1 de la pile.
Utilisation: numerr DOERR

• ERRN:

Indique le numéro de l'erreur qui vient de se produire.

• ERRM:

/*pas d'info disponible*/

• ERR0:

/*Pas d'info disponible*/

• LASTARG:

Replace dans la pile les derniers arguments donnée à la fonction qui viens de générer l'erreur.

• IFERR:

Test si une erreur c'est produite.
Utilisation: IFERR THEN seq1 ELSE seq2 END

• Programmer un jeu en RPL le puissance 4 (à deux joueurs):

Voici le programme commenter de puissance 4 simple que j'ai écrit en RPL le premier jeux que j'ai réalisé pour hp48 quand j'avais 16 ans. Version téléchargeable directement transférable dans la HP: ici.(PS: ce qui est en rouge dans le code qui suit ne doit pas être écrit dans le code source)

<<
/*Initialisation du mode graphique*/
#131d #63d PDIM {#0d #0d } PVIEW
/*Création du tableau des pièces 7 colonnes sur un affichage 131*63 soit 7 colonnes de 18 pixels de large (9 lignes pour faire 7 colonnes)*/
0 8 FOR X
X 18 * R->B
DUP #0d 2 ->LIST
SWAP #63d 2->LIST LINE NEXT
/*Initialisation*/
1 'play' STO { 0 0 0 0 0 0 0 } 'list' STO
/*Affichage du joueur en cours*/
DO UNTIL
"Joueur: " play ->STR + MSGBOX
/*Attente de préssion sur une touche du clavier entre 1 et 7*/
DO UNTIL KEY END
/*Mise en forme du résultat retourné par KEY voir plus bas la définition des touches*/
-> val << val 10 / ip 6 - 2 SWAP - 3 * 1 + val 10 MOD 2 - + >>
/*Vérification que l'on puisse jouer cette colonne*/
-> place << IF list place GET 7 < THEN
/*On incrémente la valeur de cette colonne*/
list place DUP2 get 1 + put
/*Affichage d'un rectangle blanc pour le joueur 1 stocké dans une variable 'IMG1' de taille 18*8 et d'un rectangle noir pour le joueur 2 stocké dans 'IMG2' préalablement dessinés/*
PICT SWAP place 1 - 18 * R->B
SWAP 8 * 64 SWAP - R->B 2 ->LIST
"IMG" play + STR-> RCL REPL
/*Passage au joueur suivant*/
2 - play 1 + 'play' STO END >>
0 END >>