【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验二:按键模块① - 消抖

时间:2022-04-02 14:42:26

实验二:按键模块① - 消抖

按键消抖实验可谓是经典中的经典,按键消抖实验虽曾在《建模篇》出现过,而且还惹来一堆麻烦。事实上,笔者这是在刁难各位同学,好让对方的惯性思维短路一下,但是惨遭口水攻击 ... 面对它,笔者宛如被甩的男人,对它又爱又恨。不管怎么样,如今 I’ll be back,笔者再也不会重复一样的悲剧。

按键消抖说傻不傻说难不难。所谓傻,它因为原理不仅简单(就是延迟几下下而已),而且顺序语言(C语言)也有无数不尽的例子。所谓难,那是因为人们很难从单片机的思维跳出来 ... 此外,按键消抖也有许多细节未曾被人重视,真是让人伤心。按键消抖一般有3段操作:

l 检测电平变化;

l 过滤抖动(延迟);

l 产生有效按键。

假设C语言与单片机的组合想要检测电平变化,它们一般是利用if查询或者外部中断。事后,如果这对组合想要过滤抖动,那么可以借用for延迟的力量,又或者依赖定时中断产生精明的延迟效果。反观有效案件的产生,这对组合视乎而外钟情“按下有效”似的 ... 不管怎么样,C语言与单片机这对组合在处理按键的时候,它们往往会错过一些黄金。

“黄金?”,读者震撼道。

所谓黄金时间就是电平发生变化那一瞬间,还有消抖(延迟)以后那一瞬间。按键按下期间,按键的输入电平故会发生变化,如果使用if查询去检测,结果很容易浪费单片机的处理资源,因为单片机必须一直等待 ... 换之,如果反用外部中断,中断寻址也会耽误诺干时间。

假设C语言与单片机这对组合挨过电平检测这起难关,余下的困难却是消抖动作。如果利用for循环实现去消抖,例如 Delay_ms(10) 之类的函数。For循环不仅计数不紧密,而且还会白白浪费单片机的处理资源。定时中断虽然计数紧密,但是中断触发依然也会产生诺干的寻址延迟。补上,所谓寻址延迟是处理器处理中断触发的时候,它要事先保护现场之余,也要寻址中断处理入口,然后执行中断函数,完后回复现场,最后再返回当前的工作。

感觉上,笔者好似在欺负C语言以及单片机,死劲说它们的不是。亲爱的读者,千万别误会,笔者只是在陈述事实而已。单片机本来就是比较粗野的爷们,它很难做到紧凑又毫无空隙的操作,反观FPGA却异常在行。所以说,单片机的思路很难沿用在FPGA身上,否则会出现许多笑话。如今,这是描述语言以及FPGA的新时代,所谓后浪推前浪正是新旧时代的替换。

FPGA不仅没有隐性处理,而且描述语言也是*自身。我们只要方法得当,手段有效,“黄金”要多少就有多少 ... 哇哈哈!在此,笔者说了那么多废话只是告知读者,千万别用单片机的思维去猜摸FPGA如何处理按键校抖,不然问号会没完没了。好了,废话差不多说完了,让我们切回主题吧。

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验二:按键模块① - 消抖

图2.1 按键活动的时序示意图。

如图2.1 所示,那是按键活动的时序图。高电为平按键默认状态,按键一旦按下,“按下事件”就发生了,电平随之发生抖动,抖动周期大约为10ms。事后,如果按键依然按着不放,那么电平便会处于低电平。换之,如果按键此刻被释放,那么“释放事件”发生了,电平随之由低变高,然后发生抖动,抖动周期大约为10ms。笔者曾在前面说过,按键消抖组一般有3个工作要做,亦即检测电平变化,过滤抖动,还有产生有效按键。

检测电平变化:

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验二:按键模块① - 消抖

图2.2 按键电平变化,按下事件与释放事件。

