数电模型机 on cyp0633's Blog

数电课程模型机设计：模型机整合

Mon, 27 Dec 2021 00:00:00 +0000

内容还未完成，等待更新，其中包含高度不稳定的内容，仅供参考。
文章更新较慢，可以先在GitHub浏览工程文件。

所有代码现已开放至GitHub：https://github.com/cyp0633/ModelComputer。建议在Releases代码里下载ZIP格式的源代码，更稳定。

同时提供一些资源文件，可以从https://drive.cyp0633.icu/s/eVc6获取，包含验证用的内存初始化MIF文件、实验报告和成品模型机图（PDF格式）。

本文大概遵循老师教学视频中使用的方法，即每次搭建几个元器件，并对其做验证。

关于之前部件的内容，请翻到本文底部，浏览“数电模型机”Tag下的其他文章。

模型机整体图如下图所示，后面的过程可能会用到控制信号和数据通路间的关系。

指令计数器、多路复用器、RAM、指令寄存器

指令计数器 PC，存储当前指令在RAM中存放的地址。
多路复用器 MUX，选择从PC、S和D的数据之一传入RAM。
随机存储器 RAM，存放待执行的命令。
指令寄存器 IR，用于暂存当前正在执行的指令。

这几部分较简单，建议跟随教学视频完成。

在调试RAM的过程中，如果遇到不能在LPM_FILE中输入"./xxx.mif"从而无法读取初始化内容的情况，可以用文本编辑器（VS Code等，实在没有的话记事本也行）打开项目BDF文件，查找定位现在LPM_FILE对应值的位置，将文件路径部分替换成下面这样：

verilog

  (parameter
    "LPM_FILE"
    "\"./example.mif\""
    "File containing initial contents of memory array"
    (type "PARAMETER_STRING"))

如果编辑mif时提示数字过大，那多半是默认十进制，要修改为二进制，可以用文本编辑器打开mif文件，将DATA_RADIX改成BIN。

如果在Quartus 9编译后的Timing Summary中出现"Slack: Not Operational"，则代表有锁存器，回去改模块的代码吧。我的代码中也有此提示，但这是故意而为之，是启停控制模块的必然结果，绕过后则不会有此提示。

通用寄存器组、ALU

通用寄存器组，下降沿响应，用来保存操作数和运算结果等信息。
算术逻辑单元ALU，组合部件，用于执行加、减、与、非运算，或提供数据的通路。

搭建电路的方法，视频里已给出，所以这里主要介绍验证的方法。

这里我们只需要仿真验证通用寄存器组和ALU两个模块，所以添加引脚的时候只需要添加这两个模块有关的引脚，即CLK、M、SEL、RA、RWBA、WE、C、DREG、SREG、Z。

DREG和SREG输出主要用于截取寄存器输出到ALU输入间传送的数据，方便debug。

此外，寄存器内的数值默认一开始都是0（Undefined），除了一点一点用ALU指令自加得到想要的数值之外，也可以在Verilog内直接给寄存器赋初值（默认为8’b0），如：

verilog

1
2
3

    reg [7:0] a=8'b00110110;
    reg [7:0] b=8'b10001011;
    reg [7:0] c=8'b11001110;

根据ALU引脚关系来确定输入的ｍ和sel值。以下的顺序并没有严格指定，但请使你的测试覆盖各种情况，以免组装完成后出现意想不到的错误，下同。

第一个上升沿，我们先执行加法。clk设为初始值1、5ns增1的波形，m=1允许运算，sel=1001代表ADD，ra和rwba输入加的寄存器地址，we=0允许数据输入。

这样，你就可以在c、z和上升沿后的dreg中看到运算结果。

然后第二个上升沿，我们执行减法。和前面差不多，只是sel=0110。减法时ALU运算的是t=b-a，对应的是dreg-sreg，也就是rwba指向的值减raa指向的值，对应关系下同。

按位与和取反也差不太多，这么搞就行了。

仿真波形如下图所示（不要在意最下面那三个REG，有点问题）。

波形看起来很奇怪？请不要忘了，ALU是组合部件，运算很快完成；寄存器是时序部件，更新需要等下降沿。

移位逻辑

移位逻辑，组合部件，用于将输入的数据循环向左向右移，将溢出的位另输出至Cf。

在上面的结构图中，移位逻辑是放在ALU后面的。当然首先要把移位逻辑模块放到图上了。

因为左移右移进行的时候，肯定是t=b的，ALU不需要输出Cf，所以我们可以直接用一个或门将两路数据连接起来。

也可以在t和a之间接一个输出，方便观察。

反正针脚又没怎么变，所以可以沿用寄存器和ALU的波形文件，只需加入fbus/flbus/frbus输入就行了。

在波形文件中，sel表示ALU执行计算的时候（1001/0110/1011/0101），fbus=1，flbus和frbus=0，代表移位逻辑作为数据通路，直接将输入的数据输出。

sel=1010时，代表RSR或RSL，ALU作为数据通路，让移位逻辑负责移动数据，得留两个下降沿的时间，一个给左移一个给右移。

仿真波形如下图。

40-60ns处，就是左移一下右移一下，恢复原来的样子。进位完全正常。

控制信号产生逻辑、SM、指令译码器、状态寄存器

控制信号产生逻辑，组合部件，接收指令译码器输出，产生每个模块所需要的控制信号。
SM，下降沿敏感，用于区别取指令周期和执行指令周期。
指令译码器，组合部件，将8位指令码映射为对应指令。
状态寄存器，下降沿敏感，存储cf和zf，并在使能为1的时候改变。

