Manual Rslogix5000

Libro de trabajo para las

sesiones prácticas

Logix para programadores

Sesión práctica de Logix para programadores I LOT-SP004A-ES-E Página 3 de 162

ACERCA DE ESTA SESIÓN PRÁCTICA ____________________________________________ 7

ANTES DE COMENZAR _______________________________________________________ 8

MATERIALES DE LA SESION PRACTICA ___________________________________________ 8

CONVENCIONES DEL DOCUMENTO _____________________________________________ 10

ACERCA DE ESTA SESIÓN PRÁCTICA ___________________________________________ 11

ACTIVACIÓN DEL SOFTWARE DE PROGRAMACIÓN RSLOGIX 5000 ______________________ 11

CÓMO ABRIR UN ARCHIVO EXISTENTE DEL CONTROLADOR ___________________________ 12

DIVISIÓN DEL PROGRAMA ACTUAL PARA USAR MÚLTIPLES TAREAS ____________________ 15

DIVISIÓN DE CADA SECCIÓN DEL CÓDIGO DEL TRANSPORTADOR EN SU PROPIO PROGRAMA EN LA TAREA

CONTINUA 26

RESUMEN DE LA SESIÓN PRÁCTICA 1 __________________________________________ 33



CÓMO DESCARGAR EL PROGRAMA ____________________________________________ 36

ACTIVIDAD 1 (EN LÍNEA): MÚLTIPLES TAREAS PERIÓDICAS O UNA TAREA PERIÓDICA _______ 37

RESUMEN DE LA ACTIVIDAD 1 ________________________________________________ 45

ACTIVIDAD 2 (EN LÍNEA): LOS EFECTOS DE LA TAREA PERIÓDICA EN LA TAREA CONTINUA ___ 46

RESUMEN DE LA ACTIVIDAD 2 ________________________________________________ 49



CÓMO CREAR UN TIPO DE DATOS DEFINIDO POR EL USUARIO PARA UN TRANSPORTADOR ____ 52

USO DEL UDT DE TRANSPORTADOR ___________________________________________ 60

USO DE LA FUNCIÓN DATA SCOPING ___________________________________________ 74


USO DE LA FUNCIÓN DATA SCOPING EN EL PROGRAMA _____________________________ 77





CÓMO DESCARGAR EL PROGRAMA _____________________________________________ 83

ACTIVIDAD 1 (EN LINEA): TIPOS DE DATOS INT COMPARADOS CON TIPOS DE DATOS DINT ___ 84

RESUMEN DE LA ACTIVIDAD 1_________________________________________________ 88



REUTILIZACIÓN DE CÓDIGO USANDO LAS FUNCIONES DE COPIAR Y PEGAR________________ 91

REUTILIZACIÓN DE CÓDIGO USANDO LA HERRAMIENTA LADDER PARTIAL IMPORT/EXPORT ___ 93


USO DE LA HERRAMIENTA LADDER PARTIAL IMPORT/EXPORT PARA HACER UNA EXPORTACIÓN A UN

ARCHIVO L5X ____________________________________________________________ 95


USO DE LA HERRAMIENTA LADDER PARTIAL IMPORT/EXPORT PARA HACER UNA IMPORTACIÓN A UN

ARCHIVO L5X ____________________________________________________________ 99


ACERCA DE ESTA SESIÓN PRÁCTICA __________________________________________ 106

CÓMO ABRIR UN ARCHIVO EXISTENTE DEL CONTROLADOR __________________________ 106

CÓMO DESCARGAR EL PROGRAMA ____________________________________________ 107

ACTIVIDAD 1: DUPLICACIÓN EN LÍNEA / SUBRUTINA INDEXADA / SUBRUTINA ALMACENADA EN UN BÚFER

108

RESUMEN DE LA ACTIVIDAD 1________________________________________________ 115



PORTABILIDAD DE UN PROYECTO ENTRE PLATAFORMAS LOGIX_______________________ 117




ASIGNACION DE TAGS DE ALIAS ______________________________________________ 128





HERRAMIENTA DE CÁLCULO DE MEMORIA FUERA DE LÍNEA __________________________ 143

RESUMEN DE LA SESIÓN PRÁCTICA 9 _________________________________________ 149


CÓMO PROBAR EL PROGRAMA ______________________________________________ 150

RESUMEN DE LA SESIÓN PRÁCTICA 10 ________________________________________ 162


Sesión práctica de Logix para programadores I

Acerca de esta sesión práctica

¡Bienvenido a esta serie de sesiones prácticas! Esta sesión proporciona una oportunidad de explorar la plataforma Logix. Las siguientes secciones explican lo que usted hará en esta sesión práctica, y lo que deberá hacer para completar los ejercicios prácticos.

Los programadores de PLC con experiencia aprenderán cómo aprovechar al máximo las características principales de programación que distinguen el sistema de los controladores programables tradicionales. Usted aprovechará las ventajas del modelo mutitarea/multiprogramas y de la configuración de memoria, y obtendrá sugerencias de edición y programación que le ayudarán a aumentar su productividad.

Para llevar esto a cabo, usted será asignado como programador principal de Logix en un fábrica de equipo original (OEM). El ingeniero que trabajaba con usted se fue de la compañía y ahora usted debe concluir el proyecto. El ingeniero era un usuario de PLC tradicional. Usted sabe que el cliente final ha especificado un sistema Logix de Rockwell Automation para el trabajo. Usted ha escuchado acerca de las potentes funciones que lo distinguen de los PLC tradicionales. Al comenzar a examinar el proyecto, usted nota que el ingeniero programó el proyecto como si estuviera todavía usando un PLC tradicional. Usted decide incorporar cambios para aprovechar las características Logix.

Lo que usted realizará en esta sesión práctica

A medida que complete los ejercicios en esta sesión práctica, usted:

Podrá realizar tareas de programación comunes en Logix de manera más productiva que con los PLC tradicionales. Esto se llevará a cabo mostrándole cómo utilizar:

Múltiples tareas

Múltiples programas

Tipos de datos definidos por el usuario (UDT)

Datos cubiertos

Reutilización de códigos

Portabilidad entre plataformas Logix

Alias

Cálculo de memoria fuera de línea

Funciones de descarga y prueba de su programa


¿A quién está dirigida esta sesión práctica?

Esta sesión práctica está diseñada para personas que:

Están familiarizadas con la programación de controladores SLC, PLC5 o Logix.

Han completado la sesión práctica Introducción a Logix.

Están familiarizadas con el software RSLogix 5000.

Antes de comenzar

Antes de comenzar esta sesión práctica, asegúrese de cerrar cualquier aplicación que esté activa actualmente. Tome nota que esto probablemente ya se hizo.

Para esta sesión práctica usted necesitará completar las 8 secciones en orden, ya que cada sección está basada en la sección previa.

Al final de la mayoría de secciones principales de la sesión práctica, encontrará la sección Temas cubiertos. Estas secciones ofrecen una evaluación de los temas recientemente cubiertos. Estas secciones son opcionales y no es obligatorio que usted las complete.

Materiales de la sesión práctica

Para esta sesión práctica le hemos proporcionado los siguientes materiales que le permitirán completar las sesiones prácticas incluidas en este libro de trabajo.

Hardware

Esta sesión práctica usa una de las siguientes unidades de demostración:

1796-CNET

Software

En esta sesión práctica se usa uno de los siguientes programas de software:

Software de programación RSLogix 5000 V13.03

RSLinx V2.43


Archivos

En esta sesión práctica se usan los siguientes archivos:

Estos archivos están ubicados en C:\RSLogix 5000\Project. Éste es el directorio predeterminado de RSLogix 5000.

Estos archivo se usan durante las principales secciones de la sesión práctica.

Conveyor_Program_S1.ACD








Conveyor_Program_S9_CLX.ACD

Conveyor_Program_S9_CLX.ACD

Look_up_a_bar_code.ACD

Estos archivo se usan en las secciones Temas cubiertos de la sesión práctica y son opcionales.

Z_A1_program_task_CLX.ACD

Z_A2_Int_Dint_CLX.ACD

Z_A3_PM_CLX.ACD

Z_A4_Porting_CLX.ACD

Z_A5_Alias_CN_CLX.ACD


Convenciones del documento

En este libro de trabajo hemos usado las siguientes convenciones para guiarle en el uso de los materiales de la sesión práctica.

Este estilo o símbolo: Indica lo siguiente:

Palabras mostradas en negrita cursiva (por ej., RSLogix 5000 u OK)

Cualquier ítem o botón en el que usted debe hacer clic, o un nombre de menú en el que debe elegir una opción o comando. Éste será el nombre de un ítem que usted verá en la pantalla o en un ejemplo.

Palabras mostradas en texto Courier, entre comillas sencillas (por ej., 'Controller1')

Un ítem que usted debe escribir en el campo especificado. Ésta es información que usted debe suministrar según su aplicación (por ej., una variable).

Nota: Cuando escriba el texto en el campo, recuerde que no necesita escribir las comillas; simplemente escriba las palabras (por ej., Controller1).

Para su información El texto que sigue a este símbolo es información suplementaria respecto a los materiales de la sesión práctica, pero no es información de lectura requerida para que usted complete los ejercicios. El texto que sigue a este símbolo puede proporcionarle sugerencias útiles que pueden facilitar el uso de este producto.

Nota: Si no se especifica el botón del mouse, usted debe hacer clic en el botón izquierdo del mouse.


Sesión práctica 1: Uso de multitareas/multiprogramas en Logix (20 minutos)


En esta sesión práctica introduciremos el modelo multitareas/multiprogramas en Logix. Esto demostrará la facilidad de la configuración del programa comparado con los PLC tradicionales. Usted tomará un programa existente programado con técnicas usadas en los PLC tradicionales y lo modificará para aprovechar el modelo multitareas/multiprogramas en Logix. El programa existente contiene código de lógica de escalera para 3 segmentos de transportador y un lazo de temperatura. En esta sesión práctica, usted:

abrirá un archivo de controlador existente

transferirá un lazo PID de la tarea continua a una tarea periódica

utilizará múltiples programas en la tarea continua para segmentar la programación de los 3 transportadores para facilidad de uso

Siga los pasos siguientes para completar la sesión práctica 1.

Activación del software de programación RSLogix 5000

En esta sección de la sesión práctica, usted activará el software RSLogix 5000, lo cual le permitirá programar el proyecto.

1. Haga doble clic en el icono RSLogix 5000 del escritorio para iniciar el software RSLogix 5000.

Aparece la pantalla RSLogix 5000.


Cómo abrir un archivo existente del controlador

En esta sección de la sesión práctica usted abrirá un programa existente.

1. En el menú File, seleccione Open.

Aparece la ventana Open/Import Project.


2. Haga clic con el botón izquierdo del mouse en el programa llamado Conveyor_Program_S1.ACD. El nombre del programa se resaltará y aparecerá en el campo File Name: Con esto se seleccionará el programa Conveyor_Program_S1.ACD.

3. Haga clic con el botón izquierdo del mouse en Open. Se abrirá el archivo seleccionado.


El Controller Organizer aparece al lado izquierdo de la ventana RSLogix 5000, con una carpeta del controlador llamada Conveyor_Program.

Para su información

El Controller Organizer es una representación gráfica del contenido de su archivo del controlador. Esta pantalla consta de un árbol de carpetas y archivos que contienen toda la información acerca de los programas y datos en el archivo del controlador actual. Las carpetas principales predeterminadas en este árbol son:

Controller File Name – contiene los tags del controlador cubiertos, el administrador de fallos del controlador y el administrador de encendido.

Tasks – en esta carpeta se muestran las tareas. Cada tarea muestra sus propios programas con rutinas y tags del controlador cubiertos.

Trends – en esta carpeta se muestran las tendencias.

Data Types – muestra tipos de datos predefinidos y definidos por el usuario. Los tipos de datos se crean en esta carpeta.

I/O Configuration – contiene información acerca de la configuración de hardware de este archivo del controlador. Dispone de una jerarquía de módulos con los cuales se comunica el controlador.

Al frente de cada carpeta, hay un cuadrado que contiene el signo + o el signo –. El signo + indica que la carpeta está cerrada. Haga clic en él para expandir la pantalla del árbol y mostrar los archivos en la carpeta. El signo – indica que la carpeta ya está abierta y su contenido está visible.


División del programa actual para usar múltiples tareas

Después de examinar el Controller Organizer usted observa que su ingeniero configuró el programa como si fuera un PLC tradicional. Usted recuerda, por su experiencia pasada, que esto dificulta la codificación, la resolución de problemas y la adición de segmentos de transportador adicionales. Usted decidió aprovechar al máximo el sistema Logix y segmentar las rutinas en 4 programas separados: un programa para cada transportador y una tarea periódica para el lazo de temperatura.

Para su información: Tareas en los controladores Logix

Los controladores Logix pueden utilizar 3 tipos de tareas: continua, periódicas y de evento. Usted puede definir hasta 32 tareas en un controlador ControlLogix. (Nota: Los controladores FlexLogix, DriveLogix y CompactLogix aceptan 8 tareas)

Tarea continua: La tarea continua se ejecuta en segundo plano. Cualquier tiempo de ejecución del controlador no asignado a otras tareas u operaciones (control de movimiento, tareas periódicas, tareas de evento, comunicaciones o diagnósticos) se usa para ejecutar la tarea continua.

