El tema ha sido movido a VirtualHMI - Terminal HMI Remoto.

http://foro.slicetex.com/index.php?topic=317.0

Ejemplo para utilizar el cliente ModBus RTU del PLC para leer dos módulos PD3060-PT100 (hasta 12 sensores PT100).



La finalidad de este ejemplo es mostrar como conectar dos módulos PD3060-PT100 para leer mayor cantidad de sensores PT100, pero el ejemplo se puede extender a mayor cantidad de módulos siguiendo el mismo concepto con pequeñas modificaciones.

La cantidad de módulos a conectar esta limitado por la capacidad de bus RS-485, normalmente 32.

Para conectar dos o más módulos, primero debe asegurarse que todos tengan diferentes direcciones ModBus, la misma puede cambiarse utilizando el siguiente ejemplo Pawn:

PT100_PD3060_Pawn4.zip

Primero conecte un solo módulo al bus RS-485 y cambie la dirección ModBus RTU.

Nota: Si compró los módulos con diferentes direcciones asignadas por Slicetex, el paso de cambio de dirección no es necesario.

Cuando tenga todos los módulos con diferentes direcciones, conecte los módulos en la red RS-485 como muestra el siguiente diagrama:

PD3060-PT100-PLC_DIAGRAM_TWO_MODULES.pdf

Finalmente cargue el ejemplo para dos módulos al PLC:

PT100_PD3060_Pawn3.zip

La visualización de temperaturas de los sensores PT100 conectados se muestra en Virtual-HMI.

¡Que tengan buenas mediciones!   

IMPORTANTE:

Antes de conectar dos módulos, asegúrese de entender el funcionamiento de uno solo, para ello lea la hoja de datos.

¡Buenas tardes foro de Slicetex!... en esta oportunidad, subimos un ejemplo de gran utilidad.

DESCRIPCIÓN

El actual ejemplo permite acceder desde un programa diseñado en Microsoft Visual C# a la memoria EEPROM del PLC y leer sus bytes de datos.

Posteriormente desde el programa en Visual C# puede procesar la información recibida y almacenarla en un archivo, realizar tablas, gráficos en excel, etc.

Este programa requiere un PLC con memoria EEPROM.

FUNCIONAMIENTO

El programa del PLC  llamado "EepromServerPLC" tiene un funcionamiento simple.

A grandes rasgos, activa el evento @OnUdpRx(), el cual será llamado cuando un paquete de datos UDP / IP sea recibido por Ethernet. Es decir, actúa como un servidor esperando una petición a la cual responde.

Cuando el paquete de datos es recibido se lo procesa y se comprueba que sea del tipo RX_TYPE_READ_EEPROM (ver constantes en globals.inc del proyecto PLC). Esto significa, que el primer byte del paquete recibido tenga el valor 0xB0.

Una vez identificado el tipo de paquete, obtiene en otros bytes dentro del mismo paquete la dirección inicial a leer de EEPROM (START_ADDRESS) y la cantidad de bytes solicitados (QUANTITY).

La aplicación en Visual C# se encarga de realizar una petición de este tipo, respetando el formato del paquete.

Luego se llama a la función EepromReadMakeData(), la cual se encarga de leer los bytes desde memoria EEPROM y almacenarlos en un array final, el cual será un paquete con el formato de datos tipo TX_TYPE_EEPROM_DATA (ver constantes en globals.inc) para que luego pueda ser procesado correctamente con la aplicación en Visual C#.

Nota-1: El programa del PLC fue diseñado para aceptar solo una petición de 100 bytes de lectura de memoria EEPROM por petición, por lo que si deben leerse más bytes, la aplicación en Visual C# realizará varias conexiones (peticiones) que no excedan los 100 bytes, hasta completar la lectura completa (por ejemplo para 10000 bytes, realizará 100 peticiones).

Nota-2: El programa del PLC al inicio, guarda valores de prueba en la memoria EEPROM del PLC. Dichos valores podrán ser leídos luego desde la aplicación en Visual C#.

Nota-3: Es importante señalar que la memoria EEPROM almacena bytes, es decir valores que no exceden los 8-bits (números de 0 a 255), por lo que si almacenamos enteros de 32-bits o variables float (decimales), los mismos se componen de 4 bytes, por lo tanto luego desde la aplicación en Visual C# debemos "unilos" nuevamente para poder interpretarlos como un entero de 32-bits o un float de 32-bits. Se recomienda almacenar las variables de 32-bits en direcciones de memoria que sean múltiplos de 4. Vea el código de ejemplo en C#.

APLICACIÓN VISUAL C#

