Programa de bloqueo de contraseña basado en 51 microcontroladores

Compilado con STC52, el siguiente es un programa en C. La depuración se realizó correctamente. Eche un vistazo al programa usted mismo...

#include

#include

#define uchar unsigned char

#define uint unsigned int

#define LCD_data P0

sbit SDA= P3^5;

sbit SCL=P3^4;//Configuración del puerto de control 24C08

sbit LCD_RS = P3^3 //Entrada de selección de registro;

sbit LCD_RW = P3^6; //Control de lectura/escritura del cristal líquido

sbit LCD_EN = P3^7; //Control de habilitación del cristal líquido

sbit LCD_PSB = P3^2; // Control del modo serie/paralelo

sbit FM=P2^4;//Puerto de control del zumbador

sbit RS=P2^5;

sbit T_CLK = P2^0; //Pin de línea de reloj de tiempo real//

sbit T_IO = P2^1; //Pin de línea de datos de reloj de tiempo real//

sbit T_RST = P2^ 2; //Pin de línea de reinicio del reloj en tiempo real//

sbit ds=P2^3;

sbit EN=P2^6;

bit ZZ= P2^7;

bit FZ=P3^1;

bit ACC0=ACC^0;

bit ACC7 =ACC^7;

uint temp1,s_temp; //Definir variables enteras

float f_temp; //Definir variables de punto flotante

uchar time[] =" : : ";

uchar día[]=" 20 / / ( ) ";

uchar temp0[]=" Temperatura: . grados";

uchar num,num1,flag, count,a,b;

uchar unlock_i;//indicador de descifrado

uchar t[4];

uchar t1[4];

void delay_ms(uint z)//retraso largo

{

uint x,y;

para (x=z;x> 0;x--)

for(y=110;y>0;y--);

}

void delay() //retraso corto, alrededor de 5us

{

;

}

void reshi()

{

if(RS==1)

{ unlock_i=1;

}

else

{

unlock_i=0;

}

}

uchar código mima[]={'0', '1','2','3','4','5','6','7','8','9','0','*'};

void lcd_xieping0(uchar x,uchar y,uchar fecha);

void lcd_xieping(u

char x,uchar y,uchar *str);

//****************************** ******************************

// Pantalla de inicio

// ************************************************* ***** **

void kjxs()

{

uint i,j;

lcd_xieping(0,0 ,"*** *************");

lcd_xieping(1,0," Bienvenido");

lcd_xieping(2, 0," ¡Contraseña bloquea el sistema! ");

lcd_xieping(3,0,"******************");

delay_ms(4000) ;

lcd_xieping(0,0,"Inicializando el sistema");

lcd_xieping(1,0,"Espere por favor...");

lcd_xieping (2,0,"————————");

lcd_xieping(3,0," ");

for(j= 3;j>0 ;j--)

{

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

{

lcd_xieping(3 ,i,"*");

delay_ms(250);

}

lcd_xieping(3,0," ");

}

}

//*************************** ***** *******************************

// 12864 mostrados

//**** ******************************************* ********** **

void write_cmd(uchar cmd)

{

LCD_RS = 0;

LCD_RW = 0;

LCD_EN = 0;

P0 = cmd;

delay_ms(5);

LCD_EN = 1;

delay_ms(5 );

LCD_EN = 0;

}

void write_dat(uchar dat)

{

LCD_RS = 1;

LCD_RW = 0;

LCD_EN = 0;

P0 = dat;

delay_ms(5);

LCD_EN = 1;

delay_ms(5);

LCD_EN = 0;

}

void lcd_xieping0( uchar x,uchar y,uchar fecha)

{

interruptor(x)

{

caso 0: write_cmd(0x8 y); break;

caso 1: write_cmd(0x9y);

caso 2: write_cmd(0x);

88+y); descanso;

caso 3: write_cmd(0x98+y); descanso;

}

write_dat(fecha);

}

void lcd_xieping(uchar x,uchar y,uchar *str)

