uControl
Julio 30, 2010, 12:37:53 *
Bienvenido(a), Visitante. Por favor, ingresa o regístrate.

Ingresar con nombre de usuario, contraseña y duración de la sesión
 
   Inicio   Ayuda Buscar Ingresar Registrarse  
uControl > Articulos, circuitos, tutoriales y Revista uControl > Tutoriales, guias y cursos en uControl > CCS - Libreria de gráficos para GLCD K0108
Páginas: 1 2 »   Ir Abajo
« anterior próximo »
  Imprimir  
Autor Tema: CCS - Libreria de gráficos para GLCD K0108  (Leído 1278 veces)
0 Usuarios y 1 Visitante están viendo este tema.
Ariel
Global Moderator
PIC24F
*****
Desconectado Desconectado

Sexo: Masculino
Mensajes: 4942



WWW
« : Febrero 26, 2010, 10:03:30 »
CCS - Libreria de gráficos para GLCD K0108

Introducción
El compilador CCS proporciona una libreria capaz de dibujar primitivas sobre varios modelos de displays LCD gráficos o GLCD (por Graphic Liquid Cristal Display). Hay versiones de esta libreria para pantallas con diferentes controladores embebidos, como el Samsung KS0108 o el Toshiba T6963.


Pero a pesar de que pueden distribuirse libremente los trabajos que hagamos con ellas, no pueden compartirse los programas que las contengan a menos que la persona que los recibe tambien sea un usuario registrado de CCS. Esto limita mucho su uso con fines educativos. De hecho, si quisiesemos exponer aqui un programa que grafique algo en un GLCD, estariamos violando la licencia, ya que es muy posible que muchos de los lectores de uControl no hayan comprado el compilador. Es por ello que nos hemos decidido a escribir una libreria propia, que usaremos de ahora en más para nuestros proyectos.

La librería GLCD_K0108

Puedes descargar la libreria GLCD_K0108.C haciendo click aquí.

En las siguientes secciones iremos explicando cada una de sus partes.

IMPORTANTE: El trazado de lineas se basa en el Algoritmo de Bresenham, y las circunferencias se han resuelto mediante el "algoritmo del punto medio", que divide la circunferencia en 8 partes simétricas, evitando utilizar funciones como seno, coseno o potencias, que volverian muy lenta la tarea del trazado.

GLCD_limpiar(color)
Esta es la función que "pinta" toda la pantalla con uno u otro color. Si recibe como parámetro un "1", la pintará completamente de negro. Si recibe un "0", la limpiará por completo. Por supuesto, su mayor utilidad es la segunda alternativa.

Su funcionamiento también es muy sencillo, y se "apoya" en GLCD_envia BYTE() para escribir en el GLCD. Recorre ambas mitades del GLCD, página por página, de arriba hacia abajo, escribiendo "0x00" o "0xFF" según se haya elegido pintar o borrar.


(Ház clic sobre las imágenes para ampliarlas)

En la primer imágen, utilizando GLCD_limpiar(1);, la pantalla se pinta completamente de negro. En la segunda, mediante GLCD_limpiar(0);, se pinta completamente de blanco. Podemos usar esta función para limpiar la pantalla.

Puedes ver un ejemplo de uso de esta función aquí.
Código:
#include <16F877A.h>
#device *=16
#include <stdlib.h>
#fuses  HS,NOWDT,NOLVP

#USE DELAY (CLOCK=20000000)
#include <GLCD_K0108.C>

//-------Comienza el programa -----------------------
void main()
{
     //Inicializo el GLCD, encendido.
     GLCD_inicializa(1);
    
     GLCD_limpiar(1);  //Lo pinto completamente de negro
     delay_ms(2000);   //Espero dos segundos y...
     GLCD_limpiar(0);  //...lo limpio.
}

GLCD_inicializa(modo)
Esta es la primer función de la librería que debe llamar nuestro programa. Se encarga de inicializar el GLCD, y el parametro "modo" determina si estará encendido (si recibe un "1") o apagado (si recibe un "0").

Puedes ver un ejemplo de uso de esta función aquí.
Código:
#include <16F877A.h>
#device *=16
#include <stdlib.h>
#fuses  HS,NOWDT,NOLVP

#USE DELAY (CLOCK=20000000)
#include <GLCD_K0108.C>

//-------Comienza el programa -----------------------
void main()
{
     //Inicializo el GLCD, encendido.
     GLCD_inicializa(1);
    
     GLCD_limpiar(1);  //Lo pinto completamente de negro
     delay_ms(2000);   //Espero dos segundos y...
     GLCD_limpiar(0);  //...lo limpio.
}

GLCD_punto(x, y, color)
Esta es la "primitiva gráfica" indispensable. A partir de GLCD_punto(x, y, color) escribiremos todas las funciones restantes. Los parametros que recibe GLCD_punto(x, y, color) son:

    * x: un byte, es la coordenada "x" (horizontal), con valores válidos de 0 a 127 (izquierda a derecha).
    * y: un byte, es la coordenada "y" (vertical), con valores válidos de 0 a 63 (arriba a abajo)
    * color: un bit, "0" = apagado, "1" = encendido.


(Ház clic sobre las imágenes para ampliarlas)

Puedes ver un ejemplo de uso de esta función aquí.
Código:
#include <16F877A.h>
#device *=16
#include <stdlib.h>
#fuses  HS,NOWDT,NOLVP

#USE DELAY (CLOCK=20000000)
#include <GLCD_K0108.C>

//-------Comienza el programa -----------------------
void main()
{
     int i,j;
    
     GLCD_inicializa(1);     //Inicializo el GLCD, encendido.
     GLCD_limpiar(0);        //Limpio la pantalla
    
     // Pinto puntos en el GLCD
     for(i=0; i<=127; i=i+8){
         for(j=0; j<=63; j=j+8){
            GLCD_punto(i,j,1); //Pinto el punto
         }
     }
}

GLCD_linea(x1, y1, x2, y2, color)
La linea tambien resulta indispensable a la hora de dibujar un gráfico. Los parametros que recibe GLCD_linea(x1, y1, x2, y2, color) son:

    * x1: un byte, es la coordenada "x" (horizontal) del primer extremo de la linea, con valores válidos de 0 a 127 (izquierda a derecha).
    * y1: un byte, es la coordenada "y" (vertical) del primer extremo de la linea, con valores válidos de 0 a 63 (arriba a abajo).
    * x2: un byte, es la coordenada "x" (horizontal) del segundo extremo de la linea, con valores válidos de 0 a 127 (izquierda a derecha).
    * y2: un byte, es la coordenada "y" (vertical) del segundo extremo de la linea, con valores válidos de 0 a 63 (arriba a abajo).
    * color: un bit, "0" = linea en blanco, "1" = linea en negro.


