四位密码锁*电子密码锁的设计

最新推荐文章于 2025-03-16 20:30:47 发布
最新推荐文章于 2025-03-16 20:30:47 发布
阅读量2.7w 收藏 213
点赞数 36
分类专栏： verilog 文章标签： 单片机 vivado verilog 电子 密码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qinglingLS/article/details/74278856
版权

下面的报告里说了要求和实现的操作，那肯定按照要求的去操作，去写的呀，所以操作方法和实验报告里写的一样，

另外单片机是要自己写constarint的，如果不自己写，没人知道你单片机哪个口，哪个按钮绑的啥名称，S1还是S5，还是啥的，你该按板子的哪都是按照这个按钮的绑定关系constarint来看的，把变量和按钮绑定，然后要把逻辑转化为二进制文件，烧录在单片机上才行。

会的人已经通过代码的注释和自己的理解搞好了作业，

 

2019.5.27 更新 ：
上面两个网址是仿真文件和工程（好像烧在板子上有问题）
所以我传了下面这个文件
下面是pdf和工程文件打包，也就是博客公布代码的内容和上面的实验报告pdf的打包。
https://download.csdn.net/download/qinglingls/11209189

四位密码锁大实验：

功能：

题目：电子密码锁的设计  

 [设计要求]

（1）设计一个开锁密码至少为4位数字（或更多）的密码锁。

（2）当开锁按扭开关（可设置8位或更多，其中只有4位有效，其余位为虚设）的输入代码等于所设密码时启动开锁控制电路，并且用绿灯亮、红灯灭表示开锁状态。

（3）从第一个按扭触动后的5秒内若未能将锁打开，则电路自动复位并发出报警信号，同时用绿灯灭、红灯亮表示关锁状态。 

附加功能：

（1）可以设置密码，通过设置密码按钮SP（S4）设置，且可以重新设置新密码。任何情况下按SP后输入都可以设置密码。

（2）五秒计时采用倒计时显示在开发板的七段数码管上。五秒后发出警报（绿灯亮）。

（3）能记录按键输入密码的次数（0-9）。

（4）能清零输入次数而不改变密码。

 

其中num0_1到num0_7用来控制七段电子数码管。

num1_1到num1_7用来控制计时器timer的电子数码管显示。

 

代码：