La tarea continua se ejecuta todo el tiempo. Cuando se completa la ejecución de todo el escán, éste se reinicia.

Un proyecto no necesita tener una tarea continua. Si ésta se usa, el proyecto sólo puede tener una tarea continua.

Usar: si usted desea que el código escanee todo el tiempo.

Tarea periódica: Una tarea periódica realiza una tarea según un período especificado. Usted puede configurar el régimen de ejecución de 0.1 ms a 2000 s. Cada vez que el período de la tarea periódica expire, la tarea periódica::

Interrumpirá cualquier tarea de menor prioridad

Se ejecutará una vez

Devolverá el control a la tarea interrumpida

Usar: si usted desea ejecutar un código según un período constante o múltiples veces dentro del escán de la tarea continua.

Tarea de evento: Una tarea de evento realiza una función específica basada en un evento o disparo. Los disparos pueden ser una entrada digital, una entrada analógica, operaciones de control de movimiento, un tag consumido o una instrucción de evento. Cuando el evento ocurre, la tarea de evento:

Interrumpirá cualquier tarea de menor prioridad

Se ejecutará una vez

Devolverá el control a la tarea interrumpida

Usar: si usted desea ejecutar el código tan pronto como ocurre un evento o disparo.


1. En el Controller Organizer, expanda la carpeta MainProgram haciendo clic en el signo +.

2. Una vez que se expanda el MainProgram, se verá similar a la figura siguiente.

Si hace doble clic en la MainRoutine, verá que el ingeniero estaba tratando de segmentar el programa usando la instrucción JSR para ir a los transportadores y el lazo de temperatura. Luego, si hace doble clic en la rutina Conveyor_1, notará las JSR a las rutinas relacionadas con ese transportador. Esta es la manera en que un PLC tradicional hace la segmentación del programa. Así no se aprovecha el sistema Logix.

Lo primero que usted observa es que el lazo de temperatura está codificado en la MainTask, que es una tarea continua.



Usted puede conocer el tipo de tarea si se fija en el icono de la carpeta.

Un icono de Tarea continua tiene el siguiente aspecto:

Un icono de Tarea de evento tiene el siguiente aspecto:

Un icono de Tarea periódica tiene el siguiente aspecto:

Usted sabe que es mejor programar un lazo PID usando tareas periódicas. Por lo tanto, lo primero que decide hacer es mover la rutina Temperature_Loop a una tarea periódica.

3. Haga clic con el botón derecho del mouse en la carpeta Tasks y seleccione New Task.


4. Aparecerá la ventana New Task.


En esta ventana usted configura las propiedades de una nueva tarea. Esta ventana cambia según el tipo de tarea que usted elija.

Hay dos nuevas opciones de configuración para cada tarea (comenzando con V12):

Disable Automatic Output Processing to Reduce Task Overhead

Al final de una tarea se realiza el procesamiento de salida. El controlador examina el árbol de E/S y actualiza el estado de las salidas afectadas por la tarea. Al desactivar el procesamiento de salida, la tarea se ejecuta más rápidamente. Si usted tiene una tarea periódica que sólo hace manipulación de datos y no tiene salidas, puede ser conveniente desactivar el procesamiento de salida. O si sólo tiene unas cuantas salidas que son manipuladas por la tarea, puede ser conveniente inhabilitar el procesamiento de salida y usar la instrucción IOT (Immediate Output), procesamiento de salida efectuado inmediatamente.

También puede habilitar e inhabilitar el procesamiento de salida programáticamente a través del código de aplicación usando la instrucción SSV (Set System Variable).

Inhibit Task

Esta función le permite evitar que se ejecute una tarea. Se utiliza durante la puesta en marcha del sistema para aislar y probar una tarea específica inhibiendo otras tareas en el proyecto.


También puede inhibir o desinhibir una tarea programáticamente a través del código de aplicación usando la instrucción SSV (Set System Variable).

5. Configure la nueva tarea periódica de acuerdo a los datos siguientes. Cuando haya terminado, haga clic en OK.

6. La sección Tasks del Controller Organizer ahora debe tener el siguiente aspecto.


7. Actualmente no hay un programa definido en la tarea periódica Temperature_Loop. Para añadir un programa, haga clic con el botón derecho del mouse en Temperature_Loop y seleccione New Program.

8. Aparecerá la ventana New Program.

9. Escriba, como nombre del programa, „PID_Loop‟. Cuando haya terminado, haga clic en OK

10. Haga clic en el signo + para expandir el programa PID_Loop que acaba de añadir a la tarea periódica Temperature_Loop. Usted notará que todavía no hay rutinas asignadas a este programa.


11. No tendremos que crear una nueva rutina. Arrastraremos la rutina Temperature_Loop desde la tarea continua hasta la tarea periódica. Coloque el puntero sobre la rutina Temperature_Loop. Haga clic y mantenga presionado el botón izquierdo del mouse. La rutina se resaltará. Arrastre la rutina Temperature_Loop y colóquela sobre el programa PID_Loop en la tarea periódica.

12. Cuando suelte el botón izquierdo del mouse, la rutina Temperature_Loop se añadirá al programa PID_Loop.

13. A continuación configuraremos el programa PID_Loop para tener una rutina principal que será la rutina Temperature_Loop que acabamos de arrastrar y colocar.


14. Haga clic con el botón derecho del mouse en PID_Loop y luego seleccione Properties.

15. Aparecerá la ventana Program Properties.


16. Haga clic en la ficha Configuration. Se activará la ficha Configuration. Usted observa que no se ha asignado una rutina principal.


Se pueden asignar dos tipos de rutinas para un programa: principal y de fallo. Usted siempre debe asignar una rutina principal. La rutina de fallo es opcional.

La rutina principal es la primera rutina que se ejecuta cuando se ejecuta el programa. Por ejemplo, en nuestro caso, cuando se ejecuta el PID_Loop del programa, éste se iniciará con la rutina Temperature_Loop. Esto es equivalente a una MCP para un PLC5 o un Archivo 2 para un SLC.

La rutina de fallo le permite usar código para borrar fallos específicos y permite que el controlador continúe con la ejecución. No programe la rutina de fallo para borrar globalmente todos los fallos mayores recuperables.


17. Lo que queremos es asignar la rutina Temperature_Loop como rutina principal. Para ello, haga clic en la flecha hacia abajo del cuadro de selección junto a Main: Seleccione Temperature_Loop y haga clic en Apply.

18. Con esto se asigna la rutina Temperature_Loop como rutina principal. Haga clic en OK para cerrar la ventana Program Properties.

19. Haga doble clic en la rutina Temperature_Loop. Esto abrirá el editor de lógica de escalera. Puesto que la instrucción PID anteriormente estaba en la tarea continua, tuvo que usarse un temporizador para condicionar la ejecución de PID.


20. Ahora que PID se está ejecutando en una tarea periódica, la condición de temporizador ya no se necesita. Elimine el renglón cero y la condición de temporizador efectuado (XIC) en el renglón uno.

21. En el menú File, seleccione Save As. Aparecerá la ventana Save As.

22. En el campo File Name, escriba „Conveyor_Program_S2‟. Luego haga clic en Save. Si el sistema le indica que reemplace el archivo, haga clic en Yes.


División de cada sección del código del transportador en su propio programa en la tarea continua

Ahora que usted ha concluido la transferencia del lazo de temperatura a la tarea periódica, usted decide dividir cada código del transportador en su propio programa. Esto permitirá una más fácil codificación, resolución de problemas y adición de segmentos adicionales de transportador en el futuro.

Usted continuará trabajando en el programa de la sección anterior, Conveyor_Program_S2.


Un controlador Logix le permite dividir su aplicación en múltiples programas, cada uno con sus propios datos. No hay necesidad de administrar nombres de tags que crean conflicto entre programas. Esto facilita la reutilización de códigos y nombres de tag en diferentes programas.

Actualmente, sólo nos dedicaremos al uso de varios programas. Posteriormente aprenderemos a administrar nombres de tags.

1. En el Controller Organizer, haga clic con el botón derecho del mouse en la carpeta MainTask y seleccione New Program.

2. Aparecerá la ventana New Program.


3. Cree un programa para el transportador 1. Escriba „Conveyor_1‟ en el campo Name. Luego, haga clic en OK.

4. En el Controller Organizer, ahora usted tendrá 2 programas en la tarea continua: MainProgram y Conveyor_1.

5. Ahora, arrastre y coloque las 4 rutinas de MainProgram en el programa Conveyor_1. Estas rutinas son C1_Alarm_Status, C1_Energy_Manag, C1_Start_Stop y Conveyor_1.


6. Cuando haya terminado, el Controller Organizer aparecerá de la siguiente manera:

7. A continuación debemos asignar una rutina principal al programa Conveyor_1. Recuerde que un programa siempre debe tener una rutina principal.

8. Haga clic con el botón derecho del mouse en la carpeta del programa Conveyor_1 y seleccione Properties.


9. Aparecerá la ventana Program Properties.

10. Haga clic en la ficha Configuration. Se activará la ficha Configuration.


11. Lo que queremos es asignar la rutina Conveyor_1 como rutina principal. Para ello, haga clic en la flecha hacia abajo del cuadro de selección junto a Main. Seleccione Conveyor_1 y haga clic en Apply.

12. Haga clic en OK para cerrar la ventana Program Properties.

13. En el Controller Organizer, la estructura del programa ahora aparece como se indica a

continuación. Usted observa que aparece junto a la rutina Conveyor_1. Esto la designa como rutina principal para el programa Conveyor_1.

14. Repita los pasos 1 al 12 para los otros 2 transportadores.


15. Cuando haya terminado de crear los programas para los otros 2 transportadores, la estructura del programa en el Controller Organizer aparecerá como se indica a continuación:

16. En la tarea continua, el MainProgram ya no se necesita. Ahora lo retiraremos del programa.

17. Primero tendremos que retirar el MainProgram de la lista de tareas continuas de programas programados para ejecutar. Haga clic con el botón derecho del mouse en la carpeta MainTask y seleccione Properties.


18. Aparecerá la ventana MainTask Properties.

19. Haga clic en la ficha Program Schedule. Se activará la ficha Program Schedule.


20. En la lista Scheduled, resalte MainProgram. Haga clic en Remove. Luego haga clic en Apply. Con esto se cancela la sincronización del programa. Ahora está cancelada la sincronización del programa y éste ya no será ejecutado por el controlador.

En la figura siguiente usted verá que el MainProgram ahora aparece en la lista Unscheduled.

Para su información: Priorización del programa

¿Qué significa la priorización del programa? Usted determina el orden en que se ejecutan los programas en una tarea.

En la figura anterior, el orden de ejecución sería Conveyor_1, Conveyor_2 y luego Conveyor_3. Usted puede cambiar el orden de ejecución resaltando un programa y usando las flechas de movimiento hacia arriba y hacia abajo.

Los programas no sincronizados continúan descargándose al controlador, pero no se ejecutan.

21. Haga clic en OK para cerrar la ventana Task Properties.

22. Guarde el programa haciendo clic en el icono Save en la barra de herramientas.

23. En el menú File, seleccione Close.

Resumen de la Sesión práctica 1

En esta sesión práctica tomamos un programa existente programado con técnicas usadas en los PLC tradicionales y lo modificamos para aprovechar el modelo multitareas/multiprogramas en Logix. Esto permite una más fácil codificación, resolución de problemas y expansión de código.


Sesión práctica 2: Temas cubiertos (20 minutos)

A continuación se indican los temas cubiertos. Usted puede continuar o pasar a la siguiente sesión práctica en la página 53.


En esta sección de temas cubiertos usted explorará el concepto usando:

Tareas para segmentar un proyecto en lugar de usar programas en una tarea para segmentar un proyecto

Los efectos de la ejecución de la tarea periódica en la tarea continua

En un PLC tradicional usted tenía 3 tipos diferentes de “tareas”

Principal = Continua en Logix

STI = Periódica en Logix

PII/DII = Evento en Logix

Pero sólo tenía una STI y PII/DII. En Logix usted tiene múltiples tareas periódicas y de eventos. Esto puede ser una herramienta potente, pero debe entenderse antes de implementarse.

Al programar con Logix, surge la pregunta: ¿cuál es la mejor manera de segmentar un proyecto? ¿Es mejor usar múltiples programas en una sola tarea o múltiples tareas periódicas con un programa? La respuesta más común es usar múltiples tareas periódicas con un programa, lo cual, en el 99% de los casos, es la decisión incorrecta. ¿Por qué? La mejor manera de demostrarlo es con un ejemplo en línea.

Esto se logrará usando un programa que tiene una tarea continua con 5 programas separados, 5 tareas periódicas con un programa cada una y una tarea periódica con 5 programas.

Para la tarea continua todos los programas son iguales, un lazo simple para hacer la ejecución del programa en 5 ms. Por lo tanto, con 5 programas, la tarea continua debe requerir aproximadamente 25 ms para ejecutarse. Las 5 tareas periódicas contienen el mismo programa que la tarea continua, por lo tanto cada ejecución debe tomar aproximadamente 5 ms. La pregunta ahora es: ¿A qué régimen debo ejecutar la tarea periódica y con qué prioridad deben ejecutarse las tareas?

Para su información: Prioridad de la tarea periódica