顾名思义,检测电平变化就是用来察觉“按下事件”还有“释放事件”,或者监控电平的状态变化。如图2.2所示,笔者建立一组寄存器F1~F2,F1暂存当前的电平状态,F2则暂存上一个时钟的电平状态。Verilog语言可以这样表示,如代码2.1所示:

reg F2,F1;
always @ ( posedge CLOCK )
    { F2,F1 } <= { F1,KEY };

代码2.1所示

根据图2.2的显示,按下事件是 F2 为1值,F1为0值;释放事件则是 F2为0值,F1为1值。为了不要错过电平变化的黄金时间,“按下事件”还有“释放事件”必须作为“即时“,为此 Verilog语言可以这样表示:

wire isH2L = ( F2 == 1 && F1 == 0 );
wire isL2H = ( F2 == 0 && F1 == 1 );

过滤抖动:

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验二:按键模块① - 消抖

图2.3 过滤抖动。

过滤抖动就是也可以称为延迟抖动,常规又廉价的机械按键,抖动时间大约是10ms之内,如图2.3.所示。抖动一般都发生在“按下事件”或者“释放事件”以后,过滤抖动就是延迟诺干时间即可。Verilog语言则可以这样表示,如代码2.2所示:

3: 
if( C1 == T10MS -1 ) begin C1 <= 19'd0; i <= i + 1'b1; end
else C1 <= C1 + 1'b1;

代码2.2

产生有效按键:

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验二:按键模块① - 消抖

图2.4 产生有效按键。

产生有效按键亦即立旗有效的按键事件,如图2.4所示,按下有效isPress信号,还有释放有效isRelease信号,两个信号分别都是拉高一个时钟。除了常见的按下有效或者释放有效以外,根据设计要求,有效按键按也有其它,例如:按键按下两下有效(双击),按键按下一段时间有效(长击)。至于Verilog语言则可以这样表示,如代码2.3所示:

1: begin isPress <= 1'b1; i <= i + 1'b1; end               
2: begin isPress <= 1'b0; i <= i + 1'b1; end
...
1: begin isRelease <= 1'b1; i <= i + 1'b1; end               
2: begin isRelease <= 1'b0; i <= i + 1'b1; end

代码2.3

热身完毕后,我们就可以进入实验主题了。

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验二:按键模块① - 消抖

图2.5 实验二建模图。

如图2.5所示,哪里有一块名为 key_funcmod 的功能模块,输入端为 KEY信号,输出端却为 LED信号。KEY信号连接按键资源,LED信号分别驱动两位LED资源。按键功能模块的工作主要是过滤 KEY信号变化以后所发生的抖动,接着产生“按下有效”还有“释放有效”两个有效按键,然后点亮LED资源。

key_funcmod.v
1.    module key_funcmod
2.    (
3.         input CLOCK, RESET,
4.         input KEY,
5.         output [1:0]LED
6.    );

以上内容为出入端声明。

7.         parameter T10MS = 19'd500_000;
8.         
9.         /***************************/ //sub
10.         
11.         reg F2,F1; 
12.             
13.         always @ ( posedge CLOCK or negedge RESET ) 
14.             if( !RESET ) 
15.                  { F2, F1 } <= 2'b11;
16.              else 
17.                  { F2, F1 } <= { F1, KEY };
18.                    
19.         /***************************/ //core            
20.        
21.        wire isH2L = ( F2 == 1 && F1 == 0 );
22.        wire isL2H = ( F2 == 0 && F1 == 1 );

以上内容为常量声明以及电平检测的周边操作。第7行则是10ms的常量声明,第11~17则是电平状态检测的周边操作。至于第21~22行则是“按下事件”还有“释放事件”的即时声明。

23.         reg [3:0]i;         
24.         reg isPress, isRelease;
25.         reg [18:0]C1;
26.         
27.         always @ ( posedge CLOCK or negedge RESET )
28.             if( !RESET )
29.                   begin
30.                          i <= 4'd0;
31.                         { isPress,isRelease } <= 2'b00;
32.                         C1 <= 19'd0;
33.                     end
34.              else

