Glcd 6

El uso de GLCD en nuestros proyectos es una
manera muy eficaz para llevar nuestros diseños
a otro nivel de complejidad, y sencillez de
visualización.
En esta sección vamos a desarrollar paso por
paso el funcionamiento de cada función para el
uso del GLCD, tanto como crear líneas,
cuadrados, colorear hasta visualizar una imagen
a blanco y negro usando un software que nos
permitirá generar el código necesario para
incluirlo en nuestro programa para que lo
pueda visualizar el microcontrolador.
La primera función que vamos a conocer es
la función de inicialización del GLCD:
void GLCD_init(unsigned char
mode);
La función anterior Inicializa el GLCD .
mode 1=Arranca GLCD
mode 0=Apaga GLCD
void GLCD_clear(unsigned char
color);
Esta función realiza la tarea de poner toda la
pantalla en blanco o negro según lo que
ponemos en “color”:
Color 1 pone todo negro
Color 2 pone todo blanco
Como vemos
hemos
llamado
primero a la
función de
inicialización
del GLCD y
después
pintamos la
pantalla con la función “GLCD_clear(1)” y
decimos que ponga la pantalla a negro, como se
ve en la imagen, al poner un cero en lugar de un
uno tendremos una pantalla completamente en
blanco.
ESTA SECCION APRENDEREMOS A
MANEJAR LCD GRAFICOS PARA
PODER PROYECTAR IMÁGENES,
DIBUJAR CUADROS,LINEAS,
CIRCULOS Y HASTA ESCRIBIR TEXTO.
GLCD_init(1);
GLCD_clear(1); //Pinta la pantalla en Negro
while(1);

1 de enero de 2011 [CURSO DE HI TECH PIC18]
GLCD GRAFICOS Página - 61 -
GLCD_line(0,0,50,50,0);
while(1);
Ahora si deseamos poner un punto en la
pantalla (pixel), debe de tener una coordenada
(X,Y), para ser esto hay una función llamada:
void GLCD_point(unsigned char x,
unsigned char y, unsigned char
color);
Pone un punto en la pantalla en la coordenadas
X,Y de un color indicado.
Si deseamos una serie de puntos podemos usar
un ciclo “for”.
Esto realiza una línea de puntos en la pantalla
empezando en la coordenada ‘Y’ y en ‘X’,
mientras que la coordenada ‘X’ va variar en 2, y
así realizando el efecto de puntos en línea.
Para la realización de una línea continua sin
usar la instrucción ‘for’ y sin la función
“GLCD_point” se puede usar la función:
void GLCD_line(unsigned char
x1,unsigned char y1,unsigned
char x2, unsigned char y2,
unsigned char color);
x,y =la primera coordenada de donde se
empezara la linea.
X2,y2=la segunda coordenada de donde
terminara la lina.
Color= es color de la línea.
Al colocar la coordenadas para la línea este
automáticamente dibujara la línea
correspondiente.
Las opciones de inicialización y
pintado de pantalla son iguales qe
los ejemplos anteriores, solo pondré
un ejemplo de cada función vista,
para mayor facilidad de comprencion
en el funcionamiento de las
funciones nombradas.
Esto realiza una línea empezando en la
coordenada (0,0) hasta la (50,50).
Pero aveces es necesario dibujar cuadros y
círculos, para dibujar cuadros de confirmación o
negación o lo que nosotros queramos, para
dibujar cuadros pero no sin pintar el relleno de
cuadro, se le puede decir que solo dibuja el
GLCD_init(1);//Inicializamos GLCD
GLCD_clear(1);//Pinta la pantalla en Negro
for(x=0;x<50;x+=2){
GLCD_point(x,10,0);
}//Dibujamos una serie de puntos en blanco
while(1);

