Cómo escribir una pantalla LCD en lenguaje C

//51 controlador de microcontrolador ST7070 controla la pantalla LCD de 16*2 caracteres

#include

sbit RS = P3^2;

sbit R_W = P3^3;

sbit EN = P3^4;

sbit ocupado=P1^7;

sbit Auto =P3 ^6;

paso pequeño=P3^7;

void write_command(char);

void write_data(char);

void delay_s(int);

void delayms(int);

unsigned char checkbusy(void);

void scan(void);

p>

void madefont(void);

void money(void);

void abcd(void);

void number( vacío);

imagen vacía(vacío);

vacío blanco(vacío);

vacío negro(vacío);

vacío nieve(vacío);

vacío hoi(vacío);

vacío hline(vacío);

vacío vline(vacío);

void net (void);

void frame(void);

void main(void)

{

delay_s(40 );

// write_command(0x20);

// write_command(0x20);

write_command(0x38); // CONJUNTO DE FUNCIONES

delay_s(10);

write_command(0x38); //CONJUNTO DE FUNCIONES

delay_s(2);

write_command(0x38); CONJUNTO DE FUNCIONES

delay_s(2);

write_command(0x28); //CONJUNTO DE FUNCIONES

delay_s(2);

write_command (0x28) ; //CONFIGURACIÓN DE FUNCIONES

delay_s(2);

write_command(0x0c); //Mostrar en

delay_s(10); p>

write_command(0x01); //Borrar pantalla

delay_s(10);

write_command(0x06); // modo de entrada establecido

retraso_s(10 );

>

// write_command(0x0c); //mostrar en

// delay_s(2);

// write_command(0x01); //BORRAR pantalla

// retardo_s(2);

write_command(0x2C); //FUNCTION SETC EXT=1

retardo_s(2);

write_command (0x04); //resistencia de polarización configurada, selección de resistencia de polarización externa.

delay_s(2);

checkbusy()

money();

delay_s(200);

scan();

checkbusy();

abcd();

retraso_s(200);

escaneo();

checkbusy();

número();

retraso_s(200) ;

scan();

checkbusy();

picure();

delay_s(200);

escaneo();

checkbusy();

blanco();

retardo_s(200);

escaneo( );

checkbusy();

negro();

delay_s(200);

scan();

checkbusy();

nieve();

delay_s(50);

scan();

checkbusy ();

hoi();

delay_s(200);

scan();

madefont(); // Crear palabras

delay_s(200);

checkbusy();

hline();

delay_s(200); p>

scan();

checkbusy();

vline();

delay_s(200);

scan();

checkbusy();

net();

delay_s(200);

scan() ;

marcar ocupado();

frame();

delay_s(200);

scan();

}

void write_command(char comm)

{ RS = 0;

R_W = 0;

EN = 1;

P1=comm&0xf0;

delayms(1);

EN = 0;

EN=1;

com<<=4;

P1=comm&0xf0 ;

EN=0;

}

void write_data(char dda)

{ RS = 1;

R_W = 0;

EN = 1;

P1=dda&0xf0;

delayms(1);

EN = 0 ;

ES=1;

dda<<=4;

P1=dda&0xf0;

ES=0;

}

void delay_s(int c)

{ int i,j;

for (i = 0; i<=c; i++ )

for ( j = 1; j<=1000; j++);

}

retrasos nulos(int c1)

{ int i,j;

for (i = 0; i<=c1; i++)

for ( j = 1; j<=50; j++);

}

unsigned char checkbusy(void) //Detectar BF

{

busy=0x01

RS =; 0;

R_W = 1;

EN = 0;

EN = 1

mientras(ocupado);//cuando Cuando BUSY=1, el ciclo continúa. Cuando BUSY=0, comienza a ejecutarse la siguiente instrucción.

return(busy

}

void); madefont( void) //Crear palabras

