【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验十：PS/2模块④ — 普通鼠标

实验十：PS/2模块④ — 普通鼠标

学习PS/2键盘以后，接下来就要学习 PS/2 鼠标。PS/2鼠标相较PS/2键盘，驱动难度稍微高了一点点，因为FPGA（从机）不仅仅是从PS/2鼠标哪里读取数据，FPGA还要往鼠标里写数据 ... 反之，FPGA只要对PS/2键盘读取数据即可。然而，最伤脑筋的地方就在于PS/2传输协议有奇怪的写时序。

图10.1 从机视角，从机读数据。

为了方便理解，余下我们经由从机的视角去观察PS/2的读写时序。图10.1是从机视角的读时序，从机都是皆由 PS2_CLK的下降沿读取1帧为11位的数据 ... 期间，有11个下降沿，不过为了方便调用，笔者将其整理为伪函数，结果如代码10.1所示：

1.    32: // Start bit
2.    if( isH2L ) i <= i + 1‘b1; 
3.                          
4.    33,34,35,36,37,38,39,40:  // Data byte
5.    if( isH2L ) begin T[i-33] <= PS2_DAT; i <= i + 1‘b1;  end
6.                          
7.    41: // Parity bit
8.    if( isH2L ) i <= i + 1‘b1;
9.                          
10.    42: // Stop bit
11.    if( isH2L ) i <= Go;

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

代码10.1

图10.2从机视角，从机写数据，第一帧。

首先我们必须明白，PS2_CLK 与 PS2_DAT 信号是双向的IO口，由于FPGA是从机的关系，所以FPGA一开始都处于输入状态，而PS/2鼠标一开始则处于输出状态。假设 isQ1 是FPGA针对PS2_CLK的输出控制，isQ2 是FPGA针对 PS2_DAT 的输出控制，然而复位状态（初始化）都为拉低状态。

FPGA为了获取数据的发送权，首先它必须摘取 PS2_CLK，亦即拉高 isQ1然后又拉低PS2_CLK 100us。

事后，FPGA必须释放 PS2_CLK，亦即关闭 IO或者拉低 isQ1，期间顺手拉高 isQ2，让 PS2_DAT 成为输出状态。那么重点来了，读者是否看见黄色的圈圈？当FPGA释放 PS2_CLK瞬间，PS/2鼠标早已拉低 PS2_CLK，FPGA也因此错过PS2_CLK第一次珍贵的下降沿。在此，读者需要好好注意，因为许多资料都忽略这点，笔者也不小心扑街好几次。

读者需要知道，根据PS/2传输协议，从机（FPGA）不管怎样挣扎也没有 PS2_CLK的拥有权。换句话说，无论从机（FPGA）是写数据还是读数据，从机（FPGA）都必须借助主机（PS/2鼠标）发送过来的 PS2_CLK下降沿。如果我们不小心忽略第一个下降沿，余下几个下降沿，我们也会搞错次序，最终造成数据读取错位的悲剧。

FPGA无论是写数据还是读数据，从机都必须借用 PS2_CLK 的下降沿。FPGA释放PS2_CLK之后，isQ2立即拉高，PS2_DAT 也随之拉低以示一帧数据的起始位 ... 直至下一个下降沿到来为此。

FPGA一共用了10个下降沿，即T0~T9发送8位数据位，1位校验位，还有1位停止位。T9过去不久，PS2_CLK就会引来上升沿，此刻PS/2鼠标则会反馈1位应答位，不过此刻也无暇招呼它。T10之际，那是最后一个下降沿，FPGA拉低isQ2让PS2_DAT成为输入状态，并且读取应答位，然而懒惰的笔者决定无视它。就这样从机写一帧数据就结束了。

在这里，读者是否觉得从机写一帧数据比从机读一帧数据还要麻烦呢？没错，笔者也这样觉得。可是，麻烦归麻烦，余下我们还要完成Verilog的描述工作，结果如代码10.2所示：

1.                  /****************/ // PS2 Write Function
2.                          
3.                 32: // Press low CLK 100us 
4.                if( C1 == T100US -1 ) begin C1 <= 13‘d0; i <= i + 1‘b1; end
5.                else begin isQ1 = 1‘b1; rCLK <= 1‘b0; C1 <= C1 + 1‘b1; end
6.                          
7.                33: // Release PS2_CLK and set in, PS2_DAT set out
8.                begin isQ1 <= 1‘b0; rCLK <= 1‘b1; isQ2 <= 1‘b1; i <= i + 1‘b1; end
9.                          
10.                34: // start bit 
11.                begin rDAT <= 1‘b0; i <= i + 1‘b1; end
12.                          
13.                35,36,37,38,39,40,41,42,43:  // Data byte 
14.                if( isH2L ) begin rDAT <= T[ i-35 ]; i <= i + 1‘b1; end
15.                          
16.                44: // Stop bit 
17.                if( isH2L ) begin rDAT <= 1‘b1; i <= i + 1‘b1; end
18.                          
19.                45: // Ack bit
20.                if( isH2L ) begin i <= i + 1‘b1; end
21.                          
22.                46: // PS2_DAT set in
23.                begin isQ2 <= 1‘b0; i <= i + 1‘b1; end
24.                  。。。。。。
25.     
26.      assign PS2_CLK = isQ1 ? rCLK : 1‘bz;
27.      assign PS2_DAT = isQ2 ? rDAT : 1‘bz;

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