GLCD_box(0,0,50,50,0);
GLCD_line(50,0,0,50,1);
GLCD_line(0,0,50,50,1);
while(1);
marco de un rectángulo, podemos usar la
función:
void GLCD_rect(unsigned char x1,
unsigned char y1, unsigned char
x2, unsigned char y2, unsigned
char color);
x1,y1 especifica la primera coordenada de
donde empezara el rectángulo.
x2,y2 especifica donde terminara el rectángulo.
Color es si lo deseamos pintar de blanco o
negro.
Esto realiza un rectángulo empezando en la
coordenada (0,0) y finaliza en (50,50).
Más adelante se explicara cómo hacer un botón
de “OK”, para cuando se desee preguntar y
tener una respuesta afirmativa en la pantalla.
Si en lugar de dibujar
simplemente el marco de nuestro
rectángulo, deseamos pintar
por
completo el
cuadro, de
un color en
especifico,
se debe de
usar la
siguiente
función de
pintar
cuadro.
void GLCD_box(unsigned char
x1,unsigned char y1,unsigned
char x2,unsigned char
y2,unsigned char color);
Los parámetros son iguales que la función
anterior lo único que realiza esta función es
pintar el cuadro por completo, a diferencia de la
función anterior que simplemente era dibujar el
marco de un rectángulo o cuadrado.
Como vemos hemos pintado por completo el
rectángulo a blanco y después dibujamos las
líneas, esta función es muy usada para hacer un
tipo de borrado y escribir nuevamente en el
mismo
lugar.
Más
adelante se
verá más
detenidame
nte como
funcionan
varias
funciones
en un
proyecto a
GLCD_line(0,0,50,50,0);
GLCD_rect(0,0,50,50,0);
GLCD_line(50,0,0,50,0);
while(1);
0,0
50,50

base de GLCD.
Otra función de utilidad es cuando se quiere
dibujar un círculo en la pantalla, para eso
tenemos lo siguiente:
void GLCD_cero(unsigned char x1,
unsigned char y1, unsigned char
radio, unsigned char color);
x1,y2 Especifica el punto de partida del circulo
Radio Especifica el tamaño del circulo en radio
esto debe de tomarse que estamos trabajando
en pixeles.
Color Blanco o Negro el círculo.
Un ejemplo sencillo es dibujar un círculo
donde se interceptan dos líneas.
Pero a veces es justo y necesario tener en la
pantalla algo de letras para que nuestros
proyectos estén muy bien definidos.
En la función de escribir letras tiene una
característica particular que solo
puede escribirse en mayúsculas
, algunos símbolos
y números.
Pero esta función
no deja de ser muy
útil para tener muy
bien visualizado en
la pantalla lo que
está haciendo en
ese momento,
porque con
cuadritos y círculos no es suficiente para saber
que está haciendo en ese momento el proceso.
void GLCD_text(unsigned char x,
unsigned char y,unsigned char*
textptr,unsigned char
size,unsigned char color);
x,y coordenada para iniciar a escribir
textptr Texto a escribir
size tamaño de la letra
color Negro o blanco
Ahora si deseamos borrar todo el texto
recuerde usar la función “GLCD_box” y pintar
de negro todo el rectángulo del tamaño del
texto y vuelva a escribir otro texto, como se
muestra en el
ejemplo siguiente:
GLCD_line(0,0,50,50,0);
GLCD_cero(25,25,25,0);
GLCD_line(50,0,0,50,0);
while(1);
25,25
Radio de 25
GLCD_text(0,0,"HOLA MUNDO",1,0);
while(1);

