Notas de automatización

Probando un adaptador USB/MPI chino

2012-01-17T15:37:00.000+01:00

Recientemente, en el foro de Siemens en infoPLC, me enteré de la existencia de un adaptador USB/MPI muy económico que se vende a través de ebay, total que hemos comprado uno. El pedido tardó unas tres semanas en llegar (dentro del plazo que especifica el vendedor). En el paquete venía el adaptador y un mini CD con los controladores:

(pulsar encima para ampliar)

La primera impresión es bastante lamentable, leer For SEMIES S7-300 no hace presagiar nada bueno. El cable mide unos tres metros y el adaptador en sí apenas tiene peso. La carcasa tampoco parece muy sólida y lo primero que he hecho es abrirla para curiosear la electrónica:

Han raspado los chips para evitar su identificación (pulsar para ampliar)

Nada más leer el CD saltó el antivirus detectando una amenaza. Dentro viene documentación en perfecto chino y también el programa de instalación del controlador del PC Adapter USB original de Siemens (lo cual supongo que no es muy legal). Por tanto deduzco que el controlador necesario para este adaptador chino es el mismo que el de Siemens.

Conecto el adaptador a mi ordenador y lo asigno a la máquina virtual de Virtual Box donde tengo instalado la última versión de Step7 (5.5 SP1). Enseguida el asistente de instalación de nuevos dispositivos me dice que el adaptador USB está instalado y listo para para usarse. Con el Step7 instalado, el controlador del PC Adapter de Siemens ya está disponible, con lo que el CD de controladores, en mi caso, no fue necesario.

El siguiente paso es ajustar el interface PG/PC. Debemos seleccionar PC Adapter, en mi caso con la opción Auto.

Pulsamos el botón de Propiedades y en la pestaña Conexión local debemos seleccionar Conexión a USB.

Aceptamos y listo. Ya solo queda conectar el extremo MPI al PLC y empezar a probar. Yo he usado un PLC Siemens 315-2DP que ha aceptado la conexión sin problemas: he transferido la configuración hardware, el programa y usado las funciones de visualización on-line.

También he hecho la prueba de conectarle un panel táctil TP277-6" de Siemens. En modo MPI directo funciona correctamente, tardando en transferir un proyecto de WinCC Flexible lo normal para una velocidad de 187,5 kbit/s estándar para MPI (y la única velocidad permitida por este adaptador). Luego he conectado el panel en Profibus al PLC, para probar a hacer un routing MPI-Profibus, y también ha funcionado sin problemas.

En el lateral de la carcasa del adaptador hay dos leds marcados como Power (rojo) y Active (verde), pero realmente lo único que hacen es parpadear cuando hay una comunicación activa.

Como conclusión puedo decir que simplemente funciona, aunque no me da sensación de fiabilidad. No lleva ningún marcado CE ni nada parecido. Puede servir para salir de un apuro, pero no lo veo para el trabajo diario. También hay que tener en cuenta que no permite la comunicación directa a través de redes Profibus, cosa que sí es posible con el modelo original de Siemens. Aunque por el precio que tiene no se le puede pedir más.

Actualización: la página del fabricante original de este adaptador es ésta.

Cualquier comentario será bienvenido.

Modificando tiempos en un PLC S7 desde WinCC Flexible RT

2012-01-16T17:25:00.000+01:00

Recientemente me ha tocado actualizar el programa de una máquina que llevaba un panel táctil realizado en ProTool. En este proyecto hay una serie de tiempos configurables desde el panel y me llamó la atención que estaban enlazados a variables en formato WORD, haciendo la conversión a formato S5TIME en el PLC, con segmentos como el siguiente:

El valor se recibe en un WORD, se copia en un INT, que vuelve a ser un WORD después de la instrucción I_BCD, se le añade la base de tiempo con la instrucción WOR_W, para finalmente moverlo a la variable en formato S5TIME definitiva.

No es la primera vez que me encuentro con conversiones similares, pero como no estaba del todo seguro de cómo trata WinCC Flexible directamente las variables de tipo S5TIME, pues nada mejor que hacer una sencilla prueba.

Lo primero es crear un proyecto de Step7 con una variable S5TIME en un bloque de datos y transferirlo a mi PLC.

En WinCC Flexible enlazo la variable anterior a un campo de entrada salida, le doy suficiente longitud de representación, tres dígitos para la parte decimal y tipo de formato Decimal.

La idea es ir dando distintos valores a la variable desde el Runtime de WinCC Flexible para comprobar de qué manera le llega el valor de tiempo al PLC. Así que transfiero el programa al panel y visualizo simultáneamente el valor de la variable en el PLC y la ejecución del HMI:

Dos máquinas virtuales: una con Step7 on-line con el PLC y la otra con el RT de WinCC Flexible.

Lo que me he encontrado es que introduciendo el valor en segundos (en milisegundos si obviamos la coma),
la variable en formato S5TIME del PLC recibe la conversión ya realizada, directamente, sin programar nada más. Si ponemos valores superiores a 9990,000 segundos (que es la temporización máxima de un temporizador Simatic correspondiente a 2h 36m 30s) se redondea a este valor. Asimismo, no todos los valores de tiempo son posibles, dependen de la base de tiempo, pero el PLC recibirá el valor redondeado más próximo al que hayamos introducido.

Y hasta aquí esta sencilla comprobación. Cualquier comentario será bienvenido.

Probando un servomotor Posmo A para posicionamiento simple (parte 2ª)

2011-12-26T12:59:00.000+01:00

Habiendo dejado en la entrada anterior el Posmo configurado, ahora toca realizar un proyecto en Step7 para controlarlo. Como maestro Profibus voy a usar un PLC S7-315-2DP al que voy a conectar una tarjeta simuladora de entradas / salidas digitales para dar las órdenes necesarias al servomotor y visualizar su estado.

Alimento el PLC y el servomotor, conecto el cable Profibus entre ambos y al borne 1 del servomotor un detector inductivo que hará las veces de leva de referenciado.

Ejecuto el Administrador Simatic y creo un proyecto vacío. Inserto un equipo Simatic 300 y abro la configuración hardware. Inserto mi referencia de PLC, la tarjeta simuladora, creo una red Profibus y finalmente añado el Posmo, con lo que me quedaría algo como esto:

Al PLC le he asignado la dirección Profibus número 2 y al servomotor la dirección 3, que debe coincidir con la que hayamos configurado con los microinterruptores del Posmo. La velocidad la dejo en 1,5 Mbps. Es importante que tanto la dirección inicial hardware de entradas como la de la salidas coincidan, ya que en la programación solo podremos especificar una. Para mi ejemplo he dejado la 256.

Al transferir la configuración deben desaparecer los fallos de comunicación de nuestra red Profibus, luciendo en verde el led de la parte trasera del Posmo. En caso contrario verificar el conexionado, el estado de las resistencias terminadoras y las direcciones asignadas. En mi caso no tuve ninguna dificultad.

Ya nos podemos concentrar en la programación. Siemens tiene en su página web disponible un ejemplo de programación. De este ejemplo he usado dos FB, el FB10 y FB11 que ya tienen programada la comunicación con el Posmo. El primero sirve para controlar el Posmo: referenciar, posicionar, jog, fallos, etc., y el segundo permite leer o escribir parámetros de configuración.

Yo he incorporado estos dos FB en mi proyecto y el FB10 lo usaré para referenciar, posicionar en MDI y gestión de fallos. Entre la información del Posmo que me ofrece el FB10 no está la posición instantánea, así que necesito el FB11 para leer el parámetro 40, que contiene dicho dato. Todas las variables referidas al control del Posmo las he agrupado en un bloque de datos (DB9).

Los parámetros de entrada que he necesitado para el FB10 son:

I_O_Adresss - Dirección hardware del Posmo.
Initialization - Para la puesta en servicio del Posmo, deberá ser lo primero que activemos.
Referencing - Señal que nos permitirá definir el punto actual donde se encuentre el servomotor como cero. En mi ejemplo no lo voy a usar, puesto que usaré una secuencia de referenciado.
Jogging_1 y Jogging_2 - Señales para hacer girar el servomotor en un sentido o en el contrario mientras estén activadas.
Jogging_override - Limitación de velocidad en porcentaje para los movimientos de Jog.
Start - Señal para iniciar una secuencia de desplazamiento. Debe ser activada al menos un ciclo de scan después haber modificado los parametros del bloque a ejecutar.
No_intermediate_stop y No_stop - Señales para indicar que no se realicen paradas en el cambio de bloques. En el ejemplo de Siemens las mantiene siempre a uno y las he dejado igual.
Automatic_operation, External_blockchange, Read_in_enable y Brake_release - No son necesarias en mi ejemplo.
Fault_acknowledgement - Esta señal permite borrar los fallos y avisos del Posmo. También tiene el efecto de detener el servomotor si está en movimiento.
Block_number - Número de bloque que se ejecutará cuando se dé la señal Start. Para mi ejemplo usaré el bloque número 3 para el posicionamiento en MDI y el 13 para realizar el referenciado.
Override - Limitación general de velocidad en porcentaje.
Start_byte - Condiciones auxiliares de inicio, no necesarias en mi ejemplo.
MDI_Type - Si esta señal está a cero, el desplazamiento se hará en modo absoluto. Si está a uno el movimiento será realizado relativo a la posición actual del servomotor. Para mi ejemplo usaré el modo absoluto.
MDI_Velocity y MDI_Acceleration - Velocidad y aceleración del movimiento en MDI expresadas en porcentaje respecto de la velocidad y aceleración máximas configuradas.
MDI_Position - Cota en formato REAL para realizar el posicionamiento en MDI.
Timer_for_wait - Temporizador que usa internamente el FB10, no debemos usarlo en otra parte del programa.
FB_Coordination - Esta señal sirve para coordinar los distintos FB de acceso al Posmo. Entiendo que es una especie de semáforo para que los FB no se pisen. No debemos escribir en ella en ninguna parte del programa.

El FB10 me devuelve la siguiente información:

Warning y Fault - Señales que nos indican si existe alguna advertencia en el Posmo o si este está en fallo.
Ready - Señal que nos indica que el Posmo está listo para el servicio.
Status_word - Palabra donde cada bit indica el estado del Posmo, más abajo lo describiré.
Actual_block - Número de bloque actualmente seleccionado en el Posmo.
Warm_number, Warm_info y Fault_number - Códigos numéricos que nos indican, cuando hay un fallo o advertencia, qué está pasando en el Posmo. Estos códigos están descritos en la documentación.

En el Status_word tenemos la siguiente información:

Bit 0 - Sin error de seguimiento
Bit 1 - No usado
Bit 2 - En posición de consigna.
Bit 3 - El servomotor está referenciado
Bit 4 - El servomotor aceptó la secuencia de desplazamiento.
Bit 5 - El servomotor se está moviendo.
Bit 6 - El servomotor está ejecutando una secuencia de desplazamiento.
Bit 7 - Alimentación de potencia presente.
Bit 8 - Posmo alimentado.
Bit 9 - Posmo listo para el servicio.
Bit 10 - Servicio habilitado
Bit 11 - Posmo en fallo
Bit 12 - Ningún DES2 aplicado
Bit 13 - Ningún DES3 aplicado
Bit 14 - Posmo en bloqueo de conexión.
Bit 15 - Posmo en alarma.

Para obtener la posición instantánea del Posmo llamo al FB11 como sigue:

En la llamada indico la dirección hardware del Posmo, el número de parámetro a leer, le indico que quiero leer y no escribir, y obtengo en formato DWORD el parámetro pedido. Tenemos que tener la precaución de solo dar por buena la lectura cuando el valor de coordinación (FB_Coordination) tenga valor cero.

En mi proyecto de prueba he hecho toda la programación en el FC50. Las distintas órdenes las he dado desde las entradas digitales, que deberán ser adaptadas para un proyecto "real".

El proyecto de Step7 lo tienes aquí y si quieres echar un vistazo a la parametrización del Posmo también está disponible.

En el pasado he programado varios Posmo A de esta manera y hasta ahora no he tenido el más mínimo problema. Si tienes alguna sugerencia o ves algo que no esté del todo bien, te agradeceré que lo comentes.

Probando un servomotor Posmo A para posicionamiento simple (parte 1ª)

2011-12-23T11:08:00.000+01:00

El Simodrive Posmo A es un servomotor de Siemens que hemos montado en multitud de ocasiones. Es sencillo de configurar y programar, y siempre ha dado buen resultado, destacando su fiabilidad. Aprovechando que tengo uno por aquí (referencia 6SN2132-1BC11-1BA1) voy a dedicarle una entrada.

El Posmo A sobre mi mesa preparado para hacer pruebas.

Lo primero que llama la atención es que lleva incorporado el regulador, formado un bloque compacto. Se alimenta con corriente continua, 24 o 48 V según versiones. Como interface de comunicaciones tiene un puerto Profibus. Bajo la tapa lleva unos microinterruptores donde ajustaremos la resistencia terminadora de red y la dirección Profibus. También tiene un bornero donde podremos realizar alimentación separada de electrónica y potencia, y un par de entradas / salidas configurables.

Para mis pruebas voy a conectar el cable Profibus, la alimentación de potencia y un detector inductivo que hará las veces de leva de referenciado.

Para configurarlo necesitamos el Simocom A, que podemos descargar de la página web de Siemens (no es necesaria licencia). Es un software muy sencillo, está en español incluida la completa ayuda, y nos servirá para hacer la configuración y también comprobar el correcto funcionamiento del servomotor. Para conectarnos tendremos que hacerlo necesariamente a través de Profibus, ya sea directamente o por enrutado (routing) a través de un PLC. Si no tenemos el servomotor también podemos hacer la configuración off-line y transferirla posteriormente.

Mi intención es configurar el Posmo para realizar posicionamientos absolutos en modo MDI (Manual Data Input), así que ejecuto el Simocom A y me conecto.

En el Simocom A tenemos a la izquierda un árbol con las distintas opciones de configuración. En la primera pantalla definiremos el modo de funcionamiento. El que yo necesito es Posicionar y como mi Posmo irá acoplado a un husillo lo configuro como Eje lineal.

A continuación voy al apartado Mecánica, donde especifico el paso del husillo, o sea, lo que avanza el eje lineal con cada vuelta del servomotor. En la casilla Juego de inversión se introduce la holgura que presenta nuestra mecánica al cambiar el sentido de giro.

En el apartado Límites especificaremos la velocidad y aceleración máxima que estarán permitidas a nuestro servomotor. Son parámetros importantes, ya que otros parámetros se referirán en relación porcentual a estos valores.

El servomotor dispone de la posibilidad de conectar dos entradas / salidas digitales libremente configurables. En mi caso voy a conectar en el borne 1 la señal de referenciado, dejando el borne 2 sin función.

En el apartado Vigilancia podemos activar límites de recorrido, para mantener nuestro servomotor dentro de un margen de funcionamiento. Además podemos establecer una vigilancia de posicionamiento, de forma que salte una alarma en el caso de funcionamiento anómalo.

En el apartado Regulador se puede modificar algún parámetro de regulación, pero con la configuración de fábrica nunca he tenido problemas.

En el apartado Secuencias de desplazamiento podemos programar movimientos de forma que llamando al número de secuencia se realice el movimiento configurado. Los bloques 1 y 2 están reservados para Jogging. En modo MDI , cuando se transfieren los valores de posición, velocidad y aceleración, se guardan en el bloque número 3. Otros bloques pueden, a su vez, estar reservados para realizar la secuencia de referenciado.

Finalmente, en el apartado Referenciado configuraremos la secuencia de referenciado. La secuencia que necesito es:

avanzar hacia la derecha hasta encontrar la leva de referenciado.
detener el movimiento.
avanzar hacia la izquierda a velocidad lenta hasta perder la leva.
detener el movimiento.
ajustar esa posición como origen (cero).

Se podría mejorar la precisión buscando el impulso de origen del encóder, pero para mi aplicación no es necesario.

Voy a configurar el número de secuencia 13 para iniciar el referenciado, sentido positivo de búsqueda inicial de le leva de referenciado, con inversión de sentido al encontrar la leva y especifico que la leva de referenciado está conectada al borne 1.

Más abajo especifico las velocidades de búsqueda y vuelta atrás, en porcentaje relativo a la velocidad máxima anteriormente configurada. También especifico el recorrido máximo que hará el servomotor durante la búsqueda de la leva de referenciado. Si fuese necesario, se puede cambiar la cota en la que está situada la leva. Cuando acabemos la configuración debemos pulsar sobre el botón Generar programa de referenciado, que preparará la secuencia 13 y siguientes.

Una vez terminada toda la configuración deberemos guardarla en la EPROM del servomotor, para no perderla ante una caída de tensión. También es recomendable guardar los parámetros en un archivo .par.

El Simocom A nos permite probar el funcionamiento del servomotor. Para ello deberemos tomar el control desde el PC (botón PC! de la barra superior). Con F8 desbloquearemos el regulador y ya podremos realizar movimientos en modo Jog, probar el referenciado, posicionados, etc.

Tal y como viene de fábrica, la configuración del referenciado tiene un comportamiento que, en mi caso, no es deseable: se mantiene la señal en referencia incluso después de una pérdida de tensión. Lo que necesito es que sea necesario referenciar cada vez que se encienda la máquina, ya que si se mueve el eje con la máquina apagada, las posiciones del servomotor serán incorrectas, al llevar un encóder relativo.