(Ház clic sobre las imágenes para ampliarlas)

Puedes ver un ejemplo de uso de esta función aquí.
Código:
#include <16F877A.h>
#device *=16
#include <stdlib.h>
#fuses  HS,NOWDT,NOLVP

#USE DELAY (CLOCK=20000000)
#include <GLCD_K0108.C>

//-------Comienza el programa -----------------------
void main()
{
     int i,j;
    
     GLCD_inicializa(1);     //Inicializo el GLCD, encendido.
     GLCD_limpiar(0);        //Limpio la pantalla
    
     // Trazo una linea horizontal, en medio de la pantalla
     GLCD_linea(0, 31, 127, 31, 1);
    
     // Trazo varias lineas verticales
     for(i=0; i<=127; i=i+8){
         GLCD_linea(i,0,i,63,1);
     }
    
}  

Y este código corresponde a la segunda imagen mostrada antes:
Código:
#include <16F877A.h>
#device *=16
#include <stdlib.h>
#fuses  HS,NOWDT,NOLVP

#USE DELAY (CLOCK=20000000)
#include <GLCD_K0108.C>

//-------Comienza el programa -----------------------
void main()
{
     int i;
    
     GLCD_inicializa(1);     //Inicializo el GLCD, encendido.
     GLCD_limpiar(0);        //Limpio la pantalla
    
     // Dibujo eje "X"
     GLCD_linea(0, 32, 127, 32, 1);
     for(i=0; i<=127; i=i+8){ GLCD_linea(i,31,i,33,1); }
    
     // Dibujo eje "Y"
     GLCD_linea(64, 0, 64, 64, 1);
     for(i=0; i<=63; i=i+8){ GLCD_linea(63,i,65,i,1); }
    
     // Dibujo la "grafica"
     GLCD_linea(0,63,127,0,1);  
}  

GLCD_rectangulo(x1, y1, x2, y2, color)
Los rectángulos de dibujan (internamente) mediante cuatro llamadas a la función GLCD_linea.  Los parametros que recibe GLCD_rectangulo(x1, y1, x2, y2, color) son:

    * x1: un byte, es la coordenada "x" (horizontal) de la esquina superior izquierda del rectángulo, con valores válidos de 0 a 127 (izquierda a derecha).
    * y1: un byte, es la coordenada "y" (vertical) de la esquina superior izquierda del rectángulo, con valores válidos de 0 a 63 (arriba a abajo).
    * x2: un byte, es la coordenada "x" (horizontal) de la esquina inferior derecha del rectángulo, con valores válidos de 0 a 127 (izquierda a derecha).
    * y2: un byte, es la coordenada "y" (vertical) de la esquina inferior derecha del rectángulo, con valores válidos de 0 a 63 (arriba a abajo).
    * color: un bit, "0" = rectángulo en blanco, "1" = rectángulo en negro.


(Ház clic sobre las imágenes para ampliarlas)

Puedes ver un ejemplo de uso de esta función aquí.
Código:
#include <16F877A.h>
#device *=16
#include <stdlib.h>
#fuses  HS,NOWDT,NOLVP

#USE DELAY (CLOCK=20000000)
#include <GLCD_K0108.C>

//-------Comienza el programa -----------------------
void main()
{
     int i;
    
     GLCD_inicializa(1);     //Inicializo el GLCD, encendido.
     GLCD_limpiar(0);        //Limpio la pantalla
    
     // Dibujo un rectángulo
     GLCD_rectangulo(10,10,117,40,1);
}  

Y otro más:
Código:
#include <16F877A.h>
#device *=16
#include <stdlib.h>
#fuses  HS,NOWDT,NOLVP

#USE DELAY (CLOCK=20000000)
#include <GLCD_K0108.C>

//-------Comienza el programa -----------------------
void main()
{
     int i;
    
     GLCD_inicializa(1);     //Inicializo el GLCD, encendido.
     GLCD_limpiar(0);        //Limpio la pantalla
    
     // Dibujo varios rectángulos
     for(i=0; i<=48; i=i+6){
            GLCD_rectangulo(i,i,127-i,63,1);
     }
}

Continúa en el próximo post.  Wink
* 1.jpg (23.85 KB - descargado 417 veces.)
* 2.GIF (31.72 KB - descargado 282 veces.)
* 3.GIF (14.13 KB - descargado 276 veces.)
* 4.GIF (13.55 KB - descargado 278 veces.)
* 5.GIF (13.15 KB - descargado 276 veces.)
* 6.GIF (14.36 KB - descargado 276 veces.)
* 7.GIF (19.05 KB - descargado 19 veces.)
* 8.GIF (13.85 KB - descargado 275 veces.)
* 9.GIF (19.26 KB - descargado 279 veces.)
« Última modificación: Febrero 26, 2010, 10:36:57 por Ariel » En línea
Busco ordenadores antiguos: Commodore, Sinclair, Amstrad, Atari, etc. Si sabes de alguno....¿me avisas? Tongue
Ariel
Global Moderator
PIC24F
*****
Desconectado Desconectado

Sexo: Masculino
Mensajes: 4942



WWW
« Respuesta #1 : Febrero 26, 2010, 10:23:28 »
GLCD_caja(x1, y1, x2, y2, color)
Las "cajas" son rectángulos pintados en su interior con el mismo color que el borde exterior. También se dibujan (internamente) mediante llamadas a la función GLCD_linea. Los parametros que recibe GLCD_caja(x1, y1, x2, y2, color) son:

    * x1: un byte, es la coordenada "x" (horizontal) de la esquina superior izquierda del rectángulo, con valores válidos de 0 a 127 (izquierda a derecha).
    * y1: un byte, es la coordenada "y" (vertical) de la esquina superior izquierda del rectángulo, con valores válidos de 0 a 63 (arriba a abajo).
    * x2: un byte, es la coordenada "x" (horizontal) de la esquina inferior derecha del rectángulo, con valores válidos de 0 a 127 (izquierda a derecha).
    * y2: un byte, es la coordenada "y" (vertical) de la esquina inferior derecha del rectángulo, con valores válidos de 0 a 63 (arriba a abajo).
    * color: un bit, "0" = caja en blanco, "1" = caja en negro.


