€¦ · festo gdcp-cmxr-sw-de es 0909a 3 edición...

Recortar: Arriba: 61,5 mm Abajo: 61,5 mm Izquierda: 43,5 mm Derecha: 43,5 mm

Controlador

Descripción Instrucciones de programación Base CMXR FTL

Descripción 560 317 es 0909a [748 987]

Festo GDCP-CMXR-SW-DE es 0909a 3

Edición ______________________________________________________ 0909a

Referencia ________________________________________ GDCP-CMXR-SW-ES

Nº de art. ___________________________________________________ 560 317

Festo AG & Co KG., D-73734 Esslingen, 2009

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 a pagar una indemnización por daños y perjuicios. Quedan reservados todos los derechos inherentes, en especial los de patentes, de modelos registrados y estéticos.

http://www.festo.com/

4 Festo GDCP-CMXR-SW-DE es 0909a

Lista de revisiones

Autor:

Nombre del manual: GDCP-CMXR-SW-DE

Nombre del archivo:

Lugar de almacenamiento del

archivo:

Nº Descripción Indicador de

revisión

Fecha de modificación

001 Redacción 0805NH 25.06.2008

002 Adaptación a la versión 1.20 0909a 25.08.2009

ÍNDICE


ÍNDICE

1. Introducción ........................................................................................................ 12

2. Medidas de seguridad......................................................................................... 13

2.1 Uso de la documentación................................................................................... 13

2.2 Uso conforme a lo previsto ................................................................................ 13

2.3 Personal cualificado .......................................................................................... 14

2.4 Medidas de seguridad de los productos ............................................................ 14

2.5 Medidas de seguridad de este manual ............................................................... 14

2.6 Medidas de seguridad para el producto descrito ............................................... 15

3. Edición de programas.......................................................................................... 16

3.1 Información general ........................................................................................... 16

3.2 Intérprete .......................................................................................................... 16

3.3 Inicio del programa ............................................................................................ 16

3.4 Avance de proceso............................................................................................. 16

3.5 Estructura de programa ..................................................................................... 18

3.6 Proyectos FTL .................................................................................................... 18

3.6.1 Proyecto FTL global ............................................................................ 19

3.7 Archivo de programa FTL “tip” ........................................................................... 19

3.7.1 Programas compartidos de proyecto .................................................. 20

3.8 Archivo de datos FTL “<nombre>.tid” .................................................................. 20

3.8.1 Datos de programa local .................................................................... 20

3.8.2 Datos compartidos de proyecto .......................................................... 21

3.8.3 Datoscompartidos de sistema ............................................................ 21

3.8.4 Instanciación de variables .................................................................. 22

4. Estructura del lenguaje ....................................................................................... 24

4.1 Formateado ....................................................................................................... 24

4.2 Identificadores .................................................................................................. 24

4.3 Palabras clave ................................................................................................... 24

4.4 Constantes numéricas ....................................................................................... 25

4.5 Cadenas de caracteres ....................................................................................... 25

4.6 Operadores y caracteres de delimitación ........................................................... 26

4.6.1 Operadores aritméticos ...................................................................... 26

4.6.2 Operadores lógicos ............................................................................ 26

4.6.3 Operadores comparativos .................................................................. 26

4.6.4 Otros operadores ............................................................................... 27

4.6.5 Caracteres de delimitación ................................................................. 27

ÍNDICE


5. Tipos de datos básicos ........................................................................................ 28

5.1 Tipo de dato booleano (BOOL) ........................................................................... 29

5.2 Tipos de número entero, tipo de dato REAL, tipos de patrón de bits ................... 30

5.3 Paréntesis ......................................................................................................... 30

5.4 Cadenas de caracteres (STRING) ........................................................................ 31

5.5 Tipos de datos estructurados ............................................................................ 31

5.6 Matrices ............................................................................................................ 31

5.6.1 Inicialización de matrices ................................................................... 34

5.6.2 Cómo determinar los límites de la matriz con LOW y HIGH .................. 34

5.7 Variables de referencia (mapeado) .................................................................... 36

5.7.1 Declaración de variables de referencia, <MAPTO> ................................ 37

5.7.2 Vinculación de variables de referencia, <MAP> .................................... 37

5.7.3 Comprobación de variables de referencia, <IS_MAPPED> .................... 37

5.8 Instrucción DO ................................................................................................... 39

5.8.1 Comportamiento en el área de avance aproximado ............................ 41

6. Declaración de variables ..................................................................................... 42

6.1 Inicialización ...................................................................................................... 42

7. Expresiones ........................................................................................................ 43

7.1 Secuencia de ejecución para expresiones .......................................................... 43

8. Control de programa ........................................................................................... 44

8.1 Instrucciones ..................................................................................................... 44

8.2 Asignación de valor <:=> ..................................................................................... 44

8.3 Condiciones ....................................................................................................... 44

8.4 Bifurcación <IF…THEN> ....................................................................................... 45

8.5 Instrucciones de salto ........................................................................................ 46

8.5.1 Marca de salto <LABEL> ....................................................................... 47

8.5.2 Salto condicional <IF…GOTO> .............................................................. 47

8.5.3 Salto absoluto <GOTO> ....................................................................... 48

8.6 Bucles ............................................................................................................... 48

8.6.1 Instrucción WHILE <WHILE> ................................................................. 48

8.6.2 Instrucción LOOP <LOOP> .................................................................... 49

8.7 Subprogramas ................................................................................................... 50

8.7.1 Llamada de subprograma <CALL> ........................................................ 51

8.7.2 Retorno al programa <RETURN> ........................................................... 52

8.8 Programas paralelos .......................................................................................... 53

8.8.1 Ejecución de programa paralelo <RUN> .............................................. 54

8.8.2 Finalización del programa paralelo <KILL> ........................................... 54

8.9 Influencia del avance de proceso ....................................................................... 54

ÍNDICE


8.9.1 WAIT – Instrucción con tiempo <WaitTime> .......................................... 54

8.9.2 Instrucción condicional WAIT <WAIT> .................................................. 56

8.9.3 WaitOnPath – Instrucción con tiempo <WaitOnPath> ........................... 58

8.9.4 WaitOnPos – Instrucción con tiempo <WaitOnPos> .............................. 60

8.10 Insertar comentarios <//> ................................................................................... 61

8.11 Desactivar línea de programa <##> ..................................................................... 61

9. Instrucciones de movimiento .............................................................................. 63

9.1 Descripción de la posición ................................................................................. 63

9.1.1 Posición de eje ................................................................................... 63

9.1.2 Posición cartesiana ............................................................................ 66

9.2 Movimiento punto a punto <Ptp> ........................................................................ 67

9.3 Movimiento punto a punto <PtpRel> ................................................................... 70

9.4 Movimiento de un eje, <MoveAxisPtp>, <MoveAxisCart> ...................................... 72

9.5 Movimiento lineal <Lin> ...................................................................................... 74

9.6 Movimiento lineal relativo <LinRel> ..................................................................... 76

9.7 Movimiento circular con punto de apoyo ........................................................... 78

9.7.1 Modo de funcionamiento.................................................................... 78

9.7.2 Definición de planos ........................................................................... 79

9.7.3 Instrucción Circular con punto de apoyo <CircIp> ................................. 81

9.7.4 Instrucción Circular con punto de apoyo, aproximación PTP <PtpToCircIp> ...................................................................................... 83

9.7.5 Instrucción Circular con punto de apoyo, avance lineal <LinToCircIp> .. 85

9.8 Detención del movimiento <StopMove> ............................................................. 86

9.9 Detención del programa <StopProgram> ............................................................. 87

10. Instrucciones de dinámica................................................................................... 88

10.1 Limitación automática de la dinámica, limitador de la dinámica ......................... 89

10.2 Velocidades <Vel> ............................................................................................... 90

10.3 Aceleración <Acc> ............................................................................................... 91

10.4 Sacudida <Jerk> .................................................................................................. 92

10.5 Override ............................................................................................................ 94

10.5.1 Override en la unidad manual <Ovr> .................................................... 94

10.5.2 Override dinámico <DynOvr> ............................................................... 96

10.6 Rampas de aceleración ...................................................................................... 97

10.6.1 Ajuste de formas de rampa <Ramp> ..................................................... 98

10.7 Conexión de la velocidad de trayectoria constante <VconstOn> .......................... 99

10.8 Desconexión de la velocidad de trayectoria constante <VconstOff> ................... 101

11. Instrucciones de avance aproximado ................................................................ 102

11.1 Segmentos cero ............................................................................................... 103

ÍNDICE


11.2 Área extrema ................................................................................................... 104

11.3 Avance aproximado por velocidad ................................................................... 105

11.3.1 Con factor porcentual <OvlVel> .......................................................... 105

11.4 Avance aproximado por geometría .................................................................. 107

11.4.1 Avance aproximado de los ejes X, Y y Z <OvlCart> .............................. 107

12. Sistemas de referencia (desplazamiento del punto cero) ................................. 109

12.1 Referencia del sistema ..................................................................................... 109

12.2 Datos del sistema de referencia ....................................................................... 110

12.3 Sistema de referencia con valores directos <SetRefSys> ................................... 111

12.4 Sistema de referencia con tres puntos <SetRefSys3P> ...................................... 112

12.5 Sistema de referencia universal <SetRefSysWorld> ........................................... 114

12.6 Ejemplo ........................................................................................................... 114

13. Referenciación de una cinemática ..................................................................... 116

13.1 Recorrido de referencia <RefAxis> .................................................................... 116

13.2 Recorrido de referencia asíncrono <RefAxisAsync> ............................................ 118

13.3 Espera al final del recorrido de referencia <WaitRefFinished> ............................ 120

13.4 Interrogación del estado de un eje <IsAxisReferenced> .................................... 121

14. Herramientas .................................................................................................... 122

14.1 Datos de herramienta ...................................................................................... 122

14.1.1 Datos del vector TCP ........................................................................ 122

14.2 Activación de datos de herramienta <Tool> ....................................................... 125

14.2.1 Efecto de los datos TCP .................................................................... 125

15. Interface PROFIBUS .......................................................................................... 130

15.1 Indicaciones sobre el procesamiento de señales.............................................. 131

15.2 Entradas y salidas booleanas ........................................................................... 131

15.3 Variables enteras de 32 bits ............................................................................ 132

15.4 Posiciones ....................................................................................................... 133

15.5 Sistemas de referencia .................................................................................... 134

15.6 Pausa programada <ProgHold> ......................................................................... 135

16. Sistema de comunicación .................................................................................. 137

16.1 Textos de mensaje ........................................................................................... 137

16.2 Información <SetInfo> ....................................................................................... 139

16.3 Advertencia <SetWarning> ................................................................................ 140

16.4 Mensaje de error <SetError> ............................................................................. 141

ÍNDICE


17. Funciones .......................................................................................................... 142

17.1 Lectura de la posición actual <ReadActualPos> ................................................ 142

17.2 Lectura de la posición de destino <ReadTargetPos> ......................................... 143

17.3 Memorización del valor de posición de manera permanente <SavePosition> .... 144

17.4 Lectura de la fecha y hora del sistema <Time> ................................................... 144

17.5 Conversión de un valor de fecha y hora en texto <TimeToStr> .......................... 145

17.6 Seno <SIN>, <ASIN> ........................................................................................... 146

17.7 Coseno <COS>, <ACOS> ..................................................................................... 147

17.8 Tangente <TAN>, <ATAN> ................................................................................... 149

17.9 Cotangente <COT>, <ACOT> ................................................................................ 150

17.10 Tangente 2 <ATAN2> ......................................................................................... 151

17.11 Logaritmo <LN> ................................................................................................. 151

17.12 Exponente <EXP> .............................................................................................. 151

17.13 Valor absoluto <ABS> ....................................................................................... 152

17.14 Raíz cuadrada <SQRT> ...................................................................................... 152

17.15 Desplazamiento de bits <SHR>, <SHL> ............................................................... 153

17.16 Rotación de bits <ROR>, <ROL> .......................................................................... 154

17.17 Conversión de un valor en una cadena <STR>.................................................... 155

17.18 Conversión de un valor ASCII en un carácter <CHR> ........................................... 155

17.19 Conversión de un carácter en un valor ASCII <ORD> .......................................... 155

18. Módulos ............................................................................................................ 156

18.1 Funciones ........................................................................................................ 157

18.2 Variable ........................................................................................................... 157

18.3 Comportamiento del tiempo de operación ....................................................... 158

18.3.1 Parámetro ovlEnable ........................................................................ 158

18.4 Módulo de entrada digital DIN ......................................................................... 159

18.4.1 Instanciación .................................................................................... 159

18.4.2 Métodos ........................................................................................... 161

18.4.3 Espera a estado, métodos Wait/WaitN ............................................. 162

18.4.4 Método Read para lectura de estado ................................................ 162

18.4.5 Método RisingEdge para flanco de subida ........................................ 162

18.4.6 Método ResetRisingEdge para borrar flancos ................................... 163

18.5 Módulo de salida digital DOUT......................................................................... 163

18.5.1 Instanciación .................................................................................... 163

18.5.2 Variable............................................................................................ 165

18.5.3 Métodos ........................................................................................... 166

18.5.4 Espera a estado, métodos Wait/WaitN ............................................. 167

18.5.5 Método Read para lectura de estado ................................................ 167

ÍNDICE


18.5.6 Método RisingEdge para flanco de subida ........................................ 167

18.5.7 Borrado de flancos, ResetRisingEdge ............................................... 168

18.5.8 Activación y borrado, métodos Set/Reset ......................................... 168

