Programación de robots KUKA

Training

Programación de robots 2 KUKA System Software 8 Documentación para la formación

Pro g ramació n d e ro b o t s 2

Edición: 24.02.2015 Versión: P2KSS8_robotprogramming_2_(R2)_V4

KUKA Roboter GmbH

Programación de robots 2

© Copyright 2015 KUKA Roboter GmbH Zugspitzstraße 140 D-86165 Augsburg Alemania La reproducción de esta documentación – o parte de ella – o su facilitación a terceros solamente está permitida con expresa autorización del KUKA Roboter GmbH. 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, de modo 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 la edición siguiente. Reservados los derechos a modificaciones técnicas que no tengan influencia en el funcionamiento. Traducción de la documentación srcinal KIM-PS5-DOC

Publicación: Estructura de libro: Versión:

2 / 255

Pub COLLEGE P2KSS8 Roboterprogrammierung 2 (R2) (PDF-COL) es P2KSS8 Roboterprogrammierung 2 (R2) V2.2 P2KSS8_robotprogramming_2_(R2)_V4


Índice

Índice 1

Programar c on WorkVisual ........................................................................

1.1 Resumen .................................................................................................................... 1.2 Gestionar el proyecto con WorkVisual ....................................................................... 1.2.1 Enlace de un PC con WorkVisual a una unidad de control .................................. 1.2.2 Vista general de la interfaz de usuario WorkVisual .............................................. 1.2.3 Cargar el proyecto existente en WorkVisual ......................................................... 1.2.4 Guardar proyecto WorkVisual en local ................................................................. 1.2.5 Modos de WorkVisual ........................................................................................... 1.2.6 Estructura del proyecto WorkVisual (pestaña Ficheros) ....................................... 1.2.7 Comparar proyectos con WorkVisual ................................................................... 1.2.8 Transmitir el proyecto a la unidad de control del robot (instalar) .......................... 1.2.9 Asignar el proyecto a la unidad de control del robot real ...................................... 1.2.10 Activar el proyecto en la unidad de control del robot ............................................ 1.3 Editar programas KRL con WorkVisual ..................................................................... 1.3.1 Manipulación del fichero ....................................................................................... 1.3.2 Activar el catálogo Plantillas . ............................................................................... 1.3.3 Manejo del editor KRL .......................................................................................... 1.4 Ejercicio: Editar un proyecto activo en WorkVisual ....................................................

7 7 7 7 8 10 12 12 13 14 18 28 32 35 35 39 41 54

2

Programación estructurada........................................................................

57

2.1 2.2 2.3

Resumen .................................................................................................................... Objetivo de la metodología de programación uniforme ............................................. Elementos auxiliares para la creación de programas de robot estructurados . ..........

57 57 57

2.4

Cómo crear un plan de ejecución del programa ........................................................

62

3

Introducción al nivel del experto ...............................................................

65

3.1 3.2 3.3 3.4

Resumen .................................................................................................................... Utilizar el nivel experto ............................................................................................... Ejercicio: Medición Tool y Base ................................................................................. Ejercicio: Navegador experto bucle sinfín ..................................................................

65 65 68 73

4

Variables y declaraciones ...........................................................................

75

4.1 Resumen .................................................................................................................... 4.2 Gestión de datos en KRL ........................................................................................... 4.3 Trabajar con tipos de datos simples .......................................................................... 4.3.1 Declaración de variables ...................................................................................... 4.3.2 Inicialización de variables con tipos de datos simples .......................................... 4.3.3 Manipulación de valores de variables de tipos de datos simples con KRL . .........

75 75 78 78 80 82

4.4 4.5 4.6 4.7 4.8 4.9 4.10

Visualizar variables.................................................................................................... Grupos / campos con KRL ......................................................................................... Ejercicio: Campos con tipos de datos simples y bucle de conteo ............................. Crear estructuras con KRL ........................................................................................ Ejercicio: Crear estructuras con KRL ......................................................................... El tipo de datos de enumeración ENUM .................................................................... Ejercicio: Crear un tipo de enumeración con KRL .....................................................

86 87 91 93 96 98 100

5

Subprogramas y funciones ........................................................................

101

5.1

Resumen ....................................................................................................................


101 3 / 255


4 / 255

5.2 5.3 5.4 5.5 5.6 5.7

Trabajo con subprogramas locales ........................................................................... Trabajo con subprogramas globales ......................................................................... Transmitir parámetros a subprogramas ................................................................... Ejercicio: Subprogramas con transferencia de parámetros ....................................... Programación de funciones....................................................................................... Trabajar con funciones estándar de KUKA ...............................................................

101 103 105 109 111 113

6

Programación de un mensaje con KRL .....................................................

115

6.1 6.2 6.3 6.4 6.5 6.6 6.7 6.8 6.9 6.10 6.11 6.12 6.13 6.14 6.15 6.16

Resumen ................................................................................................................... Información general sobre los mensajes definidos por el usuario ............................. Variables y estructuras para mensajes definidos por el usuario ............................... Funciones para mensajes definifos por el us uario .................................................... Trabajos con un mensaje de observación ................................................................ Ejercicio: Programar un mensaje de observación ..................................................... Trabajos con un mensaje de estado ......................................................................... Ejercicio: Programar un mensaje de estado .............................................................. Trabajos con un mensaje de acuse de recibo ........................................................... Ejercicio: Programar mensajes de acuse de recibo . ................................................ Trabajos con un mensaje de espera ......................................................................... Ejercicio: Programar mensajes de espera ................................................................. Variables y estructuras adicionales para diálogos .................................................... Funciones para diálogos........................................................................................... Trabajos con un diálogo............................................................................................ Ejercicio: Programar un diálogo ................................................................................

115 115 116 119 121 123 124 126 127 129 130 132 133 133 135 139

7

Programación d e m ovimientos c on K RL ..................................................

141

7.1 Vista general .............................................................................................................. 7.2 Programar movimientos individuales SPLINE mediante KRL ................................... 7.3 Movimiento de conjunto individual con SPTP ........................................................... 7.4 Movimiento de paso individual con SLIN y SCIRC ... ................................................. 7.5 Parámetros de m ovimiento........................................................................................ 7.5.1 SCIRC: Comportamiento de orientación – eje mplo del punto auxiliar ................. 7.5.2 SCIRC: Comportamiento de o rientación – ejemplo del p unto de destino . ........... 7.5.3 Restricciones en $CIRC_MODE .......................................................................... 7.6 Movimientos individuales SPLINE: Variables del sistema para WITH .. .................... 7.7 Programar movimientos relativos y absolutos con KRL ............................................ 7.8 Calcular o manipular posiciones de robot ................................................................. 7.9 Modificar de forma adecuada bits de Status y Turn .................................................. 7.10 Ejercicio: Paletizado y despaletizado ........................................................................ 7.11 Programación de bloques SPLINE ............................................................................ 7.11.1 Perfil de velocidad para movimientos SPLINE ..................................................... 7.11.2 Selección de paso en caso de movimientos Spline ............................................. 7.11.3 Cambios en bloques Spline .................................................................................. 7.11.4 Sustituir un movimiento CP aproximado por un movimiento Spline ..................... 7.11.5 Transición SLIN-SPL-SLIN ................................................................................... 7.11.6 PROG programación de bloques SPLINE con KRL ............................................. 7.11.7 Bloque SPLINE: Variables del sistema con WITH ...............................................

141 141 141 143 145 150 152 153 154 154 159 161 165 169 170 173 174 177 180 180 183

8

185

Trabajar con variables de sistema .............................................................


Índice

8.1 8.2 8.3

Resumen .................................................................................................................... Medición del tiempo de ciclo mediante temporizador ................................................ Ejercicio: Medición del tiempo ciclo y optimización ...................................................

185 185 187

9

Programación d e i nterrupción ...................................................................

189

9.1 9.2 9.3 9.4 9.5

Resumen .................................................................................................................... Programación de rutinas de interrupción ................................................................... Ejercicio: Trabajos con interrupciones ....................................................................... Frenar el robot y cancelar el movimiento ................................................................... Ejercicio: Cancelar movimientos con interrupciones . ...............................................

189 189 195 197 201

10

Funciones de conmutación con KRL ........................................................

203

11

Interpretador Submit...................................................................................

10.1 10.2 10.3 10.4 10.5 10.6

Resumen .................................................................................................................... Programación de funciones de conmutación sencillas .............................................. Programación del trigger en KRL ............................................................................... Programar una parada condicionada con KRL .......................................................... Programar zona de desplazamiento constante con KRL ........................................... Programar bloque de tiempo Spline ..........................................................................

11.1 Resumen .................................................................................................................... 11.2 Utilización del interpretador Submit ...........................................................................

12

Trabajos con señales analógicas ..............................................................

12.1 Resumen .................................................................................................................... 12.2 Programar entradas analógicas ................................................................................. 12.3 Programar salidas analógicas.................................................................................... 12.4 Ejercicio: Trabajos con E/S analógicas ......................................................................

13

203 203 207 210 213 215

219 219 219

223 223 223 225 229

Anexo ............................................................................................................

231

13.1 Programar los movimientos mediante KRL ............................................................... 13.2 Variables del sistema ................................................................................................. 13.2.1 $ACC .................................................................................................................... 13.2.2 $ACC_AXIS .......................................................................................................... 13.2.3 $ACC_EXTAX ...................................................................................................... 13.2.4 $APO .................................................................................................................... 13.2.5 $BASE .................................................................................................................. 13.2.6 $CIRC_TYPE ........................................................................................................ 13.2.7 Modo de ahorro energético ($ECO_LEVEL) ........................................................ 13.2.8 $GEAR_JERK ...................................................................................................... 13.2.9 $IPO_MODE ......................................................................................................... 13.2.10 $JERK ................................................................................................................... 13.2.11 $LOAD .................................................................................................................. 13.2.12 $ORI_TYPE .......................................................................................................... 13.2.13 $ROTSYS ............................................................................................................. 13.2.14 $SPL_ORI_JOINT_AUTO.................................................................................... 13.2.15 $TOOL .................................................................................................................. 13.2.16 $VEL ..................................................................................................................... 13.2.17 $VEL_AXIS ........................................................................................................... 13.2.18 $VEL_EXTAX .......................................................................................................

231 239 239 240 240 240 242 242 242 243 243 244 244 246 246 246 247 247 247 248


5 / 255


6 / 255

13.2.19 $CIRC_MODE ......................................................................................................

248

Índice ............................................................................................................

253


1 Programar con WorkVisual

1

Programar con WorkVisual

1.1

Resumen Esta unidad incluye los siguientes contenidos:     

   

1.2

Enlace de un PC con WorkVisual a una unidad de control Vista general de las inerfaces de usuario de WorkVisual Cargar los proyectos existentes en WorkVisual Modos de WorkVisual Estructura de proyectos de Workvisual (pestaña Ficheros) Comparar proyectos con WorkVisual Transmitir (instalar) el proyecto a la unidad de control del robot Asignar el proyecto a una unidad de control del robot real Activar el proyecto en la unidad de control del robot

Gestionar el proyecto con WorkVisual Para añadir o modificar programas en un proyecto ya existente de la unidad de control, es necesario seguir los siguientes pasos de trabajo:

Proceso del proyecto 1. Enlazar un PC con WorkVisual a la unidad de control a través de la interfaz KUKA System Interface KSI. (>>> 1.2.1 "Enlace de un PC con WorkVisual a una unidad de control" Página 7) 2. Cargar los pr oyectos existentes en WorkVisual. (>>> 1.2.3 "Cargar el proyecto existente en WorkVisual" Página 10) 3. Activar el modo Programación y configuración en WorkVisual. (>>> 1.2.5 "Modos de WorkVisual" Página 12) 4. Cambiar a la vista Ficheros en la estructura del proyecto de WorkVisual. (>>> 1.2.6 "Estructura del proyecto WorkVisual (pestaña Ficheros)" Página 13) 5. Modificar el proyecto, p. ej. programas KRL (>>> 1.3 "Editar programas KRL con WorkVisual" Página 35) 6. Dado el caso, co mparar proyectos con WorkVisual. (>>> 1.2.7 "Comparar proyectos con WorkVisual" Página 14) 7. Transmitir (instalar) el proyecto a la unidad de control del robot (>>> 1.2.8 "Transmitir el proyecto a la unidad de control del robot (instalar)" Página 18) 8. Asignar el proyecto a una unidad de control del robot real (>>> 1.2.9 "Asignar el proyecto a la unidad de control del robot real" Página 28) 9. Activar el proyecto en la unidad de control del robot (>>> 1.2.10 "Activar el proyecto en la unidad de control del robot" Página 32)

1.2.1

Enlace de un PC con WorkVisual a una unidad de control

Descripción



Para poder intercambiar proyectos con la unidad de control a través del ordenador de WorkVisual, se debe haber establecido una conexión de red.


7 / 255


Hasta la versión de software KSS 8.2 estaba disponible para ello exclusivamente la interfaz KLI - KUKA Line Interface, la cual debía configurarse por separado. Esta interfaz también sigue estando disponible con la KSS 8.3. A partir de la versión de software KSS 8.3 está disponible la nueva interfaz KSI - KUKA Service Interface, que es mucho más fácil de utilizar. Tras actualizar desde la versión KSS 8.2 a la versión KSS 8.3, esta interfaz también se habilita para unidades de control "antiguas".







Conectar el PC con WorkVisual en la KSI

Fig. 1-1: Conexión a la KSI a través del CSP Pos.

Descripción

1 2 3 A

Ordenador portátil con WorkVisual Cabledered ArmariodecontrolKRC4 Conexión KSI detrás de la tapa de CSP

1. El ajuste de red del PC con WorkVisual (1) está configurado en DHCP (instalación automática de una dirección de red). 2. Llevar el cable de red (2) desde el PC con Workvisual (1) hacia la interfaz KUKA Service Interface KSI (A) del armario de control (3). 3. Der La interfaz KUKA Service Interface KSI (A) está situada detrás de la tapa del Control System Panel CSP. El KR C4 asigna automáticamente una dirección IP al PC conectado.

La interfaz KUKA Service Interface KSI no debe conectarse nunca con una red IT ya existente. Esto provoca conflictos de direcciones y funciones erróneas.

1.2.2

Vista general de la interfaz de usuario WorkVisual 



8 / 255

En la interfaz de usuario no están visibles todos los elementos por defecto, sino que se pueden mostrar u ocultar según sea necesario. Aparte de las ventanas y editores mostrados, se dispone de otros. Pueden activarse de diferentes maneras o a través de las opciones de menú Ventanas y Editores.



Fig. 1-2: Resumen de la superficie de operación Pos. 1 2

Descripción Barra de menús Barras de botones

3

Zona de los editores

4 5

Cuando se abre el editor, se visualiza aquí. Tal y como se muestra en el ejemplo, pueden estar abiertos simultáneamente varios editores. Aparecerá uno encima del otro y se podrán seleccionar a través de las pestañas. Botón de ayuda Ventana Estructura del proyecto

6

Ventana Catálogos

7

En esta ventana se muestran todos los catálogos añadidos. Los elementos de los catálogos se pueden añadir en la ventana Estructura del proyecto sobre la pestaña Dispositivo o Geometría. Ventana Zonas de trabajo

8

Ventana Mensajes


9 / 255


Pos. 9

10

1.2.3

Descripción Ventana Propiedades Si se selecciona un objeto se mostrarán sus propiedades en esta ventana. Las propiedades se pueden modificar. No es posible modificar las propiedades de los campos grises. Icono Análisis de proyecto de WorkVisual

Cargar e l pr oyecto e xistente e n Wo rkVisual

Descripción

En cada unidad deun control del robot en la en queWorkVisual. exista una Esto conexión de red se puede seleccionar proyecto y cargarlo también es posible aunque el proyecto no esté en el PC. El proyecto se guarda en el directorio ...\WorkVisual Projects\Downloaded Projects.

Visualización de los proyectos activos en HMI

El proyecto activo se muestra en smartPad mediante el accionamiento del botón de Proyecto.

Fig. 1-3: Proyecto activo antes de la transferencia Explorador de proyecto

Fig. 1-4: Explorador de proyecto 



10 / 255

En Últimos ficheros se muestran los últimos utilizados Ruta: Fichero > Últimos ficheros abiertos (acceso rápido a través de una ventana de selección independiente) Con Crear proyecto se genera:  un proyecto nuevo y vacío un proyecto nuevo a partir de un modelo   un proyecto nuevo basado en un proyecto ya existente Ruta: Fichero > Nuevo


1 Programar con WorkVisual 



Cargar el proyecto WorkVisual de la unidad de control

Con Abrir proyecto se abren los proyectos ya existentes Ruta: Fichero > Abrir proyecto Con Buscar se puede cargar un proyecto de la unidad de control del robot Ruta: Fichero > Buscar proyecto

Procedimiento 1. Seleccionar la secuencia de menú Fichero > Buscar proyecto. Se abre el Explorador de proyecto. A la izquierda está seleccionada la pestaña Buscar. 2. En la zona Celdas disponibles(3), desplegar el nodo de la celda deseada. Se muestran todas las unidades de control del robot de dicha celda. 3. Desplegar nodos de la unidad de control del robot deseada. Se muestran todos los proyectos. 4. Marcar el proyecto deseado y hacer clic en Abrir. El proyecto se abre en WorkVisual.

Fig. 1-5: Buscar dirección IP En ciertos casos puede ser que, a pesar de que haya conexión de red en la ventana Buscar, no se muestre ninguna unidad de control. La ayuda presenta el siguiente procedimiento: 1. 2. 3. 4. 5.

Hacer clic en el botón Lupa (1) del explorador de WorkVisual. Se abre la ventana Find IP Address (buscar dirección IP) (2). Introducir la dirección IP deseada del armario de control. Aceptar la dirección IP con OK (2). A continuación, la unidad de control se muestra en la ventana Celdas disponibles (3).


11 / 255


1.2.4

Guardar proyecto WorkVisual en local

Fig. 1-6: Guardar los proyectos cargados 1. Guardar proyecto en la ruta del menú Fichero > Guardar como. 2. El nombre del archivo mostrado aparece ahora en la barra de título de WorkVisual con un "*"; esto quiere decir que el archivo no se ha guardado en WorkVisual. 3. Definir la ubicación del proyecto en el Explorador mostrado. 4. Especificar el nombre del archivo en la misma ventana de entrada. 5. En el botón Editar propiedades se recomienda describir el proyecto brevemente y opcionalmente añadir una imagen al proyecto. 6. Con el botón Guardar el proyecto actual se almacenará ahora en la ruta de archivo predefinido.

1.2.5

Modos de WorkVisual

Descripción





WorkVisual puede utilizarse en dos modos diferentes:  Programación y configuración Zona para trabajos relacionados con el proyecto, como los trabajos con el editor KRL, configuración de hardware, del bus de campo y de seguridad.  Administración online Zona para el diagnóstico online, como el diagnóstico de hardware y Registro Trace. Éstas pueden seleccionarse a través de la opción de menú Vista o a través de la ventana Zonas de trabajo. a. Seleccionar la secuencia de menú Ventana > Zonas de trabajo. b. Hacer clic sobre el modo deseado en la ventana Zonas de trabajo. La selección activa se representa en naranja.

Fig. 1-7: Ventana Campos de trabajo

12 / 255



Para el curso de formación para la programación del robot 2, resulta necesario contar con el modo Programación y configuración.

1.2.6

Estructura d el p royecto Wo rkVisual ( pestaña Ficheros)

Pestaña Estructura del proyecto



Pestaña Estructura del proyecto

Fig. 1-8: Ejemplo: ficheros generados automáticamente en gris  Dispositivos: En la pestaña Dispositivos se muestra de manera clara la correspondencia de los dispositivos. Aquí se puede asignar una unidad de control del robot a cada dispositivo.  Geometría: En la pestaña Geometría se preparan los datos de máquina para las cinemáticas externas, como los ejes adicionales.  Ficheros: La pestaña Ficheros contiene los ficheros de programa y configuración del proyecto. Visualización con colores de los nombres de los ficheros: Ficheros generados automáticamente (con la función Crear código):  gris  Ficheros añadidos manualmente a WorkVisual: azul 

Ficheros transmitidos por una unidad de control del robot a WorkVisual: negro

Ruta del fichero para la programación en KRL 



Para la programación en WorkVisual se crean o adaptan programas *.SRC. En el control real, estos programas se encuentran en la partición C:\KRC\Roboter\Programme



En el navegador, esta ruta se representa por separado (al igual que los Ficheros propios de Microsoft Windows.


13 / 255

Programación de robots 2 

En la pestaña Ficheros de la ventana Estructura del proyecto puede encontrarse la carpeta necesaria para la programación: Ruta: KRC\R1\PROGRAMME No borrar o manipular ningún fichero *.XML desconocido. En ciertos casos, el proyecto no puede activarse o bien produce errores.

1.2.7

Comparar proyectos con WorkVisual

Descripción

 





Principio de comparación de proyectos

Es posible comparar un proyecto en WorkVisual con otro proyecto Este puede ser un proyecto de una unidad de control del robot o un proyecto almacenado localmente Las diferencias aparecen de forma clara en una lista y puede mostrarse información detallada El usuario puede decidir individualmente para cada diferencia si quiere dejar el estado como en el proyecto actual   o si quiere aceptar el estado del otro proyecto

Unir proyecto 

Ventana de selección Comparar proyecto

Fig. 1-9: Seleccionar el proyecto para "Comparar"  

  

Proyecto activo Proyecto con el mismo nombre en el control (únicamente posible si se dispone de conexión de red) Proyecto base Proyecto inicial Proyecto local (del ordenador portátil)

Comparación: Las diferencias entre los proyectos se muestran en un resumen. Para cada una de las diferencias puede seleccionarse el estado que debe asumirse.

14 / 255



Fig. 1-10: Ejemplo: resumen de las diferencias Pos. 1

Descripción El nodo de la unidad de control del robot. Las diferentes áreas del proyecto se visualizan en subnodos. Abrir los nodos para mostrar las comparaciones. Si hay disponibles varias unidades de control del robot estas se listan una debajo de la otra. En una línea, colocar siempre el símbolo de confirmación en el valor que se quiere tomar. (Alternativa: emplear las casillas al pie de página).  Un símbolo de confirmación activado como No disponible significa que el elemento no se aceptará o que, en caso de estar ya disponible, se borrará del proyecto. Si se coloca un símbolo de confirmación en un nodo, se marcarán automáticamen te también todos los elementos subordinados. Si se quita un símbolo de confirmación en un nodo, se quitarán automáticamente también en todos los elementos subordinados. Los elementos subordinados también se pueden editar individualmente. Una casilla con contenido significa que, de los elementos subordinados, al menos  uno está seleccionado. Estado en el proyecto abierto en WorkVisual. 

2 3 4 5 6

Estado en el proyecto de comparación. Filtros para mostrar u ocultar los diversos tipos de diferencias. TRUE: En la vista general se muestran informaciones detalladas de las líneas marcadas. Flecha de retroceso: el indicador pasa a la diferencia anterior. Flecha de avance: el indicador pasa a la diferencia siguiente.

7

Los nodos cerrados se abren automáticamente. Las casillas muestran el estado de la línea marcada. En lugar de hacerse directamente en la línea, los símbolos de confirmación también se pueden colocar aquí.


15 / 255


Pos. 8 9

Descripción Confirma las modificaciones seleccionadas en el proyecto abierto. Cierra la ventana Unir proyectos. Descripción de los colores:

Columna

Descripción

Estructura del proyecto WorkVisual Valor seleccionado

Cada elemento se muestra con el color que tiene en la columna desde la que se ha seleccionado. Todos los elementos se muestran en negro.  Verde: elementos que no están disponibles en el proyecto abierto, 



Procedimiento para la comparación de proyectos

pero síelementos en el proyecto de comparación. Azul: que están disponibles en el proyecto abierto, pero no en el proyecto de comparación. Rojo: el resto de elementos. También se incluyen los elementos superiores, los cuales contienen otros elementos en diferentes colores.

1. En WorkVisual, seleccionar la secu encia de menú Extras > Comparar proyectos. Se abre la ventana Comparar proyectos.

Fig. 1-11: Comparar proyectos 2. Seleccionar el proyecto con el que se debe comparar el proyecto WorkVisual actual, p. ej., el proyecto con mismo nombre en la unidad de control del robot real.

Fig. 1-12: Seleccionar el proyecto para "Comparar" 3. Hacer clic en Continuar. Se muestra una barra de progreso. Si el proyecto contiene varias unidades de control del robot, se muestra una barra para cada una. 4. Cuando la barra de progreso se completa y además se muestra el estado: Preparado para la conexión: Hacer clic en Mostrar diferencias. Las diferencias entre los proyectos se muestran en un resumen. Si no se detectan diferencias se indicará en la ventana de mensajes. Seguir con el paso 8. Después no serán necesarios más pasos. 16 / 255



5. Para cada una de las diferencias puede seleccionarse el estado que debe adoptarse. Esto no tiene que hacerse para todas las diferencias de un paso. Si es adecuado, puede dejarse también la selección por defecto. 6. Pulsar Reunir para aceptar los cambios en WorkVisual. 7. Repetir los pasos 5 y 6 las veces que se desee. Esto permite la edición progresiva de las diferentes zonas. Si no hay más diferencias se mostrará el siguiente mensaje: No existen más diferencias. 8. cerrar la ventana Comparar proyectos. 9. Si se han modificado parámetros de los ejes adicionales en el proyecto de la unidad de control del robot, estos deberán ser actualizados en WorkVisual: Abrir la ventana Configuración de los datos de máquina para este  eje adicional.  En el sector Datos de máquina generales específicos del eje pulsar sobre el botón para la importación de los datos de la máquina. Se actualizan los datos. 10. Guardar el proyecto. Ejemplo de comparación de proyectos

Fig. 1-13: Ejemplo: Comparación de proyectos, vista general Decisión sobre qué estado del archivo(s) debe aceptarse.


17 / 255


Fig. 1-14: Ejemplo: Unir proyectos Al activar los Details pueden mostrarse las diferencias de los archivos.

Fig. 1-15: Ejemplo: Detalles activados 1.2.8

Transmitir el proyecto a la unidad de control del robot (instalar)

Descripción



 



Las modificaciones realizadas en el proyecto deben enviarse desde WorkVisual a la unidad de control. Para KUKA, este proceso se denomina "Instalación". El código se genera al transmitir un proyecto a la unidad de control del robot. La conexión de red con la unidad de control del robot real es un requisito para esta "Instalación".

Si en la unidad de control del robot real existe un proyecto que ha sido transmitido en un momento anterior y no se ha activado nunca, este es sobreescrito por causa de la transmisión de otro proyecto. Mediante la transmisión y activación de un proyecto, se sobrescribe un proyecto con mismo nombre existente en la unidad de control del robot (tras una consulta de seguridad).

18 / 255



Funciones

Crearcódigo 



Con este procedimiento se puede crear por separado el código y comprobar por adelantado si está libre de errores. Se accede a través de: Secuencia de menú Extras > Crear código.   

o botón El código aparece en la ventana Estructura del proyecto en la pestaña Ficheros. El código generado automáticamente se muestra en color gris claro.

Fig. 1-16: Ejemplo de creación de código: antes y después 

Se crea el código. Cuando ha finalizado el proceso, en la ventana de mensajes se muestran los siguientes mensajes: Se ha compilado el proyecto <"{0}" V{1}>. Los resultados están disponibles en el árbol de archivos.

Versiones de WorkVisual hasta 3.0 Procedimiento

1. En la barra de menús hacer clic en el botón Instalar ... tana Transmisión del proyecto.


. Se abre la ven-

19 / 255


Fig. 1-17: Resumen indicando la configuración incompleta 2. En caso de que se trate de un proyecto que nunca ha sido retransferido a WorkVisual por parte de una unidad de control del robot, este no incluirá todavía todos los archivos de configuración (entre los archivos de configuración se encuentran los ficheros de datos de la máquina, ficheros de la configuración de seguridad y muchos más). Se muestra una indicación correspondiente. Cuando esa indicación no se muestre: Continuar en el paso 13.   Cuando esa indicación se muestre: Continuar en el paso 3. 3. Hacer clic en Completar. Aparece la siguiente pregunta de seguridad: Configurar el proyecto y restablecer el controlador activo. ¿Desea continuar? 4. Responder con Sí a la pregunta. Se abre la ventana Unir proyectos.

Fig. 1-18: Seleccionar el proyecto para "Comparar" 5. Seleccionar un proyecto cuyos datos de configuración se quieran asumir, p. ej., el proyecto activo en la unidad real de control del robot. 6. Hacer clic en Continuar. Se muestra una barra de progreso. Si el proyecto contiene varias unidades de control del robot, se muestra una barra para cada una. 7. Si la barra de progreso está llena y además se indica el estado y Preparado para la conexión: Hacer clic en Mostrar diferencias. Las diferencias entre los proyectos se muestran en un resumen.

20 / 255



8. Para cada una de las diferencias puede seleccionarse el estado que debe adoptarse. Esto no tiene que hacerse para todas las diferencias de un paso. Si es adecuado, puede dejarse también la selección por defecto. 9. Pulsar Reunir para aceptar los cambios. 10. Repetir los pasos 8 y 9 las veces que se desee. Esto permite la edición consecutiva de las diferentes zonas. Si no hay más diferencias se mostrará el siguiente mensaje: No existen más diferencias. 11. Cerrar la ventana Comparar proyectos. 12. En la barra de menús hacer clic en el botón Instalar... . Se muestra de nuevo el resumen sobre la asignación de celdas. No aparecerá más la indicación relativa a una configuración incompleta.

Fig. 1-19: Vista general 13. Hacer clic en Continuar. Se inicia la creación del programa. Cuando el indicador del progreso llegue al 100 % se habrá creado el programa y se habrá transmitido el proyecto. 14. Hacer clic en Activar. En los modos de servicio AUT y AUT EXT, el proyecto se activa sin pregunta de seguridad si solo se trata de modificaciones del programa. Para la activación de un proyecto se requiere el perfil de usuario Experto. Si en el proyecto que ha de activarse también hay modificaciones en la seguridad, se requerirá el perfil de usuario Personal responsable de la puesta en servicio con seguridad o Técnico de mantenimiento de seguridad con un código de activación válido. 15. Exclusivo para los modos de servicio T1 y T2: KUKA smartHMI muestra la pregunta de seguridad ¿Quiere permitir la activación del proyecto […]?. Además se indica si con la activación se ha sobrescrito un proyecto, y en caso afirmativo, cuál. Si no se ha sobrescrito ningún proyecto relevante: Confirmar la pregunta en el plazo de 30 minutos con Sí.


21 / 255


16. Se muestra una vista general de los cambios que se han realizado en la unidad de control del robot en comparación con el proyecto aún activo. Mediante la casilla Detalles se pueden mostrar detalles acerca de las modificaciones. 17. La vista general mues tra la pregunta de seguri dad ¿Desea continuar?. Responder con Sí. El proyecto se activa en la unidad de control del robot. En WorkVisual se visualiza una confirmación.

Fig. 1-20: Confirmación en WorkVisual 18. Cerrar la ventana Transmisión del proyecto con Finalizar. 19. En caso de que la consulta en la unidad de control del robot no se responda en el transcurso de 30 minutos, el proyecto se transferirá igualmente. Sin embargo no estará activo en la unidad de control del robot. En este caso, el proyecto puede activarse por separado. ¡Tras la activación de un proyecto en la unidad de control del robot se debe comprobar la configuración de seguridad! De lo contrario, es posible que el robot reciba datos erróneos. Pueden producirse daños materiales, lesiones e incluso la muerte.

Si la activación de un proyecto falla aparece un mensaje de error en WorkVisual. En tal caso deben tomarse las siguientes medidas:  Activar nuevamente un proyecto. (El mismo u otro distinto).  O arrancar la unidad de control del robot con un arranque en frío.

Versiones de WorkVisual desde 3.1 Procedimiento Iniciar trasferencia de proyecto

  

Asignar unidad de control 22 / 255

En la barra de menús hacer clic en el botón Instalar ... . Se abre la ventana Transmisión del proyecto. Alternativamente, también se puede realizar la transferencia del proyecto a través de la ruta del menú: Extras > Acceder a Instalar.

1. El controlador del proyecto WorkVisual (2) está listo para asignar el controlador real (4) a la flecha azul (3). (>>> "Procedimiento" Página 31) Edición: 24.02.2015 Versión: P2KSS8_robotprogramming_2_(R2)_V4


Fig. 1-21: Asignar unidad de control Pos.

Descripción

1 2 3 4 5

Transcurso de la transferencia del proyecto Armario de control del proyecto WorkVisual Asignación del proyecto al armario de control real Armario de control real en la red de la instalación Abrir la ventana para la búsqueda de armarios de control en la red de la instalación Abrir la ventana para la comparación de proyectos Confirmación de la asignación de armario de control

6 7

2. Confirmar la asignación con el botón Continuar (7)

Solucionar conflictos





Crear código



Si hay algún conflicto o discrepancia durante la transmisión del proyecto, aparecerá una ventana de eliminación de errores que mostrará la resolución de conflictos. Seleccionar y aplicar la solución correcta de las propuestas. Después de la asignación del controlador WorkVisual generará los datos *.xml necesarios de la configuración gráfica.

Fig. 1-22: Generación de c ódigos 



Este paso de trabajo también puede llevarse a cabo por separado con antelación. Ruta: Extras > Generar código Si hay errores durante la generación de código, la barra de progreso se mostrará en rojo y se cancelará la generación.


23 / 255


Transmitir proyecto



El proyecto final será transferido automáticamente a la unidad de control en el siguiente paso de trabajo.

Fig. 1-23: Transmitir proyecto 



Activar proyecto



Los proyectos siempre se pueden transferir al controlador sin derechos de usuario explícitos. Se copiarán en el controlador de la gestión de proyectos. Si hay una desconexión durante la transferencia, se interrumpirá este paso de trabajo. Después de que el proyecto haya sido transferido, el proyecto se puede activar directamente a través de WorkVisual. Indica un fallo de activación, porque, por ejemplo, no están presentes los derechos de usuario necesarios en el controlador, mediante el icono (1) se activará de nuevo el proyecto para el controlador.

Fig. 1-24: Activación del proyecto fallida 

24 / 255

Después de de color una activación deelproyecto con éxito(1)aparecerá barra de progreso verde. Con botón Finalizar se cerraráuna el asistente.



Fig. 1-25: Trasferencia de proyecto completa 

Confirmar la activación del proyecto en el smartPAD

Si no se responde a la pregunta en la unidad de control del robot dentro de 30 min, se transmite el proyecto de todas formas, aunque no estará activo en la unidad de control del robot. Se puede activar el proyecto por separado. (>>> Fig. 1-24 )

1. En función de los cambios del proyecto, se necesitará el perfil de usuario experto o responsable de seguridad. 2. En el HMI del smartPAD aparecerá el mensaje "Entrada de usuario esperada".

Fig. 1-26: Mensaje de instalación 3. Se abre una ventana en el smartPad "Gestión de proyecto con la pregunta "¿Desea activar el proyecto "1EG2-R04-8_2_First_Test"?" Confirmar la activación con "Sí".

Fig. 1-27: Permitir activación 4. Se muestra otra ventana "Gestión de proyecto". Ahí se muestran los cambios propuestos. Responder a la pregunta "¿Desea continuar?" con "Sí".


25 / 255


Fig. 1-28: Visualización de cambios 5. En el smartPAD aparece un mensaje que lleva a cabo una reconfiguración.

Fig. 1-29: Se ejecuta reconfiguración Aplicar la suma de control modificada

26 / 255

1. Si cambia la seguridad en WorkVisual, como por ejemplo los parámetros de la interfaz de seguridad o de SafeOperation, aparecerá el siguiente mensaje de error en la ventana de mensajes: "Suma de control de la configuración de seguridad incorrecta". Edición: 24.02.2015 Versión: P2KSS8_robotprogramming_2_(R2)_V4


Fig. 1-30: Error de suma de verificación 2. Es necesario el perfil del usuario de responsable de seguridad. 3. Abrir la configuración de seguridad. Ruta: Tecla KUKA > Configuración > Configuración de seguridad 4. En la ventana "Asistente para la resolución de problemas" seleccionar la opción "Ya se ha activado un proyecto WorkVisual"

Fig. 1-31: Asistente solucionador de problemas 5. Aceptar la primera propuesta, en la que se pulsará el botón "Activar ahora".


27 / 255


6. En la ventana "Activar", responder a la pregunta "¿Seguro que quieres cambiar las siguientes partes de la configuración relacionadas con la seguridad?" con "Sí". Se ejecuta la reconfiguración. 7. Confirmar el mensaje en el smartPad "Los cambios se guardaron correctamente" con el botón "OK". 8. Confirmar el mensaje de confirmación "Confirmación: La suma de control de la configuración de seguridad no es correcta" con "Todo OK".

1.2.9

Asignar el proyecto a la unidad de control del robot real

Descripción

Un proyecto debe ser asignado antes de su transferencia de la siguiente manera: 



Controlador de destino El controlador de destino corresponde a la unidad de control real so bre la cual el proyecto se va a transferir.  Si un proyecto se carga desde una unidad de control, se procesa en WorkVisual y debe ser transferido de nuevo, la asignación se hará de forma automática. Celda  En las estructuras de instalación más complejas puede darse el caso de que haya varios robots o unidades de control en una misma celda grande.  Antes de transmitir un proyecto a una unidad de control, se le puede asignar una celda a la misma. Esta asignación no tiene ningún efecto en la capacidad de funciona miento del proyecto.  Sirve a modo de resumen y podrá visualizarse en red a través de WorkVisual.

Versiones de WorkVisual hasta 3.0 Procedimiento

1. En la barra de menús hacer clic en el botón Instalar .... Se abre la ventana Transmisión del proyecto.

Fig. 1-32: Vista general

28 / 255



2. La vista general de la celda se abre con el botón Modificar disponible en la línea Celda.

Fig. 1-33: Asignar unidad de control del robot a la celda 3. En Celda de destino se visualizan las celdas disponibles. (Las celdas se pueden renombrar haciendo clic con el botón derecho.) Si la celda deseada no está disponible se puede crear una nueva:  Hacer clic en Nueva celda. Se abre la ventana Propiedades de las celdas. Escribir un nombre y, en caso necesario, una descripción. Guardar con OK. La nueva celda aparecerá ahora en Celda de destino. 4. Marcar la celda deseada en Celda de destino . A esta celda se le debe asignar ahora la unidad de control del robot real. 5. En Unidades de control disponibles marque la unidad de control del robot que desee. Dependiendo de la topología de la red es posible que la unidad de control del robot no se visualice en Unidades de control disponibles. Si se conoce la dirección IP se puede visualizar la unidad de control del robot de la siguiente manera: 

Hacer clic en . Se abre una ventana. Introducir la dirección IP y guardar con OK. La unidad de control del robot se visualiza ahora en Unidades de control disponibles.

6. Hacer clic en . La unidad de control del robot se visualiza ahora en Controladores de destino. 7. Si el proyecto contiene varias unidades de control del robot, repetir los pasos 4 y 5 para las siguientes unidades de control del robot. 8. La unidad de control del robot virtual debe estar ahora asignada a la unidad de control del robot real: Hacer clic en Continuar. A cada unidad de control del robot virtual se le debe asignar una unidad de control del robot real. 9. En Unidades de control del proyecto marcar la unidad de control virtual.


29 / 255


10. En Unidades de control en la celda marcar la unidad de control del ro bot real y hacer clic en la virtual.

. La unidad de control del robot real es asignada a

Fig. 1-34: Asignar la unidad de control del robot real a la virtual 11. Si el proyecto contiene varias unidades de control del robot, repetir los pasos 8 y 9 para las siguientes unidades de control del robot. 12. Hacer clic en Continuar. Se muestra un resumen. (Aquí existe la posibilidad de volver a cambiar la asignación. Para ello, hacer clic sobre Modificar ….)

Fig. 1-35: Vista general 13. El proyecto se puede transmitir ahora a la unidad de control del robot. Otra posibilidad es transmitir el proyecto en otro momento. Para ello, pulsar Cancelar: la asignación se guarda y la ventana Transmisión del proyecto se cierra.

30 / 255



Versiones de WorkVisual desde 3.1 Procedimiento

1. En la barra de menús hacer clic en el botón Instalar .... Se abre la ventana Transmisión del proyecto WorkVisual. En el lado izquierdo se muestra la unidad de control del robot virtual del proyecto. En el lado derecho se muestra el controlador de destino. Será de color gris si no se ha seleccionado ninguna unidad de control.

Fig. 1-36: Asignar unidad de control del robot a la celda 2. En el lado izquierdo, activar la celda virtual utilizando la casilla. A esta celda se le debe asignar ahora la unidad de control del robot real. 3. Hacer clic en el botón …. Se abre una ventana. El filtro está ajustado automáticamente de tal manera que solo se mostrarán unidades de control del mismo tipo y la misma versión que la unidad de control virtual. Este ajuste puede modificarse.

Fig. 1-37: Asignar la unidad de control del robot real a la virtual


31 / 255


4. Seleccionar la unidad de control del robot real deseada y hacer clic en OK. La unidad de control del robot real es asignada a la virtual. Tras la asignación, la unidad de control del robot se muestra en color, así como con el nombre y la dirección IP.

Fig. 1-38: Resumen 5. Si el proyecto contiene varias unidades de control del robot, repetir los pasos 3 y 4 para las siguientes unidades de control del robot. 6. Hacer clic en Continuar. La asignación se comprueba para determinar la presencia de conflictos. En caso de que haya conflictos, se mostrará un mensaje. Los conflictos deben subsanarse ya que, de lo contrario, no se podrá transmitir el proyecto. En caso de que no haya conflictos, se generará automáticamente el código. 7. El proyecto se puede transmitir ahora a la unidad de control del robot. Otra posibilidad es transmitir el proyecto en otro momento. Para ello, pulsar Cancelar: la asignación se guarda y la ventana Transmisión del proyecto WorkVisual se cierra.

1.2.10

Activar el proyecto en la unidad de control del robot

Descripción





Función de la gestión del proyecto

32 / 255

Un proyecto puede activarse directamente en la unidad de control del robot. Un proyecto también puede activarse desde WorkVisual en la unidad de control del robot (no se explica aquí, para ello utilizar la documentación en línea de WorkVisual)

Generalidades La unidad de control del robot tiene la posibilidad de gestionar varios pro yectos en la unidad de control.  Todas las funciones solo están disponibles en el grupo de usuario Experto.  Puede accederse mediante: En la interfaz de usuario, a través de la tecla WorkVisual-Symbol y a  continuación el botón Abrir



Fig. 1-39: Visualización del proyecto en la interfaz de usuario Manejo / servicio 

Fig. 1-40: Ventana Gestión del proyecto Pos. 1 2



Descripción Se muestra el proyecto inicial. Restaura el estado de suministro de la unidad de control del robot.

3 4

Está disponible desde el grupo de usuario Experto. Se muestra el proyecto base. Crea una copia del proyecto base.

5

Está disponible desde el grupo de usuario Experto. Se muestra el proyecto activo.

6

Guarda el proyecto permanece activo. activo como proyecto base. El proyecto activo

7

Está disponible desde el grupo de usuario Experto. Crea una copia bloqueada del proyecto activo.

8

Está disponible desde el grupo de usuario Experto. Lista de los proyectos. Aquí no se muestra el proyecto activo.

Además de los proyectos regulares, la ventana Gestión del proyecto contiene los siguientes proyectos especiales:


33 / 255


Proyecto

Descripción

Proyecto inicial

El proyecto inicial está siempre disponible. No puede ser modificado por el usuario. Contiene el estado de la unidad de control del robot en el momento del suministro. El usuario puede guardar el proyecto activo como proyecto base. Esta funcionalidad se utiliza por regla general para asegurar un proyecto protegido y en condiciones de funcionamiento.

Proyecto base

El proyecto base no puede activarse pero sí copiarse. El proyecto base ya no puede ser modificado por el usuario. embargo, puede grabando un nuevoSin proyecto base (tras sobrescribirse una pregunta de seguridad). Cuando se activa un proyecto que no contiene todos los ficheros de configuración, la información que falta se toma del proyecto base. Esto puede ser el caso p. ej. si se activa un proyecto de una versión de WorkVisual anterior. Entre los ficheros de configuración se incluyen ficheros de datos de la máquina, ficheros de la configuración de seguridad y muchos otros. 

Descripción de los botones

Botón

Descripción

Activar

Activa el proyecto marcado. Si el proyecto marcado está bloqueado: Crea una copia del proyecto marcado. (Un proyecto bloqueado no puede activarse, solo una copia del mismo.) El usuario puede decidir si la copia debe activarse ya o el proyecto actual debe quedar activo.

Introducir Pin

Está disponible desde el grupo de usuario Experto. Los proyectos bloqueados no pueden ser modificados, activados o borrados. Sin embargo, pueden copiarse o desbloquearse. Por lo tanto, se puede bloquear un proyecto para evitar p. ej. que se borre por error.

Desbloquear

Solamente está disponible si está marcado un proyecto desbloqueado. Está disponible desde el grupo de usuario Experto. Desbloquea el proyecto.

Copiar

Sólo está disponible si está marcado un proyecto bloqueado. Está disponible desde el grupo de usuario Experto. Copia el proyecto marcado.

Borrar

Está disponible desde el grupo de usuario Experto. Borra el proyecto marcado. Sólo está disponible si está marcado un proyecto inactivo y desbloqueado. Está disponible desde el grupo de usuario Experto.

34 / 255



Botón

Descripción

Editar

Abre una ventana en la que pueden modificarse el nombre y/o la descripción del proyecto marcado.

Actualizar

Procedimiento

Sólo está disponible si está marcado un proyecto desbloqueado. Está disponible desde el grupo de usuario Experto. Actualiza la lista de proyectos. De esta forma se muestran, p. ej., los proyectos que se han transmitido a la unidad de control del robot desde la apertura del indicador.

Restricción: Cuando la activación causa modificaciones en el sector Parámetros de comunicación de la configuración de seguridad, debe seleccionarse el grupo de usuarios Técnico de mantenimiento de seguridad o superior. Si se ha seleccionado el modo de servicio AUT o AUT EXT: El proyecto sólo se puede activar si únicamente se modifican programas KRL. Si el proyecto contiene ajustes que provocan otros cambios no se puede activar. 1. Seleccionar la secuencia de menú Archivo > Gestión del proyecto. Se abre la ventana Gestión del proyecto. 2. Marcar el proyecto deseado y activar pulsando el botón Activar. 3. KUKA smartHMI muestra la pregunta de seguridad ¿Quiere permitir la activación del proyecto […]?. Además se indica si con la activación se ha sobrescrito un proyecto, y en caso afirmativo, cuál. Si no se ha sobrescrito ningún proyecto relevante: Confirmar la pregunta en un plazo de 30 min con Sí. 4. Se muestra una vista general de los cambios que se han realizado en la unidad de control del robot en comparación con el proyecto aún activo. Mediante la casilla Detalles se pueden mostrar detalles acerca de las modificaciones. 5. La vista general muestra la pregunta de seguridad ¿Desea continuar?. Responder con Sí. El proyecto se activa en la unidad de control del robot. ¡Tras la activación de un proyecto en la unidad de control del robot se debe comprobar la configuración de seguridad! De lo contrario, es posible que el robot reciba datos erróneos. Pueden producirse daños materiales, lesiones e incluso la muerte.

1.3

1.3.1

Editar programas KRL con WorkVisual 

Manipulación del fichero



Manejo del editor KRL

Manipulación d el f ichero

Descripción

   

Activar el catálogo Plantillas Abrir el fichero (SRC/DAT/SUB) en el editor KRL Procedimiento para añadir un fichero mediante plantillas KRL Añadir ficheros externos


35 / 255


Activar el catálogo Plantillas

Fig. 1-41: Añadir catálogo Antes de la utilización de las plantillas se debe cargar el catálogo corres pondiente.  Ruta: Fichero > Añadir catálogo  En la ventana Catálogos disponibles(1) se listan todos los catálogos instalados en WorkVisual que no se han cargado y que están activos. En la ventana Catálogos de proyecto (2) se listan todos los catálogos  instalados y cargados en WorkVisual. Estos catálogos permiten la edición.  Las teclas de flecha (2) puermiten activar y desactivar los catálogos.  Para la programación en WorkVisual se necesitan los siguientes catálogos:  Plantillas KRL KRL Templates.afc 

Modelos VW VW Templates.afc

Abrir el fichero (SRC/DAT/SUB) en el editor KRL

Procedimiento 1. En la estructura del proyecto, cambiar a la pestaña Ficheros (1)

Fig. 1-42: Árbol de proyecto de WorkVisual 2. Desplegar los directorios hasta el directorio R1

36 / 255



Fig. 1-43: Estructura de fi cheros de árbol de proyecto de WorkVisual (R1) 3. Seleccionar el fichero o  mediante doble clic 

botón de la barra de símbolos



hacer clic con el botón derecho y seleccionar editor Krl

en el

menú contextual

Fig. 1-44: Menú contextual de ratón de WorkVisual (editor KRL)


37 / 255


Procedimiento para añadir un fichero mediante plantillas KRL

Procedimiento 1. Cambiar el árbol de proyecto del fichero 2. Desplegar los directorios hasta el directorio R1 3. Seleccionar la carpeta en la que se va a crear el fichero nuevo 4. Hacer clic con el botón derecho y añadir

en el menú contextual

Fig. 1-45: Menú contextual de WorkVisual (añadir) 5. Seleccionar plantilla

Fig. 1-46: Catálogos de plantillas KRL a. En la ventana Catálogos, cambiar a la pestaña KRL Templates(1) b. Seleccionar la plantilla (2) deseada, por ejemplo Módulo. c. En la ventana Propiedades (3) se visualiza la información detallada, por ejemplo los ficheros que pueden crearse (en este caso .src y .dat). 38 / 255



6. Asignar el nombre del programa

Añadir ficheros externos

Procedimiento 1. En la ventana Estructura del proyectoen la pestaña Ficheros abrir la estructura de árbol de la unidad de control del robot. 2. Hacer clic con el botón derecho sobre el nodo en el que debe crearse el programa y seleccionar Añadir ficheros externos en el menú contextual.

Fig. 1-47: Menú contextual de WorkVisual (añadir fichero externo) 3. Navegar hasta el directorio en el que se encuentre el fichero a importar.

Fig. 1-48: Añadir ficheros externos en WorkVisual 4. Marcar el fichero y confirmar con Abrir. El fichero se añadirá a la estructura en árbol. Se pueden importar los ficheros con extensión SRC, DAT, SUB y KRL. El fichero se puede editar ahora con el editor KRL.

1.3.2

Activar el catálogo Plantillas

Descripción

Para poder llevar a cabo ciertas funciones en WorkVisual, como por ejemplo, la configuración o programación, es necesario activar los catálogos correspondientes.


39 / 255


Ejemplo  

La estructura del proyecto debería ampliarse. Hacer clic derecho en el icono de activación del controlador y en el botón "Añadir".

Fig. 1-49: Ampliar estructura del proyecto 

Aparecerá el mensaje "No se han encontrado elementos adecuados. Por favor, añadir los correspondientes catálogos".

Fig. 1-50: Mensaje de error Procedimiento Activar el catálogo Plantillas

Fig. 1-51: Añadir catálogo 



40 / 255

Antes de la utilización de las plantillas se debe cargar el catálogo correspondiente. Ruta: Fichero > Añadir catálogo





 

En la ventana Catálogos disponibles(1) se listan todos los catálogos instalados en WorkVisual que no se han cargado y que están activos. En la ventana Catálogos de proyecto (2) se listan todos los catálogos instalados y cargados en WorkVisual. Estos catálogos permiten la edición. Las teclas de flecha (2) puermiten activar y desactivar los catálogos. Para la programación en WorkVisual se necesitan los siguientes catálogos:  Plantillas KRL KRL Templates.afc 

Modelos VW VW Templates.afc

1.3.3

Manejo del editor KRL

Descripción del editor KRL

           

Conocer la interfaz de usuario del editor KRL

Conocer la interfaz de usuario del editor KRL Descripción de colores del editor KRL Visualizar las declaraciones de variables de un fichero Buscar y sustituir en ficheros Renombrar variables Autocompletar Fragmentos (snippets): entrada rápida para instrucciones KRL Corrección Quickfix Corregir o declarar automáticamente la variable no declarada. Borrar variables no utilizadas Visualizar variables Trabajar con Folds

Descripción   

El editor KRL permite la edicición confortable de programas KUKA. No es posible comprobar o dejar que se ejecuten los programas. Ruta: Editores > Editor KRL


41 / 255


Fig. 1-52: Interfaz de usuario del editor KRL Pos. 1

2

Descripción Área del programa Aquí se introduce o se procesa el código. El editor KRL ofrece numerosas funcionalidades que ayudarán al programador. Lista de subprogramas en este fichero Para acceder a un subprograma deberá seleccionarse de la lista: el curso salta a la línea DEF de dicho subprograma.

3

Si el fichero no incluye subprogramas, la lista está vacía. Lista de las declaraciones de variables Esta lista se refiere siempre al subprograma que está seleccionado actualmente en la lista de subprogramas. Para acceder a una declaración deberá seleccionarse la variable en la lista: el cursor salta a la línea con la declaración de dicha variable.

4

Si no hay presente ninguna declaración de variable, la lista está vacía. Barra de análisis Las marcas indican errores o desigualdades en el código. 



5

Al pasar con el puntero del ratón sobre una marca se visualiza una información de herramientas con la descripción del error. Al hacer clic en una marca, el cursor salta en el programa hasta el punto correspondiente. Para algunos errores/desigualdades se ofrece una corrección automática.

El cuadrado tiene el color del error de mayor gravedad que existe actualmente. Si no existen errores/desigualdades, cuadrado tiene el color verde.

42 / 255



Funciones de procesamiento generales

Marcar 

Marcar una zona: hacer clic en el punto en el que deban empezar las marcas y mantener pulsado el botón izquierdo del ratón. Arrastrar con el ratón hasta que esté marcada la zona deseada y seguidamente soltar de nuevo el botón del ratón. Si al marcar se mantiene pulsada adicionalmente la tecla ALT se podrá marcar una zona rectangular.



Marcar una línea: hacer clic en un número de línea.

Editar 



Se puede a las funciones través del acceder menú contextual. Son: de procesamiento convencionales a  Cortar, Insertar, Copiar, Borrar  Anular, Restablecer  Buscar ... Además, en el menú contextual se encuentran disponibles las instrucciones enumeradas a continuación. Todas las instrucciones no están disponibles para cualquier formato de fichero. Las instrucciones referidas a una zona marcada tienen efecto en el fichero completo si no se encuentra marcada ninguna zona. 

Opcióndemenú

Descripción

Procesar > Convertir en mayúsculas

Convierte todas las minúsculas en mayúsculas en la zona marcada.

Procesar > Convertir en minúsculas Procesar > Primera letra mayúscula Procesar > Convertir los tabuladores en espacios

Convierte todas las mayúsculas en minúsculas en la zona marcada. Convierte todas las letras iniciales en mayúsculas en la zona marcada. Sustituye las tabulaciones por espacios en el sector marcado.

Procesar > Convertir los espacios en tabuladores Procesar > Acoplar

Indicación: el número de espacios que corresponden a un tabulador se puede configurar mediante el parámetro Tamaño de entrada. Sustituye los espacios por tabuladores en el sector marcado. Añade espacios iniciales (adicionales) en cada línea de la zona marcada. Indicación: el número de espacios que se pueden insertar puede configurarse mediante el parámetro Tamaño de entrada.

Procesar > Borrar espacios iniciales Folds > Abrir todos Folds > Cerrar todos Formatear Insertar punto y coma

Elimina todos los espacios iniciales en las líneas de la zona marcada. Abre todos los folds del fichero que se muestra actualmente. Cierra todos los folds del fichero que se muestra actualmente. El sangrado, el ajuste de línea etc. se adapta en todo el fichero al estándar. El estándar válido depende del formato del fichero. Inserta punto y coma en la línea.


43 / 255


Opcióndemenú

Descripción

Borrar punto y coma Renombrar Ir a la declaración Insertar fragmento (snippet) Descripción de colores del editor KRL



Borra el punto y coma en la línea. (>>> "Renombrar variables" Página 46) (>>> "Visualizar variables" Página 52) (>>> "Fragmentos (snippets): entrada rápida para instrucciones KRL" Página 48)

Descripción de los colores El editor KRL reconoce las partes del código introducido y las representa automáticamente en diferentes colores.

Partdeeclódigo Palabras clave KRL (a excepción de ;FOLD y ;ENDFOLD) ;FOLD y ;ENDFOLD Números Cadenas(textoentrecomillas"…") Comentarios Caracteresespeciales Otro código 

Color azul medio gris azul oscuro rojo verde verdeazulado negro

Ejemplo para la utilización de los colores

Fig. 1-53: Ejemplo de colores en el editor KRL 1 2 3 4

Visualizar las declaraciones de variables de un fichero

Palabras clave KRL: azul Comentario: verde FOLD: gris Otro código: negro

Descripción Todas las variables KRL declaradas en un fichero determinado pueden vi sualizarse de forma clara en una lista.  En los ficheros SRC también se visualizan siempre las variables de los ficheros DAT correspondientes y viceversa. Procedimiento 1. Solamente si todavía no se ha visualizado la ventana Lista de variables: Visualizar esto a través de la secuencia de menú Ventana > Lista de variables.

44 / 255



2. Abrir el fichero en el editor KRL o en caso de que ya esté abierto, hacer clic en la pestaña del fichero. 3. La lista de variables muestra todas las variables declaradas en el módulo (fichero SRC y el fichero DAT correspondiente). Haciendo clic sobre una columna es posible ordenar la lista según esa columna.

Fig. 1-54: Ventana lista de variables Botón

Nombre / descripción Agrupa las variables según las funciones locales del nivel secundario El botón está pulsado: La visualización está ordenada por tipos de ficheros. (Dentro de este orden es posible ordenar además por columnas.) El botón no está pulsado: La visualización no está ordenada por tipos de ficheros.

4. Si es necesario, se puede marcar una variable en el editor KRL de esta forma:  Hacer doble clic sobre la línea del resultado de búsqueda.  O bien: Hacer clic con el botón derecho sobre la línea y seleccionar Ir en elMarcar menú contextual. a... O bien: la línea y pulsar la tecla de entrada. 5. En la ventana Lista de variables está a disposición una función de búsqueda con la que se pueden buscar variables locales en el fichero actual:  Introducir el nombre de variables o una parte del nombre en el campo de búsqueda. Se muestra inmediatamente el resultado de la búsqueda. 

Buscar y sustituir en ficheros

Descripción 



En WorkVisual hay disponible una función de búsqueda que permite buscar un texto determinado en todos los ficheros de todo el proyecto. En la ventana de búsqueda se puede seleccionar esa área. También permite examinar ficheros concretos o una zona determinada de un fichero.

Procedimiento 1. Para buscar en un fichero determinado, hay que abrirlo. 2. Para buscar en un área determinada del fichero, hay que marcarla. 3. Abrir la ventana de búsqueda: CTRL+F


45 / 255


Fig. 1-55: Búsqueda en WorkVisual 4. O bien: Abrir la ventana para buscar y reemplazar: CTRL+H

Fig. 1-56: Buscar y reemplazar 5. Hacer los ajustes deseados y hacer clic en Buscar, en Reemplazar o en Reemplazar todo.

Renombrar variables

Descripción 



Un nombre de variable se puede modificar con una sola acción en todos los lugares en los que aparezca. Esto también es posible cuando la variable está declarada en un fichero DAT y se utiliza en varios ficheros SRC.

Requisito 

46 / 255

Los ficheros en los que aparece el nombre de variable no tienen errores de sintaxis.



En un fichero con errores sintácticos no actúa el proceso de cambio automático.

Procedimiento 1. Marcar la variable deseada en cualquier lugar. 2. Hacer clic con el botón derecho y seleccionar Renombrar en el menú contextual. 3. Se abre una ventana. Cambiar el nombre y confirmar con OK.

Fig. 1-57: Renombrar variable Autocompletar

Descripción 



En el editor KRL se encuentra disponible una funcionalidad de Autocompletar. Al introducir el código se visualiza automáticamente una lista que contiene los siguientes elementos: Palabras clave KRL   Nombres de variables conocidos  Nombres de función conocidos  Tipos de datos específicos de usuario conocidos (STRUC o ENUM) Fragmentos (snippets) (>>> "Fragmentos (snippets): entrada rápida  para instrucciones KRL" Página 48)

Procedimiento 



Introducir las primeras letras de la instrucción, variable, etc. deseada en las correspondientes líneas del programa. Se abre la opción de Autocompletar:

Fig. 1-58: Autocompletar


47 / 255




En la parte superior de la lista se visualizan los elementos que corresponden a los caracteres ya introducidos. Estos elementos se vuelven a priorizar de nuevo según la frecuencia de su uso, es decir, la selección se adapta constantemente al comportamiento del usuario. En caso necesario, se puede marcar un elemento de la lista y aceptarse en el texto de programa con la tecla de entrada. Esto ahorra, p. ej., el hecho de tener que escribir continuamente los complejos nombres de variables. Navegación en la lista de Completar: Desplazarse  O bien: escribir las letras iniciales del elemento deseado. La marca salta hacia ese punto.

Fragmentos (snippets): entrada rápida para instrucciones KRL

Descripción 



 

Para las instrucciones KRL habituales se dispone de una entrada rápida en el editor KRL. Si, por ejemplo, se quiere programar un bucle FOR, no hará falta introducir la sintaxis completa FOR … = … TO … STEP … . En su lugar, se selecciona la instrucción en la lista de Completar. Sólo tienen que completarse manualmente las partes variables de la sintaxis.

Procedimiento 1. Si se comienza a escribir el código, se visualizará la lista de Completar. Aceptar en la lista de Completar la instrucción marcada con la tecla de entrada. O hacer doble clic en otra instrucción.

Fig. 1-59: Aceptar con la tecla de entrada o hacer doble clic 2. La sintaxis KRL se añadirá automáticamente. La primera posición variable está marcada de color azul. Introducir el valor deseado.

Fig. 1-60: La primera posición variable está marcada de color azul 3. Con la tecla tabulador saltar hasta la siguiente posición variable. Introducir el valor deseado. 4. Repetir el paso 3 para todas las posiciones variables. 5. Pulsar la tecla de entrada para finalizar el procesamiento.

48 / 255



Alternativas 1. La lista de fragmentos (snippet) también se puede activar por separado: hacer clic con el botón derecho y seleccionar la entrada Insertar snippet en el menú contextual. 2. Además, un fragmento (snippet) se puede introducir del siguiente modo: teclear la abreviatura y pulsar la tecla TAB. 3. (Se puede determinar la abreviatura activando la lista con los fragmentos (snippets). Marcar la instrucción. Se visualiza una información de herramientas. La 2ª línea contiene las posibles abreviaturas.)

Corrección Quickfix

Descripción 

Las partes subrayadas en el código y las marcas en la barra de análisis hacen notar errores o desigualdades.

Procedimiento 



Para algunos de estos errores/desigualdades se ofrece una corrección automática, el "Quickfix". Se visualiza una lamparita Quickfix.

Fig. 1-61: Lamparita Quickfix 

Mediante la tecla de flecha junto a la lamparita, el usuario puede visualizar diferentes posibilidades de solución y elegir una.

Corregir o declarar automá-

Las variables no declaradas se visualizan del siguiente modo:

ticamente variable nola declarada.







En el código mediante el subrayado en color rojo En la barra de análisis mediante una raya de color rojo Excepciones:  Sin embargo, el color rojo también puede indicar otro error.  Si se trata de una variable no declarada, se visualiza la siguiente información de herramientas al pasar con el puntero del ratón sobre el subrayado/la raya: La declaración de las variables [nombre] no se ha encontrado .

Procedimiento: 1. Situar el cursor en el nombre subrayado o directamente delante de la primera letra o directamente después de la última.


49 / 255


Fig. 1-62: Variable no declarada O bien: hacer clic en la raya en la barra de análisis. Junto al nombre de variable se visualiza ahora una lamparita Quickfix. 2. Comprobar si los nombres de variables se han escrito por error de forma incorrecta (de un modo diferente que en la declaración).  En caso afirmativo: corregir. El subrayado/la raya desaparece. Ya no es necesario ejecutar más pasos.  En caso negativo: continuar con el paso siguiente. 3. Mover el puntero del ratón sobre la lamparita Quickfix. Junto a la lamparita se visualiza una flecha. Hacer clic sobre la flecha. Se visualizan las siguientes opciones:

Fig. 1-63: Declarar la variable  

Declarar la variable localmente Declarar la variable en la lista de datos

4. Hacer clic en la opción deseada. 5. Solo con Declarar la variable en la lista de datos : se abre la lista de datos. Abrir el fold BASISTECH EXT.

50 / 255



6. Se añade automáticamente un fragmento (snippet) para la declaración de variables. El tipo de datos supuesto se resalta en color azul. Después de la declaración aparece el comentario: ; Esta variable es para ... .

Fig. 1-64: Variables declaradas automáticamente en la lista .dat  

Mantener o modificar el tipo de datos según sea necesario. Con la tecla tabulador ir al comentario. Procesar el comentario si es necesario. Este comentario se visualiza en la información de herramientas de la lista de Completar si la variable se marca aquí.

Borrar variables no utilizadas

Descripción 



Las variables no utilizadas se visualizan del siguiente modo:  En el código mediante el subrayado en color azul  En la barra de análisis mediante una raya de color azul Al pasar con el puntero del ratón sobre el subrayado o la raya se visualiza una información de herramientas con una descripción.

Procedimiento 1. Situar el cursor en el nombre subrayado o directamente delante de la primera letra o directamente después de la última. O bien: hacer clic en la raya en la barra de análisis. Junto al nombre de variable se visualiza ahora una lamparita Quickfix. 2. Mover el puntero del ratón sobre la lamparita Quickfix. Junto a la lamparita se visualiza una flecha.

Fig. 1-65: Eliminar variables o borrar comentarios de las mismas Hacer clic sobre la flecha. Se visualizan las siguientes opciones:  

Borrar la declaración Insertar punto y coma en la declaración

3. Hacer clic en la opción deseada.


51 / 255


Visualizar variables

Saltar a la declaración de una variable 1. Situar el cursor en el nombre de la variable, o directamente delante de la primera letra o directamente detrás de la última. 2. Hacer clic con el botón derecho y seleccionar Ir a la declaración en el menú contextual.

Fig. 1-66: Menú: botón derecho del ratón 3. El cursor marca el nombre de la variable en la sección de declaraciones. En el ejemplo: ... DECL INT counter ...

Visualizar todos los usos de una variable 1. Solamente si todavía no se ha vis ualizado la ventana Encontrar aplicaciones: Marcar la secuencia de menú Ventana > Encontrar aplicaciones. 2. Situar el cursor en el nombre de la variable, o directamente delante de la primera letra o directamente detrás de la última. 3. Hacer clic con el botón derecho del ratón y seleccionar Encontrar aplicaciones en el menú contextual. Ver también: (>>> Fig. 1-66 ) En la ventana Encontrar aplicaciones aparece una pestaña con el nombre Usos de [variable]. En ella aparecen detallados todos los usos (fichero y ruta completa, número de líneas, etc.).

52 / 255



Fig. 1-67: Utilización de filtros 4. En caso necesario: Hacer doble clic en una línea de la lista. Se marca la posición correspondiente en el programa. Se puede ejecutar, p. ej., Renombrar.

Trabajar con Folds

Descripción  El contenido del editor KRL se puede estructurar con folds al igual que un programa KRL normal. Los programas pueden configurarse a modo de resumen gracias a este  método. Abrir un fold   

Hacer doble clic en la casilla del fold cerrado. O bien: hacer clic en el signo más. Se abre el fold.

Fig. 1-68: Fold abierto Cerrar un fold  

Hacer clic en el signo menos. El Fold se cierra.

Fig. 1-69: Fold cerrado Abrir o cerrar todos los folds 

Menú contextual: Folds > Abrir todos o Cerrar todos


53 / 255


1.4

Ejercicio: E ditar un proyecto activo e n W orkVisual

Objetivo del ejercicio

Después de completar correctamente este ejercicio, se dispondrá de la competencia necesaria para efectuar las siguientes tareas: 

  

Requisitos

Los siguientes requisitos son necesarios para completar este ejercicio correctamente:  

Formulación de tarea

Conectar en la interfaz KSI de la unidad de control un PC con WorkVisual 3.x instalado. Cargar un proyecto activo en WorkVisual. Crear un nuevo programa KRL en WorkVisual. Transferir a la unidad de control el proyecto actualizado y ativarlo.



   

Se necesita un PC con WorkVisual 3.x instalado. Conocimientos teóricos sobre la gestión de proyectos en WorkVisual Enlazar el PC, con WorkVisual 3.x instalado, con la interfaz KUKA Service Interface KSI situada en el armario de control. Cargar el proyecto activo de la unidad de control en WorkVisual. Crear un nuevo programa con la denominación my1prog Crear un comentario entre ambos conjuntos de movimientos PTP HOME. Establecer la estructura de fichero específica para el proyecto pulsando el botón Code erzeugen



 

.

Instalar el proyecto pulsando el botón Instalar proyecto situado en la unidad de control. Activar ese proyecto. Comprobar si el nuevo programa instalado está disponible en la unidad de control.

Lo que se debe saber tras el ejercicio: 1. ¿Qué interfaces pueden utilizarse para enlazar un PC con WorkVisual en la unidad de control? ............................................................. ............................................................. 2. ¿Qué proyectos especiales están disponibles en la unidad de control? ............................................................. ............................................................. ............................................................. 3. ¿Cuáles son los modos de WorkVisual disponibles y cómo se utilizan? ............................................................. ............................................................. 4. ¿Qué plantillas deben activarse para la programación KRL? ............................................................. ............................................................. 5. ¿Dónde pueden crearse nuevos programas KRL en los programas de WorkVisual? ............................................................. .............................................................

54 / 255



6. ¿Para qué se utilizan los fragmentos (snippets)? ............................................................ ............................................................


55 / 255


56 / 255


2 Programación estructurada

2

Programación estructurada

2.1

Resumen Esta unidad incluye los siguientes contenidos:  



2.2

Metodología de programación uniforme Elementos auxiliares para la creación de programas de robot estructurados Plan de ejecución del programa

Objetivo de la metodología de programación uniforme

Objetivo de la metodología de programación uniforme

Una metodología de programación sirve para: 





hacer frente a problemas complejos de un modo más sencillo mediante una estructura dividida de forma rigurosa representar de forma comprensible el proceso en cuestión (sin tener conocimientos de programación más avanzados) aumentar la efectividad en el mantenimiento, la modificación y la ampliación de programas

La planificación del programa con previsión tiene como consecuencia:   



poder dividir tareas complejas en tareas parciales simples reducir el tiempo total necesario para la programación permitir la posibilidad de sustitución de componentes con el mismo rendimiento poder desarrollar componentes de forma separada

Los 6 requisitos para un programa del robot: 1. Eficacia 2. Ausencia de errores 3. Inteligibilidad 4. Mantenimiento sencillo 5. Control visual completo 6. Rentabilidad

2.3

Elementos auxiliares para la creación de programas de robot estructurados

¿Qué utilidad tiene un comentario?

Los comentarios son complementos/observaciones dentro del lenguaje de programación. Todos los lenguajes de programación se componen de instrucciones para el ordenador (código) e indicaciones para el procesador de textos (comentarios). Si se continúa el procesamiento (se compila, interpreta, etc.) de un texto fuente, se ignorarán los comentarios del software de procesamiento y, por ello, no tienen ninguna influencia en el resultado. En el controlador de KUKA se utilizan comentarios de líneas, es decir, los comentarios terminan automáticamente al final de la línea. Los comentarios por sí solos no pueden hacer que un programa sea legible, pero pueden aumentar considerablemente la legibilidad de un programa bien estructurado. Mediante los comentarios, el programador tiene la posibilidad de añadir observaciones y explicaciones en el programa sin que sean registradas como sintaxis por el controlador. El programador es responsable de que el contenido de los comentarios coincida con el estado actual de las indicaciones de programación. En caso de


57 / 255


modificaciones del programa, también se deberá comprobar los comentarios y adaptarse si es necesario. El contenido de un comentario y, de este modo, también su utilización se puede seleccionar libremente por el autor y no está sometido a ninguna sintaxis vinculante. Por regla general, los comentarios se realizan en lenguaje "humano", bien en la lengua materna del autor o en un lenguaje coloquial.       

¿Dónde y cuándo se van a utilizar los comentarios?

Observaciones sobre el contenido o función de un programa El contenido y la utilización se pueden seleccionar libremente Se mejora la legibilidad de un programa Contribución a la estructuración de un programa La responsabilidad de la actualización corresponde al programador KUKA utiliza comentarios de líneas Los comentarios no son registrados como sintaxis por el controlador

Informaciones sobre el texto fuente completo: Al principio de un texto fuente, el autor puede realizar comentarios previos, incluyendo sus propios datos, la licencia, la fecha de creación, la dirección de contacto en caso de preguntas, la lista de otros ficheros necesarios, etc. DEF PICK_CUBE() ;Este programa recoge el cubo del depósito ;Autor: Max Mustermann ;Fecha de creación: 09.08.2011 INI ... END

Subdivisión del texto fuente: Losutilizan títulos con y losfrecuencia apartados medios se pueden identificarsino como tales. Para ello,gráficos no solo se lingüísticos, también medios que se pueden aplicar a lo largo del texto. DEF PALLETIZE() ;***************************************************** ;*Este programa paletiza 16 cubos sobre la mesa* ;*Autor: Max Mustermann------------------------------* ;*Fecha de creación: 09.08.2011-----------------------* ;***************************************************** INI ... ;------------Cálculo de las posiciones---------------... ;------------Paletizado de los 16 cubos--------------... ;----------Despaletizado de los 16 cubos--------------... END

Explicación de una línea individual: De este modo se puede explicar el procedimiento o el significado de una parte del texto (p. ej. línea del programa) para que otros autores o el propio autor puedan entenderlo mejor posteriormente. DEF PICK_CUBE() INI SPTP HOME Vel=100% DEFAULT

58 / 255



SPTP Pre_Pos ; Desplazamiento a posición previa para agarrar SLIN Grip_Pos ; Cubo desplazado a posición de agarre ... END

Indicación sobre los trabajos a realizar: Los comentarios pueden identificar fragmentos de códigos insuficientes o ser un comodín para fragmentos de códigos completamente ausentes. DEF PICK_CUBE() INI ;Aquí se debe insertar el cálculo de las posiciones de palets SPTP HOME Vel=100% DEFAULT SPTP Pre_Pos ; Desplazamiento a posición previa para agarrar SLIN Grip_Pos ; Cubo desplazado a posición de agarre ;Aquí falta el cierre de la garra END

Insertar punto y coma: Si se borra provisionalmente un componente del código, aunque posiblemente se vuelve a introducir de forma posterior, se insertará un punto y coma. En cuanto está incluido en el comentario, el fragmento del código ya no es un código desde el punto de vista del compilador, es decir, prácticamente ya no está disponible. DEF Palletize() INI PICK_CUBE() ;CUBE_TO_TABLE() CUBE_TO_MAGAZINE() END

¿Qué provoca la utilización de Folds en un programa del robot? ¿Qué ejemplos existen para la utilización de Folds?

  



En FOLDS se pueden ocultar partes del programa Los contenidos de FOLDS no son visibles para el usuario Los contenidos de FOLDS se procesan de forma totalmente normal en la ejecución del programa Mediante la utilización de FOLDS se puede mejorar la legibilidad de un programa

En el controlador de KUKA, el sistema ya utiliza Folds de manera estándar, por ejemplo durante la visualización de formularios inline. Estos Folds facilitan el control visual completo de los valores introducidos en el formulario en línea y ocultan las partes del programa que no son relevantes para el operario. Además, para el usuario existe la posibilidad de crear Folds propios (a partir de grupo de usuario experto). El programador puede utilizar estos Folds, p. ej.


59 / 255


para comunicarle al operario lo que está ocurriendo en un lugar determinado del programa, pero manteniendo la sintaxis KRL real en segundo plano. En general, los Folds se representan primero cerrados tras su creación. DEF Main() ... INI

; KUKA FOLD cerrado

SET_EA

; FOLD creado por el utilizador cerrado

SPTP HOME Vel=100% DEFAULT

; KUKA FOLD cerrado

SPTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table ... SPTP HOME Vel=100% Default END DEF Main() ... INI

; KUKA FOLD cerrado

SET_EA $OUT[12]=TRUE $OUT[102]=FALSE PART=0 Position=0

; FOLD creado por el utilizador abierto

SPTP HOME Vel=100% DEFAULT ; KUKA FOLD cerrado ... SPTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table SPTP HOME Vel=100% Default END DEF Main() ... INI

; KUKA FOLD cerrado

SET_EA

; FOLD creado por el utilizador cerrado

; KUKA FOLD abierto SPTP XHOME WITH $VEL_AXIS[1]= SVEL_JOINT( 100), $TOOL= STOOL2( FHOME), $BASE= SBASE( FHOME.BASE_NO), $IPO_MODE= SIPO_MODE( FHOME.IPO_FRAME), $LOAD= SLOAD( FHOME.TOOL_NO), $ACC_AXIS[1]= SACC_JOINT( PDEFAULT), $GEAR_JERK[1]= SGEAR_JERK( PDEFAULT)

... SPTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table SPTP HOME Vel=100% Default END

¿Por qué se trabaja con tecnología de subprogramas? 60 / 255

En la programación los subprogramas se utilizan principalmente para permitir una utilización múltiple de partes de tareas iguales y, de este modo, conseguir la prevención de repeticiones de códigos. Esto también permite ahorrar en espacio de almacenamiento, entre otros aspectos. Edición: 24.02.2015 Versión: P2KSS8_robotprogramming_2_(R2)_V4


Otro motivo importante para la utilización de subprogramas es las estructuración resultante del programa. Un subprograma debe realizar una tarea parcial acotada a sí misma y fácilmente descriptible. Los subprogramas son actualmente más cortos y con una presentación clara en beneficio de la facilidad de mantenimiento y la eliminación de errores de programación. El tiempo y la administración invertidos desde el punto de vista interno del ordenador para la activación de subprogramas, no tienen prácticamente ninguna importancia en los ordenadores modernos.     

  

Aplicación de subprogramas

Posibilidad de utilización múltiple Prevención de repeticiones de códigos Ahorro de espacio de almacenamiento Los componentes se pueden desarrollar separados unos de otros Posibilidad de intercambio de componentes del mismo nivel de rendimiento en cualquier momento Estructuración del programa Tarea completa dividida en tareas parciales Mantenibilidad y eliminación de errores de programación mejoradas

DEF MAIN() INI LOOP GET_PEN() PAINT_PATH() PEN_BACK() GET_PLATE() GLUE_PLATE() PLATE_BACK() IF $IN[1]== TRUE THEN EXIT ENDIF ENDLOOP END

¿Qué provoca la inserción de líneas de instrucciones?

Para aclarar la relación entre los módulos del programa, se recomienda insertar secuencias de instrucciones encajadas en el texto de programación y escribir instrucciones con la misma profundidad de apilamiento, directamente unas debajo de las otras. El efecto logrado es puramente visual, únicamente afecta al valor de un programa como medio de información de persona a persona. DEF INSERT() INT PART, COUNTER INI SPTP HOME Vel=100% DEFAULT LOOP FOR COUNTER = 1 TO 20 PART = PART+1 ;Imposible aplicar sangría en formularios inline SPTP P1 CONT Vel=100% TOOL[2]:Gripper BASE[2]:Table PTP XP5 ; Movimiento con KRL ENDFOR


61 / 255

Programación de robots 2 ... ENDLOOP

¿Qué se consigue mediante una identificación adecuada de nombres de datos?

Para poder indicar correctamente la función de datos y señales en un programa del robot, se recomienda utilizar términos de valor informativo durante la asignación de los nombres. Entre ellos, p. ej.:    

2.4

Nombre de texto largo para señales de entrada y de salida Nombres de Tool y Base Declaraciones de señales para señales de entrada y de salida Nombres de puntos

Cómo crear un plan de ejecución del programa

¿Qué es un PEP?

Un plan de ejecución del programa (PEP) es un diagrama de flujo para un programa que también se denomina como plan de estructura del programa. Es una representación gráfica para la transformación de un algoritmo en un programa y describe la secuencia de operaciones para la solución de una tarea. Los símbolos para los planes de ejecución del programa están regulados en la norma DIN 66001. Los planes de ejecución del programa también se utilizan a menudo en programas de ordenador para la representación de procesos y tareas. En comparación con una descripción basada en un código, el algoritmo del programa presenta una legibilidad considerablemente más sencilla, ya que, gracias a la representación gráfica, la estructura se puede reconocer mucho mejor. Los errores de estructura y programación se evitan de forma más sencilla con la transformación posterior en código de programación, ya que en caso de aplicación correcta de un PEP, es posible la transformación directa en un código de programación. Al mismo tiempo, con la creación de un PEP se obtiene una documentación del programa que se va a crear.    

Símbolos PEP

Herramienta para la estructuración del proceso de un programa La ejecución del programa es fácilmente legible Los errores en la estructura se pueden reconocer de forma más sencilla Documentación simultánea del programa

Comienzo o fin de un proceso o de un programa

Fig. 2-1 Combinación de indicaciones y operaciones

Fig. 2-2 Ramificación

62 / 255



Fig. 2-3 Indicaciones generales en el código de programa

Fig. 2-4 Llamada de subprograma

Fig. 2-5 Indicación de entrada/salida

Fig. 2-6


63 / 255


Ejemplo PEP

Fig. 2-7 Cómo se crea un PEP

Partiendo de la presentación de usuario, el problema se perfecciona progresivamente hasta que se puedan visualizar lo suficiente los componentes elaborados de este modo para poder adaptarlos en KRL. Los proyectos que se creen en los siguientes pasos de desarrollo se diferencian por el aumento en la precisión de detalles. 1. 2. 3. 4. 5.

64 / 255

Subdivisión aproximada del proceso completo en aprox. 12 páginas División de la tarea completa en tareas parciales pequeñas Subdivisión aproximada de las tareas parciales Perfeccionamiento de la subdivisión de las tareas parciales Aplicación en código KRL


3 Introducción al nivel del experto

3

Introducción al nivel del experto

t

3.1

Resumen Esta unidad incluye los siguientes contenidos: 

3.2

Utilizar el nivel experto

Utilizar el nivel experto

Descripción

La unidad de control del robot ofrece diferentes grupos de usuarios con diferentes funciones. Se pueden seleccionar los siguientes grupos de usuarios:  Operario Grupo de usuario para el operario. Esto es el grupo de usuario por defecto.  Usuario Grupo de usuario para el operario. (Los grupos de usuarios del operario y del usuario están declarados por defecto para el mismo grupo destinatario.)  Experto Grupo de usuario para el programador. Este grupo de usuario está protegido por una contraseña.  Administrador Mismas funciones que las del grupo de usuario Experto. A modo adicional es posible integrar plug-ins en la unidad de control del robot. Este grupo de usuario está protegido por una contraseña. La contraseña por defecto 



kuka se debería cambiar.

Técnico de mantenimiento de seguridad Este usuario puede activar una configuración de seguridad existente del robot mediante un código de activación. Si no se utiliza ninguna opción Safe, p. ej. KUKA.SafeOperation o KUKA.SafeRangeMonitoring, el técnico de mantenimiento de seguridad dispone de derechos complementarios. En este caso, por ejemplo, está autorizado para configurar las funciones de seguridad estándar. El grupo de usuario está protegido por una contraseña. La contraseña por defecto kuka se debería cambiar. Técnico de mantenimiento de seguridad Este grupo de usuario solo es relevante cuando se utiliza KUKA.SafeOperation o KUKA.SafeRangeMonitoring. El grupo de usuario está protegido por una contraseña. La contraseña por defecto kuka se debería cambiar.

Funciones avanzadas del grupo de usuario Experto: 

 

Protegido por contraseña (predeterminada: kuka) La programación en el editor mediante KRL es posible El grupo de usuario Experto se vuelve a abandonar automáticamente  cuando se cambia al modo de servicio AUT o AUT EXT  cuando durante un tiempo determinado no se realiza ninguna operación en la interfaz de usuario (300 s) Como experto, en el menú Procesar se encuentran disponibles todas las funciones.


65 / 255


Funciones

Crear programas mediante plantillas 











Cell: El programa Cell disponible solo se puede sustituir o crearse de nuevo en caso de que se borre Cell. Expert: Módulo compuesto por ficheros SRC y DAT en los que solo está disponible el encabezamiento y el final del programa. Expert Submit: Fichero Submit (SUB) adicional compuesto de encabezamiento y final del programa. Function: Creación de función de fichero SRC, en el que solo se crea el encabezamiento de la función con una variable BOOL. El final de la función está disponible, pero debe programarse el retorno. Módulo: Módulo compuesto de ficheros SRC y DAT, en los que está disponible el encabezamiento y el final del programa y la estructura base (INI y 2x PTP HOME). Submit: Fichero Submit (SUB) adicional compuesto de encabezamiento y final del programa y estructura base (DECLARATION, INI, LOOP/ENDLOOP).

El filtro determina cómo se deben mostrar los programas en la lista de ficheros. Se puede elegir entre los siguientes filtros:   



Deseleccionar o cerra el programa. Botón Editar > Filtro y, después, seleccionar Detalle o Módulo Detalle Los programas se visualizan como ficheros SRC y DAT (ajuste por defecto). Módulos Los programas se muestran como módulos.

Fig. 3-1: Menú "Editar"

66 / 255



Abrir/cerrar FOLD 

 

Los FOLD siempre están cerrados para el usuario y se pueden abrir como experto. El experto también puede programar FOLD propios. La sintaxis para un FOLD es la siguiente: ;FOLD Nombre Instrucciones

;ENDFOLD

Las filas ENDFOLD pueden asignarse más fácilmente si se introduce aquí el nombre del FOLD. Pueden encajarse los FOLD. Mostrar/ocultar la línea DEF 



Procedimiento para activar el nivel experto y subsanar errores

Por defecto, la línea DEF está oculta. Solo se pueden efectuar declaraciones en un programa una vez que la línea DEF sea visible. La línea DEF se muestra y oculta independientemente para cada programa abierto y seleccionado. Si está activada una vista en detalle, la línea DEF está visible y no es necesario mostrarla expresamente.

Activar el nivel experto 1. Seleccionar en el me nú principal la secuencia Configuración > Grupo de usuario. 2. Registrarse como experto: Pulsar Iniciar sesión. Marcar el grupo de usuario Experto y confirmar con Iniciar sesión. 3. Introducir la contraseña (predeterminada: kuka) y confirmar con Iniciar sesión.

Subsanar el error en el programa 1. Seleccionar un módulo defectuoso en el nav egador

Fig. 3-2: Programa incorrecto 2. Seleccionar el menú Lista de errores 3. Se abre la indicación de errores ( nombre del programa.ERR) 4. Seleccionar el error, se representa una descripción detallada abajo en la indicación de errores 5. En la ventana de indicación de errores, pulsar la tecla Visualizar y saltar al programa defectuoso 6. Subsanar el error 7. Abandonar el editor y guardar


67 / 255


3 .3

Ejercicio: Medición Tool y Base



 

Requisitos


Función: introducción de los datos de herramienta de la garra

Medición de la herramienta con el método de 4 puntos XYZ y el método World 5D Medición de la herramienta mediante la entrada de valores numéricos Medición Base según el método de 3 puntos

Conocimientos teóricos sobre la medición de una herramienta Conocimientos teóricos sobre la medición de una base

Para la garra de formación con entrada numérica, indicar:

Fig. 3-3: College garra: Posición del TCP 

Garra de formación KR 16

Fig. 3-4: Garra de formación KR 16

68 / 255



Masa: M = 4,3 kg Centro de masa: X=41mm Y=35mm Orientación: A = 0° B = 0° Momentos de inercia: JX = 0,03 kgm2

Z=62mm C = 0°

JY = 0,04 kgm2

JZ = 0,12 kgm2

Y 177,73mm B 0

Z 172,49 mm C 180

Garra esquina derecha X 122,64mm A 45 

Garra de formación celda modular

Fig. 3-5: Garra de formación celda modular Masa: M = 4,4 kg Centro de masa: X=7mm Y=-24mm Orientación: A = 0° B = 0° Momentos de inercia: JX = 0,02 kgm2

Z=80mm C = 0°

JY = 0,05 kgm2

JZ = 0,11 kgm2

Y -123,97mm B 0

Z 172,71 mm C -180

Garra esquina derecha X 175,38mm A -45 

Garra de formación celda móvil


69 / 255


Fig. 3-6: Garra de formación celda móvil Masa: M = 2 kg Centro de masa: X = 23 mm Y = mm 0 Orientación: A = 0° B = 0° Momentos de inercia: JX = 0,002 kgm2

Z = 61mm

JY = 0,004 kgm2

C = 0° JZ = 0,003 kgm2

Garra esquina derecha X mm 12 A 0


Y mm 0 B 0

Z 77 mm C 0

Medición clavija 

 



Utilizar la clavija superior del depósito de clavijas y sujetarla manualmente en la garra. Medir la clavija con el método 4 puntos XYZ y el método ABC-World 5D. Utilizar como número de herramienta el 2 y como denominación "Clavija 1". Utilizar para ello los datos de carga de herramienta para la clavija indicados abajo.

Medición "base azul"  La medición de la BASE número 2 se realiza con la Clavija 1 y el método de 3 puntos. Como denominación se utiliza "base azul".

Datos de carga de la herramienta garra con clavija

70 / 255



Garra de formación KR 16



Fig. 3-7: Garra de formación KR 16 Masa: M = 4,9 kg Centro de masa: X=53mm Y=49mm Orientación: A = 0° B = 0° Momentos de inercia: JX = 0,02 kgm2 

Z=65mm C = 0°

JY = 0,03 kgm2

JZ = 0,15 kgm2

Garra de formación de celda modular

Fig. 3-8: Garra de formación celda modular Masa: M = 5 kg Centro de masa: X=23mm Y=–38mm Orientación: A = 0° B = 0° Momentos de inercia: JX = 0,02 kgm2

JY = 0,07 kgm2


Z=84mm C = 0° JZ = 0,14 kgm2 71 / 255


Garra de formación celda móvil

Fig. 3-9: Garra de formación celda móvil Masa: M = 2,14 kg Centro de masa: X = 30 mm Y = mm 0 Orientación: A = 0° B = 0° Momentos de inercia:

Z = 64mm

2

C = 0° 2

JX = 0,002 kgm JY = 0,004 kgm Lo que se debe saber tras el ejercicio:

2

JZ = 0,003 kgm

1. ¿Qué ventajas ofrece la utilización de una base sobre la mesa? ............................................................. ............................................................. 2. ¿Dónde se encuentra el punto de referencia para la medición de una herramienta? ............................................................. ............................................................. 3. ¿Cuántos sistemas de base diferentes presenta el software de KUKA? ............................................................. ............................................................. 4. ¿Cuál es la diferencia entre los métodos ABC-World 5D y 6D? ............................................................. ............................................................. 5. ¿Dónde se encuentra una base sin medir (estado de suministro)? ............................................................. .............................................................

72 / 255



3.4

Ejercicio: Navegador experto bucle sinfín


Después de completar correctamente este ejercicio, se dispondrá de la competencia necesaria para efectuar las siguientes tareas:   

Requisitos

Los siguientes requisitos son imprescindibles para superar el ejercicio con éxito: 

 


Creación de módulos en el nivel experto Combinación de módulos individuales en un programa principal Utilización de un bucle sinfín

Conocimientos teóricos sobre el navegador en el nivel experto Conocimientos teóricos sobre la utilización de subprogramas globales Conocimientos teóricos sobre un bucle sinfín

1. Crear un plan de ejecución del programa (PEP) antes del inicio de la programación. 2. Crear dos módul os adecuados (cubo_dep/cubo_rec). 3. La llamada y el bucle sinfín deben tener lugar en el módulo DEPÓSITO. 4. Comprobar el programa en los modos de servicio T1, T2 y Automático. Se deben tener en cuenta las prescripciones de seguridad enseñadas.

Lo que se debe saber tras el ejercicio: 1. ¿Cuál es la diferencia al crear un programa entre la selección de MODUL y EXPERT? ............................................................ ............................................................ ............................................................ ............................................................ ............................................................ 2. ¿Qué se entiende por el modo de ejecución del programa Paso a paso? ............................................................ ............................................................ 3. ¿Cuál es la diferencia entre SELECCIONAR y ABRIR un programa? ............................................................ ............................................................ ............................................................ 4. ¿Cuál es el aspecto de la sintaxis para un "pliegue"? ............................................................ ............................................................ 5. ¿Qué consecuencias tiene la modificación posterior de la posición HOME? ............................................................ ............................................................


73 / 255


74 / 255


4 Variables y declaraciones

4

Variables y declaraciones

4.1




4.2

Gestión de datos en KRL Tipos de datos simples con KRL Visualizar variables Grupos/campos con KRL Estructuras con KRL Tipo de datos de enumeración ENUM

Gestión de datos en KRL

Generalidades sobre variables

Fig. 4-1: Identificación de variables 





  

Convenciones sobre los nombres

En la programación de robots con KRL, una variable es en, sentido amplio de la palabra, simplemente un recipiente para operandos ("valores") que aparecen en el desarrollo de un proceso del robot. Una variable dispone de una dirección determinada asignada en la memoria de un ordenador. Una variable se denomina mediante un nombre que no es una palabra clave de KUKA. Cada variable está unida a un tipo determinado de archivos. La declaración del tipo de datos es necesaria antes de la utilización. En KRL se distingue entre variables locales y globales.

En la elección del nombre de la variable se deben tener en cuenta las siguientes reglas:  

  

Los nombres en KRL pueden tener una longitud máxima de 24 caracteres. Los nombres en KRL pueden contener letras (A-Z), cifras (0-9) y los caracteres especiales "_" y "$". Los nombres en KRL no deben comenzar con cifras. Los nombres en KRL no deben ser palabras clave. La utilización de mayúsculas y minúsculas es indiferente.

Consejos  Utilizar nombres de variables adecuados y autoexplicativos.  No utilizar nombres o abreviaturas crípticos. Utilizar una longitud de nombre adecuada, no gastar cada vez 24 carac teres.

Doble declaración de variables





Una doble declaración ocurre siempre que se usan los mismos nombres de variables (cadenas). No se trata de una doble declaración cuando se utiliza el mismo nombre en archivos SRC o DAT distintos.


75 / 255




Tipos de datos en KRL



Las dobles declaraciones en el mismo archivo SRCy DAT no están permitidas y generan un mensaje de error. Las dobles declaraciones en el archivo SRC o DAT y en el archivo $CONFIG.DAT están permitidas:  Durante la ejecución de la rutina de programación en la que ha sido declarada la variable, solo se modifica el valor local y no el valor en el archivo $CONFIG.DAT. Durante la ejecución de la rutina de programación "ajena" solo se re curre al valor procedente del archivo $CONFIG.DAT y se modifica.

Tipos de datos estándar predefinidos  BOOL: resultados del tipo "SÍ"/"NO" 





REAL: número de coma flotante, resultados de operaciones, para poder evitar errores de redondeo INT: número entero, típica variable de recuento para bucles de recuento o contadores de piezas CHAR: solo un carácter La cadena o el texto solo se puede realizar como campo CHAR

Tipos de datos simples Palabraclave Rango de valores Ejemplos 

Número entero INT -231 ... (231-1) -199 o 56

Número con coma flotante REAL ± 1.1 10-38... ± 3.4 10+38 -0,0000123 o 3,1415

Valores lógicos BOOL TRUE / FALSE TRUE o FALSE

Carácter individua l CHAR Juego de caracteres ASCII "A" o "q" o "7"

Campos / Grupo

Voltage[10] = 12.75 Voltage[11] = 15.59

Guardar varias variables del mismo tipo de datos mediante el índice Durante la inicialización o en caso de cambio del valor se debe indicar el índice  El tamaño máximo del campo depende de las necesidades de almacenamiento del tipo de datos Tipo de datos de enumeración  



color = #red 

 



Todos los valores del tipo de enumeración se definen en la creación con nombre (en forma de texto) El sistema también determina un orden El número máximo de elementos depende del espacio de almacena-

miento Tipo de datos combinado / estructura

Date = {day 14, month 12, year 1996} 





76 / 255

Tipo de datos combinado de componentes de diferentes tipos de datos Los componentes pueden estar compuestos por tipos de datos simples, pero también por estructuras Es posible el acceso a componentes individuales



Creación de variables

Declaración de variables   

 

 

Vida útil y validez de las variables

La declaración se debe realizar siempre antes de su uso. A cada variable se le debe asignar un tipo de datos. Se deben respetar las convenciones sobre nombres en la asignación de nombres. La palabra clave para la declaración es DECL. Se puede suprimir la palabra clave DECL en los cuatro tipos de datos simples. Las asignaciones de valores se realizan en avance. La declaración de variables se puede realizar en diferentes puntos. Esto afecta a la vida útil y la validez de las correspondientes variables.

Vida útil de las variables en KRL 





Por vida útil se entiende el periodo de tiempo en el que se reserva memoria para la variable. Las variables de duración temporal vuelven a liberar su espacio de almacenamiento al abandonar el programa o la función. Las variables de una lista de datos mantienen su valor actual (el más reciente) de forma permanente en la memoria.

Validez de las variables en KRL 





Declaración de variables en función del lugar de almacenamiento

Las variables declaradas como locales solo están disponibles y visibles en el programa en el cual han sido declaradas. Las variables globales están registradas en una lista de datos central (global). Las variables globales se pueden registrar también en un lista de datos local y aplicarles la palabra clave global al declararlas.

Variable en el fichero SRC  Una variable creada en el archivo SRC se denomina variable de tiempo de ejecución. Esta no siempre se puede visualizar.   Solo se encuentra disponible en la rutina de programación en la que ha sido declarada. Por tanto, la variable estará disponible durante la ejecución del programa. (Programa principal o subprograma local).  Deja libre de nuevo su espacio de memoria al alcanzar la última línea del programa (línea END). Variable en el archivo DAT local 

 

 



Se puede visualizar siempre durante la ejecución del programa del archivo SRC correspondiente. El valor de la variable se mantiene tras la finalización del programa. Está disponible en todo el archivo SRC, es decir, también en los subprogramas locales. También se puede crear como variable global. Recibe el valor actual en el archivo DAT y comienza con el valor guardado en una nueva llamada. Si la variable se declara como global, también está disponible a nivel global. Permite un acceso de lectura y de escritura en todas las rutinas de programación, si en el archivo DAT se define la palabra clave PUBLIC y en la declaración se usa adicionalmente la palabra clave GLOBAL.

Variable en el archivo de sistema $CONFIG.DAT  

Está disponible en todos los programas (global). Se puede visualizar siempre, incluso si ningún programa está activo.


77 / 255




Datos de sistema de KUKA





4 .3

Está disponible de forma global, es decir, en todas las rutinas de programación es posible un acceso de lectura y de escritura. Guarda el valor actual en el archivo $CONFIG.DAT. Los datos de sistema KUKA están presentes en todos los tipos de datos, p. ej., como Tipo de datos de enumeración, p. ej.: modo de servicio   Estructura, p. ej.: fecha/hora Las informaciones de sistema se obtienen a través de variables de sistema de KUKA. Estas leen la información actual del sistema   modifican las configuraciones actuales del sistema  están predefinidas y comienzan con el carácter "$"  $DATE (fecha y hora actuales)  $POS_ACT (posición actual del robot)  $MODE_OP(modo de servicio actual)  ...

Trabajar c on t ipos d e d atos s imples A continuación se explica la creación, la inicialización y la modificación de variables. En este caso solo se utilizan los tipos de datos simples.

Tipos de datos simples con KRL    

4.3.1

Números enteros (INT) Números con coma flotante (REAL) Valores lógicos (BOOL) Carácter individual (CHAR)

Declaración de v ariables

Principio de la declaración de variables

Ejemplo de estructura del programa en el fi chero SRC  



En la sección de declaración se deben declarar variables La sección de inicialización comienza con la primera asignación de valor, aunque a menudo con la línea "INI" En la sección de instrucciones se asignan o se modifican valores

DEF main( ) : Sección de declaraciones ... ; Sección de inicialización INI

... ; Sección de instrucciones PTP HOME Vel=100% DEFAULT ... END

Modificar la vista estándar  



78 / 255

La visualización de la línea DEF solo es posible como experto El proceso es necesario para acceder a la sección de declaración en los módulos delante de la línea "INI". Para poder ver la línea DEF y END, también es importante para la transferencia de variables a subprogramas



Planificar la declaración de variables    

Procedimiento en la declaración de variables con un tipo de datos simple

Establecer la vida útil Determinar la validez/disponibilidad Determinar el tipo de datos Asignación de nombre y declaración

Crear la variable en el fichero SRC 1. 2. 3. 4.

Grupo de usuario Experto Dejar mostrar la línea DEF Abrir el fichero SRC en el editor Realizar la declaración de las variables

DEF MY_PROG ( ) DECL INT counter DECL REAL price DECL BOOL error DECL CHAR symbol INI ... END

5. Cerrar el programa y guardar

Crear la variable en el fichero DAT 1. Grupo de usuario Experto 2. Abrir el fichero DAT en el editor 3. Realizar la declaración de las variables DEFDAT MY_PROG EXTERNAL DECLARATIONS DECL INT counter DECL REAL price DECL BOOL error DECL CHAR symbol ... ENDDAT

4. Cerrar la lista de datos y guardar

Crear variables en el fichero $CONFIG.DAT 1. Grupo de usuario Experto 2. Abrir en la carpeta SYSTEM el fichero $CONFIG.DAT en el editor DEFDAT $CONFIG BASISTECH GLOBALS AUTOEXT GLOBALS USER GLOBALS ENDDAT

3. Seleccionar el Fold "USER GLOBALS" y abrir con la tecla de función programable "Abrir/Cerrar Fold" 4. Realizar la declaración de las variables DEFDAT $CONFIG ... ;================================== ; Userdefined Types ;================================== ;================================== ; Userdefined Externals ;==================================


79 / 255

Programación de robots 2 ;================================== ; Userdefined Variables ;================================== DECL INT counter DECL REAL price DECL BOOL error DECL CHAR symbol ... ENDDAT


Crear la variable global en el fichero DAT 1. Grupo de usuario Experto 2. Abrir el fichero DAT en el editor 3. Ampliar lista de datos en el encabezamiento del programa con la palabra clave PUBLIC DEFDAT MY_PROG PUBLIC

4. Realizar la declaración de las variables DEFDAT MY_PROG PUBLIC EXTERNAL DECLARATIONS DECL GLOBAL INT counter DECL GLOBAL REAL price DECL GLOBAL BOOL error DECL GLOBAL CHAR symbol ... ENDDAT


4.3.2

Inicialización de variables con tipos de datos simples

Descripción de la inicialización con KRL









Principio de la inicialización

Después de la declaración, la variable solo tiene reservado un espacio de memoria. Su valor siempre es un valor no válido. En el archivo SRC se realiza la declaración y la inicialización siempre en dos líneas separadas. En el archivo DAT se realiza la declaración y la inicialización siempre en una línea. Un constante solo puede estar declarada en una lista de datos y debe ser inicializada inmediatamente. La sección de inicialización comienza con la primera asignación de valor.

Inicialización de números enteros 

Inicialización como número decimal

value = 58 

Inicialización como número binario

value = 'B111010'

Cálculo: 1*32+1*16+1*8+0*4+1*2+0*1 = 58

Binario Dec 

80 / 255

25 32

24

23

22

21

20

16

8

4

2

1

Inicialización hexadecimal


4 Variables y declaraciones value = 'H3A'

Cálculo: 3*16 +10 = 58

Procedimiento en la inicialización con KRL

Hex

0 1 2 3 4 5 6 7 8 9 A

B

C

D

E

F

Dec

01

11

12

13

14

15

23

45

67

89

10

Declaración e inicialización en el fichero SRC 1. Abrir el fichero SRC en el editor 2. La declaración se ha re alizado 3. Realizar la in icialización DEF MY_PROG ( ) DECL INT counter DECL REAL price DECL BOOL error DECL CHAR symbol INI counter = 10 price = 0.0 error = FALSE symbol = "X" ... END


Declaración e inicialización en el fichero DAT 1. Abrir el fichero DAT en el editor 2. La declaración se ha re alizado 3. Realizar la in icialización DEFDAT MY_PROG EXTERNAL DECLARATIONS DECL INT counter = 10 DECL REAL price = 0.0 DECL BOOL error = FALSE DECL CHAR symbol = "X" ... ENDDAT


Declaración en el fichero DAT e inicialización en el fichero SRC 1. Abrir el fichero DAT en el editor 2. Realizar la declaración DEFDAT MY_PROG EXTERNAL DECLARATIONS DECL INT counter DECL REAL price DECL BOOL error DECL CHAR symbol ... ENDDAT

3. Cerrar la lista de datos y guardar 4. Abrir el fichero SRC en el editor 5. Realizar la in icialización


81 / 255

Programación de robots 2 DEF MY_PROG ( ) ... INI counter = 10 price = 0.0 error = FALSE symbol = "X" ... END


Declaración e

Descripción

inicialización de una constante

 

Las constantes se crean con la palabra clave CONST. Las constantes solo se pueden crear en listas de datos.

creación de constantes 1. Abrir el fichero DAT en el editor. 2. Realizar la declaración y la inic ialización. DEFDAT MY_PROG EXTERNAL DECLARATIONS DECL CONST INT max_size = 99 DECL CONST REAL PI = 3.1415 ... ENDDAT

3. Cerrar la lista de datos y guardar.

4.3.3

Manipulación de valores de variables de tipos de datos simples con KRL

Listado de las posibilidades para la modificación de valores de variables con KRL

Los valores de las variables se modifican de diferentes maneras en las rutinas de programación (fichero SRC) en función de la tarea. A continuación se comentarán los métodos más comunes. La manipulación mediante operaciones de bit y funciones estándar es posible, pero aquí no se profundizará en ello.

Manipulación de datos por medio de 



Tipos de cálculo básicos  (+) Suma  (-) Resta  (*) Multiplicación  (/) División Operaciones de comparación  (==) idéntico / igualdad  (<>) desigual  (>) mayor que (<) menor que (>=) mayor o igual que  (<=) menor o igual que Operaciones lógicas  (NOT) Inversión  (AND) Y lógico  (OR) O lógico  (EXOR) O excluyente Operaciones de bit  (B_NOT) Inversión por bits  





82 / 255


4 Variables y declaraciones   

(B_AND) Combinación de Y por bits (B_OR) Combinación de O por bits (B_EXOR) Combinación de O excluyente por bits

Funciones estándar       

Relaciones en la manipulación de datos

Función absoluta Función raíz Función de seno y coseno Función de tangente Función de arcocoseno Función de arcotangente Varias funciones para la manipulación de cadenas

Modificación de valores con la utilización del tipo de datos REAL y INT 

Redondear hacia arriba/hacia abajo

; Declaración DECL INT A,B,C DECL REAL R,S,T ; Inicialización A = 3 ; A=3 B = 5.5 ; B=6 (a partir de x.5 se redondea a la alza) C = 2.25 ; C=2 (redondear a la baja) R = 4 ; R=4.0 S = 6.5 ; S=6.5 T = C ; T=2.0 (se utiliza el valor redondeado a la baja) 

Resultados de operaciones aritméticas (+;-;*)

Operandos

IN T

REAL

INT REAL

INT REAL

REAL REAL

; Declaración DECL INT D,E DECL REAL U,V ; Inicialización D = 2 E = 5 U = 0.5 V = 10.6 ; Sección de instrucciones (manipulación de datos) D = D*E ; D = 2 * 5 = 10 E = E+V ; E= 5 + 10.6 = 15.6 -> Redondear a la alza E=16 U = U*V ; U= 0.5 * 10.6 = 5.3 V = E+V ; V= 16 + 10.6 = 26.6 

Resultados de operaciones aritméticas (/) Particularidades en las operaciones aritméticas con valores enteros: 



En caso de resultados intermedios de operaciones enteras puras, se eliminarán todas las posiciones decimales. En la asignación de valor a una variable entera, el resultado se redondeará de acuerdo con las reglas normales de cálculo.

; Declaración DECL INT F


83 / 255

Programación de robots 2 DECL REAL W ; Inicialización F = 10 W = 10.0 ; Sección de instrucciones (manipulación de datos) ; INT / INT -> INT F = F/2 ; F=5 F = 10/4 ; F=2 (10/4 = 2.5 -> Cortar posición decimal) ; REAL / INT -> REAL F = W/4 ; F=3 (10.0/4=2.5 -> Redondear a la alza) W = W/4 ; W=2.5

Operaciones de comparación Con las operaciones de comparación se pueden formar expresiones lógicas. El resultado de una comparación siempre es del tipo de datos BOOL.

Operador / KRL

Descripción

==

Tipos de datos admisibles

idéntico/igual- INT, REAL, CHAR, BOOL dad desigual INT,REAL,CHAR,BOOL mayorque INT,REAL,CHAR menorque INT,REAL,CHAR mayoroigual INT, REAL, CHAR que menoroigual INT, REAL, CHAR que

<> > < >= <=

; Declaración DECL BOOL G,H ; Inicialización/sección de instrucciones G = 10>10.1 ; G=FALSE H = 10/3 == 3 ; H=TRUE G = G<>H ; G=TRUE

Operaciones lógicas Con las operaciones lógicas se pueden formar expresiones lógicas. El resultado de una operación de este tipo siempre es del tipo de datos BOOL.

Operaciones

NOTA

AANDB

AORB

A EXOR B

A=FALSE A=FALSE

B=FALSE B=TRUE

TRUE TRUE

FALSE FALSE

FALSE TRUE

FALSE TRUE

A=TRUE A=TRUE

B=FALSE B=TRUE

FALSE FALSE

FALSE TRUE

TRUE TRUE

TRUE FALSE

; Declaración DECL BOOL K,L,M ; Inicialización/sección de instrucciones K = TRUE L = NOT K ; L=FALSE

84 / 255


4 Variables y declaraciones M = (K AND L) OR (K EXOR L) ; M=TRUE L = NOT (NOT K) ; L=TRUE

Los operadores se ejecutan en el orden de su prioridad

Prioridad 1 2 3 4 5 6 7

Operador NOT(B_NOT) Multiplicación (*); división (/) Suma (+), resta (-) AND(B_AND) EXOR(B_EXOR) OR(B_OR) cualquier comparación (==; <>; ...)

; Declaración DECL BOOL X, Y DECL INT Z ; Inicialización/sección de instrucciones X = TRUE Z = 4 Y = (4*Z+16 <> 32) AND X ; Y=FALSE

Procedimiento para la manipulación de datos

1. 2. 3. 4.

Especificar el tipo de datos para la variable o variables Determinar la validez y la vida útil de las variables Realizar la declaración de variables Inicializar la variable

5. Manipular la variable en las rutinas de programación, es decir, siempre en el fichero *.SRC 6. Guardar y cerrar el fichero *.SRC

Instrucción HALT

HALT se usa, sobre todo, para realizar pruebas en la fase de programación,

por ejemplo, para visualizar el contenido de una variable en tiempo de ejecución. 



La instrucción HALT detiene el programa. La última instrucción de movimiento lanzada se ejecuta por completo. El programa puede continuarse exclusivamente con la tecla de arranque. A continuación se ejecutará la siguiente instrucción después de HALT. En un programa de interrupción el programa no se detiene hasta que se haya ejecutado por completo el procesamiento.

Ejemplo: DEF program() DECL BOOL a,b INI ... SPTP XP1 a=$IN[1] b=$IN[2] HALT IF ((a == TRUE) AND (b == FALSE)) THEN .. ENDIF ...


85 / 255


4 .4

Visualizar variables

Mostrar y modificar el valor de una variable

1. Seleccionar en el menú principal Visualización > Variable > Individual. Se abre la ventana Visualización de variable individual. 2. Introducir el nombre de la variable en el campo Nombre. 3. Cuando un programa está seleccionado, el programa se incluye automáticamente en el campo Módulo. Si debe mostrarse una variable de otro programa, introducir el programa como sigue: /R1/Nombre de programa No indicar ninguna carpeta entre /R1/ y el nombre del programa. No indicar ninguna extensión de fichero al nombrar el programa. 4. Pulsar la tecla Enter. En el campo Valor actual se visualiza el valor actual de la variable. Si no se indica nada, entonces significa que todavía no se ha asignado ningún valor a la variable. 5. Introducir el valor que se desee en el campo Valor nuevo. 6. Pulsar la tecla Enter. En el campo Valor actual aparece el nuevo valor.

Fig. 4-2: Ventana Visualización de variable individual Pos. 1 2 3 4

Descripción Nombre de la variable que debe modificarse. Nuevo valor que se debe asignar a la variable. Programa en el cual se busca la variable. En las variables del sistema el campo Módulo no es relevante. Este campo tiene dos estados: 

: el valor mostrado no se actualiza de forma automática.



: el valor mostrado se actualiza de forma automática.

Para alternar entre los diferentes estados:  

Visualización de informaciones del sistema

86 / 255

Pulsar Actualizar. Alternativa: Shift + Enter

Procedimiento para visualizar marcas, contadores y temporizadores: 

Seleccionar en el menú principal la secuencia Visualización > Variable.



Se pueden seleccionar diferentes variables del sistema:    

Marcas cíclicas Marcas Contador Temporizador

Procedimiento para visualizar entradas y salidas: 

4.5

Seleccionar en el menú principal la secuencia Visualización > Entradas/ salidas > Entradas digitales o Salidas digitales.

Grupos / campos con KRL

Descripción de campos con KRL

Los campos, o también denominados grupos, ofrecen espacio de almacenamiento para varias variables del mismo tipo de datos, que se diferencian mediante un índice 



  

El espacio de almacenamiento de los campos es finito, es decir, el tamaño máximo del campo depende de las necesidades de almacenamiento del tipo de datos Durante la declaración se deberán conocer el tamaño de campo y el tipo de datos El índice de inicio en KRL comienza siempre con 1 La inicialización siempre se puede realizar individualmente Una inicialización en el fichero SRC también se puede realizar mediante un bucle

Dimensiones del campo 

Campo de 1 dimensiones

dimension[4]= TRUE 


dimension[2,1]= 3.25 


dimension[3,4,1]= 21 

Relaciones en la utilización de campos

El campo de 4 dimensiones o superior no es compatible en KRL

La vida útil y la validez de las variables de campo es la misma que en la utilización de variables de tipo de datos simple .

Declaración de campo 

Creación en el fichero SRC

DEF MY_PROG ( ) DECL BOOL error[10] DECL REAL value[50,2] DECL INT parts[10,10,10] INI ... END 

Creación en la lista de datos (también $CONFIG.DAT)

DEFDAT MY_PROG EXTERNAL DECLARATIONS DECL BOOL error[10] DECL REAL value[50,2] DECL INT parts[10,10,10]


87 / 255

Programación de robots 2 ... ENDDAT

Declarar el campo e inicializar en el fichero SRC 

Cada campo por llamada de índice individual

DECL BOOL error[10] INI error[1]=FALSE error[2]=FALSE error[3]=FALSE error[3]=FALSE error[4]=FALSE error[5]=FALSE error[6]=FALSE error[7]=FALSE error[8]=FALSE error[9]=FALSE error[10]=FALSE 

Mediante bucles adecuados

DECL BOOL error[10] DECL INT x INI FOR x = 1 TO 10 error[x]=FALSE ENDFOR

Tras la finalización del bucle x tiene el valor 11

Inicializar el campo en la lista de datos 

Cada campo por llamada de índice individual e indicación de espera posterior en la lista de datos

DEFDAT MY_PROG EXTERNAL DECLARATIONS DECL BOOL error[10] error[1]=FALSE error[2]=FALSE error[3]=FALSE error[4]=FALSE error[5]=FALSE error[6]=FALSE error[7]=FALSE error[8]=FALSE error[9]=FALSE error[10]=FALSE 

Declaración no permitida e inicialización en la lista de datos

DEFDAT MY_PROG EXTERNAL DECLARATIONS DECL BOOL error[10] DECL INT size = 32 error[1]=FALSE error[2]=FALSE error[3]=FALSE error[4]=FALSE

88 / 255


4 Variables y declaraciones error[5]=FALSE error[6]=FALSE error[7]=FALSE error[8]=FALSE error[9]=FALSE error[10]=FALSE

Genera diez mensajes de error "Paso de valor inicial no está en la sección inicial" El campo completo podrá visualizarse si se selecciona Indicación > Variable > Únicos en el menú principal y se introducen los nombres de las variables entre corchetes y sin índice (por ejemplo error[]) en el campo Nombre

Declarar campos en la lista de datos e inicializar en el fichero SRC 

Si un campo se crea de este modo en la lista de datos, los datos actuales no se podrán consultar en la lista de datos; los valores actuales solo se pueden comprobar a través de la visualización de variables.

DEFDAT MY_PROG EXTERNAL DECLARATIONS DECL BOOL error[10]

DEF MY_PROG ( ) INI error[1]=FALSE error[2]=FALSE error[3]=FALSE ... error[10]=FALSE

o bien DEF MY_PROG ( ) INI FOR x = 1 TO 10 error[x]=FALSE ENDFOR

Inicialización mediante bucles 


DECL INT parts[15] DECL INT x FOR x = 1 TO 15 parts[x]= 4 ENDFOR 


DECL INT parts_table[10,5] DECL INT x, y FOR x = 1 TO 10 FOR y = 1 TO 5 parts_table[x, y]= 6 ENDFOR ENDFOR


89 / 255



DECL INT parts_palette[5,4,3] DECL INT x, y, z FOR x = 1 TO 5 FOR y = 1 TO 4 FOR z = 1 TO 3 parts_palette[x, y, z]= 12 ENDFOR ENDFOR ENDFOR

Procedimiento

1. Determinar el tipo de datos para el campo

paragrupos programar los

2. 3. 4. 5.

Determinar la validez y la vida útil del campo Ejecutar la declaración del campo (SCR o DAT; en este caso SRC) Inicializar los elementos del campo Manipular el campo en las rutinas de programación, es decir, siempre en el fichero SRC 6. Cerrar el fichero SRC y guardar DEF MY_PROG ( ) DECL REAL palette_size[10] DECL INT counter INI ; Inicialización FOR counter = 1 TO 10 palette_size[counter] = counter * 1.5 ENDFOR ... ; Cambiar el valor individualmente palette_size[8] = 13 ... ; Comparación de valores IF palette_size[3] > 4.2 THEN ...

90 / 255



4.6

Ejercicio: Campos con tipos de datos simples y bucle de conteo



Requisitos

Los siguientes requisitos son necesarios para completar este ejercicio correctamente: 

  


Declarar, inicializar campos con tipos de datos simples Procesar elementos de campo individuales Trabajar con la indicación de variables (configuración/indicación)

Conocimientos de tipos de datos simples Conocimientos teóricos sobre campos Conocimientos teóricos sobre el bucle FOR Conocimientos teóricos sobre la indicación de variables

Ampliar de la siguiente manera los programas creados: 







Crear un campo de una dimensión con el tamaño 12. El contenido de los campos debe ser la letra "O" o "X". Antes del inicio del proceso, todos los campos deben estar ocupados con "O". Tras el depósito del 1º cubo, el 1º cubo deberá recibir la letra "X". Para el depósito posterior se deberá proceder del mismo modo. Comprobar el índice de campo actual y el contenido del campo.

Fig. 4-3  Determinar dónde se declaran las variables. Ampliar el plan de ejecución del programa existente con este campo.   Crear un grupo nuevo para la indicación de las variables de campo necesarias.  Comprobar el programa en los modos de servicio T1, T2 y Automático. Se deben tener en cuenta las prescripciones de seguridad enseñadas. Lo que se debe saber tras el ejercicio: 1. ¿Dónde se dimensiona el tamaño de un campo? Edición: 24.02.2015 Versión: P2KSS8_robotprogramming_2_(R2)_V4

91 / 255


............................................................. ............................................................. 2. ¿Qué diferencia la declaración de un campo en el fichero SRC y en el fichero DAT? ............................................................. ............................................................. 3. ¿Qué mensaje de error aparece si se sobrepasa el índice de campo? ............................................................. ............................................................. 4. Declarar un campo de 3 dimensiones con el nombre de Precio del armario. El precio del armario se calcula de los componentes longitud, anchura y profundidad. ¿El surtido comprende 5 longitudes diferentes, 3 anchuras diferentes y 2 profundidades diferentes? ............................................................. ............................................................. 5. ¿Cómo puede visualizarse por completo el campo superior Precio del armario? ............................................................. .............................................................

92 / 255



4.7

Crear estructuras con KRL

Variables con varias informaciones individuales

Fig. 4-4 Tipo de datos combinado: Estructura Con los campos se pueden combinar variables del mismo tipo de datos.  En el mundo real, muchas veces también existen variables de tipos de datos diferentes.  Así, un coche tiene una potencia de motor o un número de kilómetros de tipo Integer (entero). Para el precio se ofrece el tipo Real. Por el contrario, la existencia de una instalación de aire acondicionado es más bien del tipo de datos Bool.  Todo junto describe un coche. Una estructura se puede definir por sí misma con la palabra clave STRUC.   Una estructura es un conjunto de diferentes tipos de datos. STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition 

Utilización de una estructura

Una estructura debe estar definida previamente para que se pueda seguir utilizando posteriormente.

Disponibilidad/definición de una estructura 







Las estructuras creadas localmente no son válidas al alcanzar la línea END Las estructuras que se utilicen en varios programas deben declararse en el fichero $CONFIG.DAT Las estructuras autodefinidas deberán terminar con TYPE para una mejor visibilidad En una estructura se pueden utilizar los tipos de datos simples INT, REAL, BOOL y CHAR.

STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition 

En una estructura se pueden integrar campos CHAR.

STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition, CHAR car_model[15] 

En una estructura se pueden utilizar también estructuras conocidas, como una posición POS.

STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition, POS car_pos 

Después de la definición de la estructura se debe declarar una variable de trabajo.

STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition DECL CAR_TYPE my_car

Inicialización /modificación de una estructura  

La inicialización se puede realizar mediante paréntesis. Durante la inicialización mediante paréntesis solo se pueden utilizar constantes (valores fijos).


93 / 255


El orden de la asignación de valores no se debe tener en cuenta.

my_car = {motor 50, price 14999.95, air_condition TRUE} my_car = {price 14999.95, motor 50, air_condition TRUE} 

 

En una estructura no se deben indicar todos los elementos de la estructura. Una estructura se inicializa con un elemento de la estructura. Los valores no inicializados son, o se ajustan como, desconocidos.

my_car = {motor 75} ; valor desconocido para precio y aire acondicionado 

La inicialización también se puede realizar mediante el separador de puntos.

my_car.price = 9999.0 

Un elemento de la estructura se puede modificar individualmente en cualquier momento mediante el separador de puntos. En este caso no se borran ni modifican el resto de elementos de la estructura.

my_car = {price 14999.95, motor 50, air_condition TRUE} my_car.price = 12000.0 ; valor mantenido para motor y aire acondicionado

No obstante: my_car = {price 14999.95, motor 50, air_condition TRUE} my_car = {price 12000.0} ; se borra el valor para motor y aire acondicionado

KUKA trabaja mucho con las estructuras predefinidas que se encuentran guardadas en el sistema. Se pueden encontrar ejemplos en las posiciones y la programación de mensajes.

Estructuras predefinidas de KUKA a partir del sector de las posiciones  

  

AXIS: STRUC AXIS REAL A1, A2, A3, A4, A5, A6 E6AXIS: STRUC E6AXIS REAL A1, A2, A3, A4, A5, A6, E1, E2, E3, E4, E5, E6 FRAME: STRUC FRAME REAL X, Y, Z, A, B, C POS: STRUC POS REAL X, Y, Z, A, B, C INT S,T E6POS: STRUC E6POS REAL X, Y, Z, A, B, C, E1, E2, E3, E4, E5, E6 INT S,T

Inicialización de una estructura con una posición 

En la inicialización mediante paréntesis solo se pueden utilizar constantes (valores fijos)

STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition, POS car_pos DECL CAR_TYPE my_car my_car {price 14999.95, motor 50, air_condition TRUE, car_pos {X 1000, Y =500, A 0}} 

La inicialización también se puede realizar mediante el separador de puntos

my_car.price = 14999.95 my_car.motor = 50 my_car.air_condition = TRUE my_car.car_pos = {X 1000, Y 500, A 0} 

94 / 255

En la inicialización mediante el separador de puntos también se puede insertar variables Edición: 24.02.2015 Versión: P2KSS8_robotprogramming_2_(R2)_V4

4 Variables y declaraciones my_car.price = my_price*0.85 my_car.car_pos.X = x_value my_car.car_pos.Y = 750+y_value

Creación de una estructura

1. Definición de la e structura STRUC CAR_TYPE INT motor, REAL price, BOOL air_condition

2. Declaración de las variables de trabajo DECL CAR_TYPE my_car

3. Inicialización de las variables de trabajo my_car = {motor 50, price 14999.95, air_condition TRUE}

4. Modificación de los valores y/o comparación de valores de las variables de trabajo my_car.price = 5000.0 my_car.price = value_car IF my_car.price >= 20000.0 THEN ... ENDIF


95 / 255


4.8

Ejercicio: Crear estructuras con KRL


Después de completar correctamente este ejercicio, se dispondrá de la competencia necesaria para efectuar las siguientes tareas:  

Requisitos



Creación de estructuras propias (declaración, inicialización) Trabajar con el separador de puntos

Conocimientos teóricos sobre tipos de datos y estructuras simples

Crear un programa con el nombre de estructura. 



Generar una estructura con el nombre BOX_Tipo. En esta estructura se deben poder incluir los siguientes valores característicos: Longitud   Anchura  Altura Estado de la pintura (sí/no)  Número de botellas  Asignar a la variable CAJA la estructura BOX_Tipo e inicializar con los siguientes valores de inicio:  Longitud 25,2 Anchura 18,5   Altura 0,5  Contenido: 4 botellas No pintada 





  



En2ºlapaso primera operación procesamiento se uno incluyen botellas más. En el la CAJA aún sedepinta. Entre el paso y dos8se debe planificar un tiempo de espera de 3 segundos. Solicitar que se muestre el contenido de la variable CAJA durante el proceso. Determinar dónde se declaran las variables. Ampliar el plan de ejecución del programa existente con esta estructura. Crear un grupo nuevo para la indicación de las variables de campo necesarias. Comprobar el programa en los modos de servicio T1, T2 y Automático. Se deben tener en cuenta las prescripciones de seguridad enseñadas.

Lo que se debe saber tras el ejercicio: 1. ¿Qué es una estructura? ............................................................. ............................................................. 2. ¿Qué estructuras predefinidas de KUKA existen? ............................................................. ............................................................. 3. ¿Cuál es la diferencia entre una estructura POS y una estructura E6POS? ............................................................. ............................................................. 4. Nombrar una estructura FRAME conocida. ............................................................. 96 / 255



............................................................ 5. ¿Para qué se necesita el separador de puntos? ............................................................ ............................................................


97 / 255


4 .9

El t ipo d e d atos d e e numeración E NUM

Forma de texto como valor de variable

Fig. 4-5 

El tipo de datos de enumeración se compone de una cantidad limitada de constantes, como verde, amarillo o azul

ENUM COLOR_TYPE green, blue, red, yellow   





Utilización de de un tipo de datos enumeración

Las constantes son nombres libremente seleccionables Las constantes se determinan por programadores Un tipo de enumeración debe estar definido previamente, y posteriormente se puede seguir utilizando Una variable de trabajo, como color de la caja, del tipo COLOR_TYPE solo puede aceptar siempre un valor de una constante La asignación de valor de una constante se realiza siempre con el símbolo #

Disponibilidad / utilización  Solo se pueden utilizar constantes conocidas Finalmente puede ampliarse un tipo de enumeración (más de 250 cons tantes y más de 2000 caracteres)  Un tipo de enumeración se puede utilizar individualmente ENUM COLOR_TYPE green, blue, red, yellow 

Un tipo de enumeración se puede integrar en una estructura

ENUM COLOR_TYPE green, blue, red, yellow STRUC CAR_TYPE INT motor, REAL price, COLOR_TYPE car_color 



Creación de un tipo de datos de enumeración

Los tipos de datos de enumeración que se utilicen en varios programas deben declararse en el fichero $CONFIG.DAT Los tipos de enumeración autodefinidos deberán terminar con TYPE para una mejor visibilidad

1. Definición de las variables de las variables de enumeración y las constantes ENUM LAND_TYPE de, be, cn, fr, es, br, us, ch

2. Declaración de las variables de trabajo DECL LAND_TYPE my_land

3. Inicialización de las variables de trabajo my_land = #be

4. Comparación de valores de las va riables de trabajo

98 / 255


4 Variables y declaraciones IF my_land == #es THEN ... ENDIF


99 / 255


4.10

Ejercicio: Crear un tipo de enumeración con KRL



Requisitos



Crear una variable ENUM propia (declaración) Trabajar con variables ENUM

Conocimientos teóricos sobre tipos de datos y estructuras simples Conocimientos teóricos sobre variables ENUM sencillas

Ampliar la estructura del programa con lo siguiente: 1. Generar una variable ENUM cuyo contenido incluya los colores rojo, amarillo, verde y azul. 2. Crear una variable de lámpara para asignarle el color azul. 3. En el segundo paso, asignar a la lámpara el color amarillo. 4. Ampliar la estructura BOX_Tipo con la unidad de color y asignar a la CAJA en primer lugar el color rojo, después el amarillo y finalmente el verde. 5. Solicitar que se muestre el contenido de la variable CAJA durante el proceso.

Lo que se debe saber tras el ejercicio: 1. ¿Quién determina el número y el nombre de las constantes en el tipo de enumeración ENUM? ............................................................. ............................................................. 2. ¿Cuándo se utiliza el símbolo "#"? ............................................................. ............................................................. 3. ¿Qué es incorrecto en la siguiente generación? ENUM Día_tipo lu, ma, mi, ju, vi, sá, do ............................................................. .............................................................

100 / 255


5 Subprogramas y funciones

5

Subprogramas y funciones

5.1

Resumen Esta unidad incluye los siguientes contenidos:    

5.2

Subprogramas locales Subprogramas globales Transferencia de parámetros a un subprograma Programación de funciones

Trabajo con s ubprogramas l ocales

Definición de subprogramas locales



DEF MY_PROG( ) ; esto es el programa principal ... END _______________________________________ DEF LOCAL_PROG1( ) ; Esto es el subprograma local 1 ... END _______________________________________ DEF LOCAL_PROG2( ) ; Esto es el subprograma local 2 ... END _______________________________________ DEF LOCAL_PROG3( ) ; Esto es el subprograma local 3 ... END   

Relaciones durante el trabajo con subprogramas locales

Los subprogramas locales se encuentran después del programa principal y están identificados con DEF nombre_subprograma( )y END



Un fichero SRC puede componerse de hasta 255 subprogramas locales Los subprogramas locales se pueden llamar varias veces Además del nombre del programa es necesario el paréntesis Tras la ejecución de un subprograma local tiene lugar un retroceso a la siguientes instrucción después de la llamada del subprograma

DEF MY_PROG( ) ; esto es el programa principal ... LOCAL_PROG1( ) ... END _______________________________________ DEF LOCAL_PROG1( ) ... LOCAL_PROG2( ) ... END _______________________________________ DEF LOCAL_PROG2( ) ... END


101 / 255

Programación de robots 2  

Pueden estar encajados como máximo 20 subprogramas Las coordenadas de puntos se guardan en la correspondiente lista DAT y están disponibles para el programa completo (*.src)

DEF MY_PROG( ) ; esto es el programa principal ... SPTP P1 Vel=100% PDAT1 ... END _______________________________________ DEF LOCAL_PROG1( ) ... ; Esta es la misma posición que en el programa principal SPTP P1 Vel=100% PDAT1 ... END

DEFDAT MY_PROG ... DECL E6POS XP1={X 100, Y 200, Z 300 ... E6 0.0} ... ENDDAT 

Mediante RETURN se puede finalizar un subprograma y provoca un retroceso en el módulo del programa abierto, en el ejemplo hacia LOCAL_PROG1().

DEF MY_PROG( ) ; esto es el programa principal ... LOCAL_PROG1( ) ... END _______________________________________ DEF LOCAL_PROG1( ) ... IF $IN[12]==FALSE THEN RETURN ; Retroceso al programa principal ENDIF ... END

Procedimiento para la creación de subprogramas locales

1. Grupo de usuario Experto 2. Abrir el fichero SRC en el editor 3. Dejar mostrar la línea DEF DEF MY_PROG( ) ... END

4. Pasar con el cursor debajo de la línea END 5. Asignar un nuevo encabezamiento del programa local con DEF, nombre del programa y paréntesis DEF MY_PROG( ) ... END DEF PICK_PART( )

6. Finalizar un subprograma nuevo con una ins trucción END 102 / 255


5 Subprogramas y funciones DEF MY_PROG( ) ... END DEF PICK_PART( ) END

7. Tras pulsar Return se inserta una barra trasversal entre el programa principal y el subprograma DEF MY_PROG( ) ... END _______________________________________ DEF PICK_PART( ) END

8. El programa principal y el subprograma se pueden seguir procesando ahora 9. Cerrar el programa y guardar

5.3

Trabajo c on s ubprogramas g lobales

Definición de subprogramas globales



Los subprogramas globales disponen de ficheros SRC y DAT independientes

DEF GLOBAL1( ) ... END

DEF GLOBAL2( ) ... END 

Relaciones durante el trabajo con subprogramas locales



Los subprogramas globales se pueden llamar varias veces Tras la ejecución de un subprograma local tiene lugar un retroceso a la siguientes instrucción después de la llamada del subprograma

DEF GLOBAL1( ) ... GLOBAL2( ) ... END


DEF GLOBAL3( ) ... END 

Pueden estar encajados como máximo 20 subprogramas


103 / 255


Las coordenadas de puntos se guardan en la lista DAT correspondiente y solo están disponibles para el programa correspondiente

DEF GLOBAL1( ) ... SPTP P1 Vel=100% PDAT1 END

DEFDAT GLOBAL1( ) DECL E6POS XP1={X 100, Z 200, Z 300 ... E6 0.0} ENDDAT

Diferentes coordenadas para P1 en Global2 ( ) DEF GLOBAL2( ) ... SPTP P1 Vel=100% PDAT1 END

DEFDAT GLOBAL2( ) DECL E6POS XP1={X 800, Z 775, Z 999 ... E6 0.0} ENDDAT 

Mediante RETURN se puede finalizar un subprograma y provoca un retroceso al módulo del programa abierto; en el ejemplo, hacia GLOBAL2().


DEF GLOBAL2( ) ... IF $IN[12]==FALSE THEN RETURN ; Retroceso a GLOBAL1( ) ENDIF ... END

Procedimiento para la programación con subprogramas globales

1. Grupo de usuario Experto 2. Crear un nuevo programa DEF MY_PROG( ) ... END

3. Crear el segundo programa de nuevo DEF PICK_PART( ) ... END

4. Abrir el fichero SRC del programa MY_PROG en el editor 5. Programar la llamada del subprograma mediante el nombre del programa y paréntesis DEF MY_PROG( ) ...

104 / 255


5 Subprogramas y funciones PICK_PART( ) ... END


5.4

Transmitir parámetros a subprogramas

Descripción de la transferencia de parámetros



Sintaxis

DEF MY_PROG( ) ... CALC (K, L) ... END DEF CALC(R:IN, S:OUT) ; Posibilidad de transmisión como IN/OUTParámetro ... END 

Principio de la transferencia de parámetros





La transferencia de parámetros se puede realizar tanto a subprogramas locales como globales Transferencia de parámetros como parámetros IN (Call by value):  el valor de la variable permanece invariable en el programa principal, es decir, se continúa trabajando con el valor anterior del programa principal  el subprograma solo puede leer el valor de la variable, pero no puede escribirlo Transferencia de parámetros como parámetros OUT (Call by reference): el valor de la variable se modifica en el programa principal, es decir, se acepta la valencia del subprograma el subprograma lee el valor, lo modifica y escribe el valor nuevo de  vuelta Transferencia de parámetros a subprogramas locales 



DEF MY_PROG( ) DECL REAL r,s ... CALC_1(r) ... CALC_2(s) ... END _______________________________________ DEF CALC_1(num1:IN) ; El valor "r" se transfiere a num1 exclusivamente para lectura DECL REAL num1 ... END _______________________________________ DEF CALC_2(num2:OUT) ; El valor "s" se transfiere, modificado y reescrito, a num2 DECL REAL num2 ... END 

Transferencia de parámetros a subprogramas globales

DEF MY_PROG( ) DECL REAL r, s


105 / 255

Programación de robots 2 ... CALC_1(r) ... CALC_2(s) ... END DEF CALC_1(num1:IN) ; El valor "r" se transfiere a num1 exclusivamente para lectura DECL REAL num1 ... END

DEF CALC_2(num2:OUT) ; El valor "s" se transfiere, modificado y reescrito, a num2 DECL REAL num2 ... END  

La transferencia de valores a tipos de datos iguales siempre es posible Transferencia de valores a otros tipos de datos:

DEF MY_PROG( ) DECL DATATYPE1 value CALC(value) END _______________________________________ DEF CALC(num:IN) DECL DATATYPE2 num ... END



DATATYPE 1

DATATYPE 2

Observación

BOOL

ERROR (... parámetro incompatible)

INT INT CHAR CHAR

INT,REAL, CHAR REAL CHAR INT REAL

REAL REAL

INT CHAR

ValorINTseutilizacomovalorREAL SeutilizaelcarácterdelatablaASCII SeutilizaelvalorINTdelatablaASCII SeutilizaelvalorREALdelatabla ASCII LosvaloresREALseredondean LosvaloresREALseredondean,seutiliza el carácter de la tabla ASCII

Transferencia de varios parámetros

DEF MY_PROG( ) DECL REAL w DECL INT a, b ... CALC(w, b, a) ... CALC(w, 30, a) ... END _______________________________________ DEF CALC(ww:OUT, bb:IN, aa:OUT) ;1.) w <-> ww, b -> bb, a <-> aa ;2.) w <-> ww, 30 -> bb, a <-> aa

106 / 255


5 Subprogramas y funciones DECL REAL ww DECL INT aa, bb ... END

También es posible no transmitir valores, en caso de que en el subprograma también se calcule sin estos valores. Ejemplo: CALCULA(s,, a) 

Transferencia de parámetros con campos  Los campos solo se pueden transmitir completos a un campo nuevo  Los campos solo se pueden transmitir con el parámetro OUT (Call by reference)

DEF MY_PROG( ) DECL CHAR name[10] ... name[]="PETER" calc(name[]) ... END _______________________________________ DEF calc(my_name[]:OUT) ; Generar un campo en el subprograma siempre sin tamaño de campo ; El tamaño de campo se adapta al campo de salida DECL CHAR my_name[] ... END

Transferencia de campos completos: CAMPO_1D[] (1 dimensión), CAMPO_2D[,] (2 dimensiones), CAMPO_3D[,,] (3 dimensiones) 

Los elementos de campo individuales también se pueden transmitir

DEF MY_PROG( ) DECL CHAR name[10] ... name[]="PETER" CALC(name[1]) ... END _______________________________________ DEF calc(symbol:IN) ; Se transfiere exclusivamente un carácter DECL CHAR symbol ... END

En la transferencia elementos campo individuales solosepodrá existir una variable ydeningún campodecomo destino. Aquí solo transmite la letra "P" al subprograma.

Procedimiento para la transferencia de parámetros

Consideraciones previas 1. Determinar los parámetros que son necesarios en el subprograma 2. Determinar el tipo de transferencia de parámetros (parámetros IN u OUT) 3. Determinar los tipos de datos iniciales y de destino (lo ideal es el mismo tipo de datos) 4. Determinar el orden de la transferencia de parámetros


107 / 255


A tener en cuenta: El primer parámetro enviado se escribe sobre el primer parámetro en el subprograma, el segundo en el segundo parámetro en el subprograma, etc.

Procedimiento 1. Cargar un programa principal en el editor 2. Declarar, inicializar y posiblemente manipular variables en el programa principal 3. Crear la llamada del subprograma con la transferencia de variables 4. Cerrar y guardar el programa principal 5. Cargar el subprograma en el editor 6. Completar la línea DEF con variables y con IN/OUT 7. Declarar, inicializar y posiblemente manipular variables en el subprograma 8. Cerrar y guardar el subprograma Ejemplo completo: DEF MY_PROG( ) DECL REAL w DECL INT a, b w = 1.5 a = 3 b = 5 CALC(w, b, a) ; Valores actuales ; w = 3.8 ; a = 13 ; b = 5 END _______________________________________ DEF CALC(ww:OUT, bb:IN, aa:OUT) ; w <-> ww, b -> bb, a <-> aa DECL DECL ww = bb = aa = END

108 / 255

REAL ww INT aa, bb ww + 2.3 ; ww = 1.5 + 2.3 =3.8 ->w bb + 5 ; bb = 5 + 5 = 10 bb + aa ; aa = 10 + 3= 13 -> a



5.5

Ejercicio: Subprogramas con transferencia de parámetros



Requisitos

Los siguientes requisitos son necesarios para completar este ejercicio correctamente:   


Tecnología de subprogramas con transferencia de parámetros

Conocimientos de tecnología de subprogramas Conocimientos teóricos sobre la transferencia de parámetros Conocimientos teóricos sobre funciones

Tarea: Completar los resultados una vez ejecutados los programas. DEF transmit_var( ) INT A, B, C, D, E, F A=50 B=48 C=200 D=300 E=8 F=5 Calc (C, D, A, F, B, E) ;A = ....... B = ....... C = ....... ;D = ....... E = ....... F = ....... END --------------------------------------------------------------------------------------------------;Sub program DEF Calc (X1:OUT, X2:IN, X3:OUT, X4:IN, X6:IN, X5:OUT) INT X1, X2, X3, X4, X5, X6 ; Calculation X1 = X1 + 211 ; X1 = ………………… X2 = X2 - 312 ; X2 = ………………… X3 = X2 + X3 ; X3 = ………………… X4 = X4 * X5 ; X4 = ………………… X5 = X5 * 8 ; X5 = ………………… X6 = X6 – 40 ; X6 = ………………… END

Lo que se debe saber tras el ejercicio: 1. ¿Cuántos subprogramas pueden estar encajados? ............................................................ ............................................................ 2. ¿A qué fichero DAT accede un subprograma local? ............................................................ ............................................................ 3. ¿Dónde se declara una variable que debe ser conocida en el subprograma global y también en el programa principal? ............................................................ ............................................................


109 / 255


4. ¿Cuál es la diferencia entre "parámetros IN" y "parámetros OUT" en la transferencia de parámetros? ............................................................. .............................................................

110 / 255



5.6

Programación de funciones

Definición de funciones con KRL









 

Una función es un subprograma que envía de vuelta un valor determinado al programa principal. A menudo son necesarios determinados valores de entrada para poder calcular el valor de retorno. En el encabezamiento de la función se determina el tipo de datos que se reescriben en el programa principal. El valor que se va a transmitir se transmite con la instrucción RETURN(return_value). Existen funciones locales y globales. Sintaxis de una función:

DEFFCT DATATYPE NAME_FUNCTION( ) ... RETURN(return_value) ENDFCT

Principio de las funciones con KRL





El nombre del programa es al mismo tiempo el nombre de variable de un tipo de datos determinado Llamada de una función global

DEF MY_PROG( ) DECL REAL result, value INI ... result = CALC(value) ... END DEFFCT REAL CALC(num:IN) DECL REAL return_value, num ... RETURN(return_value) ENDFCT

La instrucción RETURN(return_value) debe aplicarse antes de la instrucción ENDFCT. 

Llamada de una función local

DEF MY_PROG( ) DECL REAL result, value INI ... result = CALC(value) ... END _______________________________________ DEFFCT REAL CALC(num:IN) DECL REAL return_value, num ... RETURN(return_value) ENDFCT 

Utilización de parámetros IN/OUT en la transferencia de valores  Transferencia de valores como parámetro IN

DEF MY_PROG( ) DECL REAL result, value INI


111 / 255

Programación de robots 2 value = 2.0 result = CALC(value) ; value = 2.0 ; result = 1000.0 END

DEFFCT REAL CALC(num:IN) DECL REAL return_value, num num = num + 8.0 return_value = num * 100.0 RETURN(return_value) ENDFCT

El valor de transferencia value no se modifica.



Transferencia de valores como parámetro OUT

DEF MY_PROG( ) DECL REAL result, value INI value = 2.0 result = CALC(value) ; value = 10.0 ; result = 1000.0 END

DEFFCT REAL CALC(num:OUT) DECL REAL return_value, num num = num + 8.0 return_value = num * 100.0 RETURN(return_value) ENDFCT

El valor de transferencia value se reescribe modificado.

Procedimiento para la programación de funciones

112 / 255

1. Determinar el valor que debe suministrar la función (tipo de datos de retorno) 2. Determinar los parámetros que son necesarios en la función (tipo de datos de transferencia) 3. Determinar el tipo de transferencia de parámetros (parámetros IN u OUT) 4. Determinar si es necesaria una función local o global 5. Cargar un programa principal en el editor 6. Declarar, inicializar y posiblemente manipular variables en el programa principal 7. Crear la llamada de función 8. Cerrar y guardar el programa principal 9. Crear la función (global o local) 10. Cargar la función en el editor 11. Completar la línea DEFFCT con el tipo de datos, las variables y con IN/ OUT 12. Declarar, inicializar y manipular variables en la función Edición: 24.02.2015 Versión: P2KSS8_robotprogramming_2_(R2)_V4


13. Crear la línea RETRUN(return_value) 14. Cerrar y guardar la función

5.7

Trabajar con funciones estándar de KUKA

Listado de las funciones estándar de KUKA

Funciones matemáticas:

Descripción

Función KRL

Cantidad Raíz Seno

ABS(x) SQRT(x) SIN(x)

Coseno Tangente Arcocoseno Arco tangente

COS(x) TAN(x) ACOS(x) ATAN2(y,x)

Funciones para variables de cadena:

Descripción

Función KRL

Determinación de la longitud de cadena en la declaración Longitud de una variable de cadena tras de la inicialización Borrado del contenido de variables de cadena Ampliar la variable de cadena Comparación del contenido de variables de cadena

StrDeclLen(x)

Copiarvariabledecadena Funciones para la emisión de mensaje:

Descripción Transmitirmensaje Transmitirdiálogo Comprobarmensaje Comprobardiálogo Borrarmensaje Lectura de la m emoria intermedia de mensajes

StrLen(x) StrClear(x) StrAdd(x,y) StrComp( x,y,z) StrCopy(x,y)

Función KRL Set_KrlMsg(a,b,c,d) Set_KrlDLg(a,b,c,d) Exists_KrlMsg(a) Exists_KrlDlg(a,b) Clear_KrlMsg(a) Get_MsgBuffer(a)

Principio para la utilización de funciones estándar de

Cada función estándar se llama con parámetros de transmisión:

KUKA





con valor fijo

result = SQRT(16)

variables de tipo de datos simple

result = SQRT(x) 

variable compuesta de campos

result = StrClear(Name[])   

variable compuesta de tipos de datos de enumeración variable compuesta de estructuras con varias variables diferentes

result = Set_KrlMsg(#QUIT, message_parameter, parameter[], option)


113 / 255


message_parameter, parameter[1...3] y option son estructura predefinidas de KUKA Cada función necesita una variable adecuada en la que se pueda guardar el resultado de esta función:  

Las funciones matemáticas devuelven un valor REAL Las funciones de cadena devuelven un valor BOOL o INT

; Borrar un string result = StrClear(Name[]) 

Las funciones de mensaje devuelven un valor BOOL o INT

; Borrar un mensaje (BOOL: borrado?) result = Clear_KrlMsg(Valor de retorno)

114 / 255


6 Programación de un mensaje con KRL

6

Programación de un mensaje con KRL

6.1


    

6.2

Generalidades acerca de los mensajes definidos por el usuario Variables y estructuras para mensajes definidos por el usuario Funciones para mensajes definifos por el usuario Trabajar con mensajes de observación Trabajar con mensajes de estado Trabajar con mensajes de confirmación Trabajar con mensajes de espera Variables y estructuras adicionales para diálogos Funciones para diálogos Trabajos con diálogos

Información general s obre l os mensajes d efinidos por el usuario Características de la programación de mensajes   







El programador puede programar mensajes propios con KRL. Se pueden emitir varios mensajes simultáneamente. Los mensajes emitidos se encuentran en una memoria intermedia de mensajes hasta que se vuelven a borrar. Los mensajes de observación no se administran en la memoria intermedia de mensajes (principio "fire and forget" [disparar y olvidarse]). Los mensajes se pueden comprobar o borrar fácilmente, salvo los mensajes de observación. En cada mensaje se pueden integrar hasta 3 parámetros.

En la ventana del mensaje de KUKA.HMI se muestra un símbolo para cada mensaje. Los símbolos están asignados a los tipos de mensaje de forma estricta y no pueden ser modificados por el programador.

Se pueden programar los siguientes tipos de mensajes: Símbolo

Tipo Mensaje de acuse de recibo Mensaje de estado Mensaje de observación

Mensaje de espera

Mensaje de diálogo (se muestra en una ventana emergente propia) No existen reacciones predefinidas del sistema de robot asociadas a los distintos tipos de mensaje (p. ej. el robot frena o se detiene el programa). Es necesario programar las reacciones deseadas. Edición: 24.02.2015 Versión: P2KSS8_robotprogramming_2_(R2)_V4

115 / 255


Variables complejas para programar mensajes    

Estructura para remitente, número de mensaje, texto del mensaje Estructura como marcador de posición para 3 parámetros posibles Estructura para el comportamiento general de un mensaje Estructura para la rotulación de los botones en mensajes de diálogo

Los mensajes se emiten, borran o comprueban mediante funciones estándar predefinidas de KUKA. Para ello se necesitan distintas variables.

Funciones para programar mensajes     

6.3

Emitir un mensaje Comprobar un mensaje Borrar un mensaje Emitir un diálogo Comprobar un diálogo

Variables y estructuras para mensajes definidos por el usuario

Estructura para remitente, número de mensaje, texto del mensaje



Estructura KUKA predefinida: KrlMsg_T STRUC KrlMsg_T CHAR Modul[24], INT Nr, CHAR Msg_txt[80] 

A partir del ejemplo

DECL KrlMsg_T mymessage mymessage = {Modul[ ] "College", Nr 1906, Msg_txt[ ] "My first Message"}



Remitente: Modul[ ]"College" Modul[ ] puede incluir, como máximo, 24 caracteres. El sistema integra el texto del remitente en la indicación entre "< >".  Número de mensaje: N.º 1906  Nº es un número entero libremente seleccionable. Los números duplicados seleccionados no se detectan.  Texto del mensaje: Msg_txt[ ] "My first Message"  Msg_txt[ ] puede incluir, como máximo, 80 caracteres. En caso de que Msg_txt[ ] deba volver a inicializarse para un mensaje subsiguiente, en primer lugar debe borrarse todo el contenido "antiguo". (>>> "Principio para la utilización de funciones estándar de KUKA" Página 113) 





... INT result INI ... result = StrClear(My_Message.Msg_txt[]) ...

116 / 255



Alternativa: ... INT X INI FOR x=1 TO 80... My_Message.Msg_txt[x] = " " ENDFOR ... 

Seleccionar el tipo de mensaje

Variables en el texto de mensaje



El texto se muestra en la segunda línea del mensaje.

Tipo de datos de enumeración EKrlMsgType

ENUM EKrlMsgType Notify, State, Quit, Waiting



#Quit: da salida a este mensaje como mensaje de confirmación



#STATE: da salida a este mensaje como mensaje de estado



#NOTIFY: da salida a este mensaje como mensaje de observación



#WAITING: da salida a este mensaje como mensaje de espera

En el texto de un mensaje se debe mostrar el valor de una variable. Por ejemplo, se debe mostrar la cantidad de piezas actual. Para ello, en el texto del mensaje se necesitan los denominados marcadores de posición. La cantidad máxima de marcadores de posición es 3. La visualización es %1, %2 y %3. Por este motivo se necesitan 3 juegos de parámetros. Cada juego de parámetros está compuesto por la estructura KUKA KrlMsgPar_T: Enum KrlMsgParType_T Value, Key, Empty STRUC KrlMsgPar_T KrlMsgParType_T Par_Type, CHAR Par_txt[26], INT Par_Int, REAL Par_Real, BOOL Par_Bool

Utilización de las unidades individuales 

   

Par_Type: clase de parámetro/marcador de posición  #VALUE: el parámetro se procesa directamente en la forma transferi-

da en el texto del mensaje (es decir, como String, valor INT, REAL o BOOL)  #KEY: el parámetro es una palabra clave que se debe buscar en la base de datos de mensajes para cargar el texto correspondiente  #EMPTY: el parámetro está en blanco Par_txt[26]: el texto o la palabra clave para el parámetro. Par_Int: se transmite un valor entero como parámetro Par_Real: se transmite un valor real como parámetro Par_Bool: se transmite un valor booleano como parámetro, se muestra el texto TRUE o FALSE

Ejemplos de programa para la transmisión directa de parámetros al marcador de posición: El texto del mensaje es Msg_txt[ ] "Avería en %1". DECL KrlMsgPar_T Parameter[3] ; 3 Crear juegos de parámetros ... Parameter[1] = {Par_Type #VALUE, Par_txt[ ] "Finisher"} Parameter[2] = {Par_Type #EMPTY} Parameter[3] = {Par_Type #EMPTY} ...


117 / 255


Salida de mensaje: Avería en el Finisher Puesto que los parámetros no se suelen describir mediante constantes, las unidades individuales se transmiten con el punto separador. Ejemplos de programa para la transmisión de parámetros con separador de puntos al marcador de posición: El texto del mensaje es Msg_txt[ ] "Faltan %1 componentes" DECL KrlMsgPar_T Parameter[3] ; 3 Crear juegos de parámetros DECL INT missing_part ... missing_part = 13 ... Parameter[1] = {Par_Type #VALUE} Parameter[1].Par_Int = missing_part Parameter[2] = {Par_Type #EMPTY} Parameter[3] = {Par_Type #EMPTY} ...

Salida de mensaje: faltan 13 componentes

Estructura para opciones de mensaje

Cuando se emite un mensaje se transfieren otras 4 opciones de mensaje. Con estas opciones se puede influir en el avance, el borrado de mensajes y introducción la base de datos Log. 

generales

Estructura KUKA predefinida: KrlMsgOpt_T

STRUC KrlMsgOpt_T BOOL Log_To_DB 

BOOL VL_Stop, BOOL Clear_P_Reset, BOOL Clear_SAW,

VL_Stop: Parada del procesamiento en avance  TRUE desencadena una parada del procesamiento en avance. El

mensaje se establece de manera sincrónica con el puntero principal. Por defecto: TRUE Clear_P_Reset : borrar durante el reset/la selección del programa  TRUE borra todos los mensajes de estado, confirmación y espera cuando se cancela el programa o se restablece. Por defecto: TRUE Por defecto: TRUE  



Los mensajes de observación sólo se pueden borrar con los botones OK o Todo OK. 



118 / 255

Clear_P_SAW: borrar durane la selección de línea mediante el botón Se-

lección de línea.  TRUE borra todos los mensajes de estado, confirmación y espera cuando se selecciona una línea mediante el menú correspondiente.  Por defecto: FALSE Log_To_DB: Entrada en la base de datos Log.  TRUE hace que este mensaje se registre en la base de datos Log. Por defecto: FALSE 



6.4

Funciones para mensajes definifos p or el usuario

Definición o emisión de un mensaje

Con esta función se define un mensaje en el programa KRL. Esto significa que el mensaje correspondiente se procesa en la memoria intermedia de mensajes interna. Excepción: los mensajes de observación, que no se administran en la memoria intermedia de mensajes. 

Funciones integradas para emitir un mensaje

DEFFCT INT Set_KrlMsg(Type:IN, MyMessage:OUT, Parameter[ ]:OUT, Option:OUT) DECL EKrlMsgType Type DECL KrlMsg_T MyMessage DECL KrlMsgPar_T Parameter[ ] DECL KrlMsgOpt_T Option  







Tipo: clase de mensaje (#Notify, #State, #Quit, #Waiting). MyMessage: estructura para información general de mensaje (remitente,

número de mensaje, texto del mensaje) Parameter[ ]: campo de los 3 parámetros posibles para los comodines %1, %2 y 3%. Deben transmitirse siempre los 3 parámetros, incluso en caso de que no se utilicen los comodines. Opción: Estructura de opciones de mensaje generales (parada del procesamiento, inicio de sesión en la base de datos de mensajes, mensaje en caso de restablecimiento del programa o borrado implícito de selección de línea) Valor de retorno de la función: se denomina "handle" (número de billete). Con este "handle" es posible controlar si el mensaje se ha podido emitir correctamente. Por lo demás, el "handle" es también el número de identificación en la memoria intermedia de mensajes. De este modo se puede comprobar o borrar un mensaje determinado.

DEF MyProg( ) DECL INT handle ... handle = Set_KrlMsg(Type, MyMessage, Parameter[ ], Option)

En caso de que se trabaje con varios mensajes, se debe utilizar o memorizar de manera intermedia un "handle" propio para cada mensaje.





handle == -1: no se ha podido emitir el mensaje (p. ej., porque la

memoria intermedia de mensajes está saturada). handle > 0: El mensaje se ha emitido correctamente y se gestionará en la memoria intermedia de mensajes con el número de identificación correspondiente. Los mensajes de observación se procesan de acuerdo con el princi-

pio "fire and forget" (disparesiempre y olvídese). En el caso de los mensajes de observación, el retorno es handle = 0 si el mensaje se ha emitido correctamente.

Comprobación de un mensaje

Con esta función se puede comprobar si un mensaje determinado con un handle definido existe todavía. También se comprueba si dicho mensaje se encuentra aún en la memoria intermedia de mensajes interna. 

Funciones integradas para comprobar un mensaje

DEFFCT BOOL Exists_KrlMsg(nHandle:IN) DECL INT nHandle


119 / 255


nHandle: el handle facilitado por la función "Set_KrlMsg(…)" para el



mensaje. Valor de retorno de la función:

DEF MyProg( ) DECL INT handle DECL BOOL present ... handle = Set_KrlMsg(Type, MyMessage, Parameter[ ], Option) ... present= Exists_KrlMsg(handle)





Borrado de un mensaje

present == TRUE: este mensaje existe aún en la memoria interme-

dia de mensajes. present == FALSE: este mensaje ya no se encuentra en la memoria intermedia de mensajes (por lo tanto, se ha confirmado o se ha borrado).

Con esta función se puede borrar un mensaje. Esto significa que el mensaje correspondiente se borra de la memoria intermedia de mensajes interna. 


DEFFCT BOOL Clear_KrlMsg(nHandle:IN) DECL INT nHandle 

nHandle: el handle facilitado por la función "Set_KrlMsg(…)" para el



mensaje. Valor de retorno de la función:

DEF MyProg( ) DECL INT handle DECL BOOL erase ... handle = Set_KrlMsg(Type, MyMessage, Parameter[ ], Option) ... eraser = Clear_KrlMsg(handle)

 



120 / 255

eraser == TRUE: se ha podido borrar este mensaje. eraser == FALSE: no se ha podido borrar este mensaje.

Funciones especiales para borrar con la función Clear_KrlMsg(handle): Clear_KrlMsg(-1): se borran todos los mensajes iniciados por este proceso. Clear_KrlMsg(-99): se borran todos los mensajes iniciados por el usuario KRL.



6.5

Trabajos con un mensaje de observación

Descripción de un mensaje de observación definido por el usuario Fig. 6-1: Mensaje de observación

Función de un mensaje de observación definido por el usuario Programación de mensajes de observación definidos por el usuario



Los mensajes de observación no se administran en la memoria intermedia



de mensajes Los mensajes de observación sólo se pueden borrar con los botones OK o Todo OK.







Los mensajes de observación son idóneos para mostrar información general. Sólo se puede emitir un mensaje de observación. Se puede comprobar si el mensaje se ha recibido correctamente. Puesto que los mensajes de observación no se administran, se pueden emitir 3 millones aproximadamente.

1. Cargar un programa principal en el editor 2. Declarar variables de trabajo para:  Remitente, número de mensaje, texto del mensaje (de KrlMsg_T)  Campos con 3 elementos para el parámetro (de KrlMsgPar_T) Opciones de mensaje generales (de KrlMsgOpt_T)   "Handle" (como ) INT 3. Inicializar variables de trabajo con los valores deseados. 4. Programar la activación de la función Set_KrlMsg(…). 5. En caso necesario, evaluar el "handle" para saber si la transmisión ha sido satisfactoria. 6. Cerrar y guardar el programa principal.

Fig. 6-2: Mensaje de observación Ejemplo de programación para visualización mencionada anteriormente: DECL KRLMSG_T mymessage DECL KRLMSGPAR_T Parameter[3] DECL KRLMSGOPT_T Option DECL INT handle ... mymessage={modul[] "College", Nr 1906, msg_txt[] "My first Message"} Option={VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE, Log_to_DB TRUE} ;Los comodines [1..3] están vacíos Parameter[1] = {Par_Type #EMPTY} Parameter[2] = {Par_Type #EMPTY} Parameter[3] = {Par_Type #EMPTY}


121 / 255

Programación de robots 2 handle = Set_KrlMsg(#NOTIFY, mymessage, Parameter[ ], Option) ...

122 / 255



6.6

Ejercicio: Programar un mensaje de observación



Requisitos

Los siguientes requisitos son imprescindibles para superar el ejercicio con éxito:  


Programar mensajes de indicación propios. Dar salida en mensajes a los parámetros que se desee.

Conocimientos del lenguaje de programación KRL Conocimientos teóricos acerca de la programación de mensajes

Tarea parcial 1: Mensaje de observación 1. Crear un mensaje de observación con el texto "Se ha iniciado el programa Cargador". 2. En cuanto se haya iniciado el programa, solamente deberá visualizarse una vez el mensaje de observación. 3. Comprobar el programa conforme a lo pres crito. Tarea parcial 2: Mensaje de observación con parámetros 1. Crear un mensaje de observación con el texto "Cubo número xxx transportado". 2. Ampliar el programa Cargador con un contador de piezas para los cubos transportados. Tras la colocación en el cargador de cubos, aumentar el número de piezas y visualizar. 3. Comprobar el programa conforme a lo pres crito.

Lo que se debe saber tras el ejercicio: 1. ¿Cómo se vuelve a borrar un mensaje de observación? ............................................................ ............................................................ 2. ¿Qué componente de la estructura del mensaje es responsable de "lanzar" el texto del mensaje? ............................................................ ............................................................


123 / 255


6 .7

Trabajos con un mensaje de estado

Descripción de un mensaje de estado definido por el usuario

Fig. 6-3: Mensaje de estado 



Función de un mensaje de estado definido por el usuario





Los mensajes de estado se administran en la memoria intermedia de mensajes. Los mensajes de estado no se pueden volver a borrar con el botón "Todo OK". Los mensajes de estado son adecuados para indicar un cambio de estado (p. ej. la supresión de una entrada). El programa persiste, por ejemplo, hasta que el estado desencadenante deja de darse. No existen reacciones predefinidas del sistema de robot asociadas a los distintos tipos de mensaje (p. ej. el robot frena o se detiene el programa). Es necesario programar las reacciones deseadas.







Programación de mensajes de estado definidos por el usuario

En la memoria intermedia de mensajes se administran 100 mensajes como máximo. (Mensajes de estado, confirmación, mantenimiento y diálogos). El mensaje de estado se vuelve a borrar mediante la función Clear_KrlMsg( ). Los mensajes de estado también se pueden borrar a través de los ajustes de las opciones de mensaje durante el reset del programa, al salir del programa o al seleccionar una línea.

1. Cargar un programa principal en el editor 2. Declarar variables de trabajo para:  Remitente, número de mensaje, texto del mensaje (de KrlMsg_T) Campos con 3 elementos para el parámetro (de KrlMsgPar_T)   Opciones de mensaje generales (de KrlMsgOpt_T)  "Handle" (como INT) Variable para el resultado de la comprobación (como BOOL)  Variable para el resultado del borrado (como BOOL)  3. Inicializar variables de trabajo con los valores deseados. 4. Programar la activación de la función Set_KrlMsg(…). 5. Detener el programa con un bucle hasta que se desaparezca el estado desencadenante. 6. Borrar el mensaje de estado con la activación de la función Clear_KrlMsg( ). 7. Cerrar y guardar el programa principal.

Fig. 6-4: Mensaje de estado 124 / 255



Ejemplo de programación para visualización/mensaje mencionados anteriormente: El mensaje de estado se emite con el estado de la entrada 12 (FALSE). El programa se detiene tras la transmisión del mensaje. El mensaje se borra con el estado de la entrada 17 (TRUE). Después, el programa prosigue. El mensaje también se borra con el reset del programa o al salir del mismo. Para ello se utiliza el ajuste en las opciones de mensaje Clear_P_Reset TRUE. DECL KRLMSG_T mymessage DECL KRLMSGPAR_T Parameter[3] DECL KRLMSGOPT_T Option DECL INT handle DECL BOOL present, eraser ... IF $IN[12]==FALSE THEN mymessage={modul[] "College", Nr 1909, msg_txt[] "My Messagetext"} Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE, Log_to_DB TRUE} ;Los comodines [1..3] están vacíos Parameter[1] = {Par_Type #EMPTY} Parameter[2] = {Par_Type #EMPTY} Parameter[3] = {Par_Type #EMPTY} handle = Set_KrlMsg(#STATE, mymessage, Parameter[ ], Option) ENDIF eraser=FALSE ;Bucle de parada hasta que se haya borrado este mensaje REPEAT IF $IN[12]==TRUE THEN eraser=Clear_KrlMsg(handle) ;Borrar mensaje ENDIF present=Exists_KrlMsg(handle) ;Prueba adicional UNTIL NOT(present) or eraser


125 / 255


6.8

Ejercicio: P rogramar un m ensaje d e e stado



Requisitos



Programar mensajes de estado propios Dar salida en mensajes a los parámetros que se desee.


Tarea parcial: Mensaje de estado 1. Crear un mensaje de estado con el texto "Programa de cubos en proceso". 2. Antes de iniciar el bucle infinito, deberá visualizarse el mensaje de estado. 3. El bucle infinito debe abandonarse a través de la entrada 16 del panel de mando y, a continuación, deberá borrarse el mensaje de estado. 4. Compruebe su programa según prescripción.

Lo que se debe saber tras el ejercicio: 1. ¿Qué significa %2 en el texto del mensaje? ............................................................. .............................................................

126 / 255



6.9

Trabajos con un mensaje de a cuse d e r ecibo

Descripción de un mensaje de acuse de recibo definido por el usuario Fig. 6-5: Mensaje de acuse de recibo 



Función de un mensaje de acuse de recibo definido por el usuario





Los mensajes de acuse de recibo son idóneos para mostrar información que el usuario debe conocer. El programa se detiene, por ejemplo, hasta que se confirme el mensaje. No existen reacciones predefinidas del sistema de robot asociadas a los distintos tipos de mensaje (p. ej. el robot frena o se detiene el programa). Es necesario programar las reacciones deseadas.









Programación de mensajes de acuse de recibo definidos por el usuario

Los mensajes de acuse de recibo se administran en la memoria intermedia de mensajes. Los mensajes de acuse de recibo solo se pueden volver a borrar con los botones OK o Todo OK.

En la memoria intermedia de mensajes se administran 100 mensajes como máximo. En el caso del mensaje de acuse de recibo (a diferencia del mensaje de observación), se puede comprobar si el usuario lo ha confirmado o no. Los mensajes de acuse de recibo se pueden volver a borrar también mediante una función en el programa. Asimismo, mensajes de de acuse de recibo se pueden medianteal los ajustes los de las opciones mensaje durante el reset borrar del programa, salir del programa o al seleccionar un paso.

1. Cargar programa principal en el editor. 2. Declarar variables de trabajo para:  Remitente, número de mensaje, texto del mensaje (de KrlMsg_T)  Campos con 3 elementos para el parámetro (de KrlMsgPar_T) Opciones de mensaje generales (de KrlMsgOpt_T)  "Handle" (como INT)   Variable para el resultado de la comprobación (como BOOL) 3. Iniciar variables de trabajo con los valores deseados. 4. Programar la activación de la función Set_KrlMsg(…). 5. Comprobar la condición de conf irmación en un bucle . 6. Activando la función Exists_KrlMsg(...), comprobar si el mensaje ya ha sido confirmado por el usuario. Si se ha confirmado el mensaje, abandonar el bucle anterior. 7. Cerrar y guardar el programa principal.

Fig. 6-6: Mensaje de acuse de recibo


127 / 255


Ejemplo de programación para visualización/mensaje mencionados anteriormente: El programa se detiene tras la transmisión del mensaje. El mensaje se borra accionando el botón OK o Todo OK . Después, el programa prosigue. El mensaje también se borra con el reset del programa o al salir del mismo. Para ello se utiliza el ajuste en las opciones de mensaje Clear_P_Reset TRUE. DECL DECL DECL DECL

KRLMSG_T mymessage KRLMSGPAR_T Parameter[3] KRLMSGOPT_T Option INT handle

DECL BOOL present ... mymessage={modul[] "College", Nr 1909, msg_txt[] "My Messagetext"} Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE, Log_to_DB TRUE} ;Los comodines [1..3] están vacíos Parameter[1] = {Par_Type #EMPTY} Parameter[2] = {Par_Type #EMPTY} Parameter[3] = {Par_Type #EMPTY} handle = Set_KrlMsg(#QUIT, mymessage, Parameter[ ], Option) ;Bucle de parada hasta que se haya borrado este mensaje REPEAT present=Exists_KrlMsg(handle) UNTIL NOT(present)

128 / 255



6.10

Ejercicio: Programar mensajes de acuse de recibo



Requisitos



Programar mensajes de confirmación propios. Dar salida en mensajes a los parámetros que se desee.


Tarea parcial 1: Mensaje de confirmación 1. Crear un mensaje de confirmación con el texto "Se ha(n) transportado xxx cubo(s)". 2. El contador de piezas ajustado debe provocar la visualización del mensaje de confirmación tras cada décimo cubo. 3. Tras la confirmación podrá segurise con el procesamiento. 4. Compruebe su programa según prescripción. Tarea parcial 2: Mensaje de estado con mensaje de confirmación 1. Crear un mensaje de confirmación con el texto "Finalizaación del programa de cubos". 2. Una vez se ha abandonado el bucle infinito con la entrada 16, se borrará el mensaje de estado "Programa de cubos en proceso". Visualizar el mensaje de confirmación y esperar hasta su confirmación. 3. Compruebe su programa según prescripción.

Lo que se debe saber tras el ejercicio: 1. ¿Cuántos mensajes de acuse de recibo se administran como máximo en la memoria intermedia de mensajes? ............................................................ ............................................................


129 / 255


6.11

Trabajos con un mensaje de espera

Descripción de un mensaje de espera definido por el usuario

Fig. 6-7: Mensaje de espera 

 

Función de un mensaje de espera definido por el usuario











Programación de mensajes de espera definidos por el usuario

Los mensajes de espera se administran en la memoria intermedia de mensajes. Los mensajes de espera se pueden volver a borrar con el botón Simular. Los mensajes de espera no se pueden volver a borrar con el menú Todo OK. Los mensajes de espera son adecuados para esperar a un estado y mostrar el símbolo de espera. El programa se detiene, por ejemplo, hasta que se vuelva a dar el estado esperado. En la memoria intermedia de mensajes se administran 100 mensajes como máximo. El mensaje de espera se vuelve a borrar mediante la función Clear_KrlMsg( ). Los mensajes de espera también se pueden borrar mediante los ajustes de las opciones de mensaje durante el reset del programa, al salir del programa o al seleccionar un paso.

1. Cargar programa principal en el editor. 2. Declarar variables de trabajo para: Remitente, número de mensaje, texto del mensaje (de KrlMsg_T)   Campos con 3 elementos para el parámetro (de KrlMsgPar_T)  Opciones de mensaje generales (de KrlMsgOpt_T) "Handle" (como INT)  Variable para el resultado de la comprobación (como BOOL)   Variable para el resultado del borrado (como BOOL) 3. Iniciar variables de trabajo con los valores deseados. 4. Programar la activación de la función Set_KrlMsg(…). 5. Detener el programa con un bucle hasta que se dé el estado esperado o hasta que se haya borrado el mensaje mediante el botón Simular. 6. Borrar el mensaje de espera con la activación de la función Clear_KrlMsg( ). 7. Cerrar y guardar el programa principal.

Fig. 6-8: Mensaje de espera Ejemplo de programación para visualización/mensaje mencionados anteriormente:

130 / 255



El programa se detiene tras la transmisión del mensaje. El mensaje se borra con el estado de la entrada 12 ( TRUE). Después, el programa prosigue. El mensaje también se borra con el reset del programa o al salir del mismo. Para ello se utiliza el ajuste en las opciones de mensaje Clear_P_Reset TRUE. DECL KRLMSG_T mymessage DECL KRLMSGPAR_T Parameter[3] DECL KRLMSGOPT_T Option DECL INT handle DECL BOOL present, eraser ... IF $IN[12]==FALSE THEN mymessage={modul[] "College", Nr 1909, msg_txt[] "My Messagetext"} Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE, Log_to_DB TRUE} ;Los comodines [1..3] están vacíos Parameter[1] = {Par_Type #EMPTY} Parameter[2] = {Par_Type #EMPTY} Parameter[3] = {Par_Type #EMPTY} handle = Set_KrlMsg(#WAITING, mymessage, Parameter[ ], Option) ENDIF eraser=FALSE ;Bucle de parada hasta que se haya borrado este mensaje REPEAT IF $IN[12]==TRUE THEN eraser=Clear_KrlMsg(handle) ;Meldung loeschen ENDIF present=Exists_KrlMsg(handle) ;kann über simuliere geloescht worden sein UNTIL NOT(present) or eraser


131 / 255


6.12

Ejercicio: Programar mensajes de espera



Requisitos



Programar mensajes de espera propios Dar salida en mensajes a los parámetros que se desee.


1. Crear un mensajes de espera con el texto "Esperar al interruptor 15 o esperar 5 segundos". 2. Al iniciarse el programa Cargador, deberá emitirse el mensaje de espera. Ampliar el programa Cargador conforme a la lógica del mensaje de espera. 3. Comprobar el programa conforme a lo prescrito.

Lo que se debe saber tras el ejercicio: 1. ¿Cuál es la diferencia entre un mensaje "STATE" y otro "WAITING"? ............................................................. .............................................................

132 / 255



6.13

Variables y es tructuras ad icionales pa ra d iálogos

Estructura para la asignación de botones

Fig. 6-9: Diálogo 

Estructura KUKA predefinida: KrlMsgDlgSK_T

Enum KrlMsgParType_T Value, Key, Empty Struc KrlMsgDlgSK_T KrlMsgParType_T Sk_Type, Char SK_txt[10] 

Sk_Type: Tipo de datos de enumeración para el tipo de rotulación de los

botones como ENUM  #VALUE: el parámetro se procesa directamente en la forma transferida en el texto del mensaje.  #KEY: el parámetro es una palabra clave que se debe buscar en la base de datos de mensajes para cargar el texto correspondiente.  #EMPTY: el botón no tiene asignación.  

Sk_txt[ ]: el campo para texto o palabra clave para el botón.

Ejemplo de programa para la rotulación de 7 botones de un diálogo:

DECL KRLMSGDLGSK_T Softkey[7] ; 7 Preparar teclas de función programable posibles ... softkey[1]={sk_type #value, sk_txt[] "key1"} softkey[2]={sk_type #value, sk_txt[] "key2"} softkey[3]={sk_type #value, sk_txt[] "key3"} softkey[4]={sk_type #value, sk_txt[] "key4"} softkey[5]={sk_type #value, sk_txt[] "key5"} softkey[6]={sk_type #value, sk_txt[] "key6"} softkey[7]={sk_type #value, sk_txt[] "key7"} ...

Se pueden asignar como máximo 10 caracteres por botón. En función de los caracteres utilizados, los botones pueden tener distinta anchura.

6.14

Funciones p ara diálogos

Establecer un diálogo

Con la función Set_KrlDlg( ) se emite un mensaje de diálogo. Esto significa que el mensaje se transfiere a la memoria intermedia de mensajes y se muestra en una ventana de mensajes propia con botones.


133 / 255


Fig. 6-10: Diálogo 

Funciones integradas para emitir un diálogo

DEFFCT Extfctp Int Set_KrlDlg (MyQuestion:OUT, Parameter[ ]:OUT, Touchkey[ ]:OUT, Option:OUT) DECL KrlMsg_T MyQuestion DECL KrlMsgPar_T Parameter[ ] DECL KrlMsgDlgSK_T Touchkey[ ] DECL KrlMsgOpt_T Option 









MyQuestion: estructura para información general de mensaje (remiten-

te, número de mensaje, texto de la pregunta) Parameter[ ]: campo para los 3 parámetros posibles para los comodines %1, %2 y 3%. Deben transmitirse siempre los 3 parámetros, incluso en caso de que no se utilicen los comodines. Tecla de función[·]: estructura para la rotulación de los 7 botones posibles. Deben transmitirse siempre los 7 botones, incluso si no se van a utilizar. Opción: Estructura de opciones de mensaje generales (parada del procesamiento, inicio de sesión en la base de datos de mensajes, mensaje en caso de restablecimiento del programa o borrado implícito de selección de línea) Valor de retorno del diálogo: "handle" para el diálogo. Con este "handle" es posible controlar si el diálogo se ha podido emitir correctamente. Por lo demás, el "handle" es también el número de identificación en la memoria intermedia de mensajes.

DEF MyProg( ) DECL INT handle ... handle = Set_KrlDlg(MyQuestion, Parameter[ ], Touchkey[ ], Option)





handle == -1: no se ha podido emitir el diálogo (p. ej., porque toda-

vía hay otro diálogo activo al que no se ha respondido aún o porque la memoria intermedia de mensajes está saturada) handle > 0: el diálogo se ha emitido correctamente y se gestionará en la memoria intermedia de mensajes con el número de identificación correspondiente. En todos los casos, un diálogo se puede emitir sólo si no hay ningún otro diálogo activo. La función sólo emite el diálogo. No espera a la respuesta del diálo-

go.

134 / 255



Comprobación y valoración de un diálogo

Con la función Exists_KrlDlg( ) se puede comprobar si aún existe un diálogo concreto. También se comprueba si dicho diálogo se encuentra aún en la memoria intermedia de mensajes. En caso de que se responda al diálogo, la función facilita información sobre el botón que se ha pulsado. 


DEFFCT BOOL Exists_KrlDlg(INT nHandle:IN, INT Answer:OUT) DECL INT nHandle, answer 

nHandle: el handle facilitado por la función "Set_KrlDlg(…)" para el



diálogo. Answer: confirmación del botón pulsado. De este modo, el botón 1, definido como "Button[1]", devuelve el valor 1.

La función no espera a la respuesta del diálogo, sino que sólo explora la memoria intermedia en busca del diálogo que tenga este handle. La consulta en el programa KRL se debe realizar cíclicamente mientras el diálogo responda o se haya borrado de otro modo. 

Valor de retorno de la función:

DEF MyProg( ) DECL INT handle, answer DECL BOOL present ... handle = Set_KrlDlg(MyQuestion, Parameter[ ], Touchkey[ ], Option) ... present = Exists_KrlDlg(handle, Answer)





present == TRUE: este diálogo existe aún en la memoria intermedia

de mensajes. present == FALSE: este diálogo ya no se encuentra en la memoria intermedia de mensajes (por lo tanto, se ha respondido). Answer se restaura ahora con el valor del botón pulsado. Los valores

válidos son del 1 al 7, en función de los números de los botones programados.

6.15

Trabajos con un diálogo

Descripción de un diálogo definido por el usuario

Fig. 6-11: Diálogo


135 / 255




Función de un diálogo definido por el usuario



  







En todos los casos, un diálogo se puede emitir sólo si no hay ningún otro diálogo activo. Es posible definir hasta 7 teclas de función programables. Los diálogos son idóneos para mostrar preguntas a las que el usuario debe contestar. Con la función Set_KrlDlg() se emite un diálogo. La función sólo emite el diálogo. No espera a la respuesta del diálogo. Con la función Exists_KrlDlg( ) se puede comprobar si aún existe un diálogo concreto. Esta función tampoco espera a la respuesta del diálogo, sino que solo explora la memoria intermedia en busca del diálogo que tenga este handle. La consulta en el programa KRL se debe realizar cíclicamente mientras el diálogo responda o se haya borrado de otro modo. Se puede conseguir que el resto del flujo de programa dependa de la tecla de función programable seleccionada por el usuario.

Evaluación de botones 



Declaración e inicialización de botones

DECL KRLMSGDLGSK_T Softkey[7] ; 7 Preparar teclas de función programable posibles softkey[1]={sk_type #value, sk_txt[] "key1"} ; respuesta -> 1 softkey[2]={sk_type #value, sk_txt[] "key2"} ; respuesta -> 2 softkey[3]={sk_type #value, sk_txt[] "key3"} ; respuesta -> 3 softkey[4]={sk_type #value, sk_txt[] "key4"} ; respuesta -> 4 softkey[5]={sk_type #value, sk_txt[] "key5"} ; respuesta -> 5 softkey[6]={sk_type #value, sk_txt[] "key6"} ; respuesta -> 6 softkey[7]={sk_type #value, sk_txt[] "key7"} ; respuesta -> 7



Evaluación mediante Exists_KrlDlg(): el botón creado en el índice 4 retorna también 4.

; tecla de función nº 4 disponible como respuesta 4 en las variables ANSWER softkey[4]={sk_type #value, sk_txt[] "key4"} present = exists_KrlDlg(handle ,ANSWER) ; ANSWER descrito por el sistema

Programación de diálogos definidos por el usuario

136 / 255

1. Cargar programa principal en el editor. 2. Declarar variables de trabajo para:  Remitente, número de mensaje, texto del mensaje (de KrlMsg_T)  Campos con 3 elementos para el parámetro (de KrlMsgPar_T) 7 botones posibles (de KrlMsgDlgSK_T)  Edición: 24.02.2015 Versión: P2KSS8_robotprogramming_2_(R2)_V4


Opciones de mensaje generales (de KrlMsgOpt_T) "Handle" (como INT)  Variable para el resultado de la comprobación (como BOOL)  Variable para el resultado de la respuesta cuyo botón se haya pulsado (como INT) Iniciar variables de trabajo con los valores deseados. Programar la activación de la función Set_KrlDlg(…). Detener el programa con un bucle hasta que se haya respondido al diálogo. Evaluar el diálogo con la activación de la función Exists_KrlDlg( ). Planificar y programar más ramificaciones en el programa.  

3. 4. 5. 6. 7.

8. Cerrar y guardar el programa principal.

Fig. 6-12: Diálogo con 3 botones Ejemplo de programación para visualización/mensaje mencionados anteriormente: los botones no deben programarse por completo, si no con espacios en blanco (n.º 1, 4, 6). En este caso, el sistema coloca de manera automática y sucesivamente los los botones. Si sólo se utilizan los botones 1, 4 y 6, únicamente son posibles las respuestas 1, 4 y 6. El programa se detiene tras aparecer el diálogo; el diálogo se cierra tras la respuesta. Después, el programa prosigue. A continuación, se programa un distribuidor. El mensaje también se borra con el reset del programa o al salir del mismo. Para ello se utiliza el ajuste en las opciones de mensaje Clear_P_Reset TRUE. DECL KRLMSG_T myQuestion DECL KRLMSGPAR_T Parameter[3] DECL KRLMSGDLGSK_T Softkey[7] ;7 Preparar teclas de función programable posibles DECL KRLMSGOPT_T Option DECL INT handle, answer DECL BOOL present ... myQuestion={modul[] "College", Nr 1907, msg_txt[] "My Question?"} Option= {VL_STOP FALSE, Clear_P_Reset TRUE, Clear_P_SAW FALSE, Log_to_DB TRUE} ;Los comodines [1..3] están vacíos Parameter[1] = {Par_Type #EMPTY} Parameter[2] = {Par_Type #EMPTY} Parameter[3] = {Par_Type #EMPTY} softkey[1]={sk_type #value, sk_txt[] "key1"} ; Botón 1 softkey[2]={sk_type #EMPTY, sk_txt[] "key2"} ; Botón 2


137 / 255

Programación de robots 2 softkey[3]={sk_type softkey[4]={sk_type softkey[5]={sk_type softkey[6]={sk_type softkey[7]={sk_type suprimirse ...

#EMPTY, #value, #EMPTY, #value, #EMPTY}

sk_txt[] "key3"} ; Botón 3 sk_txt[] "key4"} ; Botón 4 sk_txt[] "key5"} ; Botón 5 sk_txt[] "key6"} ; Botón 6 ; Botón 7: sk_txt[] también puede

...; Emitir un diálogo handle = Set_KrlDlg(myQuestion, Parameter[ ],Softkey[ ], Option) answer=0 REPEAT ; Bucle de parada hasta que se haya contestado a este diálogo present = exists_KrlDlg(handle ,answer) ; El sistema describe la respuesta UNTIL NOT(present) ... SWITCH answer CASE 1 ; Botón 1 ; Acción con botón 1 ... CASE 4 ; Botón 4 ; Acción con botón 4 ... CASE 6 ; Botón 6 ; Acción con botón 6 ... ENDSWITCH ...

138 / 255



6.16

Ejercicio: Programar un diálogo



Requisitos



Programar preguntas de diálogo propias. Dar salida en mensajes a los parámetros que se desee.


Tarea parcial: Mensaje de diálogo 1. Crear un mensaje de diálogo con el texto "Seleccionar la cantidad de cubos que deben transportarse". 2. Poner a disposición los números 2, 3, 5, 8 y asignar "FIN" a la tecla de función programable 7. 3. Ampliar el programa Cargador con el diálogo y salir del bucle infinito con "FIN". 4. Compruebe su programa según prescripción.

Lo que se debe saber tras el ejercicio: 1. ¿Cómo se rotulan las teclas de función programables en el diálogo? ............................................................ ............................................................


139 / 255


140 / 255


7 Programación de movimientos con KRL

7

Programación d e m ovimientos c on K RL

7.1

Vista general Esta unidad incluye los siguientes contenidos:     

7.2

Programar el movimiento mediante KRL Programar los movimientos relativos mediante KRL Programación de bloques Spline mediante KRL Calcular y manipular posiciones del robot Realizar una modificación adecuada de Status y Turn

Programar movimientos individuales SPLINE mediante KRL

Definición de un movimiento

Fig. 7-1: Formularios Inline paso individual movimiento SPTP/SLIN/ SCIRC Indicaciones necesarias para un movimiento            

7.3

Tipo de movimiento SPTP, SLIN, SCIRC Posición de destino y posible posición auxiliar Parada exacta o aproximación Velocidad - SPTP (%) y movimiento de trayectoria (m/s) Herramienta - TCP y carga Sistema de coordenadas base Herramienta guiada por robot o externa Aceleración y tirón (modificación de la aceleración) Posible parámetro de aproximación Control de orientación para movimientos de trayectoria Ángulo circular para un movimiento circular CIRC Control de orientación con punto auxiliar y de destino de un movimiento circular

Movimiento de conjunto individual con SPTP

Descripción

SPTP se puede programar como segmento en un bloque Spline PTP o como movimiento individual. Existe la posibilidad de copiar un movimiento individual SPTP en un bloque Spline PTP, pero solo si no contiene ninguna asignación a variables del sistema que están prohibidos allí.

Sintaxis

SPTP Punto de destino >


141 / 255


Aclaración de la sintaxis

Elemento Punto de destino

Descripción Tipo: AXIS, E6AXIS, POS, E6POS, FRAME Las coordenadas cartesianas hacen referencia al sistema de coordenadas BASE. Si no se indican todos los componentes del punto de destino, la unidad de control adopta los valores de la posición anterior para los componentes que faltan. Si esta posición anterior es el punto de destino de un circuito con ángulo circular, se aceptarán los valores del punto de destino realmente alcanzado y no del punto de destino programado. Si ninguna posición anterior es conocida para la unidad de control del robot, los componentes que falten se aceptarán de la posición actual del robot.

SysVar Valor

Asignación de valor a la variable del sistema Para segmentos SPTP: La asignación solo es válida para ese segmento. Las variables del sistema también se pueden ocupar por activación de función. Para esta función se aplican las mismas restricciones que para las funciones en el Trigger.

C_SPL





Con C_SPL: Se da una aproximación del punto de destino. $APO determina cuándo se iniciará como muy pronto el posicionamiento aproximado. Solo es posible para movimientos individuales, no para segmentos. Sin tud. C_SPL: El punto de destino se alcanza con exacti-

Hasta el software del sistema 8.2, la identificación para el posicionamiento aproximado en Spline era "C_DIS". Si en versiones superiores a 8 se utilizan programas basados en 8.2 o en versiones anteriores y contienen C_DIS, no será necesario cambiarlo a C_SPL, sino que se puede dejar.

Ejemplos



El robot se aproxima a una posición del fichero DAT; la posición ha sido programada previamente mediante formulario inline y realiza un posicionamiento aproximado a este punto P3

SPTP XP3 C_SPL 

El robot se aproxima a una posición introducida  Específico del eje (AXIS o E6AXIS)

SPTP {A1 0, A2 -80, A3 75, A4 30, A5 30, A6 110} 

Posición (con herramienta actualmente activa y Base)

SPTP {X 100, Y -50, Z 1500, A 0, B 0, C 90, S 3, T 35} 

El robot se desplaza solo con la introducción de una o varias unidades

SPTP {A1 30} ; sólo A1 desplazado a 30° SPTP {X 200, A 30} ; sólo en X a 200mm y A a 30° 

El robot se desplaza con valores modificados utilizando WITH

SPTP XP10 WITH $TOOL=tool_data[2], $LOAD=load_data[2] ; Se avanza hasta el punto P10 con TOOL 2

142 / 255



7.4

Movimiento de paso individual con SLIN y SCIRC

Descripción

SLIN, SCIRC: SLIN y SCIRC se pueden programar como segmento en un bloque Spline CP o como movimiento individual. Existe la posibilidad de copiar un movimiento individual SLIN o SCIRC en un bloque Spline CP, pero solo si no contiene ninguna asignación a variables del sistema que están prohibidos allí.

Sintaxis

SLIN: SLIN Punto de destino >

<

> C_SPL

SCIRC:

SCIRC Punto auxiliar, Punto de destino <, CA Ángulo circular> >


Elemento Punto auxiliar Punto de destino

Descripción Tipo: POS, E6POS, FRAME Las coordenadas hacen referencia al sistema de coordenadas BASE. Si no se indican todos los componentes del punto de destino, la unidad de control adopta los valores de la posición anterior para los componentes que faltan. Si esta posición anterior es el punto de destino de un circuito con ángulo circular, existe la siguiente diferencia: 



Ángulo circular

Si la posición anterior se encuentra fuera de un bloque Spline, se aceptarán los valores del punto de destino realmente alcanzado y no del punto de destino programado. Si la posición anterior se encuentra en un bloque Spline, se aceptarán los valores del punto de destino programado y no del punto de destino realmente alcanzado.

Si ninguna posición anterior es conocida para la unidad de control del robot, los componentes que falten se aceptarán de la posición actual del robot. Unidad: Grado; sin limitación

SysVar


143 / 255


Elemento Valor

Descripción Asignación de valor a la variable del sistema Para segmentos: La asignación solo es válida para ese segmento. Las variables del sistema también se pueden ocupar por activación de función. Para esta función se aplican las mismas restricciones que para las funciones en el Trigger.

C_SPL





Con C_SPL: Se da un posicionamiento aproximado del punto de destino. $APO determina cuándo se iniciará como muy pronto el posicionamiento aproximado. Solo es posible para movimientos individuales, no para segmentos. Sin C_SPL: El punto de destino se alcanza con exactitud.

Hasta el software del sistema 8.2, la identificación para el posicionamiento aproximado en Spline era "C_DIS". Si en versiones superiores a 8 se utilizan programas basados en 8.2 o en versiones anteriores y contienen C_DIS, no será necesario cambiarlo a C_SPL, sino que se puede dejar.

Ejemplos

SLIN: 

El robot se desplaza hasta una posición calculada y realiza una aproximación a este punto DEPÓSITO[4]

SLIN ABLAGE[4] C_SPL 

El robot se desplaza al punto P4 con estos valores de aceleración

SLIN P4 WITH $ACC={CP 1.8, ORI1 120, ORI2 140}

SCIRC 

El robot se acerca a las posiciones previamente programadas del archivo DAT y se desplaza en un ángulo circular de 190º.

SCIRC XP3, XP4, CA 190 

El robot se acerca a las posiciones indicadas y se desplaza en un ángulo circular de 180º.

SCIRC {X 100, Y ...}, {X 150, Y ...}, CA 180 

144 / 255

Ángulo circular positivo (CA>0): El circuito se desplaza en el sentido programado: Punto inicial - punto auxiliar - punto de destino



Fig. 7-2: Ángulo circular CA = +290° 

Ángulo circular negativo (CA<0): El circuito se desplaza en sentido contrario al sentido programado: Punto inicial - punto destino - punto de auxiliar

Fig. 7-3: Ángulo circular CA = -290°

7.5

Parámetros d e movimiento

Función de los parámetros de movimiento

Preajustes para la programación de movimientos 



Se pueden aplicar ajustes existentes: de la ejecución de la línea INI   del último formulario en línea  de los últimos ajustes de las variables de sistema correspondientes Modificar o inicializar las correspondientes variables de sistema

Variables de sistema de los parámetros de movimiento 

Herramienta: $TOOL y $LOAD  Activación del TCP medido

$TOOL = tool_data[x] ; x = 1...16


145 / 255


Activación de los datos de carga correspondientes

$LOAD = load_data[x] ; x = 1...16 

Base de referencia / base de trabajo: $BASE Activación de la base medida 

$BASE = base_data[x] ; x = 1...32 

Herramienta guiada por robot o externa: $IPO_MODE  Herramienta guiada por robot

$IPO_MODE = #BASE 

Herramienta externa

$IPO_MODE = #TCP 

Velocidad  Con movimiento PTP

$VEL_AXIS[x] ; x=1...8 para cada eje 

Con movimientos de trayectoria LIN o CIRC

$VEL.CP = 2.0 ; [m/s] Velocidad de trayectoria $VEL.ORI1 = 150 ; [°/s] Velocidad de vaivén $VEL.ORI2 = 200 ; [°/s] Velocidad rotacional

La dirección de avance de la herramienta es en la mayoría de los casos el eje X. La velocidad de giro es el giro alrededor de este eje X con ángulo C. En la velocidad de basculamiento se gira alrededor de los otros dos ángulos (A y B). 

Aceleración  Con movimiento PTP

$ACC_AXIS[x] ; x=1...8 para cada eje 


$ACC.CP = 2.0 ; [m/s²] Aceleración de trayectoria $ACC.ORI1 = 150 ; [°/s²] Aceleración de vaivén $ACC.ORI2 = 200 ; [°/s²] Aceleración rotacional 

Tirón para movimiento SPTP 

$GEAR_JERK[1...12] = 0 ... 100 Tirón del engranaje de los ejes A1 a E6 en tanto por ciento (1...100) SPTP XP10 WITH GEAR_JERK[1]=22, GEAR_JERK[2]=66 

Con movimientos de trayectoria SLIN o SCIRC

$JERK={CP 50.0,ORI 50000.0,AX {A1 1000.0,A2 1000.0,A3 1000.0,A4 1000.0,A5 1000.0,A6 1000.0,E1 1000.0,E2 1000.0,E3 1000.0,E4 1000.0,E5 1000.0,E6 1000.0}}

El grupo está formado por los siguientes componentes: 

CP: modificación de la aceleración en trayectoria en [m/s3]



ORI: modificación de la aceleración en trayectoria en [º/s3]



146 / 255

AX: modificación de la aceleración del eje en [°/s3] en ejes de rotación o en [m/s3] en el caso de ejes lineales


7 Programación de movimientos con KRL SLIN XP13 WITH $JERK = {CP 44} ; [m/s³] Modificación de la aceleración en trayectoria 

Distancia de aproximación  en caso de SPINE pasos individuales SLIN, SCIRC y en caso de SPTP: C_SPL El alejamiento respecto del punto de destino debe quedar por debajo del valor $APO.CDIS

$APO.CDIS = 250.0 ; [mm] Distancia SPTP XP3 C_SPL SLIN XP4 C_SPL 

Solo con movimiento PTP: C_PTP

$APO.CPTP = 50 ; Valor de aproximación en [%] para C_PTP PTP XP3 C_PTP 

Con movimientos de trayectoria LIN, CIRC: C_ORI El ángulo de orientación dominante debe quedar por debajo del valor $APO.CORI

$APO.CORI = 50.0 ; [°] Ángulo SLIN XP4 C_ORI 

Con movimientos de trayectoria LIN, CIRC: C_VEL La velocidad en la fase de frenado hacia el punto de destino debe quedar por debajo del valor $APO.CVEL

$APO.CVEL = 75.0 ; [%] Porcentaje LIN XP4 C_VEL 

Control de la orientación: Solo con LIN y CIRC  Con LIN y CIRC: $ORI_TYPE 

$ORI_TYPE = #CONSTANT

Durante el movimiento de trayectoria, la orientación se mantiene constante. Para el punto final se ignora la orientación programada.

Fig. 7-4: Control orientación constante 

$ORI_TYPE = #VAR

Durante el movimiento de trayectoria, la orientación se modifica continuamente hacia la orientación del punto de destino.


147 / 255


Fig. 7-5: Estándar o PTP manual 

$ORI_TYPE = #JOINT



Durante el movimiento de trayectoria, la orientación de la herramienta es modificada ininterrumpidamente desde la posición inicial hasta la posición final. Esto se logra mediante el desplazamiento lineal del ángulo del eje de la muñeca. La problemática de la singularidad de la muñeca puede evitarse con esta opción. Se produce un giro alrededor de la dirección de impacto de la herramienta. No es posible realizar un giro alrededor de la dirección de impacto de la herramienta. Solo con CIRC: $CIRC_TPYE La variable $CIRC_TYPE carece de significado cuando se efectúa un desplazamiento lineal del ángulo del eje de la muñeca con $ORI_TYPE = #JOINT. 

$CIRC_TYPE = #PATH

Control de la orientación relacionada con la trayectoria durante el movimiento circular

Fig. 7-6: Orientación constante, referida a la trayectoria 

$CIRC_TYPE = #BASE

Control de orientación referido al espacio durante el movimiento circular 148 / 255



Fig. 7-7: Orientación constante, referida a la base Configuración del círculo SCIRC

Para movimientos SCIRC, la unidad de control del robot puede tener en cuenta la orientación programada del punto auxiliar. Si se debe tener en cuenta y en qué medida puede determinarse por el usuario: 



En caso de programación con sintaxis KRL: mediante la variable del sistema $CIRC_MODE En caso de programación mediante formularios inline: en la ventana de opciones Parámetros de movimiento, pestaña Configuración del círculo

Del mismo modo, además se puede determinar para las instrucciones SCIRC con ángulo circular si el punto de destino debe tener la orientación programada o si la orientación se debe continuar de acuerdo con el ángulo circular. $CIRC_MODE solo se escribir mediante una instrucción SCIRC. $CIRC_MODE no se puede leer. Sintaxis KRL 



Para puntos auxiliares: $CIRC_MODE.AUX_PT.ORI = Reacción HP Para puntos de destino: $CIRC_MODE.TARGET_PT.ORI = Reacción ZP


149 / 255


Elemento

Descripción

Reacción HP

Tipo de datos: ENUM/menú desplegable

Comportamiento de orientación en punto auxiliar.

Reacción ZP

Comportamiento de orientación en punto de destino.

#INTERPOLATE: En el punto auxiliar, el TCP adopta la orientación programada.  #IGNORE: La unidad de control del robot ignora la orientación programada del punto auxiliar. La orientación de partida del TCP se convierte durante la trayectoria más corta en la orientación de destino.  #CONSIDER (por defecto): Básicamente existen 2 trayectorias para convertir la orientación de partida con un giro en la orientación de destino. Una corta y otra larga. Con #CONSIDER la unidad de control del robot escoge la trayectoria que se aproxime más a la orientación programada del punto auxiliar. Es posible que el TCP adopte la orientación programada del punto auxiliar en un punto indeterminado de la trayectoria. Sin embargo, éste no tiene por qué ser el caso. Tipo de datos: ENUM/menú desplegable 





#INTERPOLATE: En el punto de destino real se acepta la orientación programada del punto de destino. (Única posibilidad para SCIRC sin indicación del ángulo circular. Si #EXTRAPOLATE está ajustado, #INTERPOLATE se ejecuta igualmente.) #EXTRAPOLATE: La orientación se adapta al ángulo circular: Si el ángulo circular prolonga el movimiento, se aceptará la orientación programadaseen el punto destinocon programado. La orientación continúa dede acuerdo ello hasta el punto de destino real. Si el ángulo circular acorta el movimiento, no se alcanzará la orientación programada. (Valor por defecto para SCIRC con indicación del ángulo circular)

7.5.1

SCIRC: Comportamiento de orientación – ejemplo del punto auxiliar

Descripción

Para el TCP se han programado las siguientes orientaciones:   

Punto de inicio: 0° Punto auxiliar: 98° Punto de destino: 197°

Por lo tanto, el cambio de orientación es de 197°. Si se ignora el punto auxiliar, también se más podrácorta alcanzar la orientación de destino a través del cambio de orientación de 360° - 197° = 163°.  

#INTERPOLATE

150 / 255

Las flechas discontinuas naranjas muestran la orientación programada. Las flechas grises indican esquemáticamente cómo sería la orientación real, si se diferencia de la orientación programada.

El TCP acepta la orientación programada de 98° en el punto auxiliar. El cambio de orientación es de 197°.



Fig. 7-8: #INTERPOLATE SP AuxP TP #IGNORE

Punto de inicio Punto auxiliar Punto de destino

Se ejecuta el cambio de orientación corto de 163°. La orientación programada del punto auxiliar se ignora.

Fig. 7-9: #IGNORE #CONSIDER

#CONSIDER es adecuado si el usuario desea determinar la dirección en la que tiene que hacer el TCP el cambio de orientación, sin que dependa de una orientación determinada en el punto auxiliar. El usuario puede especificar la dirección mediante el punto auxiliar. La orientación programada del punto auxiliar es 98° y, de este modo, se encuentra en la trayectoria más larga. Por ello, la unidad de control del robot escoge la trayectoria más larga para el cambio de orientación.

Fig. 7-10: #CONSIDER Edición: 24.02.2015 Versión: P2KSS8_robotprogramming_2_(R2)_V4

151 / 255


Otro ejemplo para #CONSIDER: Si el punto auxiliar se ha programado con 262°, se encontraría en la trayectoria corta. Por ello, la unidad de control del robot escogería la trayectoria más corta para el cambio de orientación. Las flechas grises indican que en absoluto acepta obligatoriamente la orientación programada del punto auxiliar.

Fig. 7-11: #CONSIDER, otro ejemplo 7.5.2

SCIRC: Comportamiento de orientación – ejemplo del punto de destino

Descripción

 

#INTERPOLATE

Las flechas discontinuas naranjas muestran la orientación programada. Las flechas grises muestran la orientación real si se diferencia de la orientación programada.

En TP, que se encuentra delante de TP_CA, aún no se ha alcanzado la orientación programada. En TP_CA se acepta la orientación programada.

Fig. 7-12: #INTERPOLATE

#EXTRAPOLATE

152 / 255

SP

Punto de inicio

AuxP TP TP_CA

Punto auxiliar Punto de destino programado Punto de destino real. Se obtiene por el ángulo circular.

En TP se acepta la orientación programada. Para TP_CA se continúa esta orientación de acuerdo con el ángulo circular.



Fig. 7-13: #EXTRAPOLATE 7.5.3

Restricciones en $CIRC_MODE

Restricciones

Descripción de las variables del sistema 



Si para un segmento SCIRC se aplica $ORI_TYPE = #IGNORE, no se evaluará $CIRC_MODE. Si a un segmento SCIRC le precede un segmento SCIRC o SLIN para el que se aplica $ORI_TYPE = #IGNORE, no se podrá utilizar #CONSIDER en el segmento SCIRC.

Para SCIRC con ángulo circular:  



Aclaración de los mensajes de error

Para el punto auxiliar no se debe ajustar #INTERPOLATE. Si se aplica $ORI_TYPE = #IGNORE, no se podrá ajustar #EXTRAPOLATE para el punto de destino. Si precede un segmento spline para el que se aplica $ORI_TYPE = #IGNORE, no se podrá ajustar #EXTRAPOLATE para el punto de destino.

Algunos mensajes de error contienen el texto "error por regla x" En la programación de $CIRC_MODE es necesario tener en cuenta tanto la orientación como los ejes externos: 1. Regla 1: #CONSIDER se permite justo cuando no se ignoran ni el punto de inicio ni el punto de destino. 2. Regla 2: $CIRC_TYPE=#PATH se permite justo cuando no se ignoran ni el punto de inicio ni el punto de destino. 3. Regla 3: Si $ORI_TYPE=#IGNORE o $EX_AX_IGNORE se han activado, $CIRC_MODE ya no se evalúa. 4. Regla 4: si se programa un ángulo circular, queda prohibida la interpolación del punto auxiliar. 5. Regla 5: justo cuando se programe un ángulo circular, podrá determinarse el punto de destino mediante extrapolación, siempre que no se ignoren los puntos de inicio y de destino. 6. Regla 6: justo cuando se programe un ángulo circular, podrá aceptarse el punto de destino (interpolarse), siempre que no se ignore. 7. Regla 7: #CONSIDER la trayectoria únicamente tiene efecto con ejes externos de rotación continua. Con otro tipo de ejes, se escogerá siempre la trayectoria corta que corresponde a #IGNORE. 8. Regla 8: La componente TARGET_PT únicamente se tiene en cuenta cuando hay programado un ángulo circular.


153 / 255


9. Regla 9: la lectura $CIRC_MODE no se permite en ningún lugar, la escritura únicamente en el WITH-Token de un SCIRC.

7.6

Movimientos in dividuales S PLINE: V ariables d el s istema p ara WI TH

Bloque Spline, movimiento individual Spline

Para los bloques Spline y los movimientos individuales Spline se pueden describir las siguientes variables de sistema con la línea WITH: $ACC $ACC_AXIS $ACC_EXTAX $APO $BASE $CIRC_TYPE $ECO_LEVEL $GEAR_JERK $IPO_MODE $JERK $LOAD $ORI_TYPE $ROTSYS $SPL_ORI_JOINT_AUTO $SYNC_ID $SYNC_LIST $TOOL $VEL $VEL_AXIS $VEL_EXTAX Adicionalmente para SCIRC y SLIN: $CIRC_MODE Las variables del sistema están descritas en el capítulo variables del sistema.

7.7

Programar mo vimientos r elativos y ab solutos co n K RL

Movimiento absoluto

SPTP {A3 45}

Aproximación la aposición posiciona el ejedeA3 45°. de destino mediante valores absolutos. Aquí se

154 / 255



Fig. 7-14: Movimiento absoluto del eje A3 Movimiento relativo

SPTP_REL {A3 45}

Aproximación de la posición de destino mediante el avance desde la posición actual conforme al valor indicado. Aquí, el eje A3 se posiciona 45º desde la posición actual, quedando en 135º.


155 / 255


Fig. 7-15: Movimiento relativo del eje A3 La instrucción REL siempre hace referencia a la posición actual del robot. Si una instrucción REL se interrumpe, el robot por tanto efectúa, desde la posición de interrupción, todo el movimiento REL completo otra vez. SPTP_REL: SPTP_RELse puede programar como segmento en un bloque Spline PTP o como movimiento individual. Existe la posibilidad de copiar un movimiento individual SPTP_REL en un bloque Spline PTP, pero solo si no contiene ninguna asignación a variables del sistema que están prohibidos allí.

SLIN_REL, SCIRC_REL: SLIN_REL y SCIRC_REL se pueden programar como segmento en un bloque Spline CP o como movimiento individual. Existe la posibilidad de copiar un movimiento individual SLIN_REL o SCIRC_REL en un bloque Spline CP, pero solo si no contiene ninguna asignación a variables del sistema que están prohibidos allí. Los movimientos relativos SPTP_Rel, SLIN_REL y SCIRC_REL solo están disponibles a partir del software KSS 8.3.6

Sintaxis

SPTP_REL: SPTP_REL Punto de destino > <#BASE|#TOOL>

156 / 255




Descripción Tipo: AXIS, E6AXIS, POS, E6POS, FRAME El punto de destino puede indicarse de forma cartesiana o específica del eje. La unidad de control interpreta las coordenadas en relación a la posición de destino del paso anterior. Si no se indican todos los componentes del punto de destino, la unidad de control pondrá a 0 los componentes que falten. Esto quiere decir que los valores absolutos de estos componentes no variarán. Los datos de estado y giro, si existen, se tendrán en

Valor

cuenta por la unidad de control. (Esto ocurre contrariamente a SLIN_REL, SCIRC_REL y SPL_REL, donde se ignoran) Asignación de valor a la variable del sistema Para segmentos SPTP: La asignación solo es válida para ese segmento.

C_SPL

#BASE, #TOOL

Las variables del sistema también se pueden ocupar por activación de función. Para esta función se aplican las mismas restricciones que para las funciones en el Trigger.  Con C_SPL: Se da una aproximación del punto de destino. $APO determina cuándo se iniciará como muy pronto el posicionamiento aproximado. Solo es posible para movimientos individuales, no para segmentos. Sin C_SPL: El punto de destino se alcanza con exacti tud. Solo está permitido si el punto de destino se ha indicado de forma cartesiana. 



#BASE (por defecto): Las coordenadas de este punto de destino hacen referencia al sistema de coordenadas que pertenece a la base física. #TOOL: Las coordenadas de este punto de destino hacen referencia al sistema de coordenadas que pertenece a la herramienta física.

$IPO_MODE no influye en el significado de #BASE y #TOOL.

SLIN_REL: SLIN_REL Punto de destino > <#BASE|#TOOL>

SCIRC_REL: SCIRC_REL CA Ángulo Punto de destino circular> > <<,C_SPL ><#BASE|#TOOL > SysVar1 = Valor1 SysVar2


157 / 255



Descripción Tipo: POS, E6POS, FRAME El punto debe indicarse en coordenadas cartesianas. La unidad de control interpreta las coordenadas en relación a la posición de destino del movimiento anterior. Si no se indican todos los componentes del punto, la unidad de control pondrá a 0 los componentes que falten. Esto quiere decir que los valores absolutos de estos componentes no variarán. Los datos de estado y giro, si existen, se ignorarán por la unidad de control. (Esto contrasta con SPTP_REL, donde se tienen en cuenta) En el punto auxiliar se ignoran además los ángulos de orientación.

Ángulo circular

Valor

El punto auxiliar no puede ser aproximado. Siempre se ejecutará de forma exacta. Unidad: Grado; sin limitación Asignación de valor a la variable del sistema Para segmentos: La asignación solo es válida para ese segmento.

C_SPL

Las variables del sistema también se pueden ocupar por activación de función. Para esta función se aplican las mismas restricciones que para las funciones en el Trigger.  Con C_SPL: Se da una aproximación al punto de destino. $APO determina cuándo se iniciará como muy



#BASE, #TOOL





pronto posicionamiento aproximado. Solo eselposible para movimientos individuales, no para segmentos. Sin C_SPL: El punto de destino se alcanza con exactitud. #BASE (por defecto): Las coordenadas de este punto de destino hacen referencia al sistema de coordenadas que pertenece a la base física. #TOOL: Las coordenadas de este punto de destino hacen referencia al sistema de coordenadas que pertenece a la herramienta física.

$IPO_MODE no influye en el significado de #BASE y #TOOL.

Ejemplo



El eje 2 se mueve 30º en dirección negativa. El resto de ejes no se mueve.

PTP_REL {A2 -30} 

El TCP se desplaza desde la posición actual 100 mm en dirección X y 200 mm en dirección Z negativa. Y, A, B, C y S permanecen constantes. T se calcula en el trayecto más corto.

PTP_REL {X 100,Z -200} 

158 / 255

En el sistema de coordenadas BASE, el TCP se desplaza de la posición actual 100 mm en dirección X y 200 mm en dirección Z negativa. Y, A, B, C y S permanecen constantes. T se obtiene con el movimiento.


7 Programación de movimientos con KRL LIN_REL {X 100,Z -200} ; #BASE es el ajuste por defecto



La indicación #BASE o #TOOL sólo hace referencia a la instrucción LIN_REL a la cual pertenece. No repercute en las instrucciones subsiguientes. En el sistema de coordenadas TOOL, el TCP se desplaza de la posición actual 100 mm en dirección X negativa. Y, Z, A, B, C y S permanecen constantes. T se obtiene con el movimiento. Este ejemplo es apropiado para mover hacia atrás la herramienta en la dirección de avance. La condición necesaria es que la dirección de avance de la herramienta haya sido medida en dirección X.

LIN_REL {X -100} #TOOL 

El punto de destino del movimiento circular se determina mediante un ángulo circular de 500°. Se da una aproximación al punto de destino.

CIRC_REL {X 100,Y 30,Z -20},{Y 50},CA 500 C_VEL 

Ejemplos de sintaxis

SPTP XHOME SLIN XP1 SLIN_REL{X 0, Y 500, Z 0, A 0, B 0, C 0} WITH $BASE=$NULLFRAME #BASE SLIN_REL{X 400} WITH $TOOL=TOOL_DATA[1], $LOAD=LOAD_DATA[1] C_SPL #TOOL SLIN_REL{A 20} SPTP_REL{A3 90} C_SPL SPTP_REL Z 50, B -30} WITH $VEL.AXIS[4]=90 C_SPL #TOOL SPTP_REL{A1 100}

PTP_REL {A6 360}

El A6 no se mueve, ya que la unidad de control interpreta la posición de destino y la posición final como idénticas, porque tiene lugar un cálculo de módulo. SPTP_REL {A6 360}

El A6 se mueve 360º ya que no se efectúa ningún cálculo de módulo.

7.8

Calcular o manipular p osiciones d e r obot

Descripción

Posiciones de destino del robot  

Se almacenan en estructuras: Están disponibles las siguientes estructuras predefinidas:  AXIS Ángulo del eje A1 ... A6  E6AXIS Ángulo del eje A1 ... A6 y E1 ... E6  POS Posición (X, Y, Z), orientación (A, B, C) con estado y giro (S, T)  E6POS Posición (X, Y, Z), orientación (A, B, C) con estado y giro (S, T) y E1 ... E6  FRAME Posición (X, Y, Z), orientación (A, B, C)


159 / 255

Programación de robots 2  

Principio

Las posiciones existentes del fichero DAT se pueden manipular. Cada uno de los grupos de posiciones existentes se pueden modificar con precisión mediante el separador de puntos.

En el cálculo es importante tener en cuenta los ajustes TOOL y BASE correctos y activarlos a continuación en la programación de movimientos. En caso de incumplimiento pueden producirse movimientos inesperados y colisiones.

Variables de sistema importantes 



$POS_ACT: Posición actual del robot. La variable (E6POS) describe la posición teórica del TCP referida al sistema de coordenadas BASE. $AXIS_ACT: Posición actual del robot específica del eje (valor teórico). La variable (E6AXIS) incluye el ángulo actual del eje o las posiciones actuales del eje.

Calcular la posición de destino absoluta 

Modificar una vez la posición del fichero DAT

XP1.x = 450 ; Valor X nuevo 450mm XP1.z = 30.0*distance ; Se calcula el nuevo valor Z SPTP XP1 

Modificar en cada ejecución la posición del fichero DAT

; Valor X desplazado cada vez por 450mm XP2.x = XP2.x + 450 SPTP XP2 

La posición se acepta y se guarda en una variable

myposition = XP3 myposition.x = myposition.x + 100 ; Se añaden 100mm al valor x myposition.z = 10.0*distance ; Calcular el nuevo valor Z myposition.t = 35 ; Fijar valor Turn SPTP XP3 ; Posición no cambiada SPTP myposition ; Posición calculada

Procedimiento

1. Cargar el programa en el editor como experto mediante el pulsador Abrir 2. Calcular/manipular la posición. Guardar temporalmente los nuevos valores calculados en una nueva va riable 3. Comprobar los ajustes predefinidos para la programación de movimientos y aceptar o inicializar de nuevo:  Herramienta ($TOOL y $LOAD) Ajustes base ($BASE)   Herramienta externa o guiada por robot ($IPO_MODE)  Velocidad Aceleración  Posible distancia de aproximación posible control de la orientación 4. Crear una instrucción de movimiento completa  Tipo de movimiento (SPTP, SLIN, SCIRC, SPTP_REL, SLIN_REL, SCIRC_REL)  Punto de destino (con SCIRC también punto auxiliar) Para SCIRC posible ángulo circular (CA)   Activar aproximación (C_SPL, C_DIS) 5. En caso de nuevo movimiento de vuelta al punto 3 6. Cerrar el editor y guardar  

160 / 255



7.9

Modificar de forma adecuada bits de Status y Turn

Descripción



Los valores de posición (X, Y, Z) y de orientación (A, B, C) del TCP no son suficientes para determinar unívocamente la posición del robot, ya que con el mismo TCP son posibles varias posiciones del eje. Status y Turn sirven para determinar una posición unívoca desde varias posiciones del eje posibles.

Fig. 7-16: Diferentes posiciones de eje debidos a diferentes valores de Status y Turn 

Status (S) y Turn (T) forman parte de los tipos de datos POS y E6POS:

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 



La unidad de control del robot considera los valores de Status y Turn programados solo en caso de movimientos SPTP. Se ignoran para movimientos CP. Por este motivo, la primera instrucción de movimiento en un programa KRL debe ser una de las siguientes instrucciones para que se determine una posición de salida unívoca para el robot: 

Una instrucción SPTP completa del tipodel POS E6POS O bien una instrucción SPTP completa tipoo AXIS o E6AXIS "Completa" significa que se deben indicar todos los componentes del punto de destino. La posición HOME por defecto siempre es una instrucción PTP completa. En las demás instrucciones se pueden omitir Status y Turn: La unidad de control del robot conserva un valor de Status anterior.   El valor Turn resulta con el movimiento CP procedente de la trayectoria.  Para los movimientos SPTP, la unidad de control del robot selecciona el valor Turn que ofrezca el trayecto más corto posible (es decir, no se 




161 / 255


vulnera ningún interruptor de final de carrera de software y, al mismo tiempo, el que esté más próximo al ángulo de inicio).

Función

STATUS 



La indicación de Status (estado) evita ambigüedades en la posición de eje. Bit 0: indica la posición del punto de intersección de los ejes de la muñeca (A4, A5, A6).

Posición

Valor

Área por encima de la cabeza

Bit 0 = 1

El robot se encuentra en el área por encima de la cabeza si el valor X del punto de intersección de los ejes de la muñeca es negativo, referido al sistema de coordenadas A1. Área de base

Bit 0 = 0

El robot se encuentra en el área de base si el valor X del punto de intersección de los ejes de la muñeca es positivo, referido al sistema de coordenadas A1.

Fig. 7-17: Ejemplo: El punto de intersección de los ejes de la muñeca (punto rojo) se encuentra en el área de base. 

162 / 255

Bit 1: indica la posición del eje 3. El ángulo en el que se modifica el valor del bit 1 depende del tipo de robot. Para los robots cuyos ejes 3 y 4 se interseccionan, se aplica lo siguiente: Edición: 24.02.2015 Versión: P2KSS8_robotprogramming_2_(R2)_V4


Posición 0 A3 ≥ A3 < 0°

Valor °

1

=

1 Bit Bit 1 = 0

En los robots con un offset entre el eje 3 y el eje 4, el ángulo en el que se modifica el valor del bit 1, depende de la magnitud de este offset.

Fig. 7-18: Offset entre A3 y A4: Ejemplo KR 30 

Bit 2: indica la posición del eje 5. Posición

A5 > 0 0 A5 ≤  

Valor 0

=

Bit 2 = 1 2 Bit

Bit 3 no se utiliza y siempre es 0. Bit 4: indica si el punto ha sido programado o no con un robot de precisión absoluta. Con independencia del valor del bit, el punto puede se puede alcanzar tanto con robots de precisión absoluta como con robots que no sean precisión absoluta. El bit 4 sirve solo de información y no tiene influencia en el modo de cálculo del punto por parte de la unidad de control del robot. Esto también significa que cuando un robot se programa offline, se puede prescindir del bit 4. Descripción

Valor

El punto no se ha programado con un robot de precisión absoluta. El punto se ha programado con un robot de precisión absoluta.

Bit 4 = 0 Bit 4 = 1

TURN 



La indicación de Turn (giro) también permite poder alcanzar ángulos de eje superiores a +180 ° o inferiores a -180 °, sin una estrategia de desplazamiento especial (por ejemplo, puntos auxiliares). En los ejes rotatorios, los bits individuales determinan el signo que precede al valor del eje del siguiente modo: Bit = 0: ángulo ≥ 0 ° Bit = 1: ángulo < 0 ° Vista general de todos los ejes


163 / 255




Valor

Bit5

0 1

A6 ≥0 ° A5 ≥0 ° A4 ≥0 ° A3 ≥0 ° A2 ≥0 ° A6<0° A5<0° A4<0° A3<0° A2<0° A1<0°

Bit4

Bit3

Bit2

Bit1

Bit0 A1 ≥ 0 °

Ejemplo

DECL POS XP1 = {X 900, Y 0, Z 800, A 0, B 0, C 0, S 6, T 19}

T 19 corresponde a T 'B010011'. Esto significa:

Procedimiento

164 / 255

Eje

Ángulo

Binario

A1 A2 A3 A4 A5 A6

negativo negativo positivo positivo negativo positivo

1 2 4 8 16 32

1. Abrir el programa como experto. 2. Manipular Status y Turn. Guardar temporalmente los nuevos valores calculados en una nueva variable 3. Comprobar los ajustes predefinidos para la programación de movimientos y aceptar o inicializar de nuevo:  Herramienta ($TOOL y $LOAD) Ajustes base ($BASE)   Herramienta externa o guiada por robot ($IPO_MODE)  Velocidad  Aceleración  Posible distancia de aproximación  posible control de la orientación 4. Generar instrucción de movimiento completa como paso individual Tipo de movimiento (SPTP, SLIN, SCIRC)   Punto de destino (con SCIRC también punto auxiliar)  Para CIRC posible ángulo circular (CA) Activar aproximación (C_SPL, C_DIS)  5. En caso de nuevo movimiento de vuelta al punto 3 6. Cerrar el editor y guardar



7.10

Ejercicio: Paletizado y despaletizado


Después de completar correctamente este ejercicio, se dispondrá de la competencia necesaria para efectuar las siguientes tareas:      

Requisitos



Trabajar con campos Cálculo de coordenadas de posición Manejo de estructuras y del separador de puntos Aplicación de bucles FOR encajados Programación de movimientos sin formularios en línea Desplazamiento hasta las coordenadas de destino calculadas

Conocimientos sobre campos, estructuras, bucle FOR Conocimientos teóricos sobre la manipulación de datos Conocimientos teóricos sobre la programación de movimientos sin formulario inline

Se debe crear un programa con el que se recojan 16 cubos del depósito de cubos y se depositen en las posiciones previstas sobre la mesa. A continuación se deberán recoger de nuevo todos los cubos y llevarse de vuelta al depósito de cubos. Todas las posiciones para el desplazamiento deben calcularse tomando como base una posición programada. Los desplazamientos a las posiciones de descarga también se deberán realizar mediante posiciones previas calculadas. Las distancias entre las distintas posiciones de descarga son, en todos los lados, de 80 mm respectivamente. La distancia entre la posición de descarga y la posición previa debe ser de 100 mm. Tarea parcial 1: Plan de ejecución del programa  Crear un PEP para la tarea descrita. Tarea parcial 2: Cálculo de las posiciones de descarga 1. 2. 3. 4.

Crear la posición de inicio mediante un formulario en línea. Crear variables adecuadas para el cálculo de las posiciones de descarga. Inicializar las variables con valores iniciales adecuados. Calcular las 16 posiciones de descarga en la mesa de trabajo.


165 / 255


Fig. 7-19 Tarea parcial 3: Cálculo de las posiciones previas 1. Esta posición se encuentra 100 mm por encima de la posición real de la mesa del cubo. 2. Crear variables adecuadas para el cálculo de las posiciones previas. 3. Inicializar las variables con valores iniciales adecuados. 4. Calcular las 16 posiciones previas a 100 mm por encima de la mesa. Como base para el cálculo se deberán aplicar las posiciones de descarga ya calculadas.

166 / 255



Fig. 7-20 Tarea parcial 4: Paletizado y despaletizado de los cubos 1. Ampliar el programa con las instrucciones de avance necesarias, de forma que todos los cubos se depositen en la mesa y, a continuación, se vuelvan a recoger. 2. Para la recogida y del depósito de los cubos en el depósito se deberán utilizar los módulos ya existentes. 3. Utilizar para ello solo instrucciones KRL. 4. Si es necesario, aplicar los elementos auxiliares programados para la estructuración del programa.

Lo que se debe saber tras el ejercicio: 1. Calcular los valores para A, B, C, X, Y, Z: INT X, Y, Z REAL A, B, C A = 4.5 ;A= …………… B = -2 ;B= …………… C = 4.1 ;C= …………… X= 2.5 ;X= …………… Y=4 ;Y= …………… Z =0.1 ;Z= …………… A=A*B+Y ;A = …………… B=B*Z+X ;B = …………… C = C + 4/3 ;C = …………… X= X + 2.5 * 4 ;X = …………… Y = Y – 10.0/4 ;Y = …………… Z = 14 – Z * C + A ;Z = …………… 2. ¿Qué se indica con la indicación CA en el movimiento circular? ............................................................ ............................................................ Edición: 24.02.2015 Versión: P2KSS8_robotprogramming_2_(R2)_V4

167 / 255


3. ¿Cómo se llama el ajuste para el TCP externo? ............................................................. ............................................................. 4. ¿Cómo se ajusta la aproximación en un movimiento LIN? ............................................................. .............................................................

168 / 255



7.11

Programación de bloques SPLINE 







 









Además de los pasos individuales con SPTP, SLIN, SCIRC y de los movimientos relativos, se dispone de un "bloque SPLINE". El bloque SPLINE se visualiza y se planifica como movimiento único con una "trayectoria compleja". Existen dos clases de bloques SPLINE: Bloque SPLINE CP: Spline con movimientos CP (SPL, SLIN, SCIRC)  Bloque SPLINE PTP: Spline con movimientos exclusivamente en la  zona del eje (solo SPTP) Concepto de bloque: un bloque SPLINE es un conjunto de movimientos con un TOOL, un BASE y un IPO_MODE, pero con velocidades y aceleraciones diferentes en cada segmento. La trayectoria se planifica con todos los puntos, pasando por todos ellos. La trayectoria se calcula previamente en su totalidad. De este modo se conoce todo y la planificación ubicará perfectamente a la trayectoria en la zona de trabajo de los ejes. El Spline no puede desactivar la física. En las trayectorias que tienen contornos muy estrechos, la velocidad siempre se reduce, ya que los ejes de los robots son siempre los elementos que actúan como limitación. Dentro de un bloque spline no se necesita ninguna aproximación, ya que tiene lugar una trayectoria continua por todos los puntos. A pesar de ello, existen casos en los que la velocidad de trayectoria cae a 0 m/s. Podrán configurarse también otras funciones como la "velocidad constante" o el "tiempo fijo definido". Si el robot se desplaza a puntos que se encuentran sobre una superficie de trabajo, al desplazar al primer punto se puede producir una colisión con la superficie de trabajo.

Fig. 7-21: Colisión con superficie de trabajo Para evitar una colisión, tener en cuenta la recomendación para la transición SLIN-SPL-SLIN. (>>> 7.10.5 "Transición SLIN-SPL-SLIN" Página 180)

Fig. 7-22: Evitar colisión con superficie de trabajo Un bloque Spline que no contiene ningún segmento no es una instrucción de movimiento. La cantidad de segmentos en el bloque está limitada exclusivamente por la capacidad de la memoria. Además de los segmentos, un bloque Spline puede incluir los siguientes elementos:


169 / 255




Instrucciones inline de paquetes de tecnología que cuentan con función Spline Comentarios y líneas vacías

Un bloque Spline no debe contener otras instrucciones, por ej. asignaciones de variables o instrucciones lógicas. El punto de inicio de un bloque Spline es el último punto antes del bloque Spline. El punto de destino de un bloque Spline es el último punto del bloque Spline. Un bloque Spline no genera ninguna parada del movimiento de avance.

7.11.1

Perfil de velocidad para movimientos SPLINE

Velocidad SPLINE

La trayectoria siempre es la misma, independientemente del override, de la velocidad o de la aceleración. La unidad de control del robot tiene en cuenta los límites físicos del robot durante la planificación. El robot se mueve tan rápido como le es posible dentro de la velocidad programada, es decir, tanto como le permiten sus límites físicos. Esto resulta ventajoso si se compara con los movimientos LIN y CIRC convencionales, en los que no se tienen en cuenta los límites físicos durante la planificación. Tienen repercusión durante la ejecución del movimiento y, dado el caso, provocan paradas.

Reducción de la velocidad

A continuación se incluyen aquellos casos en los que no se debe alcanzar la velocidad programada:    

Esquinas salientes Grandes cambios de orientación Movimientos importantes de los ejes adicionales Cerca de singularidades

En los segmentos Spline se puede evitar una reducción de la velocidad provocada por grandes cambios de orientación, seleccionando el control de orientación Sin orientación. La programación KRL para ello es como se indica a continuación: $ORI_TYPE = #IGNORE

La reducción de la velocidad debido a un movimiento demasiado amplio del eje adicional se puede evitar en los segmentos Spline mediante $EX_AX_IGNORE.

Reducción de la velocidad a 0

Este caso se presenta en las situaciones siguientes:  

Puntos consecutivos con coordenadas idénticas. Segmentos SLIN y/o SCIRC consecutivos. Causa: Transcurso discontinuo de la dirección de la velocidad. En el caso de transiciones SLIN-SCIRC la velocidad también será 0 cuando la recta pasa tangencialmente por el círculo porque, a diferencia de la recta, el círculo es curvado.

170 / 255



Fig. 7-23: Parada exacta en P2

Fig. 7-24: Parada exacta en P2 Excepciones: 

Si se suceden una serie de segmentos SLIN que crean una recta y que cambian la orientación uniformemente, la velocidad no se reduce.

Fig. 7-25: P2 es pasado sin parada exacta. 

En una transición SCIRC-SCIRC la velocidad no se reduce cuando ambos círculos tienen el mismo punto central y el mismo radio, y cuando las orientaciones cambian uniformemente. (aprendizaje difícil, por eso calcular y programar los puntos). Los círculos con el mismo centro y el mismo radio a veces se programas para obtener círculos de ≥ 360°. Otra posibilidad más sencilla consiste en programar un ángulo circular.

Reducción de la velocidad debida a una programación por aprendizaje no uniforme

A menudo, las modificaciones en la orientación / modificaciones adicionales de la longitud cartesiana del arco distribuidas de una forma irregular provocan caídas de velocidad indeseadas. Ejemplo de una distribución irregular: PTP {x 0, y 0, z 0, A 0, B 0, SPLINE SPL {x 0, y 100, z 0, A 10, B por mm de trayectocart. SPL {x 0, y 110, z 0, A 20, B mm de trayecto cart. SPL {x 0, y 310, z 0, A 31, B por mm de trayecto cart. ENDSPLINE

C 0} ; punto de inicio del Spline 0, C 0} ; 0,1° Cambio de orientación 0, C 0} ; 1° Cambio de orientación por 0, C 0} ; 0,055° Cambio de orientación


171 / 255


La posición cartesiana, la orientación y los ejes externos tienen una relación fija. Si el TCP se "arrastra" por la tangente de la trayectoria cartesiana de un Spline, la orientación y los ejes externos se girarán (mediante el acoplamiento) prácticamente de una forma automática y viceversa (en particular, los límites de los segmentos suelen interpolarse totalmente). Muchos de los descensos indeseados de la velocidad cartesiana son imprescindibles (a causa del acoplamiento) para mantener los valores Tirones de orientación ($JERK.ORI),   Aceleraciones en la orientación ($ACC.ORI1), etc. Velocidades de orientación ($VEL.ORI1)  programados. Una distribución irregular de las trayectorias de orientación en el trayecto cartesiano (longitud del arco) debe acelerar o retardar la orientación muy a menudo, hecho que también tiende a producirse con los grandes tirones de orientación. En consecuencia, una distribución irregular provoca muchos más descensos en la velocidad que una distribución constante (proporcional) de los trayectos de orientación. Además, con tirones bruscos, tanto el robot como la muñeca del robot podrían sufrir oscilaciones. Solución Mantener la mayor uniformidad posible en la orientación y en los ejes externos Ejemplo de una distribución regular: PTP {x 0, y 0, z 0, A 0, B 0, C 0} ; punto de inicio del Spline SPLINE SPL {x 0, y 100, z 0, A 10, B 0, C 0} ; 0,1° Cambio de orientación por mm de trayecto cart. SPL {x 0, y 110, z por mm de trayecto SPL {x 0, y 310, z por mm de trayecto ENDSPLINE

0, A 11, B 0, C 0} ; 0,1° Cambio de orientación cart. 0, A 31, B 0, C 0} ; 0,1° Cambio de orientación cart.

Desconexión del control de orientación por formulario inline o KRL $ORI_TYPE = #IGNORE

Comparación con y sin control de orientación programado

Fig. 7-26: Con orientación programada

172 / 255



Fig. 7-27: Sin orientación programada Pos.

Observación

1

posición programada por aprendizaje con la orientación correspondiente posicióninterpolada posición programada por aprendizaje con la orientación correspondiente, su orientación no se acepta

2 3

A menudo: se programan muchos puntos guardando una distancia relativamente pequeña. Sin embargo, el interés recae principalmente sobre la trayectoria cartesiana (x, y, z). Sin embargo, el Spline también interpola la orientación programada, lo cual puede provocar descensos de la velocidad. Por este motivo, en el formulario Inline "Sin orientación o $ORI_TYPE = #IGNORE.

7.11.2

Selección de paso en caso de movimientos Spline

Bloque Spline

En los segmentos de un bloque Spline se puede realizar una selección de paso. 



Bloque Spline CP: El desplazamiento COI se ejecuta como movimiento LIN convencional. Esto se avisa mediante un mensaje que deberá confirmarse. Bloque Spline PTP: El desplazamiento COI se ejecuta como movimiento PTP convencional. No se notifica con un mensaje.

Tras una selección de paso, generalmente la trayectoria se desplaza al igual que cuando se desplaza el Spline durante la ejecución normal del programa. Pueden darse excepciones, como en caso de que el Spline no se haya desplazado nunca antes de la selección de paso y, siempre y cuando, la selección de paso se haya ejecutado al inicio del bloque Spline: El punto de inicio del movimiento Spline es el último punto antes del bloque Spline, es decir, el punto de inicio está situado fuera del bloque. La unidad de control del robot guarda el punto de inicio durante la ejecución normal de un Spline. De este modo, se reconoce en caso de que se vaya a realizar posteriormente una selección de paso. No obstante, si todavía no se ha desplazado el bloque Spline, esto indica que el punto de inicio no es conocido. Si después del desplazamiento COI se pulsa la tecla de inicio, la trayectoria alterada se anuncia mediante un mensaje que deberá confirmarse.

Ejemplo: Trayectoria modificada en selección de paso en P1


173 / 255


Fig. 7-28: Ejemplo: Trayectoria modificada en selección de paso en P1 1 PTP P0 2 SPLINE 3 SPL P1 4 SPL P2 5 SPL P3 6 SPL P4 7 SCIRC P5, P6 8 SPL P7 9 SLIN P8 10 ENDSPLINE

Línea 2 3…9 10 SCIRC

Descripción Encabezamiento/inicio del bloque Spline CP Segmentos Spline Fin del bloque Spline CP

Al seleccionar pasos en un segmento SCIRC que tenga programado un ángulo circular, el punto de destino se desplaza teniendo en cuenta el ángulo circular, siempre y cuando la unidad de control del robot conozca el punto inicial. En caso de que la unidad de control del robot no conozca el punto de inicio, se desplazará el punto de destino programado. En este caso aparece un mensaje que informa de que no se tiene en cuenta el ángulo circular. Durante la selección de paso en un movimiento individual SCIRC, no se tomará nunca en consideración el ángulo circular.

7.11.3

Cambios en bloques Spline

Descripción

174 / 255



Cambio de la posición del punto: Si se desplaza un punto dentro del bloque spline, el cambio máx. de la trayectoria se efectúa en los dos segmentos antes de este punto y los dos segmentos consecutivos. Normalmente, los desplazamientos de punto menores producen modificaciones de trayectoria menores. No obstante, en el caso de segmentos muy largos y segmentos muy cortos consecutivos, incluso las modificaciones menores podrían tener efectos considerables.


7 Programación de movimientos con KRL 

Ejemplo 1

Cambio del tipo de segmento: En caso de cambiar un segmento SPL en un segmento SLIN y vice versa, la trayectoria cambia en el segmento precedente y en el segmento consecutivo.

Trayectoria original: PTP P0 SPLINE SPL P1 SPL P2 SPL P3 SPL P4 SCIRC P5, P6 SPL P7 SLIN P8 ENDSPLINE

Fig. 7-29: Trayectoria srcinal Respecto a la trayectoria srcinal, se desplaza un punto: P3 se desplaza. Así, se modifica la trayectoria en los segmentos P1 - P2, P2 P3 y P3 - P4. El segmento P4 - P5 no se modifica en este caso porque pertenece a un SCIRC, definéndose así una trayectoria circular.

Fig. 7-30: El punto se desplazó Por lo que repecta a la trayectoria srcinal, se modifica el tipo de un segmento:


175 / 255


En el caso de la trayectoria srcinal el tipo de segmento cambia de P2 - P3 de SPL a SLIN. La trayectoria cambia en los segmentos P1 - P2, P2 - P3 y P3 P4. PTP P0 SPLINE SPL P1 SPL P2 SLIN P3 SPL P4 SCIRC P5, P6 SPL P7 SLIN P8 ENDSPLINE

Fig. 7-31: Tipo de segmento modificado Ejemplo 2

Trayectoria original: ... SPLINE SPL {X 100, SPL {X 102, SPL {X 104, SPL {X 204, ENDSPLINE

Y Y Y Y

0, ...} 0} 0} 0}

Fig. 7-32: Trayectoria srcinal Respecto a la trayectoria srcinal, se desplaza un punto: P3 se desplaza. Por ello la trayectoria cambia en todos los segmentos representados. Dado que P2 - P3 y P3 - P4 son segmentos muy cortos y P1 - P2 y P4 - P5 segmentos largos, el desplazamiento pequeño provoca un cambio importante de la trayectoria. ... SPLINE SPL {X 100, Y 0, ...} SPL {X 102, Y 1} SPL {X 104, Y 0}

176 / 255


7 Programación de movimientos con KRL SPL {X 204, Y 0} ENDSPLINE

Fig. 7-33: El punto se ha desplazado. Solución:  

7.11.4

Distribuir las distancias de puntos de forma más constante Programar las rectas (excepto las rectas muy cortas) como segmentos SLIN

Sustituir un movimiento CP ap roximado por un mo vimiento Sp line

Descripción

Para sustituir los movimientos CP convencionales aproximados por los movimientos Spline, se debe modificar el programa de la siguiente manera:  

Substituir LIN - LIN por SLIN - SPL - SLIN. Substituir LIN - CIRC por SLIN - SPL - SCIRC. Recomendación: Dejar que el SPL se adentre un poco en el círculo srcinal. De este modo el SCIRC se inicia más tarde que el CIRC srcinal.

En caso de movimientos aproximados se programa el punto de esquina. Por el contrario, en el bloque Spline se programan puntos tanto en el inicio de la aproximación como en el final de la aproximación. El movimiento aproximado siguiente debe reproducirse: LIN P1 C_DIS LIN P2

Movimiento Spline: SPLINE SLIN P1A SPL P1B SLIN P2 ENDSPLINE

P1A = inicio de la aproximación, P1B = final de la aproximación


177 / 255


Fig. 7-34: Movimiento con posicionamiento aproximado - Movimiento spline Posibilidades para determinar P1A y P1B: 

 

Desplazar la trayectoria aproximada y guardar las posiciones en los lugares deseados utilizando el Trigger. Calcular los puntos del programa con KRL. El inicio de la aproximación puede determinarse a partir del criterio de aproximación. Ejemplo: en caso de que se indique C_DIS como criterio de aproximación, la distancia desde el inicio de la aproximación hasta el punto de esquina se corresponde con el valor de $APO.CDIS.

El punto terminal de aproximado depende de la velocidad programada. La trayectoria SPL no corresponde exactamente al arco de aproximación, aun cuando P1A y P1B se encuentran exactamente en el inicio de aproximado y el punto terminal de aproximado. Para obtener de forma exacta el arco de aproximación, se deben inserir puntos adicionales en el Spline. Normalmente un punto es suficiente.

Ejemplo

El movimiento aproximado siguiente debe reproducirse: $APO.CDIS=20 $VEL.CP=0.5 LIN {Z 10} C_DIS LIN {Y 60}

Movimiento Spline: SPLINE WITH $VEL.CP=0.5 SLIN {Z 30} SPL {Y 30, Z 10} SLIN {Y 60} ENDSPLINE

El inicio del arco de aproximación fue calculado desde el criterio de aproximado.

178 / 255



Fig. 7-35: Ejemplo: Movimiento con posicionamiento aproximado - Movimiento spline, 1 La trayectoria SPL todavía no corresponde al arco de aproximación. Por ello se introduce un otro segmento SPL en el Spline. SPLINE WITH $VEL.CP=0.5 SLIN {Z 30} SPL {Y 15, Z 15} SPL {Y 30, Z 10} SLIN {Y 60} ENDSPLINE

Fig. 7-36: Ejemplo: Movimiento con posicionamiento aproximado - Movimiento spline, 2 Por el punto adicional la trayectoria corresponde al arco de aproximación.


179 / 255


7.11.5

Transición S LIN-SPL-SLIN En la secuencia de segmentos SLIN-SPL-SLIN se prefiere como norma que el segmento SPL transcurra dentro del ángulo menor entre las dos rectas. En función del punto de inicio y de destino del segmento SPL, la trayectoria puede transcurrir también por fuera.

Fig. 7-37: SLIN-SPL-SLIN La trayectoria transcurre por dentro si se cumplen las condiciones siguientes:  

Los dos segmentos SLIN se cortan. 2/3 ≤ a/b ≤ 3/2 a = Distancia del punto de inicio del segmento SPL al punto de intersección de los segmentos SLIN b = Distancia del punto de intersección de los segmentos SLIN al punto de destino del segmento SPL

7.11.6

PROG programación de bloques SPLINE con KRL

Bloque spline CP KRL

SPLINE … ENDSPLINE define un bloque Spline CP. Un bloque Spline CP puede contener: 

 

  

Segmentos SLIN, SCIRC y SPL (cantidad limitada por la capacidad de la memoria.) PATH-Trigger 1 bloque de tiempo (TIME_BLOCK …) o 1 zona de desplazamiento constante (CONST_VEL …) STOP WHEN PATH Comentarios Líneas vacías

El bloque no debe contener otras instrucciones, p. ej. asignaciones de variables o instrucciones lógicas.

Sintaxis SPLINE < WITH SysVar1 = Valor1 <, SysVar2 = Valor2, … > > Segmento1

… 180 / 255



ENDSPLINE

Elemento SysVar Valor

Descripción Asignación de valor a la variable del sistema. El valor no es válido para los segmentos a los que se haya asignado un valor propio. Exceptuando este caso, el valor es válido como ocurre habitualmente hasta que se asigne un valor nuevo a la variable del sistema. Las variables del sistema también se pueden ocupar por activación de función. Para esta función se aplican las mismas restricciones que para las funciones en el Trigger.

C_SPL





Con C_SPL: Se da una aproximación al punto de destino. $APO determina cuándo se iniciará como muy pronto el posicionamiento aproximado. Sin C_SPL: El punto de destino se alcanza con exactitud.

Hasta el software del sistema 8.2, la identificación para el posicionamiento aproximado en Spline era "C_DIS". Si en versiones superiores a 8 se utilizan programas basados en 8.2 o en versiones anteriores y contienen C_DIS, no será necesario cambiarlo a C_SPL, sino que se puede dejar. SPLINE SPL P1 TRIGGER WHEN PATH=GET_PATH() ONSTART DELAY=0 DO SUBPROG() PRIO=-1 SPL P2 SLIN P3 SPL P4 SCIRC P5, P6 WITH $VEL.CP=0.2 SPL P7 WITH $ACC={CP 2.0, ORI1 200, ORI2 200} SCIRC P8, P9 SPL P10 ENDSPLINE

Bloque spline PTP KRL

PTP_SPLINE … ENDSPLINE define un bloque Spline PTP. Un bloque Spline PTP puede contener:      

Segmentos SPTP (cantidad limitada por la capacidad de la memoria). PATH-Trigger 1 bloque de tiempo (TIME_BLOCK …) STOP WHEN PATH Comentarios Líneas vacías

El bloque no debe contener otras instrucciones, p. ej. asignaciones de variables o instrucciones lógicas. Sintaxis PTP_SPLINE < WITH SysVar1 = Valor1 <, SysVar2 = Valor2, … > > Segmento1

… ENDSPLINE


181 / 255


Elemento SysVar Valor

C_SPL

Descripción Asignación de valor a la variable del sistema. El valor no es válido para los segmentos a los que se haya asignado un valor propio. Exceptuando este caso, el valor es válido como ocurre habitualmente hasta que se asigne un valor nuevo a la variable del sistema. Las variables del sistema también se pueden ocupar por activación de función. Para esta función se aplican las mismas restricciones que para las funciones en el Trigger.  Con C_SPL: Se da una aproximación al punto de destino. $APO determina cuándo se iniciará como muy pronto el posicionamiento aproximado. Sin C_SPL: El punto de destino se alcanza con exacti tud.

PTP_SPLINE WITH $ACC_AXIS[1]={CP 20, ORI1 80, ORI2 80} SPTP P1 TRIGGER WHEN PATH=GET_PATH() ONSTART DELAY=0 DO SUPBROG( ) PRIO=85 SPTP P2 SPTP P3 SPTP P4 WITH $ACC_AXIS[1]={CP 10} ENDSPLINE C_SPL

Programación KRL de SPL, SLIN, SCRIC y SPTP

 

 

 

SPL puede utilizarse solamente en bloques CP SPLINE. SLIN y SCIRC pueden utilizarse como paso individual o en un bloque CP SPLINE. SPTP puede utilizarse como paso indvidual o en un bloque PTP SPLINE. La programación es prácticamente igual, solamente SCIRC puede proveerse adicionalmente de un ángulo circular. Las palabras clave son SPL, SLIN, SCIRC y SPTP. También pueden utilizarse los movimientos relativos conocidos SLIN_REL, SCIRC_REL y SPTP_REL.



Sintaxis 

SPL: SPL Punto de destino < WITH SysVar1 = Valor1 <,SysVar2 = Valor2 , …>>



SLIN: SLIN Punto de destino >



SCIRC: SCIRC Punto auxiliar, Punto de destino <, CA Ángulo circular> >



SPTP:

SPTP Punto de destino >

182 / 255




Descripción Tipo: POS, E6POS, FRAME Las coordenadas hacen referencia al sistema de coordenadas BASE. Si no se indican todos los componentes del punto de destino, la unidad de control adopta los valores de la posición anterior para los componentes que faltan. Si esta posición anterior es el punto de destino de un circuito con ángulo circular, existe la siguiente diferencia: 



Ángulo circular SysVar Valor

Si la posición anterior se encuentra fuera de un bloque Spline, se aceptarán los valores del punto de destino realmente alcanzado y no del punto de destino programado. Si la posición anterior se encuentra en un bloque Spline, se aceptarán los valores del punto de destino programado y no del punto de destino realmente alcanzado.

Si ninguna posición anterior es conocida para la unidad de control del robot, los componentes que falten se aceptarán de la posición actual del robot. Unidad: Grado; sin limitación

Asignación de valor a la variable del sistema Para segmentos: La asignación solo es válida para ese segmento. Las variables del sistema también se pueden ocupar por activación de función. Para esta función se aplican las mismas restricciones que para las funciones en el Trigger.

C_SPL





7.11.7

Con C_SPL: Se da una aproximación al punto de destino. $APO determina cuándo se iniciará como muy pronto el posicionamiento aproximado. Solo es posible para movimientos individuales, no para segmentos. Sin C_SPL: El punto de destino se alcanza con exactitud.

Bloque SPLINE: Variables del sistema con WITH

Segmento Spline

Para los segmentos Spline se pueden describir las siguientes variables de sistema con la línea WITH: $ACC $ACC_AXIS $ACC_EXTAX $CIRC_TYPE $EX_AX_IGNORE $GEAR_JERK $JERK


183 / 255


$ORI_TYPE $ROTSYS $SYNC_ID $VEL $VEL_AXIS $VEL_EXTAX Adicionalmente para SCIRC y SLIN: $CIRC_MODE Las variables del sistema están descritas en el capítulo variables del sistema.

184 / 255


8 Trabajar con variables de sistema

T

8

Trabajar con variables de sistema

8.1

Resumen

j

Esta unidad incluye los siguientes contenidos: 

8.2

Medición del tiempo ciclo mediante temporizador

Medición d el t iempo d e ci clo m ediante t emporizador

Descripción de la medición del tiempo ciclo con el temporizador de sistema de KUKA

Fig. 8-1    

$TIMER[1] $TIMER[2] ... $TIMER[32]

Las variables de sistema $TIMER[Nr] sirven para medir procesos temporales. La introducción del valor/indicación del temporizador $TIMER[Nr] se realiza en milisegundos (ms).

Inicio y parada del temporizador a través de KRL  

INICIO: $TIMER_STOP[Nr] = FALSE PARADA: $TIMER_STOP[Nr] = TRUE El temporizador también se puede preasignar, iniciar y detener manualmente a través de la ventana de indicación.

Principio de medición del tiempo ciclo

Preasignación del temporizador la preasignación del temporizador es de 0 ms en el momento del suminis tro  el temporizador mantiene su valor actual  un temporizador se puede adelantar o restituir hasta alcanzar el valor deseado ; Preasignación de Timer 5 con 0ms $TIMER[5] = 0 ; Ajuste del Timer 12 a 1,5 segundos


185 / 255

Programación de robots 2 $TIMER[12] = 1500 ; Reseteo del Timer 4 a -8 segundos $TIMER[4] = -8000 

Restablecimiento e inicialización de un temporizador

; Timer 7 Reset a 0ms $TIMER[7] = 0 ; Arranque Timer 7 $TIMER_STOP[7] = FALSE 

Parada de un temporizador y comparación posterior

; Timer 7 en marcha ... ; Parada del Timer 7 $TIMER_STOP[7] = TRUE ; en 10 segundos o más acontece ... IF $TIMER[7] >= 10000 THEN ...

El inicio y la parada del temporizador se realiza siempre a través del puntero de ejecución en avance. La instrucción WAIT SEC 0 es adecuada para generar una parada del procesamiento en avance.

Procedimiento en la medición del tiempo ciclo

1. Selección de un temporizador "libre" de los 32 temporizadores posibles 2. Preasignación / reset del temporizador 3. Arrancar el temporizador teniendo en cuenta el puntero de movimiento de avance 4. Detener avance el temporizador teniendo en cuenta el puntero de movimiento de 5. Guardar temporalmente el posible tiempo del ciclo actual o predesignar de nuevo el temporizador DEF MY_TIME( ) ... INI $TIMER[1] = 0 ; Resetear TIMER 1 PTP HOME Vel=100% DEFAULT WAIT SEC 0 ; Activar parada del procesamiento en avance $TIMER_STOP[1]=FALSE ; Arrancar medición tiempo de ciclo SPTP SPTP SLIN ... SPTP SPTP

XP1 XP2 XP3 X50 XHOME

WAIT SEC 0 ; Activar parada del procesamiento en avance $TIMER_STOP[1]=TRUE ; Parar medición tiempo de ciclo ; Memorización intermedia del tiempo de ciclo actual en el Timer 12 $TIMER[12] = $TIMER[1]; el valor se puede leer ahora en la indicación del temporizador END

186 / 255


8 Trabajar con variables de sistema

8.3

Ejercicio: Medición del tiempo ciclo y optimización



Requisitos



Trabajar con un temporizador (inicializar, iniciar, detener). Realizar la optimización del tiempo de ciclo.

Conocimientos sobre variables de sistema $TIMER[x].

Duplicar el programa "Palet" y asignar el nombre "Medición de tiempo". Se deben medir tres tiempos. El temporizador 1 debe medir el tiempo del paletizado, el temporizador 2 el proceso de recogida y el temporizador 3 el tiempo total de ambos procesos. Tener en cuenta que el temporizador no se debe iniciar o detener con el avance. 1. Para la medición del tiempo de paletizado, se debe utilizar $TIMER[1] y guardar adicionalmente el valor final en $TIMER[4]. 2. Nombrar el $TIMER[1] como "Paletizado actual" y el $TIMER[4] como "Paletizado ANTERIOR". 3. Para la medición del tiempo de despaletizado, se debe utilizar $TIMER[2] y guardar adicionalmente el valor final en $TIMER[5]. 4. Nombrar el $TIMER[2] como "Despaletizado actual" y el $TIMER[5] como "Despaletizado ANTERIOR". 5. Para la medición del tiempo total se utiliza $TIMER[3] y se guarda en $TIMER[6]. 6. Nombrar el $TIMER[3] como "Total actual" y el $TIMER[6] como "Total ANTERIOR". 7. Intentar optimizar el programa de forma adecuada. 8. Comprobar el programa en los modos de servicio T1, T2 y Automático. Se deben tener en cuenta las prescripciones de seguridad enseñadas.

Lo que deberá saberse ahora: 1. ¿Cuántos temporizadores tiene el controlador de KUKA y cómo se inician? ............................................................ ............................................................ 2. Nombrar un ejemplo para una variable del fichero $CONFIG.DAT? ............................................................ ............................................................


187 / 255


188 / 255


9 Programación de interrupción

9

Programación de interrupción

9.1


9.2

Programación de rutinas de interrupción Frenar el robot y cancelar el movimiento

Programación d e r utinas d e i nterrupción

Descripción rutinas de de interrupción

Fig. 9-1: Trabajos con rutinas de interrupción 



 

Si se da un suceso determinado, por ejemplo una entrada, la unidad de control interrumpe el programa actual y ejecuta un subprograma predefinido. Un subprograma activado por una interrupción se denomina Programa de interrupción. Pueden declararse como máximo 32 interrupciones al mismo tiempo. Simultáneamente pueden estar activas un máximo de 16 interrupciones.

Pasos importantes cuando se utiliza la interrupción    

Aspectos generales de la declaración de interrupciones Sintaxis



Declaración de interrupción Conectar/desconectar o bloquear/liberar la interrupción Detener el robot dado el caso Rechazar la planificación de trayectoria actual y recorrer una nueva trayectoria dado el caso Si se da un suceso determinado, por ejemplo una entrada, la unidad de control interrumpe el programa actual y ejecuta un subprograma predefinido.

INTERRUPT DECL Prio WHEN Ereignis DO Interruptprogramm 

Global 

Una interrupción recién se reconoce a partir del nivel en el cual fue declarada.


189 / 255


Fig. 9-2: Validez de la interrupción Una interrupción declarada en un subprograma no es conocida en el programa principal (aquí, interrupción 23).  Una interrupción con la palabra clave GLOBAL antepuesta en la declaración es conocida también en los niveles superiores (aquí, interrupción 2). Prio: prioridad Están disponibles las prioridades 1, 2, 4 - 39 y 81 -128.   Las prioridades 3 y 40 - 80 están reservadas para su uso por parte del sistema.  Puede que la interrupción 19 esté preasignada para el test de frenos. Si se producen simultáneamente varias interrupciones, se procesará  en primer lugar la que tenga la prioridad más alta y, a continuación, las de prioridades más bajas. (1 = prioridad más alta) 



190 / 255



Fig. 9-3: Prioridades de las interrupciones 

Evento: Suceso con el que debe darse la interrupción.

Este evento es reconocido por un flanco cuando se produce (disparo por flancos). 

Programa de interrupción   



Ejemplo: Declaración de una interrupción

Nombre del programa de interrupción que debe ejecutarse. Este subprograma se denomina Programa de interrupción. Las variables de duración temporal no se pueden transmitir como parámetros al programa de interrupción. Se permiten variables declaradas en una lista de datos o bien mediante transferencia de variables.

INTERRUPT DECL 23 WHEN $IN[12]==TRUE DO INTERRUPT_PROG(20,VALUE)    

Interrupción local Prioridad: 23 Evento: la entrada 12 se dectecta como flanco positivo (ascendente). Programa de interrupción: INTERRUPT_PROG(20,VALUE) Después de la declaración está desactivada una interrupción. ¡La interrupción se debe activar antes de que se pueda reaccionar al evento definido! Después de la declaración está desactivada una interrupción. La interrupción se debe activar antes de que se pueda reaccionar ante el evento definido.

Descripción

Conexión/desconexión/bloqueo/liberación de la i nterrupción

Opciones con la instrucción

Tras declarar una interrupción, se debe activar inmediatamente.

INTERRUPT ...

  

Activa una interrupción. Desactiva una interrupción. Bloquea una interrupción.


191 / 255


Sintaxis

Desbloquea una interrupción.

INTERRUPT Acción Acción    

ON: Activa una interrupción. OFF: Desactiva una interrupción. DISABLE: Bloquea una interrupción activada. ENABLE: Desbloquea una interrupción bloqueada.

Número  

Activar y desactivar una interrupción

Número (=prioridad) de la interrupción a la que hace referencia la acción.

El se puede omitir. Ennúmero este caso hacen referencia a todas las interrupciones declaON o OFF radas, DISABLE o ENABLE a todas las interrupciones activas.

Ejemplo Conexión y desconexión de una interrupción INTERRUPT DECL 20 WHEN $IN[22]==TRUE DO SAVE_POS( ) ... INTERRUPT ON 20 ;Se detecta la interrupción y se ejecuta (flanco positivo) ... INTERRUPT OFF 20 ; La interrupción está desactivada 

En este caso, la interrupción se desencadena con el cambio de estado, p. ej., para $IN[x]==TRUE, con el cambio de FALSE a TRUE. El estado no debe existir ya cuando se dé INTERRUPT ON; en caso contrario, no se podrá desencadenar la interrupción.



En estese caso, además secomo debe muy tenerpronto en cuenta lo siguiente: El cambio de estado debe producir un ciclo de interpolación después de INTERRUPT ON.  (Esto se puede conseguir programando WAIT SEC 0.012 tras INTERRUPT ON. Si no se desea que se produzca una parada del procesamiento en avance, además se puede programar CONTINUE antes de WAIT SEC.) El motivo es que INTERRUPT ON necesita un ciclo de interpolación  (= 12 ms) para que la interrupción se active realmente. Si se cambia el estado antes, la interrupción no podrá reconocer el cambio.

Rebotes de teclas Si existe el riesgo de que una interrupción se desencadene, por error, dos veces debido a la sensibilidad de un sensor ("rebotes de teclas"), puede evitarse desactivando la interrupción en la primera línea del programa de interrupción. Sin embargo, se ha de tener presente que aquí tampoco se detectará, en ningún momento, una interrupción real durante el procesamiento de la interrupción. Antes de retroceder, si tiene que continuar estando activa la interrupción, se debe volver a conectar.

Bloquear y liberar la interrupción

192 / 255

Ejemplo INTERRUPT DECL 21 WHEN $IN[25]==TRUE DO INTERRUPT_PROG( ) ... INTERRUPT ON 21 ;Se detecta la interrupción y se ejecuta de inmediato (flanco positivo) ... INTERRUPT DISABLE 21


9 Programación de interrupción ;Se detecta la interrupción y se guarda, pero no se ejecuta (flanco positivo) ... INTERRUPT ENABLE 21 ; Ahora se ejecutan las interrupciones guardadas ... INTERRUPT OFF 21 ; La interrupción está desactivada ...

Una interrupción bloqueada es detectada y guardada. La ejecución tiene lugar directamente tras la liberación de la interrupción. En este caso se debe prestar atención a la ausencia de colisiones cuando se realicen movimientos.

Procedimiento

1. Declaración de in terrupción Establecer la prioridad   Determinar el evento desencadenante  Definir y crear una rutina de interrupción DEF MY_PROG( ) INI INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( ) END _________________________________________________ DEF ERROR() END

2. Activar y desactivar una interrupción DEF MY_PROG( ) INI INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( ) INTERRUPT ON 25 ... ... INTERRUPT OFF 25 END _________________________________________________ DEF ERROR() END

3. Ampliar un programa con movimientos y definir acciones en la rutina de interrupción DEF MY_PROG( ) INI INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( ) INTERRUPT ON 25 SPTP XHOME SPTP XP1 SPTP XP2 SPTP XHOME


193 / 255

Programación de robots 2 INTERRUPT OFF 25 END _________________________________________________ DEF ERROR() $OUT[20]=FALSE $OUT[21]=TRUE END

Variables útiles del sistema para parada exacta

Fig. 9-4: Variables de sistema para parada exacta Variables de sistema útiles en caso de aproximación

Fig. 9-5: Variables de sistema en caso de posicionamiento aproximado

194 / 255



9.3

Ejercicio: T rabajos c on i nterrupciones



Requisitos

Declaración de una interrupción Crear un subprograma de interrupción Evaluar y procesar interrupciones durante la ejecución del programa


Conocimientos del lenguaje de programación KRL

Conocimientos teóricos sobre la programación de interrupciones El objetivo de esta tarea es detectar la posición de 3 cubos mediante un desplazamiento de medición definido y guardar dichas posiciones. 


1. Cree un nuevo programa con el nombre "BUSCAR". 2. Tome tres cubos del cargador (sin utilizar el robot) y colóquelos en línea sobre la mesa. 3. Programe un movimiento SLIN como desplazamiento de búsqueda que pase por encima de los tres cubos. La velocidad se debe ajustar a 0,2 m/s. 4. Es necesario activar o desactivar el sensor con la salida 27. Como confirmación de la determinación de posición recibirá una señal en la entrada 27. 5. Al detectar un cubo, el mensaje de observación debe provocar la visualización de la posición X, Y y Z del cubo. La posición se debe guardar al mismo tiempo que se detecta. Para ello, utilice un campo creado en el fichero DAT local o $config.dat. 6. Al final del desplazamiento de búsqueda se deben mostrar las tres posiciones guardadas avanzando hasta ellas, es decir, se debe avanzar a la posición, mensaje de observación "Número de cubo X avanzado" y, a continuación, avanzar a la siguiente posición. 7. Compruebe su programa según prescripción.

Lo que se debe saber tras el ejercicio: 1. ¿En qué parte del programa se declara la interrupción? ............................................................ ............................................................ 2. ¿Cuál es la diferencia entre INTERRUPT OFF 99 e INTERRUPT DISABLE 99? ............................................................ ............................................................ ............................................................ ............................................................ 3. ¿Cuándo se activa el subprograma de interrupción? ............................................................ ............................................................ 4. ¿Qué provoca la instrucción INTERRUPT OFF al comienzo de un subprograma de interrupción? ............................................................ ............................................................


195 / 255


5. ¿Qué rango de prioridad no se ha liberado para la interrupción? ............................................................. .............................................................

196 / 255



9.4

Frenar el robot y cancelar el movimiento

Descripción





Frenar el movimiento del robot y continuar





movimientos "antiguos"

Frenar el robot, a continuación continuar con el movimiento "antiguo". (>>> "Frenar el movimiento del robot y continuar movimientos "antiguos"" Página 197) Frenar el robot, cancelar el movimiento "antiguo" y continuar con el movimiento nuevo. (>>> "Frenar el movimiento del robot y cancelar movimientos "antiguos"" Página 198) El robot se detiene con BRAKE y reanuda la marcha al final de la rutina de interrupción con la trayectoria planeada en el programa principal. El robot se detiene con BRAKE y pasa a la rutina de interrupción. Una vez finalizada la rutina de interrupción, la trayectoria se reanuda desde el programa principal.

Se debe evitar que se produzcan colisiones. Si no se respeta esta medida, pueden ocasionarse daños materiales, lesiones corporales e incluso la muerte.  





Para detenerlo, se cuenta con dos rampas de frenado (STOP 1 y STOP 2) El programa de interrupción sólo se reanuda cuando el robot se ha parado. En cuanto finaliza el programa de interrupción, se reanuda el movimiento iniciado por el robot. Sintaxis:  BRAKE: STOP 2  BRAKE F: STOP 1 BRAKE sólo se puede utilizar en un programa de interrupción.

Procedimiento

1. Declaración de in terrupción Establecer la prioridad   Determinar el evento desencadenante  Definir y crear una rutina de interrupción Activar y desactivar una interrupción  DEF MY_PROG( ) INI INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( ) INTERRUPT ON 25 ... ... INTERRUPT OFF 25 END _________________________________________________ DEF ERROR() END

2. Ampliar un programa con movimientos, frenar el robot en la rutina de interrupción y definir la lógica DEF MY_PROG( ) INI


197 / 255

Programación de robots 2 INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( ) INTERRUPT ON 25 SPTP XHOME SPTP XP1 SPTP XP2 SPTP XHOME INTERRUPT OFF 25 END _________________________________________________ DEF ERROR() BRAKE $OUT[20]=FALSE $OUT[21]=TRUE END

Frenar el movimiento del robot y cancelar movimientos "antiguos"





El robot se detiene con BRAKE y debe realizar una nueva trayectoria una vez finalizada la rutina de interrupción. Para ello se puede utilizar la instrucción RESUME. El robot se detiene con BRAKE y pasa a la rutina de interrupción. Una vez finalizada la rutina de interrupción, no se debe continuar con la primera, sino que se debe realizar una nueva planificación de trayectoria. Para ello se puede utilizar también la instrucción RESUME.

Puesto que no se puede estimar con exactitud cuándo se desencadenará la interrupción, debe ser posible desplazarse sin colisionar dentro de la rutina de interrupción y de la marcha siguiente en todas las posiciones posibles de la marcha actual del robot. Si no se respeta esta medida, pueden ocasionarse daños materiales, lesiones corporales e incluso la muerte.

Funciones de



RESUME 

 









RESUME cancela todos los programas de interrupción y subprogramas en

curso hasta el nivel en el cual se encuentra declarada la interrupción actual. En el momento de la instrucción RESUME, el puntero de movimiento de avance no debe estar en el mismo nivel en el que se ha declarado la interrupción sino, como mínimo, en un nivel inferior. RESUME solo puede estar presente en programas de interrupción. En cuanto se declare una interrupción como GLOBAL, ya no se podrá utilizar RESUME en la rutina de interrupción. Las modificaciones de las variables $BASE en el programa de interrupción solo son vigentes allí. El procesamiento en avance, es decir, la variable $ADVANCE, no se puede modificar en el programa de interrupción. Los movimientos que deben cancelarse por BRAKE y RESUME en principio se deben programar en un subprograma. El comportamiento de la unidad de control del robot tras RESUME depende de la siguiente instrucción de movimiento:  Instrucción SPTP: la marcha se realiza como movimiento SPTP.  Instrucción SLIN: la marcha se realiza como movimiento SLIN.  Instrucción SCIRC: ¡la marcha se realiza siempre como movimiento SLIN!

Si la primera instrucción de movimiento después de RESUME es un movimiento SCIRC, se realizará siempre como SLIN. El movimiento se produce de manera diferente a como se planeó inicialmente. Este comportamiento se debe tener en cuenta cuando se programen instrucciones RESUME. 198 / 255



El robot debe poder avanzar al punto de destino del movimiento SCIRC como SLIN sin peligro desde cualquier posición posible en la que se pueda encontrar durante RESUME.

Procedimiento

1. Declaración de in terrupción  Establecer la prioridad Determinar el evento desencadenante   Definir y crear una rutina de interrupción DEF MY_PROG( ) INI INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( ) ... END _________________________________________________ DEF ERROR() ... END

2. Ampliar un programa con movimientos:  Para poder cancelarlo, el movimiento se debe realizar en un subprograma  El puntero de movimiento de avance debe permanecer en el subprograma Activar y desactivar una interrupción  DEF MY_PROG( ) INI INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( ) SEARCH() END _________________________________________________ DEF SEARCH() INTERRUPT ON 25 SPTP XHOME SPTP XP1 SPTP XP2 SPTP XHOME WAIT SEC 0 ; Detener puntero de movimiento de avance INTERRUPT OFF 25 END _________________________________________________ DEF ERROR() ... END

3. Editar una rutina de interrupción.  Detener robot Reposicionar el robot a $POS_INT   Rechazar el movimiento actual  Nuevo movimiento en el programa principal DEF MY_PROG( ) INI INTERRUPT DECL 25 WHEN $IN[99]==TRUE DO ERROR( ) SEARCH()


199 / 255

Programación de robots 2 END _________________________________________________ DEF SEARCH() INTERRUPT ON 25 SPTP HOME SPTP XP1 SPTP XP2 SPTP XHOME WAIT SEC 0 ; Detener puntero de movimiento de avance INTERRUPT OFF 25 END _________________________________________________ DEF ERROR() BRAKE SPTP $POS_INT RESUME END

200 / 255



9.5

Ejercicio: Cancelar movimientos con interrupciones


Después de completar correctamente este ejercicio, se dispondrá de la competencia necesaria para efectuar las siguientes tareas:     

Requisitos



Declaración de una interrupción Crear un subprograma de interrupción Evaluar y procesar interrupciones durante la ejecución del programa Frenar el movimiento del robot mediante una instrucción KRL Frenar y cancelar el movimiento del robot mediante instrucciones KRL

Conocimientos del lenguaje de programación KRL Conocimientos teóricos sobre la programación de interrupciones Conocimientos teóricos sobre las instrucciones KRL para frenar y cancelar el movimiento del robot y su correcta aplicación

Debe poder detectar la posición de 3 cubos mediante un desplazamiento de medición definido y guardar dichas posiciones. Además, el desplazamiento de medición se debe cancelar directamente después de la detección del tercer cubo. 1. Duplique su programa BUSCAR y asígnele el nombre "BUSCAR_CANCELAR". 2. Tome tres cubos del cargador (sin utilizar el robot) y colóquelos en línea sobre la mesa. 3. Programe un movimiento SLIN como desplazamiento de búsqueda que pase por encima de los tres cubos. La velocidad se debe ajustar a 0,2 m/ s. Es necesario activar o desactivar el sensor con la salida 27. Como confirmación de la determinación de posición recibirá una señal en la entrada 27. 4. Al detectar un cubo, el mensaje de observación debe provocar la visualización de la posición X, Y y Z del cubo. La posición se debe guardar al mismo tiempo que se detecta. Para ello, utilice un campo creado en el fichero DAT local o $config.dat. 5. El robot deberá detenerse inmediatamente tras encontrar el tercer cubo. Tras confirmar el mensaje "Último cubo encontrado; se interrumpe el desplazamiento de búsqueda", deberá finalizarse el desplazamiento de búsqueda. 6. Al final del desplazamiento de búsqueda se deben mostrar las tres posiciones guardadas avanzando hasta ellas, es decir, se debe avanzar a la posición, mensaje de observación "Número de cubo X avanzado" y, a continuación, avanzar a la siguiente posición. 7. Compruebe el programa según prescripción

Lo que se debe saber tras el ejercicio: 1. ¿Cuál es la diferencia entre BRAKE y BRAKE F? ............................................................ ............................................................ 2. ¿Por qué la instrucción RESUME no funciona correctamente en este caso? INTERRUPT DECL 21 WHEN $IN[1] DO located( ) INTERRUPT ON 21 Pto. inic. SLIN Pto. final SLIN $ADVANCE = 0 INTERRUPT OFF 21 ... Edición: 24.02.2015 Versión: P2KSS8_robotprogramming_2_(R2)_V4

201 / 255


END ___________________________________________ DEF located( ) INTERRUPT OFF 21 BRAKE ;pick_part RESUME END 3. ¿Cuando se desencadena una interrupción? ............................................................. .............................................................

202 / 255


10 Funciones de conmutación con KRL

10

Funciones de conmutación con KRL

10.1


10.2

Programación de funciones de conmutación sencillas Programación de funciones de conmutación referidas a la trayectoria con desplazamiento temporal

Programación de funciones de conmutación sencillas

Descripción de funciones de conmutación sencillas

Generalidades 



 

La unidad de control del robot puede administrar, como máximo, 4096 entradas digitales4096 y 4096 salidas digitales. De manera opcional, pueden ampliarse a través de WorkVisual hasta 8192 entradas digitales y 8192 salidas digitales. Las entradas/salidas se realizan a través de sistemas de buses de campo opcionales La configuración es específica del cliente La proyección se realiza a través de WorkVisual

Fig. 10-1 Posibilidades de funciones de conmutación sencillas 

 



Conexión/desconexión sencilla de una salida (con avance/parada del movimiento de avance) Pulsación de una salida Conmutación de una salida con el puntero de ejecución principal (sin parada del movimiento de avance) Ver también:

Fig. 10-2: Fomularios Inline de funciones de conmutación simple Conmutación con parada del procesamiento en avance

Sintaxis 

Conexión de una salida con parada del procesamiento en avance

$OUT[10]=TRUE 

Desconexión de una salida con parada del procesamiento en avance


203 / 255

Programación de robots 2 $OUT[10]=FALSE

Descripción 

Mediante la conmutación de una salida se genera una parada del movimiento de avance, de este modo el movimiento no podrá programarse por aproximación

... SLIN XP20 C_SPL SLIN XP21 $OUT[30]=TRUE SLIN XP22

Fig. 10-3: Conmutación con parada del procesamiento en avance Se generan dos mensajes de error: Aproximación no posible (módulo nombre, paso número) Secuencia de instrucciones sin aptitud de aproximación (módulo nombre, paso número)

Conmutación con el movimiento de avance

Sintaxis Conectar una salida en el movimiento de avance  CONTINUE $OUT[10]=TRUE 

Desconectar una salida en el movimiento de avance

CONTINUE $OUT[10]=FALSE

Descripción 

 

Mediante la utilización de la instrucción CONTINUE, se suprime la parada del movimiento de avance y, de este modo, se conmutará con el avance. La aproximación es posible con CONTINUE. CONTINUE se refiere únicamente a la línea siguiente (incluyendo líneas en blanco).

... SLIN XP20 SLIN XP21 C_SPL CONTINUE $OUT[30]=TRUE SLIN XP22

204 / 255



Fig. 10-4: Conmutación en el avance Conmutación de una salida con el puntero principal

Sintaxis  Conmutación de una salida con el puntero principal y sin parada del movimiento de avance $OUT[10]_C=TRUE

Descripción 





Se pueden conectar hasta 8 salidas referidas a la ejecución principal y sin parada del movimiento de avance En caso de que haya una parada exacta programada, se conectará al alcanzar el punto de destino En caso de que haya una aproximación programada, se conectará en el centro del movimiento de aproximación del punto de destino

... SLIN XP20 $OUT_C[30]=TRUE SLIN XP21 C_SPL SLIN XP22

Fig. 10-5: Conmutación con la ej ecución principal Pulsación de una salida

Sintaxis 

PULSE (Signal, Pegel, Impulsdauer)


205 / 255


Elemento Señal

Descripción Tipo: BOOL Salida en la que se genera el impulso. Son admisibles: OUT[Nr] Variable de señal Tipo: BOOL  

Nivel

Expresión lógica: TRUE hace referencia a un impulso positivo (alto). FALSE hace referencia a un impulso negativo (bajo). Tipo: REAL  

Duración del impulso

p. ej. 1.000.000 de segundos

Descripción  



PULSE activa un impulso.

Así, la salida se pone a un nivel definido durante un tiempo determinado y, a continuación, el sistema la restablece automáticamente. La instrucción PULSE provoca una parada del procesamiento en avance. El impulso no se interrumpe si se da una PARADA DE EMERGENCIA, una parada de operación o una

parada por error. 

Ejemplo:

PULSE ($OUT[30], TRUE, 20); Impulso positivo

PULSE ($OUT[31], FALSE, 20); Impulso negativo 

Si se programa un impulso antes de la instrucción END, el tiempo de ejecución del programa se prolongará correspondientemente

... PULSE($OUT[50],TRUE,2) END

Fig. 10-6: PULSE+END ejemplo 

Si la ejecución del programa se devuelve a su estado inicial (RESET) o se interrumpe (CANCEL) mientras está activo un impulso, el impulso se restablecerá de inmediato

... PULSE($OUT[50],TRUE,2) ; El programa se devuelve ahora a su estado inicial o se deselecciona

Fig. 10-7: PULSE+RESET ejemplo

206 / 255



10.3

Programación del trigger en KRL

Descripción

El Trigger lanza una instrucción definida por el usuario. La unidad de control del robot ejecuta la instrucción de forma paralela al movimiento del robot. El Trigger puede referirse opcionalmente al punto de inicio o de destino del movimiento. La instrucción se puede activar directamente en el punto de referencia o aún se puede desplazar en el espacio y/o temporalmente. El Trigger no se puede utilizar para movimientos PTP. Si el Trigger se utiliza en un bloque Spline, no podrá encontrarse entre el último segmento y ENDSPLINE.  

Posibilidades de la programación  Formulario inline, ventana de opciones lógica Trigger

Fig. 10-8: Trigger 

Formulario inline Spline Trigger

Fig. 10-9: Formulario inline spline Trigger 

Programación trigger con KRL

Programación mediante instrucción KRL TRIGGER WHEN PATH

Utilización de la instrucción KRL existente para TRIGGER WHEN PATH: TRIGGER WHEN PATH = Trayecto DELAY = Tiempo DO Instrucción


207 / 255


Elemento ONSTART

Descripción Punto de referencia del Trigger  

Trayecto

Con ONSTART: Punto de inicio Sin ONSTART: Punto de destino

Tipo: REAL; variable, constante o función; unidad: mm (excepción: en Splines PTP sin unidad) Desplazamiento en el espacio con respecto al punto de referencia. Si no se desea ningún desplazamiento en el espacio, fijar el Trayecto = 0. 



Tiempo

Valor negativo: desplazamiento en dirección al principio del movimiento Valor positivo: desplazamiento en dirección al final del movimiento

(>>> "Máx. desplazamiento" Página 208) Tipo: REAL; variable, constante o función; unidad: ms Desplazamiento en el tiempo con respecto al Trayecto. Si no se desea un desplazamiento temporal, ajustar Tiempo = 0. 



Valor negativo: desplazamiento en dirección al principio del movimiento Valor positivo: activación del Trigger transcurrido el tiempo

Instrucción

(>>> "Máx. desplazamiento" Página 208) Posibilidades: Asignación de valor a una variable Indicación: en el lado izquierdo de la asignación no debe haber ninguna variable de tiempo de ejecución. Instrucción OUT; instrucción PULSE; instrucción  CYCFLAG  Activación de un subprograma. En este caso debe indicarse la Prioridad. Tipo: INT; variable o constante 

Prioridad

Prioridad del Trigger. Solo relevante cuando la Instrucción activa un subprograma, pero luego obligatorio. Están disponibles las prioridades 1, 2, 4 - 39 y 81 - 128. Las prioridades 40 - 80 están reservadas para casos en los que el sistema adjudica automáticamente la prioridad. Si la prioridad debe adjudicarla de forma automática el sistema, se programa: PRIO = -1. Si varios Trigger llaman a la vez a subprogramas, se procesará primero el Trigger con la prioridad más alta y luego el de menor prioridad. 1 = prioridad más alta.

Máx. desplazamiento

El punto de conexión solo se puede desplazar hasta límites determinados. Si se programan desplazamientos mayores y, de este modo, no válidos, la unidad de control del robot conecta el Trigger como muy tarde en el límite permitido. Para ello, emite un mensaje en T1/T2.

Desplazamiento máximo para trayecto + valor de tiempo negativo: Los límites son válidos para el desplazamiento total que se obtiene del desplazamiento en el espacio y temporal negativo. 208 / 255



Desplazamiento negativo máximo hasta ...

Desplazamiento positivo máximo hasta ...

Hasta el punto de inicio (si éste no se ha programado por aproximación) Si el punto de inicio se ha programado por aproximación:

Hasta el punto de destino (si éste no se ha programado por aproximación) Si el punto de destino se ha programado por aproximación:





Si el punto de inicio es un punto PTP programado por aproximación: Hasta el final del arco de aproximación Si el punto de inicio es otro punto programado por aproximación: Hasta el principio del arco de aproximación







Para el posicionamiento aproximado homogéneo: Hasta la siguiente parada exacta después de la instrucción TRIGGER Para el posicionamiento aproximado mixto (Spline): Hasta el punto de conexión que tendría un Trigger ONSTART con PATH = 0 si se encontrara en el movimiento hacia el que se programa por aproximación. Para el posicionamiento aproximado mixto (LIN/CIRC/PTP): Hasta el principio del arco de aproximación

Desplazamiento máximo para valor de tiempo positivo: El desplazamiento temporal positivo puede ser como máximo de 1000 ms. Cada desplazamiento temporal entre 0 y 1000 ms se conecta incluso si el programa se ha desactivado entretanto.

Ejemplo Trigger con KRL

1 SPTP P0 2 SPLINE 3 SPL P1 4 SPL P2 5 SPL P3 6 SPL P4 7 TRIGGER WHEN PATH=0 ONSTART DELAY=10 DO $OUT[5]=TRUE 8 SCIRC P5, P6 9 SPL P7 10 TRIGGER WHEN PATH=-20.0 DELAY=0 DO SUBPR_2() PRIO=-1 11 SLIN P8 12 ENDSPLINE

El Trigger en la línea 10 ofrecería el mismo resultado si estuviera directamente delante del bloque Spline (es decir, entre la línea 1 y la línea 2). En ambos casos se refiere al último punto del movimiento Spline, a P8. No obstante, se recomienda situar el Trigger como en el ejemplo y no directamente antes del bloque Spline.


209 / 255


Fig. 10-10: Ejemplo TRIGGER WHEN PATH (para Spline) Restricciones para funciones en el Trigger

Los valores para DELAY y PATH se pueden asignar mediante funciones. Las funciones tienen las restricciones siguientes:   

10.4

El programa KRL que contiene la función debe tener la propiedad Oculto. La función debe ser válida globalmente. Las funciones solo deben contener las siguientes instrucciones o elementos: Asignaciones de valores   Instrucciones IF  Comentarios Líneas vacías   RETURN  Leer la variable del sistema  Activar la función KRL predefinida

Programar una parada condicionada con KRL

Descripción

La "Parada condicionada" permite al usuario definir un lugar en la trayectoria donde se para el robot si se cumple una condición determinada. El lugar se denomina "punto de parada". En cuanto deja de cumplirse la condición, el robot reanuda la marcha. Durante el tiempo de ejecución, la unidad de control del robot calcula el punto donde, posteriormente, se debe frenar para que se pueda parar en el punto de parada. A partir de ese punto (= "punto de frenado"), la unidad de control del robot evalúa si se ha cumplido o no con la condición de frenado. 



210 / 255

En cuanto se cumple la condición en el punto de frenado, el robot frena para parase en el punto de parada. En caso de que deje de cumplirse la condición antes de que se alcance el punto de parada, el robot vuelve a acelerar y no se para. Cuando no se cumple la condición en el punto de frenado, el robot continúa la marcha sin frenar.



Fig. 10-11: spline con parada condicionada Pos.

Explicación

1

punto de frenado calculado en función de la carrera y la velocidad punto de parada predefinido (mediante formulario inline o KRL) posible anulación de la expresión booleana -> aceleración de la velocidad programada

2 3

Básicamente se pueden programar tantas paradas condicionadas como se desee. No obstante, no deben solaparse más de 10 trayectos "Punto de frenado → punto de parada". Durante un procesoen deT1/T2: frenado, la unidad de controlactiva del robot muestra losde siguientes mensajes Parada condicionada (línea {Número línea}). Posibilidades de la programación 

En el bloque Spline (CP o PTP) o en el paso individual Spline: formulario inline, ventana de opciones lógica de la parada condicionada

Fig. 10-12: Parada condicionada 

Antes de un bloque Spline (CP y PTP): formulario inline Spline parada condicionada


211 / 255


Fig. 10-13: Formulario inline Condición de parada para Spline 

Parada condicionada con KRL

Programación mediante instrucción KRL STOP WHEN PATH

STOP WHEN PATH = Offset IFCondición

Elemento ONSTART

Descripción Punto de referencia de la instrucción  

Sin ONSTART: Punto de destino Con ONSTART: Punto de inicio

En caso de que se aproxime el punto de referencia, tendrán validez las mismas normas aplicadas para PATH-Trigger. Offset

Tipo: INT o REAL; constante, variable o función; unidad: mm Con Offset e puede desplazar en el espacio el punto de parada. 



Valor positivo: desplazamiento en dirección al final del movimiento Valor negativo: desplazamiento en dirección al principio del movimiento

El punto al hace referencia el desplazamiento depende deque si ONSTART está ajustado o no. Si no se desea ningún desplazamiento, debe programarse Offset=0.

Condición

El punto de parada no puede desplazarse libremente en el espacio. Tienen validez los mismos límites aplicados para PATH-Trigger. (>>> "Máx. desplazamiento" Página 208) Tipo: BOOL Condición de parada. Son admisibles:    

una variable global booleana un nombre de señal una comparación un combinación lógica simple: NOT, OR, AND o EXOR

La parada condicionada se puede utilizar en las siguientes posiciones:  



En el conjunto individual Spline En el bloque Spline (CP y PTP) Entre STOP WHEN PATH y ENDSPLINE debe haber al menos 1 segmento. Antes de un bloque Spline (CP y PTP) STOP WHEN PATH hace referencia en este caso a un bloque Spline. Entre STOP WHEN PATH y el bloque Spline pueden establecerse instrucciones, aunque no instrucciones de movimiento.

Ejemplo 1 SPTP P1

212 / 255


10 Funciones de conmutación con KRL 2 SLIN 3 STOP P3, en 4 SLIN 5 SLIN

10.5

P2 WHEN PATH = -30 IF $IN[20]==TRUE ; se detiene 30 mm antes de caso de que la entrada 20 sea TRUE P3 P4

Programar zona de desplazamiento constante con KRL

Descripción

En un bloque Spline CP, se puede definir una zona en la que el robot mantiene constante la velocidad programada, siempre y cuando sea posible. El margen se denomina "Zona de desplazamiento constante". 



 

Para cada bloque Spline CP se puede definir 1 zona de desplazamiento constante. La zona de desplazamiento constante se define mediante una instrucción de inicio y una instrucción de final. La zona no puede superar el bloque Spline. La zona puede ser tan pequeña como se desee.

Fig. 10-14: Zona de desplazamiento constante spline En caso de que no sea posible mantener constante la velocidad programada, la unidad de control del robot lo notifica durante la ejecución del programa mediante un mensaje.

Zona de desplazamiento constante a través de varios segmentos: La zona de desplazamiento constante se puede extender por varios segmentos con diferentes velocidades programadas. En este caso, las velocidades más reducidas serán válidas para toda la zona. Incluso en los segmentos con una velocidad programada más elevada, en este caso se procederá con el desplazamiento aplicando la velocidad más reducida. Aquí no se emite ningún mensaje notificando que no se ha alcanzado la velocidad. Esto sucede únicamente si no se puede mantener la velocidad más reducida. Posibilidades de la programación 

Formulario inline, ventana de opciones lógica de la zona de desplazamiento constante: se almacena el inicio o el final de la zona en el segmento CP correspondiente


213 / 255


Fig. 10-15: Zona de desplazamiento constante Programación mediante las instrucciones KRL CONST_VEL START y CONST_VEL END



Zona de desplazamiento constante con KRL

CONST_VEL START = Offset

... CONST_VEL END = Offset

Elemento ONSTART

Descripción Punto de referencia de la instrucción  

Con ONSTART: Punto de inicio Sin ONSTART: Punto de destino

Si se ha realizado el posicionamiento aproximado al punto de inicio o de destino, el punto de referencia se genera de la misma manera que durante el posicionamiento aproximado homogéneo del PATH-Trigger. Offset

Tipo: INT o REAL; constante, variable o función; unidad: mm Mediante CONST_VEL START = Offset se puede desplazar en el espacio el inicio de la zona. Mediante CONST_VEL END = Offset se puede desplazar en el espacio el final de la zona. 



Valor positivo: desplazamiento en dirección al final del movimiento Valor negativo: desplazamiento en dirección al principio del movimiento

El punto al que hace referencia el desplazamiento depende de si ONSTART está ajustado o no. Si no se desea ningún desplazamiento, debe programarse Offset=0. Con CONST_VEL se definen las zonas de desplazamiento constante. CONST_VEL solo se puede utilizar en bloques Spline CP. Entre CONST_VEL END y ENDSPLINE debe haber al menos 1 segmento Spline. Un bloque Spline CP puede contener 1 CONST_VEL o 1 TIME_BLOCK (bloque temporal), pero no los dos. 214 / 255



Ejemplo Aquí la zona de desplazamiento constante se extiende a varios segmentos con diferentes velocidades programadas. La velocidad más baja, es decir, 0,2 m/s, se aplica en este caso para la zona completa. 1 2 3 4 5 6 7 8

PTP P0 SPLINE WITH $VEL.CP = 2.5 SLIN P1 CONST_VEL START = +100 SPL P2 WITH $VEL.CP = 0.5 SLIN P3 WITH $VEL.CP = 0.2 SPL P4 WITH $VEL.CP = 0.4 CONST_VEL END = -50

9 SCIRC P5, P6 10 SLIN P7 11 ENDSPLINE

10.6

Programar bloque de tiempo Spline

Descripción

TIME_BLOCK se puede utilizar bloques Spline CP y PTP. TIME_BLOCK permite ejecutar el bloque Spline o una parte del mismo en un tiempo definido. Adicionalmente es posible asignar un componente de tiempo a secciones dentro del TIME_BLOCK. En el bloque Spline se pueden modificar, añadir o eliminar puntos sin modificar las especificaciones de tiempo. Esto permite al usuario corregir la trayectoria cartesiana y al conservar para ello las especificaciones de tiempo existentes. Un bloque Spline puede contener 1 bloque de tiempo, es decir, 1 instrucción TIME_BLOCK START … TIME_BLOCK END. En medio se puede utilizar la cantidad deseada de TIME_BLOCK PART. El bloque de tiempo solo se puede utilizar en bloques Spline. Un bloque Spline CP puede contener 1 bloque de tiempo o 1 zona de desplazamiento constante, pero no los dos.

Bloque de tiempo con KRL

TIME_BLOCK START TIME_BLOCK PART = Parte_N > TIME_BLOCK END = Tiempo total


215 / 255


Elemento Parte

Descripción Tipo: INT o REAL; constante, variable o función Parte deseada del Tiempo total para el siguiente trayecto: 



Desde el punto antes de TIME_BLOCK PART=parte_anterior hasta el punto antes de TIME_BLOCK PART=parte Si parte_anterior no existe: Desde el punto antes de TIME_BLOCK START hasta el punto antes de TIME_BLOCK PART=parte

"Parte desead" significa: Las partes se mantienen de la forma más exacta posible por la unidad de control del robot. Aunque por regla general no se mantienen de forma exacta. El usuario puede asignar las parte de forma que conjuntamente de como resultado 100. De este modo podrá considerar las partes como porcentaje del Tiempo total. Aunque las partes no deben dar como resultado 100, sino que pueden dar como resultado una suma cualquiera. La unidad de control del robot siempre iguala la suma de las partes con Tiempo total. De este modo, las partes se pueden utilizar de una forma muy flexible y también se pueden modificar. Si se asignan partes, siempre deberá haber un TIME_BLOCK PART directamente delante de TIME_BLOCK END. Entremedias no deberá haber segmentos. Tiempo total

Tipo: INT o REAL; constante, variable o función; unidad: s Tiempo durante el que se recorre el siguiente trayecto: 

Desde el punto antes de TIME_BLOCK START hasta el punto antes de TIME_BLOCK END

El valor debe ser superior a 0. El tiempo total se mantiene de forma exacta. Si no se puede mantener, p. ej. porque se ha programado un tiempo demasiado corto, el robot se desplaza con el tiempo más rápido posible. En T1 y T2 se muestra además un mensaje. Si el valor para Parte o Tiempo total se asigna a través de una función, se aplicarán las mismas restricciones que para las funciones en el Trigger.

Explicación acerca de la programación Antes de TIME_BLOCK START y después de TIME_BLOCK END no es obligatorio que haya segmentos Spline. No obstante, se recomienda programar del siguiente modo:  

Entre SPLINE y TIME_BLOCK START hay al menos 1 segmento Spline. Entre TIME_BLOCK END y ENDSPLINE hay al menos 1 segmento Spline.

Ventajas: 



216 / 255

El tiempo total programado también se conserva de forma exacta en el posicionamiento aproximado. Los segmentos antes de TIME_BLOCK START permiten acelerar hasta la velocidad necesaria. Edición: 24.02.2015 Versión: P2KSS8_robotprogramming_2_(R2)_V4


Ejemplo SPLINE SLIN P1 SPL P2 TIME_BLOCK SLIN P3 TIME_BLOCK SPL P4 SPL P5 SPL P6 TIME_BLOCK SCIRC P7,

START PART = 12.7

PART = 56.4 P8

SPL P9 TIME_BLOCK PART = 27.8 TIME_BLOCK END = 3.9 SLIN P10 ENDSPLINE

Los puntos P2 a P9 se ejecutan de forma exacta en el tiempo programado de 3,9 s. La unidad de control del robot iguala el tiempo total de 3,9 s a la suma de todas las partes, es decir, 96,9 partes.

Trayecto P2 … P3 P3 … P6 P6 … P9

Selección de paso

Tiempo que la u nidad de control del robot asigna al trayecto 12,7 partes de 3,9 s = 0,51 s 56,4 partes de 3,9 s = 2,27 s 27,8 partes de 3,9 s = 1,12 s

En función de la línea en la que se realiza la selección de paso, la unidad de control del robot planifica el bloque de tiempo o no.

Selección de paso en la línea... en el bloque Spline, antes de TIME_BLOCK START TIME_BLOCKSTART en el bloque de tiempo TIME_BLOCK END en el bloque Spline, después de TIME_BLOCK END

¿El bloque de tiempo se ha planificado? Sí No El bloque Spline se ejecutará si no existieran instrucciones TIME_BLOCK.

Si la unidad de control del robot no planifica el bloque de tiempo, emite el siguiente mensaje: Bloque de tiempo ignorado por el desplazamiento SAK.


217 / 255


218 / 255


11 Interpretador Submit

11

Interpretador Submit

t

11.1

Resumen

t

Esta unidad incluye los siguientes contenidos: Utilización del interpretador Submit



11.2

Utilización de l in terpretador Su bmit

Descripción del interpretador Submit

En el KSS 8.x se ejecutan dos tareas: Interpretador de robots (secuencia de los programas de movimiento de los robots y su lógica) Interpretador de la unidad de control (secuencia de un programa de la unidad de control ejecutado en paralelo) Estructura del programa SPS.SUB:





1 2 3 4 5 6 7 8 9 10

DEF SPS ( ) DECLARATIONS INI LOOP WAIT FOR NOT($POWER_FAIL) TORQUE_MONITOR ING() USER PLC ENDLOOP

El estado del interpretador Submit

El interpretador Submit está en funcionamiento

El interpretador Submit está detenido

El interpretador Submit no está seleccionado

El interpretador de la unidad de control:    

Se puede iniciar automática o manualmente. También se puede detener o cancelar manualmente. Puede incluir tareas de manejo y control en el entorno del robot. Se crea de manera estándar con el nombre SPS.sub en el directorio R1/ SYSTEM.

 

 



Se programar con conjunto de instrucciones KRL. con los moviNo puede se pueden ejecutar laselinstrucciones KRL relacionadas mientos del robot. Se permiten movimientos asincrónicos. Se puede acceder a las variables del sistema a través de la lectura y de la escritura. Se puede acceder a las entradas/salidas a través de la lectura y de la escritura.


219 / 255


Relaciones en la programación del interpretador Submit

¡Atención! ¡El interpretador Submit no puede utilizarse para aplicaciones críticas con respecto al tiempo! En estos casos deberá utilizarse un PLC. Causas: El interpretador Submit comparte la capacidad del sistema con el inter pretador de robots y la gestión de E/S con la mayor prioridad. Por esta razón, el interpretador Submit no se ejecuta regularmente en el ciclo de interpolación de 12 ms de la unidad de control del robot.  Además, el tiempo de ejecución del interpretador Submit es irregular. El tiempo de ejecución del interpretador Submit dependerá del número de líneas en el programa SUB. Las líneas de comentarios y las líneas vacías también influyen. 

Inicio automático del interpretador Submit  El interpretador Submit se activa de forma automática al conectar la unidad de control del robot tras un arranque en frío.  Se inicia el programa definido en el archivo KRC/STEU/MADA/$custom.dat.

$PRO_I_O[]="/R1/SPS()" 

Servicio automático del interpretador Submit  Seleccionar la secuencia de menú Configuración > Interpretador SUBMIT > Arrancar/Seleccionar para el servicio. Servicio directo a través de la barra de estado del indicador de estado  Interpretador Submit. En caso de selección, se abre una ventana con las opciones ejecutables. Si se modifica un archivo del sistema, por ejemplo $config.dat o $custom.dat, y éste resulta dañado a raíz de esta modificación, el inter-

Submit se desactiva automáticamente. Si se subsana el error enpretador el archivo del sistema se deberá seleccionar de nuevo manualmente el interpretador Submit. Particularidades de la programación del interpretador Submit 



No se pueden ejecutar instrucciones para movimientos del robot, por ejemplo:  PTP, LIN, CIRC, etc. Activaciones de subprogramas que contienen movimientos de robot   Instrucciones que hacen referencia a movimientos del robot, TRIGGER o BRAKE Se pueden controlar ejes asincrónicos, como E1.

IF (($IN[12] == TRUE) AND ( NOT $IN[13] == TRUE)) THEN ASYPTP {E1 45} ENDIF ... IF ((NOT $IN[12] == TRUE) AND ($IN[13] == TRUE)) THEN ASYPTP {E1 0} ENDIF 





220 / 255

Las instrucciones entre las líneas LOOP y ENDLOOP se ejecutan constantemente en "segundo plano". Se debe evitar cualquier parada provocada por instrucciones o bucles de espera que puedan retrasar más la ejecución del interpretador Submit. Es posible activar salidas.


11 Interpretador Submit

Advertencia No se comprobará si los interpretadores Submit y de robots acceden simultáneamente a la misma salida, ya que esto puede ser lo que se desee que ocurra en determinados casos. Por esta razón, el usuario deberá verificar con atención la asignación de las salidas. De lo contrario pueden producirse señales de salida inesperadas, como por ejemplo en los dispositivos de seguridad. Como consecuencia podrían ocasionarse importantes daños materiales, lesiones graves e incluso la muerte. En los modos de servicio del test, $OV_PRO no se puede describir desde el interpretador Submit, porque modificación puede tener resultados inesperados paramateriales, los usuariosleque la trabajan en el robot industrial. Pueden producirse daños siones graves e incluso la muerte.

Advertencia En la medida de lo posible, no utilizar el interpretador Submit para modificar las señales y variables críticas con respecto al tiempo. Procedimiento para programar el interpretador Submit

1. La programación se realiza en estado detenido o cancelado. 2. El programa estándar SPS.sub se carga en el ed itor. 3. Realizar las declaraciones e inicializaciones necesarias. Para ello se deberían utilizar las FOLDS preparadas. 4. Realizar ampliaciones del programa en la FO LD USER PLC. 5. Cerrar y guardar el interpretador Submit. 6. Si el Submit no se inicia automáticamente, iniciarlo manualmente. Ejemplo de programa basado en una programación de los intermitentes en el interpretador Submit DEF SPS( ) DECLARATIONS DECL BOOL flash ;Declaración en $CONFIG.dat INI flash = FALSE $TIMER[32]=0 ; Reiniciar TIMER[32] $TIMER_STOP[32]=false ; Iniciar TIMER[32] ... LOOP ... USER PLC IF ($TIMER[32]>500) AND (flash==FALSE) THEN flash=TRUE ENDIF IF $TIMER[32]>1000 THEN flash=FALSE $TIMER[32]=0 ENDIF ; Asignación a lámpara (salida 99) $OUT[99] = flash ... ENDLOOP


221 / 255


222 / 255


12 Trabajos con señales analógicas

12

Trabajos con señales analógicas

T

12.1 j


12.2

Programar entradas analógicas Programar salidas analógicas

Programar entradas analógicas

Descripción

Fig. 12-1: Señales analógicas 





 

Función

El KRC4 cuenta con más de 32 entradas analógicas. Para las señales analógicas se necesita un sistema de bus opcional y la proyección se debe realizar con WorkVisual. Las entradas analógicas se leen mediante las variables de sistema $ANIN[1] ... $ANIN[32]. Lectura cíclica (cada 12 ms) de una entrada analógica. Los valores $ANIN[nr] oscilan entre 1,0 y -1,0 (100 % y -100 %) y representan una tensión de entrada de entre +10 V y -10 V.

Asignación estática de valor 

Asignación directa de valores

... REAL value value = $ANIN[2] ... 

Asignación de valores de una declaración de señal

... SIGNAL sensor $ANIN[6] REAL value value = sensor ...

Asignación dinámica de valor 



Todas las variables empleadas en una instrucción ANIN deben estar declaradas en listas de datos (localmente o en el archivo $CONFIG.DAT). Como máximo están permitidas tres instrucciones ANIN ON a la vez.


223 / 255




Cómo máximo dos instrucciones ANIN ON pueden utilizar la misma variable Valor o acceder a la misma entrada analógica. Sintaxis  Iniciar lectura cíclica: ANIN ON Valor = Factor * Nombre de señal <±Offset>

Elemento

Descripción

Valor

Tipo: REAL

Factor

En Valor se registra el resultado de la lectura cíclica. Este Valor puede ser una variable o un nombre de señal para una salida. Tipo: REAL

Nombre de la señal

Un factor cualquiera. Puede ser una constante, una variable o un nombre de señal. Tipo: REAL Indica la entrada analógica. El nombre de señal se debe haber declarado antes con SIGNAL . No está permitido indicar directamente la entrada analógica $ANIN[x] en lugar del nombre de señal. Los valores de una entrada analógica $ANIN[x] oscilan entre +1,0 y -1,0 y representan una tensión de +10 V a -10 V dar. Tipo: REAL

Offset

Puede ser una constante, una variable o un nombre de señal. 



Finalizar lectura cíclica:

ANIN OFF nombre de señal Ejemplo 1:

DEFDAT myprog DECL REAL value = 0 ENDDAT DEF myprog( ) SIGNAL sensor $ANIN[3] ... ANIN ON value = 1.99*sensor-0.75 ... ANIN OFF sensor 

Ejemplo 2:

DEFDAT myprog DECL REAL value = 0 DECL REAL corr = 0.25 DECL REAL offset = 0.45 ENDDAT DEF myprog( ) SIGNAL sensor $ANIN[7] ... ANIN ON value = corr*sensor-offset ... ANIN OFF sensor

224 / 255



Procedimiento para programar con entradas analógicas

El requisito para utilizar las señales analógicas es proyectar correctamente el sistema de bus con las señales analógicas conectadas. Programación de ANIN ON/OFF 1. 2. 3. 4. 5. 6.

12.3

Selección de la entrada analógica correcta. Ejecución de la declaración de señal. Declaración de las variables necesarias en una lista de datos. Conectar: programación de la instrucción ANIN ON. Comprobación de que haya 3 entradas dinámicas activas como máximo. Desconectar: programación de la instrucción ANIN OFF.

Programar salidas a nalógicas

Descripción

Fig. 12-2: Señales analógicas  



 

Función

El KRC4 cuenta con más de 32 salidas analógicas. Para las señales analógicas se necesita un sistema de bus opcional y la proyección se debe realizar con WorkVisual. Las salidas analógicas se leen mediante las variables de sistema $ANOUT[1] ... $ANOUT[32]. Escritura cíclica (cada 12 ms) en una salida analógica. Los valores $ANOUT[nr] oscilan entre 1,0 y -1,0 (100 % y -100 %) y representan una tensión de salida de entre +10 V y -10 V.

Se pueden utilizar, como máximo, 8 salidas analógicas al mismo tiempo (estáticas y dinámicas juntas). ANOUT genera una parada del movimiento de avance.

Asignación estática de valor 

Asignación directa de valores

... ANOUT[2] = 0.7 ; 14 mA (70 %) en la salida analógica 2 (en el módulo 0-20 mA) ... 

Asignación de valores mediante variables

... REAL value value = -0.8


225 / 255

Programación de robots 2 ANOUT[4] = value ; -8 V (80 %) en la salida analógica 4 (en el módulo -10 V - 10 V) ... 

Programación mediante formulario inline

Fig. 12-3: Formulario inline ANOUT estática Pos. 1 2

Descripción Número de la salida analógica  CHANNEL_1 … CHANNEL_32 Factor para la tensión 

0 … 1 (graduación: 0.01)

Asignación dinámica de valor 



 

Todas las variables utilizadas en una instrucción ANOUT deben estar declaradas en listas de datos (localmente o en $CONFIG.DAT). Se permite un máximo de cuatro instrucciones ANOUT ON al mismo tiempo. ANOUT genera una parada del movimiento de avance. Sintaxis Iniciar escritura cíclica:  ANOUT ON Nombre de señal = Factor * Elemento de regulación <±Offset>

Elemento Nombre de la señal

Factor

Elemento de regulación Offset

Descripción Tipo: REAL Indica la salida analógica. El Nombre de señal debe haberse declarado con antelación con SIGNAL. No está permitido indicar directamente la salida analógica $ANOUT[x] en lugar del nombre de señal. Los valores de una salida analógica $ANOUT[x] oscilan entre +1,0 y -1,0 y representan una tensión de +10 V a -10 V dar. Tipo: REAL Un factor cualquiera. Puede ser una constante, una variable o un nombre de señal. Tipo: REAL Puede señal. ser una constante, una variable o un nombre de Tipo: REAL Puede ser una constante, una variable o un nombre de señal.

226 / 255



Elemento Tiempo

Valor mínimo, valor máximo

Descripción Tipo: REAL Unidad: Segundos. Con la palabra clave DELAY y una indicación de tiempo positiva o negativa, se puede emitir una señal de salida con retardo (+) o adelanto (-). Tipo: REAL Tensión mínima y/o máxima que debe existir en la salida. No se sobrepasa ni por encima ni por debajo, ni siquiera si los valores calculados están por encima o por debajo. Valores permitidos: -1,0 a +1,0 (corresponde de -10 V a +10 V). Puede ser una constante, una variable, un componente estructural o un elemento de campo. El valor mínimo debe ser en cualquier caso menor al valor máximo. Debe respetarse la secuencia de las palabras clave MINIMUM y MAXIMUM.

Finalizar escritura cíclica: ANOUT OFF Nombre de señal Ejemplo 1 



DEF myprog( ) SIGNAL motor $ANOUT[3] ... ANOUT ON motor = 3.5*$VEL_ACT-0.75 DELAY=0.5 ... ANOUT OFF motor 

Ejemplo 2

DEFDAT myprog DECL REAL corr = 1.45 DECL REAL offset = 0.25 ENDDAT DEF myprog( ) SIGNAL motor $ANOUT[7] ... ANOUT ON motor = corr*$VEL_ACT-offset ... ANOUT OFF motor

Procedimiento para programar con salidas analógicas

El requisito para utilizar las señales analógicas es proyectar correctamente el sistema de bus con las señales analógicas conectadas. Programación de ANOUT ON/OFF 1. 2. 3. 4. 5. 6.

Selección de la salida analógica correcta. Ejecución de la declaración de señal. Declaración de las variables necesarias en una lista de datos. Conectar: programación de la instrucción ANOUT ON. Comprobación de que haya 4 salidas dinámicas activas como máximo. Desconectar: programación de la instrucción ANOUT OFF.

Ejemplo:


227 / 255


Fig. 12-4: Ejemplo de señal de salida analógica DEF myprog( ) SIGNAL motor $ANOUT[3] ... ANOUT ON motor = 3.375*$VEL_ACT MINIMUM=0.30 MAXIMUM=0.97 ... ANOUT OFF motor

228 / 255



12.4

Ejercicio: Trabajos con E/S analógicas





Requisitos



Utilización de declaraciones de señales en entradas/salidas Integración estática o dinámica de entradas analógicas en los procesos de trabajo Integración estática o dinámica de salidas analógicas en los procesos de trabajo

Conocimientos teóricos sobre las declaraciones de señales Conocimientos teóricos sobre la integración de entradas/salidas analógicas

Configure su sistema de modo que pueda modificar el override del programa mediante una entrada analógica. Además, la velocidad real de desplazamiento del robot debe controlar una salida analógica. Tarea parcial 1 1. 2. 3. 4.

Cree un programa con el nombre Velocidad. Utilice la entrada analógica 1 controlada mediante el potenciómetro. Modifique el override del programa en el interpretador Submit. Compruebe su programa según prescripción.

Tarea parcial 2 1. Amplíe su programa con movimientos de trayectoria (velocidad: hasta 2 m/s) que formen parte de un bucle infinito. 2. Utilice la salida analógica 1, visualización en panel. 3. Utilizar la variable de sistema $VEL_ACT para la velocidad de desplazamiento actual. 4. Comprobar el programa conforme a lo pre scrito. 5. Adicionalmente: si la velocidad es inferior a 0,2 m/s, se debe excitar la salida de todos modos con 1.0 V; si la velocidad es superior a 1,8 m/s, la salida no debe emitir más de 9.0 V. Asegúrese de activar la E/S analógica una única vez.

Lo que se debe saber tras el ejercicio: 1. ¿Cuántas E/S analógicas se pueden utilizar en la unidad de control KRC? ............................................................ ............................................................ 2. ¿Cuántas entradas digitales, entradas analógicas y salidas analógicas predefinidas puede utilizar simultáneamente la unidad de control de KUKA? ............................................................ ............................................................ 3. ¿Cuáles son las instrucciones KRL para iniciar y finalizar cíclicamente la salida analógica? ............................................................ ............................................................


229 / 255


4. ¿Cómo se interroga una entrada analógica estáticamente? ............................................................. .............................................................

230 / 255


13 Anexo

13

An e x o

13.1

Programar los movimientos mediante KRL

Definición de un movimiento

Fig. 13-1: Formulario inline Movimiento PTP-/LIN-/CIRC Indicaciones necesarias para un movimiento           

Principio de la de programación movimientos

Tipo de movimiento - PTP, LIN, CIRC Posición de destino y posible posición auxiliar Parada exacta o aproximación Velocidad - PTP (%) y movimiento de trayectoria (m/s) Herramienta - TCP y carga Sistema de coordenadas base Herramienta guiada por robot o externa Aceleración Posible parámetro de aproximación Control de orientación para movimientos de trayectoria Posible con KRL: ángulo circular para un movimiento circular CIRC

Tipo de movimiento PTP  Punto de destino PTP


Aproximación

Descripción Tipo: POS, E6POS, AXIS, E6AXIS, FRAME El punto de destino puede indicarse de forma cartesiana o específica del eje. Las coordenadas cartesianas hacen referencia al sistema de coordenadas BASE. Si no se indican todos los componentes del punto de destino, la unidad de control adopta los valores de la posición anterior para los componentes que faltan. C_PTP 



Consigue que se produzca una aproximación del punto de destino. Para la aproximación PTP-PTP es suficiente la indicación C_PTP.

C_DIS 



Sólo para la aproximación PTP-CP. Este parámetro determina cuando se iniciará, como muy pronto, la aproximación. Son posibles las siguientes indicaciones: Parámetros de distancia: La aproximación comienza, como muy pronto, cuando la distancia con respecto al punto de destino queda por debajo del valor de $APO.CDIS.


231 / 255


El robot se aproxima a una posición del fichero DAT; la posición ha sido programada previamente mediante formulario en línea y realiza una aproximación a este punto P3

PTP XP3 C_PTP 

El robot se aproxima a una posición introducida Específico del eje (AXIS o E6AXIS) 

PTP {A1 0, A2 -80, A3 75, A4 30, A5 30, A6 110} 

Posición (con herramienta actualmente activa y Base)

PTP {X 100, Y -50, Z 1500, A 0, B 0, C 90, S 3, T 35} 

El robot se desplaza solo con la introducción de una o varias unidades

PTP {A1 30} ; sólo A1 desplazado a 30° PTP {X 200, A 30} ; sólo en X a 200mm y A a 30°

Tipo de movimiento LIN 

LIN Punto de destino


Descripción Tipo: POS, E6POS, FRAME Si no se indican todos los componentes del punto de destino, la unidad de control adopta los valores de la posición anterior para los componentes que faltan. Las informaciones sobre el estado y el giro dentro de un punto de destino del tipo POS o E6POS no se tienen en cuenta para los movimientos LIN (al igual que ocurre con los movimientos CIRC).

Aproximación de trayectoria

Las coordenadas hacen referencia al sistema de coordenadas BASE. Este parámetro consigue que se produzca una aproximación del punto de destino. Además determina cuando se iniciará, como muy pronto, la aproximación. Los datos posibles son: 

C_DIS



Parámetros de distancia: La aproximación comienza, como muy pronto, cuando la distancia con respecto al punto de destino queda por debajo del valor de $APO.CDIS. C_ORI Parámetros de orientación: La aproximación comienza, como muy pronto, cuando el ángulo de orientación dominante queda por debajo del valor de $APO.CORI.



C_VEL

Parámetros de velocidad: La aproximación comienza, como muy pronto, cuando la velocidad durante la fase de frenado queda por debajo del valor de $APO.CVEL. 

El robot se desplaza hasta una posición calculada y realiza una aproximación al punto DEPÓSITO[4]

LIN ABLAGE[4] C_DIS

232 / 255


13 Anexo

Tipo de movimiento CIRC 

CIRC Punto auxiliar, Punto de destino < Ángulo circular (CA)>

Elemento Punto auxiliar

Descripción Tipo: POS, E6POS, FRAME Si no se indican todos los componentes del punto auxiliar, la unidad de control adopta los valores de la posición anterior para los componentes que faltan. En principio, el ángulo de orientación y las informaciones sobre el estado y el giro dentro de un punto auxiliar no se tienen en cuenta. El punto auxiliar no puede ser aproximado. Se ejecuta durante el modo de ejecución del programa GO. Durante el modo de ejecución del programa Movimiento, el robot se detiene en el punto auxiliar.

Punto de destino

Las coordenadas hacen referencia al sistema de coordenadas BASE. Tipo: POS, E6POS, FRAME Si no se indican todos los componentes del punto de destino, la unidad de control adopta los valores de la posición anterior para los componentes que faltan. Las informaciones sobre el estado y el giro dentro de un punto de destino del tipo POS o E6POS no se tienen en cuenta para los movimientos CIRC (al igual que ocurre con los movimientos LIN). Las coordenadas hacen referencia al sistema de coordenadas BASE.


233 / 255


Elemento Ángulo circular CA

Descripción Indica el ángulo total del movimiento circular. Permite prolongar el movimiento más allá del punto de destino programado o acortarlo. Esto significa que el punto de destino real no incluirá el punto de destino programado. Unidad: Grados. Ninguna limitación; se puede programar en particular un ángulo circular de más de 360°. 



Aproximación de trayectoria

Ángulo circular positivo: la trayectoria circular se desplaza en dirección punto de inicio › punto auxiliar › punto de destino. Ángulo circular negativo: la trayectoria circular se

desplaza en dirección destino › punto auxiliar.punto de inicio › punto de Este parámetro consigue que se produzca una aproximación del punto de destino. Además determina cuando se iniciará, como muy pronto, la aproximación. Los datos posibles son: 

C_DIS



Parámetros de distancia: La aproximación comienza, como muy pronto, cuando la distancia con respecto al punto de destino queda por debajo del valor de $APO.CDIS. C_ORI Parámetros de orientación: La aproximación comienza, como muy pronto, cuando el ángulo de orientación dominante queda por debajo del valor de $APO.CORI.



C_VEL Parámetros de velocidad: La aproximación comien-

za, como muy pronto, cuando la velocidad durante la fase de frenado queda por debajo del valor de $APO.CVEL. 

El robot se acerca a las posiciones previamente programadas del archivo DAT y se desplaza en un ángulo circular de 190º.

CIRC XP3, XP4, CA 190 

El robot se acerca a las posiciones indicadas y se desplaza en un ángulo circular de 180º.

CIRC {X 100, Y ...}, {X 150, Y ...}, CA 180 

Ángulo circular CA En el punto de destino real se adopta la orientación que se programó en el punto de destino programado. 

234 / 255

Ángulo circular positivo (CA>0): El circuito se desplaza en el sentido programado: Punto inicial - punto auxiliar - punto de destino


13 Anexo

Fig. 13-2: Ángulo circular CA = +290° 

Ángulo circular negativo (CA<0): El circuito se desplaza en sentido contrario al sentido programado: Punto inicial - punto destino - punto de auxiliar

Fig. 13-3: Ángulo circular CA = -290° Función de los parámetros de movimiento

Preajustes para la programación de movimientos 

Se pueden aplicar ajustes existentes:  de la ejecución de la línea INI del último formulario en línea de los últimos ajustes de las variables de sistema correspondientes Modificar o inicializar las correspondientes variables de sistema  



Variables de sistema de los parámetros de movimiento 

Herramienta: $TOOL y $LOAD  Activación del TCP medido

$TOOL = tool_data[x] ; x = 1...16 

Activación de los datos de carga correspondientes


235 / 255

Programación de robots 2 $LOAD = load_data[x] ; x = 1...16 

Base de referencia / base de trabajo: $BASE  Activación de la base medida

$BASE = base_data[x] ; x = 1...32 

Herramienta guiada por robot o externa: $IPO_MODE  Herramienta guiada por robot

$IPO_MODE = #BASE 

Herramienta externa

$IPO_MODE = #TCP 

Velocidad Con movimiento PTP 

$VEL_AXIS[x] ; x=1...8 para cada eje 


$VEL.CP = 2.0 ; [m/s] Velocidad de trayectoria $VEL.ORI1 = 150 ; [°/s] Velocidad de vaivén $VEL.ORI2 = 200 ; [°/s] Velocidad rotacional

La dirección de avance de la herramienta es en la mayoría de los casos el eje X. La velocidad de giro es el giro alrededor de este eje X con ángulo C. En la velocidad de basculamiento se gira alrededor de los otros dos ángulos (A y B). 

Aceleración 

Con movimiento PTP

$ACC_AXIS[x] ; x=1...8 para cada eje 


$ACC.CP = 2.0 ; [m/s²] Aceleración de trayectoria $ACC.ORI1 = 150 ; [°/s²] Aceleración de vaivén $ACC.ORI2 = 200 ; [°/s²] Aceleración rotacional 

Tirón  para movimiento SPTP

$GEAR_JERK[1...12] = 0 ... 100 Tirón del engranaje de los ejes A1 a E6 en tanto por ciento (1...100) SPTP XP10 WITH GEAR_JERK[1]=22, GEAR_JERK[2]=66 

Con movimientos de trayectoria SLIN o SCIRC


El grupo está formado por los siguientes componentes: 








SLIN XP13 WITH $JERK = {CP 44} ; [m/s³] Modificación de la aceleración en trayectoria

236 / 255


13 Anexo 

Distancia de aproximación en caso de SPINE pasos individuales SLIN, SCIRC y en caso de  SPTP: C_SPL El alejamiento respecto del punto de destino debe quedar por debajo del valor $APO.CDIS

$APO.CDIS = 250.0 ; [mm] Distancia SPTP XP3 C_SPL SLIN XP4 C_SPL 

Solo con movimiento PTP: C_PTP

$APO.CPTP = 50 ; Valor de aproximación en [%] para C_PTP PTP XP3 C_PTP 

Con movimientos de trayectoria LIN, CIRC: C_ORI El ángulo de orientación dominante debe quedar por debajo del valor $APO.CORI

$APO.CORI = 50.0 ; [°] Ángulo SLIN XP4 C_ORI 

Con movimientos de trayectoria LIN, CIRC: C_VEL La velocidad en la fase de frenado hacia el punto de destino debe quedar por debajo del valor $APO.CVEL

$APO.CVEL = 75.0 ; [%] Porcentaje LIN XP4 C_VEL 

Control de la orientación: Solo con LIN y CIRC  Con LIN y CIRC: $ORI_TYPE 

$ORI_TYPE = #CONSTANT

Durante el movimiento de trayectoria, la orientación se mantiene constante. Para el punto final se ignora la orientación programada.

Fig. 13-4: Control orientación constante 

$ORI_TYPE = #VAR

Durante el movimiento de trayectoria, la orientación se modifica continuamente hacia la orientación del punto de destino.


237 / 255


Fig. 13-5: Estándar o PTP manual 

$ORI_TYPE = #JOINT



Durante el movimiento de trayectoria, la orientación de la herramienta es modificada ininterrumpidamente desde la posición inicial hasta la posición final. Esto se logra mediante el desplazamiento lineal del ángulo del eje de la muñeca. La problemática de la singularidad de la muñeca puede evitarse con esta opción. Se produce un giro alrededor de la dirección de impacto de la herramienta. No es posible realizar un giro alrededor de la dirección de impacto de la herramienta. Solo con CIRC: $CIRC_TPYE La variable $CIRC_TYPE carece de significado cuando se efectúa un desplazamiento lineal del ángulo del eje de la muñeca con $ORI_TYPE = #JOINT. 

$CIRC_TYPE = #PATH

Control de la orientación relacionada con la trayectoria durante el movimiento circular

Fig. 13-6: Orientación constante, referida a la trayectoria 

$CIRC_TYPE = #BASE

Control de orientación referido al espacio durante el movimiento circular 238 / 255


13 Anexo

Fig. 13-7: Orientación constante, referida a la base Procedimiento para programar movimientos mediante KRL

1. Abrir el programa como experto. 2. Comprobar los ajustes predefinidos para la programación de movimientos y aceptar o inicializar de nuevo:  Herramienta ($TOOL y $LOAD)  Ajustes base ($BASE) Herramienta externa o guiada por robot ($IPO_MODE)   Velocidad  Aceleración Posible distancia de aproximación   Posible control de la orientación 3. Crear la instrucción de movi miento, compuesta de: Tipo de movimiento (PTP, LIN, CIRC)   Punto de destino (con CIRC también punto auxiliar)  Para CIRC posible ángulo circular (CA) Activar la aproximación (C_PTP, C_DIS, C_ORI, C_VEL)  4. En caso de nuevo movimiento de vuelta al punto 3 5. Cerrar el editor y guardar

13.2

Variables del sistema

13.2.1

$ACC

Descripción

Aceleración del TCP en la alimentación La variable del tipo de estructura CP contiene la aceleración cartesiana programada para los siguientes componentes: CP: aceleración en trayectoria en [m/s2]  

ORI1: aceleración en trayectoria en [º/s2]



ORI2: aceleración rotacional en [º/s2]

Valores límite para la aceleración cartesiana: 

0.0 … $ACC_MA La aceleración cartesiana máxima $ACC_MA está definida en los datos de máquina.


239 / 255


La documentación acerca de los datos de máquina contiene información detallada sobre la variable $ACC_MA. Cuando $ACC vulnera los valores límite, se visualiza el mensaje Asignación de valor no permitida. La ejecución del programa se detiene o la instrucción de movimiento correspondiente durante el desplazamiento manual no se ejecuta.

Ejemplo 13.2.2

$ACC={CP 5.0,ORI1 500.0,ORI2 500.0}

$ACC_AXIS

Descripción

Aceleración de los ejes del robot en la alimentación La variable contiene la aceleración del eje planeada en porcentaje. En el caso de movimientos que se planean con la ayuda del modelo dinámico, el valor porcentual se refiere a los momentos del eje disponibles para la aceleración. Si no hay disponible ningún modelo dinámico, el valor porcentual se refiere a las aceleraciones definidas en los datos de máquina mediante $RAISE_TIME (variable en el archivo... R1\Mada\$machine.dat).

Sintaxis

$ACC_AXIS[Número de eje]=aceleración


Elemento

Descripción

Número del eje

Tipo: INT

1 … 6: eje del robot A1 … A6 Tipo: INT; unidad: % 

Aceleración



13.2.3

1 … 100

$ACC_EXTAX

Descripción

Aceleración de los ejes externos en la alimentación La variable contiene la aceleración del eje planeada en porcentaje. En el caso de movimientos que se planean con la ayuda del modelo dinámico, el valor porcentual se refiere a los momentos del eje disponibles para la aceleración. Si no hay disponible ningún modelo dinámico, el valor porcentual se refiere a las aceleraciones definidas en los datos de máquina mediante $RAISE_TIME (variable en el archivo... R1\Mada\$machine.dat).

Sintaxis

$ACC_EXTAX[Número de eje]=aceleración


Elemento

Descripción

Número del

Tipo: INT

eje



Aceleración

1 … 6: eje adicional E1 … E6 Tipo: INT; unidad: % 

13.2.4

1 … 100

$APO

Descripción

Parámetros de aproximación en la alimentación Con las variables se determina el trayecto de aproximación.

240 / 255


13 Anexo

Sintaxis

$APO={CVEL Velocidad, CPTP DisPTP, CDIS DisCP, CORI Orientación}


Elemento

Descripción

CVEL

Tipo: INT; unidad: % Parámetros de velocidad 

CPTP

1 … 100

El parámetro de aproximación indica con qué porcentaje de la velocidad programada comienza como mínimo la aproximación en la fase de frenado hacia el punto de destino. Tipo: INT; unidad: % Distancia de aproximación para movimientos PTP y PTP Spline (= distancia antes del punto de destino en la que comienza como mínimo la aproximación) 

1 … 100

Explicación sobre los parámetros de aproximación: (>>> "CPTP" Página 241)

CDIS

Indicación: Los movimientos PTP Spline (SPTP) pueden programarse a partir del KUKA System Software 8.3. Tipo: REAL; unidad: mm Parámetros de distancia

CORI

El posicionamiento aproximado comienza, como muy pronto, cuando la distancia con respecto al punto de destino queda por debajo del valor indicado aquí. Tipo: REAL; unidad: ° Parámetros de orientación La aproximación comienza como mínimo cuando el ángulo de orientación dominante (giro o basculación del eje longitudinal de la herramienta) queda por debajo de la distancia angular con respecto al punto de destino indicada aquí.

CPTP

El parámetro de aproximación CPTP es diferente dependiendo de si hay programado un movimiento PTP o PTP Spline (SPTP). 





En un movimiento PTP, el valor porcentual indicado con CPTP se refiere a un ángulo de eje determinado en los datos de máquina con $APO_DIS_PTP. La aproximación se efectúa cuando todos los ejes no alcancen su distancia de aproximación definida. Sin embargo, la aproximación comienza como muy pronto cuando se haya alcanzado el 50 % de la longitud del paso. Es decir, la aproximación se realiza como mínimo cuando se haya realizado la mitad de la longitud del recorrido entre el punto de inicio y el punto de destino, referido al contorno del movimiento PTP sin aproximación. Esta limitación del 50 % también es válida para la aproximación entre 2 movimientos individuales SPTP. En la aproximación entre PTP Splines que estén programados como uno de varios segmentos en bloques Spline, no está definido cuándo se puede comenzar como mínimo con la aproximación. Es decir, la aproximación empieza tal y como se haya estipulado con CPTP. En la aproximación entre PTP Splines, el valor porcentual indicado con CPTP se refiere a la longitud del recorrido del último segmento Spline en el primer bloque Spline y la longitud del recorrido del primer segmento Spline en el bloque Spline siguiente que recorren todos los ejes del robot


241 / 255


y, con ellos, los ejes adicionales acoplados matemáticamente en la zona del eje.

13.2.5

$BASE

Descripción

Sistema de coordenadas BASE en la alimentación La variable del tipo de estructura FRAME describe la posición teórica de la pieza referida al sistema de coordenadas WORLD.  

13.2.6

X, Y, Z: desplazamiento del srcen a lo largo de los ejes en [mm] A, B, C: giro del ángulo del eje en [º]

$CIRC_TYPE

Descripción

Control de orientación de CIRC en la alimentación La variable contiene el control de orientación programado de un movimiento circular. Este está referido a la base o a la trayectoria.

Sintaxis

$CIRC_TYPE=tipo


Elemento

Descripción

Tipo

Tipo: ENUM  

13.2.7

#BASE: Control de orientación referido a la base #PATH: Control de orientación referido a la trayectoria

Modo d e ah orro e nergético ( $ECO_LEVEL)

Descripción

Mediante la variable del sistema $ECO_LEVEL, el usuario puede desplazar el robot ahorrando energía. El grado de ahorro se puede ajustar a "bajo", "medio" o "alto". El modo de ahorro energético provoca que los ejes del robot y los ejes adicionales se desplacen más lentos. Cuanto mayor es el ahorro, menor será la velocidad. La cantidad de energía que se ahorra en comparación con la potencia completa, dependerá principalmente de las posiciones del eje y no se puede prever. $ECO_LEVEL no actúa sobre todos los movimientos. La siguiente tabla indica los movimientos sobre los actúa y en los que no:

¿Efecto?

Movimiento PTP LIN CIRC Movimientos Spline CP (bloque y conjunto individual)

Sí No No Sí

Con perfil de desplazamiento más elevado Movimientos Spline CP (bloque y conjunto individual)

No

Sin perfil de desplazamiento más elevado Movimientos Spline PTP (bloque y conjunto individual)

Sí

Si un programa se restablece o se desactiva, se desconectará automáticamente el modo de ahorro energético.

242 / 255


13 Anexo

En los siguientes casos estará inactivo el modo de ahorro energético, incluso si está conectado: En un desplazamiento a coincidencia de paso En una zona de desplazamiento constante en el Spline En un bloque de tiempo en el Spline

  

Si ya se han programado valores bajos para la velocidad y la aceleración, $ECO_LEVEL apenas tendrá efecto o no tendrá efecto. En función del tipo de robot puede ocurrir que en determinadas constelaciones, el ahorro con "medio" y "alto" sea igual o casi igual. (P. ej. con una carga inferior al 30% de la carga por defecto.)

Condición previa

$ADAP_ACC <> #NONE $OPT_MOVE <> #NONE

 

En las dos variables del sistema <> #NONE ya es el ajuste por defecto.

Sintaxis

$ECO_LEVEL=Nivel


Elemento

Descripción

Nivel

Tipo: ENUM 

  

13.2.8

#OFF: El modo de ahorro energético está desconectado. #LOW: Ahorro bajo #MIDDLE: Ahorro medio #HIGH: Ahorro alto

$GEAR_JERK

Descripción

Tirón de engranaje de los ejes en la alimentación Con las variables se determina el tirón de engranaje de un eje. El tirón de engranaje se refiere de forma porcentual a los datos de máquina correspondientes del modelo dinámico $DYN_DAT[]. Si al comenzar un movimiento Spline no está inicializado $GEAR_JERK, p. ej. porque la línea INI no se haya recorrido, se muestra el mensaje de confirmación Tirón de reductor no programado {Número del eje} y se detiene la ejecución del programa.

Sintaxis

$GEAR_JERK[Número de eje]=tirón de engranaje


Elemento

Descripción

Número del eje

Tipo: INT 

1 … 6: eje del robot A1 … A6



Tirón del accionamiento

13.2.9

: eje adicional E1 … E6 12unidad: Tipo:7 … INT; % 

1 … 100

$IPO_MODE

Descripción

Modo de interpolación programado en la alimentación

Sintaxis

$IPO_MODE=modo


243 / 255



Elemento

Descripción

Modo

Tipo: ENUM  

#TCP: La herramienta es una herramienta fija. #BASE: la herramienta está montada en la brida de acople.

Por defecto: #BASE

13.2.10 $JERK Descripción

Limitación cartesiana del tirón para SPLINE en la alimentación La variable del tipo de estructura JERK_STRUC limita la modificación temporal de la aceleración en los movimientos CP Spline (SLIN, SCIRC). La variable es relevante solamente con movimientos CP Spline que se planean sin modelo dinámico. (Solo KUKA System Software 8.1. A partir del KUKA System Software 8.2, la variable ya no es relevante.) El grupo está formado por los siguientes componentes: 








El tirón máximo permitido para movimientos SPLINE está definido en los datos de máquina (variable $JERK_MA en el archivo …R1\Mada\$machine.dat).

Ejemplo


13.2.11 $LOAD Descripción

Datos de carga actualmente vigentes en la alimentación La estructura contiene los datos de carga que se han introducido en la unidad de control del robot y se han asignado a la herramienta actual. El sistema de coordenadas de referencia es el sistema de coordenadas FLANGE. (>>> "Cargas en el robot" Página 245)

Sintaxis Aclaración de la sintaxis

$LOAD={M Masa, CM centro de gravedad, J inercia}

Elemento

Descripción

Masa Centro de gravedad

Tipo: REAL; unidad: kg Tipo: FRAME

X, Y, Z: Situación del centro de gravedad relativo a la brida  A, B, C: Orientación de los ejes principales de inercia relativos a la brida Tipo: INERTIA 

Inercia



244 / 255

X, Y, Z: momentos de inercia de masa alrededor de los ejes del sistema de coordenadas que está girado de forma relativa respecto a la brida mediante A, B, C Edición: 24.02.2015 Versión: P2KSS8_robotprogramming_2_(R2)_V4

13 Anexo

Cargas en el robot

Al robot pueden acoplarse distintas cargas: Carga en la brida Carga adicional en el eje 3 Carga adicional en el eje 2 Carga adicional en el eje 1

   

Fig. 13-8: Cargas en el robot 1 2

Parámetros

Carga Carga adicional sobre el eje 3

3 Cargaadicionalsobreeleje2 4 Carga adicional sobre el eje 1

Los datos de carga se definen por medio de los siguientes parámetros:

Parámetros Masa m Distancia al centro de Lx, Ly, Lz gravedad Inercias de masa en el Ix, Iy, Iz centro de gravedad

Unidad kg mm kg m2

Sistemas de referencia para los valores X, Y y Z por cada carga:

Carga Carga útil Carga adicional A3

Sistemadereferencia Sistema de coordenadas FLANGE Sistema de coordenadas FLANGE

Carga adicional A2

A4 = 0°, A5 = 0°, A6 = 0° Sistema de coordenadas ROBROOT

Carga adicional A1

A2 = -90° Sistema de coordenadas ROBROOT A1 = 0°


245 / 255


13.2.12 $ORI_TYPE Descripción

Control de orientación de un movimiento CP en la alimentación

Sintaxis

$ORI_TYPE=Tipo


Elemento

Descripción

Tipo

Tipo: ENUM 





#CONSTANT: La orientación del TCP se mantiene de forma constante durante el movimiento. #VAR: La orientación del TCP se modifica continuamente durante el movimiento. #JOINT: La orientación del TCP se modifica continuamente durante el movimiento. Esto se logra mediante el desplazamiento lineal del ángulo del eje de la muñeca (desplazamiento específico del eje).

Indicación: si $ORI_TYPE = #JOINT, la variable $CIRC_TYPE se ignora. 13.2.13 $ROTSYS Descripción

Sistema de coordenadas de referencia para la rotación en la alimentación Con la variable puede definirse el sistema de coordenadas en el que se ejecuta la rotación (A, B, C) en el caso de movimientos relativos y del desplazamiento manual.

Sintaxis

$ROTSYS=sistema de referencia


Elemento

Descripción

Sistema de referencia

Tipo: ENUM 

 

#AS_TRA: rotación en el sistema de coordenadas $TRANSSYS #BASE: rotación en el sistema de coordenadas BASE #TCP: rotación en el sistema de coordenadas TOOL

Por defecto: #AS_TRA

13.2.14 $SPL_ORI_JOINT_AUTO Descripción

$SPL_ORI_JOINT_AUTO sirve para la optimización del comportamiento de movimiento cerca de las singularidades de los ejes de la muñeca. Modo de acción de $SPL_ORI_JOINT_AUTO = #ON: 

Sintaxis

246 / 255

Para movimientos CP,decide para los que es válida $ORI_TYPE = #VAR, la unidad de controlSpline del robot automáticamente por movimiento (es decir, también por segmento) se ejecutan como #VAR o como #JOINT.

$SPL_ORI_JOINT_AUTO =tipo


13 Anexo


Elemento

Descripción

Tipo

Tipo: ENUM 





#OFF ninguna optimización cerca de la singularidad de los ejes de la muñeca #ON es una alternativa a la utilización de $ORI_TYPE = #JOINT. Mientras que $ORI_TYPE = #JOINT se puede utilizar de forma precisa para movimientos individuales, $SPL_ORI_JOINT_AUTO = #ON permite la optimización automática para secuencias de programación con el tamaño deseado y con una necesidad de modificación muy reducida. $SPL_ORI_JOINT_AUTO solo se puede modificar mediante un programa de robot. $SPL_ORI_JOINT_AUTO no se puede ajustar en segmentos Spline.

Por defecto: $SPL_ORI_JOINT_AUTO = #OFF

13.2.15 $TOOL Descripción

Sistema de coordenadas TOOL en la alimentación La variable del tipo de estructura FRAME describe la posición teórica del sistema de coordenadas TOOL referida al sistema de coordenadas FLANGE.  

X, Y, Z: desplazamiento del srcen a lo largo de los ejes en [mm] A, B, C: giro del ángulo del eje en [º]

13.2.16 $VEL Descripción

Velocidad del TCP en la alimentación La variable del tipo de estructura CP contiene la velocidad cartesiana programada para los siguientes componentes:   

CP: velocidad de trayectoria en [m/s] ORI1: velocidad de basculación en [º/s] ORI2: velocidad de rotación en [º/s]

Valores límite para la velocidad cartesiana: 

0.0 … $VEL_MA La velocidad cartesiana máxima $VEL_MA está definida en los datos de máquina. La documentación acerca de los datos de máquina contiene información detallada sobre la variable $VEL_MA.

Cuando $VEL vulnera los valores límite, se visualiza el mensaje Asignación de valor no permitida. La ejecución del programa se detiene o la instrucción de movimiento correspondiente durante el desplazamiento manual no se ejecuta.

Ejemplo

$VEL={CP 2.0,ORI1 300.0,ORI2 300.0}

13.2.17 $VEL_AXIS Descripción

Velocidad de los ejes del robot en la alimentación


247 / 255


La variable contiene la velocidad de eje programada en tanto por ciento, referida a la velocidad del eje máxima definida en los datos de la máquina $VEL_AXIS_MA (variable en el archivo …R1\Mada\$machine.dat).


$VEL_AXIS[Número de eje]=velocidad

Elemento

Descripción

Número del eje

Tipo: INT

1 … 6: eje del robot A1 … A6 Tipo: INT; unidad: % 

Velocidad



1 … 100

13.2.18 $VEL_EXTAX Descripción

Velocidad de los ejes externos en la alimentación La variable contiene la velocidad de eje programada en tanto por ciento, referida a la velocidad del eje máxima definida en los datos de la máquina $VEL_AXIS_MA (variable en el archivo …R1\Mada\$machine.dat).


$VEL_EXTAX[Número de eje]=Velocidad

Elemento

Descripción

Número del eje

Tipo: INT

1 … 6: eje adicional E1 … E6 Tipo: INT; unidad: % 

Velocidad



1 … 100

13.2.19 $CIRC_MODE Descripción

Comportamiento del control de orientación y de los ejes externos en el punto auxiliar y el punto de destino de un círculo SCIRC Para movimientos SCIRC, la unidad de control del robot puede tener en cuenta la orientación programada del punto auxiliar. Con $CIRC_MODE puede determinarse si debe tenerse en cuenta y en qué medida. Además, con $CIRC_MODE se puede determinar si el punto de destino debe tener la orientación programada en las instrucciones SCIRC con ángulo circular o si la orientación se debe escalar de acuerdo con el ángulo circular. $CIRC_MODE solo se escribir mediante una instrucción SCIRC. $CIRC_MODE no se puede leer.

Sintaxis

Para puntos auxiliares: $CIRC_MODE.AUX_PT.ORI = Reacción HP

Para puntos de destino: $CIRC_MODE.TARGET_PT.ORI = Reacción ZP

248 / 255


13 Anexo


Elemento

Descripción

Reacción HP

Tipo: ENUM 





#INTERPOLATE: En el punto auxiliar se acepta la orientación programada. #IGNORE: La orientación de partida se convierte durante la trayectoria más corta en la orientación de destino. La orientación programada del punto auxiliar se ignora. #CONSIDER: La orientación de partida se convierte durante la trayectoria en orientación de destino, que incluye la orientación programada del punto auxiliar. Es decir, auxiliar se recoge a lo largoque de la la orientación trayectoria, del peropunto no necesariamente en el punto auxiliar.

Reacción ZP

Por defecto: #CONSIDER Tipo: ENUM 



#INTERPOLATE: En el punto de destino real se acepta la orientación programada del punto de destino. (Única posibilidad para SCIRC sin indicación del ángulo circular. Si #EXTRAPOLATE está ajustado, #INTERPOLATE se ejecuta igualmente.) #EXTRAPOLATE: En el punto de destino programado se acepta la orientación programada. En el punto de destino real se escala la orientación de acuerdo con el ángulo circular.

Valor por defecto para SCIRC con indicación del ángulo circular: #EXTRAPOLATE

Restricciones





Si para un segmento SCIRC se aplica $ORI_TYPE = #IGNORE, no se evaluará $CIRC_MODE. Si a un segmento SCIRC le precede un segmento SCIRC o SLIN para el que se aplica $ORI_TYPE = #IGNORE, no se podrá utilizar #CONSIDER en el segmento SCIRC.

Para SCIRC con ángulo circular:  



Ejemplo: Punto auxiliar

Para el punto auxiliar no se debe ajustar #INTERPOLATE. Si se aplica $ORI_TYPE = #IGNORE, no se podrá ajustar #EXTRAPOLATE para el punto de destino. Si precede un segmento Spline para el que se aplica $ORI_TYPE = #IGNORE, no se podrá ajustar #EXTRAPOLATE para el punto de destino.

El TCP recorre un arco circular con 192° cartesianos.   

La orientación en el punto de inicio es 0°. La orientación en el punto auxiliar es 98°. La orientación en el punto de destino es 197°.

Por lo tanto, el cambio de orientación es de 197° si se tiene en cuenta el punto auxiliar. Si se ignora la orientación en el punto auxiliar, también se podrá alcanzar la orientación de destino a través del cambio de orientación de 360° - 197° = 163°. 

#INTERPOLATE: En el punto auxiliar se acepta la orientación programada de 98°. Por lo tanto, el cambio de orientación es de 197°.


249 / 255




Ejemplo: Punto de destino

#IGNORE: La orientación programada del punto auxiliar se ignora. Se ejecuta el cambio de orientación más corto de 163°. #CONSIDER: Se recorre la trayectoria que incluye la orientación del punto auxiliar, en este caso el cambio de orientación con 197°. Es decir, a lo largo de la trayectoria se aceptan los 98°, pero no necesariamente en el punto auxiliar.

El ejemplo muestra esquemáticamente la reacción de #INTERPOLATE y #EXTRAPOLATE.  

Las flechas discontinuas claras muestran la orientación programada. Las flechas oscuras muestran la orientación real si se diferencia de la orientación programada.

#INTERPOLATE: En TP, que se encuentra delante de TP_CA, aún no se ha alcanzado la orientación programada. En TP_CA se acepta la orientación programada.

Fig. 13-9: #INTERPOLATE SP AuxP TP TP_CA

Punto de inicio Punto auxiliar Punto de destino programado Punto de destino real. Se obtiene por el ángulo circular.

#EXTRAPOLATE: En TP se acepta la orientación programada. Para TP_CA se escala esta orientación de acuerdo con el ángulo circular.

250 / 255


13 Anexo

Fig. 13-10: #EXTRAPOLATE


251 / 255


252 / 255


Índice

Índice Símbolos $ACC 239 $ACC_AXIS 240 $ACC_EXTAX 240 $ACC_MA 239 $APO 240 $BASE 242 $CIRC_MODE 149, 248 $CIRC_TYPE 242 $ECO_LEVEL 242 $GEAR_JERK 243 $IPO_MODE 243 $JERK 244 $JERK_MA 244 $LOAD 244 $ORI_TYPE 246 $RAISE_TIME 240 $ROTSYS 246 $SPL_ORI_JOINT_AUTO 246 $TIMER r 185 $TOOL 247 $VEL 247 $VEL_AXIS 247 $VEL_AXIS_MA 248 $VEL_EXTAX 248 $VEL_MA 247

DEFFCT 111 Diálogo 135

A Activar el proyecto en la unidad de control 32 Administrador 65 Anexo 231 Avance 77 Ayuda 9

G Global 189 global 77 Grupo 87 Grupo de usuario, por defecto 65

B Barra de menús 9 Barras de botones 9 Bloque de tiempo 215 Bloque Spline CP 180 Bloque Spline PTP 181 Bloquear 34 C Campos 87 Cancelar movimiento con interrupción, ejercicio 201 Cargas en el robot 245 Cargas útiles 245 Catálogos (ventana) 9 Centro de gravedad 245 Comentario 57 Comparar proyectos 14 D DECL 77, 78 Declaraciones 75 Declaración 77, 79 Declarar interrupción, ejercicio 195

E E/S analógicas, ejercicio 229 Editor KRL 41 Ejemplo PEP 64 EKrlMsgType 117 ENUM 98 Entradas analógicas 223 Estructura 93 Estructura del proyecto (ventana) 9 Estructura del proyecto WorkVisual (pestaña Ficheros) 13 Explorador de proyecto 10 F Fold 59 Fragmentos (snippets) entrada rápida para instrucciones KRL 48 Funciones 101, 111, 113 Funciones de conmutación 203 Funciones estándar 83, 113 Funciones para la emisión de mensaje 113 Funciones para variables de cadena 113 Funciones, matemáticas 113

I Importar, proyecto de WorkVisual 35 Impulso 206 Individual (opción de menú) 86 Inercia de masa 245 Inicialización 80 interpretador Submit 219 Interrupción 189 Introducción al nivel del experto 65 K KrlMsg_T 116 KrlMsgDlgSK_T 133 KrlMsgOpt_T 118 L local 77 M Manipulación 82, 83 Masa 245 Mensaje de acuse de recibo 115, 127 Mensaje de diálogo 115 Mensaje de espera 115, 130 Mensaje de estado 115


253 / 255


mensaje de estado 124 Mensaje de observación 115, 121 Mensajes 115 mensajes 115 Mensajes (ventana) 9 Mensajes de usuario 115 mensajes de usuario 115 Metodología de programación, ejemplo PEP 64 Modificar variable 86 Modo de interpolación 243 Modos de WorkVisual 12

N Nombres de datos 62 Número de mensaje 116

Tiempo de ciclo 185 Tipo de datos de enumeración 98 Tipos de cálculo básicos 82 Transferencia de parámetros 105 Transmitir el proyecto a la unidad de control del robot (instalar) 18

V Variable, mostrar individual 86 Variables 75, 78 Variables de sistema 185 Vida útil 77 Vista general de la interfaz de usuario WorkVisual 8

W WITH (variables del sistema permitidas) 154, 183

O Operaciones de bit 82 Operaciones de comparación 82 Operaciones lógicas 82 Operario 65 P Palabra clave 77 Parada condicionada 210 PEP 62 Plan de ejecución del programa, PEP 62 Prioridad 85, 190, 208 Programación de movimientos en KRL 141 Programación estructurada 57 Programador 65 Programar un diálogo, ejercicio 139 Programar un mensaje de acuse de recibo, ejercicio 129 Programar un mensaje de espera, ejercicio 132 Programar un mensaje de estado, ejercicio 126 Programar un mensaje de observación, ejercicio 123 Propiedades (ventana) 10

Z Zona de desplazamiento constante 213, 214 Zonas de trabajo (ventana) 9 Ángulo circular 234

R Remitente 116 Return 102, 111 S Salidas analógicas 225 Seleccionar el tipo de mensaje 117 Selección de paso 173 señales analógicas 223 Singularidad, Spline CP 246 Submit 219 Subprogramas 60, 101 Subprogramas, globales 103 Subprogramas, locales 101 Símbolos PEP 62 T Template 35 Temporizador 185 Tensión 226 Texto del mensaje 116 254 / 255




255 / 255

Programación de robots KUKA

Recommend Documents