代码10.2

如代码10.2所示：

步骤32，来拉高 isQ1又拉低 rCLK 持续 100us。

步骤33，拉低 isQ1释放 PS2_CLK，然后又拉高 isQ2 准备发送数据。

步骤34，重点！由于错过第一个下降沿，我们只能拉低 rDAT产生起始位。

步骤35~43，发送8位数据位，还有1位校验位。

步骤44，发送结束位。

步骤45，无视应答位。

步骤46，拉低isQ2，让PS2_CLK为输入状态。

图10.3主机视角，从机写数据，第一帧。

接下来，让我们经由主机的视角去观察，主机如何读取从机发送过来的数据。初始状态，主机亦即 PS/2鼠标掌握 PS2_CLK与 PS2_DAT。一旦从机即FPGA载取PS2_CLK，并且拉低输出100us，立刻PS/2鼠标已经理解从机准备发送数据。100us过后，FPGA释放 PS2_CLK并且载取PS2_DAT，PS/2鼠标便开始产生时钟。如图10.2所示，PS/2鼠标都是借用上升沿读取FPGA发送过来的数据。大约11个上升沿过后，PS/2鼠标就结束读取动作，并且反馈应答位。

图10.4主机视角，从机写数据，第二帧。

每当主机接收完毕一帧数据，就会反馈一帧数据。如图10.2所示，那是图10.1的下半部分，依然是从主机视角观察从机写数据。图中显示，每当PS/2鼠标（主机）接收完毕一帧数据以后，PS/2鼠标便会反馈一帧数据，亦即PS/2鼠标会再度借用10个上升沿发送一帧数据。期间，FPGA（从机）的 PS2_CLK 与 PS2_DAT都都处于输入状态。

图10.5主机视角，从机写数据，完整时序。

图10.5是图10.3与图10.4的完整时序（主机视角）。

图10.6从机视角，从机写数据，第二帧。

既然主机反馈一帧数据，那么从机也不能无视，如图10.6所示，那是经由从机视角观察从机如何读取下一帧数据。期间，从机借用11个下降沿读取1一帧数据。

图10.7从机视角，从机写数据，完整时序。

图10.7是图10.2与图10.5的完整时序（从机视角）。

为此，代码10.2可以继续扩张，结果如代码10.3所示：

1.           /****************/ // PS2 Write Function
2.    
3.            32: // Press low CLK 100us 
4.            if( C1 == T100US -1 ) begin C1 <= 13‘d0; i <= i + 1‘b1; end
5.            else begin isQ1 = 1‘b1; rCLK <= 1‘b0; C1 <= C1 + 1‘b1; end
6.                          
7.            33: // Release PS2_CLK and set in, PS2_DAT set out
8.            begin isQ1 <= 1‘b0; rCLK <= 1‘b1; isQ2 <= 1‘b1; i <= i + 1‘b1; end
9.                          
10.            34: // start bit 
11.            begin rDAT <= 1‘b0; i <= i + 1‘b1; end
12.                          
13.            35,36,37,38,39,40,41,42,43:  // Data byte 
14.            if( isH2L ) begin rDAT <= T[ i-35 ]; i <= i + 1‘b1; end
15.                          
16.            44: // Stop bit 
17.            if( isH2L ) begin rDAT <= 1‘b1; i <= i + 1‘b1; end
18.                          
19.            45: // Ack bit
20.            if( isH2L ) begin i <= i + 1‘b1; end
21.                          
22.            46: // PS2_DAT set in
23.            begin isQ2 <= 1‘b0; i <= i + 1‘b1; end
24.                          
25.            47,48,49,50,51,52,53,54,55,56,57: // 1 Frame
26.            if( isH2L ) i <= i + 1‘b1;
27.                          
28.            58: // Return
29.            i <= Go;
30.            
31.           ......
32.      
33.        assign PS2_CLK = isQ1 ? rCLK : 1‘bz;
34.        assign PS2_DAT = isQ2 ? rDAT : 1‘bz;

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

代码10.3

步骤32~46曾在前面说过，即从机发送一帧数据。余下步骤47~57（共有11个步骤），主要用来过滤主机反馈过来的下一帧数据，步骤58则是步骤返回。不过为什么步骤47~57不是读取数据，而是过滤数据？别着急，答案很快就会揭晓，暂时忍耐一下。

