Knowledge Base Motion Pro: Conceptos Básicos · 2013. 6. 30. · Knowledge Base Motion Pro:...

Advertencia de la propiedad: Este documento contiene información propiedad de Schneider Electric S.A., y ni el documento ni la información que contiene pueden ser publicadas, reproducidas, copiadas o usadas bajo ningún concepto salvo permiso escrito por un representante válido de la compañía. Motion Pro: Conceptos Básicos página 1/180

Doc. Nb:

LMC001

Knowledge Base

Motion Pro: Conceptos Básicos

VERSION V6.3 Departamento: Nombre: Fecha:

Autores :

D.C.I.

Santiago Pavía Amposta

28-02-2008

www.infoPLC.net

Knowledge Base Motion Pro: Conceptos Básicos

Motion Pro: Conceptos Básicos página 2/180

Documentación asociada Control de versiones Lista de cambios Rev Mes-Año Autor Modificaciones

1 03-09-2007 Santi Pavía • Primera revisión con formato estándar 2 12-09-2007 Santi Pavía • Añadido Capítulo relativo al CNC 3 13-09-2007 Santi Pavía • Corrección y ampliación del capítulo CNC 4 25-09-2007 Santi Pavía • Añadido capítulo relativo a las tareas (se renumeran capítulos)

• Corrección apartado Marcas del capítulo CNC 5 03-10-2007 Santi Pavía • Añadido método adicional para crear eje virtual

• Se crea un capítulo específico para hablar del CNC • Añadido apartado dedicado a la inicialización de parámetros • Añadido apartado dedicado a las macros • Añadido apartado uso de $valor$ en pantallas visualización.

6 30-11-2007 Santi Pavía • Se reestructura capítulo CNC • Añadida explicación detallada bloques CNC • Añadido apartado relativo al SMC_NCDecoder • Añadido capítulo referente a tablas CAM • Renumeración capítulos • Se traspasa lo referente a CAM y CNC de otros capítulos a los nuevos. • Añadido capítulo dedicado a las comunicaciones.

6.1 04-11-2007 Santi Pavía • Añadido en el capítulo “Problemas y Errores” el capítulo 13.4 6.2 01-02-2008 Santi Pavía • Adaptación librerías a la versión V1940

• Añadida indicación librería necesaria en capítulo 6.3.2 • Revisión Capítulo tablas CAM / Tappets • Añadido Capítulo dedicado a la conexión de múltiples encoders

master. 6.3 28-02-2008 Santi Pavía • Añadido en capítulo “El lenguaje SFC o Graphet” explicación relativa a

las acciones de entrada y salida de tareas. • Añadido en el capítulo “Problemas y Errores” el subcapítulo “La tabla

CAM hace que el eje Vibre” • Modificados capítulos tablas CAM sustituyendo referencias a

estructuras con tipos de variables UINT por LREAL ya que son más precisas.

• Añadida explicación de entrada dOverride para variar velocidad trayectoria ONLINE en capítulo “El SMC_Interpolator”.

• Intercalado subcapítulo “Creando estructuras propias” en el capítulo “Las Levas y las Tablas CAM”

• Dividido capítulo “Las variables de usuario” en dos para explicar tanto los tipos como la volatilidad de las variables.

www.infoPLC.net



INDICE DE CONTENIDOS

1.- CONFIGURACION BASICA MOTION PRO............................................. 6

1.1.- Cambiar idioma entorno de trabajo .........................................................................6

1.2.- Crear un nuevo proyecto con Lexium 05 ................................................................8

1.3.- Entorno de trabajo.....................................................................................................9

1.4.- Gestión de librerías imprescindibles.....................................................................11

1.5.- Otros ajustes (LREAL >> REAL).............................................................................11

2.- CONFIGURACION BASICA DRIVES .................................................... 12

2.1.- Lexium 05.................................................................................................................12

2.2.- Lexium 15 MP...........................................................................................................13

3.- CONEXIÓN CON LEXIUM CONTROLLER ........................................... 16

3.1.- Conexión a través de RS485...................................................................................16

3.2.- Conexión a través de Ethernet ...............................................................................19

4.- TAREAS Y PRIORIDADES.................................................................... 26

4.1.- Tiempo de ejecución vs Tiempo de disparo .........................................................26

4.2.- Prioridades de ejecución ........................................................................................27

4.3.- Creación de tareas y su configuración..................................................................28

4.4.- Estados y Tiempos ejecución de Tareas y Grupos de ejes.................................32

5.- PARAMETRIZACIÓN INICIAL DRIVE. .................................................. 33

5.1.- Creación de listas de parámetros ..........................................................................33

5.2.- Edición archivo externo XML .................................................................................36

6.- PROGRAMACION ................................................................................. 37

6.1.- Los diferentes lenguajes de programación ..........................................................37

6.1.1.- El lenguaje SFC o Graphet................................................................................37

6.1.2.- El lenguaje CFC o Complex Flow Chart ..........................................................42

6.1.3.- El lenguaje ST o Structured Text .....................................................................44

6.2.- Las variables de usuario.........................................................................................45

6.2.1.- Los diferentes Tipos .........................................................................................45

6.2.2.- Volatilidad de las variables...............................................................................49

6.3.- Uso de un eje virtual................................................................................................50

6.3.1.- Vía bloque SMC_TimeAxisFB...........................................................................50

6.3.2.- Vía Dummy Axis.................................................................................................51

6.4.- Uso de un encoder externo ....................................................................................54

6.5.- Uso de varios encoders externos ..........................................................................57

6.6.- Las macros...............................................................................................................58

6.6.1.- Creación de un bloque de funciones...............................................................58

6.6.2.- Creación de una macro.....................................................................................60

www.infoPLC.net



7.- PRIMER PROGRAMA SIMPLE ............................................................. 64

7.1.- Creación Programa Principal .................................................................................64

7.2.- Declaración del eje a controlar ..............................................................................66

7.3.- Programa habilitación y movimiento absoluto .....................................................70

7.4.- Compilación y Transmisión programa. .................................................................75

7.5.- Resumen de conceptos y consejos.......................................................................77

8.- EL CNC Y LA INTERPOLACIÓN........................................................... 78

8.1.- Estructura de un programa CNC.........................................................................78

8.2.- Identificadores ......................................................................................................79

8.3.- Instrucciones preparatorias G.............................................................................80

8.4.- Funciones M..........................................................................................................86

8.5.- Puntos H o Switch Points ....................................................................................88

8.6.- Elementos de Programación ...............................................................................89 8.6.1.- Librerías Necesarias ....................................................................................................................89 8.6.2.- El SMC_Interpolator .....................................................................................................................89 8.6.3.- El SMC_Trafo_Gantry2 ................................................................................................................92 8.6.4.- El SMC_ControlAxisByPos .........................................................................................................93

8.7.- Creación de Trayectorias.....................................................................................95 8.7.1.- Herramientas de Diseño ..............................................................................................................95 8.7.2.- Herramientas informativas........................................................................................................100 8.7.3.- Herramientas edición.................................................................................................................101 8.7.4.- Herramientas importación/exportación ...................................................................................105

8.8.- Ejemplos de Programación ...............................................................................107 8.8.1.- Trayectoria Fija...........................................................................................................................107 8.8.2.- Trayectoria Variable ...................................................................................................................112 8.8.3.- Modificar un programa en ejecución .......................................................................................118

8.9.- La estructura SMC_GEOINFO ...........................................................................121

9.- LAS LEVAS Y LAS TABLAS CAM.......................................................124

9.1.- Introducción...........................................................................................................124

9.2.- Las estructuras necesarias ..................................................................................125

9.3.- Creando estructuras propias................................................................................127

9.4.- Levas desde entorno gráfico................................................................................128

9.5.- Levas mediante tablas ..........................................................................................132

9.6.- Ejecución de una leva ...........................................................................................135

9.7.- Gestión de múltiples levas ...................................................................................137

9.8.- Desfasado de eje esclavo .....................................................................................139

9.9.- Los Tappets ...........................................................................................................140

10.- PANTALLAS VISUALIZACION...........................................................142

10.1.- Introducción.........................................................................................................142

10.2.- Creación de una página ......................................................................................142

10.3.- Formato y uso de variables ................................................................................146

10.4.- Los Placeholders.................................................................................................149

10.4.1.- Creación de una pantalla secundaria ..........................................................149

10.4.2.- Uso de los placeholders ...............................................................................151

10.5.- Mostrar y ocultar objetos....................................................................................156

www.infoPLC.net



10.6.- Modificar color de fondo.....................................................................................156

10.7.- Modificar color de texto ......................................................................................156

10.8.- Comportamiento ante un evento........................................................................156

10.9.- Uso de Bitmaps ...................................................................................................156

10.10.- Reutilización pantallas......................................................................................156

11.- EXPORTACION / IMPORTACION PROYECTOS FORMATO ASCII..156

11.1.- Exportación..........................................................................................................156

11.2.- Importación..........................................................................................................156

12.- COMUNICACIONES ...........................................................................156

12.1.- Modbus RS485.....................................................................................................156

12.2.- Conexión HMI por RS485....................................................................................156

12.3.- I/O Scanning.........................................................................................................156

13.- PROBLEMAS Y ERRORES................................................................156

13.1.- Errores de representación en pantallas Visualización ....................................156

13.2.- Pérdida inexplicable de las comunicaciones....................................................156

13.3.- Error inexplicable tipo b404 en los Lexium05...................................................156

13.4.- Se corta la comunicación al transmitir un proyecto ........................................156

13.5.- La tabla CAM hace que el eje “Vibre”................................................................156

www.infoPLC.net



1.- CONFIGURACION BASICA MOTION PRO 1.1.- Cambiar idioma entorno de trabajo

Mediante un doble clic sobre el icono Motion Pro y tras el proceso de inicialización, aparecerá el entorno de trabajo el cual tendrá un aspecto similar al mostrado por la siguiente imagen:

www.infoPLC.net



Como se puede observar el entorno de trabajo se encuentra en inglés. Es posible cambiarla a castellano con tan sólo seguir los siguientes pasos: 1.- En menú superior Project seleccionar opción Options…

2.- En el cuadro que aparecerá ir directamente a la opción Desktop 3.- Y donde pone Language cambiarlo de English a español 4.- Pulsar sobre botón OK. NOTA: A partir de este punto se utilizará el entorno traducido al castellano en el resto del manual.

www.infoPLC.net



1.2.- Crear un nuevo proyecto con Lexium 05 En el menú superior se pulsa sobre Fichero y se escoge la opción Nuevo. Aparecerá un nuevo cuadro de selección:

Se abren las opciones de configuración existentes (sólo hay una) y se escoge “Lexium Controller V01”. Acto seguido aparecerá una serie de subopciones. Se aceptan los valores por defecto pulsando sobre el botón Aceptar.

Mediante la ejecución de estos pasos se autoconfigurará el entorno de trabajo para poder trabajar con un Lexium Controller apareciendo una última pantalla en la cual podrá escogerse el lenguaje de programación con el cual se podrá desarrollar la aplicación.

Aunque es posible escoger entre seis tipos distintos de lenguajes de programación se recomienda, para empezar, escoger CFC pues está basado en bloques de función y resulta más sencillo.

www.infoPLC.net



1.3.- Entorno de trabajo El entorno, después de todos estos pasos, pasará a adoptar el siguiente aspecto:

El entorno siempre es el mismo independientemente del tipo de lenguaje utilizado. A este entorno se le llama CODESYS. Dicho entorno de desarrollo está dividido en varias zonas y quizás las más importantes sean las correspondientes al Área de Programación, que es donde se desarrollará el programa, y al Área de Navegación del Programa, que es el que permitirá ir accediendo a todas las funcionalidades del entorno CODESYS.

Área Navegador Programa

Área Programación

Área Declaración

Variables

Área Mensajes y

Avisos

Pestañas Selección

Navegador

www.infoPLC.net



Existen hasta cuatro tipos de navegadores según se selecciones por las pestañas de selección:

De izquierda a derecha puede observarse el navegador en modo Programa: Donde aparecen todos los programas, rutinas y subrutinas utilizadas Variables: Donde aparece un listado de las variables utilizadas por el programa Visualización: Donde pueden crearse pantallas para monitorizar y controlar el valor de variables Recursos: Donde se tiene acceso a diferentes funcionalidades del entorno Codesys como gestión de

librerías, configuración de tareas de programa, acceso a diseñador de tablas CAM o CNC, etc.

www.infoPLC.net



1.4.- Gestión de librerías imprescindibles Es especialmente importante el navegador de Recursos y la subopción Library Manager pues según el tipo de programa a realizar deberán añadirse unas u otras librerías. Por defecto son necesarias una serie de librerías para la gestión de variables, puerto CAM, lenguaje PLCOpen, etc. Las mínimas librerías imprescindibles con el fin de controlar un eje en posición de forma básica son las siguientes:

� SM_PLCOpen_V1940.lib (1) � SM_Can_V1940.lib (1) � LexiumCanDrive_V1940.lib (1) � SM_Error_V1940.lib (1) � SM_DriveBasic_V1940.lib (1) � SysLibCallBack.lib (2) � SysLibFileSubst.lib (2) � SysLibTime.lib (2) � LMC_Encoder_V1002.lib (2) � 3S_CanDrv.lib (2) � LexiumControllerBusInterface_V1008.lib (2) � LMC_SysBasic_V2001.lib (2) � Standard.lib (3)

Las librerías pueden encontrarse hasta en 3 carpetas distintas. Utilizar el siguiente código identificativo: 1.- C:\Schneider Electric\Motion Control\CoDeSys V2.3\Targets\Schneider Electric\Shared Files\Library\Motion 2.- C:\Schneider Electric\Motion Control\CoDeSys V2.3\Targets\Schneider Electric\Lexium Controller V0103\Library 3.- C:\Schneider Electric\Motion Control\CoDeSys V2.3\Library Según si se desea realizar operaciones más complejas como tablas CAM, utilidades CNC u otras deberán añadirse las librerías correspondientes. Estas son las mínimas.

1.5.- Otros ajustes (LREAL >> REAL) Se ha presentado un problema a la hora de realizar el proceso de compilado de bloques que incluyen en sus definiciones internas variables del tipo LREAL y es que el entorno Codesys no es capaz de reconocerlas. La única forma conocida es que a la hora de compilar lo haga tomando como REAL todas aquellas variables que son LREAL. La forma de hacerlo es tal como muestra la siguiente imagen:

www.infoPLC.net



2.- CONFIGURACION BASICA DRIVES

2.1.- Lexium 05 Se trata de configurar un Lexium 05 para poder ser controlado desde el puerto CANSync de la Lexium Controller. Para este cometido se recomienda seguir los siguientes pasos: 1.- Pasar a parámetros por defecto. Este paso es importante pues lo primero que tendremos que decirle al equipo es la forma en la que será controlado: drC- drC- drC- drC- -> FCS FCS FCS FCS -> yES yES yES yES 2.- Tras pulsar la tecla ENT el equipo mostrará la palabra FSu-FSu-FSu-FSu- para indicarnos que es necesario una configuración inicial. Pulsamos de nuevo la tecla ENT y cambiamos los siguientes parámetros: dEVC dEVC dEVC dEVC = Cano Cano Cano Cano (Control por CanOpen) ioPi ioPi ioPi ioPi = Ab Ab Ab Ab (No afecta a comunicaciones, configurar según aplicación) CoAd CoAd CoAd CoAd = 3 3 3 3 (Nodo CanOpen, en este ejemplo es el 3 pero depende de la aplicación) Cobd Cobd Cobd Cobd = 500 500 500 500 (Velocidad comunicaciones CanOpen, en este ejemplo es 500 Kbauds) ioLt ioLt ioLt ioLt = SOU SOU SOU SOU (No afecta a comunicaciones, configurar según aplicación) SAVESAVESAVESAVE (Grabar parámetros en memoria). 3.- Apagamos y reencendemos el equipo para que los cambios tengan validez 4.- Dado que se han pasado a parámetros de fábrica previamente no olvidar de repetir el autotune tras volver e encender el equipo siguiendo el siguiente proceso: tun- tun- tun- tun- -> Strt Strt Strt Strt 5.- Tras pulsar la tecla INT el equipo empezará a realizar el proceso de autoajuste mostrando la palabra donEdonEdonEdonE tras finalizarlo correctamente.. El equipo ya quedará preparado para ser controlado vía CANSync desde el Motion Controller.

www.infoPLC.net



2.2.- Lexium 15 MP Se trata de configurar un Lexium 15MP para poder ser controlado desde el puerto CANSync de la Lexium Controller. Para este cometido se recomienda seguir los siguientes pasos: 1.- Asegurarse de pasar a parámetros por defecto mediante el uso del software Unilink MH. Tan sólo se ha de establecer comunicación con el Lexium 15MP y pulsar sobre el botón Cargar Parámetros Default en la RAM/EEPROM. Tras unos instantes el equipo quedará a sus valores de fábrica. 2.- Pulsamos el botón Configuración básica y nos aseguramos de que los parámetros de Drive y Comunicación son los adecuados. En este caso se ha cambiado Voltaje máx. de la red a “230V”, Alimentación de potencia a “Ningún Mensaje”, Dirección a “5”, Baudrate del bus CAN a “500kBaud” y Auto Enable a “On” .

www.infoPLC.net



3.- Nos aseguramos de escoger el tipo de motor adecuado prestando atención a la posibilidad de si tiene o no freno. El tipo de motor debe encontrase en la lista de motores disponibles:

4.- Nos aseguramos de escoger el tipo de realimentación de velocidad adecuado según el tipo de motor utilizado:

www.infoPLC.net



5.- Es necesario que la palabra de control se encuentre a su valor por defecto. Si no lo estuviera deberemos cambiarla a mano programando el valor 1575210 mediante el modo terminal (sólo es posible cambiar la configuración con el equipo no habilitado):

6.- Para acabar, y aunque este proceso parece que tiene lugar automáticamente tan pronto el drive detecta trama CANSync tras ser encendido, cambiamos el OPMODE a modo “5: Tarea movim. Ext.” Y finalmente grabamos los cambios en la EEPROM:

www.infoPLC.net



3.- CONEXIÓN CON LEXIUM CONTROLLER

3.1.- Conexión a través de RS485

El primer paso para poder conectar con la Lexium Controller es a través del puerto Modbus mediante el mismo cable que se utiliza con el Power Suite para la configuración del Lexium 05. Este paso es imprescindible aunque el objetivo final sea conectarse a través del puerto Ethernet puesto que inicialmente la Lexium Controller no tiene, y de hecho no está, porque encontrarse con el puerto Ethernet configurado para conectar a través de él.

Una vez establecida la conexión física entre el puerto serie del PC y el Lexium Controller es necesario realizar una pequeña configuración en el entorno Motion Pro.

Puerto RS485 (Necesario Cable PowerSuite Ref. VW3A8106)

www.infoPLC.net



1.- Dirigirse al menú superior y escoger la opción “En Línea”

2.- Dentro de la opción “En Línea” escoger “Parámetros de comunicación” y aparecerá un cuadro de configuración parecido al siguiente:

Este cuadro muestra todos los medios de comunicación disponibles para acceder desde el PC hacia la Lexium Controller. De momento, como se puede apreciar, no existe declarado ningún medio de comunicación. Para crear uno se ha de pulsar sobre el botón “New”

www.infoPLC.net



3.- Tras pulsar sobre el botón “New” aparece una nueva ventana donde podremos escoger el protocolo de comunicaciones. En este caso el que emplearemos será el RS232 tal cual por lo que seleccionaremos Serial(RS232), modificaremos el nombre del protocolo a RS232 y pulsaremos sobre el botón “OK”.

NOTA : Escogemos un puerto RS232 aunque la LMC dispone de un puerto RS485 ya que el cable de conexión a utilizar es en realidad un conversor RS232-RS485

4.- Tras pulsar sobre el botón “OK” nos aparecerá el nuevo protocolo dentro de la ventana de conexiones disponibles:

Mediante este procedimiento ya es posible intentar la conexión desde el PC hacia la Lexium Controller. La comunicación RS485 mediante el puerto Modbus se encuentra disponible en toda la gama de Lexium Controller.

Nombre de la conexión. Cambiar el nombre sugerido por RS232

Protocolo a seleccionar.

www.infoPLC.net



3.2.- Conexión a través de Ethernet Si se desea un medio de comunicación más rápido que mediante el puerto RS232 o bien simplemente queremos dejar disponible el puerto RS232 para conectar una Terminal de operador u otro elemento externo podemos emplear el puerto de comunicaciones Ethernet.

El puerto de comunicaciones Ethernet se encuentra disponible en toda la gama de Lexium Controller a excepción del modelo LC10:

Para la conexión vía Ethernet se ha de preparar tanto la Lexium Controller como el propio PC pero vayamos por partes, primero se ha de añadir el protocolo de conexión por Ethernet del mismo modo que se hizo para el protocolo RS232 en el capítulo anterior.

Puerto Ethernet NO DISPONIBLE

Puerto Ethernet DISPONIBLE

www.infoPLC.net



1.- Dirigirse al menú superior y escoger la opción “En Línea”

2.- Dentro de la opción “En Línea” escoger “Parámetros de comunicación” y aparecerá un cuadro de configuración parecido al siguiente:

Esto es así porque previamente hemos tenido que configurar la conexión RS232 para poder, ahora, después de configurar la conexión Ethernet variar el número de IP de la Lexium Controller. Evidentemente no podemos variar vía Ethernet la IP para de ese modo conectar por puerto Ethernet porque no podemos conectar por el puerto Ethernet hasta que cambiemos el valor de dicha IP por lo que tendremos que hacerlo vía RS232).

www.infoPLC.net



3.- Pulsaremos sobre el botón “New” y aparecerá la ventana de selección de protocolos de comunicación donde escogeremos el Tcp/Ip (Level 2), modificaremos el nombre del protocolo a Ethernet y pulsaremos sobre el botón “OK”.

4.- Tras pulsar sobre el botón “OK” volveremos a la pantalla anterior donde deberemos especificar el número de IP hacia la cual, cuando utilicemos el protocolo de comunicaciones Ethernet intentará conectarse:

Asegurarse, por tanto, que la dirección IP sea 192.160.68.202 y que el tamaño de los paquetes sea de 1400 (para mejorar la velocidad de comunicaciones).

NOTA: Esto no configura la Lexium Controller lo único que hace es que el software Motion Pro buscará vía Ethernet una Lexium Controller cuyo IP sea 192.160.68.202. Aún falta programar la IP dentro de la Lexium Controller para que coincida con la que se ha programado en la configuración del puerto Ethernet del software Motion Pro.

Nombre de la conexión. Cambiar el nombre sugerido por Ethernet

Protocolo a seleccionar.

www.infoPLC.net



5.- Ahora disponemos de dos métodos de conectar con la Lexium Controller: RS232 y Ethernet. Para escoger uno u otro tan sólo se ha de seleccionar en la ventana de protocolos de conexión y pulsar sobre el botón OK. Seleccionamos el protocolo RS232.

6.- Utilizando el protocolo de comunicaciones RS232 deberemos ponernos ONLINE con el Lexium Controller y una vez conectados nos dirigimos hacia la ventana “Explorador PLC” la cual tiene un aspecto similar al mostrado por la siguiente figura:

Zona introducción órdenes. Zona respuestas de

órdenes ejecutadas

www.infoPLC.net



Esta pantalla hace las veces de modo Terminal y nos permite introducir y ejecutar toda una serie de instrucciones directas de entre las cuales se destacan las tres que utilizaremos para configurar el puerto Ethernet:

ETHINF: Nos muestra la configuración actual de Ethernet de la Lexium Controller. En la imagen anterior vemos como se nos indica que la IP no se encuentra configurada (0.0.0.0).

IP: Nos permite introducir una nueva IP para la Lexium Controller:

MASK: Nos permite introducir una máscara para la Lexium Controller

Una vez introducida la IP y la Máscara podemos ejecutar de nuevo la instrucción ETHINF para comprobar que dichos parámetros han sido aceptados:

NOTA: Llegados a este punto ya tenemos el Motion Pro configurado para buscar una Lexium Controller cuya IP sea la 192.160.68.202 y la Lexium Controller configurada con una IP idéntica por lo que ya sería posible acceder a la Lexium Controller a través de un cable Ethernet cruzado estándar.

www.infoPLC.net



7.- Pero aún falta configurar el PC de modo que el puerto Ethernet quede reservado para conectar con la Lexium Controller, esto se hace del siguiente modo:

En el escritorio de Windows abrir Inicio > Configuración > Conexiones de Red

Clic con el botón derecho sobre el icono “Conexión de área local” y seleccionar “Propiedades”

www.infoPLC.net



Seleccionar “Protocolo Internet (TCP/IP) y pulsar sobre botón “Propiedades”

Seleccionar “Usar la siguiente dirección IP” e introducir como dirección IP el valor 192.160.68.200 y como máscara 255.255.255.0 para finalizar aceptando estos valores pulsando sobre el botón “Aceptar”.

NOTA: Observar como la IP del PC es 192.160.68.200 y no 192.160.68.202. La IP del PC debe ser diferente de la de la Lexium Controller. Todos los nodos de la red deben tener el mismo direccionamiento salvo el cuarto valor que debe cambiar único para cada nodo.

8.- Ahora ya podemos conectar vía Ethernet con el Lexium Controller para ello seleccionamos como protocolo de comunicaciones el Ethernet y pulsamos sobre el botón “OK”.

9.- Al entrar ONLINE el Motion Pro intentará conectar vía Ethernet con la Lexium Controller.

www.infoPLC.net



4.- TAREAS Y PRIORIDADES 4.1.- Tiempo de ejecución vs Tiempo de disparo Como se ha visto hasta el momento a la hora de estructurar una aplicación se suele crear un programa que contiene los diversos bloques de funciones dedicados a mover cada uno de los posibles ejes contenidos en la aplicación. Este programa debe encontrarse sincronizado con el bus síncrono o Motion Bus de modo que cada cierto tiempo fijo vaya enviando a los diversos ejes la consigna de posición que les correspondería según su marca de tiempo. En este caso el programa, por contener todas las instrucciones de movimiento, debería dispararse cada cierto tiempo de modo que se envíen de forma simultánea a todos los ejes de la red las diversas consignas de posición. Así aparecen dos conceptos muy importantes:

Tiempo de ejecución: Es el tiempo que necesita un programa para ejecutarse completamente y depende de la cantidad y complejidad del código contenido en él.

Tiempo de disparo: Indica cada cuanto tiempo se va a iniciar la ejecución de un programa

dado. En el siguiente diagrama podemos observar la diferencia entre un concepto y otro: Como se puede observar el ciclo de scan de un programa (tiempo disparo) es único y fijo y debe ser siempre mayor que el tiempo de ejecución del código contenido en él el cual depende a su vez de su nivel de complejidad (el cual puede variar entre disparo y disparo). NOTA : El tiempo de disparo debe ser obligatoriamente mayor que el tiempo de ejecución o de lo contrario se generará un error por intentar ejecutar un programa cuya ejecución aún no finalizó.

Tiempo Disparo

Tiempo Ejecución

www.infoPLC.net



