矩阵按键的试验---verilog

矩阵键盘的试验,采用三段式状态机处理方法。

难点在于检测状态机中：按键消抖以后逐列检测。

电路图：

代码

/********************************Copyright**************************************
**----------------------------File information--------------------------
** File name  :keyboard.v
** CreateDate :2015.04
** Funtions   :4x4矩阵键盘
** Operate on :M5C06N3L114C7
** Copyright  :All rights reserved.
** Version    :V1.0
**---------------------------Modify the file information----------------
** Modified by   :
** Modified data :
** Modify Content: 2015.6
*******************************************************************************/

module keyboard(
                  clk,
                                    rst_n,

                                    l_in,
                                    h_out,

                                    test_1,
                                    test_2,

                                    key_val,
                                    key_val_flag
                                    );
 input             clk;          /* clk = 24M */
 input             rst_n;
 input   [:]     l_in;             //列输入，一般接上拉，为高电平

 output            test_1;
 output            test_2;

 output  [:]     h_out;            //行输出信号，低有效
 output  [:]     key_val;          //按键值，输出
 output            key_val_flag;

 wire    [:]     key_val;
 reg               test_1;
 reg               test_2;
 //*************************************
 /* 分频Ƶ*20ms，用于消抖 .状态机直接用clk_20ms，则可以跳过消抖*/