呼！PS/2传输协议的写数据（从机视角）解释起来真有够呛。最后让我们来总结一下,主机无论是输出数据，还是读取数据都是借用 PS2_CLK的上升沿。反之，从机无论是输出数据，还是读取数据都是借用 PS2_CLK 的下降沿。PS/2传输协议是可谓是爷爷级别的传输协议吧，因为近代的传输协议不管对象是从机还是主机，或者是写还是读，一般都是上升沿设置数据下降沿锁存数据。很少情况是主机使用一个时间沿，从机使用另一个时间沿，例如 SPI传输协议就是最好的例子。

说完PS/2传输协议，接下来我们要进入PS/2鼠标的主题了。

鼠标也有普通鼠标与滚扩展鼠标之分 ... 所谓普通鼠标就是包含左键，中建还有右键；所谓扩展鼠标则包含左键，中建，右键还有滚轮，扩展鼠标也称为滚轮鼠标，不过一般的扩展鼠标只有一个滚轮而已。实验十的实验目的就是驱动普通鼠标。PS/2鼠标不像PS/2键盘，PS/2鼠标即使一上电也不会立即工作，期间从机必须将它使能才行。

普通鼠标一旦上电就便会立即复位，然后得到默认化参数，并且进入Steam模式。所谓Steam模式，即位置状况或者按键状况一有变化就会鼠标便会立即发送报告。话虽然那么说，实际上 Stream 模式还要依赖采集频率，默认的采集频率是 100次/秒，即采集间隔为10ms，也就是说鼠标在一秒内会检测100次位置状况还有按键状况。

举例而言，假设笔者按着左键不放，那么鼠标在一秒内会发送100次“左键好疼！左键好疼！“，直至笔者释放左键为止。再假设鼠标不小心被笔者退了一下，然后鼠标在10ms内向左移动10mm，当鼠标察觉位置状况发生变化以后，鼠标便会发送“哎呀！被人推向左边10mm了!”。

图10.7.1 鼠标的位置标示。

鼠标为了标示位置，内建2组9位的寄存器X与Y，结果如图10.7.1所示。默认下，鼠标的分辨率为4计数/mm。此外，鼠标也有能力辨识4处的移动方向，例如左移 10mm 寄存器X便计数 -40，右移10mm 寄存器X便计数 +40，上移10mm 寄存器Y便计数 +40，下移 10mm 寄存器Y便计数 -40。鼠标每隔10ms（默认采集频率）便会清零一次寄存器X与Y的内容。

PS/2鼠标不像PS/2键盘一上电便立即工作，我们必须事先发送命令8’hF4即“使能鼠标发送数据”，开启数据的水龙头。每当鼠标接收一帧数据，鼠标便会反馈一帧数据，为此 ... 从机每次向鼠标写入一帧数据，就必须接收一帧反馈数据。反馈数据为8’hFA表示“数据接收成功”，反馈数据为 8’hFE表示“第一帧数据接收失败”，反馈数据为 8’hFC则表示“第二帧数据接收成功”（有些命令是由2帧或者以上组成）。

图10.8 从机发送 “使能报告”命令，鼠标反馈接收成功。

为了驱使鼠标工作，PS/2鼠标上电以后，从机必须发送命令 8’hF4，并且接收反馈 8’hFA。如果一切顺利，那么鼠标就会开始工作，结果如图10.8所示。鼠标“使能”以后，鼠标便处于就绪状态，采集便开始 ... 此刻，如果鼠标的位置状况或者按键状况发生变化，鼠标就会发送3帧，亦即3字节的报告。

图10.9 鼠标发送报告。

如图10.9所示，那是一份3个字节的报告，Verilog可以这样描述：

1.               0: // Read 1st byte
2.              begin i <= FF_Read; Go <= i + 1‘b1; end
3.                          
4.              1: // Store 1st byte
5.              begin D1[7:0] <= T; i <= i + 1‘b1; end
6.                          
7.              2: // Read 2nd byte
8.              begin i <= FF_Read; Go <= i + 1‘b1; end
9.                          
10.              3: // Store 2nd byte
11.              begin D1[15:8] <= T; i <= i + 1‘b1; end
12.                          
13.              4: // Read 3rd byte
14.              begin i <= FF_Read; Go <= i + 1‘b1; end
15.                          
16.             5: // Store 3rd byte
17.             begin D1[23:16] <= T; i <= i + 1‘b1; end
18.                          
19.              ......                      
20.                          
21.            32: // Start bit
22.            if( isH2L ) i <= i + 1‘b1; 
23.                          
24.            33,34,35,36,37,38,39,40:  // Data byte
25.            if( isH2L ) begin T[i-33] <= PS2_DAT; i <= i + 1‘b1;  end
26.                          
27.            41: // Parity bit
28.            if( isH2L ) i <= i + 1‘b1;
29.                          
30.            42: // Stop bit
31.            if( isH2L ) i <= Go;

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

