Programando PIC con CCS ejercicio 3 (LCD)

La pantalla LCD es otro dispositivo de despliegue, de información muy versátil y viene en un gran cantidad de modelos y configuraciones, que sirve como ventana a datos, configuraciones o despliegue de información donde un LED no es suficiente.

Lo primero que debemos saber, es la conexión de la pantalla LCD segun el tipo que vamos a uasr y para esto consultaremos el siguiente PDF datashet (Hoja información) de una pantalla LCD genérica 16X2 es decir 2 filas de 16 caracteres cada una.

Después se puede profundizar con el siguiente libro.

En el libro “Compilador C CCS Y Simulador Proteus Para Microcontroladores PIC” está todas la información de lo que aquí vamos explicar de una forma más resumida, en la sección 3.3 entradas y salida 3.3.1 LCD.

Si no entendiste no importa (>*.*)> vamos a explicarlo aquí otras vez, las pantallas LCD son dispositivos que se puede dañar muy fácilmente =S varios de mis amigos en la facultad, por malas conexiones, malos tratos o un simple descuido se las cargaron x_X pero no hay que asustarse ^_^ lo hay que hacer es consultar la hojas de los fabricantes y se vera que es un standar en los pines (PIN) yo he usado varios modelos, 1X30, 4X16, 2X16 y de led en vez de cristal liquido y todas se trabaja de forma similar.

Al dorso de la pantalla veremos que los pines están numerados.

En este modelo de pantalla LCD, solo se marca el PIN 1 y el 14.

Y para identificar cual es el A y K es fácil en este modelo al verlo de frente al dispositivo y que están conectado a los dos pines anteriores al PIN señalado como 1 esto lo comprobé con un multimetro.

Como se aprecia dos imágenes mas arriba el K y A se debe respetar una polaridad, identificar los pines no es gran problema, ahora debemos saber como conectarlos, para eso vamos a ver el siguiente diagrama.

Podemos dividirlo en dos partes, la parte de (control y despliegue) y la parte de (alimentación y ajuste).

La de la derecha (alimentación y ajuste) VSS seria el neutro (polaridad -) y VDD de +3.3V a +5V (según el modelo), entre ellos una resistencia ajustable (reostato) o potenciómetro a V0 que nos servirá para ajustar el contraste de la pantalla.

El LED BKL (LED BACKLIGHT) lo podemos tomar como un circuito independiente, su función es de retroiluminar la pantalla, en cristiano moderno, es para poder ver los dígitos en la oscuridad, la A y K no es casualidad se comporta en cierto modo como

un led normal, pero este tiene mayor consumo, para su uso mas sencillo se alimenta directamente a +4.5V o a +5V mediante una resistencia de 22 ohm.

No es obligatorio conectar el (LED BACKLIGHT) para que funciones la LCD, como comentamos antes se pude tomar como un circuito aparte, lo interesante es que podemos usar un interruptor normal o uno mediante un circuito de conmutación (transistores o MOSFES) controlado por el mismo PIC que solo cuando halla actividad (por ejemplo) este encendido ya que este tiene un consumo considerable.

Para lo demás pines voy a colocar la descripción que me da una hoja de un fabricante.

MANOSSSSSSSS a la obra!!!!!!!!!!!! 

En PIC-C CCS creamos un proyecto con las siguientes características:

Micro-controlador PIC 16F877A.  Frecuencia de reloj 500.000 Hz (recuerda es una simulación simple).  Seleccionamos un cristal de <= 4 MHz (tipo de oscilador). Todas la demás opciones dejarla tal como están.

Si no recuerda como hacerlo repacen aquí y aquí.  <-------------------- repaso

Agregamos la librería  #include <  lcd.c  > que hace una función similar como un drivers en una PC.

Compilamos (F9) y luego en proyecto (project) abrimos todos lo archivos (OPEN ALL Filles) y no ubicamos en la ventana LCD.C