(Ház clic sobre las imágenes para ampliarlas)

Puedes ver un ejemplo de uso de esta función aquí.
Código:
#include <16F877A.h>
#device *=16
#include <stdlib.h>
#fuses  HS,NOWDT,NOLVP

#USE DELAY (CLOCK=20000000)
#include <GLCD_K0108.C>

//-------Comienza el programa -----------------------
void main()
{
     int i;
    
     GLCD_inicializa(1);     //Inicializo el GLCD, encendido.
     GLCD_limpiar(0);        //Limpio la pantalla
    
     // Dibujo una caja
     GLCD_caja(20,20,115,32,1);
}  

Y otro ejemplo acá:
Código:
#include <16F877A.h>
#device *=16
#include <stdlib.h>
#fuses  HS,NOWDT,NOLVP

#USE DELAY (CLOCK=20000000)
#include <GLCD_K0108.C>

//-------Comienza el programa -----------------------
void main()
{
     int i;
    
     GLCD_inicializa(1);     //Inicializo el GLCD, encendido.
     GLCD_limpiar(0);        //Limpio la pantalla
    
     // Dibujo varias cajas
     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);
}

GLCD_circulo(x1, y1, radio, color)
Esta es la función que dibuja un circulo. El interior del circulo permanece del color del fono. Estrictamente hablando, se dibuja solo la circunferencia. Los parametros que recibe GLCD_circulo(x1, y1, radio, color) son:

    * x1: un byte, es la coordenada "x" (horizontal) del centro del circulo, con valores válidos de 0 a 127 (izquierda a derecha).
    * y1: un byte, es la coordenada "y" (vertical) del centro del circulo, con valores válidos de 0 a 63 (arriba a abajo).
    * radio: un byte, es el radio de la circunferencia (en pixeles).
    * color: un bit, "0" = circulo en blanco, "1" = circulo en negro.


(Ház clic sobre las imágenes para ampliarlas)

Puedes ver un ejemplo de uso de esta función aquí.
Código:
#include <16F877A.h>
#device *=16
#include <stdlib.h>
#fuses  HS,NOWDT,NOLVP

#USE DELAY (CLOCK=20000000)
#include <GLCD_K0108.C>

//-------Comienza el programa -----------------------
void main()
{
     int i;
    
     GLCD_inicializa(1);     //Inicializo el GLCD, encendido.
     GLCD_limpiar(0);        //Limpio la pantalla
    
     // Dibujo un circulo
     GLCD_circulo(63,30,20,1);
}

Y otro:
Código:
#include <16F877A.h>
#device *=16
#include <stdlib.h>
#fuses  HS,NOWDT,NOLVP

#USE DELAY (CLOCK=20000000)
#include <GLCD_K0108.C>

//-------Comienza el programa -----------------------
void main()
{
     int i;
    
     GLCD_inicializa(1);     //Inicializo el GLCD, encendido.
     GLCD_limpiar(0);        //Limpio la pantalla
    
     // Dibujo varios circulos
     for(i=10; i<=100; i=i+16){
         GLCD_circulo(i,30,i/5+2,1); }
}


Definiciones, pines y otras yerbas
Para que la libreria pueda ser adaptada al proyecto que tienes en mente, hemos colocado los siguientes "#define" alc omienzo de la misma, para determinar que pin del PIC has conectado a cada pin del GLCD:

Código:
//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

Si tu circuito emplea pines diferentes a los del ejemplo para manejar el GLCD, deberás cambiar los valores que sea necesario.

El display está "partido" en dos mitades de 64x64 pixeles. Esto implica que al momento de escribir en el debemos seleccionar en cual de las dos mitades lo estamos haciendo. Para ello dispone de dos lineas de control (ver el pinout del GLCD en la sección correspondiente), llamadas CS1 y CS2. Asignaremos los valores de 0 y 1 a "GLCD_lado_CS1" y "GLCD_lado_CS2", respectivamente.

Código:
//Lados del GLCD
#define GLCD_lado_CS1   0
#define GLCD_lado_CS2   1

Tambien hemos definido un BYTE que guardará el dato que leyamos desde el GLCD:

Código:
BYTE GLCD_leeBYTE(int1 lado);


GLCD-K0108 en el PIC SIMULATOR IDE

FUNCIONES INTERNAS:

Veamos ahora las funciones internas básicas de la librería:
GLCD_enviaBYTE(lado, dato)

Esta función envia un byte a uno u otro lado del display. Como mencionamos antes, debemos seleccionar previamente, mediante la activación de CS1 o CS2, cual utilizaremos. El parámetro (tipo int1) "lado" es el que define a que mitad del GLCD irá a parar el "dato".
El resto de la función no tiene ningún secreto. En ella, se realizan los siguientes pasos:

   * Se pone el GLCD en "modo escritura", poniendo en bajo GLCD_RW.
    * Se coloca el dato en el puerto D del PIC durante 1 microsegundo.
    * Se habilita el GLCD, poniendo en alto GLCD_E durante 2 microsegundos.
    * Se desabilita el GLCD, poniendo en bajo nuevamente GLCD_E
    * Se vuelven a nivel bajo CS1 y CS2

GLCD_leeBYTE(lado)
Esta es la función que permite leer un byte desde el GLCD. Igual que la anterior, recibe como parámetro la información que le indica en cual de las dos mitades está el dato a leer. Realiza los siguientes pasos:

   * Se configura el puerto D como entrada.
    * Se pone el GLCD en "modo lectura", poniendo en alto GLCD_RW.
    * Se selcciona la mitad correspondiente, mediante CS1 y CS2.
    * Se habilita el GLCD, poniendo en alto GLCD_E durante 2 microsegundos.
    * Se guarda el dato y se desabilita el GLCD, poniendo en bajo nuevamente GLCD_E
    * Se vuelven a nivel bajo CS1 y CS2

La funcion devuelve un BYTE con el dato leido.

GLCD_letra(caracter, color, fuente)
El presente artículo esta incompleto, y está función no ha sido implementada. En éste momento estamos trabajando en él, y en poco tiempo estará terminado.