Para una tarea periódica, usted puede asignar un nivel de prioridad de 1 a 15. 1 es la prioridad más alta y 15 es la prioridad más baja. Una tarea de prioridad mayor siempre interrumpirá a una tarea de prioridad menor. ¿Qué sucede si usted tiene tareas con la misma prioridad? Las tareas se alternarán.


Alternar tareas significa que cuando múltiples tareas se ejecutan con la misma prioridad, éstas se ejecutarán en segmentos de tiempo de 1 ms alternándose entre sí. Por ejemplo, si tiene 3 tareas periódicas con la misma prioridad, la Tarea 1 se ejecutará por 1 ms, luego la Tarea 2 se ejecutará por 1 ms y luego la Tarea 3 se ejecutará por 1 ms. Este patrón se repetirá hasta que se haya completado la ejecución de todas las tareas.

La mayoría de personas establecerían 21 ms o 25 ms para los períodos de tareas periódicas y les darían la misma prioridad.

Veamos el detalle descargando un programa y viendo las diferentes ejecuciones de tareas y programas en acción.

Siga los pasos siguientes para completar esta sesión práctica avanzada .






2. Haga clic con el botón izquierdo del mouse en el programa llamado Z_A1_program_task_CLX.ACD.. El nombre del programa se resaltará y aparecerá en el campo File Name: Con esto ha seleccionado Z_A1_program_task_CLX.ACD.


Cómo descargar el programa

Ahora descargaremos el programa Z_A1_program_task_CLX.ACD.

1. En el menú Communication seleccione Download.


2. La ruta de comunicación al controlador se ha guardado con el proyecto. Cuando aparezca la ventana Download, seleccione Download.

3. El programa se descargará. El sistema le pedirá que cambie el controlador al modo de marcha, seleccione Yes. Si no se le pidió que cambie el controlador al modo de marcha, use el interruptor de llave para colocar el controlador en el modo de marcha.

Actividad 1 (en línea): Múltiples tareas periódicas o una tarea periódica

En esta sección exploraremos cuál metodología de programación es mejor: múltiples tareas o una tarea con múltiples programas.

1. En el Controller Organizer, usted observará que hay una tarea continua y siete tareas periódicas. Es posible que necesite minimizar las carpetas de tareas. La tarea periódica llamada Manager se usa para manipular los otros atributos de tareas. Actualmente, la tarea continua y siete tareas periódicas están inhibidas y no se ejecutarán.



Usted observa un símbolo sobre algunas de las carpetas de tareas. El símbolo de

pausa significa que la tarea está inhibida actualmente o no se está ejecutando.

2. En el Controller Organizer, haga clic con el botón derecho del mouse en la tarea periódica Periodic y seleccione Properties.

3. Aparecerá la ventana Task Properties.

4. Haga clic en la ficha Monitor.


5. En la ficha Monitor verá varios campos.

Para su información: Ficha Task Properties Monitor

Scan Times (Elapsed Time): Mostrará los tiempos transcurridos máximo y último de esta tarea.

Interval Times (Elapsed Timer Between Triggers): Mostrará los tiempos máximo y mínimo entre disparos de las tareas periódicas. Este tiempo debe ser aproximadamente el período de ejecución de la tarea periódica.

Task Overlap Count: Éste es el número de veces que esta tarea se activó para su ejecución y no pudo realizarse porque estaba en ejecución actualmente. Cuando esto ocurre, el controlador registrará un fallo menor.

Reset: Este botón restablecerá todos los campos a cero.

6. Haga clic en el botón Reset.

7. Usted verá que los tiempos de escán para la tarea son de aproximadamente 5 ms y el intervalo es aproximadamente 75 ms. El período para la tarea es 75 ms.

8. En el Controller Organizer, haga doble clic en Controller Tags. Esto abrirá el Tag Monitor. En la ventana Tag Monitor podremos manipular la ejecución del programa. Verifique que está en la ficha Monitor Tags.


9. En el Tag Monitor introduzca un 1 en la columna de valor para Inhibit_Periodic y presione Enter. El valor regresará a cero.

10. En el Tag Monitor introduzca un 1 en la columna de valor para Uninhibit_Periodic y presione Enter. El valor regresará a cero.

11. Esto causará que las otras tareas periódicas que están inhibidas comiencen a ejecutarse.

12. En el menú Window, seleccione Task Properties – Periodic. Esto traerá la ventana Task Properties al primer plano.

13. Cuando aparezca la ventana Task Properties, haga clic en el botón Reset.


14. Si se fija en la ventana Task Properties, observará que el tiempo de escán para la tarea ahora es aproximadamente 21 ms. Esto se debe a que la conmutación de tareas está ocurriendo entre las 5 tareas periódicas.

15. ¿Qué sucedería si reducimos el período de las tareas periódicas a 22 ms? En el menú Window, seleccione Controller Tags – A1_program_task(controller).

16. Esto traerá la ventana Tag Monitor al primer plano.

17. En el Tag Monitor introduzca un 1 en la columna de valor para Periodic_to_22 y presione Enter. El valor regresará a cero. Con esto acaba de cambiar todos los períodos de tareas periódicas a 22 ms.


18. Traiga Task Properties – Periodic al primer plano.

19. Haga clic en el botón Reset. Usted nota que el tiempo de escán para las tareas ahora es aproximadamente 21 ms, pero Interval Time muestra un máximo de aproximadamente 24 ms. Fue una buena decisión elegir este régimen de tarea periódica desde un inicio, ¿verdad?

20. En el Controller Organizer, haga clic con el botón derecho del mouse en la tarea periódica Periodic4 y seleccione Properties.

21. Cuando aparezca la ventana Task Properties – Periodic4, haga clic en la ficha Monitor.

22. Cuando aparezca la ficha Monitor, haga clic en el botón Reset.


23. Lo que aparece aquí no es lo que la mayoría espera.

Aparece un valor en Task Overlaps y el valor de Scan Times no es 21 ms. Esto se debe a la conmutación de tareas.

Recuerde, la tarea periódica conmutará tareas en incrementos de 1 ms. Una manera fácil de mostrar esto es con un cronograma. Por ejemplo, cada vez que usted ve P1 en la figura siguiente, es la ejecución en 1 ms de la tarea periódica 1.

P1 P2 P3 P4 P5 | P1 P2 P3 P4 P5 | P1 P2 P3 P4 P5 | P1 P2 P3 P4 P5 | P1 P2 P3 P4 P5 |

Por lo tanto, ¿cuánto tiempo requiere la tarea periódica P1 para ejecutarse? Cuente el número de PX hasta que haya contado cinco P1. Usted obtiene un conteo de 21 o 21 ms; esto es lo que vimos. Ahora, ¿cuánto tiempo requiere la tarea periódica P5 para ejecutarse? Con un conteo usted obtendrá 25 ms; esto sería para la tarea Periodic4. Esto es lo que vimos.

24. Regrese a Tag Monitor. Introduzca un 1 en la columna de valor para Periodic_to_75 y presione Enter. El valor regresará a cero. Con esto acaba de cambiar todos los períodos de tareas periódicas nuevamente a 75 ms.

25. Por lo tanto, ejecutar las tareas periódicas a 22 ms no fue una buena idea. Usted piensa, “las ejecutaré a 26 ms, esto me proporcionará tiempo de procesamiento interno y será aceptable”.

26. Modifique el valor del tag Task_22 a 26000. Esto nos permitirá cambiar los períodos de las tareas periódicas a 26 ms.


27. Introduzca un 1 en la columna de valor para Periodic_to_22 y presione Enter. El valor regresará a cero. Con esto acaba de cambiar todos los períodos de tareas periódicas nuevamente a 26 ms.

28. Conmute nuevamente a la ventana Task Properties – Periodic.

29. Haga clic en el botón Reset. Parece que todo está bien, pero lo que realmente debemos examinar es Periodic4.

30. Conmute a la ventana Task Properties – Periodic4.

31. Haga clic en el botón Reset. Usted observa que ya no hay superposiciones de tareas y el tiempo de escán es aproximadamente 24 ms. Todo está bien, la tarea se está ejecutando en el tiempo que esperábamos, y no hay superposiciones.

32. Cierre la ventana Task Properties haciendo clic en OK.

33. En la ventana Tag Monitor introduzca un 1 en la columna de valor para Inhibit_Periodic y presione Enter. El valor regresará a cero. Usted acaba de inhibir la ejecución de todas las tareas periódicas.

34. En la ventana Tag Monitor introduzca un 1 en la columna de valor para Combined_Periodic y presione Enter. El valor regresará a cero. Acaba usted de iniciar la ejecución de la tarea Combined_Periodic.

35. En el Controller Organizer, haga clic con el botón derecho del mouse en la tarea periódica Combined_Periodic y seleccione Properties.

36. Cuando aparezca la ventana Task Properties, haga clic en la ficha Configuration. Observará que el período está establecido para 25 ms.

37. A continuación, haga clic en la ficha Monitor.



39. Notará que el período de ejecución es menos de 25 ms y que no hay superposiciones, pero cuando tenía 5 tareas periódicas individuales, hubieron superposiciones y tuvo que establecer el período en 26 ms. En este caso el programa no tiene el tiempo de procesamiento interno adicional de la conmutación de tareas. Cierre la ventana haciendo clic en OK.

Usted observa que el tiempo de escán aquí es menor que el de la tarea periódica Periodic4 anterior. Usted obtiene un mejor rendimiento con la tarea Combined_Periodic.

Resumen de la actividad 1

En esta sesión práctica demostramos que es mejor hacer la segmentación del programa usando múltiples programas en una tarea en lugar de múltiples tareas. Usted obtendrá así un mejor rendimiento y no tiene que preocuparse acerca de la conmutación de tareas.

También es conveniente evitar tener varias tareas con la misma prioridad y períodos similares para evitar el tiempo de escán adicional debido a la conmutación de tareas.

El programa de ejemplo usó todas las tareas periódicas con el mismo período y prioridad. ¿Qué sucedería si tuviera un proyecto con la siguiente configuración?

Período de tarea Periodic1 2 ms, prioridad 1, ejecución 1 ms





Una mejor configuración del programa sería:



Período de tarea Periodic23 4 ms, prioridad 2, ejecución 2.0 ms (Periodic2 y Periodic3 combinadas)

Período de tarea Periodic45 15 ms, prioridad 7, ejecución 11 ms (Periodic4 y Periodic5 combinadas)

De esta manera usted evita tareas con la misma prioridad combinándolas y también combinando tareas que se ejecutan con períodos similares.

Actividad 2 (en línea): Los efectos de la tarea periódica en la tarea continua

En esta sección continuaremos usando el mismo programa de la sección previa. Veremos los efectos que las tareas periódicas tienen en la ejecución de la tarea continua.

1. En la ventana Tag Monitor introduzca un 1 en la columna de valor para Uninhibit_Continuous y presione Enter. Esto inhibirá la tarea Combined_Periodic y permitirá que la tarea continua se ejecute.

2. Abra la ventana Properties para la Continuous Task.

3. Cuando aparezca la ventana Task Properties – MainTask, haga clic en la ficha Monitor.

4. Notará que el tiempo de escán para la tarea continua es aproximadamente 24 ms a 29 ms.

5. Veamos el efecto de las tareas periódicas en la tarea continua.


7. Vaya a la ventana Tag Monitor.

8. Modifique el valor del tag Task_22 a 25000 (si está usando un controlador FlexLogix, el valor será 23000). Esto nos permitirá cambiar los períodos de la tarea periódica a 25 ms.


9. Introduzca un 1 en la columna de valor para Periodic_to_22 y presione Enter. El valor regresará a cero. Con esto acaba de cambiar todos los períodos de las tareas periódicas a 25 ms (23 ms para un controlador FlexLogix).

10. Introduzca un 1 en la columna de valor para Uninhibit_Periodic y presione Enter. El valor regresará a cero. Usted acaba de activar todas las tareas periódicas.

11. Usted nota al observar la plantilla del controlador que el controlador entró en fallo.

12. Haga clic en el icono del controlador junto a la palabra Faulted. Aparecerá un menú desplegable. Seleccione Go To Faults.


13. Aparecerá la ventana Controller Properties – A1_program_task. El error es un fallo del temporizador de control (watchdog) para la MainTask (la tarea continua). Esto significa que la tarea continua no completó su ejecución en menos de 500 ms. Esto sucedió porque las tareas periódicas estaban privando a la tarea continua de la ejecución.

14. Haga clic en el botón Clear Majors.

15. Haga clic en OK para cerrar la ventana Controller Properties.

16. Tendremos que modificar los períodos de la tarea periódica a fin de no experimentar fallos del temporizador de control (watchdog). En la ventana Tag Monitor introduzca 27000 en la columna de valor para Task_22 y presione Enter. Esto cambia los períodos de tareas periódicas a 27 ms.

17. En la ventana Tag Monitor introduzca un 1 en la columna de valor para Periodic_to_22 y presione Enter. Con esto se hace efectivo el cambio en la tarea periódica.

18. Ponga el controlador en el modo Run. El valor en Periodic_to_22 cambiará a cero. Esta vez el controlador no entra en fallo.

19. Abra la ventana Properties para la MainTask.




