Manual de referencia del lenguaje
Ejemplos
Las aventuras de Docteur R.
www.irai.com
La página se está cargando ...
Manual de referencia del lenguaje
1. Elementos comunes............................................................................................................... 7
1.1. Variables ..................................................................................................................................... 7
1.1.1. Variables booleanas............................................................................................................................. 7
1.1.2. Variables numéricas ............................................................................................................................ 8
1.1.3. Temporizaciones.................................................................................................................................. 8
1.2. Acciones .................................................................................................................................... 10
1.2.1. Asignación de una variable booleana ................................................................................................ 10
Asignación complementada de una variable booleana................................................................................ 11
1.2.2. Puesta en uno de una variable booleana ............................................................................................ 12
1.2.3. Puesta en cero de una variable booleana ........................................................................................... 13
1.2.4. Inversión de una variable booleana ................................................................................................... 13
1.2.5. Puesta en cero de un contador, una palabra o un largo...................................................................... 14
1.2.6. Incremento de un contador, una palabra o un largo........................................................................... 15
1.2.7. Decremento de un contador, una palabra o un largo.......................................................................... 15
1.2.8. Temporizaciones................................................................................................................................ 16
1.2.9. Interferencias entre las acciones........................................................................................................ 17
1.2.10. Acciones de la norma CEI 1131-3................................................................................................... 17
1.2.11. Acciones múltiples .......................................................................................................................... 18
1.2.12. Código literal................................................................................................................................... 19
1.3. Tests........................................................................................................................................... 19
1.3.1. Forma general.................................................................................................................................... 20
1.3.2. Modificador de test............................................................................................................................ 20
1.3.3. Temporizaciones................................................................................................................................ 21
1.3.4. Prioridad de los operadores booleanos .............................................................................................. 21
1.3.5. Test siempre verdadero...................................................................................................................... 22
1.3.6. Test sobre variable numérica....................................................................................................................... 22
1.3.7. Transiciones en varias líneas ............................................................................................................. 23
1.4. Utilización de símbolos..................................................................................................................... 23
1.4.1. Sintaxis de los símbolos .................................................................................................................... 23
1.4.2. Símbolos automáticos........................................................................................................................ 24
1.4.3. Sintaxis de los símbolos automáticos ................................................................................................ 24
1.4.4. ¿Cómo gestiona el compilador los símbolos automáticos? ............................................................... 24
1.4.5. Zona de atribución de las variables ................................................................................................... 25
1.5. A propósito de ejemplos .......................................................................................................... 26
1.6. Grafcet ...................................................................................................................................... 28
1.6.1. Grafcet simple ................................................................................................................................... 28
1.6.2. Divergencia y convergencia en « Y »................................................................................................ 31
1.6.3. Divergencia y convergencia en « O »................................................................................................ 33
1.6.4. Etapas pozos y fuentes, transiciones pozos y fuentes........................................................................ 36
AUTOMGEN
7
3 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.6.5. Acciones múltiples, acciones condicionadas..................................................................................... 36
1.6.6. Sincronización................................................................................................................................... 38
1.6.7. Forzados de Grafcet........................................................................................................................... 39
1.6.8. Macro-etapas ..................................................................................................................................... 48
1.6.9. Contadores......................................................................................................................................... 51
1.7. Gemma ...................................................................................................................................... 52
1.7.1. Creación de un Gemma ..................................................................................................................... 54
1.7.2. Contenido de los rectángulos del Gemma ......................................................................................... 54
1.7.3. Obtener un Grafcet correspondiente.................................................................................................. 54
1.7.4. Anular los espacios vacíos en el Grafcet ........................................................................................... 55
1.7.5. Imprimir el Gemma ........................................................................................................................... 55
1.7.6. Exportar el Gemma............................................................................................................................ 55
1.7.7. Ejemplo de Gemma ........................................................................................................................... 55
1.8. Ladder....................................................................................................................................... 58
1.8.1. Ejemplo de Ladder............................................................................................................................. 59
1.9. Logigrama................................................................................................................................. 60
1.9.1. Diseño de los logigramas................................................................................................................... 61
1.9.2. Ejemplo de logigrama........................................................................................................................ 62
1.10. Lenguajes literales.................................................................................................................. 65
1.10.1. Cómo utilizar el lenguaje literal ...................................................................................................... 65
1.10.2. Definición de una caja de código..................................................................................................... 66
1.10.3. El lenguaje literal bajo nivel............................................................................................................ 67
1.10.4. Macro-instrucción.......................................................................................................................... 120
1.10.5. Biblioteca....................................................................................................................................... 121
1.10.6. Macro-instrucciones predefinidas.................................................................................................. 121
1.10.7. Descripción de las macro-instrucciones predefinidas.................................................................... 121
1.10.8. Ejemplo en lenguaje literal bajo nivel ........................................................................................... 123
1.11. Lenguaje literal extendido................................................................................................... 126
1.11.1. Escritura de ecuaciones booleanas................................................................................................. 127
1.11.2. Escritura de ecuaciones numéricas ................................................................................................ 128
1.11.3. Estructura de tipo IF ... THEN ... ELSE ... .................................................................................... 130
1.11.4. Estructura de tipo WHILE ... ENDWHILE...................................................................................130
1.11.5. Ejemplo de programa en lenguaje literal extendido.......................................................................131
1.12. Lenguaje literal ST............................................................................................................... 132
1.12.1. Generalidades ................................................................................................................................ 132
1.12.2. Ecuaciones booleanas.................................................................................................................... 133
1.12.3. Ecuaciones numéricas.................................................................................................................... 134
1.12.4. Estructuras de programación ......................................................................................................... 135
1.12.5. Ejemplo de programa en lenguaje literal extendido.......................................................................137
AUTOMGEN
7
4 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.13. Organigrama ........................................................................................................................ 137
1.13.1. Diseño de un organigrama............................................................................................................. 138
1.13.2. Contenido de los rectángulos......................................................................................................... 139
1.14. Ilustración............................................................................................................................. 139
1.15. Bloques funcionales.............................................................................................................. 142
1.15.1. Creación de un bloque funcional ................................................................................................... 142
1.15.2. Diseño del bloque y creación del archivo « .ZON »...................................................................... 143
1.15.3. Creación del archivo « .LIB »........................................................................................................ 145
1.15.4. Ejemplo simple de bloque funcional ............................................................................................. 145
1.15.5. Ilustración...................................................................................................................................... 146
1.15.6. Complemento de sintaxis............................................................................................................... 149
1.16. Bloques funcionales evolucionados..................................................................................... 150
1.16.1. Sintaxis .......................................................................................................................................... 150
1.16.2. Diferenciar viejos y nuevos bloques funcionales........................................................................... 150
1.16.3. Ejemplo.......................................................................................................................................... 151
1.17. Bloques funcionales predefinidos ....................................................................................... 152
1.17.1. Bloques de conversión................................................................................................................... 152
1.17.2. Bloques de temporización.............................................................................................................. 153
1.17.3. Bloques de manipulación de cadena de caracteres ........................................................................ 153
1.17.4. Bloques de manipulación de tabla de palabras .............................................................................. 153
1.18. Técnicas avanzadas.............................................................................................................. 153
1.18.1. Código generado por el compilador............................................................................................... 153
1.18.2. Optimización del código generado ................................................................................................ 154
2. Ejemplos............................................................................................................................. 157
2.1. A propósito de ejemplos ........................................................................................................ 157
2.1.1. Grafcet simple ................................................................................................................................. 157
2.1.2. Grafcet con diagrama en O.............................................................................................................. 158
2.1.3. Grafcet con divergencia en Y .......................................................................................................... 159
2.1.4. Grafcet y sincronización.................................................................................................................. 160
2.1.5. Forzado de etapas ............................................................................................................................ 161
2.1.6. Etapas pozos y fuentes..................................................................................................................... 162
2.1.7. Etapas pozos y fuentes..................................................................................................................... 163
2.1.8. Forzado de Grafcets......................................................................................................................... 164
2.1.9. Memorización de Grafcets............................................................................................................... 165
2.1.10. Grafcet y macro-etapas.................................................................................................................. 166
2.1.11. Folios en cadena ............................................................................................................................ 167
2.1.12. Logigrama...................................................................................................................................... 169
2.1.13. Grafcet y Logigrama...................................................................................................................... 170
2.1.14. Caja de lenguaje literal .................................................................................................................. 171
AUTOMGEN
7
5 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2.1.15. Organigrama.................................................................................................................................. 172
2.1.16. Organigrama.................................................................................................................................. 173
2.1.17. Bloque funcional............................................................................................................................ 174
2.1.18. Bloque funcional............................................................................................................................ 175
2.1.19. Ladder............................................................................................................................................ 176
2.1.20. Ejemplo desarrollado sobre una maqueta de tren ..........................................................................177
Manual pedagógico del usuario de AUTOMGEN............................................................... 183
Distribución ................................................................................................................................... 185
El Doctor R. en el reino de la domótica....................................................................................... 185
Primer ejemplo: « quién fue el primero, el interruptor o la bombilla … » ............................. 186
Solución 1: el lenguaje natural del electricista: ladder .............................................................................. 187
Solución 2: el lenguaje secuencial del automatista: Grafcet...................................................................... 187
A jugar … ...................................................................................................................................... 190
Segundo ejemplo: « temporizaciones, minuteros y otras diversiones temporales… »............ 190
Solución 1: la simplicidad ......................................................................................................................... 191
Solución 2: mejora..................................................................................................................................... 192
Tercer ejemplo: « variación sobre el tema del conmutador… »............................................... 193
He aquí una solución en logigrama: .......................................................................................................... 194
Una solución que utiliza el lenguaje literal de AUTOMGEN. .................................................................. 195
Otra más astuta:......................................................................................................................................... 196
Prueben esto: ............................................................................................................................................. 196
Cuarto ejemplo: « Y el botón pulsador se vuelve inteligente … » ............................................ 197
Las soluciones … ........................................................................................................................... 200
Las soluciones … ........................................................................................................................... 201
« quién fue el primero, el interruptor o la bombilla … »........................................................................... 201
« temporizaciones, minuteros y otras diversiones temporales… »............................................................ 201
« variación sobre el tema del conmutador …» ........................................................................... 203
AUTOMGEN
7
6 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1. Elementos comunes
Este capítulo detalla los elementos comunes a todos los lenguajes utilizables en
AUTOMGEN.
El logo identifica las novedades utilizables en la versión 7 de AUTOMGEN.
1.1. Variables
Existen los siguientes tipos de variables:
Ö tipo booleano: la variable puede adoptar el valor verdadero (1) o falso (0).
Ö tipo numérico: la variable puede adoptar un valor numérico; existen diferentes
subtipos: variables 16 bits, 32 bits y coma flotante.
Ö tipo temporización: tipo estructurado; es una combinación del booleano y el
numérico.
A partir de la versión 6 la sintaxis de los nombres de variables puede ser la de
AUTOMGEN o la de la norma CEI 1131-3.
1.1.1. Variables booleanas
La tabla siguiente ofrece la lista exhaustiva de variables booleanas utilizables.
Tipo Sintaxis
AUTOMGEN
Sintaxis
CEI 1131-3
Comentario
Entradas I0
a I9999
%I0
a %I9999
Puede corresponder o no a entradas físicas
(depende de la configuración de las E/S del
destino).
Salidas O0
a O9999
%Q0
a %Q9999
Puede corresponder o no a entradas físicas
(depende de la configuración de las E/S del
destino).
Bits Sistema U0
a U99
%M0
a %M99
Ver el manual sobre el entorno para el detalle
de los bis Sistema.
Bits Usuario U100
a U9999
%M100
a %M9999
Bits internos de uso general.
AUTOMGEN
7
7 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Etapas
Grafcet
X0
a X9999
%X0
a %X9999
Bits de etapas Grafcet.
Bits de
palabras
M0#0
a M9999#15
%MW0:X0
a %MW9999:X15
Bits de palabras: el número del bit se
expresa en decimal y está
comprendido entre 0 (bit de peso
débil) y 15 (bit de peso fuerte).
1.1.2. Variables numéricas
La tabla siguiente ofrece la lista exhaustiva de variables numéricas.
Tipo Sintaxis
AUTOMGEN
Sintaxis
CEI 1131-3
Comentario
Contadores C0
a C9999
%C0
a %C9999
Contador de 16 bits; puede
inicializarse, incrementarse,
decrementarse y testearse con los
lenguajes booleanos sin utilizar el
lenguaje literal.
Palabras
Sistema
M0
a M199
%MW0
a %MW199
Ver el manual sobre el entorno para el
detalle de las palabras Sistema.
Palabras
Usuario
M200
a M9999
%MW200
a %MW9999
Palabra de 16 bits de uso general.
Largos L100
a L4998
%MD100
a %MD4998
Valor entero sobre 32 bits.
Flotantes F100
a F4998
%MF100
a %MF4998
Valor real sobre 32 bits (formato
IEEE).
1.1.3. Temporizaciones
La temporización es un tipo compuesto que agrupa dos variables booleanas (estado
de lanzamiento, estado de fin) y dos variables numéricas sobre 32 bits (la consigna y
el contador).
AUTOMGEN
7
8 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
El esquema siguiente muestra el cronograma de funcionamiento de una
temporización:
état de lancement
1
0
consigne
valeur de comptage
0
0
1
état de fin
El valor de consigna de una temporización está comprendido entre 0 ms y
4294967295 ms (vale decir, poco más de 49 días)
La consigna de la temporización puede modificarse por programa; ver el capítulo
(instrucción STA). 1.10.3. El lenguaje literal bajo nivel
1.10.3. El
lenguaje literal bajo nivel
El contador de la temporización puede leerse por programa; ver el capítulo
(instrucción LDA).
AUTOMGEN
7
9 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.2. Acciones
Las acciones se utilizan en:
Ö los rectángulos de acción del lenguaje Grafcet,
Ö los rectángulos de acción del lenguaje logigrama,
Action
Action
Ö las bobinas del lenguaje ladder.
Action
1.2.1. Asignación de una variable booleana
La sintaxis de la acción « Asignación » es:
«variable booleana»
Funcionamiento:
Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero,
la variable se pone en 1 (estado verdadero),
Ö si el comando del rectángulo de acción o de la bobina está en estado falso, la
variable se pone en 0 (estado falso).
Tabla de verdad:
Comando Estado de la variable (resultado)
0 0
1 1
Ejemplo:
Si la etapa 10 está activa, O0 adopta el valor 1; si no, O0 adopta el valor 0.
AUTOMGEN
7
10 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Es posible utilizar varias acciones « Asignación » para una misma variable dentro de
un programa. En este caso, los diferentes comandos se combinan en « O » lógico.
Ejemplo:
Estado de X10 Estado de X50 Estado de O5
0 0 0
1 0 1
0 1 1
1 1 1
Asignación complementada de una variable booleana
La sintaxis de la acción « Asignación complementada » es:
«N variable booleana»
Funcionamiento:
Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero,
la variable se pone en 0 (estado falso),
Ö si el comando del rectángulo de acción o de la bobina está en estado falso, la
variable se pone en 1 (estado verdadero).
Tabla de verdad:
Comando Estado de la variable (resultado)
0 1
1 0
Ejemplo:
Si la etapa 20 está activa, U100 adopta el valor 0; si no, U100 adopta el valor 1.
AUTOMGEN
7
11 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Es posible utilizar varias acciones « Asignación complementada» para una misma
variable dentro de un programa. En este caso, los diferentes comandos se combinan
en « O » lógico.
Ejemplo:
Estado de X100 Estado de X110 Estado de O20
0 0 1
1 0 0
0 1 0
1 1 0
1.2.2. Puesta en uno de una variable booleana
La sintaxis de la acción « Puesta en uno » es:
«S variable booleana»
Funcionamiento:
Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero,
la variable se pone en 1 (estado verdadero),
Ö si el comando del rectángulo de acción o de la bobina está en estado falso, el
estado de la variable no se modifica.
Tabla de verdad:
Comando Estado de la variable (resultado)
0 no cambia
1 1
Ejemplo:
Si la etapa 5000 está activa, O2 adopta el valor 1; si no, O2 conserva su estado.
AUTOMGEN
7
12 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.2.3. Puesta en cero de una variable booleana
La sintaxis de la acción « Puesta en cero » es:
«R variable booleana»
Funcionamiento:
Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero,
la variable se pone en 0 (estado falso),
Ö si el comando del rectángulo de acción o de la bobina está en estado falso, el
estado de la variable no se modifica.
Tabla de verdad:
Comando Estado de la variable (resultado)
0 no cambia
1 0
Ejemplo:
Si la etapa 6000 está activa, O3 adopta el valor 0; si no, O3 conserva su estado.
1.2.4. Inversión de una variable booleana
La sintaxis de la acción « Inversión » es:
«I variable booleana»
Funcionamiento:
Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero,
el estado de la variable se invierte a cada ciclo de ejecución,
Ö si el comando del rectángulo de acción o de la bobina está en estado falso, el
estado de la variable no se modifica.
AUTOMGEN
7
13 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Tabla de verdad:
Comando Estado de la variable (resultado)
0 no cambia
1 invertido
Ejemplo:
Si la etapa 7000 está activa, el estado de O4 se invierte; si no, O4 conserva su
estado.
1.2.5. Puesta en cero de un contador, una palabra o un largo
La sintaxis de la acción « Puesta en cero de un contador, una palabra o un largo»
es:
«R contador o palabra»
Funcionamiento:
Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero,
el contador, la palabra o el largo se pone en cero,
Ö si el comando del rectángulo de acción o de la bobina está en estado falso, el
valor del contador, de la palabra o del largo no se modifica.
Tabla de verdad:
Comando Valor del contador, de la
palabra o del largo (resultado)
0 No cambia
1 0
Ejemplo:
Si la etapa 100 está activa, el contador 25 se pone en cero; si no, C25 conserva su
valor.
AUTOMGEN
7
14 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.2.6. Incremento de un contador, una palabra o un largo
La sintaxis de la acción « Incremento de un contador » es:
«+ contador, palabra o largo»
Funcionamiento:
Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero,
el contador, la palabra o el largo se incrementa a cada ciclo de ejecución,
Ö si el comando del rectángulo de acción o de la bobina está en estado falso, el
valor del contador no se modifica.
Tabla de verdad:
Comando Valor del contador, de la
palabra o del largo (resultado)
0 No cambia
1 valor actual +1
Ejemplo:
Si la etapa 100 está activa, el contador 25 se incrementa; si no, C25 conserva su
valor.
1.2.7. Decremento de un contador, una palabra o un largo
La sintaxis de la acción « Decremento de un contador » es:
«- contador, palabra o largo»
Funcionamiento:
Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero, el
contador, la palabra o el largo se decrementa a cada ciclo de ejecución,
Ö si el comando del rectángulo de acción o de la bobina está en estado falso, el
valor del contador no se modifica.
AUTOMGEN
7
15 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Tabla de verdad:
Comando Valor del contador, de la
palabra o del largo (resultado)
0 no cambia
1 valor actual –1
Ejemplo:
Si la etapa 100 está activa, el contador 25 se decrementa; si no, C25 conserva su
valor.
1.2.8. Temporizaciones
Las temporizaciones se consideran como variables booleanas y pueden utilizarse
con las acciones « Asignación », « Asignación complementada », « Puesta en uno »,
« Puesta en cero » e « Inversión ». La consigna de la temporización puede escribirse
a continuación de la acción. La sintaxis es:
« temporización(duración) »
La duración se expresa en forma predeterminada en décimas de segundo. El
carácter « S » ubicado al final de la duración indica que se expresa en segundos.
Ejemplos:
La etapa 10 lanza una temporización de 2 segundos que permanecerá activa
mientras la etapa permanezca activa. La etapa 20 arma una temporización de 6
segundos que permanecerá activa aunque la etapa 20 esté desactivada.
Una misma temporización puede utilizarse en varios sitios con una misma consigna
en momentos diferentes. En este caso, la consigna de la temporización debe
indicarse una sola vez.
Observación: existen otras sintaxis para las temporizaciones. Ver el capítulo
1.3.3.
Temporizaciones
AUTOMGEN
7
16 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.2.9. Interferencias entre las acciones
Ciertos tipos de acción no pueden utilizarse simultáneamente con una variable. La
siguiente tabla resume las combinaciones posibles.
Asignación
Asignación
complementada
Puesta
en uno
Puesta
en cero
Inversión
Asignación
SÍ NO NO NO NO
Asignación
complementada
NO SÍ NO NO NO
Puesta en uno
NO NO SÍ SÍ SÍ
Puesta en cero
NO NO SÍ SÍ SÍ
Inversión
NO NO SÍ SÍ SÍ
1.2.10. Acciones de la norma CEI 1131-3
La siguiente tabla ofrece la lista de acciones de la norma CEI 1131-3 utilizables en
AUTOMGEN V>=6 con respecto a la sintaxis estándar de AUTOMGEN. V5.
Nombre Sintaxis
AUTOMGEN
V>=6
Sintaxis
AUTOMGEN
V5
Ejemplo
AUTOMGEN
V>=6
Ejemplo
de equivalente
AUTOMGEN V5
No memorizado Ninguno Ninguno
No memorizado N1 Ninguno
No memorizado
complementado
N0 N
Puesta en cero
R R
AUTOMGEN
7
17 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Puesta en 1 S S
Limitado
en el tiempo
LTn/duración Inexistente
Temporizado DTn/
duración
Inexistente
Impulsión sobre
frente ascendente
P1 Inexistente
Impulsión sobre
frente descendente
P0 Inexistente
Memorizado
y temporizado
SDTn/
duración
Inexistente
Temporizado
y memorizado
DSTn/
duración
Inexistente
Memorizado
y limitado
en el tiempo
SLTn/
duración
Inexistente
1.2.11. Acciones múltiples
Dentro de un mismo rectángulo de acción o de una bobina, es posible escribir varias
acciones separándolas con el carácter « , » (coma).
Ejemplo:
Es posible yuxtaponer varios rectángulos de acción (Grafcet y logigrama) o bobinas
(ladder). Consultar los capítulos correspondientes a estos lenguajes para más
detalles.
AUTOMGEN
7
18 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.2.12. Código literal
En un rectángulo de acción o una bobina es posible insertar código literal.
La sintaxis es:
« { código literal } »
Es posible escribir entre las llaves varias líneas de lenguaje literal. También aquí el
separador es el carácter « , » (coma).
Ejemplo:
Consultar los capítulos « Lenguaje literal bajo nivel », « Lenguaje literal extendido » y
« Lenguaje literal ST » para más detalles.
1.3. Tests
Los tests se utilizan en:
Ö transiciones del lenguaje Grafcet,
Test
Ö condiciones sobre acción del lenguaje Grafcet,
Test
Test
Ö tests del lenguaje logigrama,
Test
AUTOMGEN
7
19 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Ö tests del lenguaje ladder.
Test
1.3.1. Forma general
Un test es una ecuación booleana compuesta por una o por n variables separadas
por los operadores « + » (o) o « . » (y).
Ejemplo de test:
i0 (test entrada 0)
i0+i2 (test entrada 0 « o » entrada 2)
i10.i11 (test entrada 10 « y » entrada 11)
1.3.2. Modificador de test
Si se especifica sólo el nombre de una variable, el test predeterminado es « si igual
a uno» (si verdadero). Es posible utilizar modificadores para testear el estado
complementado, el frente ascendente y el frente descendente:
Ö el carácter « / » ubicado delante de una variable testea el estado
complementado,
Ö el carácter « u » o el carácter « Ï
*
» ubicado delante de una variable testea el
frente ascendente,
Ö el carácter « d » o el carácter « Ð
**
» ubicado delante de una variable testea el
frente descendiente.
Los modificadores de tests pueden aplicarse a una variable o a una expresión entre
paréntesis.
Ejemplos:
Ï i0
/i1
/(i2+i3)
Ð(i2+(i4./i5))
*
Para obtener este carácter durante la edición de un test presione la tecla [Ï].
**
Para obtener este carácter durante la edición de un test presione la tecla [Ð].
AUTOMGEN
7
20 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.3.3. Temporizaciones
Hay cuatro sintaxis disponibles para las temporizaciones.
En la primera, se activa la temporización en la acción y se menciona simplemente la
variable temporización en un test para verificar el estado de fin:
En las otras, todo se escribe en el test. La forma general es:
« temporización / variable de lanzamiento / duración »
o
« duración / variable de lanzamiento / temporización »
o
« duración / variable de lanzamiento »
En este caso, se atribuye una temporización automáticamente. La zona de atribución
es la de los símbolos automáticos; ver el capítulo . 1.4.2. Símbolos automáticos
La duración se expresa en forma predeterminada en décimas de segundo.
La duración puede expresarse en días, horas, minutos, segundos y
milisegundos con los operadores « d », « h », « m », « s » y « ms ». Por ejemplo:
1d30s = 1 día y 30 segundos.
Ejemplo con la segunda sintaxis:
Ejemplo con la sintaxis normalizada:
1.3.4. Prioridad de los operadores booleanos
El operador booleano « . » (Y) tiene una prioridad predeterminada mayor que el
operador « + » (O). Es posible utilizar paréntesis para definir otra prioridad.
AUTOMGEN
7
21 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Ejemplos:
i0.(i1+i2)
((i0+i1).i2)+i5
1.3.5. Test siempre verdadero
La sintaxis del test siempre verdadero es:
« » (ninguno) o « =1 »
1.3.6. Test sobre variable numérica
Los tests sobre variable numérica deben utilizar la siguiente sintaxis:
« variable numérica » « tipo de test » « constante o variable numérica »
El tipo de test puede ser:
Ö « = » igual,
Ö « ! » o « <> » diferente,
Ö « < » menor (sin signo),
Ö « > » mayor (sin signo),
Ö « << » menor (con signo),
Ö « >> » mayor (con signo),
Ö « <= » menor o igual (sin signo),
Ö « >= » mayor o igual (sin signo),
Ö « <<= » menor o igual (con signo),
Ö « >>= » mayor o igual (con signo).
Un flotante puede compararse sólo con otro flotante o con una constante real.
Un largo puede compararse sólo con otro largo o con una constante larga.
Una palabra o un contador puede compararse sólo con una palabra, un contador o
una constante 16 bits.
Las constantes reales deben estar seguidas del carácter « R ».
Las constantes largas (32 bits) deben estar seguidas del carácter « L ».
Les constantes enteras 16 o 32 bits están predeterminadas en decimal. Pueden
escribirse en hexadecimal (sufijo « $ » o « 16# ») o en binario (sufijo « % » o « 2# »).
AUTOMGEN
7
22 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Los tests sobre variables numéricas se utilizan en las ecuaciones como los tests
sobre variables booleanas. Pueden utilizarse con los modificadores de test siempre
que estén encerrados por paréntesis.
Ejemplos:
m200=100
%mw1000=16#abcd
c10>20.c10<100
f200=f201
m200=m203
%md100=%md102
f200=3.14r
l200=$12345678L
m200<<-100
m200>>1000
%mw500<=12
/(m200=4)
Ð(m200=100)
/(l200=100000+l200=-100000)
1.3.7. Transiciones en varias líneas
El texto de las transiciones puede ocupar varias líneas. El fin de una línea de
transición debe ser indefectiblemente un operador « . » o « + ». Las combinaciones
de teclas [CTRL] + [Ð] y [CTRL] + [Ï] permiten desplazar el cursor de una línea a
otra.
1.4. Utilización de símbolos
Los símbolos permiten asociar un texto a una variable.
Los símbolos pueden utilizarse con todos los lenguajes.
Un símbolo debe asociarse a una y sólo una variable.
1.4.1. Sintaxis de los símbolos
Los símbolos están compuestos por:
Ö un carácter « _ » opcional (subrayado, generalmente asociado a la tecla [8] en
los teclados) que marca el principio del símbolo,
Ö el nombre del símbolo,
Ö un carácter « _ » opcional (subrayado) que marca el fin del símbolo.
AUTOMGEN
7
23 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Los caracteres « _ » que encierran los nombres de los símbolos son
opcionales. Deben utilizarse si el símbolo empieza con una cifra o un operador (+,-,
etc…).
1.4.2. Símbolos automáticos
A veces es incómodo tener que definir la atribución entre cada símbolo y una
variable, especialmente si la atribución precisa de un número de variable tiene poca
importancia. Los símbolos automáticos son una solución a este problema, ya que
confían al compilador la tarea de generar automáticamente la atribución de un
símbolo a un número de variable. El tipo de variable a utilizar está dado por el
nombre del símbolo.
1.4.3. Sintaxis de los símbolos automáticos
La sintaxis de los símbolos automáticos es la siguiente:
_« nombre del símbolo » %« tipo de variable »_
El « tipo de variable » puede ser:
I , O o Q, U o M, T, C, M o MW, L o MD, F o MF.
Es posible reservar varias variables para un símbolo. Esto es útil para definir tablas.
En este caso la sintaxis es:
_« nombre del símbolo » %« tipo de variable »« longitud »_
La « longitud » representa el número de variables a reservar.
1.4.4. ¿Cómo gestiona el compilador los símbolos
automáticos?
Para compilar una aplicación, el compilador borra todos los símbolos automáticos
que se encuentran en el archivo « .SYM » de la aplicación. Cada vez que encuentra
un símbolo automático, crea una atribución única para ese símbolo en función del
tipo de variable especificado en el nombre del símbolo. El símbolo generado se
escribe en el archivo « .SYM ». Si un mismo símbolo automático aparece varias
veces en una aplicación, hará referencia a la misma variable.
AUTOMGEN
7
24 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.4.5. Zona de atribución de las variables
Cada tipo de variable tiene una zona de atribución predeterminada:
Tipo Principio Fin
I o %I 0 9999
O o %Q 0 9999
U o %M 100 9999
T o %T 0 9999
C o %C 0 9999
M o %MW 200 9999
L o %MD 100 4998
F o %MF 100 4998
La zona de atribución puede modificarse para cada tipo de variable utilizando la
directiva de compilación #SR« tipo »=« principio », « fin »
« tipo » designa el tipo de variable; « principio » y « fin », los nuevos límites a utilizar.
Esta directiva modifica la atribución de las variables automáticas en cada sitio del
folio donde está escrita hasta la siguiente directiva « #SR ».
AUTOMGEN
7
25 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.5. A propósito de ejemplos
Para ilustrar mejor este manual, hemos desarrollado ejemplos que funcionan con
una maqueta de tren cuyo esquema es el siguiente:
MAQUETA AT-850
vía 1
vía 3
vía 6
vía 7
vía 2 vía 4
1 4
2
3
5
vía 5
vía 8
S1I
T1I
S1D
T1D
S6I
T6I
S6D
T6D
S7I
T7I
S7D
T7D
S2A
T2A
S2B
T2B
S5I
T5I
S5D
T5D
S8I
T8I
S8D
T8D
S4A
T4A
S4B
T4B
S3I
T3I
S3D
T3D
Para pilotear esta maqueta hemos utilizado mapas de E/S en PC. Los símbolos
definidos por el constructor de la maqueta se han conservado.
AUTOMGEN
7
26 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Se ha creado el siguiente fichero de símbolos:
AUTOMGEN
7
27 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.6. Grafcet
AUTOMGEN soporta los elementos siguientes:
Ö divergencias y convergencias en « Y » y en « O »,
Ö etapas pozos y fuentes,
Ö transiciones pozos y fuentes,
Ö sincronización,
Ö forzados de Grafcets,
Ö memorización de Grafcets,
Ö fijación,
Ö macro-etapas.
1.6.1. Grafcet simple
La escritura de Grafcet en línea se resume a la yuxtaposición de etapas y
transiciones.
Ilustremos un Grafcet en línea con el ejemplo siguiente:
Condiciones:
La locomotora debe partir por la vía 3 hacia la derecha, hasta el extremo de la vía.
Luego regresa en sentido inverso hasta el otro extremo y vuelve a empezar.
AUTOMGEN
7
28 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución 1:
0AV1
t1d
1 AV1 , DV1
t1i
exemples\grafcet\simple1.agn
Solución 2:
0 S AV1 ,R DV1
Aller
t1d
1 S AV1 ,S DV1
Retou
r
t1i
exemple\grafcet\simple2.agn
La diferencia entre estas dos soluciones reside en el uso de las acciones
« Asignación » para el primer ejemplo y de las acciones « Puesta en uno » y
« Puesta en cero » para el segundo.
Modifiquemos las condiciones con una espera de 10 segundos cuando la locomotora
llega a la derecha de la vía 1 y una espera de 4 segundos cuando la locomotora
llega a la izquierda de la vía 1.
AUTOMGEN
7
29 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución 1:
0 AV1
Aller
t1d
10 T0(10S)
t0
20 AV1 , DV1
Retou
r
t1i
30 T1(4S)
t1
0 AV1
Aller
exemple\grafcet\simple3.agn
Solución 2:
t1d
10
10s/x10
20 AV1 , DV1
Retou
r
t1i
30
4s/x30
exemple\grafcet\simple4.agn
AUTOMGEN
7
30 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
La diferencia entre los ejemplos 3 y 4 reside en la elección de la sintaxis utilizada
para definir las temporizaciones. El resultado desde el punto de vista funcional es
idéntico.
1.6.2. Divergencia y convergencia en « Y »
Las divergencias en« Y » pueden tener n ramas. Lo importante es respetar la
utilización de los bloques de función:
Obligatoirement
un bloc [K] et
pas un bloc [L]
Obligatoirement
un bloc [M] et
pas un bloc [L]
Obligatoirement
un bloc [O] et
pas un bloc [P]
Obligatoirement
un bloc [Q] et
pas un bloc [P]
Ilustremos la utilización de las divergencias y convergencias en « Y ».
Condiciones:
Vamos a utilizar dos locomotoras: la primera efectuará idas y vueltas por la vía 1, la
segunda por la vía 3. Las dos locomotoras estarán sincronizadas (se esperarán en el
extremo de la vía).
AUTOMGEN
7
31 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución 1:
t1i t3d
40
=1
0 AV1 50 AV3
t1d t3i
10 60
=1
20 AV1 , DV1 70 AV3 , DV3
30 80
=1
exemple\grafcet\divergence et 1.agn
AUTOMGEN
7
32 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución 2:
t1d t3i
0 AV1 10 AV3
t1d . t3i
t1i t3d
20 AV1 , DV1 30 AV3 , DV3
t1i . t3d
exemple\grafcet\divergence et 2.agn
Estas dos soluciones son equivalentes desde el punto de vista funcional. La
segunda es una versión más compacta que utiliza acciones condicionadas.
1.6.3. Divergencia y convergencia en « O »
Las divergencias en « O » pueden tener n ramas. Lo importante es respetar la
utilización de los bloques de función:
o
AUTOMGEN
7
33 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
o
Las divergencias en « O » deben ramificarse obligatoriamente en vínculos
descendentes. Por ejemplo:
incorrecto; el diseño correcto es:
AUTOMGEN
7
34 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Si el ancho de la página no permite escribir un gran número de divergencias, se
puede adoptar una estructura del tipo:
Veamos un ejemplo para ilustrar la utilización de las divergencias y convergencias
en « O »:
Condiciones:
Retomemos las condiciones del primer ejemplo del capítulo: ida y vuelva de una
locomotora por la vía 1.
Solución:
0 AV1
ÇÇ
t1d t1i
DV1 2 R DV1
=1
1 S
=1
exemple\grafcet\divergence ou.agn
AUTOMGEN
7
35 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Este Grafcet podría resumirse en una etapa utilizando acciones condicionadas,
como en este ejemplo:
ÇÇ
t1d t1i
0 AV1 S DV1 R DV1
exemple\grafcet\action conditionnée.agn
1.6.4. Etapas pozos y fuentes, transiciones pozos y fuentes
Ilustremos estos principios con ejemplos:
Condiciones:
Tratemos de nuevo el segundo ejemplo de este capítulo: ida y vuelta de una
locomotora por la vía 1 con espera al final de la vía.
Solución:
0 S AV1
ÇÇ
t1d t1i
10 R AV1 30 R AV1
t0/x10/10s t1/x30/4s
20 S AV1 S DV1 40 S AV1 R DV1
=1 =1
exemple\grafcet\étapes puits et sources.agn
1.6.5. Acciones múltiples, acciones condicionadas
Ya hemos utilizado en este capítulo acciones múltiples y acciones condicionadas.
Detallemos estos dos principios.
AUTOMGEN
7
36 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Como se indica en el capítulo sobre el compilador, es posible escribir varias
acciones en un mismo rectángulo; en este caso, el carácter « , » (coma) sirve como
delimitador.
Cuando una condición se añade a un rectángulo de acción, se condiciona el
conjunto de las acciones contenidas en el rectángulo.
Es posible asociar varios rectángulos de acción a una etapa:
Otra posibilidad:
Cada rectángulo puede recibir una condición diferente:
Para diseñar una acción condicionada, ubique el cursor en el rectángulo de acción,
haga clic con el botón derecho del ratón y elija « Acción condicional » en el menú.
Para documentar la condición sobre acción, haga clic en el elemento
.
La sintaxis IF(condición) permite escribir una condición sobre acción en el
rectángulo de acción.
AUTOMGEN
7
37 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.6.6. Sincronización
Retomemos un ejemplo ya tratado para ilustrar la sincronización de Grafcets.
Condiciones:
Ida y vuelta de dos locomotoras por las vías 1 y 3 con espera entre las locomotoras
en el extremo de la vía.
Este ejemplo se había tratado con una divergencia en « Y ».
Solución 1:
10 AV1 100 AV3
t1d t3i
20 110
x110 x20
30 AV1 , DV1 120 AV3 , DV3
t3d
x40
t1i
40 130
x130
exemple\grafcet\synchro1.agn
AUTOMGEN
7
38 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución 2:
10 SX100,SX140
=1
20
x110.x150
30 SX120,SX160
=1
40
x130.x170
AV3 , DV3
t3d
x10
100 AV1 120 AV1 , DV1 140 AV3 160
t1d t1i t3i
110 130 150 170
x30 x10 x30
exemple\grafcet\synchro2.agn
Esta segunda solución es un excelente ejemplo del arte de complicar las cosas más
simples con fines pedagógicos.
1.6.7. Forzados de Grafcet
El compilador agrupa las etapas en función de los vínculos establecidos entre ellas.
Para designar un Grafcet, es suficiente hacer referencia a una de las etapas que
componen ese Grafcet.
Del mismo modo se puede designar el conjunto de Grafcets presentes en un
folio mencionando el nombre del folio.
AUTOMGEN
7
39 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Por ejemplo:
Para designar este Grafcet hablaremos de Grafcet 200, Grafcet 201 o Grafcet 202.
Al ser un conjunto de etapas, el Grafcet se convierte en una variable estructurada
compuesta por n etapas; cada etapa puede estar activa o inactiva.
Como hemos visto, AUTOMGEN divide las etapas en conjuntos independientes que
pueden agruparse, lo cual permite considerarlos como un solo Grafcet. Para agrupar
varios Grafcets se debe utilizar la directiva de compilación « #G:g1,g2 » (comando
a incluir en un comentario). Este comando agrupa los Grafcets g1 y g2. Recordemos
que la designación de un Grafcet se efectúa invocando el número de una de sus
etapas.
Veamos un ejemplo:
#G:105,200
esta directiva de compilación agrupa estos dos Grafcets:
Observación: es posible utilizar varias directivas « #G » para agrupar más de dos
Grafcets.
Ahora vamos a detallar las órdenes de forzado utilizables. Se escribirán simplemente
en rectángulos de acción como asignaciones clásicas. Soportarán tanto los
operadores S(puesta en uno), R(puesta en cero), N(asignación complementada) e
I(inversión) como las acciones condicionales.
AUTOMGEN
7
40 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.6.7.1. Forzado de un Grafcet según una lista de etapas activas
Sintaxis:
« F<Grafcet>:{<lista de etapas activas>} »
o
« F/<nombre de folio>:{<lista de etapas activas>} »
El o los Grafcets designados se forzarán al estado definido por la lista de etapas
activas que se encuentra entre llaves. Si deben estar activas varias etapas, es
necesario separarlas con el carácter « , » (coma). Si el o los Grafcets deben forzarse
al estado vacío (ninguna etapa activa), no hay que precisar ninguna etapa entre las
dos llaves.
El número de etapas puede estar precedido de « X ». Así se puede asociar un
símbolo al nombre de una etapa.
Ejemplos:
« F10:{0} »
fuerza todas las etapas del Grafcet 10 a 0 salvo la etapa 0, que se fuerza a 1.
« F0:{4,8,9,15} »
fuerza todas las etapas del Grafcet 0 a 0, salvo las etapas 4, 8, 9 y 15, que se
fuerzan a 1.
« F/marcha normal:{} »
fuerza todos los Grafcets que se encuentran en el folio « marcha normal » al estado
vacío.
1.6.7.2. Memorización del estado de un Grafcet
Estado actual de un Grafcet:
Sintaxis:
« G<Grafcet>:<N° de bit> »
o
« G/<nombre de folio>:<N° de bit> »
Este comando memoriza el estado de uno o varios Grafcets en una serie de bits. Es
necesario reservar un espacio para almacenar el estado del o de los Grafcets
AUTOMGEN
7
41 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
designados (un bit por etapa). Estos bits de almacenamiento deben ser
consecutivos. Utilice un comando #B para reservar un espacio lineal de bit.
El número de la etapa que designa el Grafcet puede estar precedido de « X ».
Así se puede asociar un símbolo al nombre de una etapa. El número del bit puede
estar precedido de « U » o de « B ». Así se puede asociar un símbolo al primer bit de
la zona de almacenamiento de estado.
Estado particular de un Grafcet:
Sintaxis:
« G<Grafcet>:<N° de bit> {lista de etapas activas} »
o
« G/<nombre de folio>:<N° de bit> {lista de etapas activas} »
Este comando memoriza el estado definido por la lista de etapas activas aplicadas a
los Grafcets especificados a partir del bit indicado. También aquí es necesario
reservar un número suficiente de bits. Si debe memorizarse una situación vacía, no
debe aparecer ninguna etapa entre las dos llaves.
El número de las etapas puede estar precedido de « X ». Así se puede
asociar un símbolo al nombre de una etapa. El número del bit puede estar precedido
de « U » o de « B ». Así se puede asociar un símbolo al primer bit de la zona de
almacenamiento de estado.
Ejemplos:
« G0:100 »
memoriza el estado actual del Grafcet 0 a partir de U100.
« G0:U200 »
memoriza el estado vacío del Grafcet 0 a partir de U200.
« G10:150{1,2} »
memoriza el estado del Grafcet 10, en el que sólo las etapas 1 y 2 están activas, a
partir de U150.
« G/PRODUCCIÓN:_ GUARDAR ESTADO PRODUCCIÓN _ »
memoriza el estado de los Grafcets que se encuentran en el folio « PRODUCCIÓN »
en la variable _GUARDAR ESTADO PRODUCCIÓN_.
AUTOMGEN
7
42 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.6.7.3. Forzado de un Grafcet a partir de un estado memorizado
Sintaxis:
« F<Grafcet>:<N° de bit> »
o
« F/<Nombre de folio>:<N° de bit> »
Fuerza el o los Grafcets con el estado memorizado a partir del bit precisado.
El número de la etapa que designa el Grafcet puede estar precedido de ‘X’. Así se
puede asociar un símbolo al nombre de una etapa. El número del bit puede estar
precedido de « U » o de « B ». Así se puede asociar un símbolo al primer bit de la
zona de almacenamiento de estado.
Ejemplo:
« G0:100 »
memoriza el estado actual del Grafcet 0
« F0:100 »
restaura ese estado
1.6.7.4. Fijación de un Grafcet
Sintaxis:
« F<Grafcet> »
o
« F/<Nombre de folio> »
Fija uno o varios Grafcets: impide su evolución.
Ejemplo:
« F100 »
fija el Grafcet 100
« F/producción »
fija los Grafcets contenidos en el folio « producción »
Ilustremos los forzados con un ejemplo.
AUTOMGEN
7
43 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Condiciones:
Retomemos un ejemplo ya tratado: ida y vuelta de dos locomotoras por las vías 1 y 3
(esta vez sin espera entre las locomotoras). Añadamos una parada de urgencia.
Cuando se detecta la parada de urgencia, todas las salidas se ponen en cero. Al
desaparecer la parada de urgencia, el programa debe reanudar el recorrido desde
donde se detuvo.
AUTOMGEN
7
44 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución 1:
#B104 réserve 4 bits pour la mémorisation de l'état des Grafcet
s
locomotive 1 locomotive 2
10 AV1 30 AV3
t1d t3i
20 AV1 , DV1 40 AV3 , DV3
t1i t3d
gestion de l'arrêt d'urgence
1000
arret urgence
1010 G10:100,G30:102
=1
1020 F10:{},F30:{}
arret urgence
1030 F10:100,F30:102
=1
exemple\grafcet\forçage1.agn
La utilización de la directiva #B104 permite reservar cuatro bits consecutivos (U100 a
U103) para memorizar el estado de los dos Grafcets.
AUTOMGEN
7
45 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
« _parada urgencia_ » ha sido asociado a un bit (U1000). Por lo tanto su estado
puede modificarse desde el entorno posicionándose encima y haciendo clic cuando
la visualización dinámica está activada.
AUTOMGEN
7
46 (C)opyright 2002 IRAI
La página se está cargando ...
Manual de referencia del lenguaje
Esta segunda solución muestra la utilización de la directiva de compilación « #G »
que permite agrupar los Grafcets para los comandos de forzado.
1.6.8. Macro-etapas
AUTOMGEN implementa las macro-etapas.
A propósito de este tema recordemos que:
Una macro-etapa ME es la única representación de un conjunto único de etapas y
transiciones llamado « expansión de ME ».
Una macro-etapa obedece a las reglas siguientes:
Ö la expansión de ME implica una etapa particular llamada etapa de entrada y una
etapa particular llamada etapa de salida.
Ö la etapa de entrada tiene la propiedad siguiente: si superamos una transición
anterior a la macro-etapa, se activa la etapa de entrada de su expansión.
Ö la etapa de salida tiene la propiedad siguiente: participa de la validación de las
transiciones posteriores a la macro-etapa.
Ö fuera de las transiciones anteriores y posteriores a ME, no existe ningún vínculo
estructural entre, por una parte, una etapa o una transición de la expansión ME y,
por otra, una etapa o una transición que no pertenece a ME.
La utilización de las macro-etapas en AUTOMGEN se define así:
Ö la expansión de una macro-etapa es un Grafcet en un folio distinto,
Ö la etapa de entrada de la expansión de una macro-etapa deberá llevar el número
0 o la identificación Exxx (xxx = un número cualquiera),
Ö la etapa de salida de la expansión de una macro-etapa deberá llevar el número
9999 o la identificación Sxxx (xxx = un número cualquiera),
Ö fuera de estas dos últimas obligaciones, la expansión de una macro-etapa puede
ser un Grafcet cualquiera y como tal puede contener macro-etapas (la
imbricación de macro-etapas es posible).
1.6.8.1. Cómo definir una macro-etapa
Debe utilizarse el símbolo . Para colocar este símbolo, haga clic en un sitio
vacío del folio y elija « Más …/Macro-etapa » en el menú contextual. Para abrir el
menú contextual, haga clic con el botón derecho del ratón sobre el fondo del folio.
AUTOMGEN
7
48 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Para definir la expansión de la macro-etapa, cree un folio, diseñe la expansión y
modifique las propiedades del folio (haciendo clic con el botón derecho del ratón en
el nombre del folio en el explorador). Ajuste el tipo de folio en « Expansión de macro-
etapas » y el número de la macro-etapa.
En modo ejecución, es posible visualizar una expansión de macro-etapa. Para ello,
es necesario ubicar el cursor sobre la macro-etapa y hacer clic con el botón
izquierdo del ratón.
Observaciones:
Ö las etapas y los bits Usuario utilizados en una expansión de macro-etapa son
locales, es decir que no tienen ninguna relación con las etapas y los bits de otros
Grafcets. Los otros tipos de variables no presentan esta característica: son
comunes a todos los niveles.
Ö si una zona de bits debe utilizarse de manera global, es necesario declararla con
la directiva de compilación « #B ».
Ö la asignación de variables no locales por diferentes niveles o diferentes
expansiones no es gestionada por el sistema. En otros términos, es necesario
utilizar las asignaciones « S » « R » o « I » para garantizar un funcionamiento
coherente del sistema.
Ilustremos la utilización de las macro-etapas con un ejemplo ya tratado: ida y vuelta
de una locomotora por la vía 1 con espera en el extremo de la vía.
Descompondremos la ida y la vuelta en dos macro-etapas distintas.
AUTOMGEN
7
49 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución:
macro-étape aller voie
1
E1
10 S AV1 ,R DV1
t1d
20 R AV1
t0/x20/10s
S1
macro-étape retour voie
1
E2
10 S AV1 ,S DV1
t1i
20 R AV1
t1/x20/4s
S2
AUTOMGEN
7
50 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
0
=
1
M1
=
1
M2
=
1
exemple\grafcet\macro-étape.agn
1.6.9. Contadores
Ilustremos la utilización de los contadores con un ejemplo.
Condiciones:
Una locomotora debe efectuar 10 idas y vueltas por la vía 1, inmovilizarse durante
quince segundos y volver a arrancar.
AUTOMGEN
7
51 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución:
0
1
2
RC0
=1
AV1
t1d
AV1 , DV1
t1i
3 +C0
c0<10 c0=10
4
15s/x4
exemple\grafcet\compteur.agn
1.7. Gemma
AUTOMGEN implementa la descripción de Grafcet de gestión de los modos de
marcha bajo forma de Gemma. El principio es un modo de edición transparente al
modo Grafcet. Es posible pasar del modo de edición Grafcet al modo de edición
Gemma. La traducción de un Gemma en Grafcet de gestión de modos de marcha es
automático e inmediato.
El comando « Editar bajo la forma de un Gemma » del menú « Caja de
herramientas » permite pasar de un modo al otro.
AUTOMGEN
7
52 (C)opyright 2002 IRAI
La página se está cargando ...
Manual de referencia del lenguaje
1.7.1. Creación de un Gemma
Para crear un Gemma:
Ö haga clic en el elemento « Folio » del explorador con el botón derecho del ratón y
seleccione el comando « Añadir un nuevo folio »,
Ö en la lista de tamaños elija « Gemma »,
Ö haga clic en el pulsador « OK »,
Ö haga clic con el botón derecho del ratón en el nombre del folio creado en el
explorador,
Ö elija « Propiedades » en el menú,
Ö pinche la opción « Mostrar bajo la forma de un Gemma ».
La ventana contiene un Gemma en el que todos los rectángulos y vínculos están
sombreados. Para validar un rectángulo o un vínculo hay que posicionarse encima y
hacer clic con el botón derecho del ratón.
Para modificar el contenido de un rectángulo o la naturaleza de un vínculo hay que
posicionarse encima y hacer clic con el botón izquierdo del ratón.
El contenido de los rectángulos del Gemma se ubicará en los rectángulos de acción
del Grafcet. La naturaleza de los vínculos se ubicará en las transiciones del Grafcet.
A cada rectángulo del Gemma puede asociarse un comentario, que aparecerá cerca
del rectángulo de acción correspondiente en el Grafcet.
1.7.2. Contenido de los rectángulos del Gemma
Los rectángulos del Gemma pueden recibir cualquier acción utilizable en el Grafcet.
Como se trata de definir una estructura de gestión de los modos de parada y de
marcha, es conveniente utilizar órdenes de forzado hacia Grafcets de nivel más bajo;
ver el capítulo 1.6.7. Forzados de Grafcet.
1.7.3. Obtener un Grafcet correspondiente
Una vez más, la opción « Mostrar bajo la forma de un Gemma » en las propiedades
del folio permite volver a una representación Grafcet. Es posible volver en cualquier
momento a una representación Gemma mientras la estructura del Grafcet no se
modifique. Las transiciones, el contenido de los rectángulos de acción y los
comentarios pueden modificarse con una actualización automática del Gemma.
AUTOMGEN
7
54 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.7.4. Anular los espacios vacíos en el Grafcet
Es posible que el Grafcet obtenido ocupe más espacio del necesario en la página. El
comando « Reorganizar la página » del menú « Herramientas » permite suprimir
todos los espacios no utilizados.
1.7.5. Imprimir el Gemma
Cuando la edición está en modo Gemma, el comando « Imprimir » permite imprimir
el Gemma.
1.7.6. Exportar el Gemma
El comando « Copiar en formato EMF » del menú « Edición » permite exportar un
Gemma en formato vectorial.
1.7.7. Ejemplo de Gemma
Ilustremos la utilización del Gemma.
Condiciones:
Imaginemos un escritorio compuesto por los pulsadores « inicio ciclo », « fin de
ciclo » y « parada de urgencia » y el testigo « INIT ».
El propósito del programa principal será hacer efectuar idas y vueltas a una
locomotora por la vía 1.
AUTOMGEN
7
55 (C)opyright 2002 IRAI
La página se está cargando ...
La página se está cargando ...
Manual de referencia del lenguaje
Ç
depart
100 AV1
t1d
110 AV1 , DV1
t1i . fin t1i . fin
120 FIN DE CYCLE OBTENU
fin de cycle obtenu
exemple\gemma\gemma.agn
1.8. Ladder
El lenguaje Ladder, también llamado « esquema de contacto », permite describir
gráficamente ecuaciones booleanas. Para realizar una función lógica « Y », es
necesario escribir contactos en serie. Para realizar una función « O », es necesario
escribir contactos en paralelo.
Función « Y »
Función « O »
El contenido de los contactos debe respetar la sintaxis definida para los tests y
detallada en el capítulo « Elementos comunes » de este manual.
AUTOMGEN
7
58 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
El contenido de las bobinas debe respetar la sintaxis definida para las acciones y
detallada en el capítulo « Elementos comunes » de este manual.
1.8.1. Ejemplo de Ladder
AV1
Ç
t1i R DV1
Ç
t1d S DV1
Empecemos con el ejemplo más simple.
Condiciones:
Ida y vuelta de una locomotora por la vía 1.
Solución 1:
exemple\ladder\ladder1.agn
Solución 2:
AV1
t1i dv1 DV1
t1d
exemple\ladder\ladder2.agn
La segunda solución es idéntica desde el punto de vista funcional. Su interés es
mostrar la utilización de una variable en auto mantenimiento.
Enriquezcamos nuestro ejemplo.
Condiciones:
La locomotora deberá detenerse 10 segundos a la derecha de la vía 1 y 4 segundos
a la izquierda.
AUTOMGEN
7
59 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución:
t1
t1d T0(10S)
S DV1
t1i T1(4S)
R DV1
t1i t1d AV1
t0
exemple\ladder\ladder3.agn
Un último ejemplo un poco más complejo.
Condiciones:
Siempre una locomotora que va y viene por la vía 1. Cada 10 idas y vueltas deberá
marcar un tiempo de parada de 15 segundos.
Solución:
b0 RC0
t0
t1d
dv1 +C0
SDV1
t1i RDV1
c0<10 AV1
t0
c0=10 T0(15S)
exemple\ladder\ladder4.agn
1.9. Logigrama
AUTOMGEN implementa el lenguaje logigrama de la siguiente manera:
AUTOMGEN
7
60 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Ö utilización de un bloque especial llamado « bloque de asignación »; este bloque
separa la zona de acción de la zona test, tiene esta forma y está asociado a
la tecla [0] (cero),
Ö utilización de las funciones « No », « Y » y « O »,
Ö utilización de rectángulos de acción a la derecha del bloque de acción.
El lenguaje logigrama permite escribir gráficamente ecuaciones booleanas.
El contenido de los tests debe respetar la sintaxis definida en el capítulo
« Elementos comunes » de este manual.
El contenido de los rectángulos de acción debe respetar la sintaxis definida para las
acciones y detallada en el capítulo « Elementos comunes » de este manual.
Zone « test »
Bloc
d’affectation
pour délimiter la
zone test de la
zone action
Zone « action »
1.9.1. Diseño de los logigramas
1.9.1.1. Número de entradas de las funciones « Y » y « O »
Las funciones « Y » y « O » se componen respectivamente de un bloque (tecla
[2]) o de un bloque
(tecla [3]), eventualmente de bloques (tecla [4]) para
añadir entradas a los bloques, y por último de un bloque (tecla [5]).
Las funciones « Y » y « O » implican pues un mínimo de dos entradas.
AUTOMGEN
7
61 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.9.1.2. Encadenamiento de las funciones
Las funciones pueden encadenarse.
1.9.1.3. Acciones múltiples
Es posible asociar varios rectángulos de acción a un logigrama después del bloque
de asignación.
o
1.9.2. Ejemplo de logigrama
Empecemos con el ejemplo más simple.
Condiciones:
Ida y vuelta de una locomotora por la vía 1.
Solución 1:
=1 AV1
Ç
t1d S DV1
Ç
t1i R DV1
exemple\logigramme\logigramme1.agn
AUTOMGEN
7
62 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución 2:
=1 AV1
t1d DV1
dv1 &
t1i O
exemple\logigramme\logigramme2.agn
La segunda solución es idéntica desde el punto de vista funcional. Su interés es
consiste en mostrar la utilización de una variable en auto mantenimiento.
Enriquezcamos nuestro ejemplo.
Condiciones:
La locomotora deberá detenerse 10 segundos a la derecha de la vía 1 y 4 segundos
a la izquierda.
Solución:
t1
t1d T0(10S)
SDV1
t1i T1(4S)
RDV1
t0 AV1
O&
O
exemple\logigramme\logigramme3.agn
Cabe notar la repetición del bloque « Y » de la parte inferior del ejemplo en las
entradas « _t1d_ » y « _t1i_ ». Esto evita tener que escribir por segunda vez estos
dos tests.
Un último ejemplo un poco más complejo.
AUTOMGEN
7
63 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Condiciones:
Siempre una locomotora que va y viene por la vía 1. Cada 10 idas y vueltas deberá
marcar un tiempo de parada de 15 segundos.
Solución:
b0 RC0
t0
t1d & +C0
dv1 O S DV1
t1i R DV1
c0<10 AV1
t0
c0=10 T0(15S)
exemple\logigramme\logigramme4.agn
AUTOMGEN
7
64 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.10. Lenguajes literales
Este capítulo describe la utilización de las tres formas de lenguaje literal disponibles
en AUTOMGEN:
Ö lenguaje literal bajo nivel,
Ö lenguaje literal extendido,
Ö lenguaje literal ST de la norma CEI 1131-3.
1.10.1. Cómo utilizar el lenguaje literal
El lenguaje literal puede utilizarse bajo la forma siguiente:
Ö archivo de código asociado a una acción (Grafcet, Ladder, logigrama),
Ö caja de código asociada a una acción (Grafcet, logigrama),
Ö código literal en un rectángulo de acción o una bobina (Grafcet, Ladder,
logigrama),
Ö caja de código utilizada bajo forma de organigrama (consultar el capítulo
« Organigrama »),
Ö archivo de código que rige el funcionamiento de un bloque funcional (consultar el
capítulo « Bloques funcionales »),
Ö archivo de código que rige el funcionamiento de una macro-instrucción; ver el
capítulo 1.10.4. Macro-instrucción.
1.10.1.1. Caja de código asociada a una etapa o un logigrama
Una caja de código asociada a una acción permite escribir algunas líneas de
lenguaje literal en una página de la aplicación.
Ejemplos:
AUTOMGEN
7
65 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
El código utilizado es escrutado mientras la acción es verdadera.
Es posible utilizar conjuntamente rectángulos de acción y cajas de código.
Ejemplo:
1.10.1.2. Código literal en un rectángulo de acción o una bobina
Los caracteres « { » y « } » permiten insertar instrucciones en lenguaje literal
directamente en un rectángulo de acción (lenguajes Grafcet y logigrama) o una
bobina (lenguaje ladder). El carácter « , » (coma) se utiliza como separador si entre
« { » y « } » hay varias instrucciones.
Este tipo de inserción puede utilizarse con órdenes condicionadas.
Ejemplos:
1.10.2. Definición de una caja de código
Para diseñar una caja de código siga las etapas siguientes:
Ö haga clic con el botón derecho del ratón en un sitio vacío del folio,
Ö elija en el menú « Más … / Caja de código »,
AUTOMGEN
7
66 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Ö haga clic sobre el borde de la caja de código para modificar su contenido.
Para salir de la caja después de modificarla utilice la tecla [Enter] o haga clic en el
exterior.
1.10.3. El lenguaje literal bajo nivel
Este capítulo detalla la utilización del lenguaje literal bajo nivel. Este lenguaje es un
código intermedio entre los lenguajes evolucionados Grafcet, logigrama, ladder,
organigrama, bloques funcionales, literal extendido, literal ST y los lenguajes
ejecutables. También se conoce con el nombre de código pivote. Los post-
procesadores traducen el lenguaje literal bajo nivel en código ejecutable para PC,
autómata o tarjeta con microprocesador.
El lenguaje literal también puede utilizarse en una aplicación para efectuar diversos
tratamientos booleanos, numéricos o algorítmicos.
El lenguaje literal bajo nivel es un lenguaje de tipo ensamblador. Utiliza una noción
de acumulador para los tratamientos numéricos.
El lenguaje literal extendido y el lenguaje literal ST descritos en los capítulos
siguientes ofrecen una alternativa simplificada y de más alto nivel para escribir
programas en lenguaje literal.
Sintaxis general de una línea de lenguaje literal bajo nivel:
«acción » [[ [« Test »] « Test » ]...]
Las acciones y los tests del lenguaje literal bajo nivel están representados por
mnemónicos compuestos de tres caracteres alfabéticos. Cada instrucción va
seguida de una expresión: variable, constante, etc...
Una línea se compone de una sola acción y eventualmente de un test. Si una línea
contiene únicamente una acción, la instrucción se ejecutará siempre, por
convención.
1.10.3.1. Variables
Las variables utilizables son las mismas que las definidas en el capítulo « Elementos
comunes ».
AUTOMGEN
7
67 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.10.3.2. Acumuladores
Ciertas instrucciones utilizan la noción de acumulador. Los acumuladores son
registros internos del sistema que ejecuta el programa final y permiten acumular
valores temporalmente.
Existen tres acumuladores: un acumulador entero 16 bits llamado AAA, un
acumulador entero 32 bits llamado AAL y un acumulador flotante llamado AAF.
1.10.3.3. Banderas
Las banderas son variables booleanas posicionadas en función del resultado de las
operaciones numéricas.
Las cuatro banderas que permiten testear el resultado de un cálculo son:
Ö indicador de retención C: indica si una operación ha generado una retención (1) o
no (0),
Ö indicador de cero Z: indica si una operación ha generado un resultado nulo (1) o
no (0),
Ö indicador de signo S: indica si una operación ha generado un resultado negativo
(1) o positivo (0),
Ö indicador de exceso O: indica si una operación ha generado un exceso de
capacidad (1).
1.10.3.4. Modos de direccionamiento
El lenguaje literal bajo nivel posee 5 modos de direccionamiento. Un modo de
direccionamiento es una característica asociada a cada una de las instrucciones del
lenguaje literal.
Los modos de direccionamiento utilizables son:
TIPO SINTAXIS EJEMPLO
Inmediato 16 bits {constante} 100
Inmediato 32 bits {constante}L 100000L
Inmediato flotante {constante}R 3.14R
Absoluto {variable} {identificación de variable} O540
Acumulador 16 bits AAA AAA
Acumulador 32 bits AAL AAL
AUTOMGEN
7
68 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Acumulador flotante AAF AAF
Indirecto {variable}{(identificación de palabra)} O(220)
Label :{nombre de label}: :bucle:
Una instrucción posee dos características: el tipo de variable y el modo de
direccionamiento. Una instrucción puede soportar o no ciertos modos de
direccionamiento o ciertos tipos de variables. Por ejemplo, hay instrucciones que se
aplican únicamente a palabras, y no a otros tipos de variables.
Observación: Las variables X y U no pueden asociarse a un direccionamiento
indirecto debido a la no linealidad de sus asignaciones. Si es necesario acceder a
una tabla de variables U, habrá que utilizar una directiva de compilación #B para
declarar una tabla de bits lineales.
1.10.3.5. Tests
Los tests que pueden asociarse a las instrucciones se componen de un mnemónico,
un tipo de test y una variable.
Los mnemónicos de tests permiten definir tests combinatorios de varias variables (y,
o). Si un test está compuesto por una sola variable, de todas maneras debe
asociarse un operador AND.
Existen solamente tres mnemónicos de test:
AND y
ORR o
EOR fin de o
He aquí algunos ejemplos de equivalencias entre ecuaciones booleanas y lenguaje
literal bajo nivel:
o0=i1 : and i1
o0=i1.i2 : and i1 and i2
o0=i1+i2 : orr i1 eor i2
o0=i1+i2+i3+i4 : orr i1 orr i2 orr i3 eor i4
o0=(i1+i2).(i3+i4) : orr i1 eor i2 orr i3 eor i4
o0=i1.(i2+i3+i4) : and i1 orr i2 orr i3 eor i4
o0=(i1.i2)+(i3.i4) ; imposible traducir directamente,
; hay que utilizar
; variables intermedias:
AUTOMGEN
7
69 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
equ u100 and i1 and i2
equ u101 and i3 and i4
equ o0 orr u100 eor u101
Los modificadores de tests permiten testear cosas que no son simplemente el
estado verdadero de una variable:
Ö / no
Ö # frente ascendente
Ö * frente descendente
Ö @ estado inmediato
Observaciones:
Ö las variables booleanas se actualizan después de cada ciclo de ejecución. En
otros términos, si durante un ciclo una variable binaria se posiciona en un estado,
su nuevo estado será realmente reconocido en el ciclo siguiente. El modificador
de test @ permite obtener el estado real de una variable booleana sin esperar el
ciclo siguiente.
Ö los modificadores de tests no son utilizables con los tests numéricos.
Ejemplos:
set o100
equ o0 and @o100 ; test verdadero desde el primer ciclo
equ o1 and o100 ; test verdadero en el segundo ciclo
Para los tests, hay sólo dos modos de direccionamiento disponibles: el modo
absoluto y el modo indirecto.
Hay un test de contadores, palabras, largos y flotantes:
Sintaxis:
« {variable} {=, !, <, >, << , >>} {constante o variable} »
= significa igual,
! significa diferente,
< significa menor sin signo,
> significa mayor sin signo,
AUTOMGEN
7
70 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
<< significa menor con signo,
>> significa mayor con signo,
Las constantes están predeterminadas en decimal. Los sufijos « $ » y « % »
permiten escribirlas en hexadecimal o en binario. Las comillas permiten escribirlas
en ASCII.
Las constantes 32 bits deben estar seguidas del carácter « L ».
Las constantes reales deben estar seguidas del carácter « R ».
Una palabra o un contador puede compararse con una palabra, un contador o una
constante 16 bits.
Un largo puede compararse con un largo o una constante 32 bits.
Un flotante puede compararse con un flotante o una constante real.
Ejemplos:
and c0>100 and m225=10
orr m200=m201 eor m202=m203 and f100=f101 and f200<f203
orr m200<<-100 eor m200>>200
and f200=3.14r
and l200=$12345678L
and m200=%1111111100000000
1.10.3.6. Comentarios
Los comentarios deben empezar con el carácter « ; » (punto y coma); todos los
caracteres siguientes se ignoran.
1.10.3.7. Base de numeración
Los valores (identificaciones de variables o constantes) pueden escribirse en
decimal, hexadecimal, binario o ASCII.
La siguiente sintaxis debe aplicarse para las constantes 16 bits:
Ö decimal: eventualmente el carácter « - » y luego 1 a 5 dígitos « 0123456789 »,
Ö hexadecimal: prefijo « $ » o « 16# » seguido de 1 a 4 dígitos
« 0123456789ABCDEF »,
Ö binario: prefijo « % » o « 2# » seguido de 1 a 16 dígitos « 01 »,
Ö ASCII: carácter « " » seguido de 1 o 2 caracteres seguidos de « " ».
La siguiente sintaxis debe aplicarse para las constantes 32 bits:
AUTOMGEN
7
71 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Ö Decimal: eventualmente el carácter « - » y luego 1 a 10 dígitos « 0123456789 »,
Ö Hexadecimal: prefijo « $ » o « 16# » seguido de 1 a 8 dígitos
« 0123456789ABCDEF »,
Ö Binario: prefijo « % » o « 2# » seguido de 1 a 32 dígitos « 01 »,
Ö ASCII: carácter « " » seguido de 1 a 4 caracteres seguidos de « " ».
La siguiente sintaxis debe aplicarse para las constantes reales:
[-] i [[.d] Esx]
i es la parte entera
d una eventual parte decimal
s eventualmente el signo del exponente
x eventualmente el exponente
1.10.3.8. Predisposiciones
Una predisposición permite fijar el valor de una variable al inicio de la aplicación.
Las variables T o %T, M o %MW, L o %MD y F o %F pueden estar predispuestas.
La sintaxis es la siguiente:
« $(variable)=constante{,constante{,constante...}} »
Para las temporizaciones el valor debe estar escrito en decimal y comprendido entre
0 y 65535.
Para las palabras debe utilizarse la siguiente sintaxis:
Ö Decimal: eventualmente el carácter « - » y luego 1 a 5 dígitos
« 0123456789 »,
Ö Hexadecimal: prefijo « $ » o « 16# » seguido de 1 a 4 dígitos
« 0123456789ABCDEF »,
Ö Binario: prefijo « % » o « 2# » seguido de 1 a 16 dígitos « 01 »,
Ö ASCII: (dos caracteres por palabra) el carácter « " » seguido de n
caracteres seguidos de « " »,
Ö ASCII: (un carácter por palabra) el carácter « ’ » seguido de n caracteres
seguidos de « ’ ».
AUTOMGEN
7
72 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Para los largos debe utilizarse la siguiente sintaxis:
Ö Decimal: eventualmente el carácter « - » y luego 1 a 10 dígitos « 0123456789 »,
Ö Hexadecimal: prefijo « $ » o « 16# » seguido de 1 a 8 dígitos
« 0123456789ABCDEF »,
Ö Binario: carácter « % » o « 2# » seguido de 1 a 32 dígitos « 01 »,
Ö ASCII: (cuatro caracteres por largo) carácter « " » seguido de n caracteres
seguidos de « " »,
Ö ASCII: (un carácter por largo) carácter « ’ » seguido de n caracteres seguidos de
« ’ »
Para los flotantes, el valor debe escribirse de la siguiente manera:
[-] i [[.d] Esx]
i es la parte entera
d una eventual parte decimal
s eventualmente el signo del exponente
x eventualmente el exponente
Ejemplos:
$t25=100
fija la consigna de la temporización 25 en 10 s
$MW200=100,200,300,400
coloca los valores 100, 200, 300, 400 en las palabras 200, 201, 202, 203
$m200="ABCDEF"
coloca la cadena de caracteres « ABCDEF » a partir de m200 (« AB » en m200,
« CD » en m201, « EF » en m202)
$m200=‘ABCDEF’
coloca la cadena de caracteres « ABCDEF » a partir de m200; cada palabra recibe
un carácter.
$f1000=3.14
coloca el valor 3,14 en f1000
$%mf100=5.1E-15
coloca el valor 5,1 * 10 exponente -15 en %mf100
$l200=16#12345678
coloca el valor 12345678 (hexa) en el largo l200
AUTOMGEN
7
73 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Es más fácil escribir texto en las predisposiciones.
Ejemplo:
$m200=" Parada compuerta N°10 "
Coloca el mensaje a partir de la palabra 200 con dos caracteres en cada palabra.
$m400=‘ Defecto motor ‘
Coloca el mensaje a partir de la palabra 400 con un carácter en el byte de peso débil
de cada palabra; el byte de peso fuerte contiene 0.
La sintaxis « $...= » permite proseguir una tabla de predisposiciones a continuación
de la anterior.
Por ejemplo:
#$m200=1,2,3,4,5
#$...=6,7,8,9
Coloca los valores de 1 a 9 en las palabras m200 a m208.
Las predisposiciones pueden escribirse de la misma manera que el lenguaje literal
bajo nivel o en una directiva de compilación en un folio. En este caso, la
predisposición empieza con el carácter « # ».
Ejemplo de predisposición escrita en una caja de código:
Ejemplo de predisposición escrita en una directiva de compilación:
AUTOMGEN
7
74 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.10.3.9. Direccionamiento indirecto
El direccionamiento indirecto permite efectuar una operación con una variable
señalada por un índice.
Son las variables M (las palabras) las que sirven de índice.
Sintaxis:
« variable ( índice ) »
Ejemplo:
lda 10 ; carga 10 en el acumulador
sta m200 ; lo coloca en la palabra 200
set o(200) ; puesta en uno de la salida señalada por la palabra 200 (o10)
1.10.3.10. Direccionamiento de una variable
El carácter « ? » permite especificar el direccionamiento de una variable.
Ejemplo:
lda ?o10 ; coloca el valor 10 en el acumulador
Esta sintaxis es interesante sobre todo si se utilizan símbolos.
Ejemplo:
lda ?_compuerta_ ; coloca en el acumulador el número de la variable
; asociada al símbolo « _compuerta_ »
Esta sintaxis también puede utilizarse en las predisposiciones para crear tablas de
direccionamientos de variables.
Ejemplo:
$m200=?_compuerta1_,?_compuerta2_,?_compuerta3_
1.10.3.11. Saltos y labels
Los saltos deben hacer referencia a un label. La sintaxis de un label es:
«:nombre del label: »
Ejemplo:
jmp:continuación:
...
:continuación:
AUTOMGEN
7
75 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.10.3.12. Lista de funciones por tipo
1.10.3.12.1. Funciones booleanas
SET puesta en uno
RES puesta en cero
INV inversión
EQU equivalencia
NEQ no-equivalencia
1.10.3.12.2. Funciones de carga y almacenamiento con enteros y flotantes
LDA carga
STA almacenamiento
1.10.3.12.3. Funciones aritméticas con enteros y flotantes
ADA suma
SBA resta
MLA multiplicación
DVA división
CPA comparación
1.10.3.12.4. Funciones aritméticas con flotantes
ABS valor absoluto
SQR raíz cuadrada
1.10.3.12.5. Funciones de acceso a los puertos de entrada/salida en PC
AIN lectura de un puerto
AOU escritura de un puerto
1.10.3.12.6. Funciones de acceso a la memoria en PC
ATM lectura de una dirección de memoria
MTA escritura de una dirección de memoria
1.10.3.12.7. Funciones binarias con enteros
ANA y bit a bit
ORA o bit a bit
XRA o exclusivo bit a bit
TSA test bit a bit
AUTOMGEN
7
76 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
SET puesta en uno de todos los bits
RES puesta en cero de todos los bits
RRA desfase a derecha
RLA desfase a izquierda
1.10.3.12.8. Otras funciones con enteros
INC incremento
DEC decremento
1.10.3.12.9. Funciones de conversión
ATB entero a booleanos
BTA booleanos a entero
FTI flotante a entero
ITF entero a flotante
LTI entero 32 bits a entero 16 bits
ITL entero 16 bits a entero 32 bits
AUTOMGEN
7
77 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.10.3.12.10. Funciones de ramificación
JMP salto
JSR salto a un subprograma
RET retorno de subprograma
1.10.3.12.11. Funciones de test
RFZ flag de resultado nulo
RFS flag de signo
RFO flag de exceso
RFC flag de retención
1.10.3.12.12. Funciones de accesos asíncronos a entradas salidas
RIN lectura de entradas
WOU escritura de salidas
1.10.3.12.13. Información contenida en la lista de funciones
Para cada instrucción se dan:
Ö Nombre: el mnemónico.
Ö Función: una descripción de la función realizada por la instrucción.
Ö Variables: tipos de variables utilizables con la instrucción.
Ö Direccionamiento: tipos de direccionamientos utilizables.
Ö Ver también: las otras instrucciones que tengan relación con este mnemónico.
Ö Ejemplo: un ejemplo de utilización.
Los post-procesadores que generan lenguajes constructores están sujetos a ciertas
restricciones. Consultar las notas sobre estos post-procesadores para conocer en
detalle dichas restricciones.
AUTOMGEN
7
78 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
A
A
B
B
S
S
Nombre : ABS - abs accumulator
Función : calcula el valor absoluto del acumulador flotante
Variables : ninguna
Direccionamiento : acumulador
Ver también : SQR
Ejemplo :
lda f200
abs aaf
sta f201
; deja en f201 el valor absoluto de f200
AUTOMGEN
7
79 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
A
A
D
D
A
A
Nombre : ADA - adds accumulator
Función : añade un valor al acumulador
Variables : M o %MW, L o %MD, F o %MF
Direccionamiento : absoluto, indirecto, inmediato
Ver también : SBA
Ejemplo :
ada 200
; añade 200 al acumulador 16 bits
ada f124
; añade el contenido de f124 al acumulador flotante
ada l200
; añade el contenido de l200 al acumulador 32 bits
ada 200L
; añade 200 al acumulador 32 bits
ada 3.14R
; añade 3.14 al acumulador flotante
AUTOMGEN
7
80 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
A
A
I
I
N
N
Nombre : AIN - accumulator input
Función : lectura de un puerto de entrada (8 bits) y almacenamiento en
la parte baja del acumulador 16 bits;
lectura de un puerto de entrada 16 bits y
almacenamiento en el acumulador 16 bits (en este caso la
dirección del puerto debe escribirse como una constante de
32 bits) utilizable sólo con el ejecutor PC
Variables : M o %MW
Direccionamiento: indirecto, inmediato
Ver también : AOU
Ejemplo :
ain $3f8
; lectura del puerto $3f8 (8 bits)
ain $3f8l
; lectura del puerto $3f8 (16 bits)
AUTOMGEN
7
81 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
A
A
N
N
A
A
Nombre : ANA - and accumulator
Función : efectúa un Y lógico entre el acumulador 16 bits
y una palabra o una constante o el acumulador 32 bits y
un largo o una constante
Variables : M o %MW, L o %MD
Direccionamiento: absoluto, indirecto, inmediato
Ver también : ORA, XRA
Ejemplo :
ana %1111111100000000
; oculta los 8 bits de peso débil del
; acumulador 16 bits
ana $ffff0000L
; oculta los 16 bits de peso débil del acumulador 32 bits
AUTOMGEN
7
82 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
A
A
O
O
U
U
Nombre : AOU - accumulator output
Función : transfiere la parte baja (8 bits) del contenido del
acumulador 16 bits a un puerto de salida;
transfiere los 16 bits del acumulador 16 bits
a un puerto de salida (en este caso la dirección del puerto
debe escribirse como una constante 32 bits)
utilizable sólo con el ejecutor PC
Variables : M o %MW
Direccionamiento: indirecto, inmediato
Ver también : AIN
Ejemplo :
lda "A"
aou $3f8
; coloca el carácter « A » en el puerto de salida $3f8
lda $3f8
sta m200
lda "z"
aou m(200)
; coloca el carácter « z » en el puerto de salida $3f8
lda $1234
aou $300l
; coloca el valor 16 bits 1234 en el puerto de salida $300
AUTOMGEN
7
83 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
A
A
T
T
B
B
Nombre : ATB - accumulator to bit
Función : transfiere los 16 bits del acumulador 16 bits
a 16 variables booleanas sucesivas; el bit
de peso débil corresponde a la primera
variable booleana
Variables : I o %I, O o %Q, B o %M, T o %T, U
*
Direccionamiento: absoluto
Ver también : BTA
Ejemplo :
lda m200
atb o0
; recopia los 16 bits de m200 en las variables
; o0 a o15
*
Atención: para poder utilizar los bits U con esta función es necesario realizar una tabla lineal de bits
con la directiva de compilación #B.
AUTOMGEN
7
84 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
A
A
T
T
M
M
Nombre : ATM - accumulator to memory
Función : transfiere el acumulador 16 bits a una dirección
memoria; la palabra o la constante especificada
define el offset de la dirección de memoria a
alcanzar; la palabra m0 debe estar cargada con el
valor del segmento de la dirección de memoria a
alcanzar; utilizable sólo con el ejecutor PC
Variables : M o %MW
Direccionamiento: indirecto, inmediato
Ver también : MTA
Ejemplo :
lda $b800
sta m0
lda 64258
atm $10
; coloca el valor 64258 en la dirección $b800:$0010
AUTOMGEN
7
85 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
B
B
T
T
A
A
Nombre : BTA - bit to accumulator
Función : transfiere 16 variables booleanas sucesivas
a los 16 bits del acumulador 16 bits;
el bit de peso débil corresponde a la primera
variable booleana
Variables : I o %I, O o %Q, B o %M, T o %T, U
*
Direccionamiento: absoluto
Ver también : ATB
Ejemplo :
bta i0
sta m200
; recopia las 16 entradas i0 a i15 en la palabra m200
*
Atención: para poder utilizar los bits U con esta función es necesario realizar una tabla lineal de bits
con la directiva de compilación #B.
AUTOMGEN
7
86 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
C
C
P
P
A
A
Nombre : CPA - compares accumulator
Función : compara un valor al acumulador 16 bits o 32 bits
o flotante; efectúa la misma operación que SBA
pero sin modificar el contenido del acumulador
Variables : M o %MW, L o %MD, F o %MF
Direccionamiento: absoluto, indirecto, inmediato
Ver también : SBA
Ejemplo :
lda m200
cpa 4
rfz o0
; pone o0 en 1 si m200 es igual a 4, si no o0
; se pone en 0
lda f200
cpa f201
rfz o1
; pone o1 en 1 si f200 es igual a f201, si no o1
; se pone en 0
AUTOMGEN
7
87 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
D
D
E
E
C
C
Nombre : DEC – decrement
Función : decrementa una palabra, un contador, un largo, el acumulador
16 bits o 32 bits
Variables : M o %MW, C o %C, L o %MD
Direccionamiento: absoluto, indirecto, acumulador
Ver también : INC
Ejemplo :
dec m200
; decrementa m200
dec aal
; decrementa el acumulador 32 bits
dec m200
dec m201 and m200=-1
; decrementa un valor 32 bits compuesto de
; m200 (peso débil)
; y m201 (peso fuerte)
AUTOMGEN
7
88 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
D
D
V
V
A
A
Nombre : DVA - divides accumulator
Función : división del acumulador 16 bits por una palabra o
una constante; división del acumulador flotante por
un flotante o una constante; división del acumulador
32 bits por un largo o una constante; para el acumulador 16
bits el resto se coloca en la palabra m0; en caso de división
por 0 el bit sistema 56 pasa a 1
Variables : M o %MW, L o %MD, F o %MF
Direccionamiento: absoluto, indirecto, inmediato
Ver también : MLA
Ejemplo :
lda m200
dva 10
sta m201
; m201 es igual a m200 dividido por 10, m0 contiene el
; resto de la división
lda l200
dva $10000L
sta l201
AUTOMGEN
7
89 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
E
E
Q
Q
U
U
Nombre : EQU - equal
Función : fuerza una variable a 1 si el test es verdadero,
en caso contrario, la variable se fuerza a 0
Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U
Direccionamiento: absoluto, indirecto (salvo con las variables X)
Ver también : NEQ
, SET, RES, INV
Ejemplo :
equ o0 and i10
; fuerza la salida o0 al mismo estado que la entrada i10
lda 10
sta m200
equ o(200) and i0
; fuerza o10 al mismo estado que la entrada i0
$t0=100
equ t0 and i0
equ o0 and t0
; fuerza o0 al estado de i0 con un retraso en la activación
; de 10 segundos
AUTOMGEN
7
90 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
F
F
T
T
I
I
Nombre : FTI - float to integer
Función : transfiere el acumulador flotante al acumulador 16 bits
Variables : ninguna
Direccionamiento: acumulador
Ver también : ITF
Ejemplo :
lda f200
fti aaa
sta m1000
; deja la parte entera de f200 en m1000
AUTOMGEN
7
91 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
I
I
N
N
C
C
Nombre : INC - increment
Función : incrementa una palabra, un contador, un largo, el acumulador
16 bits o 32 bits
Variables : M o %MW, C o %C, L o %MD
Direccionamiento: absoluto, indirecto, acumulador
Ver también : DEC
Ejemplo :
inc m200
; añade 1 a m200
inc m200
inc m201 and m201=0
; incrementa un valor sobre 32 bits, m200
; representa los
; pesos débiles, y m201 los pesos fuertes
inc l200
; incrementa el largo l200
AUTOMGEN
7
92 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
I
I
N
N
V
V
Nombre : INV - inverse
Función : invierte el estado de una variable booleana, o invierte
todos los bits de una palabra, de un largo o del acumulador 16
bits o 32 bits
Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U,
M o %MW, L o %MD
Direccionamiento: absoluto, indirecto, acumulador
Ver también : EQU
, NEQ, SET, RES
Ejemplo :
inv o0
; invierte el estado de la salida 0
inv aaa
; invierte todos los bits del acumulador 16 bits
inv m200 and i0
; invierte todos los bits de m200 si i0 está en estado 1
AUTOMGEN
7
93 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
I
I
T
T
F
F
Nombre : ITF - integer to float
Función : transfiere el acumulador 16 bits al acumulador flotante
Variables : ninguna
Direccionamiento: acumulador
Ver también : FTI
Ejemplo :
lda 1000
itf aaa
sta f200
; deja la constante 1000 en f200
AUTOMGEN
7
94 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
I
I
T
T
L
L
Nombre : ITL - integer to long
Función : transfiere el acumulador 16 bits al acumulador 32 bits
Variables : ninguna
Direccionamiento: acumulador
Ver también : LTI
Ejemplo :
lda 1000
itl aaa
sta f200
; deja la constante 1000 en l200
AUTOMGEN
7
95 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
J
J
M
M
P
P
Nombre : JMP - jump
Función : salto a un label
Variables : label
Direccionamiento: label
Ver también : JSR
Ejemplo :
jmp :fin de programa:
; ramificación incondicional en label :fin
; de programa:
jmp :continuación: and i0
set o0
set o1
:continuación:
; ramificación condicional en label :continuación:
; según el estado de i0
AUTOMGEN
7
96 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
J
J
S
S
R
R
Nombre : JSR - jump sub routine
Función : efectúa una ramificación a un subprograma
Variables : label
Direccionamiento: label
Ver también : RET
Ejemplo :
lda m200
jsr :cuadrado:
sta m201
jmp :fin:
:cuadrado:
sta m53
mla m53
sta m53
ret m53
:fin:
; el subprograma « cuadrado » eleva al cuadrado
; el contenido del acumulador
AUTOMGEN
7
97 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
L
L
D
D
A
A
Nombre : LDA - load accumulator
Función : carga en el acumulador 16 bits una constante, palabra
o contador; carga en el acumulador 32 bits un largo
o constante, carga en el acumulador flotante un
flotante o una constante, carga un contador de
temporización en el acumulador 16 bits
Variables : M o %MW, C o %C, L o %MD, F o %MF, T o %T
Direccionamiento: absoluto, indirecto, inmediato
Ver también : STA
Ejemplo :
lda 200
; carga la constante 200 en el acumulador 16 bits
lda 0.01R
; carga la constante real 0.01 en el acumulador flotante
lda t10
; carga el contador de la temporización 10 en
; el acumulador
AUTOMGEN
7
98 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
L
L
T
T
I
I
Nombre : LTI - long to integer
Función : transfiere el acumulador 32 bits al acumulador
16 bits
Variables : ninguna
Direccionamiento: acumulador
Ver también : ITL
Ejemplo :
lda l200
lti aaa
sta m1000
; deja los 16 bits de peso débil de l200 en m1000
AUTOMGEN
7
99 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
M
M
L
L
A
A
Nombre : MLA - multiples accumulator
Función : multiplicación del acumulador 16 bits por una palabra o
constante ; multiplicación del acumulador 32 bits por
un largo o constante, multiplicación del acumulador
flotante por un flotante o constante; para el acumulador
16 bits, los 16 bits de peso fuerte del resultado de la
multiplicación se transfieren a m0
Variables : M o %MW, L o %MD, F o %MF
Direccionamiento: absoluto, indirecto, inmediato
Ver también : DVA
Ejemplo :
lda m200
mla 10
sta m201
; multiplica m200 por 10, m201 está cargado con los
; 16 bits de peso débil, y m0 con los 16 bits de
; peso fuerte
AUTOMGEN
7
100 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
M
M
T
T
A
A
Nombre : MTA - memory to accumulator
Función : transfiere el contenido de una dirección de memoria al
acumulador 16 bits; la palabra o constante especificada
define el offset de la dirección de memoria a alcanzar, la palabra
m0 debe estar cargada con el valor del segmento de la dirección
de memoria a alcanzar; utilizable sólo con el ejecutor PC
Variables : M o %MW
Direccionamiento: indirecto, inmediato
Ver también : ATM
Ejemplo :
lda $b800
sta m0
mta $10
; coloca el valor contenido en la dirección $b800:$0010
; en el acumulador 16 bits
AUTOMGEN
7
101 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
N
N
E
E
Q
Q
Nombre : NEQ - not equal
Función : fuerza una variable a 0 si el test es verdadero,
en caso contrario, la variable se fuerza a 1
Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U
Direccionamiento: absoluto, indirecto (salvo con las variables X)
Ver también : EQU
, SET, RES, INV
Ejemplo :
neq o0 and i00
; fuerza la salida o0 al estado complementado de la entrada
; i10
lda 10
sta m200
neq o(200) and i0
; fuerza o10 al estado complementado de la entrada i0
$t0=100
neq t0 and i0
neq o0 and t0
; fuerza o0 al estado de i0 con un retraso en la
; desactivación de 10 segundos
AUTOMGEN
7
102 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
O
O
R
R
A
A
Nombre : ORA - or accumulator
Función : efectúa un O lógico entre el acumulador 16 bits
y una palabra o una constante, o entre el acumulador 32 bits
y un largo o una constante
Variables : M o %M, L o %MD
Direccionamiento: absoluto, indirecto, inmediato
Ver también : ANA
, XRA
Ejemplo :
ora %1111111100000000
; fuerza los 8 bits de peso fuerte del
; acumulador 16 bits a 1
ora $ffff0000L
; fuerza los 16 bits de peso fuerte del acumulador 32 bits
; a 1
AUTOMGEN
7
103 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
R
R
E
E
S
S
Nombre : RES - reset
Función : fuerza una variable booleana, una palabra,
un contador, un largo, el acumulador 16 bits
o el acumulador 32 bits a 0
Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U,
M o %MW, C o %C, L o %MD
Direccionamiento: absoluto, indirecto (salvo con las variables X), acumulador
Ver también : NEQ
, SET, EQU, INV
Ejemplo :
res o0
; fuerza la salida o0 a 0
lda 10
sta m200
res o(200) and i0
; fuerza o10 a 0 si la entrada i0 está en 1
res c0
; fuerza el contador 0 a 0
AUTOMGEN
7
104 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
R
R
E
E
T
T
Nombre : RET - return
Función : marca el retorno de un subprograma y coloca
en el acumulador 16 bits una palabra o una
constante; o coloca en el acumulador 32 bits un largo
o una constante, o coloca en el acumulador
flotante un flotante o una constante
Variables : M o %MW, L o %MD, F o %MF
Direccionamiento: absoluto, indirecto, inmediato
Ver también : JSR
Ejemplo :
ret 0
; retorno de subprograma colocando 0 en
; el acumulador 16 bits
ret f200
; retorno de subprograma colocando el contenido
; de f200 en el acumulador flotante
AUTOMGEN
7
105 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
R
R
F
F
C
C
Nombre : RFC - read flag: carry
Función : transfiere el contenido del indicador de retención
a una variable booleana
Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U
Direccionamiento: absoluto
Ver también : RFZ
, RFS, RFO
Ejemplo :
rfc o0
; transfiere el indicador de retención a o0
lda m200
ada m300
sta m400
rfc b99
lda m201
ada m301
sta m401
inc m401 and b99
; efectúa una suma sobre 32 bits
; (m400,401)=(m200,201)+(m300,301)
; m200, m300 y m400 son los pesos débiles
; m201, m301 y m401 son los pesos fuertes
AUTOMGEN
7
106 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
R
R
F
F
O
O
Nombre : RFO - read flag: overflow
Función : transfiere el contenido del indicador de exceso
a una variable booleana
Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U
Direccionamiento: absoluto
Ver también : RFZ
, RFS, RFC
Ejemplo :
rfo o0
; transfiere el indicador de exceso a o0
AUTOMGEN
7
107 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
R
R
F
F
S
S
Nombre : RFS - read flag: signe
Función : transfiere el contenido del indicador de signo a una
variable booleana
Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U
Direccionamiento: absoluto
Ver también : RFZ
, RFC, RFO
Ejemplo :
rfs o0
; transfiere el indicador de signo a o0
AUTOMGEN
7
108 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
R
R
F
F
Z
Z
Nombre : RFZ - read flag: zero
Función : transfiere el contenido del indicador de resultado nulo
a una variable booleana
Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U
Direccionamiento: absoluto
Ver también : RFC
, RFS, RFO
Ejemplo :
rfz o0
; transfiere el indicador de resultado nulo a o0
lda m200
cpa m201
rfz o0
; posiciona o0 en 1 si m200 es igual a m201
; o en 0 en caso contrario
AUTOMGEN
7
109 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
R
R
I
I
N
N
Nombre : RIN - read input
Función : efectúa una lectura de las entradas físicas. Esta función se
implementa únicamente en destinos Z y varía según el
destino. Consultar la documentación relativa a cada
ejecutor para más detalles.
Variables : ninguna
Direccionamiento: inmediato
Ver también : WOU
AUTOMGEN
7
110 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
R
R
L
L
A
A
Nombre : RLA - rotate left accumulator
Función : efectúa una rotación a la izquierda de los bits del
acumulador 16 bits o 32 bits; el bit evacuado a la izquierda
entra a la derecha; el argumento de esta función es una
constante que precisa el número de desfases a efectuar; el
tamaño del argumento (16 o 32 bits) determina cuál es el
acumulador que debe sufrir la rotación
Variables : ninguna
Direccionamiento: inmediato
Ver también : RRA
Ejemplo :
ana $f000
; aísla el dígito de peso fuerte del acumulador 16 bits
rla 4
; y lo lleva a la derecha
rla 8L
; efectúa 8 rotaciones a la izquierda de los bits del
; acumulador 32 bits
AUTOMGEN
7
111 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
R
R
R
R
A
A
Nombre : RRA - rotate right accumulator
Función : efectúa una rotación a la derecha de los bits del
acumulador 16 bits o 32 bits; el bit evacuado a la derecha
entra a la izquierda; el argumento de esta función es una
constante que precisa el número de desfases a efectuar; el
tamaño del argumento (16 o 32 bits) determina si es el
acumulador 16 o 32 bits el que deberá sufrir la rotación
Variables : ninguna
Direccionamiento: inmediato
Ver también : RLA
Ejemplo :
ana $f000
; aísla el dígito de peso fuerte del acumulador 16 bits
rra 12
; y lo lleva a la derecha.
rra 1L
; efectúa una rotación de los bits del acumulador 32 bits
; de una posición hacia la derecha
AUTOMGEN
7
112 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
S
S
B
B
A
A
Nombre : SBA - substacts accumulator
Función : quita el contenido de una palabra o una constante al
acumulador 16 bits; quita el contenido de un largo o una
constante al acumulador 32 bits; quita el contenido de un
flotante o una constante al acumulador flotante
Variables : M o %MW, L o %MD, F o %MF
Direccionamiento: absoluto, indirecto, inmediato
Ver también : ADA
Ejemplo :
sba 200
; quita 200 al acumulador 16 bits
sba f(421)
; quita el contenido del flotante cuyo número está
; contenido en la palabra 421 al acumulador flotante
AUTOMGEN
7
113 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
S
S
E
E
T
T
Nombre : SET - set
Función : fuerza una variable booleana a 1; fuerza todos los bits de
una palabra, contador, largo o del acumulador 16 bits o del
acumulador 32 bits a 1
Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U,
M o %MW, C o %C, L o %MD
Direccionamiento: absoluto, indirecto (salvo con las variables X), acumulador
Ver también : NEQ
, RES, EQU, INV
Ejemplo :
set o0
; fuerza la salida o0 a 1
lda 10
sta m200
set o(200) and i0
; fuerza o10 a 1 si la entrada i0 está en 1
set m200
; fuerza m200 al valor -1
set aal
; fuerza todos los bits del acumulador 32 bits a 1
AUTOMGEN
7
114 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
S
S
Q
Q
R
R
Nombre : SQR - square root
Función : calcula la raíz cuadrada del acumulador flotante
Variables : ninguna
Direccionamiento: acumulador
Ver también : ABS
Ejemplo :
lda 9
itf aaa
sqr aaf
fti aaa
sta m200
; deja el valor 3 en m200
AUTOMGEN
7
115 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
S
S
T
T
A
A
Nombre : STA - store accumulator
Función : almacena el acumulador 16 bits en un contador o una palabra;
almacena el acumulador 32 bits en un largo, almacena
el acumulador flotante en un flotante, almacena el
acumulador 16 bits en una consigna de temporización
Variables : M o %MW, C o %C, L o %MD, F o %MF, T o %T
Direccionamiento: absoluto, indirecto
Ver también : LDA
Ejemplo :
sta m200
; transfiere el contenido del acumulador 16 bits
; a la palabra 200
sta f200
; transfiere el contenido del acumulador flotante
; al flotante 200
sta l200
; transfiere el acumulador 32 bits al largo l200
AUTOMGEN
7
116 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
T
T
S
S
A
A
Nombre : TSA - test accumulator
Función : efectúa un Y lógico entre el acumulador 16 bits y una palabra
o una constante; efectúa un Y lógico entre el acumulador
32 bits y un largo o una constante, opera de manera
similar a la instrucción ANA, pero sin modificar el
contenido del acumulador
Variables : M o %MW, L o %MD
Direccionamiento: absoluto, indirecto, inmediato
Ver también : ANA
Ejemplo :
tsa %10
rfz b99
jmp :continuación: and b99
; ramificación en label :continuación: si el bit 1
; del acumulador 16 bits está en 0
AUTOMGEN
7
117 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
W
W
O
O
U
U
Nombre : WOU - write output
Función : efectúa una escritura de las salidas físicas. Esta función se
implementa únicamente en destinos Z (y varía según el
destino). Consultar la documentación relativa a cada
ejecutor para más detalles.
Variables : ninguna
Direccionamiento: inmediato
Ver también : RIN
AUTOMGEN
7
118 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
X
X
R
R
A
A
Nombre : XRA - xor accumulator
Función : efectúa un O EXCLUSIVO entre el acumulador 16 bits y una
palabra o una constante; efectúa un O EXCLUSIVO entre el
acumulador 32 bits y un largo o una constante
Variables : M o %MW, L o %MD
Direccionamiento: absoluto, indirecto, inmediato
Ver también : ORA
, ANA,
Ejemplo :
xra %1111111100000000
; invierte los 8 bits de peso fuerte del acumulador 16 bits
xra 1L
; invierte el bit de peso débil del acumulador 32 bits
AUTOMGEN
7
119 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.10.4. Macro-instrucción
Las macro-instrucciones son nuevas instrucciones del lenguaje literal detrás de las
cuales se esconde un conjunto de instrucciones de base.
Sintaxis de llamado de una macro-instrucción:
« %<nombre de la macro-instrucción
*
> {parámetros ...} »
Sintaxis de declaración de una macro-instrucción:
#MACRO
<programa>
#ENDM
Esta declaración se encuentra en un archivo que lleva el nombre de la macro-
instrucción y la extensión « .M ».
El archivo .M puede estar en el subrepertorio « lib » del repertorio de instalación de
AUTOMGEN o en los recursos del proyecto.
Es posible pasar diez parámetros a la macro-instrucción. A ser llamados, estos
parámetros se ubicarán sobre la misma línea que la macro-instrucción y estarán
separados por un espacio.
En el programa de la macro-instrucción la sintaxis « {?n} » hace referencia al
parámetro n.
Ejemplo:
Realicemos la macro-instrucción « cuadrado » que eleva el primer parámetro de la
macro-instrucción al cuadrado y pone el resultado en el segundo parámetro.
Llamado de la macro-instrucción:
lda 3
sta m200
%cuadrado m200 m201
; m201 contendrá 9
*
El nombre de la macro-instrucción puede ser un camino de acceso completo al archivo « .M »,
puede contener una designación de lector y de repertorio.
AUTOMGEN
7
120 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Archivo « CUADRADO.M »:
#MACRO
lda {?0}
mla {?0}
sta {?1}
#ENDM
1.10.5. Biblioteca
La noción de biblioteca permite definir recursos que se compilarán una sola vez en
una aplicación, más allá de la cantidad de llamados a esos recursos.
Sintaxis de definición de una biblioteca:
#LIBRARY <nombre de la biblioteca>
<programa>
#ENDL
<nombre de la biblioteca> es el nombre de la función que será llamada por una
instrucción
jsr :<nombre de la biblioteca>:
Al primer llamado encontrado por el compilador, el código de la biblioteca se
compila. Para los siguientes, el llamado se dirige simplemente a la rutina existente.
Este mecanismo se adapta particularmente al empleo de bloques funcionales y
macro-instrucciones para limitar la generación de código en caso de utilización
múltiple de los mismos recursos programas.
Las palabras m120 a m129 se reservan a las bibliotecas y pueden utilizarse para el
pasaje de los parámetros.
1.10.6. Macro-instrucciones predefinidas
En el subrepertorio « LIB » del repertorio donde se ha instalado AUTOMGEN hay
macro-instrucciones de conversión.
También están presentes los equivalentes en bloques funcionales.
1.10.7. Descripción de las macro-instrucciones predefinidas
1.10.7.1. Conversiones
%ASCTOBIN <dos primeros dígitos> <dos últimos dígitos> <resultado en binario>
AUTOMGEN
7
121 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Efectúa una conversión ASCII hexadecimal (dos primeros parámetros) a binario
(tercer parámetro). En salida el acumulador contiene $FFFF si los dos primeros
parámetros no son números ASCII válidos, y si no 0. Todos los parámetros son
palabras de 16 bits.
%BCDTOBIN <valor en BCD> <valor en binario>
Efectúa una conversión BCD a binario. En salida el acumulador contiene $FFFF si el
primer parámetro no es un número bcd válido, y si no 0. Los dos parámetros son
palabras de 16 bits.
%BINTOASC <valor en binario> <resultado parte alta> <resultado parte baja>
Efectúa una conversión binario (primer parámetro) a ASCII hexadecimal (segundo y
tercer parámetros). Todos los parámetros son palabras de 16 bits.
%BINTOBCD <valor en binario> <valor en BCD>
Efectúa una conversión BCD (primer parámetro) a binario (segundo parámetro). En
salida el acumulador contiene $FFFF si el número binario no puede convertirse a
BCD, y si no 0.
%GRAYTOB <valor en código GRAY> <valor en binario>
Efectúa una conversión código Gray (primer parámetro) a binario (segundo
parámetro).
1.10.7.2. Tratamiento con tabla de palabras
%COPY <primera palabra tabla fuente> <primera palabra tabla destino> <número de
palabras>
Copia una tabla de palabras fuente en una tabla de palabras destino. La longitud se
da en número de palabras.
%COMP <primera palabra tabla 1> <primera palabra tabla 2> <número de palabras>
<resultado>
Compara dos tablas de palabras. El resultado es una variable binaria que adopta el
valor 1 si todos los elementos de la tabla 1 son idénticos a la tabla 2.
%FILL <primera palabra tabla> <valor> <número de palabras>
Llena una tabla de palabras con un valor.
AUTOMGEN
7
122 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.10.7.3. Tratamiento en cadena de caracteres
La codificación de las cadenas de caracteres es la siguiente: un carácter por
palabra, una palabra que contiene el valor 0 marca el fin de la cadena. En las macro-
instrucciones, las cadenas pasan a parámetros designando la primera palabra que
las compone.
%STRCPY <cadena fuente> <cadena destino>
Copia una cadena en otra.
%STRCAT <cadena fuente> <cadena destino>
Añade la cadena fuente al final de la cadena destino.
%STRCMP <cadena 1> <cadena 2> <resultado>
Compara dos cadenas. El resultado es una variable booleana que pasa a 1 si las
dos cadenas son idénticas.
%STRLEN <cadena> <resultado>
Coloca la longitud de la cadena en la palabra resultado.
%STRUPR <cadena>
Transforma todos los caracteres de la cadena en mayúsculas.
%STRLWR <cadena>
Transforma todos los caracteres de la cadena en minúsculas.
Ejemplo:
Conversión de m200 (binario) a m202, m203 en 4 dígitos (ASCII bcd)
%bintobcd m200 m201
%bintoasc m201 m202 m203
1.10.8. Ejemplo en lenguaje literal bajo nivel
Condiciones: empecemos con el ejemplo más simple: ida y vuelta de una locomotora
por la vía 1.
AUTOMGEN
7
123 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución:
0 set _av1_
set _dv1_ and _t1d_
res _dv1_ and _t1i_
exemple\lit\littéral bas niveau1.agn
Un ejemplo un poco más evolucionado.
Condiciones:
La locomotora ahora deberá marcar una espera de 10 segundos en el extremo
derecho de la vía y otra de 4 segundos en el izquierdo.
Solución:
0 $t0=100,40
equ u100 and _t1i_ and _t1d_
equ u101 orr t0 eor t1
equ _av1_ orr u100 eor u101
set _dv1_ and _t1d_
equ t0 and _t1d_
res _dv1_ and _t1i_
equ t1 and _t1i_
exemple\lit\littéral bas niveau 2.agn
Otro ejemplo:
Condiciones:
Hacer parpadear todos los semáforos de la maqueta.
AUTOMGEN
7
124 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución:
0 ; table contenant l'adresse de tous les feux
$_table_=123,?_s1d_,?_s1i_,?_s2a_,?_s2b_
$...=?_s3d_,?_s3i_,?_s4a_,?_s4b_
$...=?_s5i_,?_s5d_,?_s6d_,?_s6i_
$...=?_s7i_,?_s7d_,?_s8d_,?_s8i_
$...=-1
; initialise l'index sur le debut de la table
lda ?_table_
sta _index_
:boucle:
; la valeur -1 marque la fin de la table
jmp :fin: and m(_index_)=-1
; inverser la sortie
lda m(_index_)
sta _index2_
inv o(_index2_)
inc _index_
jmp :boucle:
:fin:
exemple\lit\littéral bas niveau 3.agn
Este ejemplo muestra cómo emplear las predisposiciones, que aquí se utilizan para
crear una tabla de direcciones de variables. La tabla contiene la dirección de todas
las salidas que pilotean los semáforos de la maqueta.
A cada ciclo de ejecución, el estado de todos los semáforos se invierte.
Se presenta un problema y es que los semáforos parpadean demasiado rápido.
Modifiquemos el ejemplo.
Condiciones:
Ahora hay que invertir el estado de los semáforos uno por uno a cada décima de
segundo.
AUTOMGEN
7
125 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución:
10 ; table contenant l'adresse de tous les feux
$_table_=123,?_s1d_,?_s1i_,?_s2a_,?_s2b_
$...=?_s3d_,?_s3i_,?_s4a_,?_s4b_
$...=?_s5i_,?_s5d_,?_s6d_,?_s6i_
$...=?_s7i_,?_s7d_,?_s8d_,?_s8i_
$...=-1
$_index_=?_table_
:boucle:
; la valeur -1 marque la fin de la table
jmp :fin de table: and m(_index_)=-1
; inverser la sortie
lda m(_index_)
sta _index2_
inv o(_index2_)
inc _index_
jmp :fin:
:fin de table:
lda ?_table_
sta _index_
:fin:
=1
20
t0/x20/1
exemple\lit\littéral bas niveau 4.agn
1.11. Lenguaje literal extendido
El lenguaje literal extendido es un « superconjunto » del lenguaje literal bajo nivel.
Permite escribir más simplemente y bajo una forma más concisa ecuaciones
booleanas y numéricas.
También permite escribir estructuras de tipo IF ... THEN ... ELSE y WHILE ...
ENDWHILE (bucle).
AUTOMGEN
7
126 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
El lenguaje literal extendido está sujeto a las mismas reglas que el lenguaje literal
bajo nivel, utiliza la misma sintaxis para las variables, los mnemónicos, los tipos de
test (frentes, estado complementado, estado inmediato) y los modos de
direccionamiento.
Es posible « mezclar » el lenguaje literal bajo nivel con el lenguaje literal extendido.
Cuando el compilador de lenguaje literal detecta una línea escrita en lenguaje literal
extendido, la descompone en instrucciones de lenguaje literal bajo nivel y luego la
compila.
1.11.1. Escritura de ecuaciones booleanas
Sintaxis general:
« variable bool.=(tipo de asignación) (variable bool. 2 operador 1 variable bool.
3... operador n -1 variable bool. n ) »
El tipo de asignación debe precisarse si no es « Asignación ».
Puede ser:
Ö « (/) »: asignación complementada,
Ö « (0) »: puesta en cero,
Ö « (1) »: puesta en uno.
Los operadores pueden ser:
Ö « . »: y,
Ö « + »: o.
Las ecuaciones pueden contener varios niveles de paréntesis para precisar el orden
de evaluación. Las ecuaciones se evalúan en forma predeterminada de izquierda a
derecha.
Ejemplos y equivalencias con el lenguaje literal bajo nivel:
o0=(i0) equ o0 and i0
o0=(i0.i1) equ o0 and i0 and i1
o0=(i0+i1) equ o0 orr i0 eor i1
o0=(1) set o0
o0=(0) res o0
o0=(1)(i0) set o0 and i0
o0=(0)(i0) res o0 and i0
AUTOMGEN
7
127 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
o0=(1)(i0.i1) set o0 and i0 and i1
o0=(0)(i0+i1) res o0 orr o0 eor i1
o0=(/)(i0) neq o0 and i0
o0=(/)(i0.i1) neq o0 and i0 and i1
o0=(/i0) equ o0 and /i0
o0=(/i0./i1) equ o0 and /i0 and /i1
o0=(c0=10) equ o0 and c0=10
o0=(m200<100+m200>200) equ o0 orr m200<100 eor m200>200
1.11.2. Escritura de ecuaciones numéricas
Sintaxis general para los enteros:
« variable num.1=[variable num.2 operador 1 ... operador n-1 variable num.n] »
Las ecuaciones pueden contener varios niveles de corchetes para precisar el orden
de evaluación. Las ecuaciones se evalúan en forma predeterminada de izquierda a
derecha.
Los operadores para los enteros 16 y 32 bits pueden ser:
« + »: suma (equivalente a la instrucción ADA),
« - »: resta (equivalente a la instrucción SBA),
« * »: multiplicación (equivalente a la instrucción MLA),
« / »: división (equivalente a la instrucción DVA),
« < »: desfase a izquierda (equivalente a la instrucción RLA),
« > »: desfase a derecha (equivalente a la instrucción RRA),
« & »: « Y » binario (equivalente a la instrucción ANA),
« | »
*
: « O » binario (equivalente a la instrucción ORA),
« ^ »: « O exclusivo » binario (equivalente a la instrucción XRA).
Los operadores para los flotantes pueden ser:
Ö « + »: suma (equivalente a la instrucción ADA),
Ö « - »: resta (equivalente a la instrucción SBA),
Ö « * »: multiplicación (equivalente a la instrucción MLA),
Ö « / »: división (equivalente a la instrucción DVA).
No se puede precisar una constante en las ecuaciones con los flotantes. Si es
necesario, hay que utilizar predisposiciones sobre los flotantes.
*
Este carácter suele asociarse a la combinación de teclas [ALT] + [6] en los teclados.
AUTOMGEN
7
128 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Las ecuaciones con los flotantes pueden llamar a las funciones « SQR » y « ABS ».
Observación: según la complejidad de las ecuaciones, el compilador puede utilizar
variables intermedias. Estas variables son las palabras m53 a m59 para los enteros
16 bits, los largos l53 a l59 para los enteros 32 bits y los flotantes f53 a f59.
Ejemplos y equivalencias con el lenguaje literal bajo nivel:
M200=[10] lda 10
sta m200
M200=[m201] lda m201
sta m200
M200=[m201+100] lda m201
ada 100
sta m200
M200=[m200+m201-m202] lda m200
ada m201
sba m202
sta m200
M200=[m200&$ff00] lda m200
ana $ff00
sta m200
F200=[f201] lda f201
sta f200
F200=[f201+f202] lda f201
ada f202
sta f200
F200=[sqr[f201]] lda f201
sqr aaa
sta f200
F200=[sqr[abs[f201*100R]]] lda f201
mla 100R
abs aaa
sqr aaa
sta f200
L200=[l201+$12345678L] lda l201
ada $12345678L
sta l200
AUTOMGEN
7
129 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.11.3. Estructura de tipo IF ... THEN ... ELSE ...
Sintaxis general:
IF(test)
THEN
acción si test verdadero
ENDIF
ELSE
acción si test falso
ENDIF
El test debe respetar la sintaxis descrita en el capítulo sobre ecuaciones booleanas.
Puede figurar sólo una acción si test verdadero, o una acción si test falso.
Es posible imbricar varias estructuras de este tipo.
Los bits Sistema u90 a u99 se utilizan como variables temporales para gestionar
este tipo de estructura.
Ejemplos:
IF(i0)
THEN
inc m200 ; incrementar la palabra 200 si i0
ENDIF
IF(i1+i2)
THEN
m200=[m200+10] ; añadir 10 a la palabra 200 si i1 o i2
ENDIF
ELSE
res m200 ; si no borrar m200
ENDIF
1.11.4. Estructura de tipo WHILE ... ENDWHILE
Sintaxis general:
WHILE(test)
acción a repetir mientras el test sea verdadero
ENDWHILE
AUTOMGEN
7
130 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
El test debe respetar la sintaxis descrita en el capítulo sobre ecuaciones booleanas.
Es posible imbricar varias estructuras de este tipo.
Los bits Sistema u90 a u99 se utilizan como variables temporales para gestionar
este tipo de estructura.
Ejemplos:
m200=[0]
WHILE(m200<10)
set o(200)
inc m200 ; incrementar la palabra 200
ENDWHILE
Este ejemplo pone en uno las salidas o0 a o9.
1.11.5. Ejemplo de programa en lenguaje literal extendido
Retomemos el primer ejemplo del capítulo anterior.
Solución:
0 _av1_=(1)
_dv1_=(1)(_t1d_)
_dv1_=(0)(_t1i_)
exemple\lit\littéral étendu 1.agn
Enriquezcamos nuestro ejemplo con cálculos.
Condiciones:
Calcular la velocidad en milímetros por segundo y en metros por hora de la
locomotora en el trayecto de izquierda a derecha.
AUTOMGEN
7
131 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución:
0 _av1_=(1)
_dv1_=(1)(_t1d_)
_dv1_=(0)(_t1i_)
È
dv1 _temps aller_=[m32]
Ç
dv1 $_longueur_=300 ; en mm
$_mille_=1000;
$_dixdansh_=36000;
$_dix_=10;
_temps mis_=[m32-_temps aller_]
IF(_temps mis_<0)
THEN
_temps mis_=[_temps mis_+100]
ENDIF
lda _temps mis_
itf aaa
sta _dixieme_
_vitesse mm par s_=[_longueur_/[_dixieme_/_dix_]]
_vitesse m par h_=[[_longueur_/_mille_]/[_dixieme_/_dixdansh_]]
exemple\lit\littéral étendu 2.agn
La palabra 32 se utiliza para leer el tiempo Sistema. El valor luego se transfiere a
flotantes para poder efectuar los cálculos sin perder precisión.
1.12. Lenguaje literal ST
El lenguaje literal ST es el lenguaje literal estructurado definido por la norma
CEI1131-3. Este lenguaje permite escribir ecuaciones booleanas y numéricas y
estructuras de programación.
1.12.1. Generalidades
El lenguaje literal ST se utiliza en los mismos sitios que el lenguaje literal bajo nivel y
el lenguaje literal extendido.
AUTOMGEN
7
132 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Estas directivas permiten definir secciones en lenguaje literal ST:
« #BEGIN_ST » marca el principio de una sección en lenguaje ST.
« #END_ST » marca el fin de una sección en lenguaje ST.
Ejemplo:
m200=[50] ; lenguaje literal extendido
#BEGIN_ST
m201:=4; (* lenguaje ST *)
#END_ST
También es posible optar por el uso del lenguaje ST para todo un folio. La elección
se efectúa en el cuadro de diálogo de propiedades de cada folio.
En un folio con lenguaje predeterminado ST es posible insertar lenguaje literal bajo
nivel y extendido encerrando las líneas con las dos directivas « #END_ST » y
« #BEGIN_ST ».
Para el lenguaje ST los comentarios deben empezar con « (* » y terminar con « *) ».
Las instrucciones del lenguaje ST terminan con el carácter « ; ». Es posible escribir
varias instrucciones en una misma línea.
Ejemplo:
o0:=1; m200:=m200+1;
1.12.2. Ecuaciones booleanas
La sintaxis general es:
variable := ecuación booleana;
La ecuación booleana puede componerse de una constante, una variable o varias
variables separadas por operadores.
Las constantes pueden ser: 0, 1, FALSE o TRUE.
AUTOMGEN
7
133 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Ejemplos:
o0:=1;
o1:=FALSE;
Los operadores que permiten separar varias variables son: + (o), . (y), OR o AND.
El « Y » tiene prioridad sobre el « O ».
Ejemplo:
o0:=i0+i1.i2+i3;
Será tratado como:
o0:=i0+(i1.i2)+i3;
Los paréntesis pueden utilizarse en las ecuaciones para especificar las prioridades.
Ejemplo:
o0:=(i0+i1).(i2+i3);
Pueden utilizarse tests numéricos.
Ejemplo:
o0:=m200>5.m200<100;
1.12.3. Ecuaciones numéricas
La sintaxis general es:
variable := ecuación numérica;
La ecuación numérica puede componerse de una constante, una variable o varias
variables y constantes separadas por operadores.
Las constantes pueden ser valores expresados en decimal, hexadecimal (prefijo
16#) o binario (prefijo 2#).
AUTOMGEN
7
134 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Ejemplos:
m200:=1234;
m201:=16#aa55;
m202:=2#100000011101;
Los operadores que permiten separar varias variables o constantes se ordenan
según la prioridad:
* (multiplicación), / (división), + (suma), - (resta), & o AND (Y binario), XOR (O
exclusivo binario), OR (O binario).
Ejemplos:
m200:=1000*m201;
m200:=m202-m204*m203; (* equivalente a m200:=m202-(m204*m203) *)
Los paréntesis pueden utilizarse en las ecuaciones para especificar las prioridades.
Ejemplo:
m200:=(m202-m204)*m203;
1.12.4. Estructuras de programación
1.12.4.1. Test SI ENTONCES SI NO
Sintaxis:
IF condición THEN acción ENDIF;
y
IF condición THEN acción ELSE acción ENDIF;
Ejemplo:
if i0
then o0:=TRUE;
else
o0:=FALSE;
if i1 then m200:=4; endif;
endif ;
AUTOMGEN
7
135 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.12.4.2. Bucle MIENTRAS
Sintaxis:
WHILE condición DO acción ENDWHILE;
Ejemplo:
while m200<1000
do
m200:=m200+1;
endwhile;
1.12.4.3. Bucle HASTA QUE
Sintaxis:
REPEAT acción UNTIL condición; ENDREPEAT;
Ejemplo:
repeat
m200:=m200+1;
until m200=500
endrepeat;
1.12.4.4. Bucle DESDE HASTA
Sintaxis:
FOR variable:=valor de inicio TO valor de fin DO acción ENDFOR;
o
FOR variable:=valor de inicio TO valor de fin BY no DO acción ENDFOR;
Ejemplo:
for m200:=0 to 100 by 2
do
m201:=m202*m201;
endfor;
AUTOMGEN
7
136 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.12.4.5. Salida de bucle
La palabra clave « EXIT » permite salir de un bucle.
Ejemplo:
while i0
m200:=m200+1;
if m200>1000 then exit; endif;
endwhile;
1.12.5. Ejemplo de programa en lenguaje literal extendido
Retomemos el primer ejemplo del capítulo anterior.
Solución:
0 _av1_:=TRUE;
if _t1d_ then _dv1_:=TRUE; endif;
if _t1i_ then _dv1_:=FALSE; endif;
exemple\lit\littéral ST 1.agn
1.13. Organigrama
AUTOMGEN implementa una programación de tipo « organigrama ».
Para este tipo de programación se deben utilizar los lenguajes literales. Consultar los
capítulos anteriores para saber cómo utilizarlos.
La ventaja de la programación bajo forma de organigrama es la representación
gráfica de un tratamiento algorítmico.
Contrariamente al lenguaje Grafcet, la programación bajo forma de organigrama
genera un código que se ejecutará una vez por ciclo de escrutación. Esto significa
que no podemos quedarnos a la espera en un rectángulo de organigrama; es
obligatorio que la ejecución salga del organigrama para poder seguir ejecutando el
programa.
Es importante no olvidar este punto cuando se elige este lenguaje.
AUTOMGEN
7
137 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Es posible diseñar sólo rectángulos. El contenido de los rectángulos y los vínculos
determinan si el rectángulo es una acción o un test.
1.13.1. Diseño de un organigrama
Los rectángulos se diseñan eligiendo el comando « Más … / Caja de código » del
menú contextual (hacer clic con el botón derecho del ratón sobre el fondo del folio
para abrir el menú contextual).
Es necesario colocar un bloque
(tecla [<]) en la entrada de cada rectángulo;
esta entrada debe estar ubicada en la parte superior del rectángulo.
Si el rectángulo representa una acción, habrá una sola salida materializada por un
bloque
(tecla [E]) abajo y a la izquierda del rectángulo.
Un rectángulo de acción:
Si el rectángulo representa un test, habrá obligatoriamente dos salidas. La primera,
materializada por un bloque
(tecla [E]) abajo y a la izquierda representa la
salida si el test es verdadero; la segunda, materializada por un bloque (tecla [=])
inmediatamente a la derecha de la otra salida representa la salida si el test es falso.
AUTOMGEN
7
138 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Un rectángulo de test:
Las ramas de organigramas deben terminar con un rectángulo sin salida que
eventualmente puede quedar vacío.
1.13.2. Contenido de los rectángulos
1.13.2.1. Contenido de los rectángulos de acción
Los rectángulos de acción pueden contener cualquier instrucción de lenguaje literal.
1.13.2.2. Contenido de los rectángulos de test
Los rectángulos de test deben contener un test que respete la sintaxis de la parte
test de la estructura de tipo IF...THEN...ELSE... del lenguaje literal extendido.
Por ejemplo:
IF (i0)
Es posible escribir antes de este test acciones en el rectángulo de test.
Esto permite, por ejemplo, efectuar ciertos cálculos antes del test.
Si por ejemplo queremos testear si la palabra 200 es igual a la palabra 201 más 4:
m202=[m201+4]
IF(m200=m202)
1.14. Ilustración
Nuestro ya clásico primer ejemplo consiste en hacer ir y venir a una locomotora por
la vía 1 de la maqueta.
AUTOMGEN
7
139 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución:
set _av1_
if(_t1d_)
set _dv1_ if(_t1i_)
res _dv1_
exemple\organigramme\organigramme 1.agn
Segundo ejemplo
Condiciones:
Hacer parpadear todos los semáforos de la maqueta. Los semáforos cambian de
estado cada segundo.
AUTOMGEN
7
140 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución:
$t0=10
t0=( t0)
_index%m_=[?_s1d_]
inv o(_index%m_) and t0
inc _index%m_
_calcul%m_=[?_s8i_+1]
IF(_index%m_=_calcul%m_)
exemple\organigramme\organigramme 2.agn
Notar la utilización de símbolos automáticos en este ejemplo.
AUTOMGEN
7
141 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.15. Bloques funcionales
AUTOMGEN implementa la noción de bloques funcionales.
Este método de programación modular permite asociar a un elemento gráfico un
conjunto de instrucciones escritas en lenguaje literal.
Los bloques funcionales pueden ser definidos por el programador. No tienen un
número limitado. Por eso es posible constituir conjuntos de bloques funcionales que
permiten una concepción modular y estandarizada de las aplicaciones.
Los bloques funcionales se utilizan dentro de esquemas de tipo logigrama o ladder,
poseen de una a n entradas booleanas y de una a n salidas booleanas. Si el bloque
debe tratar variables no booleanas, éstas se mencionarán en el diseño del bloque
funcional. El interior del bloque puede recibir parámetros: constantes o variables.
Entrées
booléennes du
bloc (maximum
16)
Sorties
booléennes du
bloc (maximum
16)
Paramètres du
bloc (maximum
16)
1.15.1. Creación de un bloque funcional
Un bloque funcional está compuesto por dos archivos distintos: un archivo de
extensión « .ZON » que contiene el diseño del bloque funcional y un archivo de
extensión « .LIB » que contiene una serie de instrucciones escritas en lenguaje literal
que definen el funcionamiento del bloque funcional.
Los archivos « .ZON » y « .LIB » deben llevar el nombre del bloque funcional. Por
ejemplo, si decidimos crear un bloque funcional « MEMORIA », deberemos crear los
AUTOMGEN
7
142 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
archivos « MEMORIA.ZON » (para el diseño del bloque) y « MEMORIA.LIB » (para
el funcionamiento del bloque).
1.15.2. Diseño del bloque y creación del archivo « .ZON »
La envoltura de un bloque funcional está constituida por una caja de código a la que
hay que añadir bloques dedicados a los bloques funcionales.
Para diseñar un bloque funcional se deben efectuar las siguientes operaciones:
Ö utilizar el asistente (recomendado)
O:
Ö diseñar una caja de código (utilizar el comando « Más …/Caja de código » del
menú contextual):
Ö colocar un bloque (tecla [8]) en el ángulo superior izquierdo de la caja de
código:
Ö colocar un bloque (tecla [9]) en el ángulo superior derecho de la caja de
código:
Ö borrar la línea que queda en la parte superior del bloque (la tecla [A] permite
poner bloques blancos):
AUTOMGEN
7
143 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Ö hacer clic con el botón izquierdo del ratón en el ángulo superior izquierdo del
bloque funcional, ingresar el nombre del bloque funcional, que no debe superar
los 8 caracteres (los archivos « .ZON » y « .LIB » deberán llevar ese nombre),
presionar [ENTER];
Ö si se necesitan entradas booleanas suplementarias, se debe utilizar un bloque
(tecla [;]) o (tecla [:]); las entradas añadidas deben encontrarse
inmediatamente debajo de la primera entrada, sin dejar ningún espacio libre;
Ö si se necesitan salidas booleanas suplementarias, se debe añadir un bloque
(tecla [>]) o (tecla [?]); las salidas añadidas deben encontrarse
inmediatamente debajo de la primera salida, sin dejar ningún espacio libre;
Ö el interior del bloque puede contener comentarios o parámetros; los parámetros
se escriben entre llaves « {...} ». Todo lo que no se escriba entre llaves será
ignorado por el compilador. Es interesante identificar el uso de las entradas y
salidas booleanas dentro del bloque;
Ö una vez terminado un bloque, se debe utilizar el comando « Seleccionar » del
menú « Edición » para seleccionar el diseño del bloque funcional y guardarlo en
un archivo « .ZON » con el comando « Copiar en » del menú « Edición ».
AUTOMGEN
7
144 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.15.3. Creación del archivo « .LIB »
El archivo « .LIB » es un archivo de texto que contiene instrucciones en lenguaje
literal (bajo nivel o extendido). Estas instrucciones definen el funcionamiento del
bloque funcional.
Una sintaxis especial permite hacer referencia a las entradas booleanas del bloque,
a las salidas booleanas del bloque y a los parámetros del bloque.
Para hacer referencia a una entrada booleana del bloque, se debe utilizar la sintaxis
« {Ix} », donde x es el número de la entrada booleana expresado en hexadecimal (0
a f).
Para hacer referencia a una salida booleana del bloque, se debe utilizar la sintaxis
« {Ox} », donde x es el número de la salida booleana expresado en hexadecimal (0 a
f).
Para hacer referencia a un parámetro del bloque, se debe utilizar la sintaxis « {?x} »,
donde x es el número del parámetro en hexadecimal (0 a f).
El archivo .LIB puede estar ubicado en el subrepertorio « lib » del repertorio de
instalación de AUTOMGEN o en los recursos del proyecto.
1.15.4. Ejemplo simple de bloque funcional
Creemos el bloque funcional « MEMORIA », que posee dos entradas booleanas
(puesta en uno y puesta en cero) y una salida booleana (el estado de la memoria).
El diseño del bloque contenido en el archivo « MEMORIA.ZON » es:
El funcionamiento del bloque contenido en el archivo « MEMORIA.LIB » es:
{O0}=(1)({I0})
{O0}=(0)({I1})
El bloque puede utilizarse de la siguiente manera:
o
AUTOMGEN
7
145 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Para utilizar un bloque funcional en una aplicación, se debe elegir el comando
« Pegar a partir de » del menú « Edición » y elegir el archivo « .ZON »
correspondiente al bloque funcional a utilizar.
1.15.5. Ilustración
Retomemos un ejemplo ya clásico:
Condiciones:
Ida y vuelta de una locomotora por la vía 1 de la maqueta.
Solución:
ALLERRET
t1d capteur droit
t1i capteur gauche
BF aller
alimentation AV1
direction DV1
/retour
exemple\bf\bloc-fonctionnel 1.agn
; bloque funcional ALLERRET
; ida vuelta de una locomotora por una vía
; las entradas booleanas son los fines de carrera
; las salidas booleanas son la alimentación de la vía (0) y la
dirección (1)
; alimentar siempre la vía
set {O0}
; pilotear la dirección en función de los fines de carrera
{O1}=(1)({I0})
{O1}=(0)({I1})
Para ilustrar el interés de la utilización de los bloques funcionales, completemos
nuestro ejemplo.
Condiciones:
Ida y vuelta de dos locomotoras por las vías 1 y 3.
AUTOMGEN
7
146 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución:
ALLERRET
t1d capteur droit alimentation AV1
t1i capteur gauche direction DV1
BF aller/retour
ALLERRET
t3d capteur droit alimentation AV3
t3i capteur gauche direction N DV3
BF aller/retour
exemple\bf\bloc-fonctionnel 2.agn
Este ejemplo muestra que con el mismo bloque funcional se pueden hacer funcionar
de manera idéntica diferentes módulos de una parte operativa.
Completemos nuestro ejemplo para ilustrar la utilización de parámetros.
Condiciones:
Ahora las dos locomotoras deben marcar una espera al final de la vía. Para la
locomotora 1: 10 segundos a la derecha y 4 segundos a la izquierda; para la
locomotora 2: 20 segundos a la derecha y 8 segundos a la izquierda.
AUTOMGEN
7
147 (C)opyright 2002 IRAI
La página se está cargando ...
Manual de referencia del lenguaje
; bloque funcional ARATT
; ida vuelta de una locomotora por una vía con espera
; las entradas booleanas son los fines de carrera
; las salidas booleanas son la alimentación de la vía (0) y la
dirección (1)
; los parámetros son:
; 0: primera temporización
; 1: duración de la primera temporización
; 2: segunda temporización
; 3: duración de la segunda temporización
; predisposición de las dos temporizaciones
${?0}={?1}
${?2}={?3}
; alimentar la vía si no fines de carrera o si tempor. terminadas
set {O0}
res {O0} orr {I0} eor {I1}
set {O0} orr {?0} eor {?2}
; gestión de las temporizaciones
{?0}=({I0})
{?2}=({I1})
; pilotear la dirección en función de los fines de carrera
{O1}=(1)({I0})
{O1}=(0)({I1})
exemple\bf\bloc-fonctionnel 3.agn
1.15.6. Complemento de sintaxis
Una sintaxis complementaria permite efectuar un cálculo con los números de
variables referenciadas en el archivo « .LIB ».
La sintaxis « ~+n » añadida a continuación de una referencia a una variable o un
parámetro suma n.
La sintaxis « ~-n » añadida a continuación de una referencia a una variable o un
parámetro resta n.
La sintaxis « ~*n » añadida a continuación de una referencia a una variable o un
parámetro multiplica por n.
Es posible escribir varios de estos comandos seguidos; se evalúan de izquierda a
derecha.
Este mecanismo es útil cuando un parámetro del bloque funcional debe permitir
hacer referencia a una tabla de variables.
Ejemplos:
{?0}~+1
AUTOMGEN
7
149 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
hace referencia al elemento siguiente al primer parámetro; por ejemplo, si el primer
parámetro es m200, esta sintaxis hace referencia a m201.
M{?2}~*100~+200
hace referencia al tercer parámetro multiplicado por 100 más 200; por ejemplo, si el
tercer parámetro es 1, esta sintaxis hace referencia a M 1*100 + 200, es decir M300.
1.16. Bloques funcionales evolucionados
Esta funcionalidad permite crear bloques funcionales muy potentes con más
simplicidad que los bloques funcionales gestionados por archivos escritos en
lenguaje literal. Este método de programación permite un enfoque de tipo análisis
funcional.
Cualquier folio o conjunto de folios puede convertirse en un bloque funcional (a
veces se habla de encapsular un programa).
El o los folios que describen el funcionamiento de un bloque funcional pueden
acceder a las variables externas del bloque funcional: las entradas booleanas del
bloque, las salidas booleanas y los parámetros.
El principio de utilización, particularmente de la utilización de las variables externas,
es idéntico al de los viejos bloques funcionales.
1.16.1. Sintaxis
Para referenciar una variable externa de un bloque funcional se debe utilizar un
mnemónico que incluya el texto siguiente: {In} para referenciar la entrada booleana
n, {On} para referenciar la salida booleana n, {?n} para referenciar el parámetro n. El
mnemónico debe empezar con una letra.
1.16.2. Diferenciar viejos y nuevos bloques funcionales
El nombre de archivo inscrito en el diseño bloque funcional indica si se trata de un
viejo bloque funcional (gestionado por un archivo .LIB) o de un nuevo bloque
funcional (gestionado por un folio .GR7). Para un viejo bloque funcional, el nombre
no lleva extensión; para uno nuevo debe añadirse la extensión .GR7. El folio que
contiene el código que gestiona el funcionamiento del bloque funcional debe estar
integrado en la lista de folios del proyecto. En las propiedades del folio, debe
elegirse el tipo « Bloque-funcional ».
AUTOMGEN
7
150 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.16.3. Ejemplo
Contenido del folio VERINB:
BF vérin bistable
10
cde ouverture{i0} . ouvert{i2} cde fermeture{i1} . ferme{i3} . cde ouverture{i0}
20 OUVRIR{O0} 30 FERMER{O1}
ouvert{i2} ferme{i3}
40
duree{?0} /x40/ tempo{?1}
AUTOMGEN
7
151 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Llamado del bloque funcional:
VERINB.GR7
u100 CDE O O O0
u101 CDE F F O1
i1 O
i0 F
Durée
{10s}
Temporisation
{T0}
VERIN BISTABLE
exemple\bf\bloc-fonctionnel 3.agn
1.17. Bloques funcionales predefinidos
En el subrepertorio « \LIB » del repertorio donde se ha instalado AUTOMGEN hay
bloques funcionales de conversión.
También están los equivalentes en macro-instrucciones; ver el capítulo
.
1.10.3. El
lenguaje literal bajo nivel
Para insertar y parametrar un bloque funcional en una aplicación se debe
seleccionar el comando « Insertar un bloque funcional » del menú « Herramientas ».
1.17.1. Bloques de conversión
ASCTOBIN: conversión ASCII a binario
BCDTOBIN: conversión BCD a binario
BINTOASC: conversión binario a ASCII
BINTOBCD: conversión binario a BCD
GRAYTOB: conversión código Gray a binario
16BINTOM: transferencia de 16 variables booleanas a una palabra
MTO16 BIN: transferencia de una palabra a 16 variables booleanas
AUTOMGEN
7
152 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.17.2. Bloques de temporización
TEMPO: temporización a la subida
PULSOR: salida a intervalos
PULSE: impulsión temporizada
1.17.3. Bloques de manipulación de cadena de caracteres
STRCMP: comparación
STRCAT: concatenacíón
STRCPY: copia
STRLEN: cálculo de la longitud
STRUPR: puesta en minúsculas
STRLWR: puesta en mayúsculas
1.17.4. Bloques de manipulación de tabla de palabras
COMP: comparación
COPY: copia
FILL: llenado
1.18. Técnicas avanzadas
1.18.1. Código generado por el compilador
En este capítulo abordaremos la forma del código generado por la compilación de tal
o cual tipo de programa.
El utilitario « CODELIST.EXE »
*
permite traducir « en claro » un archivo de código
intermedio « .EQU » (también llamado lenguaje pivote).
Hagamos la experiencia siguiente: carguemos y compilemos el primer ejemplo de
programa del capítulo « Grafcet »: « simple1.agn » del repertorio
« exemple\grafcet »:
*
Este utilitario debe ejecutarse a partir de la línea de comando DOS.
AUTOMGEN
7
153 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
0AV1
t1d
1 AV1 , DV1
t1i
Hacer doble clic en el elemento « Archivos generados/Código pivote » en el
explorador.
Se obtiene la siguiente lista de instrucciones:
; El código siguiente ha sido generado por la compilación de: 'Folio:
GRAF1'
:00000000: RES x0 AND i0
:00000002: SET x0 AND b0
:00000004: SET x0 AND x1 AND i1
:00000007: RES x1 AND i1
:00000009: SET x1 AND x0 AND i0
; El código siguiente ha sido generado por la compilación de:
'asignaciones (acciones Grafcet, logigramas y ladder)'
:0000000C: EQU o0 ORR @x0 EOR @x1
:0000000F: EQU o23 AND @x1
Representa la traducción de la aplicación « simple1.agn » en instrucciones del
lenguaje literal bajo nivel.
Los comentarios indican el origen de las porciones de código, lo cual es útil si una
aplicación se compone de varios folios.
Obtener esta lista de instrucciones puede ser útil para responder a las preguntas
sobre el código generado por tal o cual forma de programa o la utilización de tal o
cual lenguaje.
En ciertos casos « críticos » para los que es importante conocer informaciones como
« ¿al cabo de cuántos ciclos esta acción es verdadera? » el modo paso a paso y el
examen exhaustivo del código generado resultan indispensables.
1.18.2. Optimización del código generado
Son posibles varios niveles de optimización.
AUTOMGEN
7
154 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
1.18.2.1. Optimización del código generado por el compilador
La opción de optimización del compilador permite reducir considerablemente el
tamaño del código generado. Esta directiva exige al compilador que genere menos
líneas de lenguaje literal bajo nivel; como consecuencia, el tiempo de compilación
aumenta.
Según los post-procesadores utilizados, esta opción implica una ganancia sobre el
tamaño del código o el tiempo de ejecución. Conviene efectuar pruebas para
determinar si la directiva es interesante o no según la naturaleza del programa y el
tipo de destino utilizado.
En general es interesante utilizarla con los post-procesadores para destinos Z.
1.18.2.2. Optimización del código generado por los post-procesadores
Cada post-procesador puede poseer opciones para optimizar el código generado.
Para los post-procesadores que generan código constructor consulte la nota
correspondiente.
1.18.2.3. Optimización del tiempo de ciclo: reducir el número de
temporizaciones en destinos Z
Para los destinos Z, el número de temporizaciones declaradas influye directamente
en el tiempo de ciclo. Declare el mínimo de temporizaciones en función de las
necesidades de la aplicación.
1.18.2.4. Optimización del tiempo de ciclo: anular la escrutación de
ciertas partes del programa
Sólo los destinos que aceptan instrucciones JSR y RET soportan esta técnica.
Es posible validar o « invalidar » la escrutación de ciertas partes del programa
utilizando directivas de compilación especiales.
Dichas porciones de aplicación son definidas por los folios.
Si una aplicación se descompone en cuatro folios, cada uno de ellos podrá ser
« validado » o « invalidado » independientemente.
Una directiva « #C(condición) » colocada en un folio condiciona la escrutación del
folio hasta el folio que contiene una directiva « #R ».
AUTOMGEN
7
155 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Esta condición debe utilizar la sintaxis definida para los tests; ver el capítulo
1.3.
Tests
Ejemplo:
Si un folio contiene las dos directivas:
#C(m200=4)
#R
Entonces todo lo que contiene se ejecutará sólo si la palabra 200 contiene 4.
AUTOMGEN
7
156 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2. Ejemplos
2.1. A propósito de ejemplos
Esta parte agrupa una serie de ejemplos que ilustran diferentes posibilidades de
programación con AUTOMGEN.
Todos los ejemplos se encuentran en el subrepertorio « ejemplo » del repertorio
donde se ha instalado AUTOMGEN.
Esta parte también contiene ejemplos más completos y más complejos desarrollados
para una maqueta de tren. La descripción de esta maqueta se encuentra al principio
del manual de referencia del lenguaje.
2.1.1. Grafcet simple
Este primer ejemplo es un Grafcet simple en línea:
100
i0
110 T0(100)
t0
120 O0,O1,O2
i0
exemple\grafcet\sample1.agn
Ö la transición entre la etapa 100 y la etapa 110 está constituida por el test en
la entrada 0,
AUTOMGEN
7
157 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Ö la etapa 110 activa la temporización 0 de una duración de 10 segundos;
esta temporización se utiliza como transición entre la etapa 110 y 120,
Ö la etapa 120 activa las salidas 0, 1 y 2,
Ö el complemento de la entrada 0 sirve de transición entre la etapa 120 y 100.
2.1.2. Grafcet con diagrama en O
100 O0
i0 i1 i2 i3
110 O1 120 O2 130 O3 140 O4
i4 i5 i6 i7
111 O5 131 O6
i8 i9
112 O7
i10
exemple\grafcet\sample2.agn
Este ejemplo ilustra la utilización de las divergencias y convergencias en « O ». El
número de ramas está limitado sólo por el tamaño del folio. Se trata, como establece
la norma, de un « O » no exclusivo. Si por ejemplo las entradas 1 y 2 están activas,
las etapas 120 y 130 se ponen en uno.
AUTOMGEN
7
158 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2.1.3. Grafcet con divergencia en Y
100
i0
110 O0 130 O1 160 SO2 190 O3
i1 i2
120 140 170 O4
i2 i4
150 O5 180 RO2
i7
exemple\grafcet\sample3.agn
Este ejemplo ilustra la utilización de las divergencias y convergencias en « Y ». El
número de ramas está limitado sólo por el tamaño del folio. Notemos también los
puntos siguientes:
Ö una etapa puede no implicar acciones (caso de las etapas 100, 120, y 140),
Ö las órdenes « S » y « R » se han utilizado con la salida o2 (etapas 160 y
180),
Ö la transición entre la etapa 160 y 170 queda en blanco, por lo que siempre
es verdadera; también se podría haber utilizado la sintaxis « =1 ».
AUTOMGEN
7
159 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2.1.4. Grafcet y sincronización
0 100
Ç
i0 x1 i10 i14
1 110 O0 O4
È
x110 i1 i11
O1
i12
O2
i13
O3
exemple\grafcet\sample4.agn
Este ejemplo ilustra una de las posibilidades ofrecidas por AUTOMGEN para
sincronizar varios Grafcets. La transición entre la etapa 100 y 110 « Ïx1 » significa
« esperar un frente ascendente sobre la etapa 1 ». La transición « Ðx110 » significa
« esperar un frente descendente sobre la etapa 110 ». La ejecución paso a paso de
este programa muestra la evolución exacta de las variables y de su frente a cada
ciclo. Esto permite comprender exactamente lo que pasa durante la ejecución.
Notemos también la utilización de acciones múltiples asociadas a la etapa 110, que
están condicionadas individualmente.
AUTOMGEN
7
160 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2.1.5. Forzado de etapas
10 RC0
i0 100
Ç
20 SX100 i4
110 +C0
30 i1
x120 120
exemple\grafcet\sample5.agn
En este ejemplo, se ha utilizado una orden « S » (puesta en uno) para forzar una
etapa. AUTOMGEN autoriza también el forzado de un Grafcet entero (ver ejemplos 8
y 9). El modo de ejecución paso a paso permite, también en este ejemplo,
comprender de manera precisa la evolución del programa en el tiempo. Notemos
también:
Ö la utilización de un Grafcet sin bucle (100, 110, 120),
Ö la utilización de la orden « RC0 » (puesta en cero del contador 0),
Ö la utilización de la orden « +C0 » (incrementar el contador 0), condicionada
por el frente ascendente de la entrada 4; para ejecutar la incrementación del
contador, la etapa 110 debe estar activa y un frente ascendente debe
detectarse en la entrada 4.
AUTOMGEN
7
161 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2.1.6. Etapas pozos y fuentes
Ç
i0.i1
100 O0
Ç
i0
110 O1
Ç
i0
120 O2
Ç
i0
130 O3
Ç
i0
exemple\grafcet\sample6.agn
Ya hemos visto formas similares en las que la primera etapa era activada por otro
Grafcet. Aquí la etapa 100 es activada por la transición « Ïi0 . i1 » (frente
ascendente de la entrada 0 y la entrada 1). Este ejemplo representa un registro de
desfase. « i1 » es la información a memorizar en el registro y « i0 » es el reloj que
hace progresar el desfase. El ejemplo 7 es una variante que utiliza una
temporización como reloj.
AUTOMGEN
7
162 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2.1.7. Etapas pozos y fuentes
Ç
t0.i1
100 O0
Ç
t0
110 O1
Ç
t0
120 O2
Ç
t0 t0
130 O3 1000 T0(10)
Ç
t0
exemple\grafcet\sample7.agn
Volvemos a ver la estructura de registro de desfase utilizada en el ejemplo 6. La
información de desfase esta vez es generada por una temporización (t0). « Ït0 »
representa el frente ascendente de la temporización; esta información es verdadera
durante un ciclo cuando la temporización ha terminado de descontar. La etapa 1000
gestiona el lanzamiento de la temporización. La acción de esta etapa puede
resumirse así: « activar el descuento si éste no ha terminado; en caso contrario,
restablecer la temporización ». El diagrama de funcionamiento de las
temporizaciones de este manual ayuda a entender el funcionamiento de este
programa.
AUTOMGEN
7
163 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2.1.8. Forzado de Grafcets
0
parada
1 F100:{}
100 TESTIGO INIC
Ç
urgencia bp inicio de ciclo
110 MOTOR
parada
2 F100:{100}
urgencia bp fin de ciclo
exemple\grafcet\sample8.agn
Este ejemplo ilustra la utilización de un comando de forzado de Grafcet. La orden
« F100:{} » significa « forzar todas las etapas del Grafcet que tiene una etapa que
lleva el número 100 a cero ». La orden « F100:{100} » es idéntica pero fuerza la
etapa 100 a 1. Para este ejemplo hemos utilizado símbolos:
AUTOMGEN
7
164 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2.1.9. Memorización de Grafcets
0
parada urgencia
1 G100:100
2 F100:()
parada urgencia
3 F100:100
#B200
100 TESTIGO INIC
Ç
bp inicio de ciclo
110 MOTOR
bp fin de ciclo
exemple\grafcet\sample9.agn
Este ejemplo es una variante del programa anterior. La orden « G100:100 » de la
etapa 1 memoriza el estado del Grafcet de producción antes de que se fuerce a
cero. Al retomar, el Grafcet de producción se colocará de nuevo en el estado en que
estaba antes del corte, con la orden « F100:100 ». El estado del Grafcet de
producción se memoriza a partir del bit 100 (es el segundo parámetro de las órdenes
« F » y « G » el que precisa esta ubicación), la directiva de compilación « #B200 »
reserva los bits u100 a u199 para este tipo de utilización. Notemos que una directiva
AUTOMGEN
7
165 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
« #B102 » habría bastado, ya que el Grafcet de producción sólo necesita dos bits
para memorizarse (un bit por etapa).
2.1.10. Grafcet y macro-etapas
0O0
i0
1
i1
2O1
i2
3
i3
E
10 SO10
i10
20 RO10
S
exemple\grafcet\sample11.agn
AUTOMGEN
7
166 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Este ejemplo ilustra la utilización de las macro-etapas. Los folios « Macro etapa 1 » y
« Macro etapa 3 » representan la expansión de las macro-etapas con las etapas de
entradas y de salidas. Las etapas 1 y 3 del folio « Programa principal » están
definidas como macro-etapas. A las expansiones de macro-etapas en visualización
se accede haciendo clic con el botón izquierdo del ratón en las macro-etapas.
2.1.11. Folios en cadena
0O0
i0
1O1
i1
2O2
i2
3 SUITE
continue
AUTOMGEN
7
167 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
4O3
suite
5O4
i3
6O5
i4
7 CONTINUE
exemple\grafcet\sample12.agn
En este ejemplo se han utilizado dos folios para escribir el programa. Los símbolos
« _CONTINUACIÓN_ » y « _CONTINÚA_ » se han declarado como bits (ver el
fichero de símbolos) y permiten vincular los dos Grafcets (es otra técnica de
sincronización que se puede utilizar con AUTOMGEN).
AUTOMGEN
7
168 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2.1.12. Logigrama
i0 O O0
i1
i2 & O
i3
i4
i5
i6 &
i7
i8
i9
i10
exemple\logigramme\sample14.agn
Este ejemplo desarrollado en logigramas muestra la utilización de los diferentes
bloques: el bloque de asignación asociado a la tecla [0] a la izquierda del rectángulo
de acción, el bloque « no » asociado a la tecla [1] que complementa una señal, los
bloques de anclaje de tests y las funciones « Y » y « O ».
AUTOMGEN
7
169 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2.1.13. Grafcet y Logigrama
0
Ç
bp inicio de ciclo
1
fin de ciclo
bp manual
MOTOR
etapa 1 &
seguridad 1 O
seguridad 2 O
exemple\logigramme\exempl15.agn
En este ejemplo se utilizan conjuntamente un Grafcet y un Logigrama. El símbolo
« _etapa 1_ » utilizado en el logigrama está asociado a la variable « x1 ».
Este tipo de programación presenta claramente las condiciones de activación de una
salida.
AUTOMGEN
7
170 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2.1.14. Caja de lenguaje literal
0 SO0
1
m200=[0] ; m200 se utiliza como índice
res _flag una entrada esta en 1_
WHILE( _flag una entrada esta en 1_.m200<100)
IF(i(200))
THEN
set _flag una entrada esta en 1_
ENDIF
inc m200
ENDWHILE
flag una entrada esta en 1 flag una entrada esta en 1
2RO0
exemple\lit\sample16.agn
Este programa que asocia Grafcet con caja de lenguaje literal tiene por objeto
testear las entradas i0 a i99. Si una de estas entradas está en uno, la etapa 2 está
activada y el Grafcet se encuentra en un estado que impide cualquier evolución. El
símbolo « _flag una entrada está en uno_ » está asociado al bit u500. Se ha utilizado
un direccionamiento indexado para explorar las 100 entradas. Notemos también el
empleo simultáneo del lenguaje literal bajo nivel y extendido.
AUTOMGEN
7
171 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2.1.15. Organigrama
IF(_bp validación_)
bta _entrada rueda código_ ; fin
ana %0000000000000111
sta _valor rueda código_
exemple\organigramme\sample18.agn
Este ejemplo ilustra la utilización de un organigrama para efectuar un tratamiento
algorítmico y numérico. Tres entradas provenientes de una rueda de código son
leídas y almacenadas en una palabra si una entrada de validación está activa.
AUTOMGEN
7
172 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2.1.16. Organigrama
m200=[10]
o(200)=(1)
m200=[m200+1]
IF(m200=30)
; Fin del
; bucle
exemple\organigramme\sample19.agn
Este segundo ejemplo de organigrama realiza una estructura de bucle que permite
forzar a uno una serie de salidas (o10 a o29) con un direccionamiento indirecto
(« o(200) »).
AUTOMGEN
7
173 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2.1.17. Bloque funcional
i16
i17
CALCULO
i0 PUESTAen0
i1 CALCULO
VAL. INIC
{100}
LIMITE MAX
{110}
VARIABLE
{m200}
RO0
&SO0
exemple\bf\sample20.agn
; Gestión de la entrada de RAZ
IF({I0})
THEN
{?2}=[{?0}]
ENDIF
; Gestión de la entrada de cálculo
IF(#{I1})
THEN
{?2}=[{?2}+1]
ENDIF
; Testea el límite máx
IF({?2}={?1})
THEN
{O0}=(1)
{?2}=[{?0}]
ENDIF
ELSE
{O0}=(0)
ENDIF
comptage.lib (incluido en los recursos del proyecto)
AUTOMGEN
7
174 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Este ejemplo ilustra la utilización de un bloque funcional. Las funciones del bloque
« COMPTAGE » que hemos definido son las siguientes:
Ö el cálculo se hará partiendo de un valor de inicio y se terminará en un valor
límite máximo,
Ö cuando la variable de cálculo alcance el límite máximo será forzada al valor
de inicio y la salida del bloque pasará a uno durante un ciclo de programa,
Ö el bloque poseerá una entrada booleana de RAZ y una entrada de cálculo
en el frente ascendente.
2.1.18. Bloque funcional
i0
i1
i2
i3
i4
OU_EXCLU OU_EXCLU
=1 =1
OU_EXCLU
=1
OU_EXCLU OU_EXCLU
O0
=1 =1
i5
exemple\bf\sample21.agn
; O exclusivo
neq {o0} orr /{i0} eor {i1} orr {i0} eor /{i1}
ou_exclu.lib (incluido en los recursos del proyecto)
Este segundo ejemplo de bloque funcional ilustra la utilización múltiple de un mismo
bloque. El bloque « OU_EXCLU » realiza un O exclusivo entre las dos entradas
booleanas. Este ejemplo utiliza 5 bloques para realizar un O exclusivo entre 6
entradas (i0 a i5). El archivo « OU_EXCLU.LIB » indicado abajo rige el
AUTOMGEN
7
175 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
funcionamiento del bloque. La ecuación booleana del O exclusivo es la siguiente:
« (i0./i1)+(/i0.i1) ». La forma equivalente utilizada aquí permite codificar la ecuación
en una sola línea de lenguaje literal bajo nivel sin utilizar variables intermedias.
2.1.19. Ladder
i0 i7 O0
i1 i8
i2 i9
i3 i10 O1
i4 i11 O2
i5 i12 O3
i6 i13 O4
exemple\laddersample22.agn
Este ejemplo ilustra la utilización de la programación en ladder.
AUTOMGEN
7
176 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
2.1.20. Ejemplo desarrollado sobre una maqueta de tren
AUTOMGEN
7
177 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
AUTOMGEN
7
178 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
AUTOMGEN
7
179 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
AUTOMGEN
7
180 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
AUTOMGEN
7
181 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
AUTOMGEN
7
182 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Las aventuras del Doctor R.
Manual pedagógico del usuario de AUTOMGEN
AUTOMGEN
7
183 (C)opyright 2002 IRAI
La página se está cargando ...
Manual de referencia del lenguaje
AUTOMGEN
7
185 (C)opyright 2002 IRAI
Distribución
Doctor R. ………………………………………………… Señor R.
El Doctor R. en el reino de la domótica
"Es así de delicado, todo el
mundo sabe que yo no soy
doctor en realidad."
Vamos a abordar diferentes ejemplos aplicables directamente en un proyecto de
domótica. Con un primer enfoque simple, estos ejemplos nos permitirán asimilar
diferentes aspectos de la base de los automatismos y del aprendizaje de
AUTOMGEN e IRIS.
"No hay nada que hacer. No puede
hablar como todo el mundo la
gente de IRAI."
Manual de referencia del lenguaje
Este símbolo evocará una parte comando (un autómata programable por
ejemplo).
¿Hay necesidad de precisar que esto
evocará una bombilla,
un botón pulsador
y un interruptor?
Primer ejemplo: « quién fue el primero, el interruptor
o la bombilla … »
Un simple interruptor y una simple bombilla: el interruptor está cableado en la
entrada i0, la bombilla en la salida o0. Si el interruptor se cierra, la bombilla se
enciende; si el interruptor se abre, la bombilla se apaga. Más simple, imposible.
"¡Romperse tanto la cabeza para
encender una bombilla! ¡Pero qué
mente retorcida!"
AUTOMGEN
7
186 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución 1: el lenguaje natural del electricista: ladder
Ladder es la transcripción más directa del esquema eléctrico. El contacto recibe el
nombre de la entrada donde está cableado el interruptor, la bobina el nombre de
la salida donde está cableada la bombilla.
Solución 2: el lenguaje secuencial del automatista: Grafcet
La bobina
El contacto
Un
rectángulo de
ió
Una etapa
Une transition
Otra transición
0
i0
1 O0
/i0
Otra etapa
Grafcet se basa en la noción de estado. Para nuestro problema podemos decir
que hay dos estados: el estado encendido y el estado apagado. Cada etapa
representa un estado: aquí la etapa 0 representa el estado apagado y la etapa 1
el estado encendido. Queda por determinar la condición que hace evolucionar del
AUTOMGEN
7
187 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
estado apagado al estado encendido: interruptor cerrado (indicado i0), y luego la
condición que hace pasar del estado encendido al estado apagado: interruptor
abierto (indicado / i0). Las condiciones están escritas a la derecha del elemento
indicado como transición. El rectángulo asociado a la etapa 1 llamado rectángulo
de acción contiene el nombre de la salida O0 (salida donde está cableada nuestra
bombilla). Así, en todo momento, el estado de la bombilla es el mismo que el de la
etapa 1.
¡Iupi! Corro a comprar un autómata
programable en el almacén de la
esquina. Vi llegar un envío fresco de
AUTOMGEN.
AUTOMGEN
7
188 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Los afortunados posesores de IRIS pueden utilizar dos objetos BPVOYANT para
simular este primer ejemplo.
"No pueden no hacer
promoción."
AUTOMGEN
7
189 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
A jugar …
El interruptor 1 enciende la bombilla 1, el interruptor 2 la bombilla 2. Al final de
este documento se propone una solución Grafcet.
"Me pregunto si es dos veces más
complicado o dos veces menos
simple que el primer ejemplo."
Segundo ejemplo: « temporizaciones, minuteros y
otras diversiones temporales… »
"A propósito, son las
menos diez."
AUTOMGEN
7
190 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Como ustedes se imaginan, la noción de temporización se utiliza cuando un
programa debe, de una manera u otra, efectuar acciones teniendo en cuenta un
dato relativo al tiempo. Esperar cierto tiempo antes de llevar a cabo una acción, o
bien llevar a cabo una acción durante cierto tiempo, por ejemplo.
Nuestro segundo ejemplo es el siguiente: un pasillo está equipado con una
bombilla y dos botones pulsadores. Al presionar uno de los dos botones, la
bombilla se enciende 2 minutos (según el Dr. R. ese plazo es más que suficiente
para cruzar el pasillo).
Solución 1: la simplicidad
0
i0+i1
1 O0
t0/x1/120s
Encender la bombilla si se
presiona el botón pulsador 1 o si
se presiona el botón pulsador 2.
"O" se escribe "+" en una
transición.
Esperar 2 minutos (120 segundos) utilizando la
temporización 0, es la etapa 1 la que lanza la
temporización.
AUTOMGEN
7
191 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Solución 2: mejora
La desventaja de esta solución es que si el botón pulsador se presiona mientras la
bombilla está encendida, la temporización no se restablece. La semana pasada,
el Dr. R. creyó haber restablecido el minutero y de buenas a primeras se encontró
en la oscuridad.
t0/x1/120s
↑
(i0+i1)
2
=1
0
↑
(i0+i1)
1 O0
Y si nos lanzamos a escribir un programa de verdad …
AUTOMGEN
7
192 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Una gestión inteligente de la iluminación del pasillo: se ha
colocado una bombilla en cada extremo. Cuando se presiona un
interruptor, las dos bombillas se encienden; la bombilla del lado
del interruptor presionado se apaga al cabo de 30 segundos, y la
otra al cabo de un minuto.
Tercer ejemplo: « variación sobre el tema del
conmutador… »
Recordemos el genial principio del conmutador: dos interruptores permiten
encender o apagar la misma bombilla.
AUTOMGEN
7
193 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
He aquí una solución en logigrama:
Los puristas habrán reconocido la ecuación booleana del O exclusivo.
Las cosas se ponen realmente interesantes si deseamos conservar las
propiedades del conmutador con un número de interruptores mayor que 2.
O &
i0 O & O0
i1
AUTOMGEN
7
194 (C)opyright 2002 IRAI
La página se está cargando ...
Manual de referencia del lenguaje
Otra más astuta:
0
↑ ↓
i0+
↑
i0+
↓
i1+
↑
i1+
↓
i2+
↑
i2+
↓
i3+ i3
1 IO0
=1
« IO0 » significa « invertir el estado de la salida 0 ».
Prueben esto:
Un amplio cuarto con 6 interruptores y 10 bombillas. Cada
interruptor permite iluminar más o menos el cuarto (pasando del
estado en que todo está encendido al estado en que se enciende una
bombilla, luego dos, etc...).
AUTOMGEN
7
196 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
Cuarto ejemplo: « Y el botón pulsador se vuelve
inteligente … »
En todos los ejemplos anteriores, los botones pulsadores realizan una sola
función. Es decir, la persona que los maneja tiene sólo dos opciones: presionar o
no presionar para obtener una función (encender o apagar). Imaginemos un botón
pulsador « más rendidor » capaz de recibir dos tipos de presión: una presión corta
(arbitrariamente menos de 1 segundo) o una presión larga (arbitrariamente 1
segundo o más).
"En cinco minutos quieren
hacernos creer que inventaron
el Morse."
Para este ejemplo, cuatro botones pulsadores y cuatro bombillas. En forma
predeterminada, con el uso normal, cada uno de los botones pulsadores está
asociado a una bombilla. Una presión corta enciende o apaga la bombilla
asociada. Cada botón pulsador debe permitir pilotear cada bombilla o la totalidad
de las bombillas. La tabla siguiente resume el funcionamiento.
Acción sobre los botones pulsadores Resultado
Una presión corta La bombilla asociada cambia de estado
Una presión larga y una presión corta La bombilla número 1 cambia de estado
Una presión larga y dos presiones cortas La bombilla número 2 cambia de estado
Una presión larga y tres presiones cortas La bombilla número 3 cambia de estado
Una presión larga y cuatro presiones cortas La bombilla número 4 cambia de estado
Dos presiones largas y una presión corta Todas las bombillas se apagan
Dos presiones largas y dos presiones cortas Todas las bombillas se encienden
AUTOMGEN
7
197 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
AUTOMGEN
7
198 (C)opyright 2002 IRAI
La página se está cargando ...
Manual de referencia del lenguaje
Con esto concluye este manual pedagógico. Esperamos les haya
permitido descubrir las posibilidades de AUTOMGEN.
Proponemos un último ejercicio.
Automatizar el apartamento de la tía Hortensia respetando su gusto desmedido
por los interruptores niquelados.
"¡Era hora de que esta nota
llegara a su fin!"
AUTOMGEN
7
200 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
0 2
i0 i1
1 O0 3 O1
/i0 /i1
0
↑
i0
↑
i1
10 O0,O1 50 O0,O1
t0/x10/30s t2/x50/30s
30 O1 70 O0
t1/x30/30s t3/x70/30s
Las soluciones …
« quién fue el primero, el interruptor o la bombilla … »
Como siempre,
se necesita
una lupa para
leer las
soluciones.
Es suficiente escribir dos Grafcets idénticos. Cada uno se ocupa
independientemente de un interruptor y de una bombilla.
« temporizaciones, minuteros y otras diversiones
temporales… »
Una versión simple sin la gestión del restablecimiento del minutero.
AUTOMGEN
7
201 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
El restablecimiento del minutero hace que el programa sea muy complejo.
↑
i1
↑
i1
↑
i0 t1/x30/30s t3/x70/30s
↑
i1
↑
i0
40 80
=1 =1
0
↑
i0
↑
i1
10 O0,O1 50 O0,O1
t0/x10/30s t2/x50/30s
30 O1 70 O0
t1/x30/30s t3/x70/30s
↑
i0 x10 RT0
x30 F0:{10}
x50
x70
↑
i1 x50 RT2
x10 F0:{50}
x30
x70
↑
i0 t0/x10/30s t2/x50/30s
↑
i1
↑
i0
20 30 O1 70 O0 60
=1 =1
0
↑
i0
↑
i1
10 O0,O1 50 O0,O1
Una tercera solución con Grafcet, lenguaje ladder y forzados de Grafcet. El
programa permanece legible.
AUTOMGEN
7
202 (C)opyright 2002 IRAI
Manual de referencia del lenguaje
« variación sobre el tema del conmutador …»
0 {BTA I0,ANA %11111,STA M200}
m200<>m201
1 {LDA M200,STA M201} SO0
=1 o4
SO5
o9
RO0,RO1,RO2,RO3,RO4,RO5,RO6,RO7,RO8,RO9
o0 o1 o2 o3
SO1 SO2 SO3 SO4
o5 o6 o7 o8
SO6 SO7 SO8 SO9
AUTOMGEN
7
203 (C)opyright 2002 IRAI
Transcripción de documentos
Manual de referencia del lenguaje Ejemplos Las aventuras de Docteur R. www.irai.com Manual de referencia del lenguaje 1. Elementos comunes............................................................................................................... 7 1.1. Variables ..................................................................................................................................... 7 1.1.1. Variables booleanas............................................................................................................................. 7 1.1.2. Variables numéricas ............................................................................................................................ 8 1.1.3. Temporizaciones.................................................................................................................................. 8 1.2. Acciones .................................................................................................................................... 10 1.2.1. Asignación de una variable booleana ................................................................................................ 10 Asignación complementada de una variable booleana ................................................................................ 11 1.2.2. Puesta en uno de una variable booleana ............................................................................................ 12 1.2.3. Puesta en cero de una variable booleana ........................................................................................... 13 1.2.4. Inversión de una variable booleana ................................................................................................... 13 1.2.5. Puesta en cero de un contador, una palabra o un largo ...................................................................... 14 1.2.6. Incremento de un contador, una palabra o un largo........................................................................... 15 1.2.7. Decremento de un contador, una palabra o un largo.......................................................................... 15 1.2.8. Temporizaciones................................................................................................................................ 16 1.2.9. Interferencias entre las acciones ........................................................................................................ 17 1.2.10. Acciones de la norma CEI 1131-3................................................................................................... 17 1.2.11. Acciones múltiples .......................................................................................................................... 18 1.2.12. Código literal ................................................................................................................................... 19 1.3. Tests........................................................................................................................................... 19 1.3.1. Forma general.................................................................................................................................... 20 1.3.2. Modificador de test............................................................................................................................ 20 1.3.3. Temporizaciones................................................................................................................................ 21 1.3.4. Prioridad de los operadores booleanos .............................................................................................. 21 1.3.5. Test siempre verdadero...................................................................................................................... 22 1.3.6. Test sobre variable numérica ....................................................................................................................... 22 1.3.7. Transiciones en varias líneas ............................................................................................................. 23 1.4. Utilización de símbolos..................................................................................................................... 23 1.4.1. Sintaxis de los símbolos .................................................................................................................... 23 1.4.2. Símbolos automáticos........................................................................................................................ 24 1.4.3. Sintaxis de los símbolos automáticos ................................................................................................ 24 1.4.4. ¿Cómo gestiona el compilador los símbolos automáticos? ............................................................... 24 1.4.5. Zona de atribución de las variables ................................................................................................... 25 1.5. A propósito de ejemplos .......................................................................................................... 26 1.6. Grafcet ...................................................................................................................................... 28 1.6.1. Grafcet simple ................................................................................................................................... 28 1.6.2. Divergencia y convergencia en « Y »................................................................................................ 31 1.6.3. Divergencia y convergencia en « O »................................................................................................ 33 1.6.4. Etapas pozos y fuentes, transiciones pozos y fuentes ........................................................................ 36 AUTOMGEN7 3 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.6.5. Acciones múltiples, acciones condicionadas ..................................................................................... 36 1.6.6. Sincronización ................................................................................................................................... 38 1.6.7. Forzados de Grafcet........................................................................................................................... 39 1.6.8. Macro-etapas ..................................................................................................................................... 48 1.6.9. Contadores......................................................................................................................................... 51 1.7. Gemma ...................................................................................................................................... 52 1.7.1. Creación de un Gemma ..................................................................................................................... 54 1.7.2. Contenido de los rectángulos del Gemma ......................................................................................... 54 1.7.3. Obtener un Grafcet correspondiente .................................................................................................. 54 1.7.4. Anular los espacios vacíos en el Grafcet ........................................................................................... 55 1.7.5. Imprimir el Gemma ........................................................................................................................... 55 1.7.6. Exportar el Gemma............................................................................................................................ 55 1.7.7. Ejemplo de Gemma ........................................................................................................................... 55 1.8. Ladder....................................................................................................................................... 58 1.8.1. Ejemplo de Ladder............................................................................................................................. 59 1.9. Logigrama................................................................................................................................. 60 1.9.1. Diseño de los logigramas................................................................................................................... 61 1.9.2. Ejemplo de logigrama........................................................................................................................ 62 1.10. Lenguajes literales.................................................................................................................. 65 1.10.1. Cómo utilizar el lenguaje literal ...................................................................................................... 65 1.10.2. Definición de una caja de código..................................................................................................... 66 1.10.3. El lenguaje literal bajo nivel ............................................................................................................ 67 1.10.4. Macro-instrucción.......................................................................................................................... 120 1.10.5. Biblioteca....................................................................................................................................... 121 1.10.6. Macro-instrucciones predefinidas.................................................................................................. 121 1.10.7. Descripción de las macro-instrucciones predefinidas.................................................................... 121 1.10.8. Ejemplo en lenguaje literal bajo nivel ........................................................................................... 123 1.11. Lenguaje literal extendido................................................................................................... 126 1.11.1. Escritura de ecuaciones booleanas................................................................................................. 127 1.11.2. Escritura de ecuaciones numéricas ................................................................................................ 128 1.11.3. Estructura de tipo IF ... THEN ... ELSE ... .................................................................................... 130 1.11.4. Estructura de tipo WHILE ... ENDWHILE ................................................................................... 130 1.11.5. Ejemplo de programa en lenguaje literal extendido....................................................................... 131 1.12. Lenguaje literal ST............................................................................................................... 132 1.12.1. Generalidades ................................................................................................................................ 132 1.12.2. Ecuaciones booleanas .................................................................................................................... 133 1.12.3. Ecuaciones numéricas.................................................................................................................... 134 1.12.4. Estructuras de programación ......................................................................................................... 135 1.12.5. Ejemplo de programa en lenguaje literal extendido....................................................................... 137 AUTOMGEN7 4 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.13. Organigrama ........................................................................................................................ 137 1.13.1. Diseño de un organigrama ............................................................................................................. 138 1.13.2. Contenido de los rectángulos......................................................................................................... 139 1.14. Ilustración............................................................................................................................. 139 1.15. Bloques funcionales.............................................................................................................. 142 1.15.1. Creación de un bloque funcional ................................................................................................... 142 1.15.2. Diseño del bloque y creación del archivo « .ZON »...................................................................... 143 1.15.3. Creación del archivo « .LIB »........................................................................................................ 145 1.15.4. Ejemplo simple de bloque funcional ............................................................................................. 145 1.15.5. Ilustración ...................................................................................................................................... 146 1.15.6. Complemento de sintaxis............................................................................................................... 149 1.16. Bloques funcionales evolucionados..................................................................................... 150 1.16.1. Sintaxis .......................................................................................................................................... 150 1.16.2. Diferenciar viejos y nuevos bloques funcionales........................................................................... 150 1.16.3. Ejemplo.......................................................................................................................................... 151 1.17. Bloques funcionales predefinidos ....................................................................................... 152 1.17.1. Bloques de conversión................................................................................................................... 152 1.17.2. Bloques de temporización.............................................................................................................. 153 1.17.3. Bloques de manipulación de cadena de caracteres ........................................................................ 153 1.17.4. Bloques de manipulación de tabla de palabras .............................................................................. 153 1.18. Técnicas avanzadas .............................................................................................................. 153 1.18.1. Código generado por el compilador............................................................................................... 153 1.18.2. Optimización del código generado ................................................................................................ 154 2. Ejemplos............................................................................................................................. 157 2.1. A propósito de ejemplos ........................................................................................................ 157 2.1.1. Grafcet simple ................................................................................................................................. 157 2.1.2. Grafcet con diagrama en O .............................................................................................................. 158 2.1.3. Grafcet con divergencia en Y .......................................................................................................... 159 2.1.4. Grafcet y sincronización .................................................................................................................. 160 2.1.5. Forzado de etapas ............................................................................................................................ 161 2.1.6. Etapas pozos y fuentes..................................................................................................................... 162 2.1.7. Etapas pozos y fuentes..................................................................................................................... 163 2.1.8. Forzado de Grafcets......................................................................................................................... 164 2.1.9. Memorización de Grafcets............................................................................................................... 165 2.1.10. Grafcet y macro-etapas .................................................................................................................. 166 2.1.11. Folios en cadena ............................................................................................................................ 167 2.1.12. Logigrama...................................................................................................................................... 169 2.1.13. Grafcet y Logigrama...................................................................................................................... 170 2.1.14. Caja de lenguaje literal .................................................................................................................. 171 AUTOMGEN7 5 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2.1.15. Organigrama .................................................................................................................................. 172 2.1.16. Organigrama .................................................................................................................................. 173 2.1.17. Bloque funcional............................................................................................................................ 174 2.1.18. Bloque funcional............................................................................................................................ 175 2.1.19. Ladder............................................................................................................................................ 176 2.1.20. Ejemplo desarrollado sobre una maqueta de tren .......................................................................... 177 Manual pedagógico del usuario de AUTOMGEN............................................................... 183 Distribución ................................................................................................................................... 185 El Doctor R. en el reino de la domótica....................................................................................... 185 Primer ejemplo: « quién fue el primero, el interruptor o la bombilla … » ............................. 186 Solución 1: el lenguaje natural del electricista: ladder .............................................................................. 187 Solución 2: el lenguaje secuencial del automatista: Grafcet...................................................................... 187 A jugar … ...................................................................................................................................... 190 Segundo ejemplo: « temporizaciones, minuteros y otras diversiones temporales… »............ 190 Solución 1: la simplicidad ......................................................................................................................... 191 Solución 2: mejora..................................................................................................................................... 192 Tercer ejemplo: « variación sobre el tema del conmutador… »............................................... 193 He aquí una solución en logigrama: .......................................................................................................... 194 Una solución que utiliza el lenguaje literal de AUTOMGEN. .................................................................. 195 Otra más astuta: ......................................................................................................................................... 196 Prueben esto: ............................................................................................................................................. 196 Cuarto ejemplo: « Y el botón pulsador se vuelve inteligente … » ............................................ 197 Las soluciones … ........................................................................................................................... 200 Las soluciones … ........................................................................................................................... 201 « quién fue el primero, el interruptor o la bombilla … »........................................................................... 201 « temporizaciones, minuteros y otras diversiones temporales… »............................................................ 201 « variación sobre el tema del conmutador …» ........................................................................... 203 AUTOMGEN7 6 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1. Elementos comunes Este capítulo detalla los elementos comunes a todos los lenguajes utilizables en AUTOMGEN. El logo identifica las novedades utilizables en la versión 7 de AUTOMGEN. 1.1. Variables Existen los siguientes tipos de variables: Ö tipo booleano: la variable puede adoptar el valor verdadero (1) o falso (0). Ö tipo numérico: la variable puede adoptar un valor numérico; existen diferentes subtipos: variables 16 bits, 32 bits y coma flotante. Ö tipo temporización: tipo estructurado; es una combinación del booleano y el numérico. A partir de la versión 6 la sintaxis de los nombres de variables puede ser la de AUTOMGEN o la de la norma CEI 1131-3. 1.1.1. Variables booleanas La tabla siguiente ofrece la lista exhaustiva de variables booleanas utilizables. Tipo Sintaxis Sintaxis Comentario AUTOMGEN CEI 1131-3 Entradas I0 %I0 Puede corresponder o no a entradas físicas a I9999 a %I9999 (depende de la configuración de las E/S del destino). Salidas O0 %Q0 Puede corresponder o no a entradas físicas a O9999 a %Q9999 (depende de la configuración de las E/S del destino). Bits Sistema U0 Bits Usuario AUTOMGEN7 %M0 Ver el manual sobre el entorno para el detalle a U99 a %M99 de los bis Sistema. U100 %M100 Bits internos de uso general. a U9999 a %M9999 7 (C)opyright 2002 IRAI Manual de referencia del lenguaje Etapas X0 %X0 Bits de etapas Grafcet. Grafcet a X9999 a %X9999 Bits de M0#0 %MW0:X0 Bits de palabras: el número del bit se palabras a M9999#15 a %MW9999:X15 expresa en decimal y está comprendido entre 0 (bit de peso débil) y 15 (bit de peso fuerte). 1.1.2. Variables numéricas La tabla siguiente ofrece la lista exhaustiva de variables numéricas. Tipo Sintaxis Sintaxis AUTOMGEN CEI 1131-3 Contadores C0 a C9999 Comentario %C0 Contador a %C9999 inicializarse, de 16 bits; puede incrementarse, decrementarse y testearse con los lenguajes booleanos sin utilizar el lenguaje literal. Palabras M0 %MW0 Ver el manual sobre el entorno para el Sistema a M199 a %MW199 detalle de las palabras Sistema. Palabras M200 %MW200 Palabra de 16 bits de uso general. Usuario a M9999 a %MW9999 Largos L100 %MD100 a L4998 a %MD4998 F100 %MF100 Valor real sobre 32 bits (formato a F4998 a %MF4998 IEEE). Flotantes Valor entero sobre 32 bits. 1.1.3. Temporizaciones La temporización es un tipo compuesto que agrupa dos variables booleanas (estado de lanzamiento, estado de fin) y dos variables numéricas sobre 32 bits (la consigna y el contador). AUTOMGEN7 8 (C)opyright 2002 IRAI Manual de referencia del lenguaje El esquema siguiente muestra el cronograma de funcionamiento de una temporización: 1 état de lancement 0 1 état de fin 0 consigne valeur de comptage 0 El valor de consigna de una temporización está comprendido entre 0 ms y 4294967295 ms (vale decir, poco más de 49 días) La consigna de la temporización puede modificarse por programa; ver el capítulo 1.10.3. El lenguaje literal bajo nivel (instrucción STA). El contador de la temporización puede leerse por programa; ver el capítulo 1.10.3. El lenguaje literal bajo nivel (instrucción LDA). AUTOMGEN7 9 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.2. Acciones Las acciones se utilizan en: Ö los rectángulos de acción del lenguaje Grafcet, Action Ö los rectángulos de acción del lenguaje logigrama, Action Ö las bobinas del lenguaje ladder. Action 1.2.1. Asignación de una variable booleana La sintaxis de la acción « Asignación » es: «variable booleana» Funcionamiento: Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero, la variable se pone en 1 (estado verdadero), Ö si el comando del rectángulo de acción o de la bobina está en estado falso, la variable se pone en 0 (estado falso). Tabla de verdad: Comando Estado de la variable (resultado) 0 0 1 1 Ejemplo: Si la etapa 10 está activa, O0 adopta el valor 1; si no, O0 adopta el valor 0. AUTOMGEN7 10 (C)opyright 2002 IRAI Manual de referencia del lenguaje Es posible utilizar varias acciones « Asignación » para una misma variable dentro de un programa. En este caso, los diferentes comandos se combinan en « O » lógico. Ejemplo: Estado de X10 Estado de X50 Estado de O5 0 0 0 1 0 1 0 1 1 1 1 1 Asignación complementada de una variable booleana La sintaxis de la acción « Asignación complementada » es: «N variable booleana» Funcionamiento: Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero, la variable se pone en 0 (estado falso), Ö si el comando del rectángulo de acción o de la bobina está en estado falso, la variable se pone en 1 (estado verdadero). Tabla de verdad: Comando Estado de la variable (resultado) 0 1 1 0 Ejemplo: Si la etapa 20 está activa, U100 adopta el valor 0; si no, U100 adopta el valor 1. AUTOMGEN7 11 (C)opyright 2002 IRAI Manual de referencia del lenguaje Es posible utilizar varias acciones « Asignación complementada» para una misma variable dentro de un programa. En este caso, los diferentes comandos se combinan en « O » lógico. Ejemplo: Estado de X100 Estado de X110 Estado de O20 0 0 1 1 0 0 0 1 0 1 1 0 1.2.2. Puesta en uno de una variable booleana La sintaxis de la acción « Puesta en uno » es: «S variable booleana» Funcionamiento: Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero, la variable se pone en 1 (estado verdadero), Ö si el comando del rectángulo de acción o de la bobina está en estado falso, el estado de la variable no se modifica. Tabla de verdad: Comando Estado de la variable (resultado) 0 no cambia 1 1 Ejemplo: Si la etapa 5000 está activa, O2 adopta el valor 1; si no, O2 conserva su estado. AUTOMGEN7 12 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.2.3. Puesta en cero de una variable booleana La sintaxis de la acción « Puesta en cero » es: «R variable booleana» Funcionamiento: Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero, la variable se pone en 0 (estado falso), Ö si el comando del rectángulo de acción o de la bobina está en estado falso, el estado de la variable no se modifica. Tabla de verdad: Comando Estado de la variable (resultado) 0 no cambia 1 0 Ejemplo: Si la etapa 6000 está activa, O3 adopta el valor 0; si no, O3 conserva su estado. 1.2.4. Inversión de una variable booleana La sintaxis de la acción « Inversión » es: «I variable booleana» Funcionamiento: Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero, el estado de la variable se invierte a cada ciclo de ejecución, Ö si el comando del rectángulo de acción o de la bobina está en estado falso, el estado de la variable no se modifica. AUTOMGEN7 13 (C)opyright 2002 IRAI Manual de referencia del lenguaje Tabla de verdad: Comando Estado de la variable (resultado) 0 no cambia 1 invertido Ejemplo: Si la etapa 7000 está activa, el estado de O4 se invierte; si no, O4 conserva su estado. 1.2.5. Puesta en cero de un contador, una palabra o un largo La sintaxis de la acción « Puesta en cero de un contador, una palabra o un largo» es: «R contador o palabra» Funcionamiento: Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero, el contador, la palabra o el largo se pone en cero, Ö si el comando del rectángulo de acción o de la bobina está en estado falso, el valor del contador, de la palabra o del largo no se modifica. Tabla de verdad: Comando Valor del contador, de la palabra o del largo (resultado) 0 No cambia 1 0 Ejemplo: Si la etapa 100 está activa, el contador 25 se pone en cero; si no, C25 conserva su valor. AUTOMGEN7 14 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.2.6. Incremento de un contador, una palabra o un largo La sintaxis de la acción « Incremento de un contador » es: «+ contador, palabra o largo» Funcionamiento: Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero, el contador, la palabra o el largo se incrementa a cada ciclo de ejecución, Ö si el comando del rectángulo de acción o de la bobina está en estado falso, el valor del contador no se modifica. Tabla de verdad: Comando Valor del contador, de la palabra o del largo (resultado) 0 No cambia 1 valor actual +1 Ejemplo: Si la etapa 100 está activa, el contador 25 se incrementa; si no, C25 conserva su valor. 1.2.7. Decremento de un contador, una palabra o un largo La sintaxis de la acción « Decremento de un contador » es: «- contador, palabra o largo» Funcionamiento: Ö si el comando del rectángulo de acción o de la bobina está en estado verdadero, el contador, la palabra o el largo se decrementa a cada ciclo de ejecución, Ö si el comando del rectángulo de acción o de la bobina está en estado falso, el valor del contador no se modifica. AUTOMGEN7 15 (C)opyright 2002 IRAI Manual de referencia del lenguaje Tabla de verdad: Comando Valor del contador, de la palabra o del largo (resultado) 0 no cambia 1 valor actual –1 Ejemplo: Si la etapa 100 está activa, el contador 25 se decrementa; si no, C25 conserva su valor. 1.2.8. Temporizaciones Las temporizaciones se consideran como variables booleanas y pueden utilizarse con las acciones « Asignación », « Asignación complementada », « Puesta en uno », « Puesta en cero » e « Inversión ». La consigna de la temporización puede escribirse a continuación de la acción. La sintaxis es: « temporización(duración) » La duración se expresa en forma predeterminada en décimas de segundo. El carácter « S » ubicado al final de la duración indica que se expresa en segundos. Ejemplos: La etapa 10 lanza una temporización de 2 segundos que permanecerá activa mientras la etapa permanezca activa. La etapa 20 arma una temporización de 6 segundos que permanecerá activa aunque la etapa 20 esté desactivada. Una misma temporización puede utilizarse en varios sitios con una misma consigna en momentos diferentes. En este caso, la consigna de la temporización debe indicarse una sola vez. Observación: existen otras sintaxis para las temporizaciones. Ver el capítulo 1.3.3. Temporizaciones AUTOMGEN7 16 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.2.9. Interferencias entre las acciones Ciertos tipos de acción no pueden utilizarse simultáneamente con una variable. La siguiente tabla resume las combinaciones posibles. Asignación Asignación complementada Puesta en uno Puesta en cero Inversión Asignación SÍ NO NO NO NO Asignación complementada NO SÍ NO NO NO Puesta en uno NO NO SÍ SÍ SÍ Puesta en cero NO NO SÍ SÍ SÍ Inversión NO NO SÍ SÍ SÍ 1.2.10. Acciones de la norma CEI 1131-3 La siguiente tabla ofrece la lista de acciones de la norma CEI 1131-3 utilizables en AUTOMGEN V>=6 con respecto a la sintaxis estándar de AUTOMGEN. V5. Nombre Sintaxis Sintaxis Ejemplo Ejemplo AUTOMGEN AUTOMGEN AUTOMGEN de equivalente V>=6 AUTOMGEN V5 V5 V>=6 No memorizado Ninguno Ninguno No memorizado N1 Ninguno No memorizado N0 N complementado Puesta en cero AUTOMGEN7 R R 17 (C)opyright 2002 IRAI Manual de referencia del lenguaje Puesta en 1 S S Limitado LTn/duración Inexistente en el tiempo Temporizado DTn/ Inexistente duración Impulsión sobre P1 Inexistente P0 Inexistente Memorizado SDTn/ Inexistente y temporizado duración Temporizado DSTn/ y memorizado duración Memorizado SLTn/ y limitado duración frente ascendente Impulsión sobre frente descendente Inexistente Inexistente en el tiempo 1.2.11. Acciones múltiples Dentro de un mismo rectángulo de acción o de una bobina, es posible escribir varias acciones separándolas con el carácter « , » (coma). Ejemplo: Es posible yuxtaponer varios rectángulos de acción (Grafcet y logigrama) o bobinas (ladder). Consultar los capítulos correspondientes a estos lenguajes para más detalles. AUTOMGEN7 18 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.2.12. Código literal En un rectángulo de acción o una bobina es posible insertar código literal. La sintaxis es: « { código literal } » Es posible escribir entre las llaves varias líneas de lenguaje literal. También aquí el separador es el carácter « , » (coma). Ejemplo: Consultar los capítulos « Lenguaje literal bajo nivel », « Lenguaje literal extendido » y « Lenguaje literal ST » para más detalles. 1.3. Tests Los tests se utilizan en: Ö transiciones del lenguaje Grafcet, Test Ö condiciones sobre acción del lenguaje Grafcet, Test Test Ö tests del lenguaje logigrama, Test AUTOMGEN7 19 (C)opyright 2002 IRAI Manual de referencia del lenguaje Ö tests del lenguaje ladder. Test 1.3.1. Forma general Un test es una ecuación booleana compuesta por una o por n variables separadas por los operadores « + » (o) o « . » (y). Ejemplo de test: i0 (test entrada 0) i0+i2 (test entrada 0 « o » entrada 2) i10.i11 (test entrada 10 « y » entrada 11) 1.3.2. Modificador de test Si se especifica sólo el nombre de una variable, el test predeterminado es « si igual a uno» (si verdadero). Es posible utilizar modificadores para testear el estado complementado, el frente ascendente y el frente descendente: Ö el carácter «/» ubicado delante de una variable testea el estado complementado, Ö el carácter « u » o el carácter « Ï* » ubicado delante de una variable testea el frente ascendente, Ö el carácter « d » o el carácter « Ð** » ubicado delante de una variable testea el frente descendiente. Los modificadores de tests pueden aplicarse a una variable o a una expresión entre paréntesis. Ejemplos: Ï i0 /i1 /(i2+i3) Ð(i2+(i4./i5)) * ** Para obtener este carácter durante la edición de un test presione la tecla [Ï]. Para obtener este carácter durante la edición de un test presione la tecla [Ð]. AUTOMGEN7 20 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.3.3. Temporizaciones Hay cuatro sintaxis disponibles para las temporizaciones. En la primera, se activa la temporización en la acción y se menciona simplemente la variable temporización en un test para verificar el estado de fin: En las otras, todo se escribe en el test. La forma general es: « temporización / variable de lanzamiento / duración » o « duración / variable de lanzamiento / temporización » o « duración / variable de lanzamiento » En este caso, se atribuye una temporización automáticamente. La zona de atribución es la de los símbolos automáticos; ver el capítulo 1.4.2. Símbolos automáticos. La duración se expresa en forma predeterminada en décimas de segundo. La duración puede expresarse en días, horas, minutos, segundos y milisegundos con los operadores « d », « h », « m », « s » y « ms ». Por ejemplo: 1d30s = 1 día y 30 segundos. Ejemplo con la segunda sintaxis: Ejemplo con la sintaxis normalizada: 1.3.4. Prioridad de los operadores booleanos El operador booleano « . » (Y) tiene una prioridad predeterminada mayor que el operador « + » (O). Es posible utilizar paréntesis para definir otra prioridad. AUTOMGEN7 21 (C)opyright 2002 IRAI Manual de referencia del lenguaje Ejemplos: i0.(i1+i2) ((i0+i1).i2)+i5 1.3.5. Test siempre verdadero La sintaxis del test siempre verdadero es: « » (ninguno) o « =1 » 1.3.6. Test sobre variable numérica Los tests sobre variable numérica deben utilizar la siguiente sintaxis: « variable numérica » « tipo de test » « constante o variable numérica » El tipo de test puede ser: Ö « = » igual, Ö « ! » o « <> » diferente, Ö « < » menor (sin signo), Ö « > » mayor (sin signo), Ö « << » menor (con signo), Ö « >> » mayor (con signo), Ö « <= » menor o igual (sin signo), Ö « >= » mayor o igual (sin signo), Ö « <<= » menor o igual (con signo), Ö « >>= » mayor o igual (con signo). Un flotante puede compararse sólo con otro flotante o con una constante real. Un largo puede compararse sólo con otro largo o con una constante larga. Una palabra o un contador puede compararse sólo con una palabra, un contador o una constante 16 bits. Las constantes reales deben estar seguidas del carácter « R ». Las constantes largas (32 bits) deben estar seguidas del carácter « L ». Les constantes enteras 16 o 32 bits están predeterminadas en decimal. Pueden escribirse en hexadecimal (sufijo « $ » o « 16# ») o en binario (sufijo « % » o « 2# »). AUTOMGEN7 22 (C)opyright 2002 IRAI Manual de referencia del lenguaje Los tests sobre variables numéricas se utilizan en las ecuaciones como los tests sobre variables booleanas. Pueden utilizarse con los modificadores de test siempre que estén encerrados por paréntesis. Ejemplos: m200=100 %mw1000=16#abcd c10>20.c10<100 f200=f201 m200=m203 %md100=%md102 f200=3.14r l200=$12345678L m200<<-100 m200>>1000 %mw500<=12 /(m200=4) Ð(m200=100) /(l200=100000+l200=-100000) 1.3.7. Transiciones en varias líneas El texto de las transiciones puede ocupar varias líneas. El fin de una línea de transición debe ser indefectiblemente un operador « . » o « + ». Las combinaciones de teclas [CTRL] + [Ð] y [CTRL] + [Ï] permiten desplazar el cursor de una línea a otra. 1.4. Utilización de símbolos Los símbolos permiten asociar un texto a una variable. Los símbolos pueden utilizarse con todos los lenguajes. Un símbolo debe asociarse a una y sólo una variable. 1.4.1. Sintaxis de los símbolos Los símbolos están compuestos por: Ö un carácter « _ » opcional (subrayado, generalmente asociado a la tecla [8] en los teclados) que marca el principio del símbolo, Ö el nombre del símbolo, Ö un carácter « _ » opcional (subrayado) que marca el fin del símbolo. AUTOMGEN7 23 (C)opyright 2002 IRAI Manual de referencia del lenguaje Los caracteres « _ » que encierran los nombres de los símbolos son opcionales. Deben utilizarse si el símbolo empieza con una cifra o un operador (+,-, etc…). 1.4.2. Símbolos automáticos A veces es incómodo tener que definir la atribución entre cada símbolo y una variable, especialmente si la atribución precisa de un número de variable tiene poca importancia. Los símbolos automáticos son una solución a este problema, ya que confían al compilador la tarea de generar automáticamente la atribución de un símbolo a un número de variable. El tipo de variable a utilizar está dado por el nombre del símbolo. 1.4.3. Sintaxis de los símbolos automáticos La sintaxis de los símbolos automáticos es la siguiente: _« nombre del símbolo » %« tipo de variable »_ El « tipo de variable » puede ser: I , O o Q, U o M, T, C, M o MW, L o MD, F o MF. Es posible reservar varias variables para un símbolo. Esto es útil para definir tablas. En este caso la sintaxis es: _« nombre del símbolo » %« tipo de variable »« longitud »_ La « longitud » representa el número de variables a reservar. 1.4.4. ¿Cómo gestiona el compilador los símbolos automáticos? Para compilar una aplicación, el compilador borra todos los símbolos automáticos que se encuentran en el archivo « .SYM » de la aplicación. Cada vez que encuentra un símbolo automático, crea una atribución única para ese símbolo en función del tipo de variable especificado en el nombre del símbolo. El símbolo generado se escribe en el archivo « .SYM ». Si un mismo símbolo automático aparece varias veces en una aplicación, hará referencia a la misma variable. AUTOMGEN7 24 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.4.5. Zona de atribución de las variables Cada tipo de variable tiene una zona de atribución predeterminada: Tipo Principio Fin I o %I 0 9999 O o %Q 0 9999 U o %M 100 9999 T o %T 0 9999 C o %C 0 9999 M o %MW 200 9999 L o %MD 100 4998 F o %MF 100 4998 La zona de atribución puede modificarse para cada tipo de variable utilizando la directiva de compilación #SR« tipo »=« principio », « fin » « tipo » designa el tipo de variable; « principio » y « fin », los nuevos límites a utilizar. Esta directiva modifica la atribución de las variables automáticas en cada sitio del folio donde está escrita hasta la siguiente directiva « #SR ». AUTOMGEN7 25 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.5. A propósito de ejemplos Para ilustrar mejor este manual, hemos desarrollado ejemplos que funcionan con una maqueta de tren cuyo esquema es el siguiente: S1I T1I 1 S6I T6I S1D T1D MAQUETA AT-850 S5D T5D vía 1 S6D T6D 5 4 S5I T5I S2A T2A vía 2 S2B T2B S4A T4A vía 6 vía 5 vía 7 vía 8 S7I T7I 2 S7D T7D S8I T8I vía 4 S4B T4B S8D T8D vía 3 S3I T3I S3D T3D Para pilotear esta maqueta hemos utilizado mapas de E/S en PC. Los símbolos definidos por el constructor de la maqueta se han conservado. AUTOMGEN7 26 (C)opyright 2002 IRAI 3 Manual de referencia del lenguaje Se ha creado el siguiente fichero de símbolos: AUTOMGEN7 27 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.6. Grafcet AUTOMGEN soporta los elementos siguientes: Ö divergencias y convergencias en « Y » y en « O », Ö etapas pozos y fuentes, Ö transiciones pozos y fuentes, Ö sincronización, Ö forzados de Grafcets, Ö memorización de Grafcets, Ö fijación, Ö macro-etapas. 1.6.1. Grafcet simple La escritura de Grafcet en línea se resume a la yuxtaposición de etapas y transiciones. Ilustremos un Grafcet en línea con el ejemplo siguiente: Condiciones: La locomotora debe partir por la vía 3 hacia la derecha, hasta el extremo de la vía. Luego regresa en sentido inverso hasta el otro extremo y vuelve a empezar. AUTOMGEN7 28 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución 1: 0 AV1 t1d 1 AV1 , DV1 t1i exemples\grafcet\simple1.agn Solución 2: 0 S AV1 ,R DV1 Aller t1d 1 S AV1 ,S DV1 Retour t1i exemple\grafcet\simple2.agn La diferencia entre estas dos soluciones reside en el uso de las acciones « Asignación » para el primer ejemplo y de las acciones « Puesta en uno » y « Puesta en cero » para el segundo. Modifiquemos las condiciones con una espera de 10 segundos cuando la locomotora llega a la derecha de la vía 1 y una espera de 4 segundos cuando la locomotora llega a la izquierda de la vía 1. AUTOMGEN7 29 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución 1: 0 AV1 Aller t1d 10 T0(10S) t0 20 AV1 , DV1 Retour t1i 30 T1(4S) t1 exemple\grafcet\simple3.agn Solución 2: 0 AV1 Aller t1d 10 10s/x10 20 AV1 , DV1 Retour t1i 30 4s/x30 exemple\grafcet\simple4.agn AUTOMGEN7 30 (C)opyright 2002 IRAI Manual de referencia del lenguaje La diferencia entre los ejemplos 3 y 4 reside en la elección de la sintaxis utilizada para definir las temporizaciones. El resultado desde el punto de vista funcional es idéntico. 1.6.2. Divergencia y convergencia en « Y » Las divergencias en« Y » pueden tener n ramas. Lo importante es respetar la utilización de los bloques de función: Obligatoirement un bloc [K] et pas un bloc [L] Obligatoirement un bloc [M] et pas un bloc [L] Obligatoirement un bloc [Q] et pas un bloc [P] Obligatoirement un bloc [O] et pas un bloc [P] Ilustremos la utilización de las divergencias y convergencias en « Y ». Condiciones: Vamos a utilizar dos locomotoras: la primera efectuará idas y vueltas por la vía 1, la segunda por la vía 3. Las dos locomotoras estarán sincronizadas (se esperarán en el extremo de la vía). AUTOMGEN7 31 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución 1: 40 =1 0 AV1 50 t1d AV3 t3i 10 60 =1 20 AV1 , DV1 70 t1i AV3 , DV3 t3d 30 80 =1 exemple\grafcet\divergence et 1.agn AUTOMGEN7 32 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución 2: t1d 0 t3i AV1 10 AV3 t1d . t3i t1i 20 t3d AV1 , DV1 30 AV3 , DV3 t1i . t3d exemple\grafcet\divergence et 2.agn Estas dos soluciones son equivalentes desde el punto de vista funcional. La segunda es una versión más compacta que utiliza acciones condicionadas. 1.6.3. Divergencia y convergencia en « O » Las divergencias en « O » pueden tener n ramas. Lo importante es respetar la utilización de los bloques de función: o AUTOMGEN7 33 (C)opyright 2002 IRAI Manual de referencia del lenguaje o Las divergencias en « O » deben ramificarse obligatoriamente en vínculos descendentes. Por ejemplo: incorrecto; el diseño correcto es: AUTOMGEN7 34 (C)opyright 2002 IRAI Manual de referencia del lenguaje Si el ancho de la página no permite escribir un gran número de divergencias, se puede adoptar una estructura del tipo: Veamos un ejemplo para ilustrar la utilización de las divergencias y convergencias en « O »: Condiciones: Retomemos las condiciones del primer ejemplo del capítulo: ida y vuelva de una locomotora por la vía 1. Solución: 0 AV1 Ç t1d 1 Ç t1i S DV1 2 =1 R DV1 =1 exemple\grafcet\divergence ou.agn AUTOMGEN7 35 (C)opyright 2002 IRAI Manual de referencia del lenguaje Este Grafcet podría resumirse en una etapa utilizando acciones condicionadas, como en este ejemplo: Ç t1d 0 AV1 S DV1 Ç t1i R DV1 exemple\grafcet\action conditionnée.agn 1.6.4. Etapas pozos y fuentes, transiciones pozos y fuentes Ilustremos estos principios con ejemplos: Condiciones: Tratemos de nuevo el segundo ejemplo de este capítulo: ida y vuelta de una locomotora por la vía 1 con espera al final de la vía. Solución: 0 S AV1 Ç t1d 10 Ç t1i R AV1 30 t0/x10/10s 20 S AV1 R AV1 t1/x30/4s S DV1 40 =1 S AV1 R DV1 =1 exemple\grafcet\étapes puits et sources.agn 1.6.5. Acciones múltiples, acciones condicionadas Ya hemos utilizado en este capítulo acciones múltiples y acciones condicionadas. Detallemos estos dos principios. AUTOMGEN7 36 (C)opyright 2002 IRAI Manual de referencia del lenguaje Como se indica en el capítulo sobre el compilador, es posible escribir varias acciones en un mismo rectángulo; en este caso, el carácter « , » (coma) sirve como delimitador. Cuando una condición se añade a un rectángulo de acción, se condiciona el conjunto de las acciones contenidas en el rectángulo. Es posible asociar varios rectángulos de acción a una etapa: Otra posibilidad: Cada rectángulo puede recibir una condición diferente: Para diseñar una acción condicionada, ubique el cursor en el rectángulo de acción, haga clic con el botón derecho del ratón y elija « Acción condicional » en el menú. Para documentar la condición sobre acción, haga clic en el elemento . La sintaxis IF(condición) permite escribir una condición sobre acción en el rectángulo de acción. AUTOMGEN7 37 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.6.6. Sincronización Retomemos un ejemplo ya tratado para ilustrar la sincronización de Grafcets. Condiciones: Ida y vuelta de dos locomotoras por las vías 1 y 3 con espera entre las locomotoras en el extremo de la vía. Este ejemplo se había tratado con una divergencia en « Y ». Solución 1: 10 AV1 100 t1d t3i 20 110 x110 30 AV3 x20 AV1 , DV1 120 t1i AV3 , DV3 t3d 40 130 x130 x40 exemple\grafcet\synchro1.agn AUTOMGEN7 38 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución 2: 10 SX100,SX140 =1 20 x110.x150 30 SX120,SX160 =1 40 x130.x170 100 AV1 120 t1d 110 AV1 , DV1 140 t1i 160 t3i 130 x30 AV3 150 x10 AV3 , DV3 t3d 170 x30 x10 exemple\grafcet\synchro2.agn Esta segunda solución es un excelente ejemplo del arte de complicar las cosas más simples con fines pedagógicos. 1.6.7. Forzados de Grafcet El compilador agrupa las etapas en función de los vínculos establecidos entre ellas. Para designar un Grafcet, es suficiente hacer referencia a una de las etapas que componen ese Grafcet. Del mismo modo se puede designar el conjunto de Grafcets presentes en un folio mencionando el nombre del folio. AUTOMGEN7 39 (C)opyright 2002 IRAI Manual de referencia del lenguaje Por ejemplo: Para designar este Grafcet hablaremos de Grafcet 200, Grafcet 201 o Grafcet 202. Al ser un conjunto de etapas, el Grafcet se convierte en una variable estructurada compuesta por n etapas; cada etapa puede estar activa o inactiva. Como hemos visto, AUTOMGEN divide las etapas en conjuntos independientes que pueden agruparse, lo cual permite considerarlos como un solo Grafcet. Para agrupar varios Grafcets se debe utilizar la directiva de compilación « #G:g1,g2 » (comando a incluir en un comentario). Este comando agrupa los Grafcets g1 y g2. Recordemos que la designación de un Grafcet se efectúa invocando el número de una de sus etapas. Veamos un ejemplo: #G:105,200 esta directiva de compilación agrupa estos dos Grafcets: Observación: es posible utilizar varias directivas « #G » para agrupar más de dos Grafcets. Ahora vamos a detallar las órdenes de forzado utilizables. Se escribirán simplemente en rectángulos de acción como asignaciones clásicas. Soportarán tanto los operadores S(puesta en uno), R(puesta en cero), N(asignación complementada) e I(inversión) como las acciones condicionales. AUTOMGEN7 40 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.6.7.1. Forzado de un Grafcet según una lista de etapas activas Sintaxis: « F<Grafcet>:{<lista de etapas activas>} » o « F/<nombre de folio>:{<lista de etapas activas>} » El o los Grafcets designados se forzarán al estado definido por la lista de etapas activas que se encuentra entre llaves. Si deben estar activas varias etapas, es necesario separarlas con el carácter « , » (coma). Si el o los Grafcets deben forzarse al estado vacío (ninguna etapa activa), no hay que precisar ninguna etapa entre las dos llaves. El número de etapas puede estar precedido de « X ». Así se puede asociar un símbolo al nombre de una etapa. Ejemplos: « F10:{0} » fuerza todas las etapas del Grafcet 10 a 0 salvo la etapa 0, que se fuerza a 1. « F0:{4,8,9,15} » fuerza todas las etapas del Grafcet 0 a 0, salvo las etapas 4, 8, 9 y 15, que se fuerzan a 1. « F/marcha normal:{} » fuerza todos los Grafcets que se encuentran en el folio « marcha normal » al estado vacío. 1.6.7.2. Memorización del estado de un Grafcet Estado actual de un Grafcet: Sintaxis: « G<Grafcet>:<N° de bit> » o « G/<nombre de folio>:<N° de bit> » Este comando memoriza el estado de uno o varios Grafcets en una serie de bits. Es necesario reservar un espacio para almacenar el estado del o de los Grafcets AUTOMGEN7 41 (C)opyright 2002 IRAI Manual de referencia del lenguaje designados (un bit por etapa). Estos bits de almacenamiento deben ser consecutivos. Utilice un comando #B para reservar un espacio lineal de bit. El número de la etapa que designa el Grafcet puede estar precedido de « X ». Así se puede asociar un símbolo al nombre de una etapa. El número del bit puede estar precedido de « U » o de « B ». Así se puede asociar un símbolo al primer bit de la zona de almacenamiento de estado. Estado particular de un Grafcet: Sintaxis: « G<Grafcet>:<N° de bit> {lista de etapas activas} » o « G/<nombre de folio>:<N° de bit> {lista de etapas activas} » Este comando memoriza el estado definido por la lista de etapas activas aplicadas a los Grafcets especificados a partir del bit indicado. También aquí es necesario reservar un número suficiente de bits. Si debe memorizarse una situación vacía, no debe aparecer ninguna etapa entre las dos llaves. El número de las etapas puede estar precedido de « X ». Así se puede asociar un símbolo al nombre de una etapa. El número del bit puede estar precedido de « U » o de « B ». Así se puede asociar un símbolo al primer bit de la zona de almacenamiento de estado. Ejemplos: « G0:100 » memoriza el estado actual del Grafcet 0 a partir de U100. « G0:U200 » memoriza el estado vacío del Grafcet 0 a partir de U200. « G10:150{1,2} » memoriza el estado del Grafcet 10, en el que sólo las etapas 1 y 2 están activas, a partir de U150. « G/PRODUCCIÓN:_ GUARDAR ESTADO PRODUCCIÓN _ » memoriza el estado de los Grafcets que se encuentran en el folio « PRODUCCIÓN » en la variable _GUARDAR ESTADO PRODUCCIÓN_. AUTOMGEN7 42 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.6.7.3. Forzado de un Grafcet a partir de un estado memorizado Sintaxis: « F<Grafcet>:<N° de bit> » o « F/<Nombre de folio>:<N° de bit> » Fuerza el o los Grafcets con el estado memorizado a partir del bit precisado. El número de la etapa que designa el Grafcet puede estar precedido de ‘X’. Así se puede asociar un símbolo al nombre de una etapa. El número del bit puede estar precedido de « U » o de « B ». Así se puede asociar un símbolo al primer bit de la zona de almacenamiento de estado. Ejemplo: « G0:100 » memoriza el estado actual del Grafcet 0 « F0:100 » restaura ese estado 1.6.7.4. Fijación de un Grafcet Sintaxis: « F<Grafcet> » o « F/<Nombre de folio> » Fija uno o varios Grafcets: impide su evolución. Ejemplo: « F100 » fija el Grafcet 100 « F/producción » fija los Grafcets contenidos en el folio « producción » Ilustremos los forzados con un ejemplo. AUTOMGEN7 43 (C)opyright 2002 IRAI Manual de referencia del lenguaje Condiciones: Retomemos un ejemplo ya tratado: ida y vuelta de dos locomotoras por las vías 1 y 3 (esta vez sin espera entre las locomotoras). Añadamos una parada de urgencia. Cuando se detecta la parada de urgencia, todas las salidas se ponen en cero. Al desaparecer la parada de urgencia, el programa debe reanudar el recorrido desde donde se detuvo. AUTOMGEN7 44 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución 1: #B104 réserve 4 bits pour la mémorisation de l'état des Grafcets locomotive 1 locomotive 2 10 AV1 30 t1d 20 AV3 t3i AV1 , DV1 40 t1i AV3 , DV3 t3d gestion de l'arrêt d'urgence 1000 arret urgence 1010 G10:100,G30:102 =1 1020 F10:{},F30:{} arret urgence 1030 F10:100,F30:102 =1 exemple\grafcet\forçage1.agn La utilización de la directiva #B104 permite reservar cuatro bits consecutivos (U100 a U103) para memorizar el estado de los dos Grafcets. AUTOMGEN7 45 (C)opyright 2002 IRAI Manual de referencia del lenguaje « _parada urgencia_ » ha sido asociado a un bit (U1000). Por lo tanto su estado puede modificarse desde el entorno posicionándose encima y haciendo clic cuando la visualización dinámica está activada. AUTOMGEN7 46 (C)opyright 2002 IRAI Manual de referencia del lenguaje Esta segunda solución muestra la utilización de la directiva de compilación « #G » que permite agrupar los Grafcets para los comandos de forzado. 1.6.8. Macro-etapas AUTOMGEN implementa las macro-etapas. A propósito de este tema recordemos que: Una macro-etapa ME es la única representación de un conjunto único de etapas y transiciones llamado « expansión de ME ». Una macro-etapa obedece a las reglas siguientes: Ö la expansión de ME implica una etapa particular llamada etapa de entrada y una etapa particular llamada etapa de salida. Ö la etapa de entrada tiene la propiedad siguiente: si superamos una transición anterior a la macro-etapa, se activa la etapa de entrada de su expansión. Ö la etapa de salida tiene la propiedad siguiente: participa de la validación de las transiciones posteriores a la macro-etapa. Ö fuera de las transiciones anteriores y posteriores a ME, no existe ningún vínculo estructural entre, por una parte, una etapa o una transición de la expansión ME y, por otra, una etapa o una transición que no pertenece a ME. La utilización de las macro-etapas en AUTOMGEN se define así: Ö la expansión de una macro-etapa es un Grafcet en un folio distinto, Ö la etapa de entrada de la expansión de una macro-etapa deberá llevar el número 0 o la identificación Exxx (xxx = un número cualquiera), Ö la etapa de salida de la expansión de una macro-etapa deberá llevar el número 9999 o la identificación Sxxx (xxx = un número cualquiera), Ö fuera de estas dos últimas obligaciones, la expansión de una macro-etapa puede ser un Grafcet cualquiera y como tal puede contener macro-etapas (la imbricación de macro-etapas es posible). 1.6.8.1. Cómo definir una macro-etapa Debe utilizarse el símbolo . Para colocar este símbolo, haga clic en un sitio vacío del folio y elija « Más …/Macro-etapa » en el menú contextual. Para abrir el menú contextual, haga clic con el botón derecho del ratón sobre el fondo del folio. AUTOMGEN7 48 (C)opyright 2002 IRAI Manual de referencia del lenguaje Para definir la expansión de la macro-etapa, cree un folio, diseñe la expansión y modifique las propiedades del folio (haciendo clic con el botón derecho del ratón en el nombre del folio en el explorador). Ajuste el tipo de folio en « Expansión de macroetapas » y el número de la macro-etapa. En modo ejecución, es posible visualizar una expansión de macro-etapa. Para ello, es necesario ubicar el cursor sobre la macro-etapa y hacer clic con el botón izquierdo del ratón. Observaciones: Ö las etapas y los bits Usuario utilizados en una expansión de macro-etapa son locales, es decir que no tienen ninguna relación con las etapas y los bits de otros Grafcets. Los otros tipos de variables no presentan esta característica: son comunes a todos los niveles. Ö si una zona de bits debe utilizarse de manera global, es necesario declararla con la directiva de compilación « #B ». Ö la asignación de variables no locales por diferentes niveles o diferentes expansiones no es gestionada por el sistema. En otros términos, es necesario utilizar las asignaciones « S » « R » o « I » para garantizar un funcionamiento coherente del sistema. Ilustremos la utilización de las macro-etapas con un ejemplo ya tratado: ida y vuelta de una locomotora por la vía 1 con espera en el extremo de la vía. Descompondremos la ida y la vuelta en dos macro-etapas distintas. AUTOMGEN7 49 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución: macro-étape aller voie 1 E1 10 S AV1 ,R DV1 t1d 20 R AV1 t0/x20/10s S1 macro-étape retour voie 1 E2 10 S AV1 ,S DV1 t1i 20 R AV1 t1/x20/4s S2 AUTOMGEN7 50 (C)opyright 2002 IRAI Manual de referencia del lenguaje 0 =1 M1 =1 M2 =1 exemple\grafcet\macro-étape.agn 1.6.9. Contadores Ilustremos la utilización de los contadores con un ejemplo. Condiciones: Una locomotora debe efectuar 10 idas y vueltas por la vía 1, inmovilizarse durante quince segundos y volver a arrancar. AUTOMGEN7 51 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución: 0 RC0 =1 1 AV1 t1d 2 AV1 , DV1 t1i 3 +C0 c0<10 c0=10 4 15s/x4 exemple\grafcet\compteur.agn 1.7. Gemma AUTOMGEN implementa la descripción de Grafcet de gestión de los modos de marcha bajo forma de Gemma. El principio es un modo de edición transparente al modo Grafcet. Es posible pasar del modo de edición Grafcet al modo de edición Gemma. La traducción de un Gemma en Grafcet de gestión de modos de marcha es automático e inmediato. El comando « Editar bajo la forma de un Gemma » del menú « Caja de herramientas » permite pasar de un modo al otro. AUTOMGEN7 52 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.7.1. Creación de un Gemma Para crear un Gemma: Ö haga clic en el elemento « Folio » del explorador con el botón derecho del ratón y seleccione el comando « Añadir un nuevo folio », Ö en la lista de tamaños elija « Gemma », Ö haga clic en el pulsador « OK », Ö haga clic con el botón derecho del ratón en el nombre del folio creado en el explorador, Ö elija « Propiedades » en el menú, Ö pinche la opción « Mostrar bajo la forma de un Gemma ». La ventana contiene un Gemma en el que todos los rectángulos y vínculos están sombreados. Para validar un rectángulo o un vínculo hay que posicionarse encima y hacer clic con el botón derecho del ratón. Para modificar el contenido de un rectángulo o la naturaleza de un vínculo hay que posicionarse encima y hacer clic con el botón izquierdo del ratón. El contenido de los rectángulos del Gemma se ubicará en los rectángulos de acción del Grafcet. La naturaleza de los vínculos se ubicará en las transiciones del Grafcet. A cada rectángulo del Gemma puede asociarse un comentario, que aparecerá cerca del rectángulo de acción correspondiente en el Grafcet. 1.7.2. Contenido de los rectángulos del Gemma Los rectángulos del Gemma pueden recibir cualquier acción utilizable en el Grafcet. Como se trata de definir una estructura de gestión de los modos de parada y de marcha, es conveniente utilizar órdenes de forzado hacia Grafcets de nivel más bajo; ver el capítulo 1.6.7. Forzados de Grafcet. 1.7.3. Obtener un Grafcet correspondiente Una vez más, la opción « Mostrar bajo la forma de un Gemma » en las propiedades del folio permite volver a una representación Grafcet. Es posible volver en cualquier momento a una representación Gemma mientras la estructura del Grafcet no se modifique. Las transiciones, el contenido de los rectángulos de acción y los comentarios pueden modificarse con una actualización automática del Gemma. AUTOMGEN7 54 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.7.4. Anular los espacios vacíos en el Grafcet Es posible que el Grafcet obtenido ocupe más espacio del necesario en la página. El comando « Reorganizar la página » del menú « Herramientas » permite suprimir todos los espacios no utilizados. 1.7.5. Imprimir el Gemma Cuando la edición está en modo Gemma, el comando « Imprimir » permite imprimir el Gemma. 1.7.6. Exportar el Gemma El comando « Copiar en formato EMF » del menú « Edición » permite exportar un Gemma en formato vectorial. 1.7.7. Ejemplo de Gemma Ilustremos la utilización del Gemma. Condiciones: Imaginemos un escritorio compuesto por los pulsadores « inicio ciclo », « fin de ciclo » y « parada de urgencia » y el testigo « INIT ». El propósito del programa principal será hacer efectuar idas y vueltas a una locomotora por la vía 1. AUTOMGEN7 55 (C)opyright 2002 IRAI Manual de referencia del lenguaje Ç depart 100 AV1 t1d 110 AV1 , DV1 t1i . fin t1i . fin 120 FIN DE CYCLE OBTENU fin de cycle obtenu exemple\gemma\gemma.agn 1.8. Ladder El lenguaje Ladder, también llamado « esquema de contacto », permite describir gráficamente ecuaciones booleanas. Para realizar una función lógica « Y », es necesario escribir contactos en serie. Para realizar una función « O », es necesario escribir contactos en paralelo. Función « Y » Función « O » El contenido de los contactos debe respetar la sintaxis definida para los tests y detallada en el capítulo « Elementos comunes » de este manual. AUTOMGEN7 58 (C)opyright 2002 IRAI Manual de referencia del lenguaje El contenido de las bobinas debe respetar la sintaxis definida para las acciones y detallada en el capítulo « Elementos comunes » de este manual. 1.8.1. Ejemplo de Ladder Empecemos con el ejemplo más simple. Condiciones: Ida y vuelta de una locomotora por la vía 1. Solución 1: AV1 Ç t1i R DV1 Ç t1d S DV1 exemple\ladder\ladder1.agn Solución 2: AV1 t1i dv1 DV1 t1d exemple\ladder\ladder2.agn La segunda solución es idéntica desde el punto de vista funcional. Su interés es mostrar la utilización de una variable en auto mantenimiento. Enriquezcamos nuestro ejemplo. Condiciones: La locomotora deberá detenerse 10 segundos a la derecha de la vía 1 y 4 segundos a la izquierda. AUTOMGEN7 59 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución: t1d T0(10S) S DV1 t1i T1(4S) R DV1 t1i t1d AV1 t0 t1 exemple\ladder\ladder3.agn Un último ejemplo un poco más complejo. Condiciones: Siempre una locomotora que va y viene por la vía 1. Cada 10 idas y vueltas deberá marcar un tiempo de parada de 15 segundos. Solución: b0 RC0 t0 t1d dv1 +C0 S DV1 t1i R DV1 c0<10 AV1 t0 c0=10 T0(15S) exemple\ladder\ladder4.agn 1.9. Logigrama AUTOMGEN implementa el lenguaje logigrama de la siguiente manera: AUTOMGEN7 60 (C)opyright 2002 IRAI Manual de referencia del lenguaje Ö utilización de un bloque especial llamado « bloque de asignación »; este bloque separa la zona de acción de la zona test, tiene esta forma y está asociado a la tecla [0] (cero), Ö utilización de las funciones « No », « Y » y « O », Ö utilización de rectángulos de acción a la derecha del bloque de acción. El lenguaje logigrama permite escribir gráficamente ecuaciones booleanas. El contenido de los tests debe respetar la sintaxis definida en el capítulo « Elementos comunes » de este manual. El contenido de los rectángulos de acción debe respetar la sintaxis definida para las acciones y detallada en el capítulo « Elementos comunes » de este manual. Zone « test » Bloc d’affectation pour délimiter la zone test de la zone action Zone « action » 1.9.1. Diseño de los logigramas 1.9.1.1. Número de entradas de las funciones « Y » y « O » Las funciones « Y » y « O » se componen respectivamente de un bloque [2]) o de un bloque (tecla [3]), eventualmente de bloques añadir entradas a los bloques, y por último de un bloque (tecla (tecla [4]) para (tecla [5]). Las funciones « Y » y « O » implican pues un mínimo de dos entradas. AUTOMGEN7 61 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.9.1.2. Encadenamiento de las funciones Las funciones pueden encadenarse. 1.9.1.3. Acciones múltiples Es posible asociar varios rectángulos de acción a un logigrama después del bloque de asignación. o 1.9.2. Ejemplo de logigrama Empecemos con el ejemplo más simple. Condiciones: Ida y vuelta de una locomotora por la vía 1. Solución 1: =1 AV1 Ç t1d S DV1 Ç t1i R DV1 exemple\logigramme\logigramme1.agn AUTOMGEN7 62 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución 2: =1 AV1 t1d DV1 dv1 t1i & O exemple\logigramme\logigramme2.agn La segunda solución es idéntica desde el punto de vista funcional. Su interés es consiste en mostrar la utilización de una variable en auto mantenimiento. Enriquezcamos nuestro ejemplo. Condiciones: La locomotora deberá detenerse 10 segundos a la derecha de la vía 1 y 4 segundos a la izquierda. Solución: t1d T0(10S) S DV1 t1i T1(4S) R DV1 t0 AV1 t1 O & O exemple\logigramme\logigramme3.agn Cabe notar la repetición del bloque « Y » de la parte inferior del ejemplo en las entradas « _t1d_ » y « _t1i_ ». Esto evita tener que escribir por segunda vez estos dos tests. Un último ejemplo un poco más complejo. AUTOMGEN7 63 (C)opyright 2002 IRAI Manual de referencia del lenguaje Condiciones: Siempre una locomotora que va y viene por la vía 1. Cada 10 idas y vueltas deberá marcar un tiempo de parada de 15 segundos. Solución: b0 RC0 t0 t1d dv1 & +C0 O S DV1 t1i R DV1 c0<10 AV1 t0 c0=10 T0(15S) exemple\logigramme\logigramme4.agn AUTOMGEN7 64 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.10. Lenguajes literales Este capítulo describe la utilización de las tres formas de lenguaje literal disponibles en AUTOMGEN: Ö lenguaje literal bajo nivel, Ö lenguaje literal extendido, Ö lenguaje literal ST de la norma CEI 1131-3. 1.10.1. Cómo utilizar el lenguaje literal El lenguaje literal puede utilizarse bajo la forma siguiente: Ö archivo de código asociado a una acción (Grafcet, Ladder, logigrama), Ö caja de código asociada a una acción (Grafcet, logigrama), Ö código literal en un rectángulo de acción o una bobina (Grafcet, Ladder, logigrama), Ö caja de código utilizada bajo forma de organigrama (consultar el capítulo « Organigrama »), Ö archivo de código que rige el funcionamiento de un bloque funcional (consultar el capítulo « Bloques funcionales »), Ö archivo de código que rige el funcionamiento de una macro-instrucción; ver el capítulo 1.10.4. Macro-instrucción. 1.10.1.1. Caja de código asociada a una etapa o un logigrama Una caja de código asociada a una acción permite escribir algunas líneas de lenguaje literal en una página de la aplicación. Ejemplos: AUTOMGEN7 65 (C)opyright 2002 IRAI Manual de referencia del lenguaje El código utilizado es escrutado mientras la acción es verdadera. Es posible utilizar conjuntamente rectángulos de acción y cajas de código. Ejemplo: 1.10.1.2. Código literal en un rectángulo de acción o una bobina Los caracteres « { » y « } » permiten insertar instrucciones en lenguaje literal directamente en un rectángulo de acción (lenguajes Grafcet y logigrama) o una bobina (lenguaje ladder). El carácter « , » (coma) se utiliza como separador si entre « { » y « } » hay varias instrucciones. Este tipo de inserción puede utilizarse con órdenes condicionadas. Ejemplos: 1.10.2. Definición de una caja de código Para diseñar una caja de código siga las etapas siguientes: Ö haga clic con el botón derecho del ratón en un sitio vacío del folio, Ö elija en el menú « Más … / Caja de código », AUTOMGEN7 66 (C)opyright 2002 IRAI Manual de referencia del lenguaje Ö haga clic sobre el borde de la caja de código para modificar su contenido. Para salir de la caja después de modificarla utilice la tecla [Enter] o haga clic en el exterior. 1.10.3. El lenguaje literal bajo nivel Este capítulo detalla la utilización del lenguaje literal bajo nivel. Este lenguaje es un código intermedio entre los lenguajes evolucionados Grafcet, logigrama, ladder, organigrama, bloques funcionales, literal extendido, literal ST y los lenguajes ejecutables. También se conoce con el nombre de código pivote. Los postprocesadores traducen el lenguaje literal bajo nivel en código ejecutable para PC, autómata o tarjeta con microprocesador. El lenguaje literal también puede utilizarse en una aplicación para efectuar diversos tratamientos booleanos, numéricos o algorítmicos. El lenguaje literal bajo nivel es un lenguaje de tipo ensamblador. Utiliza una noción de acumulador para los tratamientos numéricos. El lenguaje literal extendido y el lenguaje literal ST descritos en los capítulos siguientes ofrecen una alternativa simplificada y de más alto nivel para escribir programas en lenguaje literal. Sintaxis general de una línea de lenguaje literal bajo nivel: «acción » [[ [« Test »] « Test » ]...] Las acciones y los tests del lenguaje literal bajo nivel están representados por mnemónicos compuestos de tres caracteres alfabéticos. Cada instrucción va seguida de una expresión: variable, constante, etc... Una línea se compone de una sola acción y eventualmente de un test. Si una línea contiene únicamente una acción, la instrucción se ejecutará siempre, por convención. 1.10.3.1. Variables Las variables utilizables son las mismas que las definidas en el capítulo « Elementos comunes ». AUTOMGEN7 67 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.10.3.2. Acumuladores Ciertas instrucciones utilizan la noción de acumulador. Los acumuladores son registros internos del sistema que ejecuta el programa final y permiten acumular valores temporalmente. Existen tres acumuladores: un acumulador entero 16 bits llamado AAA, un acumulador entero 32 bits llamado AAL y un acumulador flotante llamado AAF. 1.10.3.3. Banderas Las banderas son variables booleanas posicionadas en función del resultado de las operaciones numéricas. Las cuatro banderas que permiten testear el resultado de un cálculo son: Ö indicador de retención C: indica si una operación ha generado una retención (1) o no (0), Ö indicador de cero Z: indica si una operación ha generado un resultado nulo (1) o no (0), Ö indicador de signo S: indica si una operación ha generado un resultado negativo (1) o positivo (0), Ö indicador de exceso O: indica si una operación ha generado un exceso de capacidad (1). 1.10.3.4. Modos de direccionamiento El lenguaje literal bajo nivel posee 5 modos de direccionamiento. Un modo de direccionamiento es una característica asociada a cada una de las instrucciones del lenguaje literal. Los modos de direccionamiento utilizables son: TIPO SINTAXIS EJEMPLO Inmediato 16 bits {constante} 100 Inmediato 32 bits {constante}L 100000L Inmediato flotante {constante}R 3.14R Absoluto {variable} {identificación de variable} O540 Acumulador 16 bits AAA AAA Acumulador 32 bits AAL AAL AUTOMGEN7 68 (C)opyright 2002 IRAI Manual de referencia del lenguaje Acumulador flotante AAF AAF Indirecto {variable}{(identificación de palabra)} O(220) Label :{nombre de label}: :bucle: Una instrucción posee dos características: el tipo de variable y el modo de direccionamiento. Una instrucción puede soportar o no ciertos modos de direccionamiento o ciertos tipos de variables. Por ejemplo, hay instrucciones que se aplican únicamente a palabras, y no a otros tipos de variables. Observación: Las variables X y U no pueden asociarse a un direccionamiento indirecto debido a la no linealidad de sus asignaciones. Si es necesario acceder a una tabla de variables U, habrá que utilizar una directiva de compilación #B para declarar una tabla de bits lineales. 1.10.3.5. Tests Los tests que pueden asociarse a las instrucciones se componen de un mnemónico, un tipo de test y una variable. Los mnemónicos de tests permiten definir tests combinatorios de varias variables (y, o). Si un test está compuesto por una sola variable, de todas maneras debe asociarse un operador AND. Existen solamente tres mnemónicos de test: AND y ORR o EOR fin de o He aquí algunos ejemplos de equivalencias entre ecuaciones booleanas y lenguaje literal bajo nivel: o0=i1 : and i1 o0=i1.i2 : and i1 and i2 o0=i1+i2 : orr i1 eor i2 o0=i1+i2+i3+i4 : orr i1 orr i2 orr i3 eor i4 o0=(i1+i2).(i3+i4) : orr i1 eor i2 orr i3 eor i4 o0=i1.(i2+i3+i4) : and i1 orr i2 orr i3 eor i4 o0=(i1.i2)+(i3.i4) ; imposible traducir directamente, ; hay que utilizar ; variables intermedias: AUTOMGEN7 69 (C)opyright 2002 IRAI Manual de referencia del lenguaje equ u100 and i1 and i2 equ u101 and i3 and i4 equ o0 orr u100 eor u101 Los modificadores de tests permiten testear cosas que no son simplemente el estado verdadero de una variable: Ö Ö Ö Ö / no # frente ascendente * frente descendente @ estado inmediato Observaciones: Ö las variables booleanas se actualizan después de cada ciclo de ejecución. En otros términos, si durante un ciclo una variable binaria se posiciona en un estado, su nuevo estado será realmente reconocido en el ciclo siguiente. El modificador de test @ permite obtener el estado real de una variable booleana sin esperar el ciclo siguiente. Ö los modificadores de tests no son utilizables con los tests numéricos. Ejemplos: set o100 equ o0 and @o100 ; test verdadero desde el primer ciclo equ o1 and o100 ; test verdadero en el segundo ciclo Para los tests, hay sólo dos modos de direccionamiento disponibles: el modo absoluto y el modo indirecto. Hay un test de contadores, palabras, largos y flotantes: Sintaxis: « {variable} {=, !, <, >, << , >>} {constante o variable} » = significa igual, ! significa diferente, < significa menor sin signo, > significa mayor sin signo, AUTOMGEN7 70 (C)opyright 2002 IRAI Manual de referencia del lenguaje << significa menor con signo, >> significa mayor con signo, Las constantes están predeterminadas en decimal. Los sufijos « $ » y « % » permiten escribirlas en hexadecimal o en binario. Las comillas permiten escribirlas en ASCII. Las constantes 32 bits deben estar seguidas del carácter « L ». Las constantes reales deben estar seguidas del carácter « R ». Una palabra o un contador puede compararse con una palabra, un contador o una constante 16 bits. Un largo puede compararse con un largo o una constante 32 bits. Un flotante puede compararse con un flotante o una constante real. Ejemplos: and c0>100 and m225=10 orr m200=m201 eor m202=m203 and f100=f101 and f200<f203 orr m200<<-100 eor m200>>200 and f200=3.14r and l200=$12345678L and m200=%1111111100000000 1.10.3.6. Comentarios Los comentarios deben empezar con el carácter « ; » (punto y coma); todos los caracteres siguientes se ignoran. 1.10.3.7. Base de numeración Los valores (identificaciones de variables o constantes) pueden escribirse en decimal, hexadecimal, binario o ASCII. La siguiente sintaxis debe aplicarse para las constantes 16 bits: Ö decimal: eventualmente el carácter « - » y luego 1 a 5 dígitos « 0123456789 », Ö hexadecimal: prefijo « $ » o « 16# » seguido de 1 a 4 dígitos « 0123456789ABCDEF », Ö binario: prefijo « % » o « 2# » seguido de 1 a 16 dígitos « 01 », Ö ASCII: carácter « " » seguido de 1 o 2 caracteres seguidos de « " ». La siguiente sintaxis debe aplicarse para las constantes 32 bits: AUTOMGEN7 71 (C)opyright 2002 IRAI Manual de referencia del lenguaje Ö Decimal: eventualmente el carácter « - » y luego 1 a 10 dígitos « 0123456789 », Ö Hexadecimal: prefijo « $ » o « 16# » seguido de 1 a 8 dígitos « 0123456789ABCDEF », Ö Binario: prefijo « % » o « 2# » seguido de 1 a 32 dígitos « 01 », Ö ASCII: carácter « " » seguido de 1 a 4 caracteres seguidos de « " ». La siguiente sintaxis debe aplicarse para las constantes reales: [-] i [[.d] Esx] i es la parte entera d una eventual parte decimal s eventualmente el signo del exponente x eventualmente el exponente 1.10.3.8. Predisposiciones Una predisposición permite fijar el valor de una variable al inicio de la aplicación. Las variables T o %T, M o %MW, L o %MD y F o %F pueden estar predispuestas. La sintaxis es la siguiente: « $(variable)=constante{,constante{,constante...}} » Para las temporizaciones el valor debe estar escrito en decimal y comprendido entre 0 y 65535. Para las palabras debe utilizarse la siguiente sintaxis: Ö Decimal: eventualmente el carácter « - » y luego 1 a 5 dígitos « 0123456789 », Ö Hexadecimal: prefijo « $ » o « 16# » seguido de 1 a 4 dígitos « 0123456789ABCDEF », Ö Binario: prefijo « % » o « 2# » seguido de 1 a 16 dígitos « 01 », Ö ASCII: (dos caracteres por palabra) el carácter « " » seguido de n caracteres seguidos de « " », Ö ASCII: (un carácter por palabra) el carácter « ’ » seguido de n caracteres seguidos de « ’ ». AUTOMGEN7 72 (C)opyright 2002 IRAI Manual de referencia del lenguaje Para los largos debe utilizarse la siguiente sintaxis: Ö Decimal: eventualmente el carácter « - » y luego 1 a 10 dígitos « 0123456789 », Ö Hexadecimal: prefijo « $ » o « 16# » seguido de 1 a 8 dígitos « 0123456789ABCDEF », Ö Binario: carácter « % » o « 2# » seguido de 1 a 32 dígitos « 01 », Ö ASCII: (cuatro caracteres por largo) carácter « " » seguido de n caracteres seguidos de « " », Ö ASCII: (un carácter por largo) carácter « ’ » seguido de n caracteres seguidos de «’» Para los flotantes, el valor debe escribirse de la siguiente manera: [-] i [[.d] Esx] i es la parte entera d una eventual parte decimal s eventualmente el signo del exponente x eventualmente el exponente Ejemplos: $t25=100 fija la consigna de la temporización 25 en 10 s $MW200=100,200,300,400 coloca los valores 100, 200, 300, 400 en las palabras 200, 201, 202, 203 $m200="ABCDEF" coloca la cadena de caracteres « ABCDEF » a partir de m200 (« AB » en m200, « CD » en m201, « EF » en m202) $m200=‘ABCDEF’ coloca la cadena de caracteres « ABCDEF » a partir de m200; cada palabra recibe un carácter. $f1000=3.14 coloca el valor 3,14 en f1000 $%mf100=5.1E-15 coloca el valor 5,1 * 10 exponente -15 en %mf100 $l200=16#12345678 coloca el valor 12345678 (hexa) en el largo l200 AUTOMGEN7 73 (C)opyright 2002 IRAI Manual de referencia del lenguaje Es más fácil escribir texto en las predisposiciones. Ejemplo: $m200=" Parada compuerta N°10 " Coloca el mensaje a partir de la palabra 200 con dos caracteres en cada palabra. $m400=‘ Defecto motor ‘ Coloca el mensaje a partir de la palabra 400 con un carácter en el byte de peso débil de cada palabra; el byte de peso fuerte contiene 0. La sintaxis « $...= » permite proseguir una tabla de predisposiciones a continuación de la anterior. Por ejemplo: #$m200=1,2,3,4,5 #$...=6,7,8,9 Coloca los valores de 1 a 9 en las palabras m200 a m208. Las predisposiciones pueden escribirse de la misma manera que el lenguaje literal bajo nivel o en una directiva de compilación en un folio. En este caso, la predisposición empieza con el carácter « # ». Ejemplo de predisposición escrita en una caja de código: Ejemplo de predisposición escrita en una directiva de compilación: AUTOMGEN7 74 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.10.3.9. Direccionamiento indirecto El direccionamiento indirecto permite efectuar una operación con una variable señalada por un índice. Son las variables M (las palabras) las que sirven de índice. Sintaxis: « variable ( índice ) » Ejemplo: lda 10 ; carga 10 en el acumulador sta m200 ; lo coloca en la palabra 200 set o(200) ; puesta en uno de la salida señalada por la palabra 200 (o10) 1.10.3.10. Direccionamiento de una variable El carácter « ? » permite especificar el direccionamiento de una variable. Ejemplo: lda ?o10 ; coloca el valor 10 en el acumulador Esta sintaxis es interesante sobre todo si se utilizan símbolos. Ejemplo: lda ?_compuerta_ ; coloca en el acumulador el número de la variable ; asociada al símbolo « _compuerta_ » Esta sintaxis también puede utilizarse en las predisposiciones para crear tablas de direccionamientos de variables. Ejemplo: $m200=?_compuerta1_,?_compuerta2_,?_compuerta3_ 1.10.3.11. Saltos y labels Los saltos deben hacer referencia a un label. La sintaxis de un label es: «:nombre del label: » Ejemplo: jmp:continuación: ... :continuación: AUTOMGEN7 75 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.10.3.12. Lista de funciones por tipo 1.10.3.12.1. Funciones booleanas SET puesta en uno RES puesta en cero INV inversión EQU equivalencia NEQ no-equivalencia 1.10.3.12.2. Funciones de carga y almacenamiento con enteros y flotantes LDA carga STA almacenamiento 1.10.3.12.3. Funciones aritméticas con enteros y flotantes ADA suma SBA resta MLA multiplicación DVA división CPA comparación 1.10.3.12.4. Funciones aritméticas con flotantes ABS valor absoluto SQR raíz cuadrada 1.10.3.12.5. Funciones de acceso a los puertos de entrada/salida en PC AIN lectura de un puerto AOU escritura de un puerto 1.10.3.12.6. Funciones de acceso a la memoria en PC ATM lectura de una dirección de memoria MTA escritura de una dirección de memoria 1.10.3.12.7. Funciones binarias con enteros ANA y bit a bit ORA o bit a bit XRA o exclusivo bit a bit TSA test bit a bit AUTOMGEN7 76 (C)opyright 2002 IRAI Manual de referencia del lenguaje SET puesta en uno de todos los bits RES puesta en cero de todos los bits RRA desfase a derecha RLA desfase a izquierda 1.10.3.12.8. Otras funciones con enteros INC incremento DEC decremento 1.10.3.12.9. Funciones de conversión ATB entero a booleanos BTA booleanos a entero FTI flotante a entero ITF entero a flotante LTI entero 32 bits a entero 16 bits ITL entero 16 bits a entero 32 bits AUTOMGEN7 77 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.10.3.12.10. Funciones de ramificación JMP salto JSR salto a un subprograma RET retorno de subprograma 1.10.3.12.11. Funciones de test RFZ flag de resultado nulo RFS flag de signo RFO flag de exceso RFC flag de retención 1.10.3.12.12. Funciones de accesos asíncronos a entradas salidas RIN lectura de entradas WOU escritura de salidas 1.10.3.12.13. Información contenida en la lista de funciones Para cada instrucción se dan: Ö Nombre: el mnemónico. Ö Función: una descripción de la función realizada por la instrucción. Ö Variables: tipos de variables utilizables con la instrucción. Ö Direccionamiento: tipos de direccionamientos utilizables. Ö Ver también: las otras instrucciones que tengan relación con este mnemónico. Ö Ejemplo: un ejemplo de utilización. Los post-procesadores que generan lenguajes constructores están sujetos a ciertas restricciones. Consultar las notas sobre estos post-procesadores para conocer en detalle dichas restricciones. AUTOMGEN7 78 (C)opyright 2002 IRAI Manual de referencia del lenguaje ABS Nombre : ABS - abs accumulator Función : calcula el valor absoluto del acumulador flotante Variables : ninguna Direccionamiento : acumulador Ver también : SQR Ejemplo : lda f200 abs aaf sta f201 ; deja en f201 el valor absoluto de f200 AUTOMGEN7 79 (C)opyright 2002 IRAI Manual de referencia del lenguaje ADA Nombre : ADA - adds accumulator Función : añade un valor al acumulador Variables : M o %MW, L o %MD, F o %MF Direccionamiento : absoluto, indirecto, inmediato Ver también : SBA Ejemplo : ada 200 ; añade 200 al acumulador 16 bits ada f124 ; añade el contenido de f124 al acumulador flotante ada l200 ; añade el contenido de l200 al acumulador 32 bits ada 200L ; añade 200 al acumulador 32 bits ada 3.14R ; añade 3.14 al acumulador flotante AUTOMGEN7 80 (C)opyright 2002 IRAI Manual de referencia del lenguaje AIN Nombre : AIN - accumulator input Función : lectura de un puerto de entrada (8 bits) y almacenamiento en la parte baja del acumulador 16 bits; lectura de un puerto de entrada 16 bits y almacenamiento en el acumulador 16 bits (en este caso la dirección del puerto debe escribirse como una constante de 32 bits) utilizable sólo con el ejecutor PC Variables : M o %MW Direccionamiento: indirecto, inmediato Ver también : AOU Ejemplo : ain $3f8 ; lectura del puerto $3f8 (8 bits) ain $3f8l ; lectura del puerto $3f8 (16 bits) AUTOMGEN7 81 (C)opyright 2002 IRAI Manual de referencia del lenguaje ANA Nombre : ANA - and accumulator Función : efectúa un Y lógico entre el acumulador 16 bits y una palabra o una constante o el acumulador 32 bits y un largo o una constante Variables : M o %MW, L o %MD Direccionamiento: absoluto, indirecto, inmediato Ver también : ORA, XRA Ejemplo : ana %1111111100000000 ; oculta los 8 bits de peso débil del ; acumulador 16 bits ana $ffff0000L ; oculta los 16 bits de peso débil del acumulador 32 bits AUTOMGEN7 82 (C)opyright 2002 IRAI Manual de referencia del lenguaje AOU Nombre : AOU - accumulator output Función : transfiere la parte baja (8 bits) del contenido del acumulador 16 bits a un puerto de salida; transfiere los 16 bits del acumulador 16 bits a un puerto de salida (en este caso la dirección del puerto debe escribirse como una constante 32 bits) utilizable sólo con el ejecutor PC Variables : M o %MW Direccionamiento: indirecto, inmediato Ver también : AIN Ejemplo : lda "A" aou $3f8 ; coloca el carácter « A » en el puerto de salida $3f8 lda $3f8 sta m200 lda "z" aou m(200) ; coloca el carácter « z » en el puerto de salida $3f8 lda $1234 aou $300l ; coloca el valor 16 bits 1234 en el puerto de salida $300 AUTOMGEN7 83 (C)opyright 2002 IRAI Manual de referencia del lenguaje ATB Nombre : ATB - accumulator to bit Función : transfiere los 16 bits del acumulador 16 bits a 16 variables booleanas sucesivas; el bit de peso débil corresponde a la primera variable booleana Variables : I o %I, O o %Q, B o %M, T o %T, U* Direccionamiento: absoluto Ver también : BTA Ejemplo : lda m200 atb o0 ; recopia los 16 bits de m200 en las variables ; o0 a o15 * Atención: para poder utilizar los bits U con esta función es necesario realizar una tabla lineal de bits con la directiva de compilación #B. AUTOMGEN7 84 (C)opyright 2002 IRAI Manual de referencia del lenguaje ATM Nombre : ATM - accumulator to memory Función : transfiere el acumulador 16 bits a una dirección memoria; la palabra o la constante especificada define el offset de la dirección de memoria a alcanzar; la palabra m0 debe estar cargada con el valor del segmento de la dirección de memoria a alcanzar; utilizable sólo con el ejecutor PC Variables : M o %MW Direccionamiento: indirecto, inmediato Ver también : MTA Ejemplo : lda $b800 sta m0 lda 64258 atm $10 ; coloca el valor 64258 en la dirección $b800:$0010 AUTOMGEN7 85 (C)opyright 2002 IRAI Manual de referencia del lenguaje BTA Nombre : BTA - bit to accumulator Función : transfiere 16 variables booleanas sucesivas a los 16 bits del acumulador 16 bits; el bit de peso débil corresponde a la primera variable booleana Variables : I o %I, O o %Q, B o %M, T o %T, U* Direccionamiento: absoluto Ver también : ATB Ejemplo : bta i0 sta m200 ; recopia las 16 entradas i0 a i15 en la palabra m200 * Atención: para poder utilizar los bits U con esta función es necesario realizar una tabla lineal de bits con la directiva de compilación #B. AUTOMGEN7 86 (C)opyright 2002 IRAI Manual de referencia del lenguaje CPA Nombre : CPA - compares accumulator Función : compara un valor al acumulador 16 bits o 32 bits o flotante; efectúa la misma operación que SBA pero sin modificar el contenido del acumulador Variables : M o %MW, L o %MD, F o %MF Direccionamiento: absoluto, indirecto, inmediato Ver también : SBA Ejemplo : lda m200 cpa 4 rfz o0 ; pone o0 en 1 si m200 es igual a 4, si no o0 ; se pone en 0 lda f200 cpa f201 rfz o1 ; pone o1 en 1 si f200 es igual a f201, si no o1 ; se pone en 0 AUTOMGEN7 87 (C)opyright 2002 IRAI Manual de referencia del lenguaje D EC Nombre : DEC – decrement Función : decrementa una palabra, un contador, un largo, el acumulador 16 bits o 32 bits Variables : M o %MW, C o %C, L o %MD Direccionamiento: absoluto, indirecto, acumulador Ver también : INC Ejemplo : dec m200 ; decrementa m200 dec aal ; decrementa el acumulador 32 bits dec m200 dec m201 and m200=-1 ; decrementa un valor 32 bits compuesto de ; m200 (peso débil) ; y m201 (peso fuerte) AUTOMGEN7 88 (C)opyright 2002 IRAI Manual de referencia del lenguaje DVA Nombre : DVA - divides accumulator Función : división del acumulador 16 bits por una palabra o una constante; división del acumulador flotante por un flotante o una constante; división del acumulador 32 bits por un largo o una constante; para el acumulador 16 bits el resto se coloca en la palabra m0; en caso de división por 0 el bit sistema 56 pasa a 1 Variables : M o %MW, L o %MD, F o %MF Direccionamiento: absoluto, indirecto, inmediato Ver también : MLA Ejemplo : lda m200 dva 10 sta m201 ; m201 es igual a m200 dividido por 10, m0 contiene el ; resto de la división lda l200 dva $10000L sta l201 AUTOMGEN7 89 (C)opyright 2002 IRAI Manual de referencia del lenguaje EQU Nombre : EQU - equal Función : fuerza una variable a 1 si el test es verdadero, en caso contrario, la variable se fuerza a 0 Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U Direccionamiento: absoluto, indirecto (salvo con las variables X) Ver también : NEQ, SET, RES, INV Ejemplo : equ o0 and i10 ; fuerza la salida o0 al mismo estado que la entrada i10 lda 10 sta m200 equ o(200) and i0 ; fuerza o10 al mismo estado que la entrada i0 $t0=100 equ t0 and i0 equ o0 and t0 ; fuerza o0 al estado de i0 con un retraso en la activación ; de 10 segundos AUTOMGEN7 90 (C)opyright 2002 IRAI Manual de referencia del lenguaje FTI Nombre : FTI - float to integer Función : transfiere el acumulador flotante al acumulador 16 bits Variables : ninguna Direccionamiento: acumulador Ver también : ITF Ejemplo : lda f200 fti aaa sta m1000 ; deja la parte entera de f200 en m1000 AUTOMGEN7 91 (C)opyright 2002 IRAI Manual de referencia del lenguaje INC Nombre : INC - increment Función : incrementa una palabra, un contador, un largo, el acumulador 16 bits o 32 bits Variables : M o %MW, C o %C, L o %MD Direccionamiento: absoluto, indirecto, acumulador Ver también : DEC Ejemplo : inc m200 ; añade 1 a m200 inc m200 inc m201 and m201=0 ; incrementa un valor sobre 32 bits, m200 ; representa los ; pesos débiles, y m201 los pesos fuertes inc l200 ; incrementa el largo l200 AUTOMGEN7 92 (C)opyright 2002 IRAI Manual de referencia del lenguaje INV Nombre : INV - inverse Función : invierte el estado de una variable booleana, o invierte todos los bits de una palabra, de un largo o del acumulador 16 bits o 32 bits Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U, M o %MW, L o %MD Direccionamiento: absoluto, indirecto, acumulador Ver también : EQU, NEQ, SET, RES Ejemplo : inv o0 ; invierte el estado de la salida 0 inv aaa ; invierte todos los bits del acumulador 16 bits inv m200 and i0 ; invierte todos los bits de m200 si i0 está en estado 1 AUTOMGEN7 93 (C)opyright 2002 IRAI Manual de referencia del lenguaje I TF Nombre : ITF - integer to float Función : transfiere el acumulador 16 bits al acumulador flotante Variables : ninguna Direccionamiento: acumulador Ver también : FTI Ejemplo : lda 1000 itf aaa sta f200 ; deja la constante 1000 en f200 AUTOMGEN7 94 (C)opyright 2002 IRAI Manual de referencia del lenguaje ITL Nombre : ITL - integer to long Función : transfiere el acumulador 16 bits al acumulador 32 bits Variables : ninguna Direccionamiento: acumulador Ver también : LTI Ejemplo : lda 1000 itl aaa sta f200 ; deja la constante 1000 en l200 AUTOMGEN7 95 (C)opyright 2002 IRAI Manual de referencia del lenguaje JMP Nombre : JMP - jump Función : salto a un label Variables : label Direccionamiento: label Ver también : JSR Ejemplo : jmp :fin de programa: ; ramificación incondicional en label :fin ; de programa: jmp :continuación: and i0 set o0 set o1 :continuación: ; ramificación condicional en label :continuación: ; según el estado de i0 AUTOMGEN7 96 (C)opyright 2002 IRAI Manual de referencia del lenguaje JSR Nombre : JSR - jump sub routine Función : efectúa una ramificación a un subprograma Variables : label Direccionamiento: label Ver también : RET Ejemplo : lda m200 jsr :cuadrado: sta m201 jmp :fin: :cuadrado: sta m53 mla m53 sta m53 ret m53 :fin: ; el subprograma « cuadrado » eleva al cuadrado ; el contenido del acumulador AUTOMGEN7 97 (C)opyright 2002 IRAI Manual de referencia del lenguaje LDA Nombre : LDA - load accumulator Función : carga en el acumulador 16 bits una constante, palabra o contador; carga en el acumulador 32 bits un largo o constante, carga en el acumulador flotante un flotante o una constante, carga un contador de temporización en el acumulador 16 bits Variables : M o %MW, C o %C, L o %MD, F o %MF, T o %T Direccionamiento: absoluto, indirecto, inmediato Ver también : STA Ejemplo : lda 200 ; carga la constante 200 en el acumulador 16 bits lda 0.01R ; carga la constante real 0.01 en el acumulador flotante lda t10 ; carga el contador de la temporización 10 en ; el acumulador AUTOMGEN7 98 (C)opyright 2002 IRAI Manual de referencia del lenguaje LTI Nombre : LTI - long to integer Función : transfiere el acumulador 32 bits al acumulador 16 bits Variables : ninguna Direccionamiento: acumulador Ver también : ITL Ejemplo : lda l200 lti aaa sta m1000 ; deja los 16 bits de peso débil de l200 en m1000 AUTOMGEN7 99 (C)opyright 2002 IRAI Manual de referencia del lenguaje MLA Nombre : MLA - multiples accumulator Función : multiplicación del acumulador 16 bits por una palabra o constante ; multiplicación del acumulador 32 bits por un largo o constante, multiplicación del acumulador flotante por un flotante o constante; para el acumulador 16 bits, los 16 bits de peso fuerte del resultado de la multiplicación se transfieren a m0 Variables : M o %MW, L o %MD, F o %MF Direccionamiento: absoluto, indirecto, inmediato Ver también : DVA Ejemplo : lda m200 mla 10 sta m201 ; multiplica m200 por 10, m201 está cargado con los ; 16 bits de peso débil, y m0 con los 16 bits de ; peso fuerte AUTOMGEN7 100 (C)opyright 2002 IRAI Manual de referencia del lenguaje MTA Nombre : MTA - memory to accumulator Función : transfiere el contenido de una dirección de memoria al acumulador 16 bits; la palabra o constante especificada define el offset de la dirección de memoria a alcanzar, la palabra m0 debe estar cargada con el valor del segmento de la dirección de memoria a alcanzar; utilizable sólo con el ejecutor PC Variables : M o %MW Direccionamiento: indirecto, inmediato Ver también : ATM Ejemplo : lda $b800 sta m0 mta $10 ; coloca el valor contenido en la dirección $b800:$0010 ; en el acumulador 16 bits AUTOMGEN7 101 (C)opyright 2002 IRAI Manual de referencia del lenguaje NEQ Nombre : NEQ - not equal Función : fuerza una variable a 0 si el test es verdadero, en caso contrario, la variable se fuerza a 1 Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U Direccionamiento: absoluto, indirecto (salvo con las variables X) Ver también : EQU, SET, RES, INV Ejemplo : neq o0 and i00 ; fuerza la salida o0 al estado complementado de la entrada ; i10 lda 10 sta m200 neq o(200) and i0 ; fuerza o10 al estado complementado de la entrada i0 $t0=100 neq t0 and i0 neq o0 and t0 ; fuerza o0 al estado de i0 con un retraso en la ; desactivación de 10 segundos AUTOMGEN7 102 (C)opyright 2002 IRAI Manual de referencia del lenguaje ORA Nombre : ORA - or accumulator Función : efectúa un O lógico entre el acumulador 16 bits y una palabra o una constante, o entre el acumulador 32 bits y un largo o una constante Variables : M o %M, L o %MD Direccionamiento: absoluto, indirecto, inmediato Ver también : ANA, XRA Ejemplo : ora %1111111100000000 ; fuerza los 8 bits de peso fuerte del ; acumulador 16 bits a 1 ora $ffff0000L ; fuerza los 16 bits de peso fuerte del acumulador 32 bits ;a1 AUTOMGEN7 103 (C)opyright 2002 IRAI Manual de referencia del lenguaje RES Nombre : RES - reset Función : fuerza una variable booleana, una palabra, un contador, un largo, el acumulador 16 bits o el acumulador 32 bits a 0 Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U, M o %MW, C o %C, L o %MD Direccionamiento: absoluto, indirecto (salvo con las variables X), acumulador Ver también : NEQ, SET, EQU, INV Ejemplo : res o0 ; fuerza la salida o0 a 0 lda 10 sta m200 res o(200) and i0 ; fuerza o10 a 0 si la entrada i0 está en 1 res c0 ; fuerza el contador 0 a 0 AUTOMGEN7 104 (C)opyright 2002 IRAI Manual de referencia del lenguaje RET Nombre : RET - return Función : marca el retorno de un subprograma y coloca en el acumulador 16 bits una palabra o una constante; o coloca en el acumulador 32 bits un largo o una constante, o coloca en el acumulador flotante un flotante o una constante Variables : M o %MW, L o %MD, F o %MF Direccionamiento: absoluto, indirecto, inmediato Ver también : JSR Ejemplo : ret 0 ; retorno de subprograma colocando 0 en ; el acumulador 16 bits ret f200 ; retorno de subprograma colocando el contenido ; de f200 en el acumulador flotante AUTOMGEN7 105 (C)opyright 2002 IRAI Manual de referencia del lenguaje RFC Nombre : RFC - read flag: carry Función : transfiere el contenido del indicador de retención a una variable booleana Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U Direccionamiento: absoluto Ver también : RFZ, RFS, RFO Ejemplo : rfc o0 ; transfiere el indicador de retención a o0 lda m200 ada m300 sta m400 rfc b99 lda m201 ada m301 sta m401 inc m401 and b99 ; efectúa una suma sobre 32 bits ; (m400,401)=(m200,201)+(m300,301) ; m200, m300 y m400 son los pesos débiles ; m201, m301 y m401 son los pesos fuertes AUTOMGEN7 106 (C)opyright 2002 IRAI Manual de referencia del lenguaje RFO Nombre : RFO - read flag: overflow Función : transfiere el contenido del indicador de exceso a una variable booleana Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U Direccionamiento: absoluto Ver también : RFZ, RFS, RFC Ejemplo : rfo o0 ; transfiere el indicador de exceso a o0 AUTOMGEN7 107 (C)opyright 2002 IRAI Manual de referencia del lenguaje RFS Nombre : RFS - read flag: signe Función : transfiere el contenido del indicador de signo a una variable booleana Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U Direccionamiento: absoluto Ver también : RFZ, RFC, RFO Ejemplo : rfs o0 ; transfiere el indicador de signo a o0 AUTOMGEN7 108 (C)opyright 2002 IRAI Manual de referencia del lenguaje RFZ Nombre : RFZ - read flag: zero Función : transfiere el contenido del indicador de resultado nulo a una variable booleana Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U Direccionamiento: absoluto Ver también : RFC, RFS, RFO Ejemplo : rfz o0 ; transfiere el indicador de resultado nulo a o0 lda m200 cpa m201 rfz o0 ; posiciona o0 en 1 si m200 es igual a m201 ; o en 0 en caso contrario AUTOMGEN7 109 (C)opyright 2002 IRAI Manual de referencia del lenguaje RIN Nombre : RIN - read input Función : efectúa una lectura de las entradas físicas. Esta función se implementa únicamente en destinos Z y varía según el destino. Consultar la documentación relativa a cada ejecutor para más detalles. Variables : ninguna Direccionamiento: inmediato Ver también : WOU AUTOMGEN7 110 (C)opyright 2002 IRAI Manual de referencia del lenguaje RLA Nombre Función : : RLA - rotate left accumulator efectúa una rotación a la izquierda de los bits del acumulador 16 bits o 32 bits; el bit evacuado a la izquierda entra a la derecha; el argumento de esta función es una constante que precisa el número de desfases a efectuar; el tamaño del argumento (16 o 32 bits) determina cuál es el acumulador que debe sufrir la rotación Variables : ninguna Direccionamiento: inmediato Ver también : RRA Ejemplo : ana $f000 ; aísla el dígito de peso fuerte del acumulador 16 bits rla 4 ; y lo lleva a la derecha rla 8L ; efectúa 8 rotaciones a la izquierda de los bits del ; acumulador 32 bits AUTOMGEN7 111 (C)opyright 2002 IRAI Manual de referencia del lenguaje RRA Nombre : RRA - rotate right accumulator Función : efectúa una rotación a la derecha de los bits del acumulador 16 bits o 32 bits; el bit evacuado a la derecha entra a la izquierda; el argumento de esta función es una constante que precisa el número de desfases a efectuar; el tamaño del argumento (16 o 32 bits) determina si es el acumulador 16 o 32 bits el que deberá sufrir la rotación Variables : ninguna Direccionamiento: inmediato Ver también : RLA Ejemplo : ana $f000 ; aísla el dígito de peso fuerte del acumulador 16 bits rra 12 ; y lo lleva a la derecha. rra 1L ; efectúa una rotación de los bits del acumulador 32 bits ; de una posición hacia la derecha AUTOMGEN7 112 (C)opyright 2002 IRAI Manual de referencia del lenguaje SBA Nombre : SBA - substacts accumulator Función : quita el contenido de una palabra o una constante al acumulador 16 bits; quita el contenido de un largo o una constante al acumulador 32 bits; quita el contenido de un flotante o una constante al acumulador flotante Variables : M o %MW, L o %MD, F o %MF Direccionamiento: absoluto, indirecto, inmediato Ver también : ADA Ejemplo : sba 200 ; quita 200 al acumulador 16 bits sba f(421) ; quita el contenido del flotante cuyo número está ; contenido en la palabra 421 al acumulador flotante AUTOMGEN7 113 (C)opyright 2002 IRAI Manual de referencia del lenguaje SET Nombre : SET - set Función : fuerza una variable booleana a 1; fuerza todos los bits de una palabra, contador, largo o del acumulador 16 bits o del acumulador 32 bits a 1 Variables : I o %I, O o %Q, B o %M, T o %T, X o %X, U, M o %MW, C o %C, L o %MD Direccionamiento: absoluto, indirecto (salvo con las variables X), acumulador Ver también : NEQ, RES, EQU, INV Ejemplo : set o0 ; fuerza la salida o0 a 1 lda 10 sta m200 set o(200) and i0 ; fuerza o10 a 1 si la entrada i0 está en 1 set m200 ; fuerza m200 al valor -1 set aal ; fuerza todos los bits del acumulador 32 bits a 1 AUTOMGEN7 114 (C)opyright 2002 IRAI Manual de referencia del lenguaje SQR Nombre : SQR - square root Función : calcula la raíz cuadrada del acumulador flotante Variables : ninguna Direccionamiento: acumulador Ver también : ABS Ejemplo : lda 9 itf aaa sqr aaf fti aaa sta m200 ; deja el valor 3 en m200 AUTOMGEN7 115 (C)opyright 2002 IRAI Manual de referencia del lenguaje STA Nombre : STA - store accumulator Función : almacena el acumulador 16 bits en un contador o una palabra; almacena el acumulador 32 bits en un largo, almacena el acumulador flotante en un flotante, almacena el acumulador 16 bits en una consigna de temporización Variables : M o %MW, C o %C, L o %MD, F o %MF, T o %T Direccionamiento: absoluto, indirecto Ver también : LDA Ejemplo : sta m200 ; transfiere el contenido del acumulador 16 bits ; a la palabra 200 sta f200 ; transfiere el contenido del acumulador flotante ; al flotante 200 sta l200 ; transfiere el acumulador 32 bits al largo l200 AUTOMGEN7 116 (C)opyright 2002 IRAI Manual de referencia del lenguaje TSA Nombre : TSA - test accumulator Función : efectúa un Y lógico entre el acumulador 16 bits y una palabra o una constante; efectúa un Y lógico entre el acumulador 32 bits y un largo o una constante, opera de manera similar a la instrucción ANA, pero sin modificar el contenido del acumulador Variables : M o %MW, L o %MD Direccionamiento: absoluto, indirecto, inmediato Ver también : ANA Ejemplo : tsa %10 rfz b99 jmp :continuación: and b99 ; ramificación en label :continuación: si el bit 1 ; del acumulador 16 bits está en 0 AUTOMGEN7 117 (C)opyright 2002 IRAI Manual de referencia del lenguaje WOU Nombre : WOU - write output Función : efectúa una escritura de las salidas físicas. Esta función se implementa únicamente en destinos Z (y varía según el destino). Consultar la documentación relativa a cada ejecutor para más detalles. Variables : ninguna Direccionamiento: inmediato Ver también : RIN AUTOMGEN7 118 (C)opyright 2002 IRAI Manual de referencia del lenguaje XRA Nombre : XRA - xor accumulator Función : efectúa un O EXCLUSIVO entre el acumulador 16 bits y una palabra o una constante; efectúa un O EXCLUSIVO entre el acumulador 32 bits y un largo o una constante Variables : M o %MW, L o %MD Direccionamiento: absoluto, indirecto, inmediato Ver también : ORA, ANA, Ejemplo : xra %1111111100000000 ; invierte los 8 bits de peso fuerte del acumulador 16 bits xra 1L ; invierte el bit de peso débil del acumulador 32 bits AUTOMGEN7 119 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.10.4. Macro-instrucción Las macro-instrucciones son nuevas instrucciones del lenguaje literal detrás de las cuales se esconde un conjunto de instrucciones de base. Sintaxis de llamado de una macro-instrucción: « %<nombre de la macro-instrucción*> {parámetros ...} » Sintaxis de declaración de una macro-instrucción: #MACRO <programa> #ENDM Esta declaración se encuentra en un archivo que lleva el nombre de la macroinstrucción y la extensión « .M ». El archivo .M puede estar en el subrepertorio « lib » del repertorio de instalación de AUTOMGEN o en los recursos del proyecto. Es posible pasar diez parámetros a la macro-instrucción. A ser llamados, estos parámetros se ubicarán sobre la misma línea que la macro-instrucción y estarán separados por un espacio. En el programa de la macro-instrucción la sintaxis « {?n} » hace referencia al parámetro n. Ejemplo: Realicemos la macro-instrucción « cuadrado » que eleva el primer parámetro de la macro-instrucción al cuadrado y pone el resultado en el segundo parámetro. Llamado de la macro-instrucción: lda 3 sta m200 %cuadrado m200 m201 ; m201 contendrá 9 * El nombre de la macro-instrucción puede ser un camino de acceso completo al archivo « .M », puede contener una designación de lector y de repertorio. AUTOMGEN7 120 (C)opyright 2002 IRAI Manual de referencia del lenguaje Archivo « CUADRADO.M »: #MACRO lda {?0} mla {?0} sta {?1} #ENDM 1.10.5. Biblioteca La noción de biblioteca permite definir recursos que se compilarán una sola vez en una aplicación, más allá de la cantidad de llamados a esos recursos. Sintaxis de definición de una biblioteca: #LIBRARY <nombre de la biblioteca> <programa> #ENDL <nombre de la biblioteca> es el nombre de la función que será llamada por una instrucción jsr :<nombre de la biblioteca>: Al primer llamado encontrado por el compilador, el código de la biblioteca se compila. Para los siguientes, el llamado se dirige simplemente a la rutina existente. Este mecanismo se adapta particularmente al empleo de bloques funcionales y macro-instrucciones para limitar la generación de código en caso de utilización múltiple de los mismos recursos programas. Las palabras m120 a m129 se reservan a las bibliotecas y pueden utilizarse para el pasaje de los parámetros. 1.10.6. Macro-instrucciones predefinidas En el subrepertorio « LIB » del repertorio donde se ha instalado AUTOMGEN hay macro-instrucciones de conversión. También están presentes los equivalentes en bloques funcionales. 1.10.7. Descripción de las macro-instrucciones predefinidas 1.10.7.1. Conversiones %ASCTOBIN <dos primeros dígitos> <dos últimos dígitos> <resultado en binario> AUTOMGEN7 121 (C)opyright 2002 IRAI Manual de referencia del lenguaje Efectúa una conversión ASCII hexadecimal (dos primeros parámetros) a binario (tercer parámetro). En salida el acumulador contiene $FFFF si los dos primeros parámetros no son números ASCII válidos, y si no 0. Todos los parámetros son palabras de 16 bits. %BCDTOBIN <valor en BCD> <valor en binario> Efectúa una conversión BCD a binario. En salida el acumulador contiene $FFFF si el primer parámetro no es un número bcd válido, y si no 0. Los dos parámetros son palabras de 16 bits. %BINTOASC <valor en binario> <resultado parte alta> <resultado parte baja> Efectúa una conversión binario (primer parámetro) a ASCII hexadecimal (segundo y tercer parámetros). Todos los parámetros son palabras de 16 bits. %BINTOBCD <valor en binario> <valor en BCD> Efectúa una conversión BCD (primer parámetro) a binario (segundo parámetro). En salida el acumulador contiene $FFFF si el número binario no puede convertirse a BCD, y si no 0. %GRAYTOB <valor en código GRAY> <valor en binario> Efectúa una conversión código Gray (primer parámetro) a binario (segundo parámetro). 1.10.7.2. Tratamiento con tabla de palabras %COPY <primera palabra tabla fuente> <primera palabra tabla destino> <número de palabras> Copia una tabla de palabras fuente en una tabla de palabras destino. La longitud se da en número de palabras. %COMP <primera palabra tabla 1> <primera palabra tabla 2> <número de palabras> <resultado> Compara dos tablas de palabras. El resultado es una variable binaria que adopta el valor 1 si todos los elementos de la tabla 1 son idénticos a la tabla 2. %FILL <primera palabra tabla> <valor> <número de palabras> Llena una tabla de palabras con un valor. AUTOMGEN7 122 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.10.7.3. Tratamiento en cadena de caracteres La codificación de las cadenas de caracteres es la siguiente: un carácter por palabra, una palabra que contiene el valor 0 marca el fin de la cadena. En las macroinstrucciones, las cadenas pasan a parámetros designando la primera palabra que las compone. %STRCPY <cadena fuente> <cadena destino> Copia una cadena en otra. %STRCAT <cadena fuente> <cadena destino> Añade la cadena fuente al final de la cadena destino. %STRCMP <cadena 1> <cadena 2> <resultado> Compara dos cadenas. El resultado es una variable booleana que pasa a 1 si las dos cadenas son idénticas. %STRLEN <cadena> <resultado> Coloca la longitud de la cadena en la palabra resultado. %STRUPR <cadena> Transforma todos los caracteres de la cadena en mayúsculas. %STRLWR <cadena> Transforma todos los caracteres de la cadena en minúsculas. Ejemplo: Conversión de m200 (binario) a m202, m203 en 4 dígitos (ASCII bcd) %bintobcd m200 m201 %bintoasc m201 m202 m203 1.10.8. Ejemplo en lenguaje literal bajo nivel Condiciones: empecemos con el ejemplo más simple: ida y vuelta de una locomotora por la vía 1. AUTOMGEN7 123 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución: 0 set _av1_ set _dv1_ and _t1d_ res _dv1_ and _t1i_ exemple\lit\littéral bas niveau1.agn Un ejemplo un poco más evolucionado. Condiciones: La locomotora ahora deberá marcar una espera de 10 segundos en el extremo derecho de la vía y otra de 4 segundos en el izquierdo. Solución: 0 $t0=100,40 equ u100 and _t1i_ and _t1d_ equ u101 orr t0 eor t1 equ _av1_ orr u100 eor u101 set _dv1_ and _t1d_ equ t0 and _t1d_ res _dv1_ and _t1i_ equ t1 and _t1i_ exemple\lit\littéral bas niveau 2.agn Otro ejemplo: Condiciones: Hacer parpadear todos los semáforos de la maqueta. AUTOMGEN7 124 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución: 0 ; table contenant l'adresse de tous les feux $_table_=123,?_s1d_,?_s1i_,?_s2a_,?_s2b_ $...=?_s3d_,?_s3i_,?_s4a_,?_s4b_ $...=?_s5i_,?_s5d_,?_s6d_,?_s6i_ $...=?_s7i_,?_s7d_,?_s8d_,?_s8i_ $...=-1 ; initialise l'index sur le debut de la table lda ?_table_ sta _index_ :boucle: ; la valeur -1 marque la fin de la table jmp :fin: and m(_index_)=-1 ; inverser la sortie lda m(_index_) sta _index2_ inv o(_index2_) inc _index_ jmp :boucle: :fin: exemple\lit\littéral bas niveau 3.agn Este ejemplo muestra cómo emplear las predisposiciones, que aquí se utilizan para crear una tabla de direcciones de variables. La tabla contiene la dirección de todas las salidas que pilotean los semáforos de la maqueta. A cada ciclo de ejecución, el estado de todos los semáforos se invierte. Se presenta un problema y es que los semáforos parpadean demasiado rápido. Modifiquemos el ejemplo. Condiciones: Ahora hay que invertir el estado de los semáforos uno por uno a cada décima de segundo. AUTOMGEN7 125 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución: 10 ; ta b le c o nt en an t l 'a d re ss e d e to u s le s f eu x $_ ta b le _= 1 23 ,? _s 1 d_ ,? _ s1 i_ ,? _ s2 a_ , ?_ s2 b _ $. .. = ?_ s3 d _, ?_ s3 i _, ?_ s 4a _, ?_ s 4b _ $. .. = ?_ s5 i _, ?_ s5 d _, ?_ s 6d _, ?_ s 6i _ $. .. = ?_ s7 i _, ?_ s7 d _, ?_ s 8d _, ?_ s 8i _ $. .. = -1 $_ in d ex _= ? _t ab le _ :b ou c le : ; la va le u r -1 m a rq ue la f in de l a t ab l e jm p : fi n d e ta bl e : an d m (_ in d ex _) = -1 ; in v er se r l a so r ti e ld a m (_ in d ex _) st a _ in de x 2_ in v o (_ in d ex 2_ ) in c _ in de x _ jm p : fi n: :f in de t a bl e: ld a ? _t ab l e_ st a _ in de x _ :f in : =1 20 t 0/ x2 0 /1 exemple\lit\littéral bas niveau 4.agn 1.11. Lenguaje literal extendido El lenguaje literal extendido es un « superconjunto » del lenguaje literal bajo nivel. Permite escribir más simplemente y bajo una forma más concisa ecuaciones booleanas y numéricas. También permite escribir estructuras de tipo IF ... THEN ... ELSE y WHILE ... ENDWHILE (bucle). AUTOMGEN7 126 (C)opyright 2002 IRAI Manual de referencia del lenguaje El lenguaje literal extendido está sujeto a las mismas reglas que el lenguaje literal bajo nivel, utiliza la misma sintaxis para las variables, los mnemónicos, los tipos de test (frentes, estado complementado, estado inmediato) y los modos de direccionamiento. Es posible « mezclar » el lenguaje literal bajo nivel con el lenguaje literal extendido. Cuando el compilador de lenguaje literal detecta una línea escrita en lenguaje literal extendido, la descompone en instrucciones de lenguaje literal bajo nivel y luego la compila. 1.11.1. Escritura de ecuaciones booleanas Sintaxis general: « variable bool.=(tipo de asignación) (variable bool. 2 operador 1 variable bool. 3... operador n -1 variable bool. n ) » El tipo de asignación debe precisarse si no es « Asignación ». Puede ser: Ö « (/) »: asignación complementada, Ö « (0) »: puesta en cero, Ö « (1) »: puesta en uno. Los operadores pueden ser: Ö « . »: y, Ö « + »: o. Las ecuaciones pueden contener varios niveles de paréntesis para precisar el orden de evaluación. Las ecuaciones se evalúan en forma predeterminada de izquierda a derecha. Ejemplos y equivalencias con el lenguaje literal bajo nivel: o0=(i0) equ o0 and i0 o0=(i0.i1) equ o0 and i0 and i1 o0=(i0+i1) equ o0 orr i0 eor i1 o0=(1) set o0 o0=(0) res o0 o0=(1)(i0) set o0 and i0 o0=(0)(i0) res o0 and i0 AUTOMGEN7 127 (C)opyright 2002 IRAI Manual de referencia del lenguaje o0=(1)(i0.i1) set o0 and i0 and i1 o0=(0)(i0+i1) res o0 orr o0 eor i1 o0=(/)(i0) neq o0 and i0 o0=(/)(i0.i1) neq o0 and i0 and i1 o0=(/i0) equ o0 and /i0 o0=(/i0./i1) equ o0 and /i0 and /i1 o0=(c0=10) equ o0 and c0=10 o0=(m200<100+m200>200) equ o0 orr m200<100 eor m200>200 1.11.2. Escritura de ecuaciones numéricas Sintaxis general para los enteros: « variable num.1=[variable num.2 operador 1 ... operador n-1 variable num.n] » Las ecuaciones pueden contener varios niveles de corchetes para precisar el orden de evaluación. Las ecuaciones se evalúan en forma predeterminada de izquierda a derecha. Los operadores para los enteros 16 y 32 bits pueden ser: « + »: suma (equivalente a la instrucción ADA), « - »: resta (equivalente a la instrucción SBA), « * »: multiplicación (equivalente a la instrucción MLA), « / »: división (equivalente a la instrucción DVA), « < »: desfase a izquierda (equivalente a la instrucción RLA), « > »: desfase a derecha (equivalente a la instrucción RRA), « & »: « Y » binario (equivalente a la instrucción ANA), « | »*: « O » binario (equivalente a la instrucción ORA), « ^ »: « O exclusivo » binario (equivalente a la instrucción XRA). Los operadores para los flotantes pueden ser: Ö « + »: suma (equivalente a la instrucción ADA), Ö « - »: resta (equivalente a la instrucción SBA), Ö « * »: multiplicación (equivalente a la instrucción MLA), Ö « / »: división (equivalente a la instrucción DVA). No se puede precisar una constante en las ecuaciones con los flotantes. Si es necesario, hay que utilizar predisposiciones sobre los flotantes. * Este carácter suele asociarse a la combinación de teclas [ALT] + [6] en los teclados. AUTOMGEN7 128 (C)opyright 2002 IRAI Manual de referencia del lenguaje Las ecuaciones con los flotantes pueden llamar a las funciones « SQR » y « ABS ». Observación: según la complejidad de las ecuaciones, el compilador puede utilizar variables intermedias. Estas variables son las palabras m53 a m59 para los enteros 16 bits, los largos l53 a l59 para los enteros 32 bits y los flotantes f53 a f59. Ejemplos y equivalencias con el lenguaje literal bajo nivel: M200=[10] lda 10 sta m200 M200=[m201] lda m201 sta m200 M200=[m201+100] lda m201 ada 100 sta m200 M200=[m200+m201-m202] lda m200 ada m201 sba m202 sta m200 M200=[m200&$ff00] lda m200 ana $ff00 sta m200 F200=[f201] lda f201 sta f200 F200=[f201+f202] lda f201 ada f202 sta f200 F200=[sqr[f201]] lda f201 sqr aaa sta f200 F200=[sqr[abs[f201*100R]]] lda f201 mla 100R abs aaa sqr aaa sta f200 L200=[l201+$12345678L] lda l201 ada $12345678L sta l200 AUTOMGEN7 129 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.11.3. Estructura de tipo IF ... THEN ... ELSE ... Sintaxis general: IF(test) THEN acción si test verdadero ENDIF ELSE acción si test falso ENDIF El test debe respetar la sintaxis descrita en el capítulo sobre ecuaciones booleanas. Puede figurar sólo una acción si test verdadero, o una acción si test falso. Es posible imbricar varias estructuras de este tipo. Los bits Sistema u90 a u99 se utilizan como variables temporales para gestionar este tipo de estructura. Ejemplos: IF(i0) THEN inc m200 ; incrementar la palabra 200 si i0 ENDIF IF(i1+i2) THEN m200=[m200+10] ; añadir 10 a la palabra 200 si i1 o i2 ENDIF ELSE res m200 ; si no borrar m200 ENDIF 1.11.4. Estructura de tipo WHILE ... ENDWHILE Sintaxis general: WHILE(test) acción a repetir mientras el test sea verdadero ENDWHILE AUTOMGEN7 130 (C)opyright 2002 IRAI Manual de referencia del lenguaje El test debe respetar la sintaxis descrita en el capítulo sobre ecuaciones booleanas. Es posible imbricar varias estructuras de este tipo. Los bits Sistema u90 a u99 se utilizan como variables temporales para gestionar este tipo de estructura. Ejemplos: m200=[0] WHILE(m200<10) set o(200) inc m200 ; incrementar la palabra 200 ENDWHILE Este ejemplo pone en uno las salidas o0 a o9. 1.11.5. Ejemplo de programa en lenguaje literal extendido Retomemos el primer ejemplo del capítulo anterior. Solución: 0 _ a v 1_ = ( 1 ) _ d v 1_ = ( 1 )( _ t 1 d_ ) _ d v 1_ = ( 0 )( _ t 1 i_ ) exemple\lit\littéral étendu 1.agn Enriquezcamos nuestro ejemplo con cálculos. Condiciones: Calcular la velocidad en milímetros por segundo y en metros por hora de la locomotora en el trayecto de izquierda a derecha. AUTOMGEN7 131 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución: 0 _av1_=(1) _dv1_=(1)(_t1d_) _dv1_=(0)(_t1i_) È dv1 _temps aller_=[m32] Ç dv1 $_longueur_=300 ; en mm $_mille_=1000; $_dixdansh_=36000; $_dix_=10; _temps mis_=[m32-_temps aller_] IF(_temps mis_<0) THEN _temps mis_=[_temps mis_+100] ENDIF lda _temps mis_ itf aaa sta _dixieme_ _vitesse mm par s_=[_longueur_/[_dixieme_/_dix_]] _vitesse m par h_=[[_longueur_/_mille_]/[_dixieme_/_dixdansh_]] exemple\lit\littéral étendu 2.agn La palabra 32 se utiliza para leer el tiempo Sistema. El valor luego se transfiere a flotantes para poder efectuar los cálculos sin perder precisión. 1.12. Lenguaje literal ST El lenguaje literal ST es el lenguaje literal estructurado definido por la norma CEI1131-3. Este lenguaje permite escribir ecuaciones booleanas y numéricas y estructuras de programación. 1.12.1. Generalidades El lenguaje literal ST se utiliza en los mismos sitios que el lenguaje literal bajo nivel y el lenguaje literal extendido. AUTOMGEN7 132 (C)opyright 2002 IRAI Manual de referencia del lenguaje Estas directivas permiten definir secciones en lenguaje literal ST: « #BEGIN_ST » marca el principio de una sección en lenguaje ST. « #END_ST » marca el fin de una sección en lenguaje ST. Ejemplo: m200=[50] ; lenguaje literal extendido #BEGIN_ST m201:=4; (* lenguaje ST *) #END_ST También es posible optar por el uso del lenguaje ST para todo un folio. La elección se efectúa en el cuadro de diálogo de propiedades de cada folio. En un folio con lenguaje predeterminado ST es posible insertar lenguaje literal bajo nivel y extendido encerrando las líneas con las dos directivas « #END_ST » y « #BEGIN_ST ». Para el lenguaje ST los comentarios deben empezar con « (* » y terminar con « *) ». Las instrucciones del lenguaje ST terminan con el carácter « ; ». Es posible escribir varias instrucciones en una misma línea. Ejemplo: o0:=1; m200:=m200+1; 1.12.2. Ecuaciones booleanas La sintaxis general es: variable := ecuación booleana; La ecuación booleana puede componerse de una constante, una variable o varias variables separadas por operadores. Las constantes pueden ser: 0, 1, FALSE o TRUE. AUTOMGEN7 133 (C)opyright 2002 IRAI Manual de referencia del lenguaje Ejemplos: o0:=1; o1:=FALSE; Los operadores que permiten separar varias variables son: + (o), . (y), OR o AND. El « Y » tiene prioridad sobre el « O ». Ejemplo: o0:=i0+i1.i2+i3; Será tratado como: o0:=i0+(i1.i2)+i3; Los paréntesis pueden utilizarse en las ecuaciones para especificar las prioridades. Ejemplo: o0:=(i0+i1).(i2+i3); Pueden utilizarse tests numéricos. Ejemplo: o0:=m200>5.m200<100; 1.12.3. Ecuaciones numéricas La sintaxis general es: variable := ecuación numérica; La ecuación numérica puede componerse de una constante, una variable o varias variables y constantes separadas por operadores. Las constantes pueden ser valores expresados en decimal, hexadecimal (prefijo 16#) o binario (prefijo 2#). AUTOMGEN7 134 (C)opyright 2002 IRAI Manual de referencia del lenguaje Ejemplos: m200:=1234; m201:=16#aa55; m202:=2#100000011101; Los operadores que permiten separar varias variables o constantes se ordenan según la prioridad: * (multiplicación), / (división), + (suma), - (resta), & o AND (Y binario), XOR (O exclusivo binario), OR (O binario). Ejemplos: m200:=1000*m201; m200:=m202-m204*m203; (* equivalente a m200:=m202-(m204*m203) *) Los paréntesis pueden utilizarse en las ecuaciones para especificar las prioridades. Ejemplo: m200:=(m202-m204)*m203; 1.12.4. Estructuras de programación 1.12.4.1. Test SI ENTONCES SI NO Sintaxis: IF condición THEN acción ENDIF; y IF condición THEN acción ELSE acción ENDIF; Ejemplo: if i0 then o0:=TRUE; else o0:=FALSE; if i1 then m200:=4; endif; endif ; AUTOMGEN7 135 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.12.4.2. Bucle MIENTRAS Sintaxis: WHILE condición DO acción ENDWHILE; Ejemplo: while m200<1000 do m200:=m200+1; endwhile; 1.12.4.3. Bucle HASTA QUE Sintaxis: REPEAT acción UNTIL condición; ENDREPEAT; Ejemplo: repeat m200:=m200+1; until m200=500 endrepeat; 1.12.4.4. Bucle DESDE HASTA Sintaxis: FOR variable:=valor de inicio TO valor de fin DO acción ENDFOR; o FOR variable:=valor de inicio TO valor de fin BY no DO acción ENDFOR; Ejemplo: for m200:=0 to 100 by 2 do m201:=m202*m201; endfor; AUTOMGEN7 136 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.12.4.5. Salida de bucle La palabra clave « EXIT » permite salir de un bucle. Ejemplo: while i0 m200:=m200+1; if m200>1000 then exit; endif; endwhile; 1.12.5. Ejemplo de programa en lenguaje literal extendido Retomemos el primer ejemplo del capítulo anterior. Solución: 0 _ a v 1 _ : = T RU E ; i f _ t 1 d _ t h e n _ d v1 _ : = T R U E ; e n d i f ; i f _ t 1 i _ t h e n _ d v1 _ : = F A L S E; e n d i f ; exemple\lit\littéral ST 1.agn 1.13. Organigrama AUTOMGEN implementa una programación de tipo « organigrama ». Para este tipo de programación se deben utilizar los lenguajes literales. Consultar los capítulos anteriores para saber cómo utilizarlos. La ventaja de la programación bajo forma de organigrama es la representación gráfica de un tratamiento algorítmico. Contrariamente al lenguaje Grafcet, la programación bajo forma de organigrama genera un código que se ejecutará una vez por ciclo de escrutación. Esto significa que no podemos quedarnos a la espera en un rectángulo de organigrama; es obligatorio que la ejecución salga del organigrama para poder seguir ejecutando el programa. Es importante no olvidar este punto cuando se elige este lenguaje. AUTOMGEN7 137 (C)opyright 2002 IRAI Manual de referencia del lenguaje Es posible diseñar sólo rectángulos. El contenido de los rectángulos y los vínculos determinan si el rectángulo es una acción o un test. 1.13.1. Diseño de un organigrama Los rectángulos se diseñan eligiendo el comando « Más … / Caja de código » del menú contextual (hacer clic con el botón derecho del ratón sobre el fondo del folio para abrir el menú contextual). Es necesario colocar un bloque (tecla [<]) en la entrada de cada rectángulo; esta entrada debe estar ubicada en la parte superior del rectángulo. Si el rectángulo representa una acción, habrá una sola salida materializada por un bloque (tecla [E]) abajo y a la izquierda del rectángulo. Un rectángulo de acción: Si el rectángulo representa un test, habrá obligatoriamente dos salidas. La primera, materializada por un bloque (tecla [E]) abajo y a la izquierda representa la salida si el test es verdadero; la segunda, materializada por un bloque (tecla [=]) inmediatamente a la derecha de la otra salida representa la salida si el test es falso. AUTOMGEN7 138 (C)opyright 2002 IRAI Manual de referencia del lenguaje Un rectángulo de test: Las ramas de organigramas deben terminar con un rectángulo sin salida que eventualmente puede quedar vacío. 1.13.2. Contenido de los rectángulos 1.13.2.1. Contenido de los rectángulos de acción Los rectángulos de acción pueden contener cualquier instrucción de lenguaje literal. 1.13.2.2. Contenido de los rectángulos de test Los rectángulos de test deben contener un test que respete la sintaxis de la parte test de la estructura de tipo IF...THEN...ELSE... del lenguaje literal extendido. Por ejemplo: IF (i0) Es posible escribir antes de este test acciones en el rectángulo de test. Esto permite, por ejemplo, efectuar ciertos cálculos antes del test. Si por ejemplo queremos testear si la palabra 200 es igual a la palabra 201 más 4: m202=[m201+4] IF(m200=m202) 1.14. Ilustración Nuestro ya clásico primer ejemplo consiste en hacer ir y venir a una locomotora por la vía 1 de la maqueta. AUTOMGEN7 139 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución: s et _ a v1 _ i f( _t 1 d_ ) s et _ d v1 _ if (_ t1 i _) re s _d v 1_ exemple\organigramme\organigramme 1.agn Segundo ejemplo Condiciones: Hacer parpadear todos los semáforos de la maqueta. Los semáforos cambian de estado cada segundo. AUTOMGEN7 140 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución: $t0=10 t0=( t0) _ i n d e x % m _ = [ ? _ s 1d _ ] i n v o ( _ i n d e x % m _) a n d t 0 inc _index%m_ _ c a l c u l % m _ = [ ? _ s8 i _ + 1 ] I F ( _ i n d e x % m _ = _ ca l c u l % m _ ) exemple\organigramme\organigramme 2.agn Notar la utilización de símbolos automáticos en este ejemplo. AUTOMGEN7 141 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.15. Bloques funcionales AUTOMGEN implementa la noción de bloques funcionales. Este método de programación modular permite asociar a un elemento gráfico un conjunto de instrucciones escritas en lenguaje literal. Los bloques funcionales pueden ser definidos por el programador. No tienen un número limitado. Por eso es posible constituir conjuntos de bloques funcionales que permiten una concepción modular y estandarizada de las aplicaciones. Los bloques funcionales se utilizan dentro de esquemas de tipo logigrama o ladder, poseen de una a n entradas booleanas y de una a n salidas booleanas. Si el bloque debe tratar variables no booleanas, éstas se mencionarán en el diseño del bloque funcional. El interior del bloque puede recibir parámetros: constantes o variables. Entrées booléennes du bloc (maximum 16) Paramètres du bloc (maximum 16) Sorties booléennes du bloc (maximum 16) 1.15.1. Creación de un bloque funcional Un bloque funcional está compuesto por dos archivos distintos: un archivo de extensión « .ZON » que contiene el diseño del bloque funcional y un archivo de extensión « .LIB » que contiene una serie de instrucciones escritas en lenguaje literal que definen el funcionamiento del bloque funcional. Los archivos « .ZON » y « .LIB » deben llevar el nombre del bloque funcional. Por ejemplo, si decidimos crear un bloque funcional « MEMORIA », deberemos crear los AUTOMGEN7 142 (C)opyright 2002 IRAI Manual de referencia del lenguaje archivos « MEMORIA.ZON » (para el diseño del bloque) y « MEMORIA.LIB » (para el funcionamiento del bloque). 1.15.2. Diseño del bloque y creación del archivo « .ZON » La envoltura de un bloque funcional está constituida por una caja de código a la que hay que añadir bloques dedicados a los bloques funcionales. Para diseñar un bloque funcional se deben efectuar las siguientes operaciones: Ö utilizar el asistente (recomendado) O: Ö diseñar una caja de código (utilizar el comando « Más …/Caja de código » del menú contextual): Ö colocar un bloque (tecla [8]) en el ángulo superior izquierdo de la caja de código: Ö colocar un bloque (tecla [9]) en el ángulo superior derecho de la caja de código: Ö borrar la línea que queda en la parte superior del bloque (la tecla [A] permite poner bloques blancos): AUTOMGEN7 143 (C)opyright 2002 IRAI Manual de referencia del lenguaje Ö hacer clic con el botón izquierdo del ratón en el ángulo superior izquierdo del bloque funcional, ingresar el nombre del bloque funcional, que no debe superar los 8 caracteres (los archivos « .ZON » y « .LIB » deberán llevar ese nombre), presionar [ENTER]; Ö si se necesitan entradas booleanas suplementarias, se debe utilizar un bloque (tecla [;]) o (tecla [:]); las entradas añadidas deben encontrarse inmediatamente debajo de la primera entrada, sin dejar ningún espacio libre; Ö si se necesitan salidas booleanas suplementarias, se debe añadir un bloque (tecla [>]) o (tecla [?]); las salidas añadidas deben encontrarse inmediatamente debajo de la primera salida, sin dejar ningún espacio libre; Ö el interior del bloque puede contener comentarios o parámetros; los parámetros se escriben entre llaves « {...} ». Todo lo que no se escriba entre llaves será ignorado por el compilador. Es interesante identificar el uso de las entradas y salidas booleanas dentro del bloque; Ö una vez terminado un bloque, se debe utilizar el comando « Seleccionar » del menú « Edición » para seleccionar el diseño del bloque funcional y guardarlo en un archivo « .ZON » con el comando « Copiar en » del menú « Edición ». AUTOMGEN7 144 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.15.3. Creación del archivo « .LIB » El archivo « .LIB » es un archivo de texto que contiene instrucciones en lenguaje literal (bajo nivel o extendido). Estas instrucciones definen el funcionamiento del bloque funcional. Una sintaxis especial permite hacer referencia a las entradas booleanas del bloque, a las salidas booleanas del bloque y a los parámetros del bloque. Para hacer referencia a una entrada booleana del bloque, se debe utilizar la sintaxis « {Ix} », donde x es el número de la entrada booleana expresado en hexadecimal (0 a f). Para hacer referencia a una salida booleana del bloque, se debe utilizar la sintaxis « {Ox} », donde x es el número de la salida booleana expresado en hexadecimal (0 a f). Para hacer referencia a un parámetro del bloque, se debe utilizar la sintaxis « {?x} », donde x es el número del parámetro en hexadecimal (0 a f). El archivo .LIB puede estar ubicado en el subrepertorio « lib » del repertorio de instalación de AUTOMGEN o en los recursos del proyecto. 1.15.4. Ejemplo simple de bloque funcional Creemos el bloque funcional « MEMORIA », que posee dos entradas booleanas (puesta en uno y puesta en cero) y una salida booleana (el estado de la memoria). El diseño del bloque contenido en el archivo « MEMORIA.ZON » es: El funcionamiento del bloque contenido en el archivo « MEMORIA.LIB » es: {O0}=(1)({I0}) {O0}=(0)({I1}) El bloque puede utilizarse de la siguiente manera: o AUTOMGEN7 145 (C)opyright 2002 IRAI Manual de referencia del lenguaje Para utilizar un bloque funcional en una aplicación, se debe elegir el comando « Pegar a partir de » del menú « Edición » y elegir el archivo « .ZON » correspondiente al bloque funcional a utilizar. 1.15.5. Ilustración Retomemos un ejemplo ya clásico: Condiciones: Ida y vuelta de una locomotora por la vía 1 de la maqueta. Solución: t1d ALLERRET capteur droit t1i capteur gauche alimentation AV1 direction DV1 BF aller /retour exemple\bf\bloc-fonctionnel 1.agn ; bloque funcional ALLERRET ; ida vuelta de una locomotora por una vía ; las entradas booleanas son los fines de carrera ; las salidas booleanas son la alimentación de la vía (0) y la dirección (1) ; alimentar siempre la vía set {O0} ; pilotear la dirección en función de los fines de carrera {O1}=(1)({I0}) {O1}=(0)({I1}) Para ilustrar el interés de la utilización de los bloques funcionales, completemos nuestro ejemplo. Condiciones: Ida y vuelta de dos locomotoras por las vías 1 y 3. AUTOMGEN7 146 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución: t1d A L L ER R E T c a p t eu r d r o i t t1i c a p t eu r g a u c h e a l i m e nt a t i o n AV1 d i re c t i o n DV1 a l i m e nt a t i o n AV3 B F a ll e r / r e t o ur t3d A L L ER R E T c a p t eu r d r o i t t3i c a p t eu r g a u c h e d i re c t i o n N D V3 B F a ll e r / r e t o ur exemple\bf\bloc-fonctionnel 2.agn Este ejemplo muestra que con el mismo bloque funcional se pueden hacer funcionar de manera idéntica diferentes módulos de una parte operativa. Completemos nuestro ejemplo para ilustrar la utilización de parámetros. Condiciones: Ahora las dos locomotoras deben marcar una espera al final de la vía. Para la locomotora 1: 10 segundos a la derecha y 4 segundos a la izquierda; para la locomotora 2: 20 segundos a la derecha y 8 segundos a la izquierda. AUTOMGEN7 147 (C)opyright 2002 IRAI Manual de referencia del lenguaje ; bloque funcional ARATT ; ida vuelta de una locomotora por una vía con espera ; las entradas booleanas son los fines de carrera ; las salidas booleanas son la alimentación de la vía (0) y la dirección (1) ; los parámetros son: ; 0: primera temporización ; 1: duración de la primera temporización ; 2: segunda temporización ; 3: duración de la segunda temporización ; predisposición de las dos temporizaciones ${?0}={?1} ${?2}={?3} ; alimentar la vía si no fines de carrera o si tempor. terminadas set {O0} res {O0} orr {I0} eor {I1} set {O0} orr {?0} eor {?2} ; gestión de las temporizaciones {?0}=({I0}) {?2}=({I1}) ; pilotear la dirección en función de los fines de carrera {O1}=(1)({I0}) {O1}=(0)({I1}) exemple\bf\bloc-fonctionnel 3.agn 1.15.6. Complemento de sintaxis Una sintaxis complementaria permite efectuar un cálculo con los números de variables referenciadas en el archivo « .LIB ». La sintaxis « ~+n » añadida a continuación de una referencia a una variable o un parámetro suma n. La sintaxis « ~-n » añadida a continuación de una referencia a una variable o un parámetro resta n. La sintaxis « ~*n » añadida a continuación de una referencia a una variable o un parámetro multiplica por n. Es posible escribir varios de estos comandos seguidos; se evalúan de izquierda a derecha. Este mecanismo es útil cuando un parámetro del bloque funcional debe permitir hacer referencia a una tabla de variables. Ejemplos: {?0}~+1 AUTOMGEN7 149 (C)opyright 2002 IRAI Manual de referencia del lenguaje hace referencia al elemento siguiente al primer parámetro; por ejemplo, si el primer parámetro es m200, esta sintaxis hace referencia a m201. M{?2}~*100~+200 hace referencia al tercer parámetro multiplicado por 100 más 200; por ejemplo, si el tercer parámetro es 1, esta sintaxis hace referencia a M 1*100 + 200, es decir M300. 1.16. Bloques funcionales evolucionados Esta funcionalidad permite crear bloques funcionales muy potentes con más simplicidad que los bloques funcionales gestionados por archivos escritos en lenguaje literal. Este método de programación permite un enfoque de tipo análisis funcional. Cualquier folio o conjunto de folios puede convertirse en un bloque funcional (a veces se habla de encapsular un programa). El o los folios que describen el funcionamiento de un bloque funcional pueden acceder a las variables externas del bloque funcional: las entradas booleanas del bloque, las salidas booleanas y los parámetros. El principio de utilización, particularmente de la utilización de las variables externas, es idéntico al de los viejos bloques funcionales. 1.16.1. Sintaxis Para referenciar una variable externa de un bloque funcional se debe utilizar un mnemónico que incluya el texto siguiente: {In} para referenciar la entrada booleana n, {On} para referenciar la salida booleana n, {?n} para referenciar el parámetro n. El mnemónico debe empezar con una letra. 1.16.2. Diferenciar viejos y nuevos bloques funcionales El nombre de archivo inscrito en el diseño bloque funcional indica si se trata de un viejo bloque funcional (gestionado por un archivo .LIB) o de un nuevo bloque funcional (gestionado por un folio .GR7). Para un viejo bloque funcional, el nombre no lleva extensión; para uno nuevo debe añadirse la extensión .GR7. El folio que contiene el código que gestiona el funcionamiento del bloque funcional debe estar integrado en la lista de folios del proyecto. En las propiedades del folio, debe elegirse el tipo « Bloque-funcional ». AUTOMGEN7 150 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.16.3. Ejemplo Contenido del folio VERINB: BF vérin bistable 10 cde ouverture{i0} . 20 OUVRIR{O0} o u ve r t { i 2 } cde fermeture{i1} . 30 ouvert{i2} ferme{i3} . cde ouverture{i0} FERMER{O1} ferme{i3} 40 d u r e e {? 0 } / x 4 0 / t e m p o { ? 1 } AUTOMGEN7 151 (C)opyright 2002 IRAI Manual de referencia del lenguaje Llamado del bloque funcional: u100 V ER I N B . G R 7 CDE O O O0 u101 CDE F F O1 i1 O i0 F D u ré e { 1 0s } T e mp o r i s a t i on { T 0} V E RI N B I S T A BL E exemple\bf\bloc-fonctionnel 3.agn 1.17. Bloques funcionales predefinidos En el subrepertorio « \LIB » del repertorio donde se ha instalado AUTOMGEN hay bloques funcionales de conversión. También están los equivalentes en macro-instrucciones; ver el capítulo 1.10.3. El lenguaje literal bajo nivel. Para insertar y parametrar un bloque funcional en una aplicación se debe seleccionar el comando « Insertar un bloque funcional » del menú « Herramientas ». 1.17.1. Bloques de conversión ASCTOBIN: conversión ASCII a binario BCDTOBIN: conversión BCD a binario BINTOASC: conversión binario a ASCII BINTOBCD: conversión binario a BCD GRAYTOB: conversión código Gray a binario 16BINTOM: transferencia de 16 variables booleanas a una palabra MTO16 BIN: transferencia de una palabra a 16 variables booleanas AUTOMGEN7 152 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.17.2. Bloques de temporización TEMPO: temporización a la subida PULSOR: salida a intervalos PULSE: impulsión temporizada 1.17.3. Bloques de manipulación de cadena de caracteres STRCMP: comparación STRCAT: concatenacíón STRCPY: copia STRLEN: cálculo de la longitud STRUPR: puesta en minúsculas STRLWR: puesta en mayúsculas 1.17.4. Bloques de manipulación de tabla de palabras COMP: comparación COPY: copia FILL: llenado 1.18. Técnicas avanzadas 1.18.1. Código generado por el compilador En este capítulo abordaremos la forma del código generado por la compilación de tal o cual tipo de programa. El utilitario « CODELIST.EXE »* permite traducir « en claro » un archivo de código intermedio « .EQU » (también llamado lenguaje pivote). Hagamos la experiencia siguiente: carguemos y compilemos el primer ejemplo de programa del capítulo « Grafcet »: « simple1.agn » del repertorio « exemple\grafcet »: * Este utilitario debe ejecutarse a partir de la línea de comando DOS. AUTOMGEN7 153 (C)opyright 2002 IRAI Manual de referencia del lenguaje 0 A V1 t1 d 1 A V1 , DV1 t1 i Hacer doble clic en el elemento « Archivos generados/Código pivote » en el explorador. Se obtiene la siguiente lista de instrucciones: ; El código siguiente ha sido generado por la compilación de: 'Folio: GRAF1' :00000000: RES x0 AND i0 :00000002: SET x0 AND b0 :00000004: SET x0 AND x1 AND i1 :00000007: RES x1 AND i1 :00000009: SET x1 AND x0 AND i0 ; El código siguiente ha sido generado por la compilación de: 'asignaciones (acciones Grafcet, logigramas y ladder)' :0000000C: EQU o0 ORR @x0 EOR @x1 :0000000F: EQU o23 AND @x1 Representa la traducción de la aplicación « simple1.agn » en instrucciones del lenguaje literal bajo nivel. Los comentarios indican el origen de las porciones de código, lo cual es útil si una aplicación se compone de varios folios. Obtener esta lista de instrucciones puede ser útil para responder a las preguntas sobre el código generado por tal o cual forma de programa o la utilización de tal o cual lenguaje. En ciertos casos « críticos » para los que es importante conocer informaciones como « ¿al cabo de cuántos ciclos esta acción es verdadera? » el modo paso a paso y el examen exhaustivo del código generado resultan indispensables. 1.18.2. Optimización del código generado Son posibles varios niveles de optimización. AUTOMGEN7 154 (C)opyright 2002 IRAI Manual de referencia del lenguaje 1.18.2.1. Optimización del código generado por el compilador La opción de optimización del compilador permite reducir considerablemente el tamaño del código generado. Esta directiva exige al compilador que genere menos líneas de lenguaje literal bajo nivel; como consecuencia, el tiempo de compilación aumenta. Según los post-procesadores utilizados, esta opción implica una ganancia sobre el tamaño del código o el tiempo de ejecución. Conviene efectuar pruebas para determinar si la directiva es interesante o no según la naturaleza del programa y el tipo de destino utilizado. En general es interesante utilizarla con los post-procesadores para destinos Z. 1.18.2.2. Optimización del código generado por los post-procesadores Cada post-procesador puede poseer opciones para optimizar el código generado. Para los post-procesadores que generan código constructor consulte la nota correspondiente. 1.18.2.3. Optimización del tiempo de ciclo: reducir el número de temporizaciones en destinos Z Para los destinos Z, el número de temporizaciones declaradas influye directamente en el tiempo de ciclo. Declare el mínimo de temporizaciones en función de las necesidades de la aplicación. 1.18.2.4. Optimización del tiempo de ciclo: anular la escrutación de ciertas partes del programa Sólo los destinos que aceptan instrucciones JSR y RET soportan esta técnica. Es posible validar o « invalidar » la escrutación de ciertas partes del programa utilizando directivas de compilación especiales. Dichas porciones de aplicación son definidas por los folios. Si una aplicación se descompone en cuatro folios, cada uno de ellos podrá ser « validado » o « invalidado » independientemente. Una directiva « #C(condición) » colocada en un folio condiciona la escrutación del folio hasta el folio que contiene una directiva « #R ». AUTOMGEN7 155 (C)opyright 2002 IRAI Manual de referencia del lenguaje Esta condición debe utilizar la sintaxis definida para los tests; ver el capítulo 1.3. Tests Ejemplo: Si un folio contiene las dos directivas: #C(m200=4) #R Entonces todo lo que contiene se ejecutará sólo si la palabra 200 contiene 4. AUTOMGEN7 156 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2. Ejemplos 2.1. A propósito de ejemplos Esta parte agrupa una serie de ejemplos que ilustran diferentes posibilidades de programación con AUTOMGEN. Todos los ejemplos se encuentran en el subrepertorio « ejemplo » del repertorio donde se ha instalado AUTOMGEN. Esta parte también contiene ejemplos más completos y más complejos desarrollados para una maqueta de tren. La descripción de esta maqueta se encuentra al principio del manual de referencia del lenguaje. 2.1.1. Grafcet simple Este primer ejemplo es un Grafcet simple en línea: 100 i0 110 T0 (100 ) t0 120 O0 ,O1, O2 i0 exemple\grafcet\sample1.agn Ö la transición entre la etapa 100 y la etapa 110 está constituida por el test en la entrada 0, AUTOMGEN7 157 (C)opyright 2002 IRAI Manual de referencia del lenguaje Ö la etapa 110 activa la temporización 0 de una duración de 10 segundos; esta temporización se utiliza como transición entre la etapa 110 y 120, Ö la etapa 120 activa las salidas 0, 1 y 2, Ö el complemento de la entrada 0 sirve de transición entre la etapa 120 y 100. 2.1.2. Grafcet con diagrama en O 100 i0 11 0 O1 i4 11 1 i1 1 20 i2 O2 130 i5 O3 i6 O5 131 i8 11 2 O0 i3 1 40 O4 i7 O6 i9 O7 i10 exemple\grafcet\sample2.agn Este ejemplo ilustra la utilización de las divergencias y convergencias en « O ». El número de ramas está limitado sólo por el tamaño del folio. Se trata, como establece la norma, de un « O » no exclusivo. Si por ejemplo las entradas 1 y 2 están activas, las etapas 120 y 130 se ponen en uno. AUTOMGEN7 158 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2.1.3. Grafcet con divergencia en Y 100 i0 110 O0 130 i1 120 O1 160 SO2 170 O4 190 O3 i2 140 i2 150 i4 O5 180 RO2 i7 exemple\grafcet\sample3.agn Este ejemplo ilustra la utilización de las divergencias y convergencias en « Y ». El número de ramas está limitado sólo por el tamaño del folio. Notemos también los puntos siguientes: Ö una etapa puede no implicar acciones (caso de las etapas 100, 120, y 140), Ö las órdenes « S » y « R » se han utilizado con la salida o2 (etapas 160 y 180), Ö la transición entre la etapa 160 y 170 queda en blanco, por lo que siempre es verdadera; también se podría haber utilizado la sintaxis « =1 ». AUTOMGEN7 159 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2.1.4. Grafcet y sincronización 0 100 i0 1 Çx1 110 Èx110 i10 O0 i1 i14 O4 i11 O1 i12 O2 i13 O3 exemple\grafcet\sample4.agn Este ejemplo ilustra una de las posibilidades ofrecidas por AUTOMGEN para sincronizar varios Grafcets. La transición entre la etapa 100 y 110 « Ïx1 » significa « esperar un frente ascendente sobre la etapa 1 ». La transición « Ðx110 » significa « esperar un frente descendente sobre la etapa 110 ». La ejecución paso a paso de este programa muestra la evolución exacta de las variables y de su frente a cada ciclo. Esto permite comprender exactamente lo que pasa durante la ejecución. Notemos también la utilización de acciones múltiples asociadas a la etapa 110, que están condicionadas individualmente. AUTOMGEN7 160 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2.1.5. Forzado de etapas 10 RC0 i0 20 100 SX100 Çi4 110 30 +C0 i1 x120 120 exemple\grafcet\sample5.agn En este ejemplo, se ha utilizado una orden « S » (puesta en uno) para forzar una etapa. AUTOMGEN autoriza también el forzado de un Grafcet entero (ver ejemplos 8 y 9). El modo de ejecución paso a paso permite, también en este ejemplo, comprender de manera precisa la evolución del programa en el tiempo. Notemos también: Ö la utilización de un Grafcet sin bucle (100, 110, 120), Ö la utilización de la orden « RC0 » (puesta en cero del contador 0), Ö la utilización de la orden « +C0 » (incrementar el contador 0), condicionada por el frente ascendente de la entrada 4; para ejecutar la incrementación del contador, la etapa 110 debe estar activa y un frente ascendente debe detectarse en la entrada 4. AUTOMGEN7 161 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2.1.6. Etapas pozos y fuentes Çi 0. i 1 100 O0 Çi 0 110 O1 Çi 0 120 O2 Çi 0 130 O3 Çi 0 exemple\grafcet\sample6.agn Ya hemos visto formas similares en las que la primera etapa era activada por otro Grafcet. Aquí la etapa 100 es activada por la transición « Ïi0 . i1 » (frente ascendente de la entrada 0 y la entrada 1). Este ejemplo representa un registro de desfase. « i1 » es la información a memorizar en el registro y « i0 » es el reloj que hace progresar el desfase. El ejemplo 7 es una variante que utiliza una temporización como reloj. AUTOMGEN7 162 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2.1.7. Etapas pozos y fuentes Çt 0 . i 1 100 O0 Çt 0 110 O1 Çt 0 120 O2 Çt 0 130 t0 O3 1000 T0(10) Çt 0 exemple\grafcet\sample7.agn Volvemos a ver la estructura de registro de desfase utilizada en el ejemplo 6. La información de desfase esta vez es generada por una temporización (t0). « Ït0 » representa el frente ascendente de la temporización; esta información es verdadera durante un ciclo cuando la temporización ha terminado de descontar. La etapa 1000 gestiona el lanzamiento de la temporización. La acción de esta etapa puede resumirse así: « activar el descuento si éste no ha terminado; en caso contrario, restablecer la temporización ». El diagrama de funcionamiento de las temporizaciones de este manual ayuda a entender el funcionamiento de este programa. AUTOMGEN7 163 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2.1.8. Forzado de Grafcets 0 100 parada urgen cia 1 Ç bp ini cio de ciclo F100:{} 110 parada urge ncia 2 TESTIG O INIC MOTOR bp fin de ciclo F100:{100} exemple\grafcet\sample8.agn Este ejemplo ilustra la utilización de un comando de forzado de Grafcet. La orden « F100:{} » significa « forzar todas las etapas del Grafcet que tiene una etapa que lleva el número 100 a cero ». La orden « F100:{100} » es idéntica pero fuerza la etapa 100 a 1. Para este ejemplo hemos utilizado símbolos: AUTOMGEN7 164 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2.1.9. Memorización de Grafcets # B 2 00 0 100 pa r a d a u r ge n c i a 1 T ES T I G O I N IC Ç b p i n i c i o de c i c l o G1 0 0 : 1 0 0 110 M OT O R b p f i n d e c ic l o 2 F1 0 0 : ( ) p a r a d a u rg e n c i a 3 F1 0 0 : 1 0 0 exemple\grafcet\sample9.agn Este ejemplo es una variante del programa anterior. La orden « G100:100 » de la etapa 1 memoriza el estado del Grafcet de producción antes de que se fuerce a cero. Al retomar, el Grafcet de producción se colocará de nuevo en el estado en que estaba antes del corte, con la orden « F100:100 ». El estado del Grafcet de producción se memoriza a partir del bit 100 (es el segundo parámetro de las órdenes « F » y « G » el que precisa esta ubicación), la directiva de compilación « #B200 » reserva los bits u100 a u199 para este tipo de utilización. Notemos que una directiva AUTOMGEN7 165 (C)opyright 2002 IRAI Manual de referencia del lenguaje « #B102 » habría bastado, ya que el Grafcet de producción sólo necesita dos bits para memorizarse (un bit por etapa). 2.1.10. Grafcet y macro-etapas 0 O0 i0 1 i1 2 O1 i2 3 i3 E 10 SO10 i10 20 RO10 S exemple\grafcet\sample11.agn AUTOMGEN7 166 (C)opyright 2002 IRAI Manual de referencia del lenguaje Este ejemplo ilustra la utilización de las macro-etapas. Los folios « Macro etapa 1 » y « Macro etapa 3 » representan la expansión de las macro-etapas con las etapas de entradas y de salidas. Las etapas 1 y 3 del folio « Programa principal » están definidas como macro-etapas. A las expansiones de macro-etapas en visualización se accede haciendo clic con el botón izquierdo del ratón en las macro-etapas. 2.1.11. Folios en cadena 0 O0 i0 1 O1 i1 2 O2 i2 3 SUITE c o n t i n ue AUTOMGEN7 167 (C)opyright 2002 IRAI Manual de referencia del lenguaje 4 O3 suite 5 O4 i3 6 O5 i4 7 C O N T I NU E exemple\grafcet\sample12.agn En este ejemplo se han utilizado dos folios para escribir el programa. Los símbolos « _CONTINUACIÓN_ » y « _CONTINÚA_ » se han declarado como bits (ver el fichero de símbolos) y permiten vincular los dos Grafcets (es otra técnica de sincronización que se puede utilizar con AUTOMGEN). AUTOMGEN7 168 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2.1.12. Logigrama i0 O O0 i1 i2 & O i3 i4 i5 i6 & i7 i8 i9 i1 0 exemple\logigramme\sample14.agn Este ejemplo desarrollado en logigramas muestra la utilización de los diferentes bloques: el bloque de asignación asociado a la tecla [0] a la izquierda del rectángulo de acción, el bloque « no » asociado a la tecla [1] que complementa una señal, los bloques de anclaje de tests y las funciones « Y » y « O ». AUTOMGEN7 169 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2.1.13. Grafcet y Logigrama 0 Ç bp inicio de ciclo 1 fin de ciclo bp manual MOTOR etapa 1 & seguridad 1 O seguridad 2 O exemple\logigramme\exempl15.agn En este ejemplo se utilizan conjuntamente un Grafcet y un Logigrama. El símbolo « _etapa 1_ » utilizado en el logigrama está asociado a la variable « x1 ». Este tipo de programación presenta claramente las condiciones de activación de una salida. AUTOMGEN7 170 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2.1.14. Caja de lenguaje literal 0 SO0 1 m 2 00 = [ 0] ; m 20 0 se u t il i z a c o mo í n di c e r e s _ f la g un a e nt r a da e st a e n 1 _ W H IL E ( _ f l ag u n a e n tr a d a e s t a e n 1 _ . m2 0 0 < 10 0 ) I F (i ( 2 0 0) ) THEN s e t _ f l ag u n a e n tr a d a e s t a e n 1 _ E N D IF inc m200 E N DW H I LE f la g un a en t r a da e st a en 1 fl a g un a en t r ad a e st a en 1 2 RO 0 exemple\lit\sample16.agn Este programa que asocia Grafcet con caja de lenguaje literal tiene por objeto testear las entradas i0 a i99. Si una de estas entradas está en uno, la etapa 2 está activada y el Grafcet se encuentra en un estado que impide cualquier evolución. El símbolo « _flag una entrada está en uno_ » está asociado al bit u500. Se ha utilizado un direccionamiento indexado para explorar las 100 entradas. Notemos también el empleo simultáneo del lenguaje literal bajo nivel y extendido. AUTOMGEN7 171 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2.1.15. Organigrama IF(_bp validación_) bta _entrada rueda código_ ana %0000000000000111 sta _valor rueda código_ ; fin exemple\organigramme\sample18.agn Este ejemplo ilustra la utilización de un organigrama para efectuar un tratamiento algorítmico y numérico. Tres entradas provenientes de una rueda de código son leídas y almacenadas en una palabra si una entrada de validación está activa. AUTOMGEN7 172 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2.1.16. Organigrama m200=[10] o(200)=(1) m200=[m200+1] IF(m200=30) ; Fin del ; bucle exemple\organigramme\sample19.agn Este segundo ejemplo de organigrama realiza una estructura de bucle que permite forzar a uno una serie de salidas (o10 a o29) con un direccionamiento indirecto (« o(200) »). AUTOMGEN7 173 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2.1.17. Bloque funcional i16 RO0 i17 & i0 CALCULO PUESTAen0 i1 CALCULO SO0 VAL. INIC {100} LIMITE MAX {110} VARIABLE {m200} exemple\bf\sample20.agn ; Gestión de la entrada de RAZ IF({I0}) THEN {?2}=[{?0}] ENDIF ; Gestión de la entrada de cálculo IF(#{I1}) THEN {?2}=[{?2}+1] ENDIF ; Testea el límite máx IF({?2}={?1}) THEN {O0}=(1) {?2}=[{?0}] ENDIF ELSE {O0}=(0) ENDIF comptage.lib (incluido en los recursos del proyecto) AUTOMGEN7 174 (C)opyright 2002 IRAI Manual de referencia del lenguaje Este ejemplo ilustra la utilización de un bloque funcional. Las funciones del bloque « COMPTAGE » que hemos definido son las siguientes: Ö el cálculo se hará partiendo de un valor de inicio y se terminará en un valor límite máximo, Ö cuando la variable de cálculo alcance el límite máximo será forzada al valor de inicio y la salida del bloque pasará a uno durante un ciclo de programa, Ö el bloque poseerá una entrada booleana de RAZ y una entrada de cálculo en el frente ascendente. 2.1.18. Bloque funcional O U _ E X C LU O U _ E X CL U =1 =1 i0 i1 O U _ E X C LU i2 =1 i3 O U _ E X C LU O U _ E X CL U =1 =1 i4 O0 i5 exemple\bf\sample21.agn ; O exclusivo neq {o0} orr /{i0} eor {i1} orr {i0} eor /{i1} ou_exclu.lib (incluido en los recursos del proyecto) Este segundo ejemplo de bloque funcional ilustra la utilización múltiple de un mismo bloque. El bloque « OU_EXCLU » realiza un O exclusivo entre las dos entradas booleanas. Este ejemplo utiliza 5 bloques para realizar un O exclusivo entre 6 entradas (i0 a i5). El archivo « OU_EXCLU.LIB » indicado abajo rige el AUTOMGEN7 175 (C)opyright 2002 IRAI Manual de referencia del lenguaje funcionamiento del bloque. La ecuación booleana del O exclusivo es la siguiente: « (i0./i1)+(/i0.i1) ». La forma equivalente utilizada aquí permite codificar la ecuación en una sola línea de lenguaje literal bajo nivel sin utilizar variables intermedias. 2.1.19. Ladder i0 i7 i1 i8 i2 i9 O0 i3 i10 O1 i4 i11 O2 i5 i12 O3 i6 i13 O4 exemple\laddersample22.agn Este ejemplo ilustra la utilización de la programación en ladder. AUTOMGEN7 176 (C)opyright 2002 IRAI Manual de referencia del lenguaje 2.1.20. Ejemplo desarrollado sobre una maqueta de tren AUTOMGEN7 177 (C)opyright 2002 IRAI Manual de referencia del lenguaje AUTOMGEN7 178 (C)opyright 2002 IRAI Manual de referencia del lenguaje AUTOMGEN7 179 (C)opyright 2002 IRAI Manual de referencia del lenguaje AUTOMGEN7 180 (C)opyright 2002 IRAI Manual de referencia del lenguaje AUTOMGEN7 181 (C)opyright 2002 IRAI Manual de referencia del lenguaje AUTOMGEN7 182 (C)opyright 2002 IRAI Manual de referencia del lenguaje Las aventuras del Doctor R. Manual pedagógico del usuario de AUTOMGEN AUTOMGEN7 183 (C)opyright 2002 IRAI Manual de referencia del lenguaje Distribución Doctor R. ………………………………………………… Señor R. "Es así de delicado, todo el mundo sabe que yo no soy doctor en realidad." El Doctor R. en el reino de la domótica Vamos a abordar diferentes ejemplos aplicables directamente en un proyecto de domótica. Con un primer enfoque simple, estos ejemplos nos permitirán asimilar diferentes aspectos de la base de los automatismos y del aprendizaje de AUTOMGEN e IRIS. "No hay nada que hacer. No puede hablar como todo el mundo la gente de IRAI." AUTOMGEN7 185 (C)opyright 2002 IRAI Manual de referencia del lenguaje Este símbolo evocará una parte comando (un autómata programable por ejemplo). ¿Hay necesidad de precisar que esto evocará una bombilla, un botón pulsador y un interruptor? Primer ejemplo: « quién fue el primero, el interruptor o la bombilla … » Un simple interruptor y una simple bombilla: el interruptor está cableado en la entrada i0, la bombilla en la salida o0. Si el interruptor se cierra, la bombilla se enciende; si el interruptor se abre, la bombilla se apaga. Más simple, imposible. "¡Romperse tanto la cabeza para encender una bombilla! ¡Pero qué mente retorcida!" AUTOMGEN7 186 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución 1: el lenguaje natural del electricista: ladder El contacto La bobina Ladder es la transcripción más directa del esquema eléctrico. El contacto recibe el nombre de la entrada donde está cableado el interruptor, la bobina el nombre de la salida donde está cableada la bombilla. Solución 2: el lenguaje secuencial del automatista: Grafcet Una etapa 0 Une transition i0 Otra etapa 1 O0 /i0 Un rectángulo de ió Otra transición Grafcet se basa en la noción de estado. Para nuestro problema podemos decir que hay dos estados: el estado encendido y el estado apagado. Cada etapa representa un estado: aquí la etapa 0 representa el estado apagado y la etapa 1 el estado encendido. Queda por determinar la condición que hace evolucionar del AUTOMGEN7 187 (C)opyright 2002 IRAI Manual de referencia del lenguaje estado apagado al estado encendido: interruptor cerrado (indicado i0), y luego la condición que hace pasar del estado encendido al estado apagado: interruptor abierto (indicado / i0). Las condiciones están escritas a la derecha del elemento indicado como transición. El rectángulo asociado a la etapa 1 llamado rectángulo de acción contiene el nombre de la salida O0 (salida donde está cableada nuestra bombilla). Así, en todo momento, el estado de la bombilla es el mismo que el de la etapa 1. ¡Iupi! Corro a comprar un autómata programable en el almacén de la esquina. Vi llegar un envío fresco de AUTOMGEN. AUTOMGEN7 188 (C)opyright 2002 IRAI Manual de referencia del lenguaje Los afortunados posesores de IRIS pueden utilizar dos objetos BPVOYANT para simular este primer ejemplo. "No pueden no hacer promoción." AUTOMGEN7 189 (C)opyright 2002 IRAI Manual de referencia del lenguaje A jugar … El interruptor 1 enciende la bombilla 1, el interruptor 2 la bombilla 2. Al final de este documento se propone una solución Grafcet. "Me pregunto si es dos veces más complicado o dos veces menos simple que el primer ejemplo." Segundo ejemplo: « temporizaciones, minuteros y otras diversiones temporales… » "A propósito, son las menos diez." AUTOMGEN7 190 (C)opyright 2002 IRAI Manual de referencia del lenguaje Como ustedes se imaginan, la noción de temporización se utiliza cuando un programa debe, de una manera u otra, efectuar acciones teniendo en cuenta un dato relativo al tiempo. Esperar cierto tiempo antes de llevar a cabo una acción, o bien llevar a cabo una acción durante cierto tiempo, por ejemplo. Nuestro segundo ejemplo es el siguiente: un pasillo está equipado con una bombilla y dos botones pulsadores. Al presionar uno de los dos botones, la bombilla se enciende 2 minutos (según el Dr. R. ese plazo es más que suficiente para cruzar el pasillo). Solución 1: la simplicidad 0 i0+i1 1 O0 Encender la bombilla si se presiona el botón pulsador 1 o si se presiona el botón pulsador 2. "O" se escribe "+" en una transición. t0/x1/120s Esperar 2 minutos (120 segundos) utilizando la temporización 0, es la etapa 1 la que lanza la temporización. AUTOMGEN7 191 (C)opyright 2002 IRAI Manual de referencia del lenguaje Solución 2: mejora La desventaja de esta solución es que si el botón pulsador se presiona mientras la bombilla está encendida, la temporización no se restablece. La semana pasada, el Dr. R. creyó haber restablecido el minutero y de buenas a primeras se encontró en la oscuridad. 0 ↑(i0+i1) 1 O0 ↑(i0+i1) t0/x1/120s 2 =1 Y si nos lanzamos a escribir un programa de verdad … AUTOMGEN7 192 (C)opyright 2002 IRAI Manual de referencia del lenguaje Una gestión inteligente de la iluminación del pasillo: se ha colocado una bombilla en cada extremo. Cuando se presiona un interruptor, las dos bombillas se encienden; la bombilla del lado del interruptor presionado se apaga al cabo de 30 segundos, y la otra al cabo de un minuto. Tercer ejemplo: « variación sobre el tema del conmutador… » Recordemos el genial principio del conmutador: dos interruptores permiten encender o apagar la misma bombilla. AUTOMGEN7 193 (C)opyright 2002 IRAI Manual de referencia del lenguaje He aquí una solución en logigrama: i0 O & O0 i1 O & Los puristas habrán reconocido la ecuación booleana del O exclusivo. Las cosas se ponen realmente interesantes si deseamos conservar las propiedades del conmutador con un número de interruptores mayor que 2. AUTOMGEN7 194 (C)opyright 2002 IRAI Manual de referencia del lenguaje Otra más astuta: 0 ↑i0+ ↓i0+ ↑i1+ ↓i1+ ↑i2+ ↓i2+ ↑i3+ ↓i3 1 IO0 =1 « IO0 » significa « invertir el estado de la salida 0 ». Prueben esto: Un amplio cuarto con 6 interruptores y 10 bombillas. Cada interruptor permite iluminar más o menos el cuarto (pasando del estado en que todo está encendido al estado en que se enciende una bombilla, luego dos, etc...). AUTOMGEN7 196 (C)opyright 2002 IRAI Manual de referencia del lenguaje Cuarto ejemplo: « Y el botón pulsador se vuelve inteligente … » En todos los ejemplos anteriores, los botones pulsadores realizan una sola función. Es decir, la persona que los maneja tiene sólo dos opciones: presionar o no presionar para obtener una función (encender o apagar). Imaginemos un botón pulsador « más rendidor » capaz de recibir dos tipos de presión: una presión corta (arbitrariamente menos de 1 segundo) o una presión larga (arbitrariamente 1 segundo o más). "En cinco minutos quieren hacernos creer que inventaron el Morse." Para este ejemplo, cuatro botones pulsadores y cuatro bombillas. En forma predeterminada, con el uso normal, cada uno de los botones pulsadores está asociado a una bombilla. Una presión corta enciende o apaga la bombilla asociada. Cada botón pulsador debe permitir pilotear cada bombilla o la totalidad de las bombillas. La tabla siguiente resume el funcionamiento. Acción sobre los botones pulsadores Resultado Una presión corta La bombilla asociada cambia de estado Una presión larga y una presión corta La bombilla número 1 cambia de estado Una presión larga y dos presiones cortas La bombilla número 2 cambia de estado Una presión larga y tres presiones cortas La bombilla número 3 cambia de estado Una presión larga y cuatro presiones cortas La bombilla número 4 cambia de estado Dos presiones largas y una presión corta Todas las bombillas se apagan Dos presiones largas y dos presiones cortas Todas las bombillas se encienden AUTOMGEN7 197 (C)opyright 2002 IRAI Manual de referencia del lenguaje AUTOMGEN7 198 (C)opyright 2002 IRAI Manual de referencia del lenguaje Con esto concluye este manual pedagógico. Esperamos les haya permitido descubrir las posibilidades de AUTOMGEN. Proponemos un último ejercicio. Automatizar el apartamento de la tía Hortensia respetando su gusto desmedido por los interruptores niquelados. "¡Era hora de que esta nota llegara a su fin!" AUTOMGEN7 200 (C)opyright 2002 IRAI Manual de referencia del lenguaje Las soluciones … « quién fue el primero, el interruptor o la bombilla … » 0 2 i0 1 i1 O0 3 /i0 Es Como siempre, se necesita una lupa para leer las soluciones. O1 /i1 suficiente escribir dos Grafcets idénticos. Cada uno se ocupa independientemente de un interruptor y de una bombilla. « temporizaciones, minuteros y otras diversiones temporales… » 0 ↑i0 10 O0,O1 ↑i1 50 t0/x10/30s 30 O1 t1/x30/30s O0,O1 t2/x50/30s 70 O0 t3/x70/30s Una versión simple sin la gestión del restablecimiento del minutero. AUTOMGEN7 201 (C)opyright 2002 IRAI Manual de referencia del lenguaje 0 ↑i0 10 ↑i1 ↑i0 ↑i1 O0,O1 50 t0/x10/30s 20 30 O1 O0,O1 ↑i1 t2/x50/30s 70 O0 60 =1 ↑i1 ↑i0 =1 ↑i0 t1/x30/30s ↑i1 t3/x70/30s 40 ↑i0 80 =1 =1 El restablecimiento del minutero hace que el programa sea muy complejo. ↑i0 0 x10 RT0 x30 F0:{10} x50 ↑i0 10 O0,O1 ↑i1 50 t0/x10/30s 30 O1 t1/x30/30s x70 O0,O1 ↑i1 t2/x50/30s 70 O0 x50 RT2 x10 F0:{50} x30 t3/x70/30s x70 Una tercera solución con Grafcet, lenguaje ladder y forzados de Grafcet. El programa permanece legible. AUTOMGEN7 202 (C)opyright 2002 IRAI Manual de referencia del lenguaje « variación sobre el tema del conmutador …» 0 {BTA I0,ANA %11111,STA M200} m200<>m201 1 {LDA M200,STA M201} o0 SO0 =1 SO1 o4 SO5 o1 SO2 o5 SO6 o2 SO3 o6 SO7 o3 SO4 o7 SO8 o8 SO9 o9 RO0,RO1,RO2,RO3,RO4,RO5,RO6,RO7,RO8,RO9 AUTOMGEN7 203 (C)opyright 2002 IRAI-
1
-
2
-
3
-
4
-
5
-
6
-
7
-
8
-
9
-
10
-
11
-
12
-
13
-
14
-
15
-
16
-
17
-
18
-
19
-
20
-
21
-
22
-
23
-
24
-
25
-
26
-
27
-
28
-
29
-
30
-
31
-
32
-
33
-
34
-
35
-
36
-
37
-
38
-
39
-
40
-
41
-
42
-
43
-
44
-
45
-
46
-
47
-
48
-
49
-
50
-
51
-
52
-
53
-
54
-
55
-
56
-
57
-
58
-
59
-
60
-
61
-
62
-
63
-
64
-
65
-
66
-
67
-
68
-
69
-
70
-
71
-
72
-
73
-
74
-
75
-
76
-
77
-
78
-
79
-
80
-
81
-
82
-
83
-
84
-
85
-
86
-
87
-
88
-
89
-
90
-
91
-
92
-
93
-
94
-
95
-
96
-
97
-
98
-
99
-
100
-
101
-
102
-
103
-
104
-
105
-
106
-
107
-
108
-
109
-
110
-
111
-
112
-
113
-
114
-
115
-
116
-
117
-
118
-
119
-
120
-
121
-
122
-
123
-
124
-
125
-
126
-
127
-
128
-
129
-
130
-
131
-
132
-
133
-
134
-
135
-
136
-
137
-
138
-
139
-
140
-
141
-
142
-
143
-
144
-
145
-
146
-
147
-
148
-
149
-
150
-
151
-
152
-
153
-
154
-
155
-
156
-
157
-
158
-
159
-
160
-
161
-
162
-
163
-
164
-
165
-
166
-
167
-
168
-
169
-
170
-
171
-
172
-
173
-
174
-
175
-
176
-
177
-
178
-
179
-
180
-
181
-
182
-
183
-
184
-
185
-
186
-
187
-
188
-
189
-
190
-
191
-
192
-
193
-
194
-
195
-
196
-
197
-
198
-
199
-
200
-
201
-
202
-
203
Documentos relacionados
Otros documentos
-
Control Techniques Unidrive M200 Step-By-Step Manual
-
Shimano ST-M020 Service Instructions
-
Trendnet TS-U100 Quick Installation Guide
-
Hornby Railmaster Instrucciones de operación
-
Groupe Brandt FC-45_BN El manual del propietario
-
Adobe Flash 5 Guía del usuario
-
Ricoo WM083 Manual de usuario
-
Epson T3 SCARA Robots Manual de usuario
-
-
Epson RS4 SCARA Robots Manual de usuario