Continúa en el próximo post.  Wink
* 1.GIF (15.79 KB - descargado 278 veces.)
* 2.GIF (21.96 KB - descargado 274 veces.)
* 3.GIF (13.41 KB - descargado 273 veces.)
* 4.GIF (15.19 KB - descargado 274 veces.)
* 5.gif (8.54 KB - descargado 393 veces.)
« Última modificación: Febrero 26, 2010, 10:37:17 por Ariel » En línea
Busco ordenadores antiguos: Commodore, Sinclair, Amstrad, Atari, etc. Si sabes de alguno....¿me avisas? Tongue
Ariel
Global Moderator
PIC24F
*****
Desconectado Desconectado

Sexo: Masculino
Mensajes: 4942



WWW
« Respuesta #2 : Febrero 26, 2010, 10:41:13 »
Este es el código fuente completo de la librería GLCD_K0108:

Código:
/////////////////////////////////////////////////////////////////////////
// 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);
      }
  }

GLCD con controlador Samsung KS0108

Por ahora, nuestra librería ofrece soporte para los GLCD de 128x64 píxeles, monocromáticos, que tienen un controlador Samsung KS0108 (o compatibles). Sin embargo, en un post que hay a continuación puedes ver una adaptación de la misma para otros controladores.

El que hemos usado en nuestras pruebas es el de la foto siguiente. Se trata de un ELWG12864-YYB-VN, con puntos negros sobre fondo verde, de la empresa Winstar.


Este es el modelo de GLCD elegido para las pruebas.

IMPORTANTE: Si tu display no es exactamente este modelo, consulta su hoja de datos para asegurarte que funcion cumple cada uno de sus pines.

Continúa en el próximo post. Wink
* 1.jpg (31.24 KB - descargado 392 veces.)
* 2.jpg (46.09 KB - descargado 383 veces.)
En línea
Busco ordenadores antiguos: Commodore, Sinclair, Amstrad, Atari, etc. Si sabes de alguno....¿me avisas? Tongue
Ariel
Global Moderator
PIC24F
*****
Desconectado Desconectado

Sexo: Masculino
Mensajes: 4942



WWW
« Respuesta #3 : Febrero 26, 2010, 10:44:17 »
Versión para GLCD con chip SED1565

El amigo Ruben Arranz nos ha mandado una version de esta libreria para displays que integran el chipset SED1565. Aquí está:

Código:
/////////////////////////////////////////////////////////////////////////
// Conexiones de pines del GLCD GTK-281 de GEM-TECH                    //
// El Patillaje esta indicado abajo, del lado del GLCD                 //
// y del Lado del PIC 18F-4550                                         //
// Sirve para Controladores como el NT7534 y el SED1565                //
// (Tambien puede ocuparse con el GLCD 12864F3,                        //
// Pero el patillaje es distinto)                                      //
//                                                                     //
//  ------------------------------------                               //
//     GLCD GTK-281 --- PIC 18F4550                                    //
//  ------------------------------------                               //
//       17: Reset  <-> A4 :6                                          //
//        4: A0     <-> C2 :17                                         //
//        5: R/W    <-> C1 :16                                         //
//        6: E      <-> C0 :15                                         //
//    7..14: D0..D7 <-> B0..B7 :33..40                                 //
//  ------------------------------------                               //
//                                                                     //
//  Los valores pueden cambiarse con los DEFINE que están más abajo    //
//---------------------------------------------------------------------//
//  > GLCD_clear(color)                                                //
//   "Borra" la pantala, llenando la del color seleccionado.           //
//   color = 0 : puntos apagados                                       //
//   color = 1 : puntos encendidos                                     //
//                                                                     //
//---------------------------------------------------------------------//
//  > GLCD_init(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                                     //
//   Tambien puede usarse directamente ON / OFF                        //
//                                                                     //
//  > GLCD_pixel(x,y,color)                                            //
//   Dibuja un punto en x,y. 0,0 es la esquina superior izquierda.     //
//                                                                     //
//  > GLCD_line(x1,y1,x2,y2,color)                                     //
//   Dibuja una linea desde (x1,y1) a (x2,y2)                          //
//                                                                     //
//  >GLCD_rectangle (x1,y1,x2,y2,color)                                //
//  Dibuja un rectangulo con esquinas en (x1,y1) y (x2,y2)             //
//                                                                     //
//  >GLCD_box (x1,y1,x2,y2,color)                                      //
//  Dibuja un rectangulo pintado con esquinas en (x1,y1) y (x2,y2)     //
//                                                                     //
//  >GLCD_circle (x1,y1,r,color)                                       //
//  Dibuja un circulo con centro en (x1,y1) y radio R                  //
//                                                                     //
//  >GLCD_text35(x,y,textptr,color)                                    //
// Escribe un texto de pequeñas dimensiones                            //
// (x,y) - Coordenada superior izquierda del primer caracter           //
// textptr - Puntero a una matriz de caracteres del texto a mostrar    //
//                                                                     //
/////////////////////////////////////////////////////////////////////////

#include <STDLIB.H>

//Pines a usar
#define GLCD_RESET   PIN_C4
#define GLCD_A0      PIN_C2
#define GLCD_RW      PIN_C1
#define GLCD_E       PIN_C0
#define GLCD_TRIS    set_tris_b
#define GLCD_SAL     output_b
#define GLCD_ENT     input_b

//Definiciones varias
#define GLCD_WIDTH   128
#define ON  1
#define OFF 0

// Declaracion de funciones
void GLCD_Data(BYTE dato);
void GLCD_Command(BYTE dato);
BYTE GLCD_readBYTE();
void GLCD_clear(int1 color);
void GLCD_init(int1 modo);
void GLCD_pixel(int8 x, int8 y, int1 color);
void GLCD_line(int x1, int y1, int x2, int y2, int1 color);
void GLCD_rectangle(int x1, int y1, int x2, int y2, int1 color);
void GLCD_box(int x1, int y1, int x2, int y2, int1 color);
void GLCD_circle(int x1, int y1, int radio, int1 color);
void glcd_text35(int8 x, int8 y, char* textptr, int1 color);