4.2.- Prioridades de ejecución En la Lexium Controller es posible programar la ejecución de programas con hasta 4 niveles distintos de prioridad. Un programa, por si mismo, salvo el programa de nombre especial PLC_PRG, no se ejecutan por si mismos sino que deben vincularse previamente a una tarea. Es mediante la configuración del nivel de prioridad de dicha tarea como es posible modificar la prioridad del programa. Los diferentes niveles de prioridad de una tarea, ordenados de mayor a menor son:

• EVENT TASK 1 • EVENT TASK 2 • MOTION BUS • AUXILIARY (Tareas Cíclicas)

En caso de que encontrándose ejecutando una tarea determinada se activara una tarea de mayor prioridad la ejecución de la primera quedaría congelada en tanto se ejecute la de mayor prioridad. Ver el siguiente diagrama para entenderlo mejor (no aparece la tarea Auxiliary pero sería la de menor prioridad).

Como se observa en el diagrama de tiempos existe una tarea denominada Motion Task que se va ejecutando cíclicamente cada cierto tiempo. Si en un momento determinado se dispara una tarea de prioridad superior, por ejemplo la Event Task 2, la tarea Motion Task queda momentáneamente congelada y se pasa a atender la tarea Event Task2, al acabar de ejecutarse la tarea Event Task 2 se continua ejecutando la tarea Motion Task desde el punto en que quedó congelada. Si mientras nos encontramos ejecutando la tarea Event Task 2 aparece la orden de ejecución de una tarea de prioridad superior, la Event Task 1, se repite el proceso: La tarea Event Task 2 queda congelada mientras se ejecuta la Event Task 1, al acabar esta se prosigue la ejecución de la Event Task 2 y sólo al finalizar dicha tarea se finaliza la ejecución de la Motion Task.

Event task execution time

Event TASK 2

Event TASK 1

Motion application task

Event input 1

Event input 2

Motion application cycle time+

both Event taskS execution time

Interruption EVT2 + EVT 1EVT 1 higher priority

Motion application cycle +

Interuption EVT 2

Periodic Motion Application cycle

www.infoPLC.net



4.3.- Creación de tareas y su configuración Siempre debería existir un programa vinculado a una tarea sincronizada con el Motion Bus. Este programa deberá contener todas las instrucciones relacionadas con control de los diversos ejes de la aplicación. La creación de esta tarea es bastante sencilla:

Pasos para la creación de una tarea:

1. Ir a pestaña Recursos 2. Doble clic sobre “Configuración de Tareas” 3. Clic con botón derecho sobre icono “Configuración de tareas” 4. Clic sobre opción Anexar Tarea

www.infoPLC.net



Tras ello aparecerá una nueva tarea a la cual le podemos dar un nombre cualquiera. Observar que aunque existe una casilla para establecer el nivel de prioridad este sólo puede ser 1 esto es porque el nivel de prioridad no se establece de forma numérica sino especificando el tipo de prioridad: Podemos decidir crear una tarea del tipo Cíclico de modo que sea ejecutada cada intervalo de tiempo determinado o bien crear una tarea que sea Controlada externamente por eventos de modo que esta se inicie bien por entradas digitales de interrupción %IX1.0 (Event Input 1) o %IX1.1 (Event Input 2) bien por una marca de tiempo para la sincronización de varios ejes (Motion_Cycle)

NOTA : No es posible definir dos tareas controladas externamente por eventos del mismo tipo (por ejemplo dos tareas Event Input 1) pero es posible definir tantas tareas cíclicas como queramos pudiendo ser el intervalo de disparo de las mismas igual o distinto entre si.

www.infoPLC.net



Como la tarea por si misma no sirve para nada si no va vinculada a un programa el siguiente paso sería vincular un programa a la tarea en curso:

1. Pulsamos con el botón derecho sobre el icono de la tarea recién creada. Pulsaremos sobre la opción Anexar Llamada de programa del cuadro que aparecerá:

2. Aparecerá un cuadro de diálogo donde podremos introducir el nombre del programa, si es que lo conocemos, que queramos vincular a la tarea el cual no debe encontrarse vinculado a otra tarea para evitar ser llamado simultáneamente desde dos tareas distintas. Si no nos acordamos de los nombres de los programas disponibles podemos pulsar sobre el botón punteado apareciendo con ello una lista de programas.

3. Seleccionar el nombre del programa que deseemos vincular con la tarea y pulsar sobre el botón Aceptar:

www.infoPLC.net



Así la siguiente configuración de tareas podría ser posible: Una tarea denominada TareaPrincipal que es la encargada de ejecutar el programa Principal() donde figuran todas las instrucciones relacionadas con el control de los diversos ejes y dos tareas cíclicas la primera denominada TareaCiclica y configurada, por ejemplo, para llamar cada segundo a los programas Supervisión() y Calculos() y la segunda, llamada TareaMediciones, que llamará al programa Temporizadores()cada 10mseg

www.infoPLC.net



4.4.- Estados y Tiempos ejecución de Tareas y Grupos de ejes Disponemos de una serie de bloques, contenidos todos ellos en la librería SysLibIecTasks.Lib, que nos permiten obtener una serie de información muy útil acerca del estado del Motion Bus así como del tiempo de ejecución de las diversas tareas: Mediante los dos bloques anteriores podemos determinar si un Axis Group determinado se encuentra o no en error y en caso que así fuera intentar resetearlo.

Los dos bloques anteriores permiten crear dos estructuras de variables p1 y p2 que contienen información relativa al estado o tiempos de ejecución de, en este caso, la tarea que controla el Motion Bus (Motion_Cycle) y la auxiliar o cíclica disparada cada cierto tiempo. Así:

p1.dwCount Número de veces que se ha ejecutado la tarea desde que se activó p1.dwCycleTime Tiempo de ejecución actual p1.dwCycleTimeAvg Tiempo de ejecución medio p1.dwCycleTimeMax Tiempo de ejecución máximo p1.dwCycleTimeMin Tiempo de ejecución mínimo p1.wMode Estado actual del LC (0=RUN, 1=STOP) p1.wStatus Estado actual de la tarea (1=Ejecutándose, 2=Detenida (por error o no))

www.infoPLC.net



5.- Parametrización inicial Drive. Existe la posibilidad de modificar el valor de una serie de parámetros de los diferentes accionamientos de forma automática durante el primer ciclo de scan de la LMC. El método utilizado desde Codesys es la creación de una lista de parámetros a modificar indicando cual debe ser el valor de dichos parámetros. Esta lista se enviará durante el primer ciclo de scan vía Motion Bus hacia el nodo que corresponda (cada nodo puede tener una lista diferente de parámetros a modificar). Este punto es especialmente útil de cara a un mantenimiento ya que es posible sustituir un equipo fácilmente si previamente se han seguido los siguientes pasos:

1. Tras acabar la puesta en marcha obtener mediante el uso de softwares a tal fin como PowerSuite o Unilink todos los parámetros cuyo valor haya sido modificado de cada uno de los ejes de la aplicación.

2. En la sección correspondiente de Motion Pro (se explica más adelante) crear una lista individual de

parámetros para cada eje con todos aquellos cuyo valor haya sido modificado.

3. Ya está, cada vez que se arranque el programa estos valores serán enviados hacia el equipo remoto que corresponda.

5.1.- Creación de listas de parámetros Durante la configuración de cada eje disponemos de una pestaña específica para realizar lo mencionado:

En este punto podemos hacer varias cosas, o rellenar a mano la lista de parámetros o utilizar un fichero externo creado a tal fin:

www.infoPLC.net



Si lo quisiéramos hacer a mano nada más fácil:

1. Hacemos clic sobre el icono de la columna Insertar.

2. En la fila que se creará se ha de indicar cual es la dirección CAN del parámetro a modificar indicando el Índice, Subíndice así como la longitud del valor que se enviará en bytes y, por supuesto, el valor que se desea para dicho parámetro. Por ejemplo, para modificar el parámetro AT_Gain, sería:

3. Una vez creada toda la lista podríamos guardarla en un fichero externo de modo que nos sirva de

Backup personal para, por ejemplo, clonar máquinas. Para ello tan sólo se ha de pulsar sobre el botón Escribir en archivo. El formato de guardado es XML con codificación iso-8859-1.

www.infoPLC.net



Si lo quisiéramos cargar la lista de parámetros mediante el uso de un archivo externo previamente creado:

1. Pulsar sobre el botón Leer de Archivo. 2. Buscamos el archivo XML que contiene la lista de parámetros. Este archivo debe no sólo ser tipo

XML sino compatible con el formato de codificación iso-8859-1 o de lo contrario no se cargaran los parámetros:

3. Cuando hayamos encontrado el fichero adecuado pulsamos sobre el botón Abrir y aparecerá toda la lista de parámetros:

NOTA: Se dispone de un archivo XML con los valores por defecto de todos los parámetros de tipo R/W del Lexium05A, pedidlo al autor de este documento si se necesitara.

www.infoPLC.net



5.2.- Edición archivo externo XML Como se ha comentado en el apartado anterior es posible guardar y cargar listas de parámetros mediante el uso de ficheros externos. No obstante se han constatado una serie de peculiaridades que hay que tener en cuenta:

1. Aunque Excel es, aparentemente, compatible con el formato XML parece que no lo es con el sistema de codificación iso-8859-1 por lo que cualquier intento de emplear Excel como editor de este tipo de ficheros provocará que estos queden inutilizados (ni siquiera hace falta modificar nada, el fichero quedará inutilizado con tan sólo abrirlo y guardarlo).

2. A este respecto se recomienda utilizar editores XML freeware que sean compatibles con el sistema

de codificación iso-8859-1. En Internet hay bastantes si se sabe buscar como por ejemplo el XMLNotepad cuyo aspecto es el mostrado en la siguiente figura:

www.infoPLC.net



6.- PROGRAMACION 6.1.- Los diferentes lenguajes de programación Existen hasta 7 tipos de lenguaje de programación que el usuario puede utilizar a su criterio. Cada uno de los cuales tiene sus ventajas y desventajas. La norma sería que cada cual utilizara el lenguaje con el que se sienta más cómodo según sus necesidades.

No obstante hay tres lenguajes que pueden destacar sobre el resto: El SFC, el CFC y el ST.

6.1.1.- El lenguaje SFC o Graphet El primero de ellos, el SFC, es un lenguaje de programación más conocido como Graphet y que permite organizar el programa mediante un diagrama de flujo. La siguiente imagen muestra un ejemplo de ello:

En la imagen anterior vemos la estructura básica de un programa realizado en SFC. Este ejemplo tiene varios elementos comunes a cualquier tipo de programa y que son:

Tarea Init: Esta tarea se ejecuta al iniciar el programa y en principio, salvo que se realice una llamada posterior, no vuelve a ejecutarse.

El triangulito negro indica que hay algún programa dentro de la tarea

www.infoPLC.net



Condiciones de entrada: Son variables tipo Bool que permiten, cuando su valor es TRUE, que el programa pase de una tarea a otra:

Estas variables tipo Bool deben ser tratadas en la tarea precedente de modo que únicamente una de ellas se activara a TRUE mientras que el resto deben permanecer a FALSE (para evitar entrar en dos tareas simultáneamente). En este caso el condicionante de entrada Gear se encuentra a TRUE (puede observarse porque su color es azul) y eso ha dado paso a que pueda ejecutarse el programa de la tarea Modo_Gear (sabemos que se está ejecutando dicho programa porque la tarea que lo contiene se encuentra resaltada en azul).

Condiciones de salida: Son variables tipo Bool que permiten, cuando su valor es TRUE, que el programa abandone la tarea que se encuentra ejecutando en ese momento y el programa siga fluyendo. En caso que el valor de la variable de salida sea FALSE el programa de la tarea activa en ese momento seguirá ejecutándose cíclicamente.

Saltos: Permiten, cuando se cumplan las condiciones de entrada, que el programa salte a una tarea anterior.

En el caso de la imagen anterior cuando la condición Parado sea TRUE el programa se dirigirá hacia la tarea Init. Una vez en la tarea Init debería tenerse la precaución de volver a poner a FALSE la variable Parado ya que de lo contrario, si el valor de la variable Parado no se resetea nunca, al volver a pasar por la zona de salto este se producirá automáticamente de forma, quizás, indeseada.

Indicativo de salto

Tarea hacia la que se producirá el salto

Condicionante de entrada al salto

www.infoPLC.net



Tareas paralelas: Son tareas que se ejecutan paralelamente al flujo de programa, pueden existir tantas como queramos pero hemos de tener en cuanta que cuantas más creemos más recursos se consumirán. Su utilidad podría ser, por ejemplo, la de gestionar las alarmas del sistema.

En la imagen anterior vemos dos tareas paralelas Monitor y EjeVirtual que se ejecutan cíclicamente tan pronto el condicionante de entrada Inicializado sea TRUE. Para abandonar la ejecución de estas tareas paralelas tan sólo es necesario configurar a TRUE el condicionante de salida Parado.

Tareas Alternativas: Son como las tareas paralelas pero únicamente puede ejecutarse una. Por ejemplo, en la siguiente estructura vemos como aún existiendo la posibilidad de ir por cuatro caminos simultáneamente el sistema toma el camino más a la izquierda.

Esta doble línea indica la existencia de una o más tareas paralelas (en este caso hay dos)

www.infoPLC.net



Acciones de entrada: Es posible ejecutar un programa una sola vez, cuando se entra en una tarea determinada, mediante la inclusión de una acción de entrada. Para ello sólo debemos hacer clic con el botón derecho del ratón sobre la tarea y seleccionar la opción “Agregar Acción de entrada”:

Posteriormente el sistema preguntará que tipo de lenguaje se desea utilizar para programar la/s acciones de entrada deseadas:

Y tras este sencillo procedimiento la tarea (en este caso la tarea “Manual”) tendrá asociado un programa que se ejecutará únicamente al entrar en la tarea.

Haciendo doble clic sobre el cuadradito con la letra “E” podremos entrar a programar lo que deseemos. Aquello que se programe será lo primero que se ejecute tan pronto se entre en la tarea “Manual”.

www.infoPLC.net



Acciones de Salida: Es posible ejecutar un programa una sola vez, cuando se sale de una tarea determinada, mediante la inclusión de una acción de salida. Para ello sólo debemos hacer clic con el botón derecho del ratón sobre la tarea y seleccionar la opción “Agregar Acción de Salida”:

Posteriormente el sistema preguntará que tipo de lenguaje se desea utilizar para programar la/s acciones de salida deseadas:

Y tras este sencillo procedimiento la tarea (en este caso la tarea “Manual”) tendrá asociado un programa que se ejecutará únicamente al salir de la tarea.

Haciendo doble clic sobre el cuadradito con la letra “X” podremos entrar a programar lo que deseemos. Aquello que se programe será lo último que se ejecute tan pronto se salga de la tarea “Manual”.

www.infoPLC.net



6.1.2.- El lenguaje CFC o Complex Flow Chart Este lenguaje permite programar mediante bloques de funciones vinculados entre ellos de forma más o menos libre. Permiten un nivel de monitorización muy alto pero su punto débil son las instrucciones de asignación y condicionamiento. Además hay que prestar muchísima atención al orden de ejecución de los diferentes bloques de función pues podría darse el caso de que se ejecutara antes un bloque indeseado que provocara el mal funcionamiento del programa.

Hay que tener en cuenta que la posibilidad de monitorización del lenguaje CFC no es la panacea ya que en ciertos momentos los valores de las variables cambian muy rápidamente y probablemente no seamos capaces de ver o analizar porque el programa se comporta anómalamente (eso pasa si las variables se encuentran cambiando constantemente o si estamos entrando y saliendo de un bloque de forma continuada y rápida).

Una Asignación

Indicativo del orden de ejecución.

www.infoPLC.net



Evidentemente podemos cambiar el orden de ejecución si pulsamos con el botón derecho del ratón sobre el entorno de programa y seleccionamos la opción Order. De los diferentes tipos de orden se recomienda utilizar el Order everything according to data flow ya que entonces se renumerarán todos los bloques según el orden de ejecución real que tendrá el programa y podremos valorar si nos interesa o no. Una vez el orden sea el deseado podemos deseleccionar la opción Show Order para evitar que se muestre el orden de ejecución de los diferentes bloques (puede resultar molesto cuando se monitoricen los diferentes estados del programa o simplemente a nivel estético).

Añade una nueva entrada al bloque seleccionado (útil para añadir entradas a bloques lógicos tipo AND u OR)

Permite negar una entrada o salida.

Añade una entrada de habilitación a un bloque que no lo tenga de forma que podemos restringir su ejecución a menos que dicha entrada sea TRUE.

www.infoPLC.net



6.1.3.- El lenguaje ST o Structured Text Este lenguaje es el más completo y potente ya que permite realizar de forma estructurada toda una serie de procesos que en el resto de lenguajes requieren un especial cuidado o bien implican mayor complicación. Evidentemente es un lenguaje alejado a la habitual programación de un PLC y requiere de un tiempo de aprendizaje mínimo pero a cambio pone en nuestras manos una capacidad de desarrollo mucho más elevado.

Las únicas recomendaciones serían que se guardara un cierto nivel estético (tabulando la información existente dentro de los condicionantes y subrutinas que impliquen acabar con la instrucción END_) y de ayuda incluyendo cuanto comentario haga falta para que en futuras consultas por el que realizó el programa u otro programador sea fácil conocer que hace cada parte del programa. Observar como el programa ejemplo de la imagen anterior dispone de comentarios en cada sección de programa y como se hace uso de las tabulaciones para incluir secciones de programa dentro de las instrucciones IF y FOR.

Número de línea, es posible añadir un breakpoint para tareas de debbuging.

En azul instrucciones ST reconocidas.

En Verde comentarios de usuario.

En Magenta constantes reconocidas por el sistema.

www.infoPLC.net



6.2.- Las variables de usuario

6.2.1.- Los diferentes Tipos Se ponen a nuestra disposición toda una serie de tipologías de variables, unas más sencillas y otras más complejas. Es importante hacer un uso adecuado de las variables con el fin de optimizar tanto los recursos consumidos por la aplicación como la propia velocidad de ejecución de la misma.

Las variables disponibles pueden ser de tipo sencillo:

Tipo Valor mínimo Valor máximo Espacio en Memoria

Ejemplo Asignación

BOOL FALSE TRUE 1 Variable:=TRUE;

BYTE 0 255 8 Bit Variable:=200;

WORD 0 65535 16 Bit Variable:=60000;

DWORD 0 4294967295 32 Bit Variable:=120000;

SINT -128 127 8 Bit Variable:=-100;

USINT 0 255 8 Bit Variable:=10;

INT -32768 32767 16 Bit Variable:=-30000;

UINT 0 65535 16 Bit Variable:=60000;

DINT -2147483648 2147483647 32 Bit Variable:=-2000000;

UDINT 0 4294967295 32 Bit Variable:=120000;

REAL 1.175494351e-38 3.402823466e+38

32 Bit Variable:=1.53;

LREAL 2.2250738585072014e-308

1.7976931348623158e+308 64 Bits Variable:=-3.56;

TIME 0d0h0m0s0ms 49d17h2m47s295ms 32 Bit Variable := t#12h34m15s

TIME_OF_DAY 00:00:00 23:59:59.999 32 Bit Variable := tod#00:00:00

DATE 1970-00-00 2106-02-06. 32 Bit Variable := d#1972-03-29

DATE_AND_TIME 1970-00-00-00:00:00 2106-02-06-06:28:15 32 Bit Variable := dt#1972-03-29-00:00:00

STRING 1 Caracter 255 Caracteres 1 Byte x Caracter Variable :=:STRING(35):='Hola';

www.infoPLC.net



O algo más complejas:

Tipo Declaración e Inicialización

ARRAY Ejemplo Declaración y Asignación valores por defecto Matriz: ARRAY [0..6] OF STRING := 'Stop', 'Velocidad', 'Posición', 'Cam', 'Gear', 'Homming','Interpolator’;

TYPE Ejemplo Declaración TYPE TIPO_SEMAFORO: (Rojo, Ambar, Verde:=10); END_TYPE Ejemplo Uso SEMAFORO1 : SEMAFORO_TIPO; SEMAFORO1:=0; (* El valor para de la señal del SEMAFORO1 es Rojo*) FOR i:= Rojo TO Verde DO i := i + 1; END_FOR;