Para solucionar este inconveniente deberemos entrar en la Lista de experto, para que nos muestre todos los parámetros del regulador.

Buscamos el parámetro 56 Opciones de funcionamiento.

Lo seleccionamos y pulsamos F4 para editarlo.

Y según lo especificado en el manual de configuración, debemos marcar los bits 0 y 1. Con esto, cada vez que demos tensión al servomotor deberemos hacer un referenciado. No olvidemos guardar en EPROM los cambios.

Hasta aquí este ejemplo de configuración de servomotor Posmo A. En una siguiente entrada me meteré con la programación desde un PLC S7-300.

Cualquier comentario será bienvenido.

Tres maneras de generar pulsos en un controlador Logix5000

2011-10-17T13:09:00.000+02:00

Es raro que programando una máquina no sea necesaria una señal pulsante, generalmente para funciones de señalización. En controladores de Rockwell, por ejemplo del tipo SLC 500, podemos echar mano de bits de sistema que cumplen esta función. Sin embargo, en la gama de controladores Logix5000, si necesitamos un pulso deberemos generarlo nosotros. En esta entrada voy a proponer tres maneras de generar una señal pulsante de un segundo de duración: primero usando temporizadores (PULSO_TEMP), luego leyendo el tiempo del sistema (PULSO_SIS) y finalmente usando tareas periódicas (PULSO_TAREA).

El código en lógica de escalera para generar un pulso con temporizadores podría tener este aspecto:

(Pincha para ver mejor la imagen)

Uso dos temporizadores, uno para controlar el semiciclo activo del pulso y otro para el semiciclo inactivo, y a cada uno de ellos le asigno una duración de 500 ms. Esta es la opción que requiere más programación.

Otra forma de generar el pulso es leyendo el tiempo del sistema. Para ello tenemos que echar mano de la instrucción GSV (Get System Value), que sirve para leer distintos parámetros de estado del controlador. El tiempo del sistema lo obtendré en una tabla de siete DINT, así que voy a crear un tipo de dato para almacenarlo. Voy al árbol del proyecto y sobre Data Types → User Defined, con el botón derecho del ratón, pulso sobre New Data Type...

Y genero un tipo de datos que voy a llamar FECHA_HORA con siete datos de formato DINT donde se almacenarán consecutivamente el año, el mes, el día, la hora, el minuto, los segundo y los microsegundos (ojo con este último dato, son microsegundos, no milisegundos - nunca me había encontrado un PLC con semejante resolución de tiempo).

Ahora declaramos una variable con este nuevo tipo de dato (yo la he llamado T_ACTUAL) y ya podemos programar:

En el primer renglón uso la instrucción GSV para almacenar en la variable T_ACTUAL la lectura del tiempo del sistema. En el dato T_ACTUAL.Microseconds tendré un valor entre 0 y 999 999; para generar el pulso de un segundo veo si ese valor es menor de 500 000 (medio segundo), activándolo en caso afirmativo.

Las dos formas de generar intermitencias que acabamos de ver tienen un inconveniente, y es que dependemos del tiempo de ciclo del PLC para ejecutar las instrucciones, restando precisión a los pulsos. Esto no tiene importancia si vamos a usar la intermitencia para la señalización, por ejemplo, de una baliza luminosa, pero puede que precisemos pulsos lo más exactos posibles, en este caso debemos usar una tarea periódica.

Una tarea periódica se ejecuta cada cierto tiempo regular definido por el usuario y se usa para funciones que requieran una ejecución precisa o determinista. Dependiendo del tipo de PLC Logix5000 se pueden crear hasta 32 tareas periódicas (en la gama CompactLogix solo cuatro) y asignar un nivel de prioridad a cada una. Cada vez que se cumple el tiempo de la tarea periódica, se interrumpe la tarea continua, se ejecuta una vez y luego devuelve el control en el mismo punto donde se interrumpió la tarea continua.

Para crear una tarea periódica, en el árbol de proyecto, pulsamos con el botón derecho del ratón sobre Tasks y seleccionamos New Task...

Le asignamos un nombre (en mi caso PULSOS).

Vamos a la pestaña Configuration y en Period asignamos un valor de 500 ms.

Dentro de esta nueva tarea creamos un programa (GENERADOR) y dentro del programa una rutina (PULSO_TAREA). Esta rutina la asigno como rutina principal al programa:

El código de esta rutina es algo tan sencillo como el siguiente renglón:

Cada 500 ms se ejecuta la rutina y en ella invierto la señal del pulso.

En la siguiente captura de pantalla se ven los tres pulsos funcionando simultánemante:

Por si alguien tiene interés, el proyecto para RSLogix 5000 de esta entrada está disponible aquí.

Y hasta aquí esta sencilla entrada sobre programación de pulsos en Logix, si algún lector tiene algún método diferente le agradeceré que lo comparta en los comentarios.

Comunicación OPC con un PLC Logix5000 desde Visual Basic

2011-10-07T16:49:00.000+02:00

Ya he hablado en el blog de comunicación OPC, en concreto en esta entrada traté el acceso a un WinAC desde Visual Basic. Ahora, aprovechando la configuración que tengo con SoftLogix sobre una máquina virtual, voy a hacer lo mismo.

Mi prueba consistirá en crear un proyecto para SoftLogix en el que definiré un par de tags, OPC_BIT y OPC_DINT, que me servirán para probar la comunicación. En el SoftLogix no voy a hacer nada más, simplemente le transferiré el proyecto, lo pondre en modo Run y monitorizaré el contenido de los tags. Luego generaré un enlace OPC con el RSLinx y desde un programa en Visual Basic leeré y escribiré en los tags del PLC.

Para establecer una comunicación OPC necesitaré un servidor OPC, y Rockwell nos lo proporciona integrado con el RSLinx, pero ojo, deberemos asegurarnos de que no sea la versión lite. Recomiendo echar un vistazo a este documento Cómo obtener resultados con RSLinx Classic (pdf) donde se especifica para qué sirve cada versión de RSLinx.

En el ordenador donde tengo instalado Visual Basic he instalado RSLinx Classic. Con mi SoftLogix funcionando compruebo que lo detecta.

Para obtener acceso al PLC a través de OPC deberemos configurar un Topic, que es la definición de la ruta de acceso al controlador. Para ello vamos al menú de RSLinx y pulsamos sobre DDE/OPC → Topic Configuration... y aparecerá una ventana donde seleccionaremos nuestro controlador y le asignaremos un Topic, en mi caso PRUEBA_OPC.

Aceptamos y ya podemos cerrar el RSLinx. Para comprobar que nuestro servidor OPC funciona, Rockwell suministra la herramienta OPC Test Client (se instala conjuntamente con el RSLinx). La ejecutamos y vamos al menú Server → Connect...

Selecciono RSLinx OPC Server.

Ahora tenemos que añadir un grupo, vamos al menú Group → Add Group...

Le asignamos un nombre cualquiera y aceptamos.

Ya solo falta añadir Items (que serán nuestros tags), vamos al menú Item → Add Item...

En la ventana que aparece, en la parte inferior izquierda navegamos por el árbol del servidor OPC, seleccionamos dentro de nuestro Topic la opción online y a la derecha deberán mostrarse los tags de nuestro proyecto Logix5000. Selecciono el tag que me interese y pulso el botón Add Item.

Y ya podemos ver el contenido de nuestro tag. Si modificamos su valor desde el RSLogix5000 veremos en el OPC Test Client como varía.

Ya hemos comprobado que tenemos acceso por OPC a nuestro controlador. Ahora lo que voy a hacer es la misma operación pero desde un programa en Visual Basic.

Crearemos un proyecto en Visual Basic y, para tener acceso a las funciones de comunicación OPC, deberemos agregar, en mi caso, la referencia OPC DA Automation Wrapper 2.02 (OPCDAAuto.DLL) que estará disponible en mi ordenador al tener instalado el RSLinx. Esta referencia difiere según sea la versión de RSLinx de que dispongamos; según leo en el foro de control.com deberemos agregar RsLinxOPCAuto.DLL o incluso RsiOPCAuto.DLL si disponemos de versiones antiguas.

Comprobamos que en Espacios de nombres importados esté marcado RsiOPCAuto.

Con esto ya podemos empezar a programar. Voy a adaptar el código de la clase que programé en la entrada sobre OPC y WinAC:

Imports OPCAutomation

Public Class OPC_NdA 'OPC Notas de Automatización
    'Objectos para establecer la comunicación OPC
    Private WithEvents ServidorOPC As OPCServer
    Private WithEvents GrupoOPC As OPCGroup
    Private WithEvents GruposOPC As OPCGroups
    Private ItemOPC() As OPCItem

    Public Conectado As Boolean 'Para saber si la conexión está activada

    'Si hay algún error se indica en estas variables
    Public Mensaje As String
    Public Detalle_Error As String

    'Constructor
    Public Sub New()
        'Al crear el objeto, no estamos conectados
        Conectado = False
    End Sub

    'Función para activar la conexión OPC
    Public Function Conectar() As Boolean

        'Si ya estoy conectado aviso y salgo.
        If Conectado Then
            Mensaje = "Error conexión OPC."
            Detalle_Error = "Se ha intentado crear una conexión OPC cuando ya hay una creada."
            Conectar = False
            Exit Function
        End If

        Try
            Mensaje = "Conectando con el servidor OPC..."
            ServidorOPC = New OPCServer
            ServidorOPC.Connect("RSLinx OPC Server")

            Mensaje = "Añadiendo grupo al servidor OPC..."
            GruposOPC = ServidorOPC.OPCGroups
            GrupoOPC = GruposOPC.Add("Grupo1")

            GrupoOPC.IsActive = True
            GrupoOPC.UpdateRate = 1000
            GrupoOPC.IsSubscribed = True

            Mensaje = "Añadiendo Items al grupo..."
            ReDim ItemOPC(100) 'Dimensionar según las necesidades

            'Introducir un ítem por cada variable del PLC en la que queramos leer o escribir
            'A cada ítem le asignamos un número, que debemos recordar para referirnos a él en el programa
            ItemOPC(0) = GrupoOPC.OPCItems.AddItem("[PRUEBA_OPC]OPC_DINT", 0)
            ItemOPC(1) = GrupoOPC.OPCItems.AddItem("[PRUEBA_OPC]OPC_BIT", 1)

        Catch ex As Exception

            Detalle_Error = "Error: " & ex.ToString
            Conectado = False
            Conectar = False
            Exit Function

        End Try

        Mensaje = "Conexión OPC realizada correctamente."
        Detalle_Error = ""
        Conectado = True
        Conectar = True

    End Function

    'Función para deshacer la conexión OPC
    Public Function Desconectar() As Boolean
        Try
            Mensaje = "Desconectando..."
            ItemOPC = Nothing

            If Not IsNothing(ServidorOPC) Then
                ServidorOPC.OPCGroups.RemoveAll()
                ServidorOPC.Disconnect()
                ServidorOPC = Nothing
            End If
            GrupoOPC = Nothing
            GruposOPC = Nothing

        Catch ex As Exception

            Detalle_Error = "Error: " & ex.ToString
            Desconectar = False
            Exit Function

        End Try

        Mensaje = "Desconexión realizada correctamente."
        Detalle_Error = ""
        Conectado = False
        Desconectar = True

    End Function

    'Función para escribir en un ítem que representa una variable entera
    'Se le pasa el índice del ítem y el valor que vamos a escribir
    'Si todo va bien devuelve True
    Public Function EscribirItemInt(ByVal Indice As Integer, ByVal Entero As Integer) As Boolean
        Dim Dims() As Integer = New Integer() {1}
        Dim Bounds() As Integer = New Integer() {1}
        Dim Serverhandles As Array = Array.CreateInstance(GetType(Integer), Dims, Bounds)
        Dim Errores As Array = Array.CreateInstance(GetType(Integer), Dims, Bounds)
        Dim Valores As Array = Array.CreateInstance(GetType(Object), Dims, Bounds)

        If Not Conectado Then
            Mensaje = "Error conexión OPC."
            Detalle_Error = "No hay establecida una conexión OPC."
            EscribirItemInt = False
            Exit Function
        End If

        Try
            Serverhandles.SetValue(ItemOPC(Indice).ServerHandle, 1)
            Errores.SetValue(0, 1)
            Valores.SetValue(Entero, 1)

            GrupoOPC.SyncWrite(1, Serverhandles, Valores, Errores)

        Catch ex As Exception

            Detalle_Error = ex.ToString
            Mensaje = "¡Error al escribir Item! [Int, Índice " & Indice & "]"
            EscribirItemInt = False
            Exit Function

        End Try

        Mensaje = ""
        Detalle_Error = ""
        EscribirItemInt = True

    End Function

    'Función para escribir en un ítem que representa una variable booleana
    'Se le pasa el índice del ítem y el valor que vamos a escribir
    'Si todo va bien devuelve True
    Public Function EscribirItemBool(ByVal indice As Integer, ByVal Bit As Boolean) As Boolean
        Dim Dims() As Integer = New Integer() {1}
        Dim Bounds() As Integer = New Integer() {1}
        Dim Serverhandles As Array = Array.CreateInstance(GetType(Integer), Dims, Bounds)
        Dim Errores As Array = Array.CreateInstance(GetType(Integer), Dims, Bounds)
        Dim Valores As Array = Array.CreateInstance(GetType(Object), Dims, Bounds)

        If Not Conectado Then
            Mensaje = "Error conexión OPC."
            Detalle_Error = "No hay establecida una conexión OPC."
            EscribirItemBool = False
            Exit Function
        End If

        Try
            Serverhandles.SetValue(ItemOPC(indice).ServerHandle, 1)
            Errores.SetValue(0, 1)
            Valores.SetValue(Bit, 1)

            GrupoOPC.SyncWrite(1, Serverhandles, Valores, Errores)

        Catch ex As Exception

            Detalle_Error = ex.ToString
            Mensaje = "¡Error al escribir Item! [Bool, Índice " & indice & "]"
            EscribirItemBool = False
            Exit Function

        End Try

        Mensaje = ""
        Detalle_Error = ""
        EscribirItemBool = True

    End Function

    'Función para leer un ítem que representa una variable entera
    'Se le pasa el índice del ítem que vamos a leer
    'Si todo va bien devuelve el valor de la variable
    Public Function LeerItemInt(ByVal Indice) As Integer

        Dim Valor As Object = Nothing
        Dim Calidad As Object = Nothing
        Dim TimeStamp As Object = Nothing

        If Not Conectado Then
            Mensaje = "Error conexión OPC."
            Detalle_Error = "No hay establecida una conexión OPC."
            LeerItemInt = 0
            Exit Function
        End If

        Try
            ItemOPC(Indice).Read(OPCDataSource.OPCDevice, Valor, Calidad, TimeStamp)
            LeerItemInt = CInt(Valor.ToString)

        Catch ex As Exception

            Detalle_Error = ex.ToString
            Mensaje = "¡Error al leer Item! [Int, Índice " & Indice & "]"
            LeerItemInt = 0
            Exit Function

        End Try

        Mensaje = ""
        Detalle_Error = ""

    End Function

    'Función para leer un ítem que representa una variable booleana
    'Se le pasa el índice del ítem que vamos a leer
    'Si todo va bien devuelve el valor de la variable
    Public Function LeerItemBool(ByRef Indice) As Boolean

        Dim Valor As Object = Nothing
        Dim Calidad As Object = Nothing
        Dim TimeStamp As Object = Nothing

        If Not Conectado Then
            Mensaje = "Error conexión OPC."
            Detalle_Error = "No hay establecida una conexión OPC."
            LeerItemBool = 0
            Exit Function
        End If

        Try
            ItemOPC(Indice).Read(OPCDataSource.OPCDevice, Valor, Calidad, TimeStamp)
            If StrComp(Valor.ToString, "True") = 0 Or Valor = 1 Then
                LeerItemBool = True
            Else
                LeerItemBool = False
            End If

        Catch ex As Exception

            Detalle_Error = ex.ToString
            Mensaje = "¡Error al leer Item! [Bool, Índice " & Indice & "]"
            LeerItemBool = False
            Exit Function

        End Try

        Mensaje = ""
        Detalle_Error = ""

    End Function

End Class

Con respecto al código que hice para Siemens simplemente he cambiado en la función Conectar el servidor OPC a RSLinx OPC Server y he adaptado la lista de items.

Para introducir los items deberemos especificar el nombre del Topic que hayamos configurado en el RSLinx entre corchetes seguido del nombre del tag, por ejemplo:

ItemOPC(0) = GrupoOPC.OPCItems.AddItem("[PRUEBA_OPC]OPC_DINT", 0)

Las funciones para leer y escribir booleanos y enteros son las mismas que las programadas en el OPC de Siemens.

Ya solo nos queda crear una interfaz sencilla para probar la conexión:

Pulsando el botón Conectar se establecerá la conexión OPC y si todo va correctamente podremos escribir y leer valores en el tag OPC_DINT y cambiar el estado del booleano OPC_BIT.

El código de este sencillo programa lo tienes en este proyecto de Visual Basic.

Y hasta aquí esta toma de contacto con la tecnología OPC en Rockwell. No es un ejemplo elaborado, pero espero que pueda servir de punto de partida para aplicaciones más complejas.

Como siempre, agradeceré cualquier comentario.