Aquí no indica como debemos usarla, lo primero que dice que debemos colocar lcd_init(); luego del ( void main {}) . Más abajo encontramos la información para conectar el PIC con la pantalla LCD la cual usaremos para armar nuestro circuito en ISIS Proteus, como se puede apreciar la librería indica la forma de usarla y la conexión.PIC-C tiene una variedad de libreria para los dispositivos LCD ya que como sabemos hay muchos tipos y configuraciones, por ejemplo la Pantalla LCD mediante I2C.

Para evitar inconveniente borramos la pantalla con el comando (printf(LCD_PUTC, "\f");) se puede usar cuanta veces se requiera, luego dentro de un bucle infinito colocamos nuestro primer ejemplo.

El circuito sera un PIC18F877A y un LM016L una pantalla LCD 16X2, como en ejercicios anteriores algunas conexiones no se hacen por simplificar, pero eso no indica que, cuando vamos hacerlo en un Proto-Board no debamos hacerlas. Hay que recordar configurar el reloj 500kHz (en la simulación), también colocar en alto el pin 1 del PIC (el18F877A lo requiere) si usamos un botón y colocamos el pin 1 en bajo se reseteara el PIC.

El ejemplo es muy simple para comenzar así que explicare lo necesario para que funcione.

En la linea 2 yo declare la librería -----------> #include <  lcd.c  >En la linea 7 por petición de la librería coloque ----------> lcd_init();En la linea 18 borre la LCD antes de escribir -------------> printf(LCD_PUTC, "\f");

Luego uso dentro del bucle infinito, lo siguientes ejercicios.

//ejemplo1lcd_gotoxy(1,1);// cd_gotoxy(x,y) donde x es la fila, y la columna.printf(LCD_PUTC, "Hola ^_^"); // entre comillas el mensaje.

Comentamos todo el ejemplo 1 y pegamos el siguiente ejercicio.//ejemplo 2lcd_gotoxy(1,1);printf(LCD_PUTC, "22XD");lcd_gotoxy(1,2);printf(LCD_PUTC, "blogspot.com");

Aquí usamos la fila una y dos.

Comentamos el ejemplo 1 y 2  para colocar el ejemplo 3 que es texto en movimiento.Antes debemos declarar -------------> int i;

//ejemplo 3lcd_gotoxy(1,1);

printf(LCD_PUTC, "Loading");

for (i=1;i<=16;++i){lcd_gotoxy(i,2);printf(LCD_PUTC, "*");delay_ms( 500 );}

Hacemos un efecto de carga, también lo podemos hacer con un texto.

Comentamos todos los ejemplos anteriores y pegamos el ultimo ejemplo el 4, recuerde que devemos tener declarada i como entero.

//ejemplo 4printf(LCD_PUTC, "\f");// borrar lcdfor (i=1;i<=16;++i){lcd_gotoxy(1,1);printf(LCD_PUTC, "Loading (%2i)",i);

lcd_gotoxy(i,2);printf(LCD_PUTC, "*");delay_ms( 500 );} 

Podemos usar un texto en movimiento y dentro de este una variable, por ejemplo un aviso que señale un temperatura.