La aplicación llamada "EepromVisualAccess" (con su código fuente) en Visual C# asociada a este ejemplo  se puede descargar desde nuestro sitio web o foro de soporte técnico (al final de este post).

A continuación mostramos una captura de pantalla de la aplicación en Visual C# y los datos recibidos de la memoria EEPROM almacenados en un archivo de texto (ver fondo de imagen).



También la aplicación ofrece guardar los datos de la memoria EEPROM en formato CSV, es decir, valores separados por "coma", así luego puede importarlo desde Excel y realizar tablas o gráficos con los valores (ver siguiente post).

Para utilizar la aplicación, recuerde antes en el código fuente Visual C# configurar la dirección IP y modelo de PLC, en la línea:

PioBoard = new Stx8xxx("192.168.1.81", 0, Stx8xxxId.STX8091)

La aplicación solicita al PLC una cantidad de bytes a leer en memoria EEPROM a partir de una direccion inicial, la cual es configurada en la ventana de la aplicación.

Todo comienza cuando se hace "click" en el botón "Leer EEPROM", el cual ejecuta el evento butReadEeprom_Click() en el código de la aplicación.

El método encargado de realizar la petición de lectura en EEPROM a través de Ethernet UDP/IP es SendReadEeprom().

Como el PLC solo puede responder 100 bytes por petición, este programa se encarga de dividir las peticiones en fragmentos en caso de solicitar más de 100 bytes de datos.

Luego la aplicación llama al método WaitPlcResponse(), el cual espera la respuesta del PLC con los bytes leídos de memoria EEPROM.

Finalmente se llama al método SaveEepromDataToFile() para guardar los datos en un archivo de texto TXT y CSV.

El usuario puede optar por almacenar los datos recibidos en archivos con formato para valor byte, formato para valor 32-bits con signo y formato para valor Float (decimal). Esto es de acuerdo a como se almacenaron los datos en memoria EEPROM, según se explicó con
anterioridad.

Nota-1: Si el programa lo solicita, es probable que le pida acceso al firewall de Windows para recibir la respuesta del PLC, por lo tanto, permitalo.

LECTURAS RECOMENDADAS

Se recomienda leer las funciones del PLC para enviar datos UDP y leer la memoria EEPROM, esto lo puede encontrar en el manual de programación del PLC:

STX80XX-MP-PLC-AX_CX_DX.pdf

También para entender el código en Visual C# puede ser útil leer la nota de aplicación AN001, que explica con dos ejemplos simples como leer, transmitir datos al PLC y usar la librería Slicetex.

LINKS DE DESCARGA

El código fuente de los ejemplos puede ser descargado de los siguientes enlaces:

• EepromVisualAccess.zip: Ejemplo en Microsoft Visual C# para acceder a la memoria EEPROM del PLC y leer datos almacenados.
• EepromServerPLC.zip: Ejemplo en lenguaje Pawn para cargar al PLC.
• Página web: Origen de los ejemplos.

PRUEBA INCIAL

Cargue el proyecto EepromServerPLC.zip al PLC (antes seleccione su modelo de PLC y compile) con StxLadder.

Luego descargue el proyecto EepromVisualAccess.zip a su computadora, abra el proyecto con Microsoft Visual C#. Configure de acuerdo a como se comentó en los párrafos de arriba la dirección IP y modelo de su PLC.

Ejecute la aplicación C# en modo "DEBUG" y luego haga click en botón "Leer EEPROM".

Si la aplicación en Windows le pide acceso o permiso a su firewall, permitalo.

Si todo sale bien, la aplicación le informará sobre la lectura de EEPROM del PLC. En este punto, puede ver en el directorio de la aplicación un archivo TXT y otro CSV con los valores leídos.

Fin de ensayo.

Este proyecto pretende ejemplificar el uso del módulo STX810 (expansión 4 salidas analógicas) en lenguaje Ladder.

El ejemplo crea una rampa de tensión en salida analógica VO1 del módulo STX810, que va desde 0 a 10V, en pasos de 0.5V cada 5 segundos.

Requiere abrir proyecto con StxLadder versión 1.8.3 o superior.

Este proyecto pretende ejemplificar el uso del módulo STX810 (expansión 4 salidas analógicas) en lenguaje Ladder usando funciones de lenguaje Pawn.

Para simplificar el uso, se crearon 2 pares de funciones Ladder por cada salida análogica:

• VoutX_Value.sld: Escribe un valor digital de 0 a 1023 en la salida X analógica
• VoutX_Volt.sld: Escribe un valor de voltaje de 0 a 10V en la salida X analógica, donde el argumento de entrada es un entero entre 0 y 10000 que lego se divide por 100 para dar el voltaje deseado (ej: si deseamos 3.5 Volts usamos 3500 como entrada).