代码10.4

步骤32~42是读一帧数据的伪函数，步骤0~1读取第一字节并且暂存道D[7:0]，步骤

2~3读取第二字节并且暂存到D[15:8]，步骤4~5读取第三字节并且暂存到D[23:16]。

至于报告的内容如表10.1所示：

表10.1 普通鼠标的报告。


字节/位
[7]
[6]
[5]
[4]
[3]
[2]
[1]
[0]

字节一
Y溢出位
X溢出位
Y[8]符号位
X[8]符号位
保留
中键
右键
左键

字节二
X[7:0]

字节三
Y[7:0]

如表10.1所示，字节一的第四位表示按键状况以外，字节一的高四位也与内部寄存器X与Y有关。字节二为寄存器X的内容，字节三位寄存器Y的内容。

字节一，[0]标示左键，1表示左键按下；[1]标示右键，1表示右键按下；[2]标示中键，1表示中键按下；[4]为字寄存器的最高位也是符号位；[5]为寄存器最高位也是符号位；节二是寄存器X的低八位，字节三是寄存器Y的低八位，因此寄存器X与Y的位宽为9。这样作的目的是为了使用补码表示鼠标的移动状况。至于补码是什么？失忆的朋友请复习《时序篇》。

图10.9.1 鼠标的有效位置。

假设寄存器X的内容为 9’b1_1111_1100，[8]为1’b1表示鼠标正在左移，[7:0]为8’b1111_1100也是 8个计数，亦即移动2mm的距离。因此 9’b1_1111_1100 表示鼠标左移2mm的举例。再假设寄存器Y的内容为 9’b0_0001_0000，[8]为0表示鼠标正在上移，[7:0] 为 8’b0001_0000也是16个计数，亦即移动4mm。因此 9’b0_0001_0000表示鼠标上移4mm。结果如图10.9.1所示。

上述内容理解完毕以后，我们便可以开始建模了。

图10.10 实验十的建模图。

图10.10 是实验十的建模图，组合模块 ps2_demo 内部包含，PS/2初始化功能模块，PS/2读功能模块，数码管基础模块，然后中间还要正直化的即时操作。顾名思义，PS/2初始化功能模块主要负责初始化的工作，简言之就是发送命令 8’hF4，完后便拉高oEn使能PS/2读功能模块。PS/2读功能模块接收 iEn拉高便会开始读取3字节的报告，并且经由oData将其输出。

稍微注意一下PS2_CLK还有PS2_DAT顶层信号，由于PS/2初始化功能模块需要双向访问PS/2鼠标，为此该顶层信号皆是出入状态（IO）。反之，PS/2读功能模块只有接收数据而已，因此该顶层信号只是出入状态。PS/2读功能模块的oData，其中[2:0]是3只按键的状况，并且直接驱动三位LED资源。

至于[23:4]则是寄存器X与寄存器Y的内容，它们经由即时操作正直化以后便联合驱动数码管基础模块，然后再显示内容。

ps2_init_funcmod.v

图10.11 PS/2 初始化功能模块的建模图。

由于该模块需要来问读写PS/2鼠标，因此顶层信号 PS2_CLK与 PS2_DAT 都是双向，亦即IO口。此外，一旦该模块完成初始化的工作，oEn就会一直拉高。

1.    module ps2_init_funcmod
2.    (
3.         input CLOCK, RESET,
4.         inout PS2_CLK, 
5.         inout PS2_DAT,
6.         output oEn
7.    );  
8.         parameter T100US = 13‘d5000;
9.         parameter FF_Write = 7‘d32;

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

以上内容是出入端声明。第8行是100us的常量声明，第9行则是伪函数的入口。

11.         /*******************************/ // sub1
12.         
13.        reg F2,F1; 
14.         
15.        always @ ( posedge CLOCK or negedge RESET )
16.             if( !RESET )
17.                  { F2,F1 } <= 2‘b11;
18.              else 
19.                  { F2, F1 } <= { F1, PS2_CLK };
20.    
21.         /*******************************/ // Core
22.         
23.         wire isH2L = ( F2 == 1‘b1 && F1 == 1‘b0 );

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

以上是检测电平变化的周边操作。第23行则是下降沿的即时声明。

24.         reg [8:0]T;
25.         reg [6:0]i,Go;
26.         reg [12:0]C1;
27.         reg rCLK,rDAT;
28.         reg isQ1,isQ2,isEn;
29.         
30.         always @ ( posedge CLOCK or negedge RESET )
31.             if( !RESET )
32.                  begin
33.                         T <= 9‘d0;
34.                         C1 <= 13‘d0;
35.                         { i,Go } <= { 7‘d0,7‘d0 };
36.                         { rCLK,rDAT } <= 2‘b11;
37.                         { isQ1,isQ2,isEn } <= 3‘b000;
38.                    end
39.               else

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

