Notas previas
Bien veamos pues como mejorar los Scripts. Lo que sigue implica el uso de funciones avanzadas del LCHype, por lo que se debe recurrir a programación un poco más compleja, pero trataré de simplificar para que se entienda mejor. En intervenciones anteriores he puesto ejemplos de scripts que incluyen lineas para representar temperatura o el uso del CPU, pero no he profundizado en su construcción.
Gráficos lineales
En el caso que nos ocupa: los LCD de nokia; debido al tamaño tan reducido, resulta más práctico usar los datos en forma gráfica que escrita. Una forma bastante sencilla es la representación de una variable en forma de un gráfico lineal que da a los scripts una mejor presentación y permite explotar mejor el limitado espacio.
Hay que recordar algo de geometría para entender como funciona el trazado de lineas. Una linea consta de un punto inicial (X0, Y0) y de un punto final (XF, YF). Tomemos una variable como por ejemplo la temperatura del CPU a lo largo del tiempo para que esto sea más claro.
Las instrucciones que nos permiten trazar el punto inicial y final de la linea se obtienen de esta forma:
Coordenada inicial (X0, Y0) o Pixel inicial
Ruta en el listado de instrucciones:
Gráfico/Pen propiedades
Linea de comando obtenida:
Coordenada final (XF, YF) o Pixel final
Ruta en el listado de instrucciones:
Gráfico/Linea
Linea de comando obtenida:
El contenido de la instruccion es:
(XF, YF, color del pixel)
El
color del pixel en ambos casos es:
1 para color
negro y 0 para
blanco
Tracemos una linea cuyo pixel inicial es (5,15) y final (25, 35)
Código:
#Header
%Param.RenderMode(Simple)
%Graph.SetTextArea(0,0,84,48)
%Graph.Font('Arial',7,1)
%Common.SetPriority(1000)
#EndHeader
#GfxMode
%Graph.Pen(5,15,1)
%Graph.LineTo(25,35,1)
#EndGfxMode
Bueno compliquemos las cosas un poco. Si el extremo inicial y final de la linea cambian dentro del mismo script, podemos obtener figuras diferentes a un rectángulo. En el script siguiente, el punto final es el punto inicial de la linea siguiente:
Código:
#Header
%Param.RenderMode(Simple)
%Graph.SetTextArea(0,0,84,48)
%Graph.Font('Arial',7,1)
%Common.SetPriority(1000)
#EndHeader
#GfxMode
%Graph.Pen(5,15,1)
%Graph.LineTo(25,35,1)
%Graph.Pen(25,35,1)
%Graph.LineTo(45,35,1)
%Graph.Pen(45,35,1)
%Graph.LineTo(15,5,1)
%Graph.Pen(15,5,1)
%Graph.LineTo(5,15,1)
#EndGfxMode
Sabemos que la Temperatura del CPU cambia con el paso del tiempo. Este comportamiento lo podemos llevar al LCD en forma lineal. Para ello debemos definir las variables: tiempo y temperatura del CPU.
Manejo del tiempo en un gráfico lineal
El tiempo como tal, no lo podemos obtener en forma directa. Podemos usar el segundero del reloj, pero al llegar al segundo 60, nos veremos en aprietos ya que no obtendremos 60 sino 0, asi que el trazado de una linea de esta forma se limita a un tamaño de 59 conteos, obligando a un "reset" del gráfico, para que resulte visualmente correcto.
Pero mediante programación, podemos definir un
contador que vaya cambiando conforme cambia el tiempo y que no nos limite a solo 59 datos.
El siguiente es un ejemplo de script que incorpora un contador de tiempo.
Código:
#Header
%Param.RenderMode(Simple)
%Graph.SetTextArea(0,0,84,48)
%Graph.Font('Arial',7,1)
%Common.SetPriority(1000)
/Actualizacion de pantalla cada 1000 milisegundos o bien cada segundo/
%DefVar(Contador=0)
#EndHeader
#GfxMode
/incremento del contador/
%Assign(Contador,%Inc(%Contador(), 1))
"Segundos: "%Contador()
#EndGfxMode
En este caso he definido una actualización de pantalla cada 1000 mili segundos (o sea cada 1 segundo). Hay que tener en mente este punto, Dependiendo del valor que asignemos a la prioridad del script, será el tiempo que represente el contador.
Asi pues, para obtener el tiempo total transcurrido hay que multiplicar el contador por el tiempo asignado a la prioridad.
Ya tenemos entonces definida la variable:
tiempo. Resta anexar la variable que queremos monitorear en el gráfico lineal, en este caso la temperatura del CPU
Código:
#Header
%Param.RenderMode(Simple)
%Graph.SetTextArea(0,0,84,48)
%Graph.Font('Arial',7,1)
%Common.SetPriority(1000)
/Actualizacion de pantalla cada 1000 milisegundos o bien cada segundo/
%DefVar(Contador=0)
#EndHeader
#GfxMode
/incremento del contador/
%Assign(Contador,%Inc(%Contador(), 1))
"Segundos: "%Contador()
/Variable a monitorear/
%Common.CreateNewLine()
"Temperatura CPU: "%UsePlugin('mbm\mbm.dll',mbmTemperature2)"ºC"
#EndGfxMode
Ahora introduzcamos los datos al código. Para ello debemos definir la coordenada a partir de la que se trazará el gráfico en el LCD.
La posición X inicial, la define el contador. Por ejemplo, si el contador inicia en 0, el gráfico iniciará en el pixel 0. Veamos pues como queda el script al incorporar las variables tiempo y temperatura para representar una linea
Código:
#Header
%Param.RenderMode(Simple)
%Graph.SetTextArea(0,0,84,48)
%Graph.Font('Arial',7,1)
%Common.SetPriority(1000)
/Acumula tiempo y define posición inicial X/
%DefVar(Contador=0)
/Posición inicial Y para la temperatura del CPU/
%DefVar(YTCPU=16)
#EndHeader
#GfxMode
/Actualiza la pantalla cuando llega al pixel 84/
%Common.ChangeScreen(84000,93)
%Assign(Contador,%Inc(%Contador(), 1))
"Seg: "%Contador()"\"%UsePlugin('mbm\mbm.dll',mbmTemperature2)"ºC"
%Graph.Pen(%Contador(),%YTCPU(),1)
%Assign(YTCPU,%UsePlugin('mbm\mbm.dll',mbmTemperature2))
%Graph.LineTo(%Contador(),%YTCPU(),1)
#EndGfxMode
El script anterior, muestra una linea invertida, los picos con valores altos están hacia abajo y siempre se mostrará en el mismo rango de pixeles, no importa el valor inicial de la variable
YTCPU, que controla la posición Y inicial del al linea.
Para corregir este comportamiento, debemos introducir una variable de corrección. La forma de hacerlo es restando a un valor mas alto el valor de la variable temperatura. He introducido una operación de resta dentro de la linea de comando que actualiza el valor de la temperatura.
Código:
%Assign(YTCPU,%Dec(45,%Trunc(%Div(%UsePlugin('mbm\mbm.dll',mbmTemperature2),1))))
Este sencillo ajuste a la linea de comando, incorpora una doble función:
primero permite que las lineas no se ven invertidas y los picos de temperatura altos, se muestren hacia arriba, mostrando gráficos visualmente correctos y adecuados al texto e imágenes y
segundo: posibilita el hecho de que podamos mover la linea hacia donde queramos. al aumentar o disminuir el valor del sustrato.
Por ejemplo, si la temperatura del CPU es 30ºC, al restar 45 - 30 = 15, estamos haciendo que la linea se dibuje en el pixel 15. Si al siguiente segundo, la temperatura sube a 47ºC, tenemos: 45 - 47 = -2. Esto significa que la linea no se verá dentro del LCD, sino que se saldrá de la pantalla.
Para que la linea quede dentro de pantalla, hay que incrementar el sustrato, a digamos 50, así, los 47ºC se dibujarán en el pixel: 50 - 47 = 3, o sea dentro del área del LCD.
El efecto que se consigue es el de una linea te temperatura que cambia con el tiempo. Asi queda el script con la corrección:
Código:
#Header
%Param.RenderMode(Simple)
%Graph.SetTextArea(0,0,84,48)
%Graph.Font('Arial',7,1)
%Common.SetPriority(1000)
/Acumula tiempo y define posición inicial X/
%DefVar(Contador=0)
/Posición inicial Y para la temperatura del CPU/
%DefVar(YTCPU=28)
#EndHeader
#GfxMode
/Actualiza la pantalla cuando llega al pixel 84/
%Common.ChangeScreen(84000,93)
%Assign(Contador,%Inc(%Contador(), 1))
"Seg: "%Contador()"\"%UsePlugin('mbm\mbm.dll',mbmTemperature2)"ºC"
%Graph.Pen(%Contador(),%YTCPU(),1)
/Ajuste de altura de la linea y corrección del valor representado/
%Assign(YTCPU,%Dec(45,%Trunc(%Div(%UsePlugin('mbm\mbm.dll',mbmTemperature2),1))))
%Graph.LineTo(%Contador(),%YTCPU(),1)
#EndGfxMode
hay que ajustar el número del Script al valor del script que tengan para este ejemplo, en mi caso el script es el número
93
Aplicando el Script
Ahora todo estará completo cuando introduzcamos un BMP adecuado que permitirá complementar el Script. He ajustado un poco el Script para mejorar la presentación.
Código:
#Header
%Param.RenderMode(Simple)
%Graph.SetTextArea(0,0,84,48)
%Graph.Font('Arial',7,1)
%Common.SetPriority(1000)
/Acumula tiempo y define posición inicial X/
%DefVar(Contador=8)
/Posición inicial Y para la temperatura del CPU/
%DefVar(YTCPU=28)
/Carga de BMP de fondo/
%Graph.LoadBitmap('linea.bmp',0,0,0,0,84,48,0,NONE)
#EndHeader
#GfxMode
/Actualiza la pantalla cuando llega al pixel 84/
%Common.ChangeScreen(74000,93)
%Assign(Contador,%Inc(%Contador(), 1))
%Graph.Pen(%Contador(),%YTCPU(),1)
/Ajuste de altura de la linea y corrección del valor representado/
%Assign(YTCPU,%Dec(55,%Trunc(%Div(%UsePlugin('mbm\mbm.dll',mbmTemperature2),1))))
%Graph.LineTo(%Contador(),%YTCPU(),1)
%Common.CreateNewLine(1,21,32)"CPU: " %UsePlugin('mbm\mbm.dll',mbmTemperature2)"ºC"
#EndGfxMode
Cada pixel representa 1ºC. La incorporación del BMP de fondo, permite que la linea dibujada tome un sentido dentro del script.
Notas finales:
Esta es una forma sencilla de obtener lineas. Existe una forma aun más compleja que recurre al uso de listas de datos. El uso de las listas, permite obtener lineas con mejores características visuales. En la siguiente veremos como construir Scripts más complejos pero a la vez más funcionales.
, y aún no he podido localizar el correcto)