{

interruptor(x)

{

caso 0: write_cmd(0x8y); break;

caso 1: write_cmd(0x9y);

caso 2: write_cmd (0x88+y); romper;

caso 3: write_cmd(0x98+y);

}

mientras (*str)

{

write_dat(*str);

str++;

}

}

void lcd_init()

{

LCD_PSB = 1; //Modo de puerto paralelo

write_cmd(0x30); //Operación de comando básico

delay_ms(5);

write_cmd(0x0C); //Mostrar cursor encendido y apagado

delay_ms(5);

write_cmd(0x01); / /Borrar contenido de la pantalla LCD

delay_ms(5);

}

//*************** * *************************************************

//Función de escaneo de teclado

//***************************** *** ****************************

ucharkeyscan1() //Función de escaneo del teclado matricial

{

uchar temp;

while(!num)

{P1=0xfe; //asignación

temp =P1; //Leer datos

temp=temp&0xf0; //Operación AND

if(temp!=0xf0) //Sentencia

{< / p>

delay_ms(2); //Retraso en el rebote

temp=P1; //Leer datos

temp=temp&0xf0;

if (temp!=0xf0)

{

switch(temp) //Selección de múltiples ramas

{

case 0x70:num = 1;break; //Separar

caso 0xb0:num=2;break;

caso 0xd0:num=3;break;

caso 0xe0: num=4;romper;

}

mientras(temp!=0xf0)

{

temp=P1;

temp=temp&0xf0;

}//Esperar a que se suelte la llave

}

}

P1= 0xfd; // Asignación

temp=P1; //Leer datos

temp=temp&0xf0;

mp!=0xf0) //Sentencia

{

delay_ms(2); //Retraso del rebote

temp=P1 //Leer datos

temp=P1; p>

temp=temp&0xf0;

if(temp!=0xf0)

{

switch(temp) //Selección de múltiples ramas

{

caso 0x70:num=5;break; //saltar

caso 0xb0:num=6;break;

caso 0xd0 :num=7;romper;

caso 0xe0:num=8;romper;

}

mientras(temp!=0xf0)

{

temp=P1;

temp=temp&0xf0;

}//Esperando a que se suelte la llave

}

}

P1=0xfb; //Asignación

temp=P1; //Leer datos

temp=temp&0xf0; /Operación AND

if(temp!=0xf0) //Sentencia

{

delay_ms(2); //Retraso en el rebote

> temp=P1; //Leer datos

temp=temp&0xf0;

if(temp!=0xf0)

{

switch (temp) //Selección de múltiples ramas

{

case 0x70:num=9;break //Saltar

case 0xb0:num=10 ;romper ;

caso 0xd0:num=11;romper;

caso 0xe0:num=12;romper;

}

while( temp!=0xf0)

{

temp=P1;

temp=temp&0xf0;

}//Esperando clave lanzamiento

}

}

}

return(num); //valor de retorno

}

uchar teclascan2()

{

uchar temp;

mientras(!num1)

{P1= 0xf7; / /Asignación

temp=P1; //Leer datos

temp=temp&0xf0; //Operación AND

if(temp!=0xf0) //Sentencia

{

delay_ms(2); //Retraso del rebote

temp=P1 //Leer datos

temp =temp&0xf0;

if(temp!=0xf0)

{

switch(temp) //Selección de múltiples ramas

{

case 0x70:num1=1;break; //salir

case 0xb0:num1=2;break;

case 0xd0:num1=3; romper;

caso 0xe0:num1=4;romper;

}

mientras(temp!=0xf0)

{

temp=P1;

temp=temp&0xf0;

}//Esperando a que se suelte la llave

}

}

}

return(num1);

}

//****************************** ** ************************************

// Motor CC

//****************************************** ****** ****************

void dianjiZZ()

{

ES= 1;

ZZ=1;

FZ=0;

}

void dianjiFZ()

{

EN=1;

ZZ=0;

FZ=1;

}

nulo dianji_stop()

{

ES=0;

}

//*********** ************* ************************************* ********

// EPPROM

//************************ ************ *******************************

void start() //Señal de inicio

{

SDA=1;

retraso();

SCL=1;

retraso();

SDA=0;

retraso();

}

