数字逻辑实验：Vivado设计单周期RISC-V处理器

已于 2025-02-24 20:53:32 修改
阅读量287 收藏 4
点赞数 6
文章标签： risc-v
于 2025-02-24 20:00:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80899857/article/details/145826348
版权

从子模块开始，按照向上的逻辑依次展示每一个模块代码如下：

immprocess.sv：根据immpro的控制信号处理立即数

module immprocess(input logic[31:0]instr,
                  input logic[2:0]immpro,
                  output logic[31:0]y);
	always_comb
	   case(immpro)
	       3'b001:y={{20{instr[31]}},instr[31:20]};
	       3'b010:y={{20{instr[31]}},instr[31:25],instr[11:7]};
	       3'b011:y={{19{instr[31]}},instr[31],instr[7],instr[30:25],instr[11:8],1'b0};
	       3'b100:y={instr[31:12],12'b0};
	       3'b101:y={{11{instr[31]}},instr[31],instr[19:12],instr[20],instr[30:21],1'b0};
	       default:y=32'b0;
	   endcase
endmodule

adder.sv：一个加法器

module adder(input logic[31:0]a,
             input logic[31:0]b,
             output logic[31:0]y);
	assign y = a+b;
endmodule

mux2.sv：一个2:1的选择器

module mux2#(parameter WIDTH = 8)
            (input logic[WIDTH-1:0]d0,
             input logic[WIDTH-1:0]d1,
             input logic s,
             output logic[WIDTH-1:0]y);
	assign y = s?d1:d0;
endmodule

flopr.sv：处理下一个PC的模块

module flopr#(parameter WIDTH = 8)
             (input logic clk,
              input logic reset,
              input logic[WIDTH-1:0]d,
              output logic[WIDTH-1:0]q);
	
	always_ff@(posedge clk,posedge reset)
		if (reset)
			q <= 0;
		else
			q <= d;
endmodule

regfile.sv：寄存器文件，对寄存器进行操作

module regfile(input logic clk,
               input logic we3,
               input logic[4:0] ra1,
               input logic[4:0] ra2,
               input logic[4:0] wa3,
               input logic[31:0]wd3,
               output logic[31:0]rd1,
               output logic[31:0]rd2,
               output logic[31:0]rf[31:0]
               );

	//three ported register file
	// read two ports combinationally
	// write third port on rising edge of clk
	// register 0 hardwired to0
	// note:for pipelined processor,write third port on falling edge of clk
	always_ff@(posedge clk)
		if (we3)
			rf[wa3] <= wd3;
	assign rd1 = (ra1!= 0)?rf[ra1]:0;
	assign rd2 = (ra2!= 0)?rf[ra2]:0;
endmodule

alu.sv：根据alucontrol的信号决定alu进行何种运算

