verilog实现的16位CPU设计

最新推荐文章于 2022-06-27 00:56:49 发布
最新推荐文章于 2022-06-27 00:56:49 发布
阅读量2.8k 收藏 42
点赞数 2
原文链接：http://www.cnblogs.com/wsine/p/4292869.html
版权

verilog实现的16位CPU设计

整体电路图

整体电路图

整体电路图

CPU状态图

CPU状态图

idle代表没有工作，exec代表在工作

实验设计思路

五级流水线，增加硬件消耗换取时间的做法。
具体每一部分写什么将由代码部分指明。

完整代码

headfile.v

头文件定义。包含整个工程中的特殊变量定义。后文中只用到gr0到gr3部分，因此该部分没写gr4到gr7，有需要的同学请自行加上。

`ifndef HEADFILE_H_

//State for CPU
`define idle        1'b0
`define exec        1'b1

//Data transfer & Arithmetic
`define  NOP        5'b00000
`define  HALT       5'b00001
`define  LOAD       5'b00010
`define  STORE      5'b00011
`define  LDIH       5'b10000
`define  ADD        5'b01000
`define ADDI        5'b01001
`define ADDC        5'b10001
`define CMP     5'b01100

//Logical / shift
`define AND     5'b01101
`define SLL     5'b00100
`define SLA     5'b00101

//Control
`define JUMP        5'b11000
`define JMPR        5'b11001
`define BZ          5'b11010
`define BNZ     5'b11011
`define BN          5'b11100
`define BC          5'b11110

//Add by myself
`define SUB     5'b01010
`define     SUBI    5'b01011
`define     SUBC    5'b10010
`define     OR      5'b01110
`define     XOR     5'b01111
`define     SRL     5'b00110
`define     SRA     5'b00111
`define     BNN     5'b11101
`define     BNC     5'b11111

//gr
`define gr0 3'b000
`define gr1 3'b001
`define gr2 3'b010
`define gr3 3'b011

`endif

CPU.v

这个是整个工程的顶层模块。输入100MHz时钟信号，四个开关选择控制七段译码管显示的内容，用button来控制CPU的一次流水线。
首先三个部分的时钟快慢要求不一样。七段译码器的时钟要求最快，要实时显示内容；memory的时钟要求较快，在PCPU下一级流水线到来之前完成数据读写。PCPU模块的时钟要求最慢，这个只是相对前面来说较慢。整个CPU的工作频率是比较快的。

`timescale 1ns / 1ps

