Y que pasa con las glcd's en sdcc?

Ver el tema anterior Ver el tema siguiente Ir abajo

Y que pasa con las glcd's en sdcc?

Mensaje por oskr el Vie 18 Mar 2011 - 16:00

hola que tal, acabo de cambiar por completo de herramientas que uso para trabajar con estos bichitos (pic's), hasta de sistema operativo. Tengo experiencia programando con basic, en pbp, y en c con ccs, bajo windows xp, exactamente este fue mi problema, que este tipo de software tienen licencia y el costo es ufffff. Y ahora estoy acoplándome a Linux con ubuntu 10.10 y a piklab con sdcc.

En fin, tengo una duda, alguien a trabajado con alguna glcd 128 x 64 , mas exactamente las que tienen el controlador k0108, conocen alguna librería libre de glcd?. he buscado por la red y encontré una librería libre en ccs, revisando la sintaxis vi que hay diferencia con sdcc, bueno eso digo, no estoy muy seguro.

No solo les comento mi duda, si no me gustaría interferir en la solucion. Este es código de una librería ccs para controlar glcd's con controlador k0108( es de u-control y lo mejor de todo es que es una librería libre), y me pregunto -¿ Sera posible acoplar este código a sdcc?- podrían ayudarme a resolver esta bola de inquietudes, gracias....

el codigo de la libreria es:

/////////////////////////////////////////////////////////////////////////
// Conexiones de pines del GLCD (Con chipset K0108)
//
// 1: CS1 <-> B1
// 2: CS1 <-> B0
// 6: R/S <-> B2
// 7: R/W <-> B3
// 8: E <-> B4
// 9..16: D0..D7 <-> D0..D7
// 17: Reset <-> B5 //
// Los valores pueden cambiarse con los DEFINE que están más abajo
//---------------------------------------------------------------------
// > GLCD_limpiar(color)
// "Borra" la pantala, llenando la del color seleccionado.
// color = 0 : puntos apagados
// color = 1 : puntos encendidos
//
// > GLCD_RAM2LCD()
// Vuelca el contenido de la RAM a la pantalla.
// solo funciona si FAST_GLCD está definido.
//---------------------------------------------------------------------
// > GLCD_inicializa(modo)
// Inicializa el GLCD, y debe llamarse ANTES de cualquier otra.
// modo = 0 : GLCD en ON
// modo = 1 : GLCD en OFF
//
// EN LAS SIGUIENTES FUNCIONES, SIEMPRE SE RESPETA QUE:
// color = 0 : puntos apagados
// color = 1 : puntos encendidos
//
// > GLCD_punto(x,y,color)
// Dibuja un punto en x,y. 0,0 es la esquina superior izquierda.
//
// > GLCD_linea(x1,y1,x2,y2,color)
// Dibuja una linea desde (x1,y1) a (x2,y2)
//
// >GLCD_rectangulo (x1,y1,x2,y2,color)
// Dibuja un rectangulo con esquinas en (x1,y1) y (x2,y2)
//
// >GLCD_caja (x1,y1,x2,y2,color)
// Dibuja un rectangulo pintado con esquinas en (x1,y1) y (x2,y2)
//
// >GLCD_circulo (x1,y1,r,color)
// Dibuja un circulo con centro en (x1,y1) y radio R
//
/////////////////////////////////////////////////////////////////////////


//Pines a usar
#define GLCD_CS1 PIN_E2
#define GLCD_CS2 PIN_E1
#define GLCD_DI PIN_C3
#define GLCD_RW PIN_C2
#define GLCD_E PIN_C1
#define GLCD_RESET PIN_E0

//Lados del GLCD
#define GLCD_lado_CS1 0
#define GLCD_lado_CS2 1

BYTE GLCD_leeBYTE(int1 lado);

//-----------------------------------------------------------------------
//Escribe un byte en una de las mitades de la pantalla (lado=0:izq Lado=1:der)
//-----------------------------------------------------------------------
void GLCD_enviaBYTE(int1 lado, BYTE dato)
{
if(lado) output_high(GLCD_CS2); // Selecciono la mitad correspondiente
else output_high(GLCD_CS1);

output_low(GLCD_RW); // Modo escritura
output_d(dato); // Coloco el dato en el puerto y...
delay_us(1); // ...espero.
output_high(GLCD_E); // Pongo el bit Enable en alto y...
delay_us(2); // ...espero.
output_low(GLCD_E); // Pongo el bit Enable en bajo.

output_low(GLCD_CS1); // Libero la linea CS1 y...
output_low(GLCD_CS2); // CS2.
}


//-----------------------------------------------------------------------
// Lee un byte de una de las dos mitades de la pantalla
//-----------------------------------------------------------------------
BYTE GLCD_leeBYTE(int1 lado)
{
BYTE dato;
set_tris_d(0xFF); // Puerto D como entrada
output_high(GLCD_RW); // GLCD en Modo lectura

// Selecciono la mitad del display a leer.
if(lado) output_high(GLCD_CS2);
else output_high(GLCD_CS1);

delay_us(1); // Espero...
output_high(GLCD_E); // Pongo en alto el pin enable y...
delay_us(2); // ...espero.
dato = input_d(); // Guardo en "dato" el valor devuelto y...
output_low(GLCD_E); // ...pongo en bajo el pin enable.

// Vuelvo a poner en bajo las lineas CS1 y CS2.
output_low(GLCD_CS1);
output_low(GLCD_CS2);

return dato;
}

//-----------------------------------------------------------------------
// Limpia el GLCD (pinta toda la pantalla de un color)
//-----------------------------------------------------------------------
void GLCD_limpiar(int1 color)
{
int8 i, j;

// Recorre las 8 paginas (vertical)
for(i = 0; i < 8; ++i)
{
output_low(GLCD_DI); // Modo instruccion

//Comienzo, en cada página, desde la dirección 0
GLCD_enviaBYTE(GLCD_lado_CS1, 0b01000000);
GLCD_enviaBYTE(GLCD_lado_CS2, 0b01000000);

//Selecciono la direccion dentro de la pagina
GLCD_enviaBYTE(GLCD_lado_CS1, i | 0b10111000);
GLCD_enviaBYTE(GLCD_lado_CS2, i | 0b10111000);

output_high(GLCD_DI); // Modo datos

// Recorre las dos mitades (horizontales)
for(j = 0; j < 64; ++j)
{ GLCD_enviaBYTE(GLCD_lado_CS1, 0xFF * color); // Enciende/apaga pixeles
GLCD_enviaBYTE(GLCD_lado_CS2, 0xFF * color); // Enciende/apaga pixeles
}
}
}


//-----------------------------------------------------------------------
//Esta funcion inicializa el LCD.
//-----------------------------------------------------------------------
void GLCD_inicializa(int1 modo)
{
// Pone los pines de control en el estado correcto.
output_high(GLCD_RESET);
output_low(GLCD_E);
output_low(GLCD_CS1);
output_low(GLCD_CS2);
output_low(GLCD_DI); // Modo instruccion

// Envio datos de inicialización -----------------------
GLCD_enviaBYTE(GLCD_lado_CS1, 0xC0);
GLCD_enviaBYTE(GLCD_lado_CS2, 0xC0);
GLCD_enviaBYTE(GLCD_lado_CS1, 0x40);
GLCD_enviaBYTE(GLCD_lado_CS2, 0x40);
GLCD_enviaBYTE(GLCD_lado_CS1, 0xB8);
GLCD_enviaBYTE(GLCD_lado_CS2, 0xB8);

// Si modo = 1 inicializa encendido. Sino, apagado.
if(modo == 1)
{ GLCD_enviaBYTE(GLCD_lado_CS1, 0x3F); // Enciendo el GLCD
GLCD_enviaBYTE(GLCD_lado_CS2, 0x3F); }
else {
GLCD_enviaBYTE(GLCD_lado_CS1, 0x3E); // Apago el GLCD
GLCD_enviaBYTE(GLCD_lado_CS2, 0x3E); }

// Borro la pantalla
GLCD_limpiar(0);
}


//-----------------------------------------------------------------------
// Dibuja un pixel
//-----------------------------------------------------------------------
void GLCD_punto(int8 x, int8 y, int1 color)
{
BYTE dato;
int1 lado = GLCD_lado_CS1; // Lado en que voy a dibujar.

if(x > 63) // Veo si cae del otro lado
{ x -= 64;
lado = GLCD_lado_CS2;}

output_low(GLCD_DI); // Modo instruccion
bit_clear(x,7); // Limpio bit MSB...
bit_set(x,6); // ...y pongo el bit 6 en 1
GLCD_enviaBYTE(lado, x); //Envio la dirección de la coordenada X

// Calculo en que pagina de las 8 cae...
GLCD_enviaBYTE(lado, (y/8 & 0xBF) | 0xB8);
output_high(GLCD_DI); // ...y paso a Modo datos

//Se necesitan dos lecturas para que devuelva el dato en la nueva direccion
GLCD_leeBYTE(lado);
dato = GLCD_leeBYTE(lado);

//De acuerdo al valor de color...
if(color == 1) bit_set(dato, y%Cool; // Enciendo el pixel
else bit_clear(dato, y%Cool; // apago el pixel

output_low(GLCD_DI); // Modo instruccion
GLCD_enviaBYTE(lado, x); // Fijo el lado a escribir,
output_high(GLCD_DI); // pongo en Modo Datos y....
GLCD_enviaBYTE(lado, dato); // dibujo el pixel
}


//-----------------------------------------------------------------------
// Dibuja una linea desde (x1,y1) a (x2,y2) de color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_linea(int x1, int y1, int x2, int y2, int1 color)
{
//Declaro variables-------------------
signed int x, y, incremento_x, incremento_y, distancia_x, distancia_y;
signed long P;
int i;

//Calculo las diferencias entre las coordenadas de origen y destino
distancia_x = abs((signed int)(x2 - x1));
distancia_y = abs((signed int)(y2 - y1));

//Inicializo x e y con las coordenadas de origen
x = x1;
y = y1;

//Calculo el sentido de los incrementos (positivos o negativos)
//en funcion de la posicion del origen y el destino
if(x1 > x2) incremento_x = -1; else incremento_x = 1;
if(y1 > y2) incremento_y = -1; else incremento_y = 1;

//Si la distancia horizontal es mayor a la vertical...
if(distancia_x >= distancia_y)
{ P = 2 * distancia_y - distancia_x;
for(i=0; i<=distancia_x; ++i)
{
GLCD_punto(x, y, color);

if(P < 0)
{ P += 2 * distancia_y;
x += incremento_x; }
else
{ P += 2*distancia_y - 2*distancia_x;
x += incremento_x;
y += incremento_y;}
}
}

//Si la distancia vertical es mayor a la horizontal...
else
{ P = 2 * distancia_x - distancia_y;
for(i=0; i<=distancia_y; ++i)
{ GLCD_punto(x, y, color);
if(P < 0)
{ P += 2 * distancia_x;
y += incremento_y; }
else
{ P += 2 * distancia_x - 2 * distancia_y;
x += incremento_x;
y += incremento_y; }
}
}
}
//-----------------------------------------------------------------------


//-----------------------------------------------------------------------
// Dibuja un rectángulo desde (x1,y1) a (x2,y2) de color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_rectangulo(int x1, int y1, int x2, int y2, int1 color)
{
GLCD_linea(x1,y1,x2,y1,color);
GLCD_linea(x1,y1,x1,y2,color);
GLCD_linea(x1,y2,x2,y2,color);
GLCD_linea(x2,y1,x2,y2,color);
}
//-----------------------------------------------------------------------

//-----------------------------------------------------------------------
// Dibuja un rectángulo PINTADO desde (x1,y1) a (x2,y2) de color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_caja(int x1, int y1, int x2, int y2, int1 color)
{
//Declaro variables-------------------
int i;

for(i=y1;i<=y2;i++) {
GLCD_linea(x1,i,x2,i,color); }

}
//-----------------------------------------------------------------------

//-----------------------------------------------------------------------
// Dibuja un circulo con centro en (x1,y1), radio y color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_circulo(int x1, int y1, int radio, int1 color)
{
signed int d, x, y;

//Inicializo las variables.
d = 1 - radio;
x = 0;
y = radio;

//Dibujo los cuatro pixeles que "caen" sobre los ejes cartesianos.
GLCD_punto(x1, y1 + radio, color);
GLCD_punto(x1, y1 - radio, color);
GLCD_punto(x1 + radio, y1, color);
GLCD_punto(x1 - radio, y1, color);

//Este es el bucle que pinta los octavos de la circunferencia.
while(x < y) {
if(d < 0) {d = d + 2 * x + 3;}
else {d = d + 2 * (x - y ) + 5;
y = y - 1 ;}
x = x + 1;

//Pone el punto en cada uno de los "octantes".
GLCD_punto(x1 + x, y1 + y, color);
GLCD_punto(x1 - x, y1 + y, color);
GLCD_punto(x1 + x, y1 - y, color);
GLCD_punto(x1 - x, y1 - y, color);
GLCD_punto(x1 + y, y1 + x, color);
GLCD_punto(x1 - y, y1 + x, color);
GLCD_punto(x1 + y, y1 - x, color);
GLCD_punto(x1 - y, y1 - x, color);
}
}
avatar
oskr
Participante
Participante

Mensajes : 18
Fecha de inscripción : 18/03/2011

Volver arriba Ir abajo

Re: Y que pasa con las glcd's en sdcc?

Mensaje por oskr el Vie 18 Mar 2011 - 16:04

esa carita que aparece en el código, debería ser un 8.
avatar
oskr
Participante
Participante

Mensajes : 18
Fecha de inscripción : 18/03/2011

Volver arriba Ir abajo

Re: Y que pasa con las glcd's en sdcc?

Mensaje por maigke el Sáb 19 Mar 2011 - 18:11

Me parece interesante tu planteamiento, en unos tiempos me gustaria colaborar un poco
avatar
maigke
Asiduo del Foro
Asiduo del Foro

Mensajes : 210
Fecha de inscripción : 12/04/2009
Edad : 40
Localización : Mexico

Volver arriba Ir abajo

POR FIN!

Mensaje por oskr el Lun 21 Mar 2011 - 9:51

Después de varios días de romperme la cabeza, y buscar y buscar la sintaxis adecuada de sdcc, ¡LO LOGRE cheers !, adapte solo unas pocas funciones. solo hay que hacer mas pruebas. Hasta ahora solo inicia la glcd y pinta de un color la pantalla completa(blanco o negro). Basta de hablar este es el código:

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
//libreria sdcc para uso de glcd con controlador k0108
//autor original u-control
//modificado por oskr segura
//funciono por primera ves 3:12am lunes 21 de marzo 2011
//solo se puede iniciar la lcd y pintar de un color
/* ----------------------------------------------------------------------- */
/* Plantilla generada por Piklab */
#include
#include
//Pines a usar
#define CS1 LATEbits.LATE0
#define CS2 LATEbits.LATE1
#define EN LATEbits.LATE2
#define RS LATCbits.LATC0
#define RW LATCbits.LATC1
#define RESET LATCbits.LATC2
#define LCDOUT TRISD = 0X00
#define LCDIN TRISD = 0XFF
#define LCD PORTD
#define LADO_CS1 0
#define LADO_CS2 1
/* ----------------------------------------------------------------------- */
/* Bits de configuración: adapte los parámetros a su necesidad */
code char at __CONFIG1L CONFIG1L = _PLLDIV_NO_DIVIDE__4MHZ_INPUT__1L & _CPUDIV__OSC1_OSC2_SRC___1__96MHZ_PLL_SRC___2__1L & _USBPLL_CLOCK_SRC_FROM_OSC1_OSC2_1L;
code char at __CONFIG1H CONFIG1H = _OSC_HS__HS_PLL__USB_HS_1H & _FCMEN_OFF_1H & _IESO_OFF_1H;
code char at __CONFIG2L CONFIG2L = _PUT_OFF_2L & _BODEN_ON_2L & _BODENV_2_0V_2L & _VREGEN_OFF_2L;
code char at __CONFIG2H CONFIG2H = _WDT_ON_2H & _WDTPS_1_32768_2H;
code char at __CONFIG3H CONFIG3H = _CCP2MUX_RC1_3H & _PBADEN_PORTB_4_0__CONFIGURED_AS_ANALOG_INPUTS_ON_RESET_3H & _LPT1OSC_OFF_3H & _MCLRE_MCLR_ON_RE3_OFF_3H;
code char at __CONFIG4L CONFIG4L = _STVR_ON_4L & _LVP_ON_4L & _ENICPORT_OFF_4L & _ENHCPU_OFF_4L & _BACKBUG_OFF_4L;
code char at __CONFIG5L CONFIG5L = _CP_0_OFF_5L & _CP_1_OFF_5L & _CP_2_OFF_5L & _CP_3_OFF_5L;
code char at __CONFIG5H CONFIG5H = _CPB_OFF_5H;
code char at __CONFIG6L CONFIG6L = _WRT_0_OFF_6L & _WRT_1_OFF_6L & _WRT_2_OFF_6L & _WRT_3_OFF_6L;
code char at __CONFIG6H CONFIG6H = _WRTC_OFF_6H & _WRTB_OFF_6H;
code char at __CONFIG7L CONFIG7L = _EBTR_0_OFF_7L & _EBTR_1_OFF_7L & _EBTR_2_OFF_7L & _EBTR_3_OFF_7L;
code char at __CONFIG7H CONFIG7H = _EBTRB_OFF_7H;
//+++++funcio de retardo+++++
void espera_us(unsigned int ust)
{
delay10tcy(1*ust);
}
void espera_ms(unsigned int mst)
{
delay1ktcy(5*mst);
}
void espera_s(unsigned int cs)
{
unsigned int s,cms;
for(s=0;s {
for(cms=0;cms<10;cms++)
{
espera_ms(100);
}
}
}

//-----------------------------------------------------------------------
//Escribe un byte en una de las mitades de la pantalla (lado=0:izq Lado=1:der)
//-----------------------------------------------------------------------
void GLCD_enviaBYTE(short int lado, unsigned char dato)
{
LCDOUT;
if(lado==1){CS2=1;} // Selecciono la mitad correspondiente
else {CS1=1;}
RW=0; // Modo escritura
LCD=dato; // Coloco el dato en el puerto y...
espera_us(1); // ...espero.
EN=1; // Pongo el bit Enable en alto y...
espera_us(2); // ...espero.
EN=0; // Pongo el bit Enable en bajo.
CS1=0; // Libero la linea CS1 y...
CS2=0; // CS2.
}
//-----------------------------------------------------------------------
// Limpia el GLCD (pinta toda la pantalla de un color)
//-----------------------------------------------------------------------
void GLCD_limpiar(short int color)
{
long int i;
long int j;

// Recorre las 8 paginas (vertical)
for(i = 0; i < 8; i++)
{
RS=0; // Modo instruccion
//Comienzo, en cada página, desde la dirección 0
GLCD_enviaBYTE(LADO_CS1, 0b01000000);
GLCD_enviaBYTE(LADO_CS2, 0b01000000);
//Selecciono la direccion dentro de la pagina
GLCD_enviaBYTE(LADO_CS1, i | 0b10111000);
GLCD_enviaBYTE(LADO_CS2, i | 0b10111000);
RS=1; // Modo datos
// Recorre las dos mitades (horizontales)
for(j = 0; j < 64; ++j)
{
GLCD_enviaBYTE(LADO_CS1, 0xFF * color); // Enciende/apaga pixeles
GLCD_enviaBYTE(LADO_CS2, 0xFF * color); // Enciende/apaga pixeles
}
}
}
//-----------------------------------------------------------------------
//Esta funcion inicializa el LCD.
//-----------------------------------------------------------------------
void GLCD_inicializa(short int modo)
{
// Pone los pines de control en el estado correcto.
RESET=1;
EN=0;
CS1=0;
CS2=0;
RS=0; // Modo instruccion
// Envio datos de inicialización -----------------------
GLCD_enviaBYTE(LADO_CS1, 0xC0);
GLCD_enviaBYTE(LADO_CS2, 0xC0);
GLCD_enviaBYTE(LADO_CS1, 0x40);
GLCD_enviaBYTE(LADO_CS2, 0x40);
GLCD_enviaBYTE(LADO_CS1, 0xB8);
GLCD_enviaBYTE(LADO_CS2, 0xB8);

// Si modo = 1 inicializa encendido. Sino, apagado.
if(modo == 1)
{
GLCD_enviaBYTE(LADO_CS1, 0x3F); // Enciendo el GLCD
GLCD_enviaBYTE(LADO_CS2, 0x3F);
}
else
{
GLCD_enviaBYTE(LADO_CS1, 0x3E); // Apago el GLCD
GLCD_enviaBYTE(LADO_CS2, 0x3E);
}
GLCD_limpiar(0);
}
void main()
{
//+++++ESTADO DE LOS PUERTOS+++++
TRISEbits.TRISE0=0; // Define pin RE0 de PORTE como salida.
TRISEbits.TRISE1=0; // Define pin RE1 de PORTE como salida.
TRISEbits.TRISE2=0; // Define pin RE2 de PORTE como salida.
TRISCbits.TRISC0=0; // Define pin RC0 de PORTC como salida.
TRISCbits.TRISC1=0; // Define pin RC1 de PORTC como salida.
TRISCbits.TRISC2=0; // Define pin RC1 de PORTC como salida.
TRISCbits.TRISC7=0; // Define pin RC1 de PORTC como salida.
//Inicializo el GLCD, encendido.
GLCD_inicializa(1);
GLCD_limpiar(1); //Lo pinto completamente de negro
espera_s(5); //Espero cinco segundos y...
GLCD_limpiar(0); //...lo limpio.
}

si ven algo mal, por favor comenten.


avatar
oskr
Participante
Participante

Mensajes : 18
Fecha de inscripción : 18/03/2011

Volver arriba Ir abajo

Re: Y que pasa con las glcd's en sdcc?

Mensaje por oskr el Lun 21 Mar 2011 - 10:03

no supe como insertar imágenes, pero les dejo los link de los pantallazos para que vean los resultados.

http://img215.imageshack.us/i/pintanegro.png/
http://img193.imageshack.us/i/pintablanco.png/
avatar
oskr
Participante
Participante

Mensajes : 18
Fecha de inscripción : 18/03/2011

Volver arriba Ir abajo

Re: Y que pasa con las glcd's en sdcc?

Mensaje por maigke el Lun 21 Mar 2011 - 13:27

Pues felicitaciones compañero, y buen aporte, siga así! bounce
avatar
maigke
Asiduo del Foro
Asiduo del Foro

Mensajes : 210
Fecha de inscripción : 12/04/2009
Edad : 40
Localización : Mexico

Volver arriba Ir abajo

Re: Y que pasa con las glcd's en sdcc?

Mensaje por oskr el Dom 27 Mar 2011 - 6:13

Listo, por fin, cheers , esta adaptado el código para funcionar con sdcc, tenia un problema muy grande, era que me mostraba mal todo, después de pintar dos o tres veces una función. Luego de revisar el código 1000000 veces, de la nada se me ocurrió checar si en proteus tenia algún campo para modificar la frecuencia de la glcd, y asi era, lo baje de 300 khz a 100khz, y ok, todo funciono. eso me dice que el programa esta bien, pero tendríamos que tener cuidado con nuestros tiempos.

aquí les va.

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
//libreria sdcc para uso de glcd con controlador k0108
//autor original u-control
//modificado por oskr segura
//funciono por primera ves 3:12am lunes 21 de marzo 2011
//solo se puede iniciar la lcd y pintar de un color
/* ----------------------------------------------------------------------- */
/* Plantilla generada por Piklab */
#include
#include
//#include

//Pines a usar
#define CS1 LATEbits.LATE0
#define CS2 LATEbits.LATE1
#define EN LATEbits.LATE2
#define RS LATCbits.LATC0
#define RW LATCbits.LATC1
#define RESET LATCbits.LATC2
#define LCDOUT TRISD = 0X00
#define LCDIN TRISD = 0XFF
#define LCD PORTD
#define LADO_CS1 0
#define LADO_CS2 1

#define BitSet(arg,posn) ((arg) |= (1 << (posn)))
#define BitClr(arg,posn) ((arg) &= ~(1 << (posn)))

/* ----------------------------------------------------------------------- */
/* Bits de configuración: adapte los parámetros a su necesidad */
code char at __CONFIG1L CONFIG1L = _PLLDIV_NO_DIVIDE__4MHZ_INPUT__1L & _CPUDIV__OSC1_OSC2_SRC___1__96MHZ_PLL_SRC___2__1L & _USBPLL_CLOCK_SRC_FROM_OSC1_OSC2_1L;
code char at __CONFIG1H CONFIG1H = _OSC_HS__HS_PLL__USB_HS_1H & _FCMEN_OFF_1H & _IESO_OFF_1H;
code char at __CONFIG2L CONFIG2L = _PUT_OFF_2L & _BODEN_ON_2L & _BODENV_2_0V_2L & _VREGEN_OFF_2L;
code char at __CONFIG2H CONFIG2H = _WDT_ON_2H & _WDTPS_1_32768_2H;
code char at __CONFIG3H CONFIG3H = _CCP2MUX_RC1_3H & _PBADEN_PORTB_4_0__CONFIGURED_AS_ANALOG_INPUTS_ON_RESET_3H & _LPT1OSC_OFF_3H & _MCLRE_MCLR_ON_RE3_OFF_3H;
code char at __CONFIG4L CONFIG4L = _STVR_ON_4L & _LVP_ON_4L & _ENICPORT_OFF_4L & _ENHCPU_OFF_4L & _BACKBUG_OFF_4L;
code char at __CONFIG5L CONFIG5L = _CP_0_OFF_5L & _CP_1_OFF_5L & _CP_2_OFF_5L & _CP_3_OFF_5L;
code char at __CONFIG5H CONFIG5H = _CPB_OFF_5H;
code char at __CONFIG6L CONFIG6L = _WRT_0_OFF_6L & _WRT_1_OFF_6L & _WRT_2_OFF_6L & _WRT_3_OFF_6L;
code char at __CONFIG6H CONFIG6H = _WRTC_OFF_6H & _WRTB_OFF_6H;
code char at __CONFIG7L CONFIG7L = _EBTR_0_OFF_7L & _EBTR_1_OFF_7L & _EBTR_2_OFF_7L & _EBTR_3_OFF_7L;
code char at __CONFIG7H CONFIG7H = _EBTRB_OFF_7H;
//+++++funcio de retardo+++++
void espera_us(unsigned int ust)
{
delay10tcy(1*ust);
}
void espera_ms(unsigned int mst)
{
delay1ktcy(5*mst);
}
void espera_s(unsigned int cs)
{
unsigned int s,cms;
for(s=0;s {
for(cms=0;cms<10;cms++)
{
espera_ms(100);
}
}
}
//-----------------------------------------------------------------------
//Escribe un byte en una de las mitades de la pantalla (lado=0:izq Lado=1:der)
//-----------------------------------------------------------------------
void GLCD_enviaBYTE(short int lado, unsigned _data)
{
LCDOUT;
LCD=0;
if(lado==1){CS2=1;} // Selecciono la mitad correspondiente
else {CS1=1;}
RW=0; // Modo escritura
LCD=_data; // Coloco el dato en el puerto y...
espera_us(1); // ...espero.
EN=1; // Pongo el bit Enable en alto y...
espera_us(2); // ...espero.
EN=0; // Pongo el bit Enable en bajo.
CS1=0; // Libero la linea CS1 y...
CS2=0; // CS2.
}
//-----------------------------------------------------------------------
// Lee un byte de una de las dos mitades de la pantalla
//-----------------------------------------------------------------------
unsigned char GLCD_leeBYTE(short int lado)
{
unsigned _data=0;
LCDIN;
RW=1; // GLCD en Modo lectura
// Selecciono la mitad del display a leer.
if(lado==1) {CS2=1;}
else {CS1=1;}
espera_us(1); // ...espero.
EN=1; // Pongo en alto el pin enable y...
espera_us(2); // ...espero.
_data = LCD ; // Guardo en "dato" el valor devuelto y...
EN=0; // ...pongo en bajo el pin enable.
// Vuelvo a poner en bajo las lineas CS1 y CS2.
CS1=0;
CS2=0;
return (_data);
}
//-----------------------------------------------------------------------
// Limpia el GLCD (pinta toda la pantalla de un color)
//-----------------------------------------------------------------------
void GLCD_limpiar(short int color)
{
long int i;
long int j;

// Recorre las 8 paginas (vertical)
for(i = 0; i < 8; i++)
{
RS=0; // Modo instruccion
//Comienzo, en cada página, desde la dirección 0
GLCD_enviaBYTE(LADO_CS1, 0b01000000);
GLCD_enviaBYTE(LADO_CS2, 0b01000000);
//Selecciono la direccion dentro de la pagina
GLCD_enviaBYTE(LADO_CS1, i | 0b10111000);
GLCD_enviaBYTE(LADO_CS2, i | 0b10111000);
RS=1; // Modo datos
// Recorre las dos mitades (horizontales)
for(j = 0; j < 64; ++j)
{
GLCD_enviaBYTE(LADO_CS1, 0xFF * color); // Enciende/apaga pixeles
GLCD_enviaBYTE(LADO_CS2, 0xFF * color); // Enciende/apaga pixeles
}
}
}
//-----------------------------------------------------------------------
//Esta funcion inicializa el LCD.
//-----------------------------------------------------------------------
void GLCD_inicializa(short int modo)
{
// Pone los pines de control en el estado correcto.
RESET=1;
EN=0;
CS1=0;
CS2=0;
RS=0; // Modo instruccion
// Envio datos de inicialización -----------------------
GLCD_enviaBYTE(LADO_CS1, 0xC0);
GLCD_enviaBYTE(LADO_CS2, 0xC0);
GLCD_enviaBYTE(LADO_CS1, 0x40);
GLCD_enviaBYTE(LADO_CS2, 0x40);
GLCD_enviaBYTE(LADO_CS1, 0xB8);
GLCD_enviaBYTE(LADO_CS2, 0xB8);
// Si modo = 1 inicializa encendido. Sino, apagado.
if(modo == 1)
{
GLCD_enviaBYTE(LADO_CS1, 0x3F); // Enciendo el GLCD
GLCD_enviaBYTE(LADO_CS2, 0x3F);
}
else
{
GLCD_enviaBYTE(LADO_CS1, 0x3E); // Apago el GLCD
GLCD_enviaBYTE(LADO_CS2, 0x3E);
}
GLCD_limpiar(0);
}
//-----------------------------------------------------------------------
// Dibuja un pixel
//-----------------------------------------------------------------------
void GLCD_punto(unsigned char x, unsigned char y, short int color)
{
unsigned char dato;
short int lado = LADO_CS2; // Lado en que voy a dibujar.
if(x > 63) // Veo si cae del otro lado
{
x-= 64;
lado = LADO_CS1;
}
RS=0; // Modo instruccion
BitClr(x,7); // Limpio bit MSB...}
BitSet(x,6); // ...y pongo el bit 6 en 1
GLCD_enviaBYTE(lado, x); //Envio la dirección de la coordenada X
GLCD_enviaBYTE(lado, (y/8 & 0xBF) | 0xB8);// Calculo en que pagina de las 8 cae...
RS=1; // ...y paso a Modo datos
//Se necesitan dos lecturas para que devuelva el dato en la nueva direccion
GLCD_leeBYTE(lado);
dato = GLCD_leeBYTE(lado);
//De acuerdo al valor de color...
if(color == 1) {BitSet(dato, y%Cool;}
if(color == 0) {BitClr(dato, y%Cool;}
RS=0; // Modo instruccion
GLCD_enviaBYTE(lado, x); // Fijo el lado a escribir,
RS=1; // pongo en Modo Datos y....
GLCD_enviaBYTE(lado, dato); // dibujo el pixel
}
//-----------------------------------------------------------------------
// Dibuja una linea desde (x1,y1) a (x2,y2) de color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_linea(signed int x1,signed int y1,signed int x2,signed int y2,short int color)
{
//Declaro variables-------------------
signed int x, y, incremento_x, incremento_y, distancia_x, distancia_y;
signed long P;
int i;
//Calculo las diferencias entre las coordenadas de origen y destino
distancia_x = ((signed int)(x2 - x1));
distancia_y = ((signed int)(y2 - y1));
if(distancia_x < 0){distancia_x=((distancia_x)*(-1));}
if(distancia_y < 0){distancia_y=((distancia_y)*(-1));}
//Inicializo x e y con las coordenadas de origen
x = x1;
y = y1;
//Calculo el sentido de los incrementos (positivos o negativos)
//en funcion de la posicion del origen y el destino
if(x1 > x2) incremento_x = -1; else incremento_x = 1;
if(y1 > y2) incremento_y = -1; else incremento_y = 1;
//Si la distancia horizontal es mayor a la vertical...
if(distancia_x >= distancia_y)
{
P = 2 * distancia_y - distancia_x;
for(i=0; i<=distancia_x; ++i)
{
GLCD_punto(x, y, color);
if(P < 0)
{
P += 2 * distancia_y;
x += incremento_x;
}
else
{
P += 2*distancia_y - 2*distancia_x;
x += incremento_x;
y += incremento_y;
}
}
}
//Si la distancia vertical es mayor a la horizontal...
else
{
P = 2 * distancia_x - distancia_y;
for(i=0; i<=distancia_y; ++i)
{
GLCD_punto(x, y, color);
if(P < 0)
{
P += 2 * distancia_x;
y += incremento_y;
}
else
{
P += 2 * distancia_x - 2 * distancia_y;
x += incremento_x;
y += incremento_y;
}
}
}
}
//-----------------------------------------------------------------------
// Dibuja un rectángulo desde (x1,y1) a (x2,y2) de color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_rectangulo(signed int x1,signed int y1,signed int x2,signed int y2,short int color)
{
GLCD_linea(x1,y1,x2,y1,color);
GLCD_linea(x1,y1,x1,y2,color);
GLCD_linea(x1,y2,x2,y2,color);
GLCD_linea(x2,y1,x2,y2,color);
}
//-----------------------------------------------------------------------
// Dibuja un rectángulo PINTADO desde (x1,y1) a (x2,y2) de color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_caja(signed int x1,signed int y1,signed int x2,signed int y2,short int color)
{
//Declaro variables-------------------
int i;
for(i=y1;i<=y2;i++)
{
GLCD_linea(x1,i,x2,i,color);
}
}
//-----------------------------------------------------------------------
// Dibuja un circulo con centro en (x1,y1), radio y color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_circulo(signed int x1,signed int y1,signed int radio,short int color)
{
signed int d, x, y;

//Inicializo las variables.
d = 1 - radio;
x = 0;
y = radio;

//Dibujo los cuatro pixeles que "caen" sobre los ejes cartesianos.
GLCD_punto(x1, y1 + radio, color);
GLCD_punto(x1, y1 - radio, color);
GLCD_punto(x1 + radio, y1, color);
GLCD_punto(x1 - radio, y1, color);

//Este es el bucle que pinta los octavos de la circunferencia.
while(x < y) {
if(d < 0) {d = d + 2 * x + 3;}
else {d = d + 2 * (x - y ) + 5;
y = y - 1 ;}
x = x + 1;

//Pone el punto en cada uno de los "octantes".
GLCD_punto(x1 + x, y1 + y, color);
GLCD_punto(x1 - x, y1 + y, color);
GLCD_punto(x1 + x, y1 - y, color);
GLCD_punto(x1 - x, y1 - y, color);
GLCD_punto(x1 + y, y1 + x, color);
GLCD_punto(x1 - y, y1 + x, color);
GLCD_punto(x1 + y, y1 - x, color);
GLCD_punto(x1 - y, y1 - x, color);
}
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
void main()
{
unsigned int i,j;
//+++++ESTADO DE LOS PUERTOS+++++
TRISEbits.TRISE0=0; // Define pin RE0 de PORTE como salida.
TRISEbits.TRISE1=0; // Define pin RE1 de PORTE como salida.
TRISEbits.TRISE2=0; // Define pin RE2 de PORTE como salida.
TRISCbits.TRISC0=0; // Define pin RC0 de PORTC como salida.
TRISCbits.TRISC1=0; // Define pin RC1 de PORTC como salida.
TRISCbits.TRISC2=0; // Define pin RC1 de PORTC como salida.
TRISCbits.TRISC7=0; // Define pin RC1 de PORTC como salida.
//Inicializo el GLCD, encendido.
GLCD_inicializa(1);
//se trazan puntos en la glcd
GLCD_limpiar(1); //...lo limpio.
for(i=0;i<65;i++)
{
for(j=0;j<33;j++)
{
GLCD_punto((i*2),(j*2),0);
}
}
espera_s(2);
GLCD_limpiar(0); //...lo limpio.
GLCD_punto(64,32,1);
for(i=0;i<65;i++)
{
for(j=0;j<33;j++)
{
GLCD_punto((i*2),(j*2),1);
}
}
// Trazo una linea horizontal, en medio de la pantalla
espera_s(2);
GLCD_limpiar(0); //...lo limpio.
GLCD_linea(0, 31, 127, 31, 1);
// Trazo varias lineas verticales
espera_s(2);
GLCD_limpiar(0); //...lo limpio.
for(i=0; i<=127; i=i+Cool
{
GLCD_linea(i,0,i,63,1);
}
// Dibujo varios rectángulos
espera_s(2);
GLCD_limpiar(0); //Limpio la pantalla
for(i=0; i<=48; i=i+6)
{
GLCD_rectangulo(i,i,127-i,63,1);
}
// Dibujo varias cajas
espera_s(2);
GLCD_limpiar(0); //Limpio la pantalla
for(i=1; i<=120; i=i+15)
{
GLCD_caja(i,5,i+8,12+i/5,1);
}
GLCD_caja(10,38,110,55,1);
// Dibujo varios circulos
espera_s(2);
GLCD_limpiar(0); //Limpio la pantalla
for(i=10; i<=100; i=i+16)
{
GLCD_circulo(i,30,i/5+2,1);
}
}


avatar
oskr
Participante
Participante

Mensajes : 18
Fecha de inscripción : 18/03/2011

Volver arriba Ir abajo

Re: Y que pasa con las glcd's en sdcc?

Mensaje por oskr el Dom 27 Mar 2011 - 6:35

hay le va una imagen de todo lo que hace,(pixel, lineas vertical, horizontal con pendiente; cuadros vacío, rellenos; círculos:
http://img684.imageshack.us/i/glcd.png/
avatar
oskr
Participante
Participante

Mensajes : 18
Fecha de inscripción : 18/03/2011

Volver arriba Ir abajo

Re: Y que pasa con las glcd's en sdcc?

Mensaje por Pikitin el Dom 27 Mar 2011 - 17:51

Hola oskr... muy buena la librería. Gracias por el aporte!!

A ver si tengo oportunidad de probarla.

Saludos.

Pikitin
veterano
veterano

Mensajes : 623
Fecha de inscripción : 26/11/2008

http://linuxmicros.blogspot.com/

Volver arriba Ir abajo

Re: Y que pasa con las glcd's en sdcc?

Mensaje por oskr el Lun 28 Mar 2011 - 22:03

despues de muchas pruebas e logrado poner texto en la glcd, son dos tipos de fuentes 3x5 y 5x5, enfin creo que casi es todo. Pero tengo una duda, podria pintarce en una pantalla virtual todo, y despues bolcarece a la glcd, para evitar que se vean algunos parpadeos en la pantalla, esto por que, en las pruebas que hago en proteus se ve cuando pinta la glcd, y creo que si queremos hacer alguna animacion se veria algo mal o como ven.
avatar
oskr
Participante
Participante

Mensajes : 18
Fecha de inscripción : 18/03/2011

Volver arriba Ir abajo

Re: Y que pasa con las glcd's en sdcc?

Mensaje por Contenido patrocinado


Contenido patrocinado


Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba

- Temas similares

 
Permisos de este foro:
No puedes responder a temas en este foro.