Manual Robótica UTN - 5. Lenguaje de Programación Rapid

Universidad Tecnológica Nacional Departamento Ingeniería Eléctrica
Facultad Regional General Pacheco Robótica y Automación 2018

5. Lenguaje de Programación
5. Programación de robots
Un robot cuenta como característica fundamental, que lo define e individualiza respecto de otras
máquinas, el hecho de ser multifuncional. Es decir, no se fabrica para un uso específico – salvo
contadas aplicaciones – sino que podemos adaptar su utilización según el proceso en que lo
apliquemos.
Esta multifuncionalidad se logra debido a que en producción funcionará según un programa
elaborado a fines de cumplir los objetivos del proceso.
El programa no será rígido, sino que podrá ser modificado, corregido, actualizado y
eventualmente reemplazado si cambia el proceso al que está destinado. De haber condiciones
desfavorables a un cambio de funcionalidad en un robot industrial, éstas estarán centradas en
cuestiones relacionadas con montos de inversión, complicaciones de logística o espacios disponibles
para una nueva utilización. No habrá cambios estructurales requeridos en el robot propiamente
dicho, a excepción lógica de diseñar y construir las nuevas herramientas requeridas.
En este capítulo conoceremos los principios empleados en la programación de un robot
industrial. Lo haremos estudiando el lenguaje de programación RAPID empleado en los robots de la
firma ABB. Salvo aspectos particulares en lo que hace a la sintaxis y formato de manejo de la
información, las herramientas, estructuras, componentes y criterios aprendidos nos servirán a futuro
para encarar el estudio de cualquier otro lenguaje de programación.
5.1. Lenguaje RAPID – Estructura del programa

El programa está compuesto por un conjunto de instrucciones que describen la actividad del
robot. Por tanto, existen instrucciones específicas para los distintos comandos, por ejemplo, para
mover el robot, otra para seleccionar una salida, etc.
En el capítulo anterior, por ejemplo, vimos qué características tienen las instrucciones de
posicionamiento MoveJ, MoveL, MoveC y MoveAbsJ. Veremos más adelante cual es la sintaxis con
que debemos emplearlas en un programa.
Por lo general, las instrucciones llevan asociado un conjunto de argumentos que definen qué
debe ocurrir con una instrucción concreta. Por ejemplo, la instrucción utilizada para restablecer una
salida contiene un argumento que define qué salida debe restablecerse, por ejemplo, RESET Do5.
Estos argumentos pueden especificarse mediante uno de los métodos siguientes:
- Como un valor numérico .............................. ej.: 5 ó 4.6.
- Como una referencia a un dato .................... ej.: reg1
- Como una expresión ..................................... ej.: 5+reg1*2
- Como una llamada a una función ................. ej.: Abs(reg1)
- Como un valor de cadena de caracteres ...... ej.: "Producción de la pieza A"
La asignación de un valor a un dato se realiza mediante la instrucción ":=". La finalización de toda
instrucción se realiza con el carácter “;”.
El valor a ser asignado puede ser cualquiera contenido en una expresión aritmética.
Ejemplos: reg1:=5;
reg1:=reg2 + reg3;
cuenta:=cuenta + 1;
En el primer ejemplo, un dato denominado reg1 guardará el valor numérico 5 luego de ejecutarse
la instrucción. Si el dato guardaba previamente el valor 5, no se verán diferencias en el programa,
Ing. Alberto R. Kremer 1-34

dado que “pisar” o “sobrescribir” un valor 5 con otro valor 5 no produce cambios. Caso contrario, el
valor guardado se actualizará al nuevo asignado.
En el ejemplo que usa el dato o variable cuenta, la instrucción resuelve primero lo que está a la
derecha del símbolo de asignación (:=), o sea, lee lo que guarda cuenta y le suma 1. Luego, toma el
resultado y lo asigna a cuenta sobrescribiendo el valor que guardaba, actualizándolo. Esta instrucción
en la que vemos la misma variable en ambos lados de la asignación no debe asustarnos. Es lo que en
programación se llama “contador” dado que, si pasamos reiteradamente por esta instrucción, en cada
pasada habrá incrementado su valor en 1, “contando” las veces que la hemos ejecutado.
Continuemos. Las instrucciones en un programa estarán agrupadas en conjuntos denominados
rutinas. En un programa habrá como mínimo una rutina, pudiendo haber más de una. Esta rutina que
como mínimo debe existir deberá denominarse main() – los paréntesis a continuación del nombre
forman parte de la estructura.
Existen tres tipos de rutinas: procedimientos, funciones y rutinas TRAP.
- Procedimientos: Se utilizan como subprogramas.
- Funciones: Devuelven un valor de un tipo concreto y se utilizan como
argumento de una instrucción.
- Rutinas TRAP: Se utilizan para dar respuesta a una interrupción. Las rutinas
TRAP pueden asociarse con una interrupción, ejecutándose por
ejemplo si se activa una entrada.
La información se almacena en espacios en memoria administrados por el controlador a tal fin.
Estos espacios serán los datos, por ejemplo, los datos de las herramientas (que contienen información
sobre las herramientas, como su TCP y su peso) y datos numéricos (que pueden usarse por ejemplo
para contar el número de piezas que deben procesarse). Los datos se agrupan en distintos tipos de
datos que describen los distintos tipos de información, como herramientas, posiciones y cargas.
Dado que es posible crear estos datos y asignarles nombres arbitrarios, no existe ningún límite
en el número de datos (excepto el límite impuesto por la memoria disponible). Estos datos pueden
existir de forma global en el programa o sólo localmente dentro de una rutina.
Existen tres tipos de datos según cómo guardan la información: constantes, variables y
persistentes.
- Constantes: Datos que guardan un valor fijo asignado al inicio del programa
o previo a su utilización. No puede variar durante la ejecución.
- Variables: Datos en los que la asignación de valores nuevos puede
realizarse durante la ejecución del programa.
- Persistentes: Dato en el que el valor de inicialización se actualiza con cada
inicio del programa, tomando el último guardado.
Finalmente, la rutina o rutinas que constituyen el programa se agrupan en conjuntos
denominados módulos. Un módulo puede ser de programa o de sistema, habiendo un único módulo
de sistema por programa, mientras que módulos de programa habrá como mínimo uno, pero puede
haber más. Este módulo mínimo que como mínimo debemos tener en el programa será el que aloje
a la rutina denominada main().

5.2. Principios de programación

Un programa para robots se ejecutará generalmente de forma secuencial, es decir, instrucción
por instrucción. En algunas ocasiones, para poder procesar diferentes situaciones aparecidas durante
la ejecución del programa son necesarias instrucciones que interrumpen esta ejecución secuencial y
que llaman a otra instrucción.
El flujo del programa puede ser controlado de acuerdo con cinco principios diferentes:
 Llamando a otra rutina (procedimiento) y, una vez que esta rutina ha sido ejecutada, el sistema
continúa la ejecución con la siguiente instrucción a la llamada de la rutina.
 Ejecutando diferentes instrucciones según si una condición se cumple o no.
 Repitiendo una secuencia de instrucciones un cierto número de veces o hasta que se haya cumplido
una condición dada.
 Saltando a una etiqueta dentro de la misma rutina.
 Parando la ejecución del programa.
Todos los elementos a ser empleados en un programa deberán tener un nombre que los
identifique. En la selección del nombre deben contemplarse las siguientes consideraciones:
 El primer carácter será siempre una letra. Los siguientes podrán ser letras, cifras o guión bajo ("_").
Esta condición es común a todo lenguaje de programación.
 La longitud máxima de cualquier nombre es de 16 caracteres. Esta limitación dependerá de la versión
del lenguaje y su programación interna. En sistemas elaborados con resoluciones de 64 bits los
nombres de los objetos pueden tener hasta 255 caracteres (aunque los nombres largos dificultan la
lectura de un código).
 No podrán utilizarse las consideradas palabras reservadas, que son aquellas que el lenguaje RAPID
destina a los tipos de datos y objetos de sistema, instrucciones y funciones. Esta es una condición
común y general; todo lenguaje de programación posee palabras que reserva a usos específicos y no
pueden ser empleadas como nombre de un elemento en particular.
El lenguaje RAPID emplea en la ejecución de programas los siguientes elementos básicos:
 Comodines
 Comentarios
 Encabezado
 Módulos
 Rutinas
 Datos
 Instrucciones
 Expresiones
Conociéndolos estaremos en condiciones de escribir código que sea interpretable por el
controlador del robot.

5.3. Componentes de un programa

5.3.1. Comodines
Los comodines se utilizan para reservar espacio en el código de un programa. Este espacio se
reserva para una futura utilización, pero no debe originar un error desde el punto de vista sintáctico.
Al leerse como instrucción, el controlador hace caso omiso (como si fuese un comentario) pero
sabe qué elemento reemplazará al comodín en una futura edición.
La siguiente tabla muestra los principales comodines del lenguaje RAPID:
Comodín Representa Comodín Representa

