Recortar: Arriba: 61,5 mm Abajo: 61,5 mm Izquierda: 43,5 mm Derecha: 43,5 mm
Controlador
Descripción Instrucciones de programación Tipo CMXR-C1
Descripción 560 317 es 0805NH [729 225]
Festo GDCP-CMXR-SW-ES es 0805NH 3
Edición ____________________________________________________________ es 0805NH
Designación _________________________________________________ GDCP-CMXR-SW-ES
Nº de art. ____________________________________________________________ 560 317
Festo AG & Co KG., D-73734 Esslingen, 2008
Internet: http://www.festo.com
E-mail: [email protected]
Sin nuestra expresa autorización, queda terminantemente prohibida la reproducción total o parcial de este documento, así como su uso indebido y/o su exhibición o comunicación a terceros. El incumplimiento de lo anterior obliga al pago de indemnización por daños y perjuicios. Quedan reservados todos los derechos inherentes, en especial los de patentes, de modelos registrados y estéticos.
4 Festo GDCP-CMXR-SW-ES es 0805NH
Lista de revisiones
Autor:
Nombre del manual: GDCP-CMXR-SW-ES
Nombre del archivo:
Lugar de almacenamiento del
archivo:
Nº de art. Descripción Indicador de revisión Fecha de modificación
001 Confección es 0805NH 25.06.2008
ÍNDICE
Festo GDCP-CMXR-SW-ES es 0805NH 5
ÍNDICE
1. Introducción ........................................................................................................ 11
2. Medidas de seguridad......................................................................................... 12
2.1 Uso de la documentación................................................................................... 12
2.2 Uso conforme a lo previsto ................................................................................ 12
2.3 Personal cualificado .......................................................................................... 13
2.4 Medidas de seguridad de los productos ............................................................ 13
2.5 Medidas de seguridad sobre este manual .......................................................... 13
2.6 Medidas de seguridad para el producto descrito ............................................... 14
3. Proceso de programas ......................................................................................... 15
3.1 Informaciones generales .................................................................................... 15
3.2 Intérprete .......................................................................................................... 15
3.3 Inicio del programa ............................................................................................ 15
3.4 Avance de proceso............................................................................................. 15
3.5 Estructura de programa ..................................................................................... 17
3.6 Proyectos FTL .................................................................................................... 17
3.6.1 Proyecto FTL global ............................................................................ 18
3.7 Archivo de programa FTL “tip” ........................................................................... 18
3.7.1 Programas compartidos de proyecto .................................................. 19
3.8 Archivo de datos FTL “<nombre>.tid” .................................................................. 19
3.8.1 Datos de programa local .................................................................... 19
3.8.2 Datos compartidos de proyecto .......................................................... 20
3.8.3 Datos compartidos de sistema ........................................................... 20
3.8.4 Instanciación de variables .................................................................. 21
4. Estructura del lenguaje ....................................................................................... 23
4.1 Formateado ....................................................................................................... 23
4.2 Identificadores .................................................................................................. 23
4.3 Palabras clave ................................................................................................... 23
4.4 Constantes numéricas ....................................................................................... 24
4.5 Cadenas de caracteres ....................................................................................... 24
4.6 Operadores y caracteres de delimitación ........................................................... 24
4.6.1 Operadores aritméticos ...................................................................... 24
4.6.2 Operadores lógicos ............................................................................ 25
4.6.3 Operadores comparativos .................................................................. 25
4.6.4 Otros operadores ............................................................................... 25
4.6.5 Caracteres de delimitación ................................................................. 26
ÍNDICE
6 Festo GDCP-CMXR-SW-ES es 0805NH
5. Tipos de datos básicos ........................................................................................ 27
5.1 Tipo de dato booleano (BOOL) ........................................................................... 28
5.2 Tipos de número entero, tipo de dato REAL, tipos de patrón de bits ................... 28
5.3 Cadenas de caracteres (STRING) ........................................................................ 29
5.4 Tipos de datos estructurados ............................................................................ 29
5.5 Matrices ............................................................................................................ 29
6. Declaración de variables ..................................................................................... 30
6.1 Inicialización ...................................................................................................... 30
7. Expresiones ........................................................................................................ 31
7.1 Secuencia de ejecución para expresiones .......................................................... 31
8. Control de programa ........................................................................................... 32
8.1 Instrucciones ..................................................................................................... 32
8.2 Asignación de valor <:=> ..................................................................................... 32
8.3 Condiciones ....................................................................................................... 32
8.4 Bifurcación <IF…THEN> ....................................................................................... 34
8.5 Instrucciones de salto ........................................................................................ 35
8.5.1 Marca de salto <LABEL> ....................................................................... 35
8.5.2 Salto condicional <IF…GOTO> .............................................................. 36
8.5.3 Salto absoluto <GOTO> ....................................................................... 36
8.6 Bucles ............................................................................................................... 36
8.6.1 Instrucción WHILE <WHILE> ................................................................. 37
8.6.2 Instrucción LOOP <LOOP> .................................................................... 37
8.7 Subprogramas ................................................................................................... 38
8.7.1 Llamada de subprograma <CALL> ........................................................ 39
8.7.2 Retorno al programa <RETURN> ........................................................... 40
8.8 Programas paralelos .......................................................................................... 41
8.8.1 Ejecución de programa paralelo <RUN> ............................................... 42
8.8.2 Detención de programa paralelo <KILL> ............................................... 42
8.9 WAIT – Instrucción con tiempo <WaitTime> ......................................................... 42
8.10 Instrucción condicional WAIT <WAIT> .................................................................. 43
8.11 Insertar comentarios <//> ................................................................................... 46
8.12 Desactivar línea de programa <##> ..................................................................... 46
9. Instrucciones de movimiento .............................................................................. 48
9.1 Descripción de la posición ................................................................................. 48
9.1.1 Posición de eje ................................................................................... 49
9.1.2 Posición cartesiana ............................................................................ 51
9.2 Movimiento punto a punto <Ptp> ........................................................................ 52
ÍNDICE
Festo GDCP-CMXR-SW-ES es 0805NH 7
9.3 Movimiento punto a punto <PtpRel> ................................................................... 55
9.4 Movimiento de un eje, <MoveAxisPtp>, <MoveAxisCart> ...................................... 57
9.5 Movimiento lineal <Lin> ...................................................................................... 59
9.6 Movimiento lineal relativo <LinRel> ..................................................................... 61
9.7 Movimiento circular con punto de apoyo ........................................................... 63
9.7.1 Funcionamiento ................................................................................. 63
9.7.2 Definición de planos ........................................................................... 64
9.7.3 Instrucción Circular con punto de apoyo <CircIp> ................................. 66
9.7.4 Instrucción Circular con punto de apoyo, aproximación PTP <PtpToCircIp> .......................................................................................................... 68
9.7.5 Instrucción Circular con punto de apoyo, avance lineal <LinToCircIp> .. 70
9.8 Detención del movimiento <StopMove> .............................................................. 71
10. Instrucciones de dinámica................................................................................... 72
10.1 Velocidades <Vel> ............................................................................................... 72
10.2 Aceleración <Acc> ............................................................................................... 73
10.3 Sacudida <Jerk> .................................................................................................. 74
10.4 Override ............................................................................................................ 76
10.4.1 Override en la unidad manual <Ovr> ................................................... 76
10.4.2 Override dinámico <DynOvr> ............................................................... 77
10.5 Rampas de aceleración ...................................................................................... 78
10.5.1 Ajuste de formas de rampa <Ramp> ..................................................... 79
10.6 Conexión de la velocidad de trayectoria constante <VconstOn> .......................... 80
10.7 Desconexión de la velocidad de trayectoria constante <VconstOff> ..................... 82
11. Márgenes de avance aproximado ........................................................................ 83
11.1 Área extrema ..................................................................................................... 84
11.2 Avance aproximado por velocidad ..................................................................... 85
11.2.1 Con factor porcentual <OvlVel> ............................................................ 85
11.3 Avance aproximado por geometría .................................................................... 87
11.3.1 Avance aproximado de los ejes X, Y y Z <OvlCart> ................................ 87
11.4 Sistemas de referencia (desplazamiento del punto cero) ................................... 89
11.5 Referencia del sistema ....................................................................................... 89
11.6 Datos del sistema de referencia ......................................................................... 90
11.7 Sistema de referencia con valores directos <SetRefSys> ..................................... 91
11.8 Sistema de referencia con tres puntos <SetRefSys3P> ........................................ 92
11.9 Sistema de referencia universal <SetRefSysWorld> ............................................. 93
11.10 Ejemplo ............................................................................................................. 94
ÍNDICE
8 Festo GDCP-CMXR-SW-ES es 0805NH
12. Referenciación de un robot ................................................................................. 96
12.1 Recorrido de referencia <RefAxis> ....................................................................... 96
12.2 Recorrido de referencia asíncrono <RefAxisAsync> .............................................. 98
12.3 Espera al final del recorrido de referencia <WaitRefFinished> ........................... 100
12.4 Interrogación del estado de un eje <IsAxisReferenced> ..................................... 101
13. Herramientas .................................................................................................... 102
13.1 Datos de herramienta ...................................................................................... 102
13.1.1 Datos del vector TCP ........................................................................ 102
13.2 Activación de datos de herramienta <Tool> ....................................................... 105
13.2.1 Efecto de los datos TCP .................................................................... 105
14. Interface PROFIBUS .......................................................................................... 110
14.1 Entradas y salidas booleanas ........................................................................... 110
14.2 Variables del tipo integral de 32 bits ................................................................ 111
14.3 Posiciones ....................................................................................................... 111
14.4 Sistemas de referencia .................................................................................... 113
14.5 Pausa programada <ProgHold> ......................................................................... 114
15. Sistema de comunicación .................................................................................. 116
15.1 Textos de mensaje ........................................................................................... 116
15.2 Información <SetInfo> ....................................................................................... 118
15.3 Advertencia <SetWarning> ............................................................................... 119
15.4 Mensaje de error <SetError> ............................................................................. 120
16. Funciones .......................................................................................................... 121
16.1 Lectura de la posición actual <ReadActualPos> ................................................. 121
16.2 Lectura de la posición de destino <ReadTargetPos> .......................................... 122
16.3 Memorización del valor de posición de manera permanente <SavePosition> .... 123
16.4 Lectura de la fecha y hora del sistema <Time> ................................................... 123
16.5 Conversión de un valor de fecha y hora en texto <TimeToStr> ........................... 124
16.6 Seno <SIN>, <ASIN> ........................................................................................... 125
16.7 Coseno <COS>, <ACOS> ..................................................................................... 126
16.8 Tangente <TAN>, <ATAN> ................................................................................... 128
16.9 Cotangente <COT>, <ACOT> ................................................................................ 129
16.10 Tangente 2 <ATAN2> ......................................................................................... 130
16.11 Logaritmo <LN> ................................................................................................. 130
16.12 Exponente <EXP> .............................................................................................. 130
16.13 Valor absoluto <ABS> ....................................................................................... 131
ÍNDICE
Festo GDCP-CMXR-SW-ES es 0805NH 9
16.14 Raíz cuadrada <SQRT> ...................................................................................... 131
16.15 Desplazamiento de bits <SHR>, <SHL> ............................................................... 132
16.16 Rotación de bits <ROR>, <ROL> .......................................................................... 133
17. Módulos ............................................................................................................ 134
17.1 Funciones ........................................................................................................ 135
17.2 Variables ......................................................................................................... 135
17.3 Comportamiento del tiempo de operación ....................................................... 136
17.3.1 Parámetro ovlEnable ........................................................................ 136
17.4 Subunidad de entrada digital DIN .................................................................... 137
17.4.1 Instanciación .................................................................................... 137
17.4.2 Métodos ........................................................................................... 138
17.4.3 Espera a estado, métodos Wait/WaitN ............................................. 140
17.4.4 Método Read para lectura de estado ................................................ 140
17.4.5 Método RisingEdge para flanco de subida ........................................ 140
17.4.6 Método ResetRisingEdge para borrar flancos ................................... 141
17.5 Subunidad de salida digital DOUT ................................................................... 141
17.5.1 Instanciación .................................................................................... 141
17.5.2 Variables .......................................................................................... 143
17.5.3 Métodos ........................................................................................... 144
17.5.4 Espera a estado, métodos Wait/WaitN ............................................. 145
17.5.5 Método Read para lectura de estado ................................................ 145
17.5.6 Método RisingEdge para flanco de subida ........................................ 145
17.5.7 Borrado de flancos, ResetRisingEdge ............................................... 146
17.5.8 Activación y borrado, métodos Set/Reset ......................................... 146
17.5.9 Activación de la salida, método Write ............................................... 147
17.6 Subunidad de entrada analógica AIN ............................................................... 147
17.6.1 Instanciación .................................................................................... 147
17.6.2 Variables .......................................................................................... 148
17.6.3 Métodos ........................................................................................... 149
17.6.4 Espera a que el valor sea menor/mayor, métodos WaitLss, WaitGrt .. 150
17.6.5 Espera a que el valor entre/salga de un margen, métodos WaitIns, WaitOuts .......................................................................................... 151
17.6.6 Interrogación del valor, método Read ............................................... 151
17.7 Subunidad de salida analógica AOUT .............................................................. 152
17.7.1 Instanciación .................................................................................... 152
17.7.2 Variables .......................................................................................... 153
17.7.3 Métodos ........................................................................................... 154
17.7.4 Escritura del valor de salida, método Write ....................................... 155
17.7.5 Espera a que el valor sea mayor/menor, métodos WaitLss, WaitGrt .. 155
17.7.6 Espera a que el valor entre/salga de un margen, métodos WaitIns, WaitOuts ........................................................................................................ 156
ÍNDICE
10 Festo GDCP-CMXR-SW-ES es 0805NH
17.7.7 Lectura del valor de salida, método Read ......................................... 156
17.8 Subunidad de reloj CLOCK ............................................................................... 157
17.8.1 Instanciación .................................................................................... 157
17.8.2 Métodos ........................................................................................... 158
17.8.3 Puesta en marcha del reloj, método Start ......................................... 159
17.8.4 Parada del reloj, método Stop .......................................................... 159
17.8.5 Borrado del reloj, método Reset ....................................................... 159
17.8.6 Lectura del reloj, método Read ......................................................... 159
17.8.7 Conversión del valor de fecha y hora en cadena de caracteres .......... 160
17.9 Subunidad de encoder ENCODER ..................................................................... 161
17.9.1 Instanciación .................................................................................... 161
17.9.2 Variables .......................................................................................... 162
17.9.3 Métodos ........................................................................................... 163
17.9.4 Ajuste del encoder, método Set ........................................................ 163
17.9.5 Lectura del encoder, método Read ................................................... 164
17.10 Subunidad CANopen COPDEVICE ..................................................................... 165
17.10.1 Instanciación .................................................................................... 165
17.10.2 Métodos ........................................................................................... 166
17.10.3 Escritura de SDO, método WriteSDO ................................................ 166
17.10.4 Lectura de SDO, método ReadSDOSigned ........................................ 167
17.10.5 Lectura de SDO, método ReadSDOUnsigned .................................... 168
18. Señales de periféricos ....................................................................................... 169
18.1 Empleo de las entradas y salidas digitales ....................................................... 169
18.2 Empleo de las entradas y salidas analógicas .................................................... 169
19. Ejemplos ........................................................................................................... 171
19.1 Detención de movimientos .............................................................................. 171
19.2 Empleo de las subunidades de entrada y salida ............................................... 174
19.3 Control del avance de proceso ......................................................................... 175
19.4 Empleo de pinzas ............................................................................................ 176
19.4.1 Pinzas por vacío ............................................................................... 176
19.4.2 Pinzas paralelas neumáticas ............................................................ 180
19.4.3 Unidad giratoria con pinzas neumáticas ........................................... 183
19.5 Empleo de la interface PLC ............................................................................... 187
19.5.1 Tarea ................................................................................................ 187
19.5.2 Interface PLC .................................................................................... 187
19.5.3 Programa secuencial ........................................................................ 188
1. Introducción
Festo GDCP-CMXR-SW-ES es 0805NH 11
1. Introducción En este documento se describe el juego de instrucciones FTL (Festo Teach Language) del
control multieje CMXR con la versión de software 1.0. La programación del control CMXR se efectúa con la unidad manual CDSA-D1-VX o con el plugin CMXR del Festo Configuration Tool (FCT).
Figura 1.1 Control multieje CMXR-C1 de Festo Unidad manual CDSA-D1-VX de Festo
FTL es un lenguaje de programación con un juego de instrucciones concebido para la creación de programas por el usuario de la máquina. De gran simplicidad, este lenguaje permite crear ciclos de máquina sencillos sin necesidad de amplios conocimientos de programación.
2. Medidas de seguridad
12 Festo GDCP-CMXR-SW-ES es 0805NH
2. Medidas de seguridad
2.1 Uso de la documentación
Este documento está concebido para los usuarios y programadores de robots que funcionan con el sistema CMXR de Festo. Existe una introducción al manejo y a la programación. La formación correspondiente del personal es condición previa indispensable.
2.2 Uso conforme a lo previsto
Advertencia
El sistema CMXR de Festo no está diseñado para problemas de control relevantes para la seguridad (p. ej., parada en caso de
emergencia o control de velocidades reducidas).
Conforme a EN-954-1, el sistema CMXR de Festo es sólo de cate-goría B y, por tanto, no es suficiente para realizar funciones de seguridad de protección del personal. Para problemas de control relativos a la seguridad o para la seguri-dad de las personas deberán aplicarse medidas de protección externas que garanticen un estado operativo seguro del sistema completo, incluso en caso de fallo.
En caso de producirse daños como consecuencia de la no observancia de las indicaciones de advertencia, Festo no asume ninguna responsabilidad.
Indicación
Lea enteros los capítulos Medidas de seguridad 2.3 y ss. antes de la puesta en marcha.
Si la documentación en el idioma presentado no se entiende a la perfección, diríjase al proveedor y notifíqueselo.
El funcionamiento perfecto y seguro del sistema de mando requiere un transporte, almacenamiento, montaje e instalación en condiciones adecuadas y profesionales, así como un esmerado manejo y mantenimiento.
2. Medidas de seguridad
Festo GDCP-CMXR-SW-ES es 0805NH 13
2.3 Personal cualificado
Indicación
Los trabajos en los equipos eléctricos únicamente pueden ser llevados a cabo por personal debidamente formado y cualificado.
2.4 Medidas de seguridad de los productos
Advertencia
PELIGRO
Observe las disposiciones en materia de eliminación de residuos especiales al eliminar las baterías gastadas.
Aunque las baterías son de baja tensión, en caso de cortocircuito pueden liberar suficiente corriente como para hacer arder materiales inflamables. Por tanto, no deben eliminarse junto con materiales conductores (como, p. ej., virutas de hierro, lana de acero sucia de aceite, etc.).
ESD
Elementos sensibles a las descargas electrostáticas: estos elemen-tos pueden sufrir daños si no se manejan correctamente.
Advertencia
PELIGRO
Movimientos peligrosos.
Peligro de muerte, lesiones graves y daños materiales por movi-miento accidental de los ejes.
2.5 Medidas de seguridad sobre este manual
Advertencia
PELIGRO
La inobservancia puede tener como consecuencia daños materiales y lesiones físicas graves.
Atención
La inobservancia puede tener como consecuencia daños materiales graves.
2. Medidas de seguridad
14 Festo GDCP-CMXR-SW-ES es 0805NH
2.6 Medidas de seguridad para el producto descrito
Advertencia
PELIGRO
Peligro de muerte por equipos de PARADA DE EMERGENCIA deficientes.
Los equipos de PARADA DE EMERGENCIA deben mantener su eficacia y estar siempre al alcance en todos los modos de funciona-miento de la instalación. El desbloqueo del equipo de PARADA DE EMERGENCIA no debe provocar ningún rearranque incontrolado.
Antes de conectar debe comprobarse primero la cadena de PARADA DE EMERGENCIA.
Advertencia
PELIGRO
Peligro para el personal y el material.
Pruebe todos los programas nuevos antes de poner en marcha la instalación.
Advertencia
PELIGRO
La instalación posterior de componentes y las modificaciones del sistema pueden reducir la seguridad.
Ello puede provocar lesiones físicas y daños materiales o ambien-tales graves. Por tanto, para la instalación posterior de componentes o las modificaciones de la instalación con accesorios de equipo de otros fabricantes debe contarse con la autorización de Festo.
Advertencia
PELIGRO
Peligro por alta tensión.
Los trabajos de mantenimiento deben efectuarse siempre, si no se indica lo contrario, con la instalación desconectada. Para ello, la instalación debe asegurarse contra la reconexión no autorizada o involuntaria.
Si es necesario realizar trabajos de medición o de comprobación en la instalación, éstos deberán ser efectuados por un electricista.
Atención
Sólo deben utilizarse repuestos autorizados por Festo.
3. Proceso de programas
Festo GDCP-CMXR-SW-ES es 0805NH 15
3. Proceso de programas
3.1 Informaciones generales
FTL es la sigla que se obtiene de Festo Teach Language. FTL es un lenguaje de programación
y sirve para programar los controles CMXR.
El FTL es un lenguaje de programación para robótica y sistemas de manipulación muy completo pero fácil de aprender y dominar. Con él, el usuario puede programar de manera orientada a su aplicación. Las instrucciones están formadas por elementos del inglés.
3.2 Intérprete
Los programas FTL no son compilados sino convertidos por un intérprete. Dicho intérprete
lee, al inicio, los programas estructurados en la memoria para procesarlos de manera óptima. Este proceso requiere un breve tiempo de respuesta dependiendo de la longitud del programa. Por esta razón es recomendable cargar el programa antes del inicio para
poder arrancar el programa con rapidez.
3.3 Inicio del programa
Para iniciar un programa éste debe cargarse primero en el proyecto correspondiente. La carga puede efectuarse mediante la unidad manual o a través de un control externo mediante una interface de control.
Indicación
Sólo puede cargarse un único proyecto de usuario. Además, el proyecto de sistema global está siempre cargado.
La ejecución del programa comienza, tras la señal de arranque, en la posición actual del contador de programa.
Si el contador de programa se encuentra en la última línea del programa secuencial, el programa termina pero permanece cargado. Si durante la secuencia deben arrancarse programas paralelos, el programa principal permanece activo hasta que éstos terminan.
3.4 Avance de proceso
Para conseguir un proceso rápido del programa, el intérprete calcula un número de
instrucciones de movimientos por adelantado. El cálculo por adelantado se realiza en marcha al mismo tiempo que se ejecuta el programa y se trata en el sistema. La magnitud del avance de proceso, es decir, el número de instrucciones de movimiento calculado por adelantado, está guardada en el sistema.
3. Proceso de programas
16 Festo GDCP-CMXR-SW-ES es 0805NH
Indicación
El avance de proceso hace referencia a las instrucciones de movi-miento. Otras instrucciones situadas entre las instrucciones de movimiento como, p. ej., la modificación de valores dinámicos o la modificación de variables, no se ven afectadas.
En este avance de proceso se descodifican las instrucciones de FTL y se preparan para los cálculos posteriores. Además, también se planifica la trayectoria del movimiento, calculada a partir de los valores dinámicos ajustados.
Con algunas instrucciones del FTL es posible influir en el avance de proceso, es decir, éste puede detenerse en determinadas circunstacias. Ello puede darse, p. ej., en caso de la bifurcación de un programa donde se decide por señales de entrada de los periféricos. Si el avance de proceso se detiene, el conjunto de instrucciones calculado por adelantado se
procesa y la cinemática detiene el movimiento. Después se calcula la decisión de la bifurcación del programa y se ejecutan las instrucciones de movimiento siguientes.
Indicación
La detención del avance de proceso mediante la instrucción corre-spondiente puede provocar, en ocasiones, paradas indeseadas en la trayectoria. Con este tipo de instrucciones no es posible el avance aproximado de los movimientos.
La figura muestra un extracto de un programa FTL. La flecha superior indica la instrucción actual que se está ejecutando. La flecha inferior marca la instrucción activa del cálculo por adelantado de proceso. La distancia entre las dos flechas es el avance de proceso.
Más información y ejemplos sobre el avance de proceso se describen en el capítulo 19.3 Control del avance de proceso.
Lin(Pos1)
Lin(Pos2)
Lin(Pos3)
Lin(Pos4)
Lin(Pos5)
Lin(Pos6)
Lin(Pos7)
Lin(Pos8)
Lin(Pos9)
Proceso principal
Avance de proceso
3. Proceso de programas
Festo GDCP-CMXR-SW-ES es 0805NH 17
3.5 Estructura de programa
Todos los programas FTL están guardados en la tarjeta de memoria (Compact Flash Card) del control multieje CMXR en el directorio application\control\teachcontrol (en adelante denominado directorio de aplicación de texto). Los programas se disponen en una estruc-tura de carpetas. Un proyecto contiene los programas de movimientos asignados. El número de proyectos y programas está limitado por el tamaño de la tarjeta de memoria.
Estructuras de programa:
3.6 Proyectos FTL
Un proyecto FTL se guarda como subdirectorio en el directorio de aplicación. El nombre de directorio es el título del proyecto y tiene la extensión “tt”.
Ejemplos de títulos de proyecto:
Proyecto “_global”
Proyecto “cube”
Proyecto “PickPlace”
3. Proceso de programas
18 Festo GDCP-CMXR-SW-ES es 0805NH
En un proyecto se reúnen todos los programas FTL. Por tanto, todos los programas son
elementos de un proyecto. No está permitido crear más subdirectorios dentro de un directorio de proyecto.
Indicación
La estructura y administración de proyecto se generan y gestionan automáticamente mediante el software gráfico de la unidad manual y el editor del software FCT.
3.6.1 Proyecto FTL global
Además de todos los proyectos FTL, existe un proyecto FTL global que recibe el nombre “_global”. Este nombre es fijo y no debe modificarse. El proyecto sirve para todos los proyectos. Todos los datos y programas guardados en él son accesibles desde el resto de
los proyectos. Si es necesario utilizar datos o programas en varios proyectos, éstos se guardan en el proyecto global. De ese modo se garantiza la coherencia de datos.
El proyecto global “_global" se carga y activa automáticamente al arrancar el CMXR.
3.7 Archivo de programa FTL “tip”
Todos los programas FTL que pertenecen a un proyecto se guardan en el directorio de proyecto asignado. Un programa se compone del código de programa y de los datos correspondientes. Éstos se guardan en archivos diferentes con el mismo nombre pero con una extensión diferente (file extension):
<nombre>.tip Extensión de archivo para código de programa.
<nombre>.tid Extensión de archivo para datos de programa.
Ejemplo:
Para un programa con el nombre “Load” se crea el archivo “Load.tip”. El nombre del archivo de los datos locales de programa se denomina “Load.tid”.
Si el programa se guarda mediante la unidad manual CDSA o mediante el editor de pro-gramación de Festo (en el Festo Configuration Tool), el archivo de datos locales de pro-grama se genera automáticamente. Si la generación de programa se efectúa con otro software, debe observar que se guarde el archivo de datos correspondiente para cada programa.
Indicación
Si el programa se genera mediante un software de otra marca debe observarse que se mantenga la convención de designación de los archivos.
3. Proceso de programas
Festo GDCP-CMXR-SW-ES es 0805NH 19
3.7.1 Programas compartidos de proyecto
El proyecto compartido de sistema “_global” puede contener programas además de datos.
Dichos programas pueden ser utilizados por todos los programas en todos los proyectos.
Los programas compartidos de sistema destacan por su gran utilidad. Así, los programas que dependen de la cinemática utilizada pueden definirse y guardarse independientemente de los proyectos de aplicación. Si una cinemática no posee posiciones fijas, como, p. ej., una posición de seguridad, el desplazamiento a esta posición puede guardarse una vez en el proyecto global.
3.8 Archivo de datos FTL “<nombre>.tid”
En el sistema de mando CMXR, los datos sirven como variable y para la comunicación. La
estructura de proyecto permite guardar los datos de una manera clara y limitar el acceso a
ellos. Un archivo de datos se reconoce por la extensión de archivo “tid” y, como el archivo de programa, está basado en texto. En el sistema puede haber:
Datos locales de programas dentro de los programas individuales.
Datos compartidos de proyecto para cada proyecto.
Datos compartidos de sistema para todos los proyectos.
Esta distribución permite seleccionar quién tiene acceso a los datos. La comunicación entre los programas o los proyectos se puede controlar también de este modo. Con datos compartidos de proyecto puede comunicarse entre programas, y con datos compartidos de sistema entre los proyectos.
3.8.1 Datos de programa local
Los datos de programa local son conocidos únicamente dentro del programa. Otros
programas o proyectos no tienen acceso a estos datos.
Indicación
Los datos de programa local son conocidos y válidos únicamente dentro del programa. Otros programas o proyectos no tienen acceso a estos datos.
En la figura siguiente se muestran los programas “Fill” y “Sort”. Cada uno de estos
programas posee datos locales y datos de programa guardados en los archivos correspondientes.
3. Proceso de programas
20 Festo GDCP-CMXR-SW-ES es 0805NH
3.8.2 Datos compartidos de proyecto
Con datos compartidos de proyecto puede comunicarse entre cada uno de los programas dentro de un proyecto. Otros programas fuera del proyecto correspondiente no tienen acceso a estos datos.
Los datos compartidos de proyecto se guardan en un archivo propio con el nombre “_globalvars.tid”. Si un proyecto se guarda mediante la unidad manual CDSA o con el editor de programación FTL, este archivo de datos compartidos de proyecto se crea automáticamente. Si la generación de programa se efectúa con otro software, p. ej., con software de programación del cliente, debe observar que se cree este archivo de datos.
Indicación
Si el programa se genera mediante un software de otra marca debe observarse que se cree el archivo “_globalvars.tid” en el directorio de proyecto.
En la figura siguiente se muestran los proyectos “FillPalett” y “FeedParts”. Cada uno de estos proyectos dispone de datos compartidos de proyecto guardados en el archivo “_globalvars.tid” y en el directorio de proyecto.
3.8.3 Datos compartidos de sistema
Los datos compartidos de sistema son conocidos en todo el sistema en todos los programas de todos los proyectos. Estos datos compartidos de sistema están asignados al proyecto global “_global” y guardados dentro de él en el archivo de datos “_globalvars.tid”.
Indicación
Como todos los programas tienen acceso a los datos compartidos de sistema, estos datos deben utilizarse con cuidado. Compruebe que varios programas no puedan acceder simultáneamente a estos datos. Si es necesario, bloquéelos con las medidas necesarias en la aplicación.
3. Proceso de programas
Festo GDCP-CMXR-SW-ES es 0805NH 21
En la figura siguiente se muestra el proyecto global “_global” enlazado con datos compar-
tidos de proyecto y locales. Además, en el área de objetos compartidos de sistema también se muestran programas compartidos de sistema.
3.8.4 Instanciación de variables
Las variables se declaran de la manera siguiente dentro del archivo de datos “<nombre>.tid":
Sintaxis
<nombre de variable> : <tipo de variable> := <valor>
El usuario puede elegir el nombre de las variables. En todo caso, sólo es posible crear una variable por línea.
Ejemplo:
cpos1 : CARTPOS := (100, 50, 100, 0, 0, 0)
cpos2 : CARTPOS := (600, 550, 100, 180, 0, 0)
índice : DINT := 17
Los tipos de variables posibles se describen en los capítulos siguientes.
3. Proceso de programas
22 Festo GDCP-CMXR-SW-ES es 0805NH
Atención
Los valores de variables que se modifican en el programa durante el tiempo de ejecución no se escriben en el archivo de datos de la tarjeta de memoria y sólo se mantienen mientras que el proyecto/ programa está cargado. Al descargar el proyecto/programa o en caso de caída de tensión de alimentación se pierden los datos modificados en el programa.
Indicación
Para guardar de manera permanente los valores de posición en la tarjeta de memoria puede utilizarse la macro “SavePosition”.
4. Estructura del lenguaje
Festo GDCP-CMXR-SW-ES es 0805NH 23
4. Estructura del lenguaje
4.1 Formateado
Los archivos FTL son archivos de texto legibles. Los comandos o declaraciones se separan por retornos de carro. Por lo general se diferencia entre mayúsculas y minúsculas.
4.2 Identificadores
Los identificadores sirven para identificar proyectos, programas, subunidades, variables, constantes y tipos. Un identificador es una secuencia de letras, cifras y el símbolo “_”.
Indicación
Los símbolos permitidos son a…z, A…Z, 0…9 y _ (guión bajo). Todos los demás símbolos son inadmisibles.
Los identificadores distinguen entre mayúsculas y minúsculas, es decir, las variables deben escribirse siempre igual (con las mismas mayúsculas o minúsculas).
Ejemplo:
Una variable con el identificador “Índice” no es la misma que las variables con el identifi-cador “ÍNDICE”. En este caso se trata de dos variables distintas.
Indicación
A diferencia de los identificadores, los nombres de programa y los títulos de proyecto no distinguen entre mayúsculas y minúsculas.
4.3 Palabras clave
Las palabras clave forman parte del lenguaje FTL. Todas las palabras clave de FTL se escriben en mayúscula y no deben utilizarse como nombre de programas, variables ni tipos.
Lista de todas las palabras clave:
CALL IF THEN END_IF ELSIF ELSE
GOTO LABEL WHILE DO END_WHILE LOOP
END_LOOP RETURN RUN KILL OR XOR
MOD AND NOT BOOL DINT DWORD
REAL STRING
El resto de tipos de datos creados a partir de estas claves también son palabras clave.
4. Estructura del lenguaje
24 Festo GDCP-CMXR-SW-ES es 0805NH
4.4 Constantes numéricas
Se diferencia entre números enteros y reales. Los enteros pueden escribirse en represen-tación decimal, binaria o hexadecimal.
Ejemplos de números enteros válidos:
Notación decimal 100 -100
Notación binaria 2#1010 -2#1010
Notación hexadecimal 16#1ABF -16#1ABF
Los números reales (valores en coma flotante) pueden representarse con coma decimal o con notación exponencial. Los valores con coma decimal deben poseer como mínimo una
posición tras la coma.
Ejemplos de números reales válidos:
Notación decimal: 1.01 178.473
Notación exponencial: 1.99E4 1.99e+8 1e-8
4.5 Cadenas de caracteres
Las cadenas de caracteres, los denominados strings, se abren y cierran con el carácter ". Pueden incluir todos los caracteres imprimibles. La longitud de una cadena está limitada a 255 caracteres. Son válidos todos los caracteres ASCII.
Ejemplo de una cadena de caracteres válida:
“Control multieje CMXR-C1”
4.6 Operadores y caracteres de delimitación
Los operadores se utilizan en expresiones y describen cómo conectar los valores de variables y las constantes numéricas. Normalmente, los operadores se representan con caracteres especiales y palabras clave.
4.6.1 Operadores aritméticos
Operadores Significado
+ Adición
- Sustracción
* Multiplicación
/ División
MOD Módulo operación
Tabla 4.1 Operadores aritméticos
4. Estructura del lenguaje
Festo GDCP-CMXR-SW-ES es 0805NH 25
4.6.2 Operadores lógicos
Estos operadores pueden utilizarse en valores de verdad y en números enteros. Con los números enteros funcionan en bits.
Operadores Significado
AND Operación Y
OR Operación O
XOR Operación O de disyunción
NOT Negación
Tabla 4.2 Operadores lógicos
4.6.3 Operadores comparativos
Operadores Significado
< Menor que
<= Menor o igual que
= Igual a
<> No igual a
>= Mayor o igual que
> Mayor que
Tabla 4.3 Operadores comparativos
4.6.4 Otros operadores
Operadores Significado
. Operador punto para acceder a los elementos de la
estructura
[ ] Operadores corchetes para acceder a matrices
( ) Paréntesis para, p. ej., listas de parámetros
Tabla 4.4 Otros operadores
4. Estructura del lenguaje
26 Festo GDCP-CMXR-SW-ES es 0805NH
4.6.5 Caracteres de delimitación
Operadores Significado
:= Asignación de valor para variables
: Carácter se separación para instanciar variables
, Carácter de enumeración en listas de parámetros para
llamar a funciones o macros
Tabla 4.5 Caracteres de delimitación
5. Tipos de datos básicos
Festo GDCP-CMXR-SW-ES es 0805NH 27
5. Tipos de datos básicos FTL soporta cinco tipos de datos:
Datos booleanos Números enteros Patrones de bits Números variables de coma flotante Cadenas de caracteres
Dentro de estos cinco tipos de datos se derivan tipos de datos elementales en FTL.
En función del significado del tipo de dato se realiza una asignación para un margen de valores determinado y las operaciones correspondientes.
Tipo de dato Interpretación Capacidad de memoria Margen de valores
BOOL Bit 8 bits TRUE o FALSE
DINT Número entero 32 bits -2.147.483.648 … +2.147.483.647
DWORD Patrón de bits 32 bits 32 bits
REAL Número variable de coma
flotante
32 bits Conforme a IEEE
STRING Cadena de caracteres Máx. 255 bytes Máx. 255 caracteres
Tabla 5.1 Tipos de datos básicos
Según el tipo de dato es posible efectuar operaciones distintas.
Tipo de dato Operaciones
BOOL Operaciones lógicas AND, OR, XOR, NOT
DINT Operaciones aritméticas, operaciones de comparación
DWORD Operaciones de bits AND, OR, XOR, NOT, SHL, SHR, ROL, ROR, =, <>
REAL Operaciones aritméticas, operaciones de comparación
STRING Operaciones de comparación, +
Tabla 5.2 Operaciones posibles
En principio, para asignar valores, los tipos de datos deben ser equivalentes. Sin embargo,
FTL soporta también parcialmente la asignación de tipos de datos diferentes. En este caso se realiza una conversión de tipo automática.
De\a BOOL Números enteros
Patrón de bits REAL STRING
BOOL Sí --- --- --- ---
Números enteros --- Sí Sí Sí ---
Patrón de bits --- Sí Sí --- ---
REAL --- Sí --- Sí ---
STRING --- --- --- --- Sí
Tabla 5.3 Asignaciones posibles
5. Tipos de datos básicos
28 Festo GDCP-CMXR-SW-ES es 0805NH
5.1 Tipo de dato booleano (BOOL)
El tipo de dato booleano tiene el valor TRUE o FALSO. Se utiliza sobre todo para operaciones lógicas y también en combinación con señales de periféricos, p. ej., entradas de sensores y salidas de actuadores.
Ejemplo:
Variables:
pos1ocupada : BOOL
pos2ocupada : BOOL
pos3ocupada : BOOL
mín1posLibre : BOOL
todasLibres : BOOL
Código de programa:
todasLibres := NOT pos1ocupada AND NOT pos2ocupada AND
NOT pos3ocupada
min1posLibre := pos1ocupada XOR pos2ocupada XOR pos3ocupada
5.2 Tipos de número entero, tipo de dato REAL, tipos de patrón de bits
El lenguaje de programación FTL soporta enteros, tipos de datos de números variables de coma flotante y de patrones de bits. Según el caso pueden asignarse entre sí estos tipos de datos (véase el capítulo 5 Tipos de datos básicos en la página 27). Con este modelo de asignación, el sistema convierte los tipos de manera interna automáticamente.
Según la clase de conversión de tipos, puede perderse en precisión, p. ej., para convertir de REAL a DINT, el sistema elimina las posiciones decimales.
Ejemplos de conversiones de tipos:
Variables:
presión : REAL
índice : DINT
Código de programa:
presión := 1.53
índice := presión // Conversión REAL->DINT
La variable “índice” recibe el valor “1” después de la conversión.
5. Tipos de datos básicos
Festo GDCP-CMXR-SW-ES es 0805NH 29
Indicación
Las conversiones de tipos sólo deben utilizarse cuando la conse-cuencia está perfectamente clara (véase el ejemplo más arriba).
5.3 Cadenas de caracteres (STRING)
Las cadenas de caracteres se describen con el tipo de dato STRING. La longitud de una cadena está limitada a 255 caracteres. Las cadenas de caracteres, también denominadas strings, pueden asignarse entre sí y conectarse fácilmente con ayuda del operador +.
Ejemplo:
Variable:
textoMensaje : STRING
pieza : STRING
Código de programa:
textoMensaje := “cilindro “
pieza := “DNC “
textoMensaje := textoMensaje + pieza + “ha arrancado“
5.4 Tipos de datos estructurados
Por tipos de datos estructurados se entiende una agrupación fija de tipos de datos básicos en un tipo de dato nuevo.
Los tipos de datos estructurados no pueden crearse a nivel de usuario. Éstos (sólo) se
utilizan como tipos de datos en instrucciones FTL. Una aplicación es, p. ej., la represen-tación de posiciones. Con el tipo de dato “AXISPOS” se describe una posición de eje compuesta por seis variables del tipo de dato básico REAL en una secuencia determinada. Véase el capítulo 9.1 Descripción de la posición en la página 48.
5.5 Matrices
Las matrices se utilizan para agrupar tipos de datos iguales en una unidad ordenada. El acceso a cada uno de los elementos de la matriz se realiza con un índice.
No es posible crear matrices a nivel de usuario. Éstas se utilizan, p. ej., dentro de la inter-face PLC.
6. Declaración de variables
30 Festo GDCP-CMXR-SW-ES es 0805NH
6. Declaración de variables La declaración de variables se efectúa en los archivos correspondientes con la extensión “tid”. En ellos se fija el nombre de la variable y el tipo de dato. El nombre y el tipo de dato se separan entre sí con dos puntos.
Sintaxis
<nombre> : <tipo>
Ejemplos de declaraciones de variable válidas:
offset : REAL
flag : BOOL
índice : DINT
nombre : STRING
6.1 Inicialización
Todas las variables FTL se inicializan automáticamente. Las variables de números enteros y las variables reales se inicializan con 0, las cadenas de caracteres (strings) con una cadena vacía "" y la variable booleana con FALSE.
Además de la inicialización automática también es posible inicializar variables con un valor determinado. Ello también se denomina inicialización explícita. El valor inicial se introduce según la indicación de tipo en forma de asignación en el archivo de datos. Las variables
reales también pueden inicializarse con valores enteros.
Ejemplo de inicializaciones válidas:
índice : DINT := 1
pi : REAL := 3.1415
radio : REAL := 10
flag : BOOL := TRUE
mensaje : STRING := "Hola"
7. Expresiones
Festo GDCP-CMXR-SW-ES es 0805NH 31
7. Expresiones Una expresión describe un valor asignado a un tipo de dato determinado. Una expresión puede contener variables y funciones. Las partes integrantes de una expresión se conectan con operadores.
valor := SQRT(a) – 2*a*b + SQRT(b)
7.1 Secuencia de ejecución para expresiones
Los operadores de una expresión se procesan en una secuencia determinada:
1. [] (Índice de matriz)
2. NOT (Negación)
3. * / MOD AND (Multipl., división, módulo, Y lógico)
4. + - OR XOR (Adición, sustracción, O/EXOR lógicos)
5. < <= = <> >= > (Operaciones de comparación)
8. Control de programa
32 Festo GDCP-CMXR-SW-ES es 0805NH
8. Control de programa
8.1 Instrucciones
Los programas FTL se componen de una sucesión de instrucciones separadas por retornos de carro. Instrucciones reconocidas por el FTL:
1. Asignación de valor
2. Bifurcaciones: IF, IF .. GOTO, GOTO .. LABEL, RETURN
3. Bucles: WHILE, LOOP
4. Ejecución de rutinas: CALL, llamada a macro, RUN, KILL
5. Instrucción de sincronización: WAIT
8.2 Asignación de valor <:=>
La asignación de valor se compone de un carácter de variable a la izquierda del operador, el propio operador de asignación := y una expresión a la derecha del operador. El tipo de
dato de la expresión debe poder asignarse al tipo de dato de la variable.
Sintaxis
<variable > := <expresión>
Ejemplos:
i := 1
x := a + b * 2
8.3 Condiciones
Dentro de instrucciones, bifurcaciones o bucles es posible formular condiciones. Éstas pueden contener operandos booleanos (p. ej., AND, OR) o un operando comparativo (p. ej., >, <=,=). Para formular una condición es importante tener en cuenta que los operandos comparativos sólo pueden realizar un enlace. Si se necesitan más enlaces, éstos deberán efectuarse mediante varias instrucciones. Los operandos booleanos permiten establecer varios enlaces en una instrucción.
Para los ejemplos siguientes se van a utilizar las variables indicadas a continuación:
marcador : BOOL
flag1 : BOOL
flag2 : BOOL
flag3 : BOOL
8. Control de programa
Festo GDCP-CMXR-SW-ES es 0805NH 33
índice : DINT
Ejemplos de condiciones permitidas:
marcador := índice < 10
marcador := flag1 AND flag2 OR flag3
IF índice < 10 THEN
:
END_IF
WHILE índice < 5 DO
:
END_WHILE
WHILE NOT flag1 AND flag3 OR flag2 DO
:
END_WHILE
Ejemplos de condiciones no permitidas:
marcador := índice < 10 AND índice < 0
marcador := flag1 AND índice < 7
IF índice < 10 AND índice > 5 THEN
:
END_IF
Indicación
No está permitido utilizar varios enlaces con operandos compara-tivos dentro de una condición.
Ejemplo para programar una condición con varios enlaces:
flag1 := índice < 10
flag2 := índice > 0
IF flag1 AND flag2 THEN
:
END_IF
8. Control de programa
34 Festo GDCP-CMXR-SW-ES es 0805NH
8.4 Bifurcación <IF…THEN>
La instrucción IF permite realizar bifurcaciones dependientes de condiciones en la ejecución del programa. La condición debe ser del tipo de dato BOOL y puede estar compuesta por varios operandos. Con la instrucción ELSIF pueden formularse varias condiciones. Con la instrucción ELSE es posible definir instrucciones que pueden saltarse si las condiciones no son pertinentes. La instrucción IF se cierra con la instrucción END_IF.
Sintaxis
IF <condición> THEN
<instrucciones>
ELSIF <condición> THEN
<instrucciones>
ELSE
<instrucciones>
END_IF
La instrucción ELSEIF puede aparecer varias veces.
Ejemplo:
Un equipo de medición emite dos señales que admiten evaluación de calidad.
piezaOk Señal de pieza buena
piezaMala Señal de pieza desechable
En el ejemplo de FTL siguiente se introduce una bifurcación al detectar una pieza buena o una pieza desechable. Si las señales no están definidas, es decir, las dos señales tienen el estado TRUE o FALSE, se avanza a la posición PosStart.
IF piezaOk AND NOT piezaMala THEN // Pieza buena
Lin(pos12)
Lin(pos13)
ELSIF NOT piezaOk AND piezaMala THEN // Pieza desechable
Lin(pos3)
Lin(pos4)
ELSE
Lin(posStart) // Ningunas señales definidas
END_IF
8. Control de programa
Festo GDCP-CMXR-SW-ES es 0805NH 35
8.5 Instrucciones de salto
En los programas FTL debe efectuarse saltos con frecuencia. Estos saltos pueden ser condicionales o incondicionales. Para realizar un salto, se requiere un punto inicial y un destino.
Indicación
El destino del salto debe situarse dentro del programa activo. No está permitido realizar un salto dentro de un bloque de instruc-ciones con IF..THEN, WHILE ni LOOP. Sin embargo, sí es posible saltar desde un bloque de instrucciones semejante.
8.5.1 Marca de salto <LABEL>
Una marca de salto debe declararse como destino de un salto. La marca de salto se componen de un nombre que puede ser elegido por el usuario. La marca de salto es inequívoca y sólo debe aparecer una vez dentro de un programa. Para que el sistema detecte una marca de salto, la palabra clave LABEL se coloca delante.
Sintaxis
LABEL <marca de salto>
Con las instrucciones de salto descritas a continuación puede saltarse a la marca de salto.
:
Lin(pos15)
Lin(pos16)
Lin(pos5)
Lin(pos6)
:
IF teilOk GOTO lblHome
LABEL lblHome
Condiciòn de salto
Destino de salto
8. Control de programa
36 Festo GDCP-CMXR-SW-ES es 0805NH
Indicación
Para programar con TeachView debe definirse primero el destino del salto (LABEL). La instrucción GOTO no puede programarse hasta ese momento.
8.5.2 Salto condicional <IF…GOTO>
Con la instrucción IF…GOTO se ejecutan saltos condicionales. Esta instrucción requiere, como la bifurcación del programa IF…THEN, una condición que debe cumplir el tipo de dato BOOL.
Sintaxis
IF <condición> GOTO <marca de salto>
Si la condición se cumple, es decir, si el resultado es TRUE, se ejecuta el salto. Si la con-dición no se cumple, es decir, si el resultado es FALSE, se ejecutan las instrucciones de las siguientes líneas de programa.
8.5.3 Salto absoluto <GOTO>
A diferencia de la instrucción de salto condicional IF…GOTO, la instrucción GOTO es absoluta. Ello significa que no hay instrucción condicional.
Sintaxis
GOTO <marca de salto>
Con la instrucción GOTO pueden saltarse partes del programa con gran facilidad. Ésta es apropiada para saltar desde bucles de programa.
Indicación
Para programar con TeachView debe definirse primero el destino del salto (LABEL). La instrucción GOTO no puede programarse hasta ese momento.
8.6 Bucles
Los bucles son instrucciones del programa que repiten una parte definida del mismo de manera condicional o incondicional. Con ellos es posible abreviar considerablemente los programas dependiendo de la tarea, p. ej., extracción de piezas de una paleta cuyas posiciones pueden calcularse partiendo de la disposición conocida.
8. Control de programa
Festo GDCP-CMXR-SW-ES es 0805NH 37
Atención
La programación de bucles sin fin puede reducir el comportamiento de operación del control CMXR. Los bucles sin fin deben poseer instrucciones como Wait o WaitTime para no bloquear el control CMXR.
8.6.1 Instrucción WHILE <WHILE>
La instrucción WHILE sirve para repetir una secuencia de instrucciones si se cumple una condición. El resultado de la condición del bucle debe ser del tipo de dato BOOL. El bucle puede contener un número ilimitado de instrucciones. La instrucción WHILE se cierra con la palabra clave END_WHILE.
Indicación
Si un bucle va a pasar con mucha frecuencia y no contiene instruc-ciones WAIT, puede entorpecer la ejecución de otros programas FTL. En un caso así, por lo general el control está configurado para activar una advertencia y detener brevemente el programa no cooperativo.
Sintaxis
WHILE <condición> DO
<instrucciones>
END_WHILE
Ejemplo:
WHILE índice < 5 DO
Lin(pos1)
Lin(pos2)
Lin(pos3)
índice := índice + 1
END_WHILE
8.6.2 Instrucción LOOP <LOOP>
La instrucción LOOP sirve para repetir una secuencia de instrucciones. El usuario puede
introducir directamente el número de repeticiones de las instrucciones. Para cada instruc-ción LOOP se crea automáticamente una variable de bucle interna que se inicializa a 1 al ejecutar el bucle. El bucle se ejecuta hasta que el valor de las variables de bucle internas supera el valor final. Si el valor final es inferior a 1, el bucle no se ejecuta sino que se salta. Después de cada pasada, el valor de las variables de bucle suma uno y el valor final se calcula de nuevo.
El bucle puede contener un número ilimitado de instrucciones.
8. Control de programa
38 Festo GDCP-CMXR-SW-ES es 0805NH
Sintaxis
LOOP <número> DO
<instrucciones>
END_LOOP
Ejemplos:
LOOP 10 DO // 10 pasadas
índice := índice + 13
END_LOOP
j := 0
...
LOOP j DO // se salta ya que j = 0
índice := índice + 13
END_LOOP
:
8.7 Subprogramas
En un programa pueden llamarse a otros programas. Estos programas deben encontrarse en el mismo proyecto que el programa activo o en el proyecto global (_global, véase el capítulo 3.6.1 Proyecto FTL global en la página 18). Los programas llamados se denominan
subprogramas.
Indicación
Un subprograma no requiere ningún identificador especial, se crea de la misma manera que cualquier otro programa y se guarda en un proyecto. La diferencia entre programa y subprograma radica en que este último se activa desde un programa y no directamente desde el proyecto.
Proceso:
Mientras se procesa el subprograma, el programa que lo ha llamado espera a que acabe. Al finalizar el subprograma se retorna automáticamente al programa superior, que se reanuda.
8. Control de programa
Festo GDCP-CMXR-SW-ES es 0805NH 39
Esquema de secuencias:
En este ejemplo, el programa “feed” llama al subprograma “movehome”. Si el programa “movehome” ha finalizado el proceso, el programa “feed” reanuda su operación.
Ventajas:
La creación de programas con subprogramas permite programar de una manera clara y eficiente. El código de programa para tareas parciales se guarda por separado y puede ser utilizado por varios programas. Ello mejora el mantenimiento y la coherencia de los pro-
gramas.
8.7.1 Llamada de subprograma <CALL>
El subprograma se llama con la instrucción CALL. No es posible transferir parámetros de programa al subprograma. Si es necesario transferir datos, esto deberá efectuarse a través de las variables globales. La llamada suministra los valores correspondientes para estas variables y se procesan dentro del subprograma.
No es posible realizar llamadas recursivas de programas. Por tanto, un programa no se puede llamar a sí mismo. Además, tampoco es posible llamar al programa que está llamando.
Sintaxis
CALL <nombre del programa> ( )
Subprograma
Programa principal
8. Control de programa
40 Festo GDCP-CMXR-SW-ES es 0805NH
Ejemplo:
:
variante := 17 // Variable para el programa Pegar
sentidoDerecho := TRUE // Variable para el programa Pegar
sentidoIzquierdo := FALSE // Variable para el programa Pegar
CALL Pegar() // Subprograma Pegar
CALL FahreStart() // Unterprogramm fahre Startposition
:
8.7.2 Retorno al programa <RETURN>
En principio, un subprograma termina con la última instrucción. La instrucción RETURN sirve para terminar un subprograma antes de la última instrucción. Con ella se termina el subprograma antes de tiempo y se retorna al programa que ha efectuado la llamada para su reanudación.
Sintaxis
RETURN
Con la instrucción RETURN no es posible devolver los valores al programa de nivel superior. Si fuese necesario transmitir esta información, puede utilizar las variables correspondientes.
Indicación
Si la instrucción RETURN se ejecuta en el programa principal, éste se detiene y termina.
Al llamar a RETURN en un programa paralelo o en un subprograma, éstos terminan. El programa principal se reanuda.
Ejemplo:
:
CALL VerificarPieza()// Llamar al subprograma VerificarPieza
IF NOT piezaOk THEN
estadoPieza := 10 // Variable global para el valor de retorno
RETURN // Adelanto del fin de programa
END_IF
Lin(pos3)
:
8. Control de programa
Festo GDCP-CMXR-SW-ES es 0805NH 41
8.8 Programas paralelos
Un programa del proyecto activo o del proyecto global también puede iniciarse como proceso paralelo. El sistema operativo del CMXR se encarga del proceso en paralelo de estos programas gracias al sistema interno multitarea.
Indicación
Las instrucciones de desplazamiento en una cinemática sólo son posibles en un programa paralelo si un programa principal no ha dado una instrucción de desplazamiento. Si la instrucción de desplazamiento se realiza desde un programa principal o paralelo, el sistema genera un error.
Aplicación:
Los programas paralelos permiten crear procesos asíncronos o de sincronía parcial con el programa principal. Un ejemplo es el control de una unidad de alimentación de piezas o de expulsión controlada con entradas/salidas. En este caso, la secuencia puede describirse con instrucciones lógicas y el procesamiento de las entradas/salidas. Según el requerimiento, una sincronización con el programa principal puede realizarse mediante variables globales.
Esquema de secuencias:
En este ejemplo, el programa “feed” llama al programa paralelo “calculate”. El programa “calculate” espera primero a una señal e incrementa el contador con una unidad. Mientras tanto, el programa principal “feed” sigue procesando.
Programa paralelo
Programa principal
8. Control de programa
42 Festo GDCP-CMXR-SW-ES es 0805NH
Indicación
Si se programa un bucle sin fin en un programa paralelo, debe gar-antizarse que ello no bloquee la ejecución de los otros programas. El reparto de la capacidad de procesamiento con otros programas se garantiza con una instrucción Wait o WaitTime.
8.8.1 Ejecución de programa paralelo <RUN>
Un programa paralelo se ejecuta con la instrucción RUN. No es posible transferir pará-metros al programa que se va a ejecutar. Para transferir datos pueden utilizarse las variables globales.
Sintaxis
RUN <nombre del programa>
Un programa activo no puede ejecutarse simultáneamente como programa paralelo.
8.8.2 Detención de programa paralelo <KILL>
Un programa paralelo activo puede detenerse y terminarse con la instrucción “KILL” emitida desde el programa que lo ha llamado.
Sintaxis
KILL <nombre del programa>
La instrucción RETURN en programas paralelos también provoca su terminación.
8.9 WAIT – Instrucción con tiempo <WaitTime>
La instrucción WAIT con indicación de tiempo permite programar un tiempo de espera. Este tiempo de espera repercute en el comportamiento de movimiento y fuerza la detención del cálculo por adelantado de proceso, que a su vez para el movimiento. El tiempo de espera empieza a contar una vez ejecutada la instrucción anterior. Transcurrido este tiempo se reanuda el programa.
Sintaxis
WaitTime (<timeMS >: DINT)
8. Control de programa
Festo GDCP-CMXR-SW-ES es 0805NH 43
El tiempo se indica en milisegundos mediante un valor o una variable.
Indicación
Para sincronizar el avance de proceso con el proceso principal, utilice la instrucción WaitTime 0.
Ejemplo:
Un sistema de manipulación equipado con una pinza extrae piezas de una paleta. Para agarrar las piezas con seguridad debe esperarse un tiempo determinado.
Extracto de un programa de movimientos:
:
Lin(pos1) // Avanzar sobre posición de agarre
Lin(pos2) // Avanzar a posición de agarre
Gripper.Set() // Cerrar pinza
WaitTime(70) // Esperar 70 ms de tiempo de agarre
Lin(pos1) // Avanzar sobre posición de agarre
:
Desarrollo del movimiento:
8.10 Instrucción condicional WAIT <WAIT>
La instrucción WAIT condicional permite interrogar estados binarios. Este estado puede estar compuesto por una única variable booleana, una combinación de interrogaciones o una sola interrogación.
Tiempo de espera 70 ms
Tiempo
Velocidad de trayectoria
Pos2 pos2 Pos1
8. Control de programa
44 Festo GDCP-CMXR-SW-ES es 0805NH
El procesamiento de la instrucción WAIT se efectúa en el avance de proceso, es decir cuando
el control CMXR calcula por adelantado. Si la condición no se cumple, el avance de proceso (cálculo por adelantado) se detiene hasta que no se cumple la condición de la instrucción WAIT.
Si el retardo temporal es tan grande que incluso la ejecución principal del programa de
movimientos alcanza la instrucción WAIT, ésta también se detiene y provoca la parada del movimiento. El proceso y el cálculo por adelantado no se reanudan hasta que no se cumple la condición de la instrucción WAIT.
Indicación
Como la interrogación de la condición en el avance de proceso se realiza con éxito, la modificación efectuada por dicho avance después del procesamiento ya no se registra. Para registrar puede forzarse una sincronización con el proceso principal ajustando previamente la instrucción WaitTime (véase el capítulo 8.9 WAIT – Instrucción con tiempo en la página 42).
En la condición de la instrucción WAIT pueden utilizarse los tipos de datos básicos BOOL,
REAL y DINT con operadores lógicos y operadores comparativos. No es posible utilizar los operadores aritméticos ni de bits.
Sintaxis
WAIT <condición>
Lin(pos1)
Lin(pos2)
Lin(pos3)
Lin(pos4)
Lin(pos5)
Wait sensor
Lin(pos6)
Lin(pos7)
Lin(pos8)
Lin(pos9)
Proceso principal
Avance de proceso
Lin(pos1)
Lin(pos2)
Lin(pos3)
Lin(pos4)
Lin(pos5)
Wait sensor
Lin(pos6)
Lin(pos7)
Lin(pos8)
Lin(pos9)
Proceso principal
Avance de proceso
Condición para WAIT cumplida, se reanuda el proceso del avance de proceso.
Si la condición para WAIT no se cumple, el avance de proceso se detiene hasta que se cumple la condición.
8. Control de programa
Festo GDCP-CMXR-SW-ES es 0805NH 45
Ejemplo:
Se van a alimentar piezas en un plano inclinado a un sistema de manipulación. Un sensor digital detecta la presencia de una pieza y el sistema de manipulación puede recogerla a continuación.
El sensor detecta si hay una pieza sobre la bandeja. Si hay una pieza preparada, el sistema de manipulación la recoge.
Extracto de un programa de movimientos:
:
Lin(pos2) // Avanzar sobre pieza
Vacuum.Set() // Vacío conectado
Wait sensor // Esperar a que haya una pieza
Lin(pos1) // Avanzar hasta pieza
Lin(pos2) // Avanzar sobre pieza
Lin(pos3) // Avanzar sobre bandeja
Lin(pos4) // Posar pieza
WaitTime(0) // Esperar a proceso principal
Vacuum.Reset() // Vacío desconectado
Lin(pos3) // Avanzar sobre bandeja
:
Sensor
X
Z
Pinza por vacío
Pieza Bandeja
Pos2
Pos1 Pos3
Pos4
8. Control de programa
46 Festo GDCP-CMXR-SW-ES es 0805NH
Si no hay ninguna pieza sobre la bandeja, el sistema de manipulación espera a la pieza y
el movimiento se detiene. Cuando el sensor indica “Presencia de pieza", el programa se reanuda. Si al arrancar ya hay una pieza, el sistema de manipulación avanza inmediat-amente hasta ella sin interrumpir el movimiento.
8.11 Insertar comentarios <//> Un comentario se abre con la secuencia de caracteres "//". Ésta puede colocarse sola a partir del comienzo de línea o después de una instrucción FTL y cerrar al final de línea.
Sintaxis
// <cualquier texto>
Una instrucción FTL puede comentarse con el carácter de comentario. Esta instrucción no afecta de ningún modo al proceso del programa.
En la figura siguiente se muestra la máscara del programa de la unidad manual con un
comentario y una instrucción del programa con aclaración:
8.12 Desactivar línea de programa <##>
Con la secuencia de caracteres "##" se desactivan las líneas de programa para el proceso del programa pero se conserva la verificación de la sintaxis.
Indicación
## <instrucción de programa>
Ello implica:
Una instrucción FTL no se procesa en el programa, es decir, el contenido no afecta de ningún modo.
8. Control de programa
Festo GDCP-CMXR-SW-ES es 0805NH 47
El contenido de la instrucción de programa se somete a la verificación de la sintaxis del
compilador. Si, p. ej., se borra una variable utilizada, el error se emite al arrancar el programa.
Indicación
En el caso de las instrucciones de programa compuestas por varias líneas, como, p. ej., IF..THEN…ELSE, deben desactivarse todas las líneas de programa correspondientes.
En la figura siguiente se muestra la máscara del programa de la unidad manual con instrucciones del programa desactivas en las líneas 8 a 10:
9. Instrucciones de movimiento
48 Festo GDCP-CMXR-SW-ES es 0805NH
9. Instrucciones de movimiento Los movimientos de una se activan con instrucciones de movimiento. Dichas instrucciones describen el movimiento desde la posición actual al punto de destino indicado. Para el movimiento se tienen en cuenta valores ajustados previamente como, p. ej., la velocidad, la aceleración o la orientación.
Los movimientos son de diferentes tipos. Hay movimientos con interpolación de ejes (movimiento punto a punto) y movimientos en un espacio cartesiano. Los movimientos cartesianos utilizan una transformación interna de la.
9.1 Descripción de la posición
Todas las posiciones se guardan en las denominadas variables de posición. Estas variables de posición son necesarias para indicar las posiciones a las instrucciones de movimiento.
No es posible la indicación directa con constantes. Todas las variables de posición se guardan en el archivo de datos correspondiente (véase el capítulo 3.8 Archivo de datos FTL en la página 19).
Una posición puede introducirse en el sistema de coordenadas de ejes o en un sistema de coordenadas cartesianas. Como estas indicaciones de posición tienen orígenes diferentes, existen dos tipos de datos:
1. AXISPOS para la indicación en el sistema de coordenadas de ejes.
2. CARTPOS para la indicación en el sistema de coordenadas cartesianas.
El número de ejes en CMXR está limitado a seis. Estos ejes pueden distribuirse en ejes cinemáticos y auxiliares. Las posiciones de todos los ejes se guardan en variables de posición.
Así, el tipo de dato AXISPOS 9 contiene valores de coordenadas. Con un límite de seis grados de libertad de movimiento, el tipo de dato CARTPOS contiene asimismo nueve valores de coordenadas divididos en tres indicaciones de posición, tres indicaciones de orientación y tres ejes auxiliares.
El número de valores de coordenadas en el entorno de programación del plugin FCT está limitado al número de los ejes planificados, el resto está bloqueado.
Indicación
Los dos tipos de datos AXISPOS y CARTPOS pueden utilizarse para instrucciones de movimiento. El control CMXR ejecuta conversiones automáticas si es necesario (transformaciones de coordenadas). Para más información consulte la descripción de instrucciones.
Los tipos de datos AXISPOS y CARTPOS son de tipo estructurado (véase el capítulo 5.4 Tipos de datos estructurados en la página 29).
9. Instrucciones de movimiento
Festo GDCP-CMXR-SW-ES es 0805NH 49
9.1.1 Posición de eje
Una posición de eje se describe con el tipo de dato estructurado AXISPOS (véase el capítulo 5.4 Tipos de datos estructurados de la página 29). Éste contiene nueve posiciones de nueve ejes distintos cuyo valor de posición se introduce con el tipo de dato REAL. En función del modelo cinemático seleccionado, los ejes seleccionados pueden ser lineales o rotativos, o una combinación de los dos. La unidad de una posición se indica en mm o en grados.
Estructura:
El número máximo de ejes de una cinemática es de nueve. Por tanto, el tipo de dato con-tiene nueve posiciones de ejes. Estos valores individuales de posición están guardados en nueve variables REAL.
Tipo de dato AXISPOS:
a1 : REAL Posición del eje cinemático 1
a2 : REAL Posición del eje cinemático 2
a3 : REAL Posición del eje cinemático 3
a4 : REAL Posición del eje cinemático 4
a5 : REAL Posición del eje cinemático 5
a6 : REAL Posición del eje cinemático 6
a7 : REAL Posición del eje auxiliar 1
a8 : REAL Posición del eje auxiliar 2
a9 : REAL Posición del eje auxiliar 3
El tipo de dato AXISPOS describe el alcance máximo posible de una posición de eje. Si no hay ejes, la indicación de la posición de estos ejes es irrelevante. Por lo general, el valor de
posición indicado para estos ejes es 0. En el editor FCT se bloquean los campos de estos ejes.
El nombre de cada posición permite acceder a cada uno de los valores de posición del tipo
AXISPOS.
Ejemplo:
Variable:
startPos : AXISPOS := (100, 50, 30, 0, 0, 0, 0, 0, 0)
posA1 : REAL
posA2 : REAL
Programa:
:
Lin(startPos) // Avanzar a startPos
posA1 := startPos.a1 // Guardar valor de eje convertido 1
posA2 := startPos.a2 // Guardar valor de eje convertido 2
:
9. Instrucciones de movimiento
50 Festo GDCP-CMXR-SW-ES es 0805NH
La asignación de ejes individuales a la estructura de datos de posición AXISPOS se efectúa
mediante una numeración. Esta numeración ya se ha realizado en la configuración de los ejes cinemáticos. De manera análoga a esta numeración se asignan las indicaciones de posición del tipo de dato AXISPOS a cada uno de los ejes.
Ejemplo:
Pórtico cartesiano con tres ejes de movimiento con tres ejes lineales y un eje de rotación (giro de la pinza). En la configuración se realizaron los ajustes siguientes:
Eje 1 = Eje X
Eje 2 = Eje Y
Eje 3 = Eje Z
Eje 4 = Eje de rotación de la pinza
Los ejes 5 y 6 no existen, no hay ejes auxiliares.
La asignación en el tipo de dato AXISPOS se realiza de manera análoga a esta numeración:
a1 : REAL Posición eje 1 = Eje X
a2 : REAL Posición eje 2 = Eje Y
a3 : REAL Posición eje 3 = Eje Z
a4 : REAL Posición eje 4 = Eje de rotación de pinza
a5 : REAL Posición eje 5, no existe
a6 : REAL Posición eje 6, no existe
a7 : REAL Posición eje auxiliar 1, no existe
a8 : REAL Posición eje auxiliar 2, no existe
a9 : REAL Posición eje auxiliar 3, no existe
9. Instrucciones de movimiento
Festo GDCP-CMXR-SW-ES es 0805NH 51
9.1.2 Posición cartesiana
A diferencia de la posición de eje del tipo de dato AXISPOS, el tipo de posición cartesiano
CARTPOS describe una posición en un sistema de coordenadas cartesiano.
Un cuerpo posee un máximo de seis grados de libertad de movimiento. Con ayuda de estos valores puede definirse la posición y la orientación del cuerpo en el espacio. Estos seis grados de libertad de movimiento se describen con seis indicaciones en el tipo de dato CARTPOS. Además, se indica la posición de los tres ejes auxiliares, aunque dicha indicación es una posición de ejes, ya que con los ejes auxiliares no pueden realizarse desplazamientos cartesianos. Los ejes auxiliares se interpolan junto con los ejes cinemáticos en la posición de destino, pero los primeros ejecutan una interpolación punto a punto (PTP).
Estructura:
Tipo de dato CARTPOS
x : REAL Desplazamiento a lo largo del eje X
y : REAL Desplazamiento a lo largo del eje Y
z : REAL Desplazamiento a lo largo del eje Z
a : REAL Indicación de orientación, rotación alrededor del eje Z
b : REAL Indicación de orientación, rotación alrededor del eje Y rotado
c : REAL Indicación de orientación, rotación alrededor del eje Z rotado
aux1 : REAL Posición del eje auxiliar 1
aux2 : REAL Posición del eje auxiliar 2
aux3 : REAL Posición del eje auxiliar 3
No es posible realizar algunas indicaciones en una posición cartesiana debido a la cinemá-
tica seleccionada o a su grado de libertad de movimiento. Las indicaciones de posición individuales en el tipo de dato CARTPOS no están unidas a los ejes físicos de la cinemática,
sino a su grado de libertad de movimiento.
La posición cartesiana contiene las indicaciones para un máximo de seis grados de libertad de movimiento. X, Y, Z son las posiciones de traslación, A, B y C describen la orientación de la posición. La orientación se indica, como en todo el sistema, conforme a la convención de los ángulos de Euler ZYZ.
Un tipo de dato CARTPOS está estructurado como el tipo de dato AXISPOS (véase el capítulo
5.4 Tipos de datos estructurados de la página 29). El nombre de cada uno de los valores del tipo de dato permite acceder a los valores de posición individuales.
Ejemplo:
Variable:
startPos : CARTPOS := (1050, 130, 30, 0, 0, 0, 0, 0, 0)
newPos : CARTPOS := (0, 0, 0, 0, 0, 0, 0, 0, 0)
posX : REAL
posY : REAL
9. Instrucciones de movimiento
52 Festo GDCP-CMXR-SW-ES es 0805NH
Programa:
:
Lin(startPos) // Avanzar a StartPos
newPos := startPos // Copiar StartPos
newPos.x := newPos.x + 10 // Calcular X
newPos.y := newPos.y + 35.7 // Calcular Y
Lin(newPos) // Avanzar a posición calculada
:
El efecto de las indicaciones de posición y orientación cartesianas depende de los grados de libertad de movimiento de la cinemática.
Ejemplo:
Tenemos un manipulador de cinemática paralela (trípode) con tres ejes principales, sin ejes manuales. Con los tres ejes principales se cubren los tres grados de libertad de movimiento
de traslación X, Y y Z. Como no hay ejes manuales, no es posible orientar la herramienta. La programación de las variables a, b, c, aux1, aux2 o aux3 en la indicación de posición del tipo de dato CARTPOS no tiene efecto alguno.
9.2 Movimiento punto a punto <Ptp>
El movimiento punto a punto (PTP) es la opción más rápida para desplazar el extremo de herramienta (TCP) a la posición deseada. El movimiento PTP es una instrucción de des-plazamiento punto a punto con posición de destino. Con esta instrucción se arrancan simultáneamente todos los ejes y llegan a la posición de destino programada al mismo
tiempo. Para el movimiento se utilizan los valores dinámicos activos en ese momento, p. ej., la velocidad y la aceleración. La dinámica efectiva se obtiene de la combinación de las dinámicas de todos los ejes participantes. El eje más lento determina la dinámica. El movimiento del TCP se obtiene en este caso de la combinación del movimiento de ejes individuales. El movimiento en el TCP no está definido.
9. Instrucciones de movimiento
Festo GDCP-CMXR-SW-ES es 0805NH 53
Atención
Como el movimiento PTP no está restringido a una trayectoria, sino que los ejes sólo se interpolan al destino, pueden produ-cirse aceleraciones o velocidades inesperadas en la herramienta (TCP). Por tanto, los movimientos deben comprobarse por si se producen pérdidas o daños en las piezas y/o en la herramienta.
Debido a la interpolación axial, durante un movimiento PTP no puede tenerse en cuenta ningún dato de herramienta. Por ello es importante prestar siempre atención las herramientas para protegerlas contra daños.
Para minimizar el peligro de colisión deben comprobarse todos los movimientos PTP a una velocidad reducida, p. ej., puede
utilizarse el override.
Sintaxis
Ptp ( <Pos> : AXISPOS o CARTPOS)
Parámetro Significado Unidad
Pos Posición de destino AXISPOS o CARTPOS
Tabla 9.1 Parámetro de la instrucción PTP
La indicación de posición puede ser cartesiana o en el sistema de coordenadas de ejes (en relación con cada eje). El control multieje CMXR transforma las posiciones como corresponde.
Ejemplo:
Debe posicionarse un pórtico cartesiano con tres ejes X, Y, Z y un eje de rotación con pinza.
1 Eje Y
2 Eje Z
3 Eje de rotación
con pinza
4 Eje X
Variable:
1
4
3
2
9. Instrucciones de movimiento
54 Festo GDCP-CMXR-SW-ES es 0805NH
pos1 : CARTPOS := (100, 50, 100, 0, 0, 0, 0, 0, 0)
pos2 : CARTPOS := (600, 550, 100, 180, 0, 0, 0, 0, 0)
Programa:
:
Ptp(pos1)
Ptp(pos2)
:
En el ejemplo se muestra la trayectoria del eje Z y del extremo de herramienta (TCP). Debido a la colocación vertical de la cinemática cartesiana, la trayectoria en el eje Z es una recta. Como la herramienta posee una asimetría con el eje Z, esta trayectoria se comporta de un modo inesperado ya que, con la interpolación síncrona, todos los ejes se desplazan juntos a su punto de destino sin tener en cuenta la trayectoria descrita.
X
Y
Trayectoria aproximada en el TCP
Trayectoria en el eje Z
Eje de rotación 0 grados
Eje de rotación 90 grados
Eje de rotación 180 grados
9. Instrucciones de movimiento
Festo GDCP-CMXR-SW-ES es 0805NH 55
9.3 Movimiento punto a punto <PtpRel>
La instrucción PTP funciona de manera análoga a la instrucción PTP relativa, con la diferencia de que la posición indicada es relativa a la posición inicial. La indicación de posición se suma a la posición inicial.
Una aplicación posible es, p. ej., el posicionamiento relativo dentro de una retícula, como con una paleta.
Sintaxis
PtpRel ( <Dist> : AXISDIST o CARTDIST)
Parámetro Significado Unidad
Dist Distancia relativa que debe recorrerse AXISDIST o CARTDIST
Tabla 9.2 Parámetro de la instrucción PtpRel
La indicación de distancia puede ser cartesiana o relativa a cada eje. El control CMXR transforma las posiciones como corresponde.
Ejemplo:
En una aplicación de manipulación, la pieza se desplaza a cuatro posiciones, cada una a una unidad de medición.
pos2
Eje X
Eje Z
300
pos3 pos1
150
110
225
1 2 3 4
850 100 207
9. Instrucciones de movimiento
56 Festo GDCP-CMXR-SW-ES es 0805NH
Variable:
:
pos1 : CARTPOS := (100, 0, 300, 0, 0, 0, 0, 0, 0)
pos2 : CARTPOS := (207, 0, 225, 0, 0, 0, 0, 0, 0)
pos3 : CARTPOS := (850, 0, 300, 0, 0, 0, 0, 0, 0)
distX : CARTDIST := (110, 0, 0, 0, 0, 0, 0, 0, 0)
distZpos : CARTDIST := (0, 0, 150, 0, 0, 0, 0, 0, 0)
distZneg : CARTDIST := (0, 0, -150, 0, 0, 0, 0, 0, 0)
:
Programa:
:
Ptp(pos1)
Ptp(pos2)
LOOP 3 DO
PtpRel(distZneg)
CALL Verificar() // Llamada de ciclo de comprobación
PtpRel(distZpos)
PtpRel(distX)
END_LOOP
PtpRel(distZneg)
CALL Verificar() // Llamada de ciclo de comprobación
PtpRel(distZpos)
PtpRel(distX)
Ptp(pos3)
:
El ciclo de medición de la pieza, así como su evaluación, se procesan en el subprograma “verificar”. El contenido del subprograma no se representa para una mayor simplificación.
9. Instrucciones de movimiento
Festo GDCP-CMXR-SW-ES es 0805NH 57
9.4 Movimiento de un eje, <MoveAxisPtp>, <MoveAxisCart>
Con las instrucciones MoveAxisPtp y MoveAxisCart se posiciona un eje de la cinemática
con un movimiento PTP o un movimiento cartesiano. No se indica la posición de destino absoluta del eje.
Sintaxis
MoveAxisPtp (<Axis> : ENUM, <Pos> : REAL)
MoveAxisCart (<CartComp> : ENUM, <Pos> : REAL)
Parámetros Significado Unidad
Eje Eje físico seleccionado que
debe desplazarse
Enumeración con los valores A1
a A9 para los ejes 1 a 9
Pos Posición de destino absoluta Unidad de los ejes definidos
Tabla 9.3 Parámetros de la instrucción MoveAxisPtp
Parámetros Significado Unidad
CartComp Eje cartesiano seleccionado que
debe desplazarse
Enumeración con los valores
X Y Z ; A B C
Pos Posición de destino cartesiana
absoluta
Unidad de los ejes definidos
Tabla 9.4 Parámetros de la instrucción MoveAxisCart
Como aquí se trata de un eje individual, el movimiento se efectúa teniendo en cuenta posibles limitaciones, p. ej., override, dinámica máxima de ejes.
Ejemplo:
Una cinemática cartesiana se compone de cuatro ejes: Eje 1 = Eje X Eje 2 = Eje Y Eje 3 = Eje Z Eje 4 = Eje de rotación de la herramienta
En el ejemplo debe recogerse una pieza en una posición y posarse en otra. Para ello, el eje de rotación debe estar posicionado como corresponde.
9. Instrucciones de movimiento
58 Festo GDCP-CMXR-SW-ES es 0805NH
Variable:
:
pos1 : CARTPOS := (300, 0, 250, 0, 0, 0, 0, 0, 0)
RecogidaArriba : CARTPOS := (350, 0, 145, 0, 0, 0, 0, 0, 0)
pos2 : CARTPOS := (575, 0, 250, 0, 0, 0, 0, 0, 0)
posPinza : REAL := 96.5
:
Programa con movimientos PTP:
:
Ptp(pos1) // Arrancar
Ptp(recogidaArriba) // Recogida arriba
MoveAxisPtp(A4, posPinza) // Girar pinza
MoveAxisPtp(A3, 50) // Hacia abajo
Gripper.Set() // Cerrar pinza
MoveAxisPtp(A3, 145) // Hacia arriba
MoveAxisPtp(A1, 450) // Posado abajo
MoveAxisPtp(A4, 180) // Girar sobre bandeja
MoveAxisPtp(A3, 50) // Posado abajo
Gripper.Set() // Abrir pinza
MoveAxisPtp(A3, 145) // Posado abajo
Ptp(pos2) // Arrancar
:
pos2
Eje X
Eje Z
50
575 450
145
pos1
recogidaArriba
recogidaAbajo
posadoArriba
posadoAbajo
250
350 300
9. Instrucciones de movimiento
Festo GDCP-CMXR-SW-ES es 0805NH 59
9.5 Movimiento lineal <Lin>
Con un movimiento lineal, el control multieje CMXR calcula una recta que lleva de la posición actual (posición inicial) a la posición programada (posición de destino). Este movimiento se calcula y ejecuta teniendo en cuenta los valores de trayectoria ajustados, como, p. ej., la aceleración y la velocidad de trayectoria, la orientación y los datos de herramienta. Si en la indicación de posición de destino se indica una modificación de la orientación, el desplazamiento por esta trayectoria es continuo desde la orientación del punto inicial hasta la orientación final.
El movimiento lineal es un movimiento cartesiano, es decir, éste se calcula con ayuda de la función interna de transformación de coordenadas para la cinemática existente. La posición se programa siempre en el extremo de la herramienta (TCP). Del mismo modo, todos los valores dinámicos, como la aceleración y la velocidad de trayectoria, se alcanzan directa-mente en el TCP. La ventaja radica en que los valores dinámicos en la herramienta son
limitados y conocidos. Por tanto, en la pinza actúan fuerzas repetibles.
Sintaxis
Lin ( <Pos> : AXISPOS o CARTPOS)
Parámetro Significado Unidad
Pos Posición de destino absoluta AXISPOS o CARTPOS
Tabla 9.5 Parámetro de la instrucción Lin
La indicación de posición puede ser cartesiana o relativa a cada eje. El control multieje
CMXR transforma las posiciones como corresponde.
9. Instrucciones de movimiento
60 Festo GDCP-CMXR-SW-ES es 0805NH
Ejemplo:
Debe posicionarse un pórtico cartesiano con tres ejes X, Y, Z y un eje de rotación en la pinza. El extremo de herramienta (TCP) está definido con un vector en el punto central de la pinza (véase el capítulo 13 Herramientas en la página 102).
Variable:
:
pos1 : CARTPOS := (100, 50, 100, 0, 0, 0, 0, 0, 0)
pos2 : CARTPOS := (600, 550, 100, 180, 0, 0, 0, 0, 0)
gripper : TCPTOOL := (-100, 0, 97, 0, 0, 0,)
:
Programa:
:
Tool(gripper)
Lin(pos1)
Lin(pos2)
:
Eje X
Eje Y
Eje Z
Eje de rotación con pinza
Vector en el TCP
9. Instrucciones de movimiento
Festo GDCP-CMXR-SW-ES es 0805NH 61
Como se muestra en la figura, el TCP (extremo de herramienta) describe la trayectoria con un movimiento lineal. Todas las indicaciones de velocidad se refieren siempre al TCP. La trayectoria es definida en función a este. Sin embargo, no está previsto que la brida de herramienta discurra por la trayectoria en el plano X-Y. Esta trayectoria se obtiene de la combinación de la cinemática y del vector del TCP, y se calcula mediante la transformación interna de coordenadas.
9.6 Movimiento lineal relativo <LinRel>
La instrucción Lin relativa funciona de manera análoga a la instrucción Lin. La indicación de posición se suma a la posición inicial.
Una aplicación posible es, p. ej., el posicionamiento relativo dentro de una retícula, como con una paleta.
Sintaxis
LinRel (<Dist> : AXISDIST o CARTDIST)
Parámetro Significado Unidad
Dist Posición de destino relativa AXISDIST o CARTDIST
Tabla 9.6 Parámetro de la instrucción LinRel
La indicación de distancia puede ser cartesiana o relativa a cada eje. El control multieje CMXR transforma las posiciones como corresponde.
X
Y
Eje de rotación 0 grados
Eje de rotación 90 grados
Eje de rotación 180 grados
Trayectoria en el TCP
Trayectoria aproximada en el eje Z
9. Instrucciones de movimiento
62 Festo GDCP-CMXR-SW-ES es 0805NH
Ejemplo:
Un contorno contiene tramos repetibles. Estos tramos pueden describirse de manera relativa. Este tipo de aplicación se resuelve con comodidad utilizando una programación de bucles.
Variable:
:
pos1 : CARTPOS := (98.5, 100, 0, 0, 0, 0, 0, 0, 0)
pos2 : CARTPOS := (387, 100, 0, 0, 0, 0, 0, 0, 0)
distX : CARTDIST := (57, 0, 0, 0, 0, 0, 0, 0, 0)
distYpos : CARTDIST := (0, 112, 0, 0, 0, 0, 0, 0, 0)
distYneg : CARTDIST := (0, -112, 0, 0, 0, 0, 0, 0, 0)
pos3 : CARTPOS := (1050, 45, 0, 0, 0, 0, 0, 0, 0)
dirección : BOOL
:
pos2
S
Eje Y
100
1050 387 98.5
45
pos3
pos1
57
112
9. Instrucciones de movimiento
Festo GDCP-CMXR-SW-ES es 0805NH 63
Programa:
:
Lin(pos1)
Lin(pos2)
dirección := TRUE
LOOP 5 DO
IF dirección = TRUE THEN
LinRel(distYpos)
ELSE
LinRel(distYneg)
END_IF
LinRel(distX)
dirección := NOT dirección
END_LOOP
LinRel(distYneg)
Lin(pos3)
:
Con las variables “dirección” se define el sentido del movimiento relativo del eje Y. De este
modo puede programarse el movimiento con un bucle.
9.7 Movimiento circular con punto de apoyo
La interpolación circular se diferencia de la interpolación lineal no sólo por la forma geométrica, sino también porque, además de los puntos inicial y final, debe indicarse un punto de apoyo para definir el círculo de manera inequívoca.
9.7.1 Funcionamiento
El círculo se define a partir de un punto de apoyo, que debe encontrarse dentro de la trayectoria circular, y del punto final de la trayectoria circular. En la trayectoria circular se avanza primero hasta el punto de apoyo y después al punto final. El radio de la trayectoria
circular se obtiene a partir de un cálculo interno con punto inicial, punto de apoyo y punto final de la trayectoria circular.
9. Instrucciones de movimiento
64 Festo GDCP-CMXR-SW-ES es 0805NH
En la figura siguiente se muestra un movimiento circular utilizando un punto de apoyo:
El círculo se mueve de manera que el TCP se desplaza desde el punto inicial pasando
por el punto de apoyo hasta el punto final. El punto de apoyo se encuentra siempre, por definición, entre los puntos inicial y final.
Restricciones:
Se recibe un mensaje de error si por lo menos dos posiciones que definen el círculo tienen la misma posición, o si todos los puntos se encuentran sobre una recta. En estos casos no es posible calcular la trayectoria circular matemáticamente.
Con este método no se puede describir un círculo completo (360°). Para describir un círculo
completo deben unirse dos semicírculos.
La orientación del punto de apoyo no se tienen en cuenta para interpolar el arco. La inter-polación se efectúa exclusivamente entre los puntos inicial y final. Si es necesario cambiar orientaciones dentro de un arco, es posible segmentar el arco en varias partes para ajustar las orientaciones en los puntos inicial y final.
9.7.2 Definición de planos
La trayectoria circular se efectúa en un plano definido a partir de los tres puntos: punto inicial, punto de apoyo y punto final. Con esta definición se extiende el plano en el espacio donde se va a describir la trayectoria circular.
Punto final
Punto de apoyo
Punto de apoyo
Posición inicial Posición inicial
Punto final
9. Instrucciones de movimiento
Festo GDCP-CMXR-SW-ES es 0805NH 65
En la figura se muestra una trayectoria circular con sus tres puntos de apoyo, que definen
un plano en el espacio donde se encuentra la trayectoria.
Indicación
La trayectoria circular siempre está en un plano. No es posible realizar una interpolación helicoidal con una interpolación adicional perpendicular al plano.
La trayectoria circular se efectúa en un plano definido a partir de los tres puntos
Posición inicial
Punto final
Punto de apoyo
9. Instrucciones de movimiento
66 Festo GDCP-CMXR-SW-ES es 0805NH
9.7.3 Instrucción Circular con punto de apoyo <CircIp>
La instrucción Circular con punto de apoyo tiene la sintaxis de programa siguiente:
Sintaxis
CircIp ( <IpPos> : AXISPOS o CARTPOS,
<Pos> : AXISPOS o CARTPOS)
Parámetros Significado Unidad
IpPos Punto de apoyo en el círculo AXISPOS o CARTPOS
Pos Posición final del arco AXISPOS o CARTPOS
Tabla 9.7 Parámetros de la instrucción CircIp
La indicación de posiciones puede ser cartesiana o relativa a cada eje. El control multieje CMXR transforma las posiciones como corresponde.
Advertencia
La instrucción círculo requiere la indicación de los puntos inicial y final. El punto inicial se construye con el punto final del movimiento anterior. Si este punto se desplaza, la trayectoria circular sufre una modificación. Ésta puede ser incontrolada y provocar una colisión. La modificación del punto inicial no genera necesariamente un mensaje de error ya que el resultado es correcto.
9. Instrucciones de movimiento
Festo GDCP-CMXR-SW-ES es 0805NH 67
Ejemplo:
Debe recorrerse el contorno siguiente:
El eje Z permanece en la coordenada 0. La aproximación al punto inicial del arco se efectúa con una instrucción de desplazamiento aparte, p. ej., Ptp o Lin.
Variables:
:
pos1 : CARTPOS := (950, 500, 0, 0, 0, 0, 0, 0, 0)
pos2 : CARTPOS := (455, 300, 0, 0, 0, 0, 0, 0, 0)
IpPos : CARTPOS := (1050, 400, 0, 0, 0, 0, 0, 0, 0)
EndPos : CARTPOS := (950, 300, 0, 0, 0, 0, 0, 0, 0)
:
Programa:
:
Lin(pos1) // Aproximar a punto inicial
CircIp(IpPos, EndPos) // Movimiento circular en punto final
Lin(pos2) // Arrancar
:
Posición pos1
Punto de apoyo IpPos
Punto final EndPos Posición pos2
Eje X
Eje Y
300
400
500
1050 950 455
9. Instrucciones de movimiento
68 Festo GDCP-CMXR-SW-ES es 0805NH
9.7.4 Instrucción Circular con punto de apoyo, aproximación PTP <PtpToCircIp>
A diferencia de la instrucción Circular CircIp, esta instrucción tiene el punto inicial del
arco en la lista de parámetros. Ello tiene la ventaja de que el arco se describe de manera coherente. La aproximación al punto inicial del arco se efectúa con una instrucción PTP. Por lo demás, el comportamiento es igual que el de la instrucción CircIp.
Como la aproximación al punto inicial es un movimiento PTP, y la interpolación circular es un movimiento cartesiano, no es posible ni un avance aproximado geométrico ni una velocidad de trayectoria constante. El avance aproximado se efectúa en función de las posibilidades que ofrece un movimiento PTP.
Sintaxis
PtpToCircIp ( <StartPos> : AXISPOS o CARTPOS,
<IpPos> : AXISPOS o CARTPOS,
<Pos> : AXISPOS o CARTPOS)
Parámetros Significado Unidad
StartPos Punto inicial del arco AXISPOS o CARTPOS
IpPos Punto de apoyo del arco AXISPOS o CARTPOS
Pos Punto final del arco AXISPOS o CARTPOS
Tabla 9.8 Parámetros de la instrucción PtpToCircIp
La indicación de posiciones puede ser cartesiana o relativa a cada eje. El control multieje CMXR transforma las posiciones como corresponde.
9. Instrucciones de movimiento
Festo GDCP-CMXR-SW-ES es 0805NH 69
Ejemplo:
Debe recorrer el contorno siguiente:
El plano del eje Z es 0. La aproximación al punto inicial del arco se realiza con un movimiento PTP (punto a punto). El punto inicial se transmite con la instrucción PtpToCircIp.
Variables:
:
StartPos : CARTPOS := (950, 500, 0, 0, 0, 0, 0, 0, 0)
IpPos : CARTPOS := (1050, 400, 0, 0, 0, 0, 0, 0, 0)
EndPos : CARTPOS := (950, 300, 0, 0, 0, 0, 0, 0, 0)
Pos1 : CARTPOS := (455, 300, 0, 0, 0, 0, 0, 0, 0)
:
Programa :
:
// Aproximación PTP, movimiento circular cartesiano
PtpToCircIp(StartPos, IpPos, EndPos)
Lin(Pos1) // Arrancar
:
Posición inicial StartPos
Punto de apoyo IpPos
Punto final EndPos Posición Pos1
Eje X
Eje Y
300
400
500
1050 950 455
9. Instrucciones de movimiento
70 Festo GDCP-CMXR-SW-ES es 0805NH
9.7.5 Instrucción Circular con punto de apoyo, avance lineal <LinToCircIp>
Como la instrucción PtpToCircIp, la instrucción LinToCircIp contiene el punto inicial de la
trayectoria circular. El recorrido de la trayectoria circular sólo puede ser cartesiano. Ello significa que el movimiento en el punto inicial y la trayectoria circular en caso de avance aproximado puede ser geométrico. También es posible una velocidad de trayectoria constante.
Sintaxis
LinToCircIp (<StartPos> : AXISPOS o CARTPOS,
<IpPos> : AXISPOS o CARTPOS,
<Pos> : AXISPOS o CARTPOS)
Parámetros Significado Unidad
StartPos Punto inicial del arco AXISPOS o CARTPOS
IpPos Punto de apoyo del arco AXISPOS o CARTPOS
Pos Punto final del arco AXISPOS o CARTPOS
Tabla 9.9 Parámetros de la instrucción LinToCircIP
La indicación de posiciones puede ser cartesiana o relativa a cada eje. El control multieje CMXR transforma las posiciones como corresponde.
Ejemplo:
Una cinemática debe recorrer el centorno siguiente:
El plano del eje Z es 0. La aproximación al punto inicial del arco se realiza con un movimiento lineal. El punto inicial se transmite con la instrucción LinToCirc.
Variables:
Posición inicial StartPos
Punto de apoyo IpPos
Punto final EndPos Posición Pos1
Eje X
Eje Y
300
400
500
1050 950 455
9. Instrucciones de movimiento
Festo GDCP-CMXR-SW-ES es 0805NH 71
:
StartPos : CARTPOS := (950, 500, 0, 0, 0, 0, 0, 0, 0)
IpPos : CARTPOS := (1050, 400, 0, 0, 0, 0, 0, 0, 0)
EndPos : CARTPOS := (950, 300, 0, 0, 0, 0, 0, 0, 0)
Pos1 : CARTPOS := (455, 300, 0, 0, 0, 0, 0, 0, 0)
:
Programa :
:
// Aproximación lineal, movimiento circular cartesiano
LinToCircIp(StartPos, IpPos, EndPos)
Lin(Pos1) // Arrancar
:
9.8 Detención del movimiento <StopMove>
Con la instrucción StopMove se detiene la cinemática y se descartan todos los datos de
trayectoria ya calculados. La instrucción influye en el avance de proceso.
La cinemática se detiene con la máxima rampa de frenado definida para detener la cine-mática. La reducción de la dinámica por un override no afectan a la detención.
Sintaxis
StopMove()
Una aplicación de esta parada es, p. ej., el desplazamiento hasta un obstáculo detectado por un sensor. Una vez detectado el estado, la instrucción StopMove detiene el movimiento.
En el capítulo 19.1 Detención de movimientos en la página 171 se da un ejemplo de utiliza-ción de la instrucción StopMove.
10. Instrucciones de dinámica
72 Festo GDCP-CMXR-SW-ES es 0805NH
10. Instrucciones de dinámica Con las instrucciones de dinámica pueden programarse la velocidad, la aceleración y la sacudida para los movimientos del robot. La dinámica de los movimientos punto a punto (PTP) y los movimientos cartesianos puede ajustarse por separado.
Los valores dinámicos pueden modificarse en cualquiera de las líneas de programa.
10.1 Velocidades <Vel>
Con la instrucción Vel puede indicarse la velocidad para un movimiento cartesiano o PTP.
El control reduce los valores indicados a las velocidades máximas permitidas de cada uno de los ejes participantes. Si la velocidad máxima permitida da lugar a alguna limitación se emite un mensaje.
Sintaxis
Vel (<Mode> : ENUM, <valor> : REAL)
Parámetros Significado Unidad
Mode Tipo de velocidad Enumeración: dynPtp, dynCart
Value Valor de velocidad Indicación de velocidad
Tabla 10.1 Parámetros de la instrucción Vel
Parámetros de enumeración Mode
Tipo de movimiento Unidad
dynPtp Punto a punto %
dynCart Cartesiano mm/s
Tabla 10.2 Unidades del parámetro Value
Ejemplo:
Variable:
:
axis0 : AXISPOS := (-60, -60, 0, 0, 0, 0, 0, 0, 0)
axis1 : AXISPOS := (60, 60, 0, 0, 0, 0, 0, 0, 0)
axis2 : AXISPOS := (100, 60, 0, 0, 0, 0, 0, 0, 0)
:
Programa :
10. Instrucciones de dinámica
Festo GDCP-CMXR-SW-ES es 0805NH 73
:
Vel(dynPtp, 30) // Velocidad para PTP al 30%
Ptp(axis0)
Vel(dynCart, 500) // Velocidad de trayectoria a 500 mm/s
Lin(axis1)
speed := 85
Vel(dynPtp, speed) // Velocidad para PTP al 85%
Ptp(axis3)
:
10.2 Aceleración <Acc>
Ajuste de la aceleración y la deceleración para movimientos PTP y cartesianos de los ejes
manuales. Las instrucciones siguientes se reducen al valor indicado. El control reduce automáticamente la aceleración o la deceleración al sobrepasar el valor límite de eje.
Sintaxis
Acc ( <Mode> : ENUM, <ValueAcc> : REAL, OPT <ValueDec> : REAL)
Parámetros Significado Unidad
Mode Tipo de aceleración Enumeración: dynPtp, dynCart
ValueAcc Valor de aceleración mm/s² o grado/s²
ValueDec Valor de deceleración, indicación opcional mm/s² o grado/s²
Tabla 10.3 Parámetros de la instrucción Acc
Parámetros de enumeración Mode
Tipo de movimiento Unidad
dynPtp Punto a punto %
dynCart Cartesiano mm/s²
Tabla 10.4 Unidades de los parámetros ValueAcc, ValueDec
Indicación
Si no se indica el parámetro opcional ValueDec (para la rampa de frenado), el valor del parámetro ValueAcc (para la aceleración) se utilizará para la rampa de frenado. En ese caso, el perfil es simétrico.
10. Instrucciones de dinámica
74 Festo GDCP-CMXR-SW-ES es 0805NH
Ejemplo:
Variable:
:
pos0 : AXISPOS := (-60, -60, 0, 0, 0, 0, 0, 0, 0)
pos1 : AXISPOS := (60, 60, 0, 0, 0, 0, 0, 0, 0)
pos2 : AXISPOS := (100, 60, 0, 0, 0, 0, 0, 0, 0)
:
Programa:
:
Ptp(pos0)
Acc(dynPtp, 30, 30) // Aceleración para PTP al 30%
Ptp(pos1)
Acc(dynCart, 100) // Aceleración de trayectoria a
100 mm/s²
Lin(pos2)
:
10.3 Sacudida <Jerk>
Ajuste de la sacudida para movimientos PTP y cartesianos. Las instrucciones siguientes se
reducen al valor indicado. El control reduce automáticamente la sacudida al sobrepasarse el valor límite de eje.
Sintaxis
Jerk ( <Mode> : ENUM, <Value> : REAL)
Parámetros Significado Unidad
Mode Tipo de movimiento Enumeración: dynPtp, dynCart
Value Tipo de sacudida
Tabla 10.5 Parámetro de la instrucción Jerk
Parámetros de enumeración Mode
Tipo de movimiento Unidad
dynPtp Punto a punto %
dynCart Cartesiano mm/s³
Tabla 10.6 Unidades del parámetro Value
10. Instrucciones de dinámica
Festo GDCP-CMXR-SW-ES es 0805NH 75
Ejemplo:
Variable:
:
pos0 : AXISPOS := (-60, -60, 0, 0, 0 ,0, 0, 0, 0)
pos1 : AXISPOS := (60, 60, 0, 0, 0, 0, 0, 0, 0)
pos2 : AXISPOS := (100, 60, 0, 0, 0, 0, 0, 0, 0)
:
Programa:
:
Ptp(pos0)
Jerk(dynPtp, 50) // Sacudida para PTP al 50%
Ptp(pos1)
Jerk(dynCart, 5000) // Sacudida en la trayectoria a
5000 mm/s³
Lin(pos2)
:
10. Instrucciones de dinámica
76 Festo GDCP-CMXR-SW-ES es 0805NH
10.4 Override
Con un override pueden ajustarse todos los valores dinámicos en porcentajes. Ello permite influir fácilmente en los valores de aceleración, velocidad y sacudida. La trayectoria progra-mada no se modifica.
Indicación
Para reducir únicamente la velocidad, debe modificarse directa-mente la indicación del valor de velocidad. Si la reducción se efectúa mediante el override, influye también en la aceleración y en la sacudida. Ello reduce el aprovechamiento de la dinámica del eje y ralentiza el movimiento en la suma.
Hay dos tipos de override diferentes: Override dinámico: influye en los valores ajustados de velocidad, aceleración y
sacudida. Override en la unidad manual.
Funcionamiento del override
Dinámica = dinámica programada * override dinámico
10.4.1 Override en la unidad manual <Ovr>
El override coincide con el ajuste efectuado en la unidad manual CDSA-D1-VX mediante
las teclas V+, V-. El override se indica en porcentajes siendo 100% la dinámica máxima. Una reducción del override ralentiza la dinámica pero no modifica la trayectoria.
En la figura se muestran las teclas V- y V+ utilizadas para ajustar el override en la unidad manual CDSA-D1-VX.
El override es muy útil para la puesta a punto. Sin embargo, en modo automático debe
estar al 100% para poder aprovechar al máximo la dinámica. Las adaptaciones correspon-dientes de dinámica deben efectuarse directamente con las instrucciones de velocidad y aceleración.
Con la instrucción Ovr puede ajustarse directamente un valor de override en el programa.
Éste tiene el mismo efecto que una modificación efectuada con las teclas de la unidad manual.
10. Instrucciones de dinámica
Festo GDCP-CMXR-SW-ES es 0805NH 77
Sintaxis
Ovr ( <Value> : REAL)
Parámetro Significado Unidad
Value Valor de override Porcentaje
Tabla 10.7 Parámetro de la instrucción Ovr
Indicación
Para aprovechar la dinámica máxima del robot, el valor del override en modo automático debe estar siempre al 100%. Las adaptaciones de dinámica deben efectuarse directamente con las instrucciones correspondientes.
10.4.2 Override dinámico <DynOvr>
Con la instrucción DynOvr se influye en los valores dinámicos ajustados o programados
adoptando el override ajustado en la unidad manual.
Sintaxis
DynOvr ( <Value> : REAL)
Parámetro Significado Unidad
Value Valor del override dinámico Porcentaje
Tabla 10.8 Parámetro de la instrucción DynOvr
Indicación
El override no modifica la trayectoria.
10. Instrucciones de dinámica
78 Festo GDCP-CMXR-SW-ES es 0805NH
10.5 Rampas de aceleración
Con la instrucción Ramp puede ajustarse una forma de rampa para la aceleración o la
deceleración. El usuario puede elegir entre cuatro formas de rampa. Al arrancar se activa la rampa sinusoidal.
Figura con las cuatro formas de rampa:
Rampa trapezoidal
Con la rampa trapezoidal, la trayectoria de aceleración describe una forma trapezoidal. Por tanto, la sacudida describe una forma rectangular. Con la rampa trapezoidal se obtienen los tiempos de ejecución de la trayectoria más cortos.
Con un parámetro opcional puede influirse en la forma de rampa. Éste puede ser > 0 y <= 0,5. Con un valor 0,5 se obtiene un triángulo de aceleración. Si el valor es, p. ej., 0,1, la rampa adopta casi un perfil rectangular.
Si no se indica el parámetro opcional, éste se ajusta automáticamente al factor 0,5 y se obtiene el triángulo de aceleración.
Forma de rampa trape-zoidal con un factor 0,5
Aceleración
0,0
0,2
0,4
0,6
0,8
1,0
1,2
0,00 0,21 0,43 0,64 0,85
Acele
ració
n
Tiempo
Sacudida mínima
0,000
0,200
0,400
0,600
0,800
1,000
1,200
0,000 0,167 0,333 0,500 0,667 0,833 1,000
Acele
ració
n
Tiempo
Sinusoidal
0,000
0,200
0,400
0,600
0,800
1,000
1,200
0,000 0,167 0,333 0,500 0,667 0,833 1,000
Acele
ració
n
Tiempo
Seno cuadrado
0,0
0,2
0,4
0,6
0,8
1,0
1,2
0,00 0,21 0,43 0,64 0,85
Acele
ració
n
Tiempo
Sacudida mínima
Forma de rampa trapezoidal con un factor aproximado de 0,1
Tiempo
10. Instrucciones de dinámica
Festo GDCP-CMXR-SW-ES es 0805NH 79
Rampa sinusoidal
La rampa sinusoidal tiene la ventaja de que no sólo la trayectoria de aceleración es sinusoidal, sino también la de sacudida. Así, la trayectoria de aceleración es más suave que la de la rampa trapezoidal. Sin embargo, el tiempo de ejecución para alcanzar la velocidad es ligeramente superior.
Rampa de seno cuadrado
La rampa de seno cuadrado describe la trayectoria más suave de todas, pero también es la que más tiempo de ejecución requiere.
Rampa de sacudida mínima
La rampa de sacudida mínima es una forma de rampa especial en la que se obtiene un término medio entre tiempo de ejecución y suavidad del movimiento. La trayectoria descrita por la aceleración es semejante a un perfil sinusoidal pero la trayectoria de
sacudida no es sinusoidal sino en forma de diente de sierra. Ello permite realizar un movimiento suave con un tiempo corto de ejecución.
Indicación
La utilización de un tipo de rampa depende del robot empleado y de la aplicación. Tras seleccionar la forma de rampa, debe probarse en el movimiento.
10.5.1 Ajuste de formas de rampa <Ramp>
Con la instrucción Ramp puede seleccionarse una forma de rampa. Ésta se utilizará para
todos los movimientos de todas las instrucciones de movimiento que se realicen a
continuación.
Sintaxis
Ramp( <Ramptype> : ENUM, OPT <Param> : REAL)
Parámetros Significado Unidad
Tipo de rampa Tipo de rampa, selecciona la forma de rampa Enumeración:
TRAPEZOID
SINE
SINESQUARE
MINJERK
Param Parámetro para rampas trapezoidales -----
Tabla 10.9 Parámetros de la instrucción Ramp
10. Instrucciones de dinámica
80 Festo GDCP-CMXR-SW-ES es 0805NH
Ejemplo:
:
Ramp(TRAPEZOID) // Selección de la rampa trapezoidal
Lin(pos1)
Lin(pos2)
WaitTime(1000)
Ramp(SINE) // Selección de la rampa sinusoidal
Lin(pos3)
Lin(pos4)
:
10.6 Conexión de la velocidad de trayectoria constante <VconstOn>
Con esta instrucción se conecta la monitorización de la velocidad de trayectoria constante. Ésta sólo afecta a instrucciones cartesianas como, p. ej., LIN y CIRC. Dicha instrucción no
afecta de ningún modo a los movimientos PTP.
Sintaxis
VconstOn (<Tolerance> : REAL, <StopOnViolation> : BOOL)
Parámetros Significado Unidad
Tolerance Valor porcentual del bajón permitido de la velocidad de
trayectoria
Valor porcentual de 0% a
100%
StopOnViolation Si es TRUE, se emite un error por incumplimiento de la
tolerancia
Interruptor: TRUE o FALSE
Tabla 10.10 Parámetros de la instrucción VconstOn
Indicación
Si se requiere una velocidad de trayectoria constante, debe tenerse en cuenta que para el área de avance aproximado se haya ajustado un avance aproximado por geometría (véase el capítulo 11.3 Avance aproximado por geometría en la página 87). Un avance aproximado basado en la velocidad porcentual provoca la modificación de la velocidad de trayectoria en el área de avance aproximado.
El control multieje CMXR calcula la velocidad posible de trayectoria basándose en la trayectoria y en los valores dinámicos máximos de la mecánica. El límite de la velocidad posible de trayectoria lo determina la dinámica de la mecánica. Si es necesario programar
10. Instrucciones de dinámica
Festo GDCP-CMXR-SW-ES es 0805NH 81
segmentos de trayectoria que, debido a los límites de dinámica, no se pueden recorrer a
una velocidad de trayectoria constante, en estos puntos se producen bajones de la velo-cidad de trayectoria.
Con el parámetro Tolerance puede indicarse un valor porcentual para obtener bajones
permitidos de la velocidad de trayectoria. Si el valor de tolerancia indicado es 100%, la monitorización se desconecta.
Indicación
La monitorización de la velocidad de trayectoria no tiene en cuenta el override ajustado en la unidad manual. Es decir, si el robot no alcanza la velocidad máxima debido al límite impuesto por un over-ride, la monitorización se activa y se genera un error.
Ejemplo:
Programa:
:
Lin(pos1)
VconstOn(25, TRUE)
Lin(pos2)
Lin(pos3)
VconstOff()
:
10. Instrucciones de dinámica
82 Festo GDCP-CMXR-SW-ES es 0805NH
10.7 Desconexión de la velocidad de trayectoria constante <VconstOff>
Con esta instrucción se desconecta una velocidad de trayectoria constante.
Sintaxis
VconstOff ( )
Indicación
La interrupción del programa de usuario no provoca la desconexión automática de la monitorización de la velocidad de trayectoria. Al volver a arrancar el programa de usuario debe desconectarse siempre primero la monitorización.
11. Márgenes de avance aproximado
Festo GDCP-CMXR-SW-ES es 0805NH 83
11. Márgenes de avance aproximado Como avance aproximado se entiende la aceleración de los ejes para aproximarse a la po-sición siguiente aunque aún no se hubiese alcanzado la posición anterior. A menudo no es necesario alcanzar con precisión una posición, sino realizar el movimiento de manera rá-pida y suave, es decir, con el menor esfuerzo posible de la mecánica. La función de avance aproximado permite ajustar la precisión de alcance de un punto y la dureza del movimiento.
En la figura siguiente se muestra el funcionamiento del avance aproximado.
El programa de movimientos está ajustado con un punto de posicionamiento en la posición 1 y después en la posición 2. Con la función de avance aproximado, ajustada con una instrucción de programa, el equipo no se aproxima a la posición exacta. Los perfiles dinámicos para aproximarse a cada una de las posiciones se pasan a las áreas de avance aproximado, lo que aumenta la dinámica.
Indicación
Al cargar un programa no hay ningún avance aproximado activo, es decir, el equipo se aproxima a las posiciones exactas. El avance aproximado debe activarse con las funciones correspondientes.
El avance aproximado se efectúa de dos maneras:
1. Avance aproximado por velocidad basado en la velocidad.
2. Avance aproximado por posición basado en una distancia predefinida.
En las páginas siguientes se describen estos tipos.
Áreas de avance aproximado
Posición 1 Posición 2
Trayectoria del robot
11. Márgenes de avance aproximado
84 Festo GDCP-CMXR-SW-ES es 0805NH
11.1 Área extrema
Si la distancia entre dos puntos es menor que la necesaria para avanzar entre la trayectoria de avance aproximado parametrizada, el control reduce automáticamente el área de avance aproximado entre los puntos para describir el mejor valor de avance aproximado posible.
En la figura se muestran en línea discontinua los círculos del área de avance aproximado obtenido a partir de la parametrización. Los círculos se solapan porque la distancia entre las posiciones A y B no es suficiente para recorrer este perfil. El control calcula automática-mente el área de avance aproximado máximo posible, representado por los círculos grises.
Indicación
El avance aproximado está limitado al 50% de la longitud del seg-mento de trayectoria. Si el área de avance aproximado es mayor que el límite máximo permitido, el control multieje CMXR la reduce automáticamente al 50% de la longitud del segmento de trayectoria.
Indicación
Si la longitud del segmento de trayectoria es demasiado corta, ello puede provocar bajones de dinámica incontrolados si se redujo el área de avance aproximado definida. Para evitarlo debe adaptarse la trayectoria o el área de avance aproximado.
Overlapping transition area
Programmed transition area
Transition area generated by the controller
Travelled path
11. Márgenes de avance aproximado
Festo GDCP-CMXR-SW-ES es 0805NH 85
11.2 Avance aproximado por velocidad
Para el avance aproximado por velocidad se solapan los perfiles dinámicos de la trayectoria. Con ello se obtiene un movimiento a la posición siguiente dentro del área de avance aproximado.
11.2.1 Con factor porcentual <OvlVel>
Para el avance aproximado por velocidad se define previamente un grado de avance con un valor porcentual. El margen de valores va de 0% a 200%.
Sintaxis
OvlVel (<Value> : REAL)
Parámetro Significado Unidad
Value Valor de avance aproximado Porcentaje
Tabla 11.1 Parámetro de la instrucción OvlVel
Parámetros:
Porcentaje del parámetro de avance aproximado en %
0% Sin avance aproximado
100% Aprovechamiento máximo de las aceleraciones de ejes
100 a 200% Sin pérdida de tiempo, movimiento más suave con un radio de avance
aproximado mayor
Los valores menores que 100% provocan desviaciones de la posición pero requieren más tiempo de movimiento ya que la velocidad debe reducirse. Con un valor del 100%, se aprovechan al máximo las reservas de aceleración de los ejes teniendo en cuenta una desviación lo más pequeña posible de la posición. Si se indican valores entre 100% y 200%, las desviaciones de la posición (errores de seguimiento) aumentan y las acelera-ciones de los ejes se reducen a diferencia de un ajuste del 100%.
En la figura siguiente se muestran los perfiles de velocidad en un recorrido a las posiciones 1 y 2. En el recorrido se han definido diferentes valores para el área de avance aproximado.
11. Márgenes de avance aproximado
86 Festo GDCP-CMXR-SW-ES es 0805NH
La gráfica 1 muestra un perfil de velocidad donde no se ha producido un solapamiento. Los ejes frenan dentro de la trayectoria; de este modo se alcanzan las posiciones 1 y 2 con precisión. La gráfica central representa un solapamiento parcial. La gráfica inferior muestra un solapamiento total (100%) de los perfiles de velocidad.
Indicación
En el área de avance aproximado se trabaja con la dinámica de ejes máxima. Ello significa que el tramo que se encuentra dentro del área de avance aproximado no es un radio, sino una curva desco-nocida que se deriva de los valores dinámicos actuales de los ejes.
Ejemplo:
:
OvlVel(100) // Avance aproximado al 100%
Lin(pos1)
Lin(pos2)
OvlVel(75) // Avance aproximado al 75%
Lin(pos3)
:
0 %
50 %
100 %
1) no overlapping
Y direction
Smooth transition area
X direction
Cycle time
Cycle time
Cycle time
2) partial overlapping
3) full overlapping
11. Márgenes de avance aproximado
Festo GDCP-CMXR-SW-ES es 0805NH 87
11.3 Avance aproximado por geometría
En el avance aproximado por geometría, se fijan las desviaciones de la posición final pro-gramada. A diferencia del avance aproximado por velocidad, la asimetría es geométrica, es decir, se indica en unidades de longitud o de ángulos.
En el avance aproximado por geometría se diferencia entre el avance aproximado de los ejes cartesianos X, Y y Z y el de los ejes de orientación.
Indicación
El avance aproximado por geometría sólo puede utilizarse con movimientos cartesianos. Los movimientos PTP no se pueden efectuar con este tipo de avance aproximado.
11.3.1 Avance aproximado de los ejes X, Y y Z <OvlCart>
El avance aproximado de movimientos cartesianos con fijación geométrica se define indicando una distancia del TCP en la trayectoria hasta el punto de destino. Esta distancia es el radio de una esfera cuyo punto central conforma la posición de destino.
El movimiento de avance aproximado se inicia al entrar en la esfera y finaliza en el punto donde la esfera vuelve a cortarse con el tramo de trayectoria siguiente. Esta trayectoria circular discurre en tangente con los dos tramos de trayectoria relevantes.
Sintaxis
OvlCart (<Radius> : REAL)
Parámetro Significado Unidad
Radio Radio de avance aproximado, distancia al
punto final
Unidad de longitud ajustada
Tabla 11.2 Parámetro de la instrucción OvlCart
Esfera con radio de avance aproximado
11. Márgenes de avance aproximado
88 Festo GDCP-CMXR-SW-ES es 0805NH
Indicación
El avance aproximado se necesita muy a menudo en combinación con una velocidad de trayectoria constante. Ésta se ajusta con la instrucción VconstOn (véase el capítulo 10.6 Conexión de la velocidad de trayectoria constante en la página 80).
Ejemplo:
Un contorno debe recorrerse a una velocidad de trayectoria constante y con un radio de avance aproximado de 5 mm.
Vel(dynCart, 300) // Velocidad de trayectoria a 300 mm/s
VconstOn(25, TRUE) // Conectar vel. trayectoria const.
OvlCart(5) // Ajustar área de avance aproximado
Lin(p1)
Lin(p2)
Lin(p3)
Lin(p4)
Lin(p5)
Lin(p6)
p6
p1 p2
p3 p4
p5
Radio de avance aproximado
11. Márgenes de avance aproximado
Festo GDCP-CMXR-SW-ES es 0805NH 89
11.4 Sistemas de referencia (desplazamiento del punto cero)
Los sistemas de referencia son sistemas de coordenadas cartesianas con tres grados de libertad de movimiento de traslación y tres de rotación. La orientación se define a partir de la convención de los ángulos de Euler ZYZ.
Indicación
Como los sistemas de referencia son de tipo cartesiano, no afectan al punto cero de ejes individuales del sistema de coordenadas de ejes. Éstos sólo afectan al sistema de coordenadas cartesianas.
Al inicio de un programa está activado el sistema de coordenadas universales.
11.5 Referencia del sistema
Un sistema de referencia toma como referencia el punto cero cartesiano de un sistema de coordenadas ya definido. Los valores definidos del sistema de referencia nuevo provocan un desplazamiento en los seis grados de libertad de movimiento.
Como se aprecia en la figura, es posible definir varios sistemas de referencia en el punto cero cartesiano de otro sistema de referencia, pero sólo una referencia puede estar activa.
Indicación
El anidamiento de sistemas de referencia debe efectuarse con precaución. En ocasiones éste es un mecanismo útil para una programación eficiente aunque dificulta la lectura del programa y el anidamiento descuidado puede provocar colisiones.
X
Y
Z X
Y
Z
X
Y
Z
Punto cero del sistema de coordenadas universales
Desplazamiento 1
X
Y
Z
Desplazamiento 2
Desplazamiento aditivo al desplazamiento 2
11. Márgenes de avance aproximado
90 Festo GDCP-CMXR-SW-ES es 0805NH
Indicación
El desplazamiento del sistema de referencia consiste en una traslación y una rotación (orientación). Durante la ejecución se realiza primero el desplazamiento y después la rotación.
11.6 Datos del sistema de referencia
Los datos de un sistema de referencia se componen de una traslación tridimensional y de una indicación de orientación tridimensional. La orientación se define a partir del método de Euler ZYZ.
Estos datos se guardan en una variable de tipo de dato estructurado. El usuario puede elegir el nombre del sistema de referencia. El número de sistemas de referencia está limitado por la capacidad de memoria.
Existen diferentes posibilidades para definir los datos de un sistema de referencia:
1. Indicación directa de los valores.
2. Indicación a través de tres puntos cartesianos.
Además de los valores del sistema de referencia también es posible establecer una refer-encia en otro sistema de referencia. Además, en cada uno de los tipos de datos estructu-rados es posible referenciar a otro sistema de referencia con el parámetro RefSys. Con el parámetro RefSys pueden indicarse todas las posibilidades en los tipos de datos.
A continuación se describen las instrucciones para activar un sistema de referencia.
11. Márgenes de avance aproximado
Festo GDCP-CMXR-SW-ES es 0805NH 91
11.7 Sistema de referencia con valores directos <SetRefSys>
La instrucción SetRefSys activa un sistema de referencia cuyos datos absolutos están
registrados en la estructura de los datos de la variable transferida.
Sintaxis
SetRefSys(<refSys> : REFSYSDATA)
Parámetro Significado Unidad
refSys Sistema de referencia definido por los valores
de desplazamiento
Unidades de longitud y de ángulo
Tabla 11.3 Parámetro de la instrucción SetRefSys
Con la indicación directa del valor se revelan los valores directamente con la variable transferida. Los datos ya transferidos sólo pueden modificarse realizando de nuevo la llamada.
Estructura del tipo de dato REFSYSDATA:
baseRs : REFSYS Referencia a otro sistema de referencia
x : REAL Desplazamiento a lo largo del eje X
y : REAL Desplazamiento a lo largo del eje Y
z : REAL Desplazamiento a lo largo del eje Z
a : REAL Rotación de Euler, rotación alrededor del eje Z
b : REAL Rotación de Euler, rotación alrededor del eje Y rotado
c : REAL Rotación de Euler, rotación alrededor del eje Z rotado
Con el parámetro baseRs puede indicarse otra referencia, la cual tiene efecto aditivo en el sistema de referencia. Para referenciar el robot respecto al sistema de coordenadas universales, debe efectuarse respecto a la variable de sistema _system.world.
Ejemplo:
Datos:
refsysdata0 : REFSYSDATA := (MAPX("_system.world"),
100, 150, 0, 0, 0, 0)
Programa:
SetRefSys(refsysdata0)
11. Márgenes de avance aproximado
92 Festo GDCP-CMXR-SW-ES es 0805NH
11.8 Sistema de referencia con tres puntos <SetRefSys3P>
Con la instrucción siguiente, SetRefSys3P, se activa un sistema de referencia cuyos datos
se determinan mediante tres posiciones en el espacio.
Sintaxis
SetRefSys3P(<refSys> : REFSYS3P)
Parámetro Significado Unidad
refSys Sistema de referencia determinado por tres
posiciones
Unidades de longitud y de ángulo
Tabla 11.4 Parámetro de la instrucción SetRefSys3P
Aplicación:
Este tipo de descripción de un sistema de referencia permite realizar el teaching mediante tres posiciones. Estas tres posiciones son de tipo cartesiano y tienen seis grados de libertad de movimiento.
Significado de las posiciones:
La primera posición determina el origen del sistema de referencia.
La segunda posición determina un punto por el que discurre el eje X positivo
cartesiano del sistema de referencia.
La tercera posición determina un punto en el plano XY.
Indicación
Las orientación de las posiciones es irrelevante. Para los cálculos se necesitan sólo las posiciones cartesianas.
Estructura del tipo de dato REFSYS3P:
baseRs : REFSYS Referencia a otro sistema de referencia
p0 : CARTPOS Origen del sistema de referencia que se va a definir
px : CARTPOS Posición a lo largo del eje X
pxy : CARTPOS Posición en el plano X-Y
Con el parámetro baseRs puede indicarse otra referencia, la cual tiene efecto aditivo en el
sistema de referencia. Para referenciar el robot respecto al sistema de coordenadas uni-versales, debe efectuarse respecto a la variable de sistema _system.world.
11. Márgenes de avance aproximado
Festo GDCP-CMXR-SW-ES es 0805NH 93
Ejemplo:
Datos:
refsys3p0 : REFSYS3P := (MAPX("_system.world"),
(100, 100, 0, 0, 0, 0, 0, 0, 0),
(200, 100, 0, 0, 0, 0, 0, 0, 0),
(200, 200, 0, 0, 0, 0, 0, 0, 0))
Programa:
SetRefSys3P(refsys3p0)
11.9 Sistema de referencia universal <SetRefSysWorld>
Con esta instrucción se activa el sistema de referencia universal cuyo origen está guardado en la configuración del robot.
Sintaxis
SetRefSysWorld()
Si un sistema de referencia se activa con la instrucción SetRefSys o SetRefsys3P y se
desea desactivar dicho sistema en un punto determinado del programa, se utiliza la instrucción SetRefSysWorld.
11. Márgenes de avance aproximado
94 Festo GDCP-CMXR-SW-ES es 0805NH
11.10 Ejemplo
En el ejemplo siguiente deben vaciarse dos paletas y alimentar las piezas en una máquina.
Las dos paletas tienen el mismo contenido y las mismas dimensiones. Para no complicar la programación se activa un sistema de referencia para cada paleta y el programa de las paletas se formula en un subprograma.
Para el sistema de referencia de la paleta 1 se utiliza la variable RefPal1, y RefPal2 para la paleta 2.
Datos:
:
refPal1 : REFSYSDATA := (MAPX("_system.world"),
0, 0, 0, 0, 0, 0)
refPal2 : REFSYSDATA := (MAPX("_system.world"),
0, 0, 0, 0, 0, 0)
pos1 : CARTPOS := (100, 80, 70, 0, 0, 0, 0, 0, 0)
:
Programa:
:
refPal1.x := 300 // Desplazamiento de paleta 1 en X
refPal1.y := 300 // Desplazamiento de paleta 1 en Y
refPal2.x := 1500 // Desplazamiento de paleta 2 en X
refPal2.y := 300 // Desplazamiento de paleta 2 en Y
Lin(pos1) // Avance a seguridad en el sistema
universal
Alimentación de la máquina
X
Y
Paleta 1 Paleta 2
Sensor para detección de espacio libre
300
300 1500
11. Márgenes de avance aproximado
Festo GDCP-CMXR-SW-ES es 0805NH 95
SetRefSys(refPal1) // Activar desplazamiento de paleta 1
CALL Feed() // Llamar a subprograma Feed (alimentar
piezas)
SetRefSys(refPal2) // Activar desplazamiento de paleta 2
CALL Feed() // Llamar a subprograma Feed
SetRefSysWorld() // Activar sistema universal
Lin(pos1)
:
12. Referenciación de un robot
96 Festo GDCP-CMXR-SW-ES es 0805NH
12. Referenciación de un robot
12.1 Recorrido de referencia <RefAxis>
La instrucción RefAxis permite referenciar ejes. El recorrido de referencia se ejecuta
siempre con un único eje.
Sintaxis
RefAxis(<axis>:AXIS, OPT <refData>:REFDATA, OPT <timeout>:REAL)
Parámetros Significado Unidad
Eje Eje seleccionado que se va a referenciar Enumeración A1, A2, hasta A9
refData Conjunto de datos del recorrido de referencia,
p. ej., cómo se va a referenciar
Ninguna
timeout Tiempo para el desarrollo de la operación
(después se emite un mensaje de error, la
referenciación se interrumpe)
Segundos
Tabla 12.1 Parámetros de la instrucción RefAxis
Durante el recorrido de referencia debe observarse que los ejes participantes pueden moverse con libertad. El movimiento ejecutado es axial. Según el tipo de robot, la disposición de los ejes en la herramienta puede provocar movimientos incontrolados.
Atención
Durante el recorrido de referencia debe observarse que los ejes participantes pueden moverse con libertad. Además, deben selec-cionarse los valores dinámicos apropiados para estos movimientos de modo que el recorrido de referencia sea razonable. En este caso, unos valores dinámicos elevados razonables.
Indicación
Los parámetros refData y timeout son opcionales. Si no se indican, la posición real actual se toma como posición de referencia (DS 402 - método 35).
12. Referenciación de un robot
Festo GDCP-CMXR-SW-ES es 0805NH 97
La referenciación requiere algunos datos para su ejecución. Éstos se indican en un
conjunto de datos de referencia del tipo REFDATA.
Parámetros Tipo Significado
method DINT Método de recorrido de referencia conforme a CANopen
DS 402
offset REAL Offset de la posición de referencia [mm]
velSwitch REAL Velocidad de referenciación (arranque del interruptor)
velZero REAL Velocidad de avance lento (búsqueda del flanco)
acc REAL Aceleración del recorrido de referencia
Tabla 12.2 Estructura del tipo de dato REFDATA
Método del recorrido de referencia
El recorrido de referencia puede realizarse de varias maneras, p. ej., limitador de carrera negativo con evaluación de impulso de puesta a cero, limitador de carrera positivo con evaluación de impulso de puesta a cero o recorrido de referencia a un limitador de carrera. Todos estos métodos se encuentran en la documentación del CANopen correspondiente de cada control para accionamiento.
La tabla siguiente muestra los métodos de referenciación para equipos CANopen conforme a DS 402.
Valor Sentido Destino Punto de referencia para cero
-18 Positivo Tope Tope
-17 Negativo Tope Tope
-2 Positivo Tope Impulso de puesta a cero
-1 Negativo Tope Impulso de puesta a cero
1 Negativo Limitador de carrera Impulso de puesta a cero
2 Positivo Limitador de carrera Impulso de puesta a cero
7 Positivo Interruptor de referencia Impulso de puesta a cero
11 Negativo Interruptor de referencia Impulso de puesta a cero
17 Negativo Limitador de carrera Limitador de carrera
18 Positivo Limitador de carrera Limitador de carrera
23 Positivo Interruptor de referencia Interruptor de referencia
27 Negativo Interruptor de referencia Interruptor de referencia
33 Negativo Impulso de puesta a cero Impulso de puesta a cero
34 Positivo Impulso de puesta a cero Impulso de puesta a cero
35 - Ningún recorrido Posición real actual
Tabla 12.3 Métodos del recorrido de referencia
12. Referenciación de un robot
98 Festo GDCP-CMXR-SW-ES es 0805NH
Desplazamiento de la posición de referencia
Con el parámetro offset puede definirse un desplazamiento del punto cero en relación a la posición de referencia. Después de la referenciación se suma este valor de offset al punto cero de referencia. La indicación del valor real del eje afectado se actualiza como corresponde.
Velocidad de referenciación, velocidad de avance lento, aceleración
Con la velocidad de referenciación y la aceleración se ajusta la dinámica del eje para la referenciación. Ésta es relevante desde el inicio del recorrido de referencia hasta alcanzar el flanco del interruptor correspondiente. Cuando se detecta el flanco, se conmuta a velocidad de avance lento y se finaliza el recorrido de referencia conforme al método seleccionado.
12.2 Recorrido de referencia asíncrono <RefAxisAsync>
Con esta instrucción es posible referenciar varios ejes de robot al mismo tiempo. La instrucción no espera a que el recorrido de referencia finalice, sino que el desarrollo del programa se reanuda al activar la instrucción de referenciación. Para determinar si la referenciación ha acabado o para leer su estado existen las instrucciones WaitRefFinished y IsAxisReferenced.
Sintaxis
RefAxisAsync(<axis>:AXIS, OPT <refData>:REFDATA, OPT <timeout>:REAL)
Parámetros Significado Unidad
Eje Eje seleccionado que se va a referenciar Enumeración A1, A2, hasta A9
refData Conjunto de datos del recorrido de referencia,
p. ej., cómo se va a referenciar
Ninguna
timeout Tiempo para el desarrollo de la operación
(después se emite un mensaje de error, la
referenciación se interrumpe)
Segundos
Tabla 12.4 Parámetros de la instrucción RefAxisAsync
12. Referenciación de un robot
Festo GDCP-CMXR-SW-ES es 0805NH 99
Durante el recorrido de referencia debe observarse que los ejes participantes pueden
moverse con libertad. El movimiento ejecutado es axial. Según el tipo de robot, la disposición de ejes en la herramienta puede provocar movimientos incontrolados.
Atención
Durante el recorrido de referencia debe observarse que todos los ejes participantes pueden moverse con libertad. Además, deben seleccionarse los valores dinámicos apropiados para estos movi-mientos de modo que el recorrido de referencia sea razonable. En este caso, unos valores dinámicos elevados razonables.
Los parámetros y su funcionamiento se corresponden con la instrucción RefAxis.
12. Referenciación de un robot
100 Festo GDCP-CMXR-SW-ES es 0805NH
12.3 Espera al final del recorrido de referencia <WaitRefFinished>
Con esta instrucción se espera a que finalicen todos los recorridos de referencia asíncronos iniciados.
Sintaxis
WaitRefFinished( ) : BOOL
La instrucción espera a que finalicen los recorridos de referencia asíncronos (se espera a la ejecución principal) o a que aparezca un error en un recorrido de referencia.
Si no aparece ningún error en el recorrido de referencia se emite TRUE, de lo contrario, FALSE.
Programa:
: RefAxisAsync(A1, refdata0)
RefAxisAsync(A2, refdata0)
RefAxisAsync(A3, refdata0)
RefAxisAsync(A4)
boolReference := WaitRefFinished()
IF NOT boolReference THEN
SetError("error en la referenciación")
END_IF
12. Referenciación de un robot
Festo GDCP-CMXR-SW-ES es 0805NH 101
12.4 Interrogación del estado de un eje <IsAxisReferenced>
Con esta instrucción se interroga si un eje está referenciado.
Sintaxis
IsAxisReferenced(axis : AXIS ) : BOOL
Parámetro Significado Unidad
Eje Eje seleccionado objeto de la
interrogación
Enumeración A1, A2, hasta A9
Tabla 12.5 Parámetro de la instrucción IsAxisReferenced
Si el eje indicado está referenciado se emite TRUE, de lo contrario, FALSE.
13. Herramientas
102 Festo GDCP-CMXR-SW-ES es 0805NH
13. Herramientas El control multieje CMXR permite definir los datos de longitud de una herramienta. Estos datos se describen en forma de un vector de seis dimensiones. De ese modo puede asignarse una orientación, además de las dimensiones, a la herramienta. La orientación se define a partir del método de Euler ZYZ. El origen del vector es el punto cero en la brida de la herramienta. El extremo de la herramienta, denominado TCP (Tool Center Point), fija
el punto final. Con los datos de herramienta se determina el sistema de coordenadas de herramienta.
13.1 Datos de herramienta
13.1.1 Datos del vector TCP
Los datos de herramienta están guardados en el tipo de dato estructurado TCPTOOL. Éste contiene los datos de los seis grados de libertad de movimiento.
Estructura:
Tipo de dato TCPTOOL
x : REAL Desplazamiento a lo largo del eje X
y : REAL Desplazamiento a lo largo del eje Y
z : REAL Desplazamiento a lo largo del eje Z
a : REAL Indicación de orientación, rotación alrededor del eje Z
b : REAL Indicación de orientación, rotación alrededor del eje Y rotado
c : REAL Indicación de orientación, rotación alrededor del eje Z rotado
Z
X Y
Brida de herramienta Sistema de coordenadas del vector de seis dimensiones con origen en la brida
13. Herramientas
Festo GDCP-CMXR-SW-ES es 0805NH 103
Los tres valores de traslación X, Y y Z definen el TCP en el espacio estando todos los ejes
en posición inicial. De este modo se desplaza el sistema de coordenadas de la herramienta al TCP. Éste también puede girarse indicando su orientación (parámetros A, B y C) en el espacio.
Ejemplo de datos TCP:
Un pórtico cartesiano tiene un eje giratorio neumático en el extremo del eje Z con una pinza por vacío. La herramienta está montada en sentido del eje Z. La orientación del TCP no cambia respecto al sistema original de coordenadas del sistema.
Se obtienen los siguientes datos TCP:
X = 0
Y = 0
Z = Longitud de herramienta
A = 0
B = 0
C = 0
Ahora, la herramienta, que dispone de un eje giratorio neumático, se ha inclinado 30 grados en el espacio. El TCP se calcula con el ángulo del movimiento giratorio.
Se obtienen los siguientes datos:
X = Longitud de herramienta x sin(30°)
Y = 0
Z = Longitud de herramienta x cos(30°)
A = 0
B = 0
C = 0
La orientación del sistema de coorde-nadas de herramienta no cambia. Si es necesario, deberá ajustarse con los parámetros A, B y C.
Longitud de herramienta
Z
X
Y
Eje Z
Eje X
Asimetría en Z
Z
X
Y
Eje Z
Eje X
Asimetría en X
Ángulo de 30°
13. Herramientas
104 Festo GDCP-CMXR-SW-ES es 0805NH
Además, la orientación del sistema de coordenadas de herramienta debe apuntar en el
sentido de la herramienta rotada. Para rotar se emplea el método de Euler ZYZ.
Se obtienen los siguientes datos:
X = Longitud de herramienta x sin(30°)
Y = 0
Z = Longitud de herramienta x cos(30°)
A = 0
B = 30
C = 0
Estas descripciones de herramienta se guardan en variables. Para una herramienta pueden definirse un número ilimitado de variables TCP, pero sólo puede estar activado un conjunto de datos. Las diferentes descripciones se utilizan cuando una herramienta tiene diferentes puntos de referencia que deben intercambiarse en funcionamiento dependiendo de la tarea.
Como los datos de herramienta están guardados como variable en la memoria, su número está limitado por la capacidad de la memoria.
El programador debe asegurarse de asignar correctamente los datos TCP a la herramienta. El control multieje CMXR no conoce ninguna referencia de los datos de herramienta en relación a la herramienta física.
Atención
Si los datos TCP son inadecuados o incorrectos hay peligro de colisión.
Asimetría en Z
Z
X
Y
Eje Z
Eje X
Asimetría en X
Ángulo
13. Herramientas
Festo GDCP-CMXR-SW-ES es 0805NH 105
13.2 Activación de datos de herramienta <Tool>
Con la instrucción siguiente pueden activarse los datos de un Tool Center Point (TCP) dentro de un programa FTL. Esta instrucción de herramienta activa datos TCP nuevos para el robot. De este modo se modifica el punto de trabajo del robot.
Sintaxis
Tool (<ToolData> : TCPTOOL)
Los datos para el TCP se encuentran en la variable a transferir. Estos datos se leen en el avance de proceso del intérprete FTL y se introducen a partir de este punto en la planifi-
cación de la trayectoria del movimiento. Estos datos TCP se tienen en cuenta en todas las instrucciones siguientes.
Parámetro Significado Unidad
ToolData Datos de herramienta TCPTOOL
Tabla 13.1 Parámetro de la instrucción Tool
La llamada de la instrucción Tool no provoca ningún movimiento de posicionado, sino que
sólo da a conocer los datos TCP ahora activos. En la próxima instrucción de desplazamiento cartesiano se incluyen estos datos en el cálculo y se tienen en cuenta en la ejecución del movimiento.
Si se salta una instrucción Tool en el programa FTL, o en la unidad manual el indicador de frase para ejecución del programa está posicionado de manera que no se puede ejecutar dicha instrucción, pueden provocarse lesiones físicas o daños en la máquina. La orientación siguiente de herramienta podría no ser adecuada para el movimiento, con lo que se corre peligro de colisión.
Advertencia
Al modificar la instrucción Tool se efectúa un salto en la trayectoria cartesiana del TCP: Si el contador de programa de la unidad manual está posicionado de manera que puede saltar una instrucción Tool, ello puede provocar reacciones incontroladas durante el movimiento cartesiano.
13.2.1 Efecto de los datos TCP
Los datos TCP se activan con una instrucción en el programa FTL y se leen en el avance de proceso del intérprete. Estos datos TCP actuales se incluyen en el cálculo de la planificación de trayectoria de las instrucciones de movimiento siguientes. A continuación se presenta un ejemplo en el que se describe el comportamiento de los datos de herramienta aplicados a un eje giratorio neumático.
13. Herramientas
106 Festo GDCP-CMXR-SW-ES es 0805NH
Ejemplo:
Una unidad manual tiene un eje giratorio neumático en la brida de herramienta. Con ayuda de este eje puede girarse la herramienta a una posición fija. Este movimiento giratorio modifica la orientación de la herramienta. Para que el control multieje CMXR pueda calcular un movimiento cartesiano en el espacio teniendo en cuenta la posición del TCP debe indicarse la orientación nueva después del movimiento giratorio.
Las dos orientaciones posibles de la herramienta limitan los TCP a dos y, por tanto, a dos conjuntos de datos: tool1 y tool2.
Orientación 1, herramienta vertical:
La longitud de la herramienta vertical discurre a lo largo del eje Z del sistema de coorde-nadas de herramienta. De este modo, el TCP sólo dispone de una traslación en sentido del
eje Z, las indicaciones de orientación son 0.
Datos de herramienta para tool1:
X = 0 Desplazamiento a lo largo del eje X
Y = 0 Desplazamiento a lo largo del eje Y
Z = Longitud de herramienta Desplazamiento a lo largo del eje Z
A = 0 Rotación de Euler, rotación alrededor del eje Z
B = 0 Rotación de Euler, rotación alrededor del eje Y rotado
C = 0 Rotación de Euler, rotación alrededor del eje Z rotado
X
Z
Pinza por vacío
Y
Eje de rotación
Longitud de herramienta
TCP
13. Herramientas
Festo GDCP-CMXR-SW-ES es 0805NH 107
Orientación 2, herramienta girada:
Con el movimiento giratorio, el TCP se desplaza hacia un lado. La orientación de la herra-mienta se ha modificado.
El robot de la figura es de sistema cartesiano. En éste, la posición del sistema de coorde-nadas cartesiano de los ejes de base X, Y y Z coinciden con el sistema de coordenadas de herramienta cartesianas. Si se utiliza la regla de la mano derecha para determinar la orien-tación, la herramienta gira alrededor del eje Y en dirección positiva.
Datos de herramienta para tool2:
X = Longitud x sin(30°) Desplazamiento a lo largo del eje X
Y = 0 Desplazamiento a lo largo del eje Y
Z = Longitud x cos(30°) Desplazamiento a lo largo del eje Z
A = 0 Rotación de Euler, rotación alrededor del eje Z
B = 30 Rotación de Euler, rotación alrededor del eje Y rotado
C = 0 Rotación de Euler, rotación alrededor del eje Z rotado
Ejemplo de programa:
Nuestro robot cartesiano debe desplazarse con la herramienta vertical de una posición 1 a otra 2. A continuación, el eje giratorio gira la herramienta. Ahora, la herramienta girada
debe desplazarse a la posición 2.
Desplazamiento de pos1 a pos2:
Tool(tool1)
Lin(pos1)
Lin(pos2)
X
Z
Pinza por vacío
Y
Longitud de herramienta
Eje de rotación
TCP
13. Herramientas
108 Festo GDCP-CMXR-SW-ES es 0805NH
En el caso de las instrucciones de desplazamiento cartesiano de pos1 a pos2, el control tiene en cuenta automáticamente los datos activos de herramienta tool1.
Giro del eje giratorio:
:
Tool(tool1)
Lin(pos1)
Lin(pos2)
Call Rotate() // Llamar a subprograma
:
El movimiento giratorio provoca que el Tool Center Point (TCP) se desplace hacia arriba. Debido al eje neumático, el control no puede efectuar automáticamente movimientos de compensación. Para aproximarse a la posición 2 debe definirse la orientación nueva de la herramienta.
X
Z Y
Pieza pos1 pos2
Z
X
Y
Pieza pos1
pos2
Z
13. Herramientas
Festo GDCP-CMXR-SW-ES es 0805NH 109
Segundo desplazamiento a pos2 con tool2:
:
Tool(tool1)
Lin(pos1)
Lin(pos2)
Call Rotate() // Llamar a subprograma
Tool(tool2)
Lin(pos2)
:
La segunda vez que se efectúa el desplazamiento a la posición 2 se orienta el TCP a la posición 2 con sus datos nuevos. Según el caso, puede realizarse un movimiento de compensación con todos los ejes como máximo.
Indicación
Si se utiliza un eje giratorio eléctrico procesado como grado de libertad de movimiento en el robot cartesiano, no es necesario modificar la orientación de herramienta a diferencia del eje giratorio neumático.
Con el eje giratorio eléctrico se programa la orientación deseada dentro de una instrucción de desplazamiento.
A continuación, el control CMXR calcula automáticamente la posición de los ejes teniendo en cuenta la orientación programada.
X
Y
Pieza pos2
Z Z
Movimiento de compensación
14. Interface PROFIBUS
110 Festo GDCP-CMXR-SW-ES es 0805NH
14. Interface PROFIBUS El CMXR puede ser controlado por una unidad de control de nivel superior (PLC/IPC) mediante la interface PROFIBUS. Además, a través de ella pueden escribirse y leerse datos en forma de variables. Todos estos datos son datos compartidos de sistema y están a disposición de todos los programas FTL. La comunicación con la unidad de control de nivel superior se efectúa cíclicamente en el ciclo de actualización de PROFIBUS.
Con el nuevo arranque del sistema se ajustan todos los valores a cero. La unidad de control de nivel superior debe enviar los datos necesarios para procesar los programas antes de arrancar el programa.
Indicación
Si en un programa se necesitan datos coherentes, es importante copiarlos como datos locales antes de su procesamiento.
Indicación
Los datos de interface no se guardan en el buffer y todos tienen el valor cero cuando se arranca el sistema de nuevo. Los datos necesarios para el procesamiento deben escribirse antes de arrancar.
14.1 Entradas y salidas booleanas
La interface dispone de 16 señales de entrada y salida digitales que en adelante se verán siempre desde la perspectiva del CMXR. Las señales están disponibles en forma de variable booleana en el control. Estas señales booleanas se intercambian cíclicamente con la
unidad de control de nivel superior.
Indicación
Las variables booleanas se transmiten automáticamente a la unidad de control de nivel superior o son leídas por dicha unidad a través del ciclo de PROFIBUS.
Las variables booleanas están guardadas en una matriz a la que se accede a través de los índices 0 a 15.
Sintaxis
plc_InBool [ <Arrayindex> ] : BOOL
plc_OutBool [ <Arrayindex> ] : BOOL
En las variables de matriz plc_InBool están guardadas todas las señales de entrada. La variable de matriz plc_OutBool contiene todos los datos de salida.
Ejemplo:
14. Interface PROFIBUS
Festo GDCP-CMXR-SW-ES es 0805NH 111
:
plc_OutBool[9] := FALSE // Bit 9 a PLC en FALSE
IF plc_InBool[5] THEN // Comprobar bit 5 de PLC
Lin(pos1)
Lin(pos2)
END_IF
plc_OutBool[9] := TRUE // Bit 9 a PLC en TRUE
:
14.2 Variables del tipo integral de 32 bits
La interface dispone de 256 variables de tipo integral DINT, que comprende 32 bits. Estas variables no se someten a un intercambio de datos cíclico y el control externo puede
escribirlas o leerlas según sea necesario.
Indicación
Las variables de enteros no son leídas por la unidad de control de nivel superior ni se envían a dicha unidad automáticamente. Si es necesario deberán ser enviadas a la unidad de control de nivel superior o ser leídas por ésta.
Las variables de enteros están guardadas en una matriz a la que se accede a través de los
índices 0 a 255.
Sintaxis
plc_Dint [ <Arrayindex> ] : DINT
Ejemplo:
:
IF plc_Dint[3] = 13 THEN
:
:
END_IF
14.3 Posiciones
La interface soporta dos tipos de datos de posición. Desde el control externo es posible enviar posiciones de eje y posiciones cartesianas al control multieje CMXR. El número
14. Interface PROFIBUS
112 Festo GDCP-CMXR-SW-ES es 0805NH
máximo es de 256 posiciones de eje y 256 posiciones cartesianas. Estas variables no se
someten a un intercambio de datos cíclico y el control externo puede escribirlas o leerlas según sea necesario.
Indicación
Las variables de posición no son leídas por la unidad de control de nivel superior ni se envían a dicha unidad automáticamente. Si es necesario deberán ser enviadas por el control externo o ser leídas por éste.
Las variables de posición están guardadas en matrices. El acceso a ellas se realiza a través de los índices 0 a 255.
Indicación
plc_AxisPos [ <Arrayindex> ] : AXISPOS
plc_CartPos [ <Arrayindex> ] : CARTPOS
La variable de interface plc_AxisPos contiene 256 posiciones del tipo de dato AXISPOS; la variable plc_CartPos contiene 256 posiciones del tipo de dato CARTPOS.
Ejemplo:
:
Ptp(plc_AxisPos[17])
Lin(plc_AxisPos[18])
Lin(plc_AxisPos[19])
Lin(plc_CartPos[1])
:
14. Interface PROFIBUS
Festo GDCP-CMXR-SW-ES es 0805NH 113
14.4 Sistemas de referencia
A través de la interface externa puede definirse un máximo de 16 sistemas de referencia. Estas variables son del tipo REFSYSDATA y pueden utilizarse con la instrucción SetRefSys.
Estas variables no se someten a un intercambio de datos cíclico y el control externo puede escribirlas o leerlas según sea necesario.
Indicación
Los sistemas de referencia no son leídos por la unidad de control de nivel superior ni se envían a dicha unidad automáticamente. Si es necesario deberán ser enviados por el control externo o ser leídos por éste.
Los sistemas de referencia están guardados en una matriz a la que se accede a través de los índices 0 a 15.
Sintaxis
plc_RefSys [ <Arrayindex> ] : REFSYSDATA
El tipo de dato REFSYSDATA permite relacionar un sistema de referencia con otro de forma aditiva. La interface permite esta operación, pero sólo dentro de la propia interface, es decir, no se puede activar ninguna referencia a los sistemas de referencia ya existentes en el sistema. La referencia a otro sistema de referencia se basa en una asignación numérica
predefinida de 0 a 15 efectuada por el control externo. Si el valor establecido es -1, se activa la referencia respecto al sistema de coordenadas universales del robot.
Indicación
Los sistemas de referencia que se establecen a través de la interface externa sólo pueden enlazarse dentro de los sistemas de referencia de la interface. No es posible referenciar a un sistema de referencia definido fuera de la interface.
Ejemplo:
:
Lin(pos2)
SetRefSys (plc_RefSys [3] )
Lin(pos3)
Lin(pos4)
:
14. Interface PROFIBUS
114 Festo GDCP-CMXR-SW-ES es 0805NH
14.5 Pausa programada <ProgHold>
Esta instrucción es apropiada para efectuar pruebas o la puesta a punto. Puede insertarse en un punto cualquiera del programa para detenerse cuando se requiera. Si la pausa debe tener lugar o no, se decide externamente a través de la interface. Si esta señal está activada, es decir, si tiene el estado TRUE, el programa de movimientos se detiene llamando a la macro ProgHold. El programa se reanuda con otra instrucción de arranque.
Si la señal de detención no está colocada en la interface, el programa se ejecuta sin parar.
Sintaxis
ProgHold ( )
Para llamar a la macro no se requiere ningún parámetro.
Ejemplo:
:
OvlVel(100) // Avance aproximado completo
Lin(pos1)
Lin(pos2)
ProgHold() // Pausa programada
Lin(pos3)
Lin(pos4)
ProgHold() // Pausa programada
Lin(pos5)
:
El programa del ejemplo se aproxima a diferentes posiciones estando ajustado un avance aproximado por velocidad del 100%. Si la señal de la pausa programada está activada, el programa se para en este punto. Con ello se obtiene el siguiente desarrollo de velocidad:
14. Interface PROFIBUS
Festo GDCP-CMXR-SW-ES es 0805NH 115
Desarrollo con pausa programada:
Desarrollo sin pausa programada:
pos2 pos1 pos3 pos4 pos5
Velocidad
Tiempo
Tiempo entre instrucciones de parada y de arranque
pos2 pos1 pos3 pos4 pos5
Velocidad
Tiempo
15. Sistema de comunicación
116 Festo GDCP-CMXR-SW-ES es 0805NH
15. Sistema de comunicación Desde el programa de movimientos pueden generarse mensajes. Se distinguen los siguientes tipos de mensaje:
Información
Advertencia
Error
Estos mensajes se introducen en la memoria de mensajes del control y se archivan como corresponde. Los mensajes se borran acusando recibo de ellos en la unidad manual o a través de un control externo.
Figura de la memoria de mensajes en la unidad manual:
15.1 Textos de mensaje
La programación en FTL (Festo Teach Language) permite generar mensajes de información, advertencia y error desde el programa de movimientos. El propio usuario define libremente
los textos de mensaje como cadena de caracteres (string). Esta cadena de caracteres también puede contener entradas variables en forma de dos parámetros como máximo (p. ej., DINT, REAL, string, BOOL). Los dos parámetros opcionales se colocan introduciendo un símbolo de porcentaje y un número en el texto de mensaje.
%1 Significa primer parámetro opcional
%2 Significa segundo parámetro opcional
15. Sistema de comunicación
Festo GDCP-CMXR-SW-ES es 0805NH 117
Si se indican tipos, como posiciones de eje, sólo se inserta el nombre de variable en la
cadena de caracteres. Los tipos de datos estructurados no pueden representarse en un texto de mensaje.
Indicación
El contenido de las variables se inserta en el texto de mensaje al transferir los tipos de variable DINT, REAL y cadena de caracteres. El tipo de variable BOOL se inserta en el texto de mensaje depen-diendo de si el estado es TRUE o FALSE.
Ejemplo:
En un programa se crean dos variables con valores asignados. Estos valores se emiten con la macro SetInfo.
Variables:
param1 : DINT := 7
param2 : REAL := 3.48
Código de programa:
SetInfo (“sensor %1, valor de presión %2 bar“, param1, param2)
Se visualiza el texto de información siguiente: “Sensor 7, valor de presión 3,48 bar”.
15. Sistema de comunicación
118 Festo GDCP-CMXR-SW-ES es 0805NH
15.2 Información <SetInfo>
La instrucción SetInfo activa un mensaje de información en el sistema de comunicación.
Sintaxis
SetInfo( <text> : STRING,
OPT <param1> : ANY,
OPT <param2> : ANY)
Parámetros Significado Unidad
text Texto del mensaje de información STRING
param1 Primer parámetro posible ANY
Param2 Segundo parámetro posible ANY
Tabla 15.1 Parámetros de la instrucción SetInfo
La composición del texto de mensaje se describe en el capítulo 15.1 Textos de mensaje en la página 116.
Un mensaje de información se marca con el símbolo en la memoria de errores del
control multieje CMXR.
Indicación
Un mensaje de información no influye en el movimiento de ningún modo. Sólo sirve para informar.
Ejemplo:
pressure := Sensor.Read(); // Leer un valor de presión
cycle := cycle + 1 // Contar ciclo
SetInfo ("Cycle %1 finished, Value %2", cycle, pressure)
Indicación en la unidad manual:
15. Sistema de comunicación
Festo GDCP-CMXR-SW-ES es 0805NH 119
15.3 Advertencia <SetWarning>
La instrucción SetWarning coloca un mensaje de advertencia en el sistema de
comunicación.
Sintaxis
SetWarning( <text> : STRING,
OPT <param1> : ANY,
OPT <param2> : ANY)
Parámetros Significado Unidad
text Texto del mensaje de advertencia STRING
param1 Primer parámetro posible ANY
Param2 Segundo parámetro posible ANY
Tabla 15.2 Parámetros de la instrucción SetWarning
La composición del texto de mensaje se describe en el capítulo 15.1 Textos de mensaje en la página 116.
Un mensaje de advertencia se marca con el símbolo en la memoria de errores del
control multieje CMXR.
Indicación
Un mensaje de advertencia no influye en el movimiento de ningún modo. Sólo sirve para informar.
Ejemplo:
pressure := Sensor.Read(); // Leer un valor de presión
cycle := cycle + 1 // Contar ciclo
SetWarning("Cycle %1 finished, Value %2",cycle, pressure)
Indicación en la unidad manual:
15. Sistema de comunicación
120 Festo GDCP-CMXR-SW-ES es 0805NH
15.4 Mensaje de error <SetError>
La instrucción SetError coloca un mensaje de error en el sistema de comunicación. Esta
instrucción influye en el procesamiento del programa, parándolo. Los movimientos que se estén efectuando se detienen. Acusando recibo del mensaje de error se reanuda el programa/movimiento.
Sintaxis
SetError( <text> : STRING,
OPT <param1> : ANY,
OPT <param2> : ANY)
Parámetros Significado Unidad
Texto Texto del mensaje de error STRING
param1 Primer parámetro posible ANY
Param2 Segundo parámetro posible ANY
Tabla 15.3 Parámetros de la instrucción SetError
Un mensaje de error se marca con el símbolo en la memoria de errores del control multieje CMXR.
Indicación
La edición de un mensaje de error provoca la detención del movi-miento. El robot no puede continuar el recorrido hasta que no se acusa recibo del mensaje de error.
Ejemplo:
pressure := Sensor.Read(); // Leer un valor de presión
cycle := cycle + 1 // Contar ciclo
SetError("Cycle %1 error, pressure %2", cycle, pressure)
Indicación en la unidad manual:
Si aparece un mensaje de error, el texto de error se visualiza también en la cabecera de la unidad manual. Además, el LED de error de la unidad manual se ilumina en rojo.
16. Funciones
Festo GDCP-CMXR-SW-ES es 0805NH 121
16. Funciones
16.1 Lectura de la posición actual <ReadActualPos>
Lectura de la posición actual del robot.
Sintaxis
ReadActualPos (<Pos> : POSITION)
La posición actual del robot se escribe en la variable transferida. Si la variable transferida es del tipo CARTPOS, la posición se guarda como valor cartesiano. Si se transfiere una
variable del tipo AXISPOS, la posición se guarda en coordinadas de ejes.
Parámetro Significado Unidad
Pos Variable de destino de la
posición leída
AXISPOS o CARTPOS
Tabla 16.1 Parámetro de la instrucción ReadActualPos
Atención
Un valor de posición guardado en una variable sólo se conserva mientras el programa o el proyecto está cargado. Los valores de variable no se guardan en el archivo de datos de la tarjeta de me-moria. Los valores se pierden cuando se deselecciona el programa/ proyecto. Para guardar la posición puede utilizarse la macro SavePosition.
Ejemplo:
El programa del ejemplo lee la posición actual, recorre los movimientos programados en las instrucciones y, al final, regresa a la posición leída.
Variable:
startPos : AXISPOS := (0, 0, 0, 0, 0, 0, 0, 0, 0)
axis0 : AXISPOS := (0, 0, 0, 0, 0, 0, 0, 0, 0)
axis1 : AXISPOS := (60, -120, 0, 0, 0, 0, 0, 0, 0)
axis2 : AXISPOS := (-120, -120, -250, 0, 0, 0, 0, 0, 0)
16. Funciones
122 Festo GDCP-CMXR-SW-ES es 0805NH
Programa:
ReadActualPos(startPos)
PTP(axis0)
PTP(axis1)
PTP(axis2)
PTP(startPos)
16.2 Lectura de la posición de destino <ReadTargetPos>
Lectura de la posición de destino programada del robot.
Sintaxis
ReadTargetPos (<Pos> : POSITION)
La posición de destino actual programada del robot se escribe en la variable transferida. Si la variable transferida es del tipo CARTPOS, la posición se guarda como valor cartesiano. Si se transfiere una variable del tipo AXISPOS, la posición se guarda en coordinadas de ejes.
Parámetro Significado Unidad
Pos Variable de destino de la
posición leída
AXISPOS o CARTPOS
Tabla 16.2 Parámetro de la instrucción ReadTargetPos
Atención
Un valor de posición guardado en una variable sólo se conserva mientras el programa o el proyecto está cargado. Los valores no se guardan en el archivo de datos de la tarjeta de memoria. Los valores se pierden cuando se deselecciona el programa/proyecto. Para guardar la posición puede utilizarse la macro SavePosition.
16. Funciones
Festo GDCP-CMXR-SW-ES es 0805NH 123
16.3 Memorización del valor de posición de manera permanente <SavePosition>
La macro guarda un valor de posición de manera permanente en la tarjeta de memoria.
Sintaxis
SavePosition (<Pos> : POSITION)
Con la macro SavePosition se guardan los valores de la variable <Pos> en el archivo de
datos de la tarjeta de memoria. De este modo, la posición puede restablecerse al volver a arrancar el control.
Parámetro Significado Unidad
Pos Posición que se desea guardar AXISPOS o CARTPOS
Tabla 16.3 Parámetro de la instrucción SavePosition
Atención
La vida útil de la tarjeta de memoria se reduce si se utiliza con fre-cuencia para escribir posiciones. La macro SavePosition no debe llamarse cíclicamente en ningún caso y puede utilizarse para realizar ajustes ocasionales de la aplicación.
16.4 Lectura de la fecha y hora del sistema <Time>
Lectura de la fecha y hora del sistema en segundos desde las 00:00 horas de 01.01.1970.
Sintaxis
(<valor de fecha y hora> : DINT) := Time ( )
Esta instrucción lee la fecha y hora del sistema del control y lo devuelve como valor DINT.
Ejemplo:
value := Time() // Leer valor de fecha y hora actuales del
sistema
16. Funciones
124 Festo GDCP-CMXR-SW-ES es 0805NH
16.5 Conversión de un valor de fecha y hora en texto <TimeToStr>
Conversión de un valor de fecha y hora en texto.
Sintaxis
(<string de fecha y hora> : STRING) := TimeToStr (OPT sysTime : DINT)
Esta instrucción puede convertir una valor de fecha y hora (parámetro sysTime) en un texto con el formato “DDD mon dd hh:mm:ss yyyy”. Sin el parámetro sysTime, la fecha y hora actuales del sistema se devuelven formateadas.
El parámetro sysTime indica la fecha y hora en segundos desde las 00:00 de 01.01.1970.
Parámetros:
Parámetro Significado Unidad
sysTime Indicación opcional, valor de
fecha y hora que debe convertirse
Segundos
Tabla 16.4 Parámetro de la función TimeStr
Ejemplo:
str_Time := TimeToStr() // Leer valor de fecha y tiempo
actuales del sistema
Devolución:
str_Time = "Lun Feb 13 11:23:44 2006"
16. Funciones
Festo GDCP-CMXR-SW-ES es 0805NH 125
16.6 Seno <SIN>, <ASIN>
La función seno establece la razón matemática entre un ángulo y los lados de un triángulo rectángulo.
Fórmula:
sin(alfa) = cateto opuesto / hipotenusa
sin(alfa) = a / c
La indicación del ángulo se realiza en grados.
Sintaxis
(<valor de seno> : REAL) := SIN(<ángulo> : REAL)
Aplicación:
La función seno sirve para calcular tramos desconocidos en un triángulo rectángulo. El
tramo desconocido se calcula conociéndose el ángulo y el cateto opuesto o la hipotenusa.
Si no se conoce el ángulo, el CMXR prepara la función arco seno. Esta función calcula el ángulo contenido, p. ej., alfa, a partir del cateto opuesto y de la hipotenusa.
Sintaxis
(<ángulo en grados> : REAL) := ASIN(<valor de seno>)
La indicación del ángulo se realiza en grados.
16. Funciones
126 Festo GDCP-CMXR-SW-ES es 0805NH
Ejemplo:
a := 30 // Cateto opuesto
alpha := 23.5 // Ángulo alfa
c := a / SIN(Alpha) // Cálculo de la hipotenusa
a : = 45.89 // Cateto opuesto
c := 145.67 // Hipotenusa
value := a / c
alpha := ASIN(value) // Cálculo del ángulo
16.7 Coseno <COS>, <ACOS>
La función coseno establece la razón matemática entre un ángulo y los lados de un triángulo rectángulo.
Fórmula de coseno:
cos(alfa) = cateto adyacente / hipotenusa
cos(alfa) = b / c
La indicación del ángulo se realiza en grados.
Sintaxis
(<valor de coseno> : REAL) := COS( <ángulo>)
Aplicación:
La función coseno sirve para calcular tramos desconocidos en un triángulo rectángulo. El tramo desconocido se calcula conociéndose el ángulo y el cateto adyacente o la hipotenusa.
Si no se conoce el ángulo, el CMXR prepara la función arco coseno. Esta función calcula el ángulo contenido, p. ej., alfa, a partir del cateto adyacente y de la hipotenusa.
16. Funciones
Festo GDCP-CMXR-SW-ES es 0805NH 127
Sintaxis
(<ángulo en grados> : REAL) := ACOS(<valor de coseno>)
La indicación del ángulo se realiza en grados.
Ejemplo:
b := 30 // Cateto adyacente
alpha := 23.5 // Ángulo alfa
c := b / COS(alpha) // Cálculo de la hipotenusa
b := 45.89 // Cateto adyacente
c := 145.67 // Hipotenusa
value := b / c
alpha := ACOS(value) // Cálculo del ángulo
16. Funciones
128 Festo GDCP-CMXR-SW-ES es 0805NH
16.8 Tangente <TAN>, <ATAN>
La función tangente establece la razón matemática entre un ángulo y los lados de un triángulo rectángulo.
Fórmula de tangente:
tan(alfa) = cateto opuesto / cateto adyacente
tan(alfa) = a / b
La indicación del ángulo se realiza en grados.
Sintaxis
(<valor de tangente> : REAL) := TAN( <ángulo>)
Aplicación:
La función tangente sirve para calcular tramos desconocidos en un triángulo rectángulo. El tramo desconocido se calcula conociéndose el ángulo y el cateto adyacente o el cateto opuesto.
Si no se conoce el ángulo, el CMXR prepara la función arco tangente. Esta función calcula el ángulo contenido, p. ej., alfa, a partir del cateto adyacente y del cateto opuesto.
Sintaxis
(<ángulo en grados> : REAL) := ATAN(<valor de tangente>)
La indicación del ángulo se realiza en grados.
Ejemplo:
a := 30 // Cateto opuesto
alpha := 23.5 // Ángulo alfa
b := a / TAN(Alpha) // Cálculo del cateto adyacente
a := 45.89 // Cateto opuesto
16. Funciones
Festo GDCP-CMXR-SW-ES es 0805NH 129
b := 145.67 // Cateto adyacente
value := a / b
alpha := ASIN(value) // Cálculo del ángulo contenido
16.9 Cotangente <COT>, <ACOT>
La función cotangente establece la razón matemática entre un ángulo y los lados de un triángulo rectángulo.
Fórmula de cotangente:
Cotan(alfa) = cateto adyacente / cateto opuesto
cotan(alfa) = b / a
La indicación del ángulo se realiza en grados.
Sintaxis
(<valor de cotangente> : REAL) := COT(<ángulo>)
Aplicación:
La función cotangente sirve para calcular tramos desconocidos en un triángulo rectángulo. El tramo desconocido se calcula conociéndose el ángulo y el cateto adyacente o el cateto opuesto.
Si no se conoce el ángulo, el CMXR prepara la función arco cotangente. Esta función calcula el ángulo contenido, p. ej., alfa, a partir del cateto adyacente y del cateto opuesto.
Sintaxis
(<ángulo en grados> : REAL) := ACOT(<valor de cotangente>)
La indicación del ángulo se realiza en grados.
16. Funciones
130 Festo GDCP-CMXR-SW-ES es 0805NH
Ejemplo:
A := 30 // Cateto opuesto
Alpha := 23.5 // Ángulo alfa
B := A * COT(Alpha) // Cálculo del cateto adyacente
A := 45.89 // Cateto opuesto
B := 145.67 // Cateto adyacente
Value := B / A
Alpha := ACOT(Value) // Cálculo del ángulo contenido
16.10 Tangente 2 <ATAN2>
Calcula el arco tangente con rango de + π a –π.
Sintaxis
(<argumento> : REAL) := ATAN2 (<y> : REAL, <x> : REAL)
16.11 Logaritmo <LN>
La función logaritmo calcula el logaritmo natural del argumento transferido.
Sintaxis
(<logaritmo natural> : REAL) := LN (<valor> : REAL)
16.12 Exponente <EXP>
La función exponencial calcula el valor e(x).
Sintaxis
(<resultado> : REAL) := EXP (<valor>:REAL)
16. Funciones
Festo GDCP-CMXR-SW-ES es 0805NH 131
16.13 Valor absoluto <ABS>
La función valor absoluto devuelve el valor absoluto del valor REAL transferido. El valor devuelto es siempre positivo. Los números negativos se devuelven como valor absoluto (con signo positivo).
Sintaxis
(<valor absoluto> : REAL) := ABS (<valor> : REAL)
Ejemplo
Level := 452.98
Level := ABS(Level) // Level tiene el valor absoluto 452.98
Level := -1056.61
Level := ABS(Level) // Level tiene el valor absoluto 1056.61
16.14 Raíz cuadrada <SQRT>
La función raíz halla el valor de la raíz cuadrada de una expresión.
Sintaxis
(<valor de raíz> : REAL) := SQRT (<valor> : REAL)
Ejemplo:
Cálculo de la longitud c en un triángulo rectángulo.
Teorema de Pitágoras:
C² = A² + B² o C = √(A² + B²)
Ejemplo de programa:
A := 152.67 // Longitud del cateto A
B := 63.12 // Longitud del cateto B
Valor := A * A + B * B
C := SQRT(Value) // Cálculo de la hipotenusa
16. Funciones
132 Festo GDCP-CMXR-SW-ES es 0805NH
16.15 Desplazamiento de bits <SHR>, <SHL>
Con las funciones SHR y SHL es posible desplazar bits de datos del tipo DWORD a la derecha (función SHR) y a la izquierda (función SHL). Los bits “sobrantes” desplazados
a un lado de la variable se descartan. Los bits del otro lado se rellenan con el valor “0”.
Sintaxis
(<variable> :DWORD) := SHR (<valor : DWORD>, <count> : DINT)
(<variable> :DWORD) := SHL (<valor : DWORD>, <count> : DINT)
Ejemplo:
La instrucción siguiente desplaza 3 bits a la izquierda el contenido de la variable Mask:
Mask := SHL(Mask, 3)
Por la derecha se insertan 3 bits con el valor “0”.
Contenido de la variable:
1001 1111 0000 1100 1111 1111 1001 1100
Se obtiene el patrón de bits:
1111 1000 0110 0111 1111 1100 1110 0000
La instrucción siguiente desplaza 3 bits a la derecha el contenido de la variable Mask:
Mask := SHR(Mask, 3)
Por la izquierda se insertan 3 bits con el valor “0”.
Contenido de la variable:
1001 1111 0000 1100 1111 1111 1001 1100
Se obtiene el patrón de bits:
0001 0011 1110 0001 1001 1111 1111 0011
16. Funciones
Festo GDCP-CMXR-SW-ES es 0805NH 133
16.16 Rotación de bits <ROR>, <ROL>
Con las funciones ROR y ROL es posible rotar bits de datos del tipo DWORD a la derecha (función ROR) y a la izquierda (función ROL). Al rotar el patrón de bits, el bit que se pierde
se vuelve a insertar en el otro lado.
Sintaxis
(<variable> : DWORD) := ROR (<valor : DWORD>, <count> : DINT)
(<variable> : DWORD) := ROL (<valor : DWORD>, <count> : DINT)
Ejemplo:
La instrucción siguiente rota 4 bits a la izquierda el contenido de la variable Mask:
Mask := ROL(Mask, 4)
En el lado derecho se insertan de nuevo los 4 bits.
Contenido de la variable:
1011 1111 0110 1001 0011 000 1001 1010
Se obtiene el patrón de bits:
1111 0110 1001 0011 000 1001 1010 1011
La instrucción siguiente rota 4 bits a la derecha el contenido de la variable Mask:
Mask := ROR(Mask, 4)
En el lado izquierdo se insertan de nuevo los 4 bits.
Contenido de la variable:
1011 1111 0110 1001 0011 000 1001 1010
Se obtiene el patrón de bits:
1010 1011 1111 0110 1001 0011 000 1001
17. Módulos
134 Festo GDCP-CMXR-SW-ES es 0805NH
17. Módulos El lenguaje FTL permite utilizar subunidades. Además de datos, las subunidades contienen también componentes en forma de código de programa para conseguir una funcionalidad determinada. Para la comunicación con subunidades en FTL, dichas subunidades contienen datos de entrada y de salida.
Representación gráfica de una subunidad:
El número de datos de entrada y salida de una subunidad se guarda en FTL en un tipo de dato. Una subunidad debe declararse para ser utilizada en la aplicación. En el caso de las subunidades, esto se denomina instanciación. En esta operación se guarda una copia del paquete de subunidad con un nombre definido por el usuario (identificador). El paquete de subunidad contiene los datos de entrada y salida, así como datos internos de programa En la práctica sólo existe un código de programa.
Declaración de una instancia de subunidad
<nombre de instancia> : <tipo de instancia> (parámetro)
Subunidad: valor analógico
Código interno de programa
Datos de entrada de la subunidad
Datos de salida de la subunidad
Tipo de subunidad Valor analógico
Sistema operativo Programa FTL
Presión: tipo valor analógico
Peso: tipo valor analógico
Instanciación de subunidad en el programa de aplicación
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 135
Al igual que las variables, las instancias se guardan en el archivo de datos correspondiente.
Ejemplo de una instancia
Sensor de presión: AIN(…)
Según el tipo de subunidad se asignan datos con la declaración, p. ej., el nombre de una señal de hardware. La documentación sobre las subunidades se encuentra en los capítulos siguientes.
17.1 Funciones
Las funciones de subunidad sirven para acceder a los datos de una subunidad o llamar a funcionalidades. Para acceder a las funciones de la subunidad se necesita el nombre de
instancia y el operador punto.
Acceso a las funciones de subunidad
<nombre de instancia> . <nombre de función>
En el ejemplo se accede a la función de subunidad Read de la instancia Sensor:
merker := Sensor.Read()
En algunas funciones pueden transferirse parámetros. Consulte la descripción de cada una de las subunidades en los capítulos siguientes.
17.2 Variables
Además de funciones, las subunidades pueden contener variables. Con estas variables puede accederse a los datos de la subunidad. Para acceder a las variables de la subunidad se necesita el nombre de instancia y el operador punto.
Acceso a variables de subunidad
<nombre de instancia> . <nombre de variable>
Para acceder a los datos de algunas subunidades pueden utilizarse variables o funciones indistintamente. Los dos tipos de acceso requieren un tiempo de ejecución diferente. Para
más información, consulte la descripción de cada una de las subunidades en los capítulos siguientes.
En el ejemplo se accede a la variable de subunidad State de la instancia Sensor:
IF Sensor.state THEN
Lin(pos1)
17. Módulos
136 Festo GDCP-CMXR-SW-ES es 0805NH
ELSE
Lin(pos2)
END_IF
Recomendación:
Si el acceso puede efectuarse mediante una variable, debe utilizarse preferentemente dicha variable ya que requiere menos tiempo de ejecución.
17.3 Comportamiento del tiempo de operación
El programa FTL no se ejecuta cíclicamente sino que procesa secuencialmente instrucción a instrucción. Este comportamiento es insuficiente para algunas aplicaciones. P. ej., una
prueba para verificar si se ha cambiado el flanco en una entrada al mismo tiempo que se ejecuta un programa de movimientos tendría que efectuarse en un programa paralelo, con el trabajo añadido que ello implicaría. A fin de mejorar la comodidad de edición de una subunidad, algunas subunidades funcionan cíclicamente en el sistema operativo. Así, el usuario puede acceder a los resultados de la subunidad con los métodos o variables.
17.3.1 Parámetro ovlEnable
Algunos métodos de las subunidades siguientes poseen un parámetro opcional denominado ovlEnable. Este parámetro regula el momento de interrogación de la señal
de entrada digital. El parámetro es del tipo BOOL y puede tomar el estado TRUE o FALSE.
Estado FALSE
El avance de proceso se detiene en este punto. Si el proceso principal alcanza esta instrucción de programa, la señal se lee o se ejecuta. El movimiento se detiene y vuelve a acelerarse después de la instrucción. No es posible el avance aproximado a los movi-mientos siguientes.
Estado TRUE
Si el parámetro ovlEnable devuelve el estado TRUE, la señal se lee o se ejecuta a más tardar en el último punto donde aún sea posible reanudar el movimiento. El movimiento no se detiene sino que avanza continuamente. No es posible el avance aproximado a los movimientos siguientes.
Indicación
Si no se especifica el parámetro, se supone FALSE.
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 137
17.4 Subunidad de entrada digital DIN
La subunidad DIN sirve para interrogar y administrar una entrada digital.
17.4.1 Instanciación
Para instanciar la subunidad de entrada digital se requiere la referencia de hardware de la entrada digital. Ésta se indica con el parámetro <input> durante la instanciación.
Sintaxis
<nombre de instancia> .DIN( <timeout> : DINT,
<RisingEdge> : BOOL,
MAPX(“< input>“))
Es posible indicar otros parámetros para, p. ej., realizar ajustes previos. Sin embargo, esto no es necesario para la instanciación y puede efectuarse en el programa.
Ejemplo:
Un sensor se guarda como instancia de subunidad:
Instanciación en el archivo de datos:
Sensor : DIN := (-1, FALSE, MAPX("_system.Input1"))
Instanciación con el editor FTL
La instanciación se efectúa en el diálogo para crear variables seleccionando <tipo:> (DIN) e introduciendo el <identificador:> (Sensor). En la línea <MAPTO DINPORT> se activa la
referencia real a una entrada digital configurada.
Instanciación con la unidad manual
La instanciación de la subunidad de entrada digital por medio de la unidad manual se realiza en la máscara de variables seleccionando el tipo de dato DIN. La entrada se guarda auto-máticamente en el archivo de datos.
17. Módulos
138 Festo GDCP-CMXR-SW-ES es 0805NH
La subunidad de entrada digital posee las variables siguientes:
Variables Tipo Significado Estado al crear
Timeout REAL Timeout para esperar a las instrucciones Wait y WaitN.
-1 = Ningún timeout (espera sin límite de tiempo)
0 = Comprobación inmediata
>0 = Timeout en milisegundos
-1
RisingEdge BOOL Estado del flanco de subida FALSE
Input DINPORT Referencia a la entrada de hardware ---
Tabla 17.1 Variables de la subunidad de entrada digital
Timeout
Con el parámetro timeout puede definirse un tiempo de espera. El método de la subunidad espera al estado de señal requerido durante el tiempo ajustado.
Si el valor es -1, la espera no tiene límite.
Si se introduce un valor > 0, la espera se reduce a este tiempo máximo. La ejecución del programa se reanuda si el tiempo de espera finaliza sin aparecer el estado de señal deseado. El propio programa secuencial debe generar un mensaje de error.
Si se indica el valor 0, se realiza una comprobación inmediatamente. Si la señal no tiene el valor deseado, el programa secuencial debe generar un mensaje de error.
Más información y ejemplos para generar mensajes de error se describen en el capítulo 19.2 Empleo de las subunidades de entrada y salida.
RisingEdge
Aunque no se ha llamado a la subunidad, ésta guarda el estado de un flanco de subida.
Dicho estado puede evaluarse en el programa.
Input
La variable Input describe la referencia a la entrada de hardware de la subunidad.
17.4.2 Métodos
La subunidad dispone de varios métodos:
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 139
Métodos Descripción
Wait Esperar a que la entrada tenga el estado TRUE
WaitN Esperar a que la entrada tenga el estado FALSE
Read Leer el estado de la entrada
RisingEdge Leer el estado del flanco de subida
ResetRisingEdge Borrar el estado del flanco de subida
Tabla 17.2 Métodos de la subunidad de entrada digital DIN
En el editor FTL se visualiza automáticamente una lista con los métodos disponibles introduciendo el punto. Los métodos pueden seleccionarse en dicha lista.
En la unidad manual, los métodos pueden seleccionarse mediante el árbol de menú en el punto “Digital Inputs”.
En la figura se muestra la selección de métodos de la subunidad DIN de la unidad manual.
17. Módulos
140 Festo GDCP-CMXR-SW-ES es 0805NH
17.4.3 Espera a estado, métodos Wait/WaitN
En el programa FTL, los métodos Wait y WaitN permiten esperar a que la entrada tome el valor TRUE o FALSE. Si hay un timeout, se espera a que finalice.
Sintaxis
<nombre de instancia>.Wait (OPT ovlEnable : BOOL)
<nombre de instancia>.WaitN (OPT ovlEnable : BOOL)
Para la descripción del parámetro ovlEnable, véase el capítulo 17.3.1 de la página 136.
Ejemplo:
Ptp(pos0)
sensor.Wait() // Esperar a señal TRUE, movimiento
detenido
Ptp(pos1)
sensor.WaitN(TRUE) // Esperar a señal FALSE, sin parada
Ptp(pos2)
17.4.4 Método Read para lectura de estado
Con el método Read puede leerse el estado actual de la entrada. Los valores de retorno
son los estados TRUE o FALSE.
Sintaxis
<nombre de instancia>.Read (OPT ovlEnable: BOOL) : BOOL
Para la descripción del parámetro ovlEnable, véase el capítulo 17.3.1 en la página 136.
Ejemplo:
value := sensor.Read()
17.4.5 Método RisingEdge para flanco de subida
Con el método RisingEdge se interroga si hubo un flanco de subida en la entrada, guardado a continuación. El valor de retorno sigue siendo TRUE aunque la entrada hubiese cambiado entre tanto a FALSE. El estado del flanco se determina independientemente del ciclo del programa FTL y se ejecuta en un ciclo propio.
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 141
Sintaxis
<nombre de instancia>.RisingEdge (OPT ovlEnable: BOOL) : BOOL
Para la descripción del parámetro ovlEnable, véase el capítulo 17.3.1 en la página 136.
Ejemplo:
value := sensor.RisingEdge()
17.4.6 Método ResetRisingEdge para borrar flancos
Este método borra la marca interna del flanco de subida. Ello es necesario para comprobar un flanco de subida con el método RisingEdge.
Sintaxis
<nombre de instancia>.ResetRisingEdge()
Indicación
Si el valor de la entrada digital está activado en el momento en que se ejecuta esta instrucción, el estado de detección del flanco se borra y no se activa de nuevo hasta que no vuelve a aparecer un flanco positivo (modificación de estado de la entrada de 0 a 1) en la entrada.
Ejemplo:
sensor.ResetRisingEdge()
value := sensor.RisingEgde()
17.5 Subunidad de salida digital DOUT
La subunidad DOUT sirve para interrogar y administrar una salida digital.
17.5.1 Instanciación
Para instanciar la subunidad de salida digital se requiere la referencia de hardware de la salida digital. Ésta se indica con el parámetro <output> durante la instanciación.
Sintaxis <nombre de instancia> .DOUT( <timeout> : DINT,
<RisingEdge> : BOOL,
MAPX(“< output>“))
17. Módulos
142 Festo GDCP-CMXR-SW-ES es 0805NH
Es posible indicar otros parámetros para, p. ej., realizar ajustes previos. Sin embargo, esto
no es necesario para la instanciación y puede efectuarse en el programa.
Ejemplo:
Un cilindro se guarda como instancia de subunidad:
Instanciación en el archivo de datos:
cylinder : DOUT := (-1,FALSE, MAPX("_system.Output3"))
Instanciación con el editor FTL
La instanciación se efectúa en el diálogo para crear variables seleccionando <tipo:> (DOUT)
e introduciendo el <identificador:> (Cylinder). En la línea <MAPTO DOUTPORT> se activa la referencia real a una salida digital configurada.
Instanciación con la unidad manual
La instanciación de la subunidad de salida digital por medio de la unidad manual se realiza en la máscara de variables seleccionando el tipo de dato DOUT.
La instanciación en la unidad manual guarda automáticamente la entrada en el archivo de datos.
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 143
17.5.2 Variables
La subunidad de salida digital posee las variables siguientes:
Variables Tipo Significado Estado al crear
Timeout REAL Timeout para esperar a las instrucciones Wait y WaitN.
-1 = Ningún timeout (espera sin límite de tiempo)
0 = Comprobación inmediata
>0 = Timeout en milisegundos
-1
RisingEdge BOOL Estado del flanco de subida FALSE
Output DOUTPORT Referencia a la salida de hardware ---
Tabla 17.3 Variables de la subunidad de salida digital
Timeout
Con el parámetro timeout puede definirse un tiempo de espera. El método de la subunidad espera al estado de señal requerido durante el tiempo ajustado.
Si el valor es -1, la espera no tiene límite.
Si se introduce un valor > 0, la espera se reduce a este tiempo máximo. La ejecución del programa se reanuda si el tiempo de espera finaliza sin aparecer el estado de señal deseado. El propio programa secuencial debe generar un mensaje de error.
Si se indica el valor 0, se realiza una comprobación inmediatamente. Si la señal no tiene el valor deseado, el programa secuencial debe generar un mensaje de error.
Más información y ejemplos para generar mensajes de error se describen en el capítulo
19.2 Empleo de las subunidades de entrada y salida.
RisingEdge
Aunque no se ha llamado a la subunidad, ésta guarda el estado de un flanco de subida. Dicho estado puede evaluarse en el programa.
Output
La variable output describe la referencia a la salida de hardware de la subunidad.
17. Módulos
144 Festo GDCP-CMXR-SW-ES es 0805NH
17.5.3 Métodos
La subunidad dispone de varios métodos:
Métodos Descripción
Wait Esperar a que la salida tenga el valor TRUE
WaitN Esperar a que la salida tenga el valor FALSE
Read Leer el valor de salida
RisingEdge Leer el estado del flanco de subida
ResetRisingEdge Borrar el estado del flanco de subida
Set Activar salida, estado TRUE
Reset Borrar salida, estado FALSE
Write Activar salida al valor indicado
Tabla 17.4 Métodos de la subunidad de salida digital DOUT
En la unidad manual, los métodos pueden seleccionarse mediante el árbol de menú en el punto “Digital outputs”.
En el editor FTL se visualiza automáticamente una lista con los métodos disponibles introduciendo el punto. Los métodos pueden seleccionarse en dicha lista.
En la figura se muestra la selección de métodos de la subunidad DOUT de la unidad manual.
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 145
17.5.4 Espera a estado, métodos Wait/WaitN
En el programa FTL, los métodos Wait y WaitN permiten esperar a que la salida tome el
valor TRUE o FALSE. Si hay un timeout, se espera a que finalice.
Sintaxis
<nombre de instancia>.Wait (OPT ovlEnable : BOOL)
<nombre de instancia>.WaitN (OPT ovlEnable : BOOL)
Para la descripción del parámetro ovlEnable, véase el capítulo 17.3.1 de la página 136.
Ejemplo:
Ptp(pos0)
cylinder.Wait() // Esperar a salida TRUE, movimiento
detenido
Ptp(pos1)
cylinder.WaitN(TRUE) // Esperar a salida FALSE, sin parada
Ptp(pos2)
17.5.5 Método Read para lectura de estado
Con el método Read puede leerse el estado actual de la salida. Los valores de retorno son
los estados TRUE o FALSE.
Sintaxis
<nombre de instancia>.Read (OPT ovlEnable: BOOL) : BOOL
Para la descripción del parámetro ovlEnable, véase el capítulo 17.3.1 de la página 136.
Ejemplo:
value := cylinder.Read()
17.5.6 Método RisingEdge para flanco de subida
Con el método RisingEdge se interroga si hubo un flanco de subida en la salida, guardado
a continuación. El valor de retorno sigue siendo TRUE aunque la salida hubiese cambiado entre tanto a FALSE. El estado del flanco se determina independientemente del ciclo del programa FTL y se ejecuta en un ciclo propio.
Sintaxis
<nombre de instancia>.RisingEdge (OPT ovlEnable: BOOL) : BOOL
17. Módulos
146 Festo GDCP-CMXR-SW-ES es 0805NH
Para la descripción del parámetro ovlEnable, véase el capítulo 17.3.1 en la página 136.
Ejemplo:
value := cylinder.RisingEdge()
17.5.7 Borrado de flancos, ResetRisingEdge
Este método borra la marca interna del flanco de subida. Ello es necesario para comprobar un flanco de subida con el método RisingEdge.
Sintaxis
<nombre de instancia>.ResetRisingEdge()
Indicación
Si el valor de la salida digital está activado en el momento en que se ejecuta esta instrucción, el estado de detección del flanco se borra y no se activa de nuevo hasta que no vuelve a aparecer un flanco positivo (modificación de estado de la salida de 0 a 1) en la salida.
Ejemplo:
cylinder.ResetRisingEdge()
value := cylinder.RisingEgde()
17.5.8 Activación y borrado, métodos Set/Reset
Con el método Set se activa una salida (estado TRUE) y con Reset se borra (estado FALSE).
Sintaxis
<nombre de instancia>.Set ( )
<nombre de instancia>.Reset ( )
Set y Reset se ejecutan en la ejecución principal. La subunidad NO influye en el avance aproximado.
Ejemplo:
Lin(pos1)
Lin(pos2)
cylinder.Set() // Activa la salida cylinder a TRUE
Lin(pos3)
cylinder.Reset() // Activa la salida cylinder a FALSE
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 147
Lin(pos4)
17.5.9 Activación de la salida, método Write
Con el método Write es posible describir el estado de una salida. El estado TRUE o FALSE se devuelve como parámetro. Write funciona igual que los métodos Set y Reset.
Sintaxis
<nombre de instancia>.Write (Value: BOOL)
El método Write se procesa en la ejecución principal. La subunidad NO influye en el avance
aproximado.
Ejemplo:
cylinder.Write(TRUE) // Activa la salida cylinder a TRUE
state := FALSE
cylinder.Write(state) // Activa la salida cylinder a FALSE
17.6 Subunidad de entrada analógica AIN
La subunidad AIN sirve para interrogar y administrar una entrada analógica.
17.6.1 Instanciación
Para instanciar la subunidad de entrada analógica se requiere la referencia de hardware de la entrada analógica. Ésta se indica con el parámetro input durante la instanciación.
Sintaxis
<nombre de instancia> .AIN( <timeout> : DINT, MAPX(“< input>“))
El parámetro Input es el nombre con el que se designa la entrada de hardware. Esta asig-nación activa una relación entre la subunidad y el hardware. Es posible indicar otros pará-metros para, p. ej., realizar ajustes previos. Sin embargo, esto no es necesario para la instanciación y puede efectuarse en el programa.
Ejemplo:
Un sensor se guarda como instancia de subunidad:
17. Módulos
148 Festo GDCP-CMXR-SW-ES es 0805NH
Instanciación en el archivo de datos:
temperature : AIN := (-1, MAPX("_system.Sensor1"))
Instanciación con el editor FTL
La instanciación se efectúa en el diálogo para crear variables seleccionando <tipo:> (AIN) e introduciendo el <identificador:> (ainTemperature). En la línea <MAPTO AINPORT> se activa la referencia real a una entrada analógica configurada.
Instanciación con la unidad manual
La instanciación de la subunidad de entrada analógica por medio de la unidad manual se realiza en la máscara de variables seleccionando el tipo de dato AIN.
La instanciación en la unidad manual guarda automáticamente la entrada en el archivo de datos.
17.6.2 Variables
La subunidad de entrada analógica posee las variables siguientes:
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 149
Variables Tipo Significado Estado al crear
Timeout REAL Timeout para esperar a las instrucciones WaitLss, WaitGrt,
WaitIns y Waitouts.
-1 = Ningún timeout (espera sin límite de tiempo)
0 = Comprobación inmediata
>0 = Timeout en milisegundos
-1
Input AINPORT Referencia a la entrada de hardware ---
Tabla 17.5 Variables de la subunidad de entrada analógica
Timeout
Con el parámetro timeout puede definirse un tiempo de espera. El método de la subunidad espera al estado de señal requerido durante el tiempo ajustado.
Si el valor es -1, la espera no tiene límite.
Si se introduce un valor > 0, la espera se reduce a este tiempo máximo. La ejecución
del programa se reanuda si el tiempo de espera finaliza sin aparecer el estado de señal deseado. El propio programa secuencial debe generar un mensaje de error.
Si se indica el valor 0, se realiza una comprobación inmediatamente. Si la señal no tiene el valor deseado, el programa secuencial debe generar un mensaje de error.
Más información y ejemplos para generar mensajes de error se describen en el capítulo 19.2 Empleo de las subunidades de entrada y salida.
Input
La variable input describe la referencia a la entrada de hardware de la subunidad.
17.6.3 Métodos
La subunidad dispone de varios métodos:
Métodos Descripción
WaitLss Esperar a que el valor de entrada sea menor que el indicado
WaitGrt Esperar a que el valor de entrada sea mayor que el indicado
WaitIns Esperar a que el valor de entrada se encuentre dentro del límite
indicado
WaitOuts Esperar a que el valor de entrada se encuentre fuera del límite
indicado
Read Leer el valor de entrada
Tabla 17.6 Métodos de la subunidad de entrada analógica
En el editor FTL se visualiza automáticamente una lista con los métodos disponibles introduciendo el punto. Los métodos pueden seleccionarse en dicha lista.
17. Módulos
150 Festo GDCP-CMXR-SW-ES es 0805NH
En la unidad manual, los métodos pueden seleccionarse mediante el árbol de menú en el
punto “Analog Inputs”.
En la figura se muestra la selección de métodos de la subunidad AIN de la unidad manual.
17.6.4 Espera a que el valor sea menor/mayor, métodos WaitLss, WaitGrt
Los métodos WaitLss y WaitGrt permiten interrogar una entrada analógica para conocer
si un estado es mayor o menor que el valor indicado. Si la subunidad tiene un parámetro timeout, éste se tiene en cuenta.
Sintaxis
<nombre de instancia>.WaitLss(value : REAL, OPT ovlEnable : BOOL)
<nombre de instancia>.WaitGrt(value : REAL, OPT ovlEnable : BOOL)
Para la descripción del parámetro ovlEnable, véase el capítulo 17.3.1 de la página 136.
Parámetro Tipo Significado
value REAL Valor límite
Tabla 17.7 Parámetro de los métodos WaitLss, WaitGrt
Ejemplo:
Lin(pos1)
temperature.WaitLss(65.0, TRUE)
Lin(pos2)
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 151
17.6.5 Espera a que el valor entre/salga de un margen, métodos WaitIns, WaitOuts
Con los métodos WaitIns y WaitOuts es posible esperar a que el valor de entrada
analógico se encuentre dentro o fuera del margen de valores indicado. Si la subunidad tiene un parámetro timeout, éste se tiene en cuenta.
Sintaxis
<nombre de instancia>.WaitIns( minValue : REAL,
maxValue : REAL,
OPT ovlEnable : BOOL)
<nombre de instancia>.WaitOuts( minValue : REAL,
maxValue : REAL,
OPT ovlEnable : BOOL)
Para la descripción del parámetro ovlEnable, véase el capítulo 17.3.1 en la página 136.
Parámetros Tipo Significado
minValue REAL Valor límite inferior
maxValue REAL Valor límite superior
Tabla 17.8 Parámetros de los métodos WaitIns, WaitOuts
Ejemplo
Lin(pos1)
// Esperar a que la temperatura se encuentre dentro de los
límites
temperature.WaitIns(50.0, 55.0, TRUE)
Lin(pos2)
17.6.6 Interrogación del valor, método Read
El método Read lee el valor actual de la entrada analógica.
Sintaxis
<nombre de instancia>.Read(OPT ovlEnable)
Para la descripción del parámetro ovlEnable, véase el capítulo 17.3.1 de la página 136.
17. Módulos
152 Festo GDCP-CMXR-SW-ES es 0805NH
Ejemplo
Lin(pos1)
// Leer la temperatura sin parar la trayectoria
value := temperature.Read(TRUE)
Lin(pos2)
17.7 Subunidad de salida analógica AOUT
La subunidad AOUT sirve para interrogar y administrar una salida analógica.
17.7.1 Instanciación
Para instanciar la subunidad de salida analógica se requiere la referencia de hardware de
la salida analógica. Ésta se indica con el parámetro <port> durante la instanciación.
Sintaxis
<nombre de instancia> .AOUT( <timeout> : DINT, MAPX(“< port>“))
Es posible indicar otros parámetros para, p. ej., realizar ajustes previos. Sin embargo, esto no es necesario para la instanciación y puede efectuarse en el programa.
Ejemplo:
Una cantidad se guarda como instancia de subunidad:
Instanciación en el archivo de datos:
quantity : AOUT := (-1, MAPX("_system.SetValue"))
Instanciación con el editor FTL
La instanciación se efectúa en el diálogo para crear variables seleccionando <tipo:> (AOUT) e introduciendo el <identificador:> (aoutQuantity). En la línea <MAPTO AOUTPORT> se activa la referencia real a una salida analógica configurada.
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 153
Instanciación con la unidad manual
La instanciación de la subunidad de salida analógica por medio de la unidad manual se realiza en la máscara de variables seleccionando el tipo de dato AOUT.
La instanciación en la unidad manual guarda automáticamente la entrada en el archivo de datos.
17.7.2 Variables
La subunidad de salida analógica posee las variables siguientes:
Variables Tipo Significado Estado al crear
Timeout REAL Timeout para esperar a las instrucciones WaitLss, WaitGrt,
WaitIns y Waitouts.
-1 = Ningún timeout (espera sin límite de tiempo)
0 = Comprobación inmediata
>0 = Timeout en milisegundos
-1
Output AOUTPORT Referencia a la salida de hardware ---
Tabla 17.9 Variables de la subunidad de salida analógica
Timeout
Con el parámetro timeout puede definirse un tiempo de espera. El método de la subunidad espera al estado de señal requerido durante el tiempo ajustado.
Si el valor es -1, la espera no tiene límite.
Si se introduce un valor > 0, la espera se reduce a este tiempo máximo. La ejecución
del programa se reanuda si el tiempo de espera finaliza sin aparecer el estado de señal deseado. El propio programa secuencial debe generar un mensaje de error.
Si se indica el valor 0, se realiza una comprobación inmediatamente. Si la señal no
tiene el valor deseado, el programa secuencial debe generar un mensaje de error.
Más información y ejemplos para generar mensajes de error se describen en el capítulo 19.2 Empleo de las subunidades de entrada y salida.
17. Módulos
154 Festo GDCP-CMXR-SW-ES es 0805NH
Output
La variable output describe la referencia a la salida de hardware de la subunidad.
17.7.3 Métodos
La subunidad dispone de varios métodos:
Métodos Descripción
Write Escribir un valor en la salida analógica
WaitLss Esperar a que el valor de salida sea menor que el indicado
WaitGrt Esperar a que el valor de salida sea mayor que el indicado
WaitIns Esperar a que el valor de salida se encuentre dentro del límite
indicado
WaitOuts Esperar a que el valor de salida se encuentre fuera del límite
indicado
Read Leer el valor de salida
Tabla 17.10 Métodos de la subunidad de salida analógica
En el editor FTL se visualiza automáticamente una lista con los métodos disponibles introduciendo el punto. Los métodos pueden seleccionarse en dicha lista.
En la unidad manual, los métodos pueden seleccionarse mediante el árbol de menú en el punto “Analog Outputs”.
En la figura se muestra la selección de métodos de la subunidad AOUT de la unidad
manual.
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 155
17.7.4 Escritura del valor de salida, método Write
Con el método Write se escribe una salida analógica. El valor nominal se devuelve en el
parámetro value.
Sintaxis
<nombre de instancia>.Write(value :REAL)
Parámetro Tipo Significado
value REAL Valor nominal para la salida analógica
Tabla 17.11 Parámetro del método Write
Ejemplo:
quantity.Write(110.0) // Activa la salida a 110.0
value := 1.3
quantity.Write(value) // Activa la salida a 1.3
17.7.5 Espera a que el valor sea mayor/menor, métodos WaitLss, WaitGrt
Los métodos WaitLss y WaitGrt permiten interrogar una salida analógica para conocer si
un estado es mayor o menor que el valor indicado. Si la subunidad tiene un parámetro timeout, éste se tiene en cuenta.
Sintaxis
<nombre de instancia>.WaitLss(value : REAL, OPT ovlEnable : BOOL)
<nombre de instancia>.WaitGrt(value : REAL, OPT ovlEnable : BOOL)
Para la descripción del parámetro ovlEnable, véase el capítulo 17.3.1 de la página 136.
Parámetro Tipo Significado
value REAL Valor límite
Tabla 17.12 Parámetro de los métodos WaitLss, WaitGrt
Ejemplo:
Lin(pos1)
// Esperar a que el valor sea menor que 110.0
quantity.WaitLss(110.0, TRUE)
Lin(pos2)
17. Módulos
156 Festo GDCP-CMXR-SW-ES es 0805NH
17.7.6 Espera a que el valor entre/salga de un margen, métodos WaitIns, WaitOuts
Con los métodos WaitIns y WaitOuts es posible esperar a que el valor de salida analógico
se encuentre dentro o fuera del margen de valores indicado. Si la subunidad tiene un parámetro timeout, éste se tiene en cuenta.
Sintaxis
<nombre de instancia>.WaitIns(minValue : REAL,
maxValue : REAL, OPT ovlEnable : BOOL)
<nombre de instancia>.WaitOuts(minValue : REAL,
maxValue : REAL, OPT ovlEnable : BOOL)
Para la descripción del parámetro ovlEnable, véase el capítulo 17.3.1 de la página 136.
Parámetros Tipo Significado
minValue REAL Valor límite inferior
maxValue REAL Valor límite superior
Tabla 17.13 Parámetros de los métodos WaitIns, WaitOuts
Ejemplo
Lin(pos1)
// Esperar a que la cantidad se encuentre entre los límites
quantity.WaitIns(100.0, 110.0, TRUE)
Lin(pos2)
17.7.7 Lectura del valor de salida, método Read
El método Read lee el valor actual de la salida analógica.
Sintaxis
<nombre de instancia>.Read(OPT ovlEnable)
Para la descripción del parámetro ovlEnable, véase el capítulo 17.3.1 en la página 136.
Ejemplo
Lin(pos1)
// Leer la cantidad sin parar la trayectoria
value := quantity.Read(TRUE)
Lin(pos2)
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 157
17.8 Subunidad de reloj CLOCK
La subunidad de reloj (temporizador) puede utilizarse para cronometrar durante la ejecución del programa. El tiempo se mide en milisegundos.
17.8.1 Instanciación
Para instanciar la subunidad de reloj CLOCK se requiere el nombre de la subunidad. Dicha
subunidad no tiene variables.
Instanciación
<nombre de instancia> : CLOCK
Instanciación en el archivo de datos:
Timer : CLOCK
Instanciación con el editor FTL
La instanciación se efectúa en el diálogo para crear variables seleccionando <tipo:> (CLOCK) e introduciendo el <identificador:> (clkTimer).
Instanciación con la unidad manual
La instanciación de la subunidad de reloj por medio de la unidad manual se realiza en la máscara de variables seleccionando el tipo de dato CLOCK.
17. Módulos
158 Festo GDCP-CMXR-SW-ES es 0805NH
La instanciación en la unidad manual guarda automáticamente la entrada en el archivo de datos.
17.8.2 Métodos
La subunidad de reloj dispone de varios métodos:
Métodos Descripción
Reset Borrado de la hora
Start Poner en marcha el reloj
Stop Detener el reloj
Read Leer el tiempo detenido en ms
ToStr Conversión del tiempo en una cadena de caracteres
Tabla 17.14 Métodos de la subunidad de reloj
En el editor FTL se visualiza automáticamente una lista con los métodos disponibles intro-duciendo el punto. Los métodos pueden seleccionarse en dicha lista.
En la unidad manual, los métodos pueden seleccionarse mediante el árbol de menú en el punto “Timing Blocks”.
En la figura se muestra la selección de métodos de la subunidad CLOCK de la unidad
manual.
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 159
17.8.3 Puesta en marcha del reloj, método Start
Con el método Start se pone en marcha el temporizador. El punto inicial se guarda
internamente en la subunidad. Si se activa un Start en un temporizador ya parado, el temporizador vuelve a ponerse en marcha y el tiempo sigue corriendo. El temporizador sólo se puede reiniciar desde cero con la instrucción Reset.
Sintaxis
<nombre de instancia>.Start ( )
Ejemplo:
Timer.Start() // El reloj se pone en marcha
17.8.4 Parada del reloj, método Stop
El método Stop detiene el cronometraje. El tiempo transcurrido se calcula en la subunidad
y se visualiza para su lectura.
Sintaxis
<nombre de instancia>.Stop ( )
Ejemplo:
Timer.Stop() // El reloj se detiene
17.8.5 Borrado del reloj, método Reset
Con el método Reset se pone a cero el temporizador. Si el método Reset se ejecuta cuando
el temporizador está en marcha, éste se coloca a 0 y sigue funcionando.
Sintaxis
<nombre de instancia>.Reset ( )
Ejemplo:
Timer.Reset() // El reloj se borra
17.8.6 Lectura del reloj, método Read
Con el método Read es posible leer el valor de fecha y hora en milisegundos (ms).
17. Módulos
160 Festo GDCP-CMXR-SW-ES es 0805NH
Sintaxis
<nombre de instancia>.Read(OPT ovlEnable : BOOL) : DINT
Para la descripción del parámetro ovlEnable, véase el capítulo 17.3.1 de la página 136.
Valor de retorno: tiempo medido en milisegundos (ms)
Ejemplo:
Datos:
value : DINT
Programa:
:
Lin(pos1)
value := Timer.Read() // Leer parando la trayectoria
Lin(pos2)
value := Timer.Read(TRUE) // Leer en el proceso principal
Lin(pos3)
:
17.8.7 Conversión del valor de fecha y hora en cadena de caracteres
Con el método ToStr se convierte el valor de fecha y hora actuales en una cadena de
caracteres con la estructura siguiente <días> <horas>:<minutos>:<segundos>:<milisegundos>.
Sintaxis
<nombre de instancia>.ToStr(OPT ovlEnable : BOOL) : STRING
Para la descripción del parámetro ovlEnable, véase el capítulo 17.3.1 de la página 136.
Valor de retorno: cadena de caracteres con la información de fecha y hora
dd hh:mm:ss:ms
Ejemplo:
Datos:
tiempo : STRING
Programa:
Lin(pos1)
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 161
tiempo := Timer.ToStr() // Leer parando la trayectoria
Lin(pos2)
tiempo := Timer.ToStr(TRUE) // Leer en el proceso principal
Lin(pos3)
17.9 Subunidad de encoder ENCODER
La subunidad de encoder puede utilizarse en el programa para leer, como máximo, los dos encoders incrementales conectados.
17.9.1 Instanciación
Para instanciar la subunidad de encoder se requiere la referencia de hardware de la entrada.
Ésta se indica con el parámetro <port> durante la instanciación.
Sintaxis
<nombre de instancia> .ENCODER( <timeout> : DINT, MAPX(“< port>“))
Es posible indicar otros parámetros para, p. ej., realizar ajustes previos. Sin embargo, esto no es necesario para la instanciación y puede efectuarse en el programa.
Ejemplo:
Un encoder se guarda como instancia de subunidad:
Instanciación en el archivo de datos:
enc0 : ENCODER := (-1, MAPX("_system.Encoder_0"))
Instanciación con el editor FTL
La instanciación se efectúa en el diálogo para crear variables seleccionando <tipo:> (ENCODER) e introduciendo el <identificador:> (encTrack). En la línea <MAPTO ENCPORT> se activa la referencia real a una entrada de encoder configurada.
17. Módulos
162 Festo GDCP-CMXR-SW-ES es 0805NH
Instanciación con la unidad manual
La instanciación de la subunidad de encoder por medio de la unidad manual se realiza en la máscara de variables seleccionando el tipo de dato ENCODER.
La instanciación en la unidad manual guarda automáticamente la entrada en el archivo de datos.
17.9.2 Variables
La subunidad de encoder posee las variables siguientes:
Variables Tipo Significado Estado al crear
timeout REAL Timeout para esperar -1
port ENCPORT Referencia a la entrada de hardware ---
Tabla 17.15 Variables de la subunidad de encoder
Timeout – (desocupado actualmente en esta subunidad)
Con el parámetro timeout puede definirse un tiempo de espera. El método de la subunidad espera al estado de señal requerido durante el tiempo ajustado. En la actualidad, la sub-unidad de encoder no dispone de métodos para tener en cuenta el timeout.
Port
La variable Port describe la referencia a la entrada de hardware.
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 163
17.9.3 Métodos
La subunidad de encoder dispone de varios métodos:
Métodos Descripción
Set Ajustar manualmente el valor del encoder incremental
Read Leer el valor del encoder incremental
Tabla 17.16 Métodos de la subunidad de encoder
En el editor FTL se visualiza automáticamente una lista con los métodos disponibles intro-duciendo el punto. Los métodos pueden seleccionarse en dicha lista.
En la unidad manual, los métodos pueden seleccionarse mediante el árbol de menú en el punto “Incrementalencoder”.
En la figura se muestra la selección de métodos de la subunidad de encoder de la unidad manual.
17.9.4 Ajuste del encoder, método Set
Con el método Set, el programa de usuario puede ajustar un valor de encoder incremental.
Sintaxis:
<ENCODER>.Set ( OPT <count> : DINT, OPT <mode> : SETCOUNTMODE)
Parámetros Tipo Significado
count DINT Valor al que se debe ajustar el encoder incremental (incrementos)
mode SETCOUNTMODE Parámetro para ajustar el punto de activación
Tabla 17.17 Parámetros del método Set
La subunidad activa el valor en sincronía con la ejecución principal pero no detiene el desarrollo. Con el parámetro mode puede definirse el punto de la activación.
17. Módulos
164 Festo GDCP-CMXR-SW-ES es 0805NH
mode Significado
DIRECT El valor se activa en el próximo ciclo de sistema E/S
ZEROPULSE El valor se activa con el próximo impulso cero del encoder
Tabla 17.18 Modos del método Set
Ejemplo:
enc0.Set(1000, DIRECT)
17.9.5 Lectura del encoder, método Read
Con el método Read, el programa de usuario puede leer el valor del encoder incremental.
Sintaxis:
<ENCODER>.Read ( OPT <ovlEnable> : BOOL) : DINT
Parámetro Tipo Significado
ovlEnable BOOL Parámetro para ajustar el punto de interrogación
Tabla 17.19 Parámetro del método Read
El método devuelve el valor incremental del encoder. Éste no se computa con el valor de conversión. Para leer el valor estándar se utiliza el elemento Value para acceder directa-
mente al Port de la entrada de encoder.
Ejemplo de lectura de un valor estándar:
value := enc0.port.value
Ejemplo de lectura de un valor incremental:
value := enc0.Read()
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 165
17.10 Subunidad CANopen COPDEVICE
La subunidad CANopen puede utilizarse en el programa para activar equipos conectados con el CMXR a través del bus CAN de periféricos.
Atención
En el bus CAN de periféricos pueden controlarse equipos CANopen pero estos equipos no están sujetos al comportamiento PARADA DE EMERGENCIA de la cinemática. Los actuadores auxiliares no se frenan de manera controlada. Si el bus CAN de periféricos se controla desde un programa paralelo, éste NO se detiene en caso de PARADA DE EMERGENCIA.
Indicación
Para activar equipos individuales conectados por bus CAN con el CMXR, consulte la documentación correspondiente del fabricante del participante de bus.
17.10.1 Instanciación
La instanciación de la subunidad CANopen se efectúa automáticamente debido a la con-figuración E/S del control y no puede realizarse manualmente.
Para acceder a los equipos CANopen conectados, se utiliza un nombre inequívoco definido previamente con el software de configuración FCT. El nombre indicado en FCT no puede utilizarse directamente, sino que se le añade la terminación “_copd”. Esto es válido tanto para los actuadores conectados en el DriveBus como para los equipos CANopen del bus
CAN de periféricos.
Ejemplo:
El eje 1 de la cinemática se denomina “Axis1” en la configuración DriveBus del FCT. El acceso se efectúa con Axis1_copd.BausteinMethode( ).
Configuración de CANopen:
[IO.ONBOARD.SLOTCAN:0.FX200A:0.CAN:0.COPDEVICE:1]
name="Axis1" // Nombre del dispositivo COP
Código de programa:
Axis1_copd.WriteSDO(16#6060,0,7,eight_bits)
17. Módulos
166 Festo GDCP-CMXR-SW-ES es 0805NH
17.10.2 Métodos
La subunidad CANopen dispone de varios métodos:
Métodos Descripción
WriteSDO Escribir SDO
ReadSDOUnsigned Leer SDO sin signo
ReadSDOSigned Leer SDO con signo
Tabla 17.20 Métodos de la subunidad CANopen
En el editor FTL se visualiza automáticamente una lista con los métodos disponibles intro-duciendo el punto. Los métodos pueden seleccionarse en dicha lista.
En la unidad manual, los métodos pueden seleccionarse mediante el árbol de menú en el punto “CANopen Devices”.
En la figura se muestra la selección de métodos de la subunidad CANopen de la unidad manual.
17.10.3 Escritura de SDO, método WriteSDO
Con el método WriteSDO es posible escribir conjuntos de datos en el bus CAN.
Sintaxis:
<COPDEVICE>.WriteSDO ( <index> : DINT, <subindex> : DINT, <data> : DINT, <type> : SdoDataType ) : BOOL
Parámetros Tipo Significado
index DINT Índice de SDO
subindex DINT Subíndice de SDO
data DINT Datos que se van a escribir
17. Módulos
Festo GDCP-CMXR-SW-ES es 0805NH 167
Parámetros Tipo Significado
type SdoDataType Tipo de dato (Enum)
eight_bits (8 bits)
sixteen_bits (16 bits)
thirtytwo_bit (32 bits)
Tabla 17.21 Parámetros del método WriteSDO
Si el conjunto se escribe con éxito se devuelve TRUE, de lo contrario se devuelve FALSE.
Ejemplo:
oData := 12000
Axis3_copd.WriteSDO(16#6085, 0, oData, thirtytwo_bits)
17.10.4 Lectura de SDO, método ReadSDOSigned
Con el método ReadSDOSigned, el bus CAN puede leer conjuntos de datos con signo.
Sintaxis:
<COPDEVICE>.ReadSDOSigned (<index> : DINT, <subindex> : DINT, <data> : DINT) : BOOL
Parámetros Tipo Significado
index DINT Índice de SDO
subindex DINT Subíndice de SDO
data DINT Datos que se van a leer
Tabla 17.22 Parámetros del método ReadSDOSigned
Si el conjunto se lee con éxito se devuelve TRUE, de lo contrario se devuelve FALSE.
Ejemplo:
dint_iData : DINT := 0
Programa:
Axis3_copd.ReadSDOSigned(16#6098, 0, dint_iData)
SetInfo("recorrido de referencia leído: %1", dint_iData)
:
17. Módulos
168 Festo GDCP-CMXR-SW-ES es 0805NH
17.10.5 Lectura de SDO, método ReadSDOUnsigned
Con el método ReadSDOUnsigned es posible leer conjuntos de datos en el bus CAN. El
método detecta automáticamente la longitud de los datos leídos por el bus CAN. Éstos se devuelven sin signo como valor de 32 bits.
Sintaxis:
<COPDEVICE>.ReadSDOUnsigned (<index> : DINT, <subindex> : DINT, <data> : DWORD) : BOOL
Parámetros Tipo Significado
index DINT Índice de SDO
subindex DINT Subíndice de SDO
data DWORD Datos que se van a leer
Tabla 17.23 Parámetros del método ReadSDOUnsigned
Si el conjunto se lee con éxito se devuelve TRUE, de lo contrario se devuelve FALSE.
18. Señales de periféricos
Festo GDCP-CMXR-SW-ES es 0805NH 169
18. Señales de periféricos
18.1 Empleo de las entradas y salidas digitales
Las señales digitales se ajustan con la configuración. En ella se define un nombre para cada señal de hardware. Estos nombres pueden utilizarse en el programa de movimientos para la interrogación o el control.
Cada señal digital tiene forma de tipo de dato estructurado y contiene los datos:
State : BOOL Estado de la señal TRUE o FALSE
Error : BOOL Información sobre un error de la señal
Para acceder a estos datos se utiliza el nombre de hardware y el operador punto.
Ejemplo:
Una señal de entrada de sensor se denomina “GripperOpen”. El acceso al estado del sensor se declara:
GripperOpen.State
Esta expresión es de tipo BOOL y puede utilizarse como una variable booleana en el programa.
18.2 Empleo de las entradas y salidas analógicas
Las señales analógicas se ajustan con la configuración. En ella se define un nombre para cada señal de hardware. El nombre puede utilizarse como una variable en el programa de
movimientos y, p. ej., un valor analógico puede ser empleado para el cálculo.
Cada señal analógica tiene forma de tipo de dato estructurado y contiene los datos:
Value : REAL Valor de la señal
Error : BOOL Información sobre un error de la señal
Para acceder a estos datos se utiliza el nombre de hardware y el operador punto.
18. Señales de periféricos
170 Festo GDCP-CMXR-SW-ES es 0805NH
Ejemplo:
Una señal de entrada analógica se denomina “Level”. El acceso al estado del sensor se declara:
Level.Value
Esta expresión es de tipo REAL y puede utilizarse como una variable en el programa.
19. Ejemplos
Festo GDCP-CMXR-SW-ES es 0805NH 171
19. Ejemplos En los capítulos siguientes aparecen ejemplos de utilización del lenguaje de programación.
Advertencia
Todos los ejemplos sirven para explicar la utilización del lenguaje de programación y no pretenden una exposición completa y veraz ni proporcionar un ejemplo de aplicación lista para funcionar. Si en una aplicación se incluyen partes del programa de los ejemplos, éstos deberán comprobarse en relación a su propósito y el funcion-amiento debe asegurarse con la puesta a punto correspondiente.
La no observancia puede tener como consecuencia daños materiales y lesiones personales.
19.1 Detención de movimientos
Un robot manipulador debe recoger una placa de chapa de una pila y posarla sobre una
vía de rodillos. La altura exacta de la pila es desconocida. El sistema de pinzas está equipado con un sensor que permite interrogar si la herramienta prensora avanza en dirección a un obstáculo. Este sensor se utiliza para detectar la placa de chapa superior. Para detectar si una placa de chapa está mecanizada existe otro sensor (para detectar pilas vacías).
Vía de rodillos
Pila de chapa
Sistema de pinzas con detección de avance
Sensor para detectar pilas vacías
x
z
y
19. Ejemplos
172 Festo GDCP-CMXR-SW-ES es 0805NH
El programa de movimientos tiene las posiciones siguientes:
Descripción Nombre de la variable de posición
Posición de recogida en la pila de chapa posRecogida
Posición de seguridad sobre la pila de chapa posSeguridadChapa
Posición de seguridad sobre la vía de rodillos posSeguridadVía
Posición de posado sobre la vía de rodillos posPosado
Posición modificable frente a la pila de chapa posFrente
Tabla 19.1 Tabla de posicionamiento
Para esta aplicación pueden utilizarse más posiciones, pero el ejemplo se limita a las
indicadas.
Como la altura de pila varía, la altura de recogida es desconocida y se fija debajo de la pila.
posSeguridadChapa
posRecogida
posSeguridadVía
posPosado
19. Ejemplos
Festo GDCP-CMXR-SW-ES es 0805NH 173
Programa de movimientos:
:
Vel(dynCart, 200) // Velocidad lenta
posFrente := posSeguridadChapa
WHILE TRUE DO
Lin(posSeguridadChapa)
Wait pilaNoVacía.State // Comprobar si las piezas
están sobre la pila
Lin(posFrente)
Vel(dynCart, 200) // Velocidad lenta
Lin(posRecogida)
Wait señalAvanceSensor.State // Esperar a la señal de
avance del sensor
StopMove() // Detener el movimiento
// Fijar la posición real sobre la pila
ReadActualPos(posFrente)
// Calcular la distancia de seguridad sobre la pila
posFrente.z := posFrente.z + 10
Gripper.Set() // Cerrar pinza
Vel(dynCart, 1000) // Velocidad rápida
Lin(posSeguridadChapa)
Lin(posSeguridadVía)
Lin(posPosado)
Gripper.Reset() // Abrir pinza
END_WHILE
:
Funcionamiento
El robot avanza hasta la posición de recogida hasta que la pinza se encuentra sobre la pila
de chapa y el sensor de detección de avance emite la señal correspondiente. Esto se efectúa a velocidad lenta para impedir que se produzcan daños en el sistema.
Para alcanzar una posición lo más aproximada posible sobre la pila en el ciclo siguiente, se guarda la posición real sobre la pila. Esta posición se complementa con una distancia de seguridad. Así, en el ciclo siguiente puede avanzarse a mayor velocidad sobre la pila. A continuación se conmuta a una velocidad lenta hasta hacer contacto con la pieza.
19. Ejemplos
174 Festo GDCP-CMXR-SW-ES es 0805NH
19.2 Empleo de las subunidades de entrada y salida
Al instanciar subunidades de entrada o salida puede definirse un timeout. P. ej., si la función Wait de la subunidad se utiliza en la ejecución, el programa de usuario debe evaluar el timeout que pueda aparecer.
Programa de movimientos:
:
inSensor.Wait()
IF inSensor.Read() = FALSE THEN
// Interrumpir ejecución
SetError("El timeout ha finalizado")
RETURN
END_IF
// Reanudar ejecución
Lin(pos)
:
Indicación
La edición de un mensaje de error provoca la detención del movi-miento. No es posible reanudar la ejecución hasta que no se acusa recibo del mensaje de error.
19. Ejemplos
Festo GDCP-CMXR-SW-ES es 0805NH 175
Proceso principal
19.3 Control del avance de proceso
A continuación se va a explicar con ejemplos cómo el cálculo puede influir en el avance de proceso.
1. Espera a la señal de entrada digital
La instrucción WAIT activa la espera a una señal de entrada digital durante la ejecución del programa. Si el estado de la entrada digital es FALSE, el avance de proceso se detiene. Si el estado es TRUE, el cálculo se reanuda. Ello se muestra en la figura siguiente.
2. Contador de bucles
Una parte del programa se repite 10 veces con un bucle contador. Los ciclos se cuentan con un contador de bucles. El avance de proceso interpreta el programa secuencial e incrementa el contador de bucles. De este modo, el avance de proceso alcanza rápida-mente el fin de programa y el contador de bucles alcanza el valor 10. En este tiempo, el proceso principal ha alcanzado primero la instrucción Lin(Pos1).
Si el contador de bucles visualiza el ciclo real, el avance de proceso debe interrumpirse con una instrucción WaitTime. El contador de bucles se incrementará siempre al alcanzar la Pos3. Ello se muestra en la figura siguiente.
Lin(Pos1)
Lin(Pos2)
Lin(Pos3)
Lin(Pos4)
WAIT Sensor.State
Lin(Pos5)
Lin(Pos6)
Lin(Pos7)
Lin(Pos8)
Lin(Pos9)
Avance de proceso
Lin(Pos1)
Lin(Pos2)
Lin(Pos3)
Lin(Pos4)
WAIT Sensor.State
Lin(Pos5)
Lin(Pos6)
Lin(Pos7)
Lin(Pos8)
Lin(Pos9)
Proceso principal
Avance de proceso
19. Ejemplos
176 Festo GDCP-CMXR-SW-ES es 0805NH
Proceso principal
19.4 Empleo de pinzas
En los sistemas de manipulación se utilizan una gran cantidad de pinzas diferentes. El procedimiento de agarre requiere tiempo para cerrar o abrir la pinza y, por tanto, puede influir de manera importante en el tiempo de ciclo.
Indicación
Los tiempos de agarre aumentan el tiempo de ciclo y, por ello, deben tenerse siempre en cuenta. Algunas pinzas requieren también un tiempo de espera en el programa FTL para garantizar su apertura o cierre.
Indicación
Los tiempos de espera para el estado cerrado o abierto de las pinzas neumáticas dependen siempre de la presión ajustada. Si la presión cambia, los tiempos también deben adaptarse. Por lo general no es necesario ajustar tiempos de espera si el sistema de pinzas cuenta con sensores para posiciones finales.
En los capítulos siguientes se explica la integración de diferentes tipos de pinza en la gama CMXR.
19.4.1 Pinzas por vacío
El tipo de pinzas por vacío permite una ejecución muy rápida de los ciclos. Estas pinzas requieren vacío, que, p. ej., puede generarse con toberas Venturi.
count := 0
Lin(Pos1)
Lin(Pos2)
LOOP 10 DO
Lin(Pos3)
count:=count + 1
Lin(Pos4)
END_LOOP
Lin(Pos5) Avance de proceso
count := 0
Lin(Pos1)
Lin(Pos2)
LOOP 10 DO
Lin(Pos3)
WaitTime(1)
count:=count + 1
Lin(Pos4)
END_LOOP
Lin(Pos5)
Proceso principal
Avance de proceso
19. Ejemplos
Festo GDCP-CMXR-SW-ES es 0805NH 177
El vacío debe existir en el momento de aceptación de la pieza. Cuando la pieza se posa,
además de desconectarse el vacío debe ejecutarse un impulso de eyección para eliminar el vacío creado en la pinza. Los generadores de vacío, como VN-..-H-...-A, ejecutan auto-
máticamente el impulso de eyección al desconectarse el vacío. Con otros tipos, el impulso de eyección se controla desde una señal digital adicional.
Pinza por vacío ESG Generador de vacío VN-..-H-...-A con
impulso de eyección incorporado
Ejemplo:
Una pieza debe transportarse desde la posición pos2 a la posición pos4.
Como generador de vacío se utiliza una tobera Venturi. Ésta se controla a través de una
salida digital del CMXR. Para ello se crea una subunidad digital.
pos2 pos4
pos3 pos1
19. Ejemplos
178 Festo GDCP-CMXR-SW-ES es 0805NH
Variables:
vacío : DOUT := (...) // Subunidad de salida digital
Programa:
Vel(dynCart, 1500) // Velocidad de trayectoria = 1500 mm/s
Acc(dynCart, 5000) // Aceleración de trayectoria = 5000 mm/s²
OvlVel(75) // Avance aproximado por velocidad al 75%
Lin(pos1)
vacío.Set() // Conectar inmediatamente el vacío
Lin(pos2) // Posición de aceptación
WaitTime(10) // Tiempo de espera = 10 ms para tiempo de
agarre
Lin(pos1)
Lin(pos3) // Sobre posición de posado
Lin(pos4) // Posición de posado
vacío.Reset() // Desconectar el vacío en el punto
inferior
WaitTime(20) // Tiempo de espera = 20 ms para tiempo de
agarre
Lin(pos3)
Funcionamiento:
Como en la pinza no hay acuses de recibo es necesario introducir un tiempo de espera para el cierre y la apertura. Éste se fija y optimiza con ayuda de la puesta a punto.
Los movimientos se recorren con un avance aproximado por velocidad al 75%. Una excepción son las posiciones de aceptación pos2 y de posado pos3. La instrucción siguiente WaitTime impide el avance aproximado ya que el cálculo por adelantado de proceso se detiene en este punto y se reanuda transcurrido el ciclo.
19. Ejemplos
Festo GDCP-CMXR-SW-ES es 0805NH 179
Perfil de movimiento:
Comportamiento en la línea temporal:
pos2 pos4
pos3 pos1
Área de avance aproximado
Tiempo
pos1 pos3
Tiempo de espera
pos4
pos3
pos2
pos1
Velocidad
19. Ejemplos
180 Festo GDCP-CMXR-SW-ES es 0805NH
19.4.2 Pinzas paralelas neumáticas
Las pinzas paralelas poseen mordazas que se cierran en paralelo. Las mordazas pueden adaptarse individualmente a la aplicación.
Por lo general, las pinzas paralelas se controlan con dos salidas separadas para la apertura y el cierre. Opcionalmente pueden integrarse sensores en las pinzas para recibir los acuses
de recibo a través de las posiciones finales (abierto o cerrado).
Ejemplo:
Una pieza debe transportarse desde la posición pos2 a la posición pos4.
El equipo utilizado es una pinza paralela con sensórica de posición final. Se obtienen las señales digitales siguientes y se integran en forma de subunidades en la programación FTL.
pos2 pos4
pos3 pos1
19. Ejemplos
Festo GDCP-CMXR-SW-ES es 0805NH 181
Variables:
outPinzaAbrir : DOUT := (...) // Subunidad de salida digital
outPinzaCerrar : DOUT := (...) // Subunidad de salida digital
inPinzaAbrir : DIN := (...) // Subunidad de entrada digital
inPinzaCerrar : DIN := (...) // Subunidad de entrada digital
Programa:
Vel(dynCart, 1500) // Velocidad de trayectoria = 1500 mm/s
Acc(dynCart, 5000) // Aceleración de trayectoria = 5000 mm/s²
OvlVel(75) // Avance aproximado por velocidad al 75%
Lin(pos1)
outPinzaAbrir.Set() // Abrir pinza
outPinzaCerrar.Set()
inPinzaAbrir.Wait(TRUE) // Esperar a apertura
Lin(pos2) // Posición de aceptación
outPinzaCerrar.Set() // Cerrar pinza
outPinzaAbrir.Reset()
inPinzaCerrar.Wait() // Esperar a cierre
Lin(pos1)
Lin(pos3)
Lin(pos4) // Posición de posado
outPinzaAbrir.Set() // Abrir pinza
outPinzaCerrar.Reset()
inPinzaAbrir.Wait() // Esperar a apertura
Lin(pos3)
Funcionamiento:
Si se dispone de sensores para acusar recibo de las posiciones finales de agarre,
no es necesario un tiempo de espera.
Los movimientos se recorren con un avance aproximado por velocidad al 75%. El método de subunidad Wait introduce una espera al acuse de recibo de la posición final que evita un avance aproximado a las posiciones de aceptación y posado. El cálculo por adelantado de proceso se detiene en este punto y se reanuda al conmutarse la señal de entrada digital.
19. Ejemplos
182 Festo GDCP-CMXR-SW-ES es 0805NH
Perfil de movimiento:
Comportamiento en la línea temporal:
Tiempo
pos3
pos4
pos3
pos2
pos1
Tiempo de espera hasta acusar recibo del cierre de la pinza
Tiempo de espera hasta acusar recibo de la apertura de la pinza
Velocidad
pos1
pos2 pos4
pos3 pos1
Área de avance aproximado
19. Ejemplos
Festo GDCP-CMXR-SW-ES es 0805NH 183
19.4.3 Unidad giratoria con pinzas neumáticas
La unidad giratoria con pinzas neumáticas HGDS de Festo reúne una pinza paralela con un actuador giratorio en una sola unidad.
La unidad HGDS permite montar sensores de detección de posiciones finales de la pinza y de la unidad giratoria. Los sensores se requieren para el control seguro de la aplicación.
Ejemplo:
Una pieza debe transportarse desde la posición pos2 a la posición pos4 describiendo un giro de 90 grados.
La unidad utilizada es la HGDS, que dispone de los sensores correspondientes para detectar las posiciones finales. Se obtienen las señales digitales siguientes y se integran en forma de subunidades en la programación FTL.
pos2 pos4
pos3 pos1
Giro de 90 grados
Unidad giratoria con pinzas HGDS con pinza paralela
19. Ejemplos
184 Festo GDCP-CMXR-SW-ES es 0805NH
Variables:
outPinzaAbrir : DOUT := (...) // Subunidad de salida digital
outPinzaCerrar : DOUT := (...) // Subunidad de salida digital
outPos0grados : DOUT := (...) // Subunidad de salida digital
outPos90grados : DOUT := (...) // Subunidad de salida digital
inPinzaAbrir : DIN := (...) // Subunidad de entrada digital
inPinzaCerrar : DIN := (...) // Subunidad de entrada digital
inPos0grados : DIN := (...) // Subunidad de entrada digital
inPos90grados : DIN := (...) // Subunidad de entrada digital
Programa:
Vel(dynCart, 1500) // Velocidad de trayectoria = 1500 mm/s
Acc(dynCart, 5000) // Aceleración de trayectoria = 5000 mm/s²
OvlVel(75) // Avance aproximado por velocidad al 75%
Lin(pos1) // Avanzar sobre pieza
outPinzaCerrar.Reset() // Abrir pinza
outPinzaAbrir.Set()
outPos0grados.Set() // Girar a 0 grados
outPos90grados.Reset()
inPinzaAbrir.Wait() // Esperar a pinza abierta
inPos0grados.Wait() // Esperar a 0 grados
Lin(pos2) // Posición de aceptación
outPinzaCerrar.Set() // Cerrar pinza
outPinzaAbrir.Reset()
inPinzaCerrar.Wait() // Esperar a pinza cerrada
Lin(pos1)
outPos0grados.Reset() // Girar a 90 grados
outPos90grados.Set()
Lin(pos3)
inPos90grados.Wait(TRUE) // Esperar a 90 grados con avance
aproximado
Lin(pos4) // Posición de posado
outPinzaCerrar.Reset() // Abrir pinza
outPinzaAbrir.Set()
inPinzaAbrir.Wait() // Esperar a pinza abierta
Lin(pos3)
19. Ejemplos
Festo GDCP-CMXR-SW-ES es 0805NH 185
Funcionamiento
Con los sensores integrados no es necesario un tiempo de espera para acusar recibo de los movimientos de la pinza ni de giro.
La interrogación del movimiento de giro de 90 grados se ejecuta con posibilidad de realizar el avance aproximado. Ello significa que si no existe acuse de recibo del giro de 90 grados al avanzar a la pos4, el movimiento se detiene y se espera hasta que se acusa recibo. Si el acuse de recibo ya se ha efectuado, se ejecuta directamente un movimiento de avance aproximado a la pos4.
Perfil de movimiento:
El acuse de recibo del movimiento de giro de 90 grados se detecta antes de alcanzar la
posición pos3. Se ejecuta un movimiento de avance aproximado a la pos4.
El acuse de recibo del movimiento de giro de 90 grados no se ha detectado antes de
alcanzar la posición pos3. Se espera al acuse de recibo en la posición pos3 y no se ejecuta el movimiento de avance aproximado a la pos4.
pos2 pos4
pos3 pos1
Área de avance aproximado
pos2 pos4
pos3 pos1
Área de avance aproximado
19. Ejemplos
186 Festo GDCP-CMXR-SW-ES es 0805NH
Comportamiento en la línea temporal:
El acuse de recibo del movimiento de giro de 90 grados tuvo lugar antes de alcanzar la posición pos3. Se ejecuta un movimiento de avance aproximado a la pos4.
No hay acuse de recibo del giro de 90 grados en la posición pos3. Se espera a recibirlo.
Tiempo
pos1 pos3
pos4 pos3 pos2
pos1
Tiempo de espera hasta acusar recibo del cierre de la pinza
Tiempo de espera hasta acusar recibo de la apertura de la pinza
Velocidad
Tiempo de espera hasta acusar recibo del giro de 90 grados
Tiempo
pos1 pos3
pos4
pos3
pos2
pos1
Tiempo de espera hasta acusar recibo del cierre de la pinza
Tiempo de espera hasta acusar recibo de la apertura de la pinza
Velocidad
Acuse de recibo del giro de 90 grados
19. Ejemplos
Festo GDCP-CMXR-SW-ES es 0805NH 187
19.5 Empleo de la interface PLC
19.5.1 Tarea
En el ejemplo siguiente se van a recoger piezas en la posición “posRecogida” y se van a transportar a la posición de posado “posPosado”. La posición de recogida es dinámica. Las coordenadas exactas son calculadas en cada ciclo por un sistema de visión y enviadas al control a través de la interface PLC PROFIBUS.
Para el ciclo van a calcularse dos posiciones intermedias dinámicas a partir de las posiciones inicial y final. Aquéllas se van a utilizar como puntos de apoyo en el ciclo.
Si el PLC no suministra los datos a tiempo, el ciclo se detiene en la posición “posEspera” hasta que el PLC está preparado.
19.5.2 Interface PLC
El intercambio de datos entre el control CMXR y el PLC se efectúa con dos bits de sincron-ización. En el primer paso, el PLC señaliza que se han enviado los datos. En el momento en que CMXR recibe los datos, se lo indica al PLC. A continuación se borran las dos señales de interface. La secuencia se muestra en el diagrama del ciclo siguiente.
Posicionar
Señal del SPS Datos preparados
plc_inboolreg[0]
Señal al PLC Datos leídos
plc_outboolreg[0]
Se ha transmitido la posición nueva
Posicionamiento efectuado
Transmisiòn
fin
Sprungziel
posRecogida posPosado
sobreposPosado sobreposRecogida posEspera
19. Ejemplos
188 Festo GDCP-CMXR-SW-ES es 0805NH
19.5.3 Programa secuencial
Variables:
posEspera : CARTPOS := (...)
posRecogida : CARTPOS := (...)
posPosado : CARTPOS := (...)
sobreposRecogida: CARTPOS := (...)
sobreposPosado : CARTPOS := (...)
Pinza : DOUT := (...)
Programa:
// Inicialización
Acc(dynCart, 4000)
Vel(dynCart, 100)
Lin(posEspera)
WHILE TRUE DO
// Handshake
WAIT plc_inboolreg[0] // El PLC señaliza una posición nueva
posRecogida := plc_cposreg[0]
sobreposRecogida.x := plc_cposreg[0].x
sobreposRecogida.y := plc_cposreg[0].y
plc_outboolreg[0] := TRUE // Confirma la recepción
WAIT NOT plc_inboolreg[0] // Esperar a la respuesta del PLC
plc_outboolreg[0] := FALSE
// Avanzar a la posición de aceptación
Lin(sobreposRecogida)
Lin(posRecogida)
// Agarrar
Pinza := TRUE
WaitTime(200)
// Avanzar a la posición de posado
Lin(sobreposRecogida)
Lin(sobreposPosado)
19. Ejemplos
Festo GDCP-CMXR-SW-ES es 0805NH 189
Lin(posPosado)
// Posar
Pinza := FALSE
WaitTime(200)
// Avanzar a la posición de espera
Lin(sobrep osPosado)
Lin(posEspera)
END_WHILE
Índice de términos Técnicos
190 Festo GDCP-CMXR-SW-ES es 0805NH
Índice de términos Técnicos
#
##........................................................ 46
/
// ........................................................ 46
_
_global.tt ............................................. 18
A
ABS ................................................... 131
Acc ...................................................... 73 ACOS ................................................. 126 ACOT ................................................. 129 ASIN .................................................. 125 ATAN ................................................. 128 ATAN2 ............................................... 130 Avance de proceso ................ 42, 44, 175 AXISPOS .............................................. 48
C
CALL .................................................... 39 CARTPOS ............................................. 48 CircIp ................................................... 66
Comentario .......................................... 46 Conversiones de tipos ......................... 28 COS ................................................... 126 COT ................................................... 129
D
DynOvr ................................................ 77
E
Ejemplo Control del avance de proceso ........ 175 Detención de movimientos ............. 171 Empleo de la interface PLC.............. 187
Empleo de las subunidades de entrada y salida ........................................ 174
Empleo de pinzas ........................... 176 WAIT con entrada digital ................... 45
Error .................................................. 169 EXP .................................................... 130
F
FTL ........................................ 11, 15, 18
G
GOTO .................................................. 36
H
Herramientas .................................... 102
I
IF…GOTO ............................................. 36
IF…THEN ............................................. 34 Interface Profibus .............................. 110 IsReferenced ..................................... 101
J
Jerk ..................................................... 74
K
KILL ..................................................... 42
L
LABEL ................................................. 35 Lin....................................................... 59
LinRel .................................................. 61 LinToCircIp .......................................... 70 LN ..................................................... 130 LOOP .................................................. 37
M
MoveAxisCart ...................................... 57 MoveAxisPtp ....................................... 57
O
OvlCart ................................................ 87 OvlVel ................................................. 85 Ovr ...................................................... 76
P
Palabras clave ..................................... 23 plc_AxisPos ....................................... 112 plc_CartPos ....................................... 112 plc_RefSys ........................................ 113 plc_VarDint ....................................... 111 Posición cartesiana ............................. 51 Posición de eje .................................... 49
Índice de términos Técnicos
Festo GDCP-CMXR-SW-ES es 0805NH 191
ProgHold ........................................... 114
PTP ...................................................... 52 PtpRel ................................................. 55 PtpToCircIp .......................................... 68
R
Ramp ................................................... 79 Read .................................................. 164 ReadActualPos .................................. 121 ReadSDOSigned ................................ 167 ReadSDOUnsigned ............................ 168 ReadTargetPos .................................. 122 RefAxis ................................................ 96
RefAxisAsync ....................................... 98 Registro del programa desactivado ..... 46 RETURN ............................................... 40
ROL ................................................... 133 ROR ................................................... 133 RUN ..................................................... 42
S
SavePosition ..................................... 123 Set .................................................... 163 SetError ............................................. 120 SetInfo .............................................. 118 SetRefSys ............................................ 91
SetRefSys3P ........................................ 92 SetRefSysWorld ................................... 93 SetWarning........................................ 119 SHL ................................................... 132
SHR ................................................... 132
SIN .................................................... 125 Sistemas de referencia ...................... 113 SQRT ................................................. 131 State ................................................. 169 StopMove ........................................... 71
T
TAN ................................................... 128 TCP ................................................... 102 tid ................................................. 18, 19 Tiempo de espera ................................ 42 Time .................................................. 123 TimeToStr ......................................... 124
tip ....................................................... 18 Tipos de datos .................................... 27 Tool .................................................. 105
V
Value ................................................ 169 VconstOff ............................................ 82 VconstOn ............................................ 80 Vel ...................................................... 72
W
WAIT ................................................... 43 WaitRefFinished ................................ 100
WaitTime............................................. 42 WHILE ................................................. 37 WriteSDO .......................................... 166