module alu(input logic [31:0] srca,
           input logic [31:0] srcb,
           input logic [3:0] alucontrol,
           output logic [31:0] aluout,
           output logic zero,
           output logic smaller);
	always_comb
		case (alucontrol)
			4'b0010: aluout  = srca + srcb;
			4'b0110: aluout  = srca - srcb;
			4'b0000: aluout  = srca & srcb;
			4'b0001: aluout  = srca | srcb;
			4'b0111: aluout  = (srca < srcb) ? 32'd1 : 32'd0;
			4'b0011: aluout  = srca >> srcb;
			4'b0100: aluout  = srca << srcb;
			4'b0101: aluout  = srca ^ srcb;
			4'b1000: aluout  = srca >>> srcb;
			default: aluout = 32'b0;
		endcase
	assign zero = (aluout == 32'b0);
	assign smaller = (srca < srcb);

endmodule

datapath.sv：包含对alu与register整体处理的模块

module datapath(input logic clk,                                             
                input logic reset,
                input logic memtoreg,
                input logic branch_beq,
                input logic branch_bne,
                input logic branch_blt,
                input logic alusrc,
                input logic regwrite,
                input logic jump,
                input logic [3:0]alucontrol,
                input logic [2:0]immpro,
                input logic isonlyimm,
                output logic [31:0] pc,
                input logic [31:0] instr,
                output logic [31:0] aluout,
                output logic [31:0] writedata,
                input logic [31:0] readdata,
                output logic[31:0]rf[31:0]
                );
	

	logic[31:0]pcnext,pcnextbr_beq,pcnextbr_bne,pcnextbr_blt,pcplus4,pcbranch;
	logic[31:0]signimm;
	logic[31:0]srca,srcb;
	logic[31:0]result_1,result;
	logic zero,pcsrc_beq,pcsrc_bne,pcsrc_blt,smaller;
	
	assign pcsrc_beq=zero & branch_beq;
	assign pcsrc_bne=(~zero) & branch_bne;
	assign pcsrc_blt=smaller & branch_blt;
	
	immprocess immp(.instr(instr),
                    .immpro(immpro),
                    .y(signimm));
                    
	adder pcadd1(
		.a(pc),
		.b(32'b100),
		.y(pcplus4)
	);
	
	adder pcadd2(
		.a(pc),
		.b(signimm),
		.y(pcbranch)
	);

	mux2#(.WIDTH(32)) pcbrmux_beq(
		.d0(pcplus4),
		.d1(pcbranch),
		.s(pcsrc_beq),
		.y(pcnextbr_beq)
	);
	
	mux2#(.WIDTH(32)) pcbrmux_bne(
		.d0(pcnextbr_beq),
		.d1(pcbranch),
		.s(pcsrc_bne),
		.y(pcnextbr_bne)
	);
	
	mux2#(.WIDTH(32)) pcbrmux_blt(
		.d0(pcnextbr_bne),
		.d1(pcbranch),
		.s(pcsrc_blt),
		.y(pcnextbr_blt)
	);
	
	mux2#(.WIDTH(32)) pcmux(
		.d0(pcnextbr_blt),
		.d1(pcbranch),
		.s(jump),
		.y(pcnext)
	);
	
	//nextPC logic
	flopr#(.WIDTH(32)) pcreg(
		.clk(clk),
		.reset(reset),
		.d(pcnext),
		.q(pc)
	);
	
	regfile rfile(
		.clk(clk),
		.we3(regwrite),
		.ra1(instr[19:15]),
		.ra2(instr[24:20]),
		.wa3(instr[11:7]),
		.wd3(result),
		.rd1(srca),
		.rd2(writedata),
		.rf(rf)
	);
	
	//ALU logic
	mux2#(.WIDTH(32)) srcbmux(
		.d0(writedata),
		.d1(signimm),
		.s(alusrc),
		.y(srcb)
	);

    alu alu(
		.srca(srca),
		.srcb(srcb),
		.alucontrol(alucontrol),
		.aluout(aluout),
		.zero(zero),
		.smaller(smaller)
	);
	
	// register file logic
	
	mux2#(.WIDTH(32)) resmux(
		.d0(aluout),
		.d1(readdata),
		.s(memtoreg),
		.y(result_1)
	);
	
	mux2#(.WIDTH(32)) resimm(
		.d0(result_1),
		.d1(signimm),
		.s(isonlyimm),
		.y(result)
	);
	
endmodule

controller.sv：控制器，根据输入的机器码决定一系列控制信号