<TDN> Definición del tipo de dato <VAR> Una referencia (variable, persistente o parámetro)
<DDN> Una declaración de datos a datos de objeto
<RDN> Una declaración de rutina <EIT> La cláusula ELSE de una instrucción IF

<PAR> Un parámetro alternativo formal opcional <CSE> La cláusula CASE de una instrucción TEST
<ALT> Un parámetro formal opcional <EXP> Una expresión
<DIM> Una definición de la dimensión formal de la matriz <ARG> Un argumento de llamada de procedimiento
<SMT> Una instrucción <ID> Un identificador
5.3.2. Comentarios
Se emplean en el código de cualquier programa para que ayuden al programador a explicar
criterios de utilización de partes del programa, descripción de datos o instrucciones y cualquier
narración que desee hacer en el código.
Tiene como característica que admite cualquier tipo de caracteres, dado que el controlador
cuando lee este texto lo pasa por alto sin interpretarlo como una instrucción. Para ser reconocido, en
cualquier lenguaje un comentario debe iniciarse por un carácter específico que identifica el inicio del
comentario.
En el lenguaje RAPID los comentarios deben iniciarse con el carácter: !
Los comentarios sirven para facilitar la comprensión del programa. Por lo tanto, se debe saber
que no afectan de ningún modo el funcionamiento del programa.
Ejemplo
! Las siguientes instrucciones sirven para tomar una lata de la mesa

Instruccion1
Instruccion2
!
! Las siguientes instrucciones sirven para llevar la lata al pallet de destino
Instruccion3
Instruccion4
!
! Las siguientes instrucciones sirven para dejar la lata en el pallet
Instruccion5
Instruccion6

5.3.3. Encabezado
Dependiendo de la estructura de archivos con la que elaboremos un programa, en ciertos casos
el código inicia con un encabezado que sirve para proporcionar cierta información específica.
No interviene en el funcionamiento del programa. En el lenguaje RAPID, en función de la versión
de lenguaje que se emplee, los programas iniciarán siempre con el siguiente encabezado:
%%%
VERSION:1 (Versión M94 ó M94A del programa)
LANGUAGE:ENGLISH (o bien otro idioma: alemán o francés)
%%%
En los programas que elaboremos podremos ingresar indistintamente o no este encabezado
cuando empleemos el software de simulación para realizar las pruebas de funcionamiento.
5.3.4. Módulos
Como hemos visto, una aplicación estará dividida en módulos. Habrá módulos de programa y
módulos de sistema.
5.3.4.1. Módulos de programa
Un módulo de programa estará formado por diferentes datos y rutinas.
En todo programa habrá como mínimo un módulo de programa, y será éste el que contendrá el
procedimiento de inicio o entrada del programa llamado main.
Ejecutar un programa significa, realmente, ejecutar este procedimiento main o principal. El
programa podrá incluir varios módulos de programa, pero sólo uno de ellos contiene un
procedimiento principal.
Mientras que las pequeñas instalaciones suelen estar contenidas en un único módulo de
programa, las instalaciones más complejas pueden tener un módulo principal que hace referencia a
rutinas y/o datos contenidos en uno o varios otros módulos. Esta organización de un programa en
distintos módulos permite al programador dividir el trabajo agrupando tareas por funcionalidad,
resultando partes más pequeñas de código que serán más sencillas de escribir, leer y eventualmente
corregir.
5.3.4.2. Módulos de sistema
Un módulo de sistema contendrá información de uso general, por ejemplo: la declaración de
datos de sistema (como ser las entradas y salidas que se definen en etapa de parametrización y son
comunes a todos los programas), la definición de herramientas, la definición de los sistemas de
coordenadas definidos por el usuario, etc.
Cuando se guarda un programa no se incluyen estos módulos, los cuales son accesibles sólo
desde la unidad de programación o bien empleando herramientas especiales de software.

5.3.4.3. Declaración de los módulos
Una declaración de módulo especifica el nombre y los atributos de este módulo. Dichos atributos
sólo podrán añadirse de forma OFF-LINE, cuando estamos escribiendo código mediante una
herramienta de software específica, y no mediante la unidad de programación.
Los atributos nos permiten dar ciertas características a los módulos, como permitir que sea de
sólo lectura, que pueda o no ser modificable, permitir o no su ejecución paso a paso, que pueda o no
ser visualizado en la unidad de programación, etc.
No utilizaremos atributos en los módulos como objetivo de este curso.
Como en toda estructura, de cualquier lenguaje de programación, debemos abrirla y cerrarla. Lo
haremos con palabras clave según el lenguaje. En RAPID, abrimos un módulo con la palabra
“MODULE” y lo cerramos con “ENDMODULE”. Veamos un ejemplo:
MODULE nombre_módulo
! ___
! ___
! ___
ENDMODULE
Al igual que cualquier otro componente en un programa, y como es regla básica en cualquier
lenguaje de programación, un módulo no podrá tener el mismo nombre que otro módulo o que una
rutina global o que un dato.

5.3.5. Rutinas
Las rutinas agrupan las instrucciones que al ejecutarse harán que el robot realice su trabajo. Es
la verdadera mínima expresión de un programa, siendo que toda instrucción – con excepción de la
declaración de datos – debe estar contenida en una rutina.
5.3.5.1. Alcance y declaración de las rutinas
El alcance de una rutina indica el área dentro del programa en que la rutina está accesible.
Hemos dicho que todo programa inicia su ejecución a partir de la rutina main. Luego, es en la
rutina main donde estarán las instrucciones que permitan “llamar” a otras rutinas, pasando la
ejecución a la primera instrucción de la rutina “llamada”. En función del alcance, una rutina podrá o
no ser llamada desde un sitio, por poder o no verse desde allí.
En forma predeterminada toda rutina es global, llamándose así a una rutina que puede ser vista
desde cualquier punto del programa. Para declararla lo haremos con palabras clave como se muestra
en el siguiente ejemplo:
PROC Nombre_Rutina(…)
….
….
….
ENDPROC
Una rutina será en cambio local, cuando podremos verla para llamarla sólo desde otra rutina que
comparta módulo con aquella. La declaramos así:
LOCAL PROC Nombre_Rutina(…)
….
….
….
ENDPROC
La siguiente figura ejemplifica la situación:

Desde la rutina “h” se podrá:
- Llamar a las rutinas “c” y “d” del módulo 1,

dado que son globales.
- No se podrá llamar a las rutinas “a” o “b”
porque son locales.
- Llamar a todas las rutinas del módulo 2, dado
que se encuentran en su mismo módulo.
Una rutina no deberá tener el mismo nombre que otra rutina o datos dentro del mismo módulo.
Una rutina global no deberá tener el mismo nombre que otra rutina global o que datos globales de
otro módulo.
Reiterando conceptos para fijar conceptos, independientemente de la consideración anterior, en
programación es norma no repetir nombres, independientemente de que un elemento pueda o no
ser visto desde un sitio con nombre compartido.

5.3.5.2. Parámetros de una rutina

Si observamos los ejemplos considerados al tratar el alcance de las rutinas, veremos que a
continuación del nombre sigue la apertura y cierre de paréntesis. Igual situación veíamos al
presentarles la rutina main().
Estos paréntesis sirven para “pasar” parámetros eventuales a la rutina al momento de llamarla
desde otra rutina. ¿Qué significa esto? Que podemos llamar a una rutina, y en la llamada indicar qué
valores queremos que tengan ciertos datos en su interior. Esta forma de utilización de una rutina hace
que mejore su reutilización en distintas partes del programa, donde mediante los parámetros
podemos adaptar una misma rutina a distintas situaciones.
No es obligatorio el uso de parámetros en una rutina, sólo conveniente y útil en función del caso.
Como la rutina main será siempre la de inicio y no se ejecuta en esta instancia por ser llamada desde
otra rutina, siempre tendrá vacío el espacio interior a los paréntesis.
Veamos el siguiente ejemplo:
PROC miRutina1 (num Dato1, num Dato2, RobTarget P1)
….
….
ENDPROC
En el ejemplo anterior, tenemos una rutina llamada “miRutina1”. Cuando la llamemos desde
alguna rutina, deberemos indicar qué valores numéricos tomarán las variables “Dato1” y “Dato2” y
qué valor del tipo RobTarget (posición) tomará la variable “P1”.
Veamos cómo llamaríamos a esta rutina desde otra:
….
miRutina1 23, 450, A1;
….
De acuerdo a lo explicado, estaríamos llamando a la rutina “miRutina1”, dándole valor 23 al dato
“Dato1”, 450 al dato “Dato2” y el dato de posición A1 (gestionado anteriormente en el programa) al
dato “P1”.
5.3.5.3. Funciones y rutinas TRAP
A diferencia de las rutinas del tipo procedimiento, una función es una rutina en la que sí o sí
debemos pasar parámetros, dado que su misión es procesar información y hacer una devolución a
través de un dato que será empleado en una instrucción.
Llamaremos a una rutina de tipo procedimiento mediante una instrucción específica, mientras
que el llamado a una función se realiza en el interior de una instrucción en la que se emplea el dato
devuelto por la función.
Veamos el siguiente ejemplo de declaración y uso de una función:

