Generalidades · 2003. 3. 19. · Title: Generalidades Author: SM Created Date: 3/19/2003 10:24:19...

Manual de referencia Versión 3

de los post-procesadores

www.irai.com

Manual de referencia de los post-procesadores

GENERALIDADES.............................................................................................................................................. 7 CONFIGURACIÓN.............................................................................................................................................. 8

ARCHIVOS DE CONFIGURACIÓN........................................................................................................................... 8 Sistema........................................................................................................................................................... 8 Correspondencias de variables ..................................................................................................................... 8 Código constructor de inicio ......................................................................................................................... 8 Código constructor de fin .............................................................................................................................. 8

CONFIGURACIÓN PREDETERMINADA................................................................................................................... 8 Modificar las declaraciones predeterminadas .............................................................................................. 9 Utilizar las declaraciones predeterminadas.................................................................................................. 9

VISUALIZAR Y MODIFICAR LOS ELEMENTOS DE CONFIGURACIÓN........................................................................ 9 SISTEMA.............................................................................................................................................................. 9

Configuración material ................................................................................................................................. 9 Configuración de software ............................................................................................................................ 9 Opciones de generación de código................................................................................................................ 9 Declaraciones de variables ......................................................................................................................... 10 Otros elementos ........................................................................................................................................... 10 Ver el elemento « Sistema » bajo forma de texto......................................................................................... 10 Mostrar los elementos de sistema................................................................................................................ 11

CORRESPONDENCIAS DE VARIABLES ................................................................................................................. 11 Asignación unitaria ..................................................................................................................................... 12 Asignación lineal ......................................................................................................................................... 12 Asignación automática ................................................................................................................................ 12 Tipos de variables suprimir AUTOMGEN .................................................................................................. 13 Mostrar los elementos de correspondencias de variables ........................................................................... 15 Modificar un elemento de correspondencia de variables............................................................................ 17 Añadir un elemento de correspondencia de variables................................................................................. 17 Suprimir un elemento de correspondencias de variable.............................................................................. 19 Asociar un bit de AUTOMGEN a un bit sistema de un destino................................................................... 19 Asociar una tabla de palabras de AUTOMGEN a una tabla de palabras fijas del destino ........................ 20 Asociar palabras de AUTOMGEN a entradas o salidas analógicas de un destino .................................... 20 Asociar una tabla de bits de AUTOMGEN a una tabla de bits de un destino............................................. 21 Ver las correspondencias de variables bajo forma de texto........................................................................ 21

CÓDIGO CONSTRUCTOR DE INICIO, CÓDIGO CONSTRUCTOR DE FIN.................................................................... 22 Referencia a una variable AUTOMGEN..................................................................................................... 22 Referencia a un símbolo de la aplicación AUTOMGEN............................................................................. 22 Definición y referencia a un label ............................................................................................................... 22

INSERTAR CÓDIGO CONSTRUCTOR EN UNA APLICACIÓN.................................................................................... 22 ELECCIÓN DE OPCIONES DE CONEXIÓN.............................................................................................................. 22 ELECCIÓN DE UN MODO DE CONEXIÓN .............................................................................................................. 23 PARAMETRAJE DEL MÓDULO DE COMUNICACIÓN.............................................................................................. 23

POST-PROCESADOR PL7............................................................................................................................... 24 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 24 MODO DE GENERACIÓN DE UN ARCHIVO EJECUTABLE....................................................................................... 25

Modo de generación directa del archivo binario ........................................................................................ 25 Modo de generación de un archivo « .FEF » .............................................................................................. 27

UTILIZACIÓN DE TAREAS DE INTERRUPCIONES.................................................................................................. 29 EJEMPLOS ESPECÍFICOS ..................................................................................................................................... 29

Entradas / salidas analógicas...................................................................................................................... 29 Contador rápido TSX 37-10 ........................................................................................................................ 29 Contador rápido TSX 37-10 utilizado en descuento.................................................................................... 29 Contador rápido TSX 37-22 ........................................................................................................................ 29 ASI ............................................................................................................................................................... 30 MAGELIS .................................................................................................................................................... 30

POST-PROCESADOR PL72............................................................................................................................. 31 ELECCIÓN DEL TIPO DE AUTÓMATA................................................................................................................... 31 ELEMENTOS SINTÁCTICOS ESPECÍFICOS ............................................................................................................ 31

AUTOMGEN7 3 (C)opyright 2003 IRAI


Llamado de los bloques función PL72......................................................................................................... 31 Utilización de la tarea rápida ..................................................................................................................... 33

MÓDULO DE COMUNICACIÓN ............................................................................................................................ 33 EJEMPLOS ESPECÍFICOS ..................................................................................................................................... 33

Entradas / salidas analógicas...................................................................................................................... 34 Contador rápido .......................................................................................................................................... 34 Bloques texto y xbt....................................................................................................................................... 35 Bloques texto y UNITELWAY ...................................................................................................................... 37

POST-PROCESADOR S7200............................................................................................................................ 40 ELECCIÓN DEL TIPO DE CPU ............................................................................................................................. 40 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 40 EJEMPLO ESPECÍFICO......................................................................................................................................... 40

POST-PROCESADOR ABB.............................................................................................................................. 41 ELECCIÓN DEL TIPO DE AUTÓMATA................................................................................................................... 41

Autómata AC31 ........................................................................................................................................... 41 Autómata CS31............................................................................................................................................ 41

MÓDULO DE COMUNICACIÓN ............................................................................................................................ 41 UTILITARIO ....................................................................................................................................................... 41 EJEMPLOS ESPECÍFICOS ..................................................................................................................................... 41

Entradas / salidas analógicas...................................................................................................................... 41 Interrupciones.............................................................................................................................................. 41

POST-PROCESADOR GE-FANUC / ALSPA................................................................................................. 42 ELECCIÓN DEL TIPO DE AUTÓMATA................................................................................................................... 42 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 42 UTILITARIO ....................................................................................................................................................... 42

POST-PROCESADOR STEP5 .......................................................................................................................... 43 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 43 ESTRUCTURA DE LA APLICACIÓN ...................................................................................................................... 43

Elección de los bloques de programas a utilizar......................................................................................... 45 Elección del bloque de datos ....................................................................................................................... 45

ELECCIÓN DEL TIPO DE PROCESADOR................................................................................................................ 46 ASOCIACIÓN DEL CÓDIGO ESCRITO EN UN FOLIO A UN BLOQUE PROGRAMA...................................................... 46 SINTAXIS ESPECÍFICAS ...................................................................................................................................... 46

Definición de bloques .................................................................................................................................. 46 POST-PROCESADOR TSX 07 ......................................................................................................................... 49

MÓDULO DE COMUNICACIÓN ............................................................................................................................ 49 POST-PROCESADOR PS3-PS4 ....................................................................................................................... 50

MÓDULO DE COMUNICACIÓN ............................................................................................................................ 50 POST-PROCESADOR PS4 ............................................................................................................................... 51

MÓDULO DE COMUNICACIÓN ............................................................................................................................ 51 TRANSFERENCIA DE LOS PROGRAMAS AL SOFTWARE SUCOSOFT S40 DE MOELLER ................................... 51

Procedimiento a seguir para importar el archivo generado por AUTOMGEN al software MOELLER y luego introducirlo en el autómata ............................................................................................................... 52

POST-PROCESADOR RPX.............................................................................................................................. 56 ELECCIÓN DEL TIPO DE AUTÓMATA................................................................................................................... 56 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 56 UTILITARIO ....................................................................................................................................................... 56

POST-PROCESADOR PL71............................................................................................................................. 57 ELECCIÓN DEL TIPO DE AUTÓMATA................................................................................................................... 57 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 57 TAREA CONTADOR RÁPIDO................................................................................................................................ 57



EJEMPLOS ESPECÍFICOS ..................................................................................................................................... 57 Contador...................................................................................................................................................... 57 Contador rápido .......................................................................................................................................... 58

POST-PROCESADOR PB................................................................................................................................. 59 ELECCIÓN DEL TIPO DE AUTÓMATA................................................................................................................... 59 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 59 SINTAXIS ESPECÍFICAS ...................................................................................................................................... 59

POST-PROCESADOR SMC ............................................................................................................................. 61 ELECCIÓN DEL TIPO DE AUTÓMATA................................................................................................................... 61 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 61 SINTAXIS ESPECÍFICAS ...................................................................................................................................... 61

POST-PROCESADOR S7300............................................................................................................................ 62 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 62 SINTAXIS ESPECÍFICAS ...................................................................................................................................... 62

Definición de las variables de un bloque..................................................................................................... 63 Llamado de los bloques ............................................................................................................................... 63

IMPORTACIÓN AL SOFTWARE SIMATIC DE SIEMENS..................................................................................... 64 ESTRUCTURA DEL CÓDIGO GENERADO .............................................................................................................. 66