Para comentar todo un ejemplo o un segmento de código usamos al comienzo */ y al final /*

Para una mejor compresión un Vídeo con los cuatros ejemplos.

Puede descargar el ejemplo aquí.

 

FUNCION DESCRIPCION

initLCD( )Envía los comandos para inicializar el LCD. El cursor va a la posición (0,0).

clearLCD( ) Pone las 16 celdas del LCD en blanco.

cursorXY(1,5) Posiciona el cursor en el renglón 1, celda 5

stringLCD(wib)

En este ejemplo, "wib" es un arreglo con formato de string. La función escribe el string en el LCD. Máximo 8 caracteres. Programa de prueba CCSLCD4.c

PutLCD('*')Escribe el caracter indicado entre diéresis en la posición en donde se encuentre el cursor.

PutLCD(53); se envía el código ASCII del número 5, cuyo valor decimal es 53

PutLCD(x); se envía al LCD, en un solo caracter, el valor de la variable x, que debe ser un código ASCII.

PutLCD("1234")Funciona como la función stringLCD( ), pero sin necesidad de inicializar un arreglo. Envía un caracter tras otro. Ver el programa de prueba 2.

delay_ms(100)Retraso de 100 milisegundos. Argumento máximo 1000 milisegundos.

strcpy(letrero,"AMIGOS") Es una función suplementaria para el manejo de strings. Almacena en memoria el texto entrecomillado en un arreglo de nombre "letrero". El arreglo tiene formato de "string".

Esta función está integrada al compilador CCS, en la librería string.h

 

Basic LCD Control using CCS

Ok.... before we go on ... It is a heckuva lot easier to buy a serial LCD. Scott Edwards had a really good deal on LCD screens ($29) for a while (apparently the sale is over). Crystalfontz has some also (Crystalfontz) for about the same prices (haven't tried Crystalfontz). Can't beat those prices. You will spend more than $30.00 worth of time putting one together. However, it is still fun to get one going. So here's an easy one to start.

The above diagram shows the hook up for a simple serial LCD. This hookup is described in the file lcd.c which comes with the examples provided with CCS. The file is copyrighted and cannot be reproduced here. So, if you have CCS, then read on.

The difference between the above drawing and the CCS example is that I've added a serial input onto A0. Now all that has to be done is wait for a serial input and then put it into the LCD program. Each input must be terminated with a carriage return (char 13). That means, in C code, you should end your string with an '\r', not an '\n'. .

I found some really cheap LCD modules at BGMicro ($2.70 each) that were only 1 X 16 - so this code only expects that. If you have a different LCD, then modify the code a little and set the appropriate flags in the LCD.C include file. Now, I'm going to emphasize this.... be sure to modify the flags in the LCD.C file for your particular LCD!

Once you get this sucker running, you use the pot to adjust for contrast. Several example LCD projects just say tie this to ground. I have NEVER gotten that to work well (always too dark). Contrast has always had to be adjustable for the LCDs that I've tried. Get it going and keep hitting reset/adjusting the pot until you can clearly see the 'Ready . . ." message. Because the A0 pin is floating, the program will periodically crash if you don't have the input tied to your controlling program output. That's ok... it makes a nice recycle effect when it crashes (the Ready . . . message keeps blinking). I planned it that way .... (heh, heh).

My code looks a little like this:

#include < 16F84.H >#fuses HS,NOPROTECT,NOWDT

#use delay(clock=4000000)//// the following file is included with the examples that come// with CCS. You should modify it for your type of LCD before you// use it!

#include < lcd.c >

//// declare the rs232 parameters. Leave off the INVERT if you are feeding// this from a PC through a MAX232 or similar//

#use rs232(baud=9600, rcv=PIN_A0,parity=n,bits=8,INVERT)

main() {

//// If you feed the buffer with more than 16 characters, it will crash// So you might want to bullet proof this a whole lot more. I didn't// and my prototypes work fine - because I don't send it more than // 16 characters (grin). PS: the extra characters in the array are for// the carriage return/null on the end of the string.//// The array initialization is not needed, but shown as a reminder of// the space being used.// char buf[18]={32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32};

unsigned xc=0; lcd_init(); // mandatory

lcd_putc("\fReady . . .\n"); // nice and friendly delay_ms(2000); lcd_putc("\f"); // clear the screen (uses codes in lcd.c) while(1) { gets(buf); // puts data into buf[] until it reaches a char 13 (cr) lcd_putc("\f"); // clears screen before printing buffer - remove if more

// than one line LCD. Clear it with your input code instead.

// for(xc=0;xc<16;xc++) { if(buf[xc]==0) buf[xc]=32; // eliminate the null character if(buf[xc]==13) buf[xc]=32; // not needed if using gets to get string if(buf[xc]==10) buf[xc]=32; // not needed if using more than 1X16 lcd_putc(buf[xc]); // buf[xc]=32; // resets buffer contents to spaces } }}

Back to start of this section