18.5.9 Activación de la salida, método Write ............................................... 169

18.5.10 Activación de la salida con una duración determinada, método Pulse ................................................................................... 169

18.6 Módulo de entrada analógica AIN .................................................................... 170

18.6.1 Instanciación .................................................................................... 170

18.6.2 Variable............................................................................................ 172

18.6.3 Métodos ........................................................................................... 172

18.6.4 Espera a que el valor sea menor/mayor, métodos WaitLss , WaitGrt ............................................................................................. 173

18.6.5 Espera a que el valor entre/salga de un margen, métodos WaitIns, WaitOuts .......................................................................................... 174

18.6.6 Interrogación del valor, método Read ............................................... 174

18.7 Módulo de salida analógica AOUT .................................................................... 175

18.7.1 Instanciación .................................................................................... 175

18.7.2 Variable............................................................................................ 176

18.7.3 Métodos ........................................................................................... 177

18.7.4 Escritura del valor de salida, método Write ....................................... 178

18.7.5 Esperar a que el valor aumente/disminuya, métodos WaitLss , WaitGrt ............................................................................................. 178

18.7.6 Espera a que el valor entre/salga de un margen, métodos WaitIns, WaitOuts ........................................................................................... 179

18.7.7 Lectura del valor de salida, método Read ......................................... 179

18.8 Módulo de reloj CLOCK .................................................................................... 180

18.8.1 Instanciación .................................................................................... 180

18.8.2 Métodos ........................................................................................... 181

18.8.3 Puesta en marcha del reloj, método Start ......................................... 182

18.8.4 Parada del reloj, método Stop .......................................................... 182

18.8.5 Borrado del reloj, método Reset ....................................................... 182

18.8.6 Lectura del reloj, método Read ......................................................... 182

18.8.7 Conversión del valor de fecha y hora en cadena de caracteres .......... 183

18.9 Módulo de encoder ENCODER .......................................................................... 184

18.9.1 Instanciación .................................................................................... 184

18.9.2 Variable............................................................................................ 185

18.9.3 Métodos ........................................................................................... 185

18.9.4 Ajuste del encoder, método Set ........................................................ 186

18.9.5 Lectura del encoder, método Read ................................................... 187

18.10 Módulo CANopen COPDEVICE .......................................................................... 187

18.10.1 Instanciación .................................................................................... 188

18.10.2 Métodos ........................................................................................... 188

18.10.3 Escritura de SDO, método WriteSDO ................................................ 189

ÍNDICE


18.10.4 Lectura de SDO, método ReadSDOSigned ........................................ 189

18.10.5 Lectura de SDO, método ReadSDOUnsigned .................................... 191

19. Señales de periféricos ....................................................................................... 192

19.1 Empleo de las entradas y salidas digitales ....................................................... 192

19.2 Empleo de las entradas y salidas analógicas .................................................... 192

20. Ejemplos ........................................................................................................... 194

20.1 Detención de movimientos .............................................................................. 194

20.2 Empleo de los módulos de entrada y salida ..................................................... 197

20.3 Control del avance de proceso ......................................................................... 198

20.4 Empleo de pinzas ............................................................................................ 199

20.4.1 Pinzas por vacío ............................................................................... 200

20.4.2 Pinzas paralelas neumáticas ............................................................ 203

20.4.3 Unidad giratoria con pinzas neumáticas ........................................... 206

20.5 Empleo de la interface PLC ............................................................................... 210

20.5.1 Tarea ................................................................................................ 210

20.5.2 Interface PLC .................................................................................... 210

20.5.3 Programa secuencial ........................................................................ 211

21. Árbol de menús de las instrucciones FTL........................................................... 213

1. Introducción


1. Introducción En este documento se describe el conjunto de instrucciones FTL (Festo Teach Language)

del control multieje CMXR de Festo a partir de la versión de software 1.20. La progra-mació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.

Este manual es válido a partir de la versión de software 1.20 del CMXR. Esta versión es compatible con la versión de software 1.

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 tareas de control relacionadas con la seguridad (p. ej., parada en caso de emergencia o control de velocidades reducidas).

Conforme a EN-13849-1, el sistema CMXR de Festo es sólo de categoría B y, por tanto, no es suficiente para realizar funciones de seguridad de protección del personal. Para tareas de control relevantes para la seguridad o para la segu-ridad de las personas deberán aplicarse medidas de protección externas adicionales 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 entero el capítulo Medidas de seguridad, especialmente el apartado 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.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 mate-riales 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: los compo-nentes pueden sufrir daños si no se manipulan 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 de 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.6 Medidas de seguridad para el producto descrito

Advertencia

¡Peligro!

Peligro de muerte por equipos de parada de emergencia insufi-cientes.

Los equipos de PARADA DE EMERGENCIA deben mantener su efi-cacia y estar siempre al alcance en todos los modos de funcio-namiento 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 mermar la seguridad.

Ello puede provocar lesiones físicas y daños materiales o ambien-tales graves. Por tanto, para la instalación posterior de compo-nentes 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. Edición de programas



3.1 Información general

FTL es la sigla que se obtiene de Festo Teach Language. FTL es un lenguaje de progra-

mación de movimientos y sirve para programar los controles CMRX.

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 cierto 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 se arrancan progra-mas paralelos, el programa principal permanece activo hasta que éstos terminan.

3.4 Avance de proceso

Para procesar rápidamente el 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.



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, calcu-lada 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 circunstancias. 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 correspondiente 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 20.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.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 estructura 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”



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 programación de Festo (en el Festo Configuration Tool), el archivo de datos locales de programa 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.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 independiente-mente 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.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 Datoscompartidos de sistema

Los datos compartidos de sistema son conocidos en todo el sistema en todos los pro-gramas 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.



En la figura siguiente se muestra el proyecto global “_global” enlazado con datos

compartidos 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)

index : DINT := 17

Los tipos de variables posibles se describen en los capítulos siguientes.



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



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, módulos, 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 “Index” no es la misma que las variables con el identificador “INDEX”. 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 MAP MAPTO WAIT

BOOL DINT DWORD REAL STRING ARRAY

El resto de tipos de datos creados a partir de estas claves también son palabras clave.



Lista de todas las funciones:

SIN COS TAN COT LN ABS

SQRT EXP ASIN ACOS ATAN ATAN2

ACOT SHR SHL ROR ROL STR

CHR ORD LOW HIGH

También son válidas las restricciones mencionadas para todos los nombres de instrucción, por ejemplo Lin, Vel, SetError, etc.

4.4 Constantes numéricas

Se diferencia entre números enteros y reales. Los enteros pueden escribirse en

representació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

Operador Significado

+ Adición

- Sustracción

* Multiplicación

/ División

MOD Módulo operación

Tabla 4.1 Operadores aritméticos

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.


AND Operación Y

OR Operación O

XOR Operación O de disyunción

NOT Negación (NO)

Tabla 4.2 Operadores lógicos

4.6.3 Operadores comparativos


< Menor que

<= Menor o igual que

= Igual

<> No igual a

>= Mayor o igual que

> Mayor que

Tabla 4.3 Operadores comparativos



4.6.4 Otros operadores


. 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.6.5 Caracteres de delimitación


:= Asignación de valor para variables

: Carácter de 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


5. Tipos de datos básicos FTL soporta cinco tipos de datos:

Datos booleanos. Números enteros. Patrón 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 datos

Interpretación Capacidad de memoria

Margen de valores

BOOL Bit 8 Bit TRUE o FALSE

DINT Número entero 32 Bit -2.147.483.648 … +2.147.483.647

DWORD Patrón de bits 32 Bit 32 Bit

REAL Número variable

de coma flotante

32 Bit 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 datos

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. Con determinados tipos de datos, para la asignación se deben utilizar las funciones integradas STR, CHR y ORD.

De\a BOOL Números enteros

Patrón de bits REAL STRING

BOOL Sí --- --- --- STR

Números

enteros

--- Sí Sí Sí STR, CHR

Patrón de bits --- Sí Sí --- STR, CHR

REAL --- Sí --- Sí STR

STRING --- ORD ORD --- Sí

Tabla 5.3 Asignaciones posibles

Dependiendo del tipo de datos, se pueden realizar las siguientes asignaciones:

Función Operación

STR Convierte cualquier tipo de datos en una cadena de caracteres.

CHR Convierte un valor ASCII en un único carácter.

ORD Convierte un único carácter en un valor ASCII.

Tabla 5.4 Funciones integradas

5.1 Tipo de dato booleano (BOOL)

El tipo de dato booleano tiene el valor TRUE o FALSO. Se utiliza sobre todo para opera-ciones 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:

pos1 : BOOL

pos2 : BOOL

pos3 : BOOL

min1PosValid : BOOL

allPosValid : BOOL

Código de programa:

allPosValid := NOT pos1 AND NOT pos2 AND NOT pos3

min1PosValid := pos1 XOR pos2 XOR pos3



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 28). Con este modelo de asignación, el sistema convierte internamente los tipos de manera automática.

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:

pressure : REAL

index : DINT


pressure := 1.53

index := pressure // conversión REAL->DINT

La variable “index” recibe el valor “1” después de la conversión.

Indicación

Las conversiones de tipos sólo deben utilizarse cuando la consecuencia está perfectamente clara (véase el ejemplo más arriba).

5.3 Paréntesis

Los paréntesis se utilizan para agrupar cálculos de acuerdo con el orden de procesamiento. Los paréntesis son procesados de dentro a fuera.

Ejemplo:

:

IF (Index < 10) AND (Index > 5) THEN

:

END_IF

:

Distance := (xRow + 10) * Index

:



5.4 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:

message : STRING

part : STRING


message := “cylinder ”

part := “DNC ”

message := message + part + “is extended”

5.5 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 63.

5.6 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. Los límites de la matriz están sometidos a control. Si se realiza una operación que rebasa el tamaño de la matriz, aparece un aviso.

Declaración de matrices:

Sintaxis

VAR

<nombre> : ARRAY [ <tamaño de la matriz> ] OF <tipo de datos> :=

( <inicialización>)

END_VAR



En el parámetro “tamaño de la matriz” se especifica:

El tamaño de la matriz

El índice de rango de la matriz

Las dimensiones de la matriz

Tamaño de la matriz

El tamaño de la matriz se indica por medio de una constante (número entero). El tamaño de la matriz no se puede indicar con una variable.

// Matriz con 10 elementos

Matrix1 : ARRAY [10] OF DINT

// Matriz con 12 elementos

Matrix2 : ARRAY [12] OF CARTPOS



Índice de rango

El índice de rango de la matriz comienza normalmente por 0 y termina por el tamaño de matriz definido menos 1. Si, por ejemplo, se define una matriz de 10 elementos, el índice de la matriz irá de 0 a 9. Mediante el índice de la matriz se accede al elemento individual de la matriz.

Si se requiere un índice de matriz especial, puede especificarse en la declaración de la matriz.

Sintaxis

VAR

<nombre> : ARRAY [<comienzo del índice> ... <final del índice> ] OF

<tipo de datos> := ( <inicialización>)

END_VAR

El siguiente ejemplo muestra una matriz de 10 elementos cuyo índice va de 3 a 12:

Matrix3 : ARRAY [3...12] OF DINT

Dimensiones

Toda matriz tiene, por lo menos, una dimensión, pero también puede tener varias dimensiones. Las matrices multidimensionales se indican especificando sus dimensiones entre corchetes separadas por una coma.

Sintaxis

VAR

<nombre> : ARRAY [<tamaño 1> , <tamaño 2>, <tamaño 3>, ... ] OF

<tipo de datos> := ( <inicialización>)

END_VAR

Los siguientes ejemplos muestran la declaración de matrices multidimensionales:

// Matriz de 2 dimensiones con 3 elementos cada una

= 9 elementos

Matrix1 : ARRAY [3, 3] OF DINT

// Matriz de 3 dimensiones con 3 elementos o 2 elementos

= 18 elementos

Matrix2 : ARRAY [3, 3, 2] OF DINT



Si es necesario, en las matrices multidimensionales también se puede indicar un índice de

rango. El siguiente ejemplo muestra una matriz de 3 x 3 elementos, cada uno con un índice de rango distinto:

Matrix3 : ARRAY [1..3, 5..7, 0..2] OF DINT

5.6.1 Inicialización de matrices

El sistema inicializa las matrices con el valor 0. Si se desea una inicialización distinta, puede indicarse entre paréntesis después del tipo de matriz.

Ejemplo:

Matrix1 : ARRAY [7] OF DINT := (0, 1, 2, 3, , , )

Matrix2 : ARRAY [3, 3] OF DINT := ((1, , 9), (3, , 7), (, , 6))

Cada campo de la matriz se introduce con una coma. Si no se desea inicializar este campo, no debe indicarse. No obstante, la coma es imprescindible para que los demás elementos se inicialicen correctamente.

5.6.2 Cómo determinar los límites de la matriz con LOW y HIGH

Con la palabra clave LOW se puede averiguar el índice de rango más bajo de una matriz y con la palabra clave HIGH, el índice de rango más alto.

Sintaxis

<variable : DINT> := LOW( <variable de matriz> )

<variable : DINT> := HIGH( <variable de matriz> )

A las funciones LOW y HIGH se les transfiere una variable de matriz. Si es preciso averiguar

los límites de una matriz unidimensional, solamente se transfiere el nombre de la matriz. En el caso de las matrices multidimensionales, se debe indicar siempre la dimensión desde la cual se deben transmitir los límites.

Matrix : ARRAY [5, 19, 10..34] OF REAL

Los límites de rango de la matriz son:

De 0 a 4 para la primera dimensión

