Control de GLCD de 128x64 puntos

Aunque son un poco mas costosos que los LCD de caracteres, pueden ser útiles a la hora de mostrar gráficamente algún parámetro, por ejemplo barras, animaciones, figuras geométricas, texto y también imágenes o fotos. 
Para manejar una imagen o foto por ejemplo tenemos que tener en cuenta que necesitamos de un microcontrolador con buena memoria y velocidad, ya que el renderisado se realiza de forma secuencial, por ejemplo el microcontrolador utilizado para este ejemplo no es suficiente para mostrar una imagen.
En este ejemplo se mostrara un voltimetro y amperimetro, dentro de unos recuadros, con texto informativo y demás.
Para este ejemplo estoy utilizando las librerías para CCS, HDM64GS12.c y graphics.c
La librería HDM64GS12, posee el control del GLCD propiamente dicho y dentro de la misma en su encabezado encontraremos el pinout del mismo para poder conectarlo. El GLCD debe tener el controlador KS0108, debemos tener en cuenta que en el pinout debe tener los pines de selección de chip CS1 y CS2.
La librería Graphics es la librería que nos permitirá dibujar y escribir en el mismo, que detallare las funciones principales de la misma (de todas formas pueden verlo en el encabezado de la librería).

Funciones para controlar el GLCD:

glcd_line(x1, y1, x2, y2, color)
Dibuja una linea desde la coordenada (x1,y1) hasta (x2,y2), la variable color puede ser ON o OFF, esta es la que habilita la linea o no (para mostrarla o no).

glcd_rect(x1, y1, x2, y2, fill, color)
Dibuja un rectángulo desde la coordenada (x1,y1) hasta (x2,y2), la variable fill es para rellenar el rectángulo si esta en YES, o solo dibuja el contorno con NO. la variable color al igual que en el resto de las funciones es la que habilita o no el rectángulo.

glcd_bar(x1, y1, x2, y2, width, color)
Dibuja una barra desde la coordenada (x1,y1) hasta (x2,y2), la variable width es el número de pixel de ancho de la barra, la variable color al igual que en el resto de las funciones es la que habilita o no la barra.

glcd_circle(x, y, radius, fill, color)
Dibuja un circulo en la coordenada (x,y), la variable radius es el numero de pixeles de radio de del circulo, a variable fill es para rellenar el circulo si esta en YES, o solo dibuja el contorno con NO. la variable color al igual que en el resto de las funciones es la que habilita o no el circulo.

glcd_text57(x, y, textptr, size, color)
Escribe texto en la coordenada (x,y), la variable textptr es la variable puntero donde esta alojado el carácter o string, a variable size es el tamaño del carácter, la variable color al igual que en el resto de las funciones es la que habilita o no el texto.

glcd_pixel(x, y, color)
Dibuja un punto o pixel en la dirección de la coordenada (x,y), la variable color al igual que en el resto de las funciones es la que habilita o no el punto o pixel.


A continuación mostrare el pinout del GLCD:

En este programa realizaremos un voltimetro y amperimetro que utilizara 2 canales ADC.

Se implementa el PIC16F887 por la cantidad de pines y puertos del mismo, recordemos que este GLCD requiere de una cantidad considerable de pines.