En el diagrama Inicio.sld se inicializa el Módulo de expansión.
Recuerde declarar el modulo en el PLC desde menú de StxLadder: PLC->Configurar PLC->Pestaña Expansión.
                   
Las funciones Pawn son descriptas en el manual del módulo STX810, disponible en nuestra web.

El ejemplo cuando se carga en el PLC, desde el diagrama principal llama a las funciones Ladder:

Vout1_Value.sld: escribe el valor 400 en la salida analógica 1.

Vout2_Volt.sld: escribe el valor 655 en la salida analógica 2, produciendo una tensión similar a 6.55V en la salida.

Realice en este foro las consultas especificas del Panel HMI Kinco Touchscreen al utilizarlo con nuestra línea de PLC.

• Uso del software de diseño.
• Interacción con el PLC.
• Ejemplos de conexión con el PLC.
• Información general, etc...

Para conectar el módulo de expansión de E/S digitales STX570 junto al módulo STX810 al mismo tiempo, es necesario configurar la dirección por hardware del módulo STX570 para que sea igual o mayor a 5.

Por ejemplo, direcciones válidas para STX570 serian: 5, 6, 7 y 8 (las mismas se establecen con los jumpers J1, J2 y J3)

Entonces, junto a un módulo STX810, solo se pueden conectar hasta 4 módulos STX570.

Ejemplo:

El siguiente ejemplo crea una rampa lineal entre 0-10V en cada salida analogica del modulo STX810, la cual es incrementada cada 5 segundos. En cada incremento se conmuta la salida EDOUT1 del modulo STX570.

Notar como se utiliza la direccion 5 para las funciones Stx570_Init() y Stx570_DoutToggle() del modulo STX570.


// ********************************************************************************
// Funcion     : PlcMain()
// Descripcion : Punto de entrada principal del PLC.
// ********************************************************************************

PlcMain()
{
   new Float: Volts
   
   //
   // Inicializar modulo STX810.
   //
   
   Stx810_Init()
   
   //
   // Inicializar modulo STX570.
   //
   // Utilizar direccion igual o mayor a 5.
   //
   
   Stx570_Init(5)
   
 
   //
   // Loop principal.
   //
   
   for(;;)
   {
   //
   // Generar una rampa lineal entre 0 y 10V
   //
   
   if(Volts < 10)
   {
   Volts += 2
   }
   else
   {
   Volts = 0
   }
   
   //
   // Escribir salidas analogicas con voltaje.
   //

   Stx810_WriteChVolt(1, Volts)
   Stx810_WriteChVolt(2, Volts)
   Stx810_WriteChVolt(3, Volts)
   Stx810_WriteChVolt(4, Volts)

           //
           // Conmutar salida EDOUT1 del modulo STX570.
           //
           // Notar la direccion utilizada.
           //
           
          Stx570_DoutToggle(5, EDOUT1) 
     
          //
          // Pausar 5000 mS.
          //

          DelayMS(5000)
          LedToggle()
   }

   // Retorno.
   return 0
}



Adjuntamos proyecto en archivo adjunto.

En base a consulta:

Ejemplo para crear una estructura de datos (similar a C) usando enumeraciones.

Definir estructura de datos:

enum Persona
{
   Nombre[20],       // Valor de constante = 0 (pero define un incremento de 20 para sucesor).
   Edad,                 // Valor de constante = 21
   Float: Altura       // Valor de constante = 22
}

Crear en memoria

Definir un Empleado con valores constantes de Nombre=Dimitri, Edad=25, Altura=1.9:

new Empleado[Persona] = { "Dimitri", 25, 1.9 }

Nota: El nombre de la enum "Persona", es otra constante con el valor de la ultima constante del enum + 1, es decir en este caso el valor es 23. Por lo tanto se crea indirectamente un array con 23 elementos con el nombre Empleado.

Acceso:

if(Empleado[Edad] > 65)
{
     nLcdPrintf(0, 1, LCD_NONE, "Jubilar a %s", Empleado[Nombre])   
}

En el código anterior, si la Edad de Empleado es mayor a 65 años, se imprimirá un cartel en VirtualHMI con el mensaje "Jubilar a Dimitri".

Como se puede ver, se accede al Array "Empleado" utilizando las constantes definidas en el "Enum" (Nombre, Edad, Altura), representando
campos de datos en el mismo. Esto permite estructurar datos en el array, similar a una estructura del lenguaje C.

En el ejemplo adjunto para StxLadder, se explica y añade mas información del concepto de estructura de datos con Enum.
Se definen 5 personas y se muestra información de las mismas en VirtualHMI.