Accediendo a un PLC Simatic a través de ethernet con Libnodave

2011-10-03T10:04:00.000+02:00

En esta entrada usé la biblioteca libre Libnodave para acceder a un PLC S7-300 desde Visual Basic a través de un adaptador serie/MPI. Varios lectores me hicieron consultas sobre si era posible usarla para acceder a un PLC S7-300/400 a través de ethernet, pero al no tener disponible un controlador adecuado para hacer pruebas pues no tenía respuesta. Sin embargo, de la entrada anterior tengo preparada una máquina virtual con WinAC RTX y su puerto ethernet como puerto de comunicaciones, que creo que es un banco de pruebas ideal para hacer pruebas con Libnodave.

Lo primero que voy a hacer es un proyecto en Step7 con un único DB, por ejemplo el DB10, con un único dato de formato BYTE. Lo transferiero al WinAC y pongo el PLC software en modo Run. Me pongo on line y monitorizo la variable.

En el PLC no voy a tocar nada más. A continuación lo que haré será una aplicación en Visual Basic, usando la biblioteca Libnodave a través de ethernet, que se conectará al PLC y leerá y escribirá en esa variable como prueba que el sistema funciona.

El aspecto que tendrá mi aplicación puede ser algo tan sencillo como esto:

Para realizar la conexión es nesaria una dirección IP (en mi caso la de la máquina virtual donde tengo el WinAC), un número de puerto (que según la documentación de Libnodave debe ser el 102), un número de rack (lo habitual aquí es un cero) y un número de slot (que será el número de slot donde tengamos configurado el PLC, lo podemos ver en la configuración hardware, en mi caso el dos). La programación en Visual Basic va ser muy parecida a la que hice en esta entrada, uso la misma biblioteca de la misma forma así que no repito aquí el procedimiento para incluirla en el proyecto. He adaptado la clase que creé en su momento para encapsular las funciones de acceso al PLC a través de ethernet, quedando de la siguiente manera:

Public Class Libnodave_WinAC
Dim daveSerie As libnodave.daveOSserialType
Dim daveInter As libnodave.daveInterface
Dim daveConex As libnodave.daveConnection

Public BufferLectura(1000) As Byte
Public BufferEscritura(1000) As Byte

Public Conectado As Boolean = False
Public Mensaje As String

Public Function Conectar(Optional ByVal Puerto As Integer = 102, _
Optional ByVal IP As String = "192.168.65.18", _
Optional ByVal Rack As Integer = 0, _
Optional ByVal Slot As Integer = 2) As Boolean
If Conectado Then
Mensaje = "Conexión abortada, ya existe una conexión."
Conectar = False
Exit Function
End If

Dim Respuesta As Integer

Mensaje = "Abriendo una conexión serie..."
daveSerie.rfd = libnodave.openSocket(Puerto, IP)
daveSerie.wfd = daveSerie.rfd

If daveSerie.rfd > 0 Then
Mensaje = "Conexión OK, creando interface..."

daveInter = New libnodave.daveInterface(daveSerie, "", _
0, _
libnodave.daveProtoISOTCP, _
libnodave.daveSpeed187k)

daveInter.setTimeout(1000000) 'Make this longer if you have a very long response time

Mensaje = "Inicialización del adaptador OK, creando conexión..."
daveConex = New libnodave.daveConnection(daveInter, 0, Rack, Slot)
Respuesta = daveConex.connectPLC()

If Respuesta = 0 Then
Mensaje = "Conexión correcta, lista para operar."
Conectado = True
Else
libnodave.closeSocket(daveSerie.rfd)
Mensaje = "Error al abrir la conexión [" & _
libnodave.daveStrerror(Respuesta) & "]"
Conectado = False
End If

Else
Mensaje = "Error al abrir la conexión"
Conectado = False
End If

Conectar = Conectado

End Function

Public Function Desconectar() As Boolean
If Conectado Then
daveConex.disconnectPLC()
libnodave.closeSocket(daveSerie.rfd)
Conectado = False
Mensaje = "Conexión correctamente terminada."
Desconectar = True
Else
Mensaje = "No existe conexión activa."
Desconectar = False
End If
End Function

Public Function LeerBytesDB(ByVal NumDB As Integer, _
ByVal Dir As Integer, _
ByVal NumBytes As Integer) As Boolean

Dim Respuesta As Integer

Respuesta = daveConex.readBytes(Libnodave.daveDB, NumDB, Dir, NumBytes, BufferLectura)

If Respuesta = 0 Then
Mensaje = "Leídos " & NumBytes & " bytes a partir de la dirección " & _
Dir & " en el DB " & NumDB
LeerBytesDB = True
Else
Mensaje = "Error al leer " & NumBytes & " bytes a partir de la dirección " & _
Dir & " en el DB " & NumDB
LeerBytesDB = False
End If

End Function

Public Function EscribirBytesDB(ByVal NumDB As Integer, _
ByVal Dir As Integer, _
ByVal NumBytes As Integer) As Boolean
Dim Respuesta As Integer

Respuesta = daveConex.writeBytes(Libnodave.daveDB, NumDB, Dir, NumBytes, BufferEscritura)

If Respuesta = 0 Then
Mensaje = "Escritos " & NumBytes & " bytes a partir de la dirección " & _
Dir & " en el DB " & NumDB
EscribirBytesDB = True
Else
Mensaje = "Error al escribir " & NumBytes & " bytes a partir de la dirección " & _
Dir & " en el DB " & NumDB
EscribirBytesDB = False
End If

End Function

End Class

Lo que he hecho es cambiar el protocolo serie por el protocolo ethernet. Su uso es muy sencillo, a la función Conectar se le pasan la dirección IP, el puerto, el rack y el slot. Si no hay error, con las funciones LeerBytesDB y EscribirBytesDB accedemos a datos almacenados en cualquier DB de la memoria del PLC (son exactamente las mismas funciones que en la versión serie). Al acabar debemos desconectarnos con la función Desconectar. La clase se podría completar con funciones para acceder a otras zonas de memoria permitidas por Libnodave.

Ejecuto mi aplicación, pongo los parámetros de conexión y pulso Conectar. Si todo va bien me pondrá un mensaje que el enlace está realizado. Con los botones de lectura y escritura puedo ver como modifico y leo el contenido del DB10 en mi PLC.

Si nos equivocamos al dar la dirección IP o el puerto, nos dará error. Sin embargo si ponemos un rack o slot incorrectos, puede que nos diga que la conexión está correcta, pero evidentemente no lograremos leer ni escribir nada.

Si quieres ver el código completo de este sencillo proyecto, lo tienes aquí. Si además quieres echar un vistazo a la configuración de Step7 que he usado, descárgate este proyecto.

Aunque esta prueba está hecha sobre un WinAC en una máquina virtual, pienso que el código servirá para acceder a un PLC S7-300/400 con puerto ethernet. Si algún lector hace la prueba, le agradeceré una reseña en los comentarios.

Este es un ejemplo muy sencillo, símplemente para comprobar que Libnodave funciona y es sencillo de usar. Ahora mismo se me ocurren un par de antiguos proyectos en los que podría haber usado Libnodave, consiguiendo abaratar su coste, al ahorrarnos licencias. Sin embargo no debemos olvidar que Libnodave, a pesar de su buen desempeño, no tiene una empresa detrás que nos de garantía o soporte, y que si lo usamos es por nuestra cuenta y riesgo.

Como siempre, agradeceré cualquier comentario.

Virtualizando WinAC RTX, el PLC software de Siemens

2011-09-30T09:00:00.000+02:00

Después de estar trabajando con el SoftLogix de Rockwell sobre máquinas virtuales, me he preguntado si sería posible hacer funcionar al equivalente en Siemens, el WinAC RTX, en las mismas condiciones. Así que me he puesto manos a la obra y he instalado sobre una máquina virtual en VirtualBox con Windows XP el paquete Simatic NET V7.1 + SP1 y WinAC RTX V4.4 + SP1 con su correspondiente licencia. Toda la instalación transcurrió sin problemas:


WinAC RTX ejecutándose sobre una máquina virtual (pincha sobre la imagen para verla mejor)

Ahora el problema es poder configurarlo y programarlo desde otro equipo a través del puerto ethernet. En la web de Siemens hay una guía para hacerlo, está bastante clarita y los pasos que voy a ir explicando están basados en ella.

Lo primero es asegurarnos que la configuración de red de nuestra máquina virtual es coherente con nuestra red local.

No está de más probar a hacer un ping para comprobar que existe comunicación.

Ahora vamos a ejecutar la herramienta de configuración de Simatic NET, Menú Inicio → SIMATIC → Simatic NET → Configuration Console

En la árbol de la izquierda vamos a PC Station → SIMATIC NET Configuration → Modules → Adaptador de servidor → General, ponemos el modo del módulo en Configured Mode y el perfil del interface en TCP/IP (Auto) y aplicamos.

En mi caso 'Adaptador de servidor' es la denominación de la tarjeta de red

Ya podemos cerrar la consola de configuración. El siguiente paso será introducir nuestra tarjeta de red en el configurador de componentes (Station Configurator). Para ello lo abrimos y sobre un slot vacío (en mi caso el uno), con el botón derecho del ratón, pulsamos sobre Add.

En el menú que aparece seleccionamos como tipo de componente IE General.

En Index podemos asignar el número de slot, dejo el uno y acepto.

Podemos revisar las propiedades de configuración, que coincidirán con los parámetros de red de nuestra máquina virtual.

Aceptamos y ya aparece nuestra tarjeta de red configurada y lista para aceptar conexiones.

En la máquina virtual ya solo nos queda ejecutar el WinAC para tener el sistema totalmente listo para establecer un enlace a través de ethernet.
Ahora vamos al equipo donde tengamos el software de programación Step7, en mi caso es el equipo anfitrión de la máquina virtual, pero podría cualquier otro equipo conectado a mi red local. Creamos un proyecto nuevo y configuramos nuestro WinAC RTX.

Sobre el mismo slot donde configuramos la tarjeta de red en el Station Configurator de la máquina virtual arrastramos el componente Estación PC SIMATIC → CP-Industrial Ethernet → IE General → SW V7.1

Se abrirá una ventana de configuración donde deberemos especificar la dirección IP y la máscara de red correspondentes a nuestra máquina virtual.

Compilamos y guardamos la configuración, pero aún no estamos preparados para transferirla: antes debemos abrir la configuración del interface PG/PC y tenemos que asignar la tarjeta de red de nuestro PC.

Y ahora ya podemos transmitir la configuración hardware. Una vez hecho ya podemos probar a programar y a ponernos on line con el PLC software.

Listo, hasta aquí esta entrada sobre la virtualización de un WinAC RTX. En mi caso me va a resultar muy útil para hacer pruebas sin necesitar físicamente un PLC. Con esta configuración he hecho pruebas de comunicación con la biblioteca Libnodave a través de ethernet con buenos resultados y de las que hablaré en una próxima entrada.

Como siempre agradeceré cualquier comentario.

Comunicación entre controladores Logix5000: Mensajes

2011-09-28T14:14:00.000+02:00

En esta entrada voy a resumir mis pruebas con la instrucción MSG de Logix. Usaré la misma configuración de la entrada anterior: dos máquinas virtuales con un SoftLogix en cada una que se comunicarán entre sí. El control de la mensajería la hará el primer controlador (SoftLogix A). En la segunda máquina virtual (SoftLogix B) simplemente voy a crear dos tags; en el primero, MENSAJE_DATOS_RECIBIDOS, estarán los datos que se escribirán desde el SoftLogix A. En el segundo, MENSAJE_DATOS_A_ENVIAR, pondré los datos que serán leídos desde el SoftLogix A. Y nada más, en el SoftLogix B no voy a hacer ninguna programación, simplemente voy a monitorizar los valores de ese par de tags.

Mis pruebas, por tanto, consistirán en, desde el SoftLogix A, leer y escribir a través de mensajes en los tags del SoftLogix B.

En el proyecto del SoftLogix A deberé especificar la existencia en la red Ethernet del SoftLogix B. Para ello, en el árbol de proyecto, en el apartado I/O Configuration, bajo la tarjeta Ethernet hay que incluir los módulos correspondientes para que quede como sigue:

Para cada comunicación por mensajes deberemos definir un tag de tipo MESSAGE. Como voy a usar en mensaje para escribir y otro para leer, creo los tags MENSAJE_ESCRITURA_SLB y MENSAJE_LECTURA_SLB respectivamente. También necesitaré tags que tengan el mismo formato que los tags del SoftLogix B en los que voy a leer y escribir, así que creo DATOS_A_ESCRIBIR_SLB y DATOS_LEIDOS_SLB. Finalmente creo un par de booleanos para dar las órdenes de escritura y lectura: ORDEN_ESCRITURA_SLB y ORDEN_LECTURA_SLB.

Ahora voy con la programación. Simplemente consiste en lanzar la instrucción MSG con la orden de lectura o escritura y si no está el mensaje activo. Cuando finaliza la comunicación se borra la orden respectiva.

En cada instrucción MSG deberemos asignarle el tag de tipo MESSAGE correspondiente. Para configurar el mensaje pulsaremos sobre el botón de los tres puntos que aparece en la instrucción.

Voy a empezar con el mensaje de lectura. En la pestaña Configuration lo primero es determinar el tipo de mensaje. Para la lectura de otro controlador Logix debo seleccionar CIP Data Table Read. A continuación, en Source Element debo escribir el nombre de la variable del SoftLogix B que voy a leer, decirle cuantos datos de la tabla se transmitirán en Number of Elements y en Destination Element poner el tag del SoftLogix A donde se recogeran los datos.

En la pestaña Communication hay que especificar el controlador de donde se leeran los datos. Para ello pulsamos sobre el botón Browse y seleccionamos el controlador remoto.

En la instrucción MSG de escritura deberemos hacer una configuración similar, deberemos configurar como tipo de mensaje CIP Data Table Write, especificar el tag donde están los datos a transmitir, en número de dato y el nombre de la variable en el controlador remoto donde se almacenarán.

En la pestaña Communication deberemos asímismo seleccionar el controlador remoto.

Ya tenemos todo listo para comprobar que nuestra mensajería funciona. Cargamos nuestros proyectos en los dos SoftLogix y nos ponemos on line. En los tags DATOS_A_ESCRIBIR_SLB del SoftLogix A y MENSAJE_DATOS_A_ENVIAR del SoftLogix B asigno valores al azar y activando los bits de órdenes de lectura y escritura en el SoftLogix A compruebo que los datos se transmiten correctamente.

Datos en el SoftLogix A

Datos en el SoftLogix B

Y hasta aquí esta sencilla prueba de la mensajería en Logix. Los mensajes se utilizan para realizar comunicaciones controladas por la lógica de programación. Por ejemplo, yo he tenido que usarlos recientemente para transmitir señales de alarma a un servidor, pero solo cuando se detectaba un cambio en las alarmas. De esta manera se evita saturar las comunicaciones. Además hay una serie de limitaciones como que no puede haber más de 16 mensajes simultáneos, en el manual (PDF) viene todo esto muy bien explicado.

Como siempre agradeceré cualquier comentario.

Comunicación entre controladores Logix5000: Tags producidos y consumidos

2011-09-04T15:25:00.000+02:00

Para comunicar dos controladores de la gama Logix5000 existen dos opciones: Tags producidos/consumidos [PDF] o Mensajes. Los primeros simplemente se configuran de forma que no es necesario la intervención de instrucciones de programación para su difusión: lo que escribamos en un tag productor de un controlador se verá reflejado en los tags consumidores del controlador o controladores consumidores. Los mensajes, en cambio, precisan de la instrucción MSG para su difusión.

En esta entrada haré un resumen de mis pruebas con los tags productores/consumidores. Como no dispongo físicamente de ningún controlador CompactLogix o ControlLogix con el que trastear, he preparado dos máquinas virtuales con un SoftLogix en cada una, tal y como hice en esta entrada. Las ejecutaré simultáneamente en mi ordenador a la vez que la máquina virtual donde tengo el software de programación, lo cual supone tres máquinas virtuales simultáneas sobre mi portátil, que, aparte de calentarse más que una sartén, ha aguantado estoicamente.

Teniendo ya todo el sistema de pruebas preparado, lo primero será comprobar que los controladores se ven entre sí. Para ello ejecuto el RSLinx en cualquier máquina virtual y con la herramienta RSWho observo que aparecen mis dos controladores SoftLogix:

Ahora tengo que preparar dos proyectos (ver esta entrada), uno para el contolador productor (SoftLogix A) y otro para el controlador consumidor (SoftLogix B). No voy a hacer ninguna programación, simplemente voy a configurar un tag productor, cambiar su valor en la monitorización de tags y comprobar que el valor se transmite al tag consumidor.
En el SoftLogix A (productor) creo una variable llamada PRODUCIDA del tipo DINT (obligatoriamente debe estar en el ámbito del controlador) y voy a sus propiedades.

Selecciono el tipo Produced y pulso sobre Conection...

Como solo voy a tener un consumidor, dejo la opción Max Consumers a 1 y acepto.

En el controlador productor no hay que configurar nada más, así que voy al proyecto del SoftLogix B (consumidor) y creo otra variable del mismo tipo que la anterior (también en al ámbito del controlador) y la llamo CONSUMIDA.