1. #include <16F887.h>
2. #device adc=10
3. #fuses HS,NOWDT,NOPROTECT,NOLVP
4. #use delay(clock=20000000)
5. #include <HDM64GS12.c>
6. #include <graphics.c>
7. void main(){
8.    int16 voltajeADC, voltajeADC_ant,
9.          corrienteADC, corrienteADC_ant;
10.    setup_adc_ports(sAN0|sAN1|VSS_VDD);
11.    setup_adc(ADC_CLOCK_DIV_2);
12.    char nombre[]="Electgpl";
13.    char parametro[]="   [V]       [A]   ";
14.    char voltaje[9];
15.    char corriente[9];
16.    glcd_init(ON);
17.    glcd_rect(1, 1, 127, 63, NO, ON);
18.    glcd_rect(3, 3, 125, 13, NO, ON);
19.    glcd_text57(41, 5, nombre, 1, ON);
20.    glcd_rect(3, 15, 125, 25, NO, ON);
21.    glcd_text57(8, 17, parametro, 1, ON);
22.    glcd_rect(3, 27, 125, 61, NO, ON);
23.    while(true){
24.       set_adc_channel(0);
25.       delay_us(10);
26.       voltajeADC=read_adc();
27.       if(voltajeADC_ant != voltajeADC){
28.          glcd_text57(13, 38, voltaje, 2, OFF);
29.          sprintf(voltaje, "%1.2f", (float)voltajeADC*5/1023.0);
30.          voltaje[4] = '\0';
31.          glcd_text57(13, 38, voltaje, 2, ON);  
32.          voltajeADC_ant=voltajeADC;
33.       }
34.       set_adc_channel(1);
35.       delay_us(10);
36.       corrienteADC=read_adc();
37.       if(corrienteADC_ant != corrienteADC){
38.          glcd_text57(70, 38, corriente, 2, OFF);
39.          sprintf(corriente, "%1.2f", (float)corrienteADC*5/1023.0);
40.          corriente[4] = '\0';
41.          glcd_text57(70, 38, corriente, 2, ON);  
42.          corrienteADC_ant=corrienteADC;
43.       }  
44.    }
45. }

Como podemos ver en el código fuente, incluimos las dos librerías necesarias para el GLCD, luego definimos las variables para el ADC y las variables character donde alojaremos los strings a mostrar y las dos variables dinámicas de tensión y corriente.

Luego podemos encontrar la configuración de los dos canales de ADC y seguida de la misma la primera instrucción del GLCD que sera la inicialización del mismo que lo borrara cuando el argumento de la función sea ON.

Ahora pasaremos a la función principal de loop donde se aloja el programa.

Ya que la medición de corriente como la de tensión poseen el mismo código, solo explicare una y la otra es igual.

Como podemos ver, seteamos el canal ADC a leer, esperamos los 10us para conversión segura y luego volcamos el contenido del ADC (de 0 a 1023 por estar seteado a 10bit) a la variable voltajeADC.

Por ahora voy a saltear el if y el intercambio de variables, ya que quiero demostrar de forma sencilla el funcionamiento.

La primer función para escribir de forma dinámica, necesitamos la función sprintf se utiliza para escribir strings por eso la letra s antes de printf, y aquí ingresaremos el string (en este caso voltaje[], luego le sigue el formato de dato "%1.2f" que nos dará un entero y dos decimales y por ultimo el valor que vamos a volcar al string (en este caso realizamos todo el acondicionamiento de la entrada en el mismo lugar, que es multiplicar el valor del ADC por 5V que es el fondo de escala y dividirlo por los 1023 pasos de resolución, así nos mostrara un valor de tensión de 0 a 5V).

Luego podemos encontrar el string voltaje[4] que se iguala a '\0', que se encarga de delimitar el máximo de caracteres a 4.

Ahora debemos enviar el valor que hemos convertido a string en la función sprintf a la función del GLCD glcd_text57() donde damos origen al texto en la posición (13,38), luego viene la variable string, el tamaño de la letra que le he puesto valor 2 (es un valor mediano como para que entren las dos variables) y por ultimo ON que sera el que habilita esta función para que se muestre el valor.

Ahora si nosotros cambiamos un valor por otro, que es lo que va a pasar al medir con el ADC, se sobre escribirán uno sobre el otro y no se entenderá lo que se lee, para ello es el uso del if y el intercambio de variables, como pueden ver el if es verdadero cuando el valor del ADC es distinto al ultimo valor leido por el ADC, esto es para ver si el valor cambio o no.

Una vez que es verdadero porque el valor cambia, se procede a la función glcd_text57 pero con el ultimo valor del argumento OFF ya que esto apaga e texto en ese momento y da lugar a la actualización del mismo, y luego lo pone ON y lo deja ahi hasta que se vuelva a actualizar el valor del ADC y entre al if.

De esta forma se logra actualizar en la pantalla de forma dinámica el valor.