Inicializar LCD con controlador T6963C

Hola danrod:

Vamos a hacerlo en forma de tutorial:

Vos ya tenés la rutina glcd_put_ptr que direcciona la memoria antes de escribir o leer un byte.
Para texto se invoca en la forma:

glcd_put_ptr(T_BASE,x,y);

donde:

T_BASE es la dirección de memoria donde comienza el espacio dedicado a los caracteres,
x,y son las coordenadas de posición (columna, fila).
Un byte enviado a continuación, para escribirlo en la memoria, lo interpretará como el
código ascii de un caracter.

Si en lugar de T_BASE pusiéramos G_BASE las coordenadas x,y serían una posición de la
memoria GRAFICA.
Y el byte que se envíe a escribir, lo interpretará como una cadena de bits, cada uno
indicando el estado de un pixel del byte ubicado en esa posición, en el orden:

76543210

Ejercicio:

Haz la prueba de ejecutar esto con tu tamaño de pantalla:

Código:
main()
{
char NRO_FILS=128; // Acá van tus valores
char NRO_COLS=128; // Acá van tus valores
char ANCHO_CAR=6; // Acá van tus valores
char =N;
int x;

glcd_config(NRO_FILS,NRO_COLS,ANCHO_CAR);
// Datos via PORTB y comandos via PORTC
// Caracteres ANCHO_CAR (6 ú 8) pixels de ancho : setear igual al hardware

glcd_inicio(); // Todo deshabilitado

// Activa sólo el modo gráfico
glcd_activar(_GRAF);

// Ejercicio G-1

N = (NRO_COLS / ANCHO_CAR) + 1;
// N es la cantidad de bytes por línea horizontal, en mi caso = 22

x=1;
while(x<256)
   {
   glcd_put_ptr(G_BASE,0,0); 
   glcd_fill_byte(N,NRO_FILS,x);

   Delay_ms(200);
   x*=2;
   }
}
y contame el resultado.
Fijate que no hay rutinas nuevas, sólo un direccionamiento diferente.
 
Última edición:
OK!!! lo intentare....
Muchas gracias alejandro.......................
Te Contare con detalles lo sucedido
 
Buen dia Alejandro:
He probado el ejemplo y funciona correctamente... hace un desplazamiento de columnas.
solamente cambie la glcd_config(240,128,6,8); donde 8 es la altura y 6 el ancho tanto para mod graf/Text
De igual manera en mi caso:
glcd_put_ptr(G_BASE,0,0);
glcd_fill_byte(16,240,0);
Donde 16 son la filas y 240 las columnas
Muchs Gracias. Si puedes colaborame con mas como lineas y pixeles mejor.
Intento hacer esto y se queda bloqueado!

glcd_put_ptr(G_BASE,0,0);
glcd_paint_pixel(10,10,1);
glcd_horizontal( 5,0,5,1);
Muchas gracias.
Ademas estoy confundido en lo siguiente:
En el Doc en español "Manual de Pantallas LCD Gráficas"
Esta escrito que la pantalla tiene una memoria externa 64Kbits G-RAM el la cual es posible almacenar carateres.
Si esto es cierto, como puede grabar carateres creados (muchos carateres) y poderlos escribir como si fuese un texto o grafico cualquiera??.
Si existe la posibilidad de hacer esto, me ahoraria una memoria serial EEPROM.!!!!
Gracias por el tutorial.
 
Bueno, lo del tutorial fue una manera de decir. Je, je, no es gran cosa.
Es apenas un ejemplo.

Los algoritmos de líneas, elipses y demás, los puedes copiar de la biblioteca pública para el KS108, del sitio U-control, porque ya están optimizados.
Como dije antes la diferencia es que el T6963 arma los bytes en forma horizontal.
Comprendiendo el ejemplo anterior te das idea cómo convertir de un formato a otro. Si no te sale, basta copiar la adaptación "mía" que ya habías visto en mi página. Está en C así que, a lo sumo, es cosa de retocar detalles, como algunos tipos de variable en la pasada de argumentos, para que encastren adecuadamente. En realidad eso ya está todo "posteado".

Lo de la memoria para caracteres creados por el usuario yo aún no la he usado.
En uno de los pdf que subí antes debe estar la forma de cargarlos.
Voy a ver si luego me hago un tiempo para probar.
Justo ahora empecé a tener problemas con la tensión de contraste, así que las pruebas las tendré que hacer "a media luz".

Saludos.
 
Pefecto!!!
revizare en U Control

Gracias, estamos en contacto