以上内容为相关的寄存器声明以及复位操作。注意，PS2_CLK与PS2_DAT默认下都是高电平，所示 rCLK 与 rDAT 被赋予复位值 2’b11。

40.                    case( i )
41.
42.                         /***********/ // INIT Normal Mouse
43.
44.                          0: // Send F4 1111_0100
45.                          begin T <= { 1‘b0, 8‘hF4 }; i <= FF_Write; Go <= i + 1‘b1; end
46.
47.                          1:
48.                          isEn <= 1‘b1;
49.

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

以上内容是部分核心操作。步骤0~1是主操作，主要发送命令 8’hF4，然后拉高isEn。第45行{ 1‘b0, 8‘hF4 }，其中 1’b0是校验位，PS/2的校验位是“奇校验”，如果“1”的数量为单数，那么校验位便是 0。如第45所示，8’hF4有5个“1”所示，校验位为0。

50.                          /****************/ // PS2 Write Function
51.                          
52.                          32: // Press low CLK 100us 
53.                          if( C1 == T100US -1 ) begin C1 <= 13‘d0; i <= i + 1‘b1; end
54.                          else begin isQ1 = 1‘b1; rCLK <= 1‘b0; C1 <= C1 + 1‘b1; end
55.                          
56.                          33: // Release PS2_CLK and set in, PS2_DAT set out
57.                          begin isQ1 <= 1‘b0; rCLK <= 1‘b1; isQ2 <= 1‘b1; i <= i + 1‘b1; end
58.                          
59.                          34: // start bit 
60.                          begin rDAT <= 1‘b0; i <= i + 1‘b1; end
61.                          
62.                          35,36,37,38,39,40,41,42,43:  // Data byte 
63.                          if( isH2L ) begin rDAT <= T[ i-35 ]; i <= i + 1‘b1; end
64.                          
65.                          44: // Stop bit 
66.                          if( isH2L ) begin rDAT <= 1‘b1; i <= i + 1‘b1; end
67.                          
68.                          45: // Ack bit
69.                          if( isH2L ) begin i <= i + 1‘b1; end
70.                          
71.                          46: // PS2_DAT set in
72.                          begin isQ2 <= 1‘b0; i <= i + 1‘b1; end
73.                          
74.                          47,48,49,50,51,52,53,54,55,56,57: // 1 Frame
75.                          if( isH2L ) i <= i + 1‘b1;
76.                          
77.                          58: // Return
78.                          i <= Go;
79.                            
80.                     endcase

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

以上内容是部分核心操作。第32~58行是从机写一帧数据，读一帧反馈数据的伪函数。

81.         
82.         assign PS2_CLK = isQ1 ? rCLK : 1‘bz;
83.         assign PS2_DAT = isQ2 ? rDAT : 1‘bz;
84.         assign oEn = isEn;
85.    
86.    endmodule

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }
.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

以上内容是输出驱动声明。

ps2_read_funcmod.v

图10.12 PS/2 读化功能模块的建模图。

PS/2读功能模块，如果iEn不拉高就不工作。此外，该模块也只是读入3字节的报告而已，完后便经由oTrig产生完成信号，报告内容则经由 oData。

1.    module ps2_read_funcmod
2.    (
3.         input CLOCK, RESET,
4.         input PS2_CLK,PS2_DAT,
5.         input iEn,
6.         output oTrig，
7.         output [23:0]oData
8.    );  
9.         parameter FF_Read = 7‘d32;

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

以上内容是出入端声明。第9行则是伪函数的入口地址。

11.         /*******************************/ // sub1
12.         
13.        reg F2,F1; 
14.         
15.        always @ ( posedge CLOCK or negedge RESET )
16.             if( !RESET )
17.                  { F2,F1 } <= 2‘b11;
18.              else 
19.                  { F2, F1 } <= { F1, PS2_CLK };
20.    
21.         /*******************************/ // core
22.         
23.         wire isH2L = ( F2 == 1‘b1 && F1 == 1‘b0 );

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

以上内容是检测电平变化的周边操作，第23行则是下降沿的即时声明。

24.         reg [23:0]D1;
25.         reg [7:0]T;
26.         reg [6:0]i,Go;
27.         reg isDone;
28.         
29.         always @ ( posedge CLOCK or negedge RESET )
30.             if( !RESET )
31.                  begin
32.                         D1 <= 24‘d0;
33.                         T <= 8‘d0;
34.                         { i,Go } <= { 7‘d0,7‘d0 };
35.                         isDone <= 1‘b0;
36.                    end

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

以上内容是相关的寄存器声明以及复位操作。

