用单片机设计一个简易的密码锁，用键盘输入0~9三位数的密码.密码输入正确显示“P”约3s，并通过P3.0端口将 单片机电子密码锁设计，采用4×4键盘实现密码的输入功能，当密...

你这个问题内容量太大，不可能有谁那么多时间给你开发，我这边有个做过的类似的，代码送你了。

#include <msp430x14x.h>
#include "Delay.h"
#include "x24c02.h"
#include "LCD1602.h"

uchar LCD_ID_1[16] = {"Password: ------"};
uchar LCD_ID_2[16] = {"Old Code: ------"};
uchar LCD_ID_3[16] = {"                "};
uchar LCD_ID_4[16] = {"New Code: ------"};

#define JI_OPEN P3OUT|=BIT6
#define JI_CLOSE P3OUT&=~BIT6

uchar a=10,b=10+0x40,c=0,i=0,j=0,k=0,super=0;

uchar flag=0;

uchar table1[6]={1,2,3,4,5,6};
uchar table2[6]={0,0,0,0,0,0};
uchar table3[6]={0,0,0,0,0,0};
uchar supercode[6]={8,8,8,8,8,8};
//SCL时钟线
#define SCO_SET P1OUT|=BIT3//输出高
#define SCO_RESET P1OUT&=(~BIT3)//输出低
#define SCO_IN (P1IN&BIT3)//输出
#define SCOIN P1DIR&=(~BIT3)//设置输入
#define SCOOUT P1DIR|=BIT3//设置输出
//SDA数据线
#define SDO_SET P1OUT|=BIT2
#define SDO_RESET P1OUT&=(~BIT2)
#define SDO_IN (P1IN&BIT2)
#define SDOIN P1DIR&=(~BIT2)
#define SDOOUT P1DIR|=BIT2

void shuru(void);
void shezhi(void);
void bijiao(void);

uchar chumo_read(void)
{
  uchar i,dat;
  SCOOUT;//设置输出
  SCO_RESET;//输出低
  
  SDOOUT;
  SDO_SET;
  delay_us(93);
  SDO_RESET;
  delay_us(10);
  SDOIN;
  
  for(i=0;i<16;i++)
  {
    SCO_SET;
    delay_us(5);
    
    if(SDO_IN!=0)
    {
      dat=i+1;
    }
    
    SCO_RESET;
    delay_us(5);
  }
  delay_ms(2);
  return dat;
}   

void OPEN(void)
{
  P1OUT |= BIT4;
  P3OUT &=~BIT5;
  delay_ms(1000);delay_ms(1000);
  P3OUT &=~BIT5;
  P1OUT &=~BIT4;
}
void CLOSE(void)
{
  P3OUT |= BIT5;
  P1OUT &=~BIT4;
  delay_ms(1000);delay_ms(1000);
  P3OUT &=~BIT5;
  P1OUT &=~BIT4;
}
void main( void )
{
  //系统初始化
  WDT_Init();  //STOP WDT
  MCLK_Init(); //MCLK=8M
  Port_Init(); //CLOSE ALL PORT
  
  P3DIR |= BIT5;
  P1DIR |= BIT4;
  P3OUT &=~BIT5;
  P1OUT &=~BIT4;
  d24c_init();
  
  L1602_Init();
  L1602_string(1, 1, LCD_ID_1);
  
  P3DIR|=BIT6;
  P3DIR&=~BIT7;
  P6DIR|=BIT2;
  JI_CLOSE;
  
  delay_ms(10);
  table1[0]=d24c_read(1);
  delay_ms(20);
  table1[1]=d24c_read(2);
  delay_ms(20);
  table1[2]=d24c_read(3);
  delay_ms(20);
  table1[3]=d24c_read(4);
  delay_ms(20);
  table1[4]=d24c_read(5);
  delay_ms(20);
  table1[5]=d24c_read(6);
  delay_ms(500);
  
  while(1)
  {
    delay_ms(100);

    shuru();
    shezhi();
    bijiao();
  }
}