Mira Alejandro. El problema inicio debido aque tengo problemas con tus rutinas para pixeles y lineas.
He transcrito tus rutinas al CCS pero no se que mas parametros requieren. Fijate:
// set or clr a single pixel in 240x128 array
void glcd_paint_pixel(int COLUMNA, int FILA, int color)
{
int16 addr; // memory address of byte containing pixel to write
int valor;
int16 bufer;
int resto;
valor = COLUMNA;
bufer = 0;
while( valor - _H_PIXEL >= 0 )
{
valor = valor - _H_PIXEL;
bufer = bufer + 1;
}
resto = valor ; //bufer = column/6;
addr = calcular_pos_mem( G_BASE + bufer,FILA );
// Calcula posición del puntero Text/Graf
//int16 calcular_pos_mem(int16 BASE, int FILA);
dput(addr%256);dput(addr>>8);cput(0x24); // set LCD addr. pointer
resto = _H_PIXEL - 1 - resto; //resto = 5 - column% _H_PIXEL;
if (color==1)
{
cput( 0xf8 | resto ); // set bit-within-byte command
}
else
{
cput( 0xf8 & ~resto ); // clr bit-within-byte command
}
} // lcd_paint_pixel
////////////////////////

void glcd_horizontal( int y_pix,int x_min,int x_max,int color)
{
int x_pix;
for(x_pix=x_min;x_pix<=x_max;x_pix++)
{
glcd_paint_pixel(x_pix,y_pix,color);
}
}
// ----------------------------------------------------------------
void glcd_vertical(int x_pix,int y_min,int y_max,int color)
{
//esto lo quite yo
int y_pix;
// if (color>1)
// {
// color=1;
// }
for(y_pix=y_min;y_pix<=y_max;y_pix++)
{
glcd_paint_pixel(x_pix,y_pix,color);
}
}
77*********************************************************************

Pero no se que mas parametros previos debo configurar.Cuando hago esto se queda el micro bloqueado:
.........
glcd_config(240,128,6,8);
glcd_inicio(); // Todo deshabilitado
glcd_activar(_GRAF);// Activa sólo el modo gráfico
glcd_put_ptr(G_BASE,0,0);
glcd_fill_byte(16,240,0); //OK limpia modo grafico
glcd_horizontal( 1,2,5,1); //Desde aqui queda bloqueado<
glcd_paint_pixel(10,10,1);
...................................
Este es el problema que tengo
Revize las rutinas y por logica estan bien, el problema es que no hacen lo que deberian hacer debido a que no se si requieren parametros previos.
Esa es la inquietud... como utilizar tus rutinas para pixeles y lineas?????.
 
Última edición:
Perdona que no revisé el tema en estos días. Al fusionarse tus mensajes me aparecía como leido.

Te paso las que tengo yo, ya convertidas para PIC. Son las adaptaciones de mi primer biblioteca en "C". Estas NO usan los algoritmos optimizados de la U-control. Por eso pueden ser algo más lentas.
Veremos si pasan tu test de "Manhattan" !!!

Eso sí, las pruebas hacelas en lo posible en físico, para no tener sorpresas con los simuladores, como las ya vividas.

Y trata de no usar protoboard para los pics. Lo mejor es hacerse una placa genérica, bien simple pero con todo lo necesario para conectar el display.

En el programa se dibujan elipses, que usan la rutina de dibujar pixels.

...

También fijate este proyecto.

...

Salud y €uros (antes pesetas) !
 

Adjuntos

  • Arranque Texto y Graficos.zip
    7.8 KB · Visitas: 117
Última edición:
Perdona que no revisé el tema en estos días. Al fusionarse tus mensajes me aparecía como leido.

Te paso las que tengo yo, ya convertidas para PIC. Son las adaptaciones de mi primer biblioteca en "C". Estas NO usan los algoritmos optimizados de la U-control. Por eso pueden ser algo más lentas.
Veremos si pasan tu test de "Manhattan" !!!

Eso sí, las pruebas hacelas en lo posible en físico, para no tener sorpresas con los simuladores, como las ya vividas.

Y trata de no usar protoboard para los pics. Lo mejor es hacerse una placa genérica, bien simple pero con todo lo necesario para conectar el display.

En el programa se dibujan elipses, que usan la rutina de dibujar pixels.

...

También fijate este proyecto.

...

Salud y €uros (antes pesetas) !