A este tag consumidor hay que especificarle de dónde tiene que obtener su valor, para ello en el árbol de proyecto, bajo la tarjeta ethernet virtual del SoftLogix B (consumidor), debemos introducir la configuración del SoftLogix A (productor), que quedará así:

Tenemos que tener la precaución de especificar la dirección IP del controlador productor.

Para evitar un error de duplicidad de control en la tarjeta de entradas/salidas digitales del SoftLogix A la he deshabilitado.

Ahora vamos a las propiedades del tag CONSUMIDA, selecionamos el tipo Consumed, y pulsamos sobre el botón Connection...

Como producor (producer) seleccionamos en el menú desplegable el controlador productor (en mi caso SL_Productor). En la casilla Remote Data hay que especificar el nombre de la variable producida en el controlador productor, en mi caso PRODUCIDA.

El RPI (Requested Packet Interval) es el tiempo de actualización de la variable consumida. Deberemos ser cuidadosos con este tiempo ya que un RPI bajo implica mayor consumo en los recursos de nuestra red de comunicaciones. Ademas este valor debe ser mayor que el tiempo de actualización de la red.

Y listo, ya solo nos queda comprobar que nuestra configuración funciona. Me pongo on-line con los dos SoftLogix y, monitorizando los tags, compruebo que un valor introducido en el tag PRODUCIDA del controlador productor se refleja en el tag CONSUMIDA del controlador consumidor.

Cuando configuramos tags productores o consumidores podemos seleccionar conexiones Unicast, que, según tengo entendido, exigen menos recursos de la red. Son conexiones punto a punto (point to point) entre un controlador productor y un controlador consumidor (no se permiten conexiones múltiples). Según leo en la edición en inglés del manual (en la versión en español no figura) el controlador productor debe permitir conexiones Unicast, pero es el controlador consumidor quien decide si la conexión es unicast o multicast. Sin embargo, en mis pruebas, si configuro el consumidor para permitir las conexiones Unicast, el productor también tengo que configurarlo como Unicast, si no, no funciona.

Como siempre, agradeceré cualquier comentario.

Probando Factory Talk View ME, el software de programación para PanelView

2011-08-27T22:20:00.002+02:00

De todos los programas de Rockwell con los que he tenido que trabajar hasta ahora, el que menos me ha gustado es el software de programación de paneles de operador Factory Talk View Studio Machine Edition (anteriormente denominado RSView Studio Machine Edition). Lo cierto es que dispone de prestaciones similares a programas análogos de otros fabricantes, pero el entorno no me ha parecido cómodo, ya que operaciones muy comunes hay que realizarlas con aplicaciones externas.

Este software sirve para programar la gama de paneles de operador PanelView Plus Terminal y PanelView Plus CE Computers. Nada más ejecutarlo nos ofrecerá abrir un proyecto existente o crear uno nuevo. La gestión de los proyectos es un poco especial.
Al crear uno nuevo lo almacenará en un directorio por defecto, en mi caso en "C:\Documents and Settings\All Users\Documentos\RSView Enterprise\ME\HMI projects", pero no deberemos acceder directamente, en su lugar usaremos la herramienta específica Application Manager.

Con ella podremos renombrar, copiar, borrar, hacer copias de seguridad y restaurarlas, importar proyectos de versiones anteriores y, a partir de una aplicación compilada, obtener el proyecto para editarlo. Este último punto es algo que echo de menos en otros fabricantes.

Al abrir un proyecto, el aspecto de la aplicación es el siguiente:

A la izquierda dispone de un árbol de proyecto donde tenemos acceso a los diferentes componentes. En la parte superior una barra con acceso a los objetos gráficos. Abajo está el diagnóstico que nos dará información sobre la actividad de la aplicación.

A la hora de programar objetos gráficos, tales como botones, visualizaciones de texto, etc., es muy similar a cualquier otro software de programación. La gama de objetos es amplia y no he echado de menos ningún tipo de control. La biblioteca de símbolos predefinidos que trae listos para usar es bastante completa.

Con el Factory Talk View ME es necesario instalar también el RSLinx Enterprise, que nos servirá para gestionar las comunicaciones. En el árbol de proyecto tenemos un acceso a través de RSLinx Enterprise -> Communications Setup.

Aquí podemos configurar dos accesos (shortcuts) al PLC que queramos monitorizar: uno para tener acceso desde nuestro equipo directamente, para permitirnos probar la aplicación sin necesidad de enviarla al panel; el otro es el acceso desde el propio panel al PLC. También podemos especificar el fichero del proyecto del PLC para poder obtener los tags en modo off-line.

Hay que reconocer que todo lo que tiene que ver con comunicaciones, Rockwell lo tiene muy bien desarrollado, muy sencillo y sin complicaciones.

El proyecto puede ser totalmente simulado en nuestro PC, de hecho he llegado a estar conectado al PLC con la misma aplicación HMI trabajando simultáneamente desde mi PC y desde un PanelView Plus 700 y con resultados óptimos.

La parte que me ha decepcionado de este software es la gestión de tags. No existe un integración real con el proyecto del PLC, lo que implica que debemos actualizar la lista de tags cada vez que los modifiquemos en el PLC. Además no existen referencias cruzadas ni la posibilidad de saber donde se usa un tag. Para solventar este problema, a partir de la versión cinco, existe la aplicación Application Documenter que nos permitirá listados de tags en función de su uso y referencias cruzadas, pero que al ser una aplicación independiente, no permite interaccionar con el Factory Talk View ME. Por ejemplo, para saber donde se usa una variable, echo de menos poder ir a la lista de tags y selecionar una instrucción como "ir al punto de aplicación".

Para realizar la transferencia de la aplicación al PanelView debemos previamente generar el runtime. Una vez generado, hay que abrir la aplicación Transfer Utility, seleccionar el proyecto compilado, asignar la ruta al panel y transferir. Esta misma aplicación permite obtener los proyectos compilados que existan en el panel y realizar comparaciones.

Recientemente tuve que adaptar un PanelView 700 Plus para pasar de trabajar con un MicroLogix a un CompactLogix. En el panel había configurados más de mil tags y tenía la certeza de que muchos de ellos no se usaban. Además, por imperativos del cliente, tuve que usar la versión cuatro del software, para la que no existe el Application Documenter. Con lo que para saber donde se usaba un tag (o si no se usaba) tenía que ir buscándolo pantalla por pantalla y objeto por objeto. Al final la solución fue instalar la versión seis del software, importar la aplicación y con el Application Documenter sacar un listado de referencias cruzadas de tags. Luego volví a la versión cuatro y, listado en mano, hacer limpieza. Además, al borrar un tag no te avisa de si está en uso y si borras lo que no debes tampoco se puede deshacer. En entornos de desarrollo de otros fabricantes existe la opción de eliminar las variables no usadas automáticamente, de existir esta funcionalidad en la aplicación de Rockwell me hubiese ahorrado algunas horas de trabajo.

Y hasta aquí estas breves notas sobre mis primeras impresiones sobre Factory Talk View ME. Es una aplicación que cumple su función, y tiene puntos fuertes como la comunicación, el simulador o el poder recuperar aplicaciones desde el runtime. Sin embargo, en mi opinión, no resulta cómodo por la falta de integración de las aplicaciones auxiliares. La ausencia de referencias cruzadas en el propio programa y tener que andar buscando donde se usan los tags me resulta engorroso, sobre todo cuando tienes que modificar un panel complejo.

Como siempre agradeceré cualquier comentario, especialmente si puedes aportar experiencias con este software.

Probando los Add-Ons de Logix: control de cilindro neumático de doble efecto

2011-08-14T19:39:00.000+02:00

En esta entrada programé un control para cilindros neumáticos de doble efecto en Step7. Ahora, aprovechando la configuración que preparé en las dos entradas anteriores, voy a traducir el mismo código a Logix. Para ello voy a programar un Add-On, que es lo que viene a ser el equivalente a los bloques de función (FB) de Step7.

Voy a conservar la funcionalidad: los parámetros de entrada y salida se llaman igual en ambos sistemas y tienen exactamente la misma función. Lo único que cambia es el formato de los tiempos: en Step7 son en formato #Time y en Logix son DINT expresados en milisegundos.

Empezamos creando y configurando un proyecto en el RSLogix 5000. A continuación, para crear un Add-On vamos al árbol de proyecto y sobre la carpeta Add-On Instructions, con el botón derecho del ratón, pulsamos sobre New Add-On Instruction...

Aparecerá una ventana donde deberemos darle un nombre y, opcionalmente, una descripción, número de versión, etc.

Si hemos dejado marcada la casilla Open Definition, se abrirá la ventana Add-On Instruction Definition, donde podremos especificar los parámetros de entrada y salida, las variables (tags) locales y una descripción extendida a modo de ayuda.

En la siguiente captura muestro los parámetros de entrada / salida configurados:

Las variables locales al Add-On necesarias:

Y una descripción del funcionamiento del Add-On:

Respecto al código, no voy a detallarlo aquí pues quedaría demasiado largo. Es muy similar al código de Step7, adaptado, claro está, a las perculiaridades de Logix. Al final de esta entrada pondré un enlace al Add-On exportado a un fichero en formato L5X (XML).

Al crear el Add-On, en el árbol de proyecto bajo Data Types -> Add-On-Defined, veremos que aparece un nuevo tipo de dato con el mismo nombre que el Add-On.

En él figuran todos los parámetros de entrada (Input), salida (Output) y entrada/salida (InOut). En las variables del controlador (Controller Tags), por cada cilindro neumático que pretendamos controlar deberemos declarar una variable de este tipo. En este ejemplo he declarado un tag llamado CIL_DOSIFICADOR.

Para usar el Add-On en el programa la forma de proceder será:

Asignar valores a los parámetros de entrada del tag correspondiente al cilindro.
Hacer la llamada al Add-On con el tag correspondiente.
Leer los parámetros de salida en el mismo tag.

Por ejemplo, en la siguiente captura de pantalla asigno las entradas de origen y avance del cilindro, hago la llamada al Add-On y finalmente activo las salidas correspondientes al cilindro:

El resto de parámetros los he forzado estando On-Line con el SoftLogix.

En Step7 la asignación de parámetros de entrada/salida es más visual pues se hace en la misma llamada al FB. En Logix debe hacerse por separado. Personalmente prefiero la forma en que lo hace Step7, aunque la funcionalidad es la misma en ambos sistemas.

El código de mi Add-On lo puedes descargar aquí. Para incorporarlo a un proyecto debes ir al árbol de proyecto y sobre Add-On Instructions, con el botón derecho del ratón seleccionar Import Add-On Instruction...

Y hasta aquí mi primer contacto con un Add-On en Logix. Como siempre, cualquier comentario será bienvenido.

Preparando un proyecto para programar un SoftLogix

2011-08-09T13:08:00.000+02:00

En la entrada anterior preparé una máquina virtual con SoftLogix, ahora voy a configurar un proyecto en el RSLogix 5000, el cual tengo montado en otra máquina virtual. Así que en mi equipo anfitrión voy a ejecutar dos máquinas virtuales, de la siguiente manera:

Ejecuto el RSLogix 5000 y creo un nuevo proyecto...

Lo primero que me pide es el tipo de controlador, selecciono el 1789-L60 SoftLogix y su correspondiente número de revisión. Si no nos apareciese el número de revisión necesitaríamos instalar la versión correspondiente de RSLogix 5000. Asignamos un nombre, una descripción, el número de slot que ocupa y dónde vamos a guardar nuestro proyecto.

Al pulsar OK se creará. El siguiente paso será, en el árbol de proyecto, en I/O Configuration, añadir los módulos virtuales que hemos configurado en nuestro SoftLogix. El módulo del controlador ya está puesto, así que pulsamos sobre New Module...

En el slot número 2 estaba la tarjeta simuladora de 32 entradas y 32 salidas digitales. Para configurarla seleccionamos Other -> Generic 1789 Module

A continuación nos pedirá su configuración. Le asignamos un nombre, un comentario, el número de slot, y en Conections Parameters ponemos los valores que se ven en la siguiente captura de pantalla:

Estos valores están sacados del documento de Rockwell SoftLogix5800 Controller Starter Kit (PDF).

En la siguiente ventana podremos asignar el RPI (Requested Packet Interval), que he ajustado a 50 ms. El resto de opciones las dejo tal cual.

La tarjeta de E/S ya está lista, ahora vamos con la tarjeta Communications -> SoftLogix5800 EtherNet/IP

Le decimos la versión de SoftLogix...

Y en las propiedades le decimos el slot que ocupa, damos un nombre y una descripción, y la dirección IP de la máquina virtual donde está instalado el controlador SoftLogix.

El resto de propiedades las dejamos tal cual.

En este punto ya tenemos las tarjetas configuradas. Ahora voy a ajustar la ruta (path). Me aseguro que mi SoftLogix se está ejecutando correctamente en su máquina virtual y pulso sobre el botón Who Active del RSLogix 5000

Si todo va bien aparecerá bajo el driver Ethernet el controlador SoftLogix. Lo seleccionamos y pulsamos sobre Set Project Path

Y vamos a modo On-line. Como es la primera transferencia no hay ningún proyecto en el controlador y transferimos nuestro proyecto vacío.

En el árbol de proyecto, bajo Controller Tags podemos ver que se han creado automáticamente variables para acceder a la tarjeta de E/S digitales.

Las entradas digitales están en Local:2:I.Data[1] y las salidas digitales en Local:2:O.Data[0]. Para comprobar que todo funciona correctamente voy a hacer un sencillo programa donde voy a volcar las entradas en las salidas.

Voy a la máquina virtual del SoftLogix y, con el controlador en modo Run, en las propiedades de la tarjeta simuladora, en la pestaña I/O Data activo y desactivo entradas, comprobando que se reflejan en las salidas.

Y listo, ya tengo mi banco de pruebas listo y configurado para trastear y hacer pruebas de programación, sin la necesidad de tener físicamente un PLC.

Como siempre, cualquier comentario será bienvenido.

Virtualizando SoftLogix, el PLC software de Rockwell

2011-08-07T15:49:00.008+02:00

Entre su gama de controladores Rockwell dispone de un PLC software denominado SoftLogix, sería el equivalente al WinAC de Siemens o al TwinCAT de Beckhoff. Mi interés por él viene en que ya no dispongo del CompactLogix con el que realicé las dos entradas anteriores y montar un SoftLogix sobre una máquina virtual me permitirá realizar pruebas de programación y seguir aprendiendo.

Voy a partir de una máquina virtual en VirtualBox con una configuración como la que se puede ver la siguiente captura:

Le he asignado 256 MB de RAM, he deshabilitado el audio, el adaptador de red lo he puesto en modo puente (bridge) y, como no necesito el puerto serie, también lo he deshabilitado.

A continuación he instalado Windows 2000 SP4, el SoftLogix Revision 16 con su correspondiente licencia y el RSLinx Classic 2.54. La versión del SoftLogix es importante ya que debe coincidir con la versión de RSLogix 5000 que usemos para programarlo. Al ejecutar la máquina virtual tendrá el siguiente aspecto:

También he configurado la dirección IP de mi máquina virtual, necesaria para comunicar el SoftLogix a través de Ethernet.

Ya estoy preparado para configurar mi SoftLogix. Lo que se ve en pantalla es un chasis virtual donde ir colocando tarjetas. El slot 0 está reservado al RSLinx, encargado de las comunicaciones. Para empezar voy a situar en el slot 1 el controlador. Para ello selcciono el slot 1 y voy al menú Slot -> Create Module...

A continuación nos pedirá que seleccionemos el tipo de módulo a insertar. Podemos elegir entre el controlador SoftLogix, tarjetas PCI para convertir un PC en un verdadero PLC con periferia distribuida en redes DeviceNet o Control Net, control de ejes, un simulador de 32 entradas / 32 salidas digitales y un módulo adaptador para usar un puerto Ethernet del PC.

En el slot 1 voy a situar el controlador por lo que selecciono el módulo 1789-L60 SoftLogix5860 Controller.

Lo siguiente será configurar sus propiedades, en la primera ventana con las opciones por defecto es suficiente.

Ahora aumento a 50 ms el tiempo de permanencia (dwell time) de la tarea continua y le digo que no voy a utilizar el puerto serie.

El controlador ya está insertado en el chasis virtual. En el slot 2 voy a poner una tarjeta virtual de 32 entradas / 32 salidas digitales.

En su configuración simplemente le daremos un nombre.

El último módulo que voy a configurar es el EtherNet/IP SoftLogix5800 en el slot 3. Este módulo me dará conectividad a través del puerto Ethernet virtual y me permitirá programar el SoftLogix desde otro PC o máquina virtual.

En su configuración apenas deberemos darle un nombre, ya que tomará los datos de red de la configuración IP del sistema operativo.

Ya he finalizado la configuración de los módulos, mi chasis virtual tiene el siguiente aspecto:

El software de programación RSLogix 5000 lo tengo instalado en otra máquina virtual y voy a comprobar que puedo acceder desde él a mi SoftLogix. Para ello ejecuto simultáneamente a la máquina virtual del SoftLogix la máquina virtual desde la que voy a programar, y ejecuto en esta última el RSLinx. Con la herramienta RSWho exploro la red Ethernet (previamente deberá estar instalado su driver en el RSLinx) y aparecerá mi SoftLogix con toda la configuración en sus respectivos slots:

Aquí doy por finalizada la configuración de mi máquina virtual con SoftLogix. En la siguiente entrada hablaré de como configurar el RSLogix 5000 para poder programar.

