1、CPU简介
CPU的本质是在整个电路系统中为核心电路单元，主要的作用是对数据进行逻辑和数学运算的电路单元，运算时通过人机交互控制。
2、工作示意图
CU：控制单元，分析指令，给出控制信号
IR：指令寄存器，分析指令，给出控制信号
PC：程序计数器，存放下一条指令地址，有自动加1功能
ACC：累加器，用于存放操作数/操作结果
MQ：乘商寄存器
x：用于存放操作数
ALU：实现逻辑运算
完成一条完整的指令需要三个步骤： 1、取指令（PC）
2、分析指令（IR）
3、执行指令（CU）
3、本程序设计一种基础架构的RISC CPU
1、顶层架构
1 //当wr=1的时候data上数据写有效
2 //当rd=1的时候data上数据读有效
3 module my_risc_cpu(clk, rst_n, data, addr, wr, rd);
4
5 input clk, rst_n; //系统时钟、复位
6 inout [7:0] data; //指令/数据（数据总线）
7 output [12:0] addr; //地址（地址总线）
8 output wr; //写有效使能->控制总线
9 output rd; //读有效使能->控制总线
10
11
12 wire load_ir;
13 wire clk_inc;
14 wire load_pc;
15 wire load_acc;
16 wire addr_sel;
17 wire data_link;
18 wire alu_en;
19 wire [7:0] alu_out; //计算组件计算的结果
20 wire [7:0] acc; //将计算组件计算的结果存入acc
21 wire [15:0] ir;
22 wire [12:0] pc_addr;
23
24
25 //时序控制组件
26 tm_gc tm_gc_ins(
27 .clk(clk),
28 .rst_n(rst_n),
29 .ir(ir[15:13]),
30 .load_ir(load_ir),
31 .clk_inc(clk_inc),
32 .load_pc(load_pc),
33 .load_acc(load_acc),
34 .addr_sel(addr_sel),
35 .data_link(data_link),
36 .wr(wr),
37 .rd(rd),
38 .alu_en(alu_en)
39 );
40
41 //计算组件
42 alu alu_ins(
43 .clk(clk),
44 .rst_n(rst_n),
45 .data(data),
46 .acc(acc),
47 .alu_en(alu_en),
48 .ir(ir[15:13]),
49 .alu_out(alu_out)
50 );
51
52 //累加器
53 acc_m acc_m_ins(
54 .clk(clk),
55 .rst_n(rst_n),
56 .alu_out(alu_out),
57 .load_acc(load_acc),
58 .acc(acc)
59 );
60
61 //指令寄存
62 ir_register ir_register_ins(
63 .clk(clk),
64 .rst_n(rst_n),
65 .data(data),
66 .load_ir(load_ir),
67 .ir(ir)
68 );
69
70 //指令地址发生器
71 pc_addr_gen pc_addr_gen_ins(
72 .clk_inc(clk_inc),
73 .rst_n(rst_n),
74 .load_pc(load_pc),
75 .pc_addr(pc_addr),
76 .ir(ir[12:0])
77 );
78
79 //数据选择
80 data_sel_m data_sel_m_ins(
81 .data_sel(data_link),
82 .acc(acc),
83 .data(data)
84 );
85
86 //地址路由
87 addr_sel_m addr_sel_m_ins(
88 .ir(ir[12:0]),
89 .pc_addr(pc_addr),
90 .addr_sel(addr_sel),
91 .addr(addr)
92 );
93
94 endmodule2、时序控制组件顶层
1 /*********************时序控制组件********************************/
2 module tm_gc(clk, rst_n, ir, load_ir, clk_inc, load_pc, load_acc, addr_sel, data_link, wr, rd, alu_en);
3
4 input clk, rst_n;
5
6 input [15:13] ir;
7
8 output load_ir;
9 output clk_inc;
10 output load_pc;
11 output load_acc;
12 output addr_sel;
13 output data_link;
14 output wr;
15 output rd;
16 output alu_en;
17
18 wire clk_ir;
19
20 tm_gen tm_gen_ins(
21 .clk(clk),
22 .rst_n(rst_n),
23 .alu_en(alu_en),
24 .clk_ir(clk_ir)
25 );
26
27 tm_ctl tm_ctl_ins(
28 .clk(clk),
29 .rst_n(rst_n),
30 .clk_ir(clk_ir),
31 .ir(ir),
32 .load_ir(load_ir),
33 .clk_inc(clk_inc),
34 .load_pc(load_pc),
35 .load_acc(load_acc),
36 .addr_sel(addr_sel),
37 .data_link(data_link),
38 .wr(wr),
39 .rd(rd)
40 );
41
42 endmodule2.1生成指令周期（8个机器周期）
1 //本模块主要产生指令周期的时钟信号clk_ir
2 module tm_gen(clk, rst_n, alu_en, clk_ir);
3
4 input clk, rst_n;
5 output reg alu_en;
6 output reg clk_ir;
7
8 reg [2:0] cnt; //本设计的指令周期为8个机器周期（8个clk）,8051单片机也为8个机器周期
9
10 always @ (posedge clk, negedge rst_n)
11 begin
12 if(~rst_n)
13 cnt <= 3'b0;
14 else
15 if(cnt == 3'd7)
16 cnt <= 3'd0;
17 else
18 cnt <= cnt + 1'b1;
19 end
20
21 always @ (posedge clk, negedge rst_n)
22 begin
23 if(~rst_n)
24 clk_ir <= 1'b0;
25 else
26 if(cnt == 3'd1)//2-5,四个时钟周期，尽量避免0作为开始
27 clk_ir <= 1'b1;
28 else
29 if(cnt == 3'd5)
30 clk_ir <= 1'b0;
31 end
32
33 //在clk_ir低电平的倒数第二个周期将alu_en拉高
34 always @ (posedge clk, negedge rst_n)
35 begin
36 if(~rst_n)
37 alu_en <= 1'b0;
38 else
39 if(cnt == 4'd7)
40 alu_en <= 1'b1;
41 else
42 alu_en <= 1'b0;
43 end
44
45 endmodule
2.2实现时序控制
1 module tm_ctl(clk, rst_n, clk_ir, ir, load_ir, clk_inc, load_pc, load_acc, addr_sel, data_link, wr, rd);
2
3 input clk, rst_n;
4
5 input clk_ir;
6 input [15:13] ir;
7
8 output reg load_ir;
9 output reg clk_inc;
10 output reg load_pc;
11 output reg load_acc;
12 output reg addr_sel;
13 output reg data_link;
14 output reg wr;
15 output reg rd;
16
17 parameter HLT = 3'b000,
18 RD = 3'b001,
19 WR = 3'b010,
20 SFT = 3'b011,
21 XOR = 3'b100,
22 SUB = 3'b101,
23 SKZ = 3'b110,
24 NJMP = 3'b111;
25
26
27 parameter FETCH1 = 3'd0,
28 FETCH2 = 3'd1,
29 FETCH3 = 3'd2,
30 EXZIT1 = 3'd3,
31 EXZIT2 = 3'd4,
32 EXZIT3 = 3'd5,
33 EXZIT4 = 3'd6,
34 EXZIT5 = 3'd7;
35
36 reg [2:0] state;
37
38 always @ (posedge clk, negedge rst_n)
39 begin
40 if(~rst_n)
41 state <= FETCH1;
42 else
43 case(state)
44 FETCH1 : if(clk_ir) state <= FETCH2;
45 FETCH2 : state <= FETCH3;
46 FETCH3 : state <= EXZIT1;
47 EXZIT1 : state <= EXZIT2;
48 EXZIT2 : state <= EXZIT3;
49 EXZIT3 : state <= EXZIT4;
50 EXZIT4 : state <= EXZIT5;
51 EXZIT5 : state <= FETCH1;
52 default : state <= FETCH1;
53 endcase
54 end
55
56 //此控制程序过程：在FETCH1状态拉高load_ir和rd两拍，在FETCH3拉低；读取一个完整的地址上的指令（因为数据是8位宽）；
57 //在FETCH1状态拉高load_ir和rd两拍，在FETCH3拉低；选择指令的地址pc_addr，在FETCH1拉高clk_inc一个周期让addr更新一次+1；
58 //在EXZIT1拉高clk_inc信号使得pc_addr指向下一个新的地址（用于进行下一次运算取pc_addr上对应的操作码和数据的地址）；
59 //在EXZIT2时拉高rd信号读取数据地址上的数据，且此时addr_sel为低读取的是IR的地址，赋值给了addr;读取出数据
60 //在EXZIT3时拉高alu_en信号，用IR的高三位（操作码）选择对应的操作运算
61 //在EXZIT4时拉高load_acc信号，将alu计算的结果存入累加器中
62 always @ (posedge clk, negedge rst_n)
63 begin
64 if(~rst_n)
65 begin
66 load_ir <= 1'b0;
67 clk_inc <= 1'b0;
68 load_pc <= 1'b0;
69 load_acc <= 1'b0;
70 addr_sel <= 1'b0;
71 data_link <= 1'b0;
72 wr <= 1'b0;
73 rd <= 1'b0;
74 end
75 else
76 case(state)
77 FETCH1 : begin
78 load_ir <= 1'b1;
79 clk_inc <= 1'b0;
80 load_pc <= 1'b0;
81 load_acc <= 1'b0;
82 addr_sel <= 1'b1;
83 data_link <= 1'b0;
84 wr <= 1'b0;
85 rd <= 1'b1;
86 end
87 FETCH2 : begin
88 load_ir <= 1'b1;
89 clk_inc <= 1'b1; //一次
90 load_pc <= 1'b0;
91 load_acc <= 1'b0;
92 addr_sel <= 1'b1;
93 data_link <= 1'b0;
94 wr <= 1'b0;
95 rd <= 1'b1;
96 end
97 FETCH3 : begin
98 load_ir <= 1'b0;
99 clk_inc <= 1'b0;
100 load_pc <= 1'b0;
101 load_acc <= 1'b0;
102 addr_sel <= 1'b0;
103 data_link <= 1'b0;
104 wr <= 1'b0;
105 rd <= 1'b0;
106 end
107 EXZIT1 : begin
108 load_ir <= 1'b0;
109 clk_inc <= 1'b1; //指向下一条指令首地址或（当执行跳过指令时：表示跳过下一条指令的高8位地址）
110 load_pc <= 1'b0;
111 load_acc <= 1'b0;
112 addr_sel <= 1'b0;
113 data_link <= 1'b0;
114 wr <= 1'b0;
115 rd <= 1'b0;
116 end
117 EXZIT2 : begin //在这个状态就要用ir操作码，前面状态都是相同的取操作码和进行操作数据的地址（可以读/写）
118 if((ir == RD ) || (ir == XOR) || (ir == SFT) || (ir == SUB))
119 begin
120 load_ir <= 1'b0;
121 clk_inc <= 1'b0;
122 load_pc <= 1'b0;
123 load_acc <= 1'b0;
124 addr_sel <= 1'b0;
125 data_link <= 1'b0;
126 wr <= 1'b0;
127 rd <= 1'b1;
128 end
129 else
130 if(ir == NJMP)
131 begin
132 load_ir <= 1'b0;
133 clk_inc <= 1'b0;
134 load_pc <= 1'b1; /******可以不需要这个可以给0；但要保证数据的准确性所以在这给了1*****/
135 load_acc <= 1'b0;
136 addr_sel <= 1'b0;
137 data_link <= 1'b0;
138 wr <= 1'b0;
139 rd <= 1'b0;
140 end
141 else
142 if(ir == WR) //拉高data_link
143 begin
144 load_ir <= 1'b0;
145 clk_inc <= 1'b0;
146 load_pc <= 1'b0;
147 load_acc <= 1'b0;
148 addr_sel <= 1'b0;
149 data_link <= 1'b1;
150 wr <= 1'b0;
151 rd <= 1'b0;
152 end
153 else
154 begin
155 load_ir <= 1'b0;
156 clk_inc <= 1'b0;
157 load_pc <= 1'b0;
158 load_acc <= 1'b0;
159 addr_sel <= 1'b0;
160 data_link <= 1'b0;
161 wr <= 1'b0;
162 rd <= 1'b0;
163 end
164 end
165 EXZIT3 : begin
166 if(ir == SKZ)//拉高clk_inc，表示跳过下一条指令的低8位地址
167 begin
168 load_ir <= 1'b0;
169 clk_inc <= 1'b1;
170 load_pc <= 1'b0;
171 load_acc <= 1'b0;
172 addr_sel <= 1'b0;
173 data_link <= 1'b0;
174 wr <= 1'b0;
175 rd <= 1'b0;
176 end
177 else
178 if(ir == NJMP)
179 begin
180 load_ir <= 1'b0;
181 clk_inc <= 1'b1; /****当clk_inc为高*******/
182 load_pc <= 1'b1; /******load_pc也为高时，才跳转到指令操作地址所指向的存储空间中执行新的指令*****/
183 load_acc <= 1'b0;
184 addr_sel <= 1'b0;
185 data_link <= 1'b0;
186 wr <= 1'b0;
187 rd <= 1'b0;
188 end
189 else
190 if(ir == WR) //拉高data_link和wr
191 begin
192 load_ir <= 1'b0;
193 clk_inc <= 1'b0;
194 load_pc <= 1'b0;
195 load_acc <= 1'b0;
196 addr_sel <= 1'b0;
197 data_link <= 1'b1;
198 wr <= 1'b1;
199 rd <= 1'b0;
200 end
201 else
202 begin
203 load_ir <= 1'b0;
204 clk_inc <= 1'b0;
205 load_pc <= 1'b0;
206 load_acc <= 1'b0;
207 addr_sel <= 1'b0;
208 data_link <= 1'b0;
209 wr <= 1'b0;
210 rd <= 1'b0;
211 end
212 end
213 EXZIT4 : begin //在这个状态也要用ir操作码
214 if((ir == RD ) || (ir == XOR) || (ir == SFT) || (ir == SUB))begin
215 load_ir <= 1'b0;
216 clk_inc <= 1'b0;
217 load_pc <= 1'b0;
218 load_acc <= 1'b1;
219 addr_sel <= 1'b0;
220 data_link <= 1'b0;
221 wr <= 1'b0;
222 rd <= 1'b0;
223 end
224 else
225 begin
226 load_ir <= 1'b0;
227 clk_inc <= 1'b0;
228 load_pc <= 1'b0;
229 load_acc <= 1'b0;
230 addr_sel <= 1'b0;
231 data_link <= 1'b0;
232 wr <= 1'b0;
233 rd <= 1'b0;
234 end
235 end
236 EXZIT5 : begin
237 if(ir == SKZ) //拉高clk_inc，指向下一条指令首地址
238 begin
239 load_ir <= 1'b0;
240 clk_inc <= 1'b1;
241 load_pc <= 1'b0;
242 load_acc <= 1'b0;
243 addr_sel <= 1'b0;
244 data_link <= 1'b0;
245 wr <= 1'b0;
246 rd <= 1'b0;
247 end
248 else
249 begin
250 load_ir <= 1'b0;
251 clk_inc <= 1'b0;
252 load_pc <= 1'b0;
253 load_acc <= 1'b0;
254 addr_sel <= 1'b0;
255 data_link <= 1'b0;
256 wr <= 1'b0;
257 rd <= 1'b0;
258 end
259 end
260 default : begin
261 load_ir <= 1'b0;
262 clk_inc <= 1'b0;
263 load_pc <= 1'b0;
264 load_acc <= 1'b0;
265 addr_sel <= 1'b0;
266 data_link <= 1'b0;
267 wr <= 1'b0;
268 rd <= 1'b0;
269 end
270 endcase
271 end
272
273 endmodule
3、计算组件
1 ///********************计算组件*************************/
2 ////主要完成数学或者逻辑运算，是CPU的核心组件
3 module alu(clk, rst_n, data, acc, alu_en, ir, alu_out);
4
5 input clk, rst_n; //系统时钟、复位
6 //控制信号
7 input alu_en; //当alu_en=1计算
8 input [15:13] ir; //操作码ir[15:13]
9
10 input [7:0] data; //外部存储器读取的数通过数据总线表示
11 input [7:0] acc; //运算时候所有的指令需要累加器参与运算
12
13 //输出运算结果
14 output reg [7:0] alu_out; //计算输出
15
16 parameter HLT = 3'b000,
17 RD = 3'b001,
18 WR = 3'b010,
19 SFT = 3'b011,
20 XOR = 3'b100,
21 SUB = 3'b101,
22 SKZ = 3'b110,
23 NJMP = 3'b111;
24
25 reg [7:0] data_r;
26 always @ (posedge clk, negedge rst_n)
27 begin
28 if(~rst_n)
29 data_r <= 8'd0;
30 else
31 data_r <= data;
32 end
33
34 always @ (posedge clk, negedge rst_n)
35 begin
36 if(~rst_n)
37 alu_out <= 8'd0;
38 else
39 if(alu_en)
40 case(ir)
41 HLT : alu_out <= acc; //HLT（空指令）:该指令不做任何操作
42 RD : alu_out <= data_r; //RD:将操作地址空间的数据读出，保存在累加器中
43 WR : alu_out <= acc; //WR:将累加器的数据写入操作地址空间中
44 SFT : alu_out <= {data_r[6:0], data_r[7]}; //SFT:将操作地址空间的数据读出（循环）左移1位，然后计算结果保存在累加器中
45 XOR : alu_out <= data_r ^ acc; //XOR:将操作地址空间的数据读出和累加器相异或，然后计算结果保存在累加器中
46 SUB : alu_out <= data_r - acc; //SUB:将操作地址空间的数据读出和累加器相减，然后计算结果保存在累加器中
47 SKZ : alu_out <= acc; //SKZ:跳过下一条指令执行下下一条指令
48 NJMP : alu_out <= acc; //NJMP:跳转到该指令所指向的地址空间处读取新的指令
49 default : alu_out <= alu_out;
50 endcase
51 end
52
53 endmodule
4、累加器
1 /*****************累加器***********************/
2 //主要用于保存ALU的计算结果
3 module acc_m(clk, rst_n, alu_out, load_acc, acc);
4
5 input clk, rst_n; //系统时钟、复位
6
7 //控制信号
8 input load_acc; //当load_acc=1的时候将alu的计算结果保存到累加器中
9
10 input [7:0] alu_out; //计算组件计算的结果
11 output reg [7:0] acc; //将计算组件计算的结果存入acc
12
13 always @ (posedge clk, negedge rst_n)
14 begin
15 if(~rst_n)
16 acc <= 8'd0;
17 else
18 if(load_acc)
19 acc <= alu_out;
20 end
21
22 endmodule
5、指令寄存
1 /*******************指令集寄存器*******************/
2 //寄存当前用于分析和执行的指令
3 module ir_register(clk, rst_n, data, load_ir, ir);
4
5 input clk, rst_n; //系统时钟、复位（CPU核心工作时钟）
6 //控制信号
7 input load_ir; //当load_ir=1的时候从数据总线加载指令
8 //数据总线
9 input [7:0] data; //CPU数据总线默认8bit
10 //输出指令
11 output reg [15:0] ir; //指令：默认16bit
12
13 //Note:由于数据总线8位的，指令是16位，因此需要加载两次才能完成一次指令的加载，在这里先加载指令高8位，再加载指令低8位
14 always @ (posedge clk, negedge rst_n)
15 begin
16 if(~rst_n)
17 ir <= 16'd0;
18 else
19 if(load_ir)
20 ir <= {ir[7:0], data[7:0]};
21 end
22
23 endmodule
6、指令地址发生器
1 /******************指令地址发生器******************/
2 //主要用于产生指令地址（指令放在存储器中）
3 module pc_addr_gen(clk_inc, rst_n, load_pc, pc_addr, ir);
4
5 input rst_n; //系统复位
6 //控制信号
7 input clk_inc; //用于控制指令地址变化，该信号上升沿地址自加
8 input load_pc; //当该信号为高电平的时候跳转指令地址所指向的存储空间读取指令；当load_pc=1，加载新的指令地址
9 input [12:0] ir; //指令操作地址
10 //输出指令地址
11 output reg [12:0] pc_addr;
12
13 always @ (posedge clk_inc, negedge rst_n)
14 begin
15 if(~rst_n)
16 pc_addr <= 13'd0; //复位初始地址。文件地址初始为0，我们如果改初始地址，则将会跳过一些指令（不执行一些指令）
17 else
18 if(load_pc)
19 pc_addr <= ir[12:0];
20 else
21 pc_addr <= pc_addr + 1'b1; //若没有跳转，则指令地址+1
22 end
23
24 endmodule
7、数据选择
1 module data_sel_m(data_sel, acc, data);
2
3 input data_sel;
4 input [7:0] acc;
5 inout [7:0] data;
6
7 assign data = (data_sel) ? acc : 8'hzz; //进行读操作时，data为高阻状态，读取数据
8
9 endmodule
8、地址路由
1 module addr_sel_m(ir, pc_addr, addr_sel, addr);
2
3 input [12:0] ir;
4 input [12:0] pc_addr;
5 input addr_sel;
6 output reg [12:0] addr;
7
8 always @ (*)
9 begin
10 if(addr_sel)
11 addr = pc_addr;
12 else
13 addr = ir;
14 end
15
16 endmodule
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
