Para estar al dia de las actualizaciones de esta página, y para una mejor atención por mi parte, mándame un e-mail a la siguiente dirección:

javigc@lettera.net

Indicando el nivel de programación que posees.
Pon como título: CURSO DE PROGRAMACIÓN.

• ÍNDICE

- TEMA 0. Introducción del Curso
- TEMA 1. Como hacer mi primer programa
- TEMA 2. Estructuras condicionales I: IF...THEN...ELSE...END
- TEMA 3. Cuadros de Texto
- TEMA 4. Las Variables

• TEMA 0. INTRODUCCIÓN DEL CURSO

Este curso va dirigido a aquellas personas que sepan manejar la calculadora (es decir, que sepan crear y guardar variables, moverse por los directorios...) y que quieran sacarle más provecho a su HP mediante la ejecución de algún programa que nos ayude en esas horas tan tensas de los exámenes.

 Está bien, comenzaremos nuestro curso de RPL con algunas de las convenciones que se adoptarán a lo largo de este curso:
Como el PC no tiene los carácteres de la HP, se hace obligatorio el mostrar algún tipo de conversión. Esto se hace mediante el carácter \ seguido del número ASCII de la calculadora de dicho carácter, o seguido de una palabra que significa lo mismo.
He aquí un ejemplo:
El carácter alfa de la HP se escribirá así: \140 o \Ga. (Pero no os preocupeis porque antes de usar un código nuevo, indicaré a que carácter me estoy refiriendo.

 En cuanto a las operaciones con la pila, las indicaré así:

4:
3:
2: "Hola"
1: 4 -------------------------->(Niveles de la pila)
|HOLA|ADIO| --------------->(Menús)

Para acabar esta introducción, solo me queda decir cada cuanto actualizaré esta sección. Espero actualizarla cada 15 dias para poder dar tiempo a que consulteis esta página.

• TEMA 1. COMO HACER MI PRIMER PROGRAMA

Para indicarle a la HP que vamos a escribir un programa, usaremos los delimitadores << y >> que indican el inicio y el final de un programa. Después solo queda ir introduciendo los comandos.

La filosofia de la programación en UserRPL es muy sencilla, y no requiere mucho esfuerzo entenderla, pues debes ir introduciendo los comandos como si los escribieras manualmente en la pila.
Por ejemplo, para calcular cuanto tardaremos en ir de un sitio a otro mediente la fórmula: e=v*t Podriamos escribirlo en la pila:
4:
3:
2: 20
1: 100
Y pulsar / (En el caso de que la velocidad sea 100Km/h el espacio 20Km). Con lo que nos daria 0.2 horas.
Esto es lo que hariamos manualmente, pero pongamos que tenemos que aplicar esta fórmula muchas veces. La opción
más útil es la de crear un programa que nos lo haga automáticamente:
<< / >>
¿Y ya está?
Pues en principio si, lo que hace este programa es dividir los dos números que se encuentren en la pila.
Pero ahora pongamos el ejemplo de que queramos volver a usarlo al cabo de 3 meses (he imaginemos que el programa es un poco más complicado) ¿Como sabremos lo que necesita y lo que nos da.
Para ello existe un comando muy útil: INPUT. Y lo que hace es pedir al usuario que introduzca algo.
La secuencia es:
"Introduce: Espacio Velocidad" (Linea de mensajes que aparecerá en pantalla.)
"0 0" (Valor por defecto, es aconsejable dejarlo vacio: "")
INPUT (Ejecuta la orden).
OBJ-> (Por defecto INPUT deja lo que escriba el usuario como texto, con esta orden lo convertimos a números)

Y nuestro programa quedaria:
<< "Introduce: Espacio Velocidad" "" INPUT OBJ-> / >>

• TEMA 2. ESTRUCTURAS CONDICIONALES I: IF...THEN...ELSE...END
 

Para hacer cualquier programa, y si has programado antes lo sabrás muy bien, casi con toda seguridad necesitarás que llegado un punto el programa decida si hace una u otra cosa.
Esta primera estructura condicional funciona así:
SI (Ocurre lo que hay aquí) ENTONCES (Haz esto) SINÓ (Haz esto otro) FIN
Donde:
Ocurre lo que hay aquí: Será una condición tal como 'x>5' o x 5 >.
Haz esto: Lo que quieras que haga, pueden ser tantos comandos como desees, incluso puedes poner dentro otras estructuras condicionales.
Haz esto otro: Igual que lo anterior, pero solo se ejecutará si la condición es cierta.

Bueno, lo he explicado lo más sencillo y breve que he podido para que lo entienda todo el mundo.
Pero de todas maneras, haremos un ejemplo.

<< "Introduzca un número" "0" INPUT OBJ-> 'X' STO (Nos pide un número y lo guarda como la variable global X)
IF 'X>5' (Si el número introducido es mayor que 5...)
THEN (...entonces haz lo que sigue)
"Número >5" CLLCD 3 DISP 0 WAIT (Pone en la pila un texto, borra la pantalla y lo muestra en la linea 3. Después espera hasta que pulses una tecla)
ELSE
"Número <5" CLLCD 3 DISP 0 WAIT (Igual que antes)
END
>>

En este programa hemos introducido 3 nuevos comandos:
DISP: Potente orden que muestra en pantalla el texto situado en la pila.
"Texto" L DISP (L es la linea donde queremos visualizarlo. Hay 7)
CLLCD: Antes de hacer un DISP, hay que borrar la pantalla. Lo haremos con esta orden.
WAIT: Espera un número de segundos determinados.
N WAIT (N:Nº de segundos a esperar. N=0 espera hasta que pulsas una tecla, además te deja en la
pila el código de la tecla pulsada).

• TEMA 3. CUADROS DE TEXTO

En este tema veremos 2 comandos nuevos: MSGBOX y CHOOSE.
MSGBOX: Presenta un cuadro de texto con la cadena de carácteres que le hayamos dado.

<<
"Resultado= 5Kg" (Texto que quiero visualizar)
MSGBOX
>>

CHOOSE: Presenta un cuadro en el que, con el cursor, podemos elegir la opción deseada.

<< "TÍTULO DEL CUADRO" (No te molestes en escribirlo en minúsculas ni con acentos por que no saldrán)
{  (Abrimos la lista en la que incluiremos todas las opciones)
{ "Opción1" Accion1 } (Opción1 es el texto que aparecerá, y Acción1 es lo que pasará si elijo la opción1. Si escribes más de un objeto para la acción, esta se escribirá entre << >>, si solo usas un comando no harán falta los delimitadores)
{ "Opción 2" Accion2 }
... (Escribir todas las opciones que se quieran)
} (Cerramos la lista de opciones)
1 (CHOOSE necesita saber que opción será la resaltada por defecto. Un 1 significa que será la primera, un 2 la segunda,...)
CHOOSE
DROP (Tras elegir la orden CHOOSE genera un valor que podemos borrar)
->NUM    (Evalua el objeto. Si se trata de << >> ejecutará el programa. Si no lo pusieramos, dejaria en la pila el contenido de Acción, sin ejecutarlo)
>>

Hemos introducido el comando:
DROP: Esta orden borra el objeto que se encuentre en el nivel 1 de la pila.

4:
3:
2: "Adios"
1: "Hola"

Pulsamos DROP

4:
3:
2:
1: "Adios"

Veamos un ejemplo. Supongamos que tenemos un ejercicio en el que nos pueden pedir que hallemos el área, o el perímetro de una circumferencia, y no queramos perder tiempo memorizándolas (si este es tu caso, más vale que te jubiles ya que la HP lleva estas fórmulas incorporadas en EQ LIB). Además, tendremos la posibilidad de que nos calcule el area y el perímetro.
El programa seria así:

<< "FORMULAS DEL CIRCULO"
{
{ "Area" "\pi*R^2"  }
{ "Perimetro" "2*\pi*R"  }
{ "Programa"
    <<
    "Introduce el Radio"    ""    INPUT OBJ->
    DUP
    2 ^ \pi *
    SWAP
    2 * \pi *
    >>
}}
1 CHOOSE DROP ->NUM
>>

Hemos introducido:
\pi: Corresponde al valor PI de la HP (Pusar <-| + SPC)
DUP: Duplica aquello que haya en el nivel 1 de la pila:

4:
3:
2:
1: "Hola"

Pulsamos DUP

4:
3:
2: "Hola"
1: "Hola"

SWAP: Intercambia la posición del nivel 1 al 2 y del nivel 2 al 1:

4:
3:
2: "Hola"
1: "Adios"

Pulsamos SWAP

4:
3:
2: "Adios"
1: "Hola"

 

• TEMA 4. LAS VARIABLES

Si quieres hacer un programa más o menos complicado, te va a resultar muy dificil no usar variables. Estas sirven para guardar un valor (ya sea numérico o no) con un nombre. Al usar ese nombre a lo largo del programa, estaremos usando el valor que tiene.

Hay diferentes tipos de variables (¿creias que iba a ser sencillo verdad?) las locales y las globales. No te asustes, es muy sencillo.

Globales: Las habrás usado más de una vez para guardar un valor en la memoria de la calculadora, se usan mediante la orden STO.

4:
3: 1,456 ----->Valor que queremos almacenar
2: 'R' --------->Nombre de la variable global
1: STO

De esta forma cada vez que escribamos R, nos saldrá el valor: 1,456.

Locales: Solo se usan en programas, y hacen lo mismo que las globales.
Las diferencias entre las dos, son las siguientes: Las variables globales son más lentas que las locales, deben borrarse ya que quedan en la pila, pueden recuperarse y cambiar su valor siempre que queramos, las locales solo existen mientras el programa esté ejecutandose, y no hace falta borrarlas pues desaparecen al terminar el programa.
Veremos el funcionamiento de las variables locales mediante un programa que nos calcule la Xf de un Movimiento Rectilinio Uniformemente Acelerado ( Xf=X0+V0+1/2*a*t^2)

<< -> X0 V0 A T --------> Coge de la pila 4 variables, X0: Nivel 4; V0: Nivel 3; A: Nivel 2; T:Nivel 1
'X0+V0+0.5*A*T^2' ---> Fórmula. Debe escribirse INMEDIATAMENTE después de haber guardado las variables locales o se destruirán
->NUM -------------------> Nos da el resultado de la fórmula que tenemos en el nivel 1 de la pila
>>

Si tuvieramos que usar estos valores locales más veces, o no vamos a ejecutar la fórmula todavia, podemos abrir otro programa dentro de nuestro programa:

<< -> X0 V0 A T ------------> Coge de la pila 4 variables, X0: Nivel 4; V0: Nivel 3; A: Nivel 2; T:Nivel 1

<< ----------------------------> Abro un nuevo programa, las variables locales existirán hasta que cierre este programa
"Calculo de la Xf" MSGBOX
'X0+V0+0.5*A*T^2' -------> Fórmula.
->NUM -----------------------> Nos da el resultado de la fórmula que tenemos en el nivel 1 de la pila
'Xf' STO ----------------------> Guardo el resultado com la variable global Xf.
>> ---------------------------> Cierro el programa, a partir de aquí las variables X0, V0, A y T ya no existen y no puedo recuperarlas, pero si la variable Xf.
"El resultado es: " ----------> Escribo un texto para poner el resultado.
Xf ->STR --------------------> Pongo en la pila el valor de Xf (resultado de la fórmula) y lo convierto en texto.
+ -----------------------------> Si tengo 2 textos en los niveles 1 y 2, puedo "sumarlos" y juntarlos en una sola cadena de carácteres.
CLLCD 3 DISP 0 WAIT -----> Muestro en pantalla el resutado.
DROP

>>

Como verás, nos ha quedado en la pila la variable Xf, pero no hay ni rastro del resto (por que eran locales). Si queremos borrarla, añadiremos esta linea al final del programa:

'Xf' PURGE

Hemos usado estos nuevos comandos:
->STR: Convierte un objeto en una cadena de carácteres. (<-| PRG NXT ->STR )
4:
3:
2:
1: 456.56

Pulso ->STR

4:
3:
2:
1: "456.56"

PURGE: Borra una variable global que le indiquemos.
Xf PURGE --> No borra la variable, por que al escribir Xf ponemos en la pila su valor.
'Xf' PURGE -> Borra la variable Xf.