Elección de los bloques de programas a utilizar......................................................................................... 68 ASOCIACIÓN DEL CÓDIGO ESCRITO EN UN FOLIO A UN BLOQUE PROGRAMA...................................................... 68 EJEMPLOS ESPECÍFICOS ..................................................................................................................................... 68

Liamado de un bloque STEP7 ..................................................................................................................... 68 Utilización de un bloque OB ....................................................................................................................... 68

POST-PROCESADOR OMRON ...................................................................................................................... 69 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 69 TRANSFERENCIA DE LAS APLICACIONES AL SOFTWARE CX-PROGRAMMER................................................. 69 SINTAXIS ESPECÍFICA ........................................................................................................................................ 71 ASOCIACIÓN DEL CÓDIGO ESCRITO EN UN FOLIO A UN BLOQUE PROGRAMA...................................................... 72 EJEMPLO ESPECÍFICO......................................................................................................................................... 72

POST-PROCESADOR ALSPA......................................................................................................................... 73 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 73

POST-PROCESADOR ZELIO ......................................................................................................................... 74 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 74

POST-PROCESADOR FESTO......................................................................................................................... 75 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 75 GENERACIÓN DE ARCHIVO BINARIO .................................................................................................................. 75 IMPORTACIÓN AL SOFTWARE FESTO ............................................................................................................... 75

POST-PROCESADOR ALLEN-BRADLEY.................................................................................................... 76 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 76 TRANSFERENCIA DE LOS PROGRAMAS AL SOFTWARE RS-LOGIX 500 DE ROCKWELL.................................... 76

POST-PROCESADOR MITSUBISHI.............................................................................................................. 78 ELECCIÓN DEL TIPO DE AUTÓMATA................................................................................................................... 78 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 78 TRANSFERENCIA DE LOS PROGRAMAS AL SOFTWARE FX-WIN DE MITSUBISHI ............................................ 78 TRANSFERENCIA DE LOS PROGRAMAS AL SOFTWARE GX-DEVELOPPER DE MITSUBISHI .......................... 79

POST-PROCESADOR TWIDO........................................................................................................................ 80 ELECCIÓN DE LA CONFIGURACIÓN DEL AUTÓMATA .......................................................................................... 80 MÓDULO DE COMUNICACIÓN ............................................................................................................................ 80



Generalidades Los post-procesadores son módulos de software que permiten traducir archivos de código pivote generados por el compilador AUTOMGEN a archivos ejecutables en un destino, al tiempo que aseguran la conexión dinámica al destino. La palabra « Destino » designa de manera genérica un sistema programable capaz de ejecutar una aplicación. Un post-procesador de AUTOMGEN permite programar un tipo o un conjunto de tipos de destinos (generalmente una familia de autómatas que comparten el mismo lenguaje de programación es programable con el mismo post-procesador en AUTOMGEN). Este manual contiene en su primera parte una serie de nociones fundamentales comunes a todos los post-procesadores. Luego se ofrecen informaciones específicas sobre las implementaciones hechas por cada post-procesador.



Configuración Le invitamos a prestar la mayor atención posible a las explicaciones de este capítulo.

Archivos de configuración Cada post-procesador utiliza cuatro elementos de configuración de manera específica.

Sistema Contiene la configuración material del destino, la configuración de software, opciones que permiten modificar el modo en que el post-procesador genera código, y también declaraciones de variables reservadas (para el uso interno del post-procesador). Según el destino habrá que modificar la configuración material contenida en este elemento (por ejemplo, un tipo de UC o una configuración de tipo de tarjetas de entradas / salidas).

Correspondencias de variables El saber dominar la correspondencia de las variables es esencial para el uso de los post-procesadores. Cuando el post-procesador traduce un archivo del lenguaje pivote de AUTOMGEN a un lenguaje destino específico, debe atribuir las variables de AUTOMGEN a variables del destino. Este elemento contiene la descripción precisa de la atribución de las variables. Al modificarlo, se tiene el control total sobre el uso del espacio de las variables del destino.

Código constructor de inicio Este elemento contiene lenguaje máquina del destino que se colocará al principio del código ejecutable generado por el post-procesador (ejecutado al principio del ciclo).

Código constructor de fin Este elemento contiene lenguaje máquina del destino que se colocará al final del código ejecutable generado por el post-procesador (ejecutado al final del ciclo).

Configuración predeterminada Al crear el proyecto, en éste se duplican elementos de configuración predeterminados. Las modificaciones aportadas a los elementos de configuración del proyecto no afectan a las declaraciones predeterminadas.



Modificar las declaraciones predeterminadas Haga clic con el botón derecho del ratón en el elemento « Configuración / Post-procesador / <nombre del destino> / … » y elija « Definir como configuración predeterminada ». El elemento de configuración del proyecto se define entonces como configuración predeterminada (anulación de la configuración predeterminada).
Atención: esta operación es irreversible. Sólo la reinstalación del post-procesador permite restaurar el elemento de configuración.
Utilizar las declaraciones predeterminadas Haga clic con el botón derecho del ratón en el elemento « Configuración / Post-procesador / <nombre del destino> / … » y elija « Utilizar la configuración predeterminada ». El elemento de configuración del proyecto queda entonces anulado por la configuración predeterminada.

Visualizar y modificar los elementos de configuración A los archivos de configuración se accede haciendo doble clic en el elemento « Configuración / Post-procesadores / <nombre del destino> / … ». Se abre una ventana que permite visualizar y modificar el elemento de configuración.

Sistema Este elemento de configuración es muy específico de cada post-procesador.

Configuración material Esta zona (opcional) debe modificarse para determinar la configuración material de un destino (tipo de CPU, tarjetas de entradas / salidas, por ejemplo).

Configuración de software Esta zona (opcional) debe modificarse para determinar características propias de la configuración de la aplicación (el valor de la vigilancia, por ejemplo).

Opciones de generación de código Esta zona contiene ajustes que conciernen el método de traducción que debe utilizar el post-procesador (reservados a los especialistas). El número de opciones puede



diferir de un post-procesador a otro. A continuación se listan algunas opciones comunes a todos los post-procesadores :

« Optimizar el código generado » Generalmente ajustado en « Sí ». El ajuste en « No » puede facilitar el análisis del código generado.

« No generar el código de evolución de las etapas Grafcet » Ajustado en « No » de manera predeterminada. Si se ajusta en « Sí », en el elemento « Código constructor de fin » se deben escribir las instrucciones que permiten copiar estados inmediatos de variables booleanas a los estados pasados (ver el capítulo ) Gestión de las variables booleanas de AUTOMGEN

« No generar el código de evolución de los bits usuarios » Idéntica a la opción anterior pero aplicada a los bits usuarios (variables « U ») de AUTOMGEN.

Declaraciones de variables Son declaraciones de variables utilizadas internamente por el post-procesador. Sólo los especialistas pueden modificar este elemento.

Otros elementos Puede haber otros elementos específicos de cada post-procesador.

Ver el elemento « Sistema » bajo forma de texto

Al hacer clic en el icono de la barra de herramientas, se pasa del modo « arborescencia » al modo « texto » (formato de las viejas versiones de AUTOMGEN). En el formato « Texto » es posible copiar y pegar informaciones entre los archivos de configuración.

Las modificaciones en modo « texto » deben estar reservadas a

A

los especialistas. Las modificaciones intempestivas pueden causar errores de compilación difíciles de localizar para un neófito.

UTOMGEN7 10 (C)opyright 2003 IRAI


Mostrar los elementos de sistema Al hacer doble clic en « Configuración / Post-procesadores / <nombre del post-procesador> / Sistema » se abre una ventana con el siguiente aspecto.

Ejemplo de configuración de sistema

Correspondencias de variables El saber dominar la correspondencia de las variables es esencial para el uso de los post-procesadores. Cuando el post-procesador traduce un archivo del lenguaje pivote de AUTOMGEN a un lenguaje destino específico, debe atribuir las variables de AUTOMGEN a variables del destino. Por ejemplo, si usted utilizó la palabra 200 de AUTOMGEN en su aplicación (se llama M200 o %MW200 en AUTOMGEN) esta palabra debe tener una existencia en la memoria del destino e identificarse con un nombre propio de ese destino. AUTOMGEN propone tres tipos de declaración de correspondencia de variables:

- asignación unitaria, - asignación lineal, - asignación automática.



La correspondencia de las variables para un proyecto se constituye de « n » asignaciones, cada una de las cuales utiliza uno de estos tres tipos.

Asignación unitaria Permite asociar una variable AUTOMGEN a una variable del destino. Es la más simple de las declaraciones. Debe utilizarse únicamente si es necesaria una sola declaración. Esta declaración utiliza dos informaciones: el nombre de la variable AUTOMGEN y el nombre de la variable del destino. « Asocia esta variable de AUTOMGEN a esta variable del destino »: así puede resumirse la asignación unitaria.

Asignación lineal Es una forma más evolucionada de la asignación unitaria. Permite asociar una serie de variables consecutivas (varias variables del mismo tipo cuyos números se suceden) de AUTOMGEN a una serie de variables consecutivas del destino. Esta asignación suele utilizarse para:

- la declaración de las variables de entradas / salidas, - la declaración de tablas de bits o palabras que deben tener una dirección fija

(para un enlace con un escritorio operador, por ejemplo). Esta declaración necesita tres informaciones: el nombre de la primera variable AUTOMGEN, el nombre de la primera variable del destino y la dimensión de la tabla en número de variables. « Asocia en orden esta tabla de variables AUTOMGEN a esta tabla de variables del destino »: así puede resumirse la asignación lineal.

Asignación automática Es el tipo de declaración más complejo y potente. Permite asociar uno o varios tipos de variables AUTOMGEN a un conjunto de variables del destino. Esta asignación deja en manos del compilador encontrar una asignación para cada variable presente en el código generado (siempre que corresponda a uno de los tipos) de la declaración. Este tipo de declaración suele utilizarse para todas las variables de la aplicación AUTOMGEN cuyas variables asociadas en el destino no necesitan una dirección fija precisa. Esta declaración necesita tres informaciones:



- los tipos de variables AUTOMGEN (ver el capítulo ),

Tipos de variables suprimir AUTOMGEN

Tipos de variables suprimir AUTOMGEN

- el nombre de la primera variable del conjunto del destino, - el número de la última variable (incluida) del conjunto del destino.

La asignación automática es utilizada por un post-procesador sólo si no se encuentra ninguna otra declaración para una variable. Si por ejemplo una directiva de asignación lineal define la atribución para las palabras 200 a 210 de AUTOMGEN, entonces el post-procesador no utilizará la asignación automática para tratar de asignar estas palabras. Si existen varias asignaciones automáticas para un mismo tipo de variable AUTOMGEN, entonces el post-procesador utiliza el primer conjunto de variables del destino hasta la saturación, luego el segundo hasta la saturación, luego el tercero, y así sucesivamente. Si luego de utilizar todas las asignaciones automáticas hay una variable que no se puede asignar, el compilador genera un mensaje de error que indica que la variable no está definida. « Cuando encuentres uno de estos tipos de variables, utiliza una variable del destino de esta zona »: así puede resumirse la asignación automática.

Se utilizan para declarar las correspondencias de variables y son un superconjunto (ya que para alojar una variable de AUTOMGEN se puede necesitar más de una variable del destino) de los tipos de variables AUTOMGEN.

Gestión de las variables booleanas de AUTOMGEN Uno de los principios básicos para la traducción de los lenguajes booleanos por parte del compilador AUTOMGEN es el acceso a dos estados para una misma variable booleana. Este concepto hace referencia a la noción de « ciclo de ejecución »: entidad que representa la acción realizada por el destino y que consiste en leer las instrucciones de la aplicación de manera lineal (de principio a fin) y llevar a cabo los tratamientos correspondientes. Estos dos estados se definen de la siguiente manera:

1- El estado inmediato de la variable: estado escrito por la última instrucción ejecutada por el destino relacionado a esta variable o, en su defecto, estado que la variable tenía al final del último ciclo de ejecución o, en su defecto, si es el primer ciclo de ejecución, estado de inicialización de la variable.

2- El estado pasado de la variable: estado que la variable tenía al final del último

ciclo de ejecución.



Observaciones: estos dos estados son válidos sólo para la tarea principal de la aplicación. Sólo el estado inmediato tiene sentido para las tareas asíncronas. El código generado por el compilador AUTOMGEN asume lo siguiente: - una asignación de variable booleana se hace sobre su estado inmediato, - un test de variable booleana se hace sobre su estado pasado. Estas dos reglas permiten garantizar la evolución coherente de las aplicaciones booleanas y, sobre todo, respetar las reglas de evolución de los programas generados por una descripción en lenguaje Grafcet. El código generado por el post-procesador gestiona la copia de los estados inmediatos de variables en los estados pasados en fin de ciclo. Cuando en AUTOMGEN se utiliza una variable booleana, en el destino se utilizan dos. Existen tres excepciones:

1- para una entrada todo o nada, si no se utiliza ningún test de frente, se utiliza sólo el estado pasado (« bi ») (ahorro de una variable booleana),

2- para una salida todo o nada, si no se utiliza ningún test de frente, se utiliza sólo el estado inmediato (« o »),

(esto explica por qué en las directivas de asignación de variables se encuentran sólo las variables « bi » y « o »)

3- para el post-procesador ZELIO, habida cuenta de la gestión temporal de las variables (casi idéntica a la de AUTOMGEN) se utilizan sólo los estados inmediatos en el programa en lenguaje ZELIO.

Sintaxis de los elementos standard « <nombre de variable AUTOMGEN> » hace referencia al estado inmediato de una variable booleana o a una variable numérica. « b<nombre de variable AUTOMGEN> » hace referencia al estado pasado de una variable booleana.

Sintaxis especiales para los frentes « u<nombre de variable AUTOMGEN> » hace referencia al estado « frente ascendente » de una variable booleana. « d<nombre de variable AUTOMGEN> » hace referencia al estado « frente descendente » de una variable booleana.

Sintaxis especiales para las temporizaciones « tempo <número> » hace referencia al número de una temporización.



« tconsi<número> » hace referencia a la consigna de una temporización,. « tcompt<número> » hace referencia al contador de tiempo de una temporización.

Otras sintaxis especiales (reservadas a los especialistas) « ac » hace referencia al acumulador 16 bits. « al » hace referencia al acumulador 32 bits. « af » hace referencia al acumulador flotante. « cf » hace referencia al indicador de retención. « zf » hace referencia al indicador de resultado nulo. « sf » hace referencia al indicador de resultado negativo. « of » hace referencia al indicador de exceso.

Mostrar los elementos de correspondencias de variables Al hacer doble clic en « Configuración / Post-procesadores / <nombre del post-procesador> / Correspondencia de las variables » se abre una ventana con el siguiente aspecto.

Ejemplo de correspondencias de variables Observación: si un mismo post-procesador puede generar código para varios tipos de destino (varios tipos de CPUs de autómata, por ejemplo) los diferentes elementos pueden estar condicionados para el conjunto de los tipos de destinos o para un tipo



de destino en particular. Si están condicionados, se unen a líneas « Solamente para xxx ». Ver el siguiente ejemplo.

Al hacer clic en los elementos « + » de la arborescencia, las ramas se abren; con « - » se cierran.



Modificar un elemento de correspondencia de variables Haciendo clic en cada uno de los elementos, éstos se pueden modificar.

Ejemplo de cuadro de diálogo de configuración de una asignación lineal.

Añadir un elemento de correspondencia de variables Haciendo clic con el botón derecho del ratón en los elementos « Asignación … » de la arborescencia y eligiendo « Añadir » en el menú, es posible añadir una nueva asignación. Si el post-procesador gestiona varios tipos de destinos, el siguiente cuadro de diálogo permite determinar si la nueva asignación es solamente para un tipo en particular o para todos los tipos.



Asignación unitaria

Asignación lineal



Asignación automática Cabe notar que los tipos de variables AUTOMGEN deben separarse con el carácter « & ».

Suprimir un elemento de correspondencias de variable Haga clic con el botón derecho del ratón en el elemento de correspondencia de variables y elija « Suprimir » en el menú.

Asociar un bit de AUTOMGEN a un bit sistema de un destino Se necesitan dos declaraciones. Hay que asociar las dos variables de estado de un bit « U » (« u » y « bu ») al bit sistema del destino. Se deben crear dos asignaciones unitarias, por ejemplo:

Atención: al asignar la variable u y bu de AUTOMGEN al mismo bit sistema del destino, se anula la posibilidad de realizar un test de frente ascendente o descendente en la aplicación. Es posible evitar este problema utilizando la sintaxis



« ↑(u<n>) » o « ↓(u<n>) » (« <n> » representa el número del bit) en la aplicación (esta sintaxis genera un bit intermedio donde el frente se evalúa correctamente).

Asociar una tabla de palabras de AUTOMGEN a una tabla de palabras fijas del destino Para esto, es suficiente una sola declaración, por ejemplo:

AaU

A

Las palabras del destino asignadas no deben tener otras asignaciones; así se evitará asignar dos veces las mismas variables del destino a diferentes variables AUTOMGEN.

sociar palabras de AUTOMGEN a entradas o salidas nalógicas de un destino tilice declaraciones lineales, por ejemplo:



Asociar una tabla de bits de AUTOMGEN a una tabla de bits de un destino Se necesitan dos asignaciones lineales. Por ejemplo:

Este ejemplo (los estados inmediatos y los estados pasados están asociados a las mismas variables del destino) impide el uso de tests de frente en los bits AUTOMGEN u100 a u109. Para evitar el problema hay dos soluciones posibles:

- utilizar la sintaxis « ↑(u<n>) » o « ↓(u<n>) » (« <n> » representa el número del bit) en la aplicación,

