DEMOQE Y GLCD 128x64

Escrito por braulio elias chi salavarria

En este articulo, veremos como utilizar la libreria universal para manejar el GLCD KS0108 que está en el sitio web RADZIO el cual tiene varias versiones para diferentes microcontroladores, no siendo el caso para Freescale, en esta libreria lo unico que cambie, fue el archivo de bajo nivel, que sirve para portar cualquier microcontrolador a estas librerias.

El archivo que sirve para definir puertos de entrada y salida, se llama KS0108-CFQE128.c, tuve un pequeño problema, ya que la tarjeta DEMOQE no tiene disponible un puerto completo, asi que tuve que usar una union, para no consumir mucha ram (en teoria), lo más probable es que haya una solución más eficiente y elegante a la mía, por lo pronto, funciona con esta.

#include "derivative.h"
#include "KS0108.h"
 
 
#define KS0108_DATA_DIR_0 PTFDD_PTFDD2
#define KS0108_DATA_DIR_1 PTFDD_PTFDD3
#define KS0108_DATA_DIR_2 PTFDD_PTFDD4
#define KS0108_DATA_DIR_3 PTFDD_PTFDD5
#define KS0108_DATA_DIR_4 PTFDD_PTFDD6
#define KS0108_DATA_DIR_5 PTFDD_PTFDD7
#define KS0108_DATA_DIR_6 PTGDD_PTGDD2
#define KS0108_DATA_DIR_7 PTGDD_PTGDD3
 
 
#define KS0108_DATA_0 PTFD_PTFD2
#define KS0108_DATA_1 PTFD_PTFD3
#define KS0108_DATA_2 PTFD_PTFD4
#define KS0108_DATA_3 PTFD_PTFD5
#define KS0108_DATA_4 PTFD_PTFD6
#define KS0108_DATA_5 PTFD_PTFD7
#define KS0108_DATA_6 PTGD_PTGD2
#define KS0108_DATA_7 PTGD_PTGD3
 
 
#define KS0108_RS_DIR PTCDD_PTCDD5
#define KS0108_RW_DIR PTCDD_PTCDD4
#define KS0108_EN_DIR PTCDD_PTCDD3
 
#define KS0108_CS1_DIR PTBDD_PTBDD0
#define KS0108_CS2_DIR PTBDD_PTBDD1
#define KS0108_CS3_DIR PTBDD_PTBDD1
 
#define KS0108_RS			PTCD_PTCD5
#define KS0108_RW			PTCD_PTCD4
#define KS0108_EN		  PTCD_PTCD3
 
#define KS0108_CS1			PTBD_PTBD0
#define KS0108_CS2			PTBD_PTBD1
#define KS0108_CS3			PTBD_PTBD1
 
#define DISPLAY_STATUS_BUSY 0x80
 
extern unsigned char screen_x, screen_y;
 
 
union ubyte
{
	char _byte;
	struct
	{
		char b0 : 1;
		char b1 : 1;
		char b2 : 1;
		char b3 : 1;
		char b4 : 1;
		char b5 : 1;
		char b6 : 1;
		char b7 : 1;
	} bit;
};
 
 
 