Hola Alejandro> tus rutinas son similares a las que tena antes, No me funcionaban debido a que yo las habia modificado, entonces logre hacerlas funcionar comparando los parametros que habia modiicado.
Muchas Gracias
Queria preguntarte si sabes algo del almacenamiento en la memoria GRAM de la pantalla????..............
Muchas gracias
 
Entre la documentación del proyecto anterior está el pdf del display.
Yo ya lo tenía, es el que usé cuando no tenía idea de nada.
Al final está cómo guardar caracteres generados por el usuario.
Te subo en un PDF la traducción del apartado 5.7 de ese documento.

Lo que veo es que el lugar para cualquier caracter es de 8x8, aunque luego guardes NxM (p.ej. 3x5). En este último caso hay que tener en cuenta las dimensiones para posicionar el byte que se va a leer y luego reescribir.
Voy a ver en estos días si pruebo de grabar a ver qué sale.

Saludos.

PD: Probaste de mandar bitmaps al display ?
 

Adjuntos

  • CGRAM_5_7.pdf
    71.6 KB · Visitas: 67
Última edición:
Entre la documentación del proyecto anterior está el pdf del display.
Yo ya lo tenía, es el que usé cuando no tenía idea de nada.
Al final está cómo guardar caracteres generados por el usuario.
Te subo en un PDF la traducción del apartado 5.7 de ese documento.

Lo que veo es que el lugar para cualquier caracter es de 8x8, aunque luego guardes NxM (p.ej. 3x5). En este último caso hay que tener en cuenta las dimensiones para posicionar el byte que se va a leer y luego reescribir.
Voy a ver en estos días si pruebo de grabar a ver qué sale.

Saludos.

PD: Probaste de mandar bitmaps al display ?

Gracias por la info... si he probado, con un logo que encontre con otras rutinas, pero no utiliza la GRAM... yo tengo los caracteres 3X5 en una tabla q utliza 6X8. Intentare hacer algo tambien si algo sale.... pero, se se pueden guardar muchos caracteres o imagenes????
 
Gracias por la info... si he probado, con un logo que encontre con otras rutinas, pero no utiliza la GRAM... yo tengo los caracteres 3X5 en una tabla q utliza 6X8. Intentare hacer algo tambien si algo sale.... pero, se se pueden guardar muchos caracteres o imagenes????

El tamaño depende de la cantidad de memoria que deje libre el programa, porque las imágenes las cargás en la FLASH-RAM del micro. Salvo que te compliques con una memoria externa.

Ya que la tenés, por qué no me posteás la tabla de 3x5, a ver si la puedo cargar yo en mi display (todavía no le arreglé el tema del contraste). Desde ya gracias!

Saludos
 
Última edición:
El tamaño depende de la cantidad de memoria que deje libre el programa, porque las imágenes las cargás en la FLASH-RAM del micro. Salvo que te compliques con una memoria externa.

Ya que la tenés, por qué no me posteás la tabla de 3x5, a ver si la puedo cargar yo en mi display (todavía no le arreglé el tema del contraste). Desde ya gracias!

Saludos

OK....... organizare la info y te la paso
....................................
pero, la GRAM segun entiendo una vez se quita la energia se borran los datos? o se consideraria como una EEPROM?
Lo otro: Se almacenan los datos como caracteres de usuario?????
Disculpa no habia revizado el correo antes......
 
El tamaño depende de la cantidad de memoria que deje libre el programa, porque las imágenes las cargás en la FLASH-RAM del micro. Salvo que te compliques con una memoria externa.

Ya que la tenés, por qué no me posteás la tabla de 3x5, a ver si la puedo cargar yo en mi display (todavía no le arreglé el tema del contraste). Desde ya gracias!

Saludos

Disculpa la tardanza......... aqui los tienes, sirben perfectamente
 

Adjuntos

  • carateres3x5.txt
    16.2 KB · Visitas: 52
Hola, tengo un Display gráfico con el controlador T6963. He hecho unos programas con C y están simulados con Proteus, funcionan perfectamente, pero en la realidad el GLCD parece ser que absorbe ruido y me llena toda la pantalla de pixels. En breve adjuntaré unas fotos y a ver que me consejo me dais para poder arreglar dicho entretuerto
 
Ayudate con un buffer, por ejemplo el 72ls244. A veces los micros tienen muy bajas corrientes de salida y los niveles oscilann en las fronteras de histeresis de las compuertas de entrada del lcd.
 
Hola, tengo un Display gráfico con el controlador T6963. He hecho unos programas con C y están simulados con Proteus, funcionan perfectamente, pero en la realidad el GLCD parece ser que absorbe ruido y me llena toda la pantalla de pixels. En breve adjuntaré unas fotos y a ver que me consejo me dais para poder arreglar dicho entretuerto