37.               else if( iEn )  
38.                    case( i )
39.                     
40.                     /*********/ // Normal mouse 
41.                          
42.                          0: // Read 1st byte
43.                          begin i <= FF_Read; Go <= i + 1‘b1; end
44.                          
45.                          1: // Store 1st byte
46.                          begin D1[7:0] <= T; i <= i + 1‘b1; end
47.                          
48.                          2: // Read 2nd byte
49.                          begin i <= FF_Read; Go <= i + 1‘b1; end
50.                          
51.                          3: // Store 2nd byte
52.                          begin D1[15:8] <= T; i <= i + 1‘b1; end
53.                          
54.                          4: // Read 3rd byte
55.                          begin i <= FF_Read; Go <= i + 1‘b1; end
56.                          
57.                          5: // Store 3rd byte
58.                          begin D1[23:16] <= T; i <= i + 1‘b1; end
59.                          
60.                          6:
61.                          begin isDone <= 1‘b1; i <= i + 1‘b1; end
62.                          
63.                          7:
64.                          begin isDone <= 1‘b0; i <= 7‘d0; end
65.

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

以上内容为部分核心操作。第37行 if( iEn ) 表示，iEn不拉高核心操作就不运行。步骤0~1是读取第一字节，步骤2~3是读取第二字节，步骤4~5是读取第三字节，步骤6~7则是反馈完成信号，以示一次性的报告读取已经完成。完后，i便指向步骤0。

66.                          /****************/ // PS2 Write Function
67.                          
68.                          32: // Start bit
69.                          if( isH2L ) i <= i + 1‘b1; 
70.                          
71.                          33,34,35,36,37,38,39,40:  // Data byte
72.                          if( isH2L ) begin T[i-33] <= PS2_DAT; i <= i + 1‘b1;  end
73.                          
74.                          41: // Parity bit
75.                          if( isH2L ) i <= i + 1‘b1;
76.                          
77.                          42: // Stop bit
78.                          if( isH2L ) i <= Go;
79.                            
80.                     endcase

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

以上内容为部分核心操作。步骤32~42则是伪函数，主要是负责读取一帧数据。

81.                     
82.         assign oTrig = isDone;
83.         assign oData = D1;
84.     
85.    endmodule

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

以上内容是输出驱动声明。

ps2_demo.v

组合模块ps2_demo.v的建模图就不再重复粘贴了。

1.    module ps2_demo
2.    (
3.         input CLOCK, RESET,
4.         inout PS2_CLK, PS2_DAT,
5.         output [7:0]DIG,
6.         output [5:0]SEL,
7.         output [2:0]LED
8.    );
9.        wire EnU1;
10.    
11.         ps2_init_funcmod U1
12.         (
13.             .CLOCK( CLOCK ),
14.              .RESET( RESET ),
15.              .PS2_CLK( PS2_CLK ), // < top
16.              .PS2_DAT( PS2_DAT ), // < top
17.              .oEn( EnU1 ) // > U2
18.         );
19.         
20.         wire [23:0]DataU2;
21.         
22.          ps2_read_funcmod U2
23.         (
24.             .CLOCK( CLOCK ),
25.              .RESET( RESET ),
26.              .PS2_CLK( PS2_CLK ), // < top
27.              .PS2_DAT( PS2_DAT ), // < top
28.              .iEn( EnU1 ),       // < U1
29.               .oTrig(),
30.              .oData( DataU2 )   // > U2
31.         );
32.         
33.         // immediate proses
34.         wire[7:0] X = DataU2[4] ? (~DataU2[15:8] + 1‘b1) : DataU2[15:8];
35.         wire[7:0] Y = DataU2[5] ? (~DataU2[23:16] + 1‘b1) : DataU2[23:16];
36.         
37.       smg_basemod U3
38.        (
39.           .CLOCK( CLOCK ),
40.           .RESET( RESET ),
41.            .DIG( DIG ),  // > top
42.            .SEL( SEL ),  // > top
43.            .iData( { 3‘d0,DataU2[5],Y,3‘d0,DataU2[4],X }) // < U2
44.        );
45.        
46.        assign LED = {DataU2[1], DataU2[2], DataU2[0]};
47.                          
48.    endmodule

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

该代码非常简单，第30行表示U2的oTrig无用武之地。第34~35行是正直化的即时声明。第43行是U3的联合驱动，其中 3’d0, DataU2[5] 表示第1位数码管显示Y的符号位，Y表示第2~3位的数码管显示Y的正直结果，3’d0,DataU2[4] 表示第4位数码管显示X的符号位，X表示第5~6位数码管显示X的正直结果。第46行则是各个按键情况直接驱动LED资源。

编译完成并且下载程序。假设笔者按下左键，那么LED[0]便会点亮，释放则消灭。再假设笔者向左移动鼠标，那么鼠标第4位数码管会显示1，第5~6数码管则会显示X的内容，亦即鼠标移动的举例。