o Abrir LOW da como resultado 0

o Abrir HIGH da como resultado 4



De 0 a 18 para la segunda dimensión



De 10 a 34 para la tercera dimensión



Indicación

Si se transmite a LOW o a HIGH una variable que no es una matriz, aparece un mensaje de error.

Ejemplos:

Matrix1 : ARRAY [1..4] OF DINT

Matrix2 : ARRAY [3,8] OF DINT

Index : DINT

// El índice tiene el valor 1

Index := LOW(Matrix1)


Index := HIGH(Matrix1)


Index := LOW(Matrix2)


Index := HIGH(Matrix2)


Index := LOW(Matrix2[0])


Index := HIGH(Matrix2[0])



5.7 Variables de referencia (mapeado)

El mecanismo de mapeado permite definir variables como referencias a un determinado tipo. Estas variables se pueden vincular posteriormente con objetos de ese tipo.

De esas variables de referencia se dice que están “mapeadas” a un objeto o que ese objeto está asignado a las variables de referencia. Un uso directo de las variables de referencia equivale por tanto a utilizar el objeto que ha sido asignado a ellas a través del mecanismo de mapeado.

Si se utiliza directamente una variable de referencia que no tiene asignado ningún objeto, se produce un error.

Las variables de referencia solamente utilizan la memoria estrictamente necesaria para

establecer un enlace con el objeto asignado. La memoria utilizada es independiente del tipo de objeto asignado.

El siguiente esquema muestra el mecanismo de mapeado:

Si en el programa se utiliza la variable de referencia Ref_Index, esta variable funcionará con la zona de memoria y el contenido propios de la variable Index_C.

Ejemplo: La instrucción Ref_Index := 10 describe la variable Index_C con el valor 10.

Indicación

Al leer una variable mapeada, se lee la variable asignada. De igual modo, al escribir en una variable mapeada, se escribe en la variable asignada.

Variable de referencia Index_A

Index_B

Index_C

Ref_Index

Mapeado de Ref_Index a Index_C

Variables de programa



5.7.1 Declaración de variables de referencia, <MAPTO>

La declaración de una variable de referencia se puede realizar con cualquier tipo de datos, por ejemplo DINT o REAL. La declaración se lleva a cabo anteponiendo la palabra clave MAPTO al tipo de datos propiamente dicho. Las variables de referencia no se pueden inicializar.

Sintaxis

<variable> : MAPTO <tipo de datos>

Ejemplo:

Index : MAPTO DINT

Level : MAPTO REAL

Home : MAPTO CARTPOS

En este ejemplo se han declarado 3 variables de referencia que tienen asignados distintos tipos de datos.

5.7.2 Vinculación de variables de referencia, <MAP>

Para vincular las variables de referencia a otras variables se utiliza la palabra clave MAP. A la hora de efectuar esta operación, debe recordarse que sólo es posible vincular variables que tengan el mismo tipo de datos que las variables de referencia.

Sintaxis

<variable> : MAP( <variable> )

5.7.3 Comprobación de variables de referencia, <IS_MAPPED>

Con la función IS_MAPPED se puede comprobar si una variable de referencia está vinculada a una variable. Si en el programa se utiliza una variable de referencia que no está vinculada, se producirá un error.



Sintaxis

IS_MAPPED (<variable de referencia>) : BOOL

Valores devueltos:

TRUE La variable de referencia está vinculada

FALSE La variable de referencia no está vinculada

Esta función se utiliza, por ejemplo, al emplear variables de referencia en un subprograma, en cuyo caso la vinculación de variables se realiza fuera de dicho subprograma.

Ejemplo:

IF IS_MAPPED(Level) THEN

:

:

ELSIF

SetError(“Not mapped”)

END_IF



5.8 Instrucción DO

Con la instrucción DO se pueden ejecutar instrucciones durante la ejecución principal del programa. Esta instrucción tiene la siguiente sintaxis:

Sintaxis

<macro FTL> DO <macro o instrucción>

La instrucción DO se ejecuta durante la ejecución principal del programa. La instrucción DO no influye en el cálculo por adelantado del programa.

Después de una instrucción DO puede haber una macro o una instrucción. No se permiten las macros ni instrucciones referidas a una cinemática, por ejemplo, una indicación de

dinámica o un recorrido de posicionado. Este tipo de instrucciones solamente se permiten antes de la instrucción DO, ya que la planificación de la trayectoria no puede tener en cuenta las instrucciones situadas después de la instrucción DO.

Indicación

La instrucción DO se ejecuta después de que se ha ejecutado, en la ejecución principal, la instrucción situada antes de ella. La ejecu-ción se realiza incondicionalmente.

Con la instrucción DO se pueden, por ejemplo, describir variables o establecer salidas en

la ejecución principal del programa FTL. La instrucción DO se puede utilizar combinada con todas las instrucciones de movimiento, por ejemplo Ptp o Lin.

Ejemplo de establecimiento de una salida:

Al alcanzarse la pos2 se establece la salida del módulo “Vacuum” (vacío).

:

Lin(pos1)

Lin(pos2) DO Vacuum.Set()

Lin(pos3)

:



Ejemplo de descripción de variables en el PLC:

:

Lin(pos1)

Lin(pos2) DO plc_Dint[3] := 5

Lin(pos3)

:

Con la instrucción DO se pueden llevar a cabo operaciones de conmutación sencillas. Estas operaciones se realizan en la ejecución principal del FLT. En este caso no se pueden compensar los posibles tiempos de conmutación. No se produce ninguna conexión con la

velocidad de trayectoria. Esto significa que el comportamiento de conmutación, referido a la trayectoria, se puede modificar cambiando la dinámica de dicha trayectoria.

Ejemplo

En el siguiente contorno se debe conectar una salida digital en los tramos rectos y se debe desconectar dicha salida en los arcos de círculo.

:

Lin(Pos1) DO Applicator.Set()

Lin(Pos2) DO Applicator.Reset()

CircIp(Ipos1,Pos3) DO Applicator.Set()

Lin(Pos4) DO Applicator.Reset()

CircIp(Ipos2,Pos1)

:

Pos2 Pos1

Pos3 Pos4

Ipos1

Ipos2



1

1 P1

1

1 P1´

1

1 P2

1

1 P0

La instrucción DO se ejecuta aquí.

5.8.1 Comportamiento en el área de avance aproximado

Si el avance aproximado está activado, no se podrá ejecutar la instrucción DO al alcanzar el punto programado, ya que el avance aproximado impedirá que se alcance dicho punto. En este caso, el punto de conmutación se proyecta sobre la trayectoria del área de avance aproximado y se ejecuta.

Indicación

Si los segmentos de movimiento desembocan tangencialmente uno en otro, el avance aproximado no influirá en modo alguno en la ejecución de la instrucción DO.

6. Declaración de variables


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

index : DINT

name : 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:

index : DINT := 1

pi : REAL := 3.1415

radius : REAL := 10

flag : BOOL := TRUE

message : STRING := “Hello”

7. Expresiones


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. ( ) (Paréntesis)

2. [] (Índice de matriz)

3. NOT (Negación)

4. * / MOD AND (Multiplicación, división, módulo, Y lógico)

5. + - OR XOR (Adición, sustracción, O/EXOR lógicos)

6. < <= = <> >= > (Operaciones de comparación)

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., >, <=,=). El enlace de varias comparaciones se estructura mediante los

correspondientes niveles entre paréntesis.

Para los ejemplos siguientes se van a utilizar las variables indicadas a continuación:

Marker : BOOL

Flag1 : BOOL

Flag2 : BOOL

Flag3 : BOOL

Index : DINT



Ejemplos de condiciones:

Marker := Index < 10

Marker := Flag1 AND Flag2 OR Flag3

IF Index < 10 THEN

:

END_IF

WHILE Index < 5 DO

:

END_WHILE

WHILE NOT Flag1 AND Flag3 OR Flag2 DO

:

END_WHILE

Ejemplos de condiciones con paréntesis:

Marker := (Index < 10) AND (Index < 0)

Marker := Flag1 AND (Index < 7)

IF (Index < 10) AND (Index > 5) THEN

:

END_IF

8.4 Bifurcación <IF…THEN>

La instrucción IF permite realizar bifurcaciones dependientes de condiciones en la eje-cución del programa. La condición debe ser del tipo de dato BOOL y puede estar com-puesta por varios operandos. Con la instrucción ELSIF pueden formularse varias condi-

ciones. 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.

partOk Señal de pieza buena

partBad 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 partOk AND NOT partBad THEN // pieza buena Lin(pos12) Lin(pos13) ELSIF NOT partOk AND partBad THEN // pieza desechable Lin(pos3) Lin(pos4) ELSE Lin(posStart) // ninguna señal definida END_IF

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

compone 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.

Indicación

Si la programación se efectúa con el CDSA, primero debe definirse 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.

:

Lin(pos15)

Lin(pos16)

Lin(pos5)

Lin(pos6)

:

IF teilOk GOTO lblHome

LABEL lblHome

Condición de salto

Destino del salto



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 condi-ció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 abso-luta. 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

Si la programación se efectúa con el CDSA, primero debe definirse el destino del salto (LABEL). La instrucción GOTO no puede progra-marse 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.

Atención

La programación de bucles sin fin puede afectar al 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 ejecutarse con mucha frecuencia y no contiene instrucciones 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 index < 5 DO

Lin(pos1)

Lin(pos2)

Lin(pos3)

index := index + 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 instrucció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.

Sintaxis

LOOP <número> DO

<instrucciones>

END_LOOP

Ejemplos:

LOOP 10 DO // 10 pasadas

index := index + 13



END_LOOP

j := 0

...

LOOP j DO // se salta, ya que j = 0

index := index + 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 19). Los programas llamados se deno-minan 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.



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 programas.

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. Antes de la llamada, estas variables reciben los valores correspondientes 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> ( )

Programa principal

Subprograma



Ejemplo:

:

variant := 17 // Variable para el programa Pegar

directionRight := TRUE // variable del programa Pegar

directionLeft := FALSE // variable del programa Pegar

CALL Glueing() // Subprograma Pegar

CALL MoveStart() // Subprograma “moverse hasta la

posición inicial”

:

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 CheckPart() // Llamar a subprograma CheckPart

IF NOT partOk THEN

partStatus := 10 // Variable global para el valor de retorno

RETURN // Adelanto del fin de programa

END_IF

Lin(pos3)

:



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 requeri-miento, 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” se sigue procesando.

Programa paralelo

Programa principal

Sprungziel



Indicación

Si se programa un bucle sin fin en un programa paralelo, debe garantizarse que ello no bloquee la ejecución de los otros pro-gramas. 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 Finalización del programa paralelo <KILL>

Un programa paralelo activo puede terminarse con la instrucción “KILL” emitida desde el programa que lo ha llamado. Primero se detienen el programa y la cinemática, luego el programa finaliza.

Sintaxis

KILL <nombre del programa>

La instrucción RETURN en programas paralelos también provoca su terminación.

8.9 Influencia del avance de proceso

8.9.1 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 deten-ció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)

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:

Tiempo de

espera 70

ms

Tiempo

Velocidad de trayectoria

pos1 pos1 pos2



8.9.2 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.

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 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 se realiza durante el avance de proceso, 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.1 WAIT – Instrucción con tiempo en la página 54).

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.

Lin(pos1)

Lin(pos2)

Lin(pos3)

Lin(pos4)

Lin(pos5)

Wait sensor

Lin(pos6)

Lin(pos7)

Lin(pos8)

Lin(pos9)

Proceso

principal 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.

Avance de

proceso



Sintaxis

WAIT <condición>

Ejemplo:

Se van a introducir piezas con un plano inclinado en 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(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



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 inmediata-mente hasta ella sin interrumpir el movimiento.

8.9.3 WaitOnPath – Instrucción con tiempo <WaitOnPath>

La macro WaitOnPath genera un tiempo de espera que solamente repercute sobre el movimiento. Este tiempo de espera se incorpora directamente a la planificación de la trayectoria y los ejes se frenan con la dinámica programada. Una vez transcurrido ese tiempo, se continúa con la siguiente trayectoria. El avance de proceso del programa FTL no

se detiene.

Indicación

La macro WaitOnPath no es apropiada para sincronizar instruc-ciones (por ejemplo la conmutación de una salida o la descripción de una variable) con la ejecución principal del programa.

Sintaxis

WaitOnPath ( <timeMS> : DINT )

Parámetro Significado Unidad

time Tiempo de espera ms

Tabla 8.1 Parámetros de la instrucción WaitOnPath

Ejemplo:

Con un troquel se estampa una marca sobre una pieza. Una vez alcanzada la posición de estampado, para que se transfiera el color debe aguardarse un tiempo de espera de 150 ms. Sin embargo, el avance de proceso no se debe detener.

:

Lin(pos1) // Avanzar a seguridad

Lin(printPos) // Avanzar a posición de estampado

WaitOnPath(150) // Esperar 150 ms

Lin(pos1) // Avanzar a seguridad

:



Tiempo de espera 150 ms

Tiempo


pos1

pos1

printPos



8.9.4 WaitOnPos – Instrucción con tiempo <WaitOnPos>

La macro WaitOnPos detiene el avance de proceso hasta que se ejecuta el porcentaje indicado del segmento actual. A continuación, el programa continúa ejecutándose.

Sintaxis

WaitOnPos ( OPT <pos> : REAL )


Pos Valor porcentual de longitud del

segmento de trayectoria

Porcentaje

Tabla 8.2 Parámetros de la instrucción WaitOnPos

Si está activado un avance aproximado y la distancia hasta el punto de destino del avance aproximado es lo bastante grande, el avance se ejecuta. El parámetro de la parte porcen-tual es opcional. Si no se especifica, tendrá un valor de 100%. Esto tendrá como conse-cuencia una parada sobre la trayectoria.

En el siguiente ejemplo, se alcanzan posiciones y el avance de proceso se detiene hasta que se recorre el 80% del segmento de la trayectoria. A continuación, en el ejemplo la variable Index adquiere el valor 10.

Lin(Pos1)

Lin(Pos2)

WaitOnPos(80)

Index := 10

Pos2

Pos1

80%



8.10 Insertar comentarios <//>

Un comentario se abre con la secuencia de caracteres “//”. Puede colocarse solo al comienzo de línea o después de una instrucción FTL y se cierra 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.11 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.

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


9. Instrucciones de movimiento Los movimientos de una cinemática se activan con instrucciones de movimiento. Dichas instrucciones describen el movimiento desde la posición actual al punto de destino indi-cado. 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 cinemática.

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 20).