void shuru(void)
{
  wcmd(0x80+a+c);
  wcmd(0x0f);
  
  if((chumo_read()!=0)&&(chumo_read()<11))
  {
    delay_ms(10);
    if(chumo_read()!=0)
    {
      table2[c]=chumo_read();
      L1602_char(1,a+c+1,(chumo_read()%10)+0X30);
      c++;
      delay_ms(500);
      if(c==6)
      {
        c=0;
        L1602_string(1, 1, LCD_ID_1);
      }
    }
  }
  
  j=0;
  for(i=0;i<6;i++)
  {
    if(table1[i]!=table2[i])
    {
      j=1;
      break;
    }
  } 

  if(chumo_read()==13)
  {
    delay_ms(10);
    if(chumo_read()==13)
    {
      c=0;
      L1602_string(1, 1, LCD_ID_1);
      delay_ms(1000);
    }
  }
}

void shezhi(void)
{
  if(chumo_read()==16)
  {
    delay_ms(10);
    if(chumo_read()==16)
    {
      L1602_string(1, 1, LCD_ID_3);
      L1602_string(2, 1, LCD_ID_2);
      flag=1;
      c=0;
      delay_ms(500);
    }
  }
  while(flag==1)
  {
    wcmd(0x80+0x40+a+c);
    wcmd(0x0f);
    
      if((chumo_read()!=0)&&(chumo_read()<11))
  {
    delay_ms(10);
    if(chumo_read()!=0)
    {
      table2[c]=chumo_read();
      L1602_char(2,a+c+1,(chumo_read()%10)+0X30);
      c++;
      delay_ms(500);
      if(c==6)
      {
        c=0;
        L1602_string(2, 1, LCD_ID_2);
          super=1;
          for(i=0;i<6;i++)
          {
            if(supercode[i]!=table2[i])
            {
              super=0;
              break;
            }
          } 
      }
    }
  }
  
  k=1;
  for(i=0;i<6;i++)
  {
    if(table1[i]!=table2[i])
    {
      k=0;
      break;
    }
  } 

  if(chumo_read()==13)
  {
    delay_ms(10);
    if(chumo_read()==13)
    {
      c=0;
      L1602_string(2, 1, LCD_ID_2);
      delay_ms(1000);
    }
  }
    
  if(k==1 || super == 1)
  {
     L1602_string(2, 1, LCD_ID_4);
  }
    while(k==1 || super==1)
    {
      wcmd(0x80+0x40+a+c);
      wcmd(0x0f);

      if((chumo_read()!=0)&&(chumo_read()<11))
      {
        delay_ms(10);
        if(chumo_read()!=0)
        {
          table1[c]=chumo_read();
          L1602_char(2,a+c+1,(chumo_read()%10)+0X30);
          c++;
          if(c==6)
          {
            delay_ms(1000);
            c=0;
            flag=0;
            k=0;
            super = 0;
            d24c_write(1,table1[0]);
            delay_ms(30);
            d24c_write(2,table1[1]);
            delay_ms(30);
            d24c_write(3,table1[2]);
            delay_ms(30);
            d24c_write(4,table1[3]);
            delay_ms(30); 
            d24c_write(5,table1[4]);
            delay_ms(30);
            d24c_write(6,table1[5]);
            delay_ms(30);    
  
            L1602_string(1, 1, LCD_ID_1);
            L1602_string(2, 1, LCD_ID_3);
           }
         }
         delay_ms(400);
      }
      delay_ms(100);
      if(chumo_read()==13)
      {
        delay_ms(10);
        if(chumo_read()==13)
        {
          c=0;
          L1602_string(2, 1, LCD_ID_2);
          delay_ms(500);
        }
      }
   }
  }
}
void bijiao()
{
  if((j==0)||((P3IN&BIT7)!=0))
  {
    JI_OPEN;
    P6OUT&=~BIT2;
    OPEN();
    delay_ms(2000);
    L1602_string(1, 1, LCD_ID_1);
    for(i=0;i<6;i++)
    {
      table2[i]=0;
    }
    JI_CLOSE;
    CLOSE();
  }
  else
  {
    P6OUT|=BIT2;
  }
}