Como vemos primero hemos escrto el primer
texto y después esperamos un tiempo de
visualización, después borramos y
escribimos nuevamente.
Ahora hay otra función muy especial que es
imprimir en el glcd una imagen ya definida
anteriormente, primero que nada se debe de
realizar la imagen del tamaño correcto que es
128x64 pixeles esto puede ser dibujado en paint
pero no necesitamos la imagen si no el código
necesario para guardarlo en el
microcontrolador ya que solo entiende 0’s y 1’s
no imágenes, entonces hemos de tener un
software especialmente para realizar este
trabajo.
Lo que voy a explicar es, un ejemplo sencillo de
cómo importar una imagen y
configurarla para después
sacar el código y después
pasarlo a nuestro programa
del micro, y por supuesto
como llamar la función de
imagen.
El software que vamos a usar
se llama Bitmap2LCD BASIC
V1_7 que es totalmente gratis la
versión demo, que es más que
suficiente para nuestros proyectos.
Al abrir el software nos abrirá la
ventana donde buscaremos una
imagen en formato .bmp
En la parte derecha aparecerá la imagen que
hayamos elegido, al dar dos click en la imagen
nos enviara a la ventana de modificaciones
donde nos preguntara si deseamos modificar el
tamaño, en este caso reducirlo ya que nuestra
imagen puede ser más grande que 128x64
pixeles damos OK.
En la parte superior derecha se encuentra una
barra deslizadora para modificar la imagen a
blanco y negro, la movemos para cambiar el
color hasta un punto donde nosotros deseamos
y listo.
Si desea agregar texto ya que
si unas cuantas letras no se
pudieron mostrar
correctamente solos
dirigimos nuestro mouse a un
icono en forma de doble ‘A’
damos click y aparecerá todas
las letras permitidas a escribir
y simplemente aun lado del
GLCD_text(0,0,"HOLA MUNDO",1,0);
DELAY1S();
GLCD_box(0,0,60,7,1);
GLCD_text(0,0,"HOLA ESCRIBI OTRA VEZ",1,0);
while(1);

mismo icono
damos click
para poder
escribir
donde
deseamos.
Al tener
nuestra
imagen ya
definida
podemos regresar al menú principal para
configurar la salida en hexadecimal, para ello
dirigimos nuestro mouse a la pestana de
‘output’ y en las opciones de “output file
viewer…” se encuentran las configuraciones
donde necesitamos para tener la salida
necesaria.
Debemos de tener lo siguiente:
Si tenemos lo anterior entonces simplemente
ya podemos generar nuestro código, damos
click en:
Rápidamente
aparecerá el
código como
un arreglo,
solo
copiamos el
archivo de
salida, que
debe ser en
extensión .h
y lo pegamos en la carpeta de la librería de
GLCD, si deseamos sustituir con el que ya existe
no hay problema.
Ahora en MPLAB
agregamos el
archivo en el
proyecto. Al hacer
esto el anterior se
modificara y solo
hay que cambiar
algunos parámetros
para que
simplemente
llamemos a la función de imagen y listo.
Al abrir el archivo .h estará incluyendo una
librería que no tiene nada que ver con nuestro
proyecto.

Solo borramos y cambiamos algunas cosas para
que nos quede de la siguiente manera:
Y listo solo hay que llamar a la función de
imagen .
Al introducir el cero en la función invertirá los
colores, teniendo una imagen igual pero inverso
en el color.
Como la imagen tiene 128x64 pixeles entonces
estamos consumiendo 1024 byte del
microcontrolador, entonces se deja al usuario
si desea usar esta
función en sus
proyectos, si
desea ahorrar
memoria de
programa es
preferible no
introducir
ninguna imagen a
nuestro proyecto,
pero si es
necesario entonces, inclúyalo.
Para tener más ideas podemos incluir un logo a
la pantalla y después escribir o dibujar sin
ningún problema.
Como se ve en el ejemplo siguiente donde se
Realizo primero un logo en el software y
después pasado a MPLAB y después escribimos.
GLCD_init(1);//Inicializamos GLCD
GLCD_image(0);
while(1);
Otro diseño usando el mismo método
de dibujo.

