7 de septiembre de 2009

Diseño de paneles de operador

Voy a cambiar un poco de tema, hablando de la parte más 'artística' del mundo de la automatización industrial: el diseño de paneles de operador. Cuando empecé a trabajar en mi empresa los paneles que montábamos habitualmente, quitando los de líneas de texto, eran los de Siemens de 6" y 10" táctiles. Al principio tenían 16 colores (TP27), más tarde 256 colores (TP270) y actualmente miles de colores (MP277). Si el tiempo de desarrollo del proyecto es crítico (como suele ser habitual) tiras por el camino rápido: botones con texto que cambian de color, algún dibujito con el paint y poco más.

Personalmente prefiero hacer los paneles más descriptivos, que se vea la máquina representada y que refleje sus movimientos y estados. El panel de operador es una de las partes que más hacen vistosa una máquina y un buen diseño (bonito y sobre todo práctico) ayuda a venderla y si la representación es en tres dimensiones pues ya queda la cosa chula.

Al principio mis compañeros hacían los dibujos de lás máquinas... ¡en WORD! Usaban las formas 3D del Word (cubos, cilindros, ...) para representar la máquina. Iban representando los movimientos e iban haciendo capturas de pantalla. Y lo cierto es que no quedaban mal, teniendo en cuenta que los paneles eran de 16 colores. La primera vez que me tocó desarrollar un panel desde cero ya trabajabamos con 256 colores y desarrollé mi propio método.

'Friki' fue el calificativo que me dedicaron mis compañeros cuando vieron cómo hacía los paneles. Uso el programa de diseño tridimensional POV-Ray, un programa gratuito y libre con el que se pueden hacer auténticas maravillas. Te lo puedes bajar de aquí en versión Windows.

Lo primero que hay que tener en cuenta es que no es un programa visual, tipo 3D Estudio o similares. Se programa con una sintaxis parecida al lenguaje C. Tiene variables, bucles, macros, que sirven para situar objetos (cilindros, esferas, cajas, ...) delante de una cámara y con una iluminación para sacar la 'foto' de la representación. Para 'dibujar' simplemente hay que tener un poco de visión espacial. Existen modeladores visuales para POV-Ray, pero a mí no me convencen y para lo que pretendo son demasiado complicados. Con un poquito de práctica, en pocas líneas se pueden obtener resultados vistosos. Además, la ayuda que trae es excelente, aunque está en inglés.

Voy a poner un ejemplo. Voy a representar una alimentación de piezas, llamadas triejes, que caen guiadas por una columna y se dosifican con un cilindro neumático. Vamos a tener un movimiento (el cilindro) y dos presencias (presencia de pieza alimentada y presencia en la columna de alimentación) lo que implica que vamos a tener 8 dibujos (2^3). Yo lo que hago es una tabla para ver qué movimientos necesito (no en este caso, pero muchas veces hay muchas combinaciones imposibles, que son dibujos que me ahorro):


Presencia en alimentación triejesPresencia trieje alimentadoCilindro empujador en origenNúmero de imagen
NONONO0
NONO1
NONO2
NO3
NONO4
NO5
NO6
7


Y las imágenes, en orden, serían las siguientes:









Desde el PLC, en función de los detectores, seleccionaremos la imagen apropiada de la lista de imágenes que habremos creado en el ProTool o en el Wincc Flexible.

A mí me parece que el resultado queda chulo, pero claro, esto es cuestión de gustos. Por ahora nadie se ha quejado.

Voy a poner ahora el código para hacer los dibujos. He puesto cada objeto en un fichero independiente que incluyo desde el fichero principal.

Este es el código para dibujar el trieje:

/* Trieje centrado en <0,0,0>, altura 2.5 (0,2.5), radio 5 */

#macro Trieje()

#local TEXTURA_ROJO = texture { pigment { color rgb <1,0,0> } }

#local Nariz = intersection
{
union
{
cylinder { <3,0,0>,<4.75,0,0>,1 }
sphere { <0,0,0>,1 scale <.25,1,1> translate 4.75*x }
cylinder { <3,0,0>,<3.1,0,0>,1.2 }
}
torus { 1,.1 rotate 90*z translate 3.25*x inverse }
torus { 1,.1 rotate 90*z translate 4.6*x inverse }
cone { <5,0,0>,.4,<2,0,0>,.15 inverse }
}