细节一：精简与直观

1.        0: // Read 1st byte
2.        begin i <= FF_Read; Go <= i + 1‘b1; end 
3.        1: // Store 1st byte
4.        begin D1[7:0] <= T; i <= i + 1‘b1; end
5.        2: // Read 2nd byte
6.        begin i <= FF_Read; Go <= i + 1‘b1; end
7.        3: // Store 2nd byte
8.        begin D1[15:8] <= T; i <= i + 1‘b1; end
9.        4: // Read 3rd byte
10.        begin i <= FF_Read; Go <= i + 1‘b1; end
11.        5: // Store 3rd byte
12.        begin D1[23:16] <= T; i <= i + 1‘b1; end

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

代码10.5

代码10.5是PS/2读功能模块的部分内容，期间步骤0~5表示3字节读取且暂存的过程

。事实上，代码10.5可以进一步精简，结果如代码10.6所示：

13.        0: // Read 1st byte
14.        begin i <= FF_Read; Go <= i + 1‘b1; end 
15.        1: // Store 1st byte
16.        begin D1[7:0] <= T; i <= FF_Read; Go <= i + 1‘b1;end
17.        2: // Read 2nd byte
18.        begin D1[15:8] <= T； i <= FF_Read; Go <= i + 1‘b1; end
19.        3: // Store 2nd byte
20.        begin  D1[23:16] <= T; i <= i + 1‘b1; end
21.        ......

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

代码10.6

代码10.6相较代码10.5，它虽然有很高程度的精简度，不过直观程度却不如代码10.6。

到头来到底是直观好，还是精简好，唯有见仁见智了。

细节二：完整的个体模块

图10.13 实验十的完整个体模块。

图10.13是PS/2鼠标基础模块，里边包含PS/2初始化功能模块，还有PS/2读功能模块。

该模块的最左边是顶层信号 PS2_CLK 与 PS2_DAT 的输入，鼠标完成初始化以后，PS/2初始化功能模块便会拉高 oEn 使能 PS/2读功能模块。PS/2读功能模块的左边除了顶层信号以外还有iEn，iEn不拉高该模块就不工作。PS/2读功能模块每完成3字节报告的读取，就会经由 oTrig 产生完成信号。

ps2mouse_basemod.v
1.    module ps2mouse_basemod    
2.    (
3.         input CLOCK, RESET,
4.         inout PS2_CLK, PS2_DAT,
5.         output oTrig,
6.         output [31:0]oData
7.    );
8.        wire EnU1;
9.    
10.         ps2_init_funcmod U1
11.         (
12.             .CLOCK( CLOCK ),
13.              .RESET( RESET ),
14.              .PS2_CLK( PS2_CLK ), // < top
15.              .PS2_DAT( PS2_DAT ), // < top
16.              .oEn( EnU1 ) // > U2
17.         );
18.         
19.         ps2_read_funcmod U2
20.         (
21.              .CLOCK( CLOCK ),
22.              .RESET( RESET ),
23.              .PS2_CLK( PS2_CLK ), // < top
24.              .PS2_DAT( PS2_DAT ), // < top
25.              .iEn( EnU1 ),       // < U1
26.              .oTrig( oTrig ),    // > Top
27.              .oData( oData )   // > Top
28.         );
29.                          
30.    endmodule

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

时间： 2024-09-30 15:37:17

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验十：PS/2模块④ — 普通鼠标的相关文章

【黑金原创教程】【FPGA那些事儿-驱动篇I 】连载导读

前言: 无数昼夜的来回轮替以后,这本<驱动篇I>终于编辑完毕了,笔者真的感动到连鼻涕也流下来.所谓驱动就是认识硬件,还有前期建模.虽然<驱动篇I>的硬件都是我们熟悉的老友记,例如UART,VGA等,但是<驱动篇I>贵就贵在建模技巧的升华,亦即低级建模II. 话说低级建模II,读过<建模篇>的朋友多少也会面熟几分,因为它是低级建模的进化形态.许久以前,笔者就有点燃低级建模II的念头,但是懒惰的性格让笔者别扭许久.某天,老大忽然说道:"让咱们大干一场吧

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验六：数码管模块

实验六:数码管模块 有关数码管的驱动,想必读者已经学烂了 ... 不过,作为学习的新仪式,再烂的东西也要温故知新,不然学习就会不健全.黑金开发板上的数码管资源,由始至终都没有改变过,笔者因此由身怀念.为了点亮多位数码管从而显示数字,一般都会采用动态扫描,然而有关动态扫描的信息请怒笔者不再重复.在此,同样也是动态扫描,但我们却用不同的思路去理解. 图6.1 6位数码管. 如图6.1所示,哪里有一排6位数码管,其中包好8位DIG信号还有6位SEL信号.DIG为digit,即俗称的数码管码,如果数码管

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验三：按键模块② — 点击与长点击

