# Inicializar LCD con controlador T6963C



## brownie (Ene 3, 2008)

Hola, tengo un problema con un LCD gráfico el MGLS128128 el cual se controla con el controlador T6963C, pero no he podido hacer que escriba lo que yo quiero, solo escribe basura y ya he intentado con todos los programas en C que he visto en los pdf's.

   Para controlarlo estoy utilizando un DSP de Texas, ya cheque que todas las señales llegaran bien y en los tiempos y ya no se que mas probar para que funcione, si alguien ya utilizo este controlador que me pudiera dar unos tips o como fue que inicializo y escribio se los agradecería mucho.


                                                                                           atte: brownie


----------



## Paloky (Ene 4, 2008)

Hola. 

Hace un par de años que utilice este mismo display para una aplicación y tengo echas mis librerias para su control.

Estoy en el trabajo y aquí no las tengo.  En cuando llege a mi casa te lo mando.

Las Librerias las hice en C para PIC's, pero supongo que te serviran igualmente para ver como funcionan las señales.

Un Saludo.


----------



## brownie (Ene 4, 2008)

Ha te lo agradecería muchísimo me ayudarias muchisimo. gracias.

                                                                                   atte: brownie


----------



## brownie (Ene 10, 2008)

Oye que paso con las librerias, ojala que pudieras mandarmelas porfavor, de antemano gracias.


----------



## Paloky (Ene 10, 2008)

Lo siento por la tardanza, pero no encuentro las librerias.
Seguramente las tengo en algún CD que no he localizado.

No te preocupes, que continuo buscando.


----------



## Paloky (Ene 15, 2008)

Hola Brownie, siento el retraso, pero ya lo he encontrado.

Lo tenia perdido en un CD del año 2003.

He encontrado unas pruebas que realize con el display y el PIC16F876. 
El programa está en Ensamblador ASM para PIC.

Espero que te sirva.

Saludos


----------



## brownie (Ene 18, 2008)

Paloky

Muchas gracias ojala si me sirva aunque ya voy avanzado y ya pude hacer graficos, pero de todos modos gracias por la atención de mandarmelo.  saludos.


----------



## Ruben Andrade (Sep 18, 2008)

Hola como estan, tengo una inquietud y es poder usar este material que se coloco aca para hacer trabajar una lcd grafica marca plotech 194v-0 , de 240 x 128 puntos. O que tendria que tener en cuenta. Gracias


----------



## brownie (Sep 18, 2008)

pues lo principal es que veas cual es el controlador que tiene si es el mismo T6963C no tendrias que cambiar nada o casi nada.


----------



## asherar (Sep 18, 2008)

Ruben Andrade dijo:
			
		

> Hola como estan, tengo una inquietud y es poder usar este material que se coloco aca para hacer trabajar una lcd grafica marca plotech 194v-0 , de 240 x 128 puntos. O que tendria que tener en cuenta. Gracias


A partir de algo que ya hemos "hablado" por MP nos podemos venir a este foro.
Vamos a ir juntando aquí los elementos más importantes y luego vemos que falta.

1.- El esquema de conexionado que dan en el foro "alemán" es el de la figura 
(EDITADO: comienzo a dudar que ese sea el esquema adecuado para tu display ..., 
sólo digo que dudo !).
"*CS*" puede ser "Column Select" o "Character Size".   
(uno que tengo de 128x64 pixels, que usa el MPU KS0108B, tiene CS1 y CS2 y es selector de columna: cols. 1 a 64 con CS1=H, y cols. 65 a 128 con CS2=H).
*Res* seguro es Reset signal. 
2.- Del esquemático del micro elegido sólo importan las conexiones al micro interno del display.
3.- Del programa en assembler sólo se deberá cambiar la parte relacionada con el lenguaje 
del micro en que se basa el GLCD. Este se *debería poder* bajar de la red. 
Yo te puedo subir un programa en C, para PC, que maneja un GLCD controlado por T6963C desde el LPT. (!)

Yo te aconsejo que te pases a C, ya que estás al principio del proyecto, y porque si el micro no es compatible va a haber varias cosas que modificar. 
Esto depende de las ganas que tengas y de con qué herramientas trabajás más cómodo.
El argumento más importante es que si la aplicación crece y necesitás memoria, los pics tienen 
un problemita con el direccionamiento de las páginas que te puede volver loco. 
El compilador C lo resuelve por tí, y santo remedio. Te lo digo por experiencia: años de renegar! 

Por lo visto la gente de los foros alemanes han tenido problemas en encontrar datos del display (por lo poco que entiendo del alemán traducido al español, con el "babylon")

Los enlaces que dan allí son estos:

http://www.lc-design.de/Sanyo_LC7981.pdf
http://www.lcd-module.de/eng/pdf/zubehoer/lc7981.pdf
http://www.lcd-module.de/deu/pdf/grafik/w160-6.pdf
http://www.datasheetcatalog.com/datasheets_pdf/L/C/7/9/LC7981.shtml
http://www.bue.de/tabdata/datasheet/ds_de_mtgrb.pdf
http://www.bue.de/support/archiv/pdf/mtgrman.pdf
http://www.pacificdisplay.com/gdm/GDM-16080-00.pdf