以上内容为相关的寄存器声明以及复位操作。i用来指向步骤,isPress与 isRelease则标示按下有效亦即释放有效,C1则用来计数。

35. case(i)

36.

37.         0: // H2L check

38.         if( isH2L ) i <= i + 1'b1;

39.

40.         1: // H2L debounce

41.         if( C1 == T10MS -1 ) begin C1 <= 19'd0; i <= i + 1'b1; end

42.         else C1 <= C1 + 1'b1;

43.

44.         2: // Key trigger prees up

45.         begin isPress <= 1'b1; i <= i + 1'b1; end

46.

47.         3: // Key trigger prees down

48.         begin isPress <= 1'b0; i <= i + 1'b1; end

49.

50.         4: // L2H check

51.         if( isL2H ) i <= i + 1'b1;

52.

53.         5: // L2H debounce

54.         if( C1 == T10MS -1 ) begin C1 <= 19'd0; i <= i + 1'b1; end

55.         else C1 <= C1 + 1'b1;

56.

57.         6: // Key trigger prees up

58.        begin isRelease <= 1'b1; i <= i + 1'b1; end

59.

60.         7: // Key trigger prees down

61.        begin isRelease <= 1'b0; i <= 4’d0; end

62.       
63. endcase

以上内容为核心操作。具体的核心操作过程如下:

步骤 0 等待电平由高变低;

步骤 2 用来过滤由高变低所引发的抖动;

步骤 1~3 用来产生按下有效的高脉冲;

步骤 4 等待电平由低变高;

步骤 5 用来过滤由低变高所引发的抖动;

步骤 6~7 用来产生释放有效的高脉冲,然后返回步骤 0。

 
64.        
65.        /***********************/ // sub-demo
66.        
67.        reg [1:0]D1;
68.        
69.        always @ ( posedge CLOCK or negedge RESET )
70.             if( !RESET )
71.                 D1 <= 2'b00;
72.             else if( isPress )
73.                 D1[1] <= ~D[1];
74.             else if( isRelease )
75.                 D1[0] <= ~D[0];
76.                    
77.        assign LED = D1;
78.    
79.    endmodule

以上内容为演示用的周边操作,它根据 isPress 还有 isRelease 的高脉冲,分别翻转 D1[1] 还有 D1[0]的内容。至于第77行则是输出驱动的声明,D1驱动LED输出端。编译完后便下载程序。

我们会发现第一次按下 <KEY2> 会点亮 LED[1],释放<KEY2>会点亮 LED[0]。第二次按下 <KEY2> 会消灭 LED[1],释放 <KEY2> 则会消灭 LED[0]。如此一来,实验二已经成功。实验二未结束之前,让笔者分析一下实验二的诺干细节:

细节一:过分消抖

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验二:按键模块① - 消抖

图2.6 过分消抖(过分延迟)。

结果如图2.6所示,假设笔者手痒将消抖时间拉长至1s,Verilog语言则可以这样表示,如代码2.4所示:

    3: 
    if( C1 == T1S -1 ) begin C1 <= 19'd0; i <= i + 1'b1; end
    else C1 <= C1 + 1'b1;

代码2.4

一般消抖期间,按键功能模块的核心操作就会停留在消抖(延迟)步骤,如果消抖期间笔者释放按键,那么释放事件会被无视,然后核心操作会被打乱,最后整个功能模块会跑飞。反之,如果笔者等待消抖完毕再释放按键,那么释放事件会照常发生,整个功能模块也会照常运作。

细节二:精密控时

 

1: // H2L debounce

if( C1 == T10MS -1 ) begin C1 <= 19'd0; i <= i + 1'b1; end

else C1 <= C1 + 1'b1;

2: // Key trigger prees up

begin isPress <= 1'b1; i <= i + 1'b1; end