result=((float)ReadADC()*5)/1023;
En este proyecto simple trata de adquirir una
señal análoga para después convertirla a un
valor en especifico.
Para adquirir una señal análoga el
microcontrolador PIC18F4550 tiene 13 entradas
análogas, de las cuales solo una entrada vamos
a usar, en esta entrada conectaremos un
potenciómetro de 10k a 100k cualquiera que
tengamos a la mano, después conectaremos el
GLCD, después que la entrada detecte una señal
eléctrica que varia, el microcontrolador leerá
para después convertir la señal análoga a digital
y después ser convertida a voltaje.
Para la operación de conversión simplemente
usaremos la formula.
‫ݏݐ݈݋ݒ‬ ൌ
ௗ௔௧௢ ௟௘௜ௗ௢∗௩௔௟௢௥ ௗ௘ ௥௘௙௘௥௘௡௖௜௔
௕௜௧௦
Valor de referencia puede cambiar
dependiendo de la aplicación en este caso,
tenemos un valor de referencia para el
convertidor análogo-digital que sea de la fuente
( +5 v), los bits puede ser de 8 o 10 bit que
corresponden a 255 y 1024 respectivamente. El
dato leído es el valor automático que da como
resultado de la conversión.
Ejemplo:
Si tenemos configurado que vamos a leer los 10
bits máximos de conversión que contiene el
microcontrolador y leemos un dato de 512 solo
falta hacer la regla de tres simple para tener el
voltaje leído.
‫ݏݐ݈݋ݒ‬ ൌ
512 ∗ 5‫ݏݐ݈݋ݒ‬
1023
;
‫ݏݐ݈݋ݒ‬ ൌ 2.5‫ݏݐ݈݋ݒ‬
La operación que vamos a realizar en la
programación es la anterior y la podemos
implementar de la siguiente manera:
Ahora como ya entendimos lo que vamos hacer
es hora de explicar sobre como escribir en el
GLCD, vamos hacer una imagen con nuestro
logo y que mencione el nombre de la práctica,
al pasar un segundo este borre el nombre quien
creó la practica usando la función ‘GLCD_box’ al
tener borrado la parte donde debe de ir la
lectura del adc, se lee el dato y es convertido
usando la función:
sprintf(buffer[],texto y
conversión, dato a convertir);
buffer[] es un arreglo donde se va a guardar el
resultado de la conversión de numero a texto.
Texto y conversión aquí podemos incluir texto
adicional y la conversión del número.
Dato a convertir es el dato que deseamos
cambiar a texto.
Construiremos un simple voltímetro que
mide voltaje de 0 a 5 volts y que sea
proyectado en una pantalla GLCD.