FUNC num Altura(num Lado)

RETURN 2 * Lado + 25;
ENDFUNC
PROC Trabajo()
…
Posición:=Altura(3);
ENDPROC
En la rutina “Trabajo” empleamos el valor que devuelve la función “Altura” cuando la llamamos
con el parámetro en valor 3. Luego, la variable “Lado” tomará este valor, lo procesará y la función
devolverá un resultado a través de la instrucción RETURN que será empleado en la instrucción donde
se llamó a la función.
Veremos más adelante otros ejemplos de aplicación.
Las rutinas del tipo TRAP se explican con detalle en el “Anexo A”, por no ser objetivo del presente
curso.
5.3.6. Los Datos

Toda información que maneje el programa se guardará en un espacio en memoria administrado
por el controlador. En lenguajes de alto nivel esta administración de la memoria es un tema que no
debe preocuparnos. Sólo debemos poder hacer referencia a los datos en función del nombre que le
asignemos – respetando las reglas para selección de nombres –.
La mayoría de los datos deberán ser declarados o definidos antes de poder ser utilizados. En esta
declaración deberemos indicar al programa el nombre que le daremos, el campo de aplicación, la
naturaleza de la información que guardará y eventualmente, el valor inicial con que queremos que el
dato haga su aparición en el programa.
Algunos datos se podrán emplear sin declararlos previamente, por ser datos de sistema
declarados ya en tiempo de parametrización (los hemos mencionado cuando hablamos de los
módulos de sistema).
Veremos a continuación los aspectos del dato que debemos conocer a la hora de declararlo.
5.3.6.1. Tipo de información que guardaremos en el dato

Un dato puede guardar información simple o compleja.
Contaremos con los siguientes tipos de datos simples:
- num Guardaremos valores numéricos en general, sin discriminar por conjunto
(naturales, racionales, reales) ni su tamaño.
- string Guardaremos cadenas de caracteres. Al realizar una asignación debemos
considerar que las cadenas de caracteres deben ser encerradas entre comillas
- bool Se trata de un dato booleano, que admite dos valores: Verdadero/Falso
(True/False) (0 – 1). Se suelen emplear como resultados lógicos en la
evaluación de condiciones.

Como valores complejos o registros tendremos todo el resto de datos posibles, considerándose
así porque se componen a su vez de otros datos, siendo la mínima expresión un tipo de dato simple.
Veamos los siguientes ejemplos:
 Asignación de un dato numérico Num:
A:=2;
 Asignación de un dato String:
miTexto:=”Máquina parada por fallo”;
 Asignación de un dato de posición RobTarget:
P0:=[[Posicion1, Orientacion1, Configuracion1, EjesExt1];
P0:=[[0,210,600],[0,0.259,0.5,0.766],[0, 0, 1, 0],[9E+9, 9E+9, 9E+9, 9E+9, 9E+9, 9E+9]];
 Asignación de un dato de configuración ConfData:
Configuracion1:=[0, 0, 1, 0];
 Asignación de un dato de ejes externos ExtJoint:
EjesExt1:=[9E+9, 9E+9, 9E+9, 9E+9, 9E+9, 9E+9];
 Asignación de un dato de posición JointTarget:
Punto1:=[[10,0,25,80,30,120), EjesExt1]];
En los ejemplos anteriores, recordando el dato de posición RobTarget, vemos que el dato está
formado a su vez por los datos Pos, Orient, ConfData, ExtJoint.
Luego, el dato de configuración ConfData a su vez está formado por cuatro datos numéricos
simples, así como el dato tipo Pos está formado por tres datos numéricos simples.
También podemos ver que en la asignación de valores a un dato complejo como el JointTarget,
podemos trabajar directamente con los valores numéricos simples o con un dato del tipo ExtJoint
mientras sea del tipo adecuado y guarde la información adecuada.
5.3.6.2. Duración de un valor dentro de un dato
En función la posibilidad de actualizar o no el valor de un dato, podremos definir:
- Variables
- Constantes
- Persistentes
 Datos variables
Son datos que pueden tener o no valor inicial, pero pueden ser actualizados en cualquier
parte del programa. En caso de reiniciarse el programa, vuelven a tomar el valor inicial que
indicamos en su declaración.
Ejemplos: VAR num x; !Dato numérico que se iniciará con cero.
VAR num x:=1; !Dato numérico con valor inicial 1.
VAR string Texto:=”Fallo”; !Dato String con valor inicial “Fallo”.
VAR num x{2, 3}; !Matriz de datos numérico, de 2 filas por 3 columnas,
estando los 6 valores de la tabla virtual con valor inicial cero.

Veamos qué significa trabajar con una matriz de datos.

En primer lugar, podemos definir una matriz como un conjunto de datos, ordenados en
una especie de tabla virtual (imaginaria), donde a través de la cantidad de subíndices
(encerrados entre llaves) indicamos cuantas dimensiones tiene la tabla, y a través del valor de
cada subíndice sabemos cuantos elementos por dimensión admitirá (siendo 3 el máximo de
dimensiones posibles).
De esta manera, tendremos:
- Matriz{5} Representa una simple columna de 5 datos.
- Matriz{3, 6} Representa una tabla similar a las de las planillas de Excel, con 3 filas
y 6 columnas.
Este tratamiento del primer subíndice como filas y el segundo como
columnas es así por convención. Se trata de una tabla virtual, y podemos
pensarla también como 3 columnas y 6 filas. Lo importante es poder identificar
un elemento en la tabla.
En el ejemplo, consideremos Matriz{3, 6} con los siguientes valores numéricos:
1 2 3 4 5 6
Tendremos:
1 1 4 6 0 2.4 23 - Matriz{1,1} guarda el valor 1
2 0 5 7 98 3,88 34,7
- Matriz{1,5} guarda el valor 2,4
3 0 0 123 22 6 88
- Matriz {3,6} guarda el valor 88
De igual manera podemos tener una matriz de 3 dimensiones, que pensaremos como una
tabla tridimensional, es decir, tiene filas, columnas y capas. Es especialmente útil para guardar
datos de posición que representan las ubicaciones en una pila de pallets.
 Datos constantes
Son datos que requieren un valor inicial determinado al momento de su declaración, y
luego se mantiene invariable a lo largo del programa. Es decir, no se le podrá asignar ningún
valor nuevo.
Se emplea para guardar valores que se utilizarán reiteradas veces en el programa, sin
necesidad de ser actualizados.
Ejemplos: CONST num Pi:=3.14159; !Dato numérico que contendrá el valor de π.

CONST num x{3}:={1.23, 45, 23}; !Matriz de 1 fila con 3 datos numéricos.
CONST pos dat{3}:= {[614, 778, 1020], [914, 521, 564], [221, 521, 33]};
 Datos persistentes
Son datos variables que, debiendo declararse con un valor inicial, tienen la particularidad
de que sus valores de inicialización se actualizan a medida que van variando. (Cuando se
guarda un programa, el valor de inicialización de cualquier declaración persistente reflejará el
último valor que el dato hubiera tomado durante la ejecución).
Sólo pueden ser declarados a nivel de módulos, por lo que no podrán ser declarados a
nivel de rutina. Veremos qué implica dónde se realice la declaración en el próximo apartado.
Ejemplos: PERS pos puntref:=[100.23, 7789.55, 1183.98];
PERS num reg1:=0;

5.3.6.3. Lugar de declaración de un dato

Los datos pueden ser declarados:
- A nivel de módulo, se denominan datos de programa y se declaran al inicio del módulo, antes de
cualquier rutina.
- A nivel de rutina, se denominan datos de rutina y se declaran como primeras instrucciones dentro de
una rutina.
Mientras que los datos de programa pueden ser globales o locales, los datos de rutina serán
siempre datos locales.
En función del alcance, entonces, un dato podrá ser:
 Dato Global
Es un dato declarado a nivel de módulo (dato de programa) que puede ser “visto” o ser
“accesible” desde cualquier rutina en cualquier módulo.
Ejemplo de declaración:
VAR num MiVariable;
 Dato Local
Puede ser un dato de rutina, en cuyo caso no es necesaria ninguna aclaración porque
indefectiblemente será un dato local, o un dato de programa en cuyo caso debe aclararse la
situación dado que será por defecto un dato global.
Ejemplo de declaración de un dato de rutina: VAR num MiVariable;
Ejemplo de declaración de un dato de programa: LOCAL VAR num MiVariable;
Por lo general se acostumbra a declarar todos los datos de alcance global. A nivel de módulo
declararemos los datos generales, de uso en todas las rutinas del programa, que convengan ser
declaradas al inicio del programa por prolijidad y leerse en modo resumen.
Los datos a nivel de rutina serán declarados de esta manera cuando se trate de datos específicos
de la rutina, menores para figurar en el inicio del programa, y de poco valor relativo dentro del
programa.
5.3.7. Las Instrucciones