22. Usted observa que el tiempo de escán para la tara aumentó considerablemente. Anteriormente, cuando la tarea continua era la única tarea en ejecución, se ejecutaba en 24 a 28 ms. Esto se debe a que las tareas periódicas tienen una mayor prioridad que la tarea continua.


24. En el menú Communication seleccione Go Offline.

25. En el menú File, seleccione Close. Si el sistema le pide que guarde los cambios, seleccione No.


En esta sesión práctica demostramos el efecto que la ejecución de la tarea periódica tendrá en la ejecución de la tarea continua. Es importante equilibrar las necesidades de las tareas periódicas con las de la tarea continua. Recuerde que el servicio de comunicaciones en el controlador ocurre durante la tarea continua (durante el segmento del tiempo de procesamiento interno del sistema). Por lo tanto, si usted priva de la ejecución a la tarea continua, también privará a las comunicaciones en el controlador. Esto afectará los mensajes, las transferencias en bloques, las actualizaciones de HMI, RSLogix 5000, el controlador que establece conexiones, etc.


Sesión práctica 3: Configuración de la base de datos de tags en un controlador Logix (40 minutos)


En esta sesión práctica, analizaremos y mostraremos cómo configurar la base de datos de tags usando las funciones User Defined Data Types y Data Scoping. En esta sesión práctica, usted:

Aprenderá las ventajas de usar UDT

Aprenderá como optimizar la configuración de UDT

Usará la función Data Scoping para facilitar y acelerar el desarrollo

Continuaremos modificando el programa de la sesión práctica 1. Ahora nos concentraremos en la configuración de los datos en un controlador Logix.







2. Haga clic con el botón izquierdo del mouse en el programa llamado Conveyor_Program_S3.ACD. El nombre del programa se resaltará y aparecerá en el campo File Name: Con esto ha seleccionado Conveyor_Program_S3.ACD.


Cómo crear un tipo de datos definido por el usuario para un transportador

Puesto que usted ha reorganizado la configuración del programa para aprovechar Logix, ahora está listo para comenzar a reorganizar la configuración de los datos. Usted observa que el ingeniero configuró los datos como si hubiera usado un PLC tradicional, tablas de datos de temporizador, enteros y reales. El problema es que es difícil mantener un seguimiento de los datos asociados con un dispositivo cuando estos están distribuidos en toda la memoria del controlador. Nuevamente, usted decidió aprovechar al máximo el sistema Logix y usar los tipos de datos definidos por el usuario.

Para su información: Tipos de datos definidos por el usuario

Los tipos de datos definidos por el usuario, conocidos como UDT o estructuras, le permiten organizar o agrupar los datos de manera lógica, de manera que puedan agruparse todos los datos asociados con un dispositivo.

Por ejemplo, cada transportador tiene 8 valores enteros, 3 valores reales, 2 temporizadores y 11 booleanos asociados con éste. En un PLC tradicional, se necesitarían 4 tablas de datos diferentes. Luego, al tener múltiples transportadores sería necesario asignar los transportadores a cada tabla de datos. Esto se hace difícil de manejar.

Un UDT le permite agrupar los diferentes tipos de datos (enteros, reales, de temporizador, booleanos, etc.), en un tipo de datos definido por el usuario. Usted puede crear una matriz de ese tipo UDT. Esto facilita la programación, la documentación del código y seguimiento de los datos.


1. En el Controller Organizer, haga doble clic en Controller Tags. Esto abrirá el Tag Editor.

2. Aparecerá el Tag Editor. Usted nota que la base de datos de tags tiene el mismo aspecto que la del PLC tradicional.

Para su información: Base de datos de tags Logix

En un PLC tradicional, una dirección física identifica cada ítem de dato, tal como N7:0 o B3:0/0. Si no se usaran los comentarios de dirección o símbolos, sería muy difícil leer la lógica.

En los controladores Logix no hay memoria fija, N7:0 o B3:0/0. La memoria Logix es un sistema basado en tags. El nombre del tag identifica a los datos. Esto le permite organizar los datos para imitar a su máquina. Usted puede documentar su código con los nombres de tags asignados, por ejemplo Nozzle_1_Temperature.


Para su información – Pautas para crear tags para un proyecto Logix

Pautas Detalles:

Cree tipos de datos definidos por el usuario.

Los tipos de datos definidos por el usuario (estructuras) le permiten organizar sus datos según su máquina o proceso. Un tipo de datos definido por el usuario proporciona estas ventajas:

Un tag contiene todos los datos relacionados a un aspecto específico de su

sistema. Esto mantiene juntos los datos relacionados y facilita su ubicación,

independientemente de su tipo de datos.

Cada pieza individual de datos (miembro) obtiene un nombre descriptivo. Esto

crea automáticamente un nivel inicial de documentación para su lógica.

Usted puede usar los tipos de datos para crear múltiples tags con la misma

configuración de datos.

Por ejemplo, use un tipo de datos definido por el usuario para almacenar todos los parámetros de un tanque, inclusive valores de temperatura, presión, posición de válvula y valores preseleccionados. Luego cree un tag para cada tanque basado en ese tipo de datos.

Use matrices para crear rápidamente un grupo de tags similares.

Una matriz crea múltiples ocurrencias de un tipo de datos bajo un nombre de tag común.

Las matrices permiten organizar un bloque de tags que usa el mismo tipo

de datos y realiza una función similar.

Usted organiza los datos en 1, 2 ó 3 dimensiones según lo que los datos

representan.

Por ejemplo, use una matriz de 2 dimensiones para organizar los datos para una zona de tanques. Cada elemento de la matriz representa un tanque. La ubicación del elemento dentro de la matriz representa la ubicación geográfica del tanque.

Importante: Reduzca al mínimo el uso de matrices BOOL. Muchas

instrucciones de matriz no funcionan en matrices BOOL. Esto hace más difícil inicializar y restablecer una matriz de datos BOOL.

Normalmente, use una matriz BOOL para los objetos a nivel de bit de una

pantalla PanelView.

De lo contrario, use los bits individuales de un tag DINT o una matriz de

DINT.

Aproveche los tags del controlador cubiertos.

Si desea múltiples tags con el mismo nombre, defina cada tag en el alcance del programa (tags de programa) para un diferente programa. Esto le permite usar tanto nombres lógicos como de tag en múltiples programas.

Evite usar el mismo nombre para un tag de controlador y un tag de programa. Dentro de un programa, no es posible hacer referencia a un tag de controlador si un tag con el mismo nombre existe como tag de programa para dicho programa.

Algunos tags deben ser tags del controlador cubiertos (tag de controlador).

Si desea usar el tag: Entonces asigne este alcance:

en más de un programa en el proyecto

controller scope (controller tags)

en una instrucción Message (MSG)

para producir o consumir datos entre controladores

para comunicarse con un terminal PanelView


ninguno de los citados program scope (program tags)

Para enteros, use el tipo de datos DINT

Para aumentar la eficiencia de su lógica, minimice el uso de los tipos de datos SINT o INT. Siempre que sea posible, use el tipo de datos DINT para los datos enteros.

Un controlador Logix5000 generalmente compara o manipula los valores

como valores de 32 bits (DINT o REAL).

El controlador generalmente convierte un valor SINT o INT a un valor

DINT o REAL antes de usar el valor.

Si el destino es un tag SINT o INT, el controlador normalmente convierte

el valor nuevamente a un valor SINT o INT.

La conversión a o desde SINT o INT ocurre automáticamente sin

necesidad de programación adicional. Pero requiere tiempo de ejecución y

memoria adicional.

Limite los nombres de los tags a 40 caracteres

Las siguientes son las reglas para los nombres de tags.

usar sólo caracteres alfabéticos (A–Z o a–z), caracteres numéricos (0–9) y

subrayado (_)

debe comenzar con un carácter alfabético o de subrayado

no más de 40 caracteres

no usar caracteres de subrayado consecutivamente ni como carácter final

(_)

se tratan indistintamente las mayúsculas y minúsculas

Use una combinación de caracteres mayúsculas y minúsculas

Si bien se tratan indistintamente las mayúsculas y minúsculas en los tags (A en mayúscula es igual que a en minúscula), es más fácil leer una combinación de letras mayúsculas y minúsculas.

Estos tags son más fáciles de leer: Que estos tags:

Tank_1 TANK_1

Tank1 TANK1

Tank_1

Tank1

Considere el orden alfabético de los tags.

El software RSLogix 5000 muestra tags del mismo alcance en orden alfabético. Para facilitar el monitoreo de tags relacionados, use caracteres de inicio similares para los tags que desea mantener juntos.

Si comienza el nombre de cada tag para tanque con Tank, estos tags se mantienen juntos

De lo contrario, los tags pueden terminar separados.

Nombre de tag Nombre de tag

Tank_North North_Tank

Tank_South …otros tags que comienzan con las letras o, p, q, etc.

… …

…

South_Tank


3. Haga clic con el botón izquierdo del mouse en el signo + junto a N7 en el editor de tags. Esto expandirá la matriz N7 para mostrar todos los elementos. Usted observa que los datos están definidos de N7[0] hasta N7[7]. Luego nuevamente de N7[20] hasta N7[27] y N7[40] hasta N7[47]. Estas áreas son por cada uno de los 3 transportadores, una configuración de tabla de datos PLC tradicional.

4. También examine B3, F8 y T4. Éstos siguen el mismo formato. El transportador 1 comienza en [0], el transportador 2 comienza en [20] y el transportador 3 comienza en [40]. Esto se hizo para facilitar la búsqueda de los datos de un transportador en la base de datos de tags. Esto ayuda, pero usted está usando 4 tablas de datos para los transportadores y desperdiciando memoria. Esto se lograría mejor creando un UDT.

5. Para comenzar a crear un UDT, en el Controller Organizer, bajo la carpeta Data Types, haga clic en el signo + junto a User-Defined.


6. Notará que hay un UDT llamado Conveyor (ya se inició la creación del UDT).

7. Haga doble clic en la palabra Conveyor. Esto abrirá el editor de UDT para el tipo de datos del transportador. Como ve, el UDT es una combinación de diferentes tipos de datos. Esto es una herramienta muy útil durante la programación.

Para su información: Pautas para los tipos de datos definidos por el usuario

Al crear tipos de datos definidos por el usuario, tenga en cuenta lo siguiente:

Si incluye datos que representan dispositivos de E/S, debe usar lógica para copiar los datos al UDT. No puede asignar alias de E/S en un UDT.

Si incluye una matriz en el UDT, limite la matriz a una sola dimensión. No se permite usar matrices de múltiples dimensiones en los UDT.

Cuando cree el UDT, agrupe los datos similares. Esto crea un UDT más compacto.


8. Al examinar el UDT, usted observa que los tipos de datos similares no están agrupados. Los tipos de datos BOOL y REAL están combinados. El tamaño del UDT actualmente es 52 bytes. Esto puede reducirse agrupando los datos BOOL juntos. Para hacerlo, haga clic a la izquierda de Motor_Overload. Con esto seleccionará la fila completa.

9. Luego, haga clic en el botón Move Up. Esto mueve el tag Motor_Overload hacia arriba en el UDT. Repita esto con los otros tags BOOL hasta que todos estén el mismo grupo.


10. Haga clic en Apply. Observe ahora el tamaño del UDT. Usted ha ahorrado 12 bytes. Cuando haya terminado de mover los tags BOOL, el UDT se verá como se indica a continuación:

11. Ahora añada los 8 enteros N7 en el UDT, tendrá que añadirlos manualmente. Recuerde la pauta 4 anterior (página 59). Cuando haya terminado, el UDT se verá similar a la figura siguiente. Recuerde hacer clic en Apply cuando haya terminado las adiciones. Ahora ha completado el UDT que define un transportador en el programa.

12. Haga clic en OK para cerrar la ventana de edición de UDT.


13. En el menú File, seleccione Close. El sistema le pedirá que guarde los cambios hechos en el archivo, seleccione No.

Uso del UDT de transportador

Ahora usted usará el UDT de transportador que acaba de crear. Usted observa que el UDT ayudará a optimizar la base de datos y facilitará la resolución de problemas y el desarrollo del código.


Aparece la ventana Open/Import.

2. Haga clic con el botón izquierdo del mouse en el programa llamado Conveyor_Program_S4.ACD. El nombre del programa se resaltará y aparecerá en el campo File Name: Con esto se ha seleccionado el programa Conveyor_Program_S1.ACD.



4. En el Controller Organizer, haga doble clic en Controller Tags. Esto abrirá el Tag Editor.

5. Al examinar el Tag Editor, usted verá un nuevo tag en la base de datos, Conveyor_1.

6. Haga clic en el signo + junto a Conveyor_1 para expandir el tag. Usted observa que el tag tiene el mismo formato que el UDT que acaba de crear. Esto se confirma examinando la columna Type.


7. En el Controller Organizer, expanda los 3 programas Conveyor en la tarea continua, haciendo clic en el signo + para cada programa.

8. Haga doble clic en la rutina C2_Start_Stop. Esto abrirá la rutina para visualización y edición.


9. Ahora aparece la rutina de lógica de escalera C2_Start_Stop. Usted observa que en este caso, el direccionamiento para Conveyor_2 todavía es el mismo del PLC tradicional. Por ejemplo, en el renglón 0, el temporizador está direccionado como T4:20.

10. Haga doble clic en la rutina C1_Start_Stop. Esto abrirá la rutina para visualización y edición.


