计算机原理与结构实验报告 第1篇
1.对各实验原理不太了解。结合教材上提示的电路原理图以及网上的相关资料，最后在理解试验背后理论知识原理的基础上，完成了电路的设计工作。
2. Logisim仿真软件存在BUG。试验过程中会出现明明电路正确，出现整块报错的问题。重启软件后才恢复正常。
3.对某些元器件的功能使用不太了解。最初，我将计数器误认为是寄存器，导致原码一位乘法器始终无法正常使用，百思不得其解，在和同学讨论后，才发现元器件的错误使用，改正后电路才能够正常使用。
计算机原理与结构实验报告 第2篇
观察微指令存储器地址为31H单元的内容，分析其控制功能，并编制一条微指令实现“A非”运算后右移一位的值送OUT，把这条微指令放入微程序存储器的32H单元，将31H和32H连续执行以验证其功能是否实现。
(1) 实验步骤
(2) 实验现象
OUT屏幕显示6E
（3）实验结论
通过一系列正确的操作，我们成功地实现“A非”运算后右移一位的值送OUT输出的功能实现。
计算机原理与结构实验报告 第3篇
（1）定义输入输出，时钟信号，置0信号和刷新信号。定义16位拨码输入，16位LED输出，绑定地址线和数据线。定义状态切换信号showctrl，和左右两个数码管显示当前状态。
（2）定义signal，其中定义8个16位寄存器，寄存器地址000~111。定义不同部分的控制信号。定义PC，IR。定义状态机，控制操作状态，输出状态，和转移状态。
（3）在主程序中，先定义输出状态，前4个状态同实验三输出不同部分的控制信号。5~7状态输出x，y，z寄存器的值，令高三位显示寄存器地址，便于确认。8，9状态分别输出PC和IR寄存器中的值。
（4）控制操作状态机中，在指令读取状态（1）读取指令值存入IR中，在写x寄存器地址状态（2）写入x寄存器地址，在写x寄存器数据（3）中写x寄存器数据。在写y寄存器地址状态（4）写y寄存器地址，在写y寄存器数据状态（5）写y寄存器数据。这4个写寄存器地址数据的状态可控制寄存器数据的手动存入。在译码状态（6）中译码，指令的高5位位操作码，根据不同的操作码进行不同的操作。在执行状态（7）中执行不同操作。在是否进入访存状态（8）和写回状态（9）由执行状态确定。
（5）其中在进行转移指令时，需要定义一个转移状态机来实现数据更新。
（6）简易CPU实现了访存指令（LW和SW），传送指令（BEQZ和JR），算数运算指令（ADD和SUB），逻辑运算指令（XOR），移位指令（SLLV），共8条。使用了8个16位寄存器R0~R7，地址位000~111.
计算机原理与结构实验报告 第4篇
entity SRAM is
Port ( CLK : in STD_LOGIC; --时钟
RST : in STD_LOGIC; --置0
ctrl_r : in STD_LOGIC;
input : in STD_LOGIC_VECTOR (15 downto 0); --输入
--light
LIGHT: out STD_LOGIC_VECTOR (15 downto 0); --LED灯
SEG:out std_logic_vector(6 DOWNTO 0):=not _1111001_; --数码管
SEG_LGHET:out std_logic_vector(6 DOWNTO 0):=not _1111001_; --数码管
DBC : inout STD_LOGIC; --interconn3
--RAM
ADDR : out STD_LOGIC_VECTOR (15 downto 0); --地址线
DATA : inout STD_LOGIC_VECTOR (15 downto 0); --数据线
OE : out STD_LOGIC; --输出使能端
WE : out STD_LOGIC; --允许写入
EN : out STD_LOGIC); --片选信号
end SRAM;
architecture Behavioral of SRAM is
--signal State : STD_LOGIC_VECTOR(1 downto 0);
signal tmp_write_addr:std_logic_vector(15 downto 0); --写入地址
signal tmp_write_data:std_logic_vector(15 downto 0):=x_0000_; --写入数据
signal tmp_read_addr:std_logic_vector(15 downto 0); --读地址
signal tmp_read_data:std_logic_vector(15 downto 0):=x_0000_; --读数据
signal tmp_light:std_logic_vector(15 downto 0):=x_0000_; --LED灯
type prj_state is (N,W,R); --运行状态
signal ctrl_state:prj_state;
type adram_state is (waiting); --地址输入状态
signal address_state:adram_state;
type sram_state is (waiting,start,over); --写入状态
signal write_state:sram_state;
type rram_state is (waiting,start,read,over);--读取状态
signal read_state:rram_state;
begin
process(tmp_light,tmp_read_addr)
begin
light(7 downto 0) <= tmp_light(7 DOWNTO 0);
light(15 downto 8) <= tmp_read_addr(7 DOWNTO 0); --地址低8位和数据低8位
end process;
process(RST,ctrl_r)
begin
if RST='0' then
ctrl_state<=N;
SEG_LGHET <= not_1000000_;
elsif rising_edge(ctrl_r) then
case ctrl_state is
when N=>
SEG_LGHET <= _0000110_; --1，数码管显示数字
ctrl_state<=W;
when W=>
SEG_LGHET <= _1011011_;--2
ctrl_state<=R;
when R=>
SEG_LGHET <= not_1000000_;
ctrl_state<=N;
end case;
end if;
end process;
process(RST,CLK,ctrl_state)
begin
if RST='0' then --置0
SEG <= _1000000_;
tmp_write_data<=x_0000_;
tmp_read_addr<=x_0000_;
tmp_write_addr<=x_0000_;
tmp_light<=x_0000_;
OE<='0';
WE<='0';
address_state<=waiting;
write_state<=waiting;
read_state<=waiting;
elsif rising_edge(CLK) then
case ctrl_state is --运行状态
when N=>
ADDR <= input; --写入地址单元的地址
SEG <= not_1000000_; --0
tmp_write_addr <= input;
tmp_read_addr <= input;
when W=>
case write_state is
when waiting =>
address_state <= waiting;
write_state <= start;
read_state <= waiting;
SEG <= _0000110_; --1
when start =>
tmp_write_data<=input;
ADDR <= tmp_write_addr;
DATA <= input;
EN <= '0';
OE <= '1';
WE <= '0';
SEG <= _1011011_; --2
write_state <= over;
when over =>
write_state <= waiting;
tmp_write_addr <= tmp_write_addr + 1;
SEG <= _1001111_; --3
end case;
when R=>
case read_state is
when waiting =>
address_state <= waiting;
read_state <= start;
write_state <= waiting;
SEG <= _1100110_; --4
when start=>
ADDR <= tmp_read_addr;
DATA<=(others=>'Z');
read_state<=read;
SEG <= _1101101_; --5
EN <= '0';
OE <= '1';
WE <= '1';
when read =>
EN <= '0';
OE<='0';
We<='1';
tmp_light <= DATA;
SEG <=_1111101_; --6
read_state<=over;
when over=>
SEG <= _0000111_; --7
read_state<=waiting;
tmp_read_addr<=tmp_read_addr + 1;
end case;
end case;
end if;
DBC <= '1';
end process;
end Behavioral;
计算机原理与结构实验报告 第5篇
根据实验指导书的相关内容，对于部分使用频率很高，且只用几条微指令即可完成的简单操作，可以把这部分简单操作的微指令序列固定下来，存放在一个快速存储器中。之后我们就可以用不同的指令来调用不同的微程序，以达到完成不同指令的功能。
本实验所用的实验箱的指令系统中，每条指令均由4条微指令组成。当实际需要的微指令数量不足4条时，可用无效微指令FFFFFFH补足，但最后一条有效微指令一定是CBFFFFH微指令，表示本条指令执行完毕，取下一条指令。
指令系统的工作原理：
指令获取：从存储器中获取下一条指令，通过地址总线传递给存储器。
指令解码：将获取的指令二进制通过指令总线传递给微程序计数器，高6位作为微程序入口地址，低2位分别作为SA和SB。
微程序执行：根据微程序入口地址访问微程序存储器，将控制信号输出到控制总线，执行当前微指令功能。uPC加1，输出下一条微指令，重复执行，直到“取下一条指令”微指令。
取下一条指令：PC加1，开始执行下一条指令。
计算机原理与结构实验报告 第6篇
（1）熟悉硬件描述语言及开发环境，了解硬件系统开发的基本过程
（2）掌握ALU基本设计方法和简单运算器的数据传输通路
（3）验证ALU的功能
2．要求
（1）运用所学的知识和方法采用最佳方案完成实验设计。
（2）编写简洁代码完成实验要求内容。
（3）认真书写实验报告，包括实验目的、实验内容、实验设计方案、实验仿真结果等。
计算机原理与结构实验报告 第7篇
实现一个基于MIPS指令集的CPU，数据总线16位，地址总线16位，具有8个16位的通用寄存器。指令包括访存指令（如LW，SW），传送指令（如LI，MOVE），算术运算指令（如ADDU，SUBU），逻辑运算指令（NOT，OR），移位运算指令（如SLL），具体指令见实验指导书P23-P32。
2．实验要求
计算机原理与结构实验报告 第8篇
观察机器指令码为66H的各微指令信号，验证该指令的功能。假设A=03H，R2=77H，77地址单元存放06H数据。
修改机器指令码为E8H的功能，使其完成“输出A+W的结果右移一位的值送OUT输出”操作。
**注意:**两个任务连起来做。
(1) 实验步骤
注释仪器，打开电源，手不要远离电源开关，随时准备关闭电源，注意各数码管、发光管的稳定性，静待10秒，确信仪器稳定、无焦糊味。
按Reset键初始化系统，并设置实验箱进入EM模式。设置Adr=00，按下NX，设置DB=66；而后按下NX，设置DB=E8；最后设置Adr=77，按下NX，设置DB=06。
设置实验箱进入uEM模式。设置Adr=E8，按下NX，设置E8=FF DE B8H；而后按下NX，设置E9=CB FF FFH；最后按相同的方式将EA和EB设置为FF FF FFH。
设置实验箱进入uPC模式。设置uPC=00，PC=00，A=03；按NX三次，设置R2=77，按下STEP键，观察实验结果。
记录实验结果，关闭实验箱电源。
(2) 实验现象
第一次按下STEP键时，发现uPC显示64，PC显示01。
第二次按下STEP键时，发现uPc显示65，MAR显示77。
第三次按下STEP键时，发现uPC显示66，W显示06。
第四次按下STEP键时，发现uPC显示67，A显示07。
第五次按下STEP键时，发现uPC显示E8。
第六次按下STEP键时，发现uPC显示E9，OUT显示06。
（3）实验结论
由第二次按下STEP键发现MAR显示77，可知指令码为66H的含义是将R2寄存器中的内容读出并写入MAR寄存器。
通过一系列正确的设计，我们成功地完成了“输出A+W的结果右移一位的值送OUT输出”操作功能的实现。
计算机原理与结构实验报告 第9篇
5位无符号乘法用横向进位阵列乘法器实现。该乘法器可看成4个5位串行加法器的级联。根据运算流水线的基本原理，可以在4个5位串行加法器之间增加流水寄存器缓存中间运算结果P1-P4。实现结果如图表11所示。
图表 11
（7）原码一位乘法器设计实验
无符号原码一位乘法的计算： 维护一个部分积，初始为0，每次取乘数b的最低位，如果最低位为1，部分积=部分积+乘数a，如果最低位为0，部分积=部分积+0；然后将部分积右移一位，同时将乘数b右移一位。第i次（i<=8）对部分积的右移操作移出来的数为最终乘积的第i低位，8次结束后的部分积为最终乘积的高8位。该计算方法本质是计算乘数a与乘数b的各位相乘得到的部分积，然后将所有的部分积相加。实现结果如图表12所示。
图表 12
计算机原理与结构实验报告 第10篇
entity CPU is
Port ( rst : in STD_LOGIC; --复位信号
clk : in STD_LOGIC; --时钟信号
clk0 : in STD_LOGIC; 时钟信号
SW_IN : in STD_LOGIC_VECTOR (15 downto 0); --输入
light : out STD_LOGIC_VECTOR (15 downto 0); --LED输出
SHOW_STATE_RIGHT : out STD_LOGIC_VECTOR (6 downto 0):=_1110110_; --输出当前状态 重置、取值、译码、执行、访存、写回 启动时显示H
SHow_STATE_LEFT : out STD_LOGIC_VECTOR (6 downto 0):=_1110110_; --输出显示状态，同上
ADDR : inout STD_LOGIC_VECTOR (15 downto 0); --RAM地址
DATA : inout STD_LOGIC_VECTOR (15 downto 0); --RAM数据
RAM1_EN : out STD_LOGIC; --RAM使能
RAM1_OE : out STD_LOGIC; --RAM读使能
RAM1_WE : out STD_LOGIC; --RAM写使能
DBC : inout STD_LOGIC; --interconn3 SRAM 读锁存
showctrl : in STD_LOGIC; --切换输出
bzero_ctrl : in STD_LOGIC); -- 控 制PcWriteCond 用于判断是否满足转移条件
end CPU;
architecture Behavioral of CPU is
--寄存器
TYPE ARRAY_REG IS ARRAY(0 TO 7) OF STD_LOGIC_VECTOR(15 DOWNTO 0); --定义的寄存器
SIGNAL REGS:ARRAY_REG;
signal rex:std_logic_vector(2 downto 0) := _000_; --寄存器 x 地址，通过地址找到对应寄存器
signal rey:std_logic_vector(2 downto 0) := _000_; --寄存器 y 地址
signal rez:std_logic_vector(2 downto 0) := _000_; --寄存器 z 地址
signal memtoreg:std_logic_vector(1 downto 0); --写入寄存器堆的数据来源选择 (00-ALUout 01-主存中)
signal regwrite:std_logic_vector(2 downto 0); --写寄存器控制 (000-无 001-将数据写入指定通用寄存器 010-写 SP 011-写 T)
signal regdst:std_logic_vector(1 downto 0); --选择目的寄存器 (rx rz ry)
signal iord:std_logic; --寄存器地址来源(0-指令 1-ALUout)
signal taddr:std_logic_vector(15 downto 0);
--SP 堆栈指针
signal SP:std_logic_vector(15 downto 0) := x_0000_;
type shower_state is (pc,alu,mem,reg,regx,regy,regz,pc_show,ir_show); -- 显示状态 pc - alu - 储存 - 寄存器 -regxx -regy -regy
signal shower:shower_state;
type controler_state is (instruction_fetch,wxaddr,wxdata,wyaddr,wydata,decode,execute,mem_control,write_reg); --控制周期（取指、写x地址、写x数据、写y地址、写y数据、译码、执行、访存、写回）
signal state:controler_state;
type BEQZstate is(updateaddr,updatedata);
signal beqz_state:BEQZstate;
--PC
signal pc_mem:std_logic_vector(15 downto 0) := x_0000_; --指令地址寄存器
signal pcwrite:std_logic; --写入 PC(1-写入 PC)
signal pcwritecond:std_logic; --转移指令的条件 (改写 PC)
signal pcsource:std_logic; -- 新 的 PC 来 源 选 择 (0-ALUout 1- 存 有ALUout 的寄存器)
--ALU
signal aluop:std_logic_vector(1 downto 0); --ALU 操作码 OP(00-加 01-减 10-指令功能字段决定)
signal alusrca:std_logic; --ALU 源操作数 A 的选择(1 寄存器 A 0 PC)
signal alusrcb:std_logic_vector(1 downto 0); --ALU 源操作数 B 的选择(00 寄存器 B 01 常数 1 10-IR)
--RAM
signal memread:std_logic; --RAM 读
signal memwrite:std_logic; --RAM 写
--signal tmp_write_addr:std_logic_vector(15 downto 0); --临时读
--signal tmp_read_addr:std_logic_vector(15 downto 0); --临时写
--signal tmp_data:std_logic_vector(15 downto 0); --数据
--IR
signal instructions:std_logic_vector(15 downto 0); --指令寄存器 IR
signal IR:std_logic_vector(15 downto 0) := x_0000_;
signal irwrite:std_logic; --写入 IR
signal bzero:std_logic;
signal tmpb_zero:std_logic;
signal tmp_light:std_logic_vector(15 downto 0); --十六位输出
begin
--RAM_CTR:process(memread,memwrite)
--begin
-- RAM1_EN <= '0';
-- RAM1_OE <= NOT memread;
-- RAM1_WE <= NOT memwrite;f
--end process RAM_CTR;
--输出切换
Show_Switch_ctrl : process(clk,rst,showctrl)
begin
if rst='0' then
SHow_STATE_LEFT <= _1110110_; --H
shower<=PC;
elsif rising_edge(showctrl) then
case shower is --输出不同信号
when pc =>
shower<=alu; --输出状态
SHow_STATE_LEFT <= _0000110_; --1
when alu =>
shower<=mem;
SHow_STATE_LEFT <= _1011011_; --2
when mem =>
shower<=reg;
SHow_STATE_LEFT <= _1001111_; --3
when reg =>
shower<=regx;
SHow_STATE_LEFT <= _1100110_; --4
when regx =>
shower<=regy;
SHow_STATE_LEFT <= _1101101_; --5
when regy =>
shower<=regz;
SHow_STATE_LEFT <=_1111101_; --6
when regz =>
shower <= pc_show;
SHow_STATE_LEFT <= _0000111_; --7
when pc_show =>
shower<= IR_show;
SHow_STATE_LEFT <= _1111111_; --8
when IR_show =>
shower<=pc;
SHow_STATE_LEFT <= _1110110_; --H
end case;
end if;
end process Show_Switch_ctrl;
--输出（先放入 temp signal）
SHOW_SINGNAL:process(clk0,rst,state)
begin --输出状态
if rst='0' then
tmp_light <= _0000000000000000_;
elsif rising_edge(clk0) then
case shower is
when pc => --H
tmp_light(15 downto 0)<=x_0000_;
tmp_light(15)<=pcwrite;
tmp_light(11)<=pcsource;
tmp_light(7)<=pcwritecond;
when alu => --1
tmp_light(15 downto 0)<=x_0000_;
tmp_light(15 downto 14)<=aluop;
tmp_light(11)<=alusrca;
tmp_light(7 downto 6)<=alusrcb;
when mem => --2
tmp_light(15 downto 0)<=x_0000_;
tmp_light(15)<=memread;
tmp_light(11)<=memwrite;
tmp_light(7)<=irwrite;
tmp_light(3 downto 2)<=memtoreg;
when reg => --3
tmp_light(15 downto 0)<=x_0000_;
tmp_light(15 downto 13)<=regwrite;
tmp_light(11 downto 10)<=regdst;
tmp_light(7)<=iord;
when regx => --4
tmp_light(12 downto 0) <= REGS(conv_integer(rex))(12 downto 0);
tmp_light(15 downto 13) <= rex;
when regy => --5
tmp_light(12 downto 0) <= REGS(conv_integer(rey))(12 downto 0);
tmp_light(15 downto 13) <= rey;
when regz => --6
tmp_light(12 downto 0) <= REGS(conv_integer(rez))(12 downto 0);
tmp_light(15 downto 13) <= rez;
when PC_show => --7
tmp_light <= pc_mem;
when IR_show => --8
tmp_light <= instructions;
end case;
end if;
end process SHOW_SINGNAL;
process(rst,bzero_ctrl) --控制移位
begin
if rst='0' then
bzero<='0';
elsif rising_edge(bzero_ctrl) then
if bzero = '0' then
bzero<='1';
tmpb_zero<='0';
elsif bzero='1' then
tmpb_zero<='1';
bzero<='0';
end if;
end if;
end process;
process(bzero) --控制移位
begin
if bzero='1' then
pcwritecond<='1';
elsif bzero='0' then
pcwritecond<='0';
end if;
end process;
process(rst,clk)
begin --控制状态
if(rst='0') then
RAM1_EN <= '1'; --RAM1 的片选信号
RAM1_OE <= '0'; --读信号
RAM1_WE <= '0'; --写信号
state<=instruction_fetch;
beqz_state<=updateaddr; --BEQZ
SHOW_STATE_RIGHT <= _1110110_; --H
instructions <= X_0000_;
iord<='0';
irwrite<='0';
memread<='0';
memwrite<='0';
memtoreg<=_00_;
aluop<=_00_;
alusrca<='0';
alusrcb<=_00_;
pcwrite<='0';
pcsource<='0';
regdst<=_00_;
regwrite<=_000_;
elsif rising_edge(clk)then
case state is
when instruction_fetch => --取指令值
SHOW_STATE_RIGHT <= _0000110_; --1-取值
instructions <= SW_IN; --SW 使用拨片传入地址 --将指令写入IR
MemRead<='1'; --从存储器中读数据
Memwrite <= '0'; --不写入存储器
ALUSrcA<='0'; --来自PC
IorD<='0'; --来源于PC
beqz_state<=updateaddr; --BEQZ
ALUSrcB<=_01_;
ALUOp<=_00_;
PCWrite<='1';
PCSource<='0';
IRWrite<='1';
RegWrite<=_000_;
state<=wxaddr;
rex <= instructions(10 downto 8);
when wxaddr => --写x地址-----2
SHOW_STATE_RIGHT<=_1011011_;
-- taddr <= SW_IN;
rex<=SW_IN(2 downto 0);
state<=wxdata;
when wxdata => --写x数据------3
SHOW_STATE_RIGHT<=_1001111_;
REGS(conv_integer(rex))<=SW_IN;
state<=wyaddr;
when wyaddr => --写y地址------4
SHOW_STATE_RIGHT<=_1100110_;
-- taddr<=SW_IN;
rey<=SW_IN(2 downto 0);
state<=wydata;
when wydata => --写y数据------5
SHOW_STATE_RIGHT<=_1101101_;
REGS(conv_integer(rey))<=SW_IN;
state<=decode;
when decode => --译码
SHOW_STATE_RIGHT <= _1111101_; --6-译码
IRWrite<='0';
MemRead<='0';
PCWrite<='0';
ALUSrcA<='0';
ALUSrcB<=_10_;
ALUOp<=_00_;
case instructions(15 downto 11) is
when _11100_ => -- ADDU SUBU
rex <= instructions(10 downto 8);
rey <= instructions(7 downto 5);
rez <= instructions(4 downto 2);
when _00100_ => --BEQZ
rex <= instructions(10 downto 8);
when _11101_ =>
if (instructions(2 downto 0) = _000_) then --JR
rex <= instructions(10 downto 8);
elsif (instructions(2 downto 0) = _110_) then --XOR
rex <= instructions(10 downto 8);
rey <= instructions(7 downto 5);
elsif (instructions(2 downto 0) = _100_) then --SLLV
rex <= instructions(10 downto 8);
rey <= instructions(7 downto 5);
end if;
when _10011_ => --LW
rex <= instructions(10 downto 8);
rey <= instructions(7 downto 5);
when _11011_ => --SW
rex <= instructions(10 downto 8);
rey <= instructions(7 downto 5);
when others =>
null;
end case;
state<=execute;
when execute=> --执行
SHOW_STATE_RIGHT <= _0000111_; --7
case instructions(15 downto 11)is
when _00100_=> --执行 BEQZ 如果x寄存器值为0，则跳转到目的地址执行
ALUSrcA<='1';
ALUOp<=_10_;
PCSource<='1';
rex <= instructions(10 downto 8);
state<=write_reg;
when _10011_=> --LW
ALUSrcA<='1';
ALUSrcB<=_10_;
ALUOp<=_00_;
state<=mem_control;
RAM1_EN <= '0';
RAM1_OE <= '0';
RAM1_WE <= '1';
rex <= instructions(10 downto 8);
rey <= instructions(7 downto 5);
ADDR <= REGS(conv_integer(rex)) + instructions(4 downto 0);
when _11011_=> --SW
RAM1_EN <= '0';
RAM1_OE <= '1';
RAM1_WE <= '0';
rex <= instructions(10 downto 8);
rey <= instructions(7 downto 5);
ADDR <= REGS(conv_integer(rex)) + instructions(4 downto 0);
ALUSrcA<='1';
ALUSrcB<=_10_;
ALUOp<=_00_;
state<=mem_control;
when _11100_=>
case instructions(1 downto 0) is
when _01_ => --ADDU
ALUSrcA<='1';
ALUSrcB<=_00_;
ALUOp<=_00_;
rex <= instructions(10 downto 8);
rey <= instructions(7 downto 5);
rez <= instructions(4 downto 2);
when _11_ => --SUBU
ALUSrcA<='1';
ALUSrcB<=_00_;
ALUOp<=_01_;
rex <= instructions(10 downto 8);
rey <= instructions(7 downto 5);
rez <= instructions(4 downto 2);
when others=>
null;
end case;
state<=write_reg;
when _11101_=>
case instructions(4 downto 0)is
when _01110_=> --XOR
ALUSrcA<='1';
ALUSrcB<=_00_;
ALUOp<=_10_;
rex <= instructions(10 downto 8);
rey <= instructions(7 downto 5);
state<=write_reg;
when _00000_=> --JR
rex <= instructions(10 downto 8);
--case instructions(7 downto 5)is
--when _000_=>
--ALUSrcA<='1';
--ALUOp<=_10_;
--PCWrite<='1';
--PCSource<='0';
--state<=instruction_fetch;
--when others=>
--null;
state<=write_reg;
--end case;
when _00100_=> --SLLV移位
rex <= instructions(10 downto 8);
rey <= instructions(7 downto 5);
state<=write_reg;
when others=>
null;
end case;
when others=>
null;
end case;
when mem_control=> --访存
SHOW_STATE_RIGHT <= _1111111_; --8
PCWrite<='0';
RegWrite<=_000_;
case instructions(15 downto 11)is
when _10011_=> --LW
MemRead<='1';
IorD<='1';
state<=write_reg;
REGS(conv_integer(rey)) <= DATA;
when _11011_=> --SW
RAM1_EN <= '0';
RAM1_OE <= '0';
RAM1_WE <= '1';
MemWrite<='1';
IorD<='1';
state<=instruction_fetch;
DATA <= REGS(conv_integer(rey));
when others=>
null;
end case;
when write_reg=> --写回
SHOW_STATE_RIGHT <= _1101111_; --9
MemWrite<='0';
MemRead<='0';
case instructions(15 downto 11)is
when _10011_=> --LW
RegDst<=_10_;
RegWrite<=_001_;
MemtoReg<=_01_;
state<=instruction_fetch;
when _11011_=> --SW
MemWrite<='0';
IorD<='0';
state<=instruction_fetch;
when _11100_=> --SUBU ADDU
case instructions(1 downto 0)is
when _11_ => --SUBU
REGS(conv_integer(rez)) <= REGS(conv_integer(rex)) - REGS(conv_integer(rey));
RegDst<=_01_;
RegWrite<=_001_;
MemtoReg<=_00_;
when _01_ => --ADDU
REGS(conv_integer(rez)) <= REGS(conv_integer(rex)) + REGS(conv_integer(rey));
RegDst<=_01_;
RegWrite<=_001_;
MemtoReg<=_00_;
when others=>
null;
end case;
state<=instruction_fetch;
when _11101_=> --JR XOR
case instructions(4 downto 0)is
when _00000_=> --JR
pc_mem <= REGS(conv_integer(rex));
RegDst<=_00_;
RegWrite<=_001_;
MemtoReg<=_00_;
case beqz_state is
when updateaddr=>
ADDR<=pc_mem;
beqz_state<=updatedata;
when updatedata=>
instructions<=DATA;
rex <= DATA(10 downto 8);
beqz_state<=updateaddr;
state<=wxaddr;
end case;
when _01110_=> --XOR
REGS(conv_integer(rex)) <= REGS(conv_integer(rex)) XOR REGS(conv_integer(rey));
RegDst<=_00_;
RegWrite<=_001_;
MemtoReg<=_00_;
state<=instruction_fetch;
when _00100_=> --SLLV
REGS(conv_integer(rey))<=TO_STDLOGICVECTOR(To_bitvector(REGS(conv_integer(rey))) SLL CONV_INTEGER(REGS(conv_integer(rex))));
state<=instruction_fetch;
when others=>
null;
end case;
when _00100_ => --BEQZ
if (REGS(conv_integer(rex)) = 0) then
pc_mem <= pc_mem + instructions(7 downto 0);
case beqz_state is
when updateaddr=>
ADDR<=pc_mem;
beqz_state<=updatedata;
when updatedata=>
instructions<=DATA;
rex <= DATA(10 downto 8);
beqz_state<=updateaddr;
state<=wxaddr;
end case;
else
pc_mem<= pc_mem + _0000000000000001_;
state<=instruction_fetch;
end if;
when others=>
null;
end case;
-- state<=instruction_fetch;
end case;
end if;
dbc <= '1';
end process;
light<=tmp_light; --输出结果
end Behavioral;
计算机原理与结构实验报告 第11篇
（1）用VHDL语言实现一个简易的16位ALU。
（2）通过设计一个状态机，根据状态机状态的变化输入操作数和操作码，来实现不同运算。
（3）实验中ALU要求实现基本的算术运算、逻辑运算、移位运算等，具体功能如下表所示。合理设置每条指令的标志位，包括进位标志、溢出标志、最高位和全零标志。
ALU功能表：
操作码
ADD
A + B
SUB
A – B
AND
A and B
A or B
XOR
A xor B
NOT
not A
SLL
A sll B
逻辑左移B位
SLR
A srl B
逻辑右移B位
SAL
A sal B
算数左移B位
SAR
A sar B
算数右移B位
ROL
A rol B
循环左移B位
ROR
A ror B
循环右移B位
要求：ALU 的数据输入 A、B 的长度为 16 位，操作码 op 为 4 位，算术运算时数据用补码表示。
（4）将实验过程中进行的操作与结果数据记录在下表中。
输入数据
实际输出
与预期一致性
操作码
操作数A
操作数B
运算结果
标志位
0000
00000001
00000010
00000011
0000
（5）在教学计算机上验证实现的ALU功能。
计算机原理与结构实验报告 第12篇
①5位无符号阵列乘法器设计
用与门阵列同时产生手动乘法中的各乘积项，同时用一位全加器按照手动乘法运算的需要构成全加器阵列，实现结果如图表9所示。
图表 9
②6位补码陈列乘法器设计
由于补码乘法中的乘数、被乘数和乘积的结果都以补码的形式给出，为了能利用无符号阵列乘法器，需要在运算前将乘数和被乘数先转换成无符号数，因此在相加数电路前增加了两个n位运算前求补电路，并且分别用各自的符号位作为求补控制信号。又因为无符号阵列乘法器的输出结果是无符号数，为将结果转换为补码，需要在最后增加一个2n位运算后求补电路，同时结果的符号位由异或门产生，并作为运算后求补电路的求补控制信号。6位补码阵列乘法器的实现结果如图表10所示。
图表 10
计算机原理与结构实验报告 第13篇
（1）可控加减法电路设计实验：在对应子电路中，利用已经封装好的全加器设计8位串行可控加减法电路
（2）4位快速加法器设计实验
①4位先行进位电路：在对应子电路中利用基本逻辑门实现可级联的4位先行进位电路
②4位快速加法器：在4位快速加法器子电路中利用已经设计好的4位先行进位电路以及基本逻辑门实现4位快速加法器
（3）多位快速加法器设计实验
①16位快速加法器设计
②32位快速加法器设计
（4）32位ALU设计实验
（5）阵列乘法器设计实验
①5位无符号阵列乘法器设计：在对应的子电路中实现5位无符号阵列乘法器
②6位补码陈列乘法器设计：在对应的子电路中利用已经设计好的5位阵列乘法器实现6位补码阵列乘法器
（6）原码一位乘法器设计实验：在对应子电路中利用寄存器、加法器等基本电路设计无符号一位乘法器
（7）补码一位乘法器设计实验：在对应子电路中利用寄存器、加法器等基本电路设计8位补码一位乘法器
（8）乘法流水线设计实验
计算机原理与结构实验报告 第14篇
（1）先定义输入输出，定义时钟，置0和状态控制信号ctrl_r，定义16位拨码输入，16位地址输出和16位数据输出，绑定地址线和数据线。定义左右两个数码管显示状态变化。16位led灯输出地址低8位和数据低8位。
（2）定义signal，定义状态机，控制运行状态，地址输入状态，写入状态和读取状态。
（3）3个运行状态分别进行写地址，写数据，读地址和数据的操作，每个操作中又分为小状态。
（4）添加管脚约束。
（5）运行代码无误后烧录进板子进行验证。
计算机原理与结构实验报告 第15篇
①4位先行进位电路
n位串行加法电路中和数与进位输出的逻辑表达式如下：
Si=Xi⊕Yi⊕Ci Ci+1=XiYi+(Xi⊕Yi)Ci
假设Gi=XiYi, Pi= Xi⊕Yi。当Gi=1时，Ci+1一定为1，所以将Gi称为进位生成函数；当Pi=1时，进位信号Ci才能传递到进位输出Ci+1处，所以称Pi为进位传递函数。有了进位生成函数和进位传递函数，则有以下公式：
Si=Pi⊕Ci Ci+1=Gi+PiCi
电路实现结果如图表2所示。
图表 2
②4位快速加法器
4位先行电路，加上生成Gi，Pi的与门异或门电路，再加上4个异或门就可以构成4位快速加法器，也称为并行加法器。电路实现结果如图表3所示。
图表 3
计算机原理与结构实验报告 第16篇
①16位快速加法器设计
利用先行进位电路提前产生C4、C8、C12、C16信号，将4个4位快速加法器输出的成组进位生成、传递函数G*和P*及C0连接到先行进位电路的输入端，再将对应信号连接到相应的快速加法器的进位输入端即可构成16位组内并行进位、组间并行进位的快速加法器，实现结果如图表4所示。
图表 4
②32位快速加法器设计
在实现16位快速加法器的基础上，将16位快速加法器进行组间串联连接即可实现32位快速加法器，实现结果如图表5所示。
图表 5
电路实现结果如图标6所示。
图表 6
通过给出的ALU自动测试电路进行测试，不断修改错误，直到出现正确的实验结果。实验结果如图表7、8所示。
图表 7
图表 8