3: // Key trigger prees down

begin isPress <= 1'b0; i <= i + 1'b1; end

代码2.5

根据按键功能模块,核心操作执行消抖之后都会产生有效按键,亦即为立旗寄存器

(isPress 或者 isRelease)拉高又拉低一个时钟,如代码 2.5 所示。如果笔者是一位精

密控时的狂人,这段拉高又拉低的时钟消耗,笔者也会将其考虑进去消抖时间。为此,

笔者可以这样修改,如代码 2.6 所示:

1: // H2L debounce
if( C1 == T10MS -1 -2 ) begin C1 <= 19'd0; i <= i + 1'b1; end
else C1 <= C1 + 1'b1;
2: // Key trigger prees up
begin isPress <= 1'b1; i <= i + 1'b1; end
3: // Key trigger prees down
begin isPress <= 1'b0; i <= i + 1'b1; end

代码2.6

代码2.6相较代码2.6,消抖步骤部分的if判断内多了 -2,其中 -2表示产生按键有效所消耗的时钟。

细节三:完整的个体模块

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验二:按键模块① - 消抖

图2.7 完整的按键功能模块。

图2.6是演示用的建模图,然而图2.7则是完整的建模图,其中按键功能模块有一个 KEY输入端,主要连接按键资源。此外,按键功能模块也有一组两位的沟通信号Trig,亦即按下Trig[1]产生一个高脉冲,释放Trig[0]产生一个高脉冲。

key_funcmod.v
1. module key_funcmod

2. (   
3.     input CLOCK, RESET,

4.     input KEY,

5.     output [1:0]oTrig

6. );

7.     parameter T10MS = 19'd500_000;

8.

9.     /***************************/ //sub

10.

11.     reg F2,F1;

12.

13.     always @ ( posedge CLOCK or negedge RESET )

14.         if( !RESET )

15.             { F2, F1 } <= 2'b11;

16.         else

17.             { F2, F1 } <= { F1, KEY };

18.

19.    /***************************/ //core

20.

21.    wire isH2L = ( F2 == 1 && F1 == 0 );

22.    wire isL2H = ( F2 == 0 && F1 == 1 );

23.    reg [3:0]i;

24.    reg isPress, isRelease;

25.    reg [18:0]C1;

26.

27.     always @ ( posedge CLOCK or negedge RESET )

28.         if( !RESET )

29.             begin

30.                 i <= 4'd0;

31.                 { isPress,isRelease } <= 2'b00;

32.                 C1 <= 19'd0;

33.             end

34.         else

35.             case(i)

36.

37.                 0: // H2L check

38.                 if( isH2L ) i <= i + 1'b1;

39.

40.                 1: // H2L debounce

41.                 if( C1 == T10MS -1 ) begin C1 <= 19'd0; i <= i + 1'b1; end

42.                 else C1 <= C1 + 1'b1;

43.

44.                 2: // Key trigger prees up

45.                 begin isPress <= 1'b1; i <= i + 1'b1; end

46.

47.                 3: // Key trigger prees down

48.                 begin isPress <= 1'b0; i <= i + 1'b1; end

49.

50.                 4: // L2H check

51.                 if( isL2H ) i <= i + 1'b1;

52.

53.                 5: // L2H debounce

54.                 if( C1 == T10MS -1 ) begin C1 <= 19'd0; i <= i + 1'b1; end

55.                 else C1 <= C1 + 1'b1;

56.

57.                 6: // Key trigger prees up

58.                 begin isRelease <= 1'b1; i <= i + 1'b1; end

59.

60.                 7: // Key trigger prees down

61.                 begin isRelease <= 1'b0; i <= 4’d0; end

62.

63.         endcase

64.

65.         /********************************/

66.

67. assign oTrig = { isPress, isRelease };

68.       
69. endmodule

最后别向笔者要仿真了,因为按键消抖没有仿真的意义,单是代码已经足够脑补时序了。