实验十：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;
代码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;
代码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;
代码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;
代码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;
以上内容是出入端声明。第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 );
以上是检测电平变化的周边操作。第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
以上内容为相关的寄存器声明以及复位操作。注意，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.
以上内容是部分核心操作。步骤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
以上内容是部分核心操作。第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
以上内容是输出驱动声明。
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;
以上内容是出入端声明。第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 );
以上内容是检测电平变化的周边操作，第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
以上内容是相关的寄存器声明以及复位操作。
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.
以上内容为部分核心操作。第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
以上内容为部分核心操作。步骤32~42则是伪函数，主要是负责读取一帧数据。
81.
82. assign oTrig = isDone;
83. assign oData = D1;
84.
85. endmodule
以上内容是输出驱动声明。
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
该代码非常简单，第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
代码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. ......
代码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
