PACKML

Fredy Alfonso Lancheros Suárez

Universidad Distrital
Contenido
Acercamiento a PackML ............................................................................................................ 3
¿Cómo definir un proceso con PackML? .................................................................................... 4
Implementación en Codesys ..................................................................................................... 5
SimulateActingStateComplete() ............................................................................................ 8
Aplicación de comando ......................................................................................................... 9
Implementación en Rockwell .................................................................................................. 10
Bibliografía ............................................................................................................................. 14

2
Acercamiento a PackML

PackML nace como un estándar global para la programación de máquinas automatizadas,

desde la OMAC (Organization for Machine Automation and Control) Packaging Group
(OPW). Este estándar encasilla al programador a seguir una secuencia en una máquina de
estados predefinida, de tal manera que el acoplamiento entre funciones de máquinas y
PLC de diferentes marcas, sea mucho más sencillo, además de incentivar un protocolo de
detección de fallas y su respectiva corrección y puesta en marcha de la máquina.
Dicho estándar consiste en que las máquinas (Unidades) tienen un estado donde están en
funcionamiento (Execute) y donde están paradas (Stopped o Idle), además de tener la
posibilidad de depurar fallas y manejar secuencias de recuperación (Aborting, Aborted,
Clearing). La máquina de estados PackML se puede ver en la figura 1.

Fig. 1. Máquina de estados- estándar PackML

3
Adicionalmente, el estándar PackML provee además de estados, modos de
funcionamiento, donde el programador puede escoger qué estados utilizar y cuáles no; lo
cual se explicará con más profundidad líneas abajo.

¿Cómo definir un proceso con PackML?

Son tres los pasos, o decisiones que hay que realizar a la hora de implementar un proceso con
PackML, los cuales son:

• Definir modos de funcionamiento

Los modos de funcionamiento más usuales son Automático, Manual y

Mantenimiento, aunque el programador tiene libertad para decidir cuáles usar, el
automático, al menos, es el que viene por defecto y permite usar todos los estados.
En este apartado hay que decidir qué modos usar, ya que, por defecto, el
automático es el que se utiliza cuando la máquina tiene un ciclo de producción
normal; pero se puede adicionar el modo Manual, por ejemplo, para testear los
actuadores y sensores en la máquina, siendo esta rutina de testeo la que ocuparía
el execute para este modo de funcionamiento.

• Asignar funcionalidad a los estados en cada modo de funcionamiento

Si bien PackML ya tiene unos estados preestablecidos (Execute, Stopped, Held,

etc) deja al programador la decisión de qué van a realizar cada uno de esos estados,
es por ello que hay que definir qué va a hacer el programa cuando entre a un estado
determinado, como ejemplo, apagar los actuadores cuando entra al estado
‘Stopped’.

• Modularizar el código de la máquina

Según la Norma ISA 88, hay que entender la máquina de acuerdo a los siguientes
3 niveles, lo que permite aplicar la máquina de estados de OMAC donde realmente
debe ir.

▪ Máquina (Unidad o UN): colección de módulos de equipo, ejemplo,

Reactor.
▪ Módulo de Equipo (EM): Grupo funcional de módulos de control que
llevan a cabo una función determinada, ejemplo, Unidad _ Reactor,
Módulo de Equipo _ Dispensador de agua.
▪ Módulo de control (CM): Es el más bajo nivel donde se ejecuta una
función sencilla, ejemplo, Unidad _ Reactor, Módulo de Equipo _
Dispensador de agua, Módulo de control _ Válvula de Apertura.
4
 Hay que tener en cuenta que, para la mayoría de aplicaciones, el código se basa
en una sola unidad (Máquina), la máquina está compuesta por uno o varios
módulos de equipo, que a su vez contienen uno o más módulos de control.
Además, hay que tratar de no dejar un solo módulo de control en un módulo de
equipo, ya que resultaría en un código más largo y más difícil de depurar, resulta
más sencillo, juntar algunos módulos de control que se enfoquen a una actividad
en un solo módulo de equipo. Por ejemplo, si se tiene una máquina tapadora que
consiste en la acción de 3 servomotores por separado, resulta impráctico asignarle
un módulo de equipo a cada módulo de control que en este caso es cada
servomotor, es mejor asignarles un módulo de equipo compuesto por 3 módulos
de control. Así como puede haber el caso en que los 3 servomotores estén
cumpliendo una misma función específica, como el posicionamiento en 3
dimensiones de una cámara, en la que resulta más práctico asignar un solo módulo
de control para los 3 servomotores que asignar 3 módulos de control.[1]

Implementación en Codesys

De la página oficial de Codesys se debe descargar la librería “OMAC PackML

State Machine”, tal como aparece en la figura 2[2]

Fig. 2. Librería OMAC PackML