const int8 TEXT35[95][5]={
   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b00000000, //SPACE
   0b01000100,   0b01000100,   0b01000100,   0b00000000,   0b01000100, //!
   0b10101010,   0b10101010,   0b00000000,   0b00000000,   0b00000000, //"
   0b10101010,   0b11101110,   0b10101010,   0b11101110,   0b10101010, //#
   0b01100110,   0b11001100,   0b11001100,   0b01100110,   0b11101110, //$
   0b10101010,   0b00100010,   0b01000100,   0b10001000,   0b10101010, //%
   0b01000100,   0b10101010,   0b01000100,   0b10101010,   0b01100110, //&
   0b01000100,   0b01000100,   0b00000000,   0b00000000,   0b00000000, //'
   0b01000100,   0b10001000,   0b10001000,   0b10001000,   0b01000100, //(
   0b01000100,   0b00100010,   0b00100010,   0b00100010,   0b01000100, //)
   0b00000000,   0b10101010,   0b01000100,   0b10101010,   0b00000000, //*
   0b00000000,   0b01000100,   0b11101110,   0b01000100,   0b00000000, //+
   0b00000000,   0b00000000,   0b00000000,   0b01000100,   0b10001000, //,
   0b00000000,   0b00000000,   0b11101110,   0b00000000,   0b00000000, //-
   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b01000100, //.
   0b00100010,   0b00100010,   0b01000100,   0b10001000,   0b10001000, ///
   0b11101110,   0b10101010,   0b10101010,   0b10101010,   0b11101110, //0
   0b01000100,   0b11001100,   0b01000100,   0b01000100,   0b11101110, //1
   0b11101110,   0b00100010,   0b11101110,   0b10001000,   0b11101110, //2
   0b11101110,   0b00100010,   0b11101110,   0b00100010,   0b11101110, //3
   0b10101010,   0b10101010,   0b11101110,   0b00100010,   0b00100010, //4
   0b11101110,   0b10001000,   0b11101110,   0b00100010,   0b11101110, //5
   0b11001100,   0b10001000,   0b11101110,   0b10101010,   0b11101110, //6
   0b11101110,   0b00100010,   0b01000100,   0b10001000,   0b10001000, //7
   0b11101110,   0b10101010,   0b11101110,   0b10101010,   0b11101110, //8
   0b11101110,   0b10101010,   0b11101110,   0b00100010,   0b01100110, //9
   0b00000000,   0b01000100,   0b00000000,   0b01000100,   0b00000000, //:
   0b00000000,   0b01000100,   0b00000000,   0b01000100,   0b10001000, //;
   0b00100010,   0b01000100,   0b10001000,   0b01000100,   0b00100010, //<
   0b00000000,   0b11101110,   0b00000000,   0b11101110,   0b00000000, //=
   0b10001000,   0b01000100,   0b00100010,   0b01000100,   0b10001000, //>
   0b11001100,   0b00100010,   0b01100110,   0b00000000,   0b01000100, //?
   0b01000100,   0b10101010,   0b11101110,   0b10001000,   0b01100110, //@
   0b11101110,   0b10101010,   0b11101110,   0b10101010,   0b10101010, //A
   0b11001100,   0b10101010,   0b11101110,   0b10101010,   0b11001100, //B
   0b11101110,   0b10001000,   0b10001000,   0b10001000,   0b11101110, //C
   0b11001100,   0b10101010,   0b10101010,   0b10101010,   0b11001100, //D
   0b11101110,   0b10001000,   0b11101110,   0b10001000,   0b11101110, //E
   0b11101110,   0b10001000,   0b11101110,   0b10001000,   0b10001000, //F
   0b11101110,   0b10001000,   0b10001000,   0b10101010,   0b11101110, //G
   0b10101010,   0b10101010,   0b11101110,   0b10101010,   0b10101010, //H
   0b11101110,   0b01000100,   0b01000100,   0b01000100,   0b11101110, //I
   0b00100010,   0b00100010,   0b00100010,   0b10101010,   0b11101110, //J
   0b10001000,   0b10101010,   0b11001100,   0b11001100,   0b10101010, //K
   0b10001000,   0b10001000,   0b10001000,   0b10001000,   0b11101110, //L
   0b10101010,   0b11101110,   0b11101110,   0b10101010,   0b10101010, //M
   0b00000000,   0b11001100,   0b10101010,   0b10101010,   0b10101010, //N
   0b01000100,   0b10101010,   0b10101010,   0b10101010,   0b01000100, //O
   0b11101110,   0b10101010,   0b11101110,   0b10001000,   0b10001000, //P
   0b01000100,   0b10101010,   0b10101010,   0b11101110,   0b01100110, //Q
   0b11101110,   0b10101010,   0b11001100,   0b11101110,   0b10101010, //R
   0b11101110,   0b10001000,   0b11101110,   0b00100010,   0b11101110, //S
   0b11101110,   0b01000100,   0b01000100,   0b01000100,   0b01000100, //T
   0b10101010,   0b10101010,   0b10101010,   0b10101010,   0b11101110, //U
   0b10101010,   0b10101010,   0b10101010,   0b10101010,   0b01000100, //V
   0b10101010,   0b10101010,   0b11101110,   0b11101110,   0b10101010, //W
   0b00000000,   0b10101010,   0b01000100,   0b01000100,   0b10101010, //X
   0b10101010,   0b10101010,   0b01000100,   0b01000100,   0b01000100, //Y
   0b11101110,   0b00100010,   0b01000100,   0b10001000,   0b11101110, //Z
   0b11101110,   0b10001000,   0b10001000,   0b10001000,   0b11101110, //[
   0b10001000,   0b10001000,   0b01000100,   0b00100010,   0b00100010, //\
   0b11101110,   0b00100010,   0b00100010,   0b00100010,   0b11101110, //]
   0b01000100,   0b10101010,   0b00000000,   0b00000000,   0b00000000, //^
   0b00000000,   0b00000000,   0b00000000,   0b00000000,   0b11101110, //_
   0b10001000,   0b01000100,   0b00000000,   0b00000000,   0b00000000, //`
   0b00000000,   0b01000100,   0b10101010,   0b10101010,   0b01100110, //a
   0b10001000,   0b11001100,   0b10101010,   0b10101010,   0b11001100, //b
   0b00000000,   0b01100110,   0b10001000,   0b10001000,   0b01100110, //c
   0b00100010,   0b01100110,   0b10101010,   0b10101010,   0b01100110, //d
   0b00000000,   0b01000100,   0b10101010,   0b11001100,   0b01100110, //e
   0b01100110,   0b01000100,   0b11101110,   0b01000100,   0b01000100, //f
   0b00000000,   0b01000100,   0b10101010,   0b01100110,   0b11001100, //g
   0b10001000,   0b11001100,   0b10101010,   0b10101010,   0b10101010, //h
   0b01000100,   0b00000000,   0b01000100,   0b01000100,   0b01000100, //i
   0b01000100,   0b00000000,   0b01000100,   0b01000100,   0b10001000, //j
   0b10001000,   0b10001000,   0b10101010,   0b11001100,   0b10101010, //k
   0b01000100,   0b01000100,   0b01000100,   0b01000100,   0b01000100, //l
   0b00000000,   0b11101110,   0b11101110,   0b10101010,   0b10101010, //m
   0b00000000,   0b11001100,   0b10101010,   0b10101010,   0b10101010, //n
   0b00000000,   0b01000100,   0b10101010,   0b10101010,   0b01000100, //o
   0b00000000,   0b11001100,   0b10101010,   0b11001100,   0b10001000, //p
   0b00000000,   0b01100110,   0b10101010,   0b01100110,   0b00100010, //q
   0b00000000,   0b10001000,   0b11101110,   0b10001000,   0b10001000, //r
   0b00000000,   0b01100110,   0b11001100,   0b00100010,   0b11001100, //s
   0b01000100,   0b11101110,   0b01000100,   0b01000100,   0b01000100, //t
   0b00000000,   0b10101010,   0b10101010,   0b10101010,   0b01000100, //u
   0b00000000,   0b10101010,   0b10101010,   0b01000100,   0b01000100, //v
   0b00000000,   0b10101010,   0b10101010,   0b11101110,   0b10101010, //w
   0b00000000,   0b10101010,   0b01000100,   0b01000100,   0b10101010, //x
   0b00000000,   0b10101010,   0b10101010,   0b01100110,   0b11001100, //y
   0b00000000,   0b11101110,   0b01100110,   0b11001100,   0b11101110, //z
   0b00100010,   0b01000100,   0b11001100,   0b01000100,   0b00100010, //{
   0b01000100,   0b01000100,   0b01000100,   0b01000100,   0b01000100, //|
   0b10001000,   0b01000100,   0b01100110,   0b01000100,   0b10001000, //}
   0b00000000,   0b11001100,   0b10101010,   0b00000000,   0b00000000  //~
   };