1 de enero de 2011
GLCD GRAFICOS
El diagrama se puede apreciar en la imagen de arriba.
El programa que contiene el Microcontrolador:
////////////////////////////////////////////////////////
//
//Autor: george.manson.69
//Lugar: Mexico
//Compilador: HI TECH PIC18 (LITE MODE)
////////////////////////////////////////////////////////
#include<htc.h>
#include<stdio.h>
/////////////////////////////////////////////////////////////
//Configuracion para trabajar Con oscilador interno de 8Mhz
__CONFIG(1,INTIO & FCMDIS & IESODIS & PLLDIV5 & PLLPOSTDIV2 & CPUDIV1 & USBOSC);
/////////////////////////////////////////////////////////////
__CONFIG(2,VREGDIS & PWRTEN & BORDIS & WDTDIS & BORV45 & WDTPS32K);
__CONFIG(3,PBDIGITAL & LPT1DIS & MCLREN);
__CONFIG(4,STVRDIS & LVPDIS & ICPORTDIS & DEBUGDIS);
__CONFIG(5,UNPROTECT);
//////////////////////////////
//Frecuencia FOSC 8Mhz
//////////////////////////////
#define _XTAL_FREQ 8000000
#include"libGLCD/glcd.h"
//////////////////////////////
//Variable Globales //
//////////////////////////////
float result;
unsigned char adc[25];
//////////////////////////////
//FUNCION DE 1 SEG //
//////////////////////////////
void DELAY1S(void){
[CURSO DE HI TECH PIC18]
El diagrama se puede apreciar en la imagen de arriba.
El programa que contiene el Microcontrolador:
////////////////////////////////////////////////////////
USO GLCD ////
////
////
//Compilador: HI TECH PIC18 (LITE MODE) ////
////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
//Configuracion para trabajar Con oscilador interno de 8Mhz
/////////////////////////////////////////////////////////////
__CONFIG(2,VREGDIS & PWRTEN & BORDIS & WDTDIS & BORV45 & WDTPS32K);
__CONFIG(3,PBDIGITAL & LPT1DIS & MCLREN);
__CONFIG(4,STVRDIS & LVPDIS & ICPORTDIS & DEBUGDIS);
//////////////////////////////
//////////////////////////////
//////////////////////////////
//
/////////
//////////////////////////////
//
//////////////////////////////
Página 68

GLCD GRAFICOS Página 69
unsigned char time;
for(time=0;time<100;time++){
__delay_ms(10);
}
}
/////////////////////////////////////////////////
//Funcion de interrupcion
//Si no se usa simplemente no hacemos nada...
//Esto sirve para direccionar lo los datos
//en un lugar muy cercano al Inicio de la memoria
//de datos
////////////////////////////////////////////////
static void interrupt
isr(void){}
//////////////////////////////
//FUNCION PRINCIPAL
//////////////////////////////
void main(void){
OSCCON=0x70;
NOP();NOP();NOP();NOP();
//////////////////////////////////////////////////////////////////////
// Configuracion de Puertos ///
//////////////////////////////////////////////////////////////////////
TRISC=0;
TRISD=0;
TRISE=0;
TRISA=0x01;
/*---------------------Fin de Conf. Puertos-------------------------*/
//////////////////////////////////////////////////////////////////////
// Configuracion de ADC ///
//////////////////////////////////////////////////////////////////////
OpenADC(ADC_FOSC_RC &//Internal Oscilador Interno
ADC_RIGHT_JUST &//Justificacion a la derecha (10-bit)
ADC_20_TAD, //Tiempo de Adquisicion (TAD)
ADC_CH0 &//CANAL 0 analogo
ADC_INT_OFF &//Interrupcion por ADC APAGDO
ADC_REF_VDD_VSS,//V+ref=VCC,V-ref=GND
ADC_1ANA); //AN0=analogo,resto digitales
/*---------------------Fin de Conf. ADC------------------------------*/
GIE=0; //INTERRUPCIONES GLOBALES DESACTIVADAS
PEIE=0; //DESACTIVA INTERURPCIONES POR PERIFERICOS
GLCD_init(1); //Inicializamos GLCD
GLCD_image(0);//Mandamos la imagen
DELAY1S();
while(1){
GLCD_box(0,50,80,64,1);//Borra texto viejo
ConvertADC(); //Empieza conversión
while(BusyADC()); //Ha terminado?
result=((float)ReadADC()*5)/1023;//Convierte a Voltaje
sprintf(adc,"%0.3f VOLTS",result);//Lo guarda como texto
GLCD_text(0,50,adc,1,0);//Imprime texto
DELAY1S(); //Espera tiempo de Visualización
}
}
/*-------------------------------Fin-----------------------------------*/

GLCD GRAFICOS Página 70
Funcionamiento del GLCD
Al esperar 1 segundo, se borrara ‘Hecho por jorge’ y se pondrá el valor del voltaje leído durante un
segundo mostrara el voltaje y se actualizara.
Usted puede apreciar una gran desventaja al usar un retardo de un segundo ya que estará flashando el
voltaje, para que no suceda esto puede usar para físicamente usar un retardo de 10mS para apreciar lo
que sucede.
Nota: El GLCD puede tener distintos pines
de alimentación, revise detenidamente la
hoja de datos del producto antes de
conectarlo. Mientras las conexiones de
datos siempre son iguales.

Glcd 6

Más contenido relacionado

La actualidad más candente

Destacado

Similar a Glcd 6

Glcd 6