[原创] [10月DIY]编写个超简单的CPU

cruelfox   2016-10-27 17:25 楼主
FPGA的处理能力固然强大,但在进行程序化的任务时,用状态机来实现有时就显得不如CPU写程序那么简洁。在FPGA里面也可以用逻辑来搭出简单的CPU,并固化一小段代码去实现特定的功能。考虑下最简单的CPU是什么样子呢?

最少,需要有读取程序(指令),并执行指令的过程。指令存放在一块内存当中,CPU每步取一条指令来执行,根据读出的指令内容,内部的状态发生转变——比如寄存器按指令要求进行运算,比如访问外部的端口(或总线)。指令是一个编码,描述这一步需要做的事情;执行指令的过程就是状态转移的过程。我实验的这个超简单CPU是这样:
cpu.jpg
上图中,PC是Program Counter,就是程序计数器,选择ROM中程序执行的地址。opr用来存放当前的指令,它的内容从ROM中读到。寄存器还有A寄存器和R0~R7寄存器,用来计算和存放结果,另外还有一个1-bit的“零"标志位zflag,是给条件转移指令用的。当然,若只是里面的寄存器变来变去,这个CPU就没有实用价值了,所以还有一个输入端口,以及一个输出端口,用来和寄存器A交换数据。

设计指令字长为8-bit,寄存器宽度也为8-bit。每条指令都是从ROM中读8-bit,可以最多有256种不同的指令,当然指令中能编码立即数,所以指令不会有那么多种。我给这个CPU设计了14条指令:
opcode.jpg
跳转指令有2条,无条件转移和Z条件转移,转移范围为5-bit相对地址,即-16~+15。
带立即数指令有4条,因为指令才8-bit,立即数只好分配4-bit了。装入A寄存器的高4位或低4位,以及与A做加减法。
R0~R7寄存器只能与A寄存器进行copy和比较操作。
影响zflag标志的指令有位测试指令TESTB, 比较指令COMP和加减法指令。
指令空间并没有用完,可以根据需要再补充指令。