Una vez descargada e instalada, se procede a abrir el ejemplo que trae la librería,
tal como se ve en la figura 3

5
 Fig. 3. Programa Ejemplo de PackML

Dentro del ejemplo, se puede apreciar la organización del programa de la siguiente

manera; en PLC_PRG, en la parte de asignación de variables se encuentra la
definición de Modos y Estados de funcionamiento, como se puede ver en la figura
4.

Fig. 4. Configuración de variables PLC_PRG

6
En la parte de inserción de código de programación se tiene una estructura ejemplo, en la
figura 5 se puede ver cómo se realiza el registro de los modos de trabajo.

Fig. 5. Inserción de Código PLC_PRG

En la figura 6 se puede ver cómo se hace la asignación de variables que llevarán a cabo el
cambio de estado.

Fig. 6. Definición Cambio de estado

7
Note que en la parte de cambios de estado después de la imagen anterior, aparece el
comando “SimulateActingStateComplete();”, el cual llama al método que se aprecia
como subcategoría de PLC_PRG, lo que se explicará más adelante.
En la última parte esta sección, se aprecia cómo se cambia el modo de funcionamiento,
como se aprecia en la figura 7

Fig. 7 Cambio modos de funcionamiento

SimulateActingStateComplete()

Es aquí donde el programador puede colocar su código para cada estado, en este código
ejemplo utilizan la variable “nextSupportedState” para almacenar el estado siguiente al
actual del programa, para que con la sentencia if, después de un retardo de dos segundos,
se cambie el estado actual con la sentencia
“unitModeManager.ActiveUnitMode.ActingStateCompleted();”, teniendo en cuenta que
según la imagen de la máquina de estados, figura 1, los estados Execute, Completing, etc,
se dan finalizados con el comando complete.

Fig. 8. Código ejemplo de manejo de funciones dentro de los estados

8
Aplicación de comando

Si se quiere, por ejemplo, prender un led, es decir una variable booleana en el estado
Stopped, y luego pasar a “Reseting” se puede modificar el código de
“SimulateActingStateComplete()”, agregando las siguientes líneas, también expuesto en
la figura 9:
IF (unitModeManager.ActiveUnitMode.CurrentState=PACK_ML.State.Stopped) THEN
led:=1;
xReset:=1;
END_IF

Fig. 9. Forma simplificada de utilizar un estado del PackML en Codesys

9
Implementación en Rockwell

Se crea un proyecto normal en Studio 5000, una vez creado el proyecto, en el árbol de
trabajo, en Add On Instruction, se hace click derecho y se le da importar, allí buscamos y
adjuntamos el archivo que acompaña este documento, figura 10.[3]

Fig. 10. Importar Instrucción de PackML

En la figura 11 se puede ver el archivo que se desea importar.

Fig. 11. Archivo a importar para el uso de PackML

10
Una vez se hace click en el botón “Import”, aparece una ventana emergente como la que
se ve en la figura 12, donde sólo se procede a dar “OK”.

Fig. 12. Ventana Emergente para finalizar importación de PackML

Una vez importado queda algo como lo que se ve en la figura 13

Fig. 13. PackML importado en Studio5000

Ahora para utilizarlo, lo arrastraremos a la rutina principal (Lader), como en la figura 14

y la figura 15.

11
 Fig. 14. Cómo agregar el módulo de PackML a una rutina Lader

Fig. 15. Módulo Recién agregado

Definimos las Variables para quitar los errores del Rung, para que quede como en la
figura 16

Fig. 16. Variables necesarias para el funcionamiento del módulo

12
Podemos descargar al plc y verificar que comienza en estado “Stopped”, con un contacto
pasaremos al estado “Resetting” y prenderemos un led cuando el estado sea “Resetting”,
como se aprecia en la figura 17.

Fig. 17. Algoritmo para prender un led en el estado Reseting

En la figura 18 se puede ver cómo inicia la máquina de estados recién se descarga el programa
al PLC

Fig. 18. Estado inicial del módulo

Una vez se cambia el estado a la variable “cambiar”, se ejecuta el comando “Reset”, lo que
provoca que la máquina de estados cambie su estado actual a “Resetting”, donde se energiza
una bobina llamada “Led”, esto se evidencia en las figuras 19 y 20.

13
 Fig. 19. Máquina de estados en estado Resetting

Fig. 20. Acción del estado Resetting

Bibliografía
[1] OMAC, “PackML Unit/Machine Implementation GUIDE.”
[2] “CODESYS - CODESYS.” [Online]. Available: https://www.codesys.com/. [Accessed: 25-
Jul-2019].
[3] “Automatización industrial | Seguridad industrial | Rockwell Automation España.”
[Online]. Available: https://www.rockwellautomation.com/es_ES/overview.page.
[Accessed: 25-Jul-2019].

14