实验三:按键模块② - 点击与长点击 实验二我们学过按键功能模块的基础内容,其中我们知道按键功能模块有如下操作: l 电平变化检测: l 过滤抖动: l 产生有效按键. 实验三我们也会z执行同样的事情,不过却是产生不一样的有效按键: l 按下有效(点击): l 长按下有效(长点击). 图3.1 按下有效,时序示意图. 图3.2 长按下有效,时序示意图. 如图3.1所示,按下有效既是"点击",当按键被按下并且消抖完毕以后,isSClick信号就有被拉高一个时钟(Short Click).

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

实验二:按键模块① - 消抖 按键消抖实验可谓是经典中的经典,按键消抖实验虽曾在<建模篇>出现过,而且还惹来一堆麻烦.事实上,笔者这是在刁难各位同学,好让对方的惯性思维短路一下,但是惨遭口水攻击 ... 面对它,笔者宛如被甩的男人,对它又爱又恨.不管怎么样,如今 I'll be back,笔者再也不会重复一样的悲剧. 按键消抖说傻不傻说难不难.所谓傻,它因为原理不仅简单(就是延迟几下下而已),而且顺序语言(C语言)也有无数不尽的例子.所谓难,那是因为人们很难从单片机的思维跳出来 ... 此外,

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验四：按键模块③ — 单击与双击

实验四:按键模块③ — 单击与双击 实验三我们创建了“点击”还有“长点击”等有效按键的多功能按键模块.在此,实验四同样也是创建多功能按键模块,不过却有不同的有效按键.实验四的按键功能模块有以下两项有效按键: l 单击(按下有效): l 双击(连续按下两下有效). 图4.1 单击有效按键,时序示意图. 实验四的“单击”基本上与实验三的“点击”一模一样,既按键被按下,经过消抖以后isSClick信号被拉高一个时钟,结果如图4.1所示,过程非常单调.反之,“双击”实现起来,会比较麻烦一些,因为我们还要

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验五：按键模块④ — 点击，长点击，双击

实验五:按键模块④ — 点击,长点击,双击 实验二至实验四,我们一共完成如下有效按键: l 点击(按下有效) l 点击(释放有效) l 长击(长按下有效) l 双击(连续按下有效) 然而,不管哪个实验都是只有两项“功能”的按键模块而已,如今我们要创建三项“功能”的按键模块,亦即点击(按下有效),长击,还有双击.实验继续之前,让我们先来复习一下各种有效按键. 图5.1 点击(按下有效). 如图5.1所示,所谓点击(按下有效)就是按键按下以后,isSClick信号(Single Click) 产生一

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验九：PS/2模块③ — 键盘与多组合键

实验九:PS/2模块③ — 键盘与多组合键 笔者曾经说过,通码除了单字节以外,也有双字节通码,而且双字节通码都是 8’hE0开头,别名又是 E0按键.常见的的E0按键有,<↑>,<↓>,<←>,<→>,<HOME>,<PRTSC> 等编辑键.除此之外,一些组合键也是E0按键,例如 <RCtrl> 或者 <RAlt> .所以说,当我们设计组合键的时候,除了考虑“左边”的组合键以外,我们也要考虑“右边”的组合键.&

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验七：PS/2模块① — 键盘

实验七:PS/2模块① — 键盘 实验七依然也是熟烂的PS/2键盘.相较<建模篇>的PS/2键盘实验,实验七实除了实现基本的驱动以外,我们还要深入解PS/2时序,还有PS/2键盘的行为.不过,为了节省珍贵的页数,怒笔者不再重复有关PS/2的基础内容,那些不晓得的读者请复习<建模篇>或者自行谷歌一下. 市场上常见的键盘都是应用第二套扫描码,各种扫描码如图7.2所示.<建模篇>之际,笔者也只是擦边一下PS/2键盘,简单读取单字节通码与断码而已.所谓单字节通码,就是有效的按下

【黑金原创教程】【FPGA那些事儿-驱动篇I 】实验八：PS/2模块② — 键盘与组合键

实验八:PS/2模块② — 键盘与组合键 实验七之际,我们学习如何读取PS/2键盘发送过来的通码与断码,不过实验内容也是一键按下然后释放,简单按键行为而已.然而,实验八的实验内容却是学习组合键的按键行为. 不知读者是否有类似的经历?当我们使用键盘的时候,如果5~6按键同时按下,电脑随之便会发出“哔哔”的警报声,键盘立即失效.这是键盘限制设计,不同产品也有不同限制的按键数量.默认下,最大按键数量是5~7个.所谓组合键就是两个以上的按键所产生的有效按键.举例而言,按下按键 <A> 输出“字符a”,