用Verilog语言来写这个CPU的状态转移部分:
  1. module cpu0(clk, Iaddr, Ibus, PortI, PortO);
  2. input clk;
  3. output [9:0] Iaddr;
  4. input [7:0] Ibus;
  5. input [7:0] PortI;
  6. output reg [7:0] PortO;

  7. reg [9:0] pc;
  8. reg [7:0] RA;
  9. reg [7:0] Rn[0:7];
  10. reg zflag;

  11. assign Iaddr=pc;

  12. reg [7:0] opr;
  13. always @(posedge clk)
  14.     opr <= Ibus;
  15.    
  16. wire [1:0] opc1=opr[7:6];
  17. wire [5:0] opx=opr[5:0];
  18. wire [1:0] opc2=opr[5:4];
  19. wire [3:0] imm4=opr[3:0];
  20. wire [2:0] sel=opr[2:0];

  21. reg branch;

  22. always @(posedge clk) begin
  23.     pc <= pc + 1'b1;    // default increment
  24.     branch <= 1'b0;
  25.     if(~branch) begin
  26.         if(opc1==2'd3)
  27.             if(opr[5] | zflag) begin
  28.                 pc <= pc + {{5{opr[4]}},opr[4:0]};  // jump instruction
  29.                 branch <= 1'b1;
  30.             end
  31.     end
  32. end

  33. always @(posedge clk) begin
  34.     if(~branch) begin
  35.         if(opc1==2'd1 && opc2==2'd0)
  36.             Rn[sel] <= RA;
  37.     end
  38. end

  39. always @(posedge clk) begin
  40.     if(~branch) begin
  41.         case(opc1)
  42.             2'd0: begin
  43.                 if(opx==6'd0)
  44.                     RA <= PortI;
  45.                 end
  46.             2'd1: begin
  47.                     if(opc2==2'd1)
  48.                         RA <= Rn[sel];
  49.                 end
  50.             2'd2: begin
  51.                     case(opc2)
  52.                         2'd0: RA[7:4] <= imm4;
  53.                         2'd1: RA[3:0] <= imm4;
  54.                         2'd2: RA <= RA + imm4;
  55.                         2'd3: RA <= RA - imm4;
  56.                     endcase
  57.                 end
  58.         endcase
  59.     end
  60. end

  61. always @(posedge clk) begin
  62.     if(~branch) begin
  63.         if(opc1==2'd0 && opx==6'd1)
  64.             PortO <= RA;
  65.     end
  66. end

  67. always @(posedge clk) begin
  68.     if(~branch) begin
  69.         if(opc1==2'd1) begin
  70.             case(opc2)
  71.                 2'd3: zflag <= ~RA[sel];
  72.                 2'd2: zflag <= (RA==Rn[sel]);
  73.             endcase
  74.         end
  75.         if(opc1==2'd2) begin
  76.             if(opc2[1])
  77.                 zflag <= (RA==8'd0);
  78.         end
  79.     end
  80. end

  81. endmodule


除了指令所描述的寄存器的操作外,还多了一个branch寄存器和条件判断,这是做什么呢?请注意,PC寄存器所指的是下一条要执行的指令地址(默认总是 pc <= pc + 1),但是如果遇到跳转指令,下一条指令是紧接着跳转指令的,将在下一个时钟沿上被读入opr,但是这条指令不该被执行,所以需要条件判断一下。而要跳转的位置的指令需要在PC更新之后的下一拍才能够被读入opr,这就是转移指令比普通指令要多花一个时钟周期的原因(这个CPU是两级流水线)。


写测试程序了,没有编译器,汇编程序都得自己写呢。先就手写机器码吧
  1. module coderom(addr, data);
  2. input [9:0] addr;
  3. output reg [7:0] data;

  4. always @(addr) begin
  5.   case(addr)
  6.         0 : data = 8'h80;        // LOADAL 0
  7.         1 : data = 8'h90;        // LOADAH 0
  8.         2 : data = 8'h01;        // OUT A
  9.         3 : data = 8'hA1;        // ADDA #1
  10.         4 : data = 8'h40;        // MOV R0, A
  11.         5 : data = 8'h00;        // IN A
  12.         6 : data = 8'h77;        // TESTB A,7
  13.         7 : data = 8'h50;        // MOV A, R0
  14.         8 : data = 8'hDB;        // JUMPZ 4
  15.         9 : data = 8'hF8;        // JUMP 2
  16.         default: data=8'h00;
  17.         endcase
  18. end

  19. endmodule


这个程序不干啥有价值的,就是检测到输入端口第7位为高时,循环加一计数,输出到端口点LED.

顶层模块,将ROM和CPU连起来:
  1. module cpu_top(clk, PortI, PortO);
  2. input clk;
  3. input [7:0] PortI;
  4. output [7:0] PortO;

  5. wire [7:0] rom_q;
  6. wire [9:0] rom_addr;

  7. cpu0 minicpu(.clk(clk),
  8.         .PortI(PortI),
  9.         .PortO(PortO),
  10.         .Ibus(rom_q),
  11.         .Iaddr(rom_addr));
  12.         
  13. coderom rom(
  14.     .addr(rom_addr),
  15.     .data(rom_q));  

  16. endmodule



回复评论 (24)

2推荐 白丁 

记得夏老师的verilog数字系统设计教程上有个简化risc cpu设计,还可以看看opencores上开源的or1k项目,资料也比较多。如果真是嫌状态机麻烦可以用x或者a家自己的软核啊。记得一个大大对我说,做一个简单cpu简单,但是难点是搞编译器,你这个开始说的固化一小段代码能实现吗? 本帖最后由 白丁 于 2016-10-31 09:29 编辑
training
点赞  2016-10-27 22:46
好帖子!
点赞  2016-10-27 17:57
66666666666
点赞  2016-10-27 20:22
牛,期待更多的FPGA设计
QQ:252669569
点赞  2016-10-27 21:11
自己学问浅,看不懂。
点赞  2016-10-27 21:11
很有学习价值,谢谢楼主分享
training
点赞  2016-10-27 22:42
引用: 白丁 发表于 2016-10-27 22:46
记得系老师的verilog数字系统设计教程上有个简化risc cpu设计,还可以看看opencores上开源的or1k项目,资料 ...

没错,编译器是屠龙之术。
点赞  2016-10-28 09:11
引用: 白丁 发表于 2016-10-27 22:46
记得系老师的verilog数字系统设计教程上有个简化risc cpu设计,还可以看看opencores上开源的or1k项目,资料 ...

软核是有现成的,配套的编译器也都全了,当然用起来比这个省心得多。
这个CPU没有RAM支持,没有堆栈,逻辑运算单元基本的AND, OR都没有(虽然可以扩充),和A家NIOS比弱爆了……我这么嘛,就是体验一把CPU怎么工作的,用比较少的资源实现一个执行器(姑且这么叫,比真正CPU弱多了),够完成特殊要求就够了。
我上面的代码是人肉汇编的 编译器?用C写还是不要想了。汇编器可以有。
点赞  2016-10-28 10:10
看起来好厉害的样子~
HELLO_WATER
点赞  2016-10-31 09:38
厉害
点赞  2016-12-23 19:59
点赞  2017-2-12 18:19

可以这样玩,这太厉害了吧!佩服

点赞  2020-6-12 10:55

没有玩过FPGA,但是后面也要开始接触了,原来可以这么玩,以后我也试试,厉害了!!!

点赞  2020-10-12 15:42

66666666

点赞  2020-11-11 15:12

不错,点个赞。虽然简单但是自己做做还是不一样的。兴趣提起来了,慢慢可以更新迭代再丰富。

点赞  2021-10-30 11:13
写的很详细
点赞  2021-12-19 10:57

写的很不错,特别是整洁规范,

点赞  2022-3-26 09:22

谢谢分享

点赞  2022-7-19 17:16

CPU好做编译器难啊,这玩意最难的是上下层的交互吧。

点赞  2022-8-4 13:29
12下一页
电子工程世界版权所有 京B2-20211791 京ICP备10001474号-1 京公网安备 11010802033920号
    写回复