Un sistema pensado en GRAFCET puede ser implementado fácilmente en cualquier tecnología secuencial (autómata programable, ordenador,...) en este caso describiremos un método para implementar un GRAFCET en un ordenador. Los mismos principios, aunque aplicados de otras formas, se podrán aplicar a otros métodos de programación. En la primera de las referencias bibliográficas se ha hecho la implementación en un autómata programable.
Este método contempla todas las estructuras que hemos estudiado siempre que las receptividades sean booleanas. En caso de que las receptividades no sean booleanas, puede hacerse un cambio como ya hemos visto.
Aunque las macroetapas pueden tratarse fácilmente con este método, es aconsejable sustituir las macroetapas por sus expansiones. Para describir el método usaremos un ejemplo, concretamente el GRAFCET global de las figuras siguientes. En este caso son dos GRAFCETs, G0 y G1, donde G1 es jerárquicamente superior y puede forzar a G0.
Para una fácil implementación, conviene numerar las transiciones y dar nombres a los GRAFCETs.
Vamos a definir varios vectores de variables booleanas. Vamos a utilizar uno de estos vectores para la situación de actividad de cada etapa. Llamaremos X a este vector; por lo tanto cuando la etapa 4 esté activa, lo estará X[4]. También usaremos otro vector para saber si las receptividades son ciertas o no. Le llamaremos R; por tanto cuando la transición 3 tenga cierta su receptividad, estará activo R[3].
Durante la evolución del GRAFCET, los valores del vector X cambiarán; por tanto no podemos utilizarlo para el control de la validación de las transiciones. Para mantener la información de las transiciones que están validadas usaremos el vector V. Este vector se actualizará en cada pasada y servirá también como referencia de comparación con el vector X cuando determinemos si la situación actual es estable o no.
Finalmente definiremos un vector G con una componente para cada GRAFCET conexo. Este bit estará activado cuando el GRAFCET correspondiente esté forzado. En nuestro caso tendremos G[0] y G[1], aunque este último no lo usaremos ya que corresponde GRAFCET de mayor superioridad jerárquica.
El vector T contiene el tiempo transcurrido desde la última activación de cada una de las etapas. Los vectores I y Q contienen las entradas (I) y salidas (Q) físicas mientras que los vectores E y S guardan los estados de las entradas (E) y salidas (S) hasta que se acaba un ciclo.
Una vez definidos los bits necesarios, comenzamos el programa de implementación. Se puede consultar también el listado del programa sin los comentarios
Las primeras líneas contienen la inicialización del GRAFCET. Al inicializar se deben activar todas las etapas iniciales y desactivarse las otras. Primero desactivaremos todas las etapas (incluso las que no existen, para ir más rápido) y, a continuación, activamos las dos etapas iniciales (0 y 16). Al empezar, también desactivamos todas las salidas.
Para i = 1 hasta long(X) hacer
X[i] = 0
FinPara
X[0] = 1
X[16] = 1
M = 0
Para i = 1 hasta long(Q) hacer
S[i] = 0
FinPara
En cada ciclo de programa deben copiarse las entradas físicas sobre el vector de entradas. El ciclo de programa se debe repetir indefinidamente.
Repetir
Para i = 1 hasta long(I) hacer
E[i] = I[i]
FinPara
La línea siguiente copia la situación de actividad de las etapas (vector X) sobre el vector V para guardar la información mientras evoluciona el programa. La estructura Repetir corresponde a la evolución hasta que el resultado sea estable.
Repetir
Para i = 1 hasta long(X) hacer
V[i] = X[i]
FinPara
En este punto debemos gestionar las receptividades. Se trata de definir las condiciones booleanas (función de las entradas o de los elementos internos) que describen la receptividad.
R[0] = E[1]
R[1] = E[3]
Si la condición es temporizada, usaremos el vector T. El contenido del paréntesis podrá ser cierto (1) o falso (0) y el resultado será el estado de la receptividad.
R[2] = (T[2] > 5)
R[3] = E[5] · E[6]
R[4] = E[3]
R[5] = E[2]
En el caso de una transición condicionada por una etapa, se utiliza el V correspondiente.
R[6] = V[7]
R[7] = E[1] + E[4]
R[16] = /E[7]
R[17] = E[8]
R[18] = E[9]
R[19] = E[10]
Una vez hemos implementado las receptividades, comenzamos la evolución. La evolución se debe implementar GRAFCET a GRAFCET sin que el orden tenga importancia. Si un GRAFCET está forzado no debe evolucionar; por ello, si está forzado, saltamos las líneas de evolución.
Si G[0] = 0 entonces
Al evolucionar hay que desactivar primero las etapas que tengan la transición de salida validada y la receptividad correspondiente cierta. Fijémonos que las validaciones las miramos del vector V.
Si (R[0]·V[0]) entonces X[0] = 0 FinSi
En el caso del inicio de una selección de secuencia (o también salto de etapas o repetición de secuencia) hay dos receptividades (función "O") que pueden desactivar una etapa.
Si ((R[1]+R[5])·V[0]) entonces X[1] = 0 FinSi
Si (R[2]·V[2]) entonces X[2] = 0 FinSi
En el final de unas secuencias simultaneas sólo es válida la transición si todas las etapas inmediatamente anteriores están activas (función "Y"). Entonces la misma condición sirve para desactivar más de una etapa.
Si (R[3]·V[3]·V[7]) entonces X[3] = 0 FinSi
Si (R[4]·V[4]) entonces X[4] = 0 FinSi
Si (R[6]·V[5]) entonces X[5] = 0 FinSi
Si (R[7]·V[6]) entonces X[6] = 0 FinSi
Si (R[3]·V[3]·V[7]) entonces X[7] = 0 FinSi
Después se han de activar aquellas etapas que tengan la transición de entrada validada y la receptividad correspondiente cierta. De esta forma la activación será prioritaria sobre la desactivación.
Si (R[4]·V[4]) entonces X[0] = 1 FinSi
Si (R[0]·V[0]) entonces X[1] = 1 FinSi
Si (R[1]·V[1]) entonces X[2] = 1 FinSi
Al final de una selección de secuencia (o también salto de etapas o repetición de secuencia) hay dos o más formas de activar una etapa, según cual sea la secuencia que esté operativa.
Si ((R[2]·V[2])+ (R[6]·V[5])) entonces X[3] = 1 FinSi
Al cerrar unas secuencias simultáneas sólo está validada la transición cuando todas las etapas inmediatamente precedentes son activas.
Si (R[3]·V[3]·V[7]) entonces X[4] = 1 FinSi
Si (R[5]·V[1]) entonces X[5] = 1 FinSi
Si (R[0]·V[0]) entonces X[6] = 1 FinSi
Si (R[7]·V[6]) entonces X[7] = 1 FinSi
FinSi
Una vez finalizada la evolución del primer GRAFCET, debe hacerse la de los siguientes.
Si G[1] = 0 entonces
Si (R[16]·V[16]) entonces X[16] = 0 FinSi
Si (R[17]·V[17]) entonces X[17] = 0 FinSi
Si (R[18]·V[18]) entonces X[18] = 0 FinSi
Si (R[19]·V[19]) entonces X[19] = 0 FinSi
Si (R[19]·V[19]) entonces X[16] = 1 FinSi
Si (R[16]·V[16]) entonces X[17] = 1 FinSi
Si (R[17]·V[17]) entonces X[18] = 1 FinSi
Si (R[18]·V[18]) entonces X[19] = 1 FinSi
FinSi
Una vez finalizada la evolución de todos los GRAFCETs, debemos tener en cuenta que en la nueva situación puede haber forzados que pueden cambiar la situación actual de actividad. En el caso de que cualquiera de las etapas que pueden forzar un GRAFCET esté activa, se debe activar el bit de forzado correspondiente.
Si (X[17]+X[18]+X[19]) entonces G[0] = 1 FinSi
En el caso de que el GRAFCET sea forzado a un estado diferente del actual, debemos desactivar todas las etapas activas y activar las forzadas. En nuestro caso hemos tomado la precaución de asignar números de etapa entre 0 y 15 al GRAFCET G0 y entre 16 y 31 al G1.
Si (X[18]) entonces
Para i = 1 hasta 15 hacer
X[i] = 0
FinPara
FinSi
Si (X[19]) entonces
Para i = 1 hasta 15 hacer
X[i] = 0
FinPara
X[3] = 1
X[6] = 1
FinSi
Antes de realizar las acciones asociadas a las etapas debemos comprobar que la situación alcanzada es estable. Por este motivo comparamos los contenidos de los vectores X y V y, si no son iguales, repetimos la evolución.
K = 0
Para i = 1 hasta long(X) hacer
Si (V[i] = X[i]) entonces K = 1 FinSi
FinPara
HastaQue K = 0
Las acciones impulsionales las realizaremos sólo durante un ciclo de programa; por ello usaremos la estructura siguiente.
S[1] = X[2] · (/M)
M = X[2]
La salida 2 es de tipo mantenido.
Si (X[1]) entonces S[2] = 1 FinSi
Si (X[3]) entonces S[2] = 0 FinSi
Si una acción no mantenida (como la de la salida 3) se ha de realizar en más de una etapa, deben agruparse. Las acciones condicionadas han de venir afectadas, además de la etapa, por la correspondiente condición (entrada 1). Las acciones limitadas sólo se realizan mientras el tiempo no se ha alcanzado.
S[3] = ((X[7]·E[1])+(X[4]·(T[4]<3)))
Las acciones retardadas, en cambio, se ejecutan cuando el tiempo ya ha transcurrido.
S[4] = (X[5]·(T[5]>2))
Para finalizar el ciclo de programa, copiamos las salidas.
Para i = 1 hasta long(Q) hacer
Q[i] = S[i]
FinPara
HastaQue PasoAStop