之前的RAM电路需要依靠三态门来隔离输入和输出，而现在我们直接将总线接到双向的dio口上，同时负责输入输出。所以总线上的数据要协调好。

然后就是把剩下的元件一次加进去，搭建的时候可以参考上面的模型机整体结构连接。只连上这几个元件而没有其他功能加入的电路没截图，但带有调试引脚的模型机的结构大概如下图。

记得将一些信号连接到output引脚，多留一些调试用的输出，这样便于查看各种控制信号的值和过程量，方便debug，比如控制信号、总线数据、通用寄存器输出、多路复用器输出、指令寄存器输出、指令计数器的输出。可以参考上图设置输出引脚。

整合与调试

MIF文件编写

当你认为上面的部件全都连接完成的时候，只需要时钟信号、输入和一个写得正确的MIF文件就可以让模型机跑起来了。这个MIF文件定义了RAM在开始运行时的内容，但仿真结束或FPGA板断电之后并不会被修改，因为RAM断电即丢数据的特性是by design的，真实的电脑也是这样。

随着时钟的flip-flop，指令计数器的值改变，它的一个一个值传入RAM的address端，dio端就读出了指令或是地址（JMP/JZ/JC指令）内容。如果是指令，就将其送入指令译码器，然后变成控制信号，进行下一步的操作。因为指令计数器的自增或是装载特性，模型机就可以自动寻找下一个指令执行，而指令需要在MIF文件中初始化。

一句话来概括，就是以前用控制信号或手动输入指令来控制，属于走一步教一步；现在用MIF文件让它自己读指令，相当于记住了下面的指令内容，给它一个信号它就能自己按路径跑。

MIF文件从0开始向下编写，除三种跳转指令占两位外，每个指令占一位地址。遇到跳转，则与if语句的逻辑相似。

输入与输出

正如实验四和上面我们提到的，三态门可以控制通断，从而控制输入输出。只要将输入总线和输出总线与模型机相连，然后分别用三态门（Quartus中搜索TRI）隔开，将输入输出使能控制信号作为条件，外部输入输出部分就完成了。下图中的inputdata另有输入引脚连接，图中未绘出。注意大于一位的都要用总线绘制。三态门的作用是在使能为1时原样通过数据，否则门后为高阻态。

停机（HALT）和NOP指令

HALT指令通过将SM_EN置0，从而停止取指实现。如果要恢复运行，只需要加一个输入，将SM_EN拉到1即可。所谓的”真正的停机“，可能指的是门控时钟？没有太大必要实现。

NOP指令需要让模型机保持现在的状态两个时钟周期，然后执行下一条指令。这个时候你什么都不需要做，只需要让WE=1，禁止总线向寄存器输入数据。

调试

还记得我们创建的一大堆调试引脚吗？它们的作用就是输出过程量，在执行出错的时候找到是哪里的信号出错了，从而针对性改正。有点像打断点添加中间变量检测，不是吗？因为指令常常牵一发而动全身，我们可以找到发现异常的地方，然后逐条往回推，直到找到真正执行错的地方。至于怎么调试，就很依赖对模型机结构的熟悉程度了。

不过这里有一种情况很难查出来。如果你发现总线上输入/输出的数据并不是你想要的数据，特别是凭空不知道从哪冒出来的数据，多半是总线上输出打架了：同时只有一个部件能够在模型机总线上写入数据，很可能是移位逻辑。

标准测试指令文档

标准测试指令由老师给出，包含了一些分支，能够检验大部分指令的执行情况，所以如果你能够实现所有指令，建议使用标准指令文档。

对于电脑仿真的文档，需要预先将修改寄存器代码，将C寄存器的值初始化为1000 0000。除此之外，还需要在第3-4个时钟周期输入1000 0011，才能按照预期的情况运行。

对于下板的测试文档，需要将输入长期设为1000 0011，毕竟执行很快（3MHz），你无法在输入的一瞬间将按钮拨上去，然后瞬间拨下来。

下板测试

分配引脚

Assignments - Pin

时钟使用6MHz的CLK1，将clk分配至Pin 17。

输入使用开关，比如从高位到低位71、70、69、67、65、64、63、60，代表左边8个开关，正好对应从高位到低位8位输入。

输出使用LED灯，比如118、115、114、113、112、104、103、101，代表左边8个LED灯。如果你想用数码管，大概思路是将8位输出转BCD码，然后使用一个译码器轮流输出（因为是共阴极数码管）。

下载

连接板子，打开Programmer，在Hardware Setup中选择设备，然后点击Start即可。如下图。

如果你做到现在，你就做出了一台足够优秀的模型机。我做出最终的成品图，可以下载开头链接中的文件来浏览。以下模块不会增加基本功能，也不会魔改出流水线四发射双ALU分支预测之类的骚操作，但（可能）可以增强使用体验。

附加模块设计

这部分建议参考我的设计报告和代码来研究，在文章顶部链接中。

启停控制

这是一个优先级非常高的启停控制，因为它控制着输入到模型机内的时钟。本是为按钮设计的，没写消抖，就放到开关上了。

将开始按钮作为输入，将暂停按钮作为重置。在INIT状态下，只要检测到开始按钮

**副作用：过不了Timing Requirements。**因为将时钟阻断会造成锁存，从而clock hold变为N/A。

状态显示

用于显示停机原因，HALT或是上个模块造成的Pause。