module index(input clk,
	input pw_1, input pw_2, input pw_3, input pw_4, 
	input pw_5, input pw_6, input pw_7, input pw_8,
	input sti_0, input sti_1, input sti_2,
	output x, output y,
	output reg red, output reg green, output reg alarm,
    output reg num0_1, output reg num0_2, output reg num0_3, output reg num0_4,
    output reg num0_5, output reg num0_6, output reg num0_7, output reg num0_8, 
    output reg num1_1, output reg num1_2, output reg num1_3, output reg num1_4,
    output reg num1_5, output reg num1_6, output reg num1_7, output reg num1_8
	);
	/*
	 * clk : clock
	 * pw  : password
	 * sti : stimulation
	 * red/green : output LED
	 * num: nixie
	 *
	 */
    reg ctrl;
    reg cc;
	assign x = 1;
	assign y = 1;
    initial begin
        cc <= 1'b0;
        alarm <= 1'b0;
        ctrl <= 1'b0;
        red <= 1'b1;
        green <= 1'b0;
        num0_1 <= 1'b1;
        num0_2 <= 1'b1;
        num0_3 <= 1'b1;
        num0_4 <= 1'b1;
        num0_5 <= 1'b1;
        num0_6 <= 1'b1;
        num0_8 <= 1'b1;
        num1_1 <= 1'b1;
        num1_2 <= 1'b0;
        num1_3 <= 1'b1;
        num1_4 <= 1'b1;
        num1_5 <= 1'b0;
        num1_6 <= 1'b1;
        num1_7 <= 1'b1;
    end
    // CLK 分频
	reg CLK;
	parameter N = 20000000;
	reg [31:0]ip;
	reg [31:0]ipr;

	always @(posedge clk) begin
        if(ip < N/2) begin
            ip <= ip + 1;
        end
        else begin
            CLK <= ~CLK;
            ip <= 36'b0;
        end
    end
    
    // 设置密码
	reg str_0, str_1, str_2, str_3;
    reg in_0, in_1, in_2, in_3;
    reg in__; reg vtrl;
    integer count = 0;

    // 计时器
    integer timer = 5;
    always @(posedge CLK) begin
        if(sti_2 == 1'b1) begin
            ctrl <= 1'b1;
        end
        in__ <= sti_1;
        case(count)
            0: begin
                num0_1 <= 1'b1;
                num0_2 <= 1'b1;
                num0_3 <= 1'b1;
                num0_4 <= 1'b1;
                num0_5 <= 1'b1;
                num0_6 <= 1'b1;
                num0_7 <= 1'b0;
            end
            1: begin
                num0_1 <= 1'b0;
                num0_2 <= 1'b1;
                num0_3 <= 1'b1;
                num0_4 <= 1'b0;;
                num0_5 <= 1'b0;
                num0_6 <= 1'b0;
                num0_7 <= 1'b0;
            end
            2: begin
                num0_1 <= 1'b1;
                num0_2 <= 1'b1;
                num0_3 <= 1'b0;
                num0_4 <= 1'b1;
                num0_5 <= 1'b1;
                num0_6 <= 1'b0;
                num0_7 <= 1'b1;
            end
            3: begin
                num0_1 <= 1'b1;
                num0_2 <= 1'b1;
                num0_3 <= 1'b1;
                num0_4 <= 1'b1;
                num0_5 <= 1'b0;
                num0_6 <= 1'b0;
                num0_7 <= 1'b1;
            end
            4: begin
                num0_1 <= 1'b0;
                num0_2 <= 1'b1;
                num0_3 <= 1'b1;
                num0_4 <= 1'b0;
                num0_5 <= 1'b0;
                num0_6 <= 1'b1;
                num0_7 <= 1'b1;
            end
            5: begin
                num0_1 <= 1'b1;
                num0_2 <= 1'b0;
                num0_3 <= 1'b1;
                num0_4 <= 1'b1;
                num0_5 <= 1'b0;
                num0_6 <= 1'b1;
                num0_7 <= 1'b1;
            end
            6: begin
                num0_1 <= 1'b1;
                num0_2 <= 1'b0;
                num0_3 <= 1'b1;
                num0_4 <= 1'b1;
                num0_5 <= 1'b1;
                num0_6 <= 1'b1;
                num0_7 <= 1'b1;
            end
            7: begin
                num0_1 <= 1'b1;
                num0_2 <= 1'b1;
                num0_3 <= 1'b1;
                num0_4 <= 1'b0;
                num0_5 <= 1'b0;
                num0_6 <= 1'b0;
                num0_7 <= 1'b0;
            end
            8: begin
                num0_1 <= 1'b1;
                num0_2 <= 1'b1;
                num0_3 <= 1'b1;
                num0_4 <= 1'b1;
                num0_5 <= 1'b1;
                num0_6 <= 1'b1;
                num0_7 <= 1'b1;
            end
            9: begin
                num0_1 <= 1'b1;
                num0_2 <= 1'b1;
                num0_3 <= 1'b1;
                num0_4 <= 1'b1;
                num0_5 <= 1'b0;
                num0_6 <= 1'b1;
                num0_7 <= 1'b1;
            end
            endcase
        if(sti_2 == 1'b1) begin
                in_0 <= pw_5;
                in_1 <= pw_6;
                in_2 <= pw_7;
                in_3 <= pw_8;
                if(pw_1 == 1'b1 && in_0 == str_0 && in_1 == str_1 && in_2 == str_2 && in_3 == str_3) begin
                if(cc == 1'b0) begin
                    count <= count;
                    cc <= 1'b1;
                end    
                else begin
                    count <= count + 1;
                end
                    green <= 1'b1;
                    red <= 1'b0;
                    alarm <= 1'b0;
                end else if(pw_1 == 1'b1 && (in_0 != str_0 || in_1 != str_1 || in_2 != str_2 || in_3 != str_3)) begin
                    if(cc == 1'b0) begin
                        count <= count;
                        cc <= 1'b1;
                    end else begin
                        count <= count +1 ;
                    end
                end else if(pw_1 == 1'b0) begin
                    if(in_0 == str_0 && in_1 == str_1 && in_2 == str_2 && in_3 == str_3) begin
                    if(cc == 1'b0) begin
                        count <= count;
                        cc <= 1'b1;
                    end else begin 
                        count <= count +1;
                    end
                        green <= 1'b1;
                        red <= 1'b0;
                        alarm <= 1'b0;
                    end
                    count <= count;
                end
                if(count == 9) begin
                    alarm <= 1'b1;
                    red <= 1'b1;
                    green <= 1'b0;
                end
        end
        if(pw_1 == 1'b1) begin
            case(timer)
            0: begin
               num1_1 <= 1'b1;
               num1_2 <= 1'b1;
               num1_3 <= 1'b1;
               num1_4 <= 1'b1;
               num1_5 <= 1'b1;
               num1_6 <= 1'b1;
               num1_7 <= 1'b0;
            end
            1: begin
               num1_1 <= 1'b0;
               num1_2 <= 1'b1;
               num1_3 <= 1'b1;
               num1_4 <= 1'b0;
               num1_5 <= 1'b0;
               num1_6 <= 1'b0;
               num1_7 <= 1'b0;
            end
            2: begin
               num1_1 <= 1'b1;
               num1_2 <= 1'b1;
               num1_3 <= 1'b0;
               num1_4 <= 1'b1;
               num1_5 <= 1'b1;
               num1_6 <= 1'b0;
               num1_7 <= 1'b1;
            end
            3: begin
               num1_1 <= 1'b1;
               num1_2 <= 1'b1;
               num1_3 <= 1'b1;
               num1_4 <= 1'b1;
               num1_5 <= 1'b0;
               num1_6 <= 1'b0;
               num1_7 <= 1'b1;
            end
            4: begin
               num1_1 <= 1'b0;
               num1_2 <= 1'b1;
               num1_3 <= 1'b1;
               num1_4 <= 1'b0;
               num1_5 <= 1'b0;
               num1_6 <= 1'b1;
               num1_7 <= 1'b1;
            end
            5: begin
               num1_1 <= 1'b1;
               num1_2 <= 1'b0;
               num1_3 <= 1'b1;
               num1_4 <= 1'b1;
               num1_5 <= 1'b0;
               num1_6 <= 1'b1;
               num1_7 <= 1'b1;
            end
            endcase
            if(in_0 == str_0 && in_1 == str_1 && in_2 == str_2 && in_3 == str_3) begin
                timer <= timer;
                red <= 1'b0;
                green <= 1'b1;
            end else if(ipr < 5) begin
                timer <= timer;
                red <= 1'b1;
                green <= 1'b0;
                ipr <= ipr + 1;
            end else if(ipr == 5 && ctrl == 1'b1) begin
                timer <= timer - 1;
                red <= 1'b1;
                green <= 1'b0;
                ipr <= 0;
            end
            if(timer == 0) begin
                red <= 1'b1;
                green <= 1'b0;
                alarm <= 1'b1;
            end
        end
        else begin
            timer <= 5;
        end
        if(in__ == 1'b1) begin
                timer <= 5;
                in_0 <= 0;
                in_1 <= 0;
                in_2 <= 0;
                in_3 <= 0;
                count <= 4'b0000;
                ctrl = 1'b0;
                green <= 1'b0;
                cc <= 1'b0;
                alarm <= 1'b0;
                red <= 1'b1;
                num0_1 <= 1'b1;
                num0_2 <= 1'b1;
                num0_3 <= 1'b1;
                num0_4 <= 1'b1;
                num0_5 <= 1'b1;
                num0_6 <= 1'b1;
                num0_7 <= 1'b0;
                num1_1 <= 1'b1;
                num1_2 <= 1'b0;
                num1_3 <= 1'b1;
                num1_4 <= 1'b1;
                num1_5 <= 1'b0;
                num1_6 <= 1'b1;
                num1_7 <= 1'b1;
        end
        if(sti_0 == 1'b1) begin
            str_0 <= pw_5;
                str_1 <= pw_6;
                str_2 <= pw_7;
                str_3 <= pw_8;
        end
    end
endmodule

 

 

 

管脚绑定：

set_property IOSTANDARD LVCMOS33 [get_ports alarm]
set_property IOSTANDARD LVCMOS33 [get_ports clk]
set_property IOSTANDARD LVCMOS33 [get_ports green]
set_property IOSTANDARD LVCMOS33 [get_ports num0_1]
set_property IOSTANDARD LVCMOS33 [get_ports num0_2]
set_property IOSTANDARD LVCMOS33 [get_ports num0_3]
set_property IOSTANDARD LVCMOS33 [get_ports num0_4]
set_property IOSTANDARD LVCMOS33 [get_ports num0_5]
set_property IOSTANDARD LVCMOS33 [get_ports num0_6]
set_property IOSTANDARD LVCMOS33 [get_ports num0_7]
set_property IOSTANDARD LVCMOS33 [get_ports num0_8]
set_property IOSTANDARD LVCMOS33 [get_ports num1_1]
set_property IOSTANDARD LVCMOS33 [get_ports num1_3]
set_property IOSTANDARD LVCMOS33 [get_ports num1_2]
set_property IOSTANDARD LVCMOS33 [get_ports num1_4]
set_property IOSTANDARD LVCMOS33 [get_ports num1_5]
set_property IOSTANDARD LVCMOS33 [get_ports pw_1]
set_property IOSTANDARD LVCMOS33 [get_ports num1_7]
set_property IOSTANDARD LVCMOS33 [get_ports num1_6]
set_property IOSTANDARD LVCMOS33 [get_ports num1_8]
set_property IOSTANDARD LVCMOS33 [get_ports pw_2]
set_property IOSTANDARD LVCMOS33 [get_ports pw_3]
set_property IOSTANDARD LVCMOS33 [get_ports pw_4]
set_property IOSTANDARD LVCMOS33 [get_ports sti_2]
set_property IOSTANDARD LVCMOS33 [get_ports sti_1]
set_property IOSTANDARD LVCMOS33 [get_ports red]
set_property IOSTANDARD LVCMOS33 [get_ports pw_8]
set_property IOSTANDARD LVCMOS33 [get_ports sti_0]
set_property IOSTANDARD LVCMOS33 [get_ports pw_6]
set_property IOSTANDARD LVCMOS33 [get_ports pw_7]
set_property IOSTANDARD LVCMOS33 [get_ports pw_5]
set_property PACKAGE_PIN K1 [get_ports alarm]
set_property PACKAGE_PIN H6 [get_ports green]
set_property PACKAGE_PIN H5 [get_ports red]
set_property PACKAGE_PIN B4 [get_ports num0_1]
set_property PACKAGE_PIN A4 [get_ports num0_2]
set_property PACKAGE_PIN A3 [get_ports num0_3]
set_property PACKAGE_PIN B1 [get_ports num0_4]
set_property PACKAGE_PIN A1 [get_ports num0_5]
set_property PACKAGE_PIN B3 [get_ports num0_6]
set_property PACKAGE_PIN B2 [get_ports num0_7]
set_property PACKAGE_PIN D5 [get_ports num0_8]
set_property PACKAGE_PIN D4 [get_ports num1_1]
set_property PACKAGE_PIN E3 [get_ports num1_2]
set_property PACKAGE_PIN D3 [get_ports num1_3]
set_property PACKAGE_PIN F4 [get_ports num1_4]
set_property PACKAGE_PIN F3 [get_ports num1_5]
set_property PACKAGE_PIN E2 [get_ports num1_6]
set_property PACKAGE_PIN D2 [get_ports num1_7]
set_property PACKAGE_PIN H2 [get_ports num1_8]
set_property PACKAGE_PIN P5 [get_ports pw_1]
set_property PACKAGE_PIN P4 [get_ports pw_2]
set_property PACKAGE_PIN P3 [get_ports pw_3]
set_property PACKAGE_PIN P2 [get_ports pw_4]
set_property PACKAGE_PIN R2 [get_ports pw_5]
set_property PACKAGE_PIN M4 [get_ports pw_6]
set_property PACKAGE_PIN N4 [get_ports pw_7]
set_property PACKAGE_PIN R1 [get_ports pw_8]
set_property PACKAGE_PIN U4 [get_ports sti_0]
set_property PACKAGE_PIN R17 [get_ports sti_1]
set_property PACKAGE_PIN R15 [get_ports sti_2]

set_property PACKAGE_PIN P17 [get_ports clk]

set_property IOSTANDARD LVCMOS33 [get_ports x]
set_property IOSTANDARD LVCMOS33 [get_ports y]
set_property PACKAGE_PIN G2 [get_ports x]
set_property PACKAGE_PIN G6 [get_ports y]

 

四位数字密码锁
qq_44008834的博客
11-20 2万+
四位数字密码锁 设计要求 设计一个保险箱用的4位数字密码锁，该锁有规定的地址代码A、B、C、D 4个输入端和一个开箱钥匙孔信号E的输入端，锁的密码由实验者自编。当用钥匙开箱时，如果输入的4位密码正确，则保险箱被打开；否则，电路将发出警报（可用点亮发光二极管表示）。 具体要求： 1）讨论该问题的总体解决思路，画出系统原理框图; 2）阐述即将采用的电路分析和设计原理； 3）列出真值表，并验证是否正确；...
数字电路密码锁的设计
07-21
主要是根据设计一个8位串行数字锁，并验证其操作。具体要求如下： （1） 开锁代码为8位二进制数，当输入代码的位数和位置与锁内给定的密码一致，且按规定程序开锁时，方可开锁，并点亮开锁指示灯LT。否则，系统进入“错误”状态，并发出报警信号。 （2） 开锁程序由设计者确定，并要求锁内给定的密码是可调的，且预置方便，保密性好； （3） 串行数字锁的报警方式是点亮指示灯LF，并使喇叭鸣叫来报警，报警动作响1min，停10s后在重复出现，指导按下复位开关，报警才停止。此时，数字锁自动进入等待下一次开锁的状态； （4） 报警器可以兼作门铃用，门铃响的时间通常为7~10s。
基于51单片机密码锁—六位密码LCD1602显示
2401_82402501的博客
06-26 877
具体功能： 1.密码为六位数字，有键按下，LCD1602就会显示出字符 “*”； 2.当用户键入正确密码后，再按确认键，便会开锁； 3.数字与数字之间输入的间隔时间为最长30秒； 4.当用户键入错误密码时，系统就会报警，由扬声器发出报警声，连续三次错误就会被锁定；
基于FPGA的密码锁设计
最新发布
weixin_51641330的博客
03-16 297
密码门有一个六位超级密码230419，输入后可以用户重置并且设置四位开锁密码，用于设置新的开锁密码时，需要连续输入两次并按#确认，两次必须相同，否则设置失败。开锁时，需要输入4位正确密码后，按#号键确定，密码锁可以打开，注意这里只要最后按#键前4位正确即可，密码门打开后30秒回到初始态。对于"输入密码——判定密码——开锁/死锁"部分功能，划分一个状态机S。分别检测第二次输入的密码是否与寄存器中的密码相同，如果相同，进入。对于"输入超级密码——重设密码"功能，划分一个状态机T。以上各状态中，超级密码出错。
四位密码锁设计与FPGA实现
weixin_30205153的博客
09-12 2889
本文还有配套的精品资源，点击获取 简介：四位密码锁是一种电子安全装置，利用EDA和FPGA技术设计实现，广泛应用于个人物品保护和简易安全系统。本项目包括密码锁工作原理、输入输出设备、密码比较逻辑、错误处理机制以及FPGA配置和测试。通过设计文档和工程实践，学生和工程师可以学习并掌握电子系统设计与硬件编程的完整流程，从而在电子工程领域获得实际操作经验。 1. 四位密...
用单片机设计的4位密码锁
07-01
目 录 摘要..........................................（03） 关键字........................................（03） 1 前言..........................................（04） 2 系统设计......................................（04） 2.1 电子密码锁的工作原理......................（04） 2.2 系统硬件组成..............................（04） 2.3 矩阵键盘扫面工作原理......................（05） 2.4 LED数码管动态显示原理.....................（05） 2.5 电子密码锁系统硬件设计..... ..............（06） 2.6 电子密码锁系统软件设计....... ............（07） 3 设计体会与结论................................（07） 4附录...........................................（08） 5参考文献.......................................（13） 摘要 电子密码锁是一种通过密码输入来控制电路或是芯片工作，从而控制机械开关的闭合，完成开锁、闭锁任务的电子产品。它的种类很多，有简易的电路产品，也有基于芯片的性价比较高的产品。现在应用较广的电子密码锁是以芯片为核心，通过编程来实现的。其性能和安全性已大大超过了机械锁，特点如下： 1．保密性好,编码量多,远远大于弹子锁。随机开锁成功率几乎为零。 2．密码可变。 用户可以经常更改密码，防止密码被盗，同时也可以避免因人员的更替而使锁的密级下降。 3．误码输入保护。当输入密码多次错误时，报警系统自动启动。 4. 电子密码锁操作简单易行，一学即会。 关键字；单片机 LED数码管 矩阵键盘 密码锁 Abstract Electronic Code Lock is a password input through the control circuit, or chip, thus controlling the closed mechanical switch to complete the lock, closed the task of electronic products. It is of many types, have a simple circuit products, but also the higher cost chip-based products. Now the widely used electronic code lock is a chip at the core, achieved through programming. Performance and safety have greatly exceeded the mechanical lock, the following features: 1. Privacy is good, coding quantity is far greater than the spring lock. Random unlocking success rate is almost zero. 2. Password variable. Users can always change the password, to prevent password theft, but also avoids the lock because of staff turnover Er Shi and drawing down. 3. Error input protection. When you enter your password wrong several times, the alarm system started automatically. 4. E-lock operation is simple, a school that will. Keywords; MCU LED digital tube matrix keypad lock 1 前言 随着人们生活水平的提高，如何实现家庭防盗这一问题也变的尤其的突出，传统的机械锁由于其构造的简单，被撬的事件屡见不鲜，电子锁由于其保密性高，使用灵活性好，安全系数高，受到了广大用户的亲呢。 设计本课题时构思了两种方案：一种是用以AT89s51为核心的单片机控制方案；另一种是用以74LS112双JK触发器构成的数字逻辑电路控制方案。考虑到数字电路方案原理过于简单，而且不能满足现在的安全需求，所以本文采用前一种方案。 2 系统设计 2.1电子密码锁的工作原理 电子密码锁是以51系列单片机(AT89C51)为核心，配以相应硬件电路，完成密码的识别和显示、驱动电磁执行器并检测其驱动电流值。 单片机接收键入的代码，并与存贮在EEPROM中的密码进行比较，如果密码正确，则驱动电磁执行器开锁；如果密码不正确，则允许操作人员重新输入密码，单片机将每次开锁操作和此时电磁执行器的驱动电流值作为状态信息发送给智能监控器，同时将接收来自传感器接口的报警信息也发送给智能监控器，作为智能化分析的依据。 2.2系统硬件组成 如图（1）所示，系统采用单片机ATC89C51作为控制的核心，完成系统的控制操作。单片机核心接受来自键盘扫面电路的道德键值，判断是数字键还是操作键，并送相应的处理程序。单片机提供动态扫描电路的显示码和位选信号，使动态显示电路正常工作。 键盘扫面电路采用4*4键盘，编号0~9做为数字键“0~9”，编号14做为关锁操作功能键，编号15做为确定功能键。编号13为修改密码键，编号12作为电子锁报警后的解锁键，编号11为清除显示屏键。 动态扫描电路采用4块LED数码管，利用人眼的延迟效应通过合理的软件设计使显示电路显示数字。 供电采用5V直流电压电源 2.3矩阵键盘扫描工作原理 矩阵式键盘又成为行列式键盘，是将I/O线的一部分作为行线，另一部分作为列线，按键设置在行线和列线的交叉点上，如图（）所示。这种设计减少键盘与单片机I/O接线的数目。只需要N个行线和M个列线就可以实现N*M个键的操作。 行扫描法识别键值的原理 （1） 将第0 行变为低电平，其余行为高电平，输出编码为1110.然后读取列的电平，判别第0行是否有键按下。在第0行上若有键按下，则相应的列被拉低为低电平，则表示第0行和此列相交的位置上有键按下，进而判别哪一列有键按下。若没有任一条列线为低电平，则说明0行上无键按下。 （2） 用此方法扫描第1行，第2行，第3行，判断是哪个键按下。 由此指出，按键的位置码比不等于按键的实际定义键值，因此还需要进行转换。 2.4 LED数码管动态显示原理 将所有的位选线并联在一起，由一个8位I/O口控制，实现各位的分时选通。如图（）所示。 2.5电子密码锁系统硬件设计 键盘部分 如图（）所示，采用行列式键盘，P1口作为与行列式键盘的接口。低四位做为行选线，高四位作为列选线。采用逐行扫描的方法完成。 LED动态显示部分 采用7SEG-MPX4-CC 八段数码管，总共有四个八段数码管，共阴极的方法，未选信号为低电平有效。数据接口与P2相连，P2.0~P2.7对应a~dp。未选信号与P3相连，P3.0~P3.3对应4~1. 仿真电灯一端与P0.0相连，另一端与5V的直流电源相连。 2.6电子密码锁系统软件设计 软件是系统的核心，控制硬件的工作。对于单片机的开发，可以采用C语言，也可以采用汇编语言。本次设计中，开发了两套软件分别使用C语言和汇编语言。从可读性来讲C语言相对要好一点。从简洁性来说汇编要好一点。详细代码参见附录。流程图参见附录图（9） 软件分析： 以C语言为例。系统的参数传递采用全局变量的形式 全局变量有： uchar output[4]; uchar input[4]; uchar led[16]={0x3f,0x06,0x5B,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x40,0x00}; uchar f0=1; uchar pass[4]={4,3,2,1}; sbit p0_0=P0^0; 数组output用于存储用于数码管输出的码值，input用于存储按键的键值led用于查表，存储数码管的对应编码，f0为密码配对标志，为1表示密码正确，否责密码不正确，pass用于存放密码，p0_0为P0.0口。 采用C语言与汇编混合编程，C作为主函数调用汇编子程序scan（），通过寄存器传递参数。 主要函数为scan（），完成对键盘的扫描并返回扫描的键值。Sodesw（），完成从键值到显示数码管码值的转换。display（），完成动态显示数码管。cmp （），完成输入密码与系统密码的比较，正确则开锁，错误不开。clean（），完成对输入的密码的清除。 各部分的工作，如流程图所示，图（） 3.体会与结论 4.附录 方案一：C程序中有一个小错误，但是是致命的。作为学习只用，请你找出来。若是找不到，请联系红狐狸，zhaowei153@126.com。但是方案二的汇编实现是可以用的。 c语言代码： //mimasuo.c #include #define uchar unsigned char #define uint unsigned int extern uchar scan(void); uchar output[4]; uchar input[4]; uchar led[16]={0x3f,0x06,0x5B,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x40,0x00}; uchar f0=0; uchar pass[4]={4,3,2,1}; uchar toppass[4]={ 8,8,6,6}; sbit p0_0=P0^0; sbit p0_1=P0^1; sbit p0_2=P0^2; sbit p0_3=P0^3; void codesw(void) { int i; for(i=0;i<4;i++) { output[i]=led[input[i]]; } } void display(void) { char i; char k,j; uchar select; codesw(); select=0xfe; for(i=0;i<4;i++) { P3=select; P2=output[i]; for(k=0;k<=70;k++) { for(j=0;j<=10;j++); } select=~select; select<<=1; select=~select; } } void cmp(void) { char i; if(p0_3==0) { for(i=0;i=4){f0=1;} else f0=0; } else { for(i=0;i=4){f0=1;} else f0=0; } } void clean(void) { int i; for(i=0;i=0x0)&&(keyno=0x0)&&(keyno1<=0xf)); else break; } if(keyno==0xe) { p0_0=1; f0=0; clean(); } if(keyno==0xf) { if(expass==2) { pass[3]=input[3]; pass[2]=input[2]; pass[1]=input[1]; pass[0]=input[0]; p0_1=1; expass=0; } else if((p0_3==0x0)&&(f0==0)) { cmp(); if(f0!=1){clean();} if(f0==1){counter=0;p0_3=1;p0_0=0; clean();} } else { counter++; if((counter)<=3) { cmp(); if(f0!=1) {clean();} if(f0==1){p0_0=0; clean();counter=0x0; } } else if(p0_0==0){counter=0;} else { for(keyno1=0;keyno1<=254;keyno1++) { for(counter=5;counter=4) { p0_3=0; extoppass=1; } } if(keyno==0xb) { clean(); } if((keyno>=0)&&(keyno<=9)) { input[3]=input[2]; input[2]=input[1]; input[1]=input[0]; input[0]=keyno; if(expass==1){expass++;} if(extoppass==1){extoppass++;} } } } 汇编代码： ;scan.asm $NOMOD51 NAME SCAN P0 DATA 080H P1 DATA 090H P2 DATA 0A0H P3 DATA 0B0H T0 BIT 0B0H.4 AC BIT 0D0H.6 T1 BIT 0B0H.5 EA BIT 0A8H.7 IE DATA 0A8H RD BIT 0B0H.7 ES BIT 0A8H.4 IP DATA 0B8H RI BIT 098H.0 INT0 BIT 0B0H.2 CY BIT 0D0H.7 TI BIT 098H.1 INT1 BIT 0B0H.3 PS BIT 0B8H.4 SP DATA 081H OV BIT 0D0H.2 WR BIT 0B0H.6 SBUF DATA 099H PCON DATA 087H SCON DATA 098H TMOD DATA 089H TCON DATA 088H IE0 BIT 088H.1 IE1 BIT 088H.3 B DATA 0F0H ACC DATA 0E0H ET0 BIT 0A8H.1 ET1 BIT 0A8H.3 TF0 BIT 088H.5 TF1 BIT 088H.7 RB8 BIT 098H.2 TH0 DATA 08CH EX0 BIT 0A8H.0 IT0 BIT 088H.0 TH1 DATA 08DH TB8 BIT 098H.3 EX1 BIT 0A8H.2 IT1 BIT 088H.2 P BIT 0D0H.0 SM0 BIT 098H.7 TL0 DATA 08AH SM1 BIT 098H.6 TL1 DATA 08BH SM2 BIT 098H.5 PT0 BIT 0B8H.1 PT1 BIT 0B8H.3 RS0 BIT 0D0H.3 TR0 BIT 088H.4 RS1 BIT 0D0H.4 TR1 BIT 088H.6 PX0 BIT 0B8H.0 PX1 BIT 0B8H.2 DPH DATA 083H DPL DATA 082H REN BIT 098H.4 RXD BIT 0B0H.0 TXD BIT 0B0H.1 F0 BIT 0D0H.5 PSW DATA 0D0H ?PR?scan?SCAN SEGMENT CODE PUBLIC scan RSEG ?PR?scan?SCAN scan: USING 0 MOV R3, #0FEH MOV R4, #0H MOV R1, #4H CLR PSW.5 L1: MOV A, R3 MOV P1, A MOV R5, #50 D1: MOV R6, #100 DJNZ R6, $ DJNZ R5, D1 MOV A, P1 ANL A, #0F0H MOV R2, #4 L2: JB ACC.4, N1 MOV 7EH, R4 SETB PSW.5 N1: INC R4 RR A DJNZ R2, L2 MOV A, R3 RL A MOV R3, A DJNZ R1, L1 BACK: JNB PSW.5, NO_KEY AJMP SCANOUT NO_KEY: MOV 7EH, #20H SCANOUT: MOV R7,7EH ?C0001: RET END 方案二： REL EQU 60H RELBUF EQU 61H KEYNO EQU 62H FKEY EQU 20H.0 F0_0 EQU 20H.1 ORG 0000H LJMP MAIN ORG 0030H MAIN: MOV SP, #6FH ACALL CLEAN START: ACALL DISPLAY CLR FKEY ACALL SCAN JB FKEY, G1 SJMP START G1: ACALL SCAN JB FKEY, G1 MOV A, KEYNO CJNE A, #14, G2 AJMP G4 G2: CJNE A, #15, G3 ACALL CMP JNB F0_0, G4 CLR P0.0 LCALL DELAY1 CLR F0_0 ACALL CLEAN AJMP START G3: MOV 43H, 42H MOV 42H, 41H MOV 41H, 40H MOV 40H, KEYNO AJMP START G4: SETB P0.0 ACALL CLEAN AJMP START CMP: MOV REL, #00H MOV R0, #40H MOV R7, #4H CMP1: MOV DPTR, #PASS MOV RELBUF, @R0 MOV A, REL MOVC A, @A+DPTR CJNE A, RELBUF, CMPOUT INC REL INC R0 DJNZ R7, CMP1 SETB F0_0 CMPOUT: MOV REL, #00H RET SCAN: MOV R3, #0FEH MOV R4, #0H MOV R1, #4H CLR PSW.5 L1: MOV A, R3 MOV P1, A MOV R5, #1 ACALL DELAY MOV A, P1 ANL A, #0F0H MOV R2, #4 L2: JB ACC.4, N1 MOV KEYNO, R4 SETB PSW.5 N1: INC R4 RR A DJNZ R2, L2 MOV A, R3 RL A MOV R3, A DJNZ R1, L1 BACK: JNB PSW.5, NO_KEY SETB FKEY AJMP SCANOUT NO_KEY: CLR FKEY SCANOUT: RET CODESW: MOV R0, #40H MOV R1, #50H MOV R7, #4 SW1: MOV DPTR, #TAB MOV A, @R0 MOVC A, @A+DPTR MOV @R1, A INC R0 INC R1 DJNZ R7, SW1 RET DISPLAY: ACALL CODESW MOV A, #0FEH MOV R5, #4 MOV R0, #50H DIS1: MOV P3, A MOV P2, @R0 ACALL DELAY INC R0 SETB C RLC A DJNZ R5, DIS1 RET CLEAN: MOV 40H, #0AH MOV 41H, #0AH MOV 42H, #0AH MOV 43H, #0AH RET DELAY: MOV R7, #25 D1: MOV R6, #100 DJNZ R6, $ DJNZ R7, D1 RET DELAY1: MOV R7, #245 D11: MOV R6, #225 D12: DJNZ R6, D12 DJNZ R7, D11 RET PASS: DB 4,3,2,1 TAB: DB 3FH,06H,5BH,4FH,66H DB 6DH,7DH,07H,7FH,6FH DB 40H,40H,40H,40H,86H,8EH END 图（1）系统硬件组成图 显示的数字 LED码 0 3FH 1 06H 2 5BH 3 4FH 4 66H 5 6DH 6 7DH 7 07H 8 7FH 9 6FH - 40H 图（2）LED编码表 参考电路图： 图（3）总体电路图 图（4）键盘接口电路 图（5）LED显示接口电路 图（6）开锁显示等电路 图（7）输入密码演示 图（8）锁开启电路 5.参考文献
四位数密码锁multisim仿真源文件
11-23
在密码锁设计中，这八个输入可能代表16进制的0到F，对应四位密码的每一个位。当用户输入密码时，这些信号通过逻辑门电路传递给74LS147，控制端的设置使得只有当输入的四位密码与预设的密码匹配时，特定的输出才被...
四位数密码锁数字电路Multisim仿真实例.zip
04-25
下面我们将深入探讨这个四位数密码锁数字电路的设计以及如何使用Multisim进行仿真。 首先，我们要理解四位数密码锁的工作原理。通常，这样的锁系统由四个独立的数字输入组成，每个数字范围从0到9，总共可以产生10,...
四位数密码锁数字电路Multisim仿真实例
09-09
总之，"四位数密码锁数字电路Multisim仿真实例"是一个结合理论与实践的优秀教学资源，它将复杂的密码锁系统转化为可操作的电子电路，使学习者能够直观地理解和掌握数字电路设计的核心原理。通过这样的实例，我们不仅...
密码锁设计（数字电路专题设计）
03-04
1.本次设计的密码锁的密码为一个4位的十进制数，且原始密码固化在锁内。 2. 用户按输入按键后，依次输入每位密码，若正确，则开锁；若不正确，则系统锁定，锁定结束后才可继续输入。 3. 若用户输入密码过程中出错，可以按复位键重新输入密码。 4.若用户希望修改密码，可按修改按键，进行修改密码的操作。
最新数字电子课程设计（电子密码锁的设计，电路图）
10-26
密码电子锁，一般是用预先设定的密码，用每个码位去控制触发器翻转，若码位按错则码位触发器不能翻转。密码电子锁一般还兼有电子门铃的功能。现在已有专用的电子密码锁集成器件可供选用。密码电子锁以其安全系数高、操作方便、稳定性好等特征越来越受到人们的欢迎。
与非门设计的四位代码数字锁
11-30
与非门设计的四位代码数字锁
电子密码锁课程设计（详细电路图）
04-14
【用途和摘要】本文的电子密码锁利用数字逻辑电路，实现对门的电子控制，并且有各种附加电路保证电路能够安全工作，具有极高的安全系数。 【本文关键词】电子密码锁、电压比较器、555单稳态电路、计数器、JK触发器、UPS电源。
第一部分 四位数字密码锁.docx
11-19
简易数字密码锁设计 设计一个保险箱用的4位数字密码锁，该锁有规定的地址代码A、B、C、D 4个输入端和一个开箱钥匙孔信号E的输入端，锁的密码由实验者自编。当用钥匙开箱时，如果输入的4位密码正确，则保险箱被打开；否则，电路将发出警报（可用点亮发光二极管表示）。
基于51单片机电子密码锁_4位密码(LED灯代表锁开关)毕业设计
12-28
密码为4位，只有在开锁时密码可更改，更改时要输入两遍确认； 2.采用矩阵按键输入、1602液晶显示、LED灯模拟开锁，红灯亮绿灯灭表示关锁，绿灯亮红灯灭表示开锁。 3.输入密码错误会提示错误次数，当次数大于3时，...
Verilog实现电子密码锁设计
gitblog_09764的博客
10-15 1098
Verilog实现电子密码锁设计 【下载地址】Verilog实现电子密码锁设计 本资源文件提供了一个基于Verilog语言实现的电子密码锁设计。该设计实现了以下功能：1. **设置并保存四位密码**：用户可以设置并保存一个四位数字的密码，并在数码管中显示为“1111”。2. **开锁功能**：用户首先按下开锁键，然后开始...
4位密码锁可改密码设计Verilog代码Quartus DE2开发板
diaojiangxue的博客
10-15 835
1、设计4位密码锁 2、可以输入4位十进制密码 3、可以修改密码 4、输入密码错误3次报警
评论 51
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值