- asociar los bits de estados inmediatos y pasados a dos tablas de bits diferentes en el destino. En este caso, los accesos externos a la aplicación que podrían realizarse en estos bits (por un terminal de diálogo o un software de supervisión, por ejemplo) deben respetar la filosofía de AUTOMGEN : acceso en lectura sobre los estados pasados, acceso en escritura sobre los estados inmediatos (en la práctica es posible un acceso en lectura sobre los estados inmediatos).

Los bits del destino asignados no deben tener otras asignaciones; así se evitará asignar dos veces las mismas variables del destino a diferentes variables AUTOMGEN.

Ver las correspondencias de variables bajo forma de texto

Al hacer clic en el icono de la barra de herramientas, se pasa del modo « arborescencia » al modo « texto » (formato de las viejas versiones de AUTOMGEN). En el formato « Texto » es posible copiar y pegar informaciones entre los archivos de configuración.

Las modificaciones en modo « texto » deben estar reservadas a

A

los especialistas. Las modificaciones intempestivas pueden causar errores de compilación difíciles de localizar para un neófito.



Código constructor de inicio, código constructor de fin Estos elementos de configuración contienen el código máquina propio de cada destino bajo forma textual. La sintaxis a utilizar en estas secciones es similar a los lenguajes de bajo nivel utilizables en cada destino. La observación del código generado en el paso 1 por cada post-procesador le permite visualizar la sintaxis a utilizar.

Referencia a una variable AUTOMGEN Utilice la sintaxis « _<nombre de variable AUTOMGEN>_ » para hacer referencia a una variable AUTOMGEN (añada el carácter « b » al principio de la variable para acceder al estado pasado de una variable booleana. Por ejemplo « _bu100_ »).

Referencia a un símbolo de la aplicación AUTOMGEN Sintaxis: _|nombre del símbolo|_ El carácter « | » suele asociarse a la tecla 6 del teclado.

Definición y referencia a un label « @<nombre de label> » marca un destino de salto, « _<nombre de label>_ » hace referencia al label.

Insertar código constructor en una aplicación Las palabras clave « #BEGIN_MACHINE_CODE » y « #END_MACHINE_CODE » permiten insertar código constructor en una caja de código AUTOMGEN. Estas dos directivas deben encontrarse al principio de una línea, y en la misma línea no debe haber ningún otro carácter. Las líneas que se hallan entre ambas directivas definen una zona llamada « Sección de lenguaje constructor ». La sintaxis a utilizar en una sección de lenguaje constructor es la misma que se utiliza en los elementos « Código de inicio » y « Código de fin ».

Elección de opciones de conexión Haga doble clic en el elemento « Configuración / Post-procesador / <nombre del post-procesador> / Opciones de conexión ».



Elección de un modo de conexión Los modos de conexión posibles son más o menos numerosos en función del post-procesador. El modo « Solamente conectado » suele utilizarse para crear una aplicación de supervisión. Este cuadro de diálogo se abre automáticamente cuando se solicita la conexión a un destino. Si pinchamos « No abrir más … », dejará de abrirse automáticamente. Para volver a abrirlo, mantenga presionada la tecla [Shift] del teclado lanzando el comando de conexión o el comando « Go ».

Parametraje del módulo de comunicación Haga doble clic en el elemento « Configuración / Post-procesador / <nombre del post-procesador> / Módulo de comunicación ».

Ejemplo de parametraje de un módulo de comunicación. La configuración en curso puede definirse como configuración predeterminada (para los nuevos proyectos) o restablecerse. Puede efectuarse una prueba de conexión.



Post-procesador PL7 Este post-procesador permite programar los autómatas MODICON TELEMECANIQUE SCHNEIDER TSX 37 (TSX MICRO) y TSX 57 (TSX PREMIUM).

Módulo de comunicación

El controlador UNITELWAY SCHNEIDER debe sin falta estar

ESd

P

P

A

instalado en el ordenador (en local) para poder comunicarse con los autómatas SCHNEIDER TSX 37 y TSX 57. El CD-ROM contiene controladores adaptados a una o varias versiones de WINDOWS. Pueden bajarse del sitio de IRAI: www.irai.com.

l módulo de comunicación utiliza el controlador de comunicación concebido por CHNEIDER AUTOMATION. Al hacer clic en « Parametrar y testear … » se accede irectamente a los menús del controlador de comunicación SCHNEIDER.

arametraje del módulo de comunicación

ropiedades del módulo de comunicación UNITELWAY


http://www.irai.com/


Modo de generación de un archivo ejecutable El post-procesador puede generar tanto un archivo binario telecargable directamente en el autómata (disponible únicamente en TSX 37, no disponible en TSX 57) como un archivo importable a las herramientas SCHNEIDER (disponible para TSX 37 y TSX 57). La primera solución es netamente preferible (ahorro de tiempo, simplicidad de uso). La elección del modo se efectúa en la configuración del software del post-procesador.

Modo de generación directa del archivo binario Este modo se recomienda fuertemente para TSX 37. Engendra las siguientes restricciones:

- no utilización de instrucción de sub-programas, - no soporte de instrucciones específicas (comunicación o PID, por ejemplo).

Si su aplicación debe utilizar elementos muy específicos, emplee uno de los métodos de importación que se describen a continuación.

Selección de la generación automática de un archivo binario.

Archivo de configuración del autómata Para los autómatas TSX 37-05 y TSX 37-08 en versión de base (con una sola tarjeta de entradas / salidas), en el repertorio de instalación de AUTOMGEN se proporcionan en standard archivos 3705.stx y 3708.stx.

Si el archivo de configuración no se crea, las salidas digital del

Ua

N

A

autómata no se activan.

na vez que ha creado o bajado el archivo (ver a continuación), dé el camino de cceso al archivo en el elemento de configuración siguiente:

ombre del archivo que contiene la configuración.



Un archivo de configuración puede obtenerse con tres métodos:

Telecarga del archivo de configuración en el sitio IRAI

1- baje un archivo correspondiente a la configuración de su autómata en el sitio de IRAI : www.irai.com, rúbrica « Telecarga / AUTOMGEN7 / archivos de configuración para autómata TSX 37 » (recomendado si el archivo de configuración está presente en el sitio),

2- copie el archivo que ha bajado, sin descomprimirlo (los archivos « .STX » son

archivos comprimidos), en el repertorio de instalación de AUTOMGEN o insértelo en los recursos del proyecto AUTOMGEN.

Si el archivo « .STX » se descomprime, el post-procesador no podrá

utilizarlo.

Creación de un archivo con una de las herramientas de programación SCHNEIDER

Las herramientas de software SCHNEIDER (PL7MICRO V3.1, PL7JUNIOR V3.1 o PL7PRO V3.4) son utilizables. Puede ser que los archivos creados con otras versiones no funcionen. En este caso, el autómata pasa a modo error al terminar de bajar la aplicación (Testigo « ERR » encendido en el autómata). Para crear el archivo « .STX » :

1- lance una de las herramientas SCHNEIDER y cree una aplicación siguiendo las siguientes reglas:

o elija el tipo de CPU de su autómata seleccionando siempre la versión 1.0 de CPU,

o seleccione la o las tarjetas de entradas / salidas instaladas en su autómata y, si es necesario, configúrelas,

2- guarde el archivo creado en el repertorio de instalación de AUTOMGEN o

intégrelo en los recursos del proyecto AUTOMGEN.




Comuníquese con IRAI por e-mail para obtener un archivo de configuración

1- envíe a IRAI un e-mail pidiendo un archivo de configuración y precisando: o el tipo de CPU TSX 37-05, 37-08, 37-10, 37-21 o 3722, o la posición y el tipo de tarjetas de entradas / salidas (DMZ …).

2- cuando reciba el archivo por e-mail, cópielo en el repertorio de instalación de AUTOMGEN (sin descomprimirlo) o intégrelo en los recursos del proyecto AUTOMGEN.

Modo de generación de un archivo « .FEF » En este modo, la importación a las herramientas de programación SCHNEIDER PL7 MICRO (TSX 37), PL7 JUNIOR (TSX 37 o TSX 57) o PL7 PRO (TSX 37 o TSX 57) puede ser automática o manual.

Importación manual

Selección del modo de importación manual Se debe elegir un nombre de archivo que se exportará desde AUTOMGEN:

Elección de un archivo para exportarlo al software SCHNEIDER Procedimiento:

1- Compile la aplicación en AUTOMGEN utilizando el comando « Compilar » del

menú « Programa » o haciendo clic en el botón de la barra de herramientas,

2- Lance un taller de software SCHNEIDER, cree un nuevo proyecto y utilice el

comando « Importar una aplicación » del menú « Archivo », 3- Concluida la importación, transfiera la aplicación el autómata,



4- Para obtener la visualización dinámica en AUTOMGEN, haga clic en el botón « Go » de la barra de herramientas y elija como modo de conexión « Solamente conectar ».

