设计思想
键盘扫描和编码器用于在拥有键盘的数字系统中手工输入数据，通过检测按键是否按下，产生一个唯一对应此按键的扫描码，设计十六进制键盘电路的键盘扫描和编码器。
利用状态机来循环检测信号的列位置，其中ab/c表示为a：S_row（所有行信号相与），b：row（行信号），c：Vaild（使能信号）。S_0初始状态，S_i表示检测第i列的状态，S_5表示已经找到列信号。刚开始，一旦检测到S_raw有效，说明有按键按下，此时在所有列信号置（clo=1111，即15）的情况下，依次检测行信号，先进入第一列（S_1）检测，如果在S_1状态下的row有效，就说明有按键按下，通过改变col的值来记录列号，否则依次检测其他状态。
此模块定义为hex_keypad_grayhill，输入信号有S_row、row，输出信号有code（按键字母）、vaild、col，利用S_row和row信号，通过状态机找到行信号col，然后结合row和col找到code（按键字母）。
对于上述模块中使用到的S_row，可由模块synchronizer决定的，通过检测各行线值的或来决定的，即只要给该设计模块行信号row即可。
所以整个顶层模块定义为keypad，当输入信号row，就能输出列col与code。
对于如何给keypad一个初始row值，可通过测试模块调用row_signal模块（模拟键盘产生信号模块）生成row，row_signal模块的输入信号为列信号col与key（键盘），通过col与key的逻辑关系输出信号row。
row_signal 输入：key、col；输出：row；
keypad 输入：row ；输出：code、col；
synchronizer输入：row； 输出：S_row
hex_keypad_grayhill输入：S_row、row；输出：code、col；
所以进行测试时，先利用模拟按键信号发生器给定key值（字母），调用row_signal检测按键有效性并确定按键所处的row，就能给keypad传参，得到输出code（字母）。
//顶层模块:
module keypad(clock,reset,row,code,vaild,col);
input clock,reset;
input [3:0] row;
output [3:0] code;
output vaild;
output [3:0] col;
wire s _row;
hex_keypad_grayhill U1(.code(code),.col(col),.valid(valid),
.row(row),.s row(s_row),.clock(clock),.reset(reset));
synchronizer U2(.s_row(s_row),.row(row),.clock(clock),..reset(reset));
endmodule
//编码模块:
module hex_keypad_grayhill(code,col,valid,row,s_row,clock,reset);
output[3:0] code;
output valid;
output[3:0] col;
input[3:0] row;
input s_row;
input clock,reset;
reg[3:0] col;
reg[3:0] code;
reg [5:0] state,next_state;
parameter s_O=6'b000001,s_1=6'b000010,s_2=6'b000100;
parameter s_3=6'b001000,s_4=6'b010000,s_5=6'b100000;
assign valid=((state==s_1)||(state==s_2)||(state==s_3)||(state==s_4))&&row;
always@(row or col)
case({row,col})
8'b0001_0001: code=0;
8'b0001_0010: code=1;
8'b0001_0100: code=2;
8'b0001_1000: code=3;
8'b0010_0001: code=4;
8'b0010_0010: code=5;
8'b0010_0100: code=6;
8'b0010_1000: code=7;
8'b0100_0001: code=8;
8'b0100_0010: code=9;
8'b0100_0100: code=10; //A
8'b0100_1000: code=11; //B
8'b1000_0001: code=12;
8'b1000_0010: code=13;
8'b1000_0100: code=14;
8'b1000_1000: code=15;
default code=O;
endcase
always@(state or s_row or row) //next-state logic
begin
next_state=state; col=O;
case(state)
s_0:begin
col=15;
if(s_row) next_state=s_1;
end
s_1:begin
col=1;
if(row) next_state=s_5;
else next_state=s_2;
end
s_2:begin
col=2;
if(row) next_state=s_5;
else next_state=s_3;
end
s_3:begin
col=4;
if(row) next_state=s_5;
else next_state=s_4;
end
s_4:begin
col=8;
if(row) next_state=s_5;
else next_state=s_0;
end
s_5:begin
col=15;
if(!row) next_state=s_0;
end
endcase
end
always@(posedge clock or posedge reset)
if(reset)
state<=s_o;
else
state<=next_state;
endmodule
//计算s_row模块
module synchronizer(s_row, row,clock,reset);
output s_row;
input [3:0] row;
input clock,reset;
reg a_row,s_row;
always@(negedge clock or posedge reset)
begin
if(reset)
begin
a_row<=0;s_row<=O;
end
else
begin
a_row<=(row[0]||[row[1]||row[2]||row[3]);
s_row<=a_row;
end
end
endmodule
//模拟键盘产生信号
module row_signal(row,key.,col);output [3:0] row;
input[15:0] key;
input [3:0] col;
reg[3:0] row;
always@(key or col)
begin
row[0]=key[0]&&col[0]||key[1]&&col[1]||key[2]&&col[2]||key[3]&&col[3];
row[1]=key[4]&&col[0]||key[5]&&col[1]||key[6]&&coI[2]||key[7]&&col[3];
row[2]=key[8]&&col[0]||key[9]&&col[1]||key[10]&&col[2]||key[11]&&col[3];
row[3]=key[12]&&col[0]||key[13]&&col[1]||key[14]&&col[2]||key[15]&&col[3];
end
endmodule
//Testbench
module hex_keypad_grayhill_tb;
wire [3:0] code;
wire valid;
wire [3:0] col;
wire [3:0] row;
reg clock;
reg reset;
reg [15:0] key;
integer j,k;
reg [39:0] pressed;
parameter [39:0] key_0="key_o";
parameter [39:0] key_1="key_1";
parameter i39:0] key3="key_a";
parameter [39:0] key_4="key_4";
parameter [39:0] key_5="key_5";
parameter [39:0] key_6="key_6";
parameter [39:0] key_7="key_7";
parameter [39:0] key_8="key_8";
parameter [39:0] key_9="key_9";
parameter [39:0] key_A="key_A";
parameter [39:0] key_B="key_B";
parameter [39:0] key_C="key_c";
parameter [39:0] key_D="key_D";
parameter [39:0] key_E="key_E";
parameter [39:0] key_F="key_F";
parameter [39:0] None="None";
keypad U1(.clock(clock),.reset(reset), .row(row),.code(code),.vaild(vaild),.col(col));
//top module
row_signal U2(.row(row),.key(key),.col(col));// Simulatesignal generation
always@(key)
begin
case(key)
16'h0000: pressed=None;
16'h0001: pressed=key_0;
16'h0002: pressed=key_1;
16'h0004: pressed=key_2;
16'h0008: pressed=key_3;
16'h0010: pressed=key_4;
16'h0020: pressed=key_5;
16'h0040: pressed=key_6;
16'h0080: pressed=key_7;
16'h0100: pressed=key_8;
16'h0200: pressed=key_9;
16'h0400: pressed=key_A;
16'h0800: pressed=key_B;
16'h1000: pressed=key_C;
16'h2000: pressed=key_D;
16'h4000: pressed=key_E;
16'h8000: pressed=key_F;
default:pressed=None;
endcase
end
initial #2000 $stop;
initial
begin
clock=O;
forever #5 clock=~clock;
end
initial
begin
reset=1;
#10 reset=0;
end
initial
begin
for(k=O;k<=1;k=k+1)
begin
key=0;
#20 for(j=0;j<=16;j=j+1)
begin
#20 key[j]=1;
#60 key=0;
end
end
end
endmodule