MANEJO DE PANTALLAS GRAFICAS

La presente nota trata sobre un POWERTIP PG12864 (128x64 pixeles)

Este GLCD está basado en el controlador Hitachi HD6102 o el clon de este el Samsung KS0108. Tiene dos controladores, uno controla la parte izquierda y el otro la parte derecha, en general se parece mucho al ya conocido HD44780 controlador de pantalla alfanumérica, pero este agrega tres señales nuevas, las señales CS1 y CS2 para la activación de los chips de pantalla, una señal I/D que es el equivalente a RS en los alfanuméricos y una señal de RESET muy útil a la hora de inicializar el GLCD.

Una diferencia importante en estas pantallas es la tensión de contraste que debe estar en el orden de los -8v, afortunadamente el PG12864 tiene su propio generador para el voltaje de contraste. Cada display tiene dos páginas de 64 columnas que van desde la dirección 0x40 a 0x7F esto conforma la dirección “Y”, que básicamente es como un contador que se auto incrementa de manera automática al escribir en la pantalla de tal forma que la coordenada “Y” se auto ajusta. En el caso de la coordenada “X” las cosas son un poco diferentes, no hay auto ajuste en esta coordenada y son 8 segmentos de 8 bits verticales. Para entender mejor, imaginemos que cada byte en cada segmento está colocada en una de las 64 columnas de la coordenada “Y”.

Pagina 1 de 17

La página 0 de la coordenada “X” ocupa la dirección 0xB8 luego 0xB9......... hasta 0xBF. Veamos el siguiente esquema, aquí hay un byte con el binario 10101010 cada uno de estos bit´s del byte vertical tendrá incidencia en un pixel de la pantalla . Un uno lógico es un pixel activo un cero lógico es un pixel apagado. Es importante entender que el segmento o pagina “X 0” en la dirección 0xB8 tiene 64 bytes verticales correspondiendo cada uno de ellos a una columna de la coordenada “Y” por tanto cada segmento “X” puede controlar 512 pixeles los ocho segmentos controlan 4096 pixeles en cada mitad de la pantalla, cada controlador puede manejar 4096 pixeles y claro está la pantalla tiene un total 8192 pixeles que se manejan con los dos controladores de pantalla. En el ejemplo se puede ver como se encienden y apagan 8 pixeles en la pagina 0 del eje “X” y en la columna 35 de la coordenada “Y”. Para la correcta operación de estas pantallas es importante respetar el diagrama de tiempos que el fabricante recomienda.

Pagina 2 de 17

Se puede ver aquí claramente que el ciclo de activación del pin E como mínimo dura 1uS (1000nS) toda operación sobre la pantalla está condicionada a esta ventana de tiempo total, mas allá claro de los tiempos individuales de cada una de las funciones que se deben respetar pero todo dentro de la ventana de tiempo de E. Las condiciones de RESET se pueden observar aquí, donde vemos que el pulso de reset debe finalizar luego de 1uS de puesta la alimentación en la pantalla. El reset ocurre por nivel bajo.

Pagina 3 de 17

Como alimentar la pantalla y el voltaje de contraste:

Como manejar la pantalla: El mayor problema que presenta el manejo de estas pantallas radica en que se debe disponer de mucha memoria en el dispositivo de control del GLCD, ya sea el microcontrolador o el procesador que se conecte a el debe ser capaz de manejar la información necesaria para “pintar” los pixeles. Cada grupo de 8 pixeles requiere de una posición de memoria para almacenarlo (cada uno de estos bytes verticales debe ser guardado para reproducir la imagen). Para pintar una pantalla completa, digamos un marco de fondo donde se pintaran los datos se necesitan de 1024 bytes. (1024 x 8 = 8192 pixeles disponibles en la pantalla). Un ejemplo de esto puede verlo aquí. En la imagen superior se observa la pantalla funcionando mostrando un fondo y el despliegue del dato capturado desde el conversor A/D. En la imagen blanco y negro se observa la pantalla de fondo tal cual como se la creo con el Paint de Windows. Esta imagen se dibuja con cualquier programa, lo importante es que la imagen debe ser Blanco y Negro y desde luego debe respetar el tamaño de pantalla, en este caso la pantalla es 128x64 pixeles.