NOTA: Para propósitos de prueba y aprendizaje, Rockwell tiene disponible el software RSLogix Emulate, que seguramente sería más apropiado para mis propósitos, aunque no lo tengo disponible. En la fantástica web PLCDev hay un tutorial de configuración (en inglés).

Cualquier comentario será bienvenido.

Pasos previos a programar un CompactLogix L32E

2011-06-21T11:20:00.001+02:00

Teniendo ya comunicación con mi CompactLogix L32E, es hora de ejecutar el RSLogix 5000, que es el software de programación de Rockwell necesario para esta gama de autómatas.

Voy a usar la versión 13 en inglés, algo antigua, pero es la que me exigen. Me consta que existe en español. Al ejecutarlo tiene el siguiente aspecto:

Lo primero que hay que hacer es introducir el PLC, para ello vamos a File -> New... y aparecerá la ventana New Controller.

Elegimos el modelo de PLC, su revisión, asignamos un nombre y descripción al proyecto y especificamos dónde queremos almacenarlo. Aquí es muy importante el número de revisión, pues debe coincidir con la versión del RSLogix 5000 que tengamos. Es posible tener varias versiones del RSLogix 5000 instaladas simultáneamente. Como mi proyecto debe ser compatible con la versión 13 pues es la que selecciono.

Al pulsar OK aparecerá el árbol de proyecto con nuestro PLC. El siguiente paso va a ser añadir las tarjetas que lo acompañan. Me explicaba un técnico de Rockwell que en las últimas versiones del RSLogix 5000, si estás conectado, detecta automáticamente los componentes. En este caso debo añadirlos yo a mano. Para ello vamos al árbol del proyecto I/O Configuration -> CompactBusLocal y con el botón derecho del ratón pulsamos en New Module...

En este caso simplemente dispongo de una tarjeta de 16 salidas digitales, la selecciono.

Le asigno un nombre y acepto.

Si nos fijamos en Controller Tags se han creado automáticamente las variables para acceder a la tarjeta, tanto a las salidas propiamente dichas como a variables de estado.

Ahora voy a conectarme con el PLC, así que voy al menú Communications -> Who Active

Aparecerá la ventana Who Active con la conexión que previamente configuré en el RSLinx. Busco en el árbol mi PLC y lo selecciono.

De fábrica, el PLC viene con un firmware versión 1. Pero su versión de firmware debe coincidir con la versión de RSLogix 5000, así que toca actualizar el firmware, pulsando el botón Update Firmware...

Seleccionaremos la versión de firmware correcta y pulsaremos Update

A continuación aparecerá alguna ventana de aviso y nos mostrará al progreso de la actualización (tarda unos minutos). Advertir que, una vez iniciado el proceso, no debemos desconectar el PLC ni interrumpir la transferencia o correremos el riesgo de tener que enviar nuestro autómata al servicio técnico.

En mi caso, al finalizar el proceso de actualización tuve que volver a asignarle la dirección IP al PLC con la aplicación BOOTP/DHCP Server, supongo que por no tenerla configurada como estática.

Ya tenemos el PLC listo para transferirle un programa. Para ello vamos de nuevo a la herramienta Who Active del RSLogix 5000, nos situamos sobre el PLC y pulsamos sobre Set Project Path

En la barra Path ya aparece la ruta al PLC para poder transferir el proyecto.

Ya podemos ir a modo Online

La primera vez nos dirá que no hay ningún programa en el PLC, pulsaremos a Download y ya tendremos control sobre el PLC.

En este punto tenemos ya un programa vacío cargado en el PLC, listo para empezar a trastear.

Para rematar esta entrada una nota sobre la llave en el frontal del PLC, que sirve para cambiar entre los modos RUN, REMOTE y PROGRAMACIÓN. En el modo RUN el programa se ajecutará sin posibilidad de modificación exterior, aunque podremos observarlo. En modo PROGRAMACIÓN no se ejecuta el programa y podemos acceder libremente al programa. En el modo REMOTE tenemos acceso al programa y podemos ajecutarlo o no a voluntad. Si pasamos la llave de RUN a REMOTE el programa seguirá ejecutándose, cosa que no sucede al pasar de PROGRAMACIÓN a REMOTE.

Cualquier comentario será bienvenido.

Comunicando con un PLC CompactLogix L32E

2011-06-07T15:59:00.007+02:00

Recientemente he estado unas horas con un técnico de Rockwell en las que he recibido unas pinceladas de cómo empezar a enfrentarme a la familia de PLC CompactLogix. Voy a ir redactando una serie de entradas con mis avances y, aunque todo lo que escriba lo habré probado previamente, es posible que cometa errores e imprecisiones. Si ves algo que está mal o conoces alguna forma más simple o más correcta de hacer algo de lo que aquí describo, te agradeceré un comentario.

El PLC en concreto con el que voy a hacer pruebas es un CompactLogix L32E, acompañado de una fuente de alimentación y una tarjeta de 16 salidas digitales, más la correspondiente tapa de final de bus. El PLC conectado y funcionando sobre mi mesa tiene el siguiente aspecto:

Como características más destacadas decir que tiene 750 kb de memoria de usuario, una ranura para Compact Flash, un puerto de comunicaciones serie y un puerto ethernet. Puede expandirse con un máximo de 16 módulos. Tienes las características detalladas en la página de Rockwell (PDF).

Como el cliente para el que está destinado el PLC tiene estandarizadas versiones de software antiguas, voy a utilizar una máquina virtual con Windows 2000 donde voy a instalar todos los programas: RSLogix 5000 (programación de PLC), RS View ME (programaciónd de HMI), RSNetWorx (configuración de redes) y RSLinx (gestión de comunicaciones). El técnico de Rockwell tenía todo esto montado sobre VMWare. Aprovechando que tengo varias máquinas con Virtual Box, he preparado una máquina virtual con esta última, funcionando también correctamente. Para tener comunicación a través del puerto ethernet simplemente hay que tener la precaución de poner el puerto ethernet virtual en modo puente (bridge) y asignar en el Windows 2000 una dirección IP y máscara coherentes con nuestra red (la primera vez tuve que reiniciar tanto mi máquina virtual como mi ordenador para que funcionase).

El PLC CompactLogix L32E viene de fábrica con IP dinámica. Para poder realizar una comunicación con el RSLogix 5000 tiene que tener asignada una IP fija. Para asignarle esta IP fija podemos conectarnos a través del puerto serie o, como haré yo, através del puerto ethernet. Para esta última opción Rockwell suministra la aplicación BOOTP/DHCP Server, que busca en la red dispositivos para poder direccionarlos. En menos de un minuto, si el PLC está conectado correctamente a nuestra red, el BOOTP/DHCP Server delatará su presencia mostrándo su dirección MAC.

Si hacemos doble clic sobre el dispositivo detectado podremos asignarle una dirección IP (que tiene que ser coherente con la configuración de nuestra red).

Al cabo de unos segundos deberá ya aparecer nuestro PLC con la dirección IP asignada.

En mi caso me conecto al PLC a través de un switch, pero me podría conectar directamente con un cable ethernet cruzado.

Cerramos el BOOTP/DHCP Server pues ya no lo necesitaremos más. Ahora vamos a abrir el RSLinx. Lo primero que deberemos hacer es configurar los controladores (drivers) para comunicarnos con el PLC. Para ello vamos Communications -> Configure drivers...

En el menú desplegable seleccionamos EtherNet/IP Driver.

Al pulsar sobre Add New... nos pedirá un nombre para el controlador.

Al aceptar nos preguntará por qué adaptador de red se hará la comunicación, en mi caso dejo seleccionado Windows Default.

Aceptando nuevamente deberemos tener nuestro controlador funcionando (Running).

Cerramos la ventana de configuración de controladores y vamos a ver si tenemos comunicación con el PLC. Para ello vamos al menú Communications -> RSWho

Y vemos que figura el controlador AB_ETHIP-1 que acabamos de configurar.

Pulsamos sobre el controlador y veremos como empieza a parpadear su icono, señal de que está buscando dispositivos. En breve deberá aparecer nuestro PLC y todos los puertos y tarjetas que tengamos conectados.

Ahora pulsamos el botón derecho del ratón sobre el puerto ethernet del PLC y vamos a Module Configuration.

Y en la pestaña Port Configuration nos aseguramos que esté marcada la opción Static, para que no pierda la dirección IP cuando apaguemos el PLC, y además podremos modificar la IP y la máscara de red.

Y listo, ya tenemos nuestro PLC configurado y comunicando para empezar a trastear con él.

Hasta aquí esta primera toma de contacto. Cualquier comentario será bienvenido.

Probando un panel táctil Pro-face GP4107G1D

2011-05-18T12:24:00.003+02:00

Recientemente, para una pequeña máquina, hemos estado buscando un panel táctil de reducidas dimensiones, económico, sencillo de programar, que tuviese soporte técnico cercano y que fuese fiable, y, por lo que he podido probar hasta ahora, el Pro-face GP4107G1D cumple nuestras espectativas.

Nuestra máquina va a ser controlada por un PLC S7 312 de Siemens, por lo que la comunicación con el HMI deberá realizarse por MPI. En mis pruebas el funcionamiento de la comunicación ha sido impecable, funcionando todo a la primera.

A pesar de que este panel resulta muy económico, ofrece caracerísticas solo presentes en paneles de gama más alta. Quizá la que más me ha llamado la atención es la posibilidad de programar scrips, lo que le otorga gran versatilidad.

Como características más destacadas dispone de una pantalla de 3,4" y 16 niveles de gris, con iluminación programable en color verde, naranja o rojo. El aspecto que tiene mi unidad es el siguiente:

Vista por detrás dispone de dos puertos USB:

El puerto más pequeño se usa para programarlo con un cable USB standard (en la imagen se ve el cable de mi cámara de fotos). En el otro puerto se puede conectar una memoria USB standard. En el lateral está el cable de alimentación a 24VDC y el conector MPI de comunicación.

Para programarlo se usa el software GP-Pro EX, que es con el que se programan los paneles Pro-face, aunque para esta gama básica no es necesario comprar licencia alguna. Mi distribuidor me facilitó la versión demo, que es plenamente funcional para esta gama de paneles. En la página de Pro-face, previo registro, es posible descargárselo.

NOTA: Aunque la versión que tengo del GP-Pro EX está en inglés, me consta que existe en español.

El programa tiene este aspecto:

En la imagen ya tengo seleccionado mi panel. Configurar la comunicación con el PLC es muy sencillo. En System Settings -> Peripheral List -> Device/PLC tengo todos los parámetros necesarios. En mi caso, tal y como venía la configuración por defecto fue suficiente (ya que es coincidente con la configuración que trae por defecto el PLC):

En el proyecto de Step7 no hay que configurar nada, no hay que especificarle que tiene comunicación con un panel, es suficiente con hacer la configuración en el GX-Pro EX.

No usar un panel de Siemens tiene la desventaja de que la programación no está integrada con el proyecto de Step7. Sin embargo, para paliar esta situación tenemos una herramienta para importar los símbolos del proyecto de Step7. Con el menú Common Settings -> Symbol Variable accedemos a la edición de los simbólicos de variables y pulsamos sobre Utility -> Import -> Step7 Project File:

Ahora se abrirá la herramiento para importar simbólicos desde un proyecto de Step7; debemos buscar nuestro proyecto, y seleccionar los símbolos que queramos incluir:

Ya tenemos nuestras variables definidas en el GP-Pro EX, listas para trabajar. Si más adelante modificamos el simbólico en el proyecto de Step7, deberemos volver a importarlas.

Ya estamos listos para pasar a la fase de diseño, para ello pulsamos sobre el botón Edit:

Dentro de las limitaciones técnicas del panel, puedo decir que, a pesar de ser la primera vez que toco este software, la programación me ha resultado muy sencilla. Viene con gran cantidad de controles, dibujos y formas, algunos, en mi opinión, demasiado ambiciosos. Puedes importar tus propias imágenes (eso sí, se verán en 16 tonos de gris y una resolución máxima de 200x80 puntos). Por ejempo, un botón para camiar de pantalla se configuraría así:

Si tienes alguna experiencia previa en la programación de paneles de operador, este te parecerá pan comido.

Además, se puede probar el panel en el completo simulador que trae:

Transferir el programa del panel también es muy sencillo, pulsando el botón Transfer Project aparecerá el Transfer Tool:

Si tienes el panel conectado por USB con el ordenador, transferir es inmediato. Pulsando Send Project se hará la transmisión en un instante.

Una de las cosas que quería hacer era cambiar a voluntad el color de retroiluminación del panel desde el PLC. Parar ello, según la ayuda, hay que escribir un 2 en la variable interna H_BackLightColor para cambiar a color rojo (otros valores son: un 1 representa el fondo verde, el 3 el naranja y el 0 el color que le hayamos asignado por defecto). Pero no podemos escribir directamente desde el PLC en variables internas del panel, la solución pasa por hacer un script. Para ello vamos al menú Common Settings -> Global D-Script y se abrirá la lista de scripts. Pulsamos sobre Create y se abrirá la ventana de programación de scripts. Lo que voy a hacer es, en función de la variable booleana PANEL_FONDO_ROJO que activaré/desactivaré desde el PLC, lanzar un script que en función del estado de esta variable escriba el valor correspondiente en H_BackLightColor.

Todo lo que hay que hacer es especificar como condición de disparo (trigger) un cambio en la variable del PLC. En el código con un simple condicional, si la variable está a uno escribimos un 2; en caso contrario un 0.

Para introducir variables en el script lo más cómodo es usar la herramienta Input address:

Este es un ejemplo muy sencillo, pero el uso de scrips tiene muchas aplicaciones, por ejemplo, según me explicó el comercial, se puede programar cualquier protocolo de comunicación serie que queramos, con lo que esta gama de paneles son virtualmente conectables a cualquier aparato que disponga de puerto serie.

Otra cosa que debemos tener en cuenta es que por defecto hay varias direcciones de memoria que apuntan al DB1 y que debemos cambiar para evitar sobreescritura de datos, si lo usamos en nuestro PLC. La primera es el área de sistema:

El área de sistema es interesante ya que nos permite, por ejemplo, saber el número de pantalla en la que estamos o cambiar desde el PLC a la pantalla que nos interese. Yo la he volcado al DB40, incluido el Watchdog, aunque este no se use.

El otro sitio donde se sobreescribía el DB1 era en Common Settings -> Text Table. Pulsamos sobre Change Language y, en mi caso, desactivé Enable Language Change Feature, ya que mi panel va estar en español solamente.

Y hasta aquí estas notas sobre el panel Pro-Face GP4107G1D. Como conclusión decir que me ha gustado bastante. Es muy económico y muy fácil de programar. Si has programado algún panel con anterioridad, te harás con él enseguida. Como puntos a favor destacar que no hay que pagar ninguna licencia por el software de programación, el cable de programación es un USB standard y las comunicaciones han resultado impecables. Como pegas, con el precio que tiene, no le voy a poner ninguna. Ahora me falta comprobar que tal resiste el trato diario en planta.

Como siempre, cualquier comentario será bienvenido.

Empezando con Rockwell: un vistazo desde Step7

2011-03-29T21:58:00.001+02:00

En vista de que pronto tendré que enfrentarme a un PLC Rockwell he estado poniéndome al día. Hace tiempo que no programo uno, el último fue un SLC 500 hace ya unos añitos. Ahora me toca uno de la serie CompactLogix, más avanzado. Aún no dispongo del software de programación RSLogix5000 para trastear con él, pero en la web de Rockwell hay abundante literatura para ir echando un vistazo.

Para alguien que, como yo, se siente cómodo programando en Step7, Rockwell tiene el documento perfecto: “Guía para conversión de aplicaciones Simatic S7 a Logix5000” cuya lectura recomiendo (está en español). Esta entrada es un pequeño resumen de este documento con las características que más me han llamado la atención.

Una de las cosas que más me ha gustado es que trae tablas de equivalencia entre material de Rockwell y Siemens, aquí un extracto para los PLC S7-300:

Siemens S7-300	Rockwell
313C	L23 Serial
314C-DP	L23 EtherNet/IP, L31
315-2 DP	L32E, L32C
317-2 DP	L35CR, L35E
317T-2 DP	L43, L45
319-3 PN/DP	L45, L61

(en amarillo están marcados los que me interesan).

En el documento hay más tablas con más PLC y tarjetas.

Hablando ya de las características de la programación, en el RSLogix5000 se estructura el programa en tareas (Task), que equivalen a los bloques de organización (OB) de Siemens:

Tarea continua de organización → OB de ciclo del programa
Tarea periódica → OB de interrupción cíclica
Tarea de evento → OB de interrupción hardware

Las tareas las ejecuta el sistema operativo (al igual que los OB en Step7). Una tarea puede contener uno o más programas. Cada programa contiene una sección de datos y una o más rutinas de código. A cada tarea se le puede asignar una prioridad. La tarea continua, si está presente, siempre tiene la prioridad más baja.

Un controlador Logix acepta una única tarea continua, pero no es obligatorio incluirla: se puede ejecutar todo el programa con tareas periódicas y/o tareas de evento.

La diferencia entre los conceptos programa y rutina de Logix no tiene un equivalente en Step7.

