Mensajes recientes

Páginas: 1 [2] 3 4 ... 10
11
STX8091 / Re:Código para el registro de variables en tabla (DataLogger)
« Último mensaje por ms_zamora agosto 06, 2018, 20:43:57 pm »
Estimado Boris,

Muchas gracias por enviarme el código!! Ahora mismo lo reviso y lo pruebo y le aviso para coordinar una explicación telefónica.

Le agradezco mucho su tiempo,

Silvana
12
STX8091 / Re:Código para el registro de variables en tabla (DataLogger)
« Último mensaje por Soporte agosto 06, 2018, 19:53:39 pm »
El proyecto en el PLC, tiene los siguientes puntos de interés:

En archivo "Samples.inc", tenes la constante SAMPLES_PERIOD, en ella podes especificar el intervalo de muestreo en segundos para cada registro.

Por ejemplo, podes utilizar 60, para tomar cada un minuto, o 60*10 para registrar cada 10 minutos.



En archivo "Vin.p" podes configurar los rangos de cada canal analógico.

Cada muestra analogica, es un promedio de 1000 muestras tomadas en 60 segundos, esto se especifica en la linea:

Código: (Pawn) [Seleccionar]
VinFilterAOn(1000, 60000)
También, cada muestra se analogica se registra con las funciones:

VinReadT(), VinReadHR(), VinReadE(), VinReadIR() y VinReadUV()

Que en este caso, solo devuelven el voltaje leido.

Pero podes escalar su valor devuelto dentro de dichas funciones, para que retornen a magnitud física correcta, ejemplo temperatura, humedad relativa, etc. Entonces, luego los registros contendrán los valores reales.



En archivo "Samples.inc", declaro la siguiente enumeración:

Código: (Pawn) [Seleccionar]
enum SampleDataEnum
{
   Data_TimeStamp,     // Fecha/Hora de la muestra.
   Float: Data_T,      // Tempertatura (VIN1).
   Float: Data_HR,     // Humedad Relativa (VIN2).
   Float: Data_E,      // Iluminancia (VIN3).
   Float: Data_IR,     // Radiación IR (VIN4).
   Float: Data_UV,     // Radiación UV (VIN5).
   Data_DIN,           // Estado de todas las entradas digitales (DIN1, DIN2, etc).
}

Sí te fijas, cada campo contiene las muestras de cada registro.

Fíjate que en Data_DIN almaceno el estado de todas las entradas digitales, esto es para maximizar el uso de memoria, utilizando una sola variable para almacenar el estado en cada bit de las entradas (por ejemplo DIN1 y DIN2, donde tenes CO2 y AIR).

La terminología que utilizo es "registro" para cada grupo de muestras (que contiene todos los datos). Y muestra para el valor individual.
Sin embargo, en el programa a veces uso los términos indistintamente, pero es la idea.



Las páginas web las podes modificar libremente, quizas para entender bien, te convenga leer la nota de aplicacion AN030:

http://slicetex.com/docs/an/an030/



Una vez que se llena la memoria, se genera la notificación si configuraste tu email.

Te va a notificar cada 8 horas.

Esto podes cambiarlo desde el archivo "Timeout.p", en el código:

Código: (Pawn) [Seleccionar]
   //
   // Comprobar si Timeout2 ha expirado.
   //
   
   if(Timeout2Check() == 1)
   {
      // Habilitar nuevamente todas las notificaciones por e-mail.
      MailNotifyStopClearAll()
     
      //
      // Recargar timeout con 3600*8 segundos (8 hs)
      //
     
      Timeout2Reload(3600*8)
   }

Cambiando el valor 3600*8 con el valor adecuado en segundos, podes aumentar/disminuir ese lapso.



En el programa de Visual C#, la parte de código siguiente, es donde proceso cada muestra para poder almacenarla en un archivo de texto y luego importar desde Excel. No deberia necesitar cambio (a menos que registres más sensores), ya que el PLC interpreta la magnitud fisica, y el programa solo lee el valor almacenado.