module controller(input logic [6:0]opcode,
                  input logic [6:0]funct7,
                  input logic [2:0]funct3,
                  output logic [2:0]immpro,
                  output logic isonlyimm,
                  output logic memtoreg,
                  output logic memwrite,
                  output logic branch_beq,
                  output logic branch_bne,
                  output logic branch_blt,
                  output logic alusrc,
                  output logic regwrite,
                  output logic jump,
                  output logic [3:0]alucontrol
                );
	logic [15:0]controls;
	always_comb
		case(opcode)
			7'b0110011://处理R指令
                case(funct7)
                     7'b0000000:
                         case(funct3)
                             3'b000:controls=16'b1_0_0_0_0_0_0_0_0010_000_0;//add
                             3'b001:controls=16'b1_0_0_0_0_0_0_0_0100_000_0;//sll
                             3'b010:controls=16'b1_0_0_0_0_0_0_0_0111_000_0;//slt
                             3'b100:controls=16'b1_0_0_0_0_0_0_0_0101_000_0;//xor
                             3'b101:controls=16'b1_0_0_0_0_0_0_0_0011_000_0;//srl
                             3'b110:controls=16'b1_0_0_0_0_0_0_0_0001_000_0;//or
                             3'b111:controls=16'b1_0_0_0_0_0_0_0_0000_000_0;//and
                             default:controls=16'bx_x_x_x_x_x_x_x_xxxx_xxx_x;
                         endcase
                     7'b0100000:
                         case(funct3)
                             3'b000:controls=16'b1_0_0_0_0_0_0_0_0110_000_0;//sub
                             3'b101:controls=16'b1_0_0_0_0_0_0_0_1000_000_0;//sra
                             default:controls=16'bx_x_x_x_x_x_x_x_xxxx_xxx_x;
                         endcase
                     default:controls=16'bx_x_x_x_x_x_x_x_xxxx_xxx_x;
                 endcase
             7'b0010011://第一类I指令
                 case(funct3)
                     3'b000:controls=16'b1_1_0_0_0_0_0_0_0010_001_0;//addi
                     3'b110:controls=16'b1_1_0_0_0_0_0_0_0001_001_0;//ori
                     3'b111:controls=16'b1_1_0_0_0_0_0_0_0000_001_0;//andi
                     default:controls=16'bx_x_x_x_x_x_x_x_xxxx_xxx_x;
                 endcase
             7'b0000011://lw指令
                controls=16'b1_1_0_0_0_0_1_0_0010_001_0;//lw
             7'b0100011://sw指令
                controls=16'b0_1_0_0_0_1_0_0_0010_010_0;//sw
             7'b1100111://jalr指令
                controls=16'b1_1_0_0_0_0_0_1_0010_001_0;//jalr
             7'b1100011://B指令
                case(funct3)
                    3'b000:controls=16'b0_0_1_0_0_0_0_0_0110_011_0;//beq
                    3'b001:controls=16'b0_0_0_1_0_0_0_0_0110_011_0;//bne
                    3'b100:controls=16'b0_0_0_0_1_0_0_0_0110_011_0;//blt
                    default:controls=16'bx_x_x_x_x_x_x_x_xxxx_xxx_x;
                endcase
             7'b1101111://J指令
                controls=16'b0_0_0_0_0_0_0_1_0010_101_0;//jal
             7'b0110111:
                controls=16'b1_1_0_0_0_0_0_0_0010_100_1;//lui
             default:controls=16'bx_x_x_x_x_x_x_x_xxxx_xxx_x;
         endcase 
         
    assign {regwrite,alusrc,branch_beq,branch_bne,branch_blt,memwrite,memtoreg,jump,alucontrol,immpro,isonlyimm} = controls; 
      		         
endmodule

risc.sv：单周期RISC-V处理器对机器码处理整体实现