Las instrucciones son ejecutadas de forma sucesiva a menos que una instrucción de flujo de
programa, una interrupción o un error obligue a continuar la ejecución en cualquier otro lugar.
La mayoría de instrucciones terminan en punto y coma ";".
Una etiqueta termina con dos puntos ":".
Ciertas instrucciones podrán contener otras instrucciones y entonces finalizarán con palabras
clave específicas.
Listaremos a continuación algunas instrucciones a modo de ejemplo, repasando conceptos vistos
en el capítulo anterior en el caso de las instrucciones de posicionamiento.

5.3.7.1. Instrucciones de posicionamiento

1. Instrucción MoveJ – Movimiento Eje a Eje
MoveJ P1, z100, v1000, tool0;
Como vimos en el capítulo anterior, empleamos esta instrucción para obtener un movimiento
en el que el TCP se desplaza hacia la posición P1 dejando al robot decidir la mejor trayectoria a
seguir. En la instrucción:
- P1 Es el punto destino, dato RobTarget
- z100 Es la precisión con que se pasa por el punto destino, dato ZoneData
- v1000 Velocidad del TCP en mm/s, dato SpeedData
- tool0 Herramienta predeterminada, dato ToolData
2. Instrucción MoveL – Movimiento Lineal

MoveL P1, z100, v1000, tool0;
Similar a la anterior, la trayectoria hacia el punto P1 desde donde se encuentra el TCP al
momento de leerse la instrucción será siguiendo una línea recta. Los argumentos se repiten.
3. Instrucción MoveC – Movimiento Circular

MoveC P1, P2, z100, v1000, tool0;
Similar a la anterior, la trayectoria hacia el punto P1 desde donde se encuentra el TCP al momento
de leerse la instrucción será siguiendo un arco de circunferencia, definido contemplando al punto P2
como posición auxiliar, perteneciente al arco que corresponde a la trayectoria.
5.3.7.2. Espera de tiempo

WaitTime 3;
Sirve para esperar durante un tiempo específico, indicado en la instrucción en segundos. Cuando
se ejecuta esta instrucción, el controlador aguarda el tiempo especificado hasta leer y ejecutar la
siguiente instrucción.
Durante el tiempo de espera la manipulación de las interrupciones y otras funciones similares
siguen estando activas.

5.3.7.3. Medición de tiempos – Funciones de cronómetro

Emplearemos esta metodología empleada en los robots ABB para repasar lo visto hasta el
momento.
La toma de tiempos en un programa se realiza con los siguientes elementos:
 Dato clock
Emplearemos un dato clock, al que habrá que declarar previo al proceso, para almacenar una
medida de tiempos en segundos. Deberá ser del tipo variable, dado que cambiará de valor durante
la ejecución del programa, pero no será el usuario quien escriba ni quien lea el contenido de esta
variable. Al declararse, la variable tendría valor inicial cero.
Declaración: VAR clock Reloj1;
Dado que el dato clock trabaja como un reloj que funciona como cronómetro, tendremos
instrucciones que nos permitirán gestionarlo como si contáramos con los botones de un dispositivo
físico: iniciar, pausa, detener.
La lectura del valor contenido en la variable se realiza mediante una función específica.
 Instrucción ClkStart Reloj1;
Sirve para arrancar el cronómetro previamente declarado.
 Instrucción ClkStop Reloj1;
Sirve para pausar el cronómetro.
 Instrucción ClkReset Reloj1;
Sirve para poner en cero el cronómetro.
 Función ClkRead(Reloj1)
Sirve para leer el contenido del cronómetro. El valor debe ser guardado en una variable numérica
para poder ser procesado (recordemos que las funciones se emplean en una instrucción, haciendo
uso del valor devuelto por la misma).
Ejemplo:
VAR clock reloj1; !Declaramos la variable tipo clock con nombre reloj1
VAR num tiempo1; !Declaramos la variable numérica con nombre tiempo1
PROC main() !Abrimos la rutina main
ClkReset reloj1; !Borramos el valor guardado del ciclo anterior

ClkStart reloj1; !Iniciamos el cronómetro
Instrucción1;
Instrucción2;
………
ClkStop reloj1; !Pausamos el cronómetro
tiempo1:=ClkRead(reloj1); !Leemos el cronómetro y guardamos en tiempo1
ENDPROC !Cerramos la rutina main

5.3.8. Las funciones

Las funciones devuelven valores en base a procesar información. Esta información ingresa en la
función como argumento, indicado en el momento de la llamada.
Hemos visto que una rutina puede ser de tipo función. Pero el lenguaje Rapid, como todo
lenguaje, tiene sus propias funciones incorporadas.
Por ejemplo, la función ClkRead() que vimos en el ejemplo anterior cumple con estas
características.
Otro ejemplo típico son las funciones matemáticas.
Toda operación trigonométrica, por ejemplo, corresponde a una función que devuelve un valor
(el resultado) en base a aplicar su operación matemática sobre el argumento.
Veamos: A := Cos(B)
La instrucción anterior toma el argumento B, aplica sobre el valor almacenado la función
trigonométrica coseno, y el resultado es guardado en A.
Si B=90, entonces A será 0. Si B=180, entonces B=-1.
5.3.8.1. La función Offset – Offs()
Una función muy importante por su utilidad en un lenguaje destinado al posicionamiento es la
función offset.
Esta función toma como argumento un dato de posicionamiento tipo RobTarget, le aplica en
forma indistinta un desplazamiento en X, Y y/o Z, y en función del desplazamiento genera un nuevo
posicionamiento. Como requiere información geométrica, sólo se puede emplear con datos
RobTarget.
Por ejemplo: P1:=Offs(P0, 100, 200, -100);
P1 guardará un dato RobTarget que tendrá toda la información de P0 (como ser su orientación),
pero su coordenada en X estará desplazada 100mm en sentido positivo, la coordenada en Y estará
desplazada en 200mm en sentido positivo, y la coordenada en Z lo estará en el eje Z 100mm en
sentido negativo.
¿Qué punto se obtiene con: P2:=Offs(P0, 0, 0, 0);?
Pues … ¡El mismo punto P0! Esto es así porque todos los desplazamientos están definidos con
valor cero. Debemos prestar atención a que las funciones, al igual que los parámetros y argumentos
de rutinas, emplean paréntesis en su escritura.
5.3.8.2. La función CRobT()
La función Offs() es muy útil, pero ¿qué sucede si llegamos a una posición que pretendemos como
inicio de movimientos, pero a través de un dato JointTarget, con una instrucción MoveAbsJ? ¿Y si lo
hacemos manualmente? No podremos emplear la función Offs ya que necesitamos un dato
RobTarget.
La función CRobT() guarda la posición actual del robot como tipo de dato RobTarget,
independientemente del modo en que el robot hubiera llegado a dicha posición.
Por ejemplo: A0:=CRobT();
El dato A0 guardará la posición que tenga el robot al momento de ejecutarse la instrucción, en
formato RobTarget, con toda la información correspondiente.

5.3.9. Elaborando programas en Rapid

De acuerdo a lo visto hasta el momento, un programa en Rapid tendrá el siguiente aspecto:
Veremos a continuación algunos ejemplos de programas básicos.

5.3.9.1. Procedimiento con declaración de datos en forma indirecta

En el siguiente programa veremos cómo declaramos un dato del tipo extjoint (ejes externos)
como constante, para luego emplearlo en la declaración de un dato de posición. De igual manera un
dato numérico x1 luego es empleado como dato de coordenada X en la declaración de otro dato.
Podemos realizar esta tarea, que nos simplificará la escritura cuando algún dato se repita
reiteradamente en otros datos, o bien queramos tenerlo individualizado para cambiar rápidamente
su valor inicial.
La única condición, obviamente, es que el dato a ser empleado en la declaración de otro sea
declarado previamente.

5.3.9.2. Llamada a rutina con argumentos

El siguiente programa está formado por la rutina main y otra rutina llamada Mover.
Esta rutina posee en su definición dos parámetros: un dato robtarget (posicionamiento) llamado
Posición, y un dato num (numérico) llamado Traslado.
En la rutina main llamamos a la rutina Mover dos veces, indicándole cada vez qué valores deben tomar
los parámetros indicados en su definición. En caso de no respetar la cantidad de parámetros en la llamada, o
no respetar el tipo de dato del parámetro con la información empleada en la llamada, la instrucción dará un
error y no se cargará en el controlador para ejecución del programa.

5.3.9.3. Empleo de una función

El siguiente programa está formado por la rutina main, una rutina elevación y una función denominada
Altura, que devolverá un dato numérico, y que tiene como parámetro un dato numérico llamado A.
En la rutina main se realiza el llamado a la rutina elevación, indicando que el parámetro llamado
Pos_Inicial, que es un dato robtarget, debe almacenar el dato A0 (que vemos en la declaración también es,
correctamente, un dato robtarget).
En la rutina elevación, una instrucción emplea la función Altura tomando como argumento el valor
almacenado en Estado. Si bien todavía no hemos visto la estructura IF-ELSE-ENDIF, la misma es muy simple. En
función de que una condición sea verdadera ejecutaremos ciertas instrucciones, caso contrario ejecutaremos
otras.
Llamamos a la función dato con el argumento Estado. Al llamar a la función, su argumento A tomará el
valor que guarda Estado. Luego, en función del valor que tiene A, la función Altura devolverá 200 o 300. Estos
resultados son los que afectarán la función Offset en la instrucción MoveL.