Me parece raro que sea ruido.
Para direccionar un dato en la memoria se requiere una secuencia que no es nada casual.
Si te va ruido a los cables de comunicación (bits _WR, _RD, _EN, C_D) directamente no ves
nada.

Si lo que te muestra al principio es un patrón aleatorio fijo, entonces es lo que había en la
memoria luego de estar un buen rato apagado.
Eso se resuelve fácil: Asegurate que la primera tarea sobre el display, luego de darle
alimentación y antes de activarlo (mostrar por pantalla), sea llenar toda su memoria
con ceros, un bitmap u otro contenido que corresponda.

Saludos
 
Última edición:
He solucionado el problema, he puesto como puerto analógico de entrada una línea con salida al LCD. Un despiste. Pero por otra parte lo que comentas Alejandro de cargar un bitmap, me gustaria saber como. Gracias por las respuestas
 
Paso nº1: Generar el bitmap monocromo (blanco y negro) de un tamaño que quepa en tu LCD.
Eso se puede hacer hasta con el Paint.

Por ejemplo, mi logotipo (en su versión de 64x64 pixels):


Paso nº2: Convertirlo en el formato que estás programando (ASM o C)

Para esto se puede usar un programa específico como el que trae
incorporado mikroC. O tal vez te sirva este que se baja gratis y anda ok.
Código:
// ------------------------------------------------------------
// GLCD Model: Toshiba T6963C 128x128=16384
// ------------------------------------------------------------