module risc(input logic clk,
            input logic reset,
            output logic[31:0]pc,
            input logic[31:0]instr,
            output logic memwrite,
            output logic[31:0]aluout,
            output logic[31:0]writedata,
            input logic[31:0]readdata,
            output logic[31:0]rf[31:0])
            ;
	
	logic memtoreg,alusrc,regwrite,jump,branch_beq,branch_bne,branch_blt,isonlyimm;
	logic [3:0]alucontrol;
	logic [2:0]immpro;
	
	controller c(
		.opcode(instr[6:0]),
		.funct7(instr[31:25]),
		.funct3(instr[14:12]),
		.immpro(immpro),
		.isonlyimm(isonlyimm),
		.memtoreg(memtoreg),
		.memwrite(memwrite),
        .branch_beq(branch_beq),
        .branch_bne(branch_bne),
		.alusrc(alusrc),
		.regwrite(regwrite),
		.jump(jump),
		.alucontrol(alucontrol),
		.branch_blt(branch_blt)
	);
	
	datapath dp(
		.clk(clk),
		.reset(reset),
		.memtoreg(memtoreg),
	    .branch_beq(branch_beq),
	    .branch_bne(branch_bne),
	    .branch_blt(branch_blt),
		.alusrc(alusrc),
		.regwrite(regwrite),
		.jump(jump),
		.alucontrol(alucontrol),
		.immpro(immpro),
		.isonlyimm(isonlyimm),
		.pc(pc),
		.instr(instr),
		.aluout(aluout),
		.writedata(writedata),
		.readdata(readdata),
		.rf(rf)
	);
endmodule

imem.sv：指令存储器

module imem(input logic[5:0] a,
            output logic[31:0]rd);
/*
logic[31:0]RAM[63:0];
initial
	$readmemh("C:\Users\DELL\Desktop\单周期RISC-V处理器设计\memfile.dat",RAM);
*/
// 不要声明很大的数组，FPGA板子放不下

//基本测试，用于跑simulation出一个较好的波形图

logic[31:0]RAM[0:18] = { // 注意！指令存储器容量最多只有64个字！
32'h00500113,
32'h00c00193,
32'hff718393,
32'h0023e233,
32'h0041f2b3,
32'h004282b3,
32'h02728663,
32'h0041a233,
32'h00020463,
32'h00000293,
32'h0023a233,
32'h005203b3,
32'h402383b3,
32'h0471a223,
32'h05002103,
32'h008000ef,
32'h00100113,
32'h04202a23,
32'hfe000ee3	// beq $0,$0,self，跳转到自己，终止执行后续指令
};

/*
//求1到100和的测试，用于跑BASYS板子
logic[31:0]RAM[0:11] = { // 注意！指令存储器容量最多只有64个字！
32'h000003b7,
32'h00038393,
32'h00000437,
32'h06340413,
32'h000004b7,
32'h00048493,
32'h00944863,
32'h00148493,
32'h009383b3,
32'hff5ff0ef,
32'h04702a23,
32'hfe000ee3    // beq $0,$0,self，跳转到自己，终止执行后续指令
};
*/

assign rd = RAM[a]; // 注意！指令存储器容量最多只有64个字！
endmodule

dmem.sv：数据存储器

module dmem(input logic clk,
            input logic we,
            input logic[31:0]a,
            input logic[31:0]wd,
            output logic[31:0]rd);
	
	// 不要声明很大的数组，FPGA板子放不下
	logic[31:0]RAM[63:0];	// 注意！数据存储器容量最多只有64个字！
	assign rd = RAM[a[7:2]]; // word aligned
	
	always_ff@(posedge clk)
		if (we)
			RAM[a[7:2]] <= wd;
endmodule

以上是所必需的基本模块，下面的模块分别用于跑板子和跑simulation。

（一）跑simulation所需的模块：

top.sv：用于跑simulation的顶层模块