//  `define   CLK_24M
   `define   CLK_20M 

    `ifdef  CLK_24M
        parameter  t_20ms = 'd479999;
     `endif

     `ifdef  CLK_20M
        parameter  t_20ms = 'd399999;
     `endif

  reg    [:]   cnt;
 always @(posedge clk or negedge rst_n)
  begin
    if(!rst_n)
      begin
           cnt <= 'd0;
        end
      else
       begin
         if(cnt == t_20ms)  cnt <= 'd0;
         else cnt <= cnt + 'd1;
         end
  end
  wire    shake_over = (cnt == t_20ms);
 //******************状态机******************
 localparam NO_KEY_pressed  =  'd0;        /* 初始化 */
 localparam key_shake_1     =  'd1;        /* 消抖1 */
 localparam KEY_h_1         =  'd2;        /* 检测第一列 */
 localparam KEY_h_2         =  'd3;        /* 检测第二列 */
 localparam KEY_h_3         =  'd4;        /* 检测第三列 */
 localparam KEY_h_4         =  'd5;        /* 检测第四列 */
 localparam KEY_pressed     =  'd6;        /* 按键值输出*/
 localparam key_shake_2     =  'd7;        /* 消抖2 */ 

 /* 3-1 */
 reg     [:]      current_state;
 reg     [:]      next_state;
 reg                key_pressed_flag;
 always @(posedge clk or negedge rst_n)
 begin
  if(!rst_n)
   begin
      current_state <= ;
    end
  else if(shake_over)
    begin
      current_state <= next_state;
    end
    else
         current_state <=  current_state ;
  end

 /* 3-2 */
always @(*)
 begin
     next_state     = NO_KEY_pressed;
   case(current_state)
    NO_KEY_pressed:
              begin
                        if(l_in != 'hf)   next_state = key_shake_1;
                 else  next_state = NO_KEY_pressed;
           end
        key_shake_1:
         begin
                        if(l_in != 'hf)   next_state = KEY_h_1;
                 else  next_state = NO_KEY_pressed;
           end
    KEY_h_1:
            begin
                        if(l_in != 'hf)   next_state = KEY_pressed;
                 else  next_state = KEY_h_2;
          end
        KEY_h_2:
            begin
                        if(l_in != 'hf)   next_state = KEY_pressed;
                 else  next_state = KEY_h_3;
          end
    KEY_h_3:
            begin
                        if(l_in != 'hf)   next_state = KEY_pressed;
                 else  next_state = KEY_h_4;
          end
    KEY_h_4:
            begin
                        if(l_in != 'hf)   next_state = KEY_pressed;
                 else  next_state = NO_KEY_pressed;
          end
   KEY_pressed:
          begin
                        if(l_in != 'hf)   next_state = key_shake_2;
                 else  next_state = NO_KEY_pressed;
          end
     key_shake_2:
          begin
                        if(l_in != 'hf)   next_state = key_shake_2;
                 else  next_state = NO_KEY_pressed;
          end
     default:;
    endcase
end

/* 3-3  */

 reg    [:]      l_in_reg;
 reg    [:]   h_out_reg;
 reg    [:]   h_out;
always @(posedge clk or negedge rst_n)
 begin
  if(!rst_n)
   begin
      l_in_reg <= 'd0;
            h_out_reg<= 'd0;
            h_out <= 'd0;
            key_pressed_flag <= ;
    end
  else if(shake_over)
    begin
     case(next_state)
         NO_KEY_pressed:
            begin
              l_in_reg <= l_in_reg;
                    h_out_reg<= h_out_reg;
                    h_out <= 'd0;
                    key_pressed_flag <= ;
             end
         KEY_h_1:
              begin
                     h_out <= 'b1110;
                    end
         KEY_h_2:
              begin
                     h_out <= 'b1101;
                    end
         KEY_h_3:
              begin
                     h_out <= 'b1011;
                    end
         KEY_h_4:
              begin
                     h_out <= 'b0111;
                    end

         KEY_pressed:
           begin
                     l_in_reg <= l_in;
                   h_out_reg<= h_out;
                end
         key_shake_2:  begin key_pressed_flag <= ;   end
         default:;
        endcase
   end
 end

 reg      [:]      temp_key_val;
 always @(posedge clk or negedge rst_n)
  begin
   if(!rst_n)
       temp_key_val <= 'd0;
    else
         begin
            if(key_pressed_flag)
              begin
                  case ({h_out_reg,l_in_reg})
                        'b1110_1110 :  temp_key_val <= 4'd0;
                        'b1110_1101 :    temp_key_val <= 4'd1;
                        'b1110_1011 :    temp_key_val <= 4'd2;
                        'b1110_0111 :    temp_key_val <= 4'd3;

                        'b1101_1110 :    temp_key_val <= 4'd4;
                        'b1101_1101 :    temp_key_val <= 4'd5;
                        'b1101_1011 :    temp_key_val <= 4'd6;
                        'b1101_0111 :    temp_key_val <= 4'd7;

                        'b1011_1110 :    temp_key_val <= 4'd8;
                        'b1011_1101 :    temp_key_val <= 4'd9;
                        'b1011_1011 :    temp_key_val <= 4'd10;
                        'b1011_0111 :    temp_key_val <= 4'd11;

                        'b0111_1110 :    temp_key_val <= 4'd12;
                        'b0111_1101 :    temp_key_val <= 4'd13;
                        'b0111_1011 :    temp_key_val <= 4'd14;
                        'b0111_0111 :    temp_key_val <= 4'd15;

                    default: temp_key_val <= 'd0;
                endcase
    end
   end
 end
 assign   key_val = ~temp_key_val;
 assign   key_val_flag =  ~key_pressed_flag;
 endmodule
 

测试代码：

module  testbench;

 reg             clk;          /* clk = 24M */
 reg             rst_n;
 reg   [:]     l_in;             //列输入，一般接上拉，为高电平

 wire            test_1;
 wire            test_2;

 wire  [:]     h_out;            //行输出信号，低有效
 wire  [:]     key_val;          //按键值，输出
 wire            key_val_flag;

keyboard  u1(
                  .clk,
                                    .rst_n,

                                    .l_in,
                                    .h_out,

                                    .test_1,
                                    .test_2,

                                    .key_val,
                                    .key_val_flag
                                    );
        defparam  u1.    t_20ms = ;                        

 parameter  tck = ;
 parameter  t = /tck;

 always
     #(t/)   clk = ~clk;

 task     key_test;
 input [:]   data_key;
  begin
        #(*t)     l_in = data_key;
        #(*t) l_in = 'b1111;
        #(*t);
        end
    endtask

initial
  begin
    clk = ;
    rst_n = ;
    l_in  = 'd0;

    #(*t)  rst_n = ; 

    #(*t);
    key_test('B1101);
    key_test('B1011); 

  end

endmodule 

仿真波形：