FPGA 35 数字密码锁系统设计

小灰灰 2022-09-11 08:15 163阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqMTk4NjgxNzkwMg_size_16_color_FFFFFF_t_70_pic_center]

# FPGA 35 数字密码锁系统设计 #

本次开始进行一些综合系统的入门设计，本次设计一款按键输入式密码锁，用矩阵键盘输入密码，输入完成后进行密码比对，如密码输入正确则输出开门信号以及灯光指示，如密码输入错误则蜂鸣器进行报警以及灯光指示。

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-64NXuzgj-1631606416438)(E:/Blog\_Template/source/\_posts/img/blog\_img/fpga/image-20210607171624531.png)\]][img-64NXuzgj-1631606416438_E_Blog_Template_source_posts_img_blog_img_fpga_image-20210607171624531.png]

系统设计流程如下所示：

通过Key\_Board 矩阵键盘按下，输出端口key\_Value \[3:0\]输出按键按下的值，同时输出Key\_Flag 信号。Mima\_detect 模块将开始接受按键输出的数据进行对比检测。同时通过数码管模块实现输入密码的显示，密码正确和（错误）结果发送给control模块，然后输出报警或开门信号。

各模块功能描述如表 1 所示：

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NNLthJ1t-1631606416441)(E:/Blog\_Template/source/\_posts/img/blog\_img/fpga/image-20210607171819529.png)\]][img-NNLthJ1t-1631606416441_E_Blog_Template_source_posts_img_blog_img_fpga_image-20210607171819529.png]

各模块输入输出介绍：

矩阵键盘模块介绍：

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dqUe7xMY-1631606416443)(E:/Blog\_Template/source/\_posts/img/blog\_img/fpga/image-20210607172047731.png)\]][img-dqUe7xMY-1631606416443_E_Blog_Template_source_posts_img_blog_img_fpga_image-20210607172047731.png]

key\_board.v 矩阵键盘输入模块