Importación automática La herramienta de software SCHNEIDER se lanzará automáticamente. Se puede utilizar sólo un número restringido de versiones de software SCHNEIDER. El tipo y la versión del software SCHNEIDER deben ajustarse en la configuración del software.

Selección del tipo y de la versión del software SCHNEIDER No se garantiza el funcionamiento del procedimiento de importación automática con otras versiones de software SCHNEIDER. Procedimiento a realizar una sola vez:

1- Lance una herramienta de programación SCHNEIDER y cree una nueva aplicación,

2- Configure la aplicación: tipo de autómata, tarjetas de entradas / salidas, etc…

3- Guarde el archivo creado, 4- Dé el camino de acceso completo a este archivo bajo la rúbrica

« Configuración material » del elemento « Sistema» , por ejemplo:

Procedimiento a realizar a cada ejecución de una aplicación: 1- Lance la herramienta de software SCHNEIDER (si no está lanzada), 2- Haga clic en el botón « GO » de la barra de herramientas de AUTOMGEN.



Utilización de tareas de interrupciones Si se define un folio de tipo tarea, es posible insertar lenguaje bajo nivel de AUTOMGEN o lenguaje constructor en una tarea del autómata. La siguiente tabla da la correspondencia entre el número de tarea y el tipo de tarea de interrupción del autómata. Número de tarea (folio AUTOMGEN)

Tipo de tarea autómata TSX 37

Tipo de tarea autómata TSX 57

0 Tarea rápida Tarea rápida 1 EVT1 EVT0 2 EVT2 EVT1 3 EVT3 EVT2 Etc…

Ejemplos específicos Estos ejemplos se encuentran en el repertorio « <repertorio de instalación de AUTOMGEN> /Ejemplos/Post-procesadores/PL7 ». Los archivos llevan el mismo nombre que los capítulos que siguen.

Entradas / salidas analógicas Este ejemplo ilustra el uso de las entradas / salidas analógicas.

Declaración de las entradas / salidas analógicas en un autómata TSX 37-22.

Contador rápido TSX 37-10 Este ejemplo ilustra el uso del contador rápido en un autómata TSX 37-10.

Contador rápido TSX 37-10 utilizado en descuento Este ejemplo ilustra el uso del contador rápido en un autómata TSX 37-10 en modo de descuento.

Contador rápido TSX 37-22 Este ejemplo ilustra el uso del contador rápido en un autómata TSX 37-22.



ASI Ejemplo de uso de entradas / salidas ASI

MAGELIS Ejemplo de uso de un terminal MAGELIS



Post-procesador PL72 Este post-procesador permite programar los autómatas TELEMECANIQUE SCHNEIDER TSX 17-20 (con cartucho PL72), TSX 27, TSX 47 y TSX 47-20.

Elección del tipo de autómata El elemento « Configuración / Post-procesador / PL72 / Sistema / Configuración material» del explorador permite elegir el tipo de autómata.

Elementos sintácticos específicos

Llamado de los bloques función PL72 Las siguientes sintaxis permiten llamar los bloques temporización, texto y contador rápido (TSX 17-20) con la forma textual utilizada en los elementos « Código constructor de inicio », « Código constructor de fin » y las secciones en lenguaje constructor.

Bloque temporización x.Tn=y Equivalente PL72 :

C C

E E DDTn Tn Tn Tn y y y y x x x x

Bloque texto a+b+c+d.TXTn=x:y Equivalente PL72 :

x

yE

D

I

O

S

R

d

c

b

a TXT



Bloque contador rápido a+b+c+d.FC=x:y:z Equivalente PL72 :

zF

x

yD

E

C

V

P

R

d

c

b

a FC

Bloque hora y fecha tipo WEEK (en TSX 17-20 únicamente) a.H,W,(días),(hora de inicio),(hora de fin)=x :y :z « días » representa los días de la semana; es un valor decimal codificado en 7 bits; cada bit representa un día de la semana. El día está activo si el bit está en 1. b0 corresponde al domingo y b6 al sábado. Por ejemplo, para validar el lunes y el miércoles hay que escribir el valor 21 + 23 : 2 + 8 = 10. Para validar los 7 días de la semana, el valor es 127. « hora de inicio » y « hora de fin » se expresan HH:MM : horas y minutos. Bloque hora y fecha tipo YEAR (en TSX 17-20 únicamente) a.H,Y,(fecha de inicio),(fecha de fin)=x :y :z « fecha de inicio » y « fecha de fin » se expresan JJ/MM : días y meses. Equivalente PL72 :

> z

x

y=

< a HOR



Utilización de la tarea rápida Un folio de tipo « Tarea » con el número « 1 » permite asociar el código literal o el código PL72 escrito en el folio a la tarea rápida. El folio sólo puede contener código literal bajo nivel o código PL72 escrito en un rectángulo de organigrama.


Parametraje del módulo de comunicación Si usted conecta el PC a la toma consola del autómata, seleccione sin falta « Toma consola ». Pinche « Intentar siempre una conexión a 19200 baudios » solamente si su autómata es un TSX 17-20 reciente (esta opción permite un diálogo más rápido entre el PC y el autómata). El modo « UNITELWAY » permite conectar el PC a un acoplador UNITELWAY. En este caso, la velocidad debe estar de acuerdo con la configuración del acoplador.

Si usted pincha « Intentar siempre una conexión a 19200 baudios » y su TSX 17-20 no soporta la comunicación a 19200 baudios, la conexión fracasa. Si el modo no está de acuerdo con la conexión (modo UNITELWAY seleccionado y conexión con toma consola, por ejemplo) la conexión fracasa.

Ejemplos específicos Estos ejemplos se encuentran en el repertorio « <repertorio de instalación de AUTOMGEN> / Ejemplos/ Post-procesadores / PL72 ». Los archivos llevan el mismo nombre que los capítulos que siguen.



Entradas / salidas analógicas Para poder utilizar las entradas analógicas en un autómata TSX 17-20 es necesario:

- declarar el o los bloques de entradas / salidas analógicas en el elemento « Sistema » de la configuración,

- asociar una o varias variables AUTOMGEN a las palabras de entradas / salidas TELEMECANIQUE (IW y OW).

Ejemplo:

- el autómata TSX 17-20 utiliza un bloque de 4 entradas analógicas (código 27) en posición 1 y un bloque de 2 salidas analógicas (código 21) en posición 2.

- el programa copiará simplemente el estado de la primera entrada analógica en la primera salida analógica. También comparará la segunda entrada analógica con el valor 500 (valor arbitrario) y posicionará dos salidas booleanas: O0 si la entrada es menor que 500, O1 si la entrada es mayor o igual que 500.

La declaración de los dos módulos de extensión

La asignación de las variables Estas dos declaraciones asocian las palabras M200 a M203 de AUTOMGEN a las variables IW1,0 a IW1,3 del autómata y las variables M204 y M205 de AUTOMGEN a las variables OW2,0 y OW2,1 del autómata.

Contador rápido El objetivo es contar 200 impulsos en el contador rápido. El valor corriente del contador rápido se copia en la palabra M200 de AUTOMGEN. La salida O5 es activada por la tarea rápida al final del cálculo.



El parametraje del contador rápido

Bloques texto y xbt El objetivo es dialogar con un XBT conectado al puerto consola de un autómata TSX 17-20. Las entradas I0 a I3 determinan la visualización de los mensajes número 0 a número 3 registrados en el XBT. El bloque texto TXT1 se utilizará para dialogar en el puerto consola. El formato del mensaje a enviar al XBT para mostrar un mensaje es el siguiente: ESC V xxx LF CR xxx representa el número de mensaje codificado en decimal en tres caracteres.

Asignación de una tabla de palabras para los intercambios




Parametraje del bloque texto


Bloques texto y UNITELWAY El objetivo es utilizar un acoplador UNITELWAY para efectuar la adquisición de una tabla de 3 palabras en el autómata destino. El acoplador UNITELWAY está instalado como primera extensión y se configurará como máster para utilizar dos esclavos. El autómata leído será el esclavo número 1.

Configuración del acoplador UNITELWAY



Parametraje de los dos bloques texto



Atribución de una tabla de palabras para los intercambios

Módulo de extensión digital Este ejemplo ilustra la configuración de un módulo de extensión digital. Tomamos como hipótesis un módulo de base equipado con 16 entradas y 12 salidas y un módulo de extensión equipado con 10 entradas y 8 salidas.

La definición del módulo de extensión

La asignación de las variables

Conversión Muestra cómo llamar las funciones de conversión del lenguaje PL72.

Hora y fecha Ejemplo de utilización del bloque funcional hora y fecha.



Post-procesador S7200 Este post-procesador permite programar los autómatas SIEMENS S7200 (todas las CPU 2xx).

Elección del tipo de CPU El elemento « Configuración / Post-procesador / STEP7 (S7200) / Sistema / Configuración material » del explorador permite elegir el tipo de CPU.


Parametraje del módulo de comunicación Ajuste el número de esclavo de acuerdo con el que esté configurado en el autómata.