Una posición puede introducirse en el sistema de coordenadas de ejes o en un sistema de coordenadas cartesianas. Dado que estas indicaciones de posición tienen orígenes diferentes, existen 2 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.5 Tipos de datos estructurados en la página 31).

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.5 Tipos de datos estructurados de la página 31). É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 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






a7 : REAL Posición del eje auxiliar 1



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 en otra ubicación el valor de

eje 1

posA2 := startPos.a2 // Guardar en otra ubicación el valor de

eje 2

:



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 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





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 cine-má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



No es posible realizar algunas indicaciones en una posición cartesiana debido a la cine-

má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 liber-tad de movimiento. X, Y, Z son las posiciones de traslación, A, B y C describen la orienta-ció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.5 Tipos de datos estructurados de la página 31). 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



Programa:

:

Lin(startPos) // Avanzar a StartPos

newPos := startPos // Copiar StartPos

newPos.x := newPos.x + 10 // Calcular X

newPos.x := newPos.x + 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 despla-

zamiento punto a punto con posición de destino. Con esta instrucción se arrancan simul-tá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.



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 herra-mienta (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. Para ello se puede utilizar p. ej., el override.

Sintaxis

Ptp ( <Pos> : AXISPOS o CARTPOS)


Pos Posición de destino. AXISPOS o CARTPOS

Tabla 9.1 Parámetros 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

2

1

4

3



Variable:

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

Eje de

rotación

0 grados

Eje de rotación 90 grados

Trayectoria aproximada en el TCP

Trayectoria en el eje Z

Eje de rotación

180 grados



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)


Dist Distancia relativa que debe recorrerse AXISDIST o CARTDIST

Tabla 9.2 Parámetros 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

207

100



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 Check() // Llamada de ciclo de comprobación

PtpRel(distZpos)

PtpRel(distX)

END_LOOP

PtpRel(distZneg)

CALL Check() // 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.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)


Axis 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


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.



Variable:

:

pos1 : CARTPOS := (300, 0, 250, 0, 0, 0, 0, 0, 0)

takeAbove : CARTPOS := (350, 0, 145, 0, 0, 0, 0, 0, 0)

pos2 : CARTPOS := (575, 0, 250, 0, 0, 0, 0, 0, 0)

takePos : REAL := 96.5

:

Programa con movimientos PTP:

:

Ptp(pos1) // Aproximación

Ptp(takeAbove) // Recogida arriba

MoveAxisPtp(A4, takePos) // Girar pinza

MoveAxisPtp(A3, 50) // Hacia abajo

Gripper.Set() // Cerrar pinza

MoveAxisPtp(A3, 145) // Hacia arriba

MoveAxisPtp(A1, 450) // Posado arriba

MoveAxisPtp(A4, 180) // Girar sobre bandeja

MoveAxisPtp(A3, 50) // Posado abajo

Gripper.Reset() // Abrir pinza

MoveAxisPtp(A3, 145) // Posado arriba

Ptp(pos2) // Retirada

:

pos2

X-Achse

Eje Z

50

575

450

145

pos1

Recogida arriba

Recogida abajo

Posado arriba

Posado abajo

250

350

300



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 posi-ció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

directamente 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)


Pos Posición de destino

absoluta

AXISPOS o CARTPOS

Tabla 9.5 Parámetros 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.



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 14 Herramientas en la página 122).

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



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 de 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)


Dist Posición de destino

relativa

AXISDIST o CARTDIST

Tabla 9.6 Parámetros 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



Trayectoria

en el TCP

Trayectoria

aproximada en el eje Z



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)

direction : BOOL

:

pos2

Eje Y

100

1050

387

98.5

45

pos3

pos1

57

112

Eje X



Programa:

:

Lin(pos1)

Lin(pos2)

direction := TRUE

LOOP 5 DO

IF direction = TRUE THEN

LinRel(distYpos)

ELSE

LinRel(distYneg)

END_IF

LinRel(distX)

direction := NOT direction

END_LOOP

LinRel(distYneg)

Lin(pos3)

:

Con la variable “direction” 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 geo-mé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 Modo de 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.



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.

Limitaciones:

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 de apoyo

Punto de apoyo

Punto inicial

Punto inicial

Punto final

Punto final



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.

Punto de apoyo

Punto inicial

Punto final

Plano formado por tres puntos



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)


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 corresponde con el punto final del movi-miento 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 necesaria-mente un mensaje de error ya que el resultado del cálculo es correcto.



Ejemplo:

se debe recorrer el contorno siguiente:

El eje Z permanece en la coordenada 0. La aproximación al punto inicial del arco se efectúa mediante 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) // Retirada

:

Posición pos1

Punto de apoyo IpPos

Punto final EndPos

Posición pos2

Eje X

Eje Y

300

400

500

1050

950

455



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,



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




Ejemplo:


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) // Retirada

:

Posición inicial StartPos


Punto final EndPos

Posición Pos1

Eje X

Eje Y

300

400

500

1050

950

455



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,



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


Ejemplo:


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.

Posición inicial StartPos


Punto final EndPos Posición Pos1

Eje X

Eje Y

300

400

500

1050 950 455



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 lineal, movimiento circular cartesiano

LinToCircIp(StartPos, IpPos, EndPos)

Lin(Pos1) // Retirada

:

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

cinemática. La reducción de la dinámica por un override no afecta 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 movi-

miento. En el capítulo 20.1 Detención de movimientos en la página 194 se da un ejemplo de utilización de la instrucción StopMove.



9.9 Detención del programa <StopProgram>

La instrucción StopProgram detiene el programa, que a su vez pasa al estado de parada. Esta instrucción corresponde a la tecla de parada de la unidad manual. Para continuar es necesario un nuevo inicio, p. ej. a través de la unidad manual o externamente a través de un control PLC.

La instrucción está activa en la ejecución principal, lo que significa que no se ejecuta a través del avance de proceso. La ejecución de las instrucciones anteriores, calculadas a través del avance de proceso, está garantizada.

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 afecta a la detención.

Sintaxis

StopProgram()

Ejemplo:

:

Vel(dynCart, 1000)

Lin(pos1)

Lin(pos2)

SetInfo(“insert workpiece and press start”)

StopProgram()

Lin(pos3)

CALL Conture1

:

10. Instrucciones de dinámica


10. Instrucciones de dinámica Con las instrucciones de dinámica pueden programarse la velocidad, la aceleración y la sacudida para los movimientos de la cinemática. 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.

Indicación

En la configuración (Festo Configuration Tool) se indican los valores iniciales de la dinámica. Estos valores se activan como valores iniciales cuando se inicia un programa. Si en el programa no se programa ninguna dinámica, se utilizan estos valores iniciales. Dentro del programa, los valores pueden ser sustituidos en cualquier momento por las siguientes instrucciones de dinámica:

Gráfico de ajustes de los valores dinámicos en Festo Configuration Tool:



10.1 Limitación automática de la dinámica, limitador de la dinámica

Para mantenerse fiel a la trayectoria, es necesario comparar los valores dinámicos nomi-nales con los valores dinámicos físicos posibles. Eso evitará que se rebasen los valores máximos posibles de cada uno de los ejes. Estos valores son: velocidad, aceleración y sacudida. Estos valores máximos están guardados en la configuración de los diferentes ejes.

El control CMXR cuenta con un limitador de los valores dinámicos que recibe el nombre de “limitador de la dinámica”. Este limitador opera en el cálculo por adelantado del programa FTL y compara constantemente los valores dinámicos que se deben recorrer con la máxima

dinámica posible de cada eje.

Indicación

El limitador de dinámica está continuamente activado. No es necesario activarlo.

El que el limitador de dinámica intervenga depende de los siguientes factores:

Tamaño de la dinámica programada

Configuración de la trayectoria de movimiento de la cual se derivan los valores dinámicos de los diferentes ejes.

Si se sobrepasa el máximo de por lo menos un eje debido a la dinámica programada o a la modificación de la trayectoria de movimiento, la dinámica de dicha trayectoria se reducirá de manera que el eje afectado se desplace hasta sus límites. La trayectoria no se aban-dona. Una vez que la cinemática abandone las trayectorias de movimiento críticas y sea posible una dinámica más alta, el sistema lo detectará y acelerará hasta el valor programado.

En el siguiente ejemplo se alcanza el límite de un eje y eso hace que se reduzca auto-máticamente la velocidad de la trayectoria para garantizar la fidelidad a dicha trayectoria. Una vez que el eje ha abandonado el rango crítico, se produce una aceleración hasta alcanzar el valor programado.

Velocidad de

trayectoria

Límite del eje

Reducción de la velocidad

de la trayectoria

Límite del eje individual

alcanzado



10.2 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, <Value> : REAL)


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

Enumeración parámetro 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:

:

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.3 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)


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




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.

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.4 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)


Mode Tipo de movimiento Enumeración: dynPtp, dynCart

Value Tipo de sacudida

Tabla 10.5 Parámetros de la instrucción Jerk




dynCart Cartesiano mm/s³

Tabla 10.6 Unidades del parámetro Value

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.5 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 pro-gramada 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.5.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 en funcionamiento. Sin embargo, en modo auto-mático debe estar al 100% para poder aprovechar al máximo la dinámica. Las adapta-ciones correspondientes 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.



Sintaxis

Ovr ( <Value> : REAL)


Value Valor de override Porcentaje

Tabla 10.7 Parámetros de la instrucción Ovr

Indicación

Para aprovechar la dinámica máxima de la cinemática, 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.

Funcionamiento:

Cualquier modificación del override en la unidad manual repercute inmediatamente sobre el movimiento. Debido al cálculo por adelantado del programa, el override no se puede modificar de forma inmediata a través de la macro Ovr. El uso de Ovr detiene por tanto el cálculo por adelantado, lo que a su vez provoca una parada sobre la trayectoria. No es

posible un avance aproximado hasta el siguiente segmento de la trayectoria.

Ejemplo:

// Ajuste del override al 100%

Ovr(100)

Lin(pos1)

Lin(pos2)

// Ajuste del override al 60%

Ovr(60)

Lin(pos3)

Lin(pos4)



10.5.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)


Value Valor del override dinámico Porcentaje

Tabla 10.8 Parámetros de la instrucción DynOvr

Indicación

El override no modifica la trayectoria. El valor programado no repercute sobre el cálculo por adelantado del programa.

La modificación del override con

Ovr detiene el movimiento.


pos4 pos3 pos2 pos1

60%

100%

Ändern des Override mit Ovr hält die Bewegung an.

Zeit

Bahngeschwindigkeit

pos4

pos3

pos2

pos1

60%

100%

Tiempo



10.6 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. Si el valor es 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.

Tiempo

Aceleración

0

0,2

0,4

0,6

0,8

1

1,2

0,000 0,333 0,667 1,000

Besch

leu

nig

un

g

Zeit

TrapezTrapecio Seno

JMinjerk Seno al quadrato

Ace

lera

ció

n

Ace

lera

ció

n

Ace

lera

ció

n

Ace

lera

ció

n

Forma de rampa trapezoidal con un factor aproximado de 0,1

Forma de rampa trapezoidal con un factor 0,5



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 de la cinemática empleada y de la aplicación. Tras seleccionar la forma de rampa, debe probarse en el movimiento.

10.6.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)


Ramptype 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



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.7 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)


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.4 Avance aproximado por geometría en la página 107). 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



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 velocidad de trayectoria.

Con el parámetro Tolerance puede introducirse un valor porcentual de bajón admisible en

la velocidad de trayectoria. Si el valor de tolerancia indicado es 100%, la monitorización se desconecta.

Indicación

El control de velocidad de la trayectoria no tiene en cuenta el over-ride ajustado en la unidad manual. Esto significa que si la cine-mática no alcanza toda su velocidad porque un override la limita, se activará dicho control y se producirá un error.

Ejemplo:

Programa:

:

Lin(pos1)

VconstOn(25, TRUE)

Lin(pos2)

Lin(pos3)

VconstOff ( )

:



10.8 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. Instrucciones de avance aproximado


11. Instrucciones de avance aproximado Como avance aproximado se entiende la aceleración de los ejes para aproximarse a la posició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 brusquedad del movimiento.

En la figura siguiente se muestra el funcionamiento del avance aproximado.

El programa de movimiento contiene un posicionamiento en la posición 1 y luego en la posición 2. Mediante la función de avance aproximado, que se ajusta por medio de una instrucción de programa, las distintas posiciones no se alcanzan con exactitud. 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, curvas de

polinomio

Posición 1 Posición 2

Trayectoria

de la cinemática



Indicación