11. Ahora aparece el archivo de lógica de escalera C1_Start_Stop. Usted observa que el direccionamiento para Conveyor 1 utiliza el UDT. Como ve, el código ahora está autodocumentado y el nombre del tag describe lo que es. No es necesario añadir una descripción a la dirección, como se hace en los PLC tradicionales. Todavía hay algunas direcciones de estilo antiguo en el código; nos encargaremos de ellas posteriormente.

12. Ahora, actualicemos los otros dos programas de transportador para usar UDT.

13. Primero, necesitamos crear dos nuevos tags. En el menú Window, seleccione Controller Tags – Conveyor_Program(controller). Esto traerá la ventana Tag Editor al primer plano.


14. Se activará la ventana Tag Editor. En el lado inferior izquierdo de la ventana Tag Editor hay w fichas. Haga clic en la ficha Edit Tags. Aquí crearemos dos nuevos tags, Conveyor_2 and Conveyor_3.

15. En el Tag Editor, en la parte inferior de la lista, notará que hay un espacio abierto para crear un nuevo tag.

16. En la columna Tag Name: escriba „Conveyor_2‟ y en la columna Type, escriba „Conveyor‟. Con esto se crea un tag llamado Conveyor_2 del tipo transportador.

17. Luego haga clic en la nueva fila vacía debajo de Conveyor_2 para introducir y crear el tag.

18. Ahora cree un tag para Conveyor_3.

19. Cuando haya terminado, la base de datos de tags aparecerá de la siguiente manera:


20. Ahora, necesitamos actualizar el código de lógica de escalera para usar estos nuevos tags. Comenzaremos con Conveyor_2. Sólo modificaremos las rutinas Alarm_Status y Energy_Manag. Use las tablas siguientes y refiérase a las rutinas Conveyor_1.


21. Comencemos con un ejemplo. En el Controller Organizer, haga doble clic en la rutina C2_Alarm_Status. IMPORTANTE, por ahora ignoraremos las direcciones B3 que tienen la palabra “mapped” en la descripción.

22. En el renglón cero está la instrucción OTE. La descripción es C2 Motor Overload. Si examina las figuras anteriores, verá que éste coincide con el segundo miembro en el UDT.

23. Para cambiar la dirección, haga doble clic en B3[28]. Con esto se abrirá un cuadro desplegable para que pueda seleccionar un nuevo tag.


24. Haga clic en la flecha hacia abajo para abrir el explorador de tags. Desplácese por la lista hasta que vea Conveyor_2. Haga clic en el signo + para expandir el tag. Luego seleccione Conveyor_2.Motor_Overload.

25. Haga doble clic en Conveyor_2.Motor_Overload. Esto hace que Conveyor_2.Motor_Overload sea el nuevo tag para la instrucción OTE. Luego haga clic en cualquier lugar. El renglón ahora se verá de la siguiente manera. Nuevamente, observe el código de autodocumentación.

26. Ahora, continúe y termine de actualizar esta rutina. Luego actualice la rutina Energy_Manag para el transportador 2. A continuación repita los mismos pasos para el transportador 3.

27. Usted observa en la figura del paso 25 que el tag Conveyor_2.Motor_Overload tiene una descripción. Con V12 y versiones anteriores, las descripciones introducidas en el editor UDT no se mostraban fuera del editor UDT.


Para su información: Opciones Pass Through y Append Description de UDT

A partir de la versión 13 de RSLogix 5000, hay 2 nuevas selecciones bajo Workstation Options.

Si habilita Pass-Through Descriptions, entonces, cada vez que no proporcione una descripción explícita para un tag:

La descripción del tag de base se mostrará si el tag es un alias, o

La descripción de miembro del tipo de dato definido se mostrará si el tag es un miembro, o

La descripción del tag de base se mostrará si el tag es un bit, elemento de matriz o miembro, o

La descripción del tipo de dato de base definido se mostrará.

Si selecciona esta casilla de verificación,se habilitará la casilla de verificación Append to Base Tag Descriptions.

Seleccione la casilla de verificación Append to Base Tag Descriptions si desea que la de descripción del tag de base sea parte de la descripción de paso. Añada cualquier descripción adicional según las reglas de descripción de paso.

Anteriormente a esta función, usted tenía que cortar manualmente las descripciones del editor UDT y pegarlas manualmente en los tags en el Tag Editor. Esto añadía muchas horas de programación.

28. Veamos cómo funciona esta nueva función. En el Controller Organizer, bajo la carpeta Data Types, haga clic en el signo + junto a User-Defined.


29. Observará que hay un UDT llamado Conveyor.

30. Haga doble clic en la palabra Conveyor. Esto abrirá el editor de UDT para el tipo de datos del transportador.

31. Añada las descripciones para los miembros de UDT. Cuando haya terminado, haga clic en Apply.


32. También cambiaremos la descripción de UDT. Cambie la descripción para que coincida con la figura siguiente.

33. Haga clic en Apply y luego en OK para cerrar el editor UDT.

34. En el Controller Organizer, haga doble clic en la rutina C2_Alarm_Status. Notará que las descripciones introducidas ahora están presentes en los tags. La descripción es la descripción de UDT (Conveyor Data) + la descripción de miembro de UDT (Motor Overload Indication).

35. En el menú Tools, seleccione Options.


36. Aparecerá la ventana Options.

37. Bajo Applications, haga clic en Display.

38. La ventana aparecerá de la siguiente manera.

39. Coloque la ventana WorkStation Options de manera que pueda verla y las instrucciones OTE en la rutina C2_Alarm_Status.

40. Haga clic en la casilla de verificación junto a Append To Base Tag Descriptions para desactivar esta opción. Haga clic en Apply.


41. Observará que la descripción ha cambiado. Se eliminó la descripción UDT Conveyor Data.

42. Haga clic en la casilla de verificación junto a Show Pass-Through Descriptions para desactivar esta opción. Haga clic en Apply.

43. Observará que la descripción cambió otra vez. No hay nada allí. Es así como habrían aparecido los renglones en la versión V12 y anteriores de RSLogix 5000.

44. Active nuevamente ambas opciones. Luego haga clic en Apply y luego en Ok.

45. Cuando haya terminado, haga clic en el icono Save.



Uso de la función Data Scoping

En esta sesión práctica usted aprenderá las ventajas de la función Data Scoping.

Usted acaba de usar la función User-Defined Data Types para organizar mejor su base de datos de tags y crear el código de autodocumentación. Por último, lo siguiente que debe hacer es cubrir de manera más eficiente los tags a nivel de programa. Ésta es la función Data Scoping. La función Data Scoping le permite:

Usar los mismos nombres de tag entre programas porque los tags de programa cubiertos están aislados unos de otros.

Desarrollar código estándar que puede copiarse múltiples veces sin preocuparse por colisiones de nombres de tags

Eliminar la administración de nombres de tags y ubicaciones de datos.

Rápido desarrollo de proyectos.

Para su información: Uso de la función Data Scoping

Cuando usted crea un tag, define si es un tag del controlador (dato global) o un tag de programa para un programa específico (dato local).


Un controlador Logix le permite dividir su aplicación en múltiples programas. No hay necesidad de administrar nombres de tags que crean conflicto entre programas. Esto facilita la reutilización de códigos y nombres de tag en diferentes programas. Los datos al alcance del programa están aislados de otros programas. Las rutinas no pueden acceder a los datos que estén al alcance de otro programa. Usted puede reutilizar en múltiples programas el nombre de un tag al alcance de un programa.


Uso de la función Data Scoping en el programa

1. En el Controller Organizer, haga doble clic en Controller Tags para abrir el editor de tags. Asegúrese de estar en la ficha Edit Tags; de lo contrario, no podrá realizar las operaciones de cortar/pegar.

2. Cuando se abre el Tag Editor notará que no están muchos de los tags antiguos (N7, F8, T4). Estos tags ya no se necesitan después de crear el UDT de transportador y modificar el código. Los tags Conveyor_1, Conveyor_2 y Conveyor_3 tomaron sus lugares. Los archivos F9 y PD fueron cambiados a nombres de tag en lugar de numeración de tabla de datos como en un PLC tradicional. El archivo T10 se eliminó después de mover el PID a la tarea periódica.

Ahora moveremos los tags Conveyor_1, Conveyor_2 y Conveyor_3 fuera del alcance del controlador al alcance del programa.

3. Haga doble clic en la columna Type. Con esto se clasificarán mejor los tags para la operación de edición que realizaremos.


4. Primero moveremos los tags Temp_Loop_PID, Control_Output y Process_Variable al alcance del programa Temperature_Loop.

5. Haga clic a la izquierda del tag Temp_Loop_PID. Con esto seleccionará la fila completa.

6. Luego presione sin soltar la tecla de mayúsculas y haga clic a la izquierda del tag Process_Variable. Con esto se seleccionarán los 3 tags.

7. En el menú Edit, seleccione Cut.

8. En el Tag Editor se encuentra el selector desplegable Scope. Haga clic en la flecha hacia abajo. Así mostrará todas las bases de datos de tags del programa y el controlador actual.

9. Seleccione PID_Loop.



En el menú desplegable, el „(controlador)‟ junto al nombre designa los tags al alcance del controlador. El controlador se llama Conveyor_Program. Por lo tanto Conveyor_Program (controlador) significa tags al alcance del controlador. Todos los otros nombres en la lista son nombres de programas en el controlador.

10. Con esto se abrirá el editor de tags al alcance del programa para el PID_Loop del programa.

11. Actualmente no hay tags definidos a nivel de alcance del programa para PID_Loop. Ahora pegaremos los tags que cortamos en el paso 7.

12. Haga clic en el archivo Tag Name abierto para que aparezca el cursor.

13. En el menú Edit, seleccione Paste.

14. Se pegan los 3 tags.


15. Cambie nuevamente a los tags al alcance del controlador. La pantalla tendrá el aspecto siguiente:

16. Ahora, corte/pegue el tag Conveyor_1 al alcance del programa de Conveyor_1.



19. Cuando haya terminado, el único tag que está al alcance del controlador debe ser B3. Éste se eliminará posteriormente.

20. Cuando haya terminado de mover los tags, haga clic en el icono Verify Controller . Tendrá 4 errores, pero eso está bien. Los errores tratan con el programa Simulator.

Anteriormente indicamos que los datos al alcance del programa están aislados de otros programas. Las rutinas no pueden acceder a los datos que estén al alcance de otro programa. Sin embargo, usted puede reutilizar en múltiples programas el nombre de un tag al alcance de un programa. Para probar esto vayamos a los tags alcance del programa para los 3 transportadores y cambiemos los nombres de tags Conveyor_1, Conveyor_2 y Conveyor_3 a Conveyor.

21. Seleccione los tags al alcance del programa Conveyor_1.


22. Cambie el nombre del tag „Conveyor_1‟ a „Conveyor‟.

23. Modifique los otros 2 tags, Conveyor_2 and Conveyor_3.

24. Cuando haya terminado de cambiar los nombres de los tags, haga clic en el icono Verify

Controller . Tendrá 4 errores, pero eso está bien. Los errores tratan con el programa Simulator. Usted no obtuvo ningún error asociado con tags duplicados. Eso se debe a que los tags al alcance del programa están aislados uno de otro.


La función Data Scoping para los tags facilita la reutilización de códigos y nombres de tag en diferentes programas.

En este caso usted puede crear un programa llamado Conveyor que usa tags al alcance del programa. Luego puede añadir este programa en el proyecto tantas veces como el número de segmentos de transportador que tenga, y nunca tendrá que modificar el código ni los tags.


26. Cuando el sistema le pide que guarde los cambios, seleccione No.


En esta sesión práctica usted aprendió cómo configurar la memoria usando las funciones User Defined Data Types y Data Scoping.

Aprendió las ventajas de usar UDT

Aprendió como optimizar la configuración de UDT

Aprendió como las opciones Show Pass-Through Descriptions y Append To Base Tag Description pueden ahorrar tiempo de ingeniería y documentación de código.

Aprendió las ventajas de la función Data Scoping


Sesión práctica 4: Tema cubierto (10 minutos)



En esta sección de temas cubiertos usted explorará el concepto siguiente:

Tipo de datos INT comparado con tipo de datos DINT en la ejecución del programa







2. Haga clic con el botón izquierdo del mouse en el programa llamado Z_A2_Int_Dint_CLX.ACD. El nombre del programa se resaltará y aparecerá en el campo File Name: Con esto ha seleccionado Z_A2_Int_Dint_CLX.ACD.



Ahora descargaremos el programa Z_A2_Int_Dint_CLX.ACD.





Actividad 1 (en línea): Tipos de datos INT comparados con tipos de datos DINT

Para su información: Tipos de datos INT comparados con tipos de datos DINT

Todos los controladores Logix utilizan un procesador RISC de 32 bits optimizado por operaciones de 32 bits. Debido a esto, los tipos de datos que no son de 32 bits requieren tiempo de procesamiento interno adicional para la ejecución y memoria. Ningún tipo de datos de 32 bits es del tipo BOOL, SINT o INT. Por lo tanto, siempre que sea posible, use DINT cuando realice la programación.


1. En el Controller Organizer, expanda el MainProgram.

2. Haga doble clic en la MainRoutine. Esto abrirá la rutina para visualización.