//-----------------------------------------------------------------------
//Escribe un byte en la pantalla
//-----------------------------------------------------------------------
void GLCD_Data(BYTE dato)
{
   output_low (GLCD_RW);   // Modo escritura
   output_high (GLCD_A0);  // Modo escritura
   GLCD_SAL (dato);        // Coloco el dato a escribir
   output_high (GLCD_E);   // Aviso que hay un dato a escribir
   delay_cycles( 2 );      // Espero
   output_low (GLCD_E);    // Termino la escritura del dato
   delay_cycles( 2 );      // Espero
}

//-----------------------------------------------------------------------
//Envía un comando a GLCD
//-----------------------------------------------------------------------
void GLCD_Command(BYTE dato)
{
   output_low (GLCD_RW);   // Modo comando
   output_low (GLCD_A0);   // Modo comando
   GLCD_SAL (dato);        // Coloco el Comando a escribir
   output_high (GLCD_E);   // Aviso que estoy enviado un comando
   delay_cycles( 2 );      // Espero
   output_low (GLCD_E);    // Termino el envío del comando
   delay_cycles( 2 );      // Espero
}

//-----------------------------------------------------------------------
// Lee un byte de la pantalla
//-----------------------------------------------------------------------
BYTE GLCD_readBYTE()
{
   BYTE dato;
   GLCD_TRIS (0xFF);       // Todo el Puerto como entrada de datos
   output_high (GLCD_RW);  // Modo lectura
   output_high (GLCD_A0);  // Modo lectura
   output_high (GLCD_E);   // Activo la lectura
   delay_cycles( 2 );      // Espero
   output_low (GLCD_E);    // lectura tonta
   delay_cycles( 2 );      // Espero
   output_high (GLCD_E);   // Activo la lectura
   delay_cycles( 2 );      // Espero
   dato = GLCD_ENT();      // Guardo en "dato" el valor devuelto
   output_low (GLCD_E);    // Termino la lectura
   output_low (GLCD_RW);   // Modo comando
   output_low (GLCD_A0);   // Modo comando
   GLCD_SAL (0x00);        // Limpio el Puerto de salida
   GLCD_TRIS (0x00);       // Todo el Puerto como salida de datos
   return dato;            // Retorno de la rutina con el dato
}

//-----------------------------------------------------------------------
// Limpia el GLCD (pinta toda la pantalla de un color)
//-----------------------------------------------------------------------
void GLCD_clear(int1 color)
{
   int8 i, j;
   for(i = 0; i < 7; ++i) // Recorre las 8 paginas (vertical)
   {
      for(j = 0; j < 127; ++j) // Recorre los 128 segmentos (horizontal)
      {  GLCD_Data(0xFF * color);  // Enciende/apaga pixeles
       }
   }
}


//-----------------------------------------------------------------------
//Esta funcion inicializa el LCD.
//-----------------------------------------------------------------------
void GLCD_init(int1 modo)
{
   // Pone los pines de control en el estado correcto.
   output_low(GLCD_RESET);
   delay_ms(1);
   output_high(GLCD_RESET);
   GLCD_Command(0x40);        // Linea Inicial = 0
   GLCD_Command(0xA0);        // ADC = normal
   GLCD_Command(0xA3);        // LCD-Bias = 1/7
   GLCD_Command(0xC0);        // output mode
   GLCD_Command(0xAC);        // static indicator = 0
   GLCD_Command(0xA4);        // Todos los pixeles apagados
   GLCD_Command(0xA6);        // Display no Invertido
   GLCD_Command(0xE0);        // read/modify/write
   // Si modo = 1 inicializa encendido. Sino, apagado.
   if(modo == 1)
   {  GLCD_Command(0xAF); }   // Enciendo el GLCD
   else {
      GLCD_Command(0xAE); }   // Apago el GLCD
}