En el área de avance aproximado, la trayectoria viene dada por una curva de polinomio resultante de unos cálculos matemáticos. Esta curva da lugar a un aumento continuo de la dinámica y, por consi-guiente, a un comportamiento no perjudicial para el sistema mecá-nico. Este comportamiento no se puede lograr con un redondeo por medio del radio. Por consiguiente, el avance aproximado no permite redondear los segmentos de trayectoria.

11.1 Segmentos cero

Si se programa un segmento cero, es decir, el nuevo posicionamiento sobre la posición ya alcanzada, no es posible el avance aproximado. Esto provoca un frenado seguido de una aceleración sobre la trayectoria.

Ejemplo:

Lin(pos1)

Lin(pos2)

// Nuevo posicionamiento en pos2 = no es posible el avance

aproximado

Lin(pos2)

Lin(pos3)

Puesto que la posición pos2 se ha programado más de una vez, en este punto del programa se produce una parada sobre la trayectoria.



11.2 Área extrema

Si la distancia entre dos puntos es menor que la necesaria para avanzar entre la trayec-toria 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 segmento 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 trayec-toria.

Indicación

Si la longitud del segmento de trayectoria es demasiado corta, se pueden producir 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.

Área de avance aproximado programada Área de avance aproximado que se solapa

Área de avance aproximado generada por el control

Trayectoria recorrida



11.3 Avance aproximado por velocidad

Para el avance aproximado por velocidad se solapan los perfiles dinámicos de la trayec-toria. Con ello se obtiene un movimiento a la posición siguiente dentro del área de avance aproximado.

11.3.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)


Value Valor de avance

aproximado

Porcentaje

Tabla 11.1 Parámetros de la instrucción OvlVel

Parámetros:

Porcentaje Parámetros de avance aproximado en %

0% Sin avance aproximado

100% Aprovechamiento máximo de las aceleraciones de ejes

100..200% Sin pérdida de tiempo, movimiento más suave con un área de avance aproximado más grande

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 aceleraciones de los ejes se reducen a diferencia de un ajuste del 100%.

La siguiente figura muestra los perfiles de velocidad de un desplazamiento hasta las posiciones 1 y 2. Para el área de avance aproximado se han definido distintos valores.



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 de polinomio 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)

:

1) Sin solapamiento

2) Solapamiento parcial

3) Solapamiento completo

Tiempo de ciclo

Tiempo de ciclo

Tiempo de ciclo

Sentido Y

Área de avance aproximado

Sentido X



11.4 Avance aproximado por geometría

En el avance aproximado por geometría, se fijan las desviaciones de la posición final programada. A diferencia del avance aproximado por velocidad, la asimetría es geo-mé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.

No es adecuado para redondear esquinas, ya que la forma geométrica en el área de avance aproximado no es un radio, sino una curva de polinomio. Los radios no son adecuados para el avance aproximado, ya que provocan un aumento brusco de la aceleración.

11.4.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.

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 curva es tangencial con respecto a los 2 tramos de trayectoria en cuestión. El límite del área de avance aproximado forma la mitad del más corto de los segmentos de trayectoria implicados.

La trayectoria en el área de avance aproximado no es un radio, sino un polinomio de quinto grado. Este polinomio genera la trayectoria suave máxima posible, lo que no puede hacerse con un arco de círculo.

Sintaxis

OvlCart (<Distance> : REAL)

Esfera con área

de avance

aproximado




Distance Área de avance aproximado, distancia hasta

el punto final

Unidad de longitud ajustada

Tabla 11.2 Parámetros de la instrucción OvlCart

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.7 Conexión de la velocidad de trayectoria constante en la página 99).

Ejemplo:

Un contorno debe recorrerse a una velocidad de trayectoria constante y con un área 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


12. 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.

12.1 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 aditivo

al desplazamiento 2 Desplazamiento 2



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.

12.2 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 refe-rencia en otro sistema de referencia. Además, en cada uno de los tipos de datos estruc-turados 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.



12.3 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)


refSys Sistema de referencia definido por los valores de

desplazamiento

Unidades de longitud y de

ángulo

Tabla 12.1 Parámetros 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




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 relacionar el sistema de coordenadas de la cinemática con el sistema de coordenadas universales, se debe efectuar una referenciación con la variable de sistema _system.world.

Ejemplo:

Datos:

refsysdata0 : REFSYSDATA := (MAPX("_system.world”),

100, 150, 0, 0, 0, 0)

Programa:

SetRefSys(refsysdata0)



12.4 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)


refSys Sistema de referencia determinado por tres posiciones Unidades de longitud y de ángulo

Tabla 12.2 Parámetros 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

La 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 relacionar el sistema de coordenadas de la cinemática con el sistema de coordenadas universales, se debe efectuar una referenciación con la variable de sistema _system.world.



Procedimiento de teach-in:

Atención

El tercer punto determina el plano XY positivo. El tercer punto puede, dependiendo de su posición, provocar un giro del sistema de coordenadas, por ejemplo un giro de 180 grados del eje Z.

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)

Segundo punto = eje X positivo Primer punto = origen

Tercer punto = plano XY positivo Tercer punto = plano XY positivo



12.5 Sistema de referencia universal <SetRefSysWorld>

Con esta instrucción se activa el sistema de referencia universal cuyo origen está guardado en la configuración de la cinemática.

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.

12.6 Ejemplo

En el ejemplo siguiente deben vaciarse dos paletas e introducir 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)

:

Alimentación de la máquina

X

Y

Paleta 1 Paleta 2

Sensor para detección de espacio libre

300

300 1500



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

SetRefSys(refPal1) // Activar desplazamiento de paleta 1

CALL Feed() // Llamar subprograma Feed

SetRefSys(refPal2) // Activar desplazamiento de paleta 2

CALL Feed() // Llamar subprograma Feed

SetRefSysWorld() // Activar sistema universal

Lin(pos1)

:

13. Referenciación de una cinemática



13.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)


Axis 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 13.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 cinemática, la disposición de los ejes en la herramienta puede provocar movimientos incontrolados.

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).

Atención

Durante el recorrido de referencia debe observarse que los ejes participantes pueden moverse con libertad. Además, deben seleccionarse los valores dinámicos apropiados para estos movimientos de modo que el recorrido de referencia sea razonable. En este caso, no se recomiendan valores dinámicos elevados.



La referenciación requiere algunos datos para su ejecución. Estos datos se indican en un

conjunto de datos de referencia del tipo REFDATA.

Parámetro 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 (aproximación al interruptor)

velZero REAL Velocidad de avance lento (búsqueda del flanco)

acc REAL Aceleración del recorrido de referencia

Tabla 13.2 Estructura del tipo de dato REFDATA

Indicación

Si se especifica el método de recorrido de referencia 99, se utilizarán los parámetros de recorrido de referencia tal como fueron guardados en el accionamiento mediante Festo Configuration Tool (FCT). En ese caso, el recorrido de referencia se realiza igual que durante la puesta en funcionamiento de los diferentes ejes. Todos los demás parámetros, tales como offset, velSwitch, zeroSwitch y acc serán irrelevantes.

Método del recorrido de referencia

El recorrido de referencia puede realizarse de varias maneras, p. ej., a un limitador de carrera negativo con evaluación de impulso de puesta a cero, a un limitador de carrera positivo con evaluación de impulso de puesta a cero o recorrido de referencia a un limi-tador de carrera. Todos estos métodos se encuentran en la correspondiente documen-tación del CANopen de cada regulador de 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 cero

-1 Negativo Tope Impulso cero

1 Negativo Limitador de carrera Impulso cero

2 Positivo Limitador de carrera Impulso cero

7 Positivo Interruptor de

referencia Impulso cero

11 Negativo Interruptor de

referencia Impulso cero



Valor Sentido Destino Punto de referencia para 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 cero Impulso cero

34 Positivo Impulso cero Impulso cero

35 - Ningún recorrido Posición real actual

99 - - Ejecución definida como en el

proyecto FCT del eje

Tabla 13.3 Métodos del recorrido de referencia

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 de los ejes 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.

13.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 la ejecución del programa se reanuda una vez iniciada 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)




Axis 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 13.4 Parámetros de la instrucción RefAxisAsync

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 cinemática, la disposición de ejes en la herramienta puede provocar movimientos incontrolados.

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).

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 movimientos de modo que el recorrido de referencia sea razonable. En este caso, no se recomiendan valores dinámicos elevados.

Los parámetros y su funcionamiento se corresponden con la instrucción RefAxis.

Indicación

Si se especifica el método de recorrido de referencia 99, se utilizarán los parámetros de recorrido de referencia tal como fueron guardados en el accionamiento mediante Festo Configuration Tool (FCT). En ese caso, el recorrido de referencia se realiza igual que durante la puesta en funcionamiento de los diferentes ejes. Todos los demás parámetros, tales como offset, velSwitch, zeroSwitch y acc serán irrelevantes.



13.3 Espera al final del recorrido de referencia <WaitRefFinished>

Con esta instrucción se espera a que finalicen todos los recorridos de referencia asíncro-nos 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 homing”)

END_IF

Atención

A la hora de ejecutar la macro RefAxisAsync, es obligatorio utilizar la macro WaitRefFinished para garantizar la ejecución subsiguiente del programa. Si no se aguarda al final del recorrido de referencia, el cálculo por adelantado del programa puede dar lugar a instruc-ciones que provoquen errores.



13.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


Axis Eje seleccionado objeto de la interrogación Enumeración A1,

A2, hasta A9

Tabla 13.5 Parámetros de la instrucción IsAxisReferenced

Si el eje indicado está referenciado se emite TRUE, de lo contrario, FALSE.

14. Herramientas


14. 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 asig-narse 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.

14.1 Datos de herramienta

14.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




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

14. Herramientas


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 coordena-das 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°

14. Herramientas


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 con-junto 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

14. Herramientas


14.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 la cinemática. De este modo se modifica el punto de trabajo de la cinemática.

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 plani-ficación de la trayectoria del movimiento. Estos datos TCP se tienen en cuenta en todas las

instrucciones siguientes.


ToolData Datos de herramienta TCPTOOL

Tabla 14.1 Parámetros 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 desplaza-miento 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 o 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 movi-miento cartesiano.

14.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 planifi-cació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.

14. Herramientas


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 la dirección 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

14. Herramientas


Orientación 2, herramienta girada:

Con el movimiento giratorio, el TCP se desplaza hacia un lado. La orientación de la

herramienta se ha modificado.

La cinemática de la figura es de sistema cartesiano. En éste, la posición del sistema de coordenadas cartesiano de los ejes de base X, Y y Z coinciden con el sistema de coordenadas de herramienta cartesianas. Si se aplica la regla de la mano derecha para determinar la orientació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:

Nuestra cinemática cartesiana 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

Sauggreifer

Y

Longitud de herramienta

Eje de rotación

TCP

14. Herramientas


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 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

14. Herramientas


Segundo desplazamiento a pos2 con tool2:

:

Tool(tool1)

Lin(pos1)

Lin(pos2)

CALL Rotate() // Llamar 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 la cinemática cartesiana, 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

15. Interface PROFIBUS


15. 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.



15.1 Indicaciones sobre el procesamiento de señales

Las variables FTL de la interfaz PLC tratadas en los siguientes capítulos se calculan, como otras variables, siempre en el cálculo por adelantado (avance de proceso) del programa FTL. Si es necesario ejecutar variables durante la ejecución de la línea de programa activa (ejecución principal), debe tomarse una serie de medidas adicionales. Una posibilidad consiste en utilizar la instrucción DO.

El siguiente gráfico explica las diferencias que existen en el procesamiento de señales:

15.2 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.

Lin(pos1)

Lin(pos2)

Lin(pos3)

Lin(pos4)

Lin(pos5)

plc_Dint[1] := 2

Lin(pos6)

Lin(pos7)

Lin(pos8)

Lin(pos9)

Ejecución

principal

Avance

Lin(pos1)

Lin(pos2)

Lin(pos3)

Lin(pos4)

Lin(pos5) DO plc_Dint[1] := 1

Lin(pos6)

Lin(pos7) DO plc_DInt[3] := 2

Lin(pos8)

Lin(pos9)

Lin(pos10)

Ejecución

principal

Avance

La variable se ejecuta en el

avance de proceso.

Uso de la instrucción DO, la

variable se ejecuta en la

ejecución principal.



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:

:

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

:

Ejemplos con avance de proceso, con instrucción DO

15.3 Variables enteras de 32 bits

La interface dispone de 256 variables enteras del tipo 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 enteras 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 enteras 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

15.4 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 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])

:



15.5 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 de la cinemática.

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)

:



15.6 Pausa programada <ProgHold>

Esta instrucción opera en combinación con la señal HALTENA de la interfaz PLC. Es ade-cuada para fines de prueba o puesta en funcionamiento y se puede agregar a cualquier línea de programa para detenerse en ella a petición del programa.

Si la señal HALTENA está activada en la interface, es decir, si tiene el estado TRUE, el programa de movimientos se detiene al llamar la macro ProgHold. Solamente se detendrá el programa en el que se encuentra la macro ProgHold. Los demás programas, por ejemplo los programas paralelos, continuarán ejecutándose. Si el PLC asigna a la señal HALTENA el valor estado FALSE, el programa detenido continuará ejecutándose.

Indicación

Si con la macro ProgHold se detienen varios programas (p. ej. programas paralelos), el estado de señal FALSE hará que todos ellos vuelvan a ponerse en marcha en conjunto. No es posible poner en marcha programas específicos seleccionados de entre aquellos que se han detenido.

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:



Desarrollo con pausa programada:

Desarrollo sin pausa programada:

pos2 pos1 pos3 pos4 pos5

Velocidad

Tiempo

Tiempo entre la parada y la reanudación de la marcha

pos2 pos1 pos3 pos4 pos5

Velocidad

Tiempo

16. Sistema de comunicación


16. 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:

16.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 libre-mente los textos de mensaje como cadena de caracteres (string). Esta cadena de caracte-res 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



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 String. El tipo de variable BOOL se inserta en el texto de mensaje dependiendo 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


SetInfo(“Sensor %1, pressure %2 bar”, param1, param2)

Se visualiza el siguiente texto informativo: “Sensor 7, pressure 3,48 bar”.



16.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)


text Texto del mensaje de información STRING

param1 Primer parámetro posible ANY

Param2 Segundo parámetro posible ANY

Tabla 16.1 Parámetros de la instrucción SetInfo

La composición del texto de mensaje se describe en el capítulo 16.1 Textos de mensaj en la página 137.

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:



16.3 Advertencia <SetWarning>

La instrucción SetWarning activa un mensaje de advertencia en el sistema de

comunicación.

Sintaxis

SetWarning( <text> : STRING,

OPT <param1> : ANY,

OPT <param2> : ANY)


text Texto del mensaje de advertencia STRING



Tabla 16.2 Parámetros de la instrucción SetWarning

La composición del texto de mensaje se describe en el capítulo 16.1 Textos de mensaj en la página 137.

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:



SetWarning("Cycle %1 finished, Value %2”,cycle, pressure)




16.4 Mensaje de error <SetError>

La instrucción SetError activa 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)


Text Texto del mensaje de error STRING



Tabla 16.3 Parámetros de la instrucción SetError

En la memoria de errores del control multieje CMXR, se marca un mensaje de error con el

símbolo .

Indicación

Si se emite un mensaje de error, el movimiento se detiene. La cinemática no puede continuar el recorrido hasta que no se acusa recibo del mensaje de error.

Ejemplo:



SetError("Cycle %1 error, pressure %2”, cycle, pressure)


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.

17. Funciones


17. Funciones

17.1 Lectura de la posición actual <ReadActualPos>

Lectura de la posición actual de la cinemática.

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.


Pos Variable de destino de la posición

leída

AXISPOS o CARTPOS

Tabla 17.1 Parámetros 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 memoria. 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)

17. Funciones


Programa:

ReadActualPos(startPos)

PTP(axis0)

PTP(axis1)

PTP(axis2)

PTP(startPos)

17.2 Lectura de la posición de destino <ReadTargetPos>

Lectura de la posición de destino programada de la cinemática.

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.


Pos Variable de destino de la posición

leída

AXISPOS o CARTPOS

Tabla 17.2 Parámetros 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 va-lores se pierden cuando se deselecciona el programa/proyecto. Para guardar la posición puede utilizarse la macro SavePosition.

17. Funciones


17.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.


Pos Posición que se desea guardar AXISPOS o CARTPOS

Tabla 17.3 Parámetros de la instrucción SavePosition

Atención

La vida útil de la tarjeta de memoria se reduce si se utiliza con frecuencia para escribir posiciones. La macro SavePosition no debe llamarse cíclicamente en ningún caso y puede utilizarse para reali-zar ajustes ocasionales de la aplicación.

17.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 la hora y la fecha actuales del

sistema

17. Funciones


17.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 la fecha y la 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:


sysTime Indicación opcional, valor de fecha y

hora que debe convertirse

Segundos

Tabla 17.4 Parámetros de la función TimeStr

Ejemplo:

str_Time := TimeToStr() // Leer la hora y la fecha actuales

del sistema

Devolución:

str_Time = “Mon Feb 13 11:23:44 2006”

17. Funciones


17.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>)


17. Funciones


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

17.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


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.

17. Funciones


Sintaxis

(<ángulo en grados> : REAL) := ACOS(<valor de coseno>)


Ejemplo:

b := 30 // Cateto adyacente


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

17. Funciones


17.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


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>)


Ejemplo:



b := a / TAN(alpha) // Cálculo del cateto adyacente

a := 45.89 // Cateto opuesto


17. Funciones


value := a / b

alpha := ATAN(value) // Cálculo del ángulo contenido

17.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


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>)


Ejemplo:



b := a * COT(alpha) // Cálculo del cateto adyacente

17. Funciones


a := 45.89 // Cateto opuesto


value := b / a

alpha := ACOT(value) // Cálculo del ángulo contenido

17.10 Tangente 2 <ATAN2>

Calcula el arco tangente con rango de + π a –π.

Sintaxis

(<argumento> : REAL) := ATAN2 (<y> : REAL, <x> : REAL)

17.11 Logaritmo <LN>

La función logaritmo calcula el logaritmo natural del argumento transferido.

Sintaxis

(<logaritmo natural> : REAL) := LN (<valor> : REAL)

17.12 Exponente <EXP>

La función exponencial calcula el valor e(x).

Sintaxis

(<resultado> : REAL) := EXP (<valor>:REAL)

17. Funciones


17.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

17.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

value := a * a + b * b

c := SQRT(value) // Cálculo de la hipotenusa

17. Funciones


17.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:

Con la instrucción

Mask := SHL(Mask, 3)

el contenido de la variable Mask se desplaza 3 bits a la izquierda. 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

Con la instrucción

Mask := SHR(Mask, 3)

el contenido de la variable Mask se desplaza 3 bits a la derecha. Por la izquierda se insertan 3 bits con el valor “0”.


1001 1111 0000 1100 1111 1111 1001 1100


0001 0011 1110 0001 1001 1111 1111 0011

17. Funciones


17.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:

Con la instrucción

Mask := ROL(Mask, 4)

el contenido de la variable Mask gira 4 bits a la izquierda. En el lado derecho se insertan de nuevo los 4 bits.


1011 1111 0110 1001 0011 000 1001 1010


1111 0110 1001 0011 000 1001 1010 1011

Con la instrucción

Mask := ROR(Mask, 4)

el contenido de la variable Mask gira 4 bits a la derecha. En el lado izquierdo se insertan de nuevo los 4 bits.


1011 1111 0110 1001 0011 000 1001 1010


1010 1011 1111 0110 1001 0011 000 1001

17. Funciones


17.17 Conversión de un valor en una cadena <STR>

Convierte cualquier tipo de datos en una cadena de caracteres.

Sintaxis

(<variable> : STRING) := STR (<valor> : ANY)

Ejemplo:

Con la instrucción STR se convierte el valor de la variable Real1 en una cadena.

Real1 := 25.5

String1 := STR(Real1)

String1 tiene ahora el valor “25.500000”.

17.18 Conversión de un valor ASCII en un carácter <CHR>

Convierte un valor ASCII en un único carácter.

Sintaxis

(<variable> : STRING) := CHR (<valor> : DINT / DWORD)

Ejemplo:

Con la siguiente instrucción se asigna a la variable String1 el valor “a”.

String1 := CHR(97)

17.19 Conversión de un carácter en un valor ASCII <ORD>

Convierte un único carácter en un valor ASCII.

Sintaxis

(<variable> : DINT / DWORD) := ORD (<valor> : STRING)

Ejemplo:

Con la siguiente instrucción se asigna a la variable Dint1 el valor 65.

Dint1 := ORD(“A”)

18. Módulos


18. Módulos El lenguaje FTL permite utilizar módulos. Además de datos, los módulos contienen también componentes en forma de código de programa para conseguir una funcionalidad determinada. Para la comunicación con un módulo en FTL, dichos módulos contienen datos de entrada y de salida.

Representación gráfica de un módulo:

El número de datos de entrada y salida de un módulo se guarda en FTL en un tipo de dato. Un módulo debe declararse para ser utilizado en la aplicación. En el caso de los módulos, esto se denomina instanciación. En esta operación se guarda una copia del paquete de módulo con un nombre definido por el usuario (identificador). El paquete de módulo 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 módulo

<nombre de instancia> : <tipo de instancia> (parámetro)

Tipo de módulo Valor analógico

Sistema operativo Programa FTL

Presión: tipo valor analógico

Peso: tipo valor analógico

Instanciación de módulo en el programa de

aplicación

Módulo: valor analógico

Código interno de programa

Datos de entrada

del módulo

Datos de salida

del módulo

18. Módulos


Al igual que las variables, las instancias se guardan en el archivo de datos correspon-

diente.

Ejemplo de una instancia

Sensor : AIN(…)

Según el tipo de módulo se asignan datos con la declaración, p. ej., el nombre de una señal de hardware. La documentación sobre los módulos se encuentra en los capítulos siguientes.

18.1 Funciones

Las funciones de módulo sirven para acceder a los datos de un módulo o llamar a funcionalidades. Para acceder a las funciones del módulo se necesita el nombre de instancia y el operador punto.

Acceso a las funciones de módulo

<nombre de instancia> . <nombre de función>

En el ejemplo se accede a la función de módulo Read de la instancia Sensor:

marca := Sensor.Read()

En algunas funciones pueden transferirse parámetros. Consulte la descripción de cada uno de los módulos en los capítulos siguientes.

18.2 Variable

Además de funciones, los módulos pueden contener variables. Con estas variables puede accederse a los datos del módulo. Para acceder a las variables del módulo se necesita el nombre de instancia y el operador punto.

Acceso a variables de módulo

<nombre de instancia> . <nombre de variable>

Para acceder a los datos de algunos módulos 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 uno de los módulos en los capítulos siguientes.

En el ejemplo se accede a la variable de módulo State de la instancia Sensor:

IF Sensor.state THEN

Lin(pos1)

18. Módulos


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.

18.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 un módulo, algunos módulos funcionan cíclicamente en el sistema operativo. Así, el usuario puede acceder a los resultados del módulo con los métodos o variables.

18.3.1 Parámetro ovlEnable

Algunos métodos de los módulos 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 tener el estado TRUE o FALSE.

Estado FALSE

El avance de proceso se detiene en este punto. Si el proceso principal alcanza esta in-strucció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 movimientos 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.

18. Módulos


18.4 Módulo de entrada digital DIN

El módulo DIN sirve para interrogar y administrar una entrada digital.

18.4.1 Instanciación

Para instanciar el módulo 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 módulo:

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.

18. Módulos


Instanciación con la unidad manual

La instanciación del módulo 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 automáti-camente en el archivo de datos.

El módulo de entrada digital posee las variables siguientes:

Variable 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 18.1 Variables del módulo de entrada digital

Timeout

Con el parámetro timeout puede definirse un tiempo de espera. El método del módulo 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 20.2 Empleo de los módulos de entrada y salida.

18. Módulos


RisingEdge

Aunque no se ha llamado al módulo, éste 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 del módulo.

18.4.2 Métodos

El módulo dispone de varios métodos:

Método 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 18.2 Métodos del módulo 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 del módulo DIN de la unidad manual.

18. Módulos


18.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 18.3.1 de la página 158.

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)

18.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


Ejemplo:

value := sensor.Read()

18.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.

18. Módulos


Sintaxis

<nombre de instancia>.RisingEdge (OPT ovlEnable: BOOL) : BOOL


Ejemplo:

value := sensor.RisingEdge()

18.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()

18.5 Módulo de salida digital DOUT

El módulo DOUT sirve para interrogar y administrar una salida digital.


Para instanciar el módulo 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>”))

18. Módulos


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 módulo:


cylinder : DOUT := (-1,FALSE, MAPX("_system.Output3”))


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.


La instanciación del módulo 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.

18. Módulos


18.5.2 Variable

El módulo de salida digital posee las variables siguientes:


Timeout REAL Timeout para esperar a las instrucciones Wait y WaitN.




-1

RisingEdge BOOL Estado del flanco de subida FALSE

Output DOUTPORT Referencia a la salida de hardware ---

Tabla 18.3 Variables del módulo de salida digital

Timeout




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 20.2 Empleo de los módulos de entrada y salida.

RisingEdge

Aunque no se ha llamado al módulo, éste 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 del módulo.

18. Módulos


18.5.3 Métodos



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 18.4 Métodos del módulo de salida digital DOUT

En la unidad manual, los métodos pueden seleccionarse mediante el árbol de menú en el punto “Digital outputs”.


En la figura se muestra la selección de métodos del módulo DOUT de la unidad manual.

18. Módulos


18.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 adopte 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)


Ejemplo:

Ptp(pos0)

cylinder.Wait() // Esperar a salida TRUE, movimiento

detenido

Ptp(pos1)

cyinder.WaitN(TRUE) // Esperar a salida FALSE, sin parada

Ptp(pos2)

18.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


Ejemplo:

value := cylinder.Read()

18.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

18. Módulos



Ejemplo:

value := cylinder.RisingEdge()

18.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()

18.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. El módulo NO influye en el avance aproximado.

Ejemplo:

Lin(pos1)

Lin(pos2)

cylinder.Set() // Activa la salida cylinder a TRUE

Lin(pos3)

18. Módulos


cylinder.Reset() // Activa la salida cylinder a FALSE

Lin(pos4)

18.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. El módulo 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

18.5.10 Activación de la salida con una duración determinada, método Pulse

El método Pulse ajusta la salida a TRUE por un tiempo determinado. Pulse se ejecuta en la

ejecución principal y no influye en el avance aproximado.

Sintaxis

<nombre de instancia>.Pulse (timeMs :DINT;

OPT pauseAtInterrupt: BOOL)


timeMs DINT Tiempo correspondiente a la longitud de impulso

en ms

pauseAtInterrupt BOOL Detención del tiempo de impulso cuando el

programa se para

Tabla 18.5 Parámetros del método Pulse

18. Módulos


El método Pulse activa una salida digital con un impulso de una determinada longitud.

La longitud del impulso se indica en milisegundos. Al principio del impulso, la salida siempre adquiere el estado TRUE y al final, el estado FALSE. No obstante, si la salida ya posee el estado TRUE, este estado se restablece una vez transcurrido el tiempo del im-pulso.

Con el parámetro opcional “pauseAtInterrupt” se puede indicar cuál debe ser la reacción ante una parada del programa FTL. Si no se indica este parámetro, se establece internamente el estado FALSE.

pauseAtInterruppt = TRUE:

Con TRUE se detiene el tiempo del impulso y se asigna a la salida el estado FALSE. Si el programa FTL continúa, durante el tiempo restante la salida volverá a tener el estado TRUE. Una vez transcurrido el tiempo del impulso, se establecerá el estado FALSE.

pauseAtInterruppt = FALSE:

Si el parámetro opcional no está especificado o es FALSE, el impulso se ejecuta después del inicio y hasta el final. La parada del programa FTL no tiene ninguna repercusión.

Indicación

Si se carga un programa FTL detenido, la función de impulso finalizará automáticamente y la salida adquirirá el estado FALSE.

Ejemplo:

// Activa la salida cylinder a TRUE durante 200 ms

cylinder.Pulse(200)

18.6 Módulo de entrada analógica AIN

El módulo AIN sirve para interrogar y administrar una entrada analógica.


Para instanciar el módulo 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>”))