Código: (C#) [Seleccionar]
                    //
                    // Muestra 1, TimeStamp
                    //

                    // Convertir 4 bytes en Entero de 32-bits.
                    int TimeStamp = BitConverter.ToInt32(EepromBytes, EepromIndex);

                    // Obtener fecha/hora de muestra a partir de TimeStamp.
                    DateTime SampleTime = PioBoard.Cmd.BoardInfo.TimeStampToDateTime((uint)TimeStamp);

                    //
                    // Muestra 2 a 7
                    //

                    // Convertir 4 bytes en Float de 32-bits.
                    float Sample2 = BitConverter.ToSingle(EepromBytes, EepromIndex + 4 * 1);

                    // Convertir 4 bytes en Float de 32-bits.
                    float Sample3 = BitConverter.ToSingle(EepromBytes, EepromIndex + 4 * 2);

                    // Convertir 4 bytes en Float de 32-bits.
                    float Sample4 = BitConverter.ToSingle(EepromBytes, EepromIndex + 4 * 3);

                    // Convertir 4 bytes en Float de 32-bits.
                    float Sample5 = BitConverter.ToSingle(EepromBytes, EepromIndex + 4 * 4);

                    // Convertir 4 bytes en Float de 32-bits.
                    float Sample6 = BitConverter.ToSingle(EepromBytes, EepromIndex + 4 * 5);

                    // Convertir 4 bytes en Entero de 32-bits.
                    int Sample7 = BitConverter.ToInt32(EepromBytes, EepromIndex + 4 * 6);

                    // Obtener valores de entradas digitales.
                    int Din1 = Tools.BitRead((uint)Sample7, 0) ? 1:0;
                    int Din2 = Tools.BitRead((uint)Sample7, 1) ? 1:0;

                    // Crear línea de texto.
                    sb.AppendFormat("{0} | {1} | {2} | {3} | {4} | {5} | {6} | {7} | {8}", reg + 1, TimeStamp == 0 ? "N/D": SampleTime.ToString(), Sample2, Sample3, Sample4, Sample5, Sample6, Din1, Din2);
                    sb.AppendLine();



13
STX8091 / Re:Código para el registro de variables en tabla (DataLogger)
« Último mensaje por Soporte agosto 06, 2018, 19:30:38 pm »
Buenas tardes Silvana,

Adjunto en archivos ZIP te paso el proyecto para el PLC para registrar datos como un DataLogger y el proyecto para Visual C# para recuperar los datos registrados.

Son programas simples, pero con bastante código por lo cual puede resultarte un poco abrumador al comienzo para entenderlos, ya que está escrito considerando todas las posibilidades.

Te recomiendo verlos, familiarizarte un poco, y cualquier cosa, podemos convenir algún horario y te doy una explicación breve telefónica.

Sin embargo, hacen lo que pedís, registran los datos cada 10 minutos y cuando se llena la memoria te envia una notificación por e-mail.

También podés acceder vía página web al dispositivo para configurar tu e-mail, vaciar memoria, reiniciar sistema, etc.



Para utilizarlos, primero que nada necesitas actualizar el PLC con la última versión de firmware disponible (actualmente la V215) desde la página web:

http://slicetex.com/hw/stx8091/soft.php

También, utilizar la última versión de StxLadder.



Una vez que cargues el proyecto en el PLC, podés acceder al mismo desde tu navegador web a la página del PLC, mediante la dirección "192.168.1.81" (o la que utilices en tu red con el PLC).

En la página "Resumen" te da información util del sistema.



Por ejemplo porcentaje de uso de la memoria, los dias remanentes antes de que se llene, si tenes configurado la notificación por mail, etc.

También te dice la cantidad de registros disponibles, donde cada registro contiene información de las muestreas (7 variables, hora/fecha, entradas analógicas y digitales). Por lo tanto, 7 variables de 4 bytes cada una, son 28 bytes por registro. En total, podes registrar 1159 registros, y a una velocidad de 10 minutos son 8 días de registro antes de llenar la memoria.

En la página "Registros" te muestra información de los últimos 24 registros adquiridos:





También te recomiendo ir a la página "Config > Service" y ejecutar la acción "Volver memoria a parámetros de fábrica", para poner la configuración del sistema a valores por defecto.

Luego reiniciar el sistema, para que los cambios tengan efecto.

Desde esa misma página podes vaciar la "memoria de registros".



En Visual C#, tenes el programa para recuperar todos los registros en EEPROM almacenados.



Este programa asume que el PLC esta en la dirección IP 192.168.1.81.

Podes ejecutar el programa con el ejecutable:

EepromVisualAccess\bin\Debug\EepromVisualAccess.exe

Sí te pide acceso al firewall al ejecutar, dale permiso con la clave de administrador de windows.

Una vez que se conecta, le podes decir cuantos registros leer y te los guarda en un archivo de texto, separados por carácter "|", por lo cual luego podes importarlo desde excel como una tabla.

En el ZIP, te puse como hacerlo en Excel con fotos.



Si querés modificar el programa en Visual C#, debes abrir el mismo con "Microsoft Visual C# 2015 o superior".

En el siguiente post, te doy algunos detalles más.

Saludos!




14
STX8081 / Re:Problema con las últimas versiones
« Último mensaje por PabloGa agosto 06, 2018, 12:36:39 pm »
Hola Boris buen día,

Muchas gracias por tus explicaciones.
La verdad es que tenía la sensación de que estaba super-holgado de memoria en mi PLC, pero evidentemente no es así (probablemente esté holgado de memoria flash para almacenar el programa en sí, pero jugado con la cantidad de RAM usada para variables).

Voy a tener que revisar bien el código antes de hacer cualquier upgrade de versiones, porque me parece que sí uso strings via subíndice en alguna parte, y me podría dar cualquier resultado. Fijate en las siguientes 2 funciones, que me parece que vos me las pasaste prehechas en algún momento, y las vengo utilizando. No tengo claro qué hacer con esas funciones para que sean compatibles con ese switch de compilación:

// ********************************************************************************
// Funcion     : ReemplazarEspacios()
// Descripcion : Al string que viene, se le reemplazan todos los ESPACIOS.
//
// ********************************************************************************

ReemplazarEspacios(const String[])
{
   new Buffer[30]
   new i=0
   
   // Hacer un lazo que parsea el string
   while(TRUE)
   {
      // Copiar una línea de String[] en Buffer[].
      if(String != ' ' && String != '\0')
      {
         Buffer = String
      }

      // Viene un ESPACIO en String ?
      if (String == ' ')
      {
         // Si, reemplazar por otro caracter
         Buffer = '_'
      }     
     
      // Fin de caracteres en String ?
      if (String == '\0')
      {
         Buffer = '\0'
         return Buffer
      }
      i = i+1
   }
}



// ********************************************************************************
// Funcion     : nLcdPrintMultLines()
// Descripcion : Imprime una cadena con múltiples líneas en VirtualHMI.
//               Soporta \n, que de otra manera no funciona
// ********************************************************************************

nLcdPrintMultLines(x, y, const String[])
{
   new Buffer[160]
   new i=0, j=0
   new Stop = FALSE
   
   // Parsear cadena.
   while(Stop == FALSE)
   {
      // Copiar una línea de String[] en Buffer[].
      while(String != '\n' && String != '\0')
      {
         Buffer[j++] = String[i++]
      }
     
      // Si hay carateres en Buffer[], imprimir.
      if (j != 0)
      {
         // Agregar terminador de fin de cadena.
         Buffer[j] = '\0'
         
         // Imprimir en VirtualHMI Buffer[] e incrementar numero de línea.
         nLcdPrintf(x, y, LCD_CLRLINE, "%s", Buffer)       
      }
     
      // Fin de caracteres en String[] ?
      if (String == '\0')
      {
         // Si, parar Loop.
         Stop = TRUE
      }
      else
      {
         // No, ajustar variables para próxima línea.
         j=0
         i++
         y++
      }
   }
}

Así como están ya no funcionarían, verdad ?
Gracias!
Pablo.
15
STX8081 / Re:Problema con las últimas versiones
« Último mensaje por Soporte agosto 04, 2018, 21:05:50 pm »
El problema se manifiesta así: al compilar el programa (ya con el nuevo entorno), me tira el siguiente error:

Error de Memoria: Insuficiente memoria RAM: El proyecto requiere 19668 bytes y el dispositivo tiene disponible 16384 bytes. Disminuya variables globales, variables locales inicializadas, comparta/reutilice variables globales, utilice packed strings, agrupe datos, etc.


Hola Pablo.

En las últimas versiones de firmware y StxLadder, se hace una correcta comprobación de memoria RAM utilizada antes de cargar el proyecto al PLC. Por lo tanto, quiere decir que tu código utilizaba más memoria de la permitida.

Esto en general no causa problemas porque es probable que justo no interacciones con otros sectores de RAM utilizado por el sistema operativo, pero si llegara a pasar, se te cuelga el PLC.

La solución en general es bajar la memoria RAM utilizada, que en tu caso, seguramente es por utilizar muchas cadenas/strings, ya que cada carácter consume 4 bytes en Pawn.

Lo que te aconsejo, es cargar la última versión de firmware y StxLadder, y compilar con la opción:

"Packed literal strings" , que se encuentra en "Proyecto > Propiedades > Compilador (pestaña)".



Seguramente, el porcentaje de RAM utilizada se te va reducir bastante, y te va a dar "Compilación correcta".

Sí lo compila (muy probable), tenés seguridad de que el PLC sea más estable respecto a la memoria utilizada RAM en tu proyecto.

La opción "Packed literal strings" hace que se agrupen "4" carácteres de una cadena, en una celda de 32-bits, ya que si esta opción se utiliza un carácter por celda, lo que es un desperdicio de memoria, porque 3 bytes quedan libres sin utilizar.

En general no necesitarias otro tipo de cambio en tu código, a menos que indexes en algún lugar una cadena, caracter por caracter, por ejemplo:

Código: (Pawn) [Seleccionar]
new String[]="Hola"

if(String[0]='H')
{
    // Letra H
}

Pero si solo operas con cadenas de forma normal, utilizando las funciones, no hay problemas (si debes actualizar firmware).

Sí utilizas la función StrFormat(), el tercer argumento debe ser "true" o "PACKED":

StrFormat(..., ..., true, "...", ...)

StrFormat(..., ..., PACKED, "...", ...)



En el link abajo, paso el POST donde se muestra el por qué de esta nueva característica de StxLadder, ya que en previas versiones había un calculo erróneo sobre la estimación de RAM utilizada por el proyecto y podía sobrepasar los límites admitidos.

http://foro.slicetex.com/index.php?topic=335.msg1805#msg1805

Además te da tips para disminuir uso de memoria RAM y utilizar "packed strings" .

Cualquier duda, avísame.

Saludos!









16
STX8081 / Problema con las últimas versiones (packed string)
« Último mensaje por PabloGa agosto 04, 2018, 20:05:27 pm »
Hola Boris que tal?

Hoy me dispuse a hacer una modificación al programa de mi PLC, y -como hago siempre- primero actualizo el StxLadder a la última versión disponible, y lo mismo con el firmware del PLC (el mío es un 8081-D2). Luego de la actualizaciòn tuve problemas; te paso la info:

Lo que tenía antes de actualizar era:
StxLadder 1.8.8
Firmware 227

Luego de actualizar pasé a:
Stxladder 1.9.2
Firmware 229

El problema se manifiesta así: al compilar el programa (ya con el nuevo entorno), me tira el siguiente error:

Error de Memoria: Insuficiente memoria RAM: El proyecto requiere 19668 bytes y el dispositivo tiene disponible 16384 bytes. Disminuya variables globales, variables locales inicializadas, comparta/reutilice variables globales, utilice packed strings, agrupe datos, etc.


Entonces voy a ver en el PLC qué marca, y en el display tiene el siguiente cartel:
PLC Return Code C:200 R:0

Pensé que habría un problema con el firmware, asi que lo volví para atrás a la V227. Pruebo a compilar con F6, y me da el mismo error. Entonces volví para atrás también el entorno StxLadder, y todo volvió a la normalidad (me apareció un cartel diciendo que el programa había sido construído con una versión de StxLadder superior, y que podría haber pérdidad de datos, pero seguí adelante y todo anduvo normal).

Aclaro que al grabar el firmware me aseguré de elegir la versión correcta del archivo, de acuerdo al modelo de PLC que uso: stx8081-d2.sff

En conclusión, no me queda claro si el problema está en el firmware o en el entorno.
Por lo pronto, tengo todo funcionando a la perfección, por lo que no hay ningún apuro en resolver nada.

Saludos y muchas gracias !
Pablo.
17
GRACIAS¡¡¡
18
STX8091 / Re:Código para el registro de variables en tabla
« Último mensaje por ms_zamora agosto 01, 2018, 17:45:56 pm »
Si exactamente eso sería, muchas gracias!

Silvana.-
19
buenos días, quisiera que me orienten como podría realizar la automatización: la idea es que el sistema de alimentación principal de una vivienda se a través de alimentación fotovoltaica , y al memento de que el sistema fotovoltaico tenga sus baterías en baja carga conmute a la red de alimentación publica. por otro lado el sistema controle si esta presente la alimentación de la red publica necesaria (220 vol/380 vol ); y conmute nuevamente cuando las baterías recuperen la carga necesaria el equipo que tengo en un  PLC - CUBE  STX8091H03A1-FXD1.-
espero pueda guiarme.

Buenos días.

En este caso debería utilizar dos indicaciones  en su sistema y colocarlas en una entrada digital DIN del PLC.

  • DIN1 = Indicación batería baja: Con esto le dice al PLC que hay batería baja.
  • DIN2 = Indicación de red pública: Con esto le dice al PLC que hay energía eléctrica presente.

Entonces:

DIN1=0, conmuta con salida de PLC a sistema con baterías.

DIN1=1 y DIN2=1, conmuta con salida del PLC a red pública.

DIN1=1 y DIN2=0, desconecta energía eléctrica del sistema antes que baterías se dañen.

Para obtener indicación de red pública, puede utilizar un rele de 220VCA, y alimentarlo desde la red para que conmute e introduzca un "1" o "0" en la entrada DIN.

Para obtener indicación de batería baja, debe consultar con su equipo o sistema para poder leer dicha señal de forma correcta.

Saludos!





20
STX8091 / Re:Código para el registro de variables en tabla
« Último mensaje por Soporte agosto 01, 2018, 13:19:27 pm »
Buenos días.

Gracias por su pronta respuesta. Quisiera registrar cada 10 minutos las variables ambientales, y que ese registro sea el promedio de muestras tomadas durante un minuto (para tener mas certeza del dato registrado en memoria). Por ejemplo adquirir una muestra por segundo y luego de un minuto promediar las muestras (serían 60) y ese dato promediado lo registro en memoria.
Así en una hora tendría 12 muestras guardadas en la memoria. Necesito medir durante todo el día, los días que alcance según las caracteristicas de mi PLC 8091.

Entonces serían 6 muestras por hora, de cada variable analógica. Y cada muestra a almacenar, es un promedio de las últimas 60 muestras tomadas cada 1 segundo.

Bien, realizo un ejemplo, me va a llevar unos días ya que tiene que estar pensado para que luego puedas recuperar los datos almacenados y poder notificar/chequear el momento en que la memoria esta llena.

Te aviso por este medio cuando tenga el ejemplo.

Saludos!
Páginas: 1 [2] 3 4 ... 10