//-------------------------------------------------------------------------------------------------
// Delay function
//-------------------------------------------------------------------------------------------------
void GLCD_Delay(void)
{
 
    char i=0;
    for (i=0;i<5;i++);
 
}
//-------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------
void GLCD_InitializePorts(void)
{
 
  KS0108_CS1=1;
  KS0108_CS2=1;
  KS0108_CS1_DIR=1;
  KS0108_CS2_DIR=1;
  KS0108_RS_DIR=1;
  KS0108_RW_DIR=1;
  KS0108_EN_DIR=1;
 
 
 
}
//-------------------------------------------------------------------------------------------------
// Enable Controller (0-2)
//-------------------------------------------------------------------------------------------------
void GLCD_EnableController(unsigned char controller)
{
switch(controller){
 
  case 0 : KS0108_CS1=1; KS0108_CS2=0; break;
  case 1 : KS0108_CS1=0; KS0108_CS2=1; break;
  case 2 : KS0108_CS1=0; KS0108_CS2=1; break;
 
	}
}
//-------------------------------------------------------------------------------------------------
// Disable Controller (0-2)
//-------------------------------------------------------------------------------------------------
void GLCD_DisableController(unsigned char controller)
{
switch(controller){
  case 0 : KS0108_CS1=1;
  case 1 : KS0108_CS2=1;
  case 2 : KS0108_CS3=1;
 
	}
}
//-------------------------------------------------------------------------------------------------
// Read Status from specified controller (0-2)
//-------------------------------------------------------------------------------------------------
unsigned char GLCD_ReadStatus(unsigned char controller)
{
unsigned char status;
union ubyte my_union;
 
 
KS0108_DATA_DIR_0=0;
KS0108_DATA_DIR_1=0;
KS0108_DATA_DIR_2=0;
KS0108_DATA_DIR_3=0;
KS0108_DATA_DIR_4=0;
KS0108_DATA_DIR_5=0;
KS0108_DATA_DIR_6=0;
KS0108_DATA_DIR_7=0;
 
KS0108_RW=1;
KS0108_RS=0;
GLCD_EnableController(controller);
KS0108_EN=1;
GLCD_Delay();
 
 my_union.bit.b0 = KS0108_DATA_0;
 my_union.bit.b1 = KS0108_DATA_1;
 my_union.bit.b2 = KS0108_DATA_2;
 my_union.bit.b3 = KS0108_DATA_3;
 my_union.bit.b4 = KS0108_DATA_4;
 my_union.bit.b5 = KS0108_DATA_5;
 my_union.bit.b6 = KS0108_DATA_6;
 my_union.bit.b7 = KS0108_DATA_7;
 
 KS0108_EN=0;
 
 status= my_union._byte;
 
 return status;
 
}
//-------------------------------------------------------------------------------------------------
// Write command to specified controller
//-------------------------------------------------------------------------------------------------
void GLCD_WriteCommand(unsigned char commandToWrite, unsigned char controller)
{
 
union ubyte my_data;
 
while(GLCD_ReadStatus(controller)&DISPLAY_STATUS_BUSY);
KS0108_DATA_DIR_0=1;
KS0108_DATA_DIR_1=1;
KS0108_DATA_DIR_2=1;
KS0108_DATA_DIR_3=1;
KS0108_DATA_DIR_4=1;
KS0108_DATA_DIR_5=1;
KS0108_DATA_DIR_6=1;
KS0108_DATA_DIR_7=1;
KS0108_RW=0;
KS0108_RS=0;
GLCD_EnableController(controller);
my_data._byte=commandToWrite;
KS0108_DATA_0=my_data.bit.b0;
KS0108_DATA_1=my_data.bit.b1;
KS0108_DATA_2=my_data.bit.b2;
KS0108_DATA_3=my_data.bit.b3;
KS0108_DATA_4=my_data.bit.b4;
KS0108_DATA_5=my_data.bit.b5;
KS0108_DATA_6=my_data.bit.b6;
KS0108_DATA_7=my_data.bit.b7;
 
 
KS0108_EN=1;
GLCD_Delay();
KS0108_EN=0;
GLCD_DisableController(controller);
 
}
//-------------------------------------------------------------------------------------------------
// Read data from current position
//-------------------------------------------------------------------------------------------------
unsigned char GLCD_ReadData(void)
{
unsigned char data;
union ubyte my_union;
 
while(GLCD_ReadStatus(screen_x / 64)&DISPLAY_STATUS_BUSY);
 
KS0108_DATA_DIR_0=0;
KS0108_DATA_DIR_1=0;
KS0108_DATA_DIR_2=0;
KS0108_DATA_DIR_3=0;
KS0108_DATA_DIR_4=0;
KS0108_DATA_DIR_5=0;
KS0108_DATA_DIR_6=0;
KS0108_DATA_DIR_7=0;
 
 
KS0108_RW=1;
KS0108_RS=1;
 
 
GLCD_EnableController(screen_x / 64);
 
 
 
KS0108_EN=1;
GLCD_Delay();
 
my_union.bit.b0=KS0108_DATA_0;
my_union.bit.b1=KS0108_DATA_1;
my_union.bit.b2=KS0108_DATA_2;
my_union.bit.b3=KS0108_DATA_3;
my_union.bit.b4=KS0108_DATA_4;
my_union.bit.b5=KS0108_DATA_5;
my_union.bit.b6=KS0108_DATA_6;
my_union.bit.b7=KS0108_DATA_7;
data= my_union._byte;
 
 
 
KS0108_EN=0;
GLCD_DisableController(screen_x / 64);
screen_x++;
return data;
}
//-------------------------------------------------------------------------------------------------
// Write data to current position
//-------------------------------------------------------------------------------------------------
void GLCD_WriteData(unsigned char dataToWrite)
{
 
union ubyte my_data;
 
while(GLCD_ReadStatus(screen_x / 64)&DISPLAY_STATUS_BUSY);
 
KS0108_DATA_DIR_0=1;
KS0108_DATA_DIR_1=1;
KS0108_DATA_DIR_2=1;
KS0108_DATA_DIR_3=1;
KS0108_DATA_DIR_4=1;
KS0108_DATA_DIR_5=1;
KS0108_DATA_DIR_6=1;
KS0108_DATA_DIR_7=1;
 
 
KS0108_RW=0;
KS0108_RS=1;
my_data._byte=dataToWrite;
KS0108_DATA_0=my_data.bit.b0;
KS0108_DATA_1=my_data.bit.b1;
KS0108_DATA_2=my_data.bit.b2;
KS0108_DATA_3=my_data.bit.b3;
KS0108_DATA_4=my_data.bit.b4;
KS0108_DATA_5=my_data.bit.b5;
KS0108_DATA_6=my_data.bit.b6;
KS0108_DATA_7=my_data.bit.b7;
 
GLCD_EnableController(screen_x / 64);
 
KS0108_EN=1;
GLCD_Delay();
 
KS0108_EN=0;
GLCD_DisableController(screen_x / 64);
screen_x++;
}
//-------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------
unsigned char GLCD_ReadByteFromROMMemory(unsigned char * ptr)
{
  return *(ptr);
}
//-------------------------------------------------------------------------------------------------
//
//-------------------------------------------------------------------------------------------------