我以前写过一个程序,要是找找,还是能找到的,要比你的电路简单多了.
输出就不讲了,输出电平时间是可以设置的.
输入我讲一下,我用的是1个按键,密码输入方法类似摩尔斯码,如输入2,就是连续的按2下,如果输入8,就连续按8下,在这个按键上并一个LED,这个LED为状态显示,当密码输入正确时,LED闪一下.
如果密码都正确,输出脚输出高电平.
这个电路简单吧.

按你说的有点麻烦 不过还是可以完成的

还可以不难
懂事电子设计 Vgz

任务：用单片机实现一个简单的电子密码锁，用4×4键盘组成一个0-9数字键以及确认、取消键，用·6位7段数码~

我可以提供给你做一个，但有几个问题
1、加点后是什么意思，不是没有小数点吗，加电后？
2、用什么型号的的单片机
3、要存密码必须有存储器，24C02什么的行吗

　　#include
　　#define uint unsigned int
　　#define uchar unsigned char
　　#define KEY P3 //键盘输入端口
　　#define No_key 20 //无按键时的返回值
　　#define lcddata P2 //1602的数据输入端口
　　sbit lcden= P1^2;
　　sbit lcdrs= P1^0;
　　sbit lcdrw= P1^1;
　　sbit light= P1^3;
　　sbit light1= P1^4;
　　uchar j ; //用来统计输入 个数的全局变量
　　uchar aa; //用来在定时器中计数的 全局变量

　　uchar code table[]= " Hello!";
　　uchar code table1[]=" OK! " ;
　　uchar code table2[]="Enter please:" ;
　　uchar code key_table[16] =
　　{
　　1,2,3,10,
　　4,5,6,11,
　　7,8,9,12,
　　0,13,14,15
　　};
　　uchar password[]={2,0,1,0,9,3} ; //设定初始密码
　　uchar save[6]; //保存输入的数据
　　uchar conflag ; //确认标志
　　uchar lockflag; //锁键盘标志
　　uchar startflag; //开始标志

　　void delay(uint z); //延时子函数
　　void wright_com(uchar com); //写指令函数
　　void wright_data(uchar date) ; //写数据函数
　　void init(); //初始化
　　void display_OK(); // 显示OK
　　void delete(); //删除输入的最后一个数

　　uchar keyscan() ; //带返回值的键盘扫描程序