STRUCT Ejemplo Declaración TYPE Ejes : STRUCT Activar:BOOL; Velocidad: REAL; VelHome:DWORD; Aceleracion: REAL; Deceleracion: REAL; Posicion: REAL; Tiempo: TIME; END_STRUCT END_TYPE TYPE Estructura : STRUCT Secuencia: INT; Eje: ARRAY[1..2] OF Ejes; END_STRUCT END_TYPE Ejemplo Asignación valores por defecto Secuencia: ARRAY [0..20] OF Estructura:= (Secuencia:=0, Eje:= (Activar:=TRUE, Velocidad:=200, Aceleracion:=500, Deceleracion:=500), (Activar:=TRUE, Velocidad:=200, Aceleracion:=500, Deceleracion:=500)), (Secuencia:=1, Eje:= (Activar:=TRUE, Velocidad:=200, Aceleracion:=500, Deceleracion:=500, Tiempo:=T#1m), (Activar:=TRUE, Velocidad:=200, Aceleracion:=500, Deceleracion:=500, Tiempo:=T#1m)), (Secuencia:=2, Eje:= (Activar:=TRUE, Posicion:=0, Velocidad:=200, Aceleracion:=500, Deceleracion:=500), (Activar:=TRUE, Posicion:=360, Velocidad:=200, Aceleracion:=500, Deceleracion:=500)),

www.infoPLC.net



Las variables complejas del tipo TYPE y STRUCT deben ser creadas en la pantalla Tipos de Datos. Por ejemplo, para crear una variable del tipo TYPE ejecutaremos los siguientes pasos:

1. Pulsamos con botón derecho sobre carpeta Tipo de datos y seleccionamos opción Añadir Objeto:

2. Introducimos el nombre para la nueva variable.

3. Modificamos a mano, ya que no es posible indicar el tipo de variable que queremos crear, la definición de la estructura creada por otra tipo TYPE de manera que incluya las etiquetas internas deseadas (en el ejemplo que se muestra se crean tres: Rojo, Amarillo y Verde).

4. El nuevo tipo de variable ya ha sido creado y puede ser utilizado en el resto del programa.

www.infoPLC.net



Si deseamos crear una estructura (agrupación de varios tipos distintos de variables en una única variable) es más sencillo, simplemente ejecutar los siguientes pasos:

1. Pulsamos con botón derecho sobre carpeta Tipo de datos y seleccionamos opción Añadir Objeto:

2. Introducimos el nombre para la nueva variable.

3. Una vez creada la estructura definiremos las variables internas a mano según nuestra necesidad ya únicamente se crea el patrón de estructura (el sistema no puede saber que deseamos incluir).

4. El nuevo tipo de variable ya ha sido creado y puede ser utilizado en el resto del programa.

www.infoPLC.net



6.2.2.- Volatilidad de las variables Por regla general las variables que se utilizan son del tipo volátil, es decir, cuando se quita tensión de la Lexium Motion Controller su valor se pierde. No obstante es posible definir hasta tres tipos de comportamiento distinto según se especifique a la hora de declarar la variable:

Si no se especifica que una variable debe ser de tipo RETAIN o PERSISTENT automáticamente pasa a ser volátil. Si se especifica uno o los dos tipos indicados la variable pasa a ser remanente, es decir, que puede guardar su valor aunque dependiendo de la combinación escogida se comportará de una u otra forma: RETAIN: Mantienen su valor tras una finalización incontrolada así como también tras un

apagado y encendido normal de la LMC (RESET). Un RESET de otro tipo (en frío u original) o el envío de un programa harán que los valores se inicialicen.

Un ejemplo sería un contador de piezas de una instalación de producción que tuviera que seguir contando en caso de fallo del sistema eléctrico.

PERSISTENT: Sólo mantienen su valor en caso de enviar un nuevo programa. PERSISTENT RETAIN: Si se desea que las variables PERSISTENT mantengan su valor tras un paro

incontrolado de la LMC tendrán que declararse también como RETAIN.

Un ejemplo de aplicación sería un contador de horas de servicio que tuviera que seguir contando tras un fallo del sistema eléctrico.

La siguiente tabla ayuda a entender las diferencias entre las tres categorías de variables remanentes:

Tras Comando Online

VAR VAR RETAIN VAR PERSISTENT VAR RETAIN PERSISTENT VAR PERSISTENT RETAIN

Reset - SI - SI Reset (en frío) - - - - Reset (original) - - - - Cargar (=Descargar) - - SI SI Modificación en línea SI Si SI SI

SI=Se mantiene el valor, -=se vuelve a inicializar el valor ATENCION:

• Si una variable local se declara como RETAIN en un programa, esa variable se guarda en la zona retain (como variable retain global).

• Si una variable local se declara como RETAIN en un bloque de funciones, la instancia completa de ese bloque de funciones se guarda en la zona retain (todos los datos del módulo), aunque solo se trata de esa manera la variable retain declarada.

• Si una variable local se declara en una función como RETAIN, esto no tiene ninguna consecuencia. ¡La variable no se guarda en la zona Retain! ¡Si una variable local se declara como persistente en una función, tampoco tiene consecuencias!

NOTA: Por defecto del actual firmware se recomienda utilizar únicamente las variables de tipo REMAIN PERSISTENT si se desea que la información se mantenga en ausencia de tensión de alimentación en la Lexium Motion Controller.

www.infoPLC.net



6.3.- Uso de un eje virtual El uso de los ejes virtuales es una herramienta que se suele utilizar para comprobar el funcionamiento de partes de máquina de forma autónoma al resto de la línea de producción. Por ejemplo, en una línea de corte, podemos comprobar como se comportará la sección de la cizalla volante sin necesidad de arrancar la sección de alimentación de material evitando así pérdida de producto y facilitando el test. Un eje virtual no es más que un contador que se incrementa del mismo modo que se incrementaría la posición de un encoder real que se encontrara traccionado por el flujo de material suministrado por una línea de producción simulando así el comportamiento de esta línea y por tanto pudiendo comprobar de una forma cómoda de que manera se comporta la parte esclava dependiente de dicha línea.

6.3.1.- Vía bloque SMC_TimeAxisFB Este método permite una implementación rápida de un eje virtual mediante la creación de una variable del tipo Axis_Ref (que es la utilizada por un eje real). Observar el siguiente ejemplo escrito en lenguaje CFC:

De esta rutina vemos lo siguiente:

1. Se introduce como variable de entrada la velocidad en RPM a la que queremos se desplace el eje virtual mediante la variable Vel_EjeVirtual.

2. Multiplicamos Vel_EjeVirtual por el periodo del eje maestro para trabajar en las mismas unidades que este y dividimos el resultado entre 60. Así pasamos de RPM a Unidades /seg.

3. El resultado se introduce como entrada a un bloque NE de modo que cuando la velocidad calculada sea diferente a la actual el resultado del bloque NE sea TRUE y cuando sea igual FALSE. Con esto se consigue que el bloque SMC_TimeAxisFB se reinicie cada vez que cambiamos la velocidad.

4. A la vez se introduce la velocidad calculada en la entrada fOverride del bloque SMC_TimeAxisFB. Este valor entrara en vigor tan pronto la entrada bExecute detecte un flanco de subida.

5. Se asigna FALSE y 0 a las entradas bPeriodic y fPeriod obligatoriamente mientras que la entrada fRampInTime afecta a la rampa de aceleración que se aplica para alcanzar la velocidad deseada (en este caso se pone a 0 porque interesa que la velocidad deseada sea aplicada inmediatamente)

6. El bloque SMC_TimeAxisFB generará una variable que podremos utilizar como si de un eje real se tratara (podemos añadirlo, por ejemplo, como eje master de un FB de sincronismo MC_GearIn).

7. Se toma la velocidad del eje recién creado, al que hemos llamado EjeVirtual, mediante el FB MC_ReadActualVelocity. La velocidad de este eje únicamente se utiliza para compararla con la deseada y poder actual en consecuencia sobre la entrada bExecute del bloque SMC_TimeAxisFB.

El mismo ejemplo en lenguaje ST sería:

Como se observa tampoco reviste mayor dificultad entre utilizar un lenguaje u otro.

www.infoPLC.net



6.3.2.- Vía Dummy Axis Podríamos decir que este es el método auténtico para el uso de un eje virtual ya que el eje que es posible crear mediante esta vía tendrá toda la potencia que tendría un eje real: se configura igual, puede incorporar rampas, puede habilitarse y deshabilitarse, etc.

Es necesario la siguiente librería para el uso de ejes virtuales:

• Dummydrive_V1940.lib

La librería puede encontrarse en la carpeta:

C:\Schneider Electric\Motion Control\CoDeSys V2.3\Targets\Schneider Electric\Shared Files\Library\Motion

Para utilizar un Dummy Axis este se configura del mismo modo que un eje real, es decir, desde las pantallas de configuración de ejes:

Los pasos serían:

1. Ir a pestaña Recursos. 2. Doble clic en opción Configuración del mando. 3. Clic con el botón derecho sobre el icono Lexium Controller V01 y añadimos un nuevo BusInterface. 4. Renombramos el nuevo BusInterface con el nombre BusVirtual para que no entre en conflicto con

el BusInterface que contiene el grupo de ejes reales. 5. Configuramos el BusInterface de nombre BusVirtual para que controle un accionamiento de tipo

Dummy.

www.infoPLC.net



6. Clic con el botón derecho sobre el BusInterface de nombre BusVirtual y añadimos un nuevo AxisGroup al que llamaremos VirtualGroup.

7. Enlazamos el nuevo grupo de ejes denominado VirtualGroup con la tarea TareaPrincipal ya que esta es la misma que utiliza el grupo de ejes reales. De este modo tanto los ejes reales como el virtual se encontrarán sincronizados con la misma base de tiempos. El tiempo de ciclo será igual al empleado en la configuración del grupo de ejes reales.

8. Clic con el botón derecho sobre el grupo de ejes de nombre VirtualGroup y añadimos un nuevo eje al que llamaremos EjeVirtual.

9. Configuramos el nuevo eje virtual del mismo modo que haríamos si fuera real (incluyendo el número de nodo que debe ser diferente al resto de números de nodo empleados).

10. Y ya está, el eje EjeVirtual se puede utilizar y se comportará como un eje real a pesar de que no

existe en realidad.

www.infoPLC.net



En la siguiente sección de programa se puede observar como se emplea el eje virtual recién creado como maestro de una tabla CAM (el eje real se llama Eje2):

Para la marcha y/o paro de este eje virtual o para modificar su velocidad podemos observar la siguiente sección de programa: Observar como se emplean los bloques MC_Power para habilitar o deshabilitar el eje virtual y el MC_MoveVelocity para modificar su velocidad: igual que un eje real.

www.infoPLC.net



6.4.- Uso de un encoder externo Con el fin de sincronizar el comportamiento de los diferentes ejes controlados por el Lexium Controller existe la posibilidad de conectar una referencia externa la cual puede ser un encoder externo. Una vez introducido este elemento de medida externo cada uno de los ejes puede sincronizarse con diferentes ratios con él según las necesidades del proyecto a realizar.

La incorporación de un encoder maestro es fácil:

NOTA: El encoder externo puede y debe ser alimentado desde una fuente de alimentación independiente la cual puede ser conectada en bornas del Lexium Controller que se indican en la imagen anterior (ver manual de usuario) estas bornas se encuentran internamente unidas a los pines adecuados del conector de alta densidad SUB D15 donde se conecta el encoder y no se utilizan para nada más.

Entrada de encoder externo.

Alimentar a la tensión con la que se desea trabajar con el encoder.

www.infoPLC.net



Respecto a como se declara un eje virtual nada más fácil que seguir los siguientes pasos:

Pasos a realizar

1. Dirigirse a la pantalla Recursos.

2. Doble clic sobre la opción Configuración del mando.

3. Clic con el botón derecho sobre el icono Lexium Controller V01.

4. Clic sobre la opción Anexar Subelemento del menú desplegable aparecido.

5. Clic sobre la opción MasterEncoder del submenú desplegable aparecido.

El nuevo elemento quedará añadido a la lista de elementos del Lexium Controller:

www.infoPLC.net



Aunque puede modificarse el nombre del encoder maestro recién introducido no se aconseja ya que posiblemente debido a un error del Codesys no es posible hacer referencia al nuevo encoder maestro por dicho nombre. En su lugar, para hacer referencia al encoder maestro se utilizar un formato fijo: La mejor forma de ver como se utiliza este encoder maestro es mediante un ejemplo escrito en lenguaje ST:

En este ejemplo se puede ver como mediante el uso de la variable Secuencia[NumSeq].Eje[1].MReal es posible utilizar como encoder maestro un encoder virtual (caso que su valor sea FALSE) o externo (caso que sea TRUE). Caso que el valor sea TRUE (selección encoder maestro externo real) vemos como simplemente se asigna a la variable EjeVirtual1 que es del tipo AXIS_REF el valor de Encoder1.Axis la cual es una variable reservada (de sistema, no creada por el usuario) del mismo tipo que refleja el comportamiento del encoder maestro externo real. En el caso de desear que la variable EjeVirtual1 sea reflejo del eje virtual mediante la asignación de FALSE a la variable Secuencia[NumSeq].Eje[1].MReal se recomienda dirigirse al capítulo anterior donde se habla de los ejes virtuales.

www.infoPLC.net



6.5.- Uso de varios encoders externos Hay que tener en cuentra que la LMC sólo dispone de una entrada MasterEncoder así que a nivel Hardware debería buscarse algún elemento rápido, quizás un conmutador basado el relés de estado sólido o similar, que permita dirigir las señales de un encoder u otro hacia la entrada MasterEncoder de la LMC.

Solventado este problema aparece la necesidad de poder modificar Online los ratios de la entrada MasterEncoder ya que los diferentes encoders externos que puedan ser utilizados en la aplicación no tienen porqué tener el mismo factor de escalado.

Esta operación debe realizarse de modo que no se detenga la producción si bien, quizás, se produzca un error debido al retardo del conmutador físico, ciclo de scan, etc que el cliente debe asumir.

Para modificar el escalado de un eje (sea un Drive o un MasterEncoder) de forma Online existe un bloque denominado SMC_ChangeGearingRatioEncoder y un ejemplo de su uso lo podemos observar en la siguiente sección de código:

En el ejemplo anterior se desean utilizar dos encoders externos del mismo número de pulsos, 1024, (4096 flancos) pero el primero conectado a una rueda medidora de 100mm de desarrollo y el segundo a una de 200mm.

La sección de código mostrada realiza las siguientes operaciones:

1. Tenemos dos variables tipo bolean, bOrdenRatioAlto y bOrdenRatioBajo, que utilizaremos para cargar un ratio u otro sobre la variable iRatio la cual se lleva al bloque anteriormente mencionado.

2. Mientras bOrdenRatioAlto y bOrdenRatioBajo permanecen a nivel FALSE (no deseamos modificar el ratio) se va copiando la posición actual de la línea, contenida en la variable Pos_Linea, sobre una variable auxiliar llamada AuxPosLinea, en el momento de ordenar un cambio de ratio esta copia deja de producirse.

3. Tras la modificación del ratio el bloque SMC_ChangeGearingRatioEncoder pone a TRUE su salida bDone y tras un pequeño retardo configuramos la posición actual de la línea a la previamente memorizada.

NOTA : El bloque SMC_ChangeGearingRatioEncoder modifica la posición actual de la línea según el escalado utilizado: Si nos encontramos, por ejemplo, en la cota 45mm con el ratio equivalente al perímetro de 100mm tras modificar al equivalente a 200mm, curiosamente, la posición actual de la línea pasa a ser 90mm. Por esta razón, y para evitar que el cambio de ratio afecte a la posición actual, se aconseja la estructura de programa anterior.

www.infoPLC.net



6.6.- Las macros Las macros son una herramienta que permiten reutilizar código en diferentes partes del programa de una forma autónoma y ahorrando recursos a Motion Pro ya que al contrario de lo que ocurre con un bloque de funciones una macro, en realidad, no es más que un puntero a una zona de memoria donde se encuentra el código que ejecuta. Si la macro se utiliza dos veces los recursos empleados no son el doble ya que no se repite el código involucrado disminuyendo así la carga de programa. También se suelen utilizar, aunque ese no es su cometido principal, para organizar el programa y ayudar en su mantenimiento del programa.

6.6.1.- Creación de un bloque de funciones Todo empieza creando un bloque de funciones pensado para ser usado de forma general:

1. Hacemos clic con botón derecho en carpeta Módulos y escogemos opción Insertar Objeto.

2. Creamos un nuevo módulo tipo Bloque de funciones de nombre Sub_PowerON y tipo de lenguaje de programación el CFC:

www.infoPLC.net



3. Podríamos crear una carpeta para agrupar todos los bloques de funciones que vayamos creando. En este caso se ha creado una llamada Funciones y se ha arrastrado dentro el Bloque de funciones Sub_PowerON.

4. Realizamos doble clic sobre Sub_PowerON para proceder a editarlo. Observar como al ser un bloque de funciones son necesarios una serie de parámetros de entrada, de salida e internos.

5. Un programa CFC (y la definición de variables empleadas) podría ser, por ejemplo, el siguiente:

www.infoPLC.net



6. Tras finalizar la programación ya disponemos de un nuevo bloque de funciones que podremos llamar desde cualquier parte del programa. A todos los efectos el nuevo bloque de funciones tendrá el siguiente aspecto tras ser incorporado en nuestro programa (lenguaje CFC).

6.6.2.- Creación de una macro Tras crear un bloque de funciones ya podríamos utilizarlo dentro de una macro. Las macros, una vez creadas, pueden ser utilizadas cuantas veces sea preciso en cualquier parte del programa. Para la creación de una macro se aconsejan seguir los siguientes pasos:

1. Creamos un bloque de funciones cualquiera sobre la superficie de programación. Por ejemplo un bloque AND.

2. Pulsamos con el botón derecho sobre dicho bloque y escogemos la opción Crear Macro.

www.infoPLC.net



3. El bloque AND quedará incluido en una nueva macro cuyo nombre, por defecto, es MACRO.

4. Ahora renombramos la Macro recién creada y le damos el nombre de Iniciar_Ejes. Podemos ver qué contiene la macro (y editar su contenido) con tan sólo hacer clic con el botón derecho del ratón y escoger la opción Saltar a Macro.

NOTA: Expandir macro quiere decir Destruir Macro, es decir, todo lo que se encuentre dentro de la Macro se extraerá fuera de ella y quedará como si fuera una sección de código normal dentro de la zona de programación.

5. Una vez hemos “Saltado” dentro de la Macro podremos ver que su contenido es precisamente el bloque que hemos utilizado para crear la Macro. Nos quedaremos en esta vista y modificaremos su contenido sustituyendo el bloque AND por la siguiente sección de código:

www.infoPLC.net



Observar que la sección de programa hace uso de dos instancias al bloque de funciones Sub_PowerON creado anteriormente (en el apartado anterior). Por lo demás la macro dispone de dos salidas indicando cuando los dos ejes (Axe_X y Axe_Y) han finalizado su búsqueda de home (Homes_Ok) y cuando ambos se encuentran listos para ser utilizados (Drives_Ok). Para extraer información de una Macro se ha utilizado una simbología nueva: Que como vemos tiene un aspecto redondeado. Para añadir una salida de macro tan sólo se ha de emplear el icono correspondiente de la barra de herramientas:

Si se necesita, como se observa en la imagen anterior, es posible también añadir entradas a la Macro.

6. Una vez creada la macro podemos salir de ella para observar su aspecto externo. Para ello sólo es preciso realizar clic con el botón derecho sobre la zona de programación y escoger la opción Un nivel de Macro Atrás (porque en nuestro caso sólo hemos creado un nivel):

Crear Macro

Entrada a Macro

Salida de Macro

www.infoPLC.net



7. La Macro totalmente acabada quedaría del siguiente modo:

Aunque parezca un bloque de funciones en realidad una macro es como un puntero direccionado a una agrupación de ellos de manera que en realidad esta agrupación sólo existe una vez en memoria. Si se repite la macro en 10 zonas distintas de programa no se consumen 10 veces más recursos ya que una macro no es un conjunto de código sino un puntero a un conjunto de código (a lo sumo necesitaremos los recursos que Codesys necesite para realizar 10 llamadas a la misma zona de memoria donde se encuentra la sección de código utilizada por la macro).

www.infoPLC.net



7.- PRIMER PROGRAMA SIMPLE 7.1.- Creación Programa Principal Se supone conocimientos básicos de Motion a nivel de movimientos monoeje. En el presente ejemplo se realizará un simple movimiento absoluto hacia una cota determinada, para ellos se efectuará una búsqueda de home y posteriormente un posicionado.

Si se han seguido todos los pasos explicados durante el capítulo 1 el entorno tendrá definido un primer objeto vacío llamado PLC_PRG colgando de la carpeta MODULOS dentro del NAVEGADOR DE PROGRAMAS: Este objeto, cuyo contenido se pude ver realizando un doble clic sobre su nombre: PLC_PRG, se considerará el contenedor del programa principal de la aplicación. Es posible cambiar su nombre, si así se desea, con tan sólo situar el cursor del ratón sobre el nombre PLC_PRG, pulsar el botón derecho del ratón y escoger la opción Cambiar nombre del objeto… de hecho, y para tenerlo más claro, cambiaremos el nombre de PLC_PRG a Principal. Se ha de considerar este objeto, denominado ahora Principal, como contenedor del núcleo de programa de la aplicación. Para que este objeto pase a considerarse como el núcleo principal de la aplicación primero debe ejecutarse cíclicamente y para ello debe definirse una tarea que lo vaya llamando a cada ciclo de scan del Lexium Controller. Por tanto, el siguiente paso es crear una tarea que vaya llamando al objeto Principal de forma cíclica.

Para crear una nueva tarea seleccionamos el Navegador de Recursos y realizamos un doble clic sobre “Configuración de tareas”

www.infoPLC.net



Se abrirá a la derecha del Navegador de Recursos una nueva ventana con un árbol cuya raíz se denominará Configuración de tareas donde, de momento, sólo existe un objeto colgando denominado Evento del sistema. Llevamos el cursor sobre el texto Configuración de tareas y mediante la pulsación del botón derecho seleccionamos la opción Anexar Tarea.

Aparecerá un nuevo cuadro de diálogo donde daremos nombre a la nueva tarea llamándola TareaPrincipal configurando su llamada mediante eventos externo. El evento que llamará a la nueva tarea será el ciclo de scan del Lexium Controller. Acto seguido se llevará el cursor sobre el icono de la tarea TareaPrincipal y tras hacer clic con el botón derecho se seleccionará la opción Anexar Llamada de programa. El programa que se llamará será precisamente el programa principal creado anteriormente y que se llamó Principal.

De esta forma ya tenemos creado un objeto denominado que contendrá el programa principal de la aplicación el cual será llamado cíclicamente a cada ciclo de posicionado del controlador. Dentro de este objeto, llamado Principal, es donde se deberá de escribir el programa que gobernará la aplicación a realizar.

Abrirá un listado de Programas

Disponibles

www.infoPLC.net



7.2.- Declaración del eje a controlar Antes de iniciar el desarrollo del programa falta por definir cuantos ejes controlará el Lexium Controller para ellos debemos dirigirnos al icono de Configuración de Mando dentro del Navegador de Recursos y hacer doble clic sobre él. Con esto aparecerá una nueva ventana a la derecha mostrando, mediante árbol desplegable, un resumen del contenido hardware de la aplicación, por el momento únicamente el Lexium Controller con las entradas y salidas digitales que lleva de serie.

De forma parecida a como se ha hecho a la hora de crear una nueva tarea nos situaremos con el cursor sobre el icono de la raíz del árbol Lexium Controller V01 y haremos clic con el botón derecho seleccionando Anexar Subelemento y luego BusInterface.

www.infoPLC.net



De esta forma se añadirá al árbol de recursos hardware un nuevo componente denominado BusInterface y que viene a representar el vínculo entre el controlador Lexium Controller y una posible red de accionamientos controlados por bus CANSync. Una vez añadido el componente BusInterface se ha de indicar que el bus será controlado por un Lexium Controller por lo que modificaremos la opción Controlador de accionamiento a Lexium Controller Motion Bus.

Ahora falta especificar que lo que cuelga de este bus de campo es un conjunto de accionamientos (a pesar de que en el presente ejemplo sólo se controlará un único accionamiento). Hacemos clic con el botón derecho sobre el icono BusInterface y seleccionamos Anexar AxisGroup con lo que aparecerá una nueva ventana donde vincularemos este grupo de ejes con la tarea que se ha creado anteriormente TareaPrincipal, es recomendable añadir como tiempo de ciclo 4000 us (tiempo adecuado para controlar hasta 4 ejes). Por lo demás el número de nodo local (el Lexium Controller) puede dejarse a 0, la velocidad de comunicaciones del bus CANSync a 500Kbaud (a menos que sea estrictamente necesario no se recomienda utilizar la máxima velocidad de comunicaciones ya que suele restringir bastante la longitud del cable de comunicaciones así como el número máximo de nodos) y el generador de pulsos de sincronismo en PLC.

www.infoPLC.net



Por último hay que añadir algún eje al grupo de ejes recién creado. Para ello volvemos a realizar clic con el botón derecho sobre el icono AxisGroup y seleccionamos Anexar Drive. Aparecerá una nueva pantalla para configurar dicho nuevo eje:

En esta pantalla se puede definir el escalado del nuevo eje, es decir, cuantos pulsos de encoder son necesarios para desplazar el elemento que mueve el motor una medida determinada. Como se va a trabajar a eje libre lo que haremos será definir cuantos pulsos son necesarios para desplazar 360 grados de eje de motor (de esta forma la unidad básica de medida será el grado).

www.infoPLC.net



Los parámetros más importantes son los siguientes: Drive ID: Nodo de la red CAN Tipo: Permite definir como se comportará el eje. Si se define como rotatorio el indicador

de posición actual se reseteará cada vez que se sobrepase un valor determinado prefijable (se trabajará con el módulo de la posición actual con la prefijada mientras que si se define como lineal se considerará el desplazamiento en pulsos sin realizar el módulo (situación más común).

Incrementos: Número de pulsos generados por el encoder de motor en una revolución, siempre son 131072

Unidades Softmotion: Que desplazamiento efectivo realiza la carga cuando el eje se ha desplazado el número de pulsos introducido en Incrementos. Como queremos trabajar en grados se configurará a 360.

Valores Máximos: Como su nombre indica permite ajustar velocidades y rampas de aceleración o deceleración máximas. Dejaremos los valores por defecto.

Por ello la pantalla debería quedar del siguiente modo:

A: Número de nodo, debe corresponder con el nodo CAN del drive que utilizaremos B: Número de pulsos generados durante una revolución de motor. No importa el motor que se emplee, el

valor siempre es de 131072 porque el Lexium Controller trabaja internamente con una resolución de 17 bits (2^17=131072).

C: Unidades que se desplazará la carga física. Como vamos a trabajar a eje libre (sin carga) y queremos trabajar en grados se configura a 360. Esto quiere decir que cuando el Lexium Controller cuente 131072 pulsos de encoder se considerará a efectos de unidades de usuario que se ha girado 360 grados. Todas las unidades de desplazamiento serán, a partir de este momento, en grados.

Se le cambia el nombre al eje para identificarlo mejor

A

B

C

www.infoPLC.net



7.3.- Programa habilitación y movimiento absoluto Si se han seguido los puntos anteriores ya podemos empezar a realizar nuestro primer programa. Para ello se intentará habilitar el eje y llevarlo en control de posición de un punto a otro. Volvemos al entorno de programación haciendo clic sobre la pestaña del “Navegador de Programas” y luego un doble clic sobre el programa “Principal”

Tras hacer doble clic sobre el único programa existente “Principal” aparecerá el entorno de programación de ese programa que, como se ha definido en lenguaje CFC, tiene una apariencia similar a la mostrada en la figura anterior. Así, bajo lenguaje CFC, tenemos en la barra superior de herramientas un conjunto de botones para la utilización de bloques de funciones. Para crear nuestro primer bloque tan sólo es preciso realizar un simple clic sobre el tercer icono empezando por la izquierda y luego hacer un clic sobre el “Área de programación” por defecto aparecerá el bloque de una puerta AND. Un camino más rápido es pulsar CTRL+B con el cursor situado sobre el “Área de programación”.

www.infoPLC.net



Como este bloque no nos interesa hacemos clic sobre su nombre y pulsamos la tecla F2. De este modo se abrirá el navegador detallado de bloques disponibles. Se recomienda desactivar la opción “Representación estructurada” pues de ese modo se obtiene un listado completo de los bloques disponibles y es mejor para realizar una búsqueda visual. El bloque que ahora mismo nos interesa se llama MC_POWER y se encuentra dentro de la colección de bloques de funciones estándar. Una vez seleccionado se pulsa el botón Aceptar. El anterior bloque AND quedará automáticamente sustituido por el bloque MC_POWER cuyo cometido es situar al Lexium 05 en estado de RUN. Hacemos clic sobre los interrogantes en rojo de la parte superior del bloque y le daremos como nombre, por ejemplo, RUN_EjeControlado. Pulsamos la tecla Enter y nos aparecerá un cuadro llamado “Declaración de variables”

En este caso, las opciones por defecto ya nos van bien (por lo general las opciones por defecto a la hora de renombrar un bloque ya nos van bien siempre). Pulsamos sobre el botón Aceptar.

www.infoPLC.net



Ahora es necesario activar las entradas Enable, bRegulatorOn y bDriveStart del bloque de funciones para que el Lexium05 que controla el motor se sitúe en estado de RUN. Para este cometido es necesario conectar una variable de entrada hacia dichas entradas del bloque de funciones. Podemos sin embargo utilizar como variable de entrada una constante de valor TRUE de modo que al arrancar el programa automáticamente el Lexium05 se sitúe en RUN. Para añadir una variable de entrada podemos hacer clic sobre el icono que representa la entrada a un bloque o bien pulsar CTRL+E.

Hacemos clic sobre los interrogantes y tecleamos TRUE. Posteriormente hacemos clic sobre el rabito del icono de entrada y sin soltarlo lo intentamos conectar con el rabito situado como entrada Enable del bloque MC_POWER. Volvemos ha hacer clic sobre el rabito del icono de entrada y lo conectamos a la entrada bRegulatorOn y finalmente repetimos la operación con la entrada bDriveStart. Si se ha realizado la operación descrita de forma correcta deberemos tener el siguiente bloque con las siguientes conexiones: Ahora se le ha de decir al bloque que eje deseamos situar en RUN. Volvemos a crear una entrada pero esta vez en lugar de hacer que sea una constante de valor TRUE tecleamos el nombre del eje que hemos previamente definido. Conectamos esta variable en la entrada Axis. Ahora vamos a añadir un nuevo bloque para realizar el posicionamiento propiamente dicho. El bloque a introducir es el MC_MOVEABSOLUTE y le daremos el nombre de Mover_EjeControlado.

www.infoPLC.net



Para dar la orden de moverse, de dirigirse a la cota deseada, utilizaremos una variable de entrada. Creamos por tanto una variable de entrada que conectaremos a la entrada Execute del bloque. A esta variable de entrada la llamaremos IR y tras introducir su nombre sobre el icono que representa una entrada y pulsar la tecla Enter se nos preguntará de qué tipo queremos que sea:

Si en el cuadro de declaración de variables aparecido tras pulsar la tecla Enter no aparece el tipo de variable deseado siempre es posible desplegar de nuevo el cuadro de Tipos estándar y escogerla a mano. Si recordamos de memoria cual es el tipo adecuado lo podemos escribir a mano en lugar de buscarlo.

www.infoPLC.net



Repetimos la operación con otra entrada que servirá para contener la posición deseada la cual conectaremos en la entrada Position del bloque de funciones a la que llamaremos Deseada y que definiremos como REAL. Para las entradas Velocity, Acceleration y Deceleration utilizaremos constantes de valor 1000, 1000, 1000. En la entrada Axis evidentemente añadiremos el eje que tenemos EjeControlado. El bloque correctamente finalizado tendría el siguiente aspecto: NOTA: La velocidad se expresa en unidades/segundo. Esto quiere decir que el eje, caso que llegue a la velocidad indicada girará a 1000 grados / segundo. Como las rampas de aceleración y deceleración se expresan en grados / segundo2 vemos que en realidad configurar las rampas a 1000 (igual que el valor de la velocidad) hace que el eje invierta 1 segundo en llegar desde 0 hasta la velocidad especificada (aceleración) y 1 segundo en llegar desde la velocidad especificada hasta 0 (deceleración). Para conocer el valor de la velocidad en RPM hemos de aplicar esta simple fórmula:

( ) 67,166min1

60

360

Re11000 =××=

seg

grados

v

seg

gradosRPMV

Por último añadiremos un último bloque cuyo cometido será leer la velocidad actual de eje. Simplemente para tareas de monitorización. El bloque a utilizar es el MC_ReadActualVelocity y le daremos como nombre MON_EjeControlado, activaremos la entrada Enable siempre a TRUE y especificaremos EjeControlado como eje sobre el que se desea leer la velocidad. Finalmente crearemos una variable de salida de nombre VelocidadActual y de tipo REAL.

www.infoPLC.net



7.4.- Compilación y Transmisión programa. Si todo se ha realizado correctamente podemos proceder a enviar el programa. Para el envío de programa se ha de haber declarado previamente de que manera se establecerá comunicación con el Lexium Controller (ver capítulo 3). Vamos al menú superior “En Línea” y seleccionamos “Inicio de sesión”. Automáticamente el programa se compilará y enviará. Si en el proceso de compilación se detecta algún error el envío será cancelado.

www.infoPLC.net



Una vez enviado el programa éste debe ejecutarse, para ello hemos de seleccionar la orden “Inicio” del menú superior “En Línea” o bien pulsar la tecla F5. Con ello el programa que tengamos escrito pasará a ejecutarse.

www.infoPLC.net



7.5.- Resumen de conceptos y consejos Teclas rápidas:

Con el nombre del bloque seleccionado (hacer un único clic sobre él) pulsar F1 para obtener ayuda (una descripción del bloque) o bien F2 para desplegar un listado de los posible bloques existentes.

Si situamos el cursor sobre una entrada o salida de un bloque y no lo movemos durante un rato aparecerá una pequeña descripción de dicha entrada o salida indicándonos el tipo de variable que se acepta (INT, REAL, BOOL, Etc) y las unidades en que trabaja dicha entrada (ms, s, u/s, u/s2, etc) Entorno en Inglés Entorno en Castellano CTRL+B CTRL+B : Añadir Bloque CTRL+I CTRL+E : Añadir Constante o Variable de Entrada CTRL+U CTRL+A : Añadir Variable de Salida Estando con el programa en RUN podemos modificar el valor de las variables haciendo doble clic sobre ellas e introduciendo el nuevo valor. Este cambio no tendrá validez hasta que pulsemos CTRL+F7 de modo que es posible modificar el valor de 1 o más variables de forma simultánea. Conceptos: La velocidad siempre se expresa en Unidades / Segundo Las aceleraciones y deceleraciones siempre se expresan en Unidades / Segundo2 Por lo general los bloques que disponen de una entrada de activación del tipo ENABLE responden a señales de nivel mientras que las que disponen de una entrada de activación del tipo EXECUTE responden a señales de flanco de subida.

www.infoPLC.net



8.- El CNC y la Interpolación Motion Pro pone a disposición del usuario una serie de herramientas para facilitar la creación de formas bidimensionales sobre el plano XY bien mediante el uso directo de códigos G bien bajo un cómodo entorno gráfico donde es posible dibujar, como si de un programa de CAD se tratara, la forma deseada. Aunque es posible controlar hasta 8 ejes (X, Y, Z, P, Q, U, V, W) únicamente dos de ellos pueden realizar una interpolación bidimensional. Así, si se programa una interpolación lineal, circular, parabólica, elíptica o tipo spline, el resto de ejes sólo pueden realizar movimientos lineales independientes (acercar herramienta en Z, girar torno, girar cargador herramientas, etc) El lenguaje utilizado es compatible con el estándar DIN66025 si bien únicamente se han incorporado algunas de las instrucciones preparatorias.

8.1.- Estructura de un programa CNC Un programa CNC bajo entorno Motion Pro se constituye por una serie de sentencias (líneas de programa) cada una de las cuales se forma mediante el uso de una serie de instrucciones. La primera sentencia debe empezar obligatoriamente por la instrucción “%”. Este signo indica inicio de programa y puede o no estar seguido por el nombre del programa. Si se añade un nombre de programa este debe encontrarse separado de la instrucción % por un espacio o tabulación. A partir de la primera sentencia se dispondrán línea a línea las sentencias que compondrán el programa CNC compuestas a su vez por una serie de instrucciones. Las instrucciones se encuentran formadas por una letra (identificador de instrucción) seguida de un número (ej. G01). No importa si se usan mayúsculas o minúsculas o si se añaden más o menos ceros entre el número y el identificador de la instrucción (G01=g1). La primera instrucción de cada sentencia debería ser el número de línea (N<número>), por ejemplo “N01”, y aunque a efectos internos no se usa se sugiere su empleo por razones de compatibilidad. Las diferentes instrucciones de cada sentencia deben encontrarse separadas por un espacio o por un tabulador e internamente se ejecutan de izquierda a derecha. Cada sentencia únicamente puede contener una instrucción de posicionado situado inmediatamente después de la instrucción de número de línea. Si no se introduce una instrucción de posicionado en alguna sentencia automáticamente se añadirá la de la anterior sentencia. Cada instrucción de posicionado puede ser vista como un tramo de la trayectoria (línea, arco, …). Los parámetros de velocidad o rampas se relacionan con los tramos interpolados y no con los eje que forman dicha interpolación: Si imaginamos el desplazamiento de un punto a otro como un triángulo rectángulo siendo los desplazamientos en X e Y los catetos y la hipotenusa el tramo resultante la velocidad o rampas serán las del movimiento combinado de ambos ejes X e Y, es decir, en la hipotenusa. La velocidad durante la transición de dos tramos adyacentes se determina por las siguientes reglas:

• Uno de los tramos es un posicionamiento (G0x) y el otro no: Velocidad de transición=0

• El ángulo entre las tangentes de los dos objetos en la transición es mayor que la tolerancia del ángulo: Velocidad de transición=0

• En cualquier otro caso: La velocidad de transición es la menor de las velocidades de los dos tramos involucrados.

Básicamente una instrucción de posicionado ejecuta una interpolación desde la posición destino del anterior posicionado hasta la posición destino de la actual instrucción de posicionado. La primera instrucción de posicionado tiene lugar desde la posición especificada como origen (en el CNC-Editor). Si la posición no ha sido definida se empezará desde la posición X=0, Y=0, Z=0. Es posible establecer la posición mediante la instrucción G92 tanto al principio como a mitad de programa CNC.

www.infoPLC.net



8.2.- Identificadores Como se ha comentado en el capítulo precedente existen una serie de identificadores utilizados para componer una instrucción. A continuación se listan los identificadores compatibles con Motion Pro:

ID Descripción D Radio herramienta para instrucciones de corrección de herramienta (G40-G42) o

Suavizado de trayectoria (G50/G51) o Valor de la variable a modificar (G36/G37).

E Máxima Aceleración (>0)/ Deceleración (<0) trayectoria en unidades/seg2 F Velocidad trayectoria en unidades/seg G Instrucción Preparatoria (ver siguiente tabla) H Activar Switch Point (>0), Desactivar Switch Point (<0) I Coordenada X del centro de un círculo o elipse (G02/G03/G08/G09) o

Coordenada X de una parábola, tangente, intersección, punto J Coordenada Y del centro de un círculo o elipse (G02/G03/G08/G09) o

Coordenada Y de una parábola, tangente, intersección, punto K Dirección del trazado de una elipse en sentido matemático (0º O, 90º N, …) o

Condición de salto (G20) o Valor del parámetro dT1 (funciones M)

L Posición absoluta activación Switch Point (ver identificador H) medida desde la posición de inicio (>0) o final del tramo (<0) o Condición de salto (G20) o Valor del parámetro dT2 (funciones M)

M Función N Número de secuencia. O Proporción de trayectoria recorrida para activación Switch Point (ver identificador H) de 0 a 1

(número real) o Variable a modificar (G36/G37) Estructura datos para funciones M

P Posición destino del eje adicional P Q Posición destino del eje adicional Q R Radio (G02/G03) – alternativamente a “I”, “J” o relación longitud eje menor / eje mayor (G08/G09) S Activar (>0) o Desactivar (<0) rampas en S

3: Eje Z, 7: Eje P, 8: Eje Q, 9 Eje U, 10: Eje V, 11: Eje W U Posición destino del eje adicional U V Posición destino del eje adicional V W Posición destino del eje adicional W X Coordenada X de la posición destino Y Coordenada Y de la posición destino Z Posición destino del eje adicional Z

www.infoPLC.net



8.3.- Instrucciones preparatorias G No todas las instrucciones preparatorias de la norma DIN66025 se encuentran implementadas y algunas de ellas son específicas para la Lexium Controller. A continuación se listan las instrucciones preparatorias disponibles (las instrucciones en negrita son estándar): Instrucción Descripción

G00

Movimiento de posicionado rápido utilizado para mover los ejes rápidamente entre cortes, cambios de herramienta, etc. Debe levantarse la herramienta antes de ejecutar un movimiento de este tipo.

G01

Interpolación Lineal. Se usa para eliminar material mediante el movimiento de los ejes en direcciones rectas a lo largo o a través del material.

G02

Interpolación Circular en sentido horario. La descripción de una interpolación circular puede realizarse de dos formas: Especificando el radio o bien el centro.

NOTA: No es posible definir por radio un arco de ángulo igual o superior a 180º ya que al realizar una definición por radio siempre son posibles dos caminos (uno corto y otro largo). El sistema siempre cogerá el arco más corto.

G03

Interpolación Circular en sentido anti-horario. Para más detalles ver descripción instrucción G02

G05

Punto intermedio de un tramo Spline (los extremos corresponderán con la posición final del anterior tramo y el inicial del siguiente).

Arco definido por su radio N10 G00 X20 Y20 F50 N40 G01 X50 Y20 H4 N50 G02 X35 Y05 R15 N60 G01 X20 Y05 N70 G01 X20 Y20 N80 G00 X0 Y0

Arco definido por su centro (valores incrementales) N10 G00 X20 Y20 F50 N40 G01 X50 Y20 H4 N50 G02 X35 Y05 I-15 J0 N60 G01 X20 Y05 N70 G01 X20 Y20 N80 G00 X0 Y0

www.infoPLC.net



G06

Interpolación parabólica. Para describir una parábola son necesarios las coordenadas del punto final (X/Y) así como las coordenadas del punto máximo de la parábola (I/J)

G08

Interpolación elíptica en sentido horario. Para describir una elipse son necesarios las coordenadas del punto final (X/Y), el centro (I/J), el ángulo del eje principal de la elipse (K) y el ratio entre el eje principal y el (R).

G09

Interpolación elíptica en sentido anti-horario.

G20

Efectúa un salto condicional a la línea L si K es distinto de cero. Ver siguiente sección de programa y su descripción para entender el concepto

G36 Permite modificar el valor de variables globales. Por ejemplo, si deseamos ejecutar la instrucción cAlto:=35 desde programa CNC deberíamos insertar una sentencia en el programa que rece así: N010 G36 O$cAlto$ D35

G37

Permite incrementar o decrementar el valor de variables globales. Por ejemplo, si deseamos ejecutar la instrucción cAlto:=cAlto-10 desde programa CNC deberíamos insertar una sentencia en el programa que rece así: N010 G37 O$cAlto$ D-10

N1000 G36 O$contador$ Contador:=5; N1010 G1 X100 F100 E100 E-100 Desplazamiento a cota X=100 N1020 G1 X0 Desplazamiento a cota X=0 N1030 G37 O$contador$ D-1 Contador:=Contador-1; N1040 G20 L1010 K$contador$ Si Contador es distinto de 0 salto a línea 1010

N10 G00 X100 Y100 N15 G98 N20 G08 X200 Y100 I150 J100 K45 R0.5

N0 G00 X20 Y20 F60 E600 E-600 N10 G01 Y40 N20 G06 X70 Y40 I60 J60

www.infoPLC.net



G40

Cancela cualquier compensación de herramienta previa (ver G41 / G42).

G41

Aplicación una compensación debida al grosor de la herramienta a la izquierda del sentido de corte. Esta característica permite que la superficie terminada de la pieza de trabajo sea el camino de la herramienta programado, y la herramienta será automáticamente desplazada a la izquierda de este camino por una distancia igual a su radio.

Sin corrección Aplicando Corrección herramienta con radio 5 unidades (G41 D05) hacia la izquierda del sentido de corte NOTA: Ver función SMC_ToolCorr

G42

Aplicación una compensación debida al grosor de la herramienta a la derecha del sentido de corte. Esta característica permite que la superficie terminada de la pieza de trabajo sea el camino de la herramienta programado, y la herramienta será automáticamente desplazada a la derecha de este camino por una distancia igual a su radio.

Sin Corrección Aplicando Corrección herramienta con radio 5 unidades (G42 D05) hacia la derecha del sentido de corte. NOTA: Ver función SMC_ToolCorr

www.infoPLC.net



G50

Finaliza las funciones suavizado / redondeado

G51

Esta función permite activar el suavizado de los ángulos de una trayectoria. Esto puede ser útil en aquellas aplicaciones donde la exactitud de la trayectoria no es tan importante como la velocidad a la que debe seguirse ya que para seguir un camino anguloso a veces es preciso que uno de los ejes deba pasar por velocidad 0 entre un tramo de trayectoria y otro. Por ello la instrucción G51 debe ir unida a una instrucción D que especifique el radio de suavización desde el punto de intersección de los dos tramos que crean el ángulo. Para este propósito se traza un arco de radio determinado tomando como centro el punto de unión de los dos tramos que forman el ángulo y se añade un spline. Un ejemplo de programa podría ser el siguiente:

NOTA: Ver función SMC_SmoothPath

G52

Esta función permite activar el redondeado de los ángulos de una trayectoria. La filosofía es prácticamente idéntica a la de la función G51 sin embargo con la función G52 la suavización tiene lugar no con una curva tipo spline sino con arcos de círculo.

Es importante observar como a diferencia del suavizado a base de splines el basado en arcos sólo toma, como máximo, el 50% del tramo involucrado. En el ejemplo se ha redondeado utilizando la función N10 G52 D25 pero cada lado mide 40 por tanto el primero de ellos (izquierdo) sólo puede coger 20 y no 25 como radio de curvatura. Como se ha cogido 20 el siguiente lado (superior) sólo dispone de una parte recta de 20 por lo que se coge la mitad, 10, como radio de curvatura, eso deja al lado derecho con 30 como longitud efectiva por lo que el tercer lado redondeado utilizará un radio de 15. NOTA: Ver función SMC_RoundPath

N0 G51 D10 N10 G01 X50 Y0 F50 E30 E-30 N20 G01 X0 Y10 N30 G01 X0 Y0 N40 G50

Trayectoria Original Trayectoria suavizada Trayectoria suavizada con tramos en ángulo. mediante splines (ver mediante arcos. función G51)

www.infoPLC.net



G60

Fin de la función impedir bucles.

G61

Esta función permite activar el filtrado de la trayectoria de forma que no pueden procesarse aquellas en las que el camino puede formar un bucle bien por un mal diseño bien por el radio de la herramienta.

Observar como en la figura de en medio se produce un bucle debido a que el radio de la herramienta obliga a pasar por partes que no deben ser tratadas. En la figura de la derecha, con el filtrado de bucles activado, se ve como se elimina la posibilidad de que la herramienta trabaje en zonas de la pieza no permitidas (a pesar de ello la pieza tampoco quedará bien porque no se cortará como se diseñó pero siempre se puede utilizar una herramienta de menor radio para acabarla correctamente sin tener que tirarla directamente) NOTA: Ver función SMC_AvoidLoop

G90

Se inicia la interpretación de coordenadas para los ejes X/Y/Z/P-W como valores absolutos.

G91

Se inicia la interpretación de coordenadas para los ejes X/Y/Z/P-W como valores relativos.

G92

Cambia la posición actual por la introducida sin desplazar la herramienta. Se utiliza para cambios en el punto de referencia.

G98

Se inicia la interpretación de las coordenadas I/J como valores absolutos. Por ejemplo para el ejemplo descrito en la descripción de la instrucción G02 podemos definir las coordenadas referentes al centro del arco como absolutas del siguiente modo:

Absoluto N10 G00 X20 Y20 F50 N40 G01 X50 Y20 H4 N45 G98 N50 G02 X35 Y05 I35 J20 N60 G01 X20 Y05 N70 G01 X20 Y20 N70 G00 X0 Y0 N80 M30

Trayectoria sin activar el Trayectoria sin activar el Trayectoria con el filtrado de bucles y con filtrado de bucles y con filtrado de bucle corrección de herramienta corrección de herramienta activado y con corrección de 2 unidades de 5 unidades de herramienta de 5 unidades.

www.infoPLC.net



G99

Se inicia la interpretación de las coordenadas I/J como valores relativos al punto actual (configuración por defecto). Por ejemplo para el ejemplo descrito en la descripción de la instrucción G02 podemos definir las coordenadas referentes al centro del arco como relativas del siguiente modo:

Incremental N10 G00 X20 Y20 F50 N40 G01 X50 Y20 H4 N45 G99 N50 G02 X35 Y05 I-15 J0 N60 G01 X20 Y05 N70 G01 X20 Y20 N70 G00 X0 Y0 N80 M30

www.infoPLC.net



8.4.- Funciones M Las funciones son, por decirlo de algún modo, interrupciones al programa CNC para hacer algo. Existe una ligera normativa que hace que cierto número de estas funciones sean estándar, es decir, que todo fabricante de CNC utiliza las mismas para realizar lo mismo, sin embargo hay un gran número de ellas que dependen del fabricante. En nuestro caso son totalmente configurables pues no hay ninguna definición. El usuario deberá programar que es lo que quiere hacer con cada una de ellas. A título instructivo se listan algunas de las funciones M estándar utilizadas por un gran número de fabricantes:

M00 Parar Programa M01 Paro Opcional M02/M30 Fin de Programa M03/M04/M05 Control del eje de giro del soporte de la pieza en un torno (cw/ccw/stop) M06 Cambio de herramienta (M-code depends on PLC) M19 Orientación eje de giro M40-M46 Ratio reductor eje de giro

El concepto que hay que tener claro es que únicamente es posible activar una función M a la vez, no es posible activar dos funciones M de forma simultánea. El programa CNC en su flujo de funcionamiento llegará a una determinada sentencia donde se activará una marca y en ese punto el programa quedará totalmente detenido hasta que se le indique que la marca ha sido tratada adecuadamente. En una misma sentencia no pueden coexistir códigos G y funciones M. Las funciones M deben añadirse en una sentencia aparte. Si se desean utilizar las marcas se puede seguir el siguiente proceso:

1. Se crea un programa CNC que incluya una marca.

2. La marca quedará reflejada de forma gráfica mediante un punto sobre el trazado:

Una Marca determinada.

Marca específica de fin de programa.

Marca M08

Marca M30

www.infoPLC.net



3. Ya se puede arrancar el programa, cuando se ejecute la sentencia N35 M08 el trazado quedará detenido a la espera que se realice la tarea asignada a la marca M08. El bloque de funciones SMC_Interpolator (o similar) indicará 8 en su salida wM y esto servirá para ejecutar lo que tenga que ejecutarse. Cuando haya finalizado la operativa asignada a M08 se deberá activar la entrada bAcknM para que el programa CNC pueda proseguir.

NOTA: La primera línea de un programa CNC no puede ser una marca

www.infoPLC.net



8.5.- Puntos H o Switch Points A diferencia de las funciones M que detenían la ejecución del programa CNC los puntos H o Switch Points no detienen el programa sino que se activan o desactivan al llegar a una cota determinada. Disponemos de un total de 32 Switch Points que no dejan de ser los bits de la palabra que asignemos. Es posible tener más de uno o incluso todos activados. Se pueden activar de forma proporcional a la distancia recorrida. Veamos el siguiente ejemplo:

N10 G00 X20 Y20 F10 E50 E-50 N20 G01 X20 Y120 N30 G01 X70 Y120 N40 G01 X70 Y20 H1 O0.25 N50 G01 X20 N60 G00 X0 Y0

En el ejemplo anterior se activa el Switch Point 1 (H1) tras recorrer el 25% del trayecto (70,120) - (70,20). Pero también podemos activar el Switch Points del siguiente modo:

N10 G00 X20 Y20 F10 E50 E-50 N10 G00 X20 Y20 F10 E50 E-50 N20 G01 X20 Y120 N20 G01 X20 Y120 N30 G01 X70 Y120 N30 G01 X70 Y120 N40 G01 X70 Y20 H-2 L10 N40 G01 X70 Y20 H-2 L-10 N50 G01 X20 N50 G01 X20 N60 G00 X0 Y0 N60 G00 X0 Y0

En la sección de programa izquierdo se desactiva el Switch Point 2 (H-2) tras recorrer 10 unidades del trayecto (70,120) - (70,20) mientras que en la sección derecha lo hace cuando faltan 10 unidades para finalizar el mismo trayecto ya que se ha especificado como cota final un valor negativo (L-10). En cualquier de los casos se indica gráficamente la inclusión de cualquier Switch Point mediante un punto en verde (no se distingue ni el número ni si se activa o desactiva dicho Switch Point). La palabra que contiene los diferentes bits correspondientes a los 32 Switch Points puede obtenerse del bloque SMC_Interpolator (o similar) por la salida dwSwitches.

Activación/Desactivación de un Switch Point

www.infoPLC.net



8.6.- Elementos de Programación

8.6.1.- Librerías Necesarias Para trabajar con las características CNC que ofrece Motion Pro es necesario el uso de un par de librerías que añaden al entorno de programación una serie de bloques de funciones vitales para la ejecución de programas CNC. Las librerías de CNC mínimas para poder ejecutar en la práctica un programa CNC son las siguientes:

• SM_CNC_V1940.lib • SM_Trafo_V1940.lib

Las librerías pueden encontrarse en la carpeta:

C:\Schneider Electric\Motion Control\CoDeSys V2.3\Targets\Schneider Electric\Shared Files\Library\Motion Estas librerías incluyen gran cantidad de bloques de funciones relativos a funciones CNC pero sólo se describirán los más importantes. NOTA: Es también imprescindible, para la mayoría de opciones explicadas en este capítulo, que el firmware de la Lexium Controller sea el 1.1IE02_B2 o superior o de lo contrario funciones como la del cambio al vuelo de las dimensiones de una trayectoria no funcionarán.

8.6.2.- El SMC_Interpolator Este es el bloque de funciones más importante ya que se encarga de ejecutar un programa CNC extrayendo de él la referencia a aplicar a cada eje, gestiona otros elementos como Marcas o Switch Points, nos da información acerca de que línea del programa CNC se encuentra ejecutándose, permite pausar el programa CNC de varias formas, etc

www.infoPLC.net



Entradas bExecute: Evidentemente es la entrada que pone en funcionamiento el bloque, un flanco de

subida es suficiente. poqDataIn: Esta entrada sirve para indicarle al bloque que programa CNC deseamos ejecutar.

El programa CNC a ejecutar no puede introducirse tal como se redacta o diseña en el entorno a tal efecto (lista de códigos ISO) sino que debe transformarse previamente a una estructura denominada Outqueue. Hay varias formas de hacerlo: se puede indicar al compilador que lo haga automáticamente o bien podemos hacerlo por programa vía bloque de funciones SMC_NCDecoder. De cualquier modo en esta entrada se ha de especificar el puntero hacia dicha estructura Outqueue generada.

bSlow_Stop: Esta es una entrada de pausa externa con rampas. Se toman las rampas del tramo

que se encuentre ejecutando en ese momento. El programa continua su ejecución tan pronto esta entrada pasa a FALSE.

bEmergency_Stop: Parecida a la entrada anterior también es una entrada de pausa pero sin rampas. El

programa continua su ejecución tan pronto esta entrada pasa a FALSE. dOverride: Permite modificar ONLINE la velocidad de una trayectoria. Por defecto el valor de

esta entrada es 1 pero si por ejemplo se cambia a 0.5 o a 2.0 mientras los ejes interpolados se encuentran ejecutando una trayectoria estos modificarán inmediatamente su velocidad a la mitad o al doble de la programada.

dwIpoTime: Sirve para indicarle al bloque cada cuanto ha de calcular y entregar una nueva

referencia de posición a los drives remotos. Se suele indicar el mismo tiempo que se indicó al definir el tiempo de sincronización del AxisGroup y se recomienda introducir este valor mediante precisamente la variable que contiene ese información en lugar de hacerlo numéricamente (por si posteriormente modificamos un valor y nos olvidamos del otro). Utilizar la variable AxisGroup.dwCycle siendo AxisGroup el nombre del grupo de ejes utilizado.

bAbort: Aborta la ejecución del programa CNC en ejecución esté donde esté. Esta entrada

podría utilizarse a posteriori de la entrada bEmergency_stop para abortar la ejecución de un programa CNC después de detener de forma controlada todos los ejes involucrados.

bACKnM: Permite reanudar la ejecución de un programa CNC que se encuentra detenido por

encontrarse ejecutando una Marca. Es posible saber si el programa se encuentra ejecutando una Marca viendo si la salida wM del bloque es diferente de 0.

www.infoPLC.net



Salidas bDone: Nos indica que el bloque se encuentra en ejecución de forma adecuada, sin errores. bError: Nos indica que el bloque se encuentra en ejecución pero en error. wErrorID: Nos indica el número de error caso que se haya producido alguno. piSetPosition: Contiene la referencia de posición deseada para cada eje. iStatus: Nos indica en que estado se encuentra la ejecución del programa CNC. En la

siguiente tabla pueden verse los estados posibles así como el valor numérico de cada estado:

IPO_UNKNOWN 0 Estado interno que podría darse si no se refresca el bloque

SMC_Interpolator adecuadamente. IPO_INIT 1 Inicializando. El buffer interno del bloque aún no se ha

llenado completamente. IPO_ACCEL 2 Acelerando. IPO_CONSTANT 3 Desplazamiento a velocidad constante. IPO_DECEL 4 Decelerando. IPO_FINISHED 5 Finalizada la ejecución del programa CNC. No se ejecutará

ningún otro a menos que se reinicie la entrada bExecute. IPO_WAIT 6 A la espera debido a las siguientes situaciones:

Emergency_Stop = TRUE Slow_Stop = TRUE y Velocidad = 0 Wait_At_Next_Stop = TRUE y Velocidad = 0

bWorking: Esta salida es TRUE tan pronto se ha iniciado un movimiento pero aún no ha

acabado (corresponde con los estados IPO_ACCEL, IPO_CONSTANT, IPO_DECEL y IPO_WAIT) en el resto de casos es FALSE.

iActObjectSourceNo: Muestra la línea de programa CNC que se encuentra en ese momento

ejecutándose. Si bWorking se encuentra a FALSE (porque el interpolador no se encuentra trabajando) esta salida vale -1.

dwSwitches: Contiene el estado de los 32 posibles Switch Points. Esta salida proporciona una

variable de 32 bits (double Word) y cada bit indica el estado de cada posible Switch Point.

wM: Indica el número de Marca activa. Si existe alguna marca activa el programa

permanecerá detenido hasta que se reconozca dicha Marca activando la entrada bAcknM en cuyo momento la salida wM volverá a ser 0 y el programa proseguirá su ejecución.

www.infoPLC.net



8.6.3.- El SMC_Trafo_Gantry2 Este bloque transforma la estructura de consignas ofrecida por el bloque SMC_Interpolator a referencias individuales para cada eje. No tiene mayor misterio, debe interconectarse con el bloque SMC_Interpolator del siguiente modo:

www.infoPLC.net



8.6.4.- El SMC_ControlAxisByPos Este bloque es el encargado de enviar las coordenadas recibidas desde el bloque SMC_Trafo_Gantry2 hacia cada uno de los ejes. Además se dedica a gestionar a tiempo real cualquier discrepancia entre las posiciones y/o velocidades deseadas y las reales y, caso de existir, lo indica mediante la activación de la salida digital correspondiente y, si así lo deseamos, trata de ajustarse según ciertos parámetros. Entradas iStatus: Esta entrada debe encontrarse unida con la salida homóloga del bloque

SMC_Interpolator. bEnable: Habilitación del bloque. Debe encontrarse unida con la salida bWorking del bloque

SMC_Interpolator de modo que cuando éste se encuentre trabajando el bloque SMC_ControlAxisByPos también lo esté.

bAvoidGaps: Este bloque de funciones también ofrece la posibilidad de ir controlando cualquier

desviación entre la posición y/o velocidad real del eje y la que se supone debería tener (GAP) y puede proceder a corregirla. Al activar esta entrada se irá modificando la consigna de posición enviada desde SMC_Interpolator sumándole o restándole el error detectado. La aplicación de esta corrección tendrá lugar con la velocidad y rampas especificadas por las entradas fGapVelocity, fGapAcceleration y fGapDeceleration. Mientras se corrige la consigna (bStopIpo =TRUE) es necesario pausar el bloque SMC_Interpolator, activando la entrada bEmergency_Stop.

fSetPosition: Entrada principal de referencia. Esta entrada recibe la consigna de referencia

proporcionada por el bloque SMC_Trafo_Gantry2. fGapVelocity: Velocidad del GAP (ver bAvoidGaps) cuanto mayor más rápida será la corrección. fGapAcceleration: Rampa de aceleración del GAP (ver bAvoidGap) cuanto mayor sea más rápido se

alcanzará la velocidad nominal de GAP y por tanto más rápida será la corrección. fGapDeceleration: Rampa de deceleración del GAP (ver bAvoidGap) cuanto mayor sea más rápido

acabará la imposición del GAP y por tanto más rápida será la corrección. Axis: Eje a controlar.

Movimiento Original

Se añade un GAP al movimiento Original

Se resta un GAP del movimiento Original

www.infoPLC.net



Salidas bCommandAborted: Sucede cuando desde otra parte del programa se ejecuta una orden de movimiento

que anula la presente. bError: Se activa cuando por lo que sea el bloque detecta un fallo bien interno o bien de

posición. iErrorID: En caso de existir un error esta salida nos indica el código de error. bStopIpo: Se activa cuando el bloque intenta corregir cualquier desviación existente entre la

consigna de posición/velocidad deseadas y las reales del eje. Evidentemente tiene que encontrarse activada la entrada bAvoidGaps. Se recomienda llevar esta salida a la entrada bEmergency_Stop del bloque SMC_Interpolator para detener la emisión de consignas desde dicho bloque hasta que no haya acabado la corrección del GAP por parte del bloque SMC_ControlAxisByPos (bStopIpo=FALSE).

Se necesita un bloque del tipo SMC_ControlAxisByPos por cada eje a controlar y el esquema básico de interconexión con los dos bloques anteriores es el siguiente:

En este ejemplo vemos una estructura prácticamente idéntica a la que emplearíamos en la práctica. Se envía un puntero al programa CNC mediante el uso de la instrucción ADR que nos devuelve la dirección (puntero) donde se encuentra ubicado el programa (en realidad la estructura en formato Outqueue que lo contiene) y el ciclo del Motion Bus hacia el bloque SMC_Interpolator. La consigna ofrecida por este bloque se transforma en pares de consigna XY y se envía cada una a un bloque SMC_ControlAxisByPos gracias al bloque SMC_Trafo_Gantry2. Los bloques SMC_ControlAxisByPos tienen activada la corrección de GAPs aplicándose en dichas correcciones valores de velocidad y rampas elevados para minimizar el tiempo de la corrección y mientras esta tiene lugar tiene lugar un paro rápido en la emisión de nuevos valores gracias a la activación de la entrada bEmergency_Stop cuando alguno de los ejes tiene activada la salida bStopIpo señal de que se encuentra corrigiendo un GAP. Observar como los bloques SMC_ControlAxisByPos se habilitan cuando la salida bWorking del bloque SMC_Interpolator se encuentra a TRUE

www.infoPLC.net



8.7.- Creación de Trayectorias

8.7.1.- Herramientas de Diseño El entorno de programación Motion Pro dispone de varias alternativas de cada a desarrollar un programa CNC:

• Programando a mano el programa CNC. • Dibujando la trayectoria deseada en el editor gráfico disponible. • Dibujar la trayectoria deseada en un programa CAD e importarla posteriormente.

El primer paso sería por tanto la creación de un programa que contenga la trayectoria que se desea efectuar interpolando dos ejes. Toda esta operación tiene lugar desde el editor de programas CNC al cual se puede acceder de la siguiente forma:

1. Pulsar en pestaña Recursos 2. Hacer doble clic en opción Lista de programas CNC 3. Tras esto aparecerá el editor de programas CNC el cual tiene una apariencia similar a la mostrada por

la siguientes imagen:

Zona Programa CNC en lenguaje ISO.

Zona Diseño Gráfico Trayectoria Herramienta

www.infoPLC.net



A continuación crearemos un nuevo programa para ello seguiremos los siguientes pasos:

1. Seleccionaremos menú superior Programa CNC 2. Escogeremos la opción Nuevo Programa CNC

3. Mediante el cuadro de introducción de texto que aparecerá le daremos un nombre al nuevo programa que deseamos crear:

www.infoPLC.net



4. Tras crear el nuevo programa el aspecto que adquirirá el editor de programas CNC será el siguiente:

5. Ahora se ha de decidir de que forma crearemos la trayectoria XY deseada. Podemos crearla mediante uso de instrucciones preparatorias o bien gráficamente o una combinación de ambos. Nosotros lo haremos gráficamente dado que es un método más rápido. Para ello necesitaremos hacer uso de una serie de botones que nos ayudarán a introducir los nuevos comandos:

Cabecera del programa

Entorno de diseño gráfico

Nombre nuevo programa

Permite ver como quedará el perfil al eliminar los bucles mediante el uso del comando G61

Inhabilita aquellas líneas de programa que empiecen con el símbolo /

Instrucciones G más utilizadas

Centrar dibujo en pantalla.

Renumerar sentencias.

Permite ver como afecta al perfil los comandos G41 y G42 de corrección de herramienta

Permite ver como afecta al perfil el comando G52

Permite ver como afecta al perfil el comando G51

Ver puntos interpolación intermedios (dependen del valor de F)

www.infoPLC.net



6. Únicamente mediante el uso de comandos a través de botones G1, G2 y G3 crearemos una figura similar a la siguiente:

7. Observar como algunas líneas se muestran en color verde mientras que otras lo hacen en color azul, los colores verde y azul muestran que tramos del recorrido se harán sin que la herramienta tenga contacto con el material (G00) y que tramos se harán mecanizando (G01 / G02 / G03). El programa resultante, que se va auto escribiendo mientras se van añadiendo tramos al diseño del recorrido es el siguiente:

Sentencia Descripción % Demo Instrucción Inicio Programa + Nombre Programa N0 G00 Z100.000 F50 Elevo herramienta hasta cota 100 y fijo velocidad a 50

unidades/seg. Como utilizo instrucción G00 este movimiento se hará sin mecanizar

N10 G00 X40.00 Y25.00 Desplazo herramienta a cota X=40, Y=25 . N20 Z2.0 Desplazo herramienta a cota Z=2, es decir, a 2

unidades por encima de la superficie de mecanizado. Como no he introducido ninguna instrucción se toma la anterior G00.

N30 G01 Z-0.2 Desplazo herramienta hasta una profundidad de 0.2 unidades y dado que estoy empleando la instrucción G01 se inicia el mecanizado.

N40 Y95.000 Mecanizo desde la cota actual Y=25 hasta la cota Y=95.

N50 G02 X45.000 Y100.000 I5.000 J0.000 Inicio círculo en sentido horario conectando la cota final anterior X=40, Y=95 con la cota final X=45, Y=100 y estableciendo que el círculo tendrá un radio de 5 unidades (no hay más posibilidades, si se añade un radio incorrecto el trazado no será correcto). El centro del círculo se encuentra a +5 de la última posición X conocida y a más 0 de la última posición Y conocida, por eso I=5, J=0.

N60 G01 X135.000 Y100.000 Desplazo eje X hasta cota X=135. La cota Y permanece inalterada en su posición Y=100

N70 G02 X140.000 Y95.000 I0.000 J-5.000 Otro cuarto de círculo en sentido horario. El centro del círculo se encuentra a +0 de la última posición X conocida y a -5 de la última posición Y conocida, por eso I=0, J=-5.

N80 G01 X140.00 Y85.000 Desplazamiento en Y hasta cota Y=85 manteniendo constante la cota en X

www.infoPLC.net



N90 G02 X135.000 Y80.000 I-5.000 J0.000 Otro cuarto de círculo en sentido horario. El centro del círculo se encuentra a -5 de la última posición X conocida y a más 0 de la última posición Y conocida, por eso I=-5, J=0.

N100 G01 X95.000 Y80.000 Desplazamiento en X hasta cota X=95 sin mover la cota en Y=80.

N110 G03 X90.000 Y75.000 I0.000 J-5.000 Cuarto de círculo en sentido anti-horario. El centro del círculo se encuentra a +0 de la última posición X conocida y a -0 de la última posición Y conocida, por eso I=0, J=-5.

N120 G01 X90.000 Y65.000 Desplazamiento en Y hasta cota Y=65 manteniendo constante la cota en X=90.

N130 G03 X95.000 Y60.000 I5.000 J0.000 Cuarto de círculo en sentido anti-horario. El centro del círculo se encuentra a +5 de la última posición X conocida y a más 0 de la última posición Y conocida, por eso I=5, J=0.

N140 G01 X135.000 Y60.000 Desplazamiento en X hasta la cota X=135 manteniendo constante la cota en Y=60.

N150 G02 X140.000 Y55.000 I0.000 J-5.000 Cuarto de círculo en sentido horario. El centro del círculo se encuentra a +0 de la última posición X conocida y a -5 de la última posición Y conocida, por eso I=0, J=-5.

N160 G01 X140.000 Y40.000 Desplazamiento en Y hasta cota Y=40 manteniendo constante la cota en X=140

N170 Y25.000 Sigo desplazando en Y hasta la cota Y=25 manteniendo constante la X en X=140 (se utiliza última instrucción de movimiento válida G01)

N180 G02 X135.000 Y20.000 I-5.000 J0.000 Cuarto de círculo en sentido horario. El centro del círculo se encuentra a -5 de la última posición X conocida y a +0 de la última posición Y conocida, por eso I=-5, J=0.

N190 G01 X45.000 Y20.000 Desplazamiento en X hasta cota X=45 manteniendo constante la cota en Y=20

N200 G02 X40.000 Y25.000 I-0.000 J5.000 Cuarto de círculo en sentido horario. El centro del círculo se encuentra a -0 de la última posición X conocida y a +5 de la última posición Y conocida, por eso I=0, J=5.

N210 G00 Z2.0 Elevo herramienta 2 unidades por encima de la superficie de contacto del material de forma rápida (estoy empleando instrucción G00 en lugar de G01)

N220 X105.000 Y40.000 Dirijo herramienta a alta velocidad hacia punto inicio mecanizado círculo central (un punto cualquiera de su perímetro)

N230 G01 Z-0.2 Bajo herramienta hasta 0.2 unidades por debajo de la superficie del material mecanizando ya que estoy utilizando instrucción G01 y no G00

N240 G03 X105.000 Y40.000 I-15.000 J0.000 Realizo un círculo completo pues el punto final corresponde con el punto de partida X=105, Y=40 de radio 15 a la izquierda del punto de entrada de la herramienta.

N250 G00 Z2.0 Subo herramienta a alta velocidad hasta cota Z=2. N260 M30 Marca indicadora de fin de programa.

NOTA: Como se observa no existen botones para introducir el código G00 por lo que la única forma de utilizar esta instrucción es crear todo el dibujo mediante la instrucción G01 y posteriormente editar a mano el listado modificando aquellos códigos que deseemos. Lo mismo ocurre con la precisión de las cotas: si observamos que a mano alzada se ha cometido algún error podemos editar el listado del programa ajustando las cotas a lo deseado.

www.infoPLC.net



8.7.2.- Herramientas informativas Como herramientas informativas disponemos únicamente de una opción que nos ofrece la siguiente información:

Quizás los datos más interesantes son, en primer lugar, la duración del desplazamiento (el cual depende de la velocidad de mecanizado, en este caso 50 unidades/seg ya que la primera línea de programa indica: N0 G00 Z100.000 F50 y no hay ninguna contraorden posterior) que en este caso es de 21,22 segundos y la longitud total del recorrido que en este caso es de 655.358 unidades. El resto de datos los introduce de hecho el usuario y son meramente recordatorios.

www.infoPLC.net



8.7.3.- Herramientas edición Una vez disponemos del programa disponemos de una serie de herramientas que afectan a la totalidad de este y que son:

Determinar Tamaño Queue: La Queue es una tabla que utiliza Motion Pro para la generación de

coordenadas que posteriormente utilizan los diferentes FB de la aplicación. La tabla tiene un tamaño predefinido por defecto pero es posible variar su tamaño (haciéndolo más pequeño para optimizar recursos o mayor si se está creando una trayectoria compleja).

www.infoPLC.net



Determinar Posición Inicio: Es posible desplazar el cero de máquina respecto al cero de la trayectoria creada

Determinar Tolerancia de: Este parámetro hace referencia a la ventana de parada orientada, es decir, ángulo para parada el error angular máximo tolerable para considerar que la herramienta ha

dejado de girar en un punto tal en el que es posible depositarla de nuevo en su cargador y realizar un cambio de herramienta sin peligro.

www.infoPLC.net



Desplazar Programa: Permite añadir un offset a toda la trayectoria con el fin de mover su punto de inicio de mecanizado:

Rotar Programa: Permite girar la trayectoria rotándola desde su punto inicial

www.infoPLC.net



Extender Programa: Multiplica por un factor dado todas las coordenadas utilizadas en un programa. Básicamente es un mero escalado de la trayectoria creada.

NOTA: Aunque parezca que la figura de la derecha es igual a la de la izquierda en realidad todo se encuentra a escalado a la mitad (observar como sólo hay dos cuadrados desde el origen de coordenadas hasta el punto de entrada a la figura mientras que en la figura de la izquierda hay el doble)

Virar Programa: Invierte el sentido de mecanizado de la trayectoria, en la trayectoria creada

inicialmente se mecaniza primero la parte exterior en sentido horario y finalmente se mecaniza el círculo interno pero sin embargo, al realizar un virado de programa, el sentido se invierte realizando primero el círculo y posteriormente la trayectoria exterior pero en sentido antihorario.

Hay que prestar especial atención al programa virado pues quizás se hayan virado

también, inadecuadamente, las marcas utilizadas.

www.infoPLC.net



8.7.4.- Herramientas importación/exportación Por si el editor de programas CNC incluido en Motion Pro pudiera resultar limitado existe la posibilidad de crear la trayectoria desde un software de terceros que facilite el trabajo en 3D como por ejemplo un Autocad e importar el fichero (en formato DXF o TXT) a Motion Pro o bien exportar un programa CNC a formato TXT para poder ser posteriormente leído y/o editado mediante el uso de otros sofwares. Esta capacidad de importación/exportación de programas CNC otorga a Motion Pro una gran flexibilidad y una gran portabilidad ya que es posible la creación de un programa determinado desde un software conocido por porte del cliente final y llevarlo a máquina de una forma fácil y transparente (no es necesario modificar el programa interno). Las diferentes opciones disponibles son las siguientes:

Leer Programa CNC de archivo Permite cargar un programa externo en formato ASCII con extensión TXT. El programa debe ser válido y tras la carga se nos preguntará que nombre deseamos darle al nuevo programa CNC. Una vez dado el nombre el programa cargado pasará a formar parte de la lista de programas disponibles. Escribir Programa CNC en archivo Permite exportar el programa CNC actualmente seleccionado (visualizado en pantalla) hacia un fichero en formato ASCII con extensión TXT.

www.infoPLC.net



Importar archivo DXF Permite importar un programa CNC externo que se encuentra grabado en formato DXF (formato CAD más común) transformándolo a lenguaje ISO automáticamente. Es posible que la importación no sea perfecta si la fuente no reúne una serie de requisitos como por ejemplo trabajar con una única capa u otros. Escribir OutQueue en archivo Escribe en un fichero con formato propio y extensión QUE la estructura de datos que posteriormente utilizarán los diversos bloques de funciones de la aplicación para generar el movimiento. Esta estructura de datos se crea al compilar el programa siempre que tengamos activada la opción apropiada en base al programa CNC a ejecutar ya que los diferentes bloques de funciones que lanzaran el movimiento no son capaces, por si mismos, de interpretar un programa CNC escrito en lenguaje ISO. Este fichero no puede ser leído posteriormente por el entorno Motion Pro pero se supone que su utilidad reside en que puedan ser leídos mediante unos bloques de funciones específicos creados a tal fin de modo que sea posible una utilización directa de dicha información desde el programa principal de la LMC. Este último punto, no obstante, no se ha confirmado aún pues se desconoce de que forma y en que zona de memoria debe escribirse este archivo hacia la LMC para que el programa de usuario sea capaz de trabajar con él.

www.infoPLC.net



8.8.- Ejemplos de Programación

8.8.1.- Trayectoria Fija En este capítulo crearemos un programa Motion que permita a dos ejes XY seguir la trayectoria descrita por un programa CNC creado previamente. Se utilizará el mismo programa CNC ejemplo que se ha venido utilizando en los capítulos precedentes.

Lo primero que debería hacerse es comprobar que se encuentran cargadas las librerías necesarias para el uso de los bloques de funciones relativos a la gestión de programas CNC:

� SM_CNC_V1940.lib � SM_Trafo_V1940.lib

Las librerías pueden encontrarse en la carpeta:

C:\Schneider Electric\Motion Control\CoDeSys V2.3\Targets\Schneider Electric\Shared Files\Library\Motion

Crearemos a continuación (si es que no lo hemos hecho ya) un programa CNC que será el que seguirán los dos ejes XY del proyecto Motion Pro. En el capítulo 8.7.- Creación de Trayectorias se explica al detalle como crear el programa CNC que muestra la siguiente figura:

www.infoPLC.net



PRECAUCION : Hay que tener en cuenta que el bloque SMC_Interpolator no es capaz de reconocer el programa CNC escrito por nosotros en código ISO, lo único que entiende son estructuras de datos bastante complejas, del tipo SMC_GEOINFO, que bien podríamos crear nosotros a mano (lo cual es extremadamente laborioso y precisa de unos conocimientos muy altos) o indicarle a Motion Pro que lo haga por nosotros con tan sólo activar la opción “al compilar crear Outqueue” accesible en el menú superior Programa_CNC:

www.infoPLC.net



Una vez el programa CNC, al que llamaremos Demo, ha sido creado deberemos crear un programa Motion que permita que dos ejes XY lo sigan fielmente.

Vemos lo siguiente:

1. Con la variable Iniciar_CNC iniciamos la interpolación.

2. Asignamos la dirección del programa Demo a la entrada poqDataIn del bloque FB_Interpolador.

3. Asignamos a la entrada dwIpoTime del bloque FB_Interpolador la base de tiempos del grupo de ejes donde se encuentran declarados los ejes a utilizar (en este caso Eje_X y Eje_Y) para que el cálculo de coordenadas se sincronice adecuadamente.

4. Al activarse el bloque FB_Interpolador mediante la variable Iniciar_CNC éste troceará la ruta a seguir por ambos ejes en segmentos más pequeños los cuales irá proporcionando por la salida piSetPosition. Para saber que el bloque FB_Interpolador se encuentra generando cotas la salida bWorking se pondrá a TRUE. Tenemos también la salida iStatus que ofrece información relativa del estado de ejecución del programa Demo y que luego necesitan otros bloques.

5. Se une la salida piSetPosition del bloque FB_Interpolador a la entrada del mismo nombre del bloque FB_Trafo_XY con el fin de extraer las coordenadas individuales de cada eje.

6. Por último se utilizan los bloques FB_Control_X y FB_Control_Y para iniciar el movimiento cordinado de los ejes X e Y respectivamente según la información recibida del bloque FB_Trafo_XY. Y siempre y cuando el FB_Interpolador se encuentre trabajando y sin errores (ver conexión de las salidas bWorking e iStatus del bloque FB_Interpolador con entradas bEnable e iStatus de los bloques FB_Control_X y FB_Control_Y)

www.infoPLC.net



Si ejecutamos este programa sin una mecánica de ejes coordenados X-Y no veremos gran cosa, únicamente que los ejes se mueven. Disponemos de una herramienta que nos permite ver de una forma algo más clara cual será el comportamiento de los ejes XY y si estos seguirán una trayectoria de movimiento parecida al programa CNC creado. Para hacer uso de esta herramienta se ha de incorporar un nuevo bloque al programa: El bloque SMC_TrafoF_Gantry2 y las pantallas de visualización. El bloque mencionado es fácil de configurar, se añade al programa principal, donde reside el resto de bloques relacionados con la ejecución del programa CNC y se indican los límites de las coordenadas XY del programa CNC a ejecutar así como el nombre de los dos ejes involucrados.

www.infoPLC.net



Posteriormente vamos a las pantallas de visualización y creamos una nueva página con dos elementos: Un rectángulo unido a la variable Run y que servirá para dar marcha al sistema y un control que representa un par de ejes coordenados:

Seleccionamos una visualización del tipo SMC_VISU_Gantry2.

Como PlaceHolder del control SMC_TrafoF_Gantry indicamos que queremos vincularlo con el control del mismo tipo que se encuentra en el programa Main y al que hemos llamado FB_VisuTrafo.

Una vez realizados estos pasos, en la pantalla de visualización aparecerá un control similar al siguiente

Esta representación de ejes coordenados irá siguiendo los movimientos de los ejes X (horizontal) e Y (vertical) dándonos la oportunidad de observar como se va siguiendo la trayectoria que hemos creado mediante el programa CNC.

www.infoPLC.net



8.8.2.- Trayectoria Variable Hasta ahora hemos visto como puede crearse un programa CNC utilizando las herramientas gráficas disponibles o bien mediante la programación directa de códigos ISO. Estos programas son fijos, es decir, una vez creados las longitudes de sus segmentos así como otros parámetros importantes (velocidades o rampas de aceleración por ejemplo) no pueden modificarse. Con el fin de poder modificar el valor de los diferentes parámetros que permiten definir cada uno de los tramos de una trayectoria se propondrá un sistema simple pero muy potente basado en un bloque de funciones específicos. Antes que nada hay que aclarar unos conceptos muy importantes:

• Podremos únicamente modificar el valor de todos los parámetros que consideremos importantes pero no el tipo de parámetro.

• No será posible modificar los valores en parámetros de programas que ya se encuentren en ejecución.

Aclarado esto vamos a crear un ejemplo muy sencillo: Crearemos un programa CNC acorde al patrón de corte deseado, en este caso un cuadrilátero:

www.infoPLC.net



Vemos que el programa es muy simple: Sentencia Descripción % comment Instrucción Inicio Programa N0 G00 X20 Y20 F50 Llevo herramienta hasta cota X=20, Y=20 a máxima velocidad (ya que he empleado la

instrucción G00). N10 G01 Y120 Voy desplazando herramienta por su eje vertical hasta cota Y=120 a velocidad F50

(definida en línea anterior) N20 G01 X70 Voy desplazando herramienta por su eje horizontal hasta cota X=70 a velocidad F50

(definida en primera línea) N30 G01 Y20 Voy desplazando herramienta por su eje vertical hasta cota Y=20 a velocidad F50

(definida en primera línea). N40 G01 X20 Voy desplazando herramienta por su eje horizontal hasta cota X=20 a velocidad F50

(definida en primera línea) y doy por concluida la puerta. N50 G00 X0 Y0 Vuelvo al punto inicial a alta velocidad (ya que utilizo el comando G00 en lugar del G01).

Sin embargo este programa, tal como se ha diseñado, únicamente sirve para cortar puertas de 50 unidades de ancho y 100 de alto. Puede que nos interese cortar puertas con otras dimensiones, para ellos se ha de editar a mano el programa. Esto lo haremos del siguiente modo: Modificaremos el programa a mano dejándolo del siguiente modo Sentencia Descripción % comment Instrucción Inicio Programa N0 G00 X20 Y20 F50 Llevo herramienta hasta cota X=20, Y=20 a máxima velocidad (ya que he empleado la

instrucción G00). N10 G01 Y$cAlto$ Voy desplazando herramienta por su eje vertical hasta la cota indicada por la variable

cAlto a velocidad F50 (definida en línea anterior) N20 G01 X$cAncho$ Voy desplazando herramienta por su eje horizontal hasta la cota indicada por la variable

cAncho a velocidad F50 (definida en primera línea) N30 G01 Y20 Voy desplazando herramienta por su eje vertical hasta cota Y=20 a velocidad F50

(definida en primera línea). N40 G01 X20 Voy desplazando herramienta por su eje horizontal hasta cota X=20 a velocidad F50

(definida en primera línea) y doy por concluida la puerta. N50 G00 X0 Y0 Vuelvo al punto inicial a alta velocidad (ya que utilizo el comando G00 en lugar del G01).

Observar como ahora el ancho y el alto de la puerta se definen por el valor de las variables cAncho y cAlto y que para poder ser insertadas dentro del programa CNC es preciso que vayan encerradas entre sendos signos $.

www.infoPLC.net



Las variables cAncho y cAlto deben ser definidas como tipo REAL y con ámbito global ya que van a ser modificadas desde un programa externo al de movimiento. Se recomienda inicializarlas a algún valor coherente de modo que el entorno gráfico de diseño de programas CNC siga mostrando la figura que se va a desear (sino con las dimensiones deseadas al menos si con la forma deseada).

www.infoPLC.net



En este caso no vamos a decirle al compilador que transforme el programa por nosotros escrito en una estructura SMC_GEOINFO sino que seleccionaremos la opción “al compilar crear variable de programa” ya que en este caso pasaremos directamente el listado de programa CNC a través de un nuevo bloque llamado SMC_NCDecoder que se encargará de crear una estructura SMC_GEOINFO que contemplará los nuevos datos.

Como el nuevo bloque consume muchos recursos cuando transforma un programa CNC a una estructura SMC_GEOINFO crearemos una nueva tarea llamada TareaCíclica que llamará cada 8mseg al programa Path, el cual contendrá todo el código relativo a la conversión. De esta forma no saturaremos el programa cíclico que se encuentra sincronizado a cada ciclo del Motion Bus.

www.infoPLC.net



El nuevo programa tendrá el siguiente aspecto

Cada vez que el bloque FB_NCDecoder detecta un flanco de subida en su entrada bExecute coge el programa al que hemos llamado Puerta y lo convierte en una estructura del tipo SMC_GEOINFO almacenándolo en la variable Buffer. La variable Buffer debería ser definida como una variable global del tipo adecuado del siguiente modo:

Buffer: ARRAY [0..30] OF SMC_GEOINFO; Tras finalizar la conversion el puntero a dicha variable Buffer se envia a un segundo bloque llamado FB_CheckVelocidades el cual se encarga de “filtrar” el programa traducido eliminando cualquier velocidad que sobrepase a las especificadas como máximas en el entorno del Motion Pro evitando así comportamientos anómalos. Al final se memoriza el puntero a la estructura Buffer en una nueva variable a la que se ha llamado Puntero y que se ha definido como global del siguiente modo:

Puntero: POINTER TO SMC_Outqueue; Se utiliza un bloque MOVE simplemente para evitar que el puntero se convierta en 0 cuando eliminamos la orden Run_Decoder de la entrada tanto del bloque SMC_NCDecoder como del SMC_CheckVelocities.

www.infoPLC.net



Ya tenemos pues los elementos necesarios para pasar al programa principal que será del siguiente modo:

Como se ve es idéntico al utilizado anteriormente lo único que cambia es que esta vez la entrada poqDataIn no es un puntero a una estructura fija creada automáticamente por el compilador sino un puntero a una estructura que se va recalculando cada vez que modificamos un valor. Los pasos a seguir con este programa serían:

1. Modificamos los valores cAncho y cAlto según convenga. 2. Activamos Run_Decoder para que se proceda a calcular la estructura SMC_GEOINFO teniendo en

cuenta los nuevos valores para cAncho y cAlto 3. Tan pronto Decoder_OK valga TRUE eliminamos la orden Run_Decoder. 4. Activamos Run_CNC y ambos ejes empezaran a interpolar la nueva trayectoria con los nuevos

valores. Si deseamos modificar los valores debemos esperar a que la trayectoria anterior acabe de ejecutarse (iStatus=IPO_FINISHED) y repetir el proceso nuevamente.

www.infoPLC.net



8.8.3.- Modificar un programa en ejecución Aunque es mucho más cómodo, cada vez que se quiere lanzar una trayectoria, utilizar SMC_NCDecoder para obtener una estructura SMC_GEOINFO a partir de un programa CNC cuyos parámetros de movimiento pueden variarse y lanzarla mediante SMC_Interpolator (ver capítulo 8.8.2.- Trayectoria Variable) en ciertas ocasiones conviene realizar pequeños cambios en una trayectoria ya lanzada, como acortar o prolongar las coordenadas del último punto de la trayectoria porque acaba de llegar una pieza, modificar la velocidad de la trayectoria con un potenciómetro externo, etc. La única forma de modificar el comportamiento de una trayectoria que ya se encuentra lanzada y en ejecución es modificar directamente la estructura que se pasa al bloque SMC_Interpolator. Hay que tener en cuenta la siguiente condición:

• No es posible modificar el tramo que en ese momento se encuentre ejecutándose. Por tanto lo primero es conocer que aspecto tiene la estructura interpretada por el bloque SMC_Interpolator y que contiene la descripción de la trayectoria (coordenadas de cada punto, velocidades, rampas, etc). La estructura a la que se hace referencia es del tipo:

SMC_GEOINFO Y hay dos formas de obtenerla:

1. Tras compilar el programa con la opción “al compilar crear Outqueue” activada. En este caso veremos el aspecto de la estructura directamente en la opción CNC Data dentro de Variables Globales de la pestaña Recursos:

www.infoPLC.net



Y

X

Longitud

La estructura creada automáticamente por el compilador corresponde a una trayectoria simple compuesta por un tramo lineal:

N00 G01 X180 Y360 F100 E100 E-100

Para esta simple linea de movimiento la estructura creada sería:

_CNC0_Q : ARRAY[0..3] OF SMC_GEOINFO := (iObjNo:=0, iSourceLine_No:=2, iMoveType:=1,

piStartPos:= (iFrameNo:=0, wAuxData:=3, wSProfile:=0, dX:=0, dY:=0, dZ:=0, dA:=0, dB:=0, dC:=0, dA1:=0, dA2:=0, dA3:=0, dA4:=0, dA5:=0, dA6:=0),

piDestPos:= (iFrameNo:=0, wAuxData:=3, wSProfile:=0, dX:=180, dY:=360, dZ:=0, dA:=0, dB:=0, dC:=0, dA1:=0, dA2:=0, dA3:=0, dA4:=0, dA5:=0, dA6:=0),

dP1:=0, dP2:=0, dP3:=0, dP4:=0, dP5:=0, dP6:=0, dP7:=0, dP8:=0, dT1:=0, dT2:=1, dToolRadius:=0, dVel:=100, dVelEnd:=0, dAccel:=100, dDecel:=100, dLength:=402.49223595, byInternMark:=0, dHelpPos:=0.000000,0.000000,0.000000, iHelpID:=0,0,0);

Analizando ciertos datos de dicha estructura (resaltados en rojo) creada automáticamente ya vemos que dicho vector parte de las coordenadas X=0,Y=0 y finaliza en las coordenadas X=180, Y=360. Como otros datos importantes vemos que este tramo lo hará a una velocidad de dVel=100 y cuando llegue a las coordenadas destino su velocidad será dVelEnd=0, es decir, frenará. Las rampas que se emplearán durante la ejecución de este tramo serán dAccel=100 y dDecel=100. Hay un valor muy importante calculado automáticamente que corresponde a la longitud del tramo interpolado resultante:

4922,40212960032400)0360()0180(2222

=+=−+−=+= YXLongitud

Este último cálculo es lo que realmente dificulta en gran modo la utilización de este método cuando el trayecto a realizar se aparta de las fórmulas simples (vectores, círculos) y se adentra dentro de las trayectorias complejas (parábolas, splines, elipsoides…). Para modificar estos parámetros podemos utilizar un código de programa similar al siguiente: _CNC0_Q[0].piStartPos.dX:= Posición actual del eje X; _CNC0_Q[0].piStartPos.dY:= Posición actual del eje Y; _CNC0_Q[0].piDestPos.dX:= Nueva coordenada X para el punto destino; _CNC0_Q[0].piDestPos.dY:= Nueva coordenada Y para el punto destino; _CNC0_Q[0].dLength:= SQRT((_CNC0_Q[0].piDestPos.dX-

_CNC0_Q[0].piStartPos.dX)*(_CNC0_Q[0].piDestPos.dX-_CNC0_Q[0].piStartPos.dX)+(_CNC0_Q[0].piDestPos.dY-_CNC0_Q[0].piStartPos.dY)*(_CNC0_Q[0].piDestPos.dY-_CNC0_Q[0].piStartPos.dY));

_CNC0_Q[0].dVel:= Velocidad deseada; _CNC0_Q[0].dAccel:= Rampa aceleración deseada; _CNC0_Q[0].dDecel:= Rampa Deceleración deseada; _CNC0_Q[0].dVelEnd:= 0; En este caso la trayectoria se compone de un único tramo por lo que ya se ve que se ha de coger el índice 0 de la matriz de trayectorias creada por eso se hace referencia constantemente a _CNC0_Q[0].

www.infoPLC.net



Hay que tener en cuenta que el interpolador trabaja únicamente con coordenadas absolutas por lo que al desear realizar un movimiento hemos de programar como punto de partida la posición actual de cada eje:

_CNC0_Q[0].piStartPos.dX:= Pos_Eje1.Position; _CNC0_Q[0].piStartPos.dY:= Pos_Eje2.Position;

Hecho esto la posición final es simplemente la cota final deseada también en coordenadas absolutas:

_CNC0_Q[0].piDestPos.dX:= Nueva coordenada X para el punto destino; _CNC0_Q[0].piDestPos.dY:= Nueva coordenada Y para el punto destino;

Para calcular la longitud combinada a recorrer debe realizarse un pequeño cálculo que dependerá del tipo de movimiento a realizar (vectorial, circular, etc). En este ejemplo el movimiento es vectorial por lo que el cálculo es muy sencillo:

_CNC0_Q[0].dLength:= SQRT((_CNC0_Q[0].piDestPos.dX-

_CNC0_Q[0].piStartPos.dX)*(_CNC0_Q[0].piDestPos.dX-_CNC0_Q[0].piStartPos.dX)+(_CNC0_Q[0].piDestPos.dY-_CNC0_Q[0].piStartPos.dY)*(_CNC0_Q[0].piDestPos.dY-_CNC0_Q[0].piStartPos.dY));

Básicamente se calcula la hipotenusa de un triángulo rectángulo cuyos catetos son el desplazamiento (en este caso incremental) de los ejes X e Y.

Y finalmente se han de definir la velocidad de inicio y rampas:

_CNC0_Q[0].dVel:= Velocidad (en unidades/seg); _CNC0_Q[0].dAccel:= Aceleración (en unidades/seg2); _CNC0_Q[0].dDecel:= Deceleracion (en unidades/seg2);

Así como la velocidad a la que deseemos que queden girando ambos ejes al llegar a su destino:

_CNC0_Q[0].dVelEnd:= 0;

2. Tras compilar el programa con la opción “al compilar crear variable de programa” activada. En

este caso en la opción CNC Data dentro de Variables Globales de la pestaña Recursos veremos una estructura diferente a la SMC_GEOINFO a la que no hemos de hacer caso. La estructura en cuestión hemos de crearla a mano declarando una variable global de la forma:

Buffer: ARRAY [0..30] OF SMC_GEOINFO Esta nueva variable será un array con tantas celdas como líneas de programa tenga la trayectoria a implementar (en la práctica son algo más: sumar 10 al número de líneas de programa de la trayectoria a ejecutar). Una vez declarada dicha variable su contenido se utiliza igual que en el método 1

Este método debe emplearse conjuntamente con el bloque SMC_NCDecoder (ver capítulo 8.8.2 Trayectoria Variable) ya que en ese caso lo que se hace es transformar, cuando el programador crea oportuno, un programa de movimiento ISO con el valor adecuado para los parámetros de movimiento en una estructura SMC_GEOINFO.

www.infoPLC.net



8.9.- La estructura SMC_GEOINFO La estructura SMC_GEOINFO, que conviene dominar, se define del siguiente modo: TYPE SMC_GEOINFO:

STRUCT iObjNo:INT; iSourceLineNo:INT; iMoveType:MOVTYP; piStartPos:SMC_POSINFO; piDestPos:SMC_POSINFO; dP1:LREAL; dP2:LREAL; dP3:LREAL; dP4:LREAL; dP5:LREAL; dP6:LREAL; dP7:LREAL; dP8:LREAL; dT1:LREAL; dT2:LREAL; dToolRadius:LREAL; dVel:LREAL; dVelEnd:LREAL; dAccel:LREAL; dDecel:LREAL; dLength:LREAL; byInternMark:BYTE; dHelpPos: ARRAY[0..MAX_IPOSWITCHES] OF LREAL; iHelpID: ARRAY[0..MAX_IPOSWITCHES] OF INT; END_STRUCT

END_TYPE DESCRIPCION

iObjNo: INT Indice del objeto dentro de la estructura. iSourceLineNo: INT Número de línea del programa CNC. iMoveType: MOVTYP (INT) Contiene los siguientes valores que identifican el tipo de movimiento a realizar:

LIN 1 Lineal (G01)

CLW 2 Circular horario (G02)

CCLW 3 Circular antihorario (G03)

SPLINE 5 Spline o parábola (G05, G06)

ELLCLW 8 Elipse horaria (G08)

ELLCCLW 9 Elipse antihoraria (G09)

LINPOS 100 Lineal de posicionado (G00)

INITPOS 110 Posicionado a ciegas (Punto de inicio desconocido; SMC_Interpolator añadirá un movimiento continuo)

MCOMMAND 120 Marca

piStartPos: SMC_POSINFO Esta estructura describe las coordenadas iniciales de la trayectoria. (se ignorará si iMove_Type = INITPOS). piDestPos: SMC_POSINFO Esta estructura describe las coordenadas finales de la trayectoria.

www.infoPLC.net



dP1, ..., dP8: LREAL Estas variables contienen, dependiendo del tipo de movimiento, información avanzada de la trayectoria :

LIN LINPOS

Irrelevante ya que la Start_Pos y Dest_Pos ofrecen toda la información necesaria.

CLW CCLW

dP1: Coordenada X del centro. dP2: Coordenada Y del centro. dP3: Radio.

SPLINE Parámetro de spline.

ELLCLW, ELLCCLW P1: Coordenada X del centro. P2: Coordenada Y del centro. P3: Cordenada X del eje principal. P4: Coordenada Y del eje principal. P5: Longitud del eje principal. P6: Longitud del eje secundario. P7: Dirección del eje principal (°) P8: Correlación P6/P5.

INITPOS Irrelevante.

dT1, dT2: LREAL Estas variables contienen la posición inicial y final del parámetro y su significado depende del tipo de movimiento:

LIN LINPOS

Irrelevante ya que la Start_Pos y Dest_Pos ofrecen toda la información necesaria.

CLW

dT1: Ángulo inicial en sentido matemático (grados): (0 = Este, 90 = Norte, 180 = Oeste, 360 = Sur) dT2: Apice del círculo, longitud del arco circular (grados): (p.e.: -90=cuarto de círculo, -180 =semicírculo)

CCLW

dT1: Ángulo inicial en sentido matemático (grados): (0 = Este, 90 = Norte, 180 = Oeste, 360 = Sur) dT2: Apice negativo del círculo, longitud del arco circular (grados): (p.e.: 90=cuarto de círculo, 180 =semicírculo)

SPLINE Valor inicio y final del parámetro "t" Por defecto: 0 y 1.

INITPOS Irrelevante

dToolRadius: LREAL Esta variable contiene la información necesaria para el preprocesado de la trayectoria (ver SMC_ToolCorr y SMC_RoundPath). Si los bloques indicados no son utilizados estas variables carecen de utilidad. dVel, dVelEnd: LREAL Estas variables, que deben ser utilizadas en cualquier caso, contienen información sobre el perfil de velocidad del tramo. dVel describe la velocidad objetivo durante la trayectoria, dVelEnd describe la velocidad que debe alcanzarse al final de la trayectoria (unidades/seg). dAccel, dDecel: LREAL dAccel describe la maxima aceleración permitida, dDecel describe la máxima deceleración permitida (unidades/seg²). Por defecto ambas variables valen "100". dLength: LREAL Esta variable, cuyo valor debe asignarse en cualquier caso, contiene la longitud de la trayectoria (unidades). byIntern_Mark: BYTE

www.infoPLC.net



Esta variable describe el punto de inicio y final para las acciones de preprocesado de la trayectoria:

Bit 0 set Detener corrección radio herramienta después de la trayectoria.

Bit 1 set Iniciar corrección radio herramienta a la izquierda de la trayectoria.

Bit 2 set Iniciar corrección radio herramienta a la derecha de la trayectoria.

Bit 3 set Detener suavizado/redondeado después de la trayectoria.

Bit 4 set Iniciar suavizado/redondeado en la trayectoria.

Bit 4 set Iniciar redondeado en la trayectoria

Bit 6 set Detener impedir bucles después de la trayectoria.

Bit 7 set Iniciar impedir bucles en la trayectoria.

dHelpPos: ARRAY[0..MAX_IPOSWITCHES] OF LREAL, iHelpID: ARRAY[0..MAX_IPOSWITCHES] OF INT: Estas variables describen la posición relativa (0: Inicio trayectoria, 1:Final trayectoria; parecido al código G: O) y el ID (como el código G: H) de los switches auxiliares. Si la trayectoria es un comando M, iHelpID[0] contendrá el número de M.

www.infoPLC.net



9.- Las levas y las tablas CAM

9.1.- Introducción Una leva no deja de ser una relación de sincronismo entre dos ejes, uno maestro y uno esclavo cuyo ratio depende de la posición de aquel. Por decirlo de una forma simplista una leva es un sincronismo dinámico entre dos ejes. Entendido este punto las tablas CAM son un método que permite diseñar levas electrónicas.

Imaginemos que deseamos crear una leva de tal modo que cuando el eje maestro se desplace 270 grados el eje esclavo se desplace 360 (siempre en sincronismo) en ese momento el eje esclavo deberá detenerse hasta que el eje maestro no se haya desplazado otros 270 grados y posteriormente el eje esclavo deberá retroceder los 360 grados que antes avanzó mientras el eje maestro avanza otros 270 grados. La tabla CAM que resumiría este perfil de movimiento sería:

El siguiente paso es introducir esta misma tabla mediante el uso de Motion Pro. Hay básicamente dos formas de hacerlo:

• Mediante el entorno gráfico.

• Introduciendo directamente sobre la tabla CAM los valores que nos interesan.

El primer método es el más cómodo (según los gustos) ya que es bastante visual sin embargo dicho método es únicamente útil cuando no se tiene previsto modificar dichas levas.

El segundo método es, digamos, el avanzado. Esta pensado para permitir modificar el contenido de la tabla CAM desde programa incluso aunque se esté ejecutando en ese momento. Por ejemplo, imaginemos que en la tabla anterior queremos modificar el desplazamiento del eje maestro al doble:

Con el primer método tendríamos que “dibujar” una nueva leva y mediante programa utilizar una u otra, sin embargo, modificando directamente sobre la tabla CAM no es preciso crear un “dibujo” por cada variación ya que nos podríamos limitar a modificar aquellas posiciones de la tabla que nos interesan y lanzarla. Un ejemplo claro es una cizalla volante donde la longitud a cortar va variando entre 200 y 10000: Es evidente que únicamente con un sola tabla es suficiente, no hace falta dibujar 9800 tablas una por medida.

Por supuesto hay formas combinadas, puede dibujarse la “forma” y luego interactuar con la tabla generada por ejemplo en aquellas aplicaciones donde pueda existir una corrección por marcas (la leva va modificándose incluso antes de que finalice su ciclo).

Posición Maestro

Posición Esclavo

0 0 270 360 450 360 720 0

Posición Maestro

Posición Esclavo

0 0 540 360 900 360 1440 0

www.infoPLC.net



9.2.- Las estructuras necesarias Sea de la forma en que se diseñe una leva podrán ser utilizadas como variables las siguientes estructuras, las cuales conviene conocer: Esta primera estructura es la principal, contiene la definición de cómo será la leva y siempre será necesaria una variable de este tipo:

MC_CAM_REF Parámetro Tipo Descripción wCAMStructID WORD Esta variable, que siempre tiene un valor fijo, se utilize para comprobar si la

estructura de datos, tomada como entrada por un modulo, es una estructura del tipo MC_CAM_REF

xStart, xEnd LREAL Define los valores límites de eje maestro. byType BYTE Tipo de tabla CAM que se desea emplear:

1: Equidistante. Tabla unidimensional conteniendo las posiciones del eje

esclavo. 2: No equidistante, Tabla bidimensional conteniendo pares de posiciones

maestro-esclavo 3: Descripción polinomial de puntos estratégicos consistentes en posición

maestro, posición esclavo, velocidad y aceleración (XYVA). byVarType BYTE Tipo de variables que contendran las tablas (sólo si byType=1 o byType=2):

0: INT 1: UINT 2: DINT 3: UDINT 4: REAL 5: LREAL

nElements INT Número de elementos en la tabla, por tanto número de puntos esclavo, maestro/esclavo o puntos XYVA de la leva electrónica que desea crearse.

byInterpolationQuality BYTE Grado de interpolación a realizar (sólo si byType=1 o byType=2): 1: Lineal(por defecto), 3: Cúbica

pce POINTER TO BYTE

Puntero que apunta a la estructura que contiene los puntos de la tabla:

Tipo Estructura 1 (Equidistante) SMC_CAMTable_<VarType>_<nElements>_1 2 (No Equidistante) SMC_CAMTable_<VarType>_<nElements>_2 3 (Polinomial XYVA) ARRAY OF SMC_CAMXYVA

nTappets INT Número de puntos de control. pt POINTER TO

SMC_CAMTappet Puntero que apunta a la estructura que contiene la definición de Tappets (ARRAY OF SMC_CAMTappet).

strCAMName STRING Nombre de la tabla CAM.

www.infoPLC.net



Seguidamente una de las siguientes tres estructuras será necesaria para definir la tabla de puntos que describirá el comportamiento de la leva.

SMC_CAMXYVA Una tabla CAM del tipo XYVA consiste en un array del tipo SMC_CAMXYVA. Cada variable del array describe un punto de la tabla CAM vía dX (posición eje maestro), dY (posición eje esclavo), dV (primera derivada dY/dX; correspondiente a la velocidad del eje esclavo a velocidad constante y unitaria del maestro) y dA (segunda derivada d²Y/dX²; correspondiente a la aceleración del eje esclavo a velocidad constante y unitaria del eje maestro). Como mínimo son necesarios dos puntos: uno de inicio de tabla CAM y otro de final de tabla CAM.

SMC_CAMTable_<tipo variable>_<núm puntos>_1 En este tipo de estructura se emplea una tabla donde el incremento de posición para el eje maestro es igual de punto en punto (equidistante) y por tanto no es preciso ninguna tabla que permita definirlas (sabiendo el número de puntos y los límites es suficiente). En este caso es necesario indicar donde debe encontrarse el eje esclavo a cada incremento del eje maestro. Como mínimo son necesarios dos puntos: uno de inicio de tabla CAM y otro de final de tabla CAM. Las variables fEditorMasterMin, fEditorMasterMax, fTableMasterMin, fTableMasterMax permiten aplicar una escala a los valores introducidos en las tablas de modo que luego, internamente, el sistema las traduzca a unidades de usuario. Así es posible relacionar el rango de actuación (fEditorMaster, fEditorSlave) expresado en unidades de usuario con el rango de valores que aplicaremos en las tablas (fTableMaster, fTableSlave) que puede expresarse en otras unidades o márgenes.

SMC_CAMTable_< tipo variable >_< núm puntos >_2 Parecido al caso anterior pero con incrementos no equidistantes del eje maestro entre punto y punto. En este caso son necesarias dos dimensiones en la tabla, una contendrá la posición del eje maestro y la otra la del esclavo. Como mínimo son necesarios dos puntos: uno de inicio de tabla CAM y otro de final de tabla CAM. Las variables fEditorMasterMin, fEditorMasterMax, fTableMasterMin, fTableMasterMax permiten aplicar una escala a los valores introducidos en las tablas de modo que luego, internamente, el sistema las traduzca a unidades de usuario. Así es posible relacionar el rango de actuación (fEditorMaster, fEditorSlave) expresado en unidades de usuario con el rango de valores que aplicaremos en las tablas (fTableMaster, fTableSlave) que puede expresarse en otras unidades o márgenes.

www.infoPLC.net



9.3.- Creando estructuras propias Como se ha visto en el apartado anterior el sistema proporciona una serie de estructuras predefinidas para trabajar con tablas CAM si bien estas estructuras suelen contener un número fijo de puntos (128 o 256). Si se desea trabajar con una estructura que contenga un número de puntos diferentes hemos de crearla a mano. Para ello nada más sencillo que dirigirse a la pestaña “Tipos de Datos” y crear nuestra propia estructura:

En este caso se ha creado una estructura formada por una tabla bidimensional (tabla esclava y tabla maestra) compatible con valores LREAL de 151 puntos.

Se le ha dado el nombre de SMC_CamTabla_LREAL_151_2 únicamente para mantener la compatibilidad sintáctica con las creadas por el sistema aunque podríamos haberle dado un nombre cualquiera.

IMPORTANTE : Es vital que el orden de las declaraciones sea el indicado ya que en caso de utilizar un orden distinto el comportamiento de la tabla CAM, aunque aparentemente sea correcto (no se generará ningún error de compilación y el eje esclavo se desplazará siguiendo al maestro) no se comportará según lo especificado en las tablas.

www.infoPLC.net



9.4.- Levas desde entorno gráfico Para crear la leva del ejemplo anterior nada más sencillo:

1. Ir Pestaña Recursos.

2. Doble Clic opción Disco Levas.

3. Clic con botón derecho sobre Inventario de tablas CAM y seleccionar Nuevo Disco Levas.

Hacer

4. Introducir el nombre para el nuevo perfil de levas, por ejemplo CAM0.

5. Hacemos doble clic sobre el nuevo nombre y seleccionamos el fondo de escala del eje maestro y esclavo. Para el maestro fijar 720º y para el eje esclavo 360º. También anularemos la propiedad periódico.

www.infoPLC.net



6. Mediante las opciones gráficas existentes dibujaremos el perfil deseado (tres líneas)

7. Se recomienda hacer clic sobre el área de dibujo y seleccionar Curva como tabla de modo que todo lo que vayamos dibujando lo vayamos viendo expresado numéricamente en forma de tabla pudiendo así ajustar a mano los valores que se nos resistan.

NOTA: Es posible que los valores cercanos a los dos límites (0 y 720) no puedan ser escritos, en su defecto acercarse todo lo posible a ellos (0.001 y 719.999).

www.infoPLC.net



Ahora que ya tenemos la leva “dibujada” y hemos ajustado la tabla para que sea igual a la deseada podemos proceder a compilar el programa. Antes de compilar deberemos escoger que tipo de estructura de datos vamos a utilizar (ver capítulo 9.2.- Las Estructuras necesarias). Para ello, encontrándonos en Disco de Levas dentro de la pestaña Recursos, deberemos ir al menú superior desplegable Herramientas y seleccionar Opciones de compilación:

Según la elección se utilizará una estructura u otra:

• Polinominal: SMC_CAMXYVA

• Tabla de puntos de apoyo equidistantes: SMC_CAMTable_<VarType>_<nEle.>_1

• Tabla de puntos de apoyo de elementos optimizados: SMC_CAMTable_<VarType>_<nEle.>_2

No obstante, al trabajar desde el entorno gráfico deberá seleccionarse, obligatoriamente, la primera de las tres posibilidades: Polinomial

www.infoPLC.net



Tras compilar Motion Pro habrá creado, automáticamente, la estructura de tabla CAM que posteriormente utilizará el bloque de funciones correspondiente. Esta estructura puede verse si nos dirigimos a la pestaña Recursos, carpeta Variables Globales, opción CAM Data.

Observar como la tabla CAM creada utilizando este método es una estructura del tipo SMC_CAMXYVA la cual contiene 8 puntos. Esto es así porque esta estructura no contempla líneas sino puntos por lo que por cada una de las tres líneas utilizadas en el “dibujo” de la leva Motion Pro extrae dos puntos, el que da inicio a la línea y el que le da fin, además de los puntos inicial y final de la leva en si misma (los cuales no pueden modificarse). Esta estructura es una de las tres posibles estructuras existentes aunque de hecho es la más compleja ya que relaciona, para cada punto, posición maestro X – posición esclavo Y – Velocidad – Aceleración. Estos dos últimos parámetros, Velocidad y Aceleración en el punto de tangencia, resulta de difícil cálculo. En resumen: CAM0_A: ARRAY[0..7] OF SMC_CAMXYVA := (dX := 0.000000, dY := 0.000000, dV := 0.000000, dA := 0.000000), (dX := 0.001000, dY := 0.000000, dV := 1.333338, dA := 0.000000), (dX := 270.000000, dY := 360.000000, dV := 1.333338, dA := 0.000000), (dX := 270.000000, dY := 360.000000, dV := 0.000000, dA := 0.000000), (dX := 450.000000, dY := 360.000000, dV := 0.000000, dA := 0.000000), (dX := 450.000000, dY := 360.000000, dV := -1.333338, dA := 0.000000), (dX := 719.999000, dY := 0.000000, dV := -1.333338, dA := 0.000000), (dX := 720.000000, dY := 0.000000, dV := 0.000000, dA := 0.000000);

Tabla compuesta por 8 puntos:

Start Point = 1 Line = 2 Line = 2 Line = 2 EndPoint = 1 Total = 8

www.infoPLC.net



9.5.- Levas mediante tablas En ciertas ocasiones la leva debe ir modificando su forma bien porque las características del material van variando o bien porque es necesario compensar la forma de esta debido a deslizamientos, deformidades del material o imprecisión en la cadena cinemática. En todos estos casos el empleo de la herramienta gráfica de Motion Pro es insuficiente y es preciso la utilización de tablas de puntos calculados a tiempo real mediante fórmulas matemáticas. Este método es especialmente indicado cuando la forma de la leva necesita compensarse periódicamente debido a que el material a manipular es flexible (plásticos, goma, etc) y/o es necesario interactuar sobre ellos en puntos muy concretos (entre dos marcas, sobre un dibujo, etc) por lo que la longitud de la leva no importa tanto como que a cada ciclo de máquina un punto de esta coincida con un punto del material (método llamado comúnmente como corrección por marcas). Lo primero que hay que hacer es declarar las variables que vamos a emplear. Sólo es necesario el uso de dos estructuras internas: La primera contendrá la definición de la leva y es del tipo MC_CAM_REF mientras que la segunda contiene la definición de la tabla de puntos y es del tipo SMC_CAMTable_LREAL_128_2. Para ello iremos a la pestaña Recursos, carpeta Variables Globales y opción Global_Variables y escribiremos el siguiente código:

(*Defino tabla CAM*) TablaCAM: MC_CAM_REF:=(nElements:=128, byType:=2, byVarType:=5, xStart:=0, xEnd:=720); (*Especifico límites de tabla CAM en unidades de usuario*) TablaCAM_A: SMC_CAMTable_LREAL_128_2:=( fEditorMasterMin := 0, fEditorMasterMax := 720, fTableMasterMin := 0, fTableMasterMax := 720, fEditorSlaveMin := 0, fEditorSlaveMax := 360, fTableSlaveMin := 0, fTableSlaveMax := 360);

En la inicialización de la estructura MC_CAM_REF vemos que deseamos trabajar con tablas de 128 puntos (nElements=128), de tipo bidimensional (bytype=2) para relacionar posiciones absolutas maestro-esclavo y que se emplearán variables de tipo LREAL (byVarType=5). Como en el momento de declarar las variables no tienen porque conocerse los valores máximos de las tablas utilizaremos valores arbitrarios (ver valores en rojo):

(*Defino tabla CAM*) TablaCAM: MC_CAM_REF:=(nElements:=128, byType:=2, byVarType:=5, xStart:=0, xEnd:=720); (*Especifico límites de tabla CAM en unidades de usuario*) TablaCAM_A: SMC_CAMTable_LREAL_128_2:=( fEditorMasterMin := 0, fEditorMasterMax := 720, fTableMasterMin := 0, fTableMasterMax := 720, fEditorSlaveMin := 0, fEditorSlaveMax := 360, fTableSlaveMin := 0, fTableSlaveMax := 360);

www.infoPLC.net



Una vez declaradas e inicializadas las variables básicas ya podemos crear una rutina que calcule el valor para los 128 puntos de la leva. Un ejemplo simple sería un vector calculado de tal forma que cuando el eje maestro haya recorrido 720º el esclavo haya recorrido 360º. En la siguiente rutina vemos un ejemplo que va calculando los 128 diferentes puntos para las tablas maestra y esclava:

(* Creación de una tabla CAM *) FOR i:=0 TO 127 DO (*Tabla Maestra*) TablaCAM_A.Table[i][0]:=(i / 127.0 * 720); (*Tabla Esclava*) TablaCAM_A.Table[i][1]:=(i / 127.0 * 360); END_FOR; (* Fijo límites de las tablas *) TablaCAM_A.fEditorMasterMin:=0; TablaCAM_A.fEditorMasterMax:= TablaCAM_A.Table[127][0]; TablaCAM_A.fTableMasterMin:=0; TablaCAM_A.fTableMasterMax:= TablaCAM_A.Table[127][0]; TablaCAM_A.fEditorSlaveMin:=0; TablaCAM_A.fEditorSlaveMax:= TablaCAM_A.Table[127][1]; TablaCAM_A.fTableSlaveMin:=0; TablaCAM_A.fTableSlaveMax:= TablaCAM_A.Table[127][1];

(*Fijo límites de la leva*) TablaCAM.xEnd:= TablaCAM_A.Table[127][0];

Observar como al final del cálculo de todos los puntos de la tabla es cuando podemos por fin fijar los límites tanto de la tabla como de la leva (aquellos que en el momento de la declaración de variables se dejaron “pendientes” con un valor arbitrario). Por último, con la tabla de puntos ya llena, crearemos la rutina principal encargada de lanzar el movimiento:

Es muy importante no olvidar de vincular la segunda de las variables, la tabla de puntos (TablaCAM_A), con la primera de ellas, la leva en si misma (TablaCAM) ya que es la que en definitiva introduciremos en el bloque MC_CamTableSelect. Esta vinculación tiene lugar a través del parámetro pce de la variable TablaCAM (estructura del tipo MC_CAM_REF) y tiene que hacerse a cada ciclo del Motion Bus.

Posición Maestro: 720º

Pos

ició

n E

scla

vo: 3

60º

Vinculación entre TablaCAM (leva) y TablaCAM_A (tablas de puntos)

Se selecciona la leva descrita por la variable TablaCAM

Modo de inicio de la tabla respecto a la posición actual del eje esclavo. Puede ser Relative o Absolute

www.infoPLC.net



Asimismo hay que distinguir entre dos formas de ejecutar la leva: relativa o absoluta. Si la leva se ejecuta de forma relativa no importará en que cota se encuentre el eje esclavo, la leva tomará ese punto como punto inicial y seguirá la leva de la forma definida. Si se define como absoluta lo primero que tendrá lugar es un reposicionado del eje esclavo hacia la cota marcada por el primer elemento de la tabla y a partir de ahí se ejecutará la leva según lo definido en sus tablas. El modo absoluto es quizás recomendable en aquellos casos en los que la leva describa un movimiento de ida-regreso empezando con el eje esclavo en la cota 0 (es necesario realizar algún tipo de referenciado) y finalizando la ejecución de la leva de modo que el eje esclavo acabe en el cota 0 de nuevo. El comportamiento del programa es bastante sencillo de describir:

1. Mediante el bloque MC_CamTablaSelect se especifica que eje será el maestro y cual el esclavo y que se va a emplear la leva descrita por la variable TablaCAM (la cual apunta a la tabla de puntos TablaCAM_A).

2. Cuando el bloque MC_CamTablaSelect recibe un flanco de subida en la entrada Execute se

calcula un identificador para dicha leva y se envia al siguiente bloque MC_CamIn.

3. Con el bloque MC_CamIn, al cual le llega el identificador de la leva a ejecutar así como la orden de inicio de ejecución en su entrada Execute desde la salida Done del bloque anterior, se inicia la sincronización entre ejes.

4. Cuando queremos abandonar la sincronización entre ejes debemos ejecutar el bloque MC_CamOut

pero siempre que hayamos previamente ejecutado el bloque MC_CamIn por ello se utiliza una báscula SR que almacena por un lado la condición de Insync del bloque MC_CamIn (señal de que el eje esclavo inició su sincronización con el maestro) cuya salida se compara con el estado negado de la orden de inicio de sincronización bRunEsclavo (debe mantenerse este valor a ON en tanto queramos que ambos ejes permanezcan sincronizados, si cambia a OFF saldremos de la sincronización).

www.infoPLC.net



9.6.- Ejecución de una leva Vamos a suponer que se ha creado una leva cualquiera bien desde el entorno gráfico bien a mano y la hemos llamado CAM_D. Necesitaremos tener claros tres puntos clave para el uso de dicha leva:

1. Selección de la tabla. 2. Asignar la tabla a un eje e iniciarla. 3. Desasignar la tabla del eje.

Si al considerar que se ha finalizado el trabajo con la tabla CAM no efectuamos el tercer punto (desasignar la tabla del eje) al querer asignar otra tabla o simplemente volver a cargar la misma tabla para efectuar un ciclo este no se iniciará o se iniciará incorrectamente. PRECAUCION : Hay que tener en cuenta que podemos crear y ejecutar cuantas tablas CAM deseemos, según la disponibilidad de recursos del sistema, pero bajo ningún concepto debemos ejecutar la misma tabla desde dos rutinas distintas. Si se quiere que dos ejes ejecuten la misma tabla CAM debemos crear dos tablas CAM con el mismo contenido y asociar cada una especificando ejes esclavos distintos (es posible utilizar el mismo eje maestro) El siguiente ejemplo muestra un ejemplo de uso de tabla CAM:

Vemos lo siguiente:

1. Con la variable Habilitar iniciamos la selección de la tabla a ejecutar. 2. Asignamos FALSE a las entradas MasterAbsolute y SlaveAbsolute lo cual afecta al modo en que

se ejecuta la tabla CAM. Para esos valores se tomarán los datos de la tabla CAM como relativos a la posición en la que se encuentre el eje maestro y esclavo.

3. Seguidamente asignamos a las entradas Master de los bloques involucrados el eje cuya posición se

tomará como referencia para que el eje esclavo se mueva según lo indicado por la tabla CAM. El eje esclavo se asignará a las entradas Slave de los bloques involucrados.

4. Por último se ha de indicar al bloque Seleccion_Tabla el nombre de la tabla CAM que se va a

emplear.

5. Cuando el valor de la variable Habilitar pasa a TRUE el bloque Seleccion_Tabla se ejecuta

obteniendo un número identificativo de tabla mediante la salida CamTablaID el cual se envía al bloque Asignar_Tabla.

6. Como lo que se desea es que la ejecución de los movimientos tenga lugar desde el punto actual del

eje maestro y esclavo se especifica mediante la asignación de la palabra relative a la entrada StartMode del bloque Asignar_Tabla.

www.infoPLC.net



7. Cuando el eje esclavo se encuentre en sincronismo se indicará mediante la salida In_Sync. Ahora ya es posible iniciar el movimiento del eje maestro, el esclavo se moverá según lo descrito en la tabla CAM.

8. Lo que viene a continuación es un método para asegurar que sólo se desasignará una tabla CAM

que previamente haya sido asignada: Cuando el sistema se encuentre en In_Sync memorizamos esta condición mediante una báscula SR, la salida de esta báscula se lleva a la entrada de una puerta AND, la otra entrada viene de la variable Habilitar negada. En sincronismo una entrada es TRUE y la otra es FALSE (porque está negada), cuando deseamos salir la variable Habilitar pasa a FALSE y las dos entradas de la puerta AND pasan a ser TRUE. Sólo cuando la salida de la puerta AND es TRUE se ejecuta el bloque Desasignar_Tabla permitiendo salir de la tabla CAM dejando preparado el sistema para futuros ciclos.

9. La báscula SR se resetea cuando se haya ejecutado el bloque Desasignar_Tabla.

CONCEPTO : Otro principio básico que debe seguirse religiosamente es la forma en que deben encontrarse el eje maestro y el esclavo al activar y desactivar la tabla CAM. Seguir los siguientes preceptos:

• Antes de desplazar el eje maestro el eje esclavo debe encontrarse con la tabla CAM lanzada y siguiéndola (en sincronismo) ya que si no es así el eje maestro puede desplazarse mientras el esclavo, al no encontrarse en sincronismo, no puede seguirlo pudiendo producirse errores de medida.

• Antes de desasignar la tabla CAM del eje esclavo debemos asegurarnos que el eje maestro se

encuentra detenido por las mismas razones anteriores.

www.infoPLC.net



9.7.- Gestión de múltiples levas Independientemente de si se ha empleado el método gráfico o el de creación de tablas “a mano” es posible seleccionar de un listado de levas una en concreto asignándola a una variable auxiliar que será la que introduciremos en el bloque MC_CamTableSelect (ver apartado anterior). De este modo, con una misma estructura de ejecución de levas, podremos lanzar la leva que queramos. Utilizando el método descrito en este apartado incluso podremos seleccionar la leva a ejecutar desde las pantallas de visualización. Si creamos gráficamente dos levas, tras compilar, Motion Pro creará automáticamente un código similar al siguiente:

En una primera aproximación la variable que nos interesa es:

_SMC_CAM_LIST : ARRAY[0..1] OF POINTER TO MC_CAM_REF; Nos encontramos con un array que contiene punteros que apuntan a las estructuras donde se describen cada una de las levas creadas (el primer puntero en el índice 0 y el segundo en el índice 1) y que podemos utilizar para ir asignando a nuestras variables de usuario toda la información relativa a una leva. En este caso este array contiene dos elementos porque hemos creado dos tablas: CAM_D y CAM_I. La descripción de estas dos levas se obtiene de las siguientes variables: CAM_I: MC_CAM_REF := (nElements := 6, byType := 3, xStart := 0.000000, xEnd := 360.000000, nTappets := 0, strCAMName:='CAM_I'); CAM_D: MC_CAM_REF := (nElements := 8, byType := 3, xStart := 0.000000, xEnd := 32000.000000, nTappets := 0, strCAMName:='CAM_D'); Aunque hay más datos “escondidos” de momento nos interesan estos pues son los básicos.

www.infoPLC.net



Por ejemplo, podemos crear un elemento estructura del tipo:

Y unir esta estructura con una pantalla de visualización para solicitar el nombre de la tabla que se desea emplear:

Y luego, en alguna parte del programa, realizar el resto de la asignación: FOR AuxTabla:=0 TO 1 DO IF _SMC_CAM_LIST[AuxTabla]^.strCAMName =Secuencia[NumSeq].Eje[1].Tabla.strCAMName AND PermisoEje1 THEN Secuencia[NumSeq].Eje[1].Tabla:=_SMC_CAM_LIST[AuxTabla]^; END_IF; END_FOR; En esta sección de código únicamente se rastrean todos los elementos de la lista de tablas disponible hasta encontrar uno cuyo nombre coincida con el introducido en la pantalla de visualización. Cuando esto ocurre se copia la estructura que define la leva sobre nuestra variable (que es del mismo tipo) pudiendo emplearla para ejecutarla, modificarla, etc.

.Main.Secuencia[.Main.IndSecuencia].Eje[1].Tabla.strCAMName

.Main. NumSeq

.Main. PermisoEje1

.Main. NumSeq

El campo tabla apunta a la descripción de la leva (la cual apunta a la tabla CAM)

www.infoPLC.net



9.8.- Desfasado de eje esclavo Para desfasar la posición del eje esclavo respecto el maestro en plena ejecución se suelen emplear dos técnicas:

• Utilizar un bloque de funciones a tal efecto.

Con este bloque, a cada orden bDesfasar recibida se aplicará un desfase absoluto, especificado mediante la variable Desfase. Dicho desfase es absoluto cuando se aplica (dos desfases consecutivos de 45º no equivalen a un desfase de 90º sino a uno de 45º) pero incremental respecto a la posición donde se aplica (se suma o resta a la posición que en ese momento posea el eje esclavo).

• Manipular los valores de la tabla que definen el movimiento de la leva.

Evidentemente siempre podrá modificarse la tabla maestra y/o esclava de modo que se consiga el desfase deseado. Al contrario de cómo sucedía al emplear un bloque, cuando se hace por tabla, podemos decidir entre que posiciones tendrá lugar la aplicación del desfase y aplicarlo, por tanto, de una forma mas suavizada.

www.infoPLC.net



9.9.- Los Tappets Los Tappets son marcas que pueden situarse estratégicamente en cualquier punto de una leva y que nos permiten conocer que sección de la leva se está ejecutando en cada momento. Al igual que como sucedía a la hora de definir la leva pueden definirse los Tappets mediante dos vías distintas:

1. Gráficamente.

2. Mediante programación “a mano”.

Para definir a mano los Tappets que deseamos utilizar hay que efectuar dos operaciones simples: Cuando defino la estructura de la leva indico cuantos Tappets voy a necesitar: (*Defino tabla CAM*) TablaCAM: MC_CAM_REF:=(nElements:=128, byType:=2, byVarType:=5, xStart:=0, xEnd:=720, nTappets:=8); Y posteriormente creo una variable de tipo SMC_CAMTappet que describe como actuarán cada uno de los 8 Tappets: (*Los tapptes hacen relación al ancho total del perfil maestro que en este caso es 720*) TablaTappets: ARRAY[0..7] OF SMC_CAMTappet := (ctt := 0, dwDelay := 0, dwDuration := 0, iGroupID := 1, x := 1.000000, cta := 0), (ctt := 0, dwDelay := 0, dwDuration := 0, iGroupID := 1, x := 90.000000, cta := 1), (ctt := 0, dwDelay := 0, dwDuration := 0, iGroupID := 2, x := 90.000000, cta := 0), (ctt := 0, dwDelay := 0, dwDuration := 0, iGroupID := 2, x := 180.000000, cta := 1), (ctt := 0, dwDelay := 0, dwDuration := 0, iGroupID := 3, x := 180.000000, cta := 0), (ctt := 0, dwDelay := 0, dwDuration := 0, iGroupID := 3, x := 270.000000, cta := 1), (ctt := 0, dwDelay := 0, dwDuration := 90, iGroupID := 4, x := 270.000000, cta := 0), (ctt := 0, dwDelay := 0, dwDuration := 0, iGroupID := 4, x := 360.000000, cta := 1); Lo más importante es saber diferenciar entre Tappets (que en este caso se han definido 8) e iGroupId (que en este caso sólo hay 4). Un Tappet es cualquier punto insertado en la leva mientras que el iGroupId es como el número de variable que va a ser manipulada. En la sección de código mostrada vemos que primer Tappet activa a ON (cta=0 es ON y cta=1 es OFF) el iGroupID=1 cuando la posición del eje maestro es x=1º. El segundo Tappet, sin embargo, asigna OFF al iGroupID=1 cuando la posición del eje maestro es x=90º. CONCEPTO : el iGroupID es la variable que luego consultaremos mientras que cada vez que se necesita cambiar su valor será necesario crear un Tappet distinto. Cada Tappet representa una actuación en una actuación sobre un iGroupID determinado en una posición determinada de la leva maestra.

www.infoPLC.net



Una vez creados los ocho Tappets que modifican a cuatro iGroupID podremos consultar el valor de cada iGroupID de la siguiente forma:

En el ejemplo anterior vemos como se lanza una leva y como se van consultando el estado de los cuatro diferentes iGroupID. No olvidar vincular a cada ciclo de Motion Bus la tabla de Tappets con la leva seleccionada. Esto permite incluso crear diferentes tablas de Tappets para una misma leva y seleccionar una u otra según conveniencia. NOTA : Las posiciones de activación/desactivación de los Tappets se refieren a las posiciones del eje maestro y no del esclavo.

www.infoPLC.net



10.- PANTALLAS VISUALIZACION

10.1.- Introducción Existe la posibilidad de crear toda una serie de útiles pantallas de visualización de gran utilidad para la monitorización y/o introducción de datos. Mediante el uso adecuado de estas pantallas es posible la creación de toda una compleja interface que permita al usuario interactuar con la aplicación.

10.2.- Creación de una página Las páginas de visualización se crean y utilizan siempre desde el entorno de visualización:

Los pasos para la creación de una página de visualización serían:

1. Clic sobre la pestaña Visualizaciones. 2. Botón derecho ratón sobre la carpeta Visualizaciones. 3. Seleccionar la opción Insertar objeto. 4. Darle un nombre a la nueva visualización.

5. Pulsar sobre botón Aceptar.

www.infoPLC.net



Tras seguir los pasos anteriores obtendremos el entorno adecuado para empezar a crear una visualización:

Lo primero que vamos a realizar es diseñar el aspecto gráfico y para ello disponemos de una serie de herramientas agrupadas en la barra de iconos superior:

Seleccionaremos el icono de Rectángulo y dibujaremos uno sobre el entorno de desarrollo

Entorno desarrollo.

www.infoPLC.net



El siguiente paso es darle un texto y un color de fondo a dicho rectángulo para ello haremos doble clic sobre él y veremos que aparece un nuevo cuadro:

A continuación pulsamos sobre la sección Texto e introduciremos Medidas, posteriormente haremos clic sobre el botón Fuente… y escogeremos tipo de letra Negrita y tamaño de la fuente a 11.

Sin hacer clic sobre el botón Aceptar pasamos directamente a la sección Colores para pulsar sobre el botón Interior de la categoría Color. En el cuadro de colores que aparecerá seleccionaremos un verde claro y pulsaremos sobre todos los botones Aceptar hasta que desaparezcan todos los cuadros:

www.infoPLC.net



El resultado, si se han seguido los anteriores pasos correctamente, tendrá la siguiente apariencia:

Continuamos añadiendo objetos de forma similar a la indicada hasta que nuestra pantalla tenga un aspecto similar al mostrado por la siguiente figura:

Ver siguiente apartado

Para la creación de círculos utilizaremos el icono

www.infoPLC.net



10.3.- Formato y uso de variables Si se incluye %s (en minúsculas) dentro de un texto, entonces, el lugar que ocupa, en modo Online, será sustituido por el valor de la variable introducida en la celda Textdisplay dentro de la sección Variables. Mediante el uso del carácter s el valor se mostrará tal cual sin formato pero es posible utilizar otro tipo de formato de representación:

Carácter Argumento / Salida como

d,i Número decimal

o Numero Octal sin signo

x Número Hexadecimal sin signo

u Número Decimal sin signo

c Carácter sencillo

s String

f Valores Reales

Sintaxis: % <Alineación><Ancho mínimo><Precisión> f

Precisión: Número de decimales detrás de la coma (por defecto 6)

Hacemos doble clic sobre los campos de texto que incluyen % para asociar una variable a los mismos:

Nota: Debido a un error de Motion Pro la pantalla en idioma castellano se muestra recortada impidiendo ver e introducir información importante, por ello se muestra la misma pantalla pero en idioma inglés.

En la sección Variables vemos que tenemos varias posibilidades de las cuales se destacan la siguientes:

Invisible: Introduciremos una variable tipo Bool con el fin de que el objeto asociado sea visible o no. De esta forma podremos ocultarlo o mostrarlo según el valor de dicha variable. Si no se indica nada se toma FALSE como valor por defecto (el objeto nunca es invisible).

Input Disable: Utilizado para impedir la modificación del valor de la variable asociada al objeto mediante la celda Textdisplay. En la imagen, al haberse introducido TRUE, la modificación de la variable asociada queda anulado pudiendo sólo leer su valor.

Change Color: Permite modificar el color del fondo del objeto mediante el uso de una variable, por ejemplo para resaltar la aparición de una alarma.

Textdisplay: En esta celda se introduce la variable que se desea asociar con el objeto.

www.infoPLC.net



El uso de variables es algo peculiar: Al nombre de la variable debe anteceder siempre un punto. Si son variables globales se hace referencia a ellas directamente (un punto y el nombre de la variable):

1.- Defino una variable global de nombre Posicion y tipo Real, para ello abro la pestaña Resources: 2.- Me dirijo a la carpeta Global Variables y la opción Global_Variables para definir la nueva variable: 3.- Ahora abro la pestaña Visualizations 4.- En la visualización deseada creada anteriormente hacemos doble clic sobre el objeto que queremos vincular a la nueva variable creada: 5.- Por último vinculamos la variable Posicion de modo que se muestre en lugar de %0.1f (el valor de la variable se presentará siempre con un decimal) . Observar como en la celda Textdisplay el nombre de la variable se introduce con un punto delante.

www.infoPLC.net



Si en lugar de global la variable es local (se encuentra definida dentro de un programa o bloque) debe hacerse referencia a ella indicando en que bloque o programa se ha declarado:

1.- Dentro del programa Main me encuentro la variable Pos_Eje1 que es del tipo MC_ReadActualPosition por lo que al ser un FB predefinido puedo hacer uso de todos sus parámetros de entrada y salida:

2.- Ahora abro la pestaña Visualizations 3.- En la visualización deseada creada anteriormente hacemos doble clic sobre el objeto que queremos vincular a la nueva variable creada: 4.- Por último vinculamos la variable .Main.Pos_Eje1.Posicion de modo que se muestre en lugar de %0.1f (el valor de la variable se presentará siempre con un decimal) . Observar como en la celda Textdisplay el nombre de la variable se introduce no sólo con un punto delante sino también con el nombre del programa donde ha sido declarada la variable Pos_Eje1.

NOTA: En realidad la variable Pos_Eje1 es un FB:

www.infoPLC.net



10.4.- Los Placeholders Si creamos una pantalla de visualización que, por ejemplo, muestre la posición actual de un eje (Eje 1) podemos luego llamarla dos veces desde una pantalla de visualización principal como si fuera un control más pero ambos controles mostrarán la posición del mismo eje (el Eje 1) pues así fue programada dicha pantalla de visualización secundaria. Sería una lástima y una pérdida de recursos el hecho de tener que crear 16 pantallas de visualización secundarias para mostrar la posición de 16 ejes distintos (Eje1 a Eje16) y ahí entran en juego los Placeholders… Un Placeholder no es más que un método por el cual es posible intercambiar información entre una pantalla de visualización secundaria y la pantalla de visualización principal que la utiliza. Mediante este intercambio es posible indicar a la pantalla de visualización secundaria, si es llamada dos veces, que en la primera instancia utilice, por ejemplo, un primer eje (Eje 1) y en la segunda, por ejemplo, el segundo (Eje2). De este modo una misma pantalla de visualización secundaria puede ser reutilizada de una forma más potente y versátil.

10.4.1.- Creación de una pantalla secundaria Las pantallas de visualización secundarias se crean exactamente del mismo modo que las normales. Vamos a crear una pantalla de visualización cualquiera que, por ejemplo, tenga el siguiente aspecto: La diferencia con respecto a una pantalla de visualización general es que en este caso se hace uso de variables delimitadas por el símbolo $ como parte de la ruta hacia la variable utilizada para interactuar con el control. Observemos, por ejemplo, que hace el piloto “Paro Emergencia”:

www.infoPLC.net



En este control la ruta de la variable según el valor de la cual se modificará el color del piloto es:

$Visu_axe$.FB_DriveStatus.ErrorStop La variable Visu_axe es un marcador o variable de intercambio y se llama Visu_axe porque nosotros hemos decidida llamarla así, de momento no significa nada, cuando esta pantalla sea llamada desde una pantalla de visualización principal como si de otro control se tratara veremos la verdadera utilidad de la variable Visu_axe. Es posible emplear cuantos marcadores o placeholders deseemos ya que es posible que una pantalla de visualización secundaria haga uso de bloques de funciones que se encuentren en secciones de programa distintas. En este caso utilizaremos tres tipos distintos de placeholders. Los dos siguientes Placeholder se encuentran en los siguientes lugares:

Ahora compilamos el programa y ya tenemos creada la pantalla de visualización secundaria que, en este caso, incluye tres Placeholders:

Visu_axe Visu_titulo Visu_pos

Placeholder: Visu_titulo

Placeholder: Visu_pos

www.infoPLC.net



10.4.2.- Uso de los placeholders En el apartado anterior creamos una pantalla secundaria utilizando tres placeholders. Ahora veremos como se emplean estos placeholders de modo que la misma pantalla secundaria se utilice para mostrar información de dos ejes distintos. Los pasos serían los siguientes

1. Crear una pantalla de visualización nueva. 2. Añadir a la nueva pantalla un control de nombre el de la pantalla de visualización secundaria.

3. Repetimos la operación añadiendo un segundo control idéntico. De esta forma tendremos dos controles uno para cada uno de los dos ejes que vamos a utilizar.

www.infoPLC.net



4. Hacemos doble clic sobre el objeto de la izquierda y aparecerá una caja de configuración del objeto. Recordar que aunque esta pantalla de visualización secundaria se encuentra formada por múltiples objetos estos no son accesibles cuando se llama como control desde otra pantalla de visualización:

5. Pulsamos sobre el botón Placeholder y observamos como en la ventana que aparece se muestran precisamente los tres Placeholders que anteriormente hemos creado. Ahora vamos a asignar variables a los tres:

www.infoPLC.net



6. Y por último repetimos la operación para el control de la derecha:

Como se ha visto en el apartado anterior a la hora de configurar el piloto relativo al Paro Emergencia pusimos como variable que afectaba a su color la siguiente sentencia:

$Visu_axe$.FB_DriveStatus.ErrorStop No obstante, vemos que a la hora de configurar los Placeholders desde la pantalla de visualización principal configuramos el Placeholder Visu_axe como Main.Gest_X para el control relativo a la pantalla de visualización secundaria de la izquierda y Main.Gest_Y para el de la derecha. Es decir, en realidad el piloto Paro Emergencia del control de la izquierda se iluminará según el valor de la variable Main.Gest_X. FB_DriveStatus.ErrorStop mientras que el de la derecha lo hará según el valor de la variable Main.Gest_Y. FB_DriveStatus.ErrorStop.

www.infoPLC.net



Los objetos Gest_X y Gest_Y son llamadas a un bloque de funciones:

Este bloque de funciones contiene la siguiente secuencia de instrucciones:

El segundo Placeholder, como es Eje X para el control izquierdo y Eje Y para el derecho se toman como constantes tipo string ya que no figuran como salidas de ningún bloque de funciones.

Main.Gest_X

Main.Gest_Y

Main.Gest_X.FB_DriveStatus.errorstop o

Main.Gest_Y.FB_DriveStatus.errorstop

www.infoPLC.net



Respecto al campo indicador de posición del eje la variable utilizada era $Visu_pos$.Position cuando creamos la pantalla de visualización secundaria pero como a la hora de definir los Placeholder asignamos Main.FB_PosicionX para el control izquierdo y Main.FB_PosicionY para el derecho tenemos que en realidad el control izquierdo muestra el valor de Main.FB_PosicionX.Position y el derecho Main.FB_PosicionY.Position. Estos controles se encuentran en el programa principal:

El resultado es que al arrancar el programa ambos controles muestran información distinta: el de la izquierda muestra información relativa al eje X mientras que el de la derecha al Y. No hemos tenido que crear dos pantallas idénticas cada una con las variables de un eje u otro sino que sólo hemos creado una única pantalla de visualización genérica que posteriormente hemos reutilizado para mostrar información de uno u otro eje según nos convenía:

www.infoPLC.net



10.5.- Mostrar y ocultar objetos Ahora vamos a jugar un poco con la visibilidad de controles. Lo primero que vamos a hacer es crear otro objeto cuyo texto será Activado

Hacemos clic tanto en el objeto cuyo texto es Desactivado como en el que es Activado y modificamos la celda Invisible dentro de la sección Variables introduciendo como variable Activar la cual se encuentra declarada dentro del programa Main.

Como se observa en el caso del objeto Desactivado será invisible cuando la variable Activar se encuentre a TRUE mientras que el objeto Activado funcionará a la inversa porque la variable utilizada, la misma usada en el otro objeto, se encuentra negada con la instrucción NOT. Si ahora arrastramos el objeto Activado sobre el Desactivado (uno encima del otro) parecerá que el texto cambia según el valor de la variable Activar.

www.infoPLC.net



10.6.- Modificar color de fondo También es posible modificar el color de fondo de un objeto según el valor de una variable. Para ello simplemente se ha de utilizar la celda Change Color.

1.- Hacer Clic sobre el objeto cuyo color de fondo deseamos modificar mediante el uso de una variable y tras seleccionar Variables en el cuadro aparecido introducimos la instrucción NOT .Main.Activar (sin olvidar añadir el punto inicial) en la celda Change Color:

2.- Posteriormente seleccionamos Color y mediante el uso de los botones Inside modificamos el Color y el Alarm Color en verde y rojo respectivamente:

Cuando .Main.Activar sea TRUE como la expresión se encuentra negada el equivalente será FALSE y por tanto no se cambiará el color, el color por defecto será Verde. Cuando .Main.Activar sea FALSE el valor negado será TRUE y se cambiará el color del círculo al color que se haya definido como Alarm Color, en este caso Rojo. Por tanto, según el valor de la variable asociada el icono que representa un piloto cambiará a Verde para indicar que el eje se encuentra activado o bien a Rojo para indicar que se encuentra desactivado.

www.infoPLC.net



10.7.- Modificar color de texto Otras opciones interesantes serían modificar el color del texto y no del fondo. Curiosamente debe hacerse de forma distinta, no es posible cambiar entre dos colores predefinidos mediante el uso de una variable tipo Bool como tenía lugar con el fondo sino que se hace asignando directamente el color deseado sobre la opción adecuada:

NOTA: En este caso la matriz ColorTexto[1] del programa Main contiene el color que deseamos adopte el texto en formato RGB.

Por ejemplo:

ColorTexto[1]:=16#000000 (negro) ColorTexto[1]:=16#0000FF (rojo).

El formato es, por tanto 16#BBGGRR (siendo BB=Azul, GG=Verde, RR=Rojo)

www.infoPLC.net



10.8.- Comportamiento ante un evento Otra información importante es que deseamos hacer cuando se pulsa sobre un objeto, podemos cambiar el valor de una variable, visualizar otra página o bien ejecutar una secuencia de órdenes. Tenemos varias posibilidades:

NOTA: En este caso cada vez que pulsemos sobre el objeto se invertirá el valor del contenido de la variable .Main.Habilitar. Si originalmente es TRUE pasará a ser FALSE y viceversa. La variable debe ser obligatoriamente tipo Bool.

NOTA: En este caso mientras se mantenga pulsado el ratón sobre el objeto el valor de la variable .Main.Habilitar pasará a ser TRUE y cuando se deje de pulsar volverá a ser FALSE (a menos que se haya seleccionado la opción Tap FALSE). La variable debe ser obligatoriamente tipo Bool.

NOTA: Es de utilidad cuando se desea navegar entre diversas página de visualización. En este caso al pulsar sobre el objeto la pantalla de visualización actual quedará oculta y en su lugar se mostrará la de nombre SQ_Demo. Debe indicarse como dato el nombre de una pantalla de visualización válida.

www.infoPLC.net



NOTA: Esta opción es bastante interesante pues nos permite ejecutar un microprograma. Aunque las posibilidades de este microprograma apenas se reducen a meras asignaciones se pueden realizar bastantes cosas ya que podemos vincular las variables involucradas para mostrar, ocultar, modificar colores y saltos de página.

NOTA: En el desplegable superior se selecciona la instrucción que se desea ejecutar (en este caso una asignación). Posteriormente aparecen los elementos necesarios para efectuar la instrucción seleccionada. Por ejemplo podemos escribir .Main.VerDetalle en la celda izquierda y TRUE en la derecha. Con el botón ADD añadiremos la nueva instrucción al programa (con los otros botones podemos eliminar una instrucción o subir o bajar un nivel la línea de programa seleccionada)

OJO: La ejecución no tiene lugar en tiempo de ejecución por lo que si las dos últimas líneas fueran:

.Main.IndOrden:=1 .Main.IndSecuencia:=.Main.Orden[.Main.IndOrden]

El sistema no actualizará el valor de la variable .Main.IndOrden hasta el siguiente ciclo de scan y por tanto el valor de .Main.IndSecuencia no sería correcto ya que .Main.Orden[.Main.IndOrden] posiblemente no valga lo mismo que .Main.Orden[1] aunque una línea antes se ha ordenado que .Main.IndOrden:=1.

NOTA: En este caso simplemente se indica que va a introducirse un valor cualquiera en la variable asociada y además con límites de introducción de modo que el valor introducido no puede ser ni menor de 1 ni mayor de 9999. Aunque se permite la introducción de valores decimales no es posible el uso de caracteres.

www.infoPLC.net



Icono Bitmap

10.9.- Uso de Bitmaps Podemos incluir bitmaps creados por aplicaciones de terceros con objeto de mejorar estéticamente la aplicación o bien de mostrar información de una forma más clara. Disponemos para ello de una herramienta específica accesible desde la barra de iconos de la pantalla de visualización:

Para la creación de un objeto bitmap hay que seguir los siguientes pasos:

1. Seleccionar la herramienta Bitmap en la barra de iconos superior.

2. Hacer clic con el ratón sobre la pantalla de visualización y sin soltar arrastrar el ratón hasta que el cuadro dibujado posea las dimensiones deseadas para el bitmap que se desea incluir.

3. Al soltar el botón se abrirá una ventana donde podremos escoger el bitmap.

4. El bitmap quedará incorporado al objeto añadido a la pantalla de visualización, si no posee las dimensiones adecuadas podemos redimensionarlo mediante el uso del ratón.

Podemos ir modificando las propiedades del objeto bitmap recién importado haciendo doble clic sobre él.

Un ejemplo de uso de bitmaps en una pantalla de visualización podría ser la siguiente:

Ruta donde se encuentra el bitmap.

Con el botón Transparent Color podemos seleccionar uno de los colores del bitmap y hacer que este sea transparente activando la opción Background transparent.

Muestra u oculta los márgenes del bitmap.

Embedded: La imagen queda incorporada al proyecto. Link to File: La imagen se toma de un bitmap externo (si luego se modifica su ubicación luego Motion Pro no podrá encontrarla y el objeto bitmap no se mostrará correctamente).

Anisotropic: Al escalar el área del objeto el bitmap cambiará sus dimensiones adaptándolas a la nueva área del objeto sin conservar la proporcionalidad original entre el ancho y el alto. Isotropic: Al escalar el área del objeto el bitmap cambiará sus dimensiones adaptándolas a la nueva área del objeto pero conservando la proporcionalidad original entre el ancho y el alto. Fixed: No importa lo mucho que escalemos el área del bitmap, el dibujo no se escalará manteniendo el tamaño original.

www.infoPLC.net



10.10.- Reutilización pantallas Hasta ahora se ha creado una única pantalla pero lo cómodo es crear varias individuales de modo que puedan ser llamadas desde una única pantalla general. Cuando más compleja es la aplicación más necesario es la segmentación de la pantalla que queremos visualizar en varias más pequeñas (por ejemplo una pantalla para las alarmas, otra para la graficación de información, otra para ajustar parámetros de PID, otra para introducir datos de aplicación, etc). Desde la pantalla de visualización principal y mediante el uso de botones o controles, podremos ir llamando una subpantalla u otra.

Vamos a añadir una carpeta llamada Plantillas a fin de contener las páginas que crearemos. Para ello pulsaremos con el botón derecho sobre la carpeta Visualizaciones y seleccionaremos la opción Carpeta nueva:

Una vez creada podemos modificar su nombre situándonos sobre la nueva carpeta, pulsando el botón derecho del ratón y seleccionando la opción Cambiar nombre del objeto…. Llamaremos Plantillas a la nueva carpeta.

www.infoPLC.net



A continuación iremos creando una serie de pantallas de visualización individuales y las iremos introduciendo en la nueva carpeta Plantillas. En el presente ejemplo disponemos de hasta cuatro pantallas (SQ_Datos, SQ_Grafica, SQ_Info y SQ_Tareas) introducidas en la carpeta Plantillas. Una vez creadas vamos a utilizarlas dentro de otra pantalla de visualización general a la que llamaremos SQ_Secuencia y que se encuentra fuera de la carpeta Plantillas:

Hacemos doble clic sobre SQ_Secuencia y empezaremos a llamar al resto de pantallas de usuario ya creadas. Para ello se pulsa sobre el icono Visualización y se crea una nueva visualización .

www.infoPLC.net



Observar en la imagen anterior como al soltar el ratón tras dibujar un objeto de visualización aparece un listado de visualizaciones disponibles donde se encuentran las cuatro que hemos creado anteriormente con lo que podemos añadirlas en una nueva pantalla de visualización con la ventaja de que pueden ser empleadas varias veces y en distintas pantallas. De las cuatro pantallas creadas utilizaremos la llamada SQ_Tareas para incluirla dentro de la pantalla de visualización SQ_Secuencia: Añadiremos el resto de pantallas individuales superpuestas unas encima de las otras a la izquierda de la anterior y crearemos unos rectángulos que harán de botones que nos permitirán navegar entre ellas:

Añadidos empleando el icono Rectángulo:

Añadido empleando el icono Bitmap:

Añadidos empleando el icono Visualización:

www.infoPLC.net



NOTA: Aunque existe una herramienta específica para la creación de botones se ha preferido crear los botones con la herramienta de creación de rectángulos ya que a un rectángulo se le puede cambiar el color de fondo y por tanto es más estético que un botón.

Una vez pasemos a modo ONLINE el aspecto de la pantalla SQ_Secuencia será parecida a la mostrada en la siguiente imagen:

Desde esta única pantalla de visualización podemos controlar la totalidad de la aplicación de una forma más cómoda, rápida y sencilla.

www.infoPLC.net



11.- EXPORTACION / IMPORTACION PROYECTOS FORMATO ASCII Existe la posibilidad de poder exportar/importar el proyecto en formato ASCII. Esto es especialmente útil cuando se desean realizar modificaciones o bien crear proyectos mediante entornos de terceras personas, como por ejemplo el SGS, que luego puedan ser abiertos y compilados por Codesys.

11.1.- Exportación Únicamente se utiliza la opción Exportar del menú superior Proyecto.

Tras seleccionar la opción Exportar se abrirá una ventana donde se nos preguntará que queremos exportar y si queremos generar un único fichero de exportación o varios (indicamos que queremos exportar todo y que sólo nos interesa un único fichero de exportación). Tras pulsar el botón Aceptar se abrirá otro cuadro donde se nos preguntará con que nombre queremos exportar el fichero de proyecto en formato ASCII (observar que tendrá extensión EXP) lo cual tendrá lugar tras pulsar sobre el botón Guardar.

www.infoPLC.net



El fichero creado tiene una estructura bastante particular cuyo análisis escapa del cometido del presente documento pero dado que es un formato ASCII puede ser “descifrado” y posteriormente editado mediante programas externos para, por ejemplo, automatizar la creación de programas desde un entorno más amigable que Codesys.

Por ejemplo, en la imagen siguiente, puede verse un programa denominado Habilitar formado por un FB con dos únicas entradas (Run e Izquierdo).

La sección del archivo en formato ASCII que describe este mismo programa es el siguiente:

(* @NESTEDCOMMENTS := 'Yes' *) (* @PATH := '' *) (* @SYMFILEFLAGS := '2048' *) PROGRAM Habilitar VAR Lexium15: MC_Power; END_VAR VAR_INPUT Run: BOOL; END_VAR (* @END_DECLARATION := '0' *) _CFC_BODY _ELEMENT _ID: 12 _MACROID: -1 _POS: 4, 3 _TYPE: _INPUT _TEXT: Run _NEGATE: 0 _CONNECTOR: _END _ELEMENT _ID: 10 _MACROID: -1 _POS: 8, 1 _TYPE: _BOX _INSTANCE: 1 _INSTANCENAME: Lexium15 _TYPENAME: MC_Power _ENENO: 0 _INPUTS: 4 _IN _INPUTID: 12 _INPUTIDX: 0 _NEGATE: 0 _END _IN _INPUTID: 12 _INPUTIDX: 0 _NEGATE: 0 _END

_IN _INPUTID: 12 _INPUTIDX: 0 _NEGATE: 0 _END _IN _INPUTID: 11 _INPUTIDX: 0 _NEGATE: 0 _END _OUTPUTS: 3 _OUT _NEGATE: 0 _CONNECTOR: _END _OUT _NEGATE: 0 _CONNECTOR: _END _OUT _NEGATE: 0 _CONNECTOR: _END _PARAMETERS: 0 _END _ELEMENT _ID: 11 _MACROID: -1 _POS: 6, 6 _TYPE: _INPUT _TEXT: Izquierdo _NEGATE: 0 _CONNECTOR: _END END_PROGRAM

www.infoPLC.net



11.2.- Importación Para importar un fichero previamente grabado (o creado) en formato ASCII tienen que tenerse en cuenta ciertas normas básicas:

1. Debe abrirse un nuevo proyecto “vacio” definiendo el tipo de PLC que se controlará el cual debe coincidir con el mismo PLC que controla el proyecto ASCII (de lo contrario existirán librerías que no serán cargadas adecuadamente). Si el fichero ASCII corresponde a un proyecto pensado para Lexium Controller V01 ha de abrirse Codesys para controlar un Lexium Controller V01.

2. Tras crear el nuevo proyecto en Codesys debe eliminarse todo programa creado automáticamente:

Eliminar Programa

www.infoPLC.net



3. Eliminar todas las librerías que se crean por defecto ya que las referencias a las librerías utilizadas se encuentran en el fichero ASCII y podrían darse problemas en las versiones de las librerías utilizadas en el proyecto vacio y en el proyecto a cargar.

4. Por último hay que indicar a Codesys las rutas de todas las librerías utilizadas en el archivo ASCII ya que de lo contrario no podrán ser encontradas. Esto se hace desde el menú Proyecto y opción Opciones:

Eliminar Librerías

Añadir ruta Librerías

www.infoPLC.net



5. Llegados a este punto ya puede cargarse el proyecto en formato ASCII mediante la opción Importar del menú Proyectos.

6. Antes de compilar el programa recién importado hay que vigilar que las opciones de compilación sean las deseadas pues estas no se guardan en el proyecto ASCII cuando se exporta. En especial prestar especial atención a la opción “Compilar LREAL como REAL” ya que debería estar seleccionada y no lo está cuando se importa un fichero ASCII

www.infoPLC.net



12.- COMUNICACIONES En este capítulo se irán tratando de las formas conocidas de comunicar un elemento externo con la Lexium Controller de modo que puedan intercambiarse datos. Hay varias formas:

12.1.- Modbus RS485 Todos los modelos de Lexium Controller disponen de serie de un puerto RS485 que actua como Esclavo de Modbus y que puede ser utilizado para conectar distintos tipos de periféricos.

Las características del puerto pueden alterarse desde la pestaña Recursos y la opción Explorador PLC.

En la línea de comandos podremos utilizar las siguientes posibilidades para ajustar el puerto RS485: Mbusinf : Muestra información sobre el setting actual del puerto Mbaddr<nº>: Dirección del puerto, en <nº> ( 1…31) ( 0 es esclavo desactivado) Mbusbaudrate <baud>: Asigna la velocidad de comunicación (9600,19200,38400) Para todas las configuraciones el protocolo utiliza 8 bits de datos, sin paridad y 1 bit de stop

Puerto RS485 Herramienta de Programación: Cable PowerSuite (Ref. VW3A8106) Conexión HMI: Rango de cables Magelis. Terminal Gráfico Remoto: Cable Terminal ATV71 Opción Bluetooth Solución completa de cableado incluyendo repartidores y derivaciones

Línea de comandos

Ventana Respuestas

www.infoPLC.net



Para poder acceder a las diferentes variables, bien para modificar su valor bien para leerlo, es preciso, primero, direccionarlas adecuadamente:

Como se observa, para direccional variables estas deben ser Globales y utilizarse la instrucción AT para vincular una variable de programa con un registro de memoria que será el que utilizará el elemento remoto para la comunicación. Notar como aunque la variable se asigna a un registro de tipo WORD, la variable puede definirse como INT a fin de poder trabajar con números negativos. En el ejemplo también se observa un ejemplo de acceso al bit y que todos los direccionamientos se realizan iniciando las variables con algún valor por defecto.

12.2.- Conexión HMI por RS485 Por poner un simple ejemplo a lo detallado en el apartado anterior para conectar un Terminal HMI vía Modbus RTU a través del puerto RS485. La dirección del equipo destino, el LMC, puede especificarse desde el Explorador PLC (en este caso se ha fijado a 2) Y por tanto en Vijeo Designer:

Variable de programa

Registro donde quedará direccionada la variable de programa

www.infoPLC.net



12.3.- I/O Scanning El protocolo I/O Scanning es un protocolo Modbus sobre TCP/IP que permite intercambiar 10 palabras de entrada y 10 de salida de forma cíclica entre la LMC y un dispositivo remoto que admita este servicio.

Para configurar correctamente este servicio primero hay que configurar en el navegador de dispositivos la existencia de este servicio:

Ethernet TCP/IP

Read Write

Write Read ETH_O0 AT %QW2 ETH_I0 AT %IW2

ETH_O1 AT %QW3 ETH_I1 AT %IW3

… … ETH_O10 AT %QW12 ETH_I10 AT %IW12

www.infoPLC.net



Los pasos a seguir serían los siguientes: 1. Ir a pestaña Recursos. 2. Doble clic sobre Configuración del Mando. 3. Botón derecho sobre icono Lexium Controller V01. 4. Seleccionar Anexar Subelemento. 5. Escoger Ethernet.

Tras añadir el subelemento Ethernet tendremos disponibles 10 palabras de entrada y 10 de salida que podremos configurar como deseemos. Por defecto estas 10 palabras tienen asignado un nombre que a todos los efectos se comporta como una variable global ETH_I0 a ETH_I10 para las entradas y ETH_O0 a ETH_O10 para las salidas:

Ahora se debería configurar el PLC, el cual puede ser cualquiera que ofrezca el servicio I/O Scanning: NOTA : (ETH_I0 y ETH_O0 son palabras reservadas y no pueden ser utilizadas):

10 I/O de intercambio con un

PLC con servicio I/O scanner

…%MW10 →→→→ … ETH_O10

%MW1 →→→→ ETH_O1

%MW0 →→→→ ETH_O0

…%MW110 ←←←← …ETH_I10

%MW101 ←←←← ETH_I1

%MW100 ←←←← ETH_I0

Premium/M340 LMC

MB addr

www.infoPLC.net



Por último hay que activar el servicio desde el Servidor Web de la LMC. Para ello utilizaremos cualquier navegador de Internet y accederemos al Servidor Web de la LMC mediante su IP:

Como por defecto el IOScanning se encuentra desactivado lo activaremos:

USER por defecto

www.infoPLC.net



Y por último podremos activar o desactivar el servicio desde programa Motion Pro mediante la variable IOScan_Activation que se crea automáticamente al añadir el subelemento Ethernet dentro de la categoría Ethernet Parameters:

www.infoPLC.net



13.- PROBLEMAS Y ERRORES

13.1.- Errores de representación en pantallas Visualización A veces sucede que una visualización que a priori parece correcta se muestra de forma inadecuada, por ejemplo, en el siguiente ejemplo se muestra a la izquierda la representación correcta y a la derecha una posible representación inadecuada (desaparecen ciertos campos a pesar de que no se ha utilizado ninguna opción de ocultación)

La solución parece ser la selección de la opción Apply to all visual elements dentro de la sección Security.

Correcto Incorrecto

www.infoPLC.net



13.2.- Pérdida inexplicable de las comunicaciones En ocasiones tras arrancar el programa mediante F5 (Run) todo parece ir bien y de pronto el PC deja de comunicar con el Lexium Controller. Cualquier intento posterior de conexión es inútil y sólo queda apagar el Lexium Controller para que éste pierda el programa y volver a transmitírselo. Se ha detectado que esto puede ocurrir cuando el programa posee un error que no es de sintaxis (los errores de sintaxis generalmente aparecen a la hora de compilar) como por ejemplo intentar acceder a un índice inexistente de un array o una división entre 0. En estos casos se recomienda añadir un Breakpoint y analizar el comportamiento del programa línea a línea (ejecución paso a paso) hasta localizar primero la sección y luego la instrucción donde se produce el error.

13.3.- Error inexplicable tipo b404 en los Lexium05 En programas muy sencillos se suele producir un error extraño en los Lexium05 tras ponerlos en RUN. Esto suele presentarse cuando justo después de encontrarse en RUN se intenta alguna operación de transmisión de información por el bus CAN o ejecutar una instrucción que implique movimiento. La solución es aplicar un retardo tras recibir el OK de Lexium05 involucrados antes de proseguir con secciones de programa que impliquen comunicaciones o movimientos:

Pequeña temporización antes de seguir con el programa.

www.infoPLC.net



13.4.- Se corta la comunicación al transmitir un proyecto Se ha detectado que una vez compilado un programa a la hora de transmitirlo hacia la LMC la transmisión se corta antes de finalizar generándose una pérdida de comunicaciones general y necesitándose realizar un reset de la LMC antes de volver a intentar una comunicación con ella. Este tipo de fallo suele presentarse cuando se utiliza un EDS y la primera dirección declarada no es correcta. En la imagen que se observa a continuación vemos que la primera dirección es %QB1 pero aunque a priori parece correcta porque el programa compila correctamente en la práctica la LMC no lo acepta. La primera palabra aceptable se puede calcular fácilmente cogiendo la primera palabra en formato Double, %QD1 (de 32 bits), haciendo la equivalencia primero a Word, %QW2 (de 16 bits), y finalmente a Byte, %QB4 (de 8 bits). Así pues la primera palabra en formato Byte no puede ser %QB1 sino %QB4

Como en este caso %QB1 forma parte de las direcciones de salida modificamos a mano dicha dirección introduciendo %QB4 en lugar de %QB1 y recompilamos para mover el resto de direcciones. A partir de aquí los diferentes EDS que se vayan añadiendo, al direccionarse secuencialmente a partir de la última dirección utilizada, no presentarán este problema.

www.infoPLC.net



13.5.- La tabla CAM hace que el eje “Vibre” Se ha detectado que al utilizar para definir una tabla CAM la estructura SMC_CAMTable_UINT_128_2 o cualquiera similar que utilice valores enteros (no decimales) el eje, al tener que seguir valores no reales sino redondeados, se desplace respecto al eje maestro de forma anómala, como a golpes. Esto es así porque al redondear los valores el comportamiento no sigue lo que la teoría marca. Observar por ejemplo las siguientes tablas: La de la derecha es igual que la de la izquierda solo que se toman los valores como enteros en lugar de cómo reales por lo que el eje, al intentar seguirlos, tendrá un error. En los primeros puntos, por ejemplo, el eje esclavo debería desplazarse pero sin embargo al tomar los valores como enteros en realidad se queda quieto. Esto es tanto más evidente cuanto más altas sean las unidades de usuario: si se trabaja con décimas de milímetro la vibración se notará menos que si se trabaja con milímetros. Lo recomendable, en estos casos es trabajar con estructuras de tablas CAM que permitan números decimales, por ejemplo: SMC_CAMTable_LREAL_128_2. NOTA : No utilizar la estructura SMC_CAMTable_REAL_128_2 pues el comportamiento es totalmente erróneo (si bien al compilar el programa no se genere ningún tipo de error de compilación).

www.infoPLC.net

Knowledge Base Motion Pro: Conceptos Básicos · 2013. 6. 30. · Knowledge Base Motion Pro:...

Documents

Transcript of Knowledge Base Motion Pro: Conceptos Básicos · 2013. 6. 30. · Knowledge Base Motion Pro:...