//-----------------------------------------------------------------------
// Dibuja un pixel
//-----------------------------------------------------------------------
void GLCD_pixel(int8 x, int8 y, int1 color)
{
   BYTE dato;
   int8 Posicion_Y;
   int8 Posicion_X;
   x = 127-x;
   y = 63-y;
//Primero verificar que X e Y estan dentro de los límites
   if ((x<=127)&(y<=63)){
      Posicion_Y = y / 8;             // Calculo La página a donde pertenece el bit
      Posicion_Y = 0xB0 + Posicion_Y;     // Genero el comando para ir a la página
      GLCD_Command(Posicion_Y);                 // Ejecuto el comando
      Posicion_X = x;
      swap(Posicion_X);
      Posicion_X &= 0x0F;
      Posicion_X |= 0x10;
      GLCD_Command(Posicion_X);
      Posicion_X = x;
      Posicion_X &= 0x0F;
      GLCD_Command(Posicion_X);
      dato = GLCD_ReadBYTE();
   if(color == 1)
      bit_set(dato, y%8);        // Turn the pixel on
   else                          // or
      bit_clear(dato, y%8);      // turn the pixel off
      GLCD_Data(dato);
   }
}

//-----------------------------------------------------------------------
// Dibuja una linea desde (x1,y1) a (x2,y2) de color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_line(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_pixel(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_pixel(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_rectangle(int x1, int y1, int x2, int y2, int1 color)
{
   GLCD_line(x1,y1,x2,y1,color);
   GLCD_line(x1,y1,x1,y2,color);
   GLCD_line(x1,y2,x2,y2,color);
   GLCD_line(x2,y1,x2,y2,color);
}
//-----------------------------------------------------------------------

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

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

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

//-----------------------------------------------------------------------
// Dibuja un circulo con centro en (x1,y1), radio y color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_circle(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_pixel(x1, y1 + radio, color);
    GLCD_pixel(x1, y1 - radio, color);
    GLCD_pixel(x1 + radio, y1, color);
    GLCD_pixel(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_pixel(x1 + x, y1 + y, color);
      GLCD_pixel(x1 - x, y1 + y, color);
      GLCD_pixel(x1 + x, y1 - y, color);
      GLCD_pixel(x1 - x, y1 - y, color);
      GLCD_pixel(x1 + y, y1 + x, color);
      GLCD_pixel(x1 - y, y1 + x, color);
      GLCD_pixel(x1 + y, y1 - x, color);
      GLCD_pixel(x1 - y, y1 - x, color);
      }
  }

//char characterSet[] = " !#$%&'()*+,-./0123456789:;=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
void GLCD_text35(int8 x, int8 y, char* textptr, int1 color)
{
   int i, j, k;                           // Loop counters
   BYTE pixelData[5];                     // Stores character data

   for(i=0; textptr[i] != '\0'; ++i, ++x) // Loop through the passed string
   {
      if((textptr[i] >= ' ') && (textptr[i] <= '~'))
        memcpy(pixelData, TEXT35[textptr[i]-' '], 5);
      else
         memcpy(pixelData, TEXT35[0], 5); // Default to space

      if(x+3 >= GLCD_WIDTH)          // Performs character wrapping
      {
         x = 0;                           // Set x at far left position
         y += 5 + 1;                      // Set y at next position down
      }
      for(j=3; j>0; j--, x++)             // Loop through character byte data
      {
         for(k=0; k<5; k++)               // Loop through the vertical pixels
         {
            if(bit_test(pixelData[k], j)) // Check if the pixel should be set
            {
               glcd_pixel(x, y+k, color); // Draws the pixel
            }
         }
      }
   }
}


¡Gracias Ruben!  Grin

Restricciones legales de CCS

Como deciamos en la introducción, dentro de las librerias incluidas en CCS se ha incluido una especie de licencia. Concretamente, en el código fuente de dichas librerias puede leerse algo como lo siguiente:

Código:
/////////////////////////////////////////////////////////////////////////
////        (C) Copyright 1996, 2004 Custom Computer Services        ////
//// This source code may only be used by licensed users of the CCS  ////
//// C compiler.  This source code may only be distributed to other  ////
//// licensed users of the CCS C compiler.  No other use,            ////
//// reproduction or distribution is permitted without written       ////
//// permission.  Derivative programs created using this software    ////
//// in object code form are not restricted in any way.              ////
/////////////////////////////////////////////////////////////////////////


Esto, traducido al español significa más o menos lo siguiente:

"Este código fuente sólo puede ser utilizado por usuarios con licencia del compilador C CCS. Este código fuente sólo puede ser distribuido a otros usuarios con licencia del compilador C CCS. No se permite ningún otro uso, reproducción o distribución sin el consentimiento escrito. Los programas derivados, creados utilizando este software, pueden distribuirse como código objeto sin limitantes."
En línea
Busco ordenadores antiguos: Commodore, Sinclair, Amstrad, Atari, etc. Si sabes de alguno....¿me avisas? Tongue
RGW
PIC10F
*
Desconectado Desconectado

Sexo: Masculino
Mensajes: 11
« Respuesta #4 : Mayo 11, 2010, 03:49:23 »
Hola, perdon si me equivoco de sitio, pero tengo un problema. Quisiera hacer las practicas con GLCD, pero soy de La Plata y no consigo el Display 128x64 controladora KS108. Alguien me podria decir donde comprar en Buenos Aires. Si envian a domicilio mucho mejor. Gracias, aprendo mucho de este foro.
En línea
Ariel
Global Moderator
PIC24F
*****
Desconectado Desconectado

Sexo: Masculino
Mensajes: 4942



WWW
« Respuesta #5 : Mayo 11, 2010, 06:04:36 »
En Electrcomponentes, en calle Parana al 128 de Capital Federal lo tienen... Wink

Saludos!
En línea
Busco ordenadores antiguos: Commodore, Sinclair, Amstrad, Atari, etc. Si sabes de alguno....¿me avisas? Tongue
Suky
Administradores
PIC18F
*****
Desconectado Desconectado

Sexo: Masculino
Mensajes: 1815