3. Ahora aparece la rutina de lógica de escalera MainRoutine. Esta rutina determina cómo se ejecutará el programa. Es posible llamar a 2 rutinas: Math_DINT y Math_INT. Las rutinas son idénticas, excepto que una se efectúa con tipos de datos DINT y la otra con tipos de datos INT. Actualmente se está ejecutando el archivo Math_INT.

4. Haga clic con el botón derecho del mouse en la carpeta MainTask y seleccione Properties.




7. Actualmente, el controlador está ejecutando la rutina Math_INT. El tiempo de escán es aproximadamente 14.5 ms. Recuerde que para esta rutina se usan los tipos de datos INT.

8. No cierre la ventana Task Properties. Traiga la ventana MainRoutine al primer plano.


9. Haga clic con el botón derecho del mouse en el tag Run_DINT en el renglón cero y seleccione Toggle Bit. Esto causará que el programa ejecute la rutina Math_DINT y deje de ejecutar Math_INT.

10. En el menú Window, seleccione Task Properties – MainTask. Esto traerá la ventana Task Properties al primer plano.

11. Se activará la ventana Task Properties. Haga clic en el botón Reset.

12. El tiempo de escán ahora es aproximadamente 5 ms. Esto es aproximadamente 3 veces más rápido.






En esta sesión práctica mostramos el efecto que tienen los datos que no son de 32 bits en el rendimiento del programa, comparado con el tipo de datos DINT. Es importante observar que usted verá esto con todos los tipos de datos que no son de 32 bits, no sólo INT, los cuales se usaron en el programa.

¿Por qué? Para ejecutar operaciones, el conveniente que el controlador use tipos de datos de 32 bits. Por lo tanto, el controlador convertirá los tipos de datos que no son de 32 bits a 32 bits cuando se ejecute la instrucción. Esta conversión requiere tiempo. Por ejemplo, una instrucción Add con los dos orígenes y el destino iguales que INT requiere 3 conversiones. Es importante también notar que se utilizó memoria adicional. Cuando se compila el programa se asigna memoria adicional. El controlador necesita un registro interno para almacenar el tipo convertido. En el ejemplo de programa usado, esto no se observó porque sólo teníamos una instrucción Add, por lo tanto sólo tuvieron que crearse 3 registros internos, pero esto se sumará en programas que usan tipos de datos que no son de 32 bits.


LOT-SP004A-ES-E Página 89 de 162

Sesión práctica 5: Reutilización de código (15 minutos)


Esta sesión práctica se basa en la idea presentada en la sesión práctica anterior. Es decir, cuando usted crea un programa que usa tags al alcance del programa, se facilita la reutilización de código y los nombres de los tags, lo cual facilita a su vez el desarrollo.

En esta sesión práctica, usted:

Abrirá un archivo existente

Reutilizará un programa múltiples veces en el proyecto mediante las funciones copiar y pegar

Reutilizará el código de lógica de escalera en el proyecto hasta la herramienta Ladder Partial Import/Export








Reutilización de código usando las funciones de copiar y pegar

Usted observa que en todo diseño de sistema siempre hay un lazo de temperatura y 2 o más segmentos de transportador. Decide crear una plantilla básica de un proyecto para uso como punto de inicio. Éste contiene un lazo de temperatura y un segmento de transportador.

Usted usará esta plantilla de proyecto para crear el código para un sistema de 10 segmentos de transportador.

1. En el Controller Organizer usted ve el programa base. El programa de un transportador y la tarea Temperature_Loop. Necesitará añadir 9 segmentos de transportador para tener el total de 10 especificados para el proyecto.



2. En el Controller Organizer, haga clic con el botón derecho del mouse en el programa Conveyor y seleccione Copy.

3. En el Controller Organizer, haga clic con el botón derecho del mouse la MainTask y seleccione Paste.

4. Con esto añadió una copia del código del segmento de transportador original e incrementó el nombre del programa.

5. Repita el paso 3 ocho veces más para añadir los ocho segmentos de transportador restantes.



6. Cuando haya terminado, el Controller Organizer debe aparecer de la siguiente manera.



Reutilización de código usando la herramienta Ladder Partial Import/Export

Algunas veces en un sistema, un segmento de transportador necesitará tener una estación de código de barras. Ésta es usada en el sistema por el primer y/o último segmento de transportador. Usted puede añadirla en el código de la plantilla, pero luego tendría que eliminar este código de las secciones medias, en este caso 9 segmentos de transportador. En el sistema que está programando, sólo necesitará añadirla al primer segmento de transportador.

Anteriormente, usted usaba el método de remover archivo cortando renglones de lógica de escalera y guardándolos como archivos removidos en el escritorio. Pero al pegar los archivos removidos de vuelta, tenía que dedicar tiempo a crear todos los tags. Usted desea algo más fácil y más rápido.

Para su información: Herramienta Ladder Partial Import/Export

Ésta es una nueva función con la versión 13 de RSLogix 5000.

La función básica que la herramienta Ladder Partial Import/Export proporciona es la capacidad de extraer renglones de código específicos de un proyecto y almacenarlos en un archivo externo (L5X). Posteriormente, puede importar el código nuevamente en cualquier proyecto RSLogix 5000. La diferencia significativa es que la función Partial Import/Export no está limitada sólo a los renglones de lógica de escalera, como los archivos de remoción. El archivo de exportación contiene todas las definiciones de tags, UDT y comentarios asociados. Debido a esto, cuando se importa el archivo, todo se crea y el resultado es un código que se verifica sin ningún error. Para optimizar esta función más aún, RSLogix 5000 proporciona un diálogo que lista todos los tags, UDT y descripciones asociadas, de manera que usted los puede modificar antes de realizar la importación. Esto ayuda a evitar colisiones potenciales de nombres de tag.




En esta sección de la sesión práctica usted abrirá un programa existente. Este archivo contiene el código que usted desea añadir al código del primer segmento de transportador.





2. Haga clic con el botón izquierdo del mouse en el programa llamado Look_up_a_bar_code.ACD. El nombre del programa se resaltará y aparecerá en el campo File Name: Con esto ha seleccionado Look_up_a_bar_code.ACD.


Uso de la herramienta Ladder Partial Import/Export para hacer una exportación a un archivo L5X

1. En el Controller Organizer, haga doble clic en la carpeta MainProgram para expandirla. Es aquí donde está ubicada la estación de código de barras.

2. Una vez que se expanda el MainProgram, se verá similar al siguiente.

3. Haga doble clic en la MainRoutine para abrir el editor de lógica de escalera.



4. En el menú Edit, seleccione Select All. Con esto seleccionará todos los renglones en la rutina.



5. Haga clic con el botón derecho del mouse a la izquierda del renglón cero y seleccione Export Rung.

6. Aparecerá la ventana Export Rung.



7. En el campo File Name: introduzca „Look_up_bar_code‟. Luego haga clic en Export.

8. Se creó el archivo de lógica de escalera exportado (L5X).










Uso de la herramienta Ladder Partial Import/Export para hacer una importación a un archivo L5X

1. En el Controller Organizer, haga doble clic en la carpeta del programa Conveyor para expandirla. Es aquí donde añadiremos el código de estación de código de barras.

2. Una vez que se expanda Conveyor, se verá similar al siguiente.



3. Haga clic con el botón derecho del mouse en el programa Conveyor y seleccione New Routine.

4. Aparecerá la ventana New Routine.



5. Introduzca el nombre „C_Bar_Code‟ para la rutina. Cuando haya terminado, haga clic en OK.

6. El programa Conveyor ahora se verá similar al siguiente.

7. Haga doble clic en la rutina C_Bar_Code. Esto abrirá el Ladder Editor.



8. En el Ladder Editor, haga clic con el botón derecho del mouse sobre el renglón 0 y seleccione Import Rung.

9. Aparecerá la ventana Import Rung. Haga clic con el botón izquierdo del mouse en el archivo Look_up_bar_code.L5X. Luego haga clic en Import.



10. Aparecerá la ventana Import Configuration.

Para su información: La opción Import Configuration

La función Import Configuration tiene 2 fichas:

Tags:

Estos son los tags asociados con la lógica de escalera que se está importando. Usted puede cambiar cualquier nombre de tag antes de realizar la importación. Usted también será alertado si un nombre de tag ya existe en el proyecto.

Esto le permitirá cambiar el nombre del tag si usted sabe que puede causar un problema.

Data Types:

Esto mostrará cualquier UDT que viene con la importación. Mostrará si el UDT no existe y será creado, o si existe y se usará el UDT existente. Esta ficha es informativa solamente.



11. Cambie el nombre de tag lane a „line_number‟. Luego haga clic en el campo de tag siguiente a continuación para aceptar el cambio.

Usted acaba de modificar un nombre de tag mientras está importando la lógica de escalera.

12. Haga clic en OK.

13. Comienza la importación. Cuando haya concluida, usted habrá completado el código de lógica de escalera. Lodos los tags se crean dentro del agrupamiento correcto, en este caso Conveyor. Verá lo siguiente en el Ladder Editor:

14. Desplácese a la parte superior de la rutina C_Bar_Code y elimine el renglón cero vacío.



15. Ahora tendrá que añadir un renglón en la rutina principal Conveyor para pasarlo a través de JSR a la rutina C_Bar_Code.




Usted se da cuenta que le tomo menos de 15 minutos crear su program básico. Esto antes requería varias horas. Usted hubiera tenido que copiar código, cambiar direcciones, documentar las direcciones y verificar que todo esté correcto.



Sesión práctica 6: Tema cubierto (10 minutos)



En esta sección usted explorará los siguientes conceptos de diferentes métodos de programación y sus efectos en la ejecución.

Duplicación en línea

Subrutina indexada

Subrutina almacenada en un búfer

Los tres métodos tienen ventajas y desventajas.








2. Haga clic con el botón izquierdo del mouse en el programa llamado Z_A3_PM_CLX.ACD. El nombre del programa se resaltará y aparecerá en el campo File Name: Con esto ha seleccionado Z_A3_PM_CLX.ACD.



Ahora descargaremos el programa Z_A3_PM_XXX.ACD.






Actividad 1: Duplicación en línea / Subrutina indexada / Subrutina almacenada en un búfer

En esta sección de la sesión práctica examinaremos las ventajas y desventajas de cada uno de las tres metodologías de programación.

La base de esta sesión práctica son tres renglones de código. Luego estos 3 renglones de código se ejecutarán 500 veces.

Los tres métodos:

Duplicación en línea (código basado en hardware). La rutina In_Line tiene 15 renglones o 5 conjuntos de código. Esto luego se enlaza 100 veces.

Indexado (direccionamiento indirecto). La rutina indexada tiene los 3 renglones básicos. Todos los renglones están indexados. El índice se pasa a través de la JSR. Esto luego se enlaza 100 veces.

Indexado almacenado en el búfer (copiar datos). La rutina tiene los 3 renglones básicos. Todos los datos pasan a través de JSR y son manipulados en el búfer activo y luego transferidos. Esto luego se enlaza 100 veces.



1. En el Controller Organizer, haga doble clic en la carpeta MainProgram.

2. Cuando esté expandida, verá 4 rutinas:

La MainRoutine se usa para determinar cuáles de las otras tres rutinas se llamarán.

La rutina In_Line es lógica de escalera codificada mediante hardware

La rutina indexada es indexada o direccionada indirectamente

La rutina Buffered_Index utiliza una instrucción JSR para pasar datos hacia dentro o fuera de la rutina

Hay un lazo en el programa que hace que cada rutina se ejecute 100 veces. Si usted examina estas rutinas, asegúrese de que la MainRoutine aparezca en la ventana antes de continuar.

3. Haga doble clic en la MainRoutine.



4. Primero examinaremos la duplicación en línea. En el renglón 1 introduzca un valor de uno en Run_Type. Para esto haga clic con el botón izquierdo del mouse en el valor debajo del tag Run_Type e introduzca el valor, y luego haga clic fuera de la instrucción.

Con esto habilitará el código para duplicación en línea.

Para su información: Duplicación en línea

La manera más simple de describir este método es codificado mediante hardware. Todos el código es de referencia directa.

Ventajas:

La más rápida ejecución.

Fácil de mantener porque usted puede examinar cada ocurrencia y ver los valores de tag para dicha ocurrencia.

Desventajas:

Requiere que el código sea duplicado y modificado múltiples veces. La generación del código puede acelerarse a través de búsqueda y reemplazo y la edición del archivo exportado.

5. Haga clic con el botón derecho del mouse en MainTask y seleccione Properties.



6. Aparecerá Task Properties – MainTask.

7. Haga clic en la ficha Monitor. Se activará la ficha Monitor.




9. El tiempo de escán máximo visto es aproximadamente 6 ms. El último tiempo de escán visto es aproximadamente 1.8 ms. Esto no está mal para 500 secciones de código.

10. En el menú Window, seleccione MainProgram – MainRoutine.

11. Se activará el editor de lógica de escalera.

12. Ahora examinaremos el código indexado. En el renglón 1 introduzca un valor de dos en Run_Type. Para esto haga clic con el botón izquierdo del mouse en el valor debajo del tag Run_Type e introduzca el valor, y luego haga clic fuera de la instrucción.

Esto habilitará el código para el índice.

Para su información: Subrutinas indexadas