向凌老师致敬，没有她的帮助，我可能会晚很长时间才能做出像样的模型机。

数电课程模型机设计：SM & 指令寄存器 & 状态寄存器 & 指令计数器 & 通用寄存器组 & RAM（Verilog 实现）

Wed, 15 Dec 2021 00:00:00 +0000

以下代码虽经本人检查，但并未经过验收，仅供参考，保留随时更改甚至推倒重来的可能。

前几个部分使用Verilog实现，还是比较简单的。最重要的是posedge和negedge的使用。代码中部分由GitHub Copilot生成。

AM使用Block Diagram，借助Quartus自带Megafunction实现。

SM

看懂表格就能做，非常简单。

只在时钟下降沿作用，其他时候不作用，所以使用negedge clk来捕获时钟信号下降沿。

CLK	EN	功能
下降沿	1	SM<=SM取反
下降沿	0	SM不变

verilog

module SM(clk,EN,z);
    input clk,EN;
    output z;

    reg z;

    always @(negedge clk) begin
        if(EN) z <= ~z;
    end

endmodule //SM

IR / 指令寄存器

CLK	IR_LD	功能
下降沿	1	d写入ir

应该没什么好讲的吧。

verilog

module IR(clk,ir_ld,d,ir);
    input clk,ir_ld;
    input[7:0] d;
    output[7:0] ir;

    reg[7:0] ir;
    
    always @(negedge clk) begin
        if(ir_ld) begin
            ir <= d;
        end
    end
endmodule

PSW / 状态寄存器

此程序目前存在一个问题：第一个下降沿，若cf_en或zf_en为0，c或z会变成未知值。目前把它们都设置为1，为数据做一个初始化，来规避这个问题。

CLK	控制信号	功能
下降沿	$cf_en=1$	cf写入c
下降沿	$zf_en=1$	zf写入z

这里讲一个之前一直没注意的事情。本程序可以使用两个always块。组合逻辑模块，处理cf和zf的使能；时序逻辑模块，处理下降沿更新。组合逻辑的结果由寄存器负责暂存。当然，也可以使用三个，一个处理cf，一个处理zf，一个侦测时钟信号，但生成的RTL视图实际上是一样的。

如果将cf_en,zf_en等不带沿的条件和negedge clk写到一个always条件内，Quartus会提示 10122 错误：在一个always块中，双沿的检测（就是普通的always @(n)）和单上升 / 下降沿是不能共存的。可以参考 logic - Single and double-edge expressions (Verilog) - Stack Overflow。

需要注意，之前所讲的 “输入必须都放在always条件里”，只适用于“在这些输入值改变的时候输出值需要立刻改变” 的时候，即同时侦测信号的上升沿和下降沿，这样输入值一旦改变，就可以及时的改变输出值。但时序电路不需要，如PSW只需要在时钟下降沿的时候根据两个使能信号的值更新输出就行了。所以输入和使能都没有必要放到always里，只需要在if侦测就行了。

下面是仅使用单cf_en的结果。

verilog

module PSW(clk,cf_en,zf_en,cf,zf,c,z);
    input clk,cf_en,zf_en,cf,zf;
    output c,z;
    reg c,z;
    reg cTemp,zTemp;

    always @(negedge clk) begin
        if(cf_en) begin
            c<=cf;
        end
        if(zf_en) begin
            z<=zf;
        end
    end
endmodule //PSW

PC / 指令计数器

仍然是看表格就能做。

这个 “a向入c” 的意思是将a的数据导入c。

CLK	IN PC	LD PC	功能
下降沿	1	0	$c[7..0]$ 中数据自加1
下降沿	0	1	$a[7..0]$ 向入 $c[7..0]$

verilog

module PC(ld,inc,clk,a,c);
    input ld,inc,clk;
    input[7:0] a;
    output[7:0] c;

    reg[7:0] c;

    always @(negedge clk) begin
        if (ld) begin
            c <= a;
        end else begin
            if (inc) begin
                c <= c + 1;
            end
        end
    end
endmodule //PC

REG / 通用寄存器组

不只有表里看起来这么简单。

任何时候都是能够读取的，只有写受下降沿限制。因为写的时候只由RWBA指定寄存器地址，所以RAA并没有什么关系。

读取只是把当前的值忠实读出来而已，如果有写入那就读出来新的值。

明明是寄存器，但表中甚至没有描述寄存器部分…… 也不难，定义三个八位的reg变量，就是寄存器的核心部分了，也就是读写的对象。

操作	CLK	WE	$RAA[1..0]$	$RWBA[1..0]$	功能
读			00或01或10	00或01或10	根据 $RAA[1..0]$ 的值从A,B,C中选择一个寄存器的值由S口输出根据 $RWBA[1..0]$ 的值从A,B,C中选择一个寄存器的值由D口输出
写	下降沿	0	XX	00或01或10	控制信号WE为0，根据 $RWBA[1..0]$ 的值, 在时钟下降沿将外部输入写入A,B,C三个寄存器中的某个寄存器。

寄存器是由负责读取的组合逻辑电路和负责写入的时序逻辑电路合并而成的。其读的状态不受写的状态影响，使用阻塞赋值；写则使用非阻塞赋值。

对于RAA和RWBA的输入，00代表A，01代表B，10代表C，都好理解，但如果输入11，仍然要输出C，而不是输出0或者高阻态之类的。可以直接写A、B、default。

verilog