module key_board
    (
    	Clk,
    	Rst_n,
    	Key_Board_Row_i,
    
    	Key_flag,
    	Key_Value,
    	Key_Board_Col_o
    );
    
    	input Clk ;
    	input Rst_n;
    	input [3:0]Key_Board_Row_i;
    
    	output reg Key_flag;
    	output reg [3:0]Key_Value;
    	output reg [3:0]Key_Board_Col_o;
    
    	
    	// 输入列寄存器信号，输入以后做一次寄存
    	reg [3:0]Key_Board_Row_r;
    
    	reg En_Cnt ;	//滤波定时器
    	reg [19:0] counter1; //滤波定时，时钟周期计数器
    	reg Cnt_Done;	//滤波时间完成标志信号
    
    	reg [3:0]Col_Tmp ; 	// 列按键按下状态 
    	reg  Key_Flag_r; 	// 按键成功标志位
    	
    	reg [7:0]Key_Value_tmp;
    	
    	reg  [10:0]state;
    	
    	//按键按下标志位
    	always@(posedge Clk)
    		Key_flag <= Key_Flag_r;
    	
    	// 状态机状态参数
    	localparam 
    		IDEL			= 11'b00000000001,
    		P_FILTER		= 11'b00000000010,
    		READ_ROW_P 		= 11'b00000000100,
    		SCAN_C0 		= 11'b00000001000,
    		SCAN_C1 		= 11'b00000010000,
    		SCAN_C2 		= 11'b00000100000,
    		SCAN_C3 	    = 11'b00001000000,
    		PRESS_RESULT 	= 11'b00010000000,
    		WAIT_R		    = 11'b00100000000,
    		R_FILTER 	    = 11'b01000000000,
    		READ_ROW_R 		= 11'b10000000000;
    
    	// 滤波定时计数器
    
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		counter1 <= 20'd0;
    	else if(En_Cnt)begin
    		if(counter1 == 20'd999999)
    			counter1 <= 20'd0;
    		else
    			counter1 <= counter1 + 1'b1;
    	end
    	else
    		counter1 <= 20'd0;
    		
    	always@(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		Cnt_Done <= 1'b0;
    	else if(counter1 == 20'd999999)
    		Cnt_Done <= 1'b1;
    	else
    		Cnt_Done <= 1'b0;
    
    
    
    	//状态机
    	always @(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    	begin
    	  state <= IDEL ;
    	  Key_Board_Col_o <= 4'b0000 ; //输出端口默认设置为低电平，只有按键按下时，默认的上拉电平就会变成低电平
    	  En_Cnt <= 1'b0;
    	  Col_Tmp <= 4'd0;
    	  Key_Flag_r <= 1'b0;
    	  Key_Value_tmp <= 8'd0;
    	  Key_Board_Row_r <= 4'b1111;
    	end
    	else
    	begin
    		case (state)
    			IDEL: 
    				if(~&Key_Board_Row_i)begin  // Key_Board_Row_i  不等于 4‘d1111,说明有按键按下
    					En_Cnt <= 1'b1 ;    // 开启滤波定时器
    					state <= P_FILTER;  // 跳转进入前级滤波状态
    				end
    				else begin			// 按键未按下
    					En_Cnt <=1'b0 ; // 消抖滤波定时器关闭
    					state  <=IDEL ; // 等待状态 
    				end
    			P_FILTER :
    				if(Cnt_Done) begin	//消抖滤波定时时间结束
    				  	En_Cnt <= 1'b0; //关闭滤波定时器
    					state <= READ_ROW_P; //跳转进入滤波检测状态
    				end
    				else begin			//消抖定时未结束
    					En_Cnt <= 1'b1; //继续保持
    					state <= P_FILTER;// 状态继续保持当前值
    				end
    			READ_ROW_P:
    				if (~&Key_Board_Row_i) begin  //滤波后，第二次确定按键确实按下
    					Key_Board_Row_r <= Key_Board_Row_i; // 存取当前状态的值
    					Key_Board_Col_o <= 4'b1110;  // 设置 Key_Board_Col_o 的输出信号为 4‘b1110，其它列设置为高电平
    					state <= SCAN_C0;	// 跳转进入第C0列的判断
    				end
    				else begin 			//这次是按键抖动
    					state  <=IDEL ; // 进入空闲等待状态
    					Key_Board_Col_o <= 4'b0000;  // 设置 Key_Board_Col_o 的输出信号为 4‘b0000
    				end
    			SCAN_C0 :
    				begin
    					Key_Board_Col_o <= 4'b1101;  // 设置 Key_Board_Col_o 的输出信号为 4‘b1101
    					state <= SCAN_C1;		 // 跳转进入第C1列的判断
    					if(~&Key_Board_Row_i) //其它3列设置为高电平后，Key_Board_Row_i 仍然为按键按下状态
    						Col_Tmp <= 4'b0001 ; // 表示此次按下的按键是再第一列
    					else
    						Col_Tmp <= 4'b0000 ; // 表示此次按下的按键不在这列
    				end
    			SCAN_C1 :
    				begin
    					Key_Board_Col_o <= 4'b1011;  // 设置 Key_Board_Col_o 的输出信号为 4‘b1011
    					state <= SCAN_C2;	// 跳转进入第C2列的判断
    					if(~&Key_Board_Row_i) //其它3列设置为高电平后，Key_Board_Row_i 仍然为按键按下状态
    						Col_Tmp <= 4'b0010 | Col_Tmp ; // 表示此次按下的按键是再第2列
    					else
    						Col_Tmp <= Col_Tmp ; // 表示此次按下的按键不在这列
    				end
    			SCAN_C2 :
    				begin
    					Key_Board_Col_o <= 4'b0111;  // 设置 Key_Board_Col_o 的输出信号为 4'b0111
    					state <= SCAN_C3;	// 跳转进入第C3列的判断
    					if(~&Key_Board_Row_i) //其它3列设置为高电平后，Key_Board_Row_i 仍然为按键按下状态
    						Col_Tmp <= 4'b0100 | Col_Tmp ; // 表示此次按下的按键是再第2列
    					else
    						Col_Tmp <= Col_Tmp ; // 表示此次按下的按键不在这列
    				end
    			SCAN_C3 :
    				begin
    					state <= PRESS_RESULT;	// 进入此状态后，表示按键检测已经结束，需要进入下一个按键结果分析状态
    					if(~&Key_Board_Row_i) 	// 其它3列设置为高电平后，Key_Board_Row_i 仍然为按键按下状态
    						Col_Tmp <= 4'b1000 | Col_Tmp ; // 表示此次按下的按键是再第3列
    					else
    						Col_Tmp <= Col_Tmp ; // 表示此次按下的按键不在这列
    				end
    			PRESS_RESULT:
    				begin
    					state <= WAIT_R;		// 本次结果分析完成后，进入按键松开滤波状态
    					Key_Board_Col_o <= 4'b0000; //按键检测查找完成，所以重新设置,输出Key_Board_Col_o的信号为 4‘b0000
    					if(((Key_Board_Row_r[0] + Key_Board_Row_r[1] + Key_Board_Row_r[2] + Key_Board_Row_r[3]) == 4'd3) &&
    					((Col_Tmp[0] + Col_Tmp[1] + Col_Tmp[2] + Col_Tmp[3]) == 4'd1)) // 检验是否只有一个按键按下
    					begin
    						Key_Flag_r <= 1'b1;							//产生按键成功标志信号
    						Key_Value_tmp <= {Key_Board_Row_r,Col_Tmp}; //位拼接，等下来查找
    					end
    					else
    					begin
    						Key_Flag_r <= 1'b0; 			//非单个按键按下，不产生按键完成信号
    						Key_Value_tmp <= Key_Value_tmp; //按键值保持上一次按键的值
    					end
    				end
    			WAIT_R :
    				begin
    					Key_Flag_r <= 0 ; // 按键成功标志信号清零
    					if(&Key_Board_Row_i) //  Key_Board_Row_i = 4’b1111 表示(按键未按下)即，按键松开，此时我们进入后消抖状态
    					begin
    						En_Cnt =1'b1; 		  // 开启消抖滤波的计时器
    						state <= R_FILTER ; //进入后消抖判断转态
    					end
    					else 						  // 按键仍然按下，我们在这次保持等待状态
    					begin
    						state <= WAIT_R ;
    						En_Cnt =1'b0; 		  // 消抖滤波的计时器暂时先不开启
    					end	
    				end
    			R_FILTER :
    				if(Cnt_Done)begin  		//后消抖滤波定时完成
    					En_Cnt <= 1'b0; 		//关闭滤波定时器使能信号
    					state <= READ_ROW_R; //进入按键完全释放状态判断
    				end
    				else
    				begin
    					En_Cnt <= 1'b1; 		// 滤波消抖定时器正在进行
    					state  <= R_FILTER;		// 继续保持滤波状态
    				end
    			READ_ROW_R :
    				if(&Key_Board_Row_i)  // （Key_Board_Row_i =4'd1111）即，确定按键已经松开，本次按键检测已经完成
    					state <= IDEL;
    				else 	// 按键还没松开,再次后消抖滤波
    				begin
    					state <= R_FILTER;		// 再次进入后消抖滤波状态
    					En_Cnt <= 1'b1; 		// 开启滤波消抖定时器
    				end
    			default:  state <= IDEL; // 默认，或者运行出错，进入空闲状态
    		endcase  
    	end
    
    	//按键输出状态查找表  根据 : Key_Value_tmp <= {Key_Board_Row_r,Col_Tmp};  实现数据的查找
    	always @(posedge Clk or negedge Rst_n)
    	if(!Rst_n)
    		Key_Value <= 4'd0 ;
    	else if(Key_Flag_r)  // 先判断，按键是否按下成功
    	begin
    		case (Key_Value_tmp)
    			8'b1110_0001 : Key_Value <= 4'd0;
    			8'b1110_0010 : Key_Value <= 4'd1;
    			8'b1110_0100 : Key_Value <= 4'd2;
    			8'b1110_1000 : Key_Value <= 4'd3;
    			
    			8'b1101_0001 : Key_Value <= 4'd4;
    			8'b1101_0010 : Key_Value <= 4'd5;
    			8'b1101_0100 : Key_Value <= 4'd6;
    			8'b1101_1000 : Key_Value <= 4'd7;
    			
    			8'b1011_0001 : Key_Value <= 4'd8;
    			8'b1011_0010 : Key_Value <= 4'd9;
    			8'b1011_0100 : Key_Value <= 4'd10;
    			8'b1011_1000 : Key_Value <= 4'd11;
    			
    			8'b0111_0001 : Key_Value <= 4'd12;
    			8'b0111_0010 : Key_Value <= 4'd13;
    			8'b0111_0100 : Key_Value <= 4'd14;
    			8'b0111_1000 : Key_Value <= 4'd15; 
    			default: Key_Value <= Key_Value ;
    		endcase
    	end
        
    endmodule

密码比较模块：

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L0QONLsE-1631606416445)(E:/Blog\_Template/source/\_posts/img/blog\_img/fpga/image-20210607172216752.png)\]][img-L0QONLsE-1631606416445_E_Blog_Template_source_posts_img_blog_img_fpga_image-20210607172216752.png]

module Mima_detect(
        Clk,
        Rst_n,
        Key_flag,
        Key_value,
        start_compare,
        error,
        Mima_r,
        Right
    );
    
        input  Clk;
        input  Rst_n;
        input Key_flag;
        input [3:0]Key_value;
        input start_compare;
    
        output reg error; // 密码输入错误标志信号
        output reg [15:0]Mima_r; //输出输入的密码
        output reg Right; // 密码输入正确标志信号
    
        reg [1:0]key_cnt; //密码输入个数计数器
    	 
    	     // start_compare 输入信号  加入按键滤波模块
        // 输入 : start_compare    --》 按键按下信号
        // 输出 : key_startbj_flag --》 按键按下状态
        wire key_startbj_flag;
        wire key_startbj_state;
    
        //开锁密码  设置的四位密码 : 1234
        parameter PASSWORD = 16'b0001_0010_0011_0100;
    
        // 密码输入个数计数器
        always @(posedge Clk or negedge Rst_n) begin
        if(!Rst_n)
            key_cnt <= 2'd0;
        else if(Key_flag)
            if(key_cnt == 2'd3)
                key_cnt <= 2'd0 ;
            else
                key_cnt <=key_cnt +1'b1;
        else
            key_cnt <= key_cnt;
        end
    
        // 读取输入的密码
        always @(posedge Clk or negedge Rst_n) begin
        if(!Rst_n)
            Mima_r <=16'd0;
        else if(Key_flag)
            case (key_cnt)
                2'd0 : Mima_r[15:12] <= Key_value[3:0];
                2'd1 : Mima_r[11:8] <= Key_value[3:0];
                2'd2 : Mima_r[7:4] <= Key_value[3:0];
                2'd3 : Mima_r[3:0] <= Key_value[3:0];
                default:  Mima_r <= 16'd0 ;
            endcase
        else
            Mima_r <= Mima_r ;
    
        end
    
        
        key_filter key_filter_start(
        .Clk(Clk),
        .Rst_n(Rst_n),
        .key_in(start_compare),
        .key_flag(key_startbj_flag),
        .key_state(key_startbj_state)
        );
        
        // 按键滤波后，根据滤波模块 输出的信号， key_startbj_flag 和 key_startbj_state 来判断信号
        always @(posedge Clk or negedge Rst_n) 
        begin
            if(!Rst_n) begin
                error <= 1'b0 ;
                Right <= 1'b0 ;
            end
            else if(key_startbj_flag || (!key_startbj_state))  // 按键确认按下，开始判断输入密码是否正确
    		  begin
    				if(Mima_r == PASSWORD)
    				begin
                    error <= 1'b1 ;
                    Right <= 1'b0 ;
                end
                else begin
                    error <= 1'b0 ;
                    Right <= 1'b1 ;
                end
    		  end
            else begin
                error <= 1'b0;
                Right <= 1'b0;
            end
        end
    
    endmodule

本( control )模块主要功能是根据密码检测模块的输出确定，开关门信号以及声光信号。其模块接口列表及功能描述如下所示 :

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1M16kmXd-1631606416446)(img/blog\_img/fpga/image-20210914155127419.png)\]][img-1M16kmXd-1631606416446_img_blog_img_fpga_image-20210914155127419.png]

module door_control(
        Clk,
        Rst_n,
        error,
        right,
    
    
        door_open, // 密码输入正确，门开启信号
        led_right, // 密码输入正确，亮绿灯
        beep_alarm, //密码输入错误，喇叭警告
        led_alarm  // 密码输入错误，亮警告灯
    );
    
        input Clk;
        input Rst_n;
        input error;
        input right;
    
        output door_open;
        output led_right;
        output reg beep_alarm;
        output led_alarm;
    
        
    
        reg door_open_r;
        reg led_right_r;
        reg led_alarm_r;
    
        reg beep_En ;
    
        reg [2:0]current_state ;
        reg [2:0]next_state;
    
        //由于板载led灯为置0亮，因此这里进行取反，下面按照正常情况编写
    	assign door_open = ~door_open_r;
    	assign led_alarm = ~led_alarm_r;
    	assign led_right = ~led_right_r;
    
        parameter   IDEL    = 3'b001,
                    PASS    = 3'b010,
                    ALARM   = 3'b100 ;
        
        // 三段状态机
        // 第一段；计划下次进入哪个状态 （时序逻辑）
        always @(posedge Clk or negedge Rst_n) 
        begin
            if(!Rst_n)
                current_state <= IDEL ;
            else
                current_state <= next_state;
        end
    
        //第二段： 满足什么条件进入什么状态（根据条件进行跳转或者状态保持） 组合逻辑
        always @(current_state or error or right or cnt_2s) 
        begin
            case (current_state)
                IDEL : begin
                    if(right)
                        next_state <= PASS ;
                    else if(error)
                        next_state <= ALARM ;
                    else
                        next_state <= IDEL ;
                end
                PASS : begin
                    if(right)
                        next_state <= IDEL ;
                    else if(error)
                        next_state <= ALARM ;
                    else
                        next_state <= PASS ; 
                end
                ALARM : begin
                    if(cnt_2s)  // 2S 警报时间以到
                        next_state <= IDEL ;
                    else        // 2s 警报时间未到
                        next_state <= ALARM ;
                end 
                default: next_state <= IDEL; 
            endcase    
        end
    
    
    
        // 第三段：根据进入的状态，完成相应的操作 时序逻辑
        always @(posedge Clk or negedge Rst_n) 
        begin
            if(!Rst_n) begin
                door_open_r <= 1'b0 ;
                led_alarm_r <= 1'b0 ;
                led_right_r <= 1'b0 ;
                beep_En <= 1'b0 ;
    		  end
            else begin
            case (next_state)
                IDEL :begin
                    door_open_r  <= 1'b0;	
                    led_alarm_r  <= 1'b0;
                    led_right_r  <= 1'b0;
                    beep_En <= 1'b0;	
                end
                PASS :begin
                    if(cnt_2s)begin // 密码检测时间超过2s，恢复到空闲状态
                        door_open_r  <= 1'b0;	
                        led_alarm_r  <= 1'b0;
                        led_right_r  <= 1'b0;
                        beep_En <= 1'b0;
                    end
                    else begin
                        door_open_r  <= 1'b1;
                        led_right_r  <= 1'b1;
                    end
                end
                ALARM: begin
                    if(cnt_2s)begin // 警报2S 时间以到
                        led_alarm_r <= 1'b0; // 警报灯信号关闭
                        beep_En <= 1'b0; // 喇叭警报信号关闭
                    end
                    else begin      //警报时间2s未到， 开始或继续（警报信号开启、警报灯信号开启）
                        led_alarm_r <= 1'b1 ;
                        beep_En <= 1'b1; 
                    end
                end
                default: begin
                    door_open_r  <= door_open_r;	
                    led_alarm_r  <= led_alarm_r;
                    beep_En      <= beep_En;
                    led_right_r  <= led_right_r; 
                end
            endcase
            end
        end
    
        reg [26:0]cnt; // 定时计数器
    	 reg cnt_2s ;
        // 2s 状态保持时间
        always @(posedge Clk or negedge Rst_n) 
        begin
            if(!Rst_n) begin
                cnt_2s <= 1'b0;
                cnt <= 27'd0 ;
            end
            else if(cnt == 27'd99_999_999) begin
                cnt_2s <= 1'b1 ;  //  2s 警报时间以到
                cnt <= 27'd0 ;
            end
            else begin
              cnt_2s <= 1'b0;
              cnt <= cnt + 1'b1 ;
            end
        end
    
    	//beep count   喇叭 pwm 波信号驱动
    	reg [25:0] beep_cnt;
    	localparam CNT_TOP = 5_000_000;//used in physical board Clk = 50M  
    	wire Beep_o_en;
    	always @ (posedge Clk or negedge Rst_n) begin 
    		if(!Rst_n)
    			beep_cnt <= 26'b0;
    		else if(beep_cnt < CNT_TOP) 
    			beep_cnt <= beep_cnt +1'b1;
    		else 
    			beep_cnt <= 26'b0;
    	end 
    	
    	//蜂鸣器驱动
    	always @ (posedge Clk or negedge Rst_n) begin 
    		if(!Rst_n)
    			beep_alarm <= 1'b1;
    		else if(beep_En) begin  // 喇叭 报警使能信号
    			if(Beep_o_en) 
    				beep_alarm <= 1'b1;
    			else 
    				beep_alarm <= 1'b0;
    		end
    		else                    // 
    			beep_alarm <= beep_alarm;
    	end
    
        assign Beep_o_en = (beep_cnt[14] == 1)? 1'b1:1'b0;//计数值驱动蜂鸣器鸣叫使能信号（实际是产生的是Beep_o_en的 pwm 波信号）
           
    endmodule

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jmUmXFX7-1631606416447)(img/blog\_img/fpga/image-20210914155322184.png)\]][img-jmUmXFX7-1631606416447_img_blog_img_fpga_image-20210914155322184.png]