Este método utiliza una sola copia de código con referencias indexadas en una matriz.

Ventajas:

Una copia de código permite un desarrollo rápido.

Desventajas:

Puesto que todas las referencias de tag se calculan al momento de la ejecución, este método tendrá la ejecución más lenta.

El mantenimiento y la resolución de problemas es difícil porque el código no muestra ninguna ocurrencia. Esto puede solucionarse programando una rutina de depuración y manteniendo el índice constante.



13. En el menú Window, seleccione Task Properties – MainTask.


15. El tiempo de escán máximo visto es aproximadamente 20 ms. El último tiempo de escán visto es aproximadamente 19.5 ms. Esto es aproximadamente 4 veces más lento que el código de duplicación en línea.

16. En el menú Window, seleccione MainProgram – MainRoutine.

17. Se activará el editor de lógica de escalera.



18. Finalmente, examinaremos el código indexado. En el renglón 1 introduzca un valor de tres en Run_Type. Para esto haga clic con el botón izquierdo del mouse en el valor debajo del tag Run_Type e introduzca el valor, y luego haga clic fuera de la instrucción.

Esto habilitará el código para Buffer_Index.

Para su información: Subrutinas almacenadas en un búfer

Este método utiliza una sola copia de código con referencias directas a los datos almacenados en el búfer.

Ventajas:

Una copia de código permite un desarrollo rápido.

Elimina la necesidad de calcular offsets al momento de ejecución

Desventajas:

Debido a la copia de datos a los búferes, este método tendrá una ejecución lenta.

El mantenimiento y la resolución de problemas es difícil porque el código no muestra ninguna ocurrencia. Esto puede solucionarse programando una rutina de depuración y manteniendo el índice constante.

19. En el menú Window, seleccione Task Properties – MainTask.




21. El tiempo de escán máximo visto es aproximadamente 23 ms. El último tiempo de escán visto es aproximadamente 20.5 ms. Esto es aproximadamente igual al método de índice. Es aproximadamente 4 veces más lento que el código de duplicación en línea y aproximadamente igual que el código indexado.





En esta sesión práctica mostramos las ventajas y desventajas de las tres metodologías de programación que pueden utilizarse con Logix.

Duplicación de código en línea

Subrutina indexada


Cuando se comparan, generalmente la duplicación de código en línea es la mejor opción. Esto se debe a las herramientas fuera del línea que pueden usarse para acelerar el desarrollo y el tiempo de ejecución.

Cantidad de lógica / datos

Tiem

po

de escán

Lento

Rápido Pequeño Grande

Duplicación en línea


Subrutina indexada



Sesión práctica 7: Portabilidad de las plataformas Logix (10 minutos) / OPCIONAL


En esta sección de la sesión práctica, mostraremos lo fácil que es desplazarse entre plataformas Logix.


Usará el programa de la sección previa

Cambiará el tipo de controlador definido en el proyecto










Portabilidad de un proyecto entre plataformas Logix

Usted sabe por experiencia que no venderá todos sus sistemas de transportador basados en un controlador. Usted elegirá el controlador basado en el tamaño y requisitos del sistema de cada cliente. En el pasado, esto requería que usted tenga programas para cada controlador usado.

Esto era porque con un PLC tradicional, la transferencia entre plataformas no era fácil y no podía hacerse. Generalmente esto se debía a que las diferentes plataformas no estaban basadas en una arquitectura básica. Esto añadía tiempo de desarrollo y costo a sus proyectos. Esto requería múltiples paquetes de software de programación.

Con la plataforma Logix, esto no es un problema. Todos los controladores Logix, ControlLogix, FlexLogix, SoftLogix, CompactLogix y DriveLogix se basan en la misma máquina básica Logix. Esto significa que un programa desarrollado para CompactLogix puede transferirse fácilmente a ControlLogix con solo realizar unos cuantos pasos simples.



1. En la plantilla del controlador en RSLogix 5000, haga clic en el botón Controller

Properties .



2. Aparecerá la ventana Controller Properties.

Actualmente, el proyecto está configurado para usar un controlador 1769-L20 CompactLogix. Para el trabajo que está haciendo actualmente, el cliente especificó un controlador 1756-L62. Esto representa un cambio de plataforma. Anteriormente, esto significaba más tiempo de ingeniería, pero con Logix éste no es el caso.

3. Haga clic en el botón Change Controller…



4. Aparecerá la ventana Change Controller Type.



5. Haga clic en la flecha hacia abajo para expandir la selección de controlador Type.

6. Al desplazarse por la lista puede seleccionar todos los controladores Logix. Desplácese por la lista hasta que vea 1756-L55 ControlLogix5555 Controller.



7. Haga clic en 1756-L55 ControlLogix5555 Controller para seleccionarlo como el controlador al cual desea cambiar.

8. Haga clic en OK para cambiar de un controlador 1769-L20 a un controlador 1756-L55.



9. Cuando haga clic en OK, aparecerá la ventana Change Controller Type Warning.

Estas advertencias tienen sentido. Los módulos de E/S usados en un controlador CompactLogix son diferentes a los de un controlador ControlLogix. En el caso de los programas que convertiremos, no tendremos problemas. No hemos definido ninguna E/S.

10. Haga clic en Yes para cambiar el programa.



11. La ventana Controller Properties ahora muestra que el tipo de controlador es un 1756-L55 ControlLogix. También observará que el programa fue verificado y no tiene errores. Esto es todo lo que se necesita para cambiar un programa. Fue muy fácil.

12. Ahora intente cambiar de un controlador 1756-L55 a uno 1756-L62.



13. Cuando hace la conversión, la advertencia es más corta esta vez. Esto se debe a que las E/S para un controlador 1756-L62 y un 1765-L55 son iguales.

14. Seleccione Yes.

15. Cierre la ventana Controller Properties haciendo clic en OK.


17. Cuando el sistema le pide que guarde los cambios, seleccione No.


Con Logix, la portabilidad entre plataformas no es un problema. Todos los controladores Logix, ControlLogix, FlexLogix, SoftLogix, CompactLogix y DriveLogix se basan en la misma máquina básica Logix. Esto significa que un programa desarrollado para cualquier controlador Logix puede transferirse fácilmente a otro controlador Logix con solo realizar unos cuantos pasos simples.



Sesión práctica 8: Asignación de alias en la plataforma Logix (15 minutos)


En esta sección de la sesión práctica, mostraremos que la función de asignación de alias facilita y acelera el desarrollo del proyecto.


Abrirá un proyecto existente

Asignará tags de alias actualmente en el programa a puntos de E/S




Asignación de tags de alias

Al programar un PLC tradicional, una de las cosas más difíciles es tratar con las E/S. A medida que se va desarrollando el proyecto, es posible que usted no conozca todos los detalles acerca de las E/S en el sistema.

Se han hecho varias cosas para solucionar esto:

Crear rutinas de asignación. Es decir, asignar una entrada a un bit interno y asignar un bit interno a una salida.

Crear indicadores de posición. Cuando la configuración de E/S se ha completado, buscar y reemplazar los indicadores de posición.

Esperar hasta que la configuración de E/S para el sistema esté completa, luego iniciar la codificación.

Esto sólo añade tiempo y complicación al desarrollo del proyecto. Con Logix usted no tiene que hacer este trabajo de E/S. Esto se evita usando la función de asignación de alias.

Para su información: ¿Qué es la función de asignación de alias y cuándo se usa?

Un tag de alias le permite crear un tag que representa otro tag.

Ambos tags comparten el mismo valor.

Cuando el valor de uno de los tags cambia, el otro tag también cambia

Use alias en los siguientes casos:

Programar lógica antes de haber completado la configuración de E/S

Asignar un nombre descriptivo a un punto de E/S

Proporcionar un nombre más simple para un tag complejo

El uso más común de la asignación de alias es para programar lógica antes de completar la configuración de E/S.

Por cada dispositivo de E/S, cree un nombre descriptivo que describa el dispositivo, tal como Conveyor_Start_Push_Button.

Programe la lógica usando los nombres de tags descriptivos. Pruebe la lógica sin las E/S conectadas.

Posteriormente, cuando haya concluido la configuración de E/S, añada los módulos de E/S a la configuración de E/S del controlador.

Finalmente, convierta los tags descriptivos a alias para sus conexiones de E/S respectivas.



Para su información: Limitaciones de la asignación de alias

Hay 2 limitaciones que debe tener en cuando use asignación de alias:

No puede usar asignar alias de E/S en un UDT

No puede cambiar un alias en línea

Para esta sesión práctica, los puntos de E/S están definidos.

Para el 1756-IB16D en la ranura 2:

Punto 0 = Conveyor_Start_Push_Button

Punto 1 = Conveyor_Stop_Push_Button

Punto 2 = Entrance_PE

Punto 3 = Exit_PE

Punto 4 = Conveyor_EStop_Push_Button

Punto 5 = Motor_Overload_Input

Para el 1756-OB16D en la ranura 0:

Punto 0 = Conveyor_Start_Command



1. Si examina el Controller Organizer, verá los ítems siguientes:

Sólo hay un programa Conveyor en la tarea continua o en la tarea principal.

Se han añadido 2 módulos de E/S en la configuración de E/S.


Properties .



3. Aparece la ventana Controller Properties. Observe que el tipo de controlador es 1756-L63.

4. Cierre la ventana Controller Properties haciendo clic en Cancel.

5. Ahora, expanda el programa Conveyor haciendo clic en el signo + junto a la carpeta Conveyor.

6. Una vez que el programa Conveyor esté expandido, haga doble clic en Program Tags para abrir el Tag Editor.



7. Cuando aparezca el Tag Editor, observará que esté se ha abierto con Conveyor en el campo Scope. Si hubiera hecho clic en Controller Tags, en el campo Scope diría Controller.

8. También notará que hay varios tags nuevos. Éstos originalmente estaban en el tag B3, el cual existía en el alcance del controlador. Se han movido por razones de agrupación de datos y sus nombres se cambiaron para usar las convenciones de nombres de tags Logix.

9. Comencemos con el tag Conveyor_Start_Command. Puesto que es una salida, asignaremos el alias a una salida. Anteriormente dijimos que Punto 0 = Conveyor_Start_Command.

10. En el Tag Editor, haga clic en la columna Alias For junto a Conveyor_Start_Command. Nota: asegúrese de que la ficha Edit Tags esté seleccionada en la esquina inferior izquierda de la ventana de tags.



11. Haga clic en la flecha hacia abajo. Esto abrirá el explorador de tags.



12. El explorador actualmente está establecido para explorar los tags al alcance del programa. Necesitamos cambiar a alcance del controlador, donde están ubicados los módulos de E/S. Para ello, en el Tag Browser haga clic en Controller Scoped Tags. El explorador de tags cambiará a tags al alcance del controlador.

13. El módulo de salida está en la ranura 0 y deseamos punto de salida 0. Esto haría referencia a la dirección Local:0:O.Data.0.

14. Haga clic en el signo + para expandir Local:0:O.

15. Ahora, en la expansión, haga clic en Local:0:O.Data.



16. Haga clic en la flecha hacia abajo y seleccione el punto 0.

17. Cuando hizo clic en el punto 0 se cerró el explorador y usted regresó al editor de tags.

18. El Tag Editor ahora es similar al siguiente. La (C) junto a Local:0:O.Data.0 significa que el tag está al alcance del controlador.

19. La columna Alias For ahora contiene la dirección de Conveyor_Start_Command. Estos 2 tags ahora son iguales.

20. Ahora, en el Controller Organizer, haga doble clic en la rutina C_Start_Stop.



21. Cuando aparezca la ventana, fíjese en el renglón 1.

Observe que bajo el tag Conveyor_Start_Command está <Local:0:O.Data.0>. Esto significa que Conveyor_Start_Command es un Alias para Local:0:O.Data.0. Los dos tags son equivalentes. Esto se actualizará en todo el código.

22. Ahora, asignemos alias a Conveyor_Start_Push_Button en el renglón 0.

23. Esta vez, haga doble clic en el tag Conveyor_Start_Push_Button. Seleccione Edit “Conveyor_Start_Push_Button” Properties.



24. Aparecerá la ventana Tag Properties.

25. Actualmente en Tag Type dice Base. Vamos a cambiarlo a Alias. Haga clic en el botón Alias.



26. Aparecerá la selección Alias For.

27. Haga clic en la flecha hacia abajo para abrir el explorador de tags.

28. El explorador de tags actualmente está establecido para explorar los tags al alcance del programa. Seleccione Controller Scoped Tags.

29. Anteriormente indicamos que Punto 0 = Conveyor_Start_Push_Button. Esta tarjeta de entrada está en la ranura 2, por lo tanto vamos a asignar alias a Local:2:I.Data.0. Continúe y haga esa selección.



30. Cuando haya terminado, la pantalla Tag Properties aparecerá de la siguiente manera:

31. Haga clic en Apply y luego OK para cerrar la ventana Tag Properties.



32. Observe que bajo los tags Conveyor_Start_Push_Button está <Local:2:I.Data.0>. Esto significa que Conveyor_Start_Push_Button es un alias para Local:2:I.Data.0. Los dos tags son equivalentes. Esto se actualizará en todo el código.

33. Continúe y termine de asignar alias al resto de las entradas:

Punto 1 = Conveyor_Stop_Push_Button

Punto 2 = Entrance_PE