Si queremos encontrar en Siemens una estructuración de programa similar tenemos que irnos al Simotion Scout, cuyo Execution system es muy similar al Controller Organizer de Logix.

Otra diferencia fundamental es el modo de organizar la memoria. Los datos en Step7 tienen direcciones absolutas en áreas seleccionables de memoria. En Logix los datos se organizan en bases de datos de tags: no existe direccionamiento absoluto.

En Logix se pueden definir variables (tags) globales en la base de datos bajo el control del controlador y puede accederse a ellas mediante rutinas en cualquier parte del programa. Sin embargo, si definimos los tags bajo el control del programa solo pueden utilizar en rutinas en dicho programa.

En Logix, a una variable se le pueden asignar diferentes nombres mediante alias. Uno de los usos más evidentes es asignar nombres descriptivos a los tags que por defecto se asignan a las entradas y salidas.

En Logix existen cuatro lenguajes de programación:

Diagrama de lógica de escalera (LD) – comparable con el KOP (diagrama de contactos) de Step7
Texto estructurado (ST) – Equivalente al SCL de Step7
Diagrama de bloques de funciones (FBD) – Equivalente al CFC de Step7
Diagrama de función secuencial (SFC) – Comparable al hiGraph de Step7

No hay un lenguaje equivalente al AWL (STL) de Step7.

Una rutina en lenguaje LD se divide en rungs (peldaños), equivalente a los segmentos de Step7. Algunos programadores los llaman renglones, imagino por traducir mal rungs.

Si es necesario ejecutar funciones con paso de parámetros (lo que serían los FB en Step7), en Logix existen las instrucciones Add-on con área de datos privados.

Comparación entre las instrucciones Add-On y los FB:

Ambas se pueden llamar como funciones desde cualquier lugar del programa.
Ambas contienen un área de datos propios de datos estáticos (este área en el Add-on es totalmente privado).
En una instrucción Add-on no existe área de datos temporales.
Ambas tienen tres tipos de parámetros: entrada (paso por valor), salida (paso por valor) y entrada-salida (paso por referencia). El parámetro de paso por referencia es una gran ventaja puesto que permite que se pasen eficientemente grandes estructuras de datos.

Con la instrucción Add-On se puede configurar una rutina previa al scan para que se ejecute cuando el controlador cambia del modo de programación al modo run, o se activa en el modo run. Bajo estas condiciones, la rutina previa al scan se ejecutará una vez y normalmente se usa para inicializar los datos. Es algo similar a lo que hace el OB100 en Step7.

En Step7, al iniciar el ciclo de scan se lee la imagen de proceso de entradas, se ejecuta el programa y se vuelcan las salidas, de forma que durante un mismo ciclo de scan sus valores permancen constantes. Sin embargo en los sistemas Logix, las entradas y salidas se actualizan asíncronamente, con lo cual, si se necesita que las entradas/salidas se mantengan sin variación durante la ejecución del programa, deberá ser tenido en cuenta por el programador.

Internamente todos los tipos de datos enteros se tratan en 32 bits. Si usamos uno de 8 o 16 será convertido a 32, con lo que siempre es más eficiente usar DINT que INT o SINT (estos tipos de datos se proporcionan por compatibilidad con la norma IEC61131-3).

En Logix no hay punteros. Las matrices realizan la misma función que los punteros, pero son más simples y seguras.

Hasta aquí este resumen, seguramente me dejo conceptos importantes, pero ya los iré completando por el camino.

Cualquier comentario, como siempre, será bienvenido.

Accediendo a un PLC Siemens desde Visual Basic: LIBNODAVE

2011-03-15T10:14:00.006+01:00

Libnodave es una biblioteca libre de funciones para comunicar con PLC Siemens, utilizando adaptadores MPI/PPI o Ethernet. Está disponible para descarga directa aquí y viene con el código fuente, programas de prueba, bibliotecas para Linux, Windows (32 bits), .NET y ejemplos. Para programar podemos elegir una gran variedad de lenguajes y entornos: C, C++, C#, Delphi, Pascal, Perl, Visual Basic y Visual Basic for Aplications.

Para probarlo voy a partir de la configuración que tengo hecha de las dos entradas anteriores en las que comunicaba un S5-95U con un 315-2DP por Profibus. Ahora lo que pretendo es conectarme desde mi ordenador al S7-300 para visualizar, en una aplicación en Visual Basic, las lecturas que hago de la periferia integrada del S5.

Para comunicar mi PC con el 315-2DP tengo un adaptador serie/MPI de Siemens referencia 6ES7901-2BF00-0AA0. No viene en la lista de adaptadores probados en la página de Libnodave pero ha funcionado bien, incluso a través de un adaptador USB/serie de la marca Prolific.

Para clarificar, en el siguiente esquema represento el conexionado que tengo entre los diferentes elementos:

Lo que voy a hacer en este proyecto es una aplicación en Visual Basic 2010 Express a la que voy a incorporar la biblioteca Libnodave para leer y escribir en el bloque de datos donde interactúo con la periferia del S5-95U: lo único que hará mi aplicación es leer y escribir en el DB10 del 315-2DP.

En los programas de Step5 y Step7 no tengo que modificar nada, el acceso es transparente para los PLC; la aplicación en el PC funcionará como HMI.

Lo primero es crear un nuevo proyecto en el entorno de Visual Basic. Una vez creado vamos a sus propiedades:

En la pestaña Referencias vamos a agregar una referencia nueva:

Vamos al directorio donde hayamos descomprimido Libnodave y dentro del subdirectorio Dot.NET seleccionamos la biblioteca libnodave.net.dll:

Al aceptar, en la lista de referencias ya debería aparecer libnodave.net:

Con esto ya tenemos acceso a las funciones para programar nuestra comunicación. Sin embargo, si ejecutamos la aplicación nos saldrá un error de que falta una biblioteca DLL. La solución la encontré en el foro de libnodave. Resulta que la biblioteca que hemos incorporado al proyecto es un "wrapper", o sea, una adaptación de la biblioteca de Win32 a .NET. Así que es necesario copiar manualmente la biblioteca libnodave.dll que se encuentra en el subdirectorio win en el mismo directorio donde esté el ejecutable de nuestro programa, esto es en los subdirectorios \bin\Debug y \bin\Release del directorio del proyecto en Visual Basic.

Realizado este paso ya estamos listos para iniciar la programación. Con la biblioteca Libnodave vienen un par de ejemplos en Visual Basic, en los que me he basado. He creado la clase NDA_LND para gestionar la conexión con las funciones Conectar y Desconectar y un par de funciones para leer y escribir en un DB. El código de la clase es el siguiente:

Public Class NDA_LND
Dim daveSerie As libnodave.daveOSserialType
Dim daveInter As libnodave.daveInterface
Dim daveConex As libnodave.daveConnection

Public BufferLectura(1000) As Byte
Public BufferEscritura(1000) As Byte

Public Conectado As Boolean = False
Public Mensaje As String

Public Function Conectar(Optional ByVal localMPI As Integer = 0, _
Optional ByVal plcMPI As Integer = 2, _
Optional ByVal portSerial As String = "COM1", _
Optional ByVal baud As String = "19200") As Boolean
If Conectado Then
Mensaje = "Conexión abortada, ya existe una conexión."
Conectar = False
Exit Function
End If

Dim Respuesta As Integer

Mensaje = "Abriendo una conexión serie..."
daveSerie.rfd = libnodave.setPort(portSerial, baud, AscW("O"))
daveSerie.wfd = daveSerie.rfd

If daveSerie.rfd > 0 Then
Mensaje = "Conexión serie OK, creando interface..."

daveInter = New libnodave.daveInterface(daveSerie, "My Interface 1", _
localMPI, _
libnodave.daveProtoMPI2, _
libnodave.daveSpeed187k)
daveInter.setTimeout(1000000) 'Make this longer if you have a very long response time

Mensaje = "Inicializando adaptador..."
Respuesta = daveInter.initAdapter()

If Respuesta = 0 Then
Mensaje = "Inicialización del adaptador OK, creando conexión MPI..."
daveConex = New libnodave.daveConnection(daveInter, plcMPI, 0, 0) 'Rack and slot don't matter in case of MPI
Respuesta = daveConex.connectPLC()
If Respuesta = 0 Then
Mensaje = "Conexión MPI correcta, lista para operar."
Conectado = True
Else
daveInter.disconnectAdapter()
libnodave.closePort(daveSerie.rfd)
Mensaje = "Error al abrir la conexión MPI [" & _
libnodave.daveStrerror(Respuesta) & "]"
Conectado = False
End If

Else
libnodave.closePort(daveSerie.rfd)
Mensaje = "Error al inicializar el adaptador [" & _
Respuesta & "] " & libnodave.daveStrerror(Respuesta)
Conectado = False
End If

Else
Mensaje = "Error al abrir el puerto serie " & portSerial
Conectado = False
End If

Conectar = Conectado

End Function

Public Function Desconectar() As Boolean
If Conectado Then
daveConex.disconnectPLC()
daveInter.disconnectAdapter()
libnodave.closePort(daveSerie.rfd)
Conectado = False
Mensaje = "Conexión correctamente terminada."
Desconectar = True
Else
Mensaje = "No existe conexión activa."
Desconectar = False
End If
End Function

Public Function LeerBytesDB(ByVal NumDB As Integer, _
ByVal Dir As Integer, _
ByVal NumBytes As Integer) As Boolean

Dim Respuesta As Integer

Respuesta = daveConex.readBytes(libnodave.daveDB, NumDB, Dir, NumBytes, BufferLectura)

If Respuesta = 0 Then
Mensaje = "Leídos " & NumBytes & " bytes a partir de la dirección " & _
Dir & " en el DB " & NumDB
LeerBytesDB = True
Else
Mensaje = "Error al leer " & NumBytes & " bytes a partir de la dirección " & _
Dir & " en el DB " & NumDB
LeerBytesDB = False
End If

End Function

Public Function EscribirBytesDB(ByVal NumDB As Integer, _
ByVal Dir As Integer, _
ByVal NumBytes As Integer) As Boolean
Dim Respuesta As Integer

Respuesta = daveConex.writeBytes(libnodave.daveDB, NumDB, Dir, NumBytes, BufferEscritura)

If Respuesta = 0 Then
Mensaje = "Escritos " & NumBytes & " bytes a partir de la dirección " & _
Dir & " en el DB " & NumDB
EscribirBytesDB = True
Else
Mensaje = "Error al escribir " & NumBytes & " bytes a partir de la dirección " & _
Dir & " en el DB " & NumDB
EscribirBytesDB = False
End If

End Function

End Class

Aunque no está comentado, el código creo que es fácil de entender. Con la función Conectar abrimos el puerto serie, inicializamos el adaptador y la conexión MPI, dejándola lista para operar. Comprobando el booleano que devuelve podemos saber si la operación se completó correctamente. Se le pasan por parámetros la dirección MPI del adaptador (por lo general la 0), la dirección MPI del PLC, el puerto serie por el cual comunicará y la velocidad de conexión:

S7MPI = New NDA_LND
S7MPI.Conectar(LocalMPI, PLCMPI, "COM1", "19200")

Los datos se leen con la función LeerBytesDB y se depositan en BufferLectura; por ejemplo, para leer las entradas analógicas se haría así:

S7MPI.LeerBytesDB(10, 26, 16) 'DB10, 16 bytes a partir de la dirección 26
'Entradas analógicas
EW40.Value = libnodave.getU16from(S7MPI.BufferLectura, 0)
EW42.Value = libnodave.getU16from(S7MPI.BufferLectura, 2)
EW44.Value = libnodave.getU16from(S7MPI.BufferLectura, 4)
EW46.Value = libnodave.getU16from(S7MPI.BufferLectura, 6)
EW48.Value = libnodave.getU16from(S7MPI.BufferLectura, 8)
EW50.Value = libnodave.getU16from(S7MPI.BufferLectura, 10)
EW52.Value = libnodave.getU16from(S7MPI.BufferLectura, 12)
EW54.Value = libnodave.getU16from(S7MPI.BufferLectura, 14)

y los que necesitemos escribir en BufferEscritura transfiriéndolo con la función EscribirBytesDB especificando el número de DB, la dirección de byte dentro del DB y el número de bytes a escribir:

S7MPI.BufferEscritura(8) = Valor16bits \ 256 'División entera
S7MPI.BufferEscritura(9) = Valor16bits Mod 256
S7MPI.EscribirBytesDB(10, 42, 10) 'DB10, 10 bytes a partir de la dirección 42

Una vez terminadas la operaciones debemos Desconectar, si no se quedará el puerto serie ocupado.

S7MPI.Desconectar()

El proyecto completo en Visual Basic lo tienes aquí. Si lo ejecutas tendrá el siguiente aspecto:

Con Libnodave viene documentación que deberás leer para adaptar el código a otros adaptadores. En mi caso, al inicializar el adaptador tuve que cambiar el protocolo a daveProtoMPI2 para que funcionase.

Aunque en mi ejemplo solo leo y escribo de bloques de datos se puede acceder a más áreas de memoria, habría que completar las funciones de la clase. Si alguien completa el código me gustaría echarle un vistazo.

La velocidad de comunicación no es muy buena, el adaptador serie/MPI se comunica con el PC a 19200 baudios, lo cual constituye un cuello de botella. Libnodave también permite la comunicación Ethernet, si tengo ocasión la probaré, el incremento de velocidad tiene que ser notable.

Actualización: en esta entrada pruebo Libnodave a través de ethernet.

En resumen, el autor de Libnodave ha hecho un trabajo fantástico, en las pruebas ha tenido un comportamiento impecable. Sin embargo no debemos olvidar que no tiene el soporte de una empresa detrás y que si lo usamos es por nuestra cuenta y riesgo.

Cualquier comentario será bienvenido.

Reutilizando un PLC Simatic S5-95U como cabecera Profibus (parte 2ª)

2011-03-08T12:31:00.003+01:00

En la primera parte dejamos al S5-95U preparado para funcionar como cabecera Profibus, ahora vamos a la parte de Step7.

Preparamos un proyecto de Step7 con un PLC 315-2DP y le asignamos una red Profibus con una velocidad de 1,5 Mbit/s (la máxima que soporta el S5-95U). En el catálogo buscamos "S5-95U" y lo arrastramos sobre la red Profibus, asignándole una dirección libre, en mi caso la 7.

Seleccionamos el componente que acabamos de insertar y copiamos el Módulo universal sobre los slots 1 y 2.

En las propiedades de cada módulo universal pulsamos sobre el botón Entrada directa... y donde pone Byte identificador (decimal): introducimos el primer código decimal con el que configuramos la comunicación Profibus en el DB1 del S5-95U, en mi caso 223.

Con ese código ya interpreta qué cantidad y tipo de datos se van a comunicar, tan solo debemos decirle la dirección de entradas que ocuparán los datos recibidos, en mi caso a partir de la 256.

Realizamos el proceso análogo para las salidas en el otro módulo universal, poniendo, para mi ejemplo, el valor 239.

Y como dirección de salida pongo la 256:

Y listo, guardamos y compilamos la configuración, y la transferimos al PLC. Si todo va bien y pasamos el S5-95U de Stop a Run podremos ver que el piloto rojo BF se apaga, lo que significa que ambos PLC se entienden.

Ya tenemos la configuración lista. Ya solo nos queda hacer un programa en el 315-2DP para probar el funcionamiento. Lo que he hecho es agrupar todos los datos necesarios (entradas y salidas digitales, analógicas y contadores) en un DB, y con un FC hacer la interpretación de los datos.

NOTA: para quien tenga interés, al final de esta entrada están los enlaces a los proyectos se Step5 y Step7 con todo el código.

Leer las entradas del S5-95U es tan sencillo como copiar zonas de la entrada en periferia hacia mi DB:

L PEW 256 // ENTRADAS DIGITALES
T DB10.DBW 0

L PEW 258 // ENTRADAS DE ALARMA Y BYTE DE DIAGNOSIS
T DB10.DBW 2

L PED 260 // CONTADORES RÁPIDOS
T DB10.DBD 4

L PED 264 // ENTRADAS ANALÓGICAS
T DB10.DBD 8
L PED 268
T DB10.DBD 12
L PED 272
T DB10.DBD 16
L PED 276
T DB10.DBD 20

Leo los bits que me indican si existe desbordamiento en las entradas digitales, ejemplo para la primera entrada:

// LECTURA DE LOS BITS DE DESBORDAMIENTO
U DB10.DBX 8.0
= "COM_S5".EA_OV[0]

Y proceso el valor de la entrada analógica:

// PROCESADO DE VALORES
L "COM_S5".EA_RAW[0]
L 2#11111111111000
UW
SRW 3
T "COM_S5".EA[0]

Transfiero el estado de las salidas digitales:

L DB10.DBW 42
T PAW 256

Preparo y transfiero el valor a sacar por la salida analógica:

L "COM_S5".AA
SLW 4
L 2#111111111110000
UW
T PAW 258

Y finalmente transfiero las órdenes y valores para resetear y cambiar los valores de preselección de los contadores rápidos:

L DB10.DBW 46
T PAW 260 // ORDENES DE RESETEAR CONTADORES

L DB10.DBD 48
T PAD 262 // VALORES DE PRESELECCIÓN DE CONTADORES