Tambien podemos ver diferentes funciones, como se puede ver en este ejemplo:

#include <hidef.h> /* for EnableInterrupts macro */
#include "derivative.h" /* include peripheral declarations */
#include "mcu_init.h"
 
//Library for GLCD 128x64
#include "KS0108.h"
#include "graphic.h"
#include "bitmaps.h"
 
unsigned char count=0;
 
 
void interrupt VectorNumber_Vrtc rtc_isr(void){
 
 RTCSC_RTIF=1; 
 
   count++;
   if(count>60)count=0;
}
 
 
void main(void) {
 
  EnableInterrupts; /* enable interrupts */
  /* include your code here */
  mcu_init_clock();
 
 
  GLCD_Initialize();
  GLCD_ClearScreen();
 
 
 GLCD_Bitmap(picture,0,0,128,64);
 GLCD_GoTo(0,7);
  GLCD_WriteString(" www.thinkchip.com.mx");
   count=0;
   while(count<3);
GLCD_ClearScreen();  
GLCD_GoTo(0,3);
GLCD_WriteString("+-------------------+");
GLCD_GoTo(0,4);
GLCD_WriteString("|     Ejemplo       |");
GLCD_GoTo(0,5);
GLCD_WriteString("|   GLCD 128x64     |");
GLCD_GoTo(0,6);
GLCD_WriteString("+-------------------+"); 
  count =0;
  while(count<4);
GLCD_ClearScreen();  
GLCD_Rectangle(0,0,40,40);
GLCD_Line(0,32,123,32);
GLCD_Circle(64,32,10); 
 
 
  for(;;) {
 
 
 
 
    __RESET_WATCHDOG(); /* feeds the dog */
  } /* loop forever */
  /* please make sure that you never leave main */
}

Para hacer su conexión y utilizar este ejemplo para su programa, solo tienen que definir sus pines y estará listo para trabajar, este ejemplo esta hecho para un MCF51QE128 y un bus clock de 8.34 MHz.