　　void enter_code(uchar t); //输入密码函数，把输入的数据存入数组中并在屏幕上显示相应的东西,
　　void confirm(); //确认密码对不对，把输入的数据与密码逐一对比，完全一样刚正确，
　　void succeed_an(); //输入密码成功时的 响应,
　　void fail_an(); //输入密码 失败时 响应
　　void lockkey(); //锁键盘三秒
　　void alarm(); //发出警报声
　　void reset(); //复位函数
　　void display_enter(); //显示输入
　　void main(void)
　　{
　　uchar temp;
　　init();
　　while(1)
　　{

　　if(lockflag)
　　{
　　temp=keyscan(); // 锁键期间也要进行键盘扫描
　　if(temp!=No_key) //重新记时三秒
　　{
　　aa=0; //重新在定时器中计数
　　}

　　}
　　else
　　{
　　temp=keyscan(); //反复扫描输入，等待随时输入


　　if(temp!=No_key) //有按键按下才进行下面的操作
　　{
　　if(temp==10)
　　{
　　reset();
　　startflag=1; //开始标志置位
　　}
　　if(startflag)
　　{
　　enter_code(temp); //每扫描一次键盘就要进行一次处理，保存输入的数值

　　if(temp==13) //按下确认键盘就要进行密码确认
　　{
　　confirm(); //进行确认判断
　　if(conflag) //密码确认为正确
　　{
　　succeed_an(); //密码正确，作出相应的反应
　　}
　　else
　　{
　　fail_an(); //密码错误，作相应反应
　　}
　　}

　　if(temp==14)
　　{
　　delete(); //作删除操作
　　}
　　}
　　}
　　}

　　}
　　}
　　/****** 显示enter********/
　　void display_enter()
　　{
　　uchar num;
　　wright_com(0x80);
　　for(num=0;num<13;num++)
　　{
　　wright_data(table2[num]);
　　}
　　}
　　/****** 显示OK********/
　　void display_OK()
　　{
　　uchar num;
　　wright_com(0x80);
　　for(num=0;num<13;num++)
　　{

　　wright_data(table1[num]);
　　}
　　}
　　/****** 删除最后一个********/
　　void delete()
　　{
　　wright_com(0x80+0x40+j); //确定删除对象
　　wright_data(' '); //显示空格即为删除
　　save[--j]=0; //删除后数据清零
　　wright_com(0x80+0x40+j); //为下次输入数据时写好位置，必须是在最后一个后面
　　}
　　/****** 对各种变量进行复位********/
　　void reset()
　　{
　　uchar num;
　　display_enter();
　　wright_com(0x80+0x40); //擦除屏幕上的显示
　　for(num=0;num<6;num++)
　　{
　　save[num]=0; //对输入的数值进行清零
　　wright_data(' '); //显示的是空格
　　}
　　wright_com(0x80+0x40); //下次再输入时可以又从起始位置输入
　　lockflag=0; //各种变量要清零回起始状态
　　conflag=0;
　　j=0;
　　}
　　/****** 输入密码正确进行响应********/
　　void succeed_an()
　　{


　　light=0; //灯亮
　　display_OK(); //显示成功
　　delay(1000);
　　light=1; //灯灭
　　}
　　/****** 输入密码错误进行响应********/
　　void fail_an()
　　{
　　alarm();
　　lockkey();
　　}
　　/****** 发出警报声**********/
　　void alarm() //这个以后再扩展它
　　{

　　}
　　/******锁键盘三秒************/
　　void lockkey()
　　{
　　lockflag=1;
　　}
　　/******输入密码并在屏幕上显示星号******/
　　void enter_code(uchar t)
　　{

　　if(t>=0&&t<10)
　　{

　　if(j==0)
　　{
　　wright_com(0x80+0x40) ; //第一输入时要先写入地址指令，否则无法显示
　　wright_data('*') ;
　　}
　　else
　　{
　　wright_data('*') ;//不是第一个输入则不用再写地址
　　}
　　save[j++]=t; //保存输入的数据
　　}
　　}

　　/******校对密码以确定是不是正确的**********/
　　void confirm()
　　{
　　uchar k;
　　for(k=0;k<6;k++)
　　{
　　if(password[k]!=save[k]) //对数组中的内容进行逐一比较，一旦有数据不对马上退出循环
　　{
　　break;
　　}
　　}
　　if(k==6) //要是条件退出的话说明六个数全对密码
　　{
　　conflag=1; // 进行标志密码正确
　　}

　　}


　　/******中断服务程序**********/
　　void timer0() interrupt 1
　　{

　　TH0=(65536-50000)/256;
　　TL0=(65536-50000)%256; //重装初值
　　if(lockflag)
　　{
　　aa++;
　　light1=0;
　　if(aa>=60) //三秒到了
　　{
　　aa=0; //清零可以方便下次再使用
　　light1=1; //关闭警报
　　lockflag=0; //标志清零解除键锁，方便下次使用

　　}
　　}

　　}
　　/******初始化***********/
　　void init()
　　{
　　uchar num;
　　/*****定时器初始化****/
　　TMOD=1;
　　TH0=(65536-50000)/256;
　　TL0=(65536-50000)%256;
　　ET0=1;
　　EA=1; //开启总中断
　　TR0=1;//把定时器关闭


　　/****1602初始化******/
　　lcdrw=0; //这个必须要置 零，否则无法正常显示
　　lcden=0;
　　wright_com(0x38) ; //初始化
　　wright_com(0x0c) ; //打开光标 0x0c不显示光标 0x0e光标不闪，0x0f光标闪
　　wright_com(0x01) ; //清显示
　　wright_com(0x80) ;
　　for(num=0;num<9;num++)
　　{
　　wright_data(table[num]);
　　delay(1);
　　}
　　}
　　/******1602写入指令************/
　　void wright_com(uchar com)
　　{
　　lcdrs=0;
　　lcddata=com;
　　delay(1);
　　lcden=1;
　　delay(1);
　　lcden=0;
　　}
　　/******1602写入数据***********/
　　void wright_data(uchar date)
　　{
　　lcdrs=1;
　　lcddata=date;
　　delay(1);
　　lcden=1;
　　delay(1);
　　lcden=0;
　　}
　　/******延时函数************/
　　void delay(uint z)
　　{
　　uint x,y;
　　for(x=z;x>0;x--)
　　for(y=110;y>0;y--) ;
　　}