parada nula( ) //Señal de parada

{

SDA=0;

retraso();

SCL=1;

retraso();

SDA=1 ;

retraso();

}

respuestas nulas() // Señal de respuesta

{

uchar i;

SCL=1;

retraso();

mientras ((SDA==1)&&(i<250))

i++;

SCL=0;

retraso();

}

void writebyte(uchar date) / /Escribe un byte

{

uchar i,temp;

temp= fecha;

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

{

temp=temp<<1;

SCL=0;

retraso();

SDA=CY;

retraso();

SCL=1;

retraso();

}

SCL=0;

retraso();

SDA=1; //Liberar el bus

delay();

}

uchar readbyte() //Leer un byte

{

uchar i,k;

SCL=0;

retraso();

SDA=1;

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

{

SCL=1;

retraso();

k =(k<<1)|S

DA;

SCL=0;

retraso();

}

retraso();

return(k);

}

void write(uchar add,uchar date) //Escribe un byte en una dirección

{

inicio();

writebyte(0xa0);

respons();

writebyte(agregar);

respuesta ( );

writebyte(fecha);

respons();

stop();

}

uchar read(uchar add) //Leer un byte en una dirección

{

start();

writebyte(0xa0);

respons();

writebyte(agregar);

respons();

iniciar();

writebyte(0xa1);

respons();

b=readbyte();

respons();

stop() ;

return(b);

}

//********************* *******************************************

/ / Función de hora y fecha

//************************************ * *************************

void v_WTInputByte(uchar ucDa)

{

uchar i;

ACC= ucDa;

for(i=8; i>0; i--)

{

T_IO = ACC0; //*Equivalente a RRC en ensamblaje

T_CLK = 1;

T_CLK = 0;

ACC =ACC>> 1;

}

}

uchar uc_RTOutputByte(void)

{

uchar i; p>

for(i=8; i>0; i--)

{

ACC = ACC>>1 //* Equivalente a RRC en ensamblaje

ACC7 = T_IO;

T_CLK = 1;

T_CLK = 0;

}

regresar ( ACC);

}

void v_W1302(uchar ucAddr, uchar ucDa)

{

T_RST = 0;

T_CLK = 0;

T_RST = 1;

v_WTInputByte(ucAddr); /* Dirección, comando*/

v_WTInputByte(ucDa); / * Escribe datos de 1Byte*/

T_CLK = 1;

T_RST =0;

}

uchar uc_R1302(uchar ucAddr)

{

uchar ucDa;

T_RST =

0;

T_CLK = 0;

T_RST = 1;

v_WTInputByte(ucAddr); // Dirección, comando //

ucDa = uc_RTOutputByte(); // Leer datos de 1Byte //

T_CLK = 1;

T_RST =0;

return(ucDa);

}

void Init1302(void)

{

v_W1302(0x8e,0x00); //Control de escritura WP=0

v_W1302(0x80,0x80);

v_W1302(0x90,0xa9);

v_W1302(0x80,0x00); //Segundos

v_W1302 ( 0x82,0x24); //Minuto

v_W1302(0x84,0x12); //Hora

v_W1302(0x86,0x29); //Día

v_W1302 (0x88,0x10); //Mes

v_W1302(0x8a,0x05); //Semana

v_W1302(0x8c,0x10); //Año/

v_W1302(0x8e,0x80);

}

void donetime(void)

{

uchar d;

d=uc_R1302(0x87);

día[10]=(d&0x0f)+48;

día[9]=((d>>4) &0x03 )+48;

d=uc_R1302(0x89);

día[7]=(d&0x0f)+48;

día[6]=( ( d>>4)&0x01)+48;

d=uc_R1302(0x8b);

día[13]=(d&0x07)+48;

d =uc_R1302(0x8d);

día[4]=(d&0x0f)+48;

día[3]=(d>>4)+48;

d=uc_R1302(0x81);

tiempo[15]=(d&0x0f)+48;

tiempo[14]=(d>>4)+48;

d=uc_R1302(0x83);

tiempo[12]=(d&0x0f)+48;

tiempo[11]=(d>>4 )+48 ;

d=uc_R1302(0x85);

tiempo[9]=(d&0x0f)+48;

tiempo[8]=(d >>4 )+48;

}