PIC32, voy por ti! >:(


WWW
« Respuesta #6 : Mayo 12, 2010, 11:35:22 »
Capaz Elemon sea mas economico  Grin


Saludos!
En línea
  Neuquén-Argentina 

InfoPIC
RGW
PIC10F
*
Desconectado Desconectado

Sexo: Masculino
Mensajes: 11
« Respuesta #7 : Mayo 18, 2010, 05:51:12 »
Hola, compre el glcd WG12864A TMI en ELEMON, como me aconsejaron, bastante lejos para mi. Pero no logro hacerlo funcionar  cabezaso a la pared. Con un PIC 16f877A lo conecte de la siguiente manera:
Viendo el lcd de frente con los pin hacia abajo de derecha a izquierda
1-gnd / 2-5V / 3-V0 / 4-D/I / 5-R/W / 6-E / 7 a 14 DB0 a DB7 / 15-CS1 / 16-CS2 / 17-reset / 18-Vssout / 19-A /20-K
Baje al PIC unas de las practicas lo armo en una plaqueta de pruebas y nada, los pines 3, 18, 19 y 20 no los uso. ¿Será por eso que no me funciona?. Puedo probar el GLCD sin conectarlo a un pic. Les agradeceria cualquier consejo por mas tonto que parezca ya que es la primera vez que lo uso. GRACIAS
« Última modificación: Mayo 18, 2010, 05:52:55 por RGW » En línea
Emiliano
Administradores
PIC18F
*****
Desconectado Desconectado

Sexo: Masculino
Mensajes: 1007


'67 Caprice
« Respuesta #8 : Mayo 18, 2010, 09:41:00 »
Es dificil sin verlo porque pueden ser mil cosas.
Para empezar proba subirle el contraste, de esa forma
probas si tiene alimentacion correcta y si el contraste funciona.

Despues podrias subir un circuito y el codigo que estas usando para ver que puede estar mal.

Probaste simularlo ?? funciona en la simulacion ??

Saludos
En línea
RGW
PIC10F
*
Desconectado Desconectado

Sexo: Masculino
Mensajes: 11
« Respuesta #9 : Mayo 19, 2010, 08:53:45 »
Lo conecte al pic de la siguiente manera.
1-gnd = - .
2-5V = + .
3-V0 = Potenciometro centro.
4-D/I = C3 pin 18.
5-R/W = C2 pin17.
6-E = C1 pin 16.
7 a 14 DB0 a DB7 = D0 a D 7 pin 19, 20, 21, 22, 27, 28, 29 y 30.
15-CS1 = E2 pin 10.
16-CS2 = E1 pin 9.
17-reset = E0 pin 8.
18-Vssout = No conectado.
9-A = +.
20-K = -.
Este es el programa que saque del foro. Lo compilo en CCS.
#include <16F877A.h> #device *=16 #include <stdlib.h>
#fuses  HS,NOWDT,NOLVP #USE DELAY (CLOCK=20000000) #include <GLCD_K0108.C> void main(){int i; GLCD_inicializa(1); GLCD_limpiar(0); GLCD_circulo(63,30,20,1); } Le borre los espacios para que entre mas corto.
Cargo el hex con winpic800.
Probé alimentando el GLCD, sin el pic 1 = –, 2 = +, 19 y 20 para la luz y con el potenciómetro conectado al pin 3 y no contrasta.
¿Será que los pines que tengo del GLCD no son los mismos?. Es un WG12864A-TMI blanco y azul. de la empresa WINSTAR. Y ya van 2 glcd que no logro hacer funcionar.
« Última modificación: Mayo 19, 2010, 08:55:55 por RGW » En línea
RGW
PIC10F
*
Desconectado Desconectado

Sexo: Masculino
Mensajes: 11
« Respuesta #10 : Mayo 19, 2010, 10:43:32 »
Bueno tratando y tratando encontré en este mismo foro que la pata 18 es para el contraste. Ahora anda. Hice un while con círculos y rectángulos y lo único que veo son puntos y manchas sin definr por todos lados que cambian. ¿Pude haberlo roto? me parece que lo rompi.
En línea
Suky
Administradores
PIC18F
*****
Desconectado Desconectado

Sexo: Masculino
Mensajes: 1815


PIC32, voy por ti! >:(


WWW
« Respuesta #11 : Mayo 19, 2010, 11:19:59 »
Exactamente, el potenciometro del contraste tiene en uno de sus pines Vdd y en el otro Vee o Vout, y el del medio va a pin que controla el contraste. No creo que se haya roto, me parece que es problema de inicialización. Podes agregar unas demoras de 100us al enviar un dato de escritura (En la inicialización), como para probar si mejora.


Saludos!
En línea
  Neuquén-Argentina 

InfoPIC
RGW
PIC10F
*
Desconectado Desconectado

Sexo: Masculino
Mensajes: 11
« Respuesta #12 : Mayo 19, 2010, 05:03:59 »
La verdad no se si me van a creer lo que estoy escribiendo. Pero la plaqueta de pruebas que utilice para esto tenía agujeros que no funcionaban y eso que compre la más cara. Lo pude hacer andar pero cambie en los define de la librería los que estaban en puerto C, “D/I R/W y E” al puerto B y me anda perfecto. Me fije con el tester la continuidad y los pines del puerto C y responden perfectamente. Será algo del PIC o del puerto que no sirve para esa funciòn. Gracias por todo, ya estoy haciendo las practicas.
En línea
RGW
PIC10F
*
Desconectado Desconectado

Sexo: Masculino
Mensajes: 11
« Respuesta #13 : Mayo 20, 2010, 01:22:33 »
¿Que potenciometro tengo que usar?. Los pines 19 y 20 para la iluminaciòn del GLCD se pueden conectar directamente al pic para prender solamente cuando lo pueda llegar a solicitar.
En línea
Emiliano
Administradores
PIC18F
*****
Desconectado Desconectado

Sexo: Masculino
Mensajes: 1007


'67 Caprice
« Respuesta #14 : Mayo 20, 2010, 09:14:06 »
Ni lo intentes, lo unico que lograrias seria quemar alguna salida del PIC.
Tendrias que alimentarlo a traves de algun transistor, y ahi si lo podes
prender y apagar desde el PIC.
Si lo conectas a algun pin que tenga PWM, mas adelante le podrias
hasta variar la intensidad de la iluminacion  Wink
En línea
Páginas: 1 2 »   Ir Arriba
  Imprimir  
« anterior próximo »
 
Ir a:  

Impulsado por MySQL Impulsado por PHP Powered by SMF 1.1.9 | SMF © 2006-2009, Simple Machines LLC XHTML 1.0 válido! CSS válido!

Página creada en 0.313 segundos con 23 consultas. (Pretty URLs adds 0.03s, 2q)