5.3.9.4. Ejercicio de aplicación

Con lo visto hasta el momento estamos en condiciones es escribir el código de un programa
que cumpla como objetivo el trazado en el espacio de dos cuadrados y un círculo, en un plano XY
(paralelo al suelo), con los siguientes lineamientos:
1. Contemplar como posición inicial del robot la

correspondiente a calibración (todos los ejes en 0º).
2. Tomar como posición A0 la que corresponde a:
a. Eje 1=10º
b. Eje 2=10º
c. Eje 3=25º
d. Eje 5=30º
3. Desde A0, describir el cuadrado de 300mm x 300mm.
4. Desde A0, describir el cuadrado de 400mm x 400mm.
5. Desde A0, describir el círculo según indicación en la figura.
6. Para cada figura generar una rutina, y luego llamarlas secuencialmente desde la rutina main. Para el
cuadrado considerar una única rutina que tenga como parámetro el lado del cuadrado, pasándole en
dos llamadas consecutivas el lado que debe ser tenido en cuenta.
7. Al finalizar, el robot debe quedar en la posición de calibración.
Código:
%%%
VERSION:1
LANGUAGE:ENGLISH
%%%
MODULE PROGRAMA
CONST extjoint ejes:=[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]; !Declaramos el dato ejes
CONST jointtarget P0:=[[0,0,0,0,0,0], ejes]; !Declaramos la posición de calibración
CONST jointtarget P1:=[[10,10,25,0,30,0], ejes]; !Posición de inicio de trayectorias
VAR robtarget A0; !Posición de inicio como RobTarget
PROC main()
MoveAbsJ P0, v1000, fine, tool0; !Movemos hasta calibración
MoveAbsJ P1, v1000, fine, tool0; !Movemos hasta inicio de trayectorias
A0:=CRobT(); !Guardamos posición como RobTarget
MICUADRADO 300; !Hacemos el cuadrado lado 300mm

MICUADRADO 400; !Hacemos el cuadrado lado 400mm
MICIRCULO; !Hacemos el circulo
ENDPROC
PROC MICUADRADO(num LONGITUD)
MoveL Offs(A0,-LONGITUD,0,0),v1000,fine,tool0; !Empleamos instrucciones Offset.
MoveL Offs(A0,-LONGITUD,LONGITUD,0),v1000,fine,tool0; !Observar los desplazamientos negativos
MoveL Offs(A0,0,LONGITUD,0),v1000,fine,tool0; !Observar la figura
MoveL A0,v1000,fine,tool0; !Observar el Sistema de coordenadas
ENDPROC
PROC MICIRCULO()
MoveC Offs(A0,-400,0,0),Offs(A0,-400,400,0),v1000,fine,tool0;
MoveC Offs(A0,0,400,0),A0,v1000,fine,tool0;
ENDPROC
ENDMODULE

5.4. Gestión de Entradas y Salidas

Las entradas y salidas (E/S) del PLC incorporado en el robot funcionan en un programa como
cualquier tipo de dato, con las siguientes consideraciones:
 En un PLC, las entradas se emplean para recibir y posteriormente procesar información
del entorno en el proceso automatizado. Esta información la recibimos a través de
sensores que transforman una variable física en una variable eléctrica, apta para ser
conectada al borne de entrada en el PLC. Esta señal eléctrica, que puede ser digital o
analógica, es procesada y convertida en números para su tratamiento.
Entre los sensores que podemos encontrar estarán: los inductivos, para detectar
presencia de cuerpos metálicos; botoneras, para que un operario envíe una señal en
función de una decisión; termocuplas, para medición de temperaturas; presostatos, para
medición de presiones, etc.
 Las salidas, por su parte, es mediante las cuales el PLC actúa sobre el proceso. Lo hará
manipulando señales eléctricas que también pueden ser digitales o analógicas.
En el caso de las señales digitales, trabajarán por lo general con elementos de maniobra,
como ser contactores o relés. Lo harán energizando o desenergizando sus bobinas con lo
que a través de sus contactos principales alimentarán motores, luces o las cargas que el
proceso requiera.
En el caso de señales analógicas, podrán enviar señales dentro de un rango hacia
servocontroladores a fin de dar consigna de posicionamiento a un servomotor.
 Los datos numéricos obtenidos a partir de estas señales de entradas y salidas, son datos
de Sistema que deben ser definidos en tiempo de parametrización del robot, por lo que
no deben ser declarados previo a su uso en un programa. Recuerden que un dato de
sistema está declarado, pero en el Módulo de Sistema correspondiente.
 Obviamente deben respetar el nombre recibido en la parametrización del dato.
 Podremos disponer de entradas analógicas, entradas digitales, salidas analógicas, salidas
digitales.
 Las señales digitales son datos que admiten dos estados, “encendido/apagado”,
“presente/no presente” desde el punto de vista del circuito en que estén conectados y
los sensores que les brinden información. En los programas, un estado físico “encendido”
o “presente” significa un valor 1 en el dato que representa a dicha señal. En cambio, un
estado físico “apagado” o “no presente” significará un valor 0 en dicho dato.
 Las señales analógicas, a diferencia de las digitales, admiten un rango de valores dentro
de un intervalo predefinido. En el mundo físico las señales analógicas pueden proveer en
función de un determinado estado distintas variables eléctricas.
Por ejemplo, podremos tener valores de tensión comprendidos entre 0 y 10V, valores de
corriente entre 0 y 20mA, o entre 4 y 20mA, etc. En cualquier caso, en nuestro programa,
estas señales deben tratarse como valores numéricos. Y para obtener los rangos de
valores equivalentes, estas señales deben ser escaladas previo a su uso.
En nuestros programas nos limitaremos a emplear señales digitales, quedando el uso de
señales analógicas fuera del alcance de nuestro curso.

Resumiendo, el robot suele tener una o más tarjetas de E/S. Cada una de las tarjetas tiene varios
canales digitales y/o analógicos que deberán ser conectados a señales lógicas antes de poder ser
utilizados. Esta operación se lleva a cabo en los parámetros del sistema y normalmente ya se ha
realizado utilizando nombres estándar antes de la entrega del sistema. Los nombres lógicos deberán
utilizarse siempre durante la programación.
5.4.1. Principios de programación

Siendo específicos y prácticos, nos vamos a basar en dos conceptos:
 Las entradas se leen, por cuanto debemos tomar decisión en función de la información que
traigan del proceso o entorno.
 Las salidas se escriben, dado que es a través de las cuales ejercemos alguna acción sobre el
proceso.
Veamos cómo realizar estas operaciones.
5.4.2. Lectura de las entradas digitales

Una entrada digital se lee simplemente empleándola en una condición que evalúe si guarda el
valor 1 (activada, encendida) o el valor 0 (desactivada, apagada).
En el siguiente ejemplo emplearemos una estructura simple de toma de decisión, que nos
permite aumentar un contador en una unidad en caso de que la entrada digital E01 esté activada o
en 1:
VAR num A;
IF E01=1 THEN
A:=A+1;
ENDIF
Observen en el ejemplo anterior, que la condición donde preguntamos por el valor de E01 la
armamos con el signo “=”, mientras que cuando asignamos utilizamos “:=”. Mientras que en el
lenguaje de programación Rapid se emplea esta sintaxis diferenciada, otros lenguajes hacen uso
indistinto del signo “=” tanto para condiciones como para asignaciones.
También contamos con la siguiente instrucción: WaitDI
Con esta instrucción, el programa esperará hasta que la entrada empleada en la instrucción
alcance el valor indicado.
Por ejemplo: WaitDI E01, 1;

La ejecución del programa continuará solo cuando la entrada E01 sea activada.
Si al momento de ejecutarse la instrucción la entrada E01 se encuentra activada, entonces el
programa continuará su ejecución sin demoras.

5.4.3. Escritura de salidas digitales

La escritura en una salida no se realiza en forma directa como una asignación de una variable
numérica, dado que no lo es.
Debemos emplear las siguientes instrucciones:
Set
Sirve para activar una señal de salida digital (poner a 1).
Reset
Sirve para desactivar una señal de salida digital (poner a 0).
Por ejemplo:
IF E01=1 THEN
Set S01;
ENDIF
En caso de estar activada la entrada E01, se activará la salida digital S01.
5.5. Gestión del flujo del programa