//*************************** ********** **********************************

//Función de detección de temperatura

//************************************ ************ ****************

void dsreset(void) //18B20 reinicio, función de inicialización

{

uint i;

ds=0;

i=103;

mientras(i&

gt;0)i--;

ds=1;

i=4;

mientras(i>0)i--;

}

bit tempreadbit(void) //Leer función de 1 bit

{

uint i;

bit dat ;

ds=0;i++; //i++ actúa como un retraso

ds=1;i++;i++;

dat=ds; leer datos

i=8; while(i>0)i--;

return (dat);

}

uchar tempread(void) //Leer 1 byte

{

uchar i,j,dat;

dat=0;

for(i=1;i<=8;i++)

{

j=tempreadbit();

dat=(j<<7) | (dat>>1); //El bit más bajo de los datos leídos está al frente, de modo que exactamente un byte está en DAT

}

return(dat);< / p>

}

void tempwritebyte(uchar dat) //Escribe un byte de datos en 18B20

{

uint i;

uchar j;

bit testb;

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

{

testb=dat&0x01; //Juzga si el último dígito es 1 o 0

dat=dat>>1;

if(testb) //Escribe 1

{

ds=0;

i++;i++;

ds=1;

i=8;mientras( i> 0)i--;

}

else

{

ds=0; //Escribe 0

i=8; while(i>0)i--;

ds=1;

i++;i++;

}

}

}

void tempchange(void) //DS18B20 comienza a obtener la temperatura y convertirla

{

dsreset() ; //Inicialización, cada operación en 18B20 debe inicializarse primero

delay_ms(1);

tempwritebyte(0xcc); // La escritura omite el comando de lectura de ROM.

tempwritebyte(0x44); //Escribe la instrucción de conversión de temperatura

}

void get_temp() //Lee los datos de temperatura almacenados en el registro

{

uchar a,b;

dsreset(); //Inicialización

delay_ms(1);

tempwritebyte(0xcc); //Escribir omite el comando de lectura de ROM

tempwritebyte(0xbe); //Escribir el comando de lectura

a=tempread(); bits

b=tempread(); //Leer los 8 bits superiores

temp1=b;

temp1<<=8; combinados en 1 palabra

t

emp1=temp1|a;

f_temp=temp1*0.0625; //La temperatura en el registro tiene una resolución de 12 bits, bit 0,0625°

}

/ / ************************************************* ** ************

//Función de descifrado

//****************** ** **********************************************

desbloqueo nulo()

{

uchar in,i;

if(num==0)

{

lcd_xieping(0,0,"**Sistema de bloqueo de contraseña** ");

lcd_xieping(1,0,"——————————") ;

lcd_xieping(2,0," Ingrese la contraseña: ");

lcd_xieping(3,0," ");

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

{

t1[i]=keyscan1();

lcd_xieping(3,i,"*");

num=0;

}//Ingresar contraseña

}

in=keyscan1();

if(in ==12)//bit de indicador de clave determinado

{

in=0;

num=0;

si ((t1[0]==t[0])&&(t1[1]==t[1])&&(t1[2]==t[2])&&(t1[3]= =t[3 ]))

{

flag=1;//Indicador de éxito o error de descifrado

//unlock_i=1;

a=0;//Marca de tecla de función

lcd_xieping(0,0,"**Sistema de bloqueo de contraseña** ");

lcd_xieping(1,0," ———— ————————");

lcd_xieping(2,0,"¡La contraseña es correcta!");

lcd_xieping(3,0, "Su identidad ha sido confirmada" );

delay_ms(1500);

lcd_xieping(1,0,"————————");

lcd_xieping(2, 0,"Función que desbloqueo");

lcd_xieping(3,0,"Cambio contraseña");

}

else

{

flag=0;

cuenta++;

if(cuenta==3)

{

count=0;

num=1;

lcd_xieping(1,0,"——————————") ;

lcd_xieping(2,0,"Tu oportunidad se ha agotado");

lcd_xieping(3,0,"Lo siento **no puedo entrar");

FM=0;

delay_ms(1000);

FM=1;

}

}

}

}