module CPU(
    input clk,
    input enable,
    input reset,
    input [3:0] SW,
    input start,
    input button,
    output [6:0] light,
    output [3:0] en
    );

    wire PCPU_clk;
    wire MEM_clk;
    wire LIGHT_clk;
    
    wire [15:0] d_datain;
    wire [15:0] i_datain;
    wire [3:0] select_y;
    wire [7:0] d_addr;
    wire [15:0] d_dataout;
    wire d_we;
    wire [7:0] i_addr;
    wire [15:0] y;
    
    clk_div getMEMclk(
        .orgin_clk(clk),
        .reset(reset),
        .div(16'b0100_0000_0000_0000),
        .div_clk(MEM_clk)
    );
    
    clk_div getLIGHTclk(
        .orgin_clk(clk),
        .reset(reset),
        .div(16'b0010_0000_0000_0000),
        .div_clk(LIGHT_clk)
    );
    
    PCPUcontroller PCPUctrl(
        .myclk(clk),
        .button(button),
        .reset(reset),
        .sense(PCPU_clk)
    );
    
    PCPU pcpu(
        .clock(PCPU_clk),
        .enable(enable),
        .reset(reset),
        .start(start),
        .d_datain(d_datain),
        .i_datain(i_datain),
        .select_y(SW),
        .d_addr(d_addr),
        .d_dataout(d_dataout),
        .d_we(d_we),
        .i_addr(i_addr),
        .y(y)
    );
    
    I_mem i_mem(
        .mem_clk(MEM_clk),
        .addr(i_addr),
        .rdata(i_datain)
    );
    
    D_mem d_mem(
        .mem_clk(MEM_clk),
        .dwe(d_we),
        .addr(d_addr),
        .wdata(d_dataout),
        .rdata(d_datain)
    );
    
    light_show show_light(
        .light_clk(LIGHT_clk),
        .reset(reset),
        .y(y),
        .light(light),
        .en(en)
    );

endmodule

clk_div.v

时钟分频模块，要是开始做CPU设计了还不会时钟分频的话，那我没话说了。不解释，贴代码。

`timescale 1ns / 1ps

module clk_div(
    input orgin_clk,
    input reset,
    input [15:0] div,
    output reg div_clk
    );
    
    reg [15:0] count;
    
    always@(posedge orgin_clk or posedge reset)
    begin
        if(reset)
        begin
            div_clk <= 0;
            count <= 0;
        end
        else
        begin
            if(count == div)
            begin
                div_clk <= ~div_clk;
                count <= 0;
            end
            else
                count <= count + 1'b1;
        end
    end


endmodule

PCPUcontroller.v

PCPU模块的状态控制模块。因为用的button来手动控制CPU的流水线，以免时钟太快一下子就跑完了。实现的方法是用状态机，加入trap状态，实现消抖。具体想不明白的话，建议自己画一下状态机转移图，聪明的你一定会明白的。

`timescale 1ns / 1ps

module PCPUcontroller(
    input myclk,
    input button,
    input reset,
    output reg sense
    );

    parameter STOP = 2'b00, INC = 2'b01, TRAP = 2'b10;
    
    reg [1:0] state, nextstate;
    
    always@(posedge myclk or posedge reset)
    begin
        if(reset)
            state <= STOP;
        else
            state <= nextstate;
    end
    
    always@(*)
    begin
        case(state)
            STOP:
                if(button)  nextstate <= INC;
                else            nextstate <= STOP;
            INC:                nextstate <= TRAP;
            TRAP:
                if(button)  nextstate <= TRAP;
                else            nextstate <= STOP;
            default:            nextstate <= STOP;
        endcase
    end
    
    always@(*)
    begin
        if(reset)
            sense <= 0;
        else
            case(state)
                INC:        sense <= 1'b1;
                default:    sense <= 1'b0;
            endcase
    end

endmodule

PCPU.v

整个工程中最核心的部分。注释部分是冲突处理之后的。如不需要冲突处理，把注释部分指明的代码注释掉即可。对应于前图中的五级流水线，该部分的代码亦分为五部分，请自行研啃。

`timescale 1ns / 1ps
`include"headfile.v"

module PCPU(
    input clock,
    input enable,
    input reset,
    input start,
    input [15:0] d_datain,
    input [15:0] i_datain,
    input [3:0] select_y,
    output wire [7:0] d_addr,
    output wire [15:0] d_dataout,
    output wire d_we,
    output wire [7:0] i_addr,
    output reg [15:0] y
    );

    reg state;
    reg [7:0] pc;
    reg [15:0] id_ir;
    reg [15:0] ex_ir, reg_A, reg_B, smdr;
    reg [15:0] mem_ir, reg_C, smdr1; reg dw; reg flag; reg [15:0] ALUo;reg zf, nf, cf;
    reg [15:0] wb_ir, reg_C1;
    
    reg [15:0] gr[0:7];
    
    assign d_dataout = smdr1;
    assign d_we = dw;
    assign d_addr = reg_C[7:0];
    assign i_addr = pc;
    
    /*******CPUcontrol**********************/
    reg nextstate;
    
    always@(posedge clock or posedge reset)
    begin
        if(reset)
            state <= `idle;
        else
            state <= nextstate;
    end
    
    always@(*)
    begin
        case(state)
            `idle:
                if((enable == 1'b1) && (start == 1'b1))
                    nextstate <= `exec;
                else
                    nextstate <= `idle;
            `exec:
                if((enable == 1'b0) || (wb_ir[15:11] == `HALT))
                    nextstate <= `idle;
                else
                    nextstate <= `exec;
        endcase
    end
    
    /***************************************/
    
    /****************IF*********************/
    always@(posedge clock or posedge reset)
    begin
        if(reset)
        begin
            id_ir <= 16'b0000_0000_0000_0000;
            pc <= 8'b0000_0000;
        end
        else if(state == `exec)
        begin
            /*************Hazard*******************/
            if((id_ir[15:11] == `LOAD)
             &&(i_datain[15:11] == `ADD) 
             &&((id_ir[10:8] == i_datain[7:4]) 
              ||(id_ir[10:8] == i_datain[3:0])))
            begin
                id_ir <= 16'bxxxx_xxxx_xxxx_xxxx;
                pc <= pc;
            end
            /**************************************/
            else
            begin
                id_ir <= i_datain;
                if(((mem_ir[15:11] == `BZ)  && (zf == 1'b1))
                 ||((mem_ir[15:11] == `BN)  && (nf == 1'b1))
                 ||((mem_ir[15:11] == `BC)  && (cf == 1'b1))
                 ||((mem_ir[15:11] == `BNZ) && (zf == 1'b1))
                 ||((mem_ir[15:11] == `BNN) && (nf == 1'b1))
                 ||((mem_ir[15:11] == `BNZ) && (cf == 1'b1)))
                    pc <= reg_C[7:0];
                else if((mem_ir[15:11] == `JUMP)
                        ||(mem_ir[15:11] == `JMPR))
                    pc <= reg_C[7:0];
                else
                    pc <= pc + 1'b1;
            end
        end
        else
        begin
            pc <= pc;
            id_ir <= id_ir;
        end
    end
    
    /***************************************/
    
    /****************ID*********************/
    always@(posedge clock or posedge reset)
    begin
        if(reset)
        begin
            ex_ir <= 16'b0000_0000_0000_0000;
            reg_A <= 16'b0000_0000_0000_0000;
            reg_B <= 16'b0000_0000_0000_0000;
            smdr <= 16'b0000_0000_0000_0000;
        end
        else if(state == `exec)
        begin
            ex_ir <= id_ir;
            if(id_ir[15:11] == `STORE)  //for Hazard Mode
                smdr <= ALUo;
            //reg_A
            /********************Hazard**********************/
            if(wb_ir[15:11] == `LOAD && id_ir[7:4] == wb_ir[10:8])
                reg_A <= reg_C1;
            else if(mem_ir[15:11] == `LOAD && id_ir[7:4] == mem_ir[10:8])
                reg_A <= d_datain;
            else if(ex_ir[15:11] != `LOAD && id_ir[7:4] == ex_ir[10:8])
                reg_A <= ALUo;
            else if(mem_ir[15:11] != `LOAD && id_ir[7:4] == mem_ir[10:8])
                reg_A <= reg_C; 
            else if(wb_ir[15:11] != `LOAD && id_ir[7:4] == wb_ir[10:8])
                reg_A <= reg_C1;
            else
            begin
            /***********************************************/
                if((id_ir[15:11] == `BZ)
                 ||(id_ir[15:11] == `BN)
                 ||(id_ir[15:11] == `JMPR)
                 ||(id_ir[15:11] == `BC)
                 ||(id_ir[15:11] == `BNZ)
                 ||(id_ir[15:11] == `BNN)
                 ||(id_ir[15:11] == `BNC)
                 ||(id_ir[15:11] == `ADDI)
                 ||(id_ir[15:11] == `SUBI)
                 ||(id_ir[15:11] == `LDIH))
                    reg_A <= gr[(id_ir[10:8])];
                else
                    reg_A <= gr[(id_ir[6:4])];
            end
            //reg_B
            /********************Hazard*********************/
            if(wb_ir[15:11] == `LOAD && id_ir[3:0] == wb_ir[10:8])
                reg_B <= reg_C1;
            else if(mem_ir[15:11] == `LOAD && id_ir[3:0] == mem_ir[10:8])
                reg_B <= d_datain;
            else if(ex_ir[15:11] != `LOAD && id_ir[3:0] == ex_ir[10:8])
                reg_B <= ALUo;
            else if(mem_ir[15:11] != `LOAD && id_ir[3:0] == mem_ir[10:8])
                reg_B <= reg_C;
            else if(wb_ir[15:11] != `LOAD && id_ir[3:0] == wb_ir[10:8])
                reg_B <= reg_C1;    
            else
            begin
            /***********************************************/
                if((id_ir[15:11] == `LOAD)
                 ||(id_ir[15:11] == `SLL)
                 ||(id_ir[15:11] == `SLA)
                 ||(id_ir[15:11] == `SRL)
                 ||(id_ir[15:11] == `SRA))
                    reg_B <= {12'b0000_0000_0000, id_ir[3:0]};
                else if((id_ir[15:11] == `BZ)
                        ||(id_ir[15:11] == `BN)
                        ||(id_ir[15:11] == `JUMP)
                        ||(id_ir[15:11] == `JMPR)
                        ||(id_ir[15:11] == `BC)
                        ||(id_ir[15:11] == `BNZ)
                        ||(id_ir[15:11] == `BNN)
                        ||(id_ir[15:11] == `BNC)
                        ||(id_ir[15:11] == `ADDI))
                    reg_B <= {8'b0000_0000, id_ir[7:0]};
                else if((id_ir[15:11] == `STORE))
                begin
                    reg_B <= {12'b0000_0000_0000, id_ir[3:0]};
                    //smdr <= gr[(id_ir[10:8])];    //for not Hazard
                end
                else if(id_ir[15:11] == `LDIH)
                    reg_B <= {id_ir[7:0], 8'b0000_0000};
                else
                    reg_B <= gr[id_ir[2:0]];
            end
        end
        else
        begin
            ex_ir <= ex_ir;
            reg_A <= reg_A;
            reg_B <= reg_B;
            smdr <= smdr;
        end
    end
    /***************************************/
    
    /****************EX*********************/
    always@(posedge clock or posedge reset)
    begin
        if(reset)
        begin
            mem_ir <= 16'b0000_0000_0000_0000;
            reg_C <= 16'b0000_0000_0000_0000;
            smdr1 <= 16'b0000_0000_0000_0000;
            zf <= 1'b0;
            nf <= 1'b0;
            cf <= 1'b0;
            dw <= 1'b0;
        end
        else if(state == `exec)
        begin
            mem_ir <= ex_ir;
            reg_C <= ALUo;
            cf <= cf_temp;
            if((ex_ir[15:11] == `ADD)
             ||(ex_ir[15:11] == `CMP)
             ||(ex_ir[15:11] == `ADDI)
             ||(ex_ir[15:11] == `SUB)
             ||(ex_ir[15:11] == `SUBI)
             ||(ex_ir[15:11] == `LDIH)
             ||(ex_ir[15:11] == `SLL)
             ||(ex_ir[15:11] == `SRL)
             ||(ex_ir[15:11] == `SLA)
             ||(ex_ir[15:11] == `SRA)
             ||(ex_ir[15:11] == `ADDC)
             ||(ex_ir[15:11] == `SUBC))
            begin
                if(ALUo == 16'b0000_0000_0000_0000)
                    zf <= 1'b1;
                else
                    zf <= 1'b0;
                
                if(ALUo[15] == 1'b1)
                    nf <= 1'b1;
                else
                    nf <= 1'b0;
            end
            else if(ex_ir[15:11] == `STORE)
            begin
                dw <= 1'b1;
                smdr1 <= smdr;
            end
        end
        else
        begin
            reg_C <= reg_C;
            smdr1 <= smdr1;
            dw <= dw;
        end
    end
    //ALU
    reg cf_temp;
    always@(*)
    begin
        if(state == `exec)
        begin
            if(reset)
            begin
                ALUo <= 16'b0000_0000_0000_0000;
                cf_temp <= 0;
            end
            else
                case(ex_ir[15:11])
                    `NOP:       {cf_temp, ALUo} <= {cf_temp, ALUo};
                    `HALT:  {cf_temp, ALUo} <= {cf_temp, ALUo};
                    `AND:       {cf_temp, ALUo} <= {cf_temp, reg_A & reg_B};
                    `OR:        {cf_temp, ALUo} <= {cf_temp, reg_A | reg_B};
                    `XOR:       {cf_temp, ALUo} <= {cf_temp, reg_A ^ reg_B};
                    `SLL:       {cf_temp, ALUo} <= {cf_temp, reg_A << reg_B};
                    `SRL:       {cf_temp, ALUo} <= {cf_temp, reg_A >> reg_B};
                    `SLA:       {cf_temp, ALUo} <= {cf_temp, reg_A <<< reg_B};
                    `SRA:       {cf_temp, ALUo} <= {cf_temp, reg_A >>> reg_B};
                    `JUMP:  {cf_temp, ALUo} <= {cf_temp, reg_B};
                    `LDIH:  {cf_temp, ALUo} <= {1'b0 + reg_A} + {1'b0 + reg_B};
                    `ADD:       {cf_temp, ALUo} <= {1'b0 + reg_A} + {1'b0 + reg_B};
                    `ADDI:  {cf_temp, ALUo} <= {1'b0 + reg_A} + {1'b0 + reg_B};
                    `ADDC:  {cf_temp, ALUo} <= {1'b0 + reg_A} + {1'b0 + reg_B} + cf;
                    `SUB:       {cf_temp, ALUo} <= {1'b0 + reg_A} - {1'b0 + reg_B};
                    `SUBI:  {cf_temp, ALUo} <= {1'b0 + reg_A} - {1'b0 + reg_B};
                    `SUBC:  {cf_temp, ALUo} <= {1'b0 + reg_A} - {1'b0 + reg_B} - cf;
                    `CMP:       {cf_temp, ALUo} <= {1'b0 + reg_A} - {1'b0 + reg_B};
                    `LOAD:  begin ALUo <= reg_A + reg_B; cf_temp <= cf_temp; end
                    `STORE: begin ALUo <= reg_A + reg_B; cf_temp <= cf_temp; end
                    `JMPR:  begin ALUo <= reg_A + reg_B; cf_temp <= cf_temp; end
                    `BZ:        begin ALUo <= reg_A + reg_B; cf_temp <= cf_temp; end
                    `BNZ:       begin ALUo <= reg_A + reg_B; cf_temp <= cf_temp; end
                    `BN:        begin ALUo <= reg_A + reg_B; cf_temp <= cf_temp; end
                    `BNN:       begin ALUo <= reg_A + reg_B; cf_temp <= cf_temp; end
                    `BC:        begin ALUo <= reg_A + reg_B; cf_temp <= cf_temp; end
                    `BNC:       begin ALUo <= reg_A + reg_B; cf_temp <= cf_temp; end
                    default:    {cf_temp, ALUo} <= {cf_temp, ALUo};
                endcase
        end
    end
    /***************************************/
    
    /***************MEM*********************/
    always@(posedge clock or posedge reset)
    begin
        if(reset)
        begin
            reg_C1 <= 16'b0000_0000_0000_0000;
            wb_ir <= 16'b0000_0000_0000_0000;
        end
        else if(state == `exec)
        begin
            wb_ir <= mem_ir;
            if(mem_ir[15:11] == `LOAD)
                reg_C1 <= d_datain;
            else
                reg_C1 <= reg_C;
        end
    end
    /***************************************/
    
    /****************WB********************/
    always@(posedge clock or posedge reset)
    begin
        if(reset)
        begin
            gr[0] <= 16'b0000_0000_0000_0000;
            gr[1] <= 16'b0000_0000_0000_0000;
            gr[2] <= 16'b0000_0000_0000_0000;
            gr[3] <= 16'b0000_0000_0000_0000;
            gr[4] <= 16'b0000_0000_0000_0000;
            gr[5] <= 16'b0000_0000_0000_0000;
            gr[6] <= 16'b0000_0000_0000_0000;
            gr[7] <= 16'b0000_0000_0000_0000;
        end
        else if(state == `exec)
        begin
            if((wb_ir[15:11] == `LOAD)
             ||(wb_ir[15:11] == `ADD)
             ||(wb_ir[15:11] == `ADDI)
             ||(wb_ir[15:11] == `ADDC)
             ||(wb_ir[15:11] == `SUB)
             ||(wb_ir[15:11] == `SUBI)
             ||(wb_ir[15:11] == `SUBC)
             ||(wb_ir[15:11] == `AND)
             ||(wb_ir[15:11] == `OR)
             ||(wb_ir[15:11] == `XOR)
             ||(wb_ir[15:11] == `SLL)
             ||(wb_ir[15:11] == `SRL)
             ||(wb_ir[15:11] == `SLA)
             ||(wb_ir[15:11] == `SRA)
             ||(wb_ir[15:11] == `LDIH))
                gr[wb_ir[10:8]] <= reg_C1;
        end
        else
        begin
        
        end
    end
    /***************************************/
    
    /**************select Y*****************/
    always@(*)
    begin
        case(select_y)
            4'b0000:    y <= reg_C;
            4'b0001:    y <= reg_A;
            4'b0010:    y <= reg_B;
            4'b0011:    y <= {pc, 8'b0000_0000};
            4'b0100:    y <= id_ir;
            4'b0101:    y <= smdr;
            4'b0110:    y <= reg_C1;
            4'b0111:    y <= smdr1;
            4'b1000:    y <= ex_ir;
            4'b1001:    y <= mem_ir;
            4'b1010:    y <= wb_ir;
            default: y <= reg_C;
        endcase
    end
    /***************************************/
endmodule

I_mem.v

指令存储区域。把指令写在这一部分，即可让CPU跑指定的指令。

`timescale 1ns / 1ps
`include"headfile.v"

module I_mem(
    input mem_clk,
    input [7:0] addr,
    output wire [15:0] rdata
    );

    reg [15:0] i_mem [255:0];
    assign rdata = i_mem[addr];
    
    always@(posedge mem_clk)
    begin
        case(addr)
            0:      i_mem[addr] <= {`ADDI, `gr1, 4'b1010, 4'b1011};
            1:      i_mem[addr] <= {`LDIH, `gr2, 4'b0011, 4'b1100};
            2:      i_mem[addr] <= {`ADD, `gr3, 1'b0, `gr1, 1'b0, `gr2};
            3:      i_mem[addr] <= {`STORE, `gr3, 1'b0, `gr0, 4'b0000};
            4:      i_mem[addr] <= {`ADDI, `gr1, 4'b0001, 4'b0001};
            5:      i_mem[addr] <= {`LDIH, `gr2, 4'b0001, 4'b0001};
            6:      i_mem[addr] <= {`ADD, `gr3, 1'b0, `gr1, 1'b0, `gr2};
            7:      i_mem[addr] <= {`STORE, `gr3, 1'b0, `gr0, 4'b0001};
            8:      i_mem[addr] <= {`LOAD, `gr1, 1'b0, `gr0, 4'b0000};
            9:      i_mem[addr] <= {`LOAD, `gr2, 1'b0, `gr0, 4'b0001};
            10: i_mem[addr] <= {`ADD, `gr3, 1'b0, `gr1, 1'b0, `gr2};
            11: i_mem[addr] <= {`STORE, `gr3, 1'b0, `gr0, 4'b0001};
            12: i_mem[addr] <= {`JUMP, 4'b0000, 4'b0010, 4'b1000};
            13: i_mem[addr] <= {`ADDI, `gr1, 4'b1010, 4'b1011};
            40: i_mem[addr] <= {`HALT, 11'b000_0000_0000};
            default:        i_mem[addr] <= {`NOP, 11'b000_0000_0000};
        endcase
    end

endmodule

D_mem.v

数据存储区域。结构简单，根据dwe信号来决定是读取还是写入。

`timescale 1ns / 1ps
`include"headfile.v"

module D_mem(
    input mem_clk,
    input dwe,
    input [7:0] addr,
    input [15:0] wdata,
    output wire [15:0] rdata
    );
    
    reg [15:0] d_mem [255:0];
    assign rdata = d_mem[addr];
    
    always@(posedge mem_clk)
    begin
            if(dwe)
                d_mem[addr] <= wdata;
    end


endmodule

light_show.v

七段译码管显示模块。

`timescale 1ns / 1ps

module light_show(
    input light_clk,
    input reset,
    input [15:0] y,
    output reg [6:0] light,
    output reg [3:0] en
    );

    reg [1:0] dp;
    reg [3:0] four;

    always@(posedge light_clk or posedge reset)
    begin
        if(reset)
            dp <= 0;
        else
        begin
            dp <= dp + 1'b1;
        end
    end
    
    always@(*)
    begin
        if(reset)
        begin
            four <= 0;
            en <= 0;
        end
        else
        begin
            case(dp)
                0:          begin four <= y[3:0]; en <= 4'b1110; end
                1:          begin four <= y[7:4]; en <= 4'b1101; end
                2:          begin four <= y[11:8]; en <= 4'b1011; end
                3:          begin four <= y[15:12]; en <= 4'b0111; end
                default:    begin four <= 0; en <= 0; end
            endcase
        end
    end
    
    always@(*)
    begin
        if(reset)
        begin
            light <= 7'b0001000;
        end
        else
        begin
            case(four)
                0:              light <= 7'b0000001;
                1:              light <= 7'b1001111;
                2:              light <= 7'b0010010;
                3:              light <= 7'b0000110;
                4:              light <= 7'b1001100;
                5:              light <= 7'b0100100;
                6:              light <= 7'b0100000;
                7:              light <= 7'b0001111;
                8:              light <= 7'b0000000;
                9:              light <= 7'b0000100;
                4'b1010:        light <= 7'b0001000;
                4'b1011:        light <= 7'b1100000;
                4'b1100:        light <= 7'b0110001;
                4'b1101:        light <= 7'b1000010;
                4'b1110:        light <= 7'b0110000;
                4'b1111:        light <= 7'b0111000;
                default:        light <= 7'b0000001;
            endcase
        end
    end

endmodule

VTF_CPU.v

仿真测试文件。

`timescale 1ns / 1ps

module VTF_CPU;

    // Inputs
    reg clk;
    reg enable;
    reg reset;
    reg [3:0] SW;
    reg start;
    reg button;

    // Outputs
    wire [6:0] light;
    wire [3:0] en;

    // Instantiate the Unit Under Test (UUT)
    CPU uut (
        .clk(clk), 
        .enable(enable), 
        .reset(reset), 
        .SW(SW), 
        .start(start), 
        .button(button), 
        .light(light), 
        .en(en)
    );

    initial begin
        // Initialize Inputs
        clk = 0;
        enable = 0;
        reset = 0;
        SW = 0;
        start = 0;
        button = 0;

        // Wait 100 ns for global reset to finish
        #100;
        
        $display("pc:     id_ir      :reg_A:reg_B:reg_C:da:dd:  :w:reC1:gr1 :gr2 : gr3");
        $monitor("%h:%b:%h:%h:%h:%h:%h:%b:%h:%h:%h:%h", 
            uut.pcpu.pc, uut.pcpu.id_ir, uut.pcpu.reg_A, uut.pcpu.reg_B, uut.pcpu.reg_C,
            uut.d_addr, uut.d_dataout, uut.d_we, uut.pcpu.reg_C1, uut.pcpu.gr[1], uut.pcpu.gr[2], uut.pcpu.gr[3]);
            
      enable <= 0; start <= 0;
        // Add stimulus here
        #10 reset <= 1;
        #10 reset <= 0;
        #10 enable <= 1;
        #10 start <=1;
        //#10 start <= 0;
        #100;
    end
   always #20 button = ~button;
    always #5 clk = ~clk;
endmodule

转载于:https://www.cnblogs.com/wsine/p/4292869.html

weixin_30915951
关注
  • 2
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
verilog实现的16位CPU单周期设计
weixin_30905981的博客
07-18 3019
verilog实现的16位CPU单周期设计 这个工程完成了16位CPU的单周期设计，模块化设计，包含对于关键指令的仿真与设计，有包含必要的分析说明。 单周期CPU结构图 单周期CPU设计真值表与结构图 该CPU用到的指令集,16位8个通用寄存器 设计思路 Instruction Memory： 输入8位的PC指令，输出对应内存的16位指令 Control Unit 输入16位的指令，根据...
几种常见加法器的verilog实现
热门推荐
weixin_38407219的博客
10-30 3万+
**几种常见加法器的verilog实现** 本人刚开始研一的学习，想着开个博客把研究生学习的内容记录一下，也养成一个好的习惯。研究生的方向是数字IC，把最近做的几个加法器作业记录一下。 一：16位进位跳跃加法器。 利用门级实现的加法器电路，通过进位传递函数Pi进行进位选择，可以提前进位的计算，使得后一级计...
16bitALU-verilog
01-04
一个16位ALU设计，该ALU主要能实现算术运算(加、减、带进位加、带进位减、加1、减1、传输)、逻辑运算(与、或、非、异或、同或、逻辑左移、逻辑右移操作)。
使用Verilog设计冯诺依曼结构CPU【代码】
weixin_45161294的博客
03-14 778
一 冯诺依曼结构CPU图示二 代码实现的指令三 实验报告包含的内容设计思路描述1、CPU基本组成2、CPU的工作过程3、关键模块定义程序代码变量说明程序代码结构说明模拟图及分析 一 冯诺依曼结构CPU图示 二 代码实现的指令 计算机数据总线和地址总线都是16位，指令系统包括4条指令：addi, lw, sw, add， addi: (rd) <- (rs) + imm 从寄存器rs中读取数据，和立即数imm相加后，结果放到寄存器rd中。 lw: (rd) <- memory((rs) + .
verilog实现16位五级流水线的CPU带Hazard冲突处理
weixin_30432007的博客
07-20 816
verilog实现16位五级流水线的CPU带Hazard冲突处理 该文是基于博主之前一篇博客http://www.cnblogs.com/wsine/p/4292869.html所增加的Hazard处理，相同的内容就不重复写了，可点击链接查看之前的博客。 CPU设计 该处理器的五级流水线设计： 类似于MIPS体系架构依据流水线结构设计。只要CPU从缓存中获取数据，那么执行每条MIPS指令就被分成五...
Verilog学习日志（16位运算器，可满足加减算术运算和与或非异或逻辑运算）
qq_48000445的博客
07-22 5199
这次用Verilog进行一个16位简单运算器进行建模并仿真 题目如下： 需要的功能有加、减、按位与、按位或、对输入一按位非、按位异或。16位加法器需自己完成，不要使用“+“。 根据题目，画出如图架构 然后根据架构，来进行各个功能的设计，逻辑运算非常简单，关键在于加减法的实现，因为减去一个正数可以表示为加上一个负数的补码，所以结果都采用补码表示，运算过程通过补码进行运算。 我这里加法器的设计为行波进位加法器（更细致的讲解可以参照https://blog.csdn.net/zhouxuanyuye/artic
实验二 CPU 部件实现之 ALU 和寄存器堆
m0_62001047的博客
06-27 3951
CPU 部件实现之 ALU 和寄存器堆
VHDL：设计16×16bit的寄存器组（代码思路清晰易懂）
jshsjjn的博客
06-17 1509
设计16×16bit的寄存器组，要求：(1)寄存器组中有16个16位的寄存器。(2)存在复位端，当复位信号有效(如reset=‘0’)时，寄存器组中的16个寄存器清零。(3)通用寄存器组中有一组数据输入端(如input)、两个地址输入端(如selA，selB)、一个读/写控制端(如WrA)、两组数据输出端(如outputA，outputB)。 我写的这个寄存器组的vhdl代码是可以编译通过的，希望可以帮到大家！求求大家多多支持啦！......
VHDL:设计一个四位并行加法器和16位ALU（代码思路清晰易懂）
jshsjjn的博客
06-26 5320
1.四位并行加法器的设计及仿真2.16位ALU的设计及仿真1.熟悉quartus的使用方法；2.掌握全加器的特点及设计方法；3.掌握串行进位链的并行加法器的设计方法；4.熟悉VHDL模块化设计方法；5.熟悉ALU的设计方法。 1. 基于QuartusⅡ，设计实现一位全加器。 2. 利用VHDL模块化设计方法，以设计完成的一位全加器为基础，设计实现4位并行加法器，QuartusⅡ下编译并仿真。。3. 设计实现能完成8种算术运算和8逻辑运算的16位ALU，要求： (1)具有4位的功能选择
【此后无良辰】实验二 CPU部件实现之ALU和寄存器堆
qq_40493829的博客
08-03 5426
一、 实验目的 理解和掌握CPU中的算术逻辑运算部件（ALU）和寄存器堆（Register File）的工作原理，并使用Verilog和ModelSim进行设计和仿真。 二、 实验内容 使用Verilog完成ALU的设计,并编写测试仿真文件验证其正确性。要求： ALU支持16位的加、减、与、或以及移位运算。 使用Verilog完成通用寄存器堆的设计，并编写测试仿真文件验证其正确性。要求 寄存器堆包含8个16位的寄存器； 寄存器堆有两个读端口和一个写端口。 三、 实验原理 ALU和寄存器堆的原
16位单周期cpu的verilog实现
06-12
16位单周期处理器的verilog实现。包括存储模块和仿真模块，结构很清晰，大学计算机组成原理课程必备。
简单的16位cpu设计
11-22
简单的十六位cpu课程设计，vhdl方向，非常适合学习eda课程的同学使用
使用verilog HDL 16位cpu设计
11-30
本实例是使用verilog HDL语言来进行16位cpu设计。
verilog实现16位cpu
02-25
用verilog实现16位cpu，8位存储器，能进行加减乘除和逻辑运算，支持栈，支持函数调用，跳转功能等
VHDL编写的16位CPU
09-01
VHDL编写的16位CPU,本人也在学习中欢迎交流
基于verilog设计实现8位cpu【100012497】
05-31
程序和数据统一存储，指令和数据需要从同一存储空间存取，经由同一总线传输，无法重叠执行。根据冯诺依曼体系，CPU的工作分为以下 5 个阶段：取指令阶段、指令译码阶段、执行指令阶段、访存取数和结果写回。
基于MIPS指令集的32位CPU设计与Verilog语言实现_多周期CPU
11-22
用Verilog语言设计的多周期CPU，资源里包含了源代码及多周期CPU结构图，与大家分享下。 用Verilog语言设计的多周期CPU，资源里包含了源代码及多周期CPU结构图，与大家分享下。
基于Verilog实现mips五级流水线CPU设计【100013168】
08-11
本次课程设计主要实现的是 Openmips 处理器，是一款具有哈佛结构的 32 标量处理器，兼容 MIPS32 Relerase1 指令集的结构，这样的好处是可以使用现有的 mips 编译环境实现，如 GCC 编译器等，具体的设计目标如下： ...
多周期CPU的设计与Verilog实现
06-29
多周期CPU的实现，在15版的vivado上可以打开，如果需要看到仿真的波形图，可以跑仿真，调节相关参数即可显示出来
8位cpu verilog
最新发布
12-22
8位CPU是一种基于Verilog语言设计的中央处理单元，用于实现基本的计算和控制功能。它由8位的数据总线和8位的地址总线组成，可以处理8位的数据和寻址256个内存单元。 在Verilog中设计8位CPU需要考虑到指令集的设计、寄存器的定义和控制逻辑的实现。指令集包括基本的算术运算指令、逻辑运算指令、数据传输指令以及跳转指令等，需要在Verilog中实现对应的操作码和操作逻辑。 寄存器包括程序计数器、指令寄存器、累加器、状态寄存器等，需要在Verilog中定义并实现其读写操作和逻辑控制。 控制逻辑包括时钟信号的处理、指令执行的控制、数据通路的实现等，需要在Verilog中编写组合逻辑和时序逻辑，并实现对应的状态机和控制器。 设计8位CPU还需要考虑时序和功能的正确性，通过Verilog模拟和仿真来验证设计的正确性，确保CPU可以正确地执行各种指令并产生正确的结果。同时还需要考虑性能和资源占用情况，通过Verilog综合和布局布线来优化设计，以满足CPU的运行要求和硬件资源的限制。 综上所述，在Verilog中设计8位CPU需要考虑指令集的设计、寄存器的定义和控制逻辑的实现，并通过模拟和综合来验证和优化设计，从而实现一个功能正确、性能优异的8位CPU。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值