union
{
intersection
{
sphere { <0,0,0>,3.5 }
cylinder { <0,-1.25,0>,<0,1.25,0>,3.5 }
cylinder { <0,-1.5,0>,<0,1.5,0>,2.4 inverse }
plane { x,3 }
plane { x,3 rotate 120*y }
plane { x,3 rotate 240*y }

#local angulo = 0;

#while(angulo < 360)

cylinder { <2.4,-1.5,0>,<2.4,1.5,0>,.15 rotate angulo*y inverse }

#local angulo = angulo + 15;

#end
}

object { Nariz }
object { Nariz rotate 120*y }
object { Nariz rotate 240*y }

translate 1.25*y

texture { TEXTURA_ROJO }
}

#end

Podría haberlo hecho con menos detalles, en su momento tenía tiempo. Para usarlo copia el código en un fichero de texto con el nombre "Trieje.inc".

Ahora el código de la columna de alimentación:
/* Varillas carrilera alimentación de triejes */

#macro Carril_alim()

#local TEXTURA_METAL = texture { pigment { color rgb <.75,.75,.75> } }

#local Carril = union
{
cylinder { <4,0,-1.25>,<4,25,-1.25>,.25 }
cylinder { <4,0,1.25>,<4,25,1.25>,.25 }
sphere { <4,0,-1.25>,.25 }
sphere { <4,0,1.25>,.25 }

}
union
{
object { Carril }
object { Carril rotate 120*y }
object { Carril rotate 240*y }
texture { TEXTURA_METAL }
}

#end

Para usarlo copia el código en un fichero de texto con el nombre "Carril_alim.inc".

Ahora el código del cilindro de dosificación (empujador):
// Cilindro empujador de triejes

#macro Empujador(Estado)

#local TEXTURA_AMARILLO = texture { pigment { color rgb <1,1,0> } }
#local TEXTURA_VERDE = texture { pigment { color rgb <0,1,0> } }
#local TEXTURA_METAL = texture { pigment { color rgb <.75,.75,.75> } }

union
{
intersection
{
box { <5,0,-5>,<15,2.5,5> }
plane { y,2.5 rotate 10*z translate 10*x }
translate Estado*10*x
texture { TEXTURA_METAL }
}

cylinder { <15,1.25,2>,<27,1.25,2>,.5 translate Estado*10*x texture { TEXTURA_METAL } }
cylinder { <15,1.25,-2>,<27,1.25,-2>,.5 translate Estado*10*x texture { TEXTURA_METAL } }

cylinder { <15,1.25,2>,<15.25,1.25,2>,.75 translate Estado*10*x texture { TEXTURA_METAL } }
cylinder { <15,1.25,-2>,<15.25,1.25,-2>,.75 translate Estado*10*x texture { TEXTURA_METAL } }

intersection
{
box { <17,0,-5>,<27,2.5,5> }
box { <16,2.25,-4>,<28,3,-3> inverse }
box { <16,2.25,-.5>,<28,3,.5> inverse }
box { <16,2.25,3>,<28,3,4> inverse }
box { <16,.25,-4>,<28,-1,-3> inverse }
box { <16,.25,-.5>,<28,-1,.5> inverse }
box { <16,.25,3>,<28,-1,4> inverse }
#if(Estado = 0)
texture { TEXTURA_VERDE }
#else
texture { TEXTURA_AMARILLO }
#end
}

cylinder { <27,1.25,2>,<27.1,1.25,2>,.75 texture { TEXTURA_METAL } }
cylinder { <27,1.25,-2>,<27.1,1.25,-2>,.75 texture { TEXTURA_METAL } }
}

#end

Para usarlo copia el código en un fichero de texto con el nombre "Empujador.inc".

Y ahora va el código donde se compone la escena:
#include "Trieje.inc"
#include "Carril_alim.inc"
#include "Empujador.inc"

#local Est_emp = 0; // Empujador retrocedido (0) ó avanzado (1)
#local Pres_triejes = 1; // Hay triejes en el alim. (1) ó no hay triejes (0)
#local Pres_salida = 1; // Hay trieje en la salida (1) ó no hay trieje (0)

camera
{
location <25,20,-60>*2.5
direction <0,0,1>
angle 15
up <0,1,0>
right <image_width/image_height,0,0>
look_at <7,10,0>
}

