#include <16F876.h>
#fuses XT, NOWDT
#use delay (clock=4000000)
#include <lcd.c>
#use standard_io(C)
#use standard_io(A)
enum funciones {med,cal,ini};
void medir(void){
output_toggle(pin_C0);}
void calibrar(void){
output_toggle(pin_C1);}
void inicializar(void){
output_toggle(pin_C2);}
void run_func(int numfunc){
switch(numfunc){
case med:
medir();
break;
case cal:
calibrar();
break;
case ini:
inicializar();
break;
}
}
void main(){
char item;
char n_menus=3;
lcd_init();
while(1){
if(input(PIN_A0)==1){
item++;
delay_ms(300);
lcd_putc('\f');}
if(item>(n_menus-1)){
item=0;}
switch(item){
case 0:
lcd_gotoxy(1,1);
printf(lcd_putc,"MEDIR");
lcd_gotoxy(1,1);
break;
case 1:
printf(lcd_putc,"CALIBRAR");
lcd_gotoxy(1,1);
break;
case 2:
printf(lcd_putc,"INICIALIZAR");
lcd_gotoxy(1,1);
break;
}
if(input(PIN_A1)==1)
{delay_ms(200);
run_func(item);}
}
}
///////////////////////////////////////////////////////////////////////////
//// LCDD.C ////
//// Driver for common LCD modules ////
//// ////
//// lcd_init() Must be called before any other function. ////
//// ////
//// lcd_putc(c) Will display c on the next position of the LCD. ////
//// The following have special meaning: ////
//// \f Clear display ////
//// \n Go to start of second line ////
//// \b Move back one position ////
//// ////
//// lcd_gotoxy(x,y) Set write position on LCD (upper left is 1,1) ////
//// ////
//// lcd_getc(x,y) Returns character at position x,y on LCD ////
//// ////
///////////////////////////////////////////////////////////////////////////
//// (C) Copyright 1996,2007 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. ////
///////////////////////////////////////////////////////////////////////////
// As defined in the following structure the pin connection is as follows:
// D0 enable
// D1 rs
// D2 rw
// D4 D4
// D5 D5
// D6 D6
// D7 D7
//
// LCD pins D0-D3 are not used and PIC D3 is not used.
// Un-comment the following define to use port B
// #define use_portb_lcd TRUE
struct lcd_pin_map { // This structure is overlayed
BOOLEAN enable; // on to an I/O port to gain
BOOLEAN rs; // access to the LCD pins.
BOOLEAN rw; // The bits are allocated from
BOOLEAN unused; // low order up. ENABLE will
int data : 4; // be pin B0.
} lcd;
#if defined use_portb_lcd
//#locate lcd = getenv("sfr:PORTB") // This puts the entire structure over the port
#ifdef __pch__
#locate lcd = 0xf81
#else
#locate lcd = 6
#endif
#define set_tris_lcd(x) set_tris_b(x)
#else
//#locate lcd = getenv("sfr:PORTD") // This puts the entire structure over the port
#ifdef __pch__
#locate lcd = 0xf83
#else
#locate lcd = 8
#endif
#define set_tris_lcd(x) set_tris_d(x)
#endif
#ifndef lcd_type
#define lcd_type 2 // 0=5x7, 1=5x10, 2=2 lines
#endif
#define lcd_line_two 0x40 // LCD RAM address for the second line
BYTE const LCD_INIT_STRING[4] = {0x20 | (lcd_type << 2), 0xc, 1, 6};
// These bytes need to be sent to the LCD
// to start it up.
// The following are used for setting
// the I/O port direction register.
struct lcd_pin_map const LCD_WRITE = {0,0,0,0,0}; // For write mode all pins are out
struct lcd_pin_map const LCD_READ = {0,0,0,0,15}; // For read mode data pins are in
BYTE lcd_read_byte() {
BYTE low,high;
set_tris_lcd(LCD_READ);
lcd.rw = 1;
delay_cycles(1);
lcd.enable = 1;
delay_cycles(1);
high = lcd.data;
lcd.enable = 0;
delay_cycles(1);
lcd.enable = 1;
delay_us(1);
low = lcd.data;
lcd.enable = 0;
set_tris_lcd(LCD_WRITE);
return( (high<<4) | low);
}
void lcd_send_nibble( BYTE n ) {
lcd.data = n;
delay_cycles(1);
lcd.enable = 1;
delay_us(2);
lcd.enable = 0;
}
void lcd_send_byte( BYTE address, BYTE n ) {
lcd.rs = 0;
while ( bit_test(lcd_read_byte(),7) ) ;
lcd.rs = address;
delay_cycles(1);
lcd.rw = 0;
delay_cycles(1);
lcd.enable = 0;
lcd_send_nibble(n >> 4);
lcd_send_nibble(n & 0xf);
}
void lcd_init() {
BYTE i;
set_tris_lcd(LCD_WRITE);
lcd.rs = 0;
lcd.rw = 0;
lcd.enable = 0;
delay_ms(15);
for(i=1;i<=3;++i) {
lcd_send_nibble(3);
delay_ms(5);
}
lcd_send_nibble(2);
for(i=0;i<=3;++i)
lcd_send_byte(0,LCD_INIT_STRING[i]);
}
void lcd_gotoxy( BYTE x, BYTE y) {
BYTE address;
if(y!=1)
address=lcd_line_two;
else
address=0;
address+=x-1;
lcd_send_byte(0,0x80|address);
}
void lcd_putc( char c) {
switch (c) {
case '\f' : lcd_send_byte(0,1);
delay_ms(2);
break;
case '\n' : lcd_gotoxy(1,2); break;
case '\b' : lcd_send_byte(0,0x10); break;
default : lcd_send_byte(1,c); break;
}
}
char lcd_getc( BYTE x, BYTE y) {
char value;
lcd_gotoxy(x,y);
while ( bit_test(lcd_read_byte(),7) ); // wait until busy flag is low
lcd.rs=1;
value = lcd_read_byte();
lcd.rs=0;
return(value);
}
:estudiando:
///////////////////////////////////////////////////////////////////////////
//// LCD.C ////
//// Driver for common LCD modules ////
//// ////
//// lcd_init() Must be called before any other function. ////
//// ////
//// lcd_putc(c) Will display c on the next position of the LCD. ////
//// The following have special meaning: ////
//// \f Clear display ////
//// \n Go to start of second line ////
//// \b Move back one position ////
//// ////
//// lcd_gotoxy(x,y) Set write position on LCD (upper left is 1,1) ////
//// ////
//// lcd_getc(x,y) Returns character at position x,y on LCD ////
//// ////
///////////////////////////////////////////////////////////////////////////
//// (C) Copyright 1996,2003 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. ////
///////////////////////////////////////////////////////////////////////////
//
// As defined in the following structure the pin connection is as follows:
// D0 enable
// D1 rs
// D2 rw
// D4 D4
// D5 D5
// D6 D6
// D7 D7
//
// LCD pins D0-D3 are not used and PIC D3 is not used.
//
// Un-comment the following define to use port B
#define use_portb_lcd TRUE
//
//
struct lcd_pin_map { // This structure is overlayed
BOOLEAN enable; // on to an I/O port to gain
BOOLEAN rs; // access to the LCD pins.
BOOLEAN rw; // The bits are allocated from
BOOLEAN unused; // low order up. ENABLE will
int data : 4; // be pin B0.
} lcd;
//
#if defined(__PCH__)
#if defined use_portb_lcd
#byte lcd = 0xF81 // This puts the entire structure
#else
#byte lcd = 0xF83 // This puts the entire structure
#endif
#else
#if defined use_portb_lcd
#byte lcd = 6 // on to port B (at address 6)
#else
#byte lcd = 8 // on to port D (at address 8)
#endif
#endif
//
#if defined use_portb_lcd
#define set_tris_lcd(x) set_tris_b(x)
#else
#define set_tris_lcd(x) set_tris_d(x)
#endif
//
#define lcd_type 2 // 0=5x7, 1=5x10, 2=2 lines
#define lcd_line_two 0x40 // LCD RAM address for the second line
//
BYTE const LCD_INIT_STRING[4] = {0x20 | (lcd_type << 2), 0xc, 1, 6};
// These bytes need to be sent to the LCD
// to start it up.
//
// The following are used for setting
// the I/O port direction register.
struct lcd_pin_map const LCD_WRITE = {0,0,0,0,0}; // For write mode all pins are out
struct lcd_pin_map const LCD_READ = {0,0,0,0,15}; // For read mode data pins are in
//
BYTE lcd_read_byte() {
BYTE low,high;
set_tris_lcd(LCD_READ);
lcd.rw = 1;
delay_cycles(1);
lcd.enable = 1;
delay_cycles(1);
high = lcd.data;
lcd.enable = 0;
delay_cycles(1);
lcd.enable = 1;
delay_us(1);
low = lcd.data;
lcd.enable = 0;
set_tris_lcd(LCD_WRITE);
return( (high<<4) | low);
}
//
void lcd_send_nibble( BYTE n ) {
lcd.data = n;
delay_cycles(1);
lcd.enable = 1;
delay_us(2);
lcd.enable = 0;
}
//
void lcd_send_byte( BYTE address, BYTE n ) {
lcd.rs = 0;
while ( bit_test(lcd_read_byte(),7) ) ;
lcd.rs = address;
delay_cycles(1);
lcd.rw = 0;
delay_cycles(1);
lcd.enable = 0;
lcd_send_nibble(n >> 4);
lcd_send_nibble(n & 0xf);
}
//
void lcd_init() {
BYTE i;
set_tris_lcd(LCD_WRITE);
lcd.rs = 0;
lcd.rw = 0;
lcd.enable = 0;
delay_ms(15);
for(i=1;i<=3;++i) {
lcd_send_nibble(3);
delay_ms(5);
}
lcd_send_nibble(2);
for(i=0;i<=3;++i)
lcd_send_byte(0,LCD_INIT_STRING[i]);
}
//
void lcd_gotoxy( BYTE x, BYTE y) {
BYTE address;
if(y!=1)
address=lcd_line_two;
else
address=0;
address+=x-1;
lcd_send_byte(0,0x80|address);
}
//
void lcd_putc( char c) {
switch (c) {
case '\f' : lcd_send_byte(0,1);
delay_ms(2);
break;
case '\n' : lcd_gotoxy(1,2); break;
case '\b' : lcd_send_byte(0,0x10); break;
default : lcd_send_byte(1,c); break;
}
}
//
char lcd_getc( BYTE x, BYTE y) {
char value;
lcd_gotoxy(x,y);
while ( bit_test(lcd_read_byte(),7) ); // wait until busy flag is low
lcd.rs=1;
value = lcd_read_byte();
lcd.rs=0;
return(value);
}
Rutinas con PIC micro
Aqui en este thread he apartado las rutinas y esquemas necesarios para el manejo de dispositivos tipicos en el area digital, y muy utilizado en el ámbito de la Domotica.
Display LCD 2x16 - (tipo Hitachi)
Descripción:
La pantalla de cristal liquido o LCD (Liquid Crystal Display) es un dispositivo µControlado de visualización grafico para la presentación de caracteres, símbolos o incluso dibujos (en algunos modelos), es este caso
dispone de 2 filas de 16 caracteres cada una y cada carácter dispone de una matriz de 5x7 puntos (pixels), aunque los hay de otro número de filas y caracteres. Este dispositivo esta gobernado internamente por un microcontrolador Hitachi 44780 y regula todos los parámetros de presentación, este modelo es el mas comúnmente usado y esta información se basará en el manejo de este u otro LCD compatible.
Caracteristicas principales:
-Pantalla de caracteres ASCII, además de los caracteres Kanji y Griegos.
-Desplazamiento de los caracteres hacia la izquierda o la derecha.
-Proporciona la dirección de la posición absoluta o relativa del caracter.
-Memoria de 40 caracteres por línea de pantalla.
-Movimiento del cursor y cambio de su aspecto.
-Permite que el usuario pueda programar 8 caracteres.
-Conexión a un procesador usando un interfaz de 4 u 8 bits
Funcionamiento:
Para comunicarse con la pantalla LCD podemos hacerlo por medio de sus patitas de entrada de dos maneras posibles, con bus de 4 bits o con bus de 8 bits, este ultimo es el que explicare y la rutina también será para este. En la siguiente figura vemos las dos maneras posibles de conexionar el LCD con un pic16F84.
Conexionado con bus de 4 bits
Conexionado con bus de 8 bits
Como puede apreciarse el control de contraste se realiza al dividir la alimentación de 5V con una resistencia variable de 10K.
Las líneas de datos son triestado, esto indica que cuando el LCD no esta habilitado sus entradas y salidas pasan a alta impedancia.
Descripción de pines:
PIN Nº SIMBOLO DESCRIPCION
1 Vss Tierra de alimentación GND
2 Vdd Alimentación de +5V CC
3 Vo Contraste del cristal liquido. ( 0 a +5V )
4 RS Selección del registro de control/registro de datos:
RS=0 Selección registro de control
RS=1 Selección registro de datos
5 R/W Señal de lectura/escritura:
R/W=0 Escritura (Write)
R/W=1 Lectura (Read)
6 E Habilitación del modulo:
E=0 Módulo desconectado
E=1 Módulo conectado
7-14 D0-D7 Bus de datos bidireccional.
JUEGOS DE INSTRUCCIONES:
Estas son las instrucciones para el control del modulo LCD
Hitachi 44780 o compatible
CLEAR DISPLAY
Borra el módulo LCD y coloca el cursor en la primera posición
(dirección 0). Pone el bit I/D a 1 por defecto.
RS R/W DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
0 0 0 0 0 0 0 0 0 1
Tiempo de ejecución: 1.64mS
HOME
Coloca el cursor en la posición de inicio (dirección 0) y hace que el display comience a desplazarse desde la posición original. El contenido de la memoria RAM de datos de visualización (DD RAM) permanece invariable. La dirección de la memoria RAM de datos para la visualización (DD RAM) es puesta a 0.
RS R/W DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
0 0 0 0 0 0 0 0 1 X
Tiempo de ejecución: 1.64mS
ENTRY MODE SET
Establece la dirección de movimiento del cursor y especifica si la visualización se va desplazando a la siguiente posición de la pantalla o no. Estas operaciones se ejecutan durante la lectura o escritura de la DD RAM o CG RAM. Para visualizar normalmente poner el bit S=0.
RS R/W DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
0 0 0 0 0 0 0 1 I/D S
Tiempo de ejecución: 40µS
DISPLAY ON/OFF CONTROL
Activa o desactiva poniendo en ON/OFF tanto al display (D) como al cursor (C) y se establece si este último debe o no parpadear (B).
RS R/W DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
0 0 0 0 0 0 1 D C B
Tiempo de ejecución: 40µS
CURSOR OR DISPLAY SHIFT
Mueve el cursor y desplaza el display sin cambiar el contenido de la memoria de datos de visualización DD RAM.
RS R/W DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
0 0 0 0 0 1 S/C R/L X X
Tiempo de ejecución: 40µS
FUNCTION SET
Establece el tamaño de interfase con el bus de datos (DL), número de líneas del display (N) y tipo de carácter (F)
RS R/W DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
0 0 0 0 1 DL N F X X
Tiempo de ejecución: 40µS
SET THE CG RAM ADDRESS
El módulo LCD además de tener definidos todo el conjunto de caracteres ASCII, permite al usuario definir 4 u 8 caracteres gráficos. La composición de estos caracteres se va guardando en una memoria llamada CG RAM con capacidad para 64 bytes. Cada carácter gráfico definido por el usuario se compone de 16 u 8 bytes que se almacenan en sucesivas posiciones de la CG RAM.
Mediante esta instrucción se establece la dirección de memoria CG RAM a partir de la cual se irán almacenando los bytes que definen un carácter gráfico. Ejecutando este comando todos los datos que se lean o escriban posteriormente, lo hacen desde esta memoria CG RAM.
RS R/W DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
0 0 0 1 Dirección de la CG RAM
Tiempo de ejecución: 40µS
SET THE DD RAM ADDRESS
Los caracteres o datos que se van visualizando, se van almacenando en una memoria llamada DD RAM para de aquí pasar a la pantalla.
Mediante esta instrucción se establece la dirección de la memoria
DD RAM a partir de la cual se irán almacenando los datos a visualizar. Ejecutando este comando, todos los datos que se escriban o lean posteriormente lo harán desde esta memoria DD RAM. Las direcciones de la 80h a la 8Fh corresponden con los 16 caracteres del primer renglón y de la C0h a la CFh con los 16 caracteres del segundo renglón, para este modelo de LCD.
RS R/W DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
0 0 1 Dirección de la DD RAM
Tiempo de ejecución: 40µS
READ BUSY FLAG & ADDRESS
Cuando el modulo LCD esta ejecutando cualquiera de estas instrucciones, tarda un cierto tiempo de ejecución en el que no se debe mandar ninguna instrucción. Para ello dispone de un flag llamado BUSY (ocupado) que indica que se está ejecutando una instrucción previa.
Esta instrucción de lectura informaciónrma del estado de dicho flag además de proporcionar el valor del contador de direcciones de la CG RAM o de la DD RAM según la última que se haya empleado.
RS R/W DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
0 1 BF Dirección de la CG RAM o DD RAM
Tiempo de ejecución: 40µS
WRITE DATA TO GG OR DD RAM
Mediante este comando se escribe en la memoria DD RAM los datos que se quieren presentar en pantalla y que serán los diferentes códigos ASCII de los caracteres a visualizar.
Igualmente se escribe en la memoria CG RAM los diferentes bytes que permiten confeccionar caracteres gráficos a gusto del usuario.
El escribir en uno u otro tipo de memoria depende de si se ha empleado previamente la instrucción de direccionamiento DD RAM o la de direccionamiento CG RAM.
RS R/W DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
1 0 Código ASCII o byte del carácter gráfico
Tiempo de ejecución: 40µS
READ DATA FROM CG RAM OR DD RAM
Mediante este comando se lee de la memoria DD RAM los datos que haya almacenados y que serán los códigos ASCII de los caracteres almacenados.
Igualmente se lee de la memoria CG RAM los diferentes bytes con los que se ha confeccionado un determinado carácter gráfico.
El leer de uno u otro tipo de memoria depende de si se ha empleado previamente la instrucción de direccionamiento de la DD RAM o la de direccionamiento CG RAM.
RS R/W DB7 DB6 DB5 DB4 DB3 DB2 DB1 DB0
1 1 Código ASCII o byte del carácter gráfico
Tiempo de ejecución: 40µS
ABREVIATURAS
Abreviaturas empleadas en los códigos anteriores:
S 1 - Desplaza la visualización cada vez que se escribe un dato
0 - Modo normal
I/D 1 - Incremento del cursor
0 - Decremento del cursor
S/C 1 - Desplaza el display
0 - Mueve el cursor
R/L 1 - Desplazamiento a la derecha
0 - Desplazamiento a la izquierda
BF 1 - Módulo ocupado
0 - Módulo disponible
DL 1 - Bus de datos de 8 bits
0 - Bus de datos de 4 bits
N 1 - LCD de dos líneas
0 - LCD de una línea
F 1 - Carácter de 5 x 10 puntos
0 - Carácter de 5 x 7 puntos
B 1 - Parpadeo del cursor ON
0 - Parpadeo del cursor OFF
C 1 - Cursor ON
0 - Cursor OFF
D 1 - Display ON
0 - Display OFF
X Indeterminado
Juego de caracteres:
Descripción: La siguiente librería básica de rutinas es para controlar un LCD Hitachi 44780 o compatible.
Los datos o comandos a enviar al LCD los meteremos en el acumulador W antes de hacer la llamada a cualquiera de las rutinas siguientes.
LCD_E Genera un pulso de 1µS por PORTB,2 patita 6 (Enable) del LCD. Si se usa una velocidad de micro diferente de 4MHz habrá que ajustar este tiempo.
LCD_BUSY Chequea si el LCD esta ocupado (BUSY) y retorna de la rutina cuando ya no lo este.
LCD_REG Pone al LCD en modo de recibir comandos , espera a que no este ocupado y va a LCD_E.
LCD_DATOS Pone el LCD en modo datos y manda el byte presente en W que será mostrado en pantalla.
LCD_INI Inicializacion del modulo LCD segun los tiempo marcados por el fabricante. Bus de 8 bits, 2 lineas de visualizacion y caracteres de 5 x 7 puntos.
LCD_PORT Configura los puertos del PIC para ser usados con el LCD.
Rutina
LCD 2x16
LCD.LIB
Ejemplo:
El siguiente ejemplo muestra lo fácil que es manejar un LCD. Lo que hace básicamente es configurar el LCD, los puertos del PIC y luego mandar los datos según los va cogiendo de la tabla de datos, para mostrar en el LCD la típica frase "HOLA MUNDO".
;<<<<<<----------------- INICIO PROGRAMA PRINCIPAL ------------------->>>>>>>
INICIO CLRF Digito ;Pone a 0 la variable digito
CALL LCD_PORT ;Puertos en modo LCD
BCF RA,0 ;Desactiva RS del modulo LCD
BCF RA,2 ;Desactiva E del modulo LCD
START CALL LCD_INI ;Inicia LCD (CFG puertos...)
MOVLW b'00000001' ;Borrar LCD y Home
CALL LCD_REG
MOVLW b'00000110'
CALL LCD_REG
MOVLW b'00001100' ;LCD On, cursor Off,Parpadeo Off
CALL LCD_REG
MOVLW 0x80 ;Direccion caracter
CALL LCD_REG
REPETIR MOVF Digito,w ;W=Digito
CALL DATO_1 ;Coge el caracter
IORLW 0 ;Compara
BTFSC STATUS,2 ;Es el ultimo?
GOTO acabar ;Si
CALL LCD_DATOS ;Visualiza caracter
INCF Digito,f ;Incrementa numero de Digito
GOTO REPETIR ;Vuelve a escribir
acabar nop
goto acabar ;Buclee infinito
;<<<<<<---------------------- TABLA DE DATOS ------------------------->>>>>>>
DATO_1 ADDWF PCL,1
RETLW 'H'
RETLW 'O'
RETLW 'L'
RETLW 'A'
RETLW ' '
RETLW 'M'
RETLW 'U'
RETLW 'N'
RETLW 'D'
RETLW 'O'
RETLW 0x00
Ejemplo "Hola Mundo"
HOLA.ASM
Nota: Esta rutina solo funciona correctamente con LCD's rápidos, osea los que son un poco mas caros jejej, esto lo descubrió Taiteki que fue uno de los que la probaron y les falló, la solución consiste en usar un LCD bueno o meter delays entre cada llamada a la rutina del LCD. espero que no tengáis muchos problemas con ella. Suerte.
Cortesía : x-robotics.