module top(input logic clk,
			input logic reset,
			output logic success_led,
			output logic fail_led,
			output logic[31:0] pc
	);
	logic[31:0]readdata,instr,dataadr,writedata;
	logic memwrite;
	logic[31:0]rf[31:0];

	//instantiate processor and memories
	imem imem(
		.a(pc[7:2]),
		.rd(instr)
	);
	risc risc(
		.clk(clk),
		.reset(reset),
		.pc(pc),
		.instr(instr),
		.memwrite(memwrite),
		.aluout(dataadr),
		.writedata(writedata),
		.readdata(readdata),
		.rf(rf)
	);
	dmem dmem(
		.clk(clk),
		.we(memwrite),
		.a(dataadr),
		.wd(writedata),
		.rd(readdata)
	);
  
	// 加入两个led指示灯。当写入存储器地址84且数据是7时，点亮success_led灯
	// 如果第1次写入的地址不是80，点亮fail_led灯
	always_ff @(posedge clk,posedge reset)
		if (reset)
		begin
			success_led <= 1'b0;
			fail_led <= 1'b0;
		end
		else if (memwrite == 1'b1)
		begin
			if (dataadr == 84 & writedata == 7)
				success_led <= 1'b1;
			else if (dataadr != 80)
				fail_led <= 1'b1;
		end
endmodule

testbench.sv：用于跑simulation的仿真波形图

`timescale 1ns / 1ps

module testbench();
	logic clk;
	logic reset;
	logic success_led;
	logic fail_led;
	logic [31:0]pc;

	// instantiate device to be tested
	top dut(
		.clk(clk),
		.reset(reset),
		.success_led(success_led),
		.fail_led(fail_led),
		.pc(pc)
	);
	
	// initialize test
	initial
	begin
		reset = 1;
		#10;
		reset = 0;
	end
	
	// generate clock to sequence tests
	always
	begin
	clk = 1;
	#1;
	clk = 0;
	#1;
	end
	
	// check results
	always@(posedge clk)
	begin
		if (success_led)
		begin
			$display("Simulation succeeded");
		end
		if (fail_led)
		begin
			$display("Simulation failed");
		end
	end
endmodule

（二）跑板子所需的模块

display_sum.sv：用于让板子显示最后求和得到的结果

`timescale 1ns / 1ps

module display_sum(
        input clk,
        input [31:0]num,
        output logic [10:0] disp_7seg
    ); 
  logic [1:0] sel=0;
  logic [19:0]count=0;
  logic [3:0] num1,num2,num3,num4,disp_number;
  parameter T1MS=50000; 

  always@(posedge clk) 
    begin 
        count<=count+1; 
        if(count==T1MS) 
            begin 
                count<=0; 
                sel<=sel+1; 
                if(sel==4) 
                    sel<=0; 
            end 
    end 
      
  assign num1=num/1000%10;
  assign num2=num/100%10;
  assign num3=num/10%10;
  assign num4=num%10;
  
  always_comb
    case(disp_number)
        4'd0: disp_7seg[6:0] = 7'b0000001;
	    4'd1: disp_7seg[6:0] = 7'b1001111;
		4'd2: disp_7seg[6:0] = 7'b0010010;
		4'd3: disp_7seg[6:0] = 7'b0000110;
		4'd4: disp_7seg[6:0] = 7'b1001100;
		4'd5: disp_7seg[6:0] = 7'b0100100;
		4'd6: disp_7seg[6:0] = 7'b0100000;
		4'd7: disp_7seg[6:0] = 7'b0001111;
		4'd8: disp_7seg[6:0] = 7'b0000000;
		4'd9: disp_7seg[6:0] = 7'b0000100;
		default: disp_7seg[6:0] = 7'b1111111;
	endcase
	
  always_comb 
    case(sel) 
        0: begin disp_7seg[10:7] = 4'b1110; disp_number = num4; end
		1: begin disp_7seg[10:7] = 4'b1101; disp_number = num3; end
		2: begin disp_7seg[10:7] = 4'b1011; disp_number = num2; end
		3: begin disp_7seg[10:7] = 4'b0111; disp_number = num1; end 
		default:begin disp_7seg[10:7] = 4'b1111; disp_number = 4'd0; end 
    endcase 
        
endmodule

top_show_sum.sv：跑板子所需的顶层模块

`timescale 1ns / 1ps

module top_show_sum(input logic clk,
			input logic reset,
			output logic [10:0] disp_7seg
	);

	logic[31:0]readdata,instr,pc,dataadr,writedata;
	logic[31:0]rf[31:0];
	logic memwrite;

	//instantiate processor and memories
	imem imem(
		.a(pc[7:2]),
		.rd(instr)
	);
	risc risc(
		.clk(clk),
		.reset(reset),
		.pc(pc),
		.instr(instr),
		.memwrite(memwrite),
		.aluout(dataadr),
		.writedata(writedata),
		.readdata(readdata),
		.rf(rf)
	);
	dmem dmem(
		.clk(clk),
		.we(memwrite),
		.a(dataadr),
		.wd(writedata),
		.rd(readdata)
	);
	display_sum dis(
	    .clk(clk),
	    .num(rf[7]),
	    .disp_7seg(disp_7seg)
	);
	    
endmodule

约束文件（可以根据自己需求自行修改调整）：

set_property PACKAGE_PIN W5 [get_ports clk] 
set_property IOSTANDARD LVCMOS33 [get_ports clk] 
set_property PACKAGE_PIN V17 [get_ports reset] 
set_property IOSTANDARD LVCMOS33 [get_ports reset] 

set_property PACKAGE_PIN W4 [get_ports {disp_7seg[10]}] 
set_property PACKAGE_PIN V4 [get_ports {disp_7seg[9]}] 
set_property PACKAGE_PIN U4 [get_ports {disp_7seg[8]}] 
set_property PACKAGE_PIN U2 [get_ports {disp_7seg[7]}] 
set_property PACKAGE_PIN W7 [get_ports {disp_7seg[6]}] 
set_property PACKAGE_PIN W6 [get_ports {disp_7seg[5]}] 
set_property PACKAGE_PIN U8 [get_ports {disp_7seg[4]}] 
set_property PACKAGE_PIN V8 [get_ports {disp_7seg[3]}] 
set_property PACKAGE_PIN U5 [get_ports {disp_7seg[2]}] 
set_property PACKAGE_PIN V5 [get_ports {disp_7seg[1]}] 
set_property PACKAGE_PIN U7 [get_ports {disp_7seg[0]}] 
set_property IOSTANDARD LVCMOS33 [get_ports {disp_7seg[10]}] 
set_property IOSTANDARD LVCMOS33 [get_ports {disp_7seg[9]}] 
set_property IOSTANDARD LVCMOS33 [get_ports {disp_7seg[8]}] 
set_property IOSTANDARD LVCMOS33 [get_ports {disp_7seg[6]}] 
set_property IOSTANDARD LVCMOS33 [get_ports {disp_7seg[7]}]
set_property IOSTANDARD LVCMOS33 [get_ports {disp_7seg[5]}] 
set_property IOSTANDARD LVCMOS33 [get_ports {disp_7seg[4]}] 
set_property IOSTANDARD LVCMOS33 [get_ports {disp_7seg[3]}] 
set_property IOSTANDARD LVCMOS33 [get_ports {disp_7seg[1]}] 
set_property IOSTANDARD LVCMOS33 [get_ports {disp_7seg[2]}] 
set_property IOSTANDARD LVCMOS33 [get_ports {disp_7seg[0]}]

PS：（1）注意跑板子与跑仿真图之间切换时，imem.sv中的测试指令集机器码也要切换；

         （2）跑板子时将跑仿真图所需的两个模块（top.sv与testbench.sv）disable掉，跑仿真图时同理；

         （3）板子只会显示最后的计算结果，可以创新让板子显示出每一次迭代后求和的计算结果（在本人下一个“多周期RISC-V处理器实现”中有实现这个效果）

         （4）记得文件路径不要带中文，否则跑不了板子！！！（本人因为这个耗了一晚上时间捏）

基于Vivado的RISC-V 32位单周期处理器CPU设计与实现：SystemVerilog代码解析及应用
04-12
内容概要：本文档详细介绍了基于Vivado平台实现的RISC-V 32位单周期处理器的设计与实现。主要内容涵盖寄存器组、ALU控制单元、指令译码、存储器接口以及仿真实验等方面。文中不仅提供了详细的SystemVerilog代码示例，还附带了中文手册和指令集文档，帮助初学者更好地理解和掌握RISC-V架构的工作原理。此外，文档还讨论了一些常见的陷阱和注意事项，如组合逻辑延迟、时钟频率设置等。 适合人群：适合对CPU设计感兴趣的初学者，尤其是那些希望通过实际项目深入理解RISC-V架构的人群。 使用场景及目标：①学习RISC-V指令集及其具体实现；②掌握SystemVerilog编程技巧；③熟悉Vivado工具链的使用方法；④理解单周期CPU的工作流程和内部机制。 其他说明：文档强调了理论与实践相结合的学习方法，鼓励读者动手修改测试用例并观察波形图的变化，从而加深对CPU运行原理的理解。同时，提供的中文手册为初学者解决了语言障碍，使得学习过程更加顺畅。
单周期CPU设计vivado
12-03
单周期CPU设计的文件，语言verilog，打开之后，可以用vivado直接跑，思路是正确的，具体的指令需要根据要求做小幅度调整
大二下学期个人学习笔记（2）——单周期cpu的设计（37条指令，trace下板，外设下板）
qq_52399968的博客
07-20 1443
这篇文章是单周期cpu设计的trace比对版的延续，主要介绍了trace比对通过后，单周期cpu如何进行下板验证，以及如何进行外设的设计，让cpu能跑自己写的汇编代码。
Vivado RISC-V SoC 开发环境搭建指南
gitblog_01060的博客
04-16 588
Vivado RISC-V SoC 开发环境搭建指南 vivado-risc-v Xilinx Vivado block designs for FPGA RISC-V SoC running Debian Linux distro ...
单周期CPU Vivado
07-25
用Vivado实现一个单周期CPU，不包含烧电路板内容，根据2018年的计算机组成原理及接口技术的实验课程要求。
vivado设计单周期CPU
m0_55674689的博客
06-20 2957
设计单周期CPU
verilog语言实现单周期CPU（使用vivado软件）.zip
06-11
这是计算机组成原理课设，基于verilog实现的单周期CPU代码，实现了add, addu, addi, addiu, sub, slt, and, or, xor, beq, j, sw, lw, lui,andi，addu，ori，xori，共18条指令，能够运行简单的冒泡排序。内含单周期图。
单周期处理器（systemverilog实现，vivado开发）
12-03
单周期处理器（CPU），支持以下指令：lw、sw、beq、addi、add、sub、and、or、slt。使用的开发环境是vivado，文件在压缩包中的single_cycle_processor.xpr内。压缩包内有单周期CPU的示意图。
基于RISC-V的处理器设计与实现
05-18
【作品名称】：基于RISC-V的处理器设计与实现 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】： 实验环境： 软件：...
基于Vivado的RISC-V 32位单周期处理器设计与实现：SystemVerilog代码解析及学习资源
04-11
内容概要：本文详细介绍了一款基于Vivado平台和SystemVerilog语言实现的RISC-V 32位单周期处理器。该处理器采用RV32I指令集，结构简单，适合初学者学习。文中不仅提供了详细的代码实现，如指令存储、处理器核心、...
基于Vivado的RISC-V 32位单周期处理器CPU设计与实现：SystemVerilog代码解析及学习指南
最新发布
05-23
内容概要：本文详细介绍了基于Vivado平台的RISC-V 32位单周期处理器CPU的设计与实现。该处理器采用SystemVerilog编写，结构简单明了，分为四个主要模块：取指令、译指、执行和写回。文中提供了详细的代码片段，如...
MIPS_CPU Vivado 单周期
02-25
MIPS单周期CPU，实现24+4条指令 可直接在vivado中运行
单周期CPU设计与Verilog实现
06-29
单周期的整个项目，在电脑上安装vivado即可添加项目，我个人使用的是15版的。另外需要看波形图的，点击仿真，调节相关参数即可
基于Vivado的精简指令CPU设计
09-09
利用Xilinx的Vivado套件（包括VivadoHLS）设计的精简指令集CPU架构，里面包含了各个模块所需的仿真文件。下载资源的人需要先了解一下ARM指令集与ARM架构。
RISC-V 32单周期处理器CPU：Vivado工程，SystemVerilog编写，结构简洁，仿真实践，附中文手册和指令集文档,RISC-V 32单周期处理器CPU工程：Vivado开发，Syst
03-04
RISC-V 32单周期处理器CPU：Vivado工程，SystemVerilog编写，结构简洁，仿真实践，附中文手册和指令集文档,RISC-V 32单周期处理器CPU工程：Vivado开发，SystemVerilog编写，结构简洁，仿真演示，初学者首选，附赠...
《我的Vivado实战—单周期CPU指令分析》
董哲朋的博客
08-06 5180
引言   不知道你是否和我有过同样的感受，《计算机组成原理》这门学科学起来如此的艰难：一节课下来，教室黑板上留下了满满的 “足迹”，看上去也挺简单的，不就是 0 和 1 嘛。但这些看起来简简单单的 0 1 码却成为了我当时学习路上的绊脚石。源码、反码、补码等等等等，各种的码制转换令我一头雾水，我曾一度怀疑这就是计算机干的活儿吗？   随着后面慢慢了解《计算机组成原理》后，我愿称计算机为世界上最麻烦的电子产品。也形象的将计算机描述为一套有电源、有身体、有框架，但就是没有思想的空壳儿。这时候，我们的人类社会才萌
计算机组成与结构课程设计 单周期CPU的译码模块设计（vivado）
m0_61128650的博客
07-09 1243
对于目标寄存器的指定模块则需要根据RegDst和Jal信号的不同来给write_register_address信号附上不同的值，若RegDst信号为1，Jal信号为0，则赋值为rd，若RegDst信号为0，Jal信号为1，则赋值为31(5’b11111)，其他情况，即RegDst和Jal信号均为0时，则赋值为rt，由于RegDst和Jal不同时为1忽略其赋值。.read_data (read_data), // 从DATA RAM or I/O port取出的数据。
riscv 32单周期处理器cpu，工程基于vivado，指令集rv32i,systemverilog编写，结构简单，指令
BLbmqBQBV的博客
03-06 786
此外，我们还可以通过阅读RISC-V中文手册和指令集文档的中文版本来深入了解这款处理器的相关知识。此外，这款处理器的仿真过程也相对便捷，这使得我们可以快速验证设计的正确性。riscv 32单周期处理器cpu，工程基于vivado，指令集rv32i,systemverilog编写，结构简单，指令存在ram中，可仿真，代码结构清晰，适合初学者学习，并赠送包括riscv中文手册和riscv指令集文档的中文版本。今天，就让我们从RISC-V 32位单周期处理器这个工程案例开始，探索其中的技术奥秘和编程魅力。
制作单周期CPU(分析)
热门推荐
WSQPoison的博客
04-21 1万+
用的是Vivado软件，代码部分将在下一期展现出来(内容太多我也很绝望)，这一期来讲讲思路要求 原理1.单周期：单周期CPU指一条指令在一个时钟周期内完成并开始下一条指令的执行。由时钟上升、下降沿控制相关操作。两个相邻时钟上升沿或下降沿之间的时间间隔为一个时钟周期2.CPU如何处理指令：CPU处理指令的步骤如下： a.取指令：根据PC中的指令地址，在指令存储器中获取相应指令。然后PC值会自动
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值