Hasta ahora hemos visto a los programas como ejecución sucesiva de instrucciones, una por una,
desde un inicio hasta un final. La única manera de interrumpir este flujo de programa ha sido la de
llamar a otra rutina.
Veremos a continuación una serie de estructuras que nos permitirán alterar este flujo para
adaptarnos en forma más real a los requerimientos de nuestros procesos.
5.5.1. IF-ELSE-ENDIF: Toma de decisiones
Esta estructura permite tomar decisiones en función de una o más condiciones.
Pero… ¿qué es una condición? Necesitamos conocer cómo trabajar con expresiones lógicas.
En primer lugar, una expresión lógica sirve para evaluar un valor lógico, que puede tomar dos
estados: verdadero o falso.
La podremos armar con los siguientes operadores lógico: <, <=, =, >=, >, <>, AND, XOR, OR, NOT.
Por ejemplo, sean:
A:=2; B:=3; C:=10;
Tendremos:
- A=B FALSO
- A>B FALSO
- A < B AND B < C VERDADERO (AND exige que ambas condiciones sean verdaderas)
- A > B OR B < C VERDADERO (OR exige que al menos una condición sea verdadera)
- NOT (A > B) VERDADERO (NOT invierte el resultado lógico de la expresión).
Analicemos cómo emplear las estructuras IF-ELSE-ENDIF con un par de ejemplos en los que
quedarán claras las opciones de uso.

Ejemplo 1:
IF E01=1 THEN
Set S01;
Set S02;
ENDIF
Evaluamos la condición E01=1. Si es verdadera, se activarán las salidas S01 y la S02. Caso
contrario, la estructura no realiza acción alguna.
Ejemplo 2:
IF E01=1 THEN
Set S01;
Set S02;
ELSE
Reset S03;
A:=A+1;
ENDIF
En el ejemplo anterior, se evalúa la condición E01=1. Si es verdadera, se ejecutan las instrucciones

que están a continuación. La rama ELSE permite ejecutar instrucciones en caso que la condición sea
falsa. En este caso, desactivar la salida S03 y aumentar en 1 la variable numérica A.
Ejemplo 3:
IF A=1 THEN
Set S01;
Set S02;
ELSE IF A=3 THEN
Reset S03;
D:=D+1;
ELSE IF A=4 THEN
B:=3;
ELSE
B:=0;
D:=0;
ENDIF
Como última alternativa de esta estructura, en el ejemplo evaluamos el valor de A a traves de

una sucesión de condiciones de comparación. En cuanto una condición resulte verdadera se
ejecutarán las instrucciones que correspondan a esa rama de la estructura y se saldrá de ella.
Si ninguna de las condiciones es verdadera, se ejecutarán las instrucciones correspondientes a la
rama ELSE.

5.5.2. TEST-ENDTEST: Evaluación de una variable para la toma de decisiones

Sirve cuando diferentes instrucciones deben ser ejecutadas dependiendo del valor de una
expresión o dato.
En el último ejemplo visto de la estructura IF-ELSE-ENDIF, podríamos aplicar TEST-ENDTEST de la
siguiente manera:
TEST A
CASE 1:
Set S01;
Set S02;
CASE 3:
Reset S03;
D:=D+1;
CASE 4:
B:=3;
DEFAULT
B:=0;
D:=0;
ENDTEST
Cada evaluación de la variable A que queremos analizar, se realiza en la rama CASE terminando
con el carácter “:”. Si ninguna de las anteriores condiciones es verdadera, entonces se ejecutarán las
instrucciones de la rama DEFAULT.
Tanto esta estructura como la anterior resuelven el problema de tomar decisiones según el valor
de una expresión o dato en particular. Pero la estructura TEST-ENDTEST proporciona mayor prolijidad
y facilidad de lectura. De todas maneras, quedará en la preferencia del programador el uso de una u
otra metodología.
5.5.3. FOR-ENDFOR: Repetición de estructuras I

Se usa cuando una o varias instrucciones deben repetirse un número dado de veces.
La sintaxis de esta estructura es la siguiente:
FOR Contador FROM Inicial TO Final [STEP Incremento] DO

…;
ENDFOR
Contador: El nombre del dato que contendrá el valor del contador de bucle actual. El dato es
declarado automáticamente y su nombre no podrá coincidir con ningún otro nombre de
ningún dato ya existente.
Inicial: Dato numérico que representa el valor inicial deseado del contador de bucle. (suelen ser
números enteros).
Final: Dato numérico que representa el valor final deseado del contador de bucle. (suelen ser
números enteros).

Incremento: Dato numérico que representa el salto o valor con el que el contador de bucle deberá
ser incrementado (o disminuido). Suelen ser números enteros.
Si este valor no está especificado, el valor de incremento será automáticamente 1 (o -1 si
el valor inicial es mayor que el valor final).
Ejemplo 1:
FOR i FROM 1 TO 10 DO
Rutina1;
ENDFOR
El procedimiento rutina1 se repite 10 veces.
Ejemplo 2:
FOR i FROM 10 TO 2 STEP -1 DO
a{i}:=a{i-1};
ENDFOR
Los valores de una matriz se ajustan de forma creciente. a{10}:=a{9}, a{9}:=a{8}. Para lograrlo
empleamos el valor del contador como índice de la matriz.
Operación de la estructura FOR-ENDFOR:

1. Se calculan las expresiones correspondientes a los valores iniciales, final y de incremento.
2. El contador de bucle toma el valor inicial.
3. El valor del contador de bucle será comprobado para ver si dicho valor se encuentra entre el
valor inicial y el valor final o si es igual al valor inicial o al valor final. Si el valor del contador se
encuentra fuera de esta gama, el bucle FOR se para y la ejecución del programa continúa con
la instrucción que sigue a ENDFOR.
4. Las instrucciones del bucle FOR se ejecutarán.
5. El contador de bucle será incrementado (o disminuido) de acuerdo con el valor de incremento.
6. El bucle FOR se repetirá, empezando a partir del punto 3.
Sólo podremos acceder al contador de bucle (del tipo de dato num) desde dentro del bucle FOR
y por consiguiente esconderá los demás datos y rutinas que tengan el mismo nombre. Sólo podrá ser
leído (no actualizado) por las instrucciones contenidas en el bucle FOR.
No se podrán utilizar valores decimales para los valores iniciales, finales o de paro, en
combinación con una condición de terminación exacta para el bucle FOR (no definido en el caso en
que el último bucle esté funcionando o no).

5.5.4. WHILE-ENDWHILE: Repetición de estructuras II

Se usa cuando una o varias instrucciones deben repetirse mientras que una condición específica
sea verdadera.
La sintaxis de esta estructura es la siguiente:
WHILE Condición DO
…;
ENDWHILE
Condición: La condición que debe ser cumplida para que las instrucciones del bucle puedan
ejecutarse.
Ejemplo:
WHILE reg1 < reg2 DO

…
reg1:=reg1+1;
ENDWHILE
Se repiten las instrucciones del bucle WHILE mientras reg1 < reg2.
Operación de la estructura WHILE-ENDWHILE:
1. Se evalúa la condición. Si la condición no ha sido cumplida, el bucle WHILE finaliza y la

ejecución del programa continúa con la instrucción que sigue a ENDWHILE.
2. Las instrucciones del bucle WHILE son ejecutadas.
3. Se repite el bucle WHILE empezando por el punto 1.
5.5.5. GOTO: Salto de la ejecución a una etiqueta

Sirve para transferir la ejecución del programa a otra línea (una etiqueta) dentro de la misma
rutina.
Una etiqueta sirve para dar nombre a una línea del programa. Utilizando la instrucción GOTO,
este nombre podrá utilizarse para desplazar la ejecución del programa a esa línea.
Ejemplo:
reg1:=1;
sig:
…
reg1:=reg1+1;
IF reg1<5 GOTO sig;
Las instrucciones comprendidas entre la etiqueta sig y la evaluación del valor de reg1 se
repetirán cinco veces.

Operación de la instrucción GOTO:

1. Cuando se lee la etiqueta no pasa nada, como si fuese un comentario.
2. Una etiqueta no debe ser nunca la misma que otra etiqueta dentro de la misma rutina.
3. Sólo se podrá transferir la ejecución del programa:
 A una etiqueta si se encuentra dentro de la misma rutina.

 A una etiqueta dentro de una instrucción IF o TEST si la instrucción GOTO está también situada
dentro de la misma rama de esta instrucción.
 A una etiqueta dentro de una instrucción FOR o WHILE si la instrucción GOTO está también situada
dentro de esta instrucción.
5.6. Ejercicio de aplicación

Realizaremos un ejercicio en el que aplicaremos algunas de las herramientas vistas en los
apartados anteriores. El objetivo será escribir el código de un programa que permita el trazado en el
espacio de un cuadrado y un hexágono, en un plano XY (paralelo al suelo).
+Y +Y
400mm B{3} 400mm B{4}

A{2} A{3}
200mm
A B
400mm
B{2} B{5}
200mm
A{1} A{4}
+X + X B{1} B{6}
100mm 100mm
1. Contemplar como posición inicial del robot la de calibración (todos los ejes en 0º).
2. Tomar como posición A0 la que corresponde a:
a. Eje 1=10º
b. Eje 2=10º
c. Eje 3=25º
d. Eje 5=30º
Esta será la posición de inicio de las trayectorias. En la imagen, corresponde a los puntos A{1} y
B{1}. Observar que los vértices de la figura están indicados como componentes de matrices.
3. Emplear una entrada (E01) para iniciar los movimientos. El estado de inicio es E01=1.
4. En función del estado de una segunda entrada (E02), se inicia el movimiento “A” en forma
continua (si E02=0) o la trayectoria “B” en forma continua (si E02=1). En forma continua significa
en forma cíclica.
5. Ante cambio de estado de la entrada E02, cambia la trayectoria mantenida en forma cíclica.
6. Los movimientos se detienen cuando E01=0.