module Register(WE,clk,RA,WA,i,S,D);
    input WE,clk;
    input [1:0] RA,WA;
    input [7:0] i;

    output[7:0] S,D;

    reg [7:0] S,D;
    reg [7:0] a,b,c;

    always @(RA) begin
        case(RA)
            2'b00: S=a;
            2'b01: S=b;
            2'b10: S=c;
            dmodule Register(WE,clk,RA,WA,i,S,D);
    input WE,clk;
    input [1:0] RA,WA;
    input [7:0] i;

    output[7:0] S,D;

    reg [7:0] S,D;
    reg [7:0] a=8'b00110110;
    reg [7:0] b=8'b10001011;
    reg [7:0] c=8'b11001110;

    always @(RA) begin
        case(RA)
            2'b00: S=a;
            2'b01: S=b;
            default: S=c;
        endcase
    end

    always @(WA) begin
        case(WA)
            2'b00: D=a;
            2'b01: D=b;
            default: D=c;
        endcase
    end

    always @(negedge clk) begin
        if(WE==0) begin
            case(WA)
                2'b00: a<=i;
                2'b01: b<=i;
                2'b10: c<=i;
            endcase
        end
    end

endmodule //Register

RAM

RAM包含一个QPF文件和一个MIF文件。QPF文件用于描述电路，而MIF文件用于定义RAM初始的内容。所谓初始值，就是在你没有向某个地址的内存块输入值的情况下，它默认输出的值。

新建一个Memory Initialization File，使用默认的256*8即可。里面随便填点东西，可以右键选择Custom Fill Cells搞点花样，比如使用梯度为1的Increment，可以将每个单元格赋给与它地址相等的值。

再新建一个Block Diagram File，这么画。注意三态门出来的线必须是总线（粗细可辨）。

实际上它是和指导书上有一定区别的。如果有多余的引脚，无需搭理。

双击表格可以修改参数，改成一样的就行。LPM_FILE填入刚刚MIF的相对路径，也就是说如果目录相同可以使用 “./xxx.mif” 表示，一定要带双引号。绝对路径（如D:/test/test.mif或 / root/test/test.mif）也可以。

本文代码所用波形文件在这里可以下载，建议仅用于参考波形。

数电课程模型机设计：多路开关、移位逻辑和控制信号产生逻辑（Verilog 实现）

Mon, 06 Dec 2021 00:00:00 +0000

以下代码虽经本人检查，但仅移位逻辑经过仔细验收，仅供参考。

多路开关

多路开关做起来还是很简单的，一个case语句就能搞定。记得加default，防止生成锁存器。

verilog

module mux (MADD,A,B,C,OUT);
    input[1:0] MADD;
    input[7:0] A,B,C;
    output[7:0] OUT;

    reg[7:0] OUT;

    always @(MADD,A,B,C) begin
        case (MADD) 
            2'b00: OUT=A;
            2'b01: OUT=B;
            2'b10: OUT=C;
            default: OUT=8'b0;
        endcase
    end
endmodule //mux

移位逻辑

这个应该也不算很难。我将输入的三个FBUS、FLBUS和FRBUS合成一个BUS，这样用case语句一起处理或许优雅一些（？）

可以参考下面这张图进行设计。其他情况直接全输出高阻，不用管别的，以防多路输出冲突。

verilog

module Shift_Register (F_BUS,FL_BUS,FR_BUS,a,W,Cf);
    input F_BUS,FL_BUS,FR_BUS;
    input[7:0] a;
    output[7:0] W;
    output Cf;
    
    reg[7:0] W;
    reg Cf;

    wire[2:0] BUS;
    
    assign BUS = {F_BUS,FL_BUS,FR_BUS};
    
    always @(BUS) begin
        case (BUS)
            3'b100: begin
                W = a;
                Cf = 0;
            end
            3'b010: begin
                W  = {a[6:0],a[7]};
                Cf = a[7];
            end
            3'b001: begin
                W  = {a[0],a[7:1]};
                Cf = a[0];
            end
            default: begin
                W = 8'bZZZZZZZZ;
                Cf = 0;
            end
        endcase
    end
endmodule //Shift_Register

控制信号产生逻辑

正常来说，如果希望用直接assign这种比较优雅的写法，你需要逐个摸清控制命令的运行模式，即每种IR对应的各个控制信号的值，列个表，然后找每个控制信号在什么命令输入的时候值为1。

要不然，就用一堆条件语句，只是省掉了反查的过程，还是得分析，也不优雅。

但是，老师把这个表已经列出来了，省下了大把的时间：

我们只需查找每一列输出信号对应的输入信号就行了。规定的信号针脚和表中的控制信号可能有所不同，可以参阅下面的源代码，我在注释中写了一些对应关系。

但是请注意，这里并没有包含所有的指令，比如INPUT。

空白的区域不清楚怎么搞，但我是在这部分输出了0。JZ/JC(T) 指的是JZ&&Z或JC&&C，这两种输出是等效的，虽然判断条件看起来不同；相对的，JZ/JC(F) 就是JZ&&(~Z) 或JC&&(~C)。

源代码如下，部分难以使用几个输入或表示的，我才会使用always语句。

后面整合的时候会知道，MOVB和MOVC的时候，要指定内存地址，需要将C寄存器中的数值输出，所以REG_RA（RAA）的always块中，不能因为MOVB中有一个固定的11就不作为条件；相反，为了将C忠实地输出，需要将三个MOV全都加进去；REG_WA（RWBA）也一样。

此外，上表没有包含NOP的指令输出，经测试只需要REG_WE=1即禁止读写即可，防止总线上数据污染寄存器。