![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-raS4u72p-1631606416448)(img/blog\_img/fpga/image-20210914155847258.png)\]][img-raS4u72p-1631606416448_img_blog_img_fpga_image-20210914155847258.png]

注：这里是以 HEX8 + HC595实现数码管数据刷新的显示。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xqMTk4NjgxNzkwMg_size_16_color_FFFFFF_t_70_pic_center]: /images/20220828/46eef9c19a6b47f69858e5196db6e412.png
[img-64NXuzgj-1631606416438_E_Blog_Template_source_posts_img_blog_img_fpga_image-20210607171624531.png]: /images/20220828/9be79084f5ec4f449eaa447e1fb705a3.png
[img-NNLthJ1t-1631606416441_E_Blog_Template_source_posts_img_blog_img_fpga_image-20210607171819529.png]: /images/20220828/88faeb7dd43245a8b89804e40b0a4f32.png
[img-dqUe7xMY-1631606416443_E_Blog_Template_source_posts_img_blog_img_fpga_image-20210607172047731.png]: /images/20220828/7bba5a909d084a3eb8615f050d1688c6.png
[img-L0QONLsE-1631606416445_E_Blog_Template_source_posts_img_blog_img_fpga_image-20210607172216752.png]: /images/20220828/40eeda0d887b4efaadbeb3f32cb54709.png
[img-1M16kmXd-1631606416446_img_blog_img_fpga_image-20210914155127419.png]: /images/20220828/64162d1bd82d4413bf28778ded4ba437.png
[img-jmUmXFX7-1631606416447_img_blog_img_fpga_image-20210914155322184.png]: /images/20220828/dd5d443ee34b4951951671888e2ae71f.png
[img-raS4u72p-1631606416448_img_blog_img_fpga_image-20210914155847258.png]: /images/20220828/0efe623edce44af9bf304d049577cd96.png