18. Módulos


El parámetro Input es el nombre con el que se designa la entrada de hardware. Esta

asignación activa una relación entre el módulo 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 módulo:


temperature : AIN := (-1, MAPX(“_system.Sensor1”))


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.


La instanciación del módulo de entrada analógica por medio de la unidad manual se realiza en la máscara de variables seleccionando el tipo de dato AIN.


18. Módulos


18.6.2 Variable

El módulo de entrada analógica posee las variables siguientes:


Timeout REAL Timeout para esperar a las instrucciones WaitLss, WaitGrt,

WaitIns y Waitouts.




-1

Input AINPORT Referencia a la entrada de hardware ---

Tabla 18.6 Variables del módulo de entrada analógica

Timeout





Más información y ejemplos para generar mensajes de error se describen en el capítulo 20.2 Empleo de los módulos de entrada y salida.

Input

La variable input describe la referencia a la entrada de hardware del módulo.

18.6.3 Métodos



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 18.7 Métodos del módulo de entrada analógica

18. Módulos


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 Inputs”.

En la figura se muestra la selección de métodos del módulo AIN de la unidad manual.

18.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 el módulo 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)



value REAL Valor límite

Tabla 18.8 Parámetros de los métodos WaitLss, WaitGrt

Ejemplo:

Lin(pos1)

temperature.WaitLss(65.0, TRUE)

Lin(pos2)

18. Módulos


18.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 el módulo 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)



minValue REAL Valor límite inferior

maxValue REAL Valor límite superior

Tabla 18.9 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)

18.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)


18. Módulos


Ejemplo

Lin(pos1)

// Leer la temperatura sin parar la trayectoria

value := temperature.Read(TRUE)

Lin(pos2)

18.7 Módulo de salida analógica AOUT

El módulo AOUT sirve para interrogar y administrar una salida analógica.


Para instanciar el módulo 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>”))


Ejemplo:

Una cantidad se guarda como instancia de módulo:


quantity : AOUT := (-1, MAPX(“_system.SetValue”))


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.

18. Módulos



La instanciación del módulo de salida analógica por medio de la unidad manual se realiza en la máscara de variables seleccionando el tipo de dato AOUT.


18.7.2 Variable

El módulo de salida analógica posee las variables siguientes:


Timeout REAL Timeout para esperar a las instrucciones WaitLss, WaitGrt,

WaitIns y Waitouts.




-1

Output AOUTPORT Referencia a la salida de hardware ---

Tabla 18.10 Variables del módulo de salida analógica

Timeout

Con el parámetro timeout puede definirse un tiempo de espera. El método del módulo

espera al estado de señal requerido durante el tiempo ajustado.




18. Módulos


Más información y ejemplos para generar mensajes de error se describen en el

capítulo 20.2 Empleo de los módulos de entrada y salida.

Output

La variable output describe la referencia a la salida de hardware del módulo.

18.7.3 Métodos



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 18.11 Métodos del módulo de salida analógica


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 del módulo AOUT de la unidad manual.

18. Módulos


18.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)


value REAL Valor nominal para la salida analógica

Tabla 18.12 Parámetros del método Write

Ejemplo:

quantity.Write(110.0) // Ajusta la salida a 110.0

value := 1.3

quantity.Write(value) // Ajusta la salida a 1.3

18.7.5 Esperar a que el valor aumente/disminuya, 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 el módulo 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)



value REAL Valor límite

Tabla 18.13 Parámetros de los métodos WaitLss, WaitGrt

Ejemplo:

Lin(pos1)

// Esperar a que el valor sea menos de 110.0

quantity.WaitLss(110.0, TRUE)

Lin(pos2)

18. Módulos


18.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 el módulo 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)



minValue REAL Valor límite inferior

maxValue REAL Valor límite superior

Tabla 18.14 Parámetros de los métodos WaitIns, WaitOuts

Ejemplo

Lin(pos1)

// Esperar a que la cantidad esté dentro de los límites

quantity.WaitIns(100.0, 110.0, TRUE)

Lin(pos2)

18.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)


Ejemplo

Lin(pos1)

// Leer la cantidad sin parar sobre la trayectoria

value := quantity.Read(TRUE)

Lin(pos2)

18. Módulos


18.8 Módulo de reloj CLOCK

El módulo de reloj (temporizador) puede utilizarse para cronometrar durante la ejecución del programa. El tiempo se mide en milisegundos.


Para instanciar el módulo de reloj CLOCK se requiere el nombre del módulo. Dicho módulo

no tiene variables.

Instanciación

<nombre de instancia> : CLOCK


Timer : CLOCK


La instanciación se efectúa en el diálogo para crear variables seleccionando <tipo:> (CLOCK) e introduciendo el <identificador:> (clkTimer).


La instanciación del módulo de reloj por medio de la unidad manual se realiza en la

máscara de variables seleccionando el tipo de dato CLOCK.

18. Módulos



18.8.2 Métodos

El módulo de reloj dispone de varios métodos:

Métodos Descripción

Reset Borrar la hora

Start Poner en marcha el reloj

Stop Detener el reloj

Read Leer el tiempo detenido en ms

ToStr Convertir el tiempo en una cadena de caracteres

Tabla 18.15 Métodos del módulo de reloj


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 del módulo CLOCK de la unidad manual.

18. Módulos


18.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 el módulo. 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 poner a cero con la instrucción Reset.

Sintaxis

<nombre de instancia>.Start ( )

Ejemplo:

Timer.Start() // El reloj se pone en marcha

18.8.4 Parada del reloj, método Stop

El método Stop detiene el cronometraje. El tiempo transcurrido se calcula en el módulo

y se visualiza para su lectura.

Sintaxis

<nombre de instancia>.Stop ( )

Ejemplo:

Timer.Stop() // El reloj se detiene

18.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 pone a cero y sigue funcionando.

Sintaxis

<nombre de instancia>.Reset ( )

Ejemplo:

Timer.Reset() // El reloj se reinicia

18.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).

18. Módulos


Sintaxis

<nombre de instancia>.Read(OPT ovlEnable : BOOL) : DINT


Valor de retorno: tiempo medido en milisegundos (ms)

Ejemplo:

Datos:

value : DINT

Programa:

:

Lin(pos1)

value := Timer.Read() // Leer con parada de la trayectoria

Lin(pos2)

value := Timer.Read(TRUE) // Leer en el proceso principal

Lin(pos3)

:

18.8.7 Conversión del valor de fecha y hora en cadena de caracteres

Con el método ToStr se convierten la fecha y la 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


Valor de retorno: cadena de caracteres con la información de fecha y hora dd

hh:mm:ss:ms

Ejemplo:

Datos:

time : STRING

18. Módulos


Programa:

Lin(pos1)

time := Timer.ToStr() // Leer con parada de la

trayectoria

Lin(pos2)

time := Timer.ToStr(TRUE) // Leer en el proceso principal

Lin(pos3)

18.9 Módulo de encoder ENCODER

El módulo de encoder puede utilizarse en el programa para leer, como máximo, los dos

encoders incrementales conectados.


Para instanciar el módulo 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>”))


Ejemplo:

Un encoder se guarda como instancia de módulo:


enc0 : ENCODER := (-1, MAPX("_system.Encoder_0”))


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.

18. Módulos



La instanciación del módulo de encoder por medio de la unidad manual se realiza en la máscara de variables seleccionando el tipo de dato ENCODER.


18.9.2 Variable

El módulo de encoder posee las variables siguientes:


timeout REAL Timeout para esperar -1

port ENCPORT Referencia a la entrada de hardware ---

Tabla 18.16 Variables del módulo de encoder

Timeout – (desocupado actualmente en este módulo)

Con el parámetro timeout puede definirse un tiempo de espera. El método del módulo espera al estado de señal requerido durante el tiempo ajustado. En la actualidad, el módulo 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.

18.9.3 Métodos

El módulo de encoder dispone de varios métodos:


Set Ajustar manualmente el valor del encoder incremental

Read Leer el valor del encoder incremental

Tabla 18.17 Métodos del módulo de encoder

18. Módulos




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 del módulo de encoder de la unidad manual.

18.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)


count DINT Valor al que se debe ajustar el encoder incremental (incrementos)

mode SETCOUNTMODE Parámetro para ajustar el punto de activación

Tabla 18.18 Parámetros del método Set

El módulo 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.

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 18.19 Modos del método Set

Ejemplo:

enc0.Set(1000, DIRECT)

18. Módulos


18.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


ovlEnable BOOL Parámetro para ajustar el punto de interrogación

Tabla 18.20 Parámetros 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()

18.10 Módulo CANopen COPDEVICE

El módulo 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.

18. Módulos



La instanciación del módulo CANopen se efectúa automáticamente debido a la configu-ració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


Axis1_copd.WriteSDO(16#6060,0,7,eight_bits)

18.10.2 Métodos

El módulo CANopen dispone de varios métodos:


WriteSDO Escribir SDO

ReadSDOUnsigned Leer SDO sin signo

ReadSDOSigned Leer SDO con signo

Tabla 18.21 Métodos del módulo CANopen



En la unidad manual, los métodos pueden seleccionarse mediante el árbol de menú en el punto “CANopen Devices”.

18. Módulos


En la figura se muestra la selección de métodos del módulo CANopen de la unidad manual.

18.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


index DINT Índice de SDO

subindex DINT Subíndice de SDO

data DINT Datos que se van a escribir

type SdoDataType Tipo de dato (Enum)

eight_bits (8 bits)

sixteen_bits (16 bits)

thirtytwo_bit (32 bits)

Tabla 18.22 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)

18.10.4 Lectura de SDO, método ReadSDOSigned

Con el método ReadSDOSigned, el bus CAN puede leer conjuntos de datos con signo.

18. Módulos


Sintaxis:

<COPDEVICE>.ReadSDOSigned (<index> : DINT, <subindex> : DINT, <data> : DINT) : BOOL




data DINT Datos que se van a leer

Tabla 18.23 Parámetros del método ReadSDOSigned

Si el conjunto se lee, se devuelve TRUE, de lo contrario, se devuelve FALSE.

Ejemplo:

dint_iData : DINT := 0

Programa:

Axis3_copd.ReadSDOSigned(16#6098, 0, dint_iData)

SetInfo("método de recorrido de referencia leído: %1”,

dint_iData)

:

18. Módulos


18.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




data DWORD Datos que se van a leer

Tabla 18.24 Parámetros del método ReadSDOUnsigned

Si el conjunto se lee con éxito se devuelve TRUE, de lo contrario se devuelve FALSE.

19. Señales de periféricos



19.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.

19.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.



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.

20. Ejemplos


20. Ejemplos En los capítulos siguientes aparecen ejemplos de utilización del lenguaje de progra-mació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 funcio-namiento debe asegurarse con la puesta a punto correspondiente.

La inobservancia de lo anteriomente mencionado puede ocasionar daños personales y materiales graves.

20.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

Entrada: inCollision

Sensor para detectar pilas vacías

Entrada: inStackNotEmpty

x

z

y

20. Ejemplos


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 takePosStack

Posición de seguridad sobre la pila de chapa safetyPosStack

Posición de seguridad sobre la vía de rodillos safetyDepositPos

Posición de posado sobre la vía de rodillos depositPos

Posición modificable frente a la pila de chapa prePosition

Tabla 20.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.

safetyPosStack

takePosStack

safetyDepositPos

depositPos

20. Ejemplos


Programa de movimientos:

:

Vel(dynCart, 200) // Velocidad lenta

prePosition := safetyPosStack

WHILE TRUE DO

Lin(safetyPosStack)

WAIT inStackNotEmpty.State // Comprobar si hay piezas en la

pila

Lin(prePosition)

Vel(dynCart, 200) // Velocidad lenta

Lin(takePosStack)

WAIT inCollision.State // Esperara a la señal de avance

del sensor

StopMove() // Detener el movimiento

// Fijar la posición real sobre la pila

ReadActualPos(prePosition)

// Calcular la distancia de seguridad sobre la pila

prePosition.z := prePosition.z + 10

gripper.Set() // Cerrar pinza

Vel(dynCart, 1000) // Velocidad rápida

Lin(safetyPosStack)

Lin(safetyDepositPos)

Lin(depositPos)

gripper.Reset() // Abrir pinza

Lin(safetyDepositPos)

END_WHILE

:

Modo de funcionamiento

La cinemática 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.

20. Ejemplos


20.2 Empleo de los módulos de entrada y salida

Al instanciar módulos de entrada o salida puede definirse un timeout. P. ej., si la función Wait del módulo 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(“Timeout over”)

RETURN

END_IF

// Reanudar ejecución

Lin(pos)

:

Indicación

Si se emite un mensaje de error, el movimiento se detiene. No es posible reanudar la ejecución hasta que no se acusa recibo del mensaje de error.

20. Ejemplos


Avance de proceso

20.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)

Proceso

principal 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

Avance

de proceso

20. Ejemplos


Avance de proceso

20.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.

count := 0

Lin(Pos1)

Lin(Pos2)

LOOP 10 DO

Lin(Pos3)

count:=count + 1

Lin(Pos4)

END_LOOP

Lin(Pos5)

Proceso

principal

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

Avance de

proceso

20. Ejemplos


20.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.

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 automáti-

camente 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 un módulo digital.

pos2 pos4

pos3 pos1

20. Ejemplos


Variables:

vacuum : DOUT := (...) // Módulo 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)

vacuum.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

vacuum.Reset() // Desconectar el vacío en el punto

inferior

WaitTime(20) // Tiempo de espera = 20 ms para tiempo de

agarre

Lin(pos3)

Modo de 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.

20. Ejemplos


Perfil de movimiento:

Comportamiento en la línea temporal:

Tiempo

pos1 pos3

Tiempo de espera

pos4

pos3

pos2

pos1

Velocidad

pos2 pos4

pos3 pos1

Área de avance

aproximado

20. Ejemplos


20.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 módulos en la programación FTL.

pos2 pos4

pos3 pos1

20. Ejemplos


Variables:

outGripperOpen : DOUT := (...) // Módulo de salida digital

outGripperClose : DOUT := (...) // Módulo de salida digital

inGripperOpen : DIN := (...) // Módulo de entrada digital

inGripperClosed : DIN := (...) // Módulo de entrada digital

Programa:




Lin(pos1)

outGripperOpen.Set() // Abrir pinza

outGripperClose.Reset()

inGripperOpen.Wait(TRUE) // Esperar a que se abra


outGripperClose.Set() // Cerrar pinza

outGripperOpen.Reset()

inGripperClosed.Wait() // Esperar a que se cierre

Lin(pos1)

Lin(pos3)


outGripperOpen.Set() // Abrir pinza

outGripperClose.Reset()

inGripperOpen.Wait() // Esperar a que se abra

Lin(pos3)

Modo de 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 módulo 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.

20. Ejemplos




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

20. Ejemplos


20.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 módulos en la programación FTL.

pos2 pos4

pos3 pos1

Giro de 90 grados

Unidad giratoria con pinzas

HGDS con pinza paralela

20. Ejemplos


Variables:

outGripperOpen : DOUT := (...) // Módulo de salida digital

outGripperClose : DOUT := (...) // Módulo de salida digital

outPos0Degree : DOUT := (...) // Módulo de salida digital

outPos90Degree : DOUT := (...) // Módulo de salida digital

inGripperOpen : DIN := (...) // Módulo de entrada digital

inGripperClose : DIN := (...) // Módulo de entrada digital

inPos0Degree : DIN := (...) // Módulo de entrada digital

inPos90Degree : DIN := (...) // Módulo de entrada digital

Programa:





outGripperClose.Reset() // Abrir pinza

outGripperOpen.Set()

outPos0Degree.Set() // Girar a 0 grados

outPos90Degree.Reset()

inGripperOpen.Wait() // Esperar a pinza abierta

inPos0Degree.Wait() // Esperar a 0 grados


outGripperClose.Set() // Cerrar pinza

outGripperOpen.Reset()

inGripperClose.Wait() // Esperar a pinza cerrada

Lin(pos1)

outPos0Degree.Reset() // Girar a 90 grados

outPos90Degree.Set()

Lin(pos3)

inPos90Degree.Wait(TRUE) // Esperar a 90 grados con avance

aproximado


outGripperClose.Reset() // Abrir pinza

outGripperOpen.Set()

inGripperOpen.Wait() // Esperar a pinza abierta

Lin(pos3)

20. Ejemplos


Modo de 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 directa-mente un movimiento de avance aproximado a la pos4.


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


pos2 pos4

pos3 pos1


20. Ejemplos



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

Tiemp

o 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

20. Ejemplos


20.5 Empleo de la interface PLC

20.5.1 Tarea

En el ejemplo siguiente se van a recoger piezas en la posición “pickPos” y se van a transportar a la posición de posado “depositPos”. 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 posi-ciones 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 “waitPos” hasta que el PLC está preparado.

20.5.2 Interface PLC

El intercambio de datos entre el control CMXR y el PLC se efectúa con dos bits de sin-cronizació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 de flujo 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

pickPos depositPos

aboveDepositPos abovePickPos waitPos

20. Ejemplos


20.5.3 Programa secuencial

Variables:

waitPos : CARTPOS := (...)

pickPos : CARTPOS := (...)

depositPos : CARTPOS := (...)

abovePickPos : CARTPOS := (...)

aboveDepositPos : CARTPOS := (...)

gripper : DOUT := (...)

Programa:

// Inicialización

Acc(dynCart, 4000)

Vel(dynCart, 100)

Lin(waitPos)

WHILE TRUE DO

// Handshake

WAIT plc_inboolreg[0] // PLC señaliza una posición nueva

pickPos := plc_cposreg[0]

abovePickPos.x := plc_cposreg[0].x

abovePickPos.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(abovePickPos)

Lin(pickPos)

// Agarrar

gripper.Set()

WaitTime(200)

// Avanzar a la posición de posado

Lin(abovePickPos)

Lin(aboveDepositPos)

20. Ejemplos


Lin(depositPos)

// Posar

gripper.Reset()

WaitTime(200)

// Avanzar a la posición de espera

Lin(aboveDepositPos)

Lin(waitPos)

END_WHILE

21. Árbol de menús de las instrucciones FTL



Para facilitar la programación, en la unidad manual CDSA y en el editor de programación FTL se muestra un árbol de menús que contiene todas las instrucciones FTL disponibles. A continuación se muestran todas las instrucciones del conjunto de instrucciones “Base de programación FTL”.

Árbol de menús de la unidad manual CDSA:

PLC-Interface (Interface de PLC)

ProgHold

Mathematical functions (Funciones)

Position Functions (Funciones de posición)

o ReadTargetPos

o ReadActualPos

o SavePosition

SIN

COS

TAN

COT

LN



ABS

SQRT

EXP

ASIN

ACOS

ATAN

ATAN2

ACOT

Time

TimeToStr

Reference Axis (Referenciar)

RefAxis

RefAxisAsync

WaitRefFinished

IsAxisReferenced

Movement (Instrucciones de movimiento)

PTP

Lin

CircIp

LinToCircIp

PtpToCircIp

MoveAxisPtp

MoveAxisCart

PtpRel

LinRel

StopMove

Dynamics (Instrucciones de dinámica)

DynOvr

Vel

Acc

Jerk

Ovr

OvlVel

OvlCart



Ramp

VconstOn

VconstOff

Program commands (Instrucciones)

WaitOnPath

StopProgram

WaitTime

WaitOnPos

CALL

RUN

KILL

… := …

//

WAIT

LABEL

GOTO

IF … GOTO

IF … THEN … END_IF

ELSE

ELSIF … THEN

WHILE … DO … END_WHILE

LOOP

RETURN

Robot commands (Instrucciones de robot)

Reference Systems (Sistemas de referencia)

o SetRefSys

o SetRefSys3P

o SetRefSysWorld

Tool

System functions (Funciones del sistema)

Time measurement (Cronometraje)

o CLOCK.Reset

o CLOCK.Start



o CLOCK.Stop

o CLOCK.Read

o CLOCK.ToStr

Additional commands (Funciones complementarias)

o SHR

o SHL

o ROR

o ROL

o STR

o CHR

o ORD

Message System (Sistema de comunicación)

SetInfo

SetWarning

SetError

I/O-Modules (Módulos E/S)

Analog Input (Entradas analógicas)

o AIN.Read

o AIN.WaitLss

o AIN.WaitGrt

o AIN.WaitIns

o AIN.WaitOuts

Analog Output (Salidas analógicas)

o AOUT.Write

o AOUT.Read

o AOUT.WaitLss

o AOUT.WaitGrt

o AOUT.WaitIns

o AOUT.WaitOuts

CANopen devices (Dispositivos CANopen)

o COPDEVICE.WriteSDO

o COPDEVICE.ReadSDOUnsigned

o COPDEVICE.ReadSDOSigned



Digital Input (Entradas digitales)

o DIN.Read

o DIN.Wait

o DIN.WaitN

o DIN.RisingEdge

o DIN.ResetRisingEdge

Digital Output (Salidas digitales)

o DOUT.Set

o DOUT.Reset

o DOUT.Write

o DOUT.Pulse

o DOUT.Read

o DOUT.ResetRisingEdge

o DOUT.Wait

o DOUT.WaitN

o DOUT.RisingEdge

Incremental Encoder (Encoder incremental)

o ENCODER.Set

o ENCODER.Read

Índice


#

##........................................................ 61

/

// ........................................................ 61

_

_global.tt ............................................. 19

A

ABS ................................................... 152 Acc ...................................................... 91 ACOS ................................................. 147

ACOT ................................................. 150 AIN .................................................... 170 AOUT ................................................. 175 ASIN .................................................. 146

ATAN ................................................. 149 ATAN2 ............................................... 151 Avance de proceso ................ 54, 56, 198 AXISPOS .............................................. 63

C

CALL .................................................... 51 CARTPOS ............................................. 63

CHR ................................................... 155 CircIp ................................................... 81 CLOCK ............................................... 180 Comentario .......................................... 61 Conversiones de tipos ......................... 30 COS ................................................... 147 COT ................................................... 150

D

DIN .................................................... 159 DO ....................................................... 39 DOUT ................................................. 163

DynOvr ................................................ 96

E

Ejemplo Control del avance de proceso ........ 198 Detención de movimientos ............. 194 Empleo de la interface PLC.............. 210 Empleo de los módulos de entrada y

salida .......................................... 197 Empleo de pinzas ........................... 199 WAIT con entrada digital ................... 57

ENCODER .......................................... 184

Error.................................................. 192 EXP ................................................... 151

F

FTL ........................................... 12, 16, 19

G

GOTO .................................................. 48

H

Herramientas .................................... 122

I

IF…GOTO ............................................. 47 IF…THEN ............................................. 45 Interface Profibus .............................. 130 IS_MAPPED ......................................... 37

IsReferenced ..................................... 121

J

Jerk ..................................................... 92

K

KILL ..................................................... 54

L

LABEL ................................................. 47 Lin....................................................... 74 LinRel .................................................. 76 LinToCircIp .......................................... 85 LN ..................................................... 151 LOOP .................................................. 49 LOW, HIGH .......................................... 34

M

MAP .................................................... 37 MAPTO ................................................ 37

Matriz ................................................. 31 MoveAxisCart ...................................... 72 MoveAxisPtp ....................................... 72

O

ORD .................................................. 155 OvlCart .............................................. 107 OvlVel ............................................... 105 Ovr ...................................................... 94

Índice


P

Palabras clave ..................................... 24 plc_AxisPos ....................................... 133 plc_CartPos ....................................... 133 plc_RefSys ......................................... 134 plc_VarDint ........................................ 132 Posición cartesiana .............................. 66 Posición de eje .................................... 63 ProgHold ........................................... 135 PTP ...................................................... 67 PtpRel ................................................. 70 PtpToCircIp .......................................... 83

R

Ramp ................................................... 98 Read .................................................. 187 ReadActualPos .................................. 142

ReadSDOSigned ................................ 189 ReadSDOUnsigned ............................ 191 ReadTargetPos .................................. 143 RefAxis .............................................. 116 RefAxisAsync ..................................... 118 Registro del programa desactivado ..... 61 RETURN ............................................... 52 ROL ................................................... 154

ROR ................................................... 154 RUN ..................................................... 54

S

SavePosition ..................................... 144 Segmento cero .................................. 103 Set .................................................... 186 SetError ............................................. 141 SetInfo .............................................. 139 SetRefSys .......................................... 111 SetRefSys3P ...................................... 112 SetRefSysWorld ................................. 114

SetWarning ....................................... 140

SHL ................................................... 153 SHR ................................................... 153 SIN .................................................... 146 Sistemas de referencia ...................... 134 SQRT ................................................. 152 State ................................................. 192 StopMove ........................................... 86 StopProg ............................................. 87 STR ................................................... 155

T

TAN ................................................... 149

TCP ................................................... 122 tid ................................................. 19, 20 Tiempo de espera ............................... 54 Time .................................................. 144

TimeToStr ......................................... 145 tip ....................................................... 19 Tipos de datos .................................... 28 Tool .................................................. 125

V

Value ................................................ 192 VconstOff .......................................... 101

VconstOn ............................................ 99 Vel ...................................................... 90

W

WAIT ................................................... 56 WaitOnPath ......................................... 58 WaitOnPos .......................................... 60 WaitRefFinished ................................ 120 WaitTime............................................. 54 WHILE ................................................. 48 WriteSDO .......................................... 189

Índice


€¦ · festo gdcp-cmxr-sw-de es 0909a 3 edición...

Documents