verilog

module control_signal (MOVA,MOVB,MOVC,ADD,SUB,AND1,NOT1,RSR,RSL,JMP,JZ,Z,JC,C,IN1,OUT1,NOP,HALT,IR,SM,REG_RA,REG_WA,MADD,ALU_S,PC_LD,PC_INC,REG_WE,RAM_XL,RAM_DL,ALU_M,SHI_FBUS,SHI_FLBUS,SHI_FRBUS,IR_LD,CF_EN,ZF_EN,SM_EN,IN_EN,OUT_EN);
    input MOVA,MOVB,MOVC,ADD,SUB,AND1,NOT1,RSR,RSL,JMP,JZ,Z,JC,C,IN1,OUT1,NOP,HALT,SM;
    //    MOVA,MOVB,MOVC,ADD,SUB,AND, NOT, RSR,RSL,JMP,JZ-T,JC-T,IN, OUT, NOP,HALT,SM
    input[7:0] IR;
    output[1:0] REG_RA,REG_WA,MADD;
    //          RAA,   RWBA,  MADD
    output[3:0] ALU_S;
    //          S
    output PC_LD,PC_INC,REG_WE,RAM_XL,RAM_DL,ALU_M,SHI_FBUS,SHI_FLBUS,SHI_FRBUS,IR_LD,CF_EN,ZF_EN,SM_EN,IN_EN,OUT_EN;
    //     LD PC,IN PC, /WE,   XL,    DL,    M,    F-BUS,   FL-BUS,   FR-BUS,   LD IR,            SM,

    reg[1:0] MADD,REG_RA,REG_WA;
    reg[3:0] ALU_S;
    
    assign RAM_DL = (~SM)||MOVC||JMP||(JZ&&Z)||(JC&&C); // 取指, MOVC,JMP,JZT,JCT
    assign RAM_XL = MOVB&&(~SM); //MOVB
    assign PC_LD = JMP||(JZ&&Z)||(JC&&C); //JMP,JZT,JCT
    assign PC_INC = (~SM)||(JZ&&~Z)||(JC&&~C); // 取指, JZF,JCF
    assign IR_LD = (~SM); // 取指
    assign SHI_FBUS = ADD||SUB||AND1||NOT1||OUT1||MOVA||MOVB; //ADD,SUB,AND,NOT,OUT,MOVA,MOVB
    assign SHI_FLBUS = RSL; //RSL
    assign SHI_FRBUS = RSR; //RSR
    assign ALU_M = ADD||SUB||AND1||NOT1||RSR||RSL||OUT1;
    assign REG_WE = (~SM)||OUT1||MOVB||JMP||JZ||JC||HALT||NOP;
    assign CF_EN = ADD||SUB||RSR||RSL;
    assign ZF_EN = ADD||SUB;
    assign SM_EN = ~HALT;
    assign IN_EN = IN1;
    assign OUT_EN = OUT1;
    
    always @(SM,MOVB,MOVC) begin //MADD
        if(~SM) MADD=2'b0;
        else if(MOVB) MADD=2'b10;
        else if(MOVC) MADD=2'b01;
        else MADD=2'b0; // 不锁存只能这样了吧？
    end

    always @(ADD,SUB,AND1,NOT1,RSR,RSL,OUT1,MOVA,MOVB) begin //ALU_S
        if(ADD||SUB||AND1||NOT1||RSR||RSL||OUT1||MOVA||MOVB) ALU_S[3:0]=IR[7-:4];
        else ALU_S=4'b0;
    end

    always @(ADD,SUB,AND1,MOVA,MOVB,MOVC) begin //RAA
        if(ADD||SUB||AND1||MOVA||MOVB||MOVC) REG_RA=IR[1-:2];
        else REG_RA=2'b0;
    end

    always @(ADD,SUB,AND1,NOT1,RSR,RSL,IN1,OUT1,MOVA,MOVB,MOVC) begin//RWBA
        if(ADD||SUB||AND1||NOT1||RSR||RSL||IN1||OUT1||MOVA||MOVB||MOVC) REG_WA=IR[3-:2];
        else REG_WA=2'b0;
    end
    
endmodule