Consideraciones
- Se nos pide procesar los vértices de las figuras a través de matrices con datos de posición. Esto nos será
útil porque, una vez completadas las matrices, recorrerlas para obtener los movimientos será sencillo
empleando una estructura de iteración FOR-ENDFOR.
Tenemos dos posibilidades para realizar esto:
1. Declarar dos matrices de una dimensión, una para cada figura, para el cuadrado de 4 elementos y
para el hexágono de 6. Luego, emplear cada matriz según se requiera.
2. Declarar una matriz de 6 filas por 2 columnas. Emplear la primera columna para los vértices del
cuadrado, dejando dos lugares al final sin utilizar, y emplear la segunda columna con los vértices del
hexágono.
Como hemos dicho, no hay modo correcto ni incorrecto de elaborar un código mientras cumpla con los
requerido en tiempo de ejecución. Para facilitar el desarrollo del código, emplearemos dos matrices.
- Contemplaremos que el programa trabaja en modo manual. O sea, que la ejecución cíclica del programa
dependerá del código, no del controlador. Esto significa que, finalizado un ciclo, nosotros debemos
escribir el código necesario para que la ejecución vuelva a iniciarse una y otra vez, mientras esté el
programa en ejecución.
Código
%%%
VERSION:1
LANGUAGE:ENGLISH
%%%
MODULE PROGRAMA
CONST extjoint ejes:=[9E+09,9E+09,9E+09,9E+09,9E+09,9E+09]; !Declaramos el dato ejes
CONST jointtarget P0:=[[0,0,0,0,0,0], ejes]; !Declaramos la posición de calibración
CONST jointtarget P1:=[[10,10,25,0,30,0], ejes]; !Posición de inicio de trayectorias
VAR robtarget A0; !Posición de inicio como RobTarget
VAR robtarget A{4}; !Matriz para vertices del cuadrado
VAR robtarget B{6}; !Matriz para vertices del hexagono
PROC main()
A{1}:=Offs(A0,-400,0,0); !Cargamos los vertices del cuadrado
A{2}:=Offs(A0,-400,400,0); !Presten atención a cómo ordené
A{3}:=Offs(A0,0,400,0); !los puntos dentro de la matriz.
A{4}:=A0;
B{1}:=Offs(A0,-200,-100,0); !Cargamos los vertices del hexagono
B{2}:=Offs(A0,-400,0,0);
B{3}:=Offs(A0,-400,200,0);
B{4}:=Offs(A0,-200,300,0);
B{5}:=Offs(A0,0,200,0);
B{6}:=A0;
EtiquetaInicio: !Etiqueta para funcionamiento cíclico
WaitDI E01, 1; !Inicio movimientos si E01=1
IF E02=0 THEN
CUADRADO; !Ejecuto el cuadrado
ELSE
HEXAGONO; !Ejecuto el hexagono
ENDIF
GOTO EtiquetaInicio;
ENDPROC

PROC CUADRADO()
FOR k FROM 1 TO 4 DO
MoveL A{k}, v1000, fine, tool0;
ENDFOR
ENDPROC
PROC HEXAGONO()
FOR m FROM 1 TO 6 DO
MoveL B{m}, v1000, fine, tool0;
ENDFOR
ENDPROC
ENDMODULE
¿Otro método de simular el funcionamiento cíclico?
Reescribo sólo el procedimiento main() con una ligera variación:
PROC main()
A{1}:=Offs(A0,-400,0,0); !Cargamos los vertices del cuadrado
A{2}:=Offs(A0,-400,400,0); !Presten atención a cómo ordené
A{3}:=Offs(A0,0,400,0); !los puntos dentro de la matriz.
A{4}:=A0;
B{1}:=Offs(A0,-200,-100,0); !Cargamos los vertices del hexagono
B{2}:=Offs(A0,-400,0,0);
B{3}:=Offs(A0,-400,200,0);
B{4}:=Offs(A0,-200,300,0);
B{5}:=Offs(A0,0,200,0);
B{6}:=A0;
WHILE E01=1 DO
IF E02=0 THEN
CUADRADO; !Ejecuto el cuadrado
ELSE
HEXAGONO; !Ejecuto el hexagono
ENDIF
ENDWHILE
ENDPROC
¿Funciona el código anterior?

¿Realiza el trabajo solicitado en la consigna del ejercicio? ¿Sí? ¿No?
Los invito a analizar la situación y determinar si la solución funciona, y en caso de no hacerlo por
qué no.

Anexo A – Rutinas de Interrupción

Interrupciones
Las rutinas de interrupción se emplean para ser asociadas a un evento en particular. Una vez
definido el evento, el controlador lo estará supervisando en forma permanente paralelamente a la
ejecución del programa. Cuando el evento se produce, o bien se convierte en verdadera la condición
supervisada, el controlador ejecuta en forma inmediata la rutina de interrupción, abandonando la
ejecución normal del programa.
Las interrupciones son eventos definidos por el programa, identificados mediante los números
de interrupción. Una interrupción se produce cuando se da una condición de interrupción. Al
contrario de los errores, la ocurrencia de una interrupción no está directamente relacionada con una
posición de una instrucción específica. La ocurrencia de una interrupción provoca la suspensión de la
ejecución normal del programa y el control es transferido a una rutina de tratamiento de
interrupciones (TRAP).
El programa es interrumpido, por ejemplo, cuando se activa una entrada específica en 1. Cuando
ello ocurre, el programa utilizado se interrumpe y se ejecuta un tipo especial de rutina de tratamiento
de interrupción (rutina TRAP). Una vez esto se ha ejecutado, la ejecución del programa prosigue a
partir de donde se había interrumpido.
Aunque el robot reconozca inmediatamente la ocurrencia de una interrupción (el único retraso
se deberá a la velocidad del controlador), su respuesta – llamada a la rutina TRAP correspondiente –
sólo podrá ocurrir en unas posiciones específicas del programa, que son:
- Cuando se entra en la siguiente instrucción,
- En cualquier momento durante la ejecución de una instrucción de espera, (WaitUntil).
- En cualquier momento durante la ejecución de una instrucción de movimiento (MoveL).
Esto suele provocar un retraso que oscila entre 5 y 120ms entre el reconocimiento de la
interrupción y la respuesta, según el tipo de movimiento que se está realizando en ese momento.
Principios de programación
Cada interrupción tiene asignada una identificación de interrupción propia, que se obtiene
creando una variable (de tipo de datos intnum) y relacionándola con una rutina TRAP.
La identificación de la interrupción se utiliza entonces para dar la orden a una interrupción, es
decir, para especificar el motivo de la interrupción. El motivo puede ser uno de los siguientes
acontecimientos:
- Una entrada o una salida está activada en 1 o en 0.
- Ha pasado un cierto período de tiempo después de que se haya dado la orden a una interrupción.
- Se ha alcanzado una posición específica.
Cuando se da la orden a una interrupción, ésta se encuentra automáticamente habilitada, pero
podrá ser temporalmente inhabilitada. Ello se puede producir de dos maneras:
- Todas las interrupciones pueden ser inhabilitadas. Todas las interrupciones que ocurren durante este
tiempo quedan almacenadas en una cola y son posteriormente generadas de forma automática cuando
vuelvan a ser habilitadas de nuevo.
- Las interrupciones pueden ser desactivadas individualmente. El sistema no tendrá en cuenta ninguna
interrupción que ocurra durante este tiempo.

Si se inhabilitan las interrupciones, todas las que se produzcan serán puestas en una cola y no
aparecerán hasta que se vuelvan a habilitar de nuevo. Observar que la cola de interrupciones puede
contener más de una interrupción en espera. Las interrupciones de una cola aparecerán siguiendo un
orden FIFO (la primera que entra es la primera que sale). Las interrupciones están siempre
inhabilitadas durante la ejecución de una rutina TRAP.
Cuando se realiza una ejecución paso a paso y cuando el programa ha sido detenido, las
interrupciones no serán procesadas. Las que se produzcan en estas instancias no serán tratadas.
El número máximo de interrupciones simultáneas es de 40 por tarea. La limitación total
determinada por la CPU de E/S es de 100 interrupciones.
Cuando se borra una interrupción desaparece también su definición. No es necesario borrar de
forma explícita una definición de interrupción, pero no se podrá definir una interrupción nueva a una
variable de interrupción hasta que se haya borrado la definición precedente.
Rutinas de tratamiento de las interrupciones (TRAP)
Las rutinas TRAP proporcionan un medio para procesar las interrupciones. Una rutina TRAP podrá
ser conectada a una interrupción particular mediante la instrucción CONNECT. En el caso en que
ocurra una interrupción, el control es inmediatamente transferido a la rutina TRAP asociada (siempre
y cuando haya una). Si ocurre una interrupción que no ha sido conectada a ninguna rutina TRAP, la
interrupción será considerada como un error fatal, es decir, que provoca inmediatamente el paro de
la ejecución del programa.
Ejemplo:
VAR intnum vacío;
Declaración de datos tipo intnum para
VAR intnum lleno;
asociarlas a las interrupciones.
PROC main()
…
CONNECT vacío WITH etrap; Conexión de rutina tratamiento de
CONNECT lleno WITH ftrap; interrupciones
ISignalDI di1, alto, vacío; Define las entradas del PLC que serán
ISignalDI di3, alto, lleno; supervisadas.
…
IDelete vacío;
IDelete lleno;
ENDPROC
TRAP etrap Respuesta a la interrupción “alimentador