Punto 3 = Exit_PE

Punto 4 = Conveyor_EStop_Push_Button

Punto 5 = Motor_Overload_Input

34. Cuando haya terminado de asignar alias para las 5 entradas restantes, haga clic en el icono

Save .

35. Luego, en el menú File, seleccione Close.


Como puede ver, la asignación de alias incorpora un proyecto de manera sin ningún problema. Usted ya no necesita preocuparse acerca de cuándo se terminará la configuración de E/S para un sistema.



Sesión práctica 9: Cálculo de memoria del programa fuera de línea (10 minutos)


En esta sesión práctica, mostraremos el uso de la herramienta de cálculo de memoria del programa fuera del línea incorporada en RSLogix 5000.


Abrirá un archivo existente

Verá las características de la herramienta de cálculo de memoria del programa fuera del línea

Siga estos pasos para completar la sesión práctica 6.



Herramienta de cálculo de memoria fuera de línea

Hasta este punto, con los controladores Logix la única manera de saber cuánta memoria utilizaba un proyecto era hacer una descarga al controlador y verificar en línea, o usar una hoja de cálculo con información sobre la memoria. Esto proporcionaba un cálculo muy general. Con la versión 13 de RSLogix 5000 usted puede hacer esto fuera de línea y de una manera precisa.


Properties .

2. Aparecerá la ventana Controller Properties.



3. Haga clic en la ficha Memory. Se activará la ficha Memory.

Para su información: Opción de memoria

Memory Option está establecida en el tipo de controlador que usted seleccionó para el proyecto. En nuestro ejemplo se ha seleccionado un controlador 1756-L63. Si usted desea saber si el programa cabrá en un 1756-L55M13, todo lo que tiene que hacer es cambiar el tipo del controlador para el proyecto y luego regresar a la ficha Memory.



4. Haga clic en el botón Estimate. Observe que cambiaron los datos de uso de memoria.

Para su información: Información en la ficha Memory

Según el tipo de controlador que seleccione, la información mostrada cambiará.

Datos mostrados para controlador L1, L55 y L63:

Estimated I/O memory

Estimated Data and Logix Memory

Estimated Logix Memory (L55M16 solamente)

Para controlador L33, L34, L20, L30, L31 y L35E, datos mostrados:

Estimated Data and Logix Memory (estos controladores no tienen memoria de E/S)

Las barras verde, amarilla y roja son estáticas. Son como una luz de paro: verde significa continuar, la memoria de usuario es aceptable; amarillo significa tomar precauciones, continuar con cuidado ya que queda poca memoria; y rojo significa considerar cambiarse a otro controlador con más memoria.



Esta herramienta también puede usarse en línea para medir el uso de memoria durante la ejecución del controlador. Durante el tiempo de ejecución, el campo Max Used (marca de agua alta) normalmente será mas alto que en el campo Used. Esto se debe a que la memoria del controlador se asigna y desasigna durante el tiempo de ejecución en todas las áreas.

5. Según lo aprendido en la sesión práctica 4, cambie el tipo de controlador para este proyecto a 1756-L1.

6. Cuando haya terminado de cambiar el tipo de controlador, regrese a la ficha Memory.

7. Haga clic en el botón Estimate.

Observe que ha usado aproximadamente un tercio de la memoria:



8. Haga doble clic en Controller Tags. Esto abrirá el Tag Editor.

9. Cuando se abra Tag Edit, asegúrese de que está en la ficha Edit Tags.

10. Cree un tag llamado „Big_Array‟ al alcance del controlador con un tamaño de matriz de 60000.

11. En el menú Window, seleccione Controller Properties – Conveyor_Program.

12. Cuando la ventana Controller Properties regrese al primer plano, estará en la ficha Memory. Haga clic en el botón Estimate.

Usted ha calculado el uso de memoria negativo. Esto significa que usted excedió el límite de memoria del controlador.



13. Haga clic en la flecha hacia abajo del cuadro de selección junto a Memory Options.

Esto selecciona toda la selección de memoria válida para el controlador 1756-L1.

14. Seleccione el 1756-L1M1.

Ahora se muestra una nueva área de memoria. Esta es el área de memoria extendida.

15. Haga clic en el botón Estimate.

16. El uso de memoria para el controlador se vuelve a calcular.

El controlador 1756-L1M1 tiene suficiente memoria para el proyecto.

17. Cierre la ventana Controller Properties haciendo clic en OK.


19. Si el sistema le pide que guarde los cambios, seleccione No.




La herramienta de cálculo de memoria fuera de línea es una ayuda importante en el desarrollo del proyecto. Anteriormente a la versión 13 de RSLogix 5000 usted tenía que hacer una descarga a un controlador para determinar el uso de memoria. Ahora usted puede determinar el tamaño correcto de la memoria del controlador fácilmente durante el desarrollo, en lugar de en el campo. Esto es aún más importante si:

Se usa redundancia ControlLogix, ya que con redundancia se usa el doble de E/S y memoria de datos, por lo tanto usted consumirá la memoria más rápidamente.

Se actualiza de versiones previas de Logix a V13. Usted puede determinar si el tamaño de la aplicación crecerá y excederá la capacidad del controlador que tiene.



Sesión práctica 10: Programación en línea (15 minutos)



Verificará la operación del programa

Usará la función Finalize All Edit

Usará la función Browse Logic


Usted usará el programa con el que está en línea de la sesión práctica anterior.

Cómo probar el programa

Ahora probaremos el programa. Los valores han sido cargados en los tags apropiados y parecerá que el transportador está funcionando.

1. Mientras está en línea, expanda el programa Conveyor haciendo clic en el signo +.

2. Haga doble clic en Program Tags en el programa Conveyor para abrir la base de datos de tags.



3. Cuando la base de datos de tags se abra, asegúrese de que está en la ficha Monitor Tags. Haga clic en el signo + junto a Conveyor para expandir el UDT.

Observará que los datos se han introducido en el UDT del transportador. El objetivo es que usted pueda ver el funcionamiento del código.



4. En el Controller Organizer, haga doble clic en la rutina C_Start_Stop. Esto mostrará la lógica de escalera de esta rutina.

5. Ahora, en la unidad de demostración ubicada frente a usted hay un grupo de botones pulsadores discretos. En la sesión práctica anterior, cuando asignó alias de las E/S, usted estaba apuntando aquí.

Las definiciones de los botones pulsadores son:

Conveyor_Start_Push_Button = DI0

Conveyor_Stop_Push_Button = DI1

Entrance_PE = DI2

Exit_PE = DI3

Conveyor_EStop_Push_Button = DI4

La definición de la salida es:

Conveyor_Start_Command = DO0

6. Ahora presione y mantenga presionado el botón pulsador DI0. En el código de lógica de escalera en el renglón cero, usted verá subir al Conveyor_Start_Push_Button y verá que comienza a incrementar el Conveyor_Start_Push_Button_Timer. Después de 2 segundos se activará DO0.



7. En el menú Window, seleccione Tile Horizontal. Esto hará que aparezca una pantalla dividida entre Ladder Editor y Tag Monitor.

8. En la ventana Monitor, desplácese hacia abajo hasta que vea el tag Conveyor.Motor_Speed_Scaled. Éste sería el valor analógico que iría al variador del transportador. Actualmente está en un valor de 16384 ó 50% de salida.



9. Ahora presione el botón pulsador DI1. Éste es el Conveyor_Stop_Push_Button. Examine nuevamente el tag Conveyor.Motor_Speed_Scaled. No debería ser cero. Esto es debido a que el transportador está detenido.

10. En el Controller Organizer, haga doble clic en la rutina C_Energy_Manag. La ventana aparecerá ahora de la siguiente manera.

11. Haga arrancar el transportador nuevamente presionando DI0 sin soltar durante 10 segundos. Para habilitar la administración de energía, el transportador debe funcionar durante 10 segundos sin que se dispare la célula fotoeléctrica de salida o entrada. Después de 10 segundos, el valor en Conveyor.Motor_Speed_Scaled debe cambiar al 25% de salida o 8192.



12. Al examinar el código usted observa que el temporizador no se está ejecutando y que el valor en Conveyor.Motor_Speed_Scaled no ha cambiado. Al fijarse en el renglón, usted nota que la primera condición de entrada en el renglón está no activada e incorrecta. Debería ser Conveyor_Start_Command. Hagamos una edición en línea para solucionar este problema.

13. En la barra de herramientas, en la sección Ladder, haga clic en el icono . Al hacer esto, el renglón irá al modo de edición. Usted verá “I” junto al renglón.

14. Haga doble clic en el tag Conveyor_Start_Push_Button.

15. Haga clic en la flecha hacia abajo para abrir el Tag Browser. En el Tag Browser busque el tag Conveyor_Start_Command.

16. Haga doble clic en el tag y luego en el área blanca de la ventana. Con esto se cambió la dirección de la instrucción XIO.



17. Ahora debemos aceptar las ediciones que hicimos en línea.

Para su información: Botón Finalize All

En la versión 13 de RSLogix 5000 hay una nueva función de edición en línea llamada Finalize All Edits.

Para una sesión de edición en línea antes de la versión 13, usted tenía que realizar 8 pasos:

Iniciar edición

Editar código

Aceptar ediciones

Confirmar aceptación

Probar ediciones

Confirmar prueba

Ensamblar ediciones

Confirmar ensamble

Ahora, con el botón Finalize All Edits, usted sólo necesita 4 pasos:

Iniciar edición

Editar código

Finalizar todas las ediciones

Confirmar finalización

Esto ayuda a acelerar los cambios de programación en línea.

18. Haga clic en el icono Finalize All Edits .

19. Cuando el sistema le pida que finalice todas las ediciones, haga clic en Yes.

20. Ahora las “I” al lado del renglón desaparecieron y el temporizador comenzó a incrementarse. Una vez efectuado, observe el Conveyor.Motor_Speed_Scaled, ha llegado a 8192.

21. Ahora presione ya sea DI2 o DI3, las entradas de célula fotoeléctrica. Verá que el valor en Conveyor.Motor_Speed_Scaled regresa a 16384.



Para su información: Explorador lógico

Una función nueva de la versión 13 de RSLogix 5000 es Browse Logic.

La función Browse Logic está diseñada para proporcionar una visualización de la tabla de contenido de los componentes lógicos clave. Ayuda a proporcionar a los usuarios la capacidad de ubicar fácilmente una sección particular de código con ayuda de la documentación del programa. ¿Qué encuentra Browse Logic en cada lenguaje?

Lógica de escalera: Todos los renglones, comentarios de renglón, descripciones de tags (referencias destructivas solamente), instrucciones, descripciones de tags/operandos e información sobre tags mediante información sobre herramientas.

Diagramas de bloques de funciones: Todas las hojas, todos los tags de bloque, cuadros de texto conectados/no conectados e información sobre tags mediante información sobre herramientas.

Diagrama de funciones secuenciales: Todos los pasos, transiciones y tags de acciones, cuadros de texto conectados/no conectados e información sobre tags mediante información sobre herramientas.

Texto estructurado: Todas las líneas, tags (referencias destructivas solamente) e información sobre tags mediante información sobre herramientas.

Esta herramienta es para uso en línea y fuera de línea.

22. Para mostrar el uso de la herramienta Browse Logic usted la usará para encontrar el “Easter Egg” (“huevo de pascua”) en el programa. En el menú Search seleccione Browse Logic.



23. Aparecerá la ventana Browse Logic.

Ésta es muy similar a lo que aparece debajo de la sección Tasks del Controller Organizer.

24. Haga doble clic en la tarea periódica Simulation para expandirla. Continúe expandiendo la carpeta y las rutinas debajo de ésta. Cuando haya terminado, la ventana debe aparecer de la siguiente manera.

Como ve, le proporciona la tabla de contenido.



25. Ahora use la herramienta para encontrar el “Easter Egg”. Sugerencia: hay 2 maneras de hacerlo. Una es mucho más fácil que la otra. A continuación mostraremos ambas maneras, y comenzaremos por la más difícil.

26. Comencemos expandiendo la MainTask, como lo hicimos para la Simulation Task.

Aquí no está el Easter Egg.



27. Ahora expanda el TemperatureLoop.

Usted encontró el “Easter Egg”. Estaba en un comentario de renglón en la rutina Temperature_Loop. Si usted hace clic en Rung 0 y luego hace clic en el botón Go To, esto lo llevará a ese renglón, pero no haga esto todavía.

28. La manera más fácil de encontrar el Easter Egg es introducir „Easter Egg‟ en el campo Find: y

luego hacer clic en el icono de buscar (Find) .



29. Esto lo llevará allí. Mucho más rápido.

30. Ahora haga clic en el botón Go To. Luego haga clic en Close.

31. Esto lo llevará a ese renglón en el Ladder Editor.

Usted puede ver el gran potencial que tiene esta herramienta. Puede colocar palabras clave en diferentes lugares y usar la herramienta Browse Logix para navegar rápidamente a esas áreas.






En esta sesión práctica mostramos 2 nuevas funciones que le ayudarán con la programación en línea.

Finalize All Edits: Reduce el número de pasos necesarios para aceptar ediciones en línea.

Browse Logic: Le ayuda a navegar mejor a través de un proyecto.

Manual Rslogix5000

Documents

Transcript of Manual Rslogix5000