...und hier die Vielversprechendsten: (... y aquí los más prometedores

http://forum.lcdinformación.com/viewtopic.php?t=548
http://www.skippari.net/lcd/forumstuff/hitachi_lmg6401plge_data.png 

La hoja de datos del HD61830 (que se indica en la figura) es ésta
La hoja de datos del LC981 que está acá

----------------------------------------------------------------------------------------------------------

Pero sólo vos tenés a la vista el micro. Si usas otro patillaje podés quemar alguna I/O aplicando tensión negativa o mayor que 5V. *CUIDADO*
Ojo que puede haber otros chips en la placa, como memorias, latches y demás.
Por lo que me decís en los MP el micro que tienes es el SCN0080G y la hoja de datos que corresponde debés bajarla de internet. Yo la encontré ACÁ
En el sitio http://www.avantsemi.com.tw/. 
Ahora falta conseguir el documento que indica las instrucciones que debés mandarle a ese micro para que haga cada cosa. 

La única tabla de equivalencias entre micros que encontré es ESTA.
De donde sale que a vos te sirve el *LC7940ND/YD/YC SANYO*

Una recomendación IMPORTANTE: antes de aplicar tensión conviene verificar, téster en mano, la ruta de las patillas del micro hacia los terminales de la placa para estar seguro a qué patilla corresponde cada cosa. Por si las moscas ... 

Respecto de la alimentación negativa: podés probar con -9 V. A mi con eso me sobra. 

Saludos...


----------



## asherar (Sep 18, 2008)

Una aplicación completa con protector de pantalla y todo está en este archivo "txt"que subo.
Se puede cambiar un par de lineas y sirve para 128x128 o para 240x64 pixel.
Quien tenga una duda, no dude en plantearla! Sin dudarlo, trataré de ayudar. 

La única pregunta tonta es la que no se hace.

Saludos !


----------



## Ruben Andrade (Sep 19, 2008)

Alejandro y demas compañeros, gracias por sus comentarios. Alejandro hago caso a utilizar C en el diseño de la GLCD, tengo ya el mikroC (thanks) y estoy seguro en utilizar un GLCD mas comercial, por ejemplo uno basado en controlador T6963C. Tengo una inquietud y es que como no la he comprado aun, pienso simular en el proteus el funcionamiento del codigo, pero en proteus me salen las siguientes GLCD:
- LM 3238              128x64 graphical display (Vsm Dll model)
- LM 4228              128x64 graphical display (Vsm Dll model)
- PG12864F           128x64 graphical display (Vsm Dll model)
- LGM12641BS1R   128x64 graphical lcd con controlador ks0108 (Modelo squematico)
- HDG12864F-3     128x64 graphical lcd con controlador SED1565 (Entrada paralela)
- HDG12864l-4      128x64 graphical lcd con controlador SED1565 (Entrada Paralela)
- HDG12864L-6     128x64 graphical lcd con controlador SED1565 (Interfaz seleccionable)

Como veo que no esta el controlador T6963c del cual tengo la libreria en C en el mikroC, sera que puedo utilizar alguna de estas sin tener problemas de compatibilidad? Hasta pronto.


----------



## Ruben Andrade (Sep 19, 2008)

Señores que pena el desorden que he generado, definitivamente abrire un nuevo for ya definitivo para el desarrollo con GLCD, lo llamare LCD grafico GLCD basado en controlador KS0108 ya que mirando por ahi en el MikroC, tiene esta herramienta para generar codigo directamente de imagenes cargadas. Alla los espero.


----------



## asherar (Sep 19, 2008)

Fijate Rubén que la forma de cableado del GLCD que ponen en el mikroC es diferente a la del programa que posteé yo antes. Otros esquemas de la ayuda también muestran algunos errores (como el reset en el ejemplo del ADC). 
Yo armé una biblioteca propia para mi display basado en la hoja del T6963C, y modificando las rutinas del código C posteado antes, para adaptarlas al C de mikroC. Están disponibles en la zona de descargas de mi página. 
Buscar: *Biblioteca para Pic16F873/6/A ...* y bajarse el archivo *Bib_0y1.zip*.


----------



## picproblema (Oct 20, 2008)

Hola, yo tengo un glcd t6963cfg de 240x128. Resulta que quiero mostrar una sola letra (por ejemplo la "A") y en el lugar que yo quiera de la pantalla y la pantalla muestra 8 veces la misma letra y en cualquier lado. Subo el archivo con la libreria (escrita en C) para que la prueben (si quieren). Estoy usando el compilador CCS.


----------



## asherar (Oct 21, 2008)

picproblema dijo:
			
		

> Hola, yo tengo un glcd t6963cfg de 240x128. Resulta que quiero mostrar una sola letra (por ejemplo la "A") y en el lugar que yo quiera de la pantalla y la pantalla muestra 8 veces la misma letra y en cualquier lado. Subo el archivo con la libreria (escrita en C) para que la prueben (si quieren). Estoy usando el compilador CCS.



Hola: 
Estuve revisando tu programa. 

```
#include <16f877.h>
#use delay(clock=4000000) 
#fuses XT, PUT

const int CURSOR_PTR_SET = 0x021;	//Cursor Pointer Set: Data = X,Y
const int OFFSET_REG_SET = 0x022;   //Offset Register Set: Data = data,0
const int ADDR_PTR_SET = 0x024;   	//Address Pointer Set: Data = low, high addr

/*Control Word Set commands:-*/
const int TEXT_HOME_SET = 0x040;	//Text Home Address Set: Data = low, high addr
const int TEXT_AREA_SET = 0x041;	//Text Area Set: Data = columns, 0
const int GRAPH_HOME_SET = 0x042;   //Graphics Home address Set: Data = low, high addr
const int GRAPH_AREA_SET = 0x043;   //Graphics Area Set: Data = columns, 0

/* Mode Set commands (OR with CG rom commands):-*/
const int OR_MODE = 0x080;			//OR mode
//const int XOR_MODE = 0x081;			//XOR mode
//const int AND_MODE = 0x083;			//AND mode
//const int TEXT_ATTR_MODE = 0x084;	//Text Attribute mode
//const int INT_CG_MODE = 0x080;		//Internal CG ROM mode
//const int EXT_CG_MODE = 0x088;		//External CG ROM mode

/* Display Mode commands (OR together required bits):-*/
//const int DISPLAY_OFF = 0x090;		//display off
//const int BLINK_ON = 0x091;
//const int CURSOR_ON = 0x092;
//const int TEXT_ON = 0x094;
//const int GRAPHIC_ON = 0x098;

/*Cursor Pattern Select*/
//const int CURSOR_1LINE = 0x0A0;
//const int CURSOR_2LINE = 0x0A1;
//const int CURSOR_3LINE = 0x0A2;
//const int CURSOR_4LINE = 0x0A3;
//const int CURSOR_5LINE = 0x0A4;
//const int CURSOR_6LINE = 0x0A5;
//const int CURSOR_7LINE = 0x0A6;
//const int CURSOR_8LINE = 0x0A7;

/*Data Auto Read/Write*/
const int DATA_AUTO_WR = 0x0B0;
//const int DATA_AUTO_RD = 0x0B1;
const int AUTO_DATA_RESET = 0x0B2;

/*Data Read/Write*/
const int DATA_WR_INC = 0x0C0;	//Data write and increment addr: Data = data
//const int DATA_RD_INC = 0x0C1;	//Data read and increment addr
//const int DATA_WR_DEC = 0x0C2;	//Data write and decrement addr: Data = data
//const int DATA_RD_DEC = 0x0C3;	//Data read and decrement addr
//const int DATA_WR = 0x0C4;		//Data write - no addr change: Data = data
//const int DATA_RD = 0x0C5;		//Data read - no addr change

/*Screen Peek*/
//const int16 SCREEN_PEEK = 0x0E0;

/*Screen Copy*/
//const int16 SCREEN_COPY = 0x0E8;

/*Bit Set/Reset (OR with bit number 0-7)*/

//const int BIT_RESET = 0x0F0;
//const int BIT_SET = 0x0F8;

const int16 GRAPHICS_HOME = 0x0200;
const int16 TEXT_HOME = 0x0000;
//const int16 CGRAM_HOME = 0x1800;

const int MaxBytePorFila = 30;	//240/8=30 8 es el tamaño de letra
const int MaxCantFilas = 16;	//16=128/8 8 es el tamaño de letra
const int MaxPixelsFila = 240;

#byte	PORTC	=	0x07
#byte	TRISC	=	0x87
#bit	PORTC3	=	PORTC.3
#bit	PORTC4	=	PORTC.4
#bit	PORTC5	=	PORTC.5
#bit	PORTC6	=	PORTC.6
#bit	PORTC7	=	PORTC.7

#byte	PORTD	=	0x08
#byte	TRISD	=	0x88

//Control pin setting
#define RESET			PORTC3		// LCD RST_ line
#define RD				PORTC5		// LCD Read control line  pin number
#define WR				PORTC6		// LCD Write control line pin number
#define CD				PORTC4		// LCD Control/data Select line
#define CE		    	PORTC7

#define salidas 0x00
#define entradas 0xff

void CheckEstado();
void EnviarComando(int dato);
void EnviarByte(int dato);
void PunteroHome();
void PunteroHomeGraficos();
void Inicializar();
void Barras();
void BorraTodoGrafico(int1 dato);
void BorraTodoTexto();
void GoToXY(int x, int y);
void AutoEscribir(int dato);

void PunteroHomeGraficos(){
EnviarByte(0x00);
EnviarByte(GRAPHICS_HOME >> 8);	//parte alta de GRAPHICS_HOME
EnviarComando(ADDR_PTR_SET);
}

void PunteroHome(){
EnviarByte(0x00);
EnviarByte(TEXT_HOME >> 8);	//parte alta de TEXT_HOME
EnviarComando(ADDR_PTR_SET);
}

void EnviarByte(int dato){
TRISC = salidas;
TRISD = salidas;
CheckEstado();

PORTD = dato;

CE = 0;
WR = 0;
RD = 1;
CD = 0;

delay_us(5);

WR = 1;
CE = 1;

}

void EnviarComando(int dato){
TRISC = salidas;
TRISD = salidas;
CheckEstado();

PORTD = dato;

CE = 0;
WR = 0;
RD = 1;
CD = 1;

delay_us(5);

WR = 1;
CE = 1;
}

void CheckEstado(){
int estado = 0;
TRISC = salidas;
do{
	CE = 1;
	TRISD = entradas;
	CD = 1;
	WR = 1;
	CE = 0;
	RD = 0;
	estado = PORTD;
}while ((estado & 0x03) != 0x03);

RD = 1;
CE = 1;
TRISD = salidas;
}

void Inicializar(){
int16 c=0;
TRISC=salidas;
TRISD=entradas;

EnviarComando(OR_MODE);
EnviarComando(0x9c);

EnviarByte(0x00);
EnviarByte(GRAPHICS_HOME >> 8);	//parte alta de GRAPHICS_HOME
EnviarComando(GRAPH_HOME_SET);

EnviarByte(MaxBytePorFila);
EnviarByte(0x00);
EnviarComando(GRAPH_AREA_SET);

EnviarByte(0x00);
EnviarByte(TEXT_HOME >> 8);	//parte alta de TEXT_HOME
EnviarComando(TEXT_HOME_SET);

EnviarByte(MaxBytePorFila);
EnviarByte(0x00);
EnviarComando(TEXT_AREA_SET);

EnviarByte(0x03);
EnviarByte(0x00);
EnviarComando(OFFSET_REG_SET);

EnviarByte(0x00);
EnviarByte(0x00);
EnviarComando(CURSOR_PTR_SET);

EnviarByte(0x00);
EnviarByte(0x00);
EnviarComando(ADDR_PTR_SET);

EnviarComando(DATA_AUTO_WR);
for(c=0;c<0x1fff;c++)
{
AutoEscribir(0x00);
}
EnviarComando(AUTO_DATA_RESET);
}

void BorraTodoGrafico(int1 dato){
//bit 3 = 1 toda la pantalla "negra", bit 3 = 0 se borra
int a = 0, b = 0, reg = 0;

PunteroHomeGraficos();
if (dato != 0){
reg = 0xff;
}
else{
reg = 0x00;
}
for(a=0;a<128;a++)
{
	for(b=0;b<MaxPixelsFila;b++)
	{
		EnviarByte(reg);
		EnviarComando(DATA_WR_INC);
	}
}
}

void BorraTodoTexto(){
int t = 0, t1 = 0, reg = 0;

PunteroHome();
for(t=0;t<MaxCantFilas;t++)
	{
	for(t1=0;t1<MaxPixelsFila;t1++)
			{
			EnviarByte(reg);
			EnviarComando(DATA_WR_INC);
			}
	}
}

void Barras(){
int t = 0, t1 = 0, t2 = 0;
PunteroHomeGraficos();
for(t=0;t<MaxCantFilas;t++)
	{
	t2 = ~t2;
	for(t1=0;t1<MaxPixelsFila;t1++)
			{
			t2 = ~t2;
			EnviarByte(t2);
			EnviarComando(DATA_WR_INC);
			}
	}
}

void AutoEscribir(int dato){
int estado = 0;
do{
	CE = 1;
	TRISD = salidas;
	TRISD = entradas;
	CD = 1;
	WR = 1;
	RD = 0;
	CE = 0;
	estado = PORTD;
}while ((estado & 0x08) !=0x08);

CE = 1;
TRISD = salidas;

PORTD = dato;

CE = 0;
WR = 0;
RD = 1;
CD = 0;

delay_us(1);

CE = 1;
}

void GoToXY(int x, int y){
int16 t = 0;
t = x*MaxCantFilas + y + TEXT_HOME;
//t = TEXT_HOME + (((int16)y) * MaxBytePorFila ) + x;
EnviarByte(t & 0xff);
EnviarByte(t >> 8);
EnviarComando(ADDR_PTR_SET);
}

void main(){

Inicializar();

Barras();
BorraTodoGrafico(0);

//GoToXY(5, 5);
EnviarByte(0);
EnviarByte(0x00);
EnviarComando(ADDR_PTR_SET);

EnviarByte(0x21);
delay_ms(150);
EnviarComando(DATA_WR_INC);
}
```

Veo que enviás el byte "A" (0x21), pones una espera de 150 ms y luego después mandás el comando para escribir. 
En principio no es necesario esperar entre una cosa y otra. El micro del T6963 ejecuta una instrucción más rápido que cualquier pic. 
Si es para ver todo más lento 150 ms no te sirven de mucho, en todo caso ponele 1500 ms (1 seg y medio). 

Si te repite un dato 8 veces, el error debería estar en el comando de escritura. 
Probablemente en lugar de llegarle el comando DATA_WR_INC que vos mandás, le esté llegando el comando AUTO_DATA_RESET, o AUTO_DATA_WR. 
Fijate los bits en que difieren los dos comandos y te dará la pista qué cables puedan estar sueltos, en corto o no hacer buen contacto. 

P. Ej: 
.........DATA_WR_INC = 0x0C0 = 0 1100 0000
.....AUTO_DATA_WR  = 0x0B0 = 0 1011 0000
.AUTO_DATA_RESET  = 0x0B2 = 0 1011 0010

Bueno, la idea es buscar por ahí. 

Éxitos


----------



## picproblema (Oct 21, 2008)

Hola Alejandro Sherar. El delay_ms(150) si era para ver un poco mas lento pero me quedo de un for que hice para ver si podia ver las letras de la "A" a la "J". Con ese for lo que se mostraba era que las letras de la "A" a la "D" se superponian, luego al lado de la "D" salia la "E" y se le superponia la "F" y de ahi en mas salian las demas letra (todas en grupo de 8 siempre, que mal   ). Voy a probar con el cableado de la glcd al pic a ver si le doy solucion por ese lado. Gracias por el dato y despues comento a ver como me fue.


----------



## picproblema (Oct 24, 2008)

Que tal Alejandro Sherar:



> Fijate los bits en que difieren los dos comandos y te dará la pista qué cables puedan estar sueltos, en corto o no hacer buen contacto.



Ayer pude probar las conexiones y arme una ficha (en vez de tener cables sueltos). Lamentablemente sigue dando el mismo error. Por lo tanto voy a descartar que sean las conexiones de la glcd al pic y tambien el ruido (todo el cicuito trabaja a 5v), porque ya probe con un capacitor electrolitico de 470uF. Asi que voy a dedicarme a revisar el codigo. Gracias por el tip, la verdad ahora queda un poquito mas prolijo todo.


----------



## asherar (Oct 24, 2008)

Hola: 
Ahora fijate que en la rutina CheckEstado, y otras de acceso al display, los pines que cambian deben ser seteados bien antes de hacer la lectura _estado = PORTD;_ (o la escritura). Esto te asegura que estén en los valores correctos para la transición.  
*Los tiempos de espera durante la lectura o escritura son críticos.*
Para comparación te copio mi rutina (es otro compilador y otro pic).

Tu rutina:

```
void CheckEstado(){
int estado = 0;
TRISC = salidas;
do{
	CE = 1;
	TRISD = entradas;
	CD = 1;
	WR = 1;
	CE = 0;
	RD = 0;
	estado = PORTD;
}while ((estado & 0x03) != 0x03);

RD = 1;
CE = 1;
TRISD = salidas;
}
```

Mis rutinas (yo uso el puerto B para los datos y el C para control, el TRISC lo seteo afuera):

```
// ----------------------------------------------------------------

unsigned short sget(void)  // lee estado del LCD
{
  unsigned short lcd_status;

  TRISB=0xFF;     //  ES_ENTRADA

  CEHI;   // desactiva chip (CE=1)
  CDHI;   // modo status  (CD=1)
  WRHI;   // desactiva grabacion  (WR=1)
  RDLO;	 // activa lectura  (RD=0)

  CELO;	 // activa chip (CE=0)
  CELO;   // repite para superar los 80 ns
  lcd_status = PORTB; // lee el puerto

  CEHI;   // desactiva chip
  RDHI;   // desactiva lectura

  return(lcd_status);
} // sget()

// ----------------------------------------------------------------

unsigned short dget(void)      // lee dato del LCD
{
  unsigned short lcd_byte;

  espera();  // usa sget() para esperar a que el estado del LCD sea "libre" y deja el puerto como ENTRADA

  CEHI;   // desactiva chip
  CDLO;   // modo dato
  WRHI;   // desactiva grabacion
  RDLO;	 // activa lectura

  CELO;	 // activa chip
  CELO;   // repite para superar los 80 ns
  CELO;   // repite para superar los 150 ns
  lcd_byte = PORTB; // lee el puerto

  CEHI;   // desactiva chip
  RDHI;   // desactiva lectura

  return(lcd_byte);
} // dget()

// ----------------------------------------------------------------

void dput(unsigned short byte) // escribe dato al LCD
{
  espera();  // usa sget() para esperar a que el estado del LCD sea "libre" y deja el puerto como ENTRADA

  TRISB=0;         //  ES_SALIDA

  CEHI;   // desactiva chip
  CDLO;   // modo dato
  RDHI;   // desactiva lectura
  WRLO;   // activa grabacion

  PORTB = byte; // escribe en el puerto
  CELO;	 // activa chip
  CELO;   // repite para superar los 80 ns

  CEHI;   // desactiva chip
  WRHI;   // desactiva grabacion

} // end dput()

// ----------------------------------------------------------------

void cput(unsigned short byte) // escribe comando al LCD
{
  espera();  // usa sget() para esperar a que el estado del LCD sea "libre" y deja el puerto como ENTRADA

  TRISB=0;         //  ES_SALIDA

  CEHI;   // desactiva chip
  CDHI;   // modo comando
  RDHI;   // desactiva lectura
  WRLO;   // activa grabacion

  PORTB = byte; // escribe en el puerto
  CELO;	 // activa chip
  CELO;   // repite para superar los 80 ns

  CEHI;   // desactiva chip
  WRHI;   // desactiva grabacion
  } // cput()

// ----------------------------------------------------------------
```
No aflojes, que si esto no anda lo adapto a mi compilador y lo pruebo con mi display.


----------



## picproblema (Oct 25, 2008)

Alejandro Sherar, probe el codigo que posteaste pero sigue dando el mismo problema. Comento que tambien hice el cambio del portd al portb porque pense que podira estar por defecto habilitado el psp del pic (a pesar que despues lo deshabilito por software cuando volvi al portd). Algo extraño es que cuando volvi al portd no solo salieron las 8 "A" sino que se repitieron en las 16 filas (fuente de 8x8 pixels, glcd de 240x128 pixels). Inmediatamente reseteo y ya no salen mas. Me pregunto si tendra algo que ver la hubicacion del mapa de memoria de la glcd? En fin, voy a ver la rutina que me verifica el estado (CheckEstado en mi "intento" de libreria), ya que es la unica con un bucle. Cuando tenga novedades las hago saber.


----------



## asherar (Oct 25, 2008)

Lo único que me queda decirte es que te fijes esas direcciones del mapa de memoria en la biblioteca completa que enlacé antes.


----------



## rubosax (Oct 30, 2008)

Hola a toda la comunidad,

Tengo un problema con una LCD gráfica de 240 x 160 pixels y su controlador. Quisiera saber si alguien ha trabajado con el controlador ST7529 o bien lo conoce. Es el que lleva mi LCD que no debe ser standard y quisiera saber si alguien dispone de información sobre éste panel; creo que no dispone de su propia fuente de caracteres interna.

El tema es si utilizar un micro de 8 bits junto con la LCD de la que dispongo que tendré que programar sus caracteres uno a uno o si utilizo uno de 32 bits que lleva su controlador interno y puedo controlar el LCD con garantías.

gracias por la atención

Un saludo a todos.


----------



## picproblema (Nov 25, 2008)

Hola a todos, despues de un tiempo sigo con el mismo problema, cada ves peor! Resulta que sigue enviando las 8 letras entonces probe cambiando el comando que autoincrementa el puntero (del propio controlador, no en mi software) por el comando que decrementa y el comando que no mueve el puntero y sigue dando el mismo error. Ya revise mil veces la hoja de datos del t6963cfg y por un tiempo pense que podria ser una interrupcion del controlador que este dando ese error. Creo que en ese caso no podria saber si es esa la causa del error, asi que voy a seguir probando con mi codigo.


----------



## asherar (Nov 27, 2008)

picproblema dijo:
			
		

> Hola a todos, despues de un tiempo sigo con el mismo problema, cada ves peor! Resulta que sigue enviando las 8 letras entonces probe cambiando el comando que autoincrementa el puntero (del propio controlador, no en mi software) por el comando que decrementa y el comando que no mueve el puntero y sigue dando el mismo error. Ya revise mil veces la hoja de datos del t6963cfg y por un tiempo pense que podria ser una interrupcion del controlador que este dando ese error. Creo que en ese caso no podria saber si es esa la causa del error, asi que voy a seguir probando con mi codigo.



Se me ocurren 2 cosas:
Proba de aumentar el retraso entre seteo de bits, en las rutinas de control. 
Por ejemplo poniendo un BUFER=1 - BUFER, donde BUFER es una variable que no hace nada. Solo es para perder tiempo. Digo de cambiar el valor cada vez para que si el compilador es muy inteligente, al optimizar 
no saque la instrucción.  

Ej:


```
void CheckEstado(){
int estado = 0, BUFER;
TRISC = salidas;
do{
   CE = 1;
   BUFER=1- BUFER;

   TRISD = entradas;
   BUFER=1- BUFER;

   CD = 1;
   BUFER=1- BUFER;

   WR = 1;
   BUFER=1- BUFER;

   CE = 0;
   BUFER=1- BUFER;

   RD = 0;
   BUFER=1- BUFER;

   estado = PORTD;
   BUFER=1- BUFER;

}while ((estado & 0x03) != 0x03);

RD = 1;
CE = 1;
TRISD = salidas;
}
```

La otra cosa que quedaría es cambiar de compilador. No porque ese no sirva, sino que tal vez con otro 
"debugger" diferente salte el error. 

Yo tengo experiencia con el 873 y el 876A. Tengo un 877 y un GLCD de 128x64 esperando turno. 
Encima estoy a tope con mis trabajos, si no ya ponía las manos en la masa.
Coraje! Ya sale!


----------



## picproblema (Nov 27, 2008)

Hola Alejandro Sherar, tanto tiempo. Mira, probe el retardo y no sirvio de nada    Tambien revise si la placa del modulo estaba en concordancia con la datasheet del controlador y si lo esta, nada esta mal...La verdad que eso de cambiar de compilador lo habia pensado, pero no se si me dara resultados debido a que el razonamiento para el codigo seria el mismo (es mas solo cambiarian algunas instrucciones y en el peor caso tendria que escribir todo desde cero y aprender nuevas instruccioes....). El problema se que lo debo encarar en las rutinas de enviar comando (relacionado con mi post anterior) y chekear estado...Como siempre, voy a seguir probando la programacion de la "libreria".


----------



## asherar (Nov 27, 2008)

El problema con los errores es que uno piensa que hizo una cosa bien y por eso no la revisa. 
O pasa por al lado y no lo ve. Y justo ahi está el error.
No sé que decirte. Por eso mejor no digo nada.


----------



## picproblema (Nov 27, 2008)

Que tal Alejandro Sherar. Jejejjee   es cierto lo que me decis, y lo mas probable es que el error se tan evidente que no lo veo o que la solucion sea mas facil de lo que pienso, en fin, no voy a dejar de intentar hacer andar esta pantalla, pero ya no voy a dedicar taaaaanto tiempo, tambien necesito respiro para despejar la mente, cualqeuier novedad lo posteo, saludos a todos!


----------



## picproblema (Nov 30, 2008)

Hola a todos, vuelvo con comentarios sobre mi "libreria" para la glcd. Por un lado resulta ser que si en la funcion EnviarComando quito la linea CE = 1 en la pantalla no salen las letras! (o sea, no sale nada).
Por otro lado, si utilizo la funcion AutoEscribir  (con sus comandos para auto escribr y auto resetear) salen las ocho letras, pero si a dicha funcion le quito su linea CE = 1, las 8 letras siguen saliendo.
Algo raro paso cuando desconecte el LSB de los datos y rapidamente lo conecte (solo para ver que pasaba  ) y es que en la pantalla aparecieron 7 letras . Bueno, eso es todo, nada "nuevo" pero ya dije que si hacia algo lo posteaba. Adjunto la libreria, que es un poquito diferente a la de antes.


----------



## picproblema (Dic 14, 2008)

Probe grabar el pic con LVP (en ves de NOLVP) y en la pantalla sale cualquier cosa (ruido). No se si tiene algo que ver con la fuente de alimentacion, pero si muevo dos cables (font select y mode 2) que van directo a lineas de alimentacion (una a positivo y otro a negativo) la pantalla hace cosas erraticas pero con la partcularidad de que salen caracteres/pixels de a ocho (o sea el problema principal) pero creo porque el pic esta ya enviando la "libreria" al modulo del glcd. Alguien con alguna idea de que se trate? porque yo no. 
Tambien cambien de lugar la linea de PORTB = dato (o comando)  y la puse debajo de CE=0 en las rutinas de enviar datos o comandos y salen 16 lineas de 8 caracteres (antes ya me habia pasado y lo postee aqui).


----------



## asherar (Dic 15, 2008)

No estarás armando todo en un protoboard ? :evil:


----------



## picproblema (Dic 15, 2008)

Hola Alejandro Sherar, si estoy usando protoboard. Pasa que es mas facil y como es la etapa inicial creo que es mejor...


----------



## gajobar (Jul 8, 2009)

Hola Alejandro.

Disculpá que te moleste, peroviendo algunos foros, encontré charlas y comentarios sobre GLCD, en los cuales vos respondías bastante. Lo que me hizo pensar que me podrías dar una mano con el problemita que tengo.

El problema es el siguiente, encontré un LCD gráfico de 240x128 píxeles monocromático en una fotocopiadora rota y se me ocurrió utilizarlo para mejorar un osciloscopio que armé. Bueno, comencé con investigar el circuito y los componentes del LCD. Después de mucho renegar, encontré los datasheet de todos los integrados y me topé con lo que me está limitando en este momento continuar. El uPD72030 que es un controlador de display que permite, mediante diferentes tipos de instrucciones, memorias RAM y ROM, manejar la pantalla como si fuese un monitor, es decir, posee muchas funciones de control gráfico píxel po píxel, y muchas más para el manejo de caracteres.

Teniendo toda la información y el estudio, traduccción y lectura de todo lo conseguido, comencé a programar la inicialización del LCD y alguna que otra cosita más. Entonces me topé con el inconveniente de que no me responde nada y mucho no entiendo qué es lo prioritario en las instrucciones a manejar, para que el LCD responda simplemente píxel por píxel.

Bueno, espero que leas mi duda y me puedas dar una mano. Tengo todo lo necesario para pasarte, si te hace falta, para que me des algún indicio o por donde encarar el problema. Desde ya muchas gracias.

Gabriel, desde Córdoba.... jej


----------



## asherar (Jul 9, 2009)

Problemas, ... mi segundo nombre ! 

La  hoja de datos del uP72030 no creo que nos diga mucho de cómo maneja el display. 

Me costó encontrarla. Todos los enlaces me daban en chino.  
No se si será que es obsoleto o que pronto vamos a tener que aprender el idioma.   

Estamos en contacto ...


----------



## gajobar (Jul 9, 2009)

Buenas. Gracias por ponerte en el trabajo de buscar el datasheet....

Si, me había pasado lo msmo, todo en chino y muy difícil de conseguir...

Te paso lo que yo conseguí, porque me parece que el que me enviaste es un modelo mucho mayor y más avanzado. El de mi LCD es mas pequeño, tiene menos patas...

http://www.icpdf.com/partnoview.asp?id=1607469_573440

Acá te sale en el enlace para bajar. En el cuadro que dice PDF (todo lo otro está en chino), al lado derecho hay dos flechas. La segunda flecha posee el PDF del uPD72030

Nos vemos. Saludos!


----------



## asherar (Jul 9, 2009)

Ah bueno, esto ya es otra cosa ... !

Lo que veo que falta es un poco de información de cómo se envían los comandos al micro. 
En hojas de datos de otros LCD te viene cómo poner el dato, cuando clockear, etc. 
No tenés algo de eso ? 
Lo más cercano (y no mucho) es la hoja 2, donde dice qué es y qué hace cada patilla.

Ya probaste de poner /CS en 0 y clockear en /WR con algún valor en el bus de datos ?

Ojo con la patilla TEST que debe ir fija en cero.

Hay cosas interesantes como las salidas de sincronizacion IOW1, IOW2, MEMW, 
etc., porque te dicen qué está haciendo adentro el micro.

(Voy a tener que cambiar mi avatar a éste  que parece chino)


----------



## asherar (Jul 9, 2009)

Hola: 

Vamos primero con esto, a ver si lo podemos interpretar: 


Comandos de Inicialización

*SYNC* 

1 0 0 1 0 1 1 0 (Es la cadena que distingue el comando SYNC)

*Parámetros*
• Dirección de columna (bytes) (=2 bytes)
(L)
(H)
• División de tiempo (1 byte)  ( Esto será la duración de FRM ? = FRaMe ? )
• 0 0 0 0 0 0 B1 B0 (1 byte)
• Ciclo STB (1 byte) ( Esto será la duración del ciclo de STand By ? )

*Función.* Este comando especifica el tamaño del panel LCD y los tiempos de generación de señales de control (FRM y STB) al controlador del LCD. El número total de píxeles en una fila puede ser más del doble del número del tiempo de divisiones.

B0 especifica si la conexión para la extensión es usada. 

B0 = 0 Matriz Simple
B0 = 1 Matriz Doble

B1 = 0 DRAM no usada
B1= 1 DRAM usada

*Mis comentarios: *
No me parece que los registros ingresen información mezclada, como ser 6 bits para una cosa y los dos últimos aparte. 
Pero si el registro se debe usar completo para cada parámetro, queda saber *cómo indicar de qué parámetro se trata*. 
En ese caso: 
 la dirección de la columna es un nro de 2 bytes: el Low y el High, que habrá que ingresar de uno por vez.
 la división de tiempo es un nro de 1 byte
 el byte "0 0 0 0 0 0 B1 B0" especifica el uso de extensión
 y el ciclo de Stand By se indica con otro byte

...

En otros LCD la cosa es así: 
se pone el registro identificador de comando y se da clock
se pone el registro identificador de dato/parámetro y se da clock
etc. ...
Esto en líneas generales, porque también se debe esperar que el micro esté desocupado, etc.

Acá lo último que se me ocurre es hacer: 

.- "checkear el status" hasta que se lea "wait state" (no sé cómo, tal vez leyendo /INT a ver cuándo está en cero)
.- cuando ya se pueda mandar comandos, empezar a mandar de a un byte, en este orden: 
1.- 1 0 0 1 0 1 1 0 (Es la cadena que distingue el comando SYNC)
2.- Byte Bajo (L) de la Dirección de columna
3.- Byte Alto (H) de la Dirección de columna 
4.- Byte de División de tiempo 
5.- El byte 0 0 0 0 0 0 B1 B0 
6.- Byte de duración de Ciclo STB
.- y ver que pasa ...

Decime cómo lo interpretás vos.

 <- este soy yo, luego de volverme chino


----------



## gajobar (Jul 9, 2009)

Hola Alejandro.

La verdad que mil gracias por ocuparte en detalle sobre mi inconveniente.

Te cuento, más o menos lo que vos me decís es lo que intenté entender por mi cuenta y lo que me pareción comprender. Mi duda principal estaba en el FRM y el STB.

Cuando probé todo esto, al principio no me pasaba nada, hasta que noté que el pin de reset estaba negado por hard, lo que dejaba la lógica positiva funcionando. Correjido este inconveniente continué con intentar cargar todos los parámetros del comando SYNC. En el único momento que encontraba variaciones en el LCD es cuando, en el byte correspondiente al FRM, lo iva modificando desde un valor muy chico (0x02) a uno muy parecido al tamaño del Y del LCD (0x80). En los valores que cargaba, desde el más pequeño hasta un valor alrededor del 0x35 del FRM, se observa una barra completa en el superior de la pantalla (todos los píxeles encendidos) con filas encendidas en igual cantidad al número que ponía (es decir, si colocaba el 0x02, se pintaban dos filas completas. Si ponía el 0x03, tres, y asi sucesivamente). Superando este valor (0x35), el color se hacía prácticaente imperseptible, perosí diferenciable con el resto del LCD.

Otro efecto que percivo con la variación del valor cargado del FRM, es que luego de todo , la pantalla queda observándose un leve parapdeo como si fuese el barrido. Mientras más cercano al valor del tamaño de filas, menos se nota este parpadeo.

Con todo lo demás, no se nota ninguna variación. El tema, ahora, es que no sé cómo pedirle al LCD el STATUS del uPD72030, para asi enviarle correctamente los bytes y que los leea bien, sin perderlos. 

Otra cosa que noté, es que recibe los datos, siempre y cuando espere 1ms, de lo contrario no funciona. Eso debe tener que ver con lo del STATUS del uPD72030. Pero también puede ser que sea porque he notado que el tiempo que está el WR puesto en low, es mayor al tiempo máximo que dice la Hoja de datos (15/fosc y la fosc=6MHz, lo que nos dice que no puede mayor a 2,5us).

Bueno, eso es más o menos lo que he logrado hasta el momento con lo que vi y con lo que me respondió. Muchas Gracias. Saludos


----------



## gajobar (Jul 9, 2009)

ah, me olvidaba.... el STB, es referido al tiempo de parpadeo del cursor para el manejo de textos cuando se utiliza el generador de caracteres interno, es decir, la ROM con los caracteres almacenados.

Eso es todo. Saludos y hasta el próximo post. Muchas gracias


----------



## asherar (Jul 10, 2009)

El status lo podés averiguar haciendo pooling en el bit /INT. Cuando está en cero, es que 
el micro ya no está ejecutando nada, y puede recibir comandos. 
Fijate que eso dice en la hoja de datos que me pasaste, sólo que lo pone como que 
"usted, si quiere, puede leer el bit /INT ..." pero no queda otra, salvo esperar tiempos 
excesivamente largos. 

Saludos


----------



## ROBOCOP_037 (Jul 14, 2009)

Paloky dijo:
			
		

> He encontrado unas pruebas que realize con el display y el PIC16F876.
> El programa está en Ensamblador ASM para PIC.
> 
> Saludos



Paloky hazme un favor. Puedes enviarme el conexionado de este circuito y si puedes decirme cual LCD del proteus utilizo  para hacer la simulacion?

Muchas Gracias


----------



## danrod (Nov 27, 2009)

Alejandro Sherar dijo:


> Fijate Rubén que la forma de cableado del GLCD que ponen en el mikroC es diferente a la del programa que posteé yo antes. Otros esquemas de la ayuda también muestran algunos errores (como el reset en el ejemplo del ADC).
> Yo armé una biblioteca propia para mi display basado en la hoja del T6963C, y modificando las rutinas del código C posteado antes, para adaptarlas al C de mikroC. Están disponibles en la zona de descargas de mi página.
> Buscar: *Biblioteca para Pic16F873/6/A ...* y bajarse el archivo *Bib_0y1.zip*.


 
Mira Gracias por el aporte
la vedad intente utlizarlas simulando en proteus pero.. me rindo......
Pero...... es posible q cargaras o me reenviaras una aplicacion en la que utlices tus librerias para graficos (cargados en memoria )y textos en cadenas de caracteres............. las tengo trasncritas a ccs compiler y una vez las termine de entender me comprometo a reenviarles
muchas Gracias Alejandro
Espero no molestarlo


----------



## asherar (Nov 27, 2009)

Hola: 

Con respecto al código que pides para el T6963C voy a ver si te separo algo 
medio corto como para que no te compliques con cosas que no tengan que 
ver con el display. Voy a tardar un poco (dame un par de días). 

Ahora estoy trabajando con otro display, controlado por el KS0108. 
El paquete de rutinas lo bajé de U-control (ver). 
Fue desarrollado para CCS pero yo lo probé con mikro-C y con MPLAB y 
anda perfecto con los dos. 
Es bastante distinto ya que los fonts del modo texto hay que generarlos, 
cargarlos en el micro y gestionarlos todo uno mismo.   
Con paciencia y con saliva ... al final todo funciona. 

Saludos

PD: Pido disculpas por los enlaces rotos. Esto es porque el sitio que tenía 
en geocities fue cerrado junto con todos los sitios gratuitos. 
 La nueva dirección web está en mi firma. Toda la estructura de la página 
de descargas es la misma. 

---------------------------------------------------------------------------------------------

Listo!. 
Acá dejo una aplicación sencilla. Está en mi página de descargas:
http://asherar.co.cc/DSD/descargas/index.htm
Las rutinas de las bibliotecas B0 y T1 permiten configurar, arrancar y escribir
cadenas de texto. 
El proyecto es para mikroC, por lo que si se prueba en otro compilador, 
la rutina Delay_ms se debe implementar.
Compila perfecto aunque no lo he probado en el GLCD. 
Espero que les sea útil.

Saludos !

PD: Todos mis programas llevan un "bug-intencional" a modo de "virus-didáctico" 
así que nadie espere hacerlos funcionar a la primera.


----------



## danrod (Nov 28, 2009)

Que rapido....... 
Muchas Gracias..
una vez las entienda, te las paso en CCS ......
Las probare... 
Eres muy amable


----------



## asherar (Nov 28, 2009)

Gracias a vos que me puse a revivir el display ese. 
Lo tenía medio desatendido. 
Ahora me andan los dos. 

Fijate si no: 

http://www.youtube.com/watch?v=c1XlTA4sxLM

Saludos, y que les aproveche, en aquel lado del mundo...


----------



## danrod (Nov 29, 2009)

Alejandro Sherar dijo:


> Gracias a vos que me puse a revivir el display ese.
> Lo tenía medio desatendido.
> Ahora me andan los dos.
> 
> ...


 
--------------------------------------------------------------------------Es cierto funciona en proteus y en mi pantalla tambienBuen dia Alejandro:Excelente APORTE!!!!Ahora si las entiendo!!!Sin embargo me genera error cuando ingreso mas de 1 cadena de textos.... y No entiendo por que:void glcd_config(unsigned short x_Size, unsigned short y_Size,     unsigned short Ancho_de_caracter){	_H_PIXEL = Ancho_de_caracter;	_NRO_DE_COLUMNAS = (x_Size+4)/Ancho_de_caracter;	_NRO_DE_FILAS    = (y_Size+4)/8;.......(x_Size+4)????(y_Size+4)????Mi pantalla es de 240X128240(x_pixeles)/6(Pix_ancho/caracter)= 40 caracteres/filaY son 16 filas.......Pero solamente me esta mostrando 32 caracteres y una vez intento agregar una cadena de texto en otra fila envia error al compilar... sin enmbargo la logica de las rutinas esta bien (no entiendo por q sumar+4)Tengo una inquietud adicional... solamente se pueden textos de 5X7 y 7X7...no es pòsible tener textos de menor tamaño como 3X5??? ¿para tener estos textos es necesario utilizar modo grafico y como?.Muchas gracias por responder a mi mensajePd: En el adjunto tengo los archivos modificados (descargados de tu pag. espero no te molestes)...con una simulacion de proteus....Gracias por responderMuy amable alejandro


----------



## asherar (Nov 29, 2009)

Lo de sumar +4 (la mitad de 8, el ancho máximo de caracter) es para el redondeo de la 
división entre enteros. Es como sumar 0.5 para redondeo simétrico. 
No sé qué pasa para pantallas más grandes. Creo que el programa original era para 240x128. 

Lo de las cadenas de textos que dan error puede ser que sea porque el compilador no puede 
guardarlas en la memoria que tiene disponible, o que uno ha llegado al límite de la memoria. 
Yo me he encontrado ese tipo de cosas también. Aún no le encontré la vuelta. 

Gracias por las reformas. Viste que no era demasiado complicado. 

PD: Por favor, puntuá un poco el texto que no se entiende nada.


----------



## danrod (Nov 30, 2009)

Alejandro Sherar dijo:


> Lo de sumar +4 (la mitad de 8, el ancho máximo de caracter) es para el redondeo de la
> división entre enteros. Es como sumar 0.5 para redondeo simétrico.
> No sé qué pasa para pantallas más grandes. Creo que el programa original era para 240x128.
> 
> ...


 
ok entiendoSin embargo sigo con la inquietud............... no entiendo por que si mi pantalla es de 240 pixeles entonces deberia mostrar 40 carateres y me muestra 32Lo otro es que si sabes la manera de mostrar carateres 3X5 pixeles??muchas gracias por responder


----------



## asherar (Nov 30, 2009)

Una pantalla con 240 pixels puede mostrar 40 caracteres de 6 pixels de ancho, 
o 30 caracteres de 8 . 
Si tu font es de 6, hay que revisar las rutinas que calculan la cantidad de columnas. 
Debe haber alguna macana ahí, que en mi display de 128x128 no se llega a manifiestar. 

Para caracteres de otras dimensiones habría que buscar en internet algún 
programa para generar fonts. 
De lo contrario hay que armarse de paciencia y de una hoja cuadriculada. 
En los displays basados en el T6963 los bytes se codifican horizontalmente.
 Se puede usar el font que trae incorporado, o cargarle un font propio. 
Fijate en la hoja de datos del micro (Ref. 1) o en la nota de aplicación (Ref. 2). 

P. ej: Una forma de hacer la A en 8x8 para el T6963 sería: 

00011100 = (0x1C)
00100010 =  (0x22)
 01000001 =  (0x41)
 01111111 =  (0x7F)
01000001 =  (0x41)
 01000001 =  (0x41)
01000001 =  (0x41)
00000000 = (0x00)

Para 3x5 no queda mucho espacio. Te van a quedar irreconocibles. 
Será cuestión de probar a ver qué sale.

Saludos

Ref. 1.- Hoja de datos del T6963C
Ref. 2.- Application Notes for the T6963C LCD Graphics Controller Chip


----------



## danrod (Dic 1, 2009)

Alejandro Sherar dijo:


> Una pantalla con 240 pixels puede mostrar 40 caracteres de 6 pixels de ancho,
> o 30 caracteres de 8 .
> Si tu font es de 6, hay que revisar las rutinas que calculan la cantidad de columnas.
> Debe haber alguna macana ahí, que en mi display de 128x128 no se llega a manifiestar.
> ...


 
Buen dia Alejandro:Efectivamente tu lo habias dicho....eran errores del compilador.Sin embargo, tengo problemas con el cursor, despues de la columna 16 vuelve a comenzar la fila, es decir:glcd_put_cursor(16,2) muestra el cursor en la fila 2 columna 1 ???Para hacerme entender mejor, agrega esto a tu codigo:		.		.       for (i=1; i


----------



## asherar (Dic 2, 2009)

Hola danrod. 

El cursor se configura mediante el modo texto. 
Por favor, fijate que el seteo por hard del ancho del caracter 
coincida con el seteo por software. 

Nota: 
Verás que tanto el modo gráfico como el modo texto tienen la misma cantidad 
de columnas. Esto es por la misma razón que el caracter se define por filas. 

Ahora: Ojo al piojo !
Cuando configuras para usar el font de 6 pixel de ancho, al escribir bytes en 
la memoria gráfica, ésta se va llenando con tiras de 8 pixels en forma horizontal, 
y los 2 últimos pixels de cada byte dibujado se subreescriben con la tira 
siguiente. 
Esto es porque la posición del primer pixel del byte a escribir se calcula usando el 
nro de columnas de ancho=6 que calculamos al configurar. 

Por lo tanto, aunque veas que dibuja 8 pixels por vez, el ancho útil de byte en 
modo gráfico son los 6 pixels seteados. 
No se si fui claro 

Saludos


----------



## danrod (Dic 2, 2009)

Nuevamente ...............Efectivamente tu lo habias dicho....eran errores del compilador.Sin embargo, tengo problemas con el cursor, despues de la columna 16 vuelve a comenzar la fila, es decir:glcd_put_cursor(16,2) muestra el cursor en la fila 2 columna 1 ??? Para hacerme entender mejor, agrega esto a tu codigo:           for (i=1;  i   <   020; i++)    {     glcd_put_cursor(i,2);                 // Posiciona el cursor    Delay_ms(500);    }Un favor particular, quiero mostrar pixeles y hago lo siguiente:   glcd_activar(_GRAF); glcd_paint_pixel(25, 50, 1);pero no muestra el pixel???No tienes quizas una aplicacion del modo grafico de tus rutinas.. quisiera poder mostrar un rectangulo y una pequeña imagen en cualquier sitio de la pantalla.Te agradezco por la colaboracion.Muchas Gracias por responder a los mensajes.....Mira, lños caaracteres 3X5 pixeles... se reconocen muy bien.. Encontre en el Ucontrol "CCS - Libreria de gráficos para GLCD K0108 De Ucontrol - Versión para GLCD con chip SED1565" la tabla de caracteres 3X5 pixeles. Me gustaria poder realizar una rutina similar para la presentacion de cadenas de caracters a 3X5. Soy nuevo en CCS, pero lo intentare. Por favor de casualidad tienes un ejemplo del manejo grafico de tus rutinas....(entendi las de texto, aunque tengo problemas con el cursor).Muchas gracias Alejandro.Posdarta: disculpa por mennjaes anteriores pero tenia problemas con el ENTER del teclado..jeje



			
				danrod dijo:
			
		

> Nuevamente ...............Efectivamente tu lo habias dicho....eran errores del compilador.Sin embargo, tengo problemas con el cursor, despues de la columna 16 vuelve a comenzar la fila, es decir:glcd_put_cursor(16,2) muestra el cursor en la fila 2 columna 1 ??? Para hacerme entender mejor, agrega esto a tu codigo:           for (i=1;  i   <   020; i++)    {     glcd_put_cursor(i,2);                 // Posiciona el cursor    Delay_ms(500);    }Un favor particular, quiero mostrar pixeles y hago lo siguiente:   glcd_activar(_GRAF); glcd_paint_pixel(25, 50, 1);pero no muestra el pixel???No tienes quizas una aplicacion del modo grafico de tus rutinas.. quisiera poder mostrar un rectangulo y una pequeña imagen en cualquier sitio de la pantalla.Te agradezco por la colaboracion.Muchas Gracias por responder a los mensajes.....Mira, lños caaracteres 3X5 pixeles... se reconocen muy bien.. Encontre en el Ucontrol "CCS - Libreria de gráficos para GLCD K0108 De Ucontrol - Versión para GLCD con chip SED1565" la tabla de caracteres 3X5 pixeles. Me gustaria poder realizar una rutina similar para la presentacion de cadenas de caracters a 3X5. Soy nuevo en CCS, pero lo intentare. Por favor de casualidad tienes un ejemplo del manejo grafico de tus rutinas....(entendi las de texto, aunque tengo problemas con el cursor).Muchas gracias Alejandro.Posdarta: disculpa por mennjaes anteriores pero tenia problemas con el ENTER del teclado..jeje


 
Mira el adjunto imagenes de la calculadora texas instruments..... utlizan 5X7 y 3x5 pix/caracterGracias por responder


----------



## asherar (Dic 2, 2009)

Hola: 

La parte gráfica es igual que para la de texto, sólo que: 

* En lugar la dirección de un "char" se envía el contenido del byte con los 8 pixels horizontales, 

* La dirección destino se calcula a partir de la dirección base de la memoria gráfica, 

* Hay una fila por cada pixel a lo largo de la vertical. 

La clave para dibujar un píxel es leer de la memoria el byte que lo contiene y modificar sólo el bit correspondiente al pixel. 
Luego se reescribe el byte modificado en el mismo lugar que se lo leyó. Para eso hay que leer *sin incrementar* la posición de memoria. 

Ahora ando en otra cosa que me consume todo el tiempo. En unos días veré si me desocupo y hago algo. También me dió ganas de probar con los fonts de 3x5. 

Saludos


----------



## danrod (Dic 3, 2009)

Buen Dia Alejandro
Intentare haver si puedo........ tambien intentare hacer algo con e font 3X5
Si configure el font por software/hardware 6X8 pixeles pero el cursor no supera  la columna 16.....


----------



## asherar (Dic 3, 2009)

danrod dijo:


> Buen Dia Alejandro
> Intentare haver si puedo........ tambien intentare hacer algo con e font 3X5
> Si configure el font por software/hardware 6X8 pixeles pero el cursor no supera  la columna 16.....



Qué casualidad que el la columna 16 (0 a 15) sea  la última para 128 pixels !!!!


----------



## danrod (Dic 3, 2009)

Pero utilizo 240X128 y altere tu codigo...
Mira en breve te envio tus rutinas en CCS (funcionan bien) y te daras cuenta......
Te enviare la simulacion con la pantalla 240X128 y notaras el cursor que llega hasta la columna 16 .......
Gracias por responder

Como te puedes dar cuenta, he trabajado con tus rutinas.... para modo texto me he guiado y disculpa si te molesta (por las modificaciones)... las transribi a CCS compiler y funcionan correctamente... Sinembargo.. El cursor deberia recorrer toda la fila y solamemnte recorre hasta la columna 16????En todo caso pienso que se debe alterar la rutina de Put_cur   ..Lo del modo grafico no lo entiendo, ayudame con una aplicacion en miKroC y yo me encargo del CCS (soy nuevo en esto pero estoy aprendiendo..jeje).Se que para mostrar pixeles a 3X5 pìxeles se requiere utlizar el modo grafico.... quizas podriamos hacer algo. Una vez tengamos algo arreglare las rutinas del CCS para que las puedas tener en MiKroC y CCS; colgandolas en tu pag (quedaria algo muy completo!!)Existe la posibilidad de configurar el modo grafico utilizando las dimensiones de la pantalla, es decir, 240X128 pixeles y poder mostrar un pixel en cualquier posicion de memoria sin tener que utlizar el modo texto??? como por ejempo put_pixel(100_pixel,120_pixel,1_color)???Algo adicional, encontre una rutina para teclado 4X4 en CCS, utiliza todo el puerto B y necesito utlizar la parte baja del mismo para una memoria serial...... Quizas tu me podrias ayudar con esta inquietud ¿Como se puede crear un PUERTO_X que utilice la parte alta del puerto B y la parte baja del puerto A como un nuevo puerto? que sea nombrado como PUERTO_X y TRIS_X en CCS???


----------



## asherar (Dic 3, 2009)

No me molesta en absoluto que modificaras mis rutinas. 
Además yo las bajé de otro sitio y las adapté a mis necesicades.

Lamento que ahora no puedo ponerle tiempo a esto. Para atacar el problema que 
me cuentas debería ponerme a revisar todo tranquilo, lo que me llevaría una tarde 
de las largas. 

Lo que te puedo decir es que:

1.- Lo de los puertos se puede hacer, lo que pasa es que va a ser un poco más 
lento que si usaras los 8 bits del mismo registro. Pero no creo que mucho. 

2.- El T6963C trae un font incorporado de 8x8 y memoria para cargarle un font 
hecho por el usuario, pero el KS0108 no trae nada, ni font ni memoria, por lo que 
hay que armarle un font y guardarlo en la memoria del micro!!!

3.- La incompatibilidad entre ambos se debe a que en el T6963C los bytes 
gráficos codifican líneas horizontales, y en el KS0108 lineas verticales. 

4.- Yo en realidad uso el MPLAB, el mikroC lo usé por comodidad para el C. 

Ve adelantándote y en unos días te alcanzo. 

Saludos

Lo único que veo por ahora del tema del cursor es que llamás al revés los argumentos: 

La llamada es: 

void glcd_put_cursor(int *XC*, int *YC*)*;*

y vos ponés:     



> for (i=1; i<40; i++)
> ///AQUI DEBERIA MOSTRAR EL CURSOR RECORRIENDO TODA LA FILA
> {
> glcd_put_cursor(*1,i*);// Posiciona el cursor
> ...


Así, lo que hace es dejar la columna X fija en 1, e incrementar la fila desde 
0 a 40 (recorre la columna X=1). 

Espero algún video de cómo funciona


----------



## danrod (Dic 4, 2009)

"
void glcd_put_cursor(int *XC*, int *YC*)*;*

y vos ponés: 

Así, lo que hace es dejar la columna X fija en 1, e incrementar la fila desde 
0 a 40 (recorre la columna X=1). "

En las rutinas d CCS estan configuradas para que funcionen tal cual como estan escritas... (fila estable-columna variable) me confundi un poco pero puedes intercambiar y notaras que se altera la fila........... i No es por eso.... ya lo intente. Puedes probar con tus rutinas de MiKroC......... Es mas puedes cambien en CCS y probar en proteus......
Muchas Gracias por responder.....
Intentare hacer algo con el modo grafico..........


----------



## danrod (Dic 9, 2009)

Alejandro Sherar dijo:


> No me molesta en absoluto que modificaras mis rutinas.
> Además yo las bajé de otro sitio y las adapté a mis necesicades.
> 
> Lamento que ahora no puedo ponerle tiempo a esto. Para atacar el problema que
> ...


 

Alejandro, he tenido algo de lios en la protoboard.... una vez solucionado espero mostrarte un video..........

Mira lo que enontre en español..................
http://www.ele.uva.es/~jesman/BigSeti/seti2/Miscelanea/ManualLCDGrafico.pdf


----------



## asherar (Dic 9, 2009)

Acá abrí un foro sobre herramientas para LCD gráficos: 

https://www.forosdeelectronica.com/...-resumen-datos-herramientas-16859/#post116523

Ya agregué tu enlace.


----------



## danrod (Dic 9, 2009)

Buen dia alejandro:
En funcionamiento el programa corre CORRECTAMENTE, no se porque en la simulacion con proteus tienen errores.... en todo caso NO EXISTEN problemas con el cursor!!!!!!!!!!!!!!!!!
Pido por favor si tienes alguna aplicacion con tus rutinas utlizando el modo grafico
De antemano gracias............


----------



## asherar (Dic 14, 2009)

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:


```
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.


----------



## danrod (Dic 15, 2009)

OK!!! lo intentare....
Muchas gracias alejandro.......................
Te Contare con detalles lo sucedido


----------



## danrod (Dic 17, 2009)

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.


----------



## asherar (Dic 17, 2009)

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.


----------



## danrod (Dic 17, 2009)

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?????.


----------



## asherar (Dic 21, 2009)

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) !


----------



## danrod (Dic 21, 2009)

Muchas Gracias Alejandro..probare tus rutinas nuevamente

Disculpa por las molestias
Te contare con detalles lo sucedido


----------



## danrod (Dic 23, 2009)

Alejandro Sherar dijo:


> 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" !!!
> ...


 
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


----------



## asherar (Dic 24, 2009)

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 ?


----------



## danrod (Dic 24, 2009)

Alejandro Sherar dijo:


> 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.
> ...


 
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????


----------



## asherar (Dic 24, 2009)

danrod dijo:


> 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


----------



## danrod (Dic 26, 2009)

Alejandro Sherar dijo:


> 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......


----------



## danrod (Dic 28, 2009)

Alejandro Sherar dijo:


> 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


----------



## danrod (Ene 5, 2010)

*Alejandro Sherar*
*Muchas gracias por tus aporte con tus rutinas funcionan perfectamente....*
*GRacias*


----------



## asherar (Ene 6, 2010)

Disculpa que no haya contestado estos dias. 
No estoy teniendo acceso continuo a internet. 
En pocos dias vuelvo al foro. 
Bay


----------



## alnavasqui (Mar 2, 2010)

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


----------



## antiworldx (Mar 3, 2010)

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.


----------



## asherar (Mar 3, 2010)

alnavasqui dijo:


> 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


----------



## alnavasqui (Mar 3, 2010)

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


----------



## asherar (Mar 4, 2010)

*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):

Ver el archivo adjunto logo_web.bmp​ 
*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.

```
// ------------------------------------------------------------
// 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:  

```
#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


```
// ----------------------------------------------------------------
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


----------



## alnavasqui (Mar 4, 2010)

Muchas gracias, voy a ver si lo consigo hacer. Por otra parte, tengo problemas para escribir en una eeprom i2c. He revisado los pines que contacten, he simulado el programa en Proteus y si que escribe, pero en la realidad puedo confirmar que lee, pero no escribe. ¿Puede ser debido a que la eeprom es demasiado lenta y no lo puede hacer?


----------



## asherar (Mar 5, 2010)

Sacate la duda mirando en la hoja de datos del chip. 
No tengo mucha experiencia con el bus i2c. 
Usá el buscador del foro y casi seguro encontrarás algo.


----------



## fvparg (Abr 11, 2010)

Hola a todos. Una pregunta., alguien sabe que comandos enviar para invertir la pantalla en un LCD de 240x128 de WINSTAR con controlador T6963c. ósea invertir a modo de que los textos y gráficos que están pintados pasen a no pintado y lo no pintado a pintado. Gracias a todos. Federico de Bs.As Argentina.


----------



## asherar (Abr 12, 2010)

No sé si habrá una forma más rápida, pero el método "muscular" sería ir desde 
la posición cero hasta la última haciendo: 

1.- leer y quedar en el lugar
2.- escribir el complemento de lo leido 
3.- avanzar una posición 

Como alterna lectura con escritura de a un registro por vez, no se puede 
hacer en el modo "por bloques".

El tiempo de refresco para 240x180 debe andar en un segundo o poco  menos. 
Para que no se note el "pantallazo" conviene desactivar el modo gráfico, reescribir 
la memoria, y luego restablecer el modo gráfico.

Saludos


----------



## fergart (Abr 18, 2010)

buen dia mi problema es que no muestra nada el lcd hay veces que enciende dos lineas, hay otras que solo aparece  "/" en diferentes posiciones del display y quisiera ver si me pueden ayudar a encontrar mi error, el codigo es el siguiente por cierto
 gracias por su tiepo.


```
#include <16F84A.h>
#use delay(clock=4000000)
#fuses XT, NOPROTECT, NOPUT, NOWDT
#include <lcd420.c>
#define use_portb_lcd,RTCC_INTERNAL
#use fast_io(a)
#use fast_io(b)
#byte port_a=5
#byte port_b=6
int b0,b1,b2,b3,b4,b5,b6,b7,temp;
void main()
{
while(1)
   {
   set_tris_a(0x00);
   set_tris_b(0xff);
   output_low(PIN_A0);
   delay_ms(50);
   output_high(PIN_A0);
   delay_ms(50);
   output_low(PIN_A0);
   delay_ms(50);
  if (input(PIN_B0))
  {b0=1;}
  else
  {b0=0;}
  if (input(PIN_B1))
  {b1=2;}
  else
  {b1=0;}
  if (input(PIN_B2))
  {b2=4;}
  else
  {b2=0;}
  if (input(PIN_B3))
  {b3=8;}
  else
  {b3=0;}
  if(input(PIN_B4))
  {b4=1;}
  else
  {b4=0;}
  if (input(PIN_B5))
  {b5=16;}
  else
  {b5=0;}
  if(input(PIN_B6))
  {b6=32;}
  else
  {b6=0;}
  if(input(PIN_B7))
  {b7=64;}
  else
  {b7=0;}
  temp=((b0+b1+b2+b3+b4+b5+b6+b7)*2.4)/(0.005);
   output_high(PIN_A0);
   delay_ms(200);
   set_tris_b(0x00);
   lcd_init();
   lcd_gotoxy(8,1);
   printf(lcd_putc,"FERGART");
   lcd_gotoxy(1,2);
   printf(lcd_putc,"Sensor digital");
   lcd_gotoxy(1,3);
   printf(lcd_putc,"Temperatura: %d",temp);
   delay_ms(100);
}
}
```


----------



## fvparg (Abr 18, 2010)

Hola, gracias por contestar.
El tema de hacer lo de leer el píxel e invertirlo (a parte de que se torna algo lento) tiene un problema mas y es que tengo imágenes con movimiento en mi GLCD.
Yo tengo a k un equipo que tiene este GLCD, usa un PIC18F4620 y tiene un Jumper que al cambiarlo invierte toda la pantalla instantáneamente parecería que le manda un comando directamente. 
Yo estoy usando un PIC18F4685 a 32mhz y ya tengo un programa completamente funcional, solo que quería agregarle la inversión de imagen. 
La otra que me queda es de alguna manera leer el comando que manda el otro equipo.
Pero estoy seguro q lo hace con un comando.
Desde ya muchas gracias.


----------



## thamaphyr (Sep 9, 2010)

picproblema dijo:


> Hola, yo tengo un glcd t6963cfg de 240x128.  Resulta que quiero mostrar una sola letra (por ejemplo la "A") y en el  lugar que yo quiera de la pantalla y la pantalla muestra 8 veces la  misma letra y en cualquier lado. Subo el archivo con la libreria  (escrita en C) para que la prueben (si quieren). Estoy usando el  compilador CCS.



Buenas buenas, me he basado en este  programa que hizo este user, bueno, no he logrado que me prenda ni un  pixelcito en la pantalla, pero quiza encontre el problema a este  programa, en la rutina en datasheet en auto write ahi bien dice que  debes enviar el comando 0xB2, el mismo AUTO_DATA_RESET, pero antes debes  enviar el check status de ST3, y ahi lo que se esta enviando es el  checkstatus para ST0 y ST1, porque se esta enviando a la funcion comando  y el unico que realiza ese check es la funcion autoescritura.

Bueno  pero en mi caso, lo que quiero es hacer asi sea encender un pixel, no  lo he logrado. Basandome en este codigo no se si sea porque no le este  enviando los comandos para escribir o no se que sera, pero el check  status para recibir comandos si estoy seguro q el t6963 me lo esta  recbiendo. 


Segun  entiendo no estoy seguro en el datasheet del display que ando manejando,  los comandos para mostrar en pantalla son los de data auto write y data  write, o no se si me falte aparte de enviar esos algun otro como para  mostrar, o no se si de pronto sea hardware.

http://img828.imageshack.us/img828/2430/img1225w.jpg


----------



## frmfernando (Oct 14, 2010)

Hola buenos días.

Lo primero dar las gracias a todos los que han participado en este foro para darnos toda la información que tenemos.

Por lo que veo estoy mucho más retrasado que todos ustedes en el montaje de un glcd pero bueno haber que consigo.

Llevo ya varios días intentando poner en marcha un glcd PB240128A-PA(1.0) y por el momento lo he logrado conectar a LPT1 y tanto con lcdstudio como lcdhype he logrado que me muestre información en pantalla también me pasa que me muestra una sola letra 8 veces cuando solo tengo escrita una, por lo que he podido ver el controlador que utiliza es el T6963c o eso creo por lo menos por la disposición de los cables la información que me sale en la parte trasera de la pantalla es:
   - Kl sn102 94v-o 3009
   - Powertip PB240128A-PA(1.0)
   - PG240128wrmagaco9q I C 9 0001 9929 A ROMs

   - El micro que lleva es AVANT SDN 8080G y tambien AVANT SAP1024B

Las patillas están todas en una sola linea y lo curioso es que comienzan por la K:

   - K A 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

K: GND (While)
A: 18 Ohm 5v+ (red)
1: Power supply (GND)
2: Power supply (+)
3: Vo Contrast Adjust
4: C/D Command / data select
5: RD Data read
6: WR Data Write
7: DB0 Data bus line
8: DB1 Data bus line
9: DB2 Data bus line
10: DB3 Data bus line
11: DB4 Data bus line
12: DB5 Data bus line
13: DB6 Data bus line
14: DB7 Data bus line
15: CE Chip enable
16: RST Reset
17: Vee Negative output
18: MD2 Select number of columns
19: FS1 Font selection
20: NC No connection

Esa es toda la información que he sacado, lo que me gustaría poder controlar la pantalla con un micro en estos momentos tengo el 16f84a, 16f626a y 16f873, en este mis mo hilo he visto que teniais preparado con el proteus un esquema para el 16f876a, algun alma caritativa tiene por hay los planos para poderme hacer un circuito y conectar esta pantalla?

Ya el siguiente paso es aprender a programarla para sacarle partido.
He probado en XP con Lcdhype y Lcdstudio y en Ubuntu con lcd4linux.

Les dejo unos enlaces con fotos de la pantalla.

http://img687.imageshack.us/i/05102010025.jpg/
http://img832.imageshack.us/i/05102010024.jpg/
http://img689.imageshack.us/i/05102010028.jpg/
http://img841.imageshack.us/i/05102010023b.jpg/
http://img824.imageshack.us/i/30092010018.jpg/
http://img713.imageshack.us/i/03082010033.jpg/
http://img708.imageshack.us/i/03082010028.jpg/



Muchas gracias.

Fernando.


----------



## danrod (Oct 14, 2010)

Hola compañero....
Mira esta foto... es el montaje REAL que a mi me funciono
Hay que aclara:
VEE-> la pantalla tiene un conversor interno que te ENTREGA<-12V
Este voltaje negativo sirve para al Vo el cual se encarga de fijar el contraste de la pantalla
Si tu pantalla tiene Backlight ... hay dos terminales A K que cumplen con la funcion de dar mas luz o menos... utliza un Potenciometro  y listo..
En el proteus estos terminales no existen..pero en la pantalla si..
espero que te sirva estos... saludos.. ami me fue de gran utilidad este y en genera todos los foros de lelectronica...


----------



## frmfernando (Oct 16, 2010)

Hola Danrod, muchas gracias por el esquema.

Veo que estas utilizando un Pic diferente al que yo tengo, mirare el patillaje para adaptarlo al mio.

Me podrías enviar el esquema completo?

Muchas gracias.

Fernando.

Rectifico, creo que ya tengo montado el glcd, ahora me falta algún programa para poder probarlo, alguien me puede hechar una mano y pasarme algún programa de "Hola Mundo" para ver si funciona?

De programación no tengo ni idea.

Gracias.


----------



## thamaphyr (Oct 21, 2010)

muchachos, 2 cosas extrañas que me pasa al utilizar la GLCD no se si auds les ocurre:
1) si escribo de forma consecutiva sea en modo grafico o en modo texto, este me dibuja hasta 30 caracteres diferentes, de ahi para alla no me los escribe, como si el comando whrite increment no llevara la siguiente posicion de la lcd y no escribe mas.
2) si escribo los caracteres standard del 6963c mas del 63 es decir del 0x40 en adelante, este tambien me ocurre lo del caso 1.

De resto si respeto esas dos condiciones, la GLCD me funciona bien

Un saludo


----------



## danrod (Oct 21, 2010)

....mira en este mismo post..sherar tiene esa rutinas... ami me funcionaron muy bien....


Pruebalas..eso si si tienes la 240X128.. si simulas en el proteus.. el cursor luego de cierta posición te salta ..es decir sale incorrectamente.... pero en la realidad funcionan bien..
SALUDOS...


----------



## thamaphyr (Nov 12, 2010)

ok danrod, me voy a cambiar al codigo de asherar para analizarlo, quiza sea porque quize empezar desde cero leyendo todo el datasheet de mi glcd y haciendo las funciones con comandos a mi manera, pero pues me encontre con esos dos inconvenientes, voy a empezar a a usar la libreria t6963c como las que tienen esos codigos a ver como me va, muchas gracias por tu respuesta. 


un saludo
PD: si, mi GLCD es de 240x128 y lo trabaje en ccs

Danrod, veo que cambiaste el codigo de asherar a ccs, pero no se porque no se si te sale tambien, me da un error en la libreria del t6963c.h, (adjunto la imagen), no logro enteder por qué ocurre?

http://img149.imageshack.us/img149/518/errohz.png
un saludo


----------



## danrod (Nov 12, 2010)

...@thamaphyr...

....mira si las utilice...recuerdo que el las desarrollo enMikroelectronica...un compilador.....recuerdo que las cambie al CSS..que era prácticamente lo mismo...fijate en uno de los mensajes...https://www.forosdeelectronica.com/f24/inicializar-lcd-concontrolador-t6963c-11700/index3.html
Arranque y texto ....Arranque_Text_CCS.rar
En estas rutinas se maneja el modo texto perfectamente... en esa ocasion me daba golpes en la cabeza por que el proteus no pasaba de cierta posicion del cursor... y EN LA REALIDAD funsiona bien....
..Pruebas esas rutinas..
el error te da porq que estas utlizando archivos de mikroelectronica en CCS....
Saludos.....



thamaphyr dijo:


> muchachos, 2 cosas extrañas que me pasa al utilizar la GLCD no se si auds les ocurre:
> 1) si escribo de forma consecutiva sea en modo grafico o en modo texto, este me dibuja hasta 30 caracteres diferentes, de ahi para alla no me los escribe, como si el comando whrite increment no llevara la siguiente posicion de la lcd y no escribe mas.
> 2) si escribo los caracteres standard del 6963c mas del 63 es decir del 0x40 en adelante, este tambien me ocurre lo del caso 1.
> 
> ...




Mira...no me habia fijado en tu mensaje........
Pero CREO que me paso lo mismo..lo solucione haciendo esto...

```
const int16 G_BASE = 0x0300;     // para memoria gráfica
const int16 T_BASE = 0x0000;     // para memoria de texto
```

Saludos.........



frmfernando dijo:


> Hola Danrod, muchas gracias por el esquema.
> 
> Veo que estas utilizando un Pic diferente al que yo tengo, mirare el patillaje para adaptarlo al mio.
> 
> ...


...Mira empieza por C... por mikroelectronica o CCS...
en este post encontraras el manejo por ambos compiladores.....
Cuando empece con el manejo de la pantalla no sabia nada.... edite las rutinas de Sherar...y funcionan bien...saludos.....


----------



## asherar (Nov 12, 2010)

Che, me alegro que les sirva mi humilde recopilación. Conste que yo lo único que hice fue pasarlas a una forma un poco más legible, intentando ser didácticas. 
Pero son cosas que bajé de por ahí. 
...
No quiero que me caigan con reclamos de copyright !!!


----------



## thamaphyr (Dic 11, 2010)

trankilo asherar, estoy seguro que nadie se quejara por copyright, esto es educativo, ademas desde que se le haya echado mano al codigo deja de ser copyright. Siento la demora por responder, he estado un tin ocupado y no he podido continuar, pero tan pronto tenga algo, lo posteo. Muchas gracias por tu ayuda danrod
un saludo


----------



## arielperez (Dic 27, 2010)

Hola,
Por lo que veo, han conectado sin inconvenientes el backlight del GLCD. En mi caso (Winstar W240128B) no he podido hacer que se encienda. En los pines A y K coloqué la tensión que aconsejaban y no lo logro. Alguien tuvo algún inconveniente parecido?.
Gracias.
Saluidos,
Ariel.


----------



## asherar (Dic 27, 2010)

Hola Ariel. 
A mi me pasaba lo mismo hasta que probé de conectar la polaridad contraria. 
(Nunca se olviden de la resistencia limitadora !!!)
Como se trata de diodos en inverso, en el peor de los casos no debería prender. 

Tampoco le pongan 200 kV !!!


----------



## armentatron (Ene 23, 2011)

hola amigos estoy trantado de hacer una especie de tarjeta electronica con un lcd de 20x4 y el pic 16f877 con pic basic pro. su funcionamiento es de que al energizar el pic comienza a trabajar el lcd con un mensaje de instruccion para que oprimas un unico boton para ir saltando "la pagina" al presionar el boton por primera vez comienza la primera pagina que se muestra en el lcd y no cambiara el mensaje hasta volver a presionar el boton, sin embargo no puedo salir de la primera parte y es que simulo lo que tengo en el pic simulator ide y mi pic se va a modo sleep antes de que se tenga que oprimir el boton por segunda vez. les dejo el codigo como lo estoy haciendo espero alguien me pueda ayudar o decirme en que estoy mal, agradesco la atencion.

Define LCD_DREG PORTB 
Define LCD_DBIT 4     
Define LCD_RSREG PORTB
Define LCD_RSBIT 1   
Define LCD_EREG PORTB
Define LCD_EBIT 2     
boton var portd.0
TRISB=0
trisd=%00000001
pause 500

inicio:
portd.1=0
PAUSE 500
LCDOUT $FE, 1 ' Limpiar LCD
LCDOUT $FE, 1, "Hola hermosa, para " 'Escribir en la primera línea   
Lcdout $fe, $C0, "Continuar leyendo "  'Escribir en la segunda línea
lcdout $fe, $94, "presiona el boton."
pause 1000

if boton=1 then 
portd.1=1
boton=0
LCDOUT $FE, 1
LCDOUT $FE, 1, "texto"
Lcdout $fe, $C0, "texto"  'Escribir en la segunda línea
lcdout $fe, $94, "texto"
lcdout $fe, $d4, "texto"
PAUSE 1000
endif

portd.1=0

if boton=1 then 
portd.1=1
boton=0
LCDOUT $FE, 1
LCDOUT $FE, 1, "texto2"
Lcdout $fe, $C0, "texto2"  'Escribir en la segunda línea
lcdout $fe, $94, "texto2"
lcdout $fe, $d4, "texto2"
PAUSE 1000
endif

end



el texto2 es lo que ya no me muestra, el micro se pone en sleep segun el pic simulator ide.


----------



## picproblema (Jul 9, 2011)

Buenas, despues de un tiempo vuelvo con el tema del GLCD. Esta vez escribi codigo en assembler pensando que podria "ver" errores mas facilmente pero no es asi, sigue pasando lo mismo, sea lo que sea que envie lo repite exactamente 8 veces. Mi GLCD es de 240 por 128 pixels, un modulo winstar WG240128, controlador T6963cfg (con memoria LY62256SL) y utilizo un pic 16f877. Aqui esta el codigo para quien se anime a darle una mirada:


```
list p=16f877
 include <p16f877.inc>
 radix hex
;******NOTA!!!******
; PORTB0 ---> GLCD DB0
; PORTB1 ---> GLCD DB1
; PORTB2 ---> GLCD DB2
; PORTB3 ---> GLCD DB3
; PORTB4 ---> GLCD DB4
; PORTB5 ---> GLCD DB5
; PORTB6 ---> GLCD DB6
; PORTB7 ---> GLCD DB7
;
; PORTC4 ---> GLCD CD
; PORTC5 ---> GLCD /RD
; PORTC6 ---> GLCD /WR
; PORTC7 ---> GLCD /CE
;
; PORTA0 ---> GLCD RESET
;
; GLCD FS1 ---> 0V (font 8x8)
; GLCD MD2 ---> +5V (column. = 32)
 cblock 0x20
byte_alto, byte_bajo
loop_h, loop_l
temp
delay
 endc
 org 0x00
 goto inicio
 org 0x05
inicio
 bsf  STATUS, RP0  ;cambio al banco 1
 bcf  STATUS, RP1
 bcf  RCSTA,SPEN  ;Puerto serie deshabilitado
 clrf OPTION_REG
 bsf  OPTION_REG,7 ;Resistencias pull-up del PORTB deshabilitadas
 movlw 0x06   ;Configuro PORTA como puerto ed E/S digitales
 movwf ADCON1
 clrf TRISA   ;Configuro a PORTA como salidas
 clrf TRISC   ;Configuro a PORTC como salidas
 bcf  STATUS, RP0  ;cambio a banco 0
aqui
 call GLCD_INI
 call limpiar_grafico
 call limpiar_texto
 clrf byte_bajo
 movlw 0x10
 movwf byte_alto
 call add_point  ;ubico el puntero en la posicion inicial del area de grafico en la pantalla
 movlw 0x2d  ;pixels que quiero mostrar
 call enviar_dato
 movlw 0xc4   ;0xc4 es el comando para escribir en
       ;memoria sin incrementar la posicion
       ;del address pointer
 call enviar_comando
 movlw 0x08
 movwf byte_bajo
 movlw 0x10
 movwf byte_alto
 call add_point  ;ubico el puntero en la posicion inicial
       ;del area de grafico en la pantalla
 movlw 0x41  ;pixels que quiero mostrar
 call enviar_dato
 movlw 0xc4   ;0xc4 (11000100) es el comando para escribir en memoria
       ;sin incrementar la posicion del address pointer
 call enviar_comando
bucle
goto bucle
GLCD_INI
;Rutina de inicializacion del controlador del GLCD
 bcf  PORTA,0
 nop      ;Resteo el GLCD por mas de 80ns
 bsf  PORTA,0
;Configuro el inicio de la memoria de grafico en la direccion 0x0000
 clrf byte_bajo
 clrf byte_alto
 call enviar_dos_datos
 movlw 0x42   ;0x42 es el comando para setear el inicio del area de grafico
 call enviar_comando
;Configuro el area de la memoria de grafico: 240 pixels / 8 bits (1 byte)= 30 bytes
;escojo 32 (0x0020) para facilitar operaciones logicas, tiene que coincidir con el tamaño de la pantalla
 movlw 0x20
 movwf byte_bajo
 clrf byte_alto
 call enviar_dos_datos
 movlw 0x43   ;0x43 es el comando para setear el area de graficos
 call enviar_comando
;Configuro el inicio de la memoria de texto: el area grafico es 32 byte * 128 lineas = 4096 (0x1000)
 clrf byte_bajo
 movlw 0x10
 movwf byte_alto
 call enviar_dos_datos
 movlw 0x40   ;0x40 es el comando para setear el inicio del area de texto
 call enviar_comando
;Configuro el area de la memoria de texto: 240 pixels / 8 bits (1 byte)= 30 bytes
;escojo 32 (0x0020) para facilitar operaciones logicas, tiene que coincidir con el tamaño de la pantalla
 movlw 0x20
 movwf byte_bajo
 clrf byte_alto
 call enviar_dos_datos
 movlw 0x41  ;0x41 es el comando para setear el area de texto
 call enviar_comando
;Configuro el modo como: CG=0 (uso caracteres internos), MD2=0 , MD0=0, MD0=0 para modo OR
modo_set
 movlw b'10000000'
 call enviar_comando
;Configuro el modo como: GRPH=1, TEXT=1, CUR=0, BLK=0 para texo y graficos a la vez sin cursor
display_set
 movlw b'10011100'
 call enviar_comando
;Configuro el offset register
 movlw 0x02
 movwf byte_bajo
 clrf byte_alto
 call enviar_dos_datos
 movlw 0x22   ;0x22 es el comando para la direccion
       ;del offset register
 call enviar_comando
 return
check_estado
;Comprueba el estado STA0/STA1, si ambos son 1 al mismo tiempo el
;controlador esta listo para recibir datos/comandos
 banksel TRISB
 movlw 0xff
 movwf TRISB   ;Configuro PORTB como entradas
 banksel PORTC
 movlw b'01010000'
 movwf PORTC   ;Configuro /CE=0, /WR=1, /RD=0 y CD=1 para leer estdo del GLCD
 nop
check1
 btfss PORTB,0   ;Pregunto si el bit de STA0 es 1
 goto check1   ;si no es 1 vulevo a preguntar hasta que lo sea
check1a
 btfss PORTB,1   ;Pregunto si el bit de STA1 es 1
 goto check1a   ;si no es 1 vulevo a preguntar por el primero
 movlw b'11110000'
 movwf PORTC   ;Configuro /CE=1, /WR=1, /RD=1 y CD=1
 nop
 banksel TRISB
 clrf TRISB   ;Configuro PORTB como salidas
 banksel PORTB
 return
enviar_dato
;Guarda en temp el dato a enviar, configura los pines de control (/CE, /WR, /RD y CD) y luego envia temp al PORTB
 movwf temp
 movlw b'11100000'
 movwf PORTC   ;Configuro /CE=1, /WR=1, /RD=1 y CD=0
 movf temp,W
 movwf PORTB
 nop
 movlw b'00100000'
 movwf PORTC   ;Configuro /CE=0, /WR=0, /RD=1 y CD=0 para escribir un dato al GLCD
 nop
 movlw b'11100000'
 movwf PORTC   ;Configuro /CE=1, /WR=1, /RD=1 y CD=0
 nop
 movlw b'11110000'
 movwf PORTC   ;Configuro /CE=1, /WR=1, /RD=1 y CD=1
 nop
 return
enviar_dos_datos
;Comprueba el estado STA0/STA1 para despues enviar los datos en byte_bajo y byte_alto
 call check_estado
 movf byte_bajo,W
 call enviar_dato
 call check_estado
 movf byte_alto,W
 call enviar_dato
 return
enviar_comando
;Guarda el comando en el registro temp, comprueba el estado
;STA0/STA1 y despues envia temp por el PORTB
 movwf temp
 call check_estado
 movf temp,W
 movwf PORTB
 nop
 movlw b'00110000'
 movwf PORTC   ;Configuro /CE=0, /WR=0, /RD=1 y CD=1
 nop
 movlw b'11110000'
 movwf PORTC   ;Configuro /CE=1, /WR=1, /RD=1 y CD=1
 nop
 return
limpiar_grafico
;La memoria del GLCD es de 240 pixels / 8 bits = 30 (elijo 32 para facilitar calculos)
;de ancho y 128 pixels de alto, o sea 32 * 128 = 4096 bits (0x10000) de memoria
 clrf byte_bajo
 clrf byte_alto
 call add_point
 movlw 0xb0   ;0xb0 es el comando para setear el modo de auto escritura
 call enviar_comando
 movlw 0x10
 movwf loop_l   ;filas 128 pixels / 8 bits = 16
lazo1
 movlw 0x00
 movwf loop_h   ;columnas 240 pixels / 8 bits = 30 (elijo 32)
lazo2
 clrw
 ;movlw 0x00
 call auto_escribir
 decfsz loop_h,F
 goto lazo2
 decfsz loop_l,F
 goto lazo1
 call check_estado_sta3
 movlw 0xb2   ;0xb2 es el comando para resetear el modo de auto escritura/lectura
 call enviar_comando
 return
limpiar_texto
;La memoria del GLCD es de 240 pixels / 8 bits = 30 (elijo 32 para facilitar calculos)
;de ancho y 128 pixels de alto, o sea 32 * 128 = 4096 bits (0x10000) de memoria
 clrf byte_bajo
 movlw 0x10
 movwf byte_alto
 call add_point
 movlw 0xb0   ;0xb0 es el comando para setear el modo de auto escritura
 call enviar_comando
 movlw 0x10
 movwf loop_l   ;filas 128 pixels / 8 bits = 16
lazo1a
 movlw 0x00
 movwf loop_h   ;columnas 240 pixels / 8 bits = 30 (elijo 32)
lazo2a
 clrw
 ;movlw 0x00
 call auto_escribir
 decfsz loop_h,F
 goto lazo2a
 decfsz loop_l,F
 goto lazo1a
 call check_estado_sta3
 movlw 0xb2   ;0xb2 es el comando para resetear el modo de auto escritura/lectura
 call enviar_comando
 return
check_estado_sta3
;Sub rutina que comprueba el estado del bit STA3 (Auto mode data write capability)
 banksel TRISB
 movlw 0xff
 movwf TRISB   ;Configuro PORTB como entradas
 banksel PORTB
 movlw b'01010000'
 movwf PORTC   ;Configuro /CE=0, /WR=1, /RD=0 y CD=1 para leer estdo del GLCD
 nop
check_sta3
 btfss PORTB,3   ;Pregunto si el bit de STA3 es 1
 goto check_sta3  ;si no es 1 vulevo a preguntar hasta que lo sea
 movlw b'11110000'
 movwf PORTC   ;Configuro /CE=1, /WR=1, /RD=1 y CD=1
 nop
 banksel TRISB
 clrf TRISB   ;Configuro PORTB como salidas
 banksel PORTB 
 return
add_point
;Configuro el address pointer en la ubicacion dada por byte_bajo (low address) y byte_alto (high address)
 call check_estado
 movf byte_bajo,W
 call enviar_dato
 call check_estado
 movf byte_alto,W
 call enviar_dato
 movlw 0x24   ;0x24 es el comando para el address pointer
 call enviar_comando
 return
auto_escribir
;Rutina que escribe en memoria con "auto write mode" el valor en el registro temp
 movwf temp
 call check_estado_sta3
 movf temp,W
 call enviar_dato
 return
retardo
 movlw 0xff
 movwf loop_l
la1a
 movlw 0xff
 movwf loop_h   ;columnas 240 pixels / 8 bits = 30 (elijo 32)
la2a
 decfsz loop_h,F
 goto la2a
 decfsz loop_l,F
 goto la1a
return
fin 
 END
 
;PORT_B0...PORT_B7 GLCD_D0...GLCD_D7
;PORT_C4 GLCD_CD
;PORT_C5 GLCD_/RD
;PORT_C6 GLCD_/WR
;PORT_C7 GLCD_/CE
```
 
El codigo deberia inicializar el modulo con la posicion de memoria grafica en 0000h, posicion de memoria texto en 1000h y el area de graficos y textos iguales 0020h. Limpio toda la pantalla. Envio una "M" y una "a" y termina todo. Solo es una prueba, nada definitivo.


----------



## marcofajardo (Ago 5, 2011)

hola amigos estoy tratando de programar una GLCD JHD240128D pero la verdad no tengo idea de como hacer la programacion en lenguaje C, aparte si quiero programar como las T6963C hay un pin M2 que no existe en la otra GLCD espero su respuesta...


----------



## jboond007 (Dic 5, 2011)

Hola Paloky, Antes de nada Buen trabajo. Estoy intentando manejar un display con chip T6993 con el pic 16F876 y he visto tu post, 
Me parece muy interesante el tema, ya que como te he dicho estoy intentando el control de este tipo de display.
Podrias indicarme el pinout que utilizaste entre la LCD y el PIC? para poder hacer pruebas.

Sé que es muy antiguo pero te estaría muy muy agradecido.
Antentamente, Franck.



Paloky dijo:


> Hola Brownie, siento el retraso, pero ya lo he encontrado.
> 
> Lo tenia perdido en un CD del año 2003.
> 
> ...


----------

