Programación de pantalla LCD
#incluye & ltABSACC. H & gt
# include & ltINTRINS. H & gt
#Contiene "common.h"
#Definir ancho de pantalla 0x20
estructura externa Pic * punto _ Pic 1;
/************************************************ ********************************************/
#define comando _ puerto x byte[0x 8001]//Define la dirección del puerto del comando.
# define datos _ puerto x byte[0x 8000]//Define la dirección del puerto de datos.
#define CODESTATE 0x01 //Definir el bit de detección.
#Definir estado de datos 0x02
#Definir datos para leer automáticamente 0x04
#Definir datos para escribir automáticamente en 0x08
#Definir controlar dispositivo 0x20
#Definir copia de pantalla 0x40
#Definir BLINKCONTITION 0x80
/****************** ****** ********************************************** ******* *************************/
//Verificar estado
Estado de verificación de bits volátiles (dígito de verificación de uchar)
{
Estado de Uchar;
estado = COMMAND _ PORT
Interruptor (comprobar bit )
{
Estado del código de caso:
{
Si (estado y amp0x01)
Devolver 1 ;
Otro
Devuelve 0;
}
Estado de los datos del caso:
{
Si (status & amp0x02)
Devuelve 1;
Otro
Devuelve 0;
}
Lectura automática de datos del caso:
{
If (status & amp0x04)
Devuelve 1;
Otros
Devuelve 0;
}
Los datos del caso se escriben automáticamente:
{
If (status & amp0x08)
Devolución 1;
Otro
Devolución 0;
}
Responsable del caso:
{
Si (status & amp0x02)
Devuelve 1;
Otro
Devuelve 0;
}
Captura de pantalla del caso:
{
If (status & amp0x40)
Devuelve 0;
Otro
Devolver 1;
}
Condiciones de solicitud de caso:
{
Si (status& amp0x80 )
Devuelve 1;
Otros
Devuelve 0;
}
}
}
/*************************************** *** ************************************************* **** ****/
//Juzgar escritura automática
void check_auto_write(void) puede ser reentrante
{
Y (! (check _ state(escritura automática de datos)));
}
/************************ ************************************************** * **********************/
la verificación de anulación volátil _ código _ datos (anulo) puede ser reentrante
{
Y (!(check _ state(CODESTATE)));
Y (! (check _ state(DATASTATE));
}
/********************************************* * ***********************************************/
//Configuración del puntero
p>
# define Set _ cursor _ pointer 0x 001//Establece la posición del cursor.
# define SET_CG ram_POINTER 0x 02 //SET CG ram.
#Definir configuración del puntero de dirección 0x04
Voidset _ point (uchari, uchar datadat1, uchar datadat 2) //El número que se enviará al exterior debe definirse en el área de datos .
{
check_code_data().
DATA_PORT = dat 1;
check_code_data().
DATA_PORT = dat2
check_code_data().
COMMAND_PORT =(0x 20 | I);
}
/****************** ** ************************************************* * ***************************/
//Establecer modo de visualización
#Definir lógica_ o 0x00
#define logic_XOR 0x01
#define logic_and 0x02
#define TEXT_CHAR 0x04
Vaciar settings_display _mode(uchar dat)
{
check_code_data().
COMANDO _ PUERTO = (0x 80 | dat
}
/****************; ** ************************************************* *** *******************************/
//Configuración del área de visualización
#define TEXT_ADDRESS 0x00 //Establece la primera dirección del área de texto.
# define text _ width 0x 001//Establece el ancho del área de texto.
#define GRAPHIC_ADDRESS 0x02 //Establece la dirección del encabezado del área de gráficos.
#define GRAPHIC_WIDTH 0x03 //Establece el ancho del área de gráficos.
void set_display_area(uchar i, uchar dat1, uchar dat2)
{
if((i==0x01)||(i==0x03) )
dat 2 = 0;
check_code_data().
DATA_PORT = dat 1;
check_code_data().
DATA_PORT = dat2
check_code_data().
COMMAND_PORT =(0x 40 | I);
}
/****************** ** ************************************************* * *****************************/
//Configuración del interruptor de pantalla
# Definir cursor LINK 0x01
#Definir cursor en 0x02
#Definir texto en 0x04
#Definir icono gráfico 0x08
void set_display(modo de visualización uchar)
{
check_code_data().
COMANDO _ PUERTO =(modo de visualización | 0x 90
}
/***************); * ************************************************* ** ***************************/
//Configuración de la forma del cursor
/ /Parámetros 0-7
void set_cursor(uchar i)
{
check_code_data().
COMANDO _ PUERTO =(0xa 0 | I
}
/****************; ** ************************************************* *** ****************************/
//Definición automática de lectura y escritura
#Definir escritura automática 0x00
#Definir lectura automática 0x01
#Definir parada automática 0x02
void set _ autoread write(uchar I)// reentrante
{
check_code_data().
COMMAND_PORT =(0xb 0 | I);
}
/****************** ** ************************************************* * *****************************/
//Lee la definición una vez
#Definición Agregar dirección de escritura 0x00
#Definir dirección_lectura_add 0x01
#Definir dirección de escritura _sub 0x02
#Definir dirección de lectura sub 0x03
#Definir escribir dirección sin cambio 0x04
#Definir read_address_nochange 0x05
/* & void set_once_read_write(uchar i, uchar letra)
{
check_code_data().
DATA_PORT = letra
check_code_data().
COMMAND_PORT =(0xc 0 | I);
}*/
/************** ** ************************************************* * ***************************/
//Lectura de pantalla
/*void screen_read (nulo)
{
check_code_data().
COMANDO_PUERTO=0xe0
}*/
/******************** ************************************************** * ************************/
//Copia de pantalla
/*void screen_copy(no válido )
{
check_code_data().
COMANDO_PUERTO=0xe8
}*/
/******************** ************************************************** * ***********************/
//Operación de bits
//#Definir set_bit 0x08
//#Definir borrar bit 0x00
/*void bit_operation(uchar op, uchar i)
{
check_code_data() .
COMANDO _ PUERTO =(0xf 0 | op | I
}*/
/************; ************************************************** * ******************************/
/*void print_lcd(uchar str,uchar x, uchar y)
{
Dirección entera sin signo;
addr = y * 16+x;
check_code_data().
DATA_PORT = dirección
check_code_data().
DATA_PORT = dirección & gt& gt8;
check_code_data().
COMMAND_PORT = 0x24
check_code_data().
DATA_PORT = str
check_code_data().
COMANDO_PUERTO=0xc4
}*/
/******************** ************************************************** * **********************/
//Mostrar caracteres
texto vacío _ display(uchar str) //Reentrante
{
//SET _ point(SET _ ADDRESS _ POINTER, lowaddr, high addr
//set _ once _ read_write); (write_address_add, str-0x 20);
set_autoreadwrite(escritura automática);
check_auto_write().
DATA _ PORT = str-0x 20
set _ autoread write(AUTOSTOP);
}
/*** ************************************************** * **************************************/
// Cadena de visualización
void string_display(uchar data * str, uchar lowaddr, uchar high addr) // Reentrante
{
set_point(SET_ADDRESS_POINTER, lowaddr, high addr );
set_autoreadwrite (escritura automática);
while(*str!='\0')
//set _ once _read_write(write_address_add, str [I]-0x 20);
{check_auto_write().
DATA _ PORT = * str-0x 20
str++;
}
set _ autoread write(AUTOSTOP);
}
/************************************ ***** ********************************************** ****** *******/
//Mostrar cadenas en el área de código.
cadena vacía _ display _ code (uchar num, uchar code *str, uchar lowaddr, uchar high addr)//reentrante
{
武Carlos I;
set_point(SET_ADDRESS_POINTER, lowaddr, high addr);
set_autoreadwrite(escritura automática);
if (cantidad == 0)
{
mientras(*str!='\0')
{
check_auto_write().
DATA_PORT = * str-0x 20
str++;
}
}
Otros
for(I = 0;i<NUMi++)if(dirección baja F0 0x 1f # if(SCREEN _ WIDTH = " = 0x 20)" E0...haddr = " 0; dirección = 0; caddr = 0; "dirección baja = " dirección baja+2; "3f 0x 10 20 0x 00 caddr = " dirección baja; ...0x10100256 * 256 Dirección LCD {¿Cuántas palabras se muestran? Debido a que una palabra tiene 16*16 celdas, entonces para (k = "0; k & lt(num/32); k++)" datos I, j, k , haddr, addr, caddruchar highaddr) lowaddr, uchar num, uchar *str, Uinthanzi_display (uchiarvoid muestra caracteres chinos * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * DATA _ PORT = " * str-0x 20; "check_auto_write() & gt0x1e) // Nueva línea
{
lowaddr = 0x00//Dirección baja
dirección alta = addr alta+2;;//Dirección alta
}
#Otherwise
If(SCREEN_WIDTH==0x10) //Tenga cuidado de no usar #else para saltos de línea.
if(dirección baja & gt; 0x0e) //Nueva línea
{
dirección baja = 0x00//dirección baja
dirección alta = dirección alta+1;;//Dirección alta
}
#endif
for(I = 0;i<16;i++)
{
#if(SCREEN_WIDTH==0x20)
addr = caddr+32 * I;
Si (i==8)
tenía dr++;
# De lo contrario
if(SCREEN_WIDTH==0x10)
addr = caddr+16 * I;
#endif
set_point(SET_ADDRESS_POINTER, addr, haddr);
set_autoreadwrite(escritura automática);
for(j = 0; j & lt2; j++)
{
check_auto_write().
DATA _ PORT = * str
str++;
}
set _ autoread write(AUTOSTOP);
}
}
}
/************************ ***** ********************************************** ****** *******************/
//Borrar el búfer de visualización de gráficos
Gráficos no válidos ( no válido)
{
uint j;
set_point(SET_ADDRESS_POINTER, 0x00, 0x 04);
set_autoreadwrite(escritura automática);
for(j = 0;j & lt4096;j++)
{
check_auto_write().
DATA_PORT=0x00
}
set_autoread write(AUTOSTOP);
}
/************************************************ * ******************************************/
//Borrar el búfer de visualización de caracteres
void clrtext(void)
{
uint j;
set_point(SET_ADDRESS_POINTER, 0x00, 0x 30);
set_autoreadwrite(escritura automática);
for(j = 0; j & lt1024;j++)
{
check_auto_write().
DATA_PORT=0x00
}
set_autoread write(AUTOSTOP);
}
/************************************************ * ******************************************/
// Visualización de imagen
volatile void Picture _ display(Imagen * punto 1, uchar lowaddr, uchar highaddr, bit inverse)
{
uchar data I, j, laddr
Imagen*punto;
punto = punto 1;
laddr = lowaddr
CY = 0;
p>
for(I = 0;i<(punto->longitud);i++)
{
CY = 0;
Si (I)
laddr = laddr+32;
Si (CY)
dirección alta = dirección alta+1;
set_point(SET_ADDRESS_POINTER, laddr, high addr);
set_autoreadwrite(escritura automática);
for(j = 0; j<(point->width/8 ); j++ )
{
If ((laddr!= 0x 00)&&(j!=0)) //Si no hay J! =0, cuando laddr=0x20, 0x40..., la visualización es anormal.
if((laddr+j)%32==0)
{
(punto-& gt; código de imagen)=(punto-& gt; código de imagen)+(punto->ancho/8-j);
Descanso;
}
check_auto_write().
Si (! inverso)
DATA_PORT=*(punto->código de imagen);
Otro
DATA_PORT = ~ *( punto-& gt;código de imagen);
(punto->código de imagen)++;
}
establecer _ escritura de lectura automática (AUTOSTOP);
}
}
/************************ **** *********************************************** *** ***************/
//Inicializar lcd
void init_lcd(void)
{
//uint i, j;
set_display_area(TEXT_ADDRESS, 0x00, 0x 30);
set_display_area(TEXT_WIDTH, SCREEN_WIDTH, 0x 00); 128*64 y los caracteres mostrados son 8*8, el ancho de los caracteres es 16.
set_display_area(GRAPHIC_ADDRESS,0x00,0x00);
set_display_area(GRAPHIC_WIDTH, SCREEN_WIDTH,0x00);
set_display (TEXTON | GRAPHICON); | cursor en |
set_point(SET_ADDRESS_POINTER, 0x00, 0x 00);
//set_point(SET_CURSOR_POINTER, 0x4e, 0x 30);
set_display_mode(logic_OR); );
//SET _ point(SET _ ADDRESS _ POINTER, 0x1c, 0x2e);
}
Por cierto, el principio de LCD es En realidad es lo mismo, pero es más fácil de programar con la biblioteca de fuentes. En términos generales, la programación de un monitor LCD implica los siguientes pasos.
1. Estado de lectura
Leer datos
3. Estado de escritura
4.
Simplemente significa que al enviar datos a una pantalla LCD de matriz de puntos sin fuentes, necesita averiguar la ubicación de los datos y luego enviarlos.
Es fácil de entender con sólo mirar algunos ejemplos más