　　/**********4x4矩阵键盘扫描函数*********/
　　uchar keyscan()
　　{
　　uchar temp,num=No_key; //num的初值要为无键盘按下时的返回值
　　/*********扫描第一行****************/
　　KEY=0xfe;
　　temp=KEY;
　　temp=temp&0xf0; //读出高四位
　　while(temp!=0xf0)
　　{

　　delay(5); //延时消抖
　　temp=KEY;
　　temp=temp&0xf0;
　　while(temp!=0xf0) //确认确实有按键按下
　　{

　　temp=KEY;
　　switch(temp) //根据这八个电平可以确定是哪个按键按下
　　{
　　case 0xee:num=1;
　　break;
　　case 0xde:num=2;
　　break;
　　case 0xbe:num=3;
　　break;
　　case 0x7e:num=10;
　　break;
　　}
　　while(temp!=0xf0) //等待松手
　　{
　　temp=KEY;
　　temp=temp&0xf0;
　　}

　　}
　　}
　　/*********扫描第二行***************/
　　KEY=0xfd;
　　temp=KEY;
　　temp=temp&0xf0;
　　while(temp!=0xf0)
　　{
　　delay(5);
　　temp=KEY;
　　temp=temp&0xf0;
　　while(temp!=0xf0)
　　{

　　temp=KEY;
　　switch(temp)
　　{
　　case 0xed:num=4;
　　break;
　　case 0xdd:num=5;
　　break;
　　case 0xbd:num=6;
　　break;
　　case 0x7d:num=11;
　　break;
　　}
　　while(temp!=0xf0)
　　{
　　temp=KEY;
　　temp=temp&0xf0;
　　}

　　}
　　}
　　/*********扫描第三行****************/
　　KEY=0xfb;
　　temp=KEY;
　　temp=temp&0xf0;
　　while(temp!=0xf0)
　　{
　　delay(5);
　　temp=KEY;
　　temp=temp&0xf0;
　　while(temp!=0xf0)
　　{
　　temp=KEY;
　　switch(temp)
　　{
　　case 0xeb:num=7;
　　break;
　　case 0xdb:num=8 ;
　　break;
　　case 0xbb:num=9;
　　break;
　　case 0x7b:num=12;
　　break;
　　}
　　while(temp!=0xf0)
　　{
　　temp=KEY;
　　temp=temp&0xf0;
　　}

　　}
　　}
　　/*********扫描第四行****************/
　　KEY=0xf7;
　　temp=KEY;
　　temp=temp&0xf0;
　　while(temp!=0xf0)
　　{
　　delay(5);
　　temp=KEY;
　　temp=temp&0xf0;
　　while(temp!=0xf0)
　　{
　　temp=KEY;
　　switch(temp)
　　{
　　case 0xe7:num=0;
　　break;
　　case 0xd7:num=13;
　　break;
　　case 0xb7:num=14;
　　break;
　　case 0x77:num=15;
　　break;
　　}
　　while(temp!=0xf0)
　　{
　　temp=KEY;
　　temp=temp&0xf0;
　　}

　　}
　　}

　　return num;
　　}

基于51单片机的密码锁程序
答：基于51单片机的密码锁程序,三个子程序:4*4的矩阵键盘、I2C芯片、液晶屏最好是用KeiluVision2编写的。。要求是4*4的矩阵键盘,其中10个是数字键,还包括一个确认、一个更改密码、一个... 基于51单片机的密码锁程序,三个子程序:4*4的矩阵键盘、I2C芯片、液晶屏最好是用Keil uVision2编写的。。要求是4*4的...

