PROBLEMA GLCD CON C18

[aitopes]

Que parecido al mio!!!!

Hablando en serio, aqui (Libreria de gráficos para GLCD K0108 en CCS) tienes una libreria que pone puntos sin problemas en ese display. Esta bastante facil para pasarla a C18 y esta todo bastante comentado:

Código: [Seleccionar]

/////////////////////////////////////////////////////////////////////////
// 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%8);    // Enciendo el pixel
         else     bit_clear(dato, y%8);  // 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);
      }
  }


[doppel]

jajaja hasta el mismo fondo!!

[camigod]

jajaa si, la imagen la saque de google buscando la referencia d la mia, pero es esactamente igual,
y si, de las librerias de CCS fue q saque las mias para MPLAB, pero hay un problema con la funcion de leerbyte...
y no logro hacer que funcione... no se que podra ser, pero en las simulaciones nunca lee el dato y termina borrando el pixel anterior y sobreponiendo el nuevo.

Gracias.

[MLO__]

 
MUCHAS GRACIAS CAMIGOD