Pagina 4 de 17

Como termina la imagen en ByN dentro de la memoria del microcontrolador?. Aquí la respuesta:

Se utiliza para esto un software decodificador GLC_EDITOR con el se toma la imagen en ByN y se la decodifica en una secuencia de números hexadecimales que conformaran los bytes cuyos bit´s activaran los pixeles. Cuando tenemos nuestra imagen decodificada solo tenemos que copiar la secuencia de números y pegarla de la siguiente forma para generar un string de 1024 números que formará la imagen de fondo en la pantalla gráfica. (Estamos suponiendo que nuestro lenguaje de programación en C). const char display[1024]={ 0xFF,0x01,0x01,0x01,0x01,0x01,0x01,0x01, 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01, 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0xC1, 0xC1,0xE1,0xE1,0xE1,0xE1,0xA1,0x21,0x61, 0xC1,0xC1,0x81,0x01,0x01,0x01,0x01,0x01, 0xC1,0x61,0x31,0x11,0x91,0x91,0x91,0x91, 0xF1,0x01,0xF9,0x89,0x89,0xF9,0x01,0x01, 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01, 0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,

Pagina 5 de 17

0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0xFE,0xFF,0xFF, 0xFF,0xFF,0xEF,0xC7,0xEF,0xFF,0xFF,0xFE, 0x00,0x01,0x01,0xFF,0x00,0x00,0x0E,0x0B, 0xF9,0x00,0x00,0xF9,0x09,0x0B,0x0E,0x00, 0x0F,0x09,0x09,0xF9,0x01,0xFE,0x00,0x00, 0x00,0x00,0xFF,0x01,0xCF,0x24,0x12,0x0B, 0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x07, . . . . . . .

Para los caracteres el enfoque es similar, elegimos un carácter desde windows y luego creamos una plantilla y la decodificamos con el mismo programa. Supongamos que buscamos decodificar esta secuencia de números. Esto decodificará caracteres de 16x8 pixeles. Generando una secuencia de 30 bytes donde los 15 primero bytes son la mitad superior del carácter y los restantes 15 la parte inferior del carácter. Un carácter de este formato ocupa dos segmentos “X” (dos renglones) y tomaran 8 columnas en “Y”. El resultado final será este: const char dos [30]={

//Esto codifica el número 0

0x00,0x30,0x3C,0x3C,0x1E,0x0E,0x0E,0x8E,0x8E,0xCE,0xFC,0xFC,0x78,0x00,0x00, // Mitad superior 0x00,0x78,0x7C,0x7E,0x7E,0x77,0x77,0x73,0x73,0x71,0x71,0x70,0x70,0x00,0x00, // Mitad inferior }; const char tres [30]={

//Esto codifica el número 1

0x00,0x30,0x3C,0x3C,0x1E,0x0E,0xCE,0xCE,0xCE,0xCE,0xFE,0xFC,0x38,0x00,0x00, // Mitad superior 0x00,0x0C,0x3C,0x3C,0x78,0x70,0x71,0x71,0x71,0x79,0x3F,0x3F,0x1F,0x00,0x00, // Mitad inferior };

Para dibujar estos números solo basta colocar el cursor en la coordenada XY y recorrer el string, la coordenada Y se auto incrementa por tanto es simple, cuando llegamos al vector 15 del string debemos cambiar de coordenada X (otro renglón) y volver a definir Y dado que esta se fue modificando medida que se escribía en el primer renglón. Una forma sencilla de hacer esto es con un bucle for, veamos un ejemplo: /********************************************************************************************/

void Scan_Caracter(void){

bit_set(RS,PTD);

// Se indica que se escribe un carácter.

for(a=0;a