Ejemplo específico Este ejemplo se encuentra en el repertorio « <repertorio de instalación de AUTOMGEN> / Ejemplo / Post-procesadores / S7200 ». El archivo lleva el mismo nombre que el capítulo que sigue.

Tarea de interrupción Ejemplo de llamado de una tarea de interrupción



Post-procesador ABB Este post-procesador permite programar los autómatas ABB CS31 y AC31.

Elección del tipo de autómata El elemento « Configuración / Post-procesador / ABB / Sistema / Configuración material » del explorador permite elegir el tipo de autómata.

Autómata AC31

Autómata CS31


Parametraje del módulo de comunicación

Utilitario El elemento « Configuración / Post-procesador / ABB / Terminal emulator » del explorador permite acceder a un emulador de terminal que sirve para dialogar con el autómata.

Ejemplos específicos Estos ejemplos se encuentran en el repertorio « <repertorio de instalación de AUTOMGEN> / Ejemplos / Post-procesadores / ABB ». Los archivos llevan el mismo nombre que los capítulos que siguen.

Entradas / salidas analógicas Ejemplo para ilustrar el uso de un módulo de extensión analógica en un autómata AC31.

Interrupciones Ejemplo para ilustrar el uso de las tareas de interrupciones en un autómata AC31.



Post-procesador GE-FANUC / ALSPA Este post-procesador permite programar los autómatas GE-FANUC 90 MICRO y 9030 o ALSPA 8005 y 8035.

Elección del tipo de autómata El elemento « Configuración / Post-procesador / GE-FANUC / Sistema / Configuración material » del explorador permite elegir el tipo de autómata.

Elegir standard para las CPU que no sean 350, 351 o VERSAMAX.



Utilitario El elemento « Configuración / Post-procesador / GE-FANUC / Hardware configuration & diagnostic » del explorador permite acceder a un utilitario de configuración y diagnóstico.



Post-procesador STEP5



Estructura de la aplicación El lenguaje STEP5 de SIEMENS está organizado en bloques de programas y de datos. Las aplicaciones AUTOMGEN traducidas por el post-procesador STEP5 se dividen en varios bloques. El post-procesador utiliza los siguientes bloques de manera predeterminada: - OB1 bloque de organización: este bloque llama todos los bloques que deben tratarse de manera cíclica. - OB20, OB21, OB22: bloques ejecutados al iniciarse el autómata. Estos bloques arman un bit para activar las etapas iniciales de Grafcet. Se utilizan bloques PB para el tratamiento de las predisposiciones, para gestionar la evolución de las variables booleanas y de las temporizaciones. Se utilizan bloques FB o FX para el código salido de la aplicación y para el código escrito en los archivos « .SRT » y « .END ». Se crea un bloque FB o FX para cada folio de la aplicación. Además es posible asociar folios directamente a un bloque de códigos o de datos. Si para un bloque se genera un volumen de código demasiado grande (código salido de un folio que contiene un programa voluminoso, por ejemplo), entonces el post-procesador utiliza automáticamente un nuevo bloque. El post-procesador utiliza de manera predeterminada según sus necesidades los bloques PB1 a PB255 y FB1 a FB239. Estos valores pueden modificarse (ver el capítulo

zar). Elección de los bloques de

programas a utili



La siguiente figura ilustra la estructura del código generado por el post-procesador SIEMENS:

Bloque PB Evol. de las variables tempo.

Bloque PB

Evol. de las variables

booleanas

n bloques FB o FX

Folios de la aplicación

Bloque PB Predisposiciones

Bloque FB o FX

Bloque FB o FX

Bloque OB1

Código constructor de fin

Código constructor de

inicio



Elección de los bloques de programas a utilizar Los bloques PB 1 a PB 255 y FB 1 a FB 239 se utilizan de manera predeterminada. Tres elementos de configuración permiten elegir otros bloques.

Elección del bloque de datos El bloque DB 3 se utiliza de manera predeterminada para las variables numéricas. Esta directiva permite utilizar otro bloque.

El cambio de bloque de datos implica otras dos modificaciones: - en el código constructor de inicio, hay que crear el bloque de datos correspondiente, - hay que seleccionar el bloque de datos elegido en el parametraje del módulo de diálogo.



Elección del tipo de procesador

Asociación del código escrito en un folio a un bloque programa Al escribir código literal bajo nivel o código constructor escrito en un organigrama en un folio de tipo « Tarea », asociamos este código a un bloque STEP5. El número de tarea determina el tipo y el número del bloque. El código generado por este folio debe tener en cuenta el tipo de bloque y las instrucciones utilizables en este tipo de bloque (juego de instrucciones limitado en los bloques OB y PB). La siguiente tabla indica la correspondencia entre el valor de « n » y el bloque. Número de tarea Bloque STEP5 0 a 255 OB 0 a OB 255 256 a 511 PB 0 a PB 255 512 a 767 FB 0 a FB 255 768 a 1023 FX 0 a FX 255 1024 a 1279 DB 0 a DB 255 1280 a 1535 DX 0 a DX 255

Sintaxis específicas

Definición de bloques La directiva « $BLOC <tipo de bloque> <número>» permite definir el inicio de un bloque de programa o de datos. El tipo de bloque puede ser « OB », « FB », « FX », « PB » para el código o « DB », « DX » para los datos.



El número de bloque es un valor comprendido entre 0 y 255. Los bloques « FX » y « DX » pueden utilizarse sólo en los autómatas 135U y 155U. La directiva « BE » marca el fin de un bloque. Ejemplo: $BLOC DB1 ... $BE $BLOC OB1 ... $BE las directivas « KH= », « KY= », « KC= », « KM= » y « KF= » insertan constantes en los bloques de datos DB. « KH= » inserta una constante 16 bits expresada en hexadecimal. « KY= » inserta una constante 16 bits expresada en dos valores comprendidos

entre 0 y 255 separados por una coma. « KC= » inserta una sucesión de caracteres encerrados por « ’ » (apóstrofo). « KM= » inserta una constante 16 bits expresada en binario. « KF= » inserta una constante 16 bits expresada en decimal con signo. Ejemplo: $BLOC DB 4 KH= 1234 KY=100,5 KC= ‘Esto es un texto’ KM=11111111 00000000 KF=-200 $BE

Bloques FB y FX Los bloques FB y FX del lenguaje SIEMENS pueden recibir parámetros.

Llamado Si es necesario pasar parámetros a un bloque funcional, entonces se debe utilizar la siguiente sintaxis:

- el llamado debe estar seguido del carácter « * », - la línea siguiente debe contener una instrucción de salto « SPA » a la línea

situada más allá de los parámetros, - las líneas siguientes deben contener los parámetros precedidos de un

mnemónico « U » para los bits o « L » para las palabras. Las constantes deben estar escritas como « Kx=valor » (x es el tipo de constante; ver el capítulo Definición de bloques).



Ejemplo de llamado a un bloque funcional sin parámetros: SPA FB 5 Ejemplos de llamado de bloque funcional con parámetros: SPA FB 242* SPA=_label_ L MW10 ; primer parámetro L MW12 ; segundo parámetro U M0.0 ; tercer parámetro L MW14 ; cuarto parámetro L MW16 ; quinto parámetro @label SPA FB200* SPA=_label2_ KY=0,4 ; Ejemplo de parámetro constante @label2

Escritura En los bloques FB y FX hay que utilizar los mnemónicos que terminan con el carácter ‘=‘ seguido de un número de parámetro (1=primer parámetro). Ejemplo de bloque funcional de dos parámetros (copia del primer parámetro en el segundo): $BLOC FB 100 L=1 T=2 $BE



Post-procesador TSX 07 Este post-procesador permite programar los autómatas MODICON TELEMECANIQUE SCHNEIDER TSX 07.

Módulo de comunicación El controlador UNITELWAY SCHNEIDER debe sin falta

ESd

P

P

A

estar instalado en el ordenador (en local) para poder comunicarse con los autómatas SCHNEIDER TSX 07. El CD-ROM contiene controladores adaptados a una o varias versiones de WINDOWS. Pueden bajarse del sitio de IRAI: www.irai.com. Atención: algunas versiones de WINDOWS son incompatibles con ciertos tipos de autómatas TSX 07 (TSX 0720… y TSX 0721… incompatibles con WINDOWS ME, WINDOWS 2000 o WINDOWS XP).

l módulo de comunicación utiliza el controlador de comunicación concebido por CHNEIDER AUTOMATION. Al hacer clic en « Parametrar y testear … » se accede irectamente a los menús del controlador de comunicación SCHNEIDER.

arametraje del módulo de comunicación

ropiedades del módulo de comunicación UNITELWAY




Post-procesador PS3-PS4 Este post-procesador permite programar los autómatas KLOCKNER-MOELLER PS3 y PS4.





Post-procesador PS4 Este post-procesador permite programar los autómatas MOELLER PS4-200, PS4-300 y PS416. Debe utilizarse el software SUCOSOFT S40 V5 o superior de MOELLER (incluso puede utilizarse la versión demo de este software).