light_source { <-10,50,-60> color rgb 1 }
light_source { <40,30,-30> color rgb 1 }

background { color rgb 1 }

// Se pinta la columna de triejes
#if(Pres_triejes = 1)

#local num_triejes = 1;

#while(num_triejes < 5)
object { Trieje() no_shadow translate 2.5*y*num_triejes }
#local num_triejes = num_triejes + 1;
#end
#end

// Se pinta el trieje de abajo
#if(Est_emp = 0 & Pres_triejes = 1)
object { Trieje() no_shadow }
#end

#if(Pres_salida = 1)
object { Trieje() no_shadow translate -10*x }
#end

// Se pinta la carrilera de alimentación
object { Carril_alim() no_shadow translate 3.75*y }

// Se pinta el cilindro empujador
object { Empujador(-Est_emp) no_shadow }

Para usarlo copia el código en un fichero de texto con el nombre "Alimentador.pov".

Pon todos los ficheros en un mismo directorio, doble clic sobre "Alimentador.pov" y se abre en el editor del POV-Ray. Si pulsamos el botón 'Run' se dibujará ('renderizará') la escena. Léete la ayuda para cambiar el formato de fichero de salida, las dimensiones, etc.

Para cambiar el estado de la escena están las variables 'Est_emp', 'Pres_triejes' y 'Pres_salida' al principio del fichero con sus respectivos comentarios.

Y este es mi método. El problema que tiene es que necesitas una imagen por cada estado de la máquina y a pocos movimientos que tengas el número de imágenes se dispara. Si la máquina es un poco compleja se puede planificar por zonas. También hay que tener en cuenta que debemos dibujar los actuadores lo suficientemente grandes como para poder seleccionarlos pulsando con el dedo sobre ellos.

A primera vista puede parecer tedioso, pero te aseguro que si tienes un poco de práctica no lleva mucho tiempo preparar una escena. Además, separando los objetos en ficheros es sencillo reutilizarlos.

Como siempre, agradeceré cualquier comentario, crítica o sugerencia.

7 comentarios:

  1. Me parece muy acertada la idea de aplicar render 3d en un SCADA. Con un poco de ganas y tiempo se deben de conseguir resultados realmente sorprendentes.¡Enhorabuena por tu magnífico blog y querer compartir tus vivencias en este apasionante mundillo!

    ResponderEliminar
  2. Gracias por tu comentario Principiante, has estrenado los comentarios del blog.

    La verdad es que se pueden hacer cosas muy chulas y los operarios agradecen ver la máquina representada en el panel. Lo malo es que rara vez puedo dedicar el tiempo que me gustaría a diseñar el panel.

    ResponderEliminar
  3. Buenas:
    Gracias por tu blog
    Quisiera saber si tiene algún manual dep "POV-ray". He visitado la web pero la ayuda es "on line"
    Gracias de antemano y un saludo.

    ResponderEliminar
  4. Hola pepe, se me ha despistado tu consulta, no sé si llego a tiempo, pero manuales de POVRay en castellano no conozco ninguno. Eso sí, la ayuda que viene con el programa es muy completa y muy sencilla de entender, si sabes algo inglés.

    Un saludo.

    ResponderEliminar
  5. Pregunta, los dibujos como los haces, desde un programa externo o el mismo POVRay los dibuja, y como se carga el dibujo a la pantalla con el Wincc, esto es pa lo q no sabemos cmo hacer las cosas

    ResponderEliminar
  6. Hola geoux,

    Con el POVRay genero dibujos en formato bmp y después los importo desde el WinCC Flexible como cualquier imagen.

    Para aprender a meter imágenes busca en la ayuda de WinCC un documento llamado Getting Started with WinCC Flexible (en la página web de Siemens también está disponible).

    Un saludo.

    ResponderEliminar
  7. Gracias

    Disculpa mi comentario inicial, lo primero q pense es q generabas un codigo para el wincc y generar movivientos de las figuras, despues de probar el software me di cuenta que es Render (la novates) y por consiguiente me di cuenta de mi error..

    La verdad es que estoy mas acostumbrado a trabajar con Allen Bradley y el Rsview

    saludos

    ResponderEliminar

Por favor, no pidas copias de programas comerciales, licencias o números de serie.