Mostrar Mensajes

Esta sección te permite ver todos los mensajes hechos por este usuario, recuerda que solo puedes ver los mensajes en áreas en donde tu tienes acceso.


Temas - Soporte

Páginas: [1] 2 3 4
2
STX8081 / Ejemplo display LCD para I2C y memoria EEPROM
« : junio 07, 2018, 12:13:50 pm »
Para aquellos que utilizan el display LCD a través de I2C (puerto HP2/HP3), ver siguiente post del foro:

foro.slicetex.com/index.php?topic=269.msg1432#msg1432

Adjuntamos en esta oportunidad el mismo ejemplo, pero que también escribe y lee datos de memoria EEPROM.

Cabe mencionar que las funciones para la memoria EEPROM están descriptas en el Manual de Programación Pawn del PLC.

Ver proyecto adjunto.

Saludos!

3
Librería ModBus TCP Master para Visual C#

A continuación subimos un ejemplo simple en Visual C# para comunicarse al PLC utilizando protocolo ModBus TCP.

En este caso, el PLC actúa como Esclavo y desde Visual C# (una computadora) nos comunicamos como Maestro para escribir/leer registros o bits.

Aplicación de ejemplo

Cargue en el PLC el proyecto MbTcpServerCounter.zip para StxLadder que adjuntamos.

Luego descargue el proyecto ModBusTcpResponseTime.zip para Visual C# y ejecute la aplicación "ModBusTcpResponseTime.exe" de la carpeta "bin\Release".

Especifique dirección del PLC (ejemplo 192.168.1.81) y haga click en botón "Conectar". El puerto por defecto utilizado es 502. A continuación, si no hay errores de comunicación verá la siguiente pantalla (similar):



El funcionamiento es muy simple.

En el PLC, como esclavo ModBus, constantemente se incrementa una variable contador cada 1 mS y se la carga al registro ModBus número 40001.

En el caso que el registro 40001 se haga 0 (por ejemplo un Maestro escribió valor 0), la variable contador se hace cero nuevamente.
Por lo tanto, el valor en el registro 40001 representa el tiempo que pasó desde que un Maestro escribió el valor 0 y volvió a leer el valor del registro.

La aplicación en Visual C#, simplemente envía cada 10 mS una transacción ModBus de escritura de registro (escribe valor 0 en 40001) y luego intenta leer el mismo registro a través de ModBus.

Luego imprime dicho valor en pantalla, que representa el tiempo entre escritura y lectura ModBus.

También calcula el valor promedio de los últimos X valores (definido en caja Cantidad de muestras) y el valor máximo alcanzado.

Adicionalmente en el directorio del ejecutable, se guarda un archivo de texto llamado "log.txt" que registra todas las lecturas de tiempo realizadas de la última conexión para realizar un mejor analisis.

Código en C#

Abra el proyecto en Visual C# (recomendado versión 2015 o superior).

La librería ModBus TCP Master, se encuentra en el archivo stx8xxx.dll incluido en el directorio "bin\release" del proyecto.
Es esta librería que incluimos como referencia en el proyecto (References) y debe ser empleada en su aplicación Visual C# para tener acceso a las funciones ModBus TCP.

Luego agregamos el espacio de nombre en el código fuente con:

Código: (C#) [Seleccionar]
using stx8xxx;

Creamos el objeto que accede a las funciones ModBus como maestro:

Código: (C#) [Seleccionar]
private ModBusTcpMaster MbMaster;
Para conectarnos, simplemente especificamos dirección IP y puerto (que se obtienen de los controles de la ventana):

Código: (C#) [Seleccionar]
MbMaster = new ModBusTcpMaster(textDeviceIP.Text, (ushort)numDevicePort.Value);
Luego especificamos dos eventos, que serán llamados cuando tengamos repuesta de datos y excepciones (un error):

Código: (C#) [Seleccionar]
MbMaster.OnResponseData += new ModBusTcpMaster.ResponseData(MbMaster_OnResponseData);
MbMaster.OnException += new ModBusTcpMaster.ExceptionData(MbMaster_OnException);

Posteriormente, en el código creamos una funcion para leer el registro ModBus 40001, asociado al contador del PLC:

Código: (C#) [Seleccionar]
        private bool ReadPlcCounterRegister()
        {
            bool ErrorsFound = false;

            // Check connection.
            if (!IsConnectedMsg())
            {
                ErrorsFound = true;
                return ErrorsFound;
            }

            // Unique transaction ID (only for identify this transaction on response event).
            ushort ID = 2;

            // Send "Read Holding Register" request.
            MbMaster.ReadHoldingRegister(ID, 40001, 1);

            // Return to caller.
            return ErrorsFound;
        }

Notar como usamos la función "MbMaster.ReadHoldingRegister()" para leer un Holding Register del PLC en dirección "40001". El ID, es un valor arbitrario que utilizamos para luego poder identificar en la repuesta que los datos recibidos corresponden a esta transacción y no a otra que podamos haber realizado.

También creamos una función para escribir el registro del PLC numero 40001:

Código: (C#) [Seleccionar]
        private bool WritePlcCounterRegister(ushort Value)
        {
            bool ErrorsFound = false;

            // Check connection.
            if (!IsConnectedMsg())
            {
                ErrorsFound = true;
                return ErrorsFound;
            }

            // Unique transaction ID (only for identify this transaction on response event).
            ushort ID = 1;

            // Get byte array from "Value".
            byte[] Data = BitConverter.GetBytes((ushort)IPAddress.HostToNetworkOrder((ushort)Value));
           
            // Send "Write Single Holding Register" request.
            MbMaster.WriteSingleRegister(ID, 40001, Data);           

            // Return to caller.
            return ErrorsFound;
        }

Nuevamente, notar como usamos la función "MbMaster.WriteSingleRegister()" para escribir un Holding Register del PLC en dirección "40001". El ID, es un valor arbitrario que utilizamos para luego poder identificar en la repuesta que los datos recibidos corresponden a esta transacción y no a otra que podamos haber realizado.

También, el objeto "MbMaster" de la librería contiene más funciones para leer bits, o escribir/leer varios registros al mismo tiempo. Ver documentación en código ofrecida por Visual C#

Luego, desde un timer, llamamos a estas funciones cada 10 mS, donde comprobamos variable ReadyForTransaction, que indica que estamos listos para comenzar una nueva transacción y luego comprobamos variable StartWriteTransaction, si es "1", enviamos una transacción de escritura, sino, enviamos una transacción de lectura:

Código: (C#) [Seleccionar]
        private void timerPolling_Tick(object sender, EventArgs e)
        {
            //
            // Check if previous response was received or is ready for new transaction.
            //

            if (ReadyForTransaction)
            {
                //
                // Check transaction to do: write or read counter register.
                //

                if (StartWriteTransaction)
                {
                    // Write counter register with 0 value.
                    WritePlcCounterRegister(0);
                }
                else
                {
                    // Read PLC counter register.
                    ReadPlcCounterRegister();
                }
            }
        }

La respuesta a estas transacciones, las obtenemos del evento:

Código: (C#) [Seleccionar]
        private void MbMaster_OnResponseData(ushort ID, byte function, byte[] values)
        {
            // ------------------------------------------------------------------------
            // Seperate calling threads
            // ------------------------------------------------------------------------

            if (this.InvokeRequired)
            {
                this.BeginInvoke(new ModBusTcpMaster.ResponseData(MbMaster_OnResponseData), new object[] { ID, function, values });
                return;
            }

            // ------------------------------------------------------------------------
            // Identify requested data
            // ------------------------------------------------------------------------

            StringBuilder ResponseStr = new StringBuilder("Respuesta recibida: ");

            //
            // Check ModBus function code received.
            //

            switch (function)
            {
                case 3:
                    ResponseStr.Append("Read holding register ");

                    //
                    // Check transaction ID (counter read).
                    //

                    if (ID == 2)
                    {
                        //
                        // Get register value.
                        //
                        // UInt16 RegisterValue = (UInt16)(((UInt16)(values[0] << 8)) | ((UInt16)(values[1])));
                        //

                        // Check architecture endianess.
                        if (BitConverter.IsLittleEndian)
                        {
                            // Reverse array values.
                            Array.Reverse(values);
                        }

                        // Get register value from received bytes.
                        UInt16 RegisterValue = BitConverter.ToUInt16(values, 0);

                        // Update text box values on windows form.
                        UpdateTextBox(RegisterValue);

                        // Read register is done, now, write register on next timer tick.
                        StartWriteTransaction = true;
                    }

                    break;
                case 6:
                    ResponseStr.Append("Write single register ");

                    //
                    // Check transaction ID (counter write).
                    //

                    if (ID == 1)
                    {
                        // Write register is done, now, read register on next timer tick.
                        StartWriteTransaction = false;
                    }

                    break;
                default:
                    ResponseStr.Append("Unknown ");
                    break;
            }

            // Show message in status bar.
            ResponseStr.AppendFormat("({0}) - data bytes/words ({1}/{2}).", function, values.Length, values.Length / 2);

            PrintStatusBarMessage(ResponseStr.ToString());

            // Response received, ready for next transaction.
            ReadyForTransaction = true;
        }

Cuando este evento es llamado, nos pasa 3 argumentos:

  • ID: Identificación de transacción que colocamos al realizar una operación.
  • function: Código de Función ModBus al que pertenece la repuesta.
  • values[]: Bytes recibidos de la repuesta ModBus.

Notar como el siguiente fragmento es llamado, cuando hay una repuesta de escritura:

Código: (C#) [Seleccionar]
                case 6:
                    ResponseStr.Append("Write single register ");

                    //
                    // Check transaction ID (counter write).
                    //

                    if (ID == 1)
                    {
                        // Write register is done, now, read register on next timer tick.
                        StartWriteTransaction = false;
                    }

Procesamos, si es "function=6" (repuesta de una transacción Write single register) y "ID=1" (lo establecimos en WritePlcCounterRegister(), hacemos la variable StartWriteTransaction=false para que en el próximo evento timer en timerPolling_Tick() realicemos una operación de lectura.

En la repuesta de lectura, luego de llamar a función "ReadPlcCounterRegister()" se entra al siguiente fragmento de código:

Código: (C#) [Seleccionar]
                case 3:
                    ResponseStr.Append("Read holding register ");

                    //
                    // Check transaction ID (counter read).
                    //

                    if (ID == 2)
                    {
                        //
                        // Get register value.
                        //
                        // UInt16 RegisterValue = (UInt16)(((UInt16)(values[0] << 8)) | ((UInt16)(values[1])));
                        //

                        // Check architecture endianess.
                        if (BitConverter.IsLittleEndian)
                        {
                            // Reverse array values.
                            Array.Reverse(values);
                        }

                        // Get register value from received bytes.
                        UInt16 RegisterValue = BitConverter.ToUInt16(values, 0);

                        // Update text box values on windows form.
                        UpdateTextBox(RegisterValue);

                        // Read register is done, now, write register on next timer tick.
                        StartWriteTransaction = true;
                    }

Aquí obtenemos el registro leído en RegisterValue (convertimos de valor de red a valor de computadora de 16-bits) y luego actualizamos las cajas de texto de la ventana con la función UpdateTextBox().

Al final del evento se hace la variable ReadyForTransaction igual a true indicando que la aplicación esta lista para una nueva transacción ya que recibimos el dato que esperábamos (esto es simplemente como lógica en nuestro ejemplo, para no enviar una transacción nueva sí no recibimos la enviada previamente).

Código: (C#) [Seleccionar]
            // Response received, ready for next transaction.
            ReadyForTransaction = true;
        }



Aún la librería no esta publicada en la página web oficialmente por estar en desarrollo, por ello cualquier duda, pueden utilizar nuestro foro.

Abrir los ejemplos para el PLC con StxLadder 1.8.9 o superior.

Saludos!

4
Hoy le presentamos una nueva caracteristica para sus dispositivos:

Actualización Automática de Fecha/Hora a través de Internet

En StxLadder 1.8.8 o superior es posible configurar el PLC para que actualice la fecha/hora de su reloj RTC a la hora proporcionada por internet. Esta funcionalidad requiere que tenga actualizado el firmware del PLC a la última versión.

Ventajas de actualizar la fecha/hora desde internet:

  • Su reloj estará actualizado a relojes atómicos de gran exactitud.
  • Evita problemas de envejecimiento de batería (para dispositivos con bateria de respaldo).
  • Evita derivas en el tiempo de segundos/minutos por error de hardware.
  • Años que tienen segundos "extras" son actualizados en su reloj interno.
  • Mejor desempeño para aplicaciones que requieren fecha/hora exacta, como cliente de E-MAIL.

Como requisito, necesita una conexión a internet para que el dispositivo para que pueda sincronizar cada determinado intervalo.

Configuración

En StxLadder vaya a menú "PLC > Configurar PLC".

En la ventana de dialogo que se abra, presione "Conectar!" y vaya a pestaña "Fecha/Hora" como muestra la siguiente imagen:



Tilde opción de casilla "Actualizar por red".

Luego en Time Zone debe colocar el desplazamiento UTC en horas de su región (ver mapa), por ejemplo:

  • Para Argentina utilice: -3
  • Para México utilice -5:
  • Para España utilice +5:

En Poll Rate (sec) debe colocar el intervalo en segundos que utilizará el dispositivo para realizar una petición en internet y sincronizar el reloj interno con la hora de red. Este valor es libre, puede ir de 64 segundos a 65535 segundos. Recomendamos entre 2 minutos y 2 horas.

Finalmente, una vez configurado presione el botón "Enviar" y reinicie su dispositivo (RESET) para que la configuración tome efecto.

Verificar funcionamiento:

Presione nuevamente "Conectar!" en la ventana de diálogo "Configuración del PLC" y vaya a pestaña "Información":



En el campo "Falla en RTC" debería leer el valor "No" y en el campo "Fecha/Hora en dispositivo" debería ver una fecha/hora idéntica a la de su teléfono móvil (si también toma la hora desde internet).

Consideraciones de funcionamiento:
 
La actualización de fecha/hora de red se realiza en intervalos (Poll Rate) desde que el dispositivo es energizado. Si no consigue conectarse a internet, el reloj continuará funcionando normalmente utilizando como referencia la última fecha/hora establecida. Si se produjo un corte de energía y la hora/fecha no se mantuvo por batería baja, en el próximo inicio la fecha/hora será errónea (RTC Fail) a menos que consiga nuevamente conectarse a internet para sincornizarse.

Si se restaura la configuración de fabrica del dispositivo, la actualización de fecha/hora por red es deshabilitada por defecto.

El dispositivo utiliza el protocolo NTP (Network Time Protocol) para conectarse al servidor "time.google.com" en puerto 123 (UDP). Tenga en cuenta por si tiene algún firewall o restricción especial en su red que le impida la conexión (en general, no debería tener problema alguno).

¿Por qué utilizamos servidor de Google para actualizar fecha/hora?

Primero porque sus servidores son muy confiables, son fuente primara de reloj (relojes atómicos) y segundo porque Google utiliza "leap-smeared time" a diferencia de otros servidores como POOL.NTP.

En simples palabras "Leap-smeared time" significa que en vez de agregar un segundo extra al día cada tanto (por la inconsistencia de rotación de la tierra, ya se han agregado 24 segundos desde 1972), Google agrega unos mili-segundos distribuidos en muchos días, haciendo más lento su reloj en la misma cantidad (pero imperceptible) para que cuando llegue el día de agregar el segundo extra, no haya necesidad de agregarlo de golpe y no exista un "segundo extra" desde el punto de vista informático.

Próximas novedades ...

Este atento a las novedades, pronto podrá configurar servidores (con nombre o dirección IP), especificar opciones de actualización, etc desde lenguaje Pawn y lenguaje Ladder. De esta forma tendrá más libertades de configuración  8)








7
PD3060-PT100 / Conectar dos o más módulos PD3060-PT100 al PLC
« : abril 05, 2018, 13:35:38 pm »
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.





8
STX8081 / Lectura de tarjetas RFID - Wiegand 26/32
« : marzo 15, 2018, 12:27:52 pm »
Hola Estoy en un proyecto y necesitaba poner un lector de tarjetas, queria saber que lectores tengo que usar para poder utilizar las funciones implementadas y no desarrollar nada en especial

Saludos, Esteban

Buenos días Esteban,

Necesitarías un lector con salida de protocolo Wiegand 26 o Wiegand 32, es importante que tenga los cables de conexión disponibles como el siguiente ejemplo:



Algunos son USB, esos no sirven.

Se pueden conseguir por Mercado Libre, por ejemplo:

https://articulo.mercadolibre.com.ar/MLA-608305218-lector-rfid-wiegand-intemperie-control-acces-em-marin-125khz-_JM

https://articulo.mercadolibre.com.ar/MLA-711744306-lector-wiegand-rfid-anti-clon-anti-copia-detecta-fraude-125-_JM

Luego, se conectan al PLC por el Puerto de Expansión. Como el lector de tarjetas no tiene un puerto estandar, sino cables sueltos, debes desde el Puerto de Expansión hacer una extensión ficha+cables para conectarlo al lector de tarjetas. De última te puedo armar el cable para que empieces y luego puedas hacerlo.

El harware Wiegand debe conectarse al puerto de expansión HP2/HP3 de la siguiente forma:

  • DATA0 conectar a /EXP_INT (pin 6). Tensión no debe sobre pasar +5Vcc.
  • DATA1 conectar a /BOOTL (pin 7). Tensión no debe sobre pasar +5Vcc.
  • GND a GND, es importante que esten conectados para así compartir masas entre equipos (puede ser al puerto de expansión o bornera del PLC).
  • Alimentación a 12VCC (puede ser del puerto de expansión o bornera del PLC).

Importante-1: La conexión debe hacerse con el PLC apagado y luego de configurar el hardware desde StxLadder.
Importante-2: Consultar hoja de datos del dispositivo para limites eléctricos e identificación de pines en puerto de expansión.

En cuanto a la programación, las funciones de lectrura están disponibles para lenguaje Pawn, te paso el link a la descripción de las funciones:

http://foro.slicetex.com/index.php?topic=172.msg808#msg808

Saludos!

9
¡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:


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.

10
PD3060-PT100 / Introduciendo el módulo PD3060-PT100
« : diciembre 29, 2017, 19:40:41 pm »
Introducción

Tenemos el agrado de incorporar el dispostivo PD3060-PT100, un módulo lector de sensores de temperatura PT100 (dispositivo termo-resistivo o RTD) que admite hasta 6 entradas para sensores.

Puede conectar sensores PT100 de 2 y 3 cables.
La lectura de temperatura se obtiene utilizando la interfaz de comunicación RS-485 mediante el protocolo ModBus RTU.
Ideal para conectar a un PLC, HMI o sistema de monitoreo con soporte de dicha interfaz de comunicación.



Documentación y ejemplos


Nota-1: Recuerde pulsar un botón de menú o tecla de acción en VirtualHMI para lograr conexión con el PLC, así el mismo comenzará a enviar los valores de temperatura.

Nota-2: Para modelos STX8091 / STX8092 de PLC, recuerde colocar jumpers J1 y J2 para seleccionar interfaz RS-485 en puerto de comunicación.

Más información en la página del producto en nuestro sitio web:

www.slicetex.com/modules/temperature/pd3060-pt100

Fotografías de referencia con sistema de medición PT100

Módulo y PLC



PT100 midiendo temperatura negativa en agua congelada



PT100 midiendo temperatura ambiente



Mostrando resultados de lectura en VirtualHMI


11
STX810 / Utilizar STX810 con soporte total en Lenguaje Ladder
« : septiembre 30, 2017, 19:49:14 pm »
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.


13
STX810 / Uso de STX810 en Ladder mediante funciones Pawn
« : septiembre 15, 2017, 17:51:01 pm »
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.

14
Wecon / Introducción
« : junio 17, 2017, 12:59:31 pm »
Realice en este foro las consultas especificas del Panel HMI Wecon 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...


15
Kinco / Introducción
« : junio 17, 2017, 12:56:43 pm »
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...


Páginas: [1] 2 3 4