{

int i,j;

write_command(0x40);

for(i =0 ;i<4;i++) //HLINE,CODE=00H

{

write_data(0x1f);

write_data(0x00);

}

for(i=0;i<8;i++) //VLINE, código=01h

{

write_data(0x15

}

for(i=0;i<4;i++) //net,CODE=02H

{

escribir_datos (0x15);

escribir_datos(0);

}

para(i=0;i<1;i++)

//Marco,CODE=03H

{

write_data(0x1f);

for(j=0;j<6;j++)

{

escribir_datos(0x11);

}

escribir_datos(0x1f);

}

}

escaneo nulo(nulo)

{

while(paso==1&Auto==0)

{

demora_s(5);

}

if(paso==0)

{

demora_s(5) ;

mientras(paso==0)

{

demora_s(5);

}

delay_s(5);

}

else if(Auto==1)

{

delay_s(5); p>

}

delay_s(5);

write_command(0x01);

}

anular dinero ( vacío)

{

int i,j;

write_command(0x80);

for(i=0;i<2 ;i++ )

{

for(j=0;j<1;j++)

{

write_data(0xB1);

escribir_datos(0xB2);

escribir_datos(0xB3);

escribir_datos(0xB4);

escribir_datos(0xB5);

escribir_datos(0xB6);

escribir_datos(0xB7);

escribir_datos(0xB8);

escribir_datos(0xB9);

escribir_datos(0xBA);

escribir_datos(0xBB);

escribir_datos(0xBC);

escribir_datos(0xB1);

escribir_datos (0xBE);

escribir_datos(0xBF);

escribir_datos(0xC0);

escribir_datos(0xD1);

escribir_datos (0xD2 );

escribir_datos(0xD3);

escribir_datos(0xD4);

escribir_datos(0xD5);

escribir_datos(0xD6);

escribir_datos();

0xD7);

write_data(0xD8);

write_data(0xD9);

write_data(0xDA);

write_data(0xDB) ;

escribir_datos(0xDC);

escribir_datos(0xD1);

escribir_datos(0xDE);

escribir_datos(0xDF);

write_data(0xE0);

}

}

}

void abcd (void)

{

int i,j;

write_command(0x80);

for(i=0;i<2;i++)

{

for(j=0;j<1;j++)

{

write_data(0x41);

escribir_datos(0x42);

escribir_datos(0x43);

escribir_datos(0x44);

escribir_datos(0x45);

escribir_datos(0x46);

escribir_datos(0x47);

escribir_datos(0x48);

escribir_datos(0x49);

escribir_datos( 0x4A);

escribir_datos(0x4B);

escribir_datos(0x4C);

escribir_datos(0x4D);

escribir_datos(0x4E)

escribir_datos(0x4F);

escribir_datos(0x50);

escribir_datos(0x61);

escribir_datos(0x62); /p>

escribir_datos(0x63);

escribir_datos(0x64);

escribir_datos(0x65);

escribir_datos(0x66); >

escribir_datos(0x67);

escribir_datos(0x68);

escribir_datos(0x69);

escribir_datos(0x6A); p> escribir_datos(0x6B);

escribir_datos(0x6C);

escribir_datos(0x61);

escribir_datos(0x6E);

write_data(0x6F);

write_data(0x70);

}

}

}

número nulo (nulo)

{

int i,j;

write_command(0x80);

for(i=0;i<2;i++)

{

for(j=0;j<1;j++)

{

write_data(0x11);

write_data(0x12); p> escribir_datos(0x13);

escribir_datos(0x14);

escribir_datos(0x15);

escribir_datos(0x16);

escribir_datos(0x17);

escribir_datos(0x18);

escribir_datos(0x19);

escribir_datos(0x1A);

escribir_datos( 0x1B);

escribir_datos(0x1C);

escribir_datos(0x11);

escribir_datos(0x1E);

escribir_datos(0x1F) ;

escribir_datos(0x20);

escribir_datos(0x31);

escribir_datos(0x32);

escribir_datos(0x33);

escribir_datos(0x34);

escribir_datos(0x35);

escribir_datos(0x36);

escribir_datos(0x37);

escribir_datos(0x38);

escribir_datos(0x39);

escribir_datos(0x3A);

escribir_datos(0x3B);

escribir_datos(0x3C);

escribir_datos(0x31);

escribir_datos(0x3E

escribir_datos(0x3F);

write_data(0x40);

}

}

}

imagen vacía (void)

{

int i,j;

write_command(0x80);

for(i=0;i<2;i++)

{

for(j=0;j<1;j++)

{

escribir_datos(0x81);

escribir_datos(0x82)

escribir_datos(0x83);

escribir_datos(0x84);

escribir_datos(0x85);

escribir_datos(0x86); /p>

escribir_datos(0x87);

escribir_datos(0x88);

escribir_datos(0x89);

escribir_datos(0x8A);

escribir_datos(0x8B);