Transferencia de los programas al software SUCOSOFT S40 de MOELLER En el siguiente elemento designe un archivo que servirá de intercambio entre AUTOMGEN y SUCOSOFT. Al final de la compilación en AUTOMGEN se generará este archivo.



Procedimiento a seguir para importar el archivo generado por AUTOMGEN al software MOELLER y luego introducirlo en el autómata

- Lance SUCOSOFT, - cree un nuevo proyecto, - haga clic con el botón derecho del ratón en la configuración topológica en

SUCOSOFT y elija la opción « Exportación/Importación / Importación de sources CEI/EN 61131-3 »,

- ingrese el nombre del archivo exportado por AUTOMGEN,

- haga doble clic en el elemento « _MAIN » que aparece en la lista,



- en el menú « Especial » elija « Generación de código »,

- responda « Sí » a:

- y luego « Aceptar » a:

- en el menú « Generación » elija « Parametraje del programa … »,



- seleccione un espacio adecuado para almacenar todas las variables internas (%M) de su aplicación,

- en el menú « Generación » elija « Generar el código programa »,

- si no hay errores de compilación es posible proceder a la transferencia de la aplicación al autómata. En el menú « Herramientas » elija « Test y puesta en servicio »,

- en el menú « Aparato » elija « Transferencia / Gestionador de archivos »,



- haga clic en transferir,

- al final de la transferencia desconecte el software SUCOSOFT para poder conectar AUTOMGEN al autómata y activar el modo de puesta a punto dinámica.



Post-procesador RPX Este post-procesador permite programar los autómatas CROUZET RPX.

Elección del tipo de autómata El elemento « Configuración / Post-procesador / RPX / Sistema / Configuración material » del explorador permite elegir el tipo de autómata.



Utilitario El elemento « Configuración / Post-procesador / RPX / Terminal emulator » del explorador permite acceder a un emulador de terminal que sirve para configurar los acopladores de comunicación del autómata.



Post-procesador PL71 Este post-procesador permite programar los autómatas SCHNEIDER TSX 17-10 y TSX 17-20 (sin cartucho PL72).

Elección del tipo de autómata El elemento « Configuración / Post-procesador / PL71 / Sistema / Configuración material » del explorador permite elegir el tipo de autómata.


Parametraje del módulo de comunicación (Para más información, consulte la configuración del PL72). Módulo de comunicación

Tarea contador rápido Un folio de tipo tarea con el número 1 se asociará a la tarea contador rápido del autómata.

Ejemplos específicos Estos ejemplos se encuentran en el repertorio « <repertorio de instalación de AUTOMGEN> / Ejemplos / Post-procesadores / PL71 ». Los archivos llevan el mismo nombre que los capítulos que siguen.

Contador Como las incrementaciones y decrementaciones de contadores en PL71 son limitadas (en frente ascendente únicamente) con respecto a las posibilidades de AUTOMGEN y de los autómatas TSX, es necesario emplear código en lenguaje constructor si se desea utilizarlas (ver el contenido del ejemplo).



Contador rápido El objetivo es contar 200 impulsos en el contador rápido. La salida O5 será activada por la tarea rápida al final del cálculo.



Post-procesador PB Este post-procesador permite programar los autómatas SCHNEIDER APRIL PB.

Elección del tipo de autómata El elemento « Configuración / Post-procesador / PB / Sistema / Configuración material » del explorador permite elegir el tipo de autómata.



Sintaxis específicas La directiva « $ORG=xxxx » permite definir el principio de la dirección de ensamblaje; inicialmente la dirección de ensamblaje está fijada en 0C30, Ejemplo: $ORG=1C30 La directiva « $TOP=xxx » define la dirección máxima para el salto de página. Precisa los tres dígitos de peso débil de las direcciones por encima de las cuales un salto de página será automáticamente generado por el ensamblador. La directiva « $CONST=xxxx,yyyy » define la dirección de inicio y de fin para el almacenamiento de constantes. Las constantes se alojan en una tabla fuera del programa. La directiva « WORD xxxx » inserta el valor xxxx (cuatro dígitos en hexadecimal) en el programa. La directiva « ADR xxxx » inserta la dirección de la variable xxxx (cuatro dígitos en hexadecimal) en el programa. La sintaxis #nnnn permite hacer referencia a un valor constante.



Por ejemplo: apl #1234 ; ubica la constante 1234 (hexadecimal) en el acumulador.



Post-procesador SMC Este post-procesador permite programar los autómatas SCHNEIDER APRIL SMC.

Elección del tipo de autómata El elemento « Configuración / Post-procesador / SMC / Sistema / Configuración material » del explorador permite elegir el tipo de autómata.



Sintaxis específicas La directiva « $SEQ » marca el inicio de una zona booleana. La directiva « $CAL » marca el inicio de una zona de cálculo. La directiva « $PRD » marca el inicio de una zona de predisposición de variables. Las variables booleanas pueden utilizarse en biestable o en monoestable independientemente de las convenciones del lenguaje SMC. El carácter « ! » pospuesto al signo « = » fuerza la variable a ser biestable (puesta en uno o puesta en cero), el carácter « ? » pospuesto al signo « = » fuerza la variable a ser monoestable (asignación o asignación complementada). La sintaxis « SS.cccccccc » permite escribir una secuencia de seguridad (necesaria en los autómatas SMC 25 y 600); « cccccccc » representa un nombre de programa, en un máximo de 8 caracteres.



Post-procesador S7300 Este post-procesador permite programar los autómatas SIEMENS S7300.


Parametraje del módulo de comunicación El número de esclavo debe estar de acuerdo con el que esté parametrado en el autómata.

Sintaxis específicas La directiva « $BLOC <tipo de bloque> <número>» permite definir el inicio de un bloque de programa o de datos. El tipo de bloque puede ser « OB », « FB », « FC », « SFC », « SFB » para el código o « DB » para los datos. El número de bloque es un valor comprendido entre 0 y 65535. La directiva «$ENDBLOC » marca el fin de un bloque. Ejemplo: $BLOC DB1 ... $ENDBLOC $BLOC OB1 ... $ENDBLOC La siguiente sintaxis permite declarar las variables para un bloque: Para una variable de entrada: $VAR-naturaleza tipo {:=inicialización} o $VAR-naturaleza símbolo : {tipo :=inicialización}



« naturaleza » puede ser: - « IN » para una variable de entrada, - « OUT » para una variable de salida, - « INOUT » para una variable de entrada / salida, - « TEMP » para una variable temporal, - « STAT » para una variable estática. « tipo » puede ser uno de los tipos de variable del lenguaje STEP7 : BOOL, INT, WORD, STRUCT, ENDSTRUCT, etc … « símbolo » permite asociar un mnemónico a una variable. « inicialización » es opcional y fija el valor predeterminado de una variable. Los bloques DB sólo autorizan variables de tipo estático. Los bloques OB sólo autorizan variables de tipo temporal. Los bloques FC y SFC no autorizan variables de tipo estático. Al igual que en el software SIEMENS, las declaraciones de variables deben aparecer en el siguiente orden: entrada, salida, entrada / salida, estática y temporal.

Definición de las variables de un bloque La sintaxis « £D bloque declaración » permite definir una declaración asociada a un bloque en particular. Cuando el compilador genera este bloque, entonces se utiliza la declaración.

Llamado de los bloques La sintaxis « CALL nombre de bloque {,DB de instancia} ( lista de parámetros) » permite llamar un bloque FC, FB, SFC o SFB. Ejemplo: $BLOC FC1 $VAR-IN entrada1 :BOOL :=FALSE ; $VAR-IN entrada2 :BOOL :=FALSE ; $VAR-OUT salida :BOOL ; u_entrada1_ u_entrada2_ =_salida_ $ENDBLOC $BLOC OB1 CALL FC1(_entrada1_ :=e0.0,_entrada2_ :=e0.1,_salida_ :=a0.0) $ENDBLOC



Importación al software SIMATIC de SIEMENS Para importar el código generado por AUTOMGEN al software SIMATIC de SIEMENS siga este procedimiento:

1- Dentro de la parte « Sistema » de la configuración del post-procesador S7300 seleccione SIMATIC en el elemento siguiente:

2- Compile la aplicación. 3- En AUTOMGEN abra el elemento « Código generado / Post-procesador

S7300 / Paso 2 », seleccione todas las líneas y luego el comando « Copiar » del menú « Edición ».

4- En el software SIMATIC cree un elemento de tipo « Source LIST ».



5- En SIMATIC pegue el código en la ventana que contiene la source LIST con el comando « Pegar » del menú « Edición ».

5- En SIMATIC compile el source haciendo clic en . La importación ha terminado.