Viendo el DB10 y sus comentarios debería ser sencillo saber donde leer y escribir para tener acceso a todas las entradas y salidas. Las entradas y salidas digitales son triviales. El valor de las entradas analógicas se debe leer en la tabla (array) EA, donde se deposita su lectura ya procesada, y se debe interpretar un valor de 2046 como 10 V. Para los contadores rápidos A y B hay sendas señales de reset (CONT_A_RESET y CONT_B_RESET), lo que hacen es poner los contadores a cero y asignar nuevos valores de preselección (CONT_A_PRES y CONT_B_PRES). La lectura de los contadores la tenemos en CONTADOR_A y CONTADOR_B. Finalmente, en la salida analógica (AA) deberemos escribir un valor entre 0 y 1024, significando este último valor 10 V o 20 mA.

El programa para el S5-95U lo puedes bajar aquí y para el 315-2DP aquí.

Cualquier comentario será bienvenido.

Reutilizando un PLC Simatic S5-95U como cabecera Profibus (parte 1ª)

2011-03-07T11:49:00.004+01:00

Ya que la anterior entrada he retomado el contacto con mi PLC S5-95U, voy a recuperar una vieja idea: reutilizarlo como cabecera Profibus. La idea es aprovechar su gran conectividad (entradas y salidas digitales, contadores rápidos y señales analógicas) desde un PLC más moderno, por ejemplo desde un PLC 315-2DP.

Lo que voy a hacer en esta primera parte es configurar el S5-95U para acceder a toda su periferia integrada, parametrizarlo como esclavo Profibus y hacer una sencilla programación para transmitir y recibir datos. En una segunda parte haré la integración del S5-95U en una red Profibus y el tratamiento de los datos en un S7-300.

NOTA: Aquí hice una introducción a Step5 que quedó incompleta. Esta entrada podría considerarse su continuación.

Para realizar esta entrada me he basado en este documento de Siemens: Conectar un S5-95U-DP Esclavo a un maestro CPU315-2DP.

El primer pasó será configurar el S5-95U para tener acceso a todas las posibilidades que ofrece su periferia integrada (no dispongo de periferia externa). Para ello debemos configurar su DB1, que es un bloque de datos especial que nos permite parametrizar las funciones del PLC.

Para editarlo lo recomendable es realizar un borrado total del PLC para tener un DB1 funcional ajustado con valores por defecto, y a partir de ahí adaptarlo a nuestras necesidades.

Para decirle que vamos a usar las 8 entradas analógicas modificamos en el identificador de bloque OBA su número a 8: AI 8.

El bloque OBI sirve para parametrizar las entradas de alarma, pero no me interesa, ya que las voy a utilizar como entradas digitales ordinarias, así que no es necesario modificar nada aquí.

En el bloque OBC configuraremos las entradas de contador rápido. CAP 999 para el contador A con incremento por flanco positivo y valor de preselección (valor máximo del contador) 999 - este valor se puede modificar posteriormente. De forma idéntica el contador B CBP 999.

Como no voy a usar temporizadores, en el bloque SDP voy a poner el parámetro T a cero, para que no se evalúen y ganar algo de tiempo ciclo.

Finalmente me queda por modificar el bloque DPS que es el que configura la conexión Profibus. Para activarlo debemos sustituir los caracteres # al principio y al final del bloque por espacios. El primer valor es TLN y le asigno la dirección Profibus del esclavo, en mi caso la 7. El segundo valor DPAE es un par de números que son la codificación en decimal del byte de configuración, y sirven para especificar qué cantidad de datos se van a transmitir. Para construir estos números tenemos que ir a la documentación de Siemens y leemos:

Estructura del byte de configuración:

Bit 7 Bit 6 Bit 5 y Bit 4 Bit 3, 2, 1 y 0

128 64 32 16 8 4 2 1

Consistencia Formato Long Datos de envío o recepción Longitud de datos

0: Byte o Word
1: Longitud completa 0: Estructura en byte
1: Estructura en Word 00: prohibido
01: Datos de envío al maestro
10: Datos de recepción del maestro
11: Datos de envío y recepción 0000: 1 Byte o Word
0001: 2 Byte o Word
0001: 2 Byte o Word
0010: 3 Byte o Word
0011: 4 Byte o Word
0100: 8 Byte o Word
1111: 16 Byte o Word

Ejemplo:
16 WORD de entrada digitales con consistencia como datos de envío al maestro 11011111 = 223 decimal
16 WORD de salidas digitales con consistencia como datos de recepción desde el maestro 11101111 = 239 decimal

Precisamente el valor que pone de ejemplo es el máximo de datos a transmitir o recibir, y son los valores que voy a usar. Es importante anotar estos valores, ya que nos harán falta cuando hagamos la configuración de la red Profibus en Step7.

Con todo lo visto hasta ahora, el DB1 debería presentar el siguiente aspecto:

Para que los parámetros del DB1 hagan efecto debemos pasar el PLC de Stop a Run. Si el PLC se queda en Stop es que hemos cometido algún error; debemos ser estrictos al escribir el DB, sobre todo respetando los espacios. En el manual se especifica un procedimiento para detectar donde nos hemos equivocado mediante diagnosis en el PLC, pero me ha parecido un poco farragoso. Con un poco de cuidado no deberíamos tener problemas.

Con el PLC configurado nos queda hacer un sencillo programa para transmitir el estado de las entradas y activar las salidas de la periferia integrada. Para ello he creado el FB1 con el siguiente código,

Activo las salidas digitales y la salida analógica según me llegan por Profibus:

NAME: FB1

L PW 128
T AW 32

L PW 130
T AW 40

Voy a usar dos bits para poner a cero las entradas de contador y a la vez modificar el valor de preselección. Si recibo la orden de poner a cero se copia el valor de preselección (que también se recibe por Profibus) sobre el valor del contador.

L PY 132
T MB 0
UN M 0.0
SPB =M000
L PW 134
T PW 36

M000: UN M 0.1
SPB =M001
L PW 136
T PW 38

A continuación se transmiten de forma correlativa en formato WORD las entradas digitales, las entradas de alarma, el byte de diagnosis, los contadores rápidos y las entradas analógicas.

M001: L EW 32
T PW 128

L EW 34
T PW 130

L EW 36
T PW 132

L EW 38
T PW 134

L EW 40
T PW 136

L EW 42
T PW 138

L EW 44
T PW 140

L EW 46
T PW 142

L EW 48
T PW 144

L EW 50
T PW 146

L EW 52
T PW 148

L EW 54
T PW 150

Finalmente reseteamos los bits que forman el byte de diagnóstico.

R E 35.0
R E 35.1
R E 35.2
R E 35.3
R E 35.4
R E 35.5
R E 35.6
R E 35.7

BE

Llamamos en el OB1 al FB1 y listo, ya tenemos el S5-95U listo para nuestro propósito.

He transmitido por Profibus el byte de diagnosis ya que resulta interesante. El S5-95U tiene un pila de respaldo. Si esta pila se agota, en cuanto apaguemos el PLC perderemos el programa, así que no estará de más avisar que esto puede suceder al maestro Profibus. En la documentación podemos ver cómo es este byte de diagnósis:

En el S5-95U vienen preprogramados dos FB (FB250 y FB251) para procesar señales analógicas. Ya que cada llamada a uno de ellos conlleva un retardo de 2,4 ms en el tiempo ciclo, he preferido transmitir el valor leído de las señales analógicas en "crudo" y procesarlas en Step7.

Las entradas de alarma, si se configuran en el DB1, activan el OB3 (OB de alarma). Como no le he encontrado utilidad, no las he configurado y se usan como cuatro entradas digitales ordinarias.

Para las entradas de contador rápido debemos tener en cuenta que se ponen a cero con cada paso de Stop a Run. Los contadores se incrementan con cada flanco positivo que reciban; si necesitásemos flancos negativos habría que modificar el DB1. Al llegar al valor de preselección regresan a cero. Para ponerlos a cero desde programa deberemos sobre escribirlos con un valor (16 bits sin signo), que quedará configurado como nuevo valor de preselección. Existe la posibilidad, modificando el DB1, de agruparlos como un único contador de 32 bits.

En la segunda parte me meteré con la configuración en Step7.

Probando "S5/S7 for Windows" para programar en Step5

2011-03-02T14:23:00.008+01:00

Usar el editor de Siemens en MS-DOS de Step5 es un dolor de cabeza, al menos para mí, ya que tengo un contacto muy esporádico con él y cada vez es como empezar de nuevo. Reconozco que si dominas el entorno en MS-DOS y memorizas los comandos necesarios la edición es muy rápida, pero si tienes que trabajar con él cada dos o tres años para hacer alguna pequeña adaptación... pues es una lata.

En esta entrada empecé a crear una guía como recordatorio rápido para el entorno en MS-DOS pero aún no me he animado a continuarla, más que nada porque no he vuelto a tocar ningún S5.

Pero recientemente ha pasado por mis manos un portátil que tiene instalado el software "S5/S7 for Windows" de la empresa IBHsoftec y he aprovechado para echarle un vistazo.

Así que conecto el cable serie de programación de Step5 entre mi S5-95U y el portátil, enciendo el PLC y ejecuto el programa, que tiene este aspecto:

En la parte inferior izquierda hay dos pestañas Offline / Online, pulso en la de Online y aparecen todas las opciones de comunicación:

Como tengo mi PLC conectado al puerto serie COM1 hago doble clic sobre él y enseguida aparece. No he tenido que configurar nada en el puerto, la detección es impecable. Pulso el botón derecho del ratón sobre el PLC y aparece un menú de opciones, donde puedo pasar el PLC a Start o Stop, diagnosticarlo, hacer un borrado total, etc.

Voy a ver el diagnóstico, pulso sobre Module state... y aparece el Status de la CPU. En mi caso me avisa de un fallo en la batería (que está completamente descargada).

En la barra de botones hay un botón para ver los bloques de programa que están en el PLC, lo pulso.

Y aparecen los bloques que tiene por defecto (al no tener batería, el programa anterior ha desaparecido). Voy a crear un proyecto nuevo, para ello vuelvo a la pestaña Online y sobre la carpeta donde quiera guardarlo pulso el botón derecho y selecciono New Step5 project...

Y aparece el proyecto con un montón de opciones para movernos por él y encontrar rápidamente cualquier operando. Tiene pinta de ser muy útil en proyectos grandes y farragosos.

Ahora voy al menú View y pulso sobre Offline - block list para ver los bloques guardados en el proyecto:

Como acabamos de crearlo no hay ninguno, así que con el botón derecho del ratón pulsamos sobre New block... y creo el necesario OB1.

Lo abrimos y escribimos un segmento de prueba:

Lo transferimos al PLC pulsando sobre el botón Transfer Block to the PLC.

Y pulsamos el icono de las "gafitas" para ponernos online.

La edición del DB1 es tan sencilla como ir a los bloques online, abrir el DB1, editarlo con la comodidad que el entorno Windows ofrece y transferirlo de vuelta al PLC.

Este software me ha gustado mucho. Si conoces un poco Step5 te manejarás con soltura enseguida ya que es muy intuitivo. No he tenido la oportunidad (ni creo que la tenga) de trabajar a fondo en un proyecto con él, pero sin duda es muy recomendable. Solo el hecho de pasar de un entorno MS-DOS a uno Windows es, para mí, un alivio.

Dependiendo de la licencia que compres puedes tener acceso a programar Step5, Step7 o ambos, los precios los tienes en esta tarifa (pdf). Si quieres probarlo también tienes una versión demo disponible. La he instalado en mi portátil y tiene limitaciones, no permite editar bloques mayores de 100 bytes y solo puedes trabajar con un simulador interno de PLC.

Sin embargo tener esta versión demo instalada resulta muy útil. Nos permite explorar los programas en Step5 con mucha comodidad y para imprimirlos viene fenomenal.

También está disponible una guía para empezar a usar el programa, que puedes descargar de aquí.

Como conclusión puedo asegurar que es un software del que me gustaría disponer, pero la escasa cantidad de PLC Step5 que programo no justifican su compra (y menos en los tiempos que corren). Para alguien que tenga que lidiar con ellos frecuentemente es una opción muy a tener en cuenta.

Actualización: Me han preguntado en un comentario si es posible realizar la conexión a través de un adaptador USB-serie, y, aprovechando que tengo por aquí uno de la marca Prolific, lo he probado. En la página web de IBHsoftec dice que se pueden usar estos adaptadores y en el documento "S5 for Windows Getting Started" explica como configurarlo, pero yo no he conseguido hacerlo funcionar, ni siquiera me aparece el puerto en el programa. El que no funcione puede deberse a que no estoy trabajando con la última versión del S5 for Windows (lo probé en la 6.2.2 y la última es la 6.6.9), a que este modelo de adaptador no sea compatible (estaría bien una lista de adaptadores compatibles) o a que simplemente he hecho algo mal. Si alguien ha hecho funcionar uno de estos adaptadores que avise.

Como siempre agradeceré cualquier comentario.

Comunicación Profibus entre un atornillador Rexroth CS351 y un PLC Siemens S7-300 (parte 2ª y última)

2011-02-10T21:27:00.007+01:00

En la entrada anterior dejé el atornillador configurado, ahora vamos a introducirlo en la red Profibus de Step7.

EL primer paso será abrir la herramienta de configuración hardware de Step7 para instalar el archivo GSD que generamos en la entrada anterior.

Lo seleccionamos y lo instalamos. Es posible que nos pida cerrar previamente los proyectos que tengamos abiertos.

Aquí es recomendable recordar el nombre del componente (en mi caso IMpdp fuer KE/SE/CS) para luego poder buscarlo en el catálogo.

Abrimos la configuración hardware del proyecto, donde ya tengo insertado un PLC 313C-2DP y una red Profibus, y en el catálogo buscamos nuestro atornillador.

Lo arrastramos sobre la red Profibus y nos pedirá una dirección.

Seleccionamos el atornillador, ya conectado a la red Profibus, y arrastramos desde el catálogo al interior del módulo la configuración del mapeado de entradas y salidas. Podemos asignar las direcciones de entradas y salidas que más nos convengan.

Y listo, ya tenemos nuestro atornillador configurado. Pulsamos en Guardar y compilar, cerramos la aplicación de configuración hardware y ya estamos listos para programar.

Yo he cambiado las direcciones de los dos bytes de entradas y los dos de salidas a la dirección 100, y para poder diagnosticarlos los he puesto en una tabla de variables:

Para leer los datos de par de apriete y ángulo girado debemos ir al manual titulado "Project planning manual", en el apartado 7.4.4 titulado "Formats of the results output" tenemos una tabla con el formato de cada dato. Por ejemplo, en el caso del par es un INT32. Un poco más abajo aparece un ejemplo de cómo debemos leer ese dato, lo que, a efectos prácticos, significa que debo cambiar el orden de todos los bytes.

Para saber donde leer el dato tenemos que tomar la dirección base de entradas de datos que hayamos configurado (en mi caso la 128) e ir sumando los tamaños de los datos que se transmiten.

Por ejemplo, según vemos en la imagen anterior el valor de par ocupa cuatro bytes a partir del quinto byte. Como la dirección base es 128 podemos leer el par en la dirección PED133 de la zona de entradas de periferia.

Para invertir el orden de todos los bytes he creado el FC13:

El código es bastante sencillo:

FUNCTION FC13 : VOID
TITLE =INVERTIR LOS BYTES EN UN DWORD
//DEVUELVE UN DINT
VERSION : 0.1

VAR_INPUT
DATO : DWORD ;
END_VAR
VAR_OUTPUT
DATO_INV : DINT ;
END_VAR
VAR_TEMP
AUX_DWORD : DWORD ;
AUX_DINT : DINT ;
END_VAR
BEGIN
NETWORK
TITLE =http://notasdeautomatizacion.blogspot.com

L #DATO;
T #AUX_DWORD;

L LB 0;
T LB 7;

L LB 1;
T LB 6;

L LB 2;
T LB 5;

L LB 3;
T LB 4;

L #AUX_DINT;
T #DATO_INV;
END_FUNCTION

Con esto ya tenemos el valor del par de apriete, en formato entero. En mi caso, las dos últimas cifras representan decimales; el número de decimales depende del par de apriete nominal de nuestra herramienta de atornillado, consultad en el manual.

De forma parecida obtendremos el resto de valores que hayamos configurado en la comunicación.

Ahora ya solo queda programar una lógica de activación de las señales de entrada y salida para controlar el atornillador desde el PLC y esto es algo que viene muy bien explicado en el manual, en el apartado 6 "Control signals", con diagramas temporales de activación para cada operación que necesitemos realizar, aunque también es cierto que simplemente por el nombre de cada señal ya se intuye como debemos tratarlas.

Y hasta aquí estas notas sobre el atornillador Rexroth CS351. Como conclusiones puedo decir que ha sido sencillo de configurar y la comunicación no ha ofrecido problemas. No me he metido en programar ciclos de atornillado con el software BS350 (lo hacía el cliente) pero por lo que pude ver es muy sencillo e intuitivo.

Como siempre, cualquier comentario será bienvenido.

Comunicación Profibus entre un atornillador Rexroth CS351 y un PLC Siemens S7-300 (parte 1ª)

2011-01-29T19:52:00.005+01:00