unsigned char const BITMAP[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3F, 0xFE, 0x00, 0x00, 0x00,
0x00, 0x00, 0x03, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xFF, 0xF8, 0x00, 0x00,
0x00, 0x00, 0x7F, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,
0x00, 0x03, 0xFF, 0xF8, 0x1F, 0xFF, 0xC0, 0x00, 0x00, 0x07, 0xFF, 0x00, 0x00, 0xFF, 0xE0, 0x00,
0x00, 0x0F, 0xFC, 0x00, 0x00, 0x1F, 0xF0, 0x00, 0x00, 0x1F, 0xE0, 0x00, 0x00, 0x0F, 0xF8, 0x00,
0x00, 0x3F, 0xC0, 0x00, 0x00, 0x03, 0xFC, 0x00, 0x00, 0x7F, 0x80, 0x00, 0x00, 0x00, 0xFE, 0x00,
0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x01, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x80,
0x01, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x1F, 0x80, 0x03, 0xF1, 0xFF, 0xF0, 0x00, 0x00, 0x0F, 0xC0,
0x07, 0xE1, 0xFF, 0xF0, 0x00, 0x00, 0x0F, 0xE0, 0x07, 0xE1, 0xFF, 0xF0, 0x00, 0x00, 0x07, 0xE0,
0x0F, 0xC1, 0xFF, 0xF0, 0x00, 0x00, 0x03, 0xF0, 0x0F, 0x81, 0xFF, 0xF0, 0x00, 0x00, 0x01, 0xF0,
0x0F, 0x81, 0xE1, 0xF0, 0x00, 0x00, 0x01, 0xF8, 0x1F, 0x81, 0xE0, 0xF0, 0x00, 0x00, 0x00, 0xF8,
0x1F, 0x01, 0xE0, 0xF0, 0x00, 0x00, 0x00, 0xF8, 0x1F, 0x01, 0xE0, 0xF0, 0x00, 0x00, 0x00, 0xF8,
0x3E, 0x01, 0xE0, 0xF0, 0x20, 0x00, 0x00, 0x7C, 0x3E, 0x01, 0xE0, 0xF0, 0x70, 0x00, 0x00, 0x7C,
0x3E, 0x01, 0xE0, 0xF0, 0x70, 0x00, 0x00, 0x7C, 0x3E, 0x01, 0xE0, 0xF0, 0xF8, 0x00, 0x00, 0x7C,
0x3E, 0x01, 0xE0, 0xF0, 0xF8, 0x00, 0x00, 0x7C, 0x3E, 0x01, 0xE0, 0xF0, 0xF8, 0x00, 0x00, 0x3C,
0x3C, 0x01, 0xE0, 0xF1, 0xFC, 0x00, 0x00, 0x3C, 0x3C, 0x01, 0xE0, 0xF1, 0xFC, 0x7F, 0xFF, 0xBC,
0x3C, 0x01, 0xE0, 0xF1, 0xFC, 0x7F, 0xFF, 0xFC, 0x3D, 0xFF, 0xE0, 0xF3, 0xFE, 0xFF, 0xFF, 0xFC,
0x3F, 0xFF, 0xE0, 0xF3, 0xFF, 0xFF, 0xFF, 0xFC, 0x3F, 0xFF, 0xE0, 0xF3, 0xFF, 0xFF, 0xFF, 0xFC,
0x3F, 0xFF, 0xE0, 0xF7, 0xDF, 0xFF, 0xFF, 0x7C, 0x3F, 0xFF, 0xE0, 0xF7, 0x9F, 0xE0, 0x00, 0x7C,
0x3E, 0x00, 0x00, 0xFF, 0x8F, 0xE0, 0x00, 0x7C, 0x3F, 0x00, 0x00, 0xFF, 0x8F, 0xC0, 0x00, 0xFC,
0x1F, 0x00, 0x00, 0xFF, 0x0F, 0xC0, 0x00, 0xF8, 0x1F, 0x00, 0x00, 0xFF, 0x07, 0x80, 0x00, 0xF8,
0x1F, 0x80, 0x00, 0xFE, 0x07, 0x80, 0x01, 0xF8, 0x0F, 0x80, 0x00, 0xFE, 0x07, 0x80, 0x01, 0xF0,
0x0F, 0xC0, 0x00, 0xFC, 0x03, 0x00, 0x03, 0xF0, 0x07, 0xE0, 0x00, 0xFC, 0x00, 0x00, 0x07, 0xE0,
0x07, 0xE0, 0x00, 0x7C, 0x00, 0x00, 0x07, 0xE0, 0x03, 0xF0, 0x00, 0x78, 0x00, 0x00, 0x0F, 0xC0,
0x03, 0xF8, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xC0, 0x01, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x3F, 0x80,
0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x7F, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFE, 0x00,
0x00, 0x7F, 0xC0, 0x00, 0x00, 0x03, 0xFC, 0x00, 0x00, 0x3F, 0xE0, 0x00, 0x00, 0x07, 0xFC, 0x00,
0x00, 0x1F, 0xF8, 0x00, 0x00, 0x1F, 0xF8, 0x00, 0x00, 0x0F, 0xFE, 0x00, 0x00, 0xFF, 0xE0, 0x00,
0x00, 0x03, 0xFF, 0xF0, 0x07, 0xFF, 0xC0, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x00,
0x00, 0x00, 0x7F, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFF, 0xFF, 0xF8, 0x00, 0x00,
0x00, 0x00, 0x07, 0xFF, 0xFF, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
// ----------------------------------------------------------------
NOTA: En el T6963C cada número del arreglo codifica una linea horizontal de 8 bits.


Paso nº3: Guardar el archivo con cualquier nombre y extensión.

Ejemplo: Logotipo.txt


Paso nº4: Incluir el archivo dentro del código principal, lo más al principio que sea posible.

Ejemplo:
Código:
 #include <pic.h>
#include "Logotipo.txt"


Paso nº5: En el punto del programa que sea conveniente invocar una rutina
que cargue el bmp en la memoria gráfica.

Ejemplo:

Rutina para carga de un sprite en C

Código:
// ----------------------------------------------------------------
void glcd_draw_sprite(unsigned short x0, unsigned short y0,
     unsigned char *array, unsigned short NCOLS, unsigned short NFILS )
{
    unsigned short i,j;
    unsigned char y2;
    glcd_put_ptr(G_BASE, x0, y0);
    y2 = 0;
    for (j=0;j<NFILS;j++)
        {
        y2= y2 + NCOLS;
        for (i=0;i<NCOLS;i++)
            {
            dput(array[y2+i]);cput(0xc0);
            }
        }
}
// ----------------------------------------------------------------
Esta rutina se invoca una vez inicializado el GLCD, en la forma:

glcd_draw_sprite(x0, y0,BITMAP,Lx,Ly);

Donde:

* x0, y0 son las coordenadas del vértice superior izquierdo del bitmap,
medidas en pixels desde el vértice superior izquierdo de la pantalla.
x0 es hacia la derecha
y0 es hacia abajo
Para que quede centrado: x0=y0=32.

* BITMAP es el nombre del arreglo definido en el código.

* Lx, Ly son las dimensiones del bitmap en pixels, horiz. y vert. respectivamente.
En este caso Lx=Ly=64.

Saludos
 
Última edición:
Atrás
Arriba