Estructura del código generado El lenguaje STEP7 de SIEMENS está organizado en bloques de programas y de datos. Las aplicaciones AUTOMGEN traducidas por el post-procesador STEP7 se dividen en varios bloques. El post-procesador utiliza de manera predeterminada los siguientes bloques: - OB1 bloque de organización: este bloque llama todos los bloques que deben tratarse de manera cíclica, - OB100: bloques ejecutados al inicio del autómata. Estos bloques arman un bit para activar las etapas iniciales de Grafcet. Se utilizan bloques FB para el tratamiento de las predisposiciones, para gestionar la evolución de las variables booleanas y de las temporizaciones. Se utilizan bloques FC para el código salido de la aplicación y para el código constructor de inicio y de fin. Un bloque FB para cada folio de la aplicación. Además, es posible asociar folios directamente a un bloque (ver el capítulo

a). Asociación del código escrito en un folio a un bloque program El post-procesador utiliza de manera predeterminada según sus necesidades los bloques FB1 a FB255 y FC1 a FC239. Estos valores pueden modificarse en el elemento « Sistema » de la configuración.



La siguiente figura ilustra la estructura del código generado por el post-procesador SIEMENS :

Bloque FB Evol. de las variables tempo.

Bloque FB Evol. de las variables booleanas

n bloques FC Folios de la aplicación

Bloque FB Predisposiciones

Bloque FB

Bloque FC

Bloque OB1

Archivo de fin .END

Archivo de inicio .SRT



Elección de los bloques de programas a utilizar Los bloques FC 1 a FC 239 y FB 1 a FB 255 se utilizan de manera predeterminada. Dos elementos de configuración permiten elegir otros bloques.

Asociación del código escrito en un folio a un bloque programa Al escribir código literal bajo nivel o código constructor escrito en un organigrama en un folio de tipo « Tarea », asociamos este código a un bloque STEP7. El número de tarea determina el tipo y el número del bloque. El código generado por este folio debe tener en cuenta el tipo de bloque y las instrucciones utilizables en este tipo de bloque (juego de instrucciones limitado en los bloques OB y PB). La siguiente tabla indica la correspondencia entre el número de tarea y el bloque STEP7. Número de tarea Bloque STEP7

0 a 255 OB 0 a OB 255

256 a 511 FC 0 a FC 255

512 a 767 FB 0 a FB 255

Ejemplos específicos Estos ejemplos se encuentran en el repertorio « <repertorio de instalación de AUTOMGEN> / Ejemplos / Post-procesadores / S7300 ». Los archivos llevan el mismo nombre que los capítulos que siguen.

Liamado de un bloque STEP7 Ejemplo de llamado de los bloques funcionales STEP7.

Utilización de un bloque OB Ejemplo de asociación del código escrito en un folio a un bloque OB.



Post-procesador OMRON Este post-procesador permite programar los autómatas OMRON.



Transferencia de las aplicaciones al software CX-PROGRAMMER - En AUTOMGEN, al final de la compilación, haga doble clic en el elemento

« Archivos generados / OMRON / Paso 2 »,

- seleccione todas las líneas,



- seleccione el comando « Copiar » del menú « Edición »,

- en CX-PROGRAMMER cree una aplicación virgen y visualice la zona programa en forma mnemónica,



- seleccione la zona programa y pegue las líneas,

Es posible bajar la aplicación al autómata a partir de CX-PROGRAMMER y luego volver a AUTOMGEN para poner a punto el programa en modo conectado (desconecte CX-PROGRAMMER del autómata para poder comunicarse a partir de AUTOMGEN).

Sintaxis específica La siguiente sintaxis permite fijar el valor de una palabra de dato: $DMn=valor « n » es el número de la palabra, « valor » es un valor de 16 bits expresado en decimal en forma predeterminada, o en hexadecimal si está precedido del carácter ‘H’.



Ejemplo: $DM10=50 $DM100=HA000

Asociación del código escrito en un folio a un bloque programa Al escribir código literal bajo nivel o código constructor escrito en un organigrama en un folio de tipo « Tarea », asociamos este código a una tarea de interrupción. El número de tarea es equivalente al número de interrupción.

Ejemplo específico Este ejemplo se encuentra en el repertorio « <repertorio de instalación de AUTOMGEN> / Ejemplos / Post-procesadores / S7200 ». El archivo lleva el mismo nombre que el capítulo que sigue.

Tarea de interrupción Ejemplo de llamado de una tarea de interrupción



Post-procesador ALSPA Este post-procesador permite programar los autómatas CEGELEC ALSPA C50 y C100.





Post-procesador ZELIO Este post-procesador permite programar los módulos SCHNEIDER ZELIO.





Post-procesador FESTO Este post-procesador permite programar los autómatas FPC 101, FPC 103 y FEC FESTO.



Generación de archivo binario Los archivos binarios pueden generarse y telecargarse directamente en los autómatas FPC 101 y FPC 103. Para los autómatas FEC hay que tener software FST FESTO para DOS o para WINDOWS.

Elección de un tipo de CPU (generación directa de un archivo binario)

Importación al software FESTO

Generación de un archivo .AWL compatible con FESTO Si usted utiliza software FST FESTO para DOS, relea el archivo .AWL a partir de este software. Si usted utiliza software FST FESTO para WINDOWS, abra el archivo generado en AUTOMGEN haciendo doble clic en el elemento « Archivos generados / FESTO / Paso 2 », seleccione el conjunto del archivo, utilice el comando « Copiar » del menú « Edición » y luego el comando « Pegar » en el software FESTO para recuperar el código generado. Transfiera el programa al autómata con el software FESTO. Después de desconectarse del software FESTO, puede conectarse con AUTOMGEN utilizando como modo de conexión « Solamente conectar ».



Post-procesador ALLEN-BRADLEY Este post-procesador permite programar los autómatas SLC de ROCKWELL. Se necesita el software RS-Logix 500 V5 o superior de ROCKWELL.
La versión STARTER de RS-Logix 500 no permite importar los archivos generados por AUTOMGEN.


Transferencia de los programas al software RS-Logix 500 de ROCKWELL En el siguiente elemento designe un archivo que servirá de intercambio entre AUTOMGEN y RS-Logix 500. Al final de la compilación en AUTOMGEN se generará este archivo.

Generación de un archivo .SLC compatible con RS-Logix 500 Lance RS-Logix 500 y abra el archivo .SLC generado por AUTOMGEN.



Transfiera el programa al autómata con el software RS-Logix 500. Después de desconectar RS-Logix 500 del autómata es posible realizar la puesta a punto en modo conectado a partir de AUTOMGEN.



Post-procesador MITSUBISHI Este post-procesador permite programar los autómatas MITSUBISHI de la gama FX. El código generado por AUTOMGEN puede enviarse directamente a los autómatas MITSUBISHI de la gama FX o importarse a los programas MITSUBISHI FX-WIN o GX-DEVELOPPER.

Elección del tipo de autómata El elemento « Configuración / Post-procesador / MITSUBISHI / Sistema / Configuración material » del explorador permite elegir el tipo de autómata.



Transferencia de los programas al software FX-WIN de MITSUBISHI En el siguiente elemento elija FXWIN.



Debe utilizarse la versión francesa de FXWIN. La importación

Dp«

TME

Lid DDPs Pdc

A

se ha validado con la versión 3.20 de FX-WIN.

espués de la compilación en AUTOMGEN, cree un proyecto en FX-WIN. Abra el rograma en edición en modo lista de instrucciones y elija « Inserción » en el menú Edición ».

ransferencia de los programas al software GX-DEVELOPPER de ITSUBISHI n el siguiente elemento elija GXDEVELOPPER.

ance el ejecutable « A7TOGX.EXE » que se encuentra en el directorio de nstalación de AUTOMGEN. Al lanzarlo, aparece el icono « A7 → GX » en la barra e iconos de WINDOWS.

espués de la compilación en AUTOMGEN, cree un proyecto en GX-EVELOPPER. Abra el programa en edición en modo lista de instrucciones. resione simultáneamente un segundo ambas teclas SHIFT del teclado. El programa e transfiere a GX-DEVELOPPER.

ara desinstalar el utilitario « A7TOGX » haga clic en el icono con el botón derecho el ratón. Puede dejar « A7TOGX » instalado. No necesita instalarlo y desinstalarlo ada vez que desea importar una aplicación a GX-DEVELOPPER.




Post-procesador TWIDO Este post-procesador permite programar los autómatas TWIDO de SCHNEIDER.

Elección de la configuración del autómata El elemento « Configuración / Post-procesador / TWIDO / Sistema / Configuración material » del explorador permite elegir el tipo de autómata.

El archivo « .TWD » es un archivo de configuración que debe generarse con el software TWIDOSOFT de SCHNEIDER. El subdirectorio « TWIDO » del directorio de instalación de AUTOMGEN contiene los archivos de configuración para varios tipos de autómata TWIDO.


Generalidades · 2003. 3. 19. · Title: Generalidades Author: SM Created Date: 3/19/2003 10:24:19...

Documents

Transcript of Generalidades · 2003. 3. 19. · Title: Generalidades Author: SM Created Date: 3/19/2003 10:24:19...