module control_signal (MOVA,MOVB,MOVC,ADD,SUB,AND1,NOT1,RSR,RSL,JMP,JZ,Z,JC,C,IN1,OUT1,NOP,HALT,IR,SM,REG_RA,REG_WA,MADD,ALU_S,PC_LD,PC_INC,REG_WE,RAM_XL,RAM_DL,ALU_M,SHI_FBUS,SHI_FLBUS,SHI_FRBUS,IR_LD,CF_EN,ZF_EN,SM_EN,IN_EN,OUT_EN);
    input MOVA,MOVB,MOVC,ADD,SUB,AND1,NOT1,RSR,RSL,JMP,JZ,Z,JC,C,IN1,OUT1,NOP,HALT,SM;
    //    MOVA,MOVB,MOVC,ADD,SUB,AND, NOT, RSR,RSL,JMP,JZ-T,JC-T,IN, OUT, NOP,HALT,SM
    input[7:0] IR;
    output[1:0] REG_RA,REG_WA,MADD;
    //          RAA,   RWBA,  MADD
    output[3:0] ALU_S;
    //          S
    output PC_LD,PC_INC,REG_WE,RAM_XL,RAM_DL,ALU_M,SHI_FBUS,SHI_FLBUS,SHI_FRBUS,IR_LD,CF_EN,ZF_EN,SM_EN,IN_EN,OUT_EN;
    //     LD PC,IN PC, /WE,   XL,    DL,    M,    F-BUS,   FL-BUS,   FR-BUS,   LD IR,            SM,

    reg[1:0] MADD,REG_RA,REG_WA;
    reg[3:0] ALU_S;
    
    assign RAM_DL = (~SM)||MOVC||JMP||(JZ&&Z)||(JC&&C); // 取指, MOVC,JMP,JZT,JCT
    assign RAM_XL = MOVB&&(~SM); //MOVB
    assign PC_LD = JMP||(JZ&&Z)||(JC&&C); //JMP,JZT,JCT
    assign PC_INC = (~SM)||(JZ&&~Z)||(JC&&~C); // 取指, JZF,JCF
    assign IR_LD = (~SM); // 取指
    assign SHI_FBUS = ADD||SUB||AND1||NOT1||OUT1||MOVA||MOVB; //ADD,SUB,AND,NOT,OUT,MOVA,MOVB
    assign SHI_FLBUS = RSL; //RSL
    assign SHI_FRBUS = RSR; //RSR
    assign ALU_M = ADD||SUB||AND1||NOT1||RSR||RSL||OUT1;
    assign REG_WE = (~SM)||OUT1||MOVB||JMP||JZ||JC||HALT||NOP;
    assign CF_EN = ADD||SUB||RSR||RSL;
    assign ZF_EN = ADD||SUB;
    assign SM_EN = ~HALT;
    assign IN_EN = IN1;
    assign OUT_EN = OUT1;
    
    always @(SM,MOVB,MOVC) begin //MADD
        if(~SM) MADD=2'b0;
        else if(MOVB) MADD=2'b10;
        else if(MOVC) MADD=2'b01;
        else MADD=2'b0; // 不锁存只能这样了吧？
    end

    always @(ADD,SUB,AND1,NOT1,RSR,RSL,OUT1,MOVA,MOVB) begin //ALU_S
        if(ADD||SUB||AND1||NOT1||RSR||RSL||OUT1||MOVA||MOVB) ALU_S[3:0]=IR[7-:4];
        else ALU_S=4'b0;
    end

    always @(ADD,SUB,AND1,MOVA,MOVB,MOVC) begin //RAA
        if(ADD||SUB||AND1||MOVA||MOVB||MOVC) REG_RA=IR[1-:2];
        else REG_RA=2'b0;
    end

    always @(ADD,SUB,AND1,NOT1,RSR,RSL,IN1,OUT1,MOVA,MOVB,MOVC) begin//RWBA
        if(ADD||SUB||AND1||NOT1||RSR||RSL||IN1||OUT1||MOVA||MOVB||MOVC) REG_WA=IR[3-:2];
        else REG_WA=2'b0;
    end
    
endmodule

照例，下面提供三个部件仿真时使用的波形文件，使用Quartus Prime 21.1生成：下载链接。

数电课程模型机 CPU 设计：译码器和 ALU（Verilog 实现）

Tue, 30 Nov 2021 00:00:00 +0000

译码器

译码器的指令系统表如下图所示。

译码器做起来其实不难，当编码符合要求的时候，把相应的汇编符号输出设为1就行了。

R1、R2代表操作寄存器的地址，可以为A、B或C寄存器中的任何一个，地址分别为00、01和10。

所谓” 符合要求 “，可以举个例子。比如NOT的编码是 0101 R1XX，R1代表寄存器1的地址，XX是通配符，所以可以做匹配 IR[7-:4]==4'b0101，而且应为寄存器地址的地方不能是11。（话说也没多少人会在这个位置传进11吧…… 除了喜欢点一杯炒饭的测试工程师）

特别注意的是，有三种MOV指令。这里定义第一种MOV指令为MOVA，第二种为MOVB，第三种为MOVC。我先使用1100匹配进MOV，然后再区分MOVA、MOVB和MOVC。

verilog

module decoder (EN,IR,MOVA,MOVB,MOVC,ADD,SUB,AND,NOT,RSR,RSL,JMP,JZ,JC,IN,OUT,NOP,HALT);
    input EN;
    input[7:0] IR;
    output MOVA,MOVB,MOVC,ADD,SUB,AND,NOT,RSR,RSL,JMP,JZ,JC,IN,OUT,NOP,HALT;
    reg MOVA,MOVB,MOVC,ADD,SUB,AND,NOT,RSR,RSL,JMP,JZ,JC,IN,OUT,NOP,HALT;