//****************************** ****** **********************

*******

//Modificar función de contraseña

//************************ *******************************************

nulo xiugaimima( )

{ uchar i,j,l,im,ib;

uchar t2[4];

uchar t3[4];

num=0;

lcd_xieping(1,0,"————————");

lcd_xieping(2,0,"Por favor ingrese una nueva contraseña: ");

lcd_xieping(3,0," ");

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

{

t2[i]=keyscan1();

lcd_xieping0(3,i,mima[num]);

num=0;

}

im=keyscan1();

if(im==12)//im, in, ib, son las mismas banderas clave

{

im=0;

num=0;

lcd_xieping(1,0,"————————");

lcd_xieping(2,0,"Ingrese la nueva contraseña nuevamente");

lcd_xieping(3,0," ");

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

{

t3[i]=keyscan1();

lcd_xieping0(3,i,mima[ núm]);

núm=0;

}

}

ib=keyscan1();

si(ib= =12)

{

ib=0;

num=0;

si(t2[0 ]==t3[ 0]&&t2[1]==t3[1]&&t2[2]==t3[2]&&t2[3]==t3[3])

{

t[ 0]=t3[0];

t[1]=t3[1];

t[2]=t3[2];

t [3]=t3[3];

lcd_xieping(1,0,"————————");

lcd_xieping(2, 0", ¡Felicidades! ");

lcd_xieping(3,0," La contraseña se cambió correctamente");

flag=0;

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

{

l=j+1;

escribir(l,t[j]);

delay_ms( 10);

}//24C08 escribir datos

delay_ms(1000);

}

else

{

lcd_xieping(2,0,"La contraseña ingresada dos veces es diferente");

lcd_xieping(3,0,"Error en la modificación de la contraseña");

flag=1;

delay_ms(500);

}

}

}

/ / ************************************************* ** ************

//Función de visualización

//*************************************** *************************

void xianshi()

{

donetime();

tempchange();

get_temp();

s_temp=f_temp*100;

temp0[7 ]=(s_temp%1000/1000)+48;

temp0[8]=(s_temp%1000/100)+48;

temp0[10]=(s_temp%100/10 )+48;

temp0[11]=(s_temp%10)+48;

lcd_xieping(0,0,"**Sistema de bloqueo de contraseña** "); p>

lcd_xieping(1,0,temp0);

lcd_xieping(2,0,día);

lcd_xieping(3,0,hora);

núm=0;

}

//************************ ** ************************************

//Función de desbloqueo< /p >

//****************************************** ** *******************

void kaisuo()

{

uchar i;< /p >

lcd_xieping(2,0,"Desbloqueando...");

lcd_xieping(3,0,"——Espera pacientemente——");

for( i=3;i>0;i--)

{

FM=0;

delay_ms(100);

FM=1;

delay_ms(100);

flag=0;

}

dianjiZZ();

delay_ms(10000);

dianji_stop();

lcd_xieping(2,0,"—Fin del proceso de desbloqueo—");

lcd_xieping( 3,0,"Por favor, abre la puerta");

delay_ms(5000);

dianjiFZ();

delay_ms(10000);

dianji_stop();

flag=0;

}

//*********** ******* ******************************************* *****

//Función principal

//*************************** ********* *******************************

void main()

{

uchar m;

unlock_i=1;

lcd_init(); //Inicialización de LCD

//Init1302();

kjxs(); //Iniciar pantalla

for(m=0;m<4;m++)

{ <

/p>

t[m]=read(m+1);

delay_ms(10);

}//24C08 leer datos

mientras(1)

{

reshi();

if(!unlock_i)

{

desbloquear();//Función de descifrado

}

else

{

xianshi();//Hora, fecha, temperatura función de visualización

}

if(flag==1)

{

num1=0;

a=keyscan2();

if(a==1)

{

kaisuo();//Función de desbloqueo

}

if(a==2)

{

xiugaimima();//Modificar la función de contraseña

}

}

}

}