求帮忙编一段 汇编语言,基于51单片机的密码锁,要求在下面。真心求帮忙啊...
答：;根据题目要求，本设计操作如下：;;1.初始状态数码管全显示0，然后按键盘输入4个数字，输入完成后按键盘的 ;“F”键，将输入的4为密码与原始密码1234比较，如果正确相同则P0.0口接的继电器 ;工作灯亮。如果错误不相同，则恢复初始状态全显示0.;2.输入过程中，led会逐位‘-’，直到密码输入完成 ;...

用单片机设计一个简易的密码锁,用键盘输入0~9三位数的密码.密码输入正 ...
答：你这个问题内容量太大，不可能有谁那么多时间给你开发，我这边有个做过的类似的，代码送你了。include <msp430x14x.h>#include "Delay.h"#include "x24c02.h"#include "LCD1602.h"uchar LCD_ID_1[16] = {"Password: ---"};uchar LCD_ID_2[16] = {"Old Code: ---"};uchar LCD...

求高手,求帮助,c51单片机课程设计(单片机密码锁)我的邮箱530490031@qq.c...
答：用单片机控制的窖码锁常使用汇编语言编写程序，显示器多数用。而本文所介绍的电子密犸锁使用移植性及可读性强的高级语言C语言编写，便于修改和增减功能蚤同时采用显示清楚数码管，功率消耗小而且寿命长的 液晶显示器，显示更加直观，使用更加方便。从经济实用的角度出发，采用STC89C52单片机设计出一种具有密码...

求51单片机C语言编的简易密码锁程序
答：sbit key1=P0^0;sbit key2=P0^1;sbit key3=P0^2;sbit key4=P0^3;sbit wela=P2^0;//位锁存端 define SMG P1 sbit LED=P3^0;//低电平亮 uchar code table[]={0x8d,0x86};//共阳数码管 P,E uchar chushi_mima[]={2,1,3};uchar shuru_mima[3];uchar index;//控制输入密码的...

用单片机C语言控制6位密码锁。要求有一个清除键和确认键,密码输错了...
答：用单片机C语言控制6位密码锁。要求有一个清除键和确认键,密码输错了会有报警音。请高手帮助了 程序简单易懂,能实现这些功能就行,我做个毕业设计... 程序简单易懂,能实现这些功能就行,我做个毕业设计 展开  我来答 4个回答 #热议# 该不该让孩子很早学习人情世故? gnjiao 2009-04-04 知道答主 ...

求51单片机C语言编的密码锁程序
答：matrix=m*(n+1);/*为避免乘积重复,n+1*/ for(k=0;k<16;k++){if (matrix==KeyCode[k]) return(k);} //KeyCode：见前 return(16);} //if loop }//j loop }//i loop }//Key end //用Switch...case语句得到键盘值*/ uchar Key1(void){uchar temp,m,n,i,j,matrix;P1=0x...

求助:哪位有用51单片机设计的电子密码锁的毕业设计啊,急需,小女子不胜...
答：单片机控制的密码锁设计。单片机p1引脚矩阵按键，分别代表数字键0-9，确定键，取消键，重新上档键和修改密码键。单片机从p2口输出3个信号，分别为1个已开锁指示信号和密码错误信号指示，1个黄色报警灯，分别用发光二极管L1-L2指示，还有蜂鸣器报警。LCD1602用来显示，掉电保护模块：存储电路主要作用是存储...

跪求!单片机密码锁设计
答：我有两个，均ProteUS仿真调试通过 有偿提供，第一个是帮别的毕业设计做的 第二个没有使用过。; 密码长度自由可设；; 密码设定必须加密存储；; 三次错码输入报警提示，且10分钟内不接受再次输入；; 具有超级密码功能，长度或格式特殊。其二：51单片机，4x4小键盘和1622LCD做一个简易密码锁 悬赏分：0...

基于单片机电子密码锁设计~
答：以前我在网上找到过密码锁的源代码，你可以找找。给你一个思路吧，先用7个端口做成3*4矩阵键盘，0~9 * #共12个键，另外用4个端口做红灯输出、绿灯输出、报警输出、开锁输出。*键为取消键，#键为确认键，密码可存入单片机的ROM中（不能改密码）或存入24CXX串行E2PROM（可改密码）。键盘处理方法...