always @(IR,EN) begin
    if(EN==1'b1) begin
        if (IR[7-:4]==4'b1100) begin //MOV
            if(IR[3-:2]==2'b11) begin //MOVB 11R2
                MOVA=1'b1;
                MOVB=1'b0;
                MOVC=1'b0;
            end
            else if (IR[1-:2]==2'b11) begin //MOVC R1111
                MOVA=1'b0;
                MOVB=1'b0;
                MOVC=1'b1;
            end
            else begin //MOVA R1R2
                MOVA=1'b1;
                MOVB=1'b0;
                MOVC=1'b0;
            end
        end
        else begin
            MOVA=1'b0;
            MOVB=1'b0;
            MOVC=1'b0;
        end
        if (IR[7-:4]==4'b1001 && IR[3-:2]!=2'b11 && IR[1-:2]!=2'b11) begin //ADD
            ADD=1'b1;
        end
        else ADD=1'b0;
        if (IR[7-:4]==4'b0110 && IR[3-:2]!=2'b11 && IR[1-:2]!=2'b11) begin //SUB
            SUB=1'b1;
        end
        else SUB=1'b0;
        if (IR[7-:4]==4'b1011 && IR[3-:2]!=2'b11 && IR[1-:2]!=2'b11) begin //AND
            AND=1'b1;
        end
        else AND=1'b0;
        if (IR[7-:4]==4'b0101 && IR[3-:2]!=2'b11) begin //NOT
            NOT=1'b1;
        end
        else NOT=1'b0;
        if (IR[7-:4]==4'b1010 && IR[1-:2]==2'b00 && IR[3-:2]!=2'b11) begin //RSR
            RSR=1'b1;
        end
        else RSR=1'b0;
        if (IR[7-:4]==4'b1010 && IR[1-:2]==2'b11 && IR[3-:2]!=2'b11) begin //RSL
            RSL=1'b1;
        end
        else RSL=1'b0;
        if (IR[7:0]==8'b0011_0000) begin //JMP
            JMP=1'b1;
        end
        else JMP=1'b0;
        if (IR[7:0]==8'b0011_0001) begin //JZ
            JZ=1'b1;
        end
        else JZ=1'b0;
        if (IR[7:0]==8'b0011_0010) begin //JC
            JC=1'b1;
        end
        else JC=1'b0;
        if (IR[7-:4]==4'b0010 && IR[3-:2]!=2'b11) begin //IN
            IN=1'b1;
        end
        else IN=1'b0;
        if (IR[7-:4]==4'b0100 && IR[3-:2]!=2'b11) begin //OUT
            OUT=1'b1;
        end
        else OUT=1'b0;
        if (IR[7:0]==8'b0111_0000) begin //NOP
            NOP=1'b1;
        end
        else NOP=1'b0;
        if (IR[7:0]==8'b1000_0000) begin //HALT
            HALT=1'b1;
        end
        else HALT=1'b0;
    end
    else begin
        MOVA=1'b0;
        MOVB=1'b0;
        MOVC=1'b0;
        ADD=1'b0;
        SUB=1'b0;
        AND=1'b0;
        NOT=1'b0;
        RSR=1'b0;
        RSL=1'b0;
        JMP=1'b0;
        JZ=1'b0;
        JC=1'b0;
        IN=1'b0;
        OUT=1'b0;
        NOP=1'b0;
        HALT=1'b0;
    end

end

endmodule //decoder

module decoder (EN,IR,MOVA,MOVB,MOVC,ADD,SUB,AND,NOT,RSR,RSL,JMP,JZ,JC,IN,OUT,NOP,HALT);
    input EN;
    input[7:0] IR;
    output MOVA,MOVB,MOVC,ADD,SUB,AND,NOT,RSR,RSL,JMP,JZ,JC,IN,OUT,NOP,HALT;
    reg MOVA,MOVB,MOVC,ADD,SUB,AND,NOT,RSR,RSL,JMP,JZ,JC,IN,OUT,NOP,HALT;
always @(IR,EN) begin
    if(EN==1'b1) begin
        if (IR[7-:4]==4'b1100) begin //MOV
            if(IR[3-:2]==2'b11) begin //MOVB 11R2
                MOVA=1'b1;
                MOVB=1'b0;
                MOVC=1'b0;
            end
            else if (IR[1-:2]==2'b11) begin //MOVC R1111
                MOVA=1'b0;
                MOVB=1'b0;
                MOVC=1'b1;
            end
            else begin //MOVA R1R2
                MOVA=1'b1;
                MOVB=1'b0;
                MOVC=1'b0;
            end
        end
        else begin
            MOVA=1'b0;
            MOVB=1'b0;
            MOVC=1'b0;
        end
        if (IR[7-:4]==4'b1001 && IR[3-:2]!=2'b11 && IR[1-:2]!=2'b11) begin //ADD
            ADD=1'b1;
        end
        else ADD=1'b0;
        if (IR[7-:4]==4'b0110 && IR[3-:2]!=2'b11 && IR[1-:2]!=2'b11) begin //SUB
            SUB=1'b1;
        end
        else SUB=1'b0;
        if (IR[7-:4]==4'b1011 && IR[3-:2]!=2'b11 && IR[1-:2]!=2'b11) begin //AND
            AND=1'b1;
        end
        else AND=1'b0;
        if (IR[7-:4]==4'b0101 && IR[3-:2]!=2'b11) begin //NOT
            NOT=1'b1;
        end
        else NOT=1'b0;
        if (IR[7-:4]==4'b1010 && IR[1-:2]==2'b00 && IR[3-:2]!=2'b11) begin //RSR
            RSR=1'b1;
        end
        else RSR=1'b0;
        if (IR[7-:4]==4'b1010 && IR[1-:2]==2'b11 && IR[3-:2]!=2'b11) begin //RSL
            RSL=1'b1;
        end
        else RSL=1'b0;
        if (IR[7:0]==8'b0011_0000) begin //JMP
            JMP=1'b1;
        end
        else JMP=1'b0;
        if (IR[7:0]==8'b0011_0001) begin //JZ
            JZ=1'b1;
        end
        else JZ=1'b0;
        if (IR[7:0]==8'b0011_0010) begin //JC
            JC=1'b1;
        end
        else JC=1'b0;
        if (IR[7-:4]==4'b0010 && IR[3-:2]!=2'b11) begin //IN
            IN=1'b1;
        end
        else IN=1'b0;
        if (IR[7-:4]==4'b0100 && IR[3-:2]!=2'b11) begin //OUT
            OUT=1'b1;
        end
        else OUT=1'b0;
        if (IR[7:0]==8'b0111_0000) begin //NOP
            NOP=1'b1;
        end
        else NOP=1'b0;
        if (IR[7:0]==8'b1000_0000) begin //HALT
            HALT=1'b1;
        end
        else HALT=1'b0;
    end
    else begin
        MOVA=1'b0;
        MOVB=1'b0;
        MOVC=1'b0;
        ADD=1'b0;
        SUB=1'b0;
        AND=1'b0;
        NOT=1'b0;
        RSR=1'b0;
        RSL=1'b0;
        JMP=1'b0;
        JZ=1'b0;
        JC=1'b0;
        IN=1'b0;
        OUT=1'b0;
        NOP=1'b0;
        HALT=1'b0;
    end

end

endmodule //decoder

ALU

我之前想复杂了，完全不需要设计RCA，因为Cf指的 是最高位的进位或借位（即溢出），而不是逐位取进位或借位，所以可以直接使用拼接解决。 ~~怪不得从网上找了一堆资料没发现如何找借位~~

这样就没有之前那么难了，把ppt里的东西直接翻译出来就行了，源代码如下。

verilog

module ALU2 (M,S,A,B,t,Cf,Zf);
    input M;// 算术运算指示
    input [3:0] S;// 运算类型
    input [7:0] A,B;// 参与运算的数字

    output [7:0] t;// 输出结果
    output Cf,Zf;// 是否进位，是否为 0

    reg [7:0] t;
    reg Cf,Zf;
    reg [7:0] temp1;

    always @(M,S,A,B) begin
        if (M==1'b0) begin // 不进行算术运算
            if(S==4'b1100) t[7:0]=A[7:0];
            else t=8'b0;
            Cf=1'b0;
            Zf=1'b0;
        end
        else begin// 进行算术运算
            case (S)
                4'b1001: begin //ADD
                    {Cf,t}=A+B;
                    if (t==8'b0) begin
                        Zf=1'b1;
                    end
                    else Zf=1'b0;
                end
                4'b0110: begin //SUB
                    {Cf,t}=B-A;
                    if(t==8'b0) Zf=1'b1;
                    else Zf=1'b0;
                end
                4'b1011: begin //AND
                    // t=A&&B;
                    t[0]=A[0]&&B[0];
                    t[1]=A[1]&&B[1];
                    t[2]=A[2]&&B[2];
                    t[3]=A[3]&&B[3];
                    t[4]=A[4]&&B[4];
                    t[5]=A[5]&&B[5];
                    t[6]=A[6]&&B[6];
                    t[7]=A[7]&&B[7];
                    Cf=0;
                    Zf=0;
                end
                4'b0101: begin
                    t=~B; //NOT
                    Cf=0;
                    Zf=0;
                end
                4'b1010: begin
                    t=B;
                    Cf=0;
                    Zf=0;
                end
                4'b0100: begin
                    t=B;
                    Cf=0;
                    Zf=0;
                end
                4'b1100: begin
                    t=A;
                    Cf=0;
                    Zf=0;
                end
                default: begin
                    Cf=0;
                    Zf=0;
                    t=8'b0;
                end
            endcase
        end
    end
endmodule //ALU2

module ALU2 (M,S,A,B,t,Cf,Zf);
    input M;// 算术运算指示
    input [3:0] S;// 运算类型
    input [7:0] A,B;// 参与运算的数字

    output [7:0] t;// 输出结果
    output Cf,Zf;// 是否进位，是否为 0

    reg [7:0] t;
    reg Cf,Zf;
    reg [7:0] temp1;

    always @(M,S,A,B) begin
        if (M==1'b0) begin // 不进行算术运算
            if(S==4'b1100) t[7:0]=A[7:0];
            else t=8'b0;
            Cf=1'b0;
            Zf=1'b0;
        end
        else begin// 进行算术运算
            case (S)
                4'b1001: begin //ADD
                    {Cf,t}=A+B;
                    if (t==8'b0) begin
                        Zf=1'b1;
                    end
                    else Zf=1'b0;
                end
                4'b0110: begin //SUB
                    {Cf,t}=B-A;
                    if(t==8'b0) Zf=1'b1;
                    else Zf=1'b0;
                end
                4'b1011: begin //AND
                    // t=A&&B;
                    t[0]=A[0]&&B[0];
                    t[1]=A[1]&&B[1];
                    t[2]=A[2]&&B[2];
                    t[3]=A[3]&&B[3];
                    t[4]=A[4]&&B[4];
                    t[5]=A[5]&&B[5];
                    t[6]=A[6]&&B[6];
                    t[7]=A[7]&&B[7];
                    Cf=0;
                    Zf=0;
                end
                4'b0101: begin
                    t=~B; //NOT
                    Cf=0;
                    Zf=0;
                end
                4'b1010: begin
                    t=B;
                    Cf=0;
                    Zf=0;
                end
                4'b0100: begin
                    t=B;
                    Cf=0;
                    Zf=0;
                end
                4'b1100: begin
                    t=A;
                    Cf=0;
                    Zf=0;
                end
                default: begin
                    Cf=0;
                    Zf=0;
                    t=8'b0;
                end
            endcase
        end
    end
endmodule //ALU2

本文代码仿真所使用的波形文件可从此处获取，使用Quartus II 13.0 SP1生成。2021/12/06已更新本人验收用波形，数据较多。