Recientemente me han pedido comunicar un atornillador automático CS351 de Rexroth con un PLC Siemens de la serie S7-300. La idea es seleccionar una receta a través de HMI con la secuencia de tornillos a apretar y que el PLC vaya activando el número de programa correspondiente en el atornillador, comprobando los resultados e indicando en un panel de visualización los resultados y pasos a seguir por el operario. El PLC también gestionará una sencilla maniobra neumática. En esta entrada mostraré las notas que he tomado para configurar la comunicación Profibus atornillador-PLC.

El aspecto de la unidad de control del atornillador es este (cutre-foto con mi móvil):

La unidad de atornillado con la que tengo que trabajar no viene con puerto Profibus, así que tengo que instalar una tarjeta de comunicación IMpdp.

Para configurar el atornillador necesitaremos el software de Rexroth BS350. No está disponible para descarga y deberemos ponernos en contacto con nuestro distribuidor para obtenerlo. Existen distintas versiones del programa y deberemos utilizar la que se corresponda con el firmware que lleve nuestro atornillador; en mi caso tengo el firmware V2.20, así que instalaré el BS350 V2.20, que tiene este aspecto:

El software está en español y bien traducido, lo cual siempre es de agradecer.

Para conectarnos al atornillador, para realizar la configuración, tenemos dos opciones. Una es a través de un cable ethernet cruzado y la otra es a través del puerto USB en el frontal de la unidad de control. Yo me decanté por la segunda opción. Un cable normal de impresora funcionará perfectamente. Al instalar el controlador USB es recomendable tener el atornillador cerca, para conectarlo cuando nos lo pida y completar la instalación. Si sigues las instrucciones paso a paso no tendrás problemas.

El primer paso será seleccionar cómo nos conectaremos, para ello vamos a PC->Interfaz

Y seleccionamos el modo de conexión, en mi caso USB.

Ahora iniciaremos la sesión pulsando sobre el botón de la llave.

Nos pedirá usuario y contraseña:

La unidad de atornillado ya ha estado trabajando y ya tiene una configuración programas de atornillado creados, así que, para evitar problemas, lo mejor es hacer una copia de seguridad. Para ello vamos al menú Datos->Copia de seguridad...

Seleccionamos el canal de atornillado (en mi caso solo tengo un atornillador, con lo que selecciono el primero) y guardo la copia de seguridad.

Como elegí guardar también el firmware, tarda un ratillo. Al guardar una copia de seguridad tenemos toda la configuración en un fichero, que nos servirá para restaurar en caso de desastre. Si queremos ver la configuración y no estamos conectados al atornillador, la copia de seguridad no nos sirve. Para eso tenemos la opción Archivo->Guardar célula de atornillado.

Seleccionamos lo que queramos guardar.

Y listo, ya tenemos los datos previos a salvo.

Vamos a configurar la tarjeta IMpdp Profibus, para ello pulsamos sobre Configurar el canal de atornillado

Se abrirá la ventana donde saldrá la nueva tarjeta, en color rojo ya que no la hemos configurado.

Nota: si no ves la tarjeta IMpdp haz doble clic sobre el icono de una carpeta bajo CS.

Hacemos doble clic sobre la tarjeta y se abrirá la ventana de configuración.

Seleccionamos IMpdp y aparecerán sus parámetros.

Aquí deberemos especificar la dirección Profibus (3), la cantidad entradas/salidas (16 estradas y 16 salidas), y la cantidad de datos recibidos (12 bytes) y enviados (32 bytes). Esta ha sido mi configuración, pero hay que adaptarla a cada caso. Con el botón Crear archivo GSD se generará un archivo GSD con el que deberemos configurar la red Profibus.

Enviamos la configuración recién creada con el botón Enviar

Y desaparecerá el color rojo, con lo que nuestra configuración es correcta.

El siguiente paso será especificar el contenido de los datos que se transmitirán en Profibus, para ello vamos al menú Sistema->Tabla de asignación PLC SE/CS

Para lo que pretendo hacer la configuración por defecto es suficiente con una salvedad: la señal de habilitación la asigno a la entrada 1.0, así desde el PLC podré habilitar el atornillador a voluntad. El resto de entradas me permitirán cambiar el número de programa de atornillado y acusar fallos. Para saber qué hace cada señal podemos dejar el puntero del ratón sobre cada una y saldrá una breve descripción. Con las salidas podremos obtener el número de programa seleccionado, saber si hay algún error, si el atornillador está listo, etc.

Configuradas las entradas y salidas, vamos a especificar qué variables vamos a cominicar con el atornillador, para ello vamos al menú Sistema->Datos bus de campo CS

Seleccionamos las variables que necesitamos, en mi caso son el número de programa, par mínimo, par de apriete, par máximo, ángulo mínimo, ángulo de giro, ángulo máximo, código de error y tipo de error. En total 28 bytes, que cabe en los 32 que configuré.

Ya solo nos queda pulsar el botón enviar y ya tenemos el atornillador configurado.

Por supuesto, en la completa documentación que viene con el atornillador (en formato PDF) está todo esto explicado en mayor profundidad.

Como esta entrada se está alargando demasiado, dejaré para una próxima la configuración de la red Profibus con el software de Siemens y algún ejemplo de programación.

Como siempre, cualquier comentario será bienvenido.

Visualización del tiempo ciclo con Step7 + WinCC Flexible

2010-12-02T17:20:00.005+01:00

Una de las cosas que, en mi opinión, no debe faltar en una máquina que disponga de panel de visualización, es una pantalla dedicada al tiempo ciclo. Es curioso ver como en muchas inspecciones de máquinas, el ingeniero de métodos y tiempos, cronómetro en mano, comprueba que nuestra máquina dé cadencia. Si en vez de eso, le damos una tabla de tiempos tomados de forma precisa por el PLC, le simplificaremos la labor y seguramente lo agradecerá... y ya sabemos que el ingeniero de métodos y tiempos es un tipo con el que conviene llevarse bien ;)

Nota: entiéndase tiempo de ciclo como el tiempo que transcurre desde que obtenemos una pieza terminada y la siguiente.

Para ello voy a suponer que mi máquina está comandada por un PLC S7-300 y como HMI tengo un panel táctil de Siemens como el MP277, y sobre esta base voy a programar lo que sería una visualización sencilla de los últimos diez tiempos de ciclo.

En este ejemplo el PLC calculará el tiempo ciclo y mediante una variable booleana le indicará al panel que recoja el dato. Luego el panel leerá el dato y lo introducirá en una tabla de valores, los visualizará por orden de recepción (primero el más reciente) y marcará con color verde el menor y con color amarillo el mayor. La visualización quedará tal como se muestra a continuación:

Empecemos con la programación en el PLC. He programado un bloque de función (FB) donde calculo el tiempo ciclo. Como entradas tiene una señal de habilitación HABILIT, que es necesario activar para que se ponga a controlar (p. ej. solo interesa el tiempo ciclo en modo automático). A continuación debemos introducir una señal CONTROL que se active una única vez al terminar cada ciclo de máquina. Podría ser, por ejemplo, un detector de pieza en salida, pero yo prefiero poner el estado final de la lógica de funcionamiento. El tiempo ciclo será el intervalo entre dos flancos positivos consecutivos en dicha señal. La entrada T_LIMITE sirve para descartar tiempos ciclo muy altos (p. ej. si el operario salió a tomar el bocadillo), solo se considerarán los tiempos de ciclo inferiores. Si queremos visualizar todos, hay que poner aquí un tiempo suficientemente alto.

En las salidas tenemos un booleano PULSO que, cada vez que hay un nuevo tiempo de ciclo, da un pulso de dos segundos, que nos servirá para decirle al panel que recoja un nuevo dato. Finalmente en la salida T_CICLO tendremos el tiempo de ciclo medido en milisegundos (formato TIME). Nótese que el tiempo de ciclo mínimo a medir será de dos segundos (más un pequeño margen de seguridad), en máquinas más rápidas este código no sirve.

Una llamada al FB descrito puede ser como esta:

Nota: los tiempos se gestionan internamente, el FB no consume temporizadores Simatic.

Está programado en diagrama de contactos (KOP) y para incorporarlo a un proyecto de Step7 copia el siguiente código a un fichero fuente y compílalo:

FUNCTION_BLOCK FB13
TITLE =CONTROL TIEMPO CICLO
//http://notasdeautomatizacion.blogspot.com
VERSION : 0.1

VAR_INPUT
HABILIT : BOOL ; //HABILITACIÓN
CONTROL : BOOL ; //SEÑAL DE CONTROL DE TIEMPO CICLO
T_LIMITE : TIME ; //TIEMPO MÁXIMO PARA CONSIDERAR UN TIEMPO CICLO
END_VAR
VAR_OUTPUT
PULSO : BOOL ; //PULSO PARA INDICAR UN NUEVO TIEMPO CICLO
T_CICLO : TIME ; //TIEMPO CICLO (EN MILISEGUNDOS)
END_VAR
VAR
PRIMER_CTRL : BOOL ;
FP_HABILIT : BOOL ;
FP_CTRL : BOOL ;
T_INI_CICLO : TIME ;
T_AUX_PULSO : TIME ;
END_VAR
VAR_TEMP
TIME_TICKS : TIME ;
END_VAR
BEGIN
NETWORK
TITLE =LECTURA DEL TIEMPO DEL SISTEMA
//EN MILISEGUNDOS TRASCURRIDOS DESDE EL ÚLTIMO ARRANQUE DEL PLC
CALL "TIME_TCK" (
RET_VAL := #TIME_TICKS);
NOP 0;
NETWORK
TITLE =PRIMER CONTROL
//CUANDO SE HABILITA NO SE TIENE EN CUENTA LA PRIMERA SEÑAL DE CONTROL
//(EL PRIMER TIEMPO CICLO SE DA CON LA SEGUNDA SEÑAL DE CONTROL)
U #HABILIT;
FP #FP_HABILIT;
S #PRIMER_CTRL;
NETWORK
TITLE =SEÑAL DE CONTROL DE TIEMPO CICLO
//EL TIEMPO CICLO SE CALCULA ENTRE DOS FLANCOS POSITIVOS DE LA SEÑAL DE CONTROL
//CUANDO HAY UN NUEVO TIEMPO CICLO SE DA UN PULSO DE DOS SEGUNDOS
U #CONTROL;
FP #FP_CTRL;
U #HABILIT;
= L 4.0;
U L 4.0;
UN #PRIMER_CTRL;
= L 4.1;
U L 4.1;
SPBNB _001;
L #TIME_TICKS;
L #T_INI_CICLO;
-D ;
T #T_CICLO;
_001: NOP 0;
U L 4.1;
SPBNB _002;
L #TIME_TICKS;
T #T_INI_CICLO;
_002: NOP 0;
U L 4.1;
U( ;
L #T_CICLO;
L #T_LIMITE;
<=D ;
) ;
= L 4.2;
U L 4.2;
SPBNB _003;
L #TIME_TICKS;
L T#2S;
+D ;
T #T_AUX_PULSO;
_003: NOP 0;
U L 4.2;
BLD 102;
S #PULSO;
U L 4.0;
U #PRIMER_CTRL;
= L 4.1;
U L 4.1;
SPBNB _004;
L #TIME_TICKS;
T #T_INI_CICLO;
_004: NOP 0;
U L 4.1;
BLD 102;
R #PRIMER_CTRL;
NETWORK
TITLE =PULSO DE LECTURA DE TIEMPO CICLO
//RESET AL PASAR DOS SEGUNDOS DESDE SU ACTIVACIÓN
U #PULSO;
U( ;
L #TIME_TICKS;
L #T_AUX_PULSO;
>=D ;
) ;
R #PULSO;
END_FUNCTION_BLOCK

Nota: si una vez compilado te falla la conversión de AWL a KOP, desactiva en las opciones del editor de Step7, en la pestaña FUP/KOP, la casilla Comprobar los tipos de operandos.

Hasta aquí la parte de programación en el PLC, ahora vamos al WinCC Flexible.

Lo primero será enlazar la variable del PLC que nos indicará que hay un nuevo tiempo ciclo:

Importante: en esta variable deberemos cambiar el modo de adquisición a Ciclo continuo, para así ir obteniendo los tiempos incluso sin estar en la pantalla donde se utiliza.

También debemos enlazar la variable donde hay que leer el tiempo de ciclo:

Ahora crearemos dos tablas de variables (internas, sin conexión con el PLC) con la cantidad de tiempos de ciclo que queramos mostrar, en mi caso diez. La primera, TIEMPOS, servirá para almacenar los tiempos de ciclo ordenados, en formato entero (16 bits) y la segunda, MARCAR, voy a usarla para marcar los colores de la representación de los tiempos de ciclo mayor y menor.

Creadas las variables necesarias, pasamos a la programación del script. Agregamos un script nuevo al proyecto (lo he llamado TIEMPO_CICLO) y copiamos el siguiente código:

'SE LLAMARÁ AL SCRIPT CADA VEZ QUE CAMBIE "PULSO CICLO"
'PERO SOLO SE AÑADIRÁ UN TIEMPO SI ES TRUE
If SmartTags("PULSO CICLO") = True Then

Const NUM_TIEMPOS = 10 'NÚMERO DE TIEMPOS QUE SE ALMACENAN

Dim INDICE 'ÍNDICE PARA RECORRER LOS TIEMPOS
Dim INDICE_CORTO 'ÍNDICE DEL TIEMPO MÁS CORTO
Dim INDICE_LARGO 'ÍNDICE DEL TIEMPO MÁS LARGO

'HACEMOS SITIO EN LA TABLA DE TIEMPOS
'SE DESCARTA EL ÚLTIMO TIEMPO Y SE MUEVEN HACIA ABAJO
For INDICE = NUM_TIEMPOS - 1 To 1 Step -1
SmartTags("TIEMPOS")(INDICE) = SmartTags("TIEMPOS")(INDICE -1)
Next

'SE ALMACENA EL TIEMPO CICLO ACTUAL COMO EL MÁS RECIENTE
'EN DÉCIMAS DE SEGUNDO
SmartTags("TIEMPOS")(0) = SmartTags("T_CICLO") / 100

'BÚSQUEDA DE LOS TIEMPO MÁS CORTO Y MÁS LARGO
INDICE_CORTO = 0
INDICE_LARGO = 0
For INDICE = 1 To NUM_TIEMPOS - 1
If SmartTags("TIEMPOS")(INDICE) < SmartTags("TIEMPOS")(INDICE_CORTO) And _
SmartTags("TIEMPOS")(INDICE) > 0 Then
INDICE_CORTO = INDICE
End If

If SmartTags("TIEMPOS")(INDICE) > SmartTags("TIEMPOS")(INDICE_LARGO) Then
INDICE_LARGO = INDICE
End If
Next

'SI LOS ÍNDICE CORTO Y LARGO SON IGUALES NO SE HACE NADA
If INDICE_CORTO <> INDICE_LARGO Then

For INDICE = 0 To NUM_TIEMPOS - 1
SmartTags("MARCAR")(INDICE) = 0 'FONDO BLANCO

If INDICE = INDICE_LARGO Then
SmartTags("MARCAR")(INDICE) = 2 'FONDO AMARILLO
End If

If INDICE = INDICE_CORTO Then
SmartTags("MARCAR")(INDICE) = 1 'FONDO VERDE
End If
Next

End If

End If

En el script debemos adaptar la constante NUM_TIEMPOS al número de tiempos de ciclo que deseemos mostrar. Básicamente, lo que hace es ir incorporando, de manera ordenada, los tiempos de ciclo descartando el más antiguo. Como expresar el tiempo en milisegundos puede ser excesivo, se divide entre cien para mostrarlo en décimas de segundo. Luego se repasa la tabla de tiempos buscando el más breve y el más largo, asignando en el índice correspondiente de la tabla MARCAR un uno si es el más breve o un dos si es el más largo (el resto se mantienen a cero).

El siguiente paso es saber cuándo ejecutar el script, y para ello tenemos la variable PULSO CICLO (o el nombre que le hayas asignado). Vamos a sus eventos y en Cambio de valor asignamos nuestro script, así logramos que se ejecute cada vez que se detecte un pulso.

Ahora solo nos queda preparar nuestra pantalla de tiempos de ciclo, con diez (o los que hayamos programado) campos de salida:

Para que cambien los colores de fondo de la representación de los tiempos más largo y más corto, debemos activar para cada campo de salida Animaciones -> Apariencia y asignar como variable MARCAR con su índice correspondiente.

Y con esto ya tendríamos la visualización de tiempos de ciclo terminada.

Me quedo con la sensación de que esta aplicación es más larga de explicar que de implementar. Es evidente que hay muchas maneras de mejorarla: se pueden guardar los tiempos en un histórico, representarlos gráficamente y lo que se nos ocurra (y nos permita el WinCC Flexible). Si alguien implementa alguna mejora o se le ocurre alguna manera más eficiente de hacer esto mismo, estaría encantado de echarle un vistazo.

Bit 7	Bit 6	Bit 5 y Bit 4	Bit 3, 2, 1 y 0
128	64	32 16	8 4 2 1
Consistencia	Formato Long	Datos de envío o recepción	Longitud de datos
0: Byte o Word 1: Longitud completa	0: Estructura en byte 1: Estructura en Word	00: prohibido 01: Datos de envío al maestro 10: Datos de recepción del maestro 11: Datos de envío y recepción	0000: 1 Byte o Word 0001: 2 Byte o Word 0001: 2 Byte o Word 0010: 3 Byte o Word 0011: 4 Byte o Word 0100: 8 Byte o Word 1111: 16 Byte o Word