abrir_valv; vacío”
RETURN;
ENDTRAP
TRAP ftrap Respuesta a la interrupción “alimentador

Cerrar_valv; lleno”
RETURN;
ENDTRAP
Varias interrupciones podrán ser conectadas a la misma rutina TRAP. La variable del sistema
INTNO contiene el número de interrupción y podrá ser utilizada por una rutina TRAP para la
identificación de la interrupción. Después de haber tomado las medidas necesarias, se podrá finalizar
una rutina TRAP utilizando la instrucción RETURN o cuando se alcanza el final (ENDTRAP o ERROR) de
la rutina TRAP. La ejecución continúa a partir del lugar en que ocurrió la interrupción.

Anexo B - Tratamiento de Errores

Un error de ejecución es una situación anormal, si se considera el proceso de ejecución de una
parte específica de un programa de trabajo. Un error hace que la continuación de la ejecución sea
imposible (o por lo menos peligrosa). “Desbordamiento” y “división por cero” son ejemplo de errores.
Los errores son identificados por su único número de error que el robot reconoce siempre. La
ocurrencia de un error provoca la suspensión de la ejecución normal del programa y el control pasa
a un gestor de errores. El concepto del gestor de errores hace que sea posible proporcionar una
respuesta y posiblemente recuperar la situación de error que ha aparecido durante la ejecución del
programa. En el caso en que no se pueda proseguir con la ejecución del programa, el gestor de errores
podrá por lo menos asegurar que la interrupción del programa sea suave.
Gestor de errores
Cualquier rutina puede incluir un gestor de errores, que formará realmente parte de la rutina y
el alcance de cualquier dato de rutina comprenderá también el gestor de errores de la rutina. En el
caso en que ocurra un error durante la ejecución de la rutina, el control será transferido a su gestor
de errores.
Ejemplo: FUNC num divsegur( num X, num Y)
RETURN X/Y;
ERROR
IF ERRNO = ERR_DIVZERO THEN
TPWrite “El denominador no puede ser cero”;
RETURN X;
ENDIF
ENDFUNC
La variable del sistema ERRNO contiene el código de error del error más reciente y será utilizado
por el gestor de errores para poder identificarlo. Después de que se hayan tomado todas las medidas
necesarias, el gestor de errores podrá:
 Proseguir con la ejecución, empezando por la instrucción en la que se ha producido el error.
Esto se llevará a cabo utilizando la instrucción RETRY. En el caso en que esta instrucción vuelva a
provocar el mismo error, se producirán hasta cuatro recuperaciones del error; luego la ejecución se
detendrá.
 Continuar la ejecución, empezando con la instrucción siguiente a la instrucción en la que ha
ocurrido el error. Esto se consigue utilizando la instrucción TRYNEXT.
 Devolver el control al que ha llamado la rutina utilizando la instrucción RETURN. En el caso en
que la rutina sea una función, la instrucción RETURN deberá especificar un valor de retorno apropiado.
 Propagar el error al que ha llamado la rutina utilizando la instrucción RAISE.
Cuando ocurre un error en una rutina que no contiene ningún gestor de errores o cuando se
alcanza el final del gestor de errores (ENDFUNC, ENDPROC o ENDTRAP), el gestor de errores del
sistema es llamado. El gestor de errores del sistema sólo registrará el error y detendrá la ejecución.
En una cadena de llamada de rutinas, cada rutina puede tener su propio gestor de errores. En el
caso en que ocurra un error en una rutina que dispone de un gestor de errores y si el error ha sido
propagado de forma explícita mediante la instrucción RAISE, volverá a aparecer el mismo error en el
punto que se llamó la rutina – el error ha sido propagado. Si se alcanza el principio de una cadena de

llamada (la rutina de entrada de la tarea) sin encontrar ningún gestor de errores, o si se alcanza el
final de cualquier gestor de errores dentro de la cadena de llamada, se llamará al gestor de errores
del sistema. El gestor de errores del sistema sólo registrará el error y detendrá la ejecución. Dado que
una rutina TRAP sólo podrá ser llamada por el sistema (como una respuesta a una interrupción),
cualquier propagación de un error desde una rutina TRAP se realizará al gestor de errores del sistema.
La recuperación de errores no estará disponible para las instrucciones que se encuentran en el
gestor de ejecución hacia atrás. Estos tipos de errores serán siempre enviados al gestor de errores
del sistema.
Además de los errores detectados y generados por el robot, un programa puede, de forma
explícita, provocar errores mediante la instrucción RAISE. Esta utilidad podrá utilizarse para resolver
situaciones muy complejas. Podrá utilizarse, por ejemplo, para salir de posiciones profundamente
anidadas, es decir, de situaciones en que se han llamado a subrutinas dentro de subrutinas de forma
excesiva. Se podrá utilizar cualquier número de error entre 1 y 90 en una instrucción RAISE. Los
errores suscitados de forma explícita son procesados exactamente de la misma forma que los errores
provocados por el sistema.
Se debe observar que no será posible resolver o responder a errores que ocurren dentro de una
cláusula de error. Este tipo de errores son siempre enviados al gestor de errores del sistema.

Manual Robótica UTN - 5. Lenguaje de Programación Rapid

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manual Robótica UTN - 5. Lenguaje de Programación Rapid

Cargado por

Copyright:

Formatos disponibles

Universidad Tecnológica Nacional Departamento Ingeniería Eléctrica

Facultad Regional General Pacheco Robótica y Automación 2018

5.1. Lenguaje RAPID – Estructura del programa

Ing. Alberto R. Kremer 1-34

Ing. Alberto R. Kremer 2-34

5.2. Principios de programación

Ing. Alberto R. Kremer 3-34

5.3. Componentes de un programa

Comodín Representa Comodín Representa

<RDN> Una declaración de rutina <EIT> La cláusula ELSE de una instrucción IF

! Las siguientes instrucciones sirven para tomar una lata de la mesa

Ing. Alberto R. Kremer 4-34

Ing. Alberto R. Kremer 5-34

5.3.4.3. Declaración de los módulos

Ing. Alberto R. Kremer 6-34

La siguiente figura ejemplifica la situación:

- Llamar a las rutinas “c” y “d” del módulo 1,

Ing. Alberto R. Kremer 7-34

5.3.5.2. Parámetros de una rutina

Ing. Alberto R. Kremer 8-34

FUNC num Altura(num Lado)

5.3.6. Los Datos

5.3.6.1. Tipo de información que guardaremos en el dato

Ing. Alberto R. Kremer 9-34

Ing. Alberto R. Kremer 10-34

Veamos qué significa trabajar con una matriz de datos.

Ejemplos: CONST num Pi:=3.14159; !Dato numérico que contendrá el valor de π.

Ing. Alberto R. Kremer 11-34

5.3.6.3. Lugar de declaración de un dato

5.3.7. Las Instrucciones

Ing. Alberto R. Kremer 12-34

5.3.7.1. Instrucciones de posicionamiento

2. Instrucción MoveL – Movimiento Lineal

3. Instrucción MoveC – Movimiento Circular

5.3.7.2. Espera de tiempo

Ing. Alberto R. Kremer 13-34

5.3.7.3. Medición de tiempos – Funciones de cronómetro

PROC main() !Abrimos la rutina main

ClkReset reloj1; !Borramos el valor guardado del ciclo anterior

Ing. Alberto R. Kremer 14-34

5.3.8. Las funciones

Ing. Alberto R. Kremer 15-34

5.3.9. Elaborando programas en Rapid

Veremos a continuación algunos ejemplos de programas básicos.

Ing. Alberto R. Kremer 16-34

5.3.9.1. Procedimiento con declaración de datos en forma indirecta

Ing. Alberto R. Kremer 17-34

5.3.9.2. Llamada a rutina con argumentos

Ing. Alberto R. Kremer 18-34

5.3.9.3. Empleo de una función

Ing. Alberto R. Kremer 19-34

5.3.9.4. Ejercicio de aplicación

1. Contemplar como posición inicial del robot la

MICUADRADO 300; !Hacemos el cuadrado lado 300mm

Ing. Alberto R. Kremer 20-34

5.4. Gestión de Entradas y Salidas

Ing. Alberto R. Kremer 21-34

5.4.1. Principios de programación

5.4.2. Lectura de las entradas digitales

Por ejemplo: WaitDI E01, 1;

Ing. Alberto R. Kremer 22-34

5.4.3. Escritura de salidas digitales

5.5. Gestión del flujo del programa