174576709 Programacion experto Kuka

Vista previa del material en texto

ProgExperteBHR5.2 09.03.01 es 1 de 197
SOFTWARE
KR C2 / KR C3
Programación por el experto
KUKA System Software (KSS)
Release 5.2
Edición: 12.09.2005 Versión: 01
2 de 197 ProgExperteBHR5.2 09.03.01 es
e Copyright 2005
KUKA Roboter GmbH
Zugspitzstrasse 140
D--86165 Augsburg
La reproducción de esta documentación -- o parte de ella -- o su facilitación a terceros solamenta está permitida con expresa autorización del
editor.
Además del volumen descrito en esta documentación, pueden existir funciones en condiciones de funcionamiento. El usuario no adquiere el
derecho sobre estas funciones en la entrega de un aparato nuevo, ni en casos de servicio.
Hemos controlado el contenido del presente escrito en cuanto a la concordancia con la descripción del hardware y el software. Aún así, no
pueden excluirse totalmente todas las divergencias, demodo tal, que no aceptamos responsabilidades respecto a la concordancia total. Pero
el contenido de estos escritos es controlado periodicamente, y en casos de divergencia, éstas son enmendadas y presentadas correctamente
en las ediciones siguientes.
Reservados los derechos a modificaciones técnicas que no tengan influencia sobre la función.
3 de 197ProgExperteBHR5.2 09.03.01 es
Indice
1 Generalidades sobre los programas KRL 7. . . . . . . . . . . . . . . . . . . . . . . . . .
1.1 Estructura y creación de programas 7. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.1.1 Superficie del programa 7. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.1.2 Concepto de archivo 8. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.1.3 Estructura de archivos 8. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Crear programas y editarlos 10. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2.1 Crear un programa nuevo 10. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2.2 Editar, compilar y vincular un programa 11. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3 Modificación de programas 13. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.1 Corrección de programa 13. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.2 Editor 13. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.2.1 Funciones de bloque 13. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.2.2 Copiar (CTRL--C) 14. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.2.3 Insertar (CTRL--V) 14. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.2.4 Cortar (CTRL--X) 14. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.2.5 Borrar 14. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.2.6 Buscar 14. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.2.7 Reemplazar 15. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.4 Esconder partes de un programa 17. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.4.1 FOLD 17. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.4.1.1 Programa de ejemplo 18. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.5 Modo de ejecución del programa 20. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.5.1 Selección del modo de ejecución del programa 20. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.5.2 Cambio del modo de ejecución del programa 21. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.6 Tratamiento de errores 23. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.7 Comentarios 26. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2 Variables y declaraciones 27. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.1 Variables y nombres 27. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Objetos de datos 29. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.1 Declaración e inicialización de objetos de datos 29. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.2 Tipos de datos simples 30. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.3 Campos 33. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.4 Cadenas de caracteres 36. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.5 Estructuras 36. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.6 Tipos de enumeración 39. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3 Manipulación de datos 40. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.1 Operadores 40. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.1.1 Operadores aritméticos 40. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.1.2 Operador geométrico 42. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.1.3 Operadores de comparación 46. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.1.4 Operadores lógicos 47. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.1.5 Operadores de bits 48. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.1.6 Prioridades de los operadores 50. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programación por el experto
4 de 197 ProgExperteBHR5.2 09.03.01 es
2.3.2 Funciones estándar 51. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.4 Variables del sistema y archivos del sistema 53. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5 Manipulación de variables de cadena 57. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5.1 Longitud de una variable decadena en la declaración 57. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5.2 Longitud de una variable de cadena después de la inicialización 57. . . . . . . . . . . . . . . . . . . . . .
2.5.3 Borrar el contenido de una variable de cadena 58. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5.4 Ampliar la variable de cadena 58. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5.5 Búsqueda de variables de cadena 59. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5.6 Comparación del contenido de variables de cadena 59. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5.7 Copiar una variable de cadena 60. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3 Programación de movimiento 61. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1 Utilización de diferentes sistemas de coordenadas 61. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 Movimientos punto a punto (PTP) 67. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.1 General (PTP sincrónico) 67. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.2 Perfil de marcha más elevado 68. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.3 Instrucciones de movimiento 68. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2.3.1 Singularidades 78. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3 Movimientos de trayectoria (movimientos CP = Continuous Path) 80. . . . . . . . . . . . . . . . . . . .
3.3.1 Velocidad y aceleración 80. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3.2 Control de la orientación 82. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3.3 Movimientos lineales 87. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3.4 Movimientos circulares 89. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.4 Procesamiento en avance 91. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5 Movimientos con posicionamiento aproximado 93. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5.1 Posicionamiento aproximado PTP--PTP 94. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5.2 Posicionamiento aproximado LIN--LIN 96. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5.3 Posicionamiento aproximado CIRC--CIRC y posicionamiento aproximado CIRC--LIN 98. . . .
3.5.4 Posicionamiento aproximado PTP -- trayectoria 101. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.5.5 Cambio de herramienta durante el posicionamiento aproximado 104. . . . . . . . . . . . . . . . . . . . . .
3.6 Programación por aprendizaje de los puntos 105. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4 Control de ejecución del programa 107. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1 Ramificaciones de programa 107. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.1 Instrucciones de salto 107. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.2 Ramificación condicionada 107. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.3 Distribuidor 108. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Bucles 109. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.1 Bucles de conteo 109. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.2 Bucle rechazante 110. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.3 Bucles no rechazantes 111. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.4 Bucles sinfín 112. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.5 Terminación anticipada de la ejecución de bucles 112. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3 Instrucciones de espera 113. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.1 Espera a un evento 113. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.2 Tiempos de espera 115. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4 Detener el programa 116. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.5 Confirmación de mensajes 116. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5 de 197ProgExperteBHR5.2 09.03.01 es
5 Instrucciones de entrada/salida 118. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.1 Generalidades 118. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.2 Entradas y salidas binarias 118. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3 Entradas y salidas digitales 121. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.1 Declaración de la señal 121. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.2 Lectura de números de señal 123. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.3 Activar salidas en el punto de destino 125. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.4 Salidas de impulso 127. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.5 Entradas y salidas analógicas 129. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.5.1 Salidas Analógicas 129. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.5.2 Entradas analógicas 131. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.6 Entradas digitales predefinidas 134. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6 Subprogramas y funciones 136. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.1 Declaraciones 136. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2 Llamada y transferencia de parámetros 139. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7 Tratamiento de interrupciones144. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.1 Declaración 144. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2 Activación de interrupciones 146. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.3 Detención de movimientos en ejecución 150. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.4 Cancelación de rutinas de interrupción 151. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.5 Utilización de banderas (flags) cíclicas 154. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8 Trigger -- Acciones de conmutación referentes a la trayectoria 156. . . . . .
8.1 Acciones de conmutación en el punto de inicio o de destino de la trayectoria 156. . . . . . . . . . .
8.2 Acciones de conmutación en cualquier lugar sobre la trayectoria 159. . . . . . . . . . . . . . . . . . . . .
9 Listas de datos 164. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1 Listas de datos locales 164. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2 Listas de datos globales 165. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10 Editor externo 168. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.1 Arranque del editor externo 169. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.2 Operación 170. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3 Menú “Fichero” 172. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3.1 Abrir 172. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3.2 Guardar 172. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3.3 Salida 172. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3.4 Cerrar 173. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3.5 Salir 173. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.4 Menú “Editar” 174. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.4.1 Cortar (“CTRL”--“X”) 174. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programación por el experto
6 de 197 ProgExperteBHR5.2 09.03.01 es
10.4.2 Copiar (“CTRL”--“C”) 174. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.4.3 Pegar como ... 174. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.4.4 Borrar 174. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.4.5 Seleccionar todo (“CTRL”+”A”) 174. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.5 Menú “Utilidades” 175. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.5.1 Espejo 175. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.5.2 Entrada manual 176. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.5.3 Cambio de bloque 180. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.5.4 Limpiar lista de ficheros 180. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.5.5 Ajuste del TCP o de BASE 181. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.6 Menú “HotEdit” 182. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.6.1 Base, TCP y World 182. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.6.2 TTS (Sistema de coordenadas de corrección) 184. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.6.2.1 Position--TTS 185. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.6.3 Limite 187. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.6.3.1 Limits -- Base/World 187. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.6.3.2 Limits -- TTS 187. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.7 Menú “Ext Utilidades” 188. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.7.1 Fichero -- Espejo 188. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.7.2 Fichero -- Cambiar 190. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.7.2.1 Utilizar el fichero de referencia existente 191. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.7.2.2 Crear un nuevo fichero de referencia 192. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.7.3 Limite cambiado 193. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.8 Menú “Opciones” 194. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.8.1 Ajuste de salida 194. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.9 Menú “Ayuda” 195. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.9.1 Versión 195. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.9.2 Permanecer arriba 195. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1 Generalidades sobre los programas KRL
7 de 197ProgExperteBHR5.2 09.03.01 es
1 Generalidades sobre los programas KRL
1.1 Estructura y creación de programas
1.1.1 Superficie del programa
En el instante de haber cambiado al nivel del experto, se modifica la superficie de operación
del modo representado a continuación:
Mientras que para el usuario son invisibles todos los archivos de sistema, el experto puede
verlos y también editarlos en la ventana de programas. Además,junto a los nombres de ar-
chivo y comentarios, en el nivel del experto puedenmostrarse también las extensiones, atri-
butos y tamaños de los archivos.
Según los ajustes predeterminados, después de la instalación, los siguientes programas y
archivos se encuentran en diferentes directorios KRC.
En el directorio “KRC:\R1\” se encuentra el siguiente archivo:
CELL.SRC Programa para el mando de robots a través de un PLC central.
Aquí, se selecciona a partir de un número de programa, el pro-
grama de la pieza correspondiente
En el directorio “KRC\R1\MADA\” se encuentran los siguientes archivos:
Fichero Significado
$MACHINE.DAT Lista de datos del sistema con variables del sistema para la adapta-
ción de la unidad de control y del robot
$ROBCOR.DAT Lista de datos del sistema con datos para el modelo dinámico del
robot
KSD... Archivos servo específicos de la máquina
MACHINE.UPG Archivo del sistema para futuras actualizaciones
ROBCOR.UPG Archivo del sistema para futuras actualizaciones
Programación por el experto
8 de 197 ProgExperteBHR5.2 09.03.01 es
En el directorio “KRC:\R1\SYSTEM\” se encuentran los siguientes archivos:
Fichero Significado
$CONFIG.DAT Lista de datos del sistema con datos generales de configuración
BAS.SRC Paquete básico para el comando de movimientos
IR_STOPM.SRC Programa para el tratamiento de errores cuando se producen
averías
SPS.SUB Fichero submit para controles paralelos
En el directorio “KRC:\R1\TP\” se encuentra el siguiente archivo:
Fichero Significado
P00.DAT
P00.SRC
Paquete de programas para el acoplamiento a un PLC
Normalmente, los programas y archivos para paquetes de tecnología opcionales se
guardan en el directorio “TP”.
1.1.2 Concepto de archivo
Un programa KRL puede estar compuesto de un fichero SRC y de un fichero DAT.
Aquí, el fichero con la extensión “SRC” es el archivo con el código de programa propiamente
dicho. Aquí existen las variantes DEF y DEFFCT (con valor de retorno). Por el contrario, el
fichero con la extensión “DAT” contiene los datos específicos para el programa. Esta parti-
ción está basada en el concepto de archivo de KRL: El programa contiene, además de las
instrucciones de movimiento, distintas acciones que deben ser ejecutadas por el robot in-
dustrial. Éstas pueden ser determinadas secuencias de movimientos, por ejemplo abrir o
cerrar una herramienta con garras, amén de otras ejecuciones más complejas, tales como
el mando de una pinza de soldadura tomando en consideración las condiciones límite.
Para efectuar el test de programas es útil, y a veces necesario, poder ejecutar tareas parcia-
les. El concepto de archivo realizado en KRL, cumple con las necesidades especiales de
la programación del robot.
1.1.3 Estructura de archivos
Un archivo es la unidad que programa el programador. Con ello, un archivo corresponde a
una unidad de programa en el disco duro o en la memoria (RAM). Cada programa en KRL
puede constar de uno o varios archivos. Los programas simples comprenden exactamente
un archivo. Las tareas más complejas se solucionan mejor con un programa compuesto de
varios archivos.
La información detalladaacerca de los subprogramas y funciones se encuentra en el apar-
tado [Subprogramas y funciones].
La estructura interior de un archivo KRL consta de la sección de declaraciones, la sección
de instrucciones y hasta 255 subprogramas y funciones locales.
El nombre del objeto sin extensión es asimismo el nombre del archivo y por ello se indica
en la declaración con “DEF”. El nombre debe constar de un máximo de 24 caracteres y no
debe ser ninguna palabra clave (véase el capítulo [Variables y declaraciones]). Cada ar-
chivo comienza con la declaración “DEF” y finaliza con “END”.
DEF NAME(X1:IN)
Declaraciones
Instrucciones
END
DEF
1 Generalidades sobre los programas KRL (continuación)
9 de 197ProgExperteBHR5.2 09.03.01 es
Las declaraciones seevalúanantes de la ejecucióndel programa, es decir, durante la compi-
lación. En la sección de declaraciones no debe haber ninguna instrucción. La primera ins-
trucción constituye asimismo el comienzo de la sección de instrucciones.
Contrariamente a lo que ocurre en la sección de declaraciones, las instrucciones tienen un
carácter dinámico: se ejecutan durante la ejecución del programa.
Un programa del robot puede constar de un solo fichero de programa o de un fichero de pro-
grama con la correspondiente lista de datos. La lista de datos y el fichero se señalizan como
correspondientes mediante sus nombres comunes. Los nombres solamente se diferencian
por la extensión, por ejemplo:
Fichero: PROG1.SRC
Lista de datos: PROG1.DAT
En la lista de datos sólo se permiten asignaciones de valores con “=”. Cuando la lista
dedatos y el fichero poseenelmismonombre, puedenutilizarse las variables que esténdecla-
radas en la lista de datos de igual modo que las variables declaradas en el fichero SRC.
La información detallada acerca de este tema se encuentra en el capítulo [Listas de
datos].
Declaración
Instrucción
Lista de datos
Programación por el experto
10 de 197 ProgExperteBHR5.2 09.03.01 es
1.2 Crear programas y editarlos
1.2.1 Crear un programa nuevo
Softkey Significado
Nuevo Dado que un programa para robot puede crearse también sin lista
de datos, el archivo y la lista de datos no se crean automáticamente
al mismo tiempo en el nivel de experto. Para crear un programa,
pulse la tecla del softkey “Nuevo”. Aparece la siguiente ventana:
OK Se le solicita que seleccione un Template. Utilice para ello las teclas
de flecha y confirme su selección con la tecla del softkey “OK” o con
la tecla de entrada.
Los Templates disponibles no pueden ser creados en todos los directorios.
La informaciónmás detallada acerca de los Templates se encuentra en elManual deope-
ración en la documentación [Instrucciones], capítulo [Navegador], apartado
[Apéndice].
Los distintos Templates de forma individual:
Template Significado
Modul Se crea un fichero SRC y un fichero DAT, que contiene un pro-
grama base o tronco de programa.
Expert Se crea un fichero SRC y un fichero DAT, que contienen solo el
encabezamiento DEF… y END.
Cell En este caso sólo se crea un fichero SRC que contiene un pro-
grama base o tronco de programa. Este programa sirve para el
mando del robot a través de un PLC central.
Function En este caso se crea una función (fichero SRC) que contiene el
encabezamiento DEF… y END.
Submit Se crea un fichero SUB con una base o tronco de programa. El
fichero Submit contiene instrucciones y puede ser utilizado por
ejemplo, para controles cíclicos (garras, etc.). El fichero Submit
trabaja en forma paralela al servicio del robot y es ejecutado por
el interpretador de la unidad de control.
Expert Submit Como en el caso del Template Submit, se crea un fichero SUB que,
sin embargo, sólo contiene el encabezamiento DEF… y END.
El encabezamiento DEF… y END y los programas base o troncos de programas de cada
uno de los Template se encuentran (por ejemplo, para el Template Cell) en “C:\KRC\RO-
BOTER\TEMPLATE\CellVorgabe.src”.
Si ha seleccionado el correspondiente Template, se le solicitará que dé un nombre al fichero
que desea generar.
Nombre de fichero
(máx. 24 caracteres)
Extensión del fichero
(SRC, DAT o SUB)
Comentario
El nombre del fichero es lo único obligatorio y puede tener, como máx., una longitud de 24
caracteres. La extensión del fichero se completa automáticamente. Si quiere agregar un co-
mentario, con la tecla de flecha derecha desplace el cursor sobre el campo correspondiente
e introduzca el texto deseado.
1 Generalidades sobre los programas KRL (continuación)
11 de 197ProgExperteBHR5.2 09.03.01 es
Para confirmar la entrada, pulse la tecla del softkey “OK” o la tecla de retorno.
La lista de datos es imprescindible si en su archivo SRC también desea insertarinstrucciones guiadas por menú.
1.2.2 Editar, compilar y vincular un programa
Si ha creado un fichero o una lista de datos con “Nuevo”, puede procesarlos con el editor.
Para ello se utiliza la tecla del softkey “Abrir”. Al cerrar el editor, se compila el código de
programa completo, es decir, el código KRL textual se traduce a un lenguaje de máquina
comprensible para la unidad de control.
Para que el programa sea claro y comprensible, es necesario, por ej., que cuando existen
ramificaciones éstas queden colocadas en distintos niveles. Esto se puede lograr en el
editor utilizando los espacios en blanco.
El compilador comprueba el código para verificar que la sintaxis y la semántica son correc-
tas. Si existe algún error, se emite el correspondiente mensaje y se genera un archivo de
fallos con la extensión “.ERR”.
Sólo se pueden seleccionar y ejecutar programas exentos de errores.
Encontrará más información sobre el tratamiento de errores o fallos de edición en el apar-
tado [Tratamiento de errores].
Cuando se carga un programa con la tecla del softkey “Seleccionar”, todos los ficheros y
listas de datos necesarios se vinculan para formar un programa. Al vincular estos datos, el
sistema comprueba si todos los módulos existen, han sido analizados y están exentos de
errores. Además, cuando seefectúauna transferencia deparámetros, el vínculo comprueba
la compatibilidad de tipos entre los parámetros transmitidos. Al igual que ocurre durante las
compilaciones, si durante este proceso aparece algún error, se genera un fichero de error
con la extensión “.ERR”.
A continuación se presenta un ejemplo sencillo de programa para la definición de velocida-
des y aceleraciones de ejes:
Programación por el experto
12 de 197 ProgExperteBHR5.2 09.03.01 es
DEF PROG1()
;----- Sección de declaraciones -----
INT J
;------ Sección de instrucciones -------
$VEL_AXIS[1]=100 ;Especificación de las velocidades de eje
$VEL_AXIS[2]=100
$VEL_AXIS[3]=100
$VEL_AXIS[4]=100
$VEL_AXIS[5]=100
$VEL_AXIS[6]=100
$ACC_AXIS[1]=100 ;Especificación de las aceleraciones de eje
$ACC_AXIS[2]=100
$ACC_AXIS[3]=100
$ACC_AXIS[4]=100
$ACC_AXIS[5]=100
$ACC_AXIS[6]=100
PTP {A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}
FOR J=1 TO 5
PTP {A1 4}
PTP {A2 -7,A3 5}
PTP {A1 0,A2 -9,A3 9}
ENDFOR
PTP {A1 0,A2 -90,A3 90,A4 0,A5 0,A6 0}
END
1 Generalidades sobre los programas KRL (continuación)
13 de 197ProgExperteBHR5.2 09.03.01 es
1.3 Modificación de programas
Básicamente, existen dos posibilidades de modificar un programa en la superficie de
operación del nivel del experto:
G Corrección de programa (PROKOR)
G Editor
1.3.1 Corrección de programa
Corrección de programa es el método normal. Si se selecciona un programa o se detiene
un programa en curso, el sistema pasa automáticamente al modo PROKOR.
Aquí se pueden introducir o modificar instrucciones por medio del formulario inline o en código
ASCII (en el nivel del experto) que únicamente afectan a una línea de programa. Por lo tanto,
quedan excluidas las estructuras de control (bucles, etc.) y las declaraciones de variables.
En el estado seleccionado, al salir de la línea de programa, las entradas erróneas son
borradas inmediatamente y aparece un mensaje de error en la ventana de mensajes.
1.3.2 Editor
Mediante la tecla del softkey “Abrir”, debe abrir un programa cuyo contenido desee
modificar con las funciones de bloque.
Por ello, para procesar o insertar determinadas instrucciones KRL o estructuras de progra-
mas, debe utilizarse el editor. Dado que al cerrar el editor se compila el código completo,
también pueden detectarse errores que se producen en relación con otras líneas (por ejem-
plo, variables declaradas incorrectamente).
Los programas que contienen instrucciones de movimiento (p. ej. PTP, LIN, CIRC) y se
cargan en el editor para su posterior procesamiento, deben encontrarse en el directorio
“KRC:\...”. De lo contrario, aparece el correspondiente mensaje de error (como sucede,
por ejemplo, al copiar bloques).
1.3.2.1 Funciones de bloque
Las funciones de bloque solamente están disponibles en el editor a partir del nivel del “Ex-
perto”. Mediante la tecla del softkey “Editar”, debe abrir el programa cuyo contenido desea
modificar con las funciones de bloque. Para saber cómo pasar antes al nivel del “Experto”,
consulte el capítulo [Configurar el sistema], apartado “Grupo de usuario”.
Coloque primero el cursor intermitente del editor sobre el comienzo oel final de aquella parte
de programa que desea cambiar de lugar. Luego mantenga pulsada la tecla “Shift” en el te-
cladomoviendomientras tanto el cursor hacia arriba ohacia abajo. Deestamanera,marcará
la parte del programa que, en el paso siguiente, va a procesar con las funciones de bloque.
La parte marcada aparecerá resaltada en otro color.
Pulse la tecla de menú “Editar” y seleccione la función deseada en el menú que se abrirá.
Si para las funciones debloque sehan deutilizar el bloque numérico y el teclado, la función
NUM debe estar desactivada. Para ello, pulse en el teclado la tecla “NUM”. En ese mo-
mento, se desactivará la indicación correspondiente en la línea de estado.
Programación por el experto
14 de 197 ProgExperteBHR5.2 09.03.01 es
1.3.2.2 Copiar (CTRL--C)
[Procesar > Copiar]
La sección marcada del programa es memorizada en el portapapeles para su posterior pro-
cesamiento. Esta sección puede ser insertada a continuación en otro lugar.
Alternativamente, puedemantener pulsada la tecla CTRL del bloque numérico y pulsar en
el teclado la tecla C. A continuación suelte ambas teclas.
1.3.2.3 Insertar (CTRL--V)
Coloque el cursor del editor sobre el punto donde desea insertar la parte de programa “co-
piada” o “cortada”.
[Procesar > Insertar]
Seleccione ahora la opción “Insertar”. La parte de programa antes marcada se inserta de-
bajo del cursor de edición.
Alternativamente, se puedemantener pulsada la tecla CTRL del bloque numérico y pulsar
la tecla V del teclado. A continuación, suelte ambas teclas.
1.3.2.4 Cortar (CTRL--X)
Si selecciona en el menú la opción “Cortar”, la parte de programa marcada se guardará en
el portapapeles y se borrará del listado del programa.
[Procesar > Cortar]
Alternativamente, se puedemantener pulsada la tecla CTRL del bloque numérico y pulsar
la tecla X del teclado. A continuación, suelte ambas teclas.
1.3.2.5 Borrar
[Procesar > Borrar]
La regiónmarcada puede ser eliminada del programa. En este caso, no sememoriza ningún
dato en el portapapeles. Esta parte eliminada del programa quedará con ello definitivamente
borrada.
Por este motivo, la ventana de mensajes formula una pregunta de seguridad que debe ser
respondida mediante la barra de teclas de función programable.
Cancelar La acción “Borrar” queda cancelada.
Sí La región marcada se borra definitivamente.
No La función “Borrar” queda cancelada.
Si se selecciona en el menú la opción “Borrar”, la parte marcada del programa es borrada
del listado sin que se memorice ningún dato en el portapapeles.
1.3.2.6 Buscar
Encontrará más información en el Manual de operación, dentro de la documentación
Programación por el usuario, capítulo [Creación y modificación de un programa],
apartado [Trabajar con el editor de programa].
1 Generalidades sobre los programas KRL (continuación)
15 de 197ProgExperteBHR5.2 09.03.01 es
1.3.2.7 Reemplazar
La función “Buscar y reemplazar” sólo existe en el nivel del experto y, en ese nivel, sólo está
disponible en el editor. Esta aplicación busca en el programa, dentro de la zona visible (que-
dan excluidas las líneas de folds o las folds abiertas), una secuencia de caracteres previa-
mente indicada y permite sustituirla por otra secuencia de caracteres definida.
Para ello seleccione en el menú “Procesar” la opción “Reemplazar”.
[Procesar > Reemplazar]
Se abrirá la siguienteventana:
Introduzca una secuencia de caracteres en la línea de búsqueda y luego, con la tecla de fle-
cha, baje hasta la línea de reemplazo. Introduzca en ella la secuencia de caracteres que
debe reemplazar a la secuencia buscada.
Programación por el experto
16 de 197 ProgExperteBHR5.2 09.03.01 es
Softkey Significado
Buscar Si la secuencia de caracteres aparece varias veces en el docu-
mento, pero sólo desea reemplazarla una vez en un lugar deter-
minado, pulse varias veces la tecla del softkey “Buscar” hasta
que encuentre el lugar que busca.
Reemplazar A continuación pulse “Reemplazar”. La secuencia de caracteres
buscada quedará reemplazada por la secuencia de caracteres
previamente indicada.
Reemplazar todo Si desea que la secuencia de caracteres buscada sea reempla-
zada en todos los lugares donde aparece o en la región que pre-
viamente marcó, después de introducirla en el formulario de
búsqueda/reemplazo (tal como se describe más arriba) pulse la
tecla del softkey “Reemplazar todo”.
Al hacerlo, en la ventana de mensajes aparecerá el mensaje “Se
ha encontrado la región especificada o marcada”. (Este mensaje
es una confirmación de que la búsqueda se efectuó en todo el
programa o en la región marcada).
Cancelar Al pulsar la tecla del softkey “Cancelar”, abandonará el modo de
reemplazo y en la ventana de mensajes podrá ver la cantidad de
reemplazos efectuados desde el momento en que se activó esta
función.
1 Generalidades sobre los programas KRL (continuación)
17 de 197ProgExperteBHR5.2 09.03.01 es
1.4 Esconder partes de un programa
Al contrario que en los editores normales, el editor KCP permite visualizar aquellas partes
específicas del contenido de un programa que el usuario desea ver. Así, por ejemplo, el
usuario ve solamente los contenidos esenciales de un programa, mientras que el experto
puede ver el programa completo.
1.4.1 FOLD
La superficie de operación KUKA utiliza una técnica especial para visualizar con claridad un
programa. Las instrucciones marcadas como comentarios KRL permiten suprimir la visuali-
zación de las partes subsiguientes del programa. De esta manera, el programa queda divi-
dido en apartados adecuados que se denominan “FOLDS” por tener las características de
una carpeta.
Normalmente, las “FOLDS” se encuentran “cerradas”, y sólo pueden ser “abiertas” en el ni-
vel del experto. Estos elementos contienen información que el usuario no puede ver en la
superficie de operación de KUKA (KUKA--BOF). En el nivel del experto, se puede hacer que
un bloque KRL sea invisible para el usuario. Para ello, se deben delimitar las correspondien-
tes declaraciones o instrucciones pormedio de las denominaciones “;FOLD” y “;ENDFOLD”.
En un programa, las folds se pueden visualizar u ocultar pulsando la tecla de menú “Proce-
sar”, y luego seleccionando “FOLD” y el comando deseado.
Programa seleccionado
Programa en el editor
FOLD
Copiar
Insertar
Cortar
Borrar
Buscando...
Reemplazar
Cerrar
Procesar FOLD actual abr/cer
Abrir todas FOLD
Cerrar todas FOLD
FOLD
Copiar
Insertar
Cortar
Borrar
Buscando...
Reemplazar
Cancelar programa
Resetear programa
Modificar
Procesar FOLD actual abr/cer
Abrir todas FOLD
Cerrar todas FOLD
Programación por el experto
18 de 197 ProgExperteBHR5.2 09.03.01 es
Se puede elegir entre las siguientes opciones:
FOLD actual abr/
cer
abre o cierra la FOLD en la línea en la que se encuentra el cur-
sor de edición
Abrir todas FOLD abre todas las FOLD del programa
Cerrar todas FOLD cierra todas las FOLD del programa
Si se resetea un programa seleccionado en el cual hay Folds abiertas, éstas se cerrarán
automáticamente.
De la secuencia...
;FOLD RESET OUT
FOR I=1 TO 16
$OUT[I]=FALSE
ENDFOR
;ENDFOLD
....estando las Folds cerradas, en la superficie de operación solamente se visualizarán las
palabras “RESET OUT”. Con esta instrucción se puede, por ejemplo, hacer invisible para
el usuario la sección de declaraciones e inicialización.
1.4.1.1 Programa de ejemplo
DEF FOLDS()
;FOLD DECLARE
;--------- Sección de declaración ---------
EXT BAS (BAS_COMMAND :IN,REAL :IN )
DECL AXIS HOME
INT I
;ENDFOLD
;FOLD INITIAL
;---------- Inicialización ---------
INTERRUPT DECL 3 WHEN $STOPMESS==TRUE DO IR_STOPM ( )
INTERRUPT ON 3
BAS (#INITMOV,0 ) ;Inicialización de velocidades,
;aceleraciones, $BASE, $TOOL, etc.
FOR I=1 TO 16
$OUT[I]=FALSE
ENDFOR
HOME={AXIS: A1 0,A2 -90,A3 90,A4 0,A5 30,A6 0}
;ENDFOLD
;------------- Sección principal------------
PTP HOME ;desplazamiento COI
LIN {X 540,Y 630,Z 1500,A 0,B 90,C 0}
PTP HOME
END
1 Generalidades sobre los programas KRL (continuación)
19 de 197ProgExperteBHR5.2 09.03.01 es
En la superficie de operación, el programa de este ejemplo tiene el siguiente aspecto:
Sección principal
El mismo programa con folds abiertas:
Sección principal
Sección de declaraciones
Inicialización
Inicialización de velocidades;
aceleraciones
Con la FOLD cerrada, sólo se puede ver la expresión que aparece después de la palabra
clave “FOLD”. Por el contrario, con la FOLD abierta se visualizan todas las instrucciones
y declaraciones.
”FOLD” es simplemente una instrucción para el editor. El compilador interpreta las
instrucciones FOLD gracias a que éstas llevan delante el signo de punto y coma como si
fuera un comentario normal.
Programación por el experto
20 de 197 ProgExperteBHR5.2 09.03.01 es
1.5 Modo de ejecución del programa
1.5.1 Selección del modo de ejecución del programa
Elmododeejecucióndel programaespecifica si el procesamiento delmismodebe realizarse
G sin que el programa se detenga
G por pasos de movimiento o
G por pasos individuales (línea).
En la siguiente tabla se describen todos los modos de ejecución de programas.
Modo de
ejecución
Descripción
#GO
Todas las instrucciones se procesan sin interrupción dentro del
programa hasta llegar al final del mismo.
#MSTEP Motion Step (paso de movimiento)
El programa se ejecuta paso por paso, es decir, con una parada
después de cada paso de movimiento.
El programa se ejecuta sin avance.
#ISTEP Paso incremental (paso individual)
El programa se ejecuta por pasos programados, es decir, con una
parada después de cada instrucción (también de las líneas en
blanco).
El programa se ejecuta sin avance.
#PSTEP Program Step (paso de programa)
Los subprogramas se ejecutan por completo.
El programa se ejecuta sin avance.
#CSTEP Continuous Step (paso de movimiento)
El programa se ejecuta paso por paso, es decir, con una parada
después de cada paso de movimiento con parada exacta.
El programa se ejecuta con avance, es decir, la ejecución se
efectúa con posicionamiento aproximado.
Los modos de ejecución de programas #GO, #MSTEP y #ISTEP pueden seleccionarse en
el KCP a través de una función de estado o por medio de la variable “$PRO_MODE”. En
cambio, #PSTEP y #CSTEP pueden ser declarados solamente a través de la variable
“$PRO_MODE”.
[Indicación > Variable > Únicos]
Encontrará información más detallada en el capítulo [Variables y declaraciones],
apartado [Objetos de datos] bajo (Tipos de enumeración).
1 Generalidades sobre los programas KRL (continuación)
21 de 197ProgExperteBHR5.2 09.03.01 es
1.5.2 Cambio del modo de ejecución del programa
Normalmente no es necesario un desplazamiento COI al cambiar el modo de ejecución del
programa. Si el cambio de modo de ejecución del programa tiene lugar durante un paso de
movimiento con avance, se ejecutará, por lo menos, el paso de movimiento actual. En el
caso de un paso demovimiento con posicionamiento aproximado, se ejecutan hasta el final
el paso de movimiento actual y el siguiente.
Conmutación ...STEP--GO
Al cambiar el modo de ejecución del programa de “#...STEP” a “#GO”, no se selecciona nin-
gún paso y por tanto no se puede realizar ningún desplazamientoCOI. Cuando se llega al
siguiente paso demovimiento, el sistema pasa al modo “#GO”. En este caso, no es necesa-
rio volver a pulsar la tecla de arranque.
El interpretador no se reinicia, ya que primero ha alcanzado el siguiente paso de
movimiento. No es necesario borrar la ejecución principal, ya que en elmodo deoperación
“#...STEP” la memoria intermedia sólo contiene el paso de movimiento actual.
Conmutación GO--...STEP
Al cambiar el modo de ejecución del programa de “#GO” a “#...STEP”, el robot se desplaza
hasta la siguiente parada exacta o hasta que el avance ha sido ejecutado por completo. En
el caso de un paso de movimiento con posicionamiento aproximado, se ejecuta, por lo me-
nos, el paso de movimiento siguiente. No se producen desplazamientos hasta otras zonas
de aproximación, ningún punto que quede fuera del punto de destino se podrá alcanzar me-
diante una selección de paso.
Pulsando la tecla de arranque, se efectúa una selección de paso en el paso de movimiento
que sigue al paso de ejecución principal. A continuación, el sistema pasa al modo de ejecu-
ción de programa “#...STEP”. Si en este momento no es posible seleccionar ningún paso,
se visualizará el correspondiente mensaje de estado. En este caso, la ejecución principal,
incluido el posicionamiento aproximado, continuarán hasta que sea posible una selección
de paso.
El interpretador se reinicia cuando finaliza el paso de movimiento. Los pasos de
movimiento que fueron planeados en el avance se borran de la memoria intermedia.
1 DEF Sub1() 1 DEF TEST()
2 PTP P2 2 PTP HOME
=> 3 PTP P3 Ejecución principal 3 PTP P1
4 PTP P4 4 SUB1()
5 PTP P5 5 PTP P6
6 END => 6 PTP P7 Avance
7 END
El puntero principal se encuentra en el subprograma “SUB1()”; el puntero adelantado está
en el programa principal, en “TEST()”. Si en ese momento se cambia el modo de ejecución
del programa a “...STEP”, se visualizará unmensaje deestado. Sólo después deque el pun-
tero principal llega al punto “P6” del programa principal se efectúa una selección de paso
en el siguiente paso de movimiento. A continuación, el mensaje de estado se borra y el sis-
tema pasa al modo de ejecución de programa “#...STEP”.
Programación por el experto
22 de 197 ProgExperteBHR5.2 09.03.01 es
Caso especial de interrupción:
1 DEF Interrupt()
2 INT I
3 INTERRUPT DECLARE 5 WHEN $IN[10]==TRUE DO POSITION()
4 PTP HOME
5 PTP P1
=> 6 LIN P2 Ejecución principal
7 INTERRUPT ON
8 LIN P3
9 INTERRUPT OFF
10 PTP P4
11 END
12
13 DEF POSITION()
14 $OUT[12]=TRUE
=> 15 BRAKE Avance
16 $OUT[52]=FALSE
16 END
Al cambiar el modo de ejecución del programa, el puntero adelantado se encuentra dentro
de un subprograma de interrupción. En este caso, el avance ejecuta el subprograma de
interrupción paso por paso en el modo de ejecución de programa “#...STEP” antes de que
continúe la ejecución principal.
Caso especial de instrucción CIRC:
El paso de movimiento CIRC actual finaliza antes pasar al modo de ejecución de programa
“#...STEP”.
1 Generalidades sobre los programas KRL (continuación)
23 de 197ProgExperteBHR5.2 09.03.01 es
1.6 Tratamiento de errores
Si se produce un error al compilar o al vincular, en la ventana de mensajes aparece un
mensaje de error y en el navegador se marca el fichero donde está el error.
Un ejemplo sería el fichero
“ERROR.SRC”, que fue creado (con
errores):
Una vez cerrado el editor, aparece en la ventana de mensajes una indicación acerca de la
cantidad de errores.
Al mismo tiempo, durante este proceso, los ficheros afectados son marcados con una cruz
roja.
Las teclas de softkey disponibles son las siguientes:
BorrarEditar DATAbrirEditar ERRNuevo
La tecla del softkey “Abrir” carga el fichero en el editor; al pulsar la tecla del softkey “Editar
DAT” seabre conel editor el fichero deextensiónDat. Si deseaborrar los ficheros quecontie-
nen errores, pulse “Borrar”. Con la opción “Nuevo” podrá crear un nuevo fichero.
Nombre del fichero
Descripción breve
Número de fallo
Número de línea y columna
erróneas
Línea errónea del texto
fuente
Descripción del fallo
*1
Editar ERR
Con ello, la barra de teclas de softkey cambia:
ActualizaEditor Cerrar
Programación por el experto
24 de 197 ProgExperteBHR5.2 09.03.01 es
INDICACIÓN *1
Los números de línea indicados corresponden a los números absolutos de línea
en el programa, del mismo modo que se visualizarían en un editor ASCII normal.
Para que los números de línea de la indicación de fallos concuerden con los
números de línea en el KCP, todas las folds deben estar abiertas y la visualiza-
ción de detalles y la línea DEF deben estar activas. No obstante, esta forma de
visualización es algo confusa, ya que ofrece toda la información aunque no sea
necesaria. Encontrará más información sobre la visualización de detalles y la
línea DEF en el apartado [Esconder partes de un programa].
En la indicación de fallos se puede observar que han aparecido los siguientes fallos:
G 3 líneas en el fichero SRC contienen errores;
G los números de línea con errores son 24, 25 y 28;
G en la línea 24, los números de error
-- 2263: tipo de variable de bucle diferente a INT
G en la línea 25 el número de error
-- 2249: expresión diferente a INT
G en la línea 28 el mensaje de error
-- 2309: se espera el signo “(”
De los mensajes de error “2263” se puede deducir de inmediato que la variable I no fue de-
clarada como entera. El mensaje de error 2249 también es resultado de la ausencia de esa
declaración, ya que en un bucle de conteo el contador siempre debe ser del tipo INT. Elmen-
saje “2309” significa: el compilador interpreta la línea como una llamada de subprograma
en la que sin embargo faltan los paréntesis.
El significado de los números de error también se
puede visualizar en línea mediante la función de
menú “Variable” > ”Únicos”. Para ello, indique en
la ventana de estado, en el campo de entrada
“Nombre” el signo “&” seguido del número de
error. En este caso, sería por ejemplo “&2263” y
se pulsaría la tecla de entrada.
[Indicación > Variable > Únicos]
Si ahora carga en el editor el fichero SRC (en este caso, “ERROR.SRC”), puede efectuar
las correcciones correspondientes. Para facilitar esta labor, el cursor se coloca, parpa-
deando, sobre la primera línea errónea. Compruebe que está desactivada la visibilidad limi-
tada y que puede verse la línea DEF. Encontrará información más detallada en el apartado
[Esconder partes de un programa].
En el siguiente ejemplo no es necesario abrir las folds. No obstante, si se desea hacerlo,
utilice la instrucción de menú “Procesar > FOLD > Abrir todas FOLD”.
La línea “INT I” que faltaba en el programa creado originalmente debe ser insertada de-
lante de la línea “INI”. Esto sólo es posible cuando puede verse la línea “DEF ERROR
( )”.
1 Generalidades sobre los programas KRL (continuación)
25 de 197ProgExperteBHR5.2 09.03.01 es
Así pues, en el ejemplo de la página 23, agregue la línea
INT I
delante de la línea INI y tache uno de los signos de igualdad dobles.
I = I + 1
Insertar esta línea aquí
Eliminar un signo de
igualdad
Después de haber cerrado el editor y memorizado el fichero corregido, en la lista de fallos
(Error de listado) puedepulsar la tecla del softkey “Actualiza” y la lista de fallos desaparecerá
cuando se hayan corregido todos los fallos.
Programación por el experto
26 de 197 ProgExperteBHR5.2 09.03.01 es
1.7 Comentarios
Los comentarios son un componente importante de cualquier programa informático. Con
ellos puede clarificar la estructura de un programa y hacer que otros puedan comprenderla.
Los comentarios no influyen en la velocidad de procesamiento del programa.
Los comentarios se pueden colocar en cualquier parte de un programa. Siempre comienzan
con un punto y coma “;”, por ej.:
…
PTP P1 ;Desplazamiento al punto departida
…
;--- Reiniciar salidas ---
FOR I = 1 TO 16
$OUT[I] = FALSE
ENDFOR
…
2 Variables y declaraciones
27 de 197ProgExperteBHR5.2 09.03.01 es
2 Variables y declaraciones
2.1 Variables y nombres
Junto al uso de constantes, es decir, la indicación directa del valor en forma de números,
caracteres, etc., en KRL también pueden utilizarse dentro del programa variables y otras
formas de datos.
En la programación de robots industriales, las variables son necesarias, por ejemplo, para
el procesamiento del sensor. Con ellas, el valor leído por el sensor se puede memorizar y
evaluar en diferentes lugares del programa. Además, se pueden efectuar operaciones arit-
méticas para calcular, por ejemplo, una nueva posición.
En el programa, una variable se representa por medio de un nombre que se puede elegir
libremente dentro de unos determinados límites.
Nombres en KRL
S pueden tener una longitud máxima de 24 caracteres
S pueden contener letras (A--Z), cifras (0--9) y los caracteres ’_’ y ’$’
S no deben comenzar con cifras
S no deben ser palabras clave
Puesto que todas las variables del sistema (véase el apartado 2.4) comienzan con ’$’,
no se debe utilizar este signo como primer carácter en los nombres definidos por el
propio usuario.
Nombres válidos en KRL son, por ejemplo:
SENSOR_1
BOQUILLA13
P1_HASTA_P12
Una variable se debe considerar como un área dememoria fija, a cuyo contenido puede ac-
cederse a través del nombre de variable. Por ello, la variable se crea para el tiempo quedura
el procesamiento del programa mediante una posición de memoria (lugar) y un contenido
de memoria (valor).
Asignación de valor:
Los valores se asignan a las variables mediante el signo de igualdad (=). La instrucción
CANTIDAD = 5
significa por tanto queen el área dememoria se registra, con la direcciónCANTIDAD, el valor
5. Al programador no le interesa la apariencia exacta de la dirección, por lo que el compilador
la asigna de manera independiente. Lo único que importa es que en el programa se pueda
acceder en todo momento al contenido de memoria por medio de su nombre.
Dado que cada objeto de datos (véase el apartado 2.2) necesita su propia cantidad de me-
moria, el tipo dedatos deunavariable debe ser acordado (declarado) antes de su uso (véase
el apartado 2.2.1).
Programación por el experto
28 de 197 ProgExperteBHR5.2 09.03.01 es
Duración:
La duración de una variable es el tiempo durante el cual dicha variable tiene asignada una
posición de memoria. Este tiempo depende de si la variable está declarada en un archivo
SRC o en una lista de datos:
G Variable declarada en un archivo SRC
La duración se limita al tiempo de funcionamiento del programa. Una vez finalizado el
procesamiento, el área de memoria vuelve a quedar libre. Por lo tanto, el valor de la
variable se pierde.
G Variable declarada en una lista de datos (véase el capítulo Listas de datos)
La duración no depende del tiempo de procesamiento del programa. La variable existe
mientras exista la lista dedatos. Dichas variables son, por lo tanto, permanentes (hasta
la próxima conexión / desconexión).
2 Variables y declaraciones (continuación)
29 de 197ProgExperteBHR5.2 09.03.01 es
2.2 Objetos de datos
Objetos de datos son aquellas unidades de memoria de un determinado tipo de datos que
pueden recibir un nombre. Las unidades dememoria pueden constar de muchas células de
memoria diferentes (bytes, palabras, etc.). Si el programador acuerda un objeto de datos
de este tipo con un nombre, se obtiene una variable. A partir de ese momento, la variable
ocupa una o varias células de memoria en las que el programa puede grabar y leer datos.
Gracias a la posibilidad de denominar simbólicamente las células de memoria con nombres
libremente seleccionables, la programación resultamás fácil y clara, y el programa sepuede
leer con mayor facilidad.
El siguiente ejemplo sirve para clarificar el término “tipo de datos”: en una célula dememoria
con 8 bits se encuentra la combinación de bits
00110101
¿Cómo debe interpretarse esta combinación de bits? ¿Se trata de la representación binaria
del número 53 o del carácter ASCII “5” (que se representa con el mismo patrón de bits)?
Tipo de datos:
Para poder dar una respuesta inequívoca a esta cuestión, falta todavía una información im-
portante: eltipo de datos de unobjeto dedatos. Enel casoanterior, podría tratarse, por ejem-
plo, del tipo “número entero” (INTEGER) o “carácter” (CHARACTER).
Además de por estas razones (de naturaleza computacional), el uso de tipos de datos se
justifica por lo cómodo que resulta para el usuario, ya que le permite trabajar exactamente
con aquellos tipos que son idóneos para su aplicación en particular.
2.2.1 Declaración e inicialización de objetos de datos
DECL:
La asignación de un nombre de variable a un tipo de datos y la reserva de la posición de
memoria se efectúan en KRL por medio de la declaración DECL. Con
DECL INT CANTIDAD,NUMERO
se declaran, por ejemplo, dos variables CANTIDAD y NUMERO del tipo de datos “número
entero” (integer).
De este modo, el compilador conoce estas dos variables y el tipo de datos correspondiente,
y utilizando las variables puede comprobar si este tipo dedatos permite efectuar laoperación
deseada.
Tal como muestra el ejemplo, la declaración comienza con la palabra clave DECL, seguida
por el tipo de datos y la lista de variables que deben contenerlo.
Para declarar variables y campos de un tipo de datos predefinido, se puede omitir la
palabra clave DECL. Junto a los tipos de datos simples INT, REAL, CHAR y BOOL
(véase el apartado 2.2.2) se encuentran predefinidos, entre otros, los tipos de datos de
estructura POS, E6POS, FRAME, AXIS y E6AXIS (véase el apartado 2.2.5).
En las variables (¡no los campos!) con datos del tipo POS, se puede omitir toda la de-
claración. El tipo de datos POS se considera el tipo estándar para variables.
La palabra clave DECL es imprescindible para poder declarar los tipos de estructura o
los de enumeración libremente definibles (véanse los apartados 2.2.5 y 2.2.6).
Inicialización:
Una vez declarada una variable, su valor se define inicialmente como no válido, ya que de
lo contrario este valor dependería de la ocupaciónaleatoria de lamemoria. Para poder traba-
jar con la variable, es necesario asignarle previamente un determinado valor. Esta primera
asignación de un valor a una variable se denomina inicialización.
Para crear nuevos archivos con la tecla del softkey “Nuevo”, en la superficie de opera-
ción KUKA también se genera automáticamente una secuencia INI. La declaración de
variables siempre debe efectuarse antes de esta secuencia.
Programación por el experto
30 de 197 ProgExperteBHR5.2 09.03.01 es
La asignación de un valor a una variable es una instrucción y, por ello, no puede efectuarse
en la sección de declaraciones. No obstante, en la sección de instrucciones la inicialización
sepuede realizar en cualquiermomento. Sin embargo, todas las variables declaradas deben
ser convenientemente inicializadas en una sección de inicialización directamente después
de la sección de declaración (véase Fig. 8).
Solamente en las listas de datos está permitido inicializar variables directamente en la línea
de declaración.
DEF NAME()
;---- Sección de declaraciones----
…
;---- Sección de inicialización ----
…
;---- Sección de instrucciones ----
…
END
Fig. 8 Estructura básica de un programa del robot
Encontrará más información en el capítulo [Listas de datos].
2.2.2 Tipos de datos simples
Tipos de datos simples son ciertos tipos de datos básicos que existen en la mayoría de len-
guajes deprogramación. Al contrario que los tipos dedatos estructurados (véaseelapartado
2.2.3--2.2.6), los tipos de datos simples contienen un único valor. Los tipos de datos conoci-
dos en KRL aparecen en una lista juntocon su rango de valores correspondiente en Tab. 1.
Tipo de datos Entero Real Booleano Carácter
Palabra clave INT REAL BOOL CHAR
Significado Número entero Número con
coma flotante
Estado lógico 1 carácter
Rango de
valores
-231…231-1 ±1.1E-38…
±3.4E+38
TRUE, FALSE Carácter ASCII
Tab. 1 Tipo de datos simple
2 Variables y declaraciones (continuación)
31 de 197ProgExperteBHR5.2 09.03.01 es
INT:
El tipo dedatos Integer (número entero) constituye unaparte de la cantidad total denúmeros
enteros. Solamente es posiblemanejar una parte porque ningúnordenador puede visualizar
todos los números enteros, cuya cantidad es en teoría infinita. Los 32 bits previstos para los
tipos enteros en el KR C... proporcionan por tanto 231 números enteros más el signo corres-
pondiente. El número 0 es considerado parte de los números positivos.
Con
NÚMERO = -23456
se asigna a la variable NÚMERO el valor -23456.
Si a una variable INTEGER se le asigna un valor REAL, el valor se redondea según las nor-
mas generales (x.0 hasta x.49 redondeado hacia abajo, x.5 hasta x.99 redondeado hacia
arriba). A través de la instrucción
NÚMERO = 45,78
la variable INTEGER NÚMERO recibe el valor 46.
Excepción: en la división de enteros, se corta la posición decimal, por ejemplo: 7/4 = 1
Sistema binario/hexadecimal:
Mientras que el ser humano calcula y piensa en el sistema decimal, un ordenador solamente
reconoce unos y ceros que representan los estados “activo” e “inactivo”. Un estado (activo
o inactivo) se representa por tanto mediante un bit. Por motivos de velocidad, en general el
ordenador accede a un paquete completo de estos ceros y unos. El tamaño típico de un pa-
quete son 8 bits (=1 byte), 16 bits o 32 bits. Por ello, en las operaciones propias de la má-
quina, a menudo resulta útil el uso del sistema binario (sistema de 2 dígitos: cifras 0 y 1) o
del sistema hexadecimal (sistema de 16 dígitos: cifras 0--9 y A--F). Los valores enteros bina-
rios o hexadecimales pueden indicarse en KRL mediante las comillas simples (’) y una B,
para la representación binaria, o una H, para la hexadecimal.
D 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
H 0 1 2 3 4 5 6 7 8 9 A B C D E F 10
Tab. 2 Los primeros 17 números de los sistemas decimal y hexadecimal
El número 90 se puede por tanto asignar en KRL a tres diferentes tipos de variable entera:
NUMENT = 90 ;Sistema decimal
NUMENT = ’B1011010’ ;Sistema binario
NUMENT = ’H5A’ ;Sistema hexadecimal
Bin→Dec:
La conversión de los números binarios al sistema decimal se realiza del modo siguiente:
1 0 1 1 0 1 0
= 1S26+0S25+1S24+1S23+0S22+1S21+0S20= 90
26 25 24 23 22 21 20
= 1S26+0S25+1S24+1S23+0S22+1S21+0S20= 90
Hex→ Dec:
Para transferir los números desde el sistema hexadecimal al sistema decimal, proceda del
modo siguiente:
5 A
=5S161+10S160=90
161 160
=5S161+10S160=90
Programación por el experto
32 de 197 ProgExperteBHR5.2 09.03.01 es
REAL:
La coma flotante significa la división de un número enmantisa y exponente, y su representa-
ción de forma normalizada. Así se representa, por ejemplo:
5.3 como 0.53000000 E+01
-100 como -0.10000000 E+03
0.0513 como 0.51300000 E-01
Al calcular con valores reales, debido a la cantidad limitada de posiciones de coma flotante
y a la inexactitud que eso conlleva, es preciso recordar que las leyes algebraicas habituales
dejan de ser válidas para todos los casos. Así, por ejemplo, en el álgebra vale:
1
3
× 3 = 1
Si se deja realizar este cálculo a un ordenador, puede obtenerse un resultado de sólo
0.99999999 E+00. Una comparación lógica de este número con el número 1 daría como
resultado el valor FALSE. Sin embargo, para las aplicaciones prácticas en el campo de los
robots, suele ser suficiente esta exactitud si se tiene en cuenta que la prueba lógica de igual-
dad para magnitudes reales sólo se puede realizar adecuadamente dentro de un pequeño
rango de tolerancia.
Algunas asignaciones admisibles en variables reales son, por ejemplo:
NUMREAL1 = -13.653
NUMREAL2 = 10
NUMREAL3 = 34.56 E-12
Si a una variable REAL se le asigna un valor ENTERO (INTEGER), se efectúa una
conversión automática de tipo según REAL. La variable NUMREAL2 tiene por tanto, según
esta asignación, el valor 10.0.
BOOL:
Las variables booleanas sirven para describir estados lógicos (por ejemplo,
entradas/salidas). Solamente pueden asumir los valores TRUE (verdadero) y FALSE
(falso):
ESTADO1 = TRUE
ESTADO2 = FALSE
CHAR:
Las variables de carácter pueden representar exactamente 1 carácter del juego de caracte-
res ASCII. Para poder asignar un carácter ASCII a una variable CHAR, el carácter asignado
debe estar entre comillas (”):
CARACTER1 = “G”
CARACTER2 = “?”
Respecto a la memorización de todas las series de caracteres, consulte el apartado 2.2.4.
2 Variables y declaraciones (continuación)
33 de 197ProgExperteBHR5.2 09.03.01 es
2.2.3 Campos
Se conocen como campos aquellos agrupamientos de objetos de un mismo tipo de datos
que formanunobjeto dedatos. A los componentes individuales deun campose puedeacce-
der a través de índices. Mediante la declaración
DECL INT OTTO[7]
Índice de campo:
puede poner, por ejemplo, 7 números enteros diferentes en el campo OTTO[]. A cada com-
ponente individual del campo se puede acceder indicando el correspondiente índice (el pri-
mer índice es siempre el 1):
OTTO[1] = 5 ; al 1˚ elemento se le asigna el número 5
OTTO[2] = 10 ; al 2˚ elemento se le asigna el número 10
OTTO[3] = 15 ; al 3˚ elemento se le asigna el número 15
OTTO[4] = 20 ; al 4˚ elemento se le asigna el número 20
OTTO[5] = 25 ; al 5˚ elemento se le asigna el número 25
OTTO[6] = 30 ; al 6˚ elemento se le asigna el número 30
OTTO[7] = 35 ; al 7˚ elemento se le asigna el número 35
De manera gráfica, cabe imaginarse el campo con el nombre OTTO[] como una estantería
con 7 compartimentos. De acuerdo con las asignaciones anteriores, la ocupación de los
compartimentos ofrecería el siguiente aspecto:
5 10 15 20 25 30 35
[1] [2] [3] [4] [5] [6] [7]OTTO
Fig. 9 Representación de un campo unidimensional
Si es preciso inicializar todos los elementos de un campo con el mismo número, por ejemplo
el 0, no es necesario programar explícitamente cada asignación, sino que se puede “auto-
matizar” la preasignación por medio de un bucle y de una variable de conteo:
FOR I = 1 TO 7
OTTO[I] = 0
ENDFOR
Encontrará más información en el capítulo [Control de ejecución del programa],
apartado [Bucles].
La variable de conteo es en este caso la variable entera I. Ésta debe haber sido declarada
antes de ser utilizada como número entero.
S El tipo de datos de un campo es opcional. De este modo, cada uno de los elemen-
tos puede constar a su vez de una composición de tipos de datos (por ejemplo: un
campo compuesto de campos)
S Para el índice sólo se permite utilizar tipos de datos enteros
S Además de las constantes y variables, para el índice también se permite utilizar ex-
presiones aritméticas (véase el apartado 2.3.1)
S El índice siempre empieza a contar a partir de 1
Programación por el experto
34 de 197 ProgExperteBHR5.2 09.03.01 es
Bidimensional:
Además de los campos unidimensionales tratados hasta ahora (es decir, los campos con
un solo índice), en KRL pueden utilizarse también campos bidimensionales o
tridimensionales. Con
DECL REAL MATRIX[5,4]
se declara un campo bidimensional 5×4 con 5×4=20 elementos del tipo REAL. Gráfica-
mente, este campo puede representarse como una matriz con 5 columnas y 4 filas. Con la
secuencia de programa
I[3] = 0
FOR COLUMNA = 1 TO 5
FOR FILA = 1 TO 4
I[3] = I[3] + 1
MATRIX[COLUMNA,FILA] = I[3]
ENDFOR
ENDFOR
los elementos de la matriz reciben un valor que corresponde con el orden de su asignación.
Así pues, la ocupación de matriz obtenida es la siguiente:
Fila 3
3
Fila 2
Fila 1Plano 1
Fila 4
1
2
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
C
ol
um
na
2
C
ol
um
na
3
C
ol
um
na
4
C
ol
um
na
5C
ol
um
na
1
Fig. 10 Representación de un campo bidimensional
Tridimensional:
Al fin y al cabo, cabe imaginarse los campos tridimensionales comovariasmatrices bidimen-
sionales dispuestas una tras otra. La tercera dimensión indica, por así decirlo, el plano en
el que se encuentra la matriz (véase Fig. 11). Un campo tridimensional se declara de forma
análoga a los campos unidimensionales o bidimensionales, por ejemplo:
DECL BOOL FELD_3D[3,5,4]
La secuencia de inicialización podría tener el siguiente aspecto:
FOR PLANO = 1 TO 3
FOR COLUMNA = 1 TO 5
FOR FILA = 1 TO 4
CAMPO_3D[PLANO,COLUMNA,FILA] = FALSE
ENDFOR
ENDFOR
ENDFOR
2 Variables y declaraciones (continuación)
35 de 197ProgExperteBHR5.2 09.03.01 es
Fila 3
3
Fila 2
Fila 1
Plano 3
Plano 2
Plano 1
Fila 4
1
2
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
25
26
29
30
33
34
35
36
37
38
39
40
41
42
45
46
49
50
53
54
55
56
57
58
59
60
C
ol
um
na
2
C
ol
um
na
3
C
ol
um
na
4
C
ol
um
na
5C
ol
um
na
1
Fig. 11 Representación de un campo tridimensional
Programación por el experto
36 de 197 ProgExperteBHR5.2 09.03.01 es
2.2.4 Cadenas de caracteres
Tal como se describe anteriormente, el tipo de datos CHAR sólo permite guardar caracteres
individuales. Para utilizar cadenas de caracteres completas, por ejemplo palabras, basta
con definir un campo unidimensional del tipo CHAR:
DECL CHAR NAME[8]
Como viene siendo habitual, se puede acceder a cada uno de los elementos del campo
NAME[], por ejemplo:
NAME[3] = “G”
G
También se pueden introducir cadenas de caracteres completas:
NAME[] = “ABCDEFG”
ocupa los siete primeros elementos del campo NAME[] con las letras A, B, C, D, E,
F y G:
A B C D E F G
2.2.5 Estructuras
STRUC:
Si es necesario agrupar diferentes tipos de datos, el campono es apropiado, por lo quedebe
recurrirse a la forma general de composición. Con la instrucción de declaración STRUC pue-
den agruparse diferentes tipos de datos definidos previamente (o tipos de datos predefini-
dos) en un nuevo tipo de datos compuesto. En especial, las composiciones y los campos
pueden ser parte de otras composiciones.
Un ejemplo típico del uso de composiciones es el tipo de datos estándar POS. Este tipo
consta de 6 valores REAL y 2 valores INT, y fue definido en el archivo $OPERATE.SRC de
la siguiente manera:
STRUC POS REAL X, Y, Z, A, B, C, INT S, T
Punto separador:
Si ahora se utiliza por ejemplo una variable POSICIÓN del tipo de datos de estructura POS,
se pueden ocupar los elementos individualmente mediante el punto separador, por ejemplo:
POSICION.X = 34.4
POSICION.Y = -23.2
POSICION.Z = 100.0
POSICION.A = 90
POSICION.B = 29.5
POSICION.C = 3.5
POSICION.S = 2
POSICION.T = 6
o conjuntamente por medio de lo que se conoce como agregado
POSICION={X 34.4,Y -23.2,Z 100.0,A 90,B 29.5,C 3.5,S 2,T 6}
Encontrarámás informaciónenel capítulo [Variablesydeclaraciones], apartado [Decla-
ración e inicialización de objetos de datos].
2 Variables y declaraciones (continuación)
37 de 197ProgExperteBHR5.2 09.03.01 es
Los agregados se rigen por las siguientes normas:
S Los valores de un agregado pueden ser constantes simples o incluso agregados.
S En un agregado no es necesario indicar todos los componentes de la estructura.
S Los componentes no necesitan indicarse en el orden en que fueron definidos.
S Cada componente debe estar incluido en un agregado una sola vez.
S En los campos de estructuras, un agregado describe el valor de un elemento de
campo individual.
S Al comienzo de un agregado puede estar indicado el nombre del tipo de estructura
(separado por un signo de dos puntos).
Así pues, las variables POS también admiten, por ejemplo, las siguientes asignaciones:
POSICION={B 100.0,X 29.5,T 6}
POSICION={A 54.6,B -125.64,C 245.6}
POSICION={POS: X 230,Y 0.0,Z 342.5}
En las estructuras POS, E6POS, AXIS, E6AXIS y FRAME los componentes que faltan
no sufren ningún cambio. En todos los demás agregados, los componentes inexi-
stentes se definen como no válidos.
El siguiente ejemplo explica el procedimiento de creación de algunas variables de estruc-
tura:
En un subprograma de soldadura al arco, es necesario transferir a una variable S_PARA la
siguiente información:
REAL V_HILO Velocidad del hilo
INT CARACT Línea característica 0…100%
BOOL ARCO con/sin arco (para simulación)
La variable S_PARA debe constar de 3 elementos correspondientes a diferentes tipos de da-
tos. En primer lugar, se debe definir un nuevo tipo de datos que cumpla estos requisitos:
STRUC TIPOSOLD REAL V_HILO, INT CARACT, BOOL ARCO
De este modo, se ha creado un nuevo tipo de datos con la denominación TIPOSOLD (TI-
POSOLD no es ninguna variable). TIPOSOLD consta de 3 componentes: V_HILO, CA-
RACT y ARCO. A continuación, puede declararse una variable opcional del nuevo tipo de
datos, por ejemplo:
DECL TIPOSOLD S_PARA
De este modo, se ha creado una variable S_PARA del tipo de datos TIPOSOLD. Tal como
sehadescrito, a los elementos individuales sepuedeacceder pormediodel puntoseparador
o del agregado:
S_PARA.V_HILO = 10.2
S_PARA.CARACT = 66
S_PARA.ARCO = TRUE
o
S_PARA = {V_HILO 10.2,CARACT 50, ARCO TRUE}
Para poder diferenciar mejor los tipos de datos autodefinidos de las variables, los nom-
bres de los nuevos tipos de datos deben terminar con…TIPO.
En el archivo $OPERATE.SRC se encuentran predefinidas las estructuras siguientes:
STRUC AXIS REAL A1,A2,A3,A4,A5,A6
STRUC E6AXIS REAL A1,A2,A3,A4,A5,A6,E1,E2,E3,E4,E5,E6
STRUC FRAME REAL X,Y,Z,A,B,C
STRUC POS REAL X,Y,Z,A,B,C, INT S,T
STRUC E6POS REAL X,Y,Z,A,B,C,E1,E2,E3,E4,E5,E6, INT S,T
Programación por el experto
38 de 197 ProgExperteBHR5.2 09.03.01 es
Los componentes A1…A6 de la estructura AXIS son valores angulares (ejes rotatorios) o
valores de translación (ejes translatorios) para el desplazamiento específico de los ejes del
robot 1…6.
Con los componentes adicionales E1…E6 en la estructura E6AXIS se puede acceder a los
ejes adicionales.
En la estructura FRAME se pueden especificar 3 valores de posición en el espacio (X,Y y Z)
así como 3 orientaciones en el espacio (A, B y C). De este modo, un punto en el espacio
queda definido unívocamente por su posición y por su orientación.
Dado que existen robots que pueden desplazarse hasta un mismo punto en el espacio con
varias posiciones de eje, las variables enteras S y Tde la estructura POS sirven paradetermi-
nar una posición unívoca del eje.
Encontrará más información en el capítulo [Programación de movimiento], apartado
[Instrucciones de movimiento] Status (S) y Turn (T).
Con los componentes E1…E6 de la estructura E6POS, se puede acceder de nuevo a los
ejes adicionales.
Tipos de datos geométricos:
Los tipos AXIS, E6AXIS, POS, E6POS y FRAME también se conocen como tipos de datos
geométricos, ya que con ellos el programador puede describir con facilidad relaciones geo-
métricas.
Encontrará más información en el capítulo [Programación de movimiento], apartado
[Utilización de diferentes sistemas de coordenadas].
2 Variables y declaraciones (continuación)
39 de 197ProgExperteBHR5.2 09.03.01 es
2.2.6 Tipos de enumeración
Un tipo de datos de enumeración es un tipo de datos que se compone de una cantidad limi-
tada de constantes. Las constantes son nombres libremente definibles y pueden ser especi-
ficadas por el usuario. Una variable de este tipo (variable de enumeración) solamente puede
aceptar el valor