Uso del microcontrolador 51 y at24c02 para almacenar contraseñas en un bloqueo de contraseña, cómo escribir un programa de comparación de contraseñas, lenguaje C
#include
#include
#define uchar unsigned char
#define uint unsigned int
#define No_key 20 //Definir el valor predeterminado cuando no hay clave
#define KEY P3 //Definir el puerto de entrada de clave
uchar m=0 ; //Definir tiempos de eliminación de contraseñas //Ingresar nuevas contraseñas
#define lcddata P0 //Definir entrada de datos LCD
uchar data save[6]; ingrese la contraseña Guardar matriz
sbit lcden= P3^4; //Defina el puerto de habilitación de cristal líquido
sbit lcdrs= P3^5; //Puerto de conversión de señal de comando de datos LCD
sbit dula=P2^6; //Definir selección de segmento
sbit wei=P2^7; //Definir selección de bits
unsigned char yinyue=0; p>
contraseña de uchar[]={2,2,2,2,2,2}; //Definir contraseña inicial
tabla de códigos de uchar[]= " ¡Hola! "; >
uchar code table1[]=" ¡OK! ";
uchar code table2[]="Ingrese por favor";
uchar code table3[]="palabra incorrecta " ;
tabla de códigos uchar4[]="¡palabra antigua! ";
tabla de códigos uchar5[]="¡palabra nueva! ";
uchar incorrecto=0 ;
sbit Beep = P2^3;
/*void delayms(unsigned char a) //Subrutina de retardo de milisegundos
{
while(--a); //Usa while(--a) en lugar de while(a--); ¡Puedes compilarlo y ver el resultado del ensamblaje! >void ydelay (unsigned char m) //Retraso de frecuencia de control
{
unsigned i=3*m
while(-- i); /p>
}
unsigned char yn=0; //n es la variable constante de ritmo
unsigned char yp,ym //m es la variable constante de frecuencia
código de carácter sin firmar music_tab[] ={
0x18, 0x30, 0x1C, 0x10, //El formato es: constante de frecuencia, constante de ritmo, constante de frecuencia, constante de ritmo,
p>
0x20, 0x40, 0x1C, 0x10,
0x1
8, 0x10, 0x20, 0x10,
0x1C, 0x10, 0x18,
0x1C, 0x20, 0x20, 0x20,
0x1C, 0x20, 0x18. , 0x20,
0x20, 0x80, 0xFF , 0x20,
0x30, 0x1C, 0x10 , 0x18,
0x20, 0x15, 0x20 , 0x1C,
p>
0x20, 0x20, 0x20, 0x26,
0x40, 0x20, 0x20, 0x2B,
0x20, 0x26, 0x20, 0x20,
0x20, 0x30, 0x80, 0xFF,
0x20, 0x20, 0x1C, 0x10,
0x18, 0x10, 0x20, 0x20,
0x26, 0x20, 0x2B, 0x20,
0x30, 0x20, 0x2B, 0x40,
0x20, 0x20, 0x1C, 0x10,
0x18, 0x10, 0x20. , 0x20,
p>
0x26, 0x20, 0x2B , 0x20,
0x30, 0x20, 0x2B , 0x40,
0x20, 0x30, 0x1C , 0x10,
0x18, 0x20, 0x15, 0x20,
0x1C, 0x20, 0x20, 0x20,
0x26, 0x40, 0x20, 0x20,
0x2B, 0x20, 0x26, 0x20,
0x20, 0x20, 0x30, 0x80,
0x20, 0x30, 0x1C, 0x10,
0x20, 0x10, 0x1C, 0x10,
p>
0x20, 0x20, 0x26, 0x20,
0x2B, 0x20, 0x30, 0x20,
0x2B, 0x40, 0x20, 0x15,
0x1F, 0x05, 0x20, 0x10,
0x1C, 0x10, 0x20, 0x20,
0x26, 0x20, 0x2B. , 0x20,
0x30, 0x20, 0x2B , 0x40,
0x20, 0x30, 0x1C , 0x10,
0x18, 0x20, 0x15 , 0x20,
0x1C, 0x20, 0x20, 0x20,
p>
0x26, 0x40, 0x20, 0x20,
0x2B, 0x20, 0x26, 0x20,
0x20, 0x20, 0x30, 0x30,
0x20, 0x30, 0x1C, 0x10,
0x18, 0x40, 0x1C, 0x20,
0x20, 0x20, 0x26, 0x40,
0x13, 0x60, 0x18, 0x20,
0x15, 0
x40, 0x13, 0x40,
0x18, 0x80, 0x00
}
*/
uchar temp,flag=0, conflag;//Defina temp como indicador de detección de teclado como indicador de contraseña
uchar k,xiugai; //k es el indicador de recuento de contraseñas
uchar j=0; número de entradas de usuario Estadísticas
sbit a=P1^0; //Final del flash
char liang=1; //Cantidad de control del recuento de flash
void display_enter ();
void reset();
void enter_code(uchar t);
uchar cambiar contraseña ();
void confirm ();
void delete() ;
void change_code(uchar t);
void delay(uint z) //Función de retardo, el valor de z es este El número de ms de retraso de la función, como delay(200); el retraso es de aproximadamente 200 ms.
{ //delay(500) el retraso es de aproximadamente 500 ms.
uint x,y
for(x=z;x>0;x--)
for(y=110;y>0;y--) ;
}
/*void InitTimer0(void) //Temporizador de flash
{
TMOD = 0x01;
TH0 = 0x0D8;
TL0 = 0x0F0;
EA = 1;
ET0 = 1;
TR0 = 1 ;
}
void InitTimer1(void)
{
TMOD = 0x10;
TH1 = 0x0FF ;
TL1 = 0x9C;
EA = 1;
ET1 = 1;
TR1 = 1;
}
void shanguang()
{
a=0;
retraso(500);
a=1;
retraso(500);
} */
/******1602 comando de escritura***** ************ */
void wright_com(uchar com)
{
lcdrs=0;
lcddata=com;
retraso(1);
lcden=1;
retraso(1);
lcden=0;
}
/******1602Escribir datos**********/
void wright_data(uchar fecha)
{
lcdrs
=1;
lcddata=fecha;
retraso(1);
lcden=1;
retraso(1);
lcden=0;
}
/************Función de escaneo de teclado matricial 4x4******* *** /
uchar keyscan()
{
uchar temp,num=No_key //El valor inicial de num debe ser el valor de retorno cuando no se presiona ningún teclado
/************Escanea la primera línea******************/
KEY=0xfe;
temp=KEY;
temp=temp&0xf0 //Lee los cuatro bits superiores
while(temp!=0xf0)
{
delay(10); //Retraso en el rebote
temp=KEY;
temp=temp&0xf0;
while(temp !=0xf0) //Confirma que efectivamente hay un botón presionado
{
temp=KEY;
switch(temp) / /Según estos ocho niveles Puede determinar qué tecla se presionó
{
case 0xee:num=1;
break;
caso 0xde:num= 2;
ruptura;
caso 0xbe:num=3;
ruptura;
caso 0x7e:num =10;
break;
}
while(temp!=0xf0) //Esperando soltarme
{
temp= CLAVE;
temp=temp&0xf0;
}
}
}
/***** ****Escanea la segunda línea***************/
KEY=0xfd;
temp =CLAVE;
temp=temp&0xf0;
mientras(temp!=0xf0)
{
demora(15);
temp= CLAVE;
temp=temp&0xf0;
while(temp!=0xf0)
{
temp =TECLA;
cambiar(temp)
{
caso 0xed:num=4;
romper;
caso 0xdd:num= 5;
ruptura;
caso 0xbd:num=6;
ruptura;
caso 0x7d :num=11;
descanso;
}
mientras(temp!=0xf0)
{
temp=CLAVE;
temp=temp&0xf0;
}
}
}
/************Escanea la tercera línea******************/
KEY=0xfb;
temp =CLAVE;
temp=temp&0xf0;
mientras(temp!=0xf0)
{
retraso( 10);
temp=KEY;
temp=temp&0xf0;
while(temp!=0xf0)
{
temp =TECLA;
cambiar(temp)
{
case 0xeb:num=7;
break;
caso 0xdb:num=8;
ruptura;
caso 0xbb:num=9;
ruptura;
caso 0x7b :num=12;
descanso;
}
while(temp!=0xf0)
{
temp=CLAVE;
temp=temp&0xf0;
}
}
}
/** *******Escanea la cuarta línea******************/
KEY=0xf7;
temp=CLAVE;
temp=temp&0xf0;
mientras(temp!=0xf0)
{
retraso(10) );
temp=KEY;
temp=temp&0xf0;
while(temp!=0xf0)
{
temp=CLAVE;
cambiar(temp)
{
caso 0xe7:num=0;
romper;
caso 0xd7:num=13;
ruptura;
caso 0xb7:num=14;
ruptura;
caso 0x77:num= 15;
descanso;
}
mientras(temp!=0xf0)
{
temp= CLAVE;
temp=temp&0xf0;
}
}
}
devolver num;
}
void display_OK()
{
uchar num;
wright_com( 0x80);
for(num=0;num<12;num++)
{
wright_data(table1[num]);
}
}
void display_fired()
{
uchar num;
wright_com(0x80 );
for(núm=
0;num<12;num++)
{
wright_data(table3[num]);
incorrecto++;
if(incorrecto ==2)
{
Beep=0;
while(1) //Realizar escaneo del teclado
{
temp=keyscan();
if(temp!=No_key)//Si no es un valor nulo
{ if(temp==11) // ¿Es una contraseña? Eliminar clave
{
eliminar();
}
enter_code(temp); contraseña
if(temp==12) //Si es una clave de confirmación
{
confirm();//Compare la contraseña para determinar si es correcta
if(conflag==1) //La contraseña es correcta
{
Beep=1;}}}}
}
}
}
void display_hello()
{
uchar num;
wright_com(0x80);
for(num=0;num<12;num++)
{
wright_data(table[num] );
}
}
void display_old()
{
uchar num;
wright_com(0x80);
for(num=0;num<12;num++)
{
wright_data(table4[num]) ;
}
}
void display_new()
{
uchar num;
wright_com(0x80);
for(num=0;num<12;num++)
{
wright_data(table5[num]);
}
}
void init()
{
uchar num;
/****1602 inicialización** ****/
dula=0;
wei=0;//Esto debe establecerse en cero, de lo contrario no puede se mostrará normalmente
lcden=0
wright_com(0x38); //Inicialización
wright_com(0x0c); //Abrir el cursor 0x0c sin mostrar el cursor 0x0e el cursor no parpadea, el cursor 0x0f parpadea
wright_com(0x01); //Borrar la pantalla
wright_com(0x01); //Borrar la pantalla
wright_com); (0x80);
for(num=0; num<7;num++)
{
wright_data(tabla[num]);
p>
retraso(1);
}
}
void main()
{
//InitTimer0();
init();
while(1)
{
temp=keyscan() ;
if(temp!=No_key)
{
if(temp==10) //Determine si es una clave de entrada de contraseña y una re -entrar clave
p>
{
reset();
flag=1;
}
if(flag==1)
{
enter_code(temp);
}
if(temp== 11) //¿Es una clave de eliminación de contraseña?
{
eliminar();
}
if(temp==12 ) //Determinar si es una clave de confirmación de contraseña
{
confirm();
if(conflag==1)
{
display_OK(); //Desbloquear //Si presionar la tecla de cambio de contraseña
}
if(conflag==0) //Mostrar error de contraseña
{
display_fired();
}
}
if(temp==15 )
{
cambiar contraseña();
}
}
}
}
void reset()
{
uchar num;
wright_com(0x01) ;
display_enter();
wright_com( 0x80x40); //Borrar la visualización en la pantalla
for(num=0;num<6;num++)
{
save[num ]=0; //Borrar el valor ingresado
wright_data(' '); //Se muestran los espacios
}
wright_com(0x80 +0x40); //La próxima vez que ingreses, puedes ingresar desde la posición inicial nuevamente //Varias variables deben borrarse al estado inicial
flag= 0;
conflag= 0; //Gran error que los bits de bandera no están separados
j=0;
}
void enter_code(uchar t)
{
if(t>=0&&t<
10)
{
if(j==0)
{
wright_com(0x80x40); //Primero Cuándo; Al ingresar, primero debe escribir el comando de dirección; de lo contrario, no se podrá mostrar
wright_data('*') ;
}
else
{
wright_data('*') ;//Si no es la primera entrada, no es necesario volver a escribir la dirección
}
save[j++]=t; // Guarda los datos ingresados
}
}
void confirm()
{
uchar k;
for(k=0;k<6;k++)
{
if(contraseña[k]! =save[k]) //matriz de pares Compara los contenidos uno por uno y sale del ciclo inmediatamente si hay algún error en los datos
{
break;
}
}
if(k==6) //Si la condición existe, significa que los seis números son correctos para la contraseña
{
conflag=1; // Marcar que la contraseña es correcta
}
}
/****** Eliminar el último ********/
void eliminar ()
{ if(j>0)
{
wright_com(0x80x4j-1); //Confirmar para eliminar el objeto
wright_data(' '); //Mostrar espacios significa eliminación
save[--j ]=0;
//Los datos se borran después de la eliminación
wright_com(0x80x4j); //Escribe la posición para la próxima vez que ingreses datos, debe ser después del último
}
}
void Timer0Interrupt(void) interrupción 1
{ TR0=0;
if(P1==0x8f)
{
a=0;
TR0 = 1; //Apaga el temporizador 1
}
}
/*** *** Mostrar ingresar************/
void display_enter()
{
uchar num;
wright_com(0x80);
for(num=0;num<12; num++)
{
wright_data(table2[num]);
}
}
uchar cambiar contraseña () //Definir la función de cambio de contraseña
{
display_old(); / /Mostrar palabra antigua
while(1) //Realizar escaneo de teclado
{ if(P3==0x1f) //Módulo de detección inalámbrica
{
P1=0x00;
}
si(P3==
0x2f)
{
P1=0x00;
Pitido=0;}
temp=keyscan();
if(temp!=No_key)//Si no es un valor nulo
{ if(temp==11) //¿Es una clave de eliminación de contraseña?
{
eliminar();
}
enter_code(temp); //Guardar la contraseña
if(temp==12); ) //Si es la clave de confirmación
{
confirm();// Compara la contraseña para determinar si es correcta
if(conflag== 1) //La contraseña es correcta
{
display_new();//Mostrar nueva contraseña
for(m=0;m<6;m++ )
eliminar() ;
k=0;
while(1) //Escanear el teclado
{ temp=keyscan ();
if( temp!=No_key) //Si no está vacío
if(temp==11) //Si es la clave de eliminación de contraseña
{
eliminar();
}
change_code(temp); //Guardar la clave en contraseña
if( temp>=0&&temp<10)
k++;
if(k==6)
{ display_OK();//Mostrar modificación exitosa
for(m=0;m<6 ;m++)
eliminar();
retrasar(500);
display_hello();
bandera=0;
p>devuelve 0;
}
}
}
else
display_fired() ;
devuelve 0;
}
}
}
}
void change_code(uchar t)
{
if(t>=0&&t<10)
{
if(j== 0)
{
wright_com(0x80x40); //El comando de dirección debe escribirse primero al ingresar. , de lo contrario no se podrá mostrar
wright_data(' *') ;
}
else
{
wright_data('*') ;//Si no es la primera entrada No es necesario escribir la dirección
}
contraseña[j++]=t; //Guardar los datos ingresados
}
}
/*void Timer1Interrupt(void ) interrumpir 3
{
TH0=0xd8
TL0=0xef
yn--;
Si no hay una estructura iic, simplemente agrégala tú mismo