(最新版)VHDL,CPU实验报告
cpu实验报告 VHDL 东大
Computer Organization and ArchitectureCourse Design——CPU DesignSchool of Information Science and EngineeringSoutheast UniversityMAY 2011TABLE OF CONTENTSPurposeInstruction SetInternal Registers and MemoryALUMicroprogrammed Control UnitCPU Design1．Architecture of CPU2．Control Signals3．Contents of ROM(microprogram and control signals) 4．contents of RAM(instructions to run)Simulation of the CPU1．The overview of top-level entity2．The waveform of the simulation of the CPUAppendix(CPU design in VHDL language)PurposeThe purpose of this project is to design a simple CPU (Central Processing Unit). This CPU has basic instruction set, and we will utilize its instruction set to generate a very simple program to verify its performance. For simplicity, we will only consider the relationship among the CPU, registers, memory and instruction set. That is to say we only need consider the following items: Read/Write Registers, Read/Write Memory and Execute the instructions.At least four parts constitute a simple CPU: the control unit, the internal registers, the ALU and instruction set, which are the main aspects of our project design and will be studied.Instruction SetSingle-address instruction format is used in our simple CPU design. The instruction word contains two sections: the operation code (opcode), which defines the function of instructions (addition, subtraction, logic operations, etc.); the address part, in most instructions, the address part contains the memory location of the datum to be operated, we called it direct addressing. In some instructions, the address part is the operand, which is called immediate addressing.For simplicity, the size of memory is 256×16 in the computer. The instruction word has 16 bits. The opcode part has 8 bits and address part has 8 bits. The instruction word format can be expressed in Figure 4Figure 4 the instruction formatThe opcode of the relevant instructions are listed in Table 1.In Table 1, the notation [x] represents the contents of the location x in the memory. For example, the instruction word 00000011101110012 (03B916) means that the CPU adds word at location B916 in memory into the accumulator (ACC); the instruction word 00000101000001112 (050716) means if the sign bit of the ACC (ACC [15]) is 0, the CPU will use the address part of the instruction as the address of next instruction, if the sign bit is 1, the CPU will increase the program counter (PC) and use its content as the address of the next instruction.INSTRUCTION OPCODE COMMENTSSTORE X 00000001 ACC→[X]LOAD X 00000010 [X]→ACCADD X 00000011 ACC＋[X]→ACCSUB X 00000100 ACC－[X]→ACCJMPGEZ X 00000101 If ACC≥0 then X→PC else PC＋1→PCJMP X 00000110 X→PCHALT 00000111 Halt a programMPY X 00001000 ACC×[X]→ACC,MRDIV X 00001001 ACC÷[X]→ACC,DRAND X 00001010 ACC and [X]→ACCOR X 00001011 ACC or [X]→ACCNOT X 00001100 NOT [X]→ACCSHIFTR 00001101 SHIFT ACC to Right 1 bit,Logic ShiftSHIFTL 00001110 SHIFT ACC to Left 1 bit,Logic Shift………………All the instructions except the Division instruction must be supported in your design.It is better if you can implement the instruction: DIV X. Also, you can design more instructions if needed.Internal Registers and MemoryMAR (Memory Address Register)MAR contains the memory location of the word to be read from the memory or written into the memory. Here, READ operation is denoted as the CPU reads from memory, and WRITE operation is denoted as the CPU writes to memory. In our design, MAR has 8 bits to access one of 256 addresses of the memory.MBR (Memory Buffer Register)MBR contains the value to be stored in memory or the last value read from memory. MBR is connected to the address lines of the system bus. In our design, MBR has 16 bits.PC (Program Counter)PC keeps track of the instructions to be used in the program. In our design, PC has 8 bits.IR (Instruction Register)IR contains the opcode part of an instruction. In our design, IR has 8 bits.BR (Buffer Register)BR is used as an input of ALU, it holds other operand for ALU. In our design, BR has 16 bitsAll the registers are positive-edge-triggered.All the reset signals for the registers are synchronized to the clock signal..ALUALU (Arithmetic Logic Unit) is a calculation unit which accomplishes basic arithmetic and logic operations. In our design, some operations are supported which are listed as follows in table 2.Table 2 ALU OperationsADD ACC<-ACC+BR Add BR to ACCSUB ACC<-ACC-BR SUB BR from ACCSRL ACC<-SRL(ACC) Shift ACC to the left by 1 bitSRR ACC<-SRR(ACC) Shift ACC to the right by 1 bitAND ACC<-ACC and BR AND operationOR ACC<-ACC or BR OR operationNOT ACC<-not(ACC) NOT operationMPY ACC<-ACC*BR Multiply operationMicroprogrammed Control UnitWe have learnt the knowledge of Microprogrammed control unit. Here, we only review some terms and basic structures.In the Microprogrammed control, the microprogram consists of some microinstructions and the microprogram is stored in control memory that generates all the control signals required to execute the instruction set correctly. The microinstruction contains some micro-operations which are executed at the same time.Figure 2 Control Unit Micro-architectureFigure 2 shows the key elements of such an implementation. The set of microinstructions is stored in the control memory. The control address register contains the address of the next microinstructions to be read. When a microinstruction is read from the control memory, it is transferred to a control buffer register. The register connects to the control lines emanating from the control unit. Thus, reading a microinstruction from the control memory is the same as executing that microinstruction. The third element shown in the figure is a sequencing unit that loads the control address register and issues a read command.CPU Design1.Architecture of CPUFigure 3 CPU data path and control signalsFigure 3 indicates a simple CPU architecture and its use of a variety of internal data paths and control signals. Our CPU design should be based on this architecture.You should determine the control signals according to the CPU architecture and your design. An example is given below to show the procedure, this example describes the control unit design for the LOAD instruction.First, we need determine the control flowchart of the LOAD instruction2.Control SignalsAt first,we determined the control signals according to the CPU architecture and our design.as shown in Table 3.Table 3 Control Bit for the Micro-operationsBit in Control Memory Micro-operation Meaningc0 CAR<-CAR+1 Control Address Incrementc1 CAR<-*** Control Address Redirection,c2 CAR<-0 Reset Control Address to zero positionc3 MBR<-MEMORY Memory Content to MBRc4 IR<-MBR[15..8] Copy MBR[15..8] to IR for OPCODEc5 MAR<-MBR[7..0] Copy MBR[7..0] to MAR for addressc6 PC<-PC+1 Increment PC for indicating positionc7 BR<-MBR Copy MBR data to BR for buffer to ALUc8 ACC<-0 Reset ACC register to zeroc9 MBR<-ACC Copy ACC value to MBRc10 MAR<-PC Copy PC value to MAR for next addressc11 PC<-MBR[7..0] Copy MAR[7..0] to PCc12 MBR<-PC Copy PC value to MBR for next addressc13c14c15 memory<-MBR Copy ACC value to Memoryc16c17c18c19c20 ACC<-ACC+BR Add BR to ACCc21 ACC<-ACC-BR SUB BR from ACCc22 ACC<-SRL(ACC) Shift ACC to the left by 1 bitc23 ACC<-SRR(ACC) Shift ACC to the right by 1 bitc24 ACC<-ACC and BR AND operationc25 ACC<-ACC or BR OR operationc26 ACC<-not(ACC) NOT operationc27 ACC<-ACC*BR Multiply operation3.Contents of ROM(microprogram and control signals)Then according to the control flowcharts for each instruction we can get the microprogram and corresponding control signals descriptions for each instruction.And in order to memory the control signals we use a lpm_rom to implement ROM with only address input and data output with size is 256×32. Contents in ROM can change opcode to microprogram and corresponding control signals. Table 4 shows the contents of the ROM, which functions as the Control Memory.Table 4 Microprograms of the Instruction SetLOAD XMBR<=memroy,CAR<=CAR+1 C3,C0 00000009IR<=MBR[15..8],CAR<=CAR+1 C4,C0 00000011CAR<=*** C1 00000002MAR<=MBR[7..0],PC<=PC+1,CAR<=CAR+1 C5,C6,C0 00000061MBR<=memroy,,CAR<=CAR+1 C3,C0 00000009BR<=MBR,ACC<=0,CAR<=CAR+1 C7,C8,C0 00000181ACC<=ACC+BR,CAR<=CAR+1 C20,C0 00100001MAR<=PC,CAR<=0 C10,C2 00000404STORE XMBR<=memroy,CAR<=CAR+1 C3,C0 00000009IR<=MBR[15..8],CAR<=CAR+1 C4,C0 00000011CAR<=*** C1 00000002MAR<=MBR[7..0], PC<=PC+1,CAR<=CAR+1 C5,C6,C0 00000061MBR<=ACC,CAR<=CAR+1 C9,C0 00000201Memroy<=MBR,CAR<=CAR+1 C15,C0 00008001MAR<=PC,CAR<=0 C10,C2 00000404ADD XMBR<=memroy,CAR<=CAR+1 C3,C0 00000009 IR<=MBR[15..8],CAR<=CAR+1 C4,C0 00000011 CAR<=*** C1 00000002 MAR<=MBR[7..0],PC<=PC+1,CAR<=CAR+1 C5,C6,C0 00000061 MBR<=memroy,CAR<=CAR+1 C3,C0 00000005 BR<=MBR,CAR<=CAR+1 C7,C0 00000081 ACC<=ACC+BR,CAR<=CAR+1 C20,C0 00100001 MAR<=PC,CAR<=0 C10,C2 00000404SUB XMBR<=memroy,CAR<=CAR+1 C3,C0 00000009 IR<=MBR[15..8],CAR<=CAR+1 C4,C0 00000011 CAR<=*** C1 00000002 MAR<=MBR[7..0],PC<=PC+1,CAR<=CAR+1 C5,C6,C0 00000061 MBR<=memroy,CAR<=CAR+1 C3,C0 00000009 BR<=MBR,CAR<=CAR+1 C7,C0 00000081 ACC<=ACC-BR,CAR<=CAR+1 C21,C0 00200001 MAR<=PC,CAR<=0 C10,C2 00000404JMPGEZ XMBR<=memroy,CAR<=CAR+1 C3,C0 00000009 IR<=MBR[15..8],CAR<=CAR+1 C4,C0 00000011 CAR<=*** C1 00000002 PC<=PC+1,CAR<=CAR+1 C6,C0 00000041 MAR<=PC,CAR<=0 C10,C2 00000404 Or PC<=MBR[7..0],CAR<=CAR+1; C11,C0 00000801 MAR<=PC,CAR<=0; C10,C2 00000404JMP XMBR<=memroy,CAR<=CAR+1 00000009 IR<=MBR[15..8],CAR<=CAR+1 00000011 CAR<=*** 00000002 PC<=MBR[7..0],CAR<=CAR+1 00000801 MAR<=PC,CAR<=0 00000404HALTMBR<=memroy,CAR<=CAR+1 00000009 IR<=MBR[15..8],CAR<=CAR+1 00000011 CAR<=*** 00000002 PC<=PC+1,CAR<=CAR+1 C6,C0 00000041 CAR<=CAR+1 C0 00000001 CAR<=CAR+1 C0 00000001 MAR<=PC,CAR<=0; C10,C2 00000404MPY XMBR<=memroy,CAR<=CAR+1 C3,C0 00000009 IR<=MBR[15..8],CAR<=CAR+1 C4,C0 00000011 CAR<=*** C1 00000002 MAR<=MBR[7..0],PC<=PC+1,CAR<=CAR+1 C5,C6,C0 00000061 MBR<=memory,CAR<=CAR+1 C3,C0 00000009 BR<=MBR,CAR<=CAR+1 C7,C0 00000081 ACC<=ACC*BR,CAR<=CAR+1 C27,C0 08000001 MAR<=PC,CAR<=0 C10,C2 00000404AND XMBR<=memroy,CAR<=CAR+1 C3,C0 00000009 IR<=MBR[15..8],CAR<=CAR+1 C4,C0 00000011 CAR<=*** C1 00000002 MAR<=MBR[7..0],PC<=PC+1,CAR<=CAR+1 C5,C6,C0 00000061 MBR<=memory,CAR<=CAR+1 C3,C0 00000009 BR<=MBR,CAR<=CAR+1 C7,C0 00000081 ACC<=ACC and BR,CAR<=CAR+1 C24,C0 01000001 MAR<=PC,CAR<=0 C10,C2 00000404OR XMBR<=memroy,CAR<=CAR+1 C3,C0 00000009 IR<=MBR[15..8],CAR<=CAR+1 C4,C0 00000011CAR<=*** C1 00000002 MAR<=MBR[7..0],PC<=PC+1,CAR<=CAR+1 C5,C6,C0 00000061 MBR<=memory,CAR<=CAR+1 C3,C0 00000009 BR<=MBR,CAR<=CAR+1 C7,C0 00000081 ACC<=ACC or BR,CAR<=CAR+1 C25,C0 02000001 MAR<=PC,CAR<=0 C10,C2 00000404NOT XMBR<=memroy,CAR<=CAR+1 C3,C0 00000009 IR<=MBR[15..8],CAR<=CAR+1 C4,C0 00000011 CAR<=*** C1 00000002 MAR<=MBR[7..0],PC<=PC+1,CAR<=CAR+1 C5,C6,C0 00000061 MBR<=memory,CAR<=CAR+1 C3,C0 00000009 BR<=MBR,ACC<=0,CAR<=CAR+1 C7,C8,,C0 00000181 ACC<=not BR,CAR<=CAR+1 C26,C0 04000001 MAR<=PC,CAR<=0 C10,C2 00000404SHIFTLMBR<=memroy,CAR<=CAR+1 C3,C0 00000009 IR<=MBR[15..8],CAR<=CAR+1 C4,C0 00000011 CAR<=*** C1 00000002 MAR<=MBR[7..0],PC<=PC+1,CAR<=CAR+1 C5,C6,C0 00000061 MBR<=memory,CAR<=CAR+1 C3,C0 00000009 BR<=MBR,ACC<=0,CAR<=CAR+1 C7,C8,,C0 00000181 ACC<=SRL BR,CAR<=CAR+1 C22,C0 00400001 MAR<=PC,CAR<=0 C10,C2 00000404SHIFTRMBR<=memroy,CAR<=CAR+1 C3,C0 00000009 IR<=MBR[15..8],CAR<=CAR+1 C4,C0 00000011 CAR<=*** C1 00000002 MAR<=MBR[7..0],PC<=PC+1,CAR<=CAR+1 C5,C6,C0 00000061 MBR<=memory,CAR<=CAR+1 C3,C0 00000009 BR<=MBR,ACC<=0,CAR<=CAR+1 C7,C8,,C0 00000181 ACC<=SRR BR,CAR<=CAR+1 C23,C0 00800001 MAR<=PC,CAR<=0 C10,C2 000004044.contents of RAM(instructions to run)When we want to execute some instructions, we just need to write instructions in RAM. A program is given as an example:Calculate the result of (1+2+3+...+100)=5050.1. programming with C language:sum=0;temp=100;loop :sum=sum+temp;temp=temp-1;if temp>=0 goto loop;end2. Assume in the memory:sum is stored at location A4,temp is stored at location A3,the contents of location A0 is 0,8the contents of location A1 is 1,the contents of location A2 is 10010=6416.We can translate the above C language program with the instructions listed in Table 1into the instruction program as shown in Table.Table Example of a programProgram with C language Program withinstructions contents of memory(RAM) in HEX Address Contentssum=0; LOAD A0 00 02A0STORE A4 01 01A4 temp=100;LOAD A2 02 02A2STORE A3 03 01A3loop :sum=sum+temp; LOOP:LOAD A4 04 02A4 ADD A3 05 03A3 STORE A4 06 01A4temp=temp-1; LOAD A3 07 02A3 SUB A1 08 04A1 STORE A3 09 01A3if temp>=0 goto loop; JMPGEZ LOOP 0A 0504 endHALT 0B 0700Sum1=a8 LOAD A8 0C 02A8 Sum1=a8*a9 MPY A9 0D 08A9 Sum2=aa LOAD AA 0E 02AA Sum2=aa*a9 MPY A9 0F 08A9 Sum3=aa LOAD AA 10 02AA Sum3=aa*ab MPY AB 11 08ABSimulation of the CPU1. The overview of top-level entity2. The waveform of the simulation of the CPU(1)The simulation waveform of calculating the the sum of all integers from 1 to 100. & 4*8 ;4*(-7);(-7)*(-8)(including STORE, LOAD, ADD, SUB, JMPGEZ, HALT,MPY. ) Content of the ram:The waveform of the result of (1+2+3+4+5+….+100=5050):2-1=15049+1=5050 The simulation waveform of MPY.8*4=32 (-7)*4=32 (-8)*(-7)=56Appendix(CPU design in VHDL language)BR:library ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity br isport(clk:in std_logic;load_mbr:in std_logic; --c[11]data_mbr:in std_logic_vector(15 downto 0);out_br:out std_logic_vector(15 downto 0)); end br;architecture arc_br of br isbeginprocess(clk)variable data_br:std_logic_vector(15 downto 0); beginif(clk'event and clk='1')thenif(load_mbr='1')then --load mbr to brdata_br:=data_mbr;end if;else null;end if;out_br<=data_br;end process;end arc_br;MARlibrary ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity mar isport(clk:in std_logic;reset:in std_logic;load_pc:in std_logic;load_mbr:in std_logic;data_pc:in std_logic_vector(7 downto 0);data_mbrl:in std_logic_vector(7 downto 0);out_mar:out std_logic_vector(7 downto 0));end mar;architecture arc_mar of mar isprocess(clk,reset)variable data_mar:std_logic_vector(7 downto 0); beginif(clk'event and clk='1')thenif(reset='1') then data_mar:="00000000";elsif(load_pc='1')thendata_mar:=data_pc;elsif(load_mbr='1')thendata_mar:=data_mbrl;else null;end if;end if;out_mar<=data_mar;end process;end arc_mar;MBRlibrary ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity mbr isport(clk:in std_logic;reset:in std_logic;load_acc:in std_logic;load_ram:in std_logic;load_pc:in std_logic;data_pc:in std_logic_vector(15 downto 0);data_acc:in std_logic_vector(15 downto 0);data_ram:in std_logic_vector(15 downto 0);out_mbr_other:out std_logic_vector(15 downto 0);out_mbr_mar:out std_logic_vector(7 downto 0));end mbr;architecture arc_mbr of mbr isprocess(clk,reset)variable data_mbr:std_logic_vector(15 downto 0); beginif(clk'event and clk='1')thenif(reset='1') then data_mbr:="0000000000000000";elsif(load_ram='1')thendata_mbr:=data_ram;elsif(load_pc='1')thendata_mbr:=data_pc;elsif(load_acc='1')thendata_mbr:=data_acc;else null;end if;end if;out_mbr_other<=data_mbr;out_mbr_mar<=data_mbr(7 downto 0);end process;end arc_mbr;IRlibrary ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity ir isport(clk:in std_logic;reset:in std_logic;load_mbr:in std_logic;data_mbr:in std_logic_vector(15 downto 0);out_ir:out std_logic_vector(7 downto 0));end ir;architecture arc_ir of ir isbeginprocess(clk,reset)variable data_ir:std_logic_vector(7 downto 0);beginif(clk'event and clk='1')thenif(reset='1') then data_ir:="00000000";elsif(load_mbr='1')thendata_ir:=data_mbr(15 downto 8);else null;end if;end if;out_ir<=data_ir;end process;end arc_ir;PClibrary ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity pc isport(clk:in std_logic;load_mbr:in std_logic;inc:in std_logic;reset:in std_logic;mbr_to_pc:in std_logic_vector(15 downto 0);out_pc_mar:out std_logic_vector(7 downto 0);out_pc_mbr:out std_logic_vector(15 downto 0) );end pc;architecture arc_pc of pc isbeginprocess(clk)variable data_pc:std_logic_vector(7 downto 0);beginif(clk'event and clk='1')thenif(reset='1') then data_pc:="00000000"; --reset elsif(inc='1')then --pc<=pc+1data_pc:=data_pc+1;elsif(load_mbr='1')then --load mbr to pc data_pc:=mbr_to_pc(7 downto 0);else null;end if;end if;out_pc_mar<=data_pc;out_pc_mbr(7 downto 0)<=data_pc;out_pc_mbr(15 downto 8)<="00000000";end process;end arc_pc;ALUlibrary ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity alu isport(acc_clr:in std_logic;clk:in std_logic;cs:in std_logic_vector(7 downto 0);br:in std_logic_vector(15 downto 0);acc_flag:out std_logic;accl:buffer std_logic_vector(15 downto 0);acch:out std_logic_vector(15 downto 0) );end alu;architecture arc_alu of alu isbeginp0:process(clk)variable data_acc:std_logic_vector(31 downto 0); variable data_acc2:std_logic_vector(15 downto 0); beginif(clk'event and clk='1') thenif acc_clr='1' then data_acc2:=x"0000";elsecase cs iswhen "00000001" => data_acc2:=data_acc2+br; --addwhen "00000010" => data_acc2:=data_acc2-br; --subwhen "00000100" => data_acc2:=data_acc2(14 downto 0)&'0'; --shift to leftwhen "00001000" => data_acc2:='0'& data_acc2(15 downto 1); --shift to rightwhen "00010000" => data_acc2:=data_acc2 and br; --andwhen "00100000" => data_acc2:=data_acc2 or br; --orwhen "01000000" => data_acc2:=not br; --notwhen "10000000" => data_acc:=data_acc2*br; --mpydata_acc2:=data_acc(15 downto 0);when others => null;end case;end if;end if;accl<=data_acc2; --flagacch<=data_acc(31 downto 16);acc_flag<=data_acc2(15);end process p0;end arc_alu;CU1library ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity cu1 isport(clk:in std_logic;reset:in std_logic;flag:in std_logic;cu1_inc:in std_logic; --c0ir_cu1:in std_logic; --c1cu1_clear:in std_logic; --c2ir_to_cu1:in std_logic_vector(7 downto 0);cu1_to_cm:out std_logic_vector(7 downto 0));end cu1;architecture behave of cu1 issignal reg:std_logic_vector(7 downto 0);beginp0:process(clk,reset)beginif(clk'event and clk='1') thenif (reset='1' or cu1_clear='1')thenreg<="00000000";elsif(cu1_inc='1') then reg<=reg+1;elsif(ir_cu1='1')thencase ir_to_cu1 iswhen "00000001"=> --01 stroereg<=x"08";when "00000010"=> --02 loadreg<=x"10";when "00000011"=> --03 addreg<=x"18";when "00000100"=> --04 subreg<=x"20";when "00000101"=> --05 jmpgzeif(flag='1') thenreg<=x"28";else reg<=x"30";end if;when "00000110"=> --06 jmpreg<=x"30";when "00000111"=> --07 haltreg<=x"38";when "00001000"=> --08 mpyreg<=x"40";when "00001001"=> --09 divreg<=x"48";when "00001010"=> --0a andreg<=x"50";when "00001011"=> --0b orreg<=x"58";when "00001100"=> --0c notreg<=x"60";when "00001101"=> --0d srrreg<=x"68";when "00001110"=> --0e srlreg<=x"70";when others=>end case;end if;end if;cu1_to_cm<=reg;end process p0;end behave;CU2library ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity cu2 isport(cm_cu2:in std_logic_vector(31 downto 0);c0,c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12,c13,c14,c15:out std_logic;C27_20:out std_logic_vector(7 downto 0));end cu2;architecture behave of cu2 isbeginC0<=cm_cu2(0);C1<=cm_cu2(1);C2<=cm_cu2(2);C3<=cm_cu2(3);C4<=cm_cu2(4);C5<=cm_cu2(5);C6<=cm_cu2(6);C7<=cm_cu2(7);C8<=cm_cu2(8);C9<=cm_cu2(9);C10<=cm_cu2(10);C11<=cm_cu2(11);C12<=cm_cu2(12);C13<=cm_cu2(13);C14<=cm_cu2(14);C15<=cm_cu2(15);C27_20<=cm_cu2(27 downto 20);end behave;CLK_DIFlibrary ieee;use ieee.std_logic_1164.all;use ieee.std_logic_unsigned.all;entity clk_dif isport(clk_in:in std_logic;clk_out:out std_logic);end CLK_dif;architecture behave of clk_dif isbeginp0:process(clk_in)variable counter:std_logic_vector(2 downto 0):="000"; beginif (clk_in'event and clk_in='0') thenif(counter="100") thenclk_out<='1';counter:="000";elseclk_out<='0';counter:=counter+'1';end if;end if;end process p0;end behave;。
接口实验 VHDL编程 实验报告
短学期接口实验VHDL编程实验任务：用VHDL编程实现十六进制的计数显示。
并通过仿真或观察波形验证设计电路的正确性。
最后在SE-5M型EDA实验开发系统上执行验证结果。
实验设备：SE-5M 型EDA实验开发系统，Maxplus 9.23 。
实验原理：首先用MAxplus编写程序，然后进行编译，进行管叫设定，最后将程序下再到实验版的下载板上验证程序。
实验用到了以下管角：时钟信号CP1(CP2): 进行时钟信号设定。
总共有12个信号源，根据所需的时钟频率，跳线设置。
键盘扫描相应管角：Se-5M中有一个4X4的矩阵键盘，其连接图如下,键盘矩阵是与89C51和管理芯片(F7128)直接相连，而通过管理芯片键盘阵列实现了与CPLD间接相连，他是通过KEY来实现的。
当CZ1的KEY置ON时，CPLD可与89C51的P1口相连或者键盘阵列相连，当CZ1D的KEY置OFF时，89C51的P1口及键盘阵列与CPLD断开。
当CPLD和小键盘相连时H1-H4用于发出扫描信号，V1-V4为接收扫描信号，即H1-H4为输出管角，V1-V4为输入管角。
在具体在操作中，一个作为行扫描，一个作为列扫描，从而最终确定用户所按的键。
静态显示数码管M1-M2：用来选择最终的显示结果在哪一数码管上进行显示，例，要在最左边的那个数码管上显示结果，相应的值应该是“10000000”，如果要所有的数码管都显示，相应的值就是“11111111”。
动态显示数码管M3-M4: 用来将最终的结果显示在数码管上，由于要把每个数字或字母分成7段来显示，所以采用了动态扫描电路方式，将静态现实中的数码管M3,M4对应的8个I/O口用于动态显示的数码管的8个管，由于此处没用到小数点位dp,故总设它为0。
关于7段的分发和具体对应的数字和字符，祥见下图和下表：编程思想：首先要对输入输出数据进行定义，有两个4位的数组COL,ROW 分别相对应输入的行和输出的列，从而最终可以确定用户所按得键。
vhdl实验报告
vhdl实验报告VHDL实验报告引言：VHDL（Very High Speed Integrated Circuit Hardware Description Language）是一种硬件描述语言，广泛应用于数字电路设计和仿真。
本篇实验报告将介绍我在VHDL实验中的学习和实践经验，包括实验目的、实验过程、实验结果以及对VHDL的理解和展望。
一、实验目的VHDL实验的主要目的是让我们掌握VHDL语言的基本语法和使用方法，能够利用VHDL描述数字电路，并通过仿真和综合工具进行验证和实现。
通过这些实验，我们可以深入了解数字电路的原理和设计方法，提高我们的逻辑设计能力和工程实践能力。
二、实验过程在实验过程中，我们首先学习了VHDL的基本语法，包括实体声明、端口声明、信号声明等。
然后，我们通过实例学习了VHDL的建模方法，包括组合逻辑电路的建模和时序逻辑电路的建模。
在组合逻辑电路的建模中，我们学习了使用逻辑运算符和条件语句描述电路的功能；在时序逻辑电路的建模中，我们学习了使用过程语句和时钟信号描述电路的状态转换。
在学习了VHDL的基础知识后，我们开始进行实验设计。
我们选择了一个简单的数字电路，如4位加法器，来进行实验验证。
首先，我们通过VHDL语言描述了加法器的功能和结构，包括输入端口、输出端口和中间信号。
然后，我们使用仿真工具进行了功能仿真，验证了加法器的正确性。
接着，我们使用综合工具将VHDL代码综合成门级电路，并进行了时序仿真和时序优化，验证了加法器的时序正确性和性能。
三、实验结果通过实验，我们成功地实现了4位加法器的功能，并验证了其正确性和性能。
在功能仿真中，我们输入了不同的测试数据，观察了输出结果，发现加法器能够正确地进行加法运算，并得到了正确的结果。
在时序仿真中，我们观察了电路的时序行为，包括输入信号的变化、输出信号的响应和中间信号的传播延迟等，发现加法器能够在时序上满足要求，并且具有较好的性能。
vhdl设计实验报告
vhdl设计实验报告VHDL设计实验报告引言VHDL（Very High Speed Integrated Circuit Hardware Description Language）是一种硬件描述语言，广泛应用于数字电路设计和验证。
本实验旨在通过设计一个简单的电路来熟悉VHDL语言的基本语法和设计流程。
一、实验背景数字电路是现代电子系统的基础，而VHDL则是描述和设计数字电路的重要工具。
VHDL可以帮助工程师们以一种形式化的语言来描述电路的功能和结构，从而实现电路的模拟和验证。
二、实验目的本实验的目的是通过使用VHDL语言设计一个简单的电路，加深对VHDL语言的理解，并掌握基本的电路设计流程。
三、实验步骤1. 确定电路功能在设计电路之前，首先需要明确电路的功能。
本实验中，我们选择设计一个4位加法器电路。
2. 设计电路结构根据电路功能的要求，设计电路的结构。
在本实验中，我们需要设计一个4位加法器，因此需要使用4个输入端口和一个输出端口。
3. 编写VHDL代码使用VHDL语言编写电路的描述代码。
在代码中，需要定义输入和输出端口的类型和位宽，并实现电路的功能。
4. 进行仿真使用仿真工具对设计的电路进行仿真，以验证电路的功能是否符合预期。
通过输入不同的测试数据，观察输出是否正确。
5. 下载到FPGA开发板将设计好的电路代码下载到FPGA开发板上进行验证。
通过连接输入信号和观察输出信号，验证电路在实际硬件上的运行情况。
四、实验结果与分析经过仿真和实际验证，我们设计的4位加法器电路在功能上符合预期。
输入不同的数据进行加法运算时，输出结果都正确。
五、实验总结通过本次实验，我们深入了解了VHDL语言的基本语法和设计流程。
通过设计一个简单的电路，我们掌握了VHDL的应用方法，并通过仿真和实际验证，加深了对电路设计的理解。
六、实验心得本实验让我对VHDL语言有了更深入的认识。
通过实际操作，我更加熟悉了VHDL的编写和仿真流程。
VHDL与数字电路设计实验报告
VHDL与数字电路设计实验报告引言本实验旨在通过使用VHDL编程语言和数字电路设计技术，实现特定功能的电路设计。
本文档将对实验的步骤、设计原理和结果进行详细描述。
实验步骤1. 步骤一：熟悉VHDL编程语言在实验开始之前，团队成员对VHDL编程语言进行了研究和熟悉。
我们了解了VHDL的基本语法、数据类型和结构，并获得了对VHDL设计原理的初步理解。
2. 步骤二：设计功能电路在本实验中，我们选择了一个特定的功能电路进行设计。
我们首先进行了功能需求分析，并根据需求确定了电路的输入输出信号以及主要的逻辑运算。
然后，我们使用VHDL编程语言将电路的逻辑运算实现为代码，并进行了仿真和测试。
3. 步骤三：电路仿真和验证为了验证我们设计的电路功能的正确性，我们使用了VHDL仿真工具进行了电路的仿真和验证。
我们根据输入信号的不同组合，观察输出信号的变化，并与我们预期的结果进行比较。
通过这一步骤，我们确认了我们设计的电路能够按照预期工作。
4. 步骤四：电路实现和测试在确认电路的设计和仿真结果无误之后，我们进一步将电路实现到实际的数字电路平台上，并进行了硬件测试。
我们使用实际的输入信号来测试电路的性能和稳定性，并对输出信号进行观察和分析。
通过这一步骤，我们验证了电路在实际环境中的可行性。
设计原理我们设计的电路基于特定的功能需求，采用了经典的数字电路设计原理。
通过使用VHDL编程语言，我们将电路的逻辑运算实现为逻辑门和触发器的组合。
通过将输入信号连接到适当的逻辑门和触发器，我们实现了所需的功能。
结果与分析经过实验步骤的完成，我们成功地设计和实现了一个具有特定功能的数字电路。
在仿真测试和实际测试中，电路都表现出了良好的性能和稳定性。
根据结果的分析，我们验证了电路的设计原理和逻辑的正确性。
结论本实验通过使用VHDL编程语言和数字电路设计技术，成功地实现了一个具有特定功能的电路设计。
我们的实验结果表明，VHDL和数字电路设计技术在电路设计领域具有重要的应用价值。
VHDL实验报告(1)
VHDL 实验报告******班级：电子0701学号：************实验一组合逻辑电路设计一实验目的：1. 熟悉mux+pluxII软件，可以进行新文件的编辑和文件的修改。
2. 掌握门电路VHDL语言程序设计方法。
3. 掌握选择器VHDL语言程序设计方法。
4. 掌握加法器VHDL语言程序设计方法。
5. 熟悉VHDL编程的基本方法。
二实验设备：1.计算机2.Max+PlusII软件三实验原理及内容：1 二输入与门（1）实验原理二输入与门是我们数字电路中的一个基础逻辑门电路，是最基本的逻辑门电路之一，也是最简单的逻辑门之一。
它能实现两个输入端的相与，一般有三个端口。
二输入与门的表达式是：Y=ab二输入与门的逻辑符号如图（1）所示，真值表如表（1）所示。
图（1）与门逻辑符号表（1）与门真值表（2）实验内容a.在mux+pluxII文本编辑环境下，打开新文本，编写两输入与门VHDL语言源程序，程序设计如下：LIBRARY IEEE;USE IEEE.STD_LOGIC_1164.ALL;ENTITY and2 ISPORT(a,b: IN STD_LOGIC;Y: OUT STD_LOGIC);END and2;ARCHITECTURE behave OF and2 ISBEGINY <= a and b;END behave;b．对源程序进行编译，按照提示进行修改，直至编译通过。
c．对编译程序进行仿真，分析并记录仿真波形，其仿真波形图如图（2）所示。
图（2）二输入与门仿真图d.在自己的目录下保存相应的源文件、波形文件。
2 四选一选择器（1）实验原理四选一选择器如图（3）所示，真值表如表（2）所示。
图（3）mux4管脚图表（2）mux4真值表（2）实验内容a.在mux+plusII文本编辑环境下，打开新文件，编辑四选一VHDL源程序文件，其程序设计如下：LIBRARY IEEEUSE IEEE.STD_LOGIC_1164.ALL;ENTITY mux4 ISPORT(A: IN STD_LOGIC_VECTOR (1 DOWNTO 0);D0,D1,D2,D3:IN STD_LOGIC;G:IN STD_LOGIC;Y: OUT STD_LOGIC);END mux4;ARCHITECTURE dataflow OF mux4 ISBEGINPROCESS (A,D0,D1,D2,D3,G)BEGINIF (G ='0') THENIF (A="00")THEN Y <= D0;ELSIF(A="01")THEN Y <= D1;ELSIF(A="10")THEN Y <= D2;ELSE Y <= D3;END IF;ELSE Y <='0';END IF;END PROCESS;END dataflow;b.对源程序进行编译，按照提示进行修改，直到编译通过。
VHDL实验报告
年月日VHDL实验报告学院专业学号姓名实验1 译码器设计一、实验原理1、译码器是数字系统中常用的组合逻辑电路，常用于地址译码。
74LS138是最常用的一种小规模集成电路，它有3个二进制输入端和8个译码输出端。
表1.1是它的真值表。
表1.1 3－8 译码器真值表2、普通的LED数码管由7段和一个点组成，使用它进行显示，需要译码驱动。
本实验实现一个七段LED显示译码电路。
为了实验方便，在译码之前加入一个4位二进制加法计数器，当低频率的脉冲信号输入计数器后，由7段译码器将计数值译为对应的十进制码，并由数码管显示出来。
图1.1为此电路的原理图。
图1.1 7段LED译码显示电路二、实验内容1、设计一个4－16译码器。
2、设计轮流显示表1.2所示字符的程序。
表1.2 字母显示真值表3、通过仿真，观察设计的正确性。
4、下载、验证设计的正确性。
三、源程序1、4－16译码器。
LIBRARY IEEE;USE IEEE.STD_LOGIC_1164.ALL;ENTITY decode ISPORT( d0, d1, d2,d3, s1 ,s2 ,s3:IN STD_LOGIC;Y : OUT STD_LOGIC_VECTOR ( 15 DOWNTO 0 ) );END decode;ARCHITECTURE rtl OF decode ISSIGNAL indata : STD_LOGIC_VECTOR ( 3 DOWNTO 0 );BEGINIndata <= d3 & d2 & d1 & d0 ;PROCESS ( indata, s1, s2, s3 )BEGINIF (s1 ='1' AND s2='0' AND s3 = '0' ) THENCASE indata ISWHEN "0000" => Y <= "1111111111111110" ;WHEN "0001" => Y <= "1111111111111101" ;WHEN "0010" => Y <= "1111111111111011" ; WHEN "0011" => Y <= "1111111111110111" ;WHEN "0100" => Y <= "1111111111101111" ;WHEN "0101" => Y <= "1111111111011111" ;WHEN "0110" => Y <= "1111111110111111" ;WHEN "0111" => Y <= "1111111101111111" ;WHEN "1000" => Y <= "1111111011111111" ;WHEN "1001" => Y <= "1111110111111111" ;WHEN "1010" => Y <= "1111101111111111" ; WHEN "1011" => Y <= "1111011111111111" ;WHEN "1100" => Y <= "1110111111111111" ;WHEN "1101" => Y <= "1101111111111111" ;WHEN "1110" => Y <= "1011111111111111" ;WHEN "1111" => Y <= "0111111111111111" ;WHEN OTHERS=> NULL;END CASE;ELSEY <= "1111111111111111" ;END IF;END PROCESS;END rtl;2、轮流显示表1.2所示字符的程序。
数字电路设计实验vhdl语言实验报告
实验一秒表计数器的设计实验目的:本实验通过设计四种频率可选的数字时钟系统, 以达到熟悉VHDL 语言编程语法、设计思路和熟练掌握Quartus II 开发软件的目的。
二、实验内容:该数字时钟的显示格式如下所示: HH: MM: SS, 其中HH表示时计数的两位, MM表示分计数的两位, SS表示秒计数的两位。
本系统输入信号分别为复位信号rst(高有效)、sel(两位信号, 分别可以选择2分频、4分频8分频和16分频)、clk_in(时钟信号)、8位时输出、8位分输出、8位秒输出(其中高4为表示对应的高半字节、低4位表示的低半字节, 譬如当时间为08:59:30时, 时输出为”0000_1000”,分输出为”0101_1001”,秒输出为”0011_0000”)。
该时钟系统可以通过Sel信号时钟运行的快慢。
三、实验流程:通过对实验内容的分析: 可以考虑时钟系统的可由三部分组成: 1.分频器:分频器为时序电路并且通过《数字电路》理论课程的学习可知由计数器来实现, 同学可以回想一下实验1中是如何实现计数器电路的设计）, 该模块主要产生2.4.8、16分频的时钟信号；2.多路选择器:在VHDL中多路选择器为组合逻辑, 可以有多种实现方法, 在这里主要选用了case语句来实现。
该模块的作用是从分频器中根据Sel信号选择适当的时钟信号；3.时钟控制器:该模块比较复杂, 主要实现功能是实现一个24小时的计时。
当时间为00:00:59的时候下一个时钟到来时状态的跳变为00:01:00, 计时中多数计数为加1操作, 有几个特殊状态需要重点考虑：当时间产生分进数时, 譬如上例。
当时间产生时进数时, 譬如00:01:59时刻的下一个状态为00:02:00;当时间产生时进数时, 譬如00:59:59是个的下一个状态为01:00：00。
当时间产生天进数时, 譬如23:59:59的下一个状态为00:00:00。
四、仿真要求:1、本次试验的结果全部采用功能仿真分析:在结果图中能够看到让复位信号rst为有效的情况下, 所有的输出为00:00:00；2.当频率选择输出分别为”00”、”01”、”10”、”11”时秒为的进数分别包含2.4.8、16倍clk_in的时钟周期；3.可以看到完整的计时周期00:00:00->23:59:59->00:00:00。
VHDL数字电路课程实验报告
VHDL数字电路课程实验报告实验一8分频器一、实验要求：分别用信号量和变量实现八分频器二、实验过程：1、代码：8分频器vhdlibrary ieee;use ieee.std_logic_1164.all;entity freq_divider isport(clk: in std_logic;out1, out2: buffer bit);end freq_divider;architecture example of freq_divider issignal count1: integer range 0 to 7;beginprocess(clk)variable count2: integer range 0 to 7;beginif(clk'event and clk='1') thencount1<=count1+1;count2:=count2+1;if(count1=3) thenout1<=not out1;count1<=0;end if;if(count2=4) thenout2<=not out2;count2:=0;end if;end if;end process;end example;八分频器tbLIBRARY ieee;USE ieee.std_logic_1164.all;ENTITY fd_tb isEND fd_tb;architecture behavior of fd_tb iscomponent freq_dividerport(clk:IN STD_LOGIC;out1, out2: buffer bit);end component;signal clk:std_logic;signal out1,out2:bit;beginu1: freq_divider port map(clk,out1,out2);processbeginclk<='0';wait for 50 ns;loopclk<=not clk;wait for 25 ns;end loop;end process;end behavior;2、结果图：实验二实现例8.6一、实验要求：电路只有一个输入时钟信号，输出信号在适中的两个边沿都会发生变化二、实验内容：1、代码信号发生器vhdENTITY signal_gen ISPORT (clk: IN BIT;outp: OUT BIT);END signal_gen;ARCHITECTURE fsm OF signal_gen ISTYPE state IS (one, two, three);SIGNAL pr_state1, nx_state1: state;SIGNAL pr_state2, nx_state2: state;SIGNAL out1, out2: BIT;BEGINPROCESS(clk)BEGINIF (clk'EVENT AND clk = '1') THENpr_state1 <= nx_state1;END IF;END PROCESS;PROCESS (clk)BEGINIF (clk'EVENT AND clk = '0') THENpr_state2 <= nx_state2;END IF;END PROCESS;PROCESS (pr_state1)BEGINCASE pr_state1 ISWHEN one =>out1 <= '0';nx_state1 <= two;WHEN two =>out1 <= '1';nx_state1 <= three;WHEN three =>out1 <= '1';nx_state1 <= one;END CASE;END PROCESS;PROCESS (pr_state2)BEGINCASE pr_state2 ISWHEN one =>out2 <= '1';nx_state2 <= two;WHEN two =>out2 <= '0';nx_state2 <= three;WHEN three =>out2 <= '1';nx_state2 <= one;END CASE;END PROCESS;outp <= out1 AND out2;END fsm;信号发生器tbentity tb_fsm isend tb_fsm;architecture behavior of tb_fsm is component signal_gen isport( clk: in bit;outp: out bit);end component;signal clk,outp:bit;beginu1: signal_gen port map(clk,outp); processbeginclk<='0';wait for 20 ns;loopclk<=not clk;wait for 10 ns;end loop;end process;end behavior;2、结果图实验三常数比较器一、实验要求常数比较器，用于比较的变量位宽应大于等于常数二、实验内容1、代码常数比较器vhdLIBRARY ieee;USE ieee.std_logic_1164.all;entity compare isport(b: in integer range 0 to 15;x1,x2,x3: out std_logic);end compare;architecture compare of compare isconstant a: integer:=10;beginx1<='1' when a>b else '0';x2<='1' when a=b else '0';x3<='1' when a<b else '0';end compare;常数比较器tbLIBRARY ieee;USE ieee.std_logic_1164.all;entity tb_compare isend tb_compare;architecture behavior of tb_compare iscomponent compareport(b: in integer range 0 to 15;x1,x2,x3: out std_logic);end component;signal b: integer;signal x1,x2,x3: std_logic;beginu1: compare port map(b, x1,x2,x3);processbeginb<=5; wait for 10 ns;b<=8; wait for 10 ns;b<=10; wait for 10 ns;b<=13; wait for 10 ns; b<=10; wait for 10 ns; b<=3; wait for 10 ns; end process;end behavior;2、结果图实验四序列检测器一、实验要求序列检测’1001’弱检测到，输出‘1‘，否则输出’0‘二、实验内容1、状态图2、代码序列检测器vhdlibrary ieee;use ieee.std_logic_1164.all;entity string_detector isport(datain,clk: in bit;q: out bit);end string_detector;architecture sd of string_detector istype state is (zero, one, two, three, four);signal pr_state, nx_state: state;beginprocess(clk)beginif(clk'event and clk='1') thenpr_state<=nx_state;end if;end process;process(datain, pr_state)begincase pr_state iswhen zero=>q<='0';if(datain='1') then nx_state<=one;else nx_state<=zero;end if;when one=>q<='0';if(datain='0') then nx_state<=two;else nx_state<=zero;end if;when two=>q<='0';if(datain='0') then nx_state<=three;else nx_state<=zero;end if;when three=>q<='0';if(datain='1') then nx_state<=four;else nx_state<=zero;end if;when four=>q<='1';nx_state<=zero;end case;end process;end sd;序列检测器tb------------------------------------------------------------------ library ieee;use ieee.std_logic_1164.all;------------------------------------------------------------------ entity testBench isend testBench;------------------------------------------------------------------architecture test of testBench iscomponent string_detector isport(datain,clk: in bit;q: out bit);end component;signal datain,clk:bit;signal q:bit;beginSD: string_detector port map(datain,clk,q);processbeginfor i in 0 to 100 loopclk<='0';wait for 10 ns;clk<='1';wait for 10 ns;end loop;end process;processbegindin<='1';wait for 20ns;din<='0';wait for 20ns;din<='0';wait for 20ns;din<='0';wait for 20ns;din<='1';wait for 20ns;din<='0';wait for 20ns;din<='0';wait for 20ns;din<='1';wait for 20ns;din<='0';wait for 20ns;din<='1';wait for 20ns;din<='0';wait for 20ns;end process;end test;3、结果图。
VHDL硬件课程设计实验报告
硬件课程设计实验报告一、全加器设计1、实验目的(1)了解四位全加器的工作原理。
(2)掌握基本组合逻辑电路的FPGA实现。
(3)熟练应用Quartus II进行FPGA开发。
2、实验原理全加器是由两个加数X i和Y i以及低位来的进位C i-1作为输入，产生本位和S i以及向高位的进位C i的逻辑电路。
它不但要完成本位二进制码X i和Y i相加，而且还要考虑到低一位进位C i-1的逻辑。
对于输入为X i、Y i和C i-1，输出为S i和C i的情况，根据二进制加法法则可以得到全加器的真值表如下表所示：全加器真值表由真值表得到S i和C i的逻辑表达式经化简后为：这仅仅是一位的二进制全加器，要完成一个四位的二进制全加器，只需要把四个级联起来即可。
i3、实验内容本实验要完成的任务是设计一个四位二进制全加器。
具体的实验过程就是利用实验系统上的拨动开关模块的K1～K4作为一个加数X输入，K5～K8作为另一个加数Y输入，用LED模块的LED1～LED8来作为结果S输出，LED亮表示输出‘1’，LED灭表示输出‘0’。
实验箱中的拨动开关、LED与FPGA的接口电路，以及拨动开关、LED 与FPGA的管脚连接在以前的实验中都做了详细说明，这里不在赘述。
4、实验现象与结果以设计的参考示例为例，当设计文件加载到目标器件后，拨动相应的拨动开关，输入两个四位的加数，则在LED灯上显示这两个数值相加的结果的二进制数。
5、实验报告(1)出不同的加数，绘仿真波形，并作说明。
(2)在这个程序的基础上设计一个八位的全加器。
(3)在这个程序的基础上，用数码管来显示相乘结果的十进制值。
(4)将实验原理、设计过程、编译仿真波形和分析结果、硬件测试结果记录下来。
二、七段数码显示设计1、七段显示基本原理七段显示器，在许多产品或场合上经常可见。
其内部结构是由八个发光二极管所组成，为七个笔画与一个小数点，依顺时针方向为A、B、C、D、E、F、G与DP等八组发光二极管之排列，可用以显示0～9数字及英文数A、B、C、D、E、F。
《CPU设计实验报告》word版
CPU设计实验报告姓名：学号：邮箱：一、实验目的：1、掌握硬件描述语言VHDL和EDA工具Quartus II；利用VHDL设计16位串行CPU，实现算术和逻辑运算指令、转移指令、访存指令、堆栈指令和控制指令；2、掌握CPU的调试和测试方法。
二、实验内容：1、运用硬件描述语言VHDL实现寄存器堆和算数逻辑单元设计、指令集和指令格式、时序设计和整体结构设计、指令译码器的设计、访存单元的设计、调试单元的设计；2、上机调试。
三、实验步骤：1、寄存器堆的设计寄存器堆由16个16位寄存器组成。
其中reset是异步清0端，reset=0时将所有寄存器清0。
dr_sel和sr_sel是目实用文档标寄存器和源寄存器编号，dr_out和sr_out输出目标寄存器和源寄存器的内容。
reg_sel指定一个寄存器编号，将该寄存器内容送给reg_out，这两个端口用于调试时观察每个寄存器的值。
reg_en是写允许端。
reg_en=“01”时，在clk的上升沿将from_alu写入dr_sel指定的寄存器；reg_en=“10”时，在clk的上升沿将from_mem写入dr_sel指定的寄存器。
reg_en取其他值时不改变寄存器堆的值。
设计方法：subtype WORD is std_logic_vector(15 downto 0);type REGISTERARRAY is array ( 0 to 15 ) of WORD;signal reg_bank: REGISTERARRAY 则reg_bank就是我们所需要的寄存器堆。
写寄存器堆的方法：reg_bank(conv_integer(dr_sel))<=from_alu;实用文档读寄存器堆的方法：dr_out <= reg_bank(conv_integer(dr_sel));其中，conv_integer是STD_LOGIC_ UNSINGED 程序包提供的函数，将标准逻辑矢量转换成整数，作为reg_bank 的下标。
VHDL实验报告
实验一一、实验目的：1、掌握用VHDL 语言和EPLD 进行组合逻辑电路的设计方法。
2、加深对EPLD 设计全过程的理解。
3、掌握组合逻辑电路的静态测试方法。
二、实验设备：1、PC 机2、EDA 实验箱（主芯片是ALTERA EPM7128SLC84-15）。
三、实验内容：1．用VHDL语言设计的四舍五入判别电路，其输入为8421BCD码。
a.程序：library ieee;use ieee.std_logic_1164.all;entity judge isport(a:in std_logic_vector(0 to 3);b:out std_logic);end judge;architecture art of judge isbeginprocess(a)beginif(a<="1001"and a>="0101")thenb<='1';elsif(a<"0101")thenb<='0';elseb<='X';end if;end process;end art;b.运行结果：2．用VHDL语言设计的四个开关控制一盏灯，其中任一开关动作都会导致灯的变化。
a.程序：library ieee;use ieee.std_logic_1164.all;entity xor2 isport(a,b:in std_logic;c:out std_logic);end xor2;architecture artxor2 of xor2 isbeginc<=a xor b;end artxor2;library ieee;use ieee.std_logic_1164.all;entity switch isport(a,b,c,d:in std_logic;q:out std_logic);end switch;architecture art of switch iscomponent xor2 isport(a,b:in std_logic;c:out std_logic);end component xor2;signal tmpa,tmpb:std_logic;beginU1:xor2 port map(a,b,tmpa);U2:xor2 port map(c,d,tmpb);U3:xor2 port map(tmpa,tmpb,q);end art;b.运行结果：其中设开关闭合为1，灯亮为13．用VHDL语言设计优先排队电路，其中A优先级最高，B优先级次高，C优先级最低，并且输出端只有优先级较高的为1。
EDA与VHDL 实验报告--16位cpu 设计
[EDA与VHDL 实验报告][16位CPU设计]0 / 1916位cpu 设计一、顶层系统设计1.1 组成结构CPU的结构如图所示。
这是一个采用单总线系统架构的复杂指令系统结构的16 位CPU 。
处理器包含了各种基本器件模块。
他们是8个16位的寄存器reg0~ reg7、一个运算器ALU、一个移位寄存器Shifter、一个程序计数器PortCnt、一个指令寄存器InstrReg、一个比较器Comp、一个地址寄存器Addreg、和一个控制单元Control。
这些模块公共用一组16 位的三台数据总线。
系统采用自顶向下的方法进行设计。
顶层设计由微处理器和存储器通过一组双向数据总线连接，它们由一组地址总线和一些控制总线组成。
处理器从外存储器中读取指令，并通过执行这些指令来运行程序。
这些指令存储在指令寄存器中，并由控制单元译码。
控制单元使得相应的信号互相作用，并使处理单元执行这些指令。
1.2. 指令系统设计在设计处理器时首先要确定Cpu 具有哪些功能，并针对这些功能采用哪些指令，然后确定指令的格式。
为了使设计的CPU 具有基本的运算功能，指令将设计成以下形式，可以分为如下几类.●装载指令：指令从其他寄存器或存储器装载数据或是立刻赋值。
●存储指令：指令存储寄存器的值写到存储器●分支指令：指令使处理器转到其它地址，一些分支指令为条件转移，另外一些为无条件转移●移位指令：这些指令用移位寄存器单元执行移位操作，实现数据传递1.2.1 指令格式所有的指令都包含五位操作码。
单字节指令在低6位指令中包含两个3 位寄存器，一个是源操作数寄存器，另一个是目的操作数寄存器。
双字节指令中，第一个字节中包含目标寄存器的地址，第二个字节中包含了指令地址或者操作数。
指令格式如下：（1）单字指令（2）双字指令第一个字中包含目标寄存器的地址，第二个字中包含了指令地址或者操作数。
1.2.2 指令操作码1.3. 顶层结构的VHDL 设计CPU 原件的VHDL 描述CPU_LIB.VHDL 用来说明连接各个原件之间的信号类型。
VHDL实验报告
VHDL练习一1、七段译码管设计流程：七段译码管的实现不需要什么运算，和逻辑，只需要设定对应关系就可以。
首先调用ieee库，调用std_logic_1164.all，然后定义实体dec7，包含输入端口clk、data_in，输出端口dec，其中clk是std_logic类型，data_in根据要求是一个整型，输出端口对应到译码管的7段器件，所以是std_logic_vector类型。
接着定义结构体实现功能，进程敏感表为clk，使用case语句分情况输出，默认共阴极译码管，0为亮灯，当输出不在0~9范围时输出中间横线。
备注：一开始使用三位二进制数作为输入，后验证可以使用整型作为输入数据。
验证模块：声明空实体dec7_tb进行测试，将参数定义，并赋初值。
对被测试原件映射，定义时钟周期20ns，时钟进程自循环进行。
主进程验证时随意选取3组数据进行测试结果：结果与设计一致，认为设计成功。
2、十进制计数器设计流程：实体counter10，输入信号reset，up_enable，clk，输出信号bcd（4位），count。
结构体设计，定义信号变量temp（4位），作为可读数，记录当前数字。
当reset有效（当1有效），计数清零，否则当up_enable有效并获得clk上升沿时，计数加1，当计数达到9，count输出一个脉冲并将计数器归零。
完成后将计数器数字输出给bcd。
后来发现可以定义bcd为inout类型，就不需要temp作为中间变量。
验证模块：分别验证计数正确性、count输出、reset功能、up_enable功能。
结果：符合设计目标，计数器到9输出脉冲，up_enable为零时不计数，reset重置。
3、序列检测器设计流程：采用5位移位寄存器实现序列检测，当reset有效，重置寄存器；否则时钟上升沿到来时进行寄存器内容左移并在最低位读入数据，检测当前寄存器内容是否满足要求，是的话输出匹配信号脉冲。
验证模块：验证模块中增加constant std_logic_vector类型的data作为输入码流，预设为16位。
(最新版)vhdl实验报告
福建农林大学计算机与信息学院信息工程类实验报告2013年11 月13 日实验项目列表福建农林大学计算机与信息学院信息工程类实验报告系：电子信息工程系专业：电子信息工程年级： 2010级姓名：学号：实验课程： VHDL数字系统设计实验室号：__ 田C407 实验设备号： 07 实验时间： 11.12 指导教师签字：成绩：实验一数控分频器的设计1．实验目的和要求学习数控分频器的设计、分析和测试方法。
2．实验原理信号有不同的分频比，数控分频器就是用计数值可并行预置的加法计数器设计完成的，方法是将计数溢出位与预置数加载输入信号相接即可，详细设计程序如例1所示。
数控分频器的仿真波形如图1所示：输入不同的CLK频率和预置值D，给出如图1的时序波形。
100.0μs200.0μs300.0μs400.0μs图1 当给出不同输入值D时，FOUT输出不同频率(CLK周期=50ns)3．主要仪器设备（实验用的软硬件环境）实验的硬件环境是：微机一台GW48 EDA实验开发系统一套电源线一根十芯JTAG口线一根USB下载线一根USB下载器一个示波器实验的软件环境是：Quartus II 9.0软件4．操作方法与实验步骤（1）创建工程，并命名位test。
（2）打开QuartusII,建立VHDL文件，并输入设计程序。
保存为DVF.（3）选择目标器件。
Acex1k—EP1K100QC208-3。
（4）启动编译。
（5）建立仿真波形图。
（6）仿真测试和波形分析。
（7）引脚锁定编译。
（8）编程下载。
（9）硬件测试5．实验内容及实验数据记录在实验系统上硬件验证例5-20的功能。
可选实验电路模式1（第一章图4）；键2/键1负责输入8位预置数D(PIO7-PIO0)；CLK由clock0输入，频率选65536Hz 或更高(确保分频后落在音频范围)；输出FOUT接扬声器(SPKER)。
编译下载后进行硬件测试：改变键2/键1的输入值，可听到不同音调的声音。
【实验】VHDL实验报告
【关键字】实验项目一数据选择器一、实验与设计要求1．熟悉MAX+PLUS II的编译环境，掌握该集成环境各个菜单项的使用;2．了解MAX+PLUSII的VHDL程序设计输入方法，初步了解该软件的仿真环境;3．初步运用VHDL编程，体会硬件描述语言的先进性;4．理解VHDL语言的并发执行的特点；5．熟悉VHDL语法6. 按照如下图示，设计一个四路的数据选择器，该电路能将四组不同的数据有选择的输出，每一组数据的宽度为4，输出那一组数据由选择开关决定，如下表：AB QCDS0S1二、实验与设计方法1．加入MAX+PLUSII软件之前，在E盘上新建一个工作目录\lyung。
2．加入MAX+PLUSII文本编辑器，编写VHDL程序,并保存文件至\lyung\mux41.vhd：3. 将工程指向当前文件并编译当前文件。
4. 建立波形仿真文件，设置输入、输出端口及输入端口的信号波形，保存波形仿真文件。
5. 加入仿真器工作环境，查看波形仿真结果。
6. 选择器件, 为电路端口分配FPGA器件引脚。
7. 进行第二次编译（包括逻辑综合和器件工艺映射），生成目标文件（*.sof等）。
8．将目标文件下载至FPGA器件。
9．在实验台上进行实际操作，验证设计的正确性。
三、实验与设计结果通过实验，初步熟悉了MAX+PLUS II的编译环境，并掌握该集成环境各个菜单项的使用。
实验过程中，了解了MAX+PLUSII的VHDL程序设计输入方法，初步运用VHDL编程，成功的按照实验要求设计了程序的VHDL源码（见附件1），熟悉了VHDL语法，理解了VHDL语言的并发执行的特点；并进行了仿真实验（仿真实验截图见图4-1），初步了解该软件的仿真环境，并成功的将文件烧入实验平台，成功通过了测试（实验平台截图见图4-2）。
四、程序源码及实验截图4-0、VHDL源码如下：LIBRARY IEEE;USE IEEE.STD_LOGIC_1164.ALL;ENTITY mux41 ISPORT (a,b,c,d: IN STD_LOGIC_VECTOR (3 DOWNTO 0);s1,s0: IN STD_LOGIC;q: OUT STD_LOGIC_VECTOR (3 DOWNTO 0));END mux41;ARCHITECTURE behave OF mux41 ISSIGNAL sel: STD_LOGIC_VECTOR(1 DOWNTO 0);BEGINsel <= s1 & s0;q<= a WHEN sel="00" ELSEb WHEN sel="01" ELSEc WHEN sel="10" ELSEd WHEN sel="11" ELSE"XXXX";END behave ;图 4-2 实验平台实验项目二三—八译码器一、实验与设计要求1.掌握组合逻辑电路的设计的一般步骤和方法；2.掌握一般电路设计要求及其设计知识；3. 设计一个3-8译码器，此电路有三个输入端（A，B，C），八个输出端D[7··0]；当输入为为不同的值（0~7）时，只有对应的输出端才有输出；如下图所示：Y7二、实验与设计方法1.建立真值表2. 编写VHDL语言程序3. 将工程指向当前文件并编译当前文件。
可编程实验报告_VHDL
实验1 74ls157 4二选一选择器library ieee;use ieee.std_logic_1164.all;entity ls157 isport (a1,a2,a3,a4,b1,b2,b3,b4,g : IN STD_LOGIC;y1,y2,y3,y4 : OUT STD_LOGIC); end;architecture one of ls157 isbeginprocess(g)beginif g='0' theny1<=a1;y2<=a2;y3<=a3;y4<=a4;elsey1<=b1;y2<=b2;y3<=b3;y4<=b4;end if;end process;end architecture one ;实验二74ls04 6一输入非门library ieee;use ieee.std_logic_1164.all;entity ls04 isport (a1,a2,a3,a4,a5,a6 : IN STD_LOGIC;y1,y2,y3,y4,y5,y6 : OUT STD_LOGIC);end;architecture one of ls04 isbeginy1 <= not a1;y2 <= not a2;y3 <= not a3;y4 <= not a4;y5 <= not a5;y6 <= not a6;end architecture one ;实验三74ls08 4二输入与门library ieee;use ieee.std_logic_1164.all;entity ls08 isport (a1,a2,a3,a4,b1,b2,b3,b4 : IN STD_LOGIC;y1,y2,y3,y4 : OUT STD_LOGIC); end;architecture one of ls08 isbeginy1 <= a1 and b1;y2 <= a2 and b2;y3 <= a3 and b3;y4 <= a4 and b4;end architecture one ;实验四74ls10 3三输入与非门library ieee;use ieee.std_logic_1164.all;entity ls10 isport (a1,a2,a3,b1,b2,b3,c1,c2,c3 : IN STD_LOGIC;y1,y2,y3 : OUT STD_LOGIC); end;architecture one of ls10 isbeginy1 <= not (a1 and b1 and c1);y2 <= not (a2 and b2 and c2);y3 <= not (a3 and b3 and c3);end architecture one ;实验五74ls32 4二输入或门library ieee;use ieee.std_logic_1164.all;entity ls32 isport (a1,a2,a3,a4,b1,b2,b3,b4 : IN STD_LOGIC;y1,y2,y3,y4 : OUT STD_LOGIC); end;architecture one of ls32 isbeginy1 <= a1 or b1;y2 <= a2 or b2;y3 <= a3 or b3;y4 <= a4 or b4;end architecture one ;实验六74ls49（TI）四线—七段译码器/驱动器library ieee;use ieee.std_logic_1164.all;entity ls49ti isport ( bi : IN STD_LOGIC;inputs : IN STD_LOGIC_vector(3 downto 0);outputs : OUT STD_LOGIC_vector(6 downto 0)); end;architecture one of ls49ti isbeginprocess(bi,inputs)beginif bi = '1' thencase inputs iswhen "0000" => outputs <= "0111111";when "0001" => outputs <= "0000110";when "0010" => outputs <= "1011011";when "0011" => outputs <= "1001111";when "0100" => outputs <= "1100110";when "0101" => outputs <= "1101101";when "0110" => outputs <= "1111100";when "0111" => outputs <= "0000111";when "1000" => outputs <= "1111111";when "1001" => outputs <= "1100111";when "1010" => outputs <= "1011000";when "1011" => outputs <= "1001100";when "1100" => outputs <= "1100010";when "1101" => outputs <= "1101001";when "1110" => outputs <= "1111000";when "1111" => outputs <= "0000000";when others => null;end case;elsif bi = '0' thenoutputs <= "0000000";end if;end process;end architecture one ;实验七74ls86 4二输入异或门library ieee;use ieee.std_logic_1164.all;entity ls86 isport (a1,a2,a3,a4,b1,b2,b3,b4 : IN STD_LOGIC;y1,y2,y3,y4 : OUT STD_LOGIC); end;architecture one of ls86 isbeginy1 <= a1 xor b1;y2 <= a2 xor b2;y3 <= a3 xor b3;y4 <= a4 xor b4;end architecture one ;实验八74ls138library ieee;use ieee.std_logic_1164.all;entity ls138 isport ( g1,g2 : IN STD_LOGIC;inputs : IN STD_LOGIC_vector(2 downto 0);outputs : OUT STD_LOGIC_vector(7 downto 0)); end;architecture one of ls138 isbeginprocess(g1,g2,inputs)beginif g1 = '1' thenif g2='0' thencase inputs iswhen "000" => outputs <= "01111111";when "001" => outputs <= "10111111";when "010" => outputs <= "11011111";when "011" => outputs <= "11101111";when "100" => outputs <= "11110111";when "101" => outputs <= "11111011";when "110" => outputs <= "11111101";when "111" => outputs <= "11111110";when others => null;end case;elseoutputs <= "11111111";end if;end if;end process;end architecture one ;实验九74ls145TIlibrary ieee;use ieee.std_logic_1164.all;entity ls145ti isport ( inputs : IN STD_LOGIC_vector(3 downto 0);outputs : OUT STD_LOGIC_vector(9 downto 0)); end;architecture one of ls145ti isbeginprocess(inputs)begincase inputs iswhen "0000" => outputs <= "0111111111";when "0001" => outputs <= "1011111111";when "0010" => outputs <= "1101111111";when "0011" => outputs <= "1110111111";when "0100" => outputs <= "1111011111";when "0101" => outputs <= "1111101111";when "0110" => outputs <= "1111110111";when "0111" => outputs <= "1111111011";when "1000" => outputs <= "1111111101";when "1001" => outputs <= "1111111110";when others => null;end case;end process;end architecture one ;实验十74ls373 三态8D锁存器library ieee;use ieee.std_logic_1164.all;entity ls373 isport (oc,c : in std_logic;d : in std_logic_vector(7 downto 0);q : buffer std_logic_vector(7 downto 0)); end;architecture one of ls373 isbeginprocess(c,oc)beginif oc='0' thenif c='1' thenq<=d;elseq<=q;end if;elseq<="ZZZZZZZZ";end if;end process;end architecture one ;。
CPU处理器实验设计实验报告
“计算机设计与实践”处理器实验设计报告目录一：实验目的 (2)二：实验环境 (2)三：设计思想 (2)1、CPU接口信号定义 (2)2、CPU设计方案 (3)四：实验设计及测试 (15)1、各模块设计及测试 (15)波形仿真 (15)2、整体的设计及测试 (19)波形仿真 (19)五：下载 (21)六：遇到的问题及解决方法 (25)七：实验体会 (25)一：实验目的1.掌握Xilinx ISE集成开发环境使用方法2.掌握VHDL语言3.掌握FPGA编程方法及硬件调试手段4.深刻理解处理器结构和计算机系统的整体工作原理二：实验环境Xilinx ISE集成开发环境，ModelSim或ISim仿真工具、COP2000实验平台或SD2100数字逻辑设计实验平台或Diligent Nexys3开发板。
三：设计思想1、C PU接口信号定义2、 C PU 设计方案① 指令格式设计1.2. 其他指令15 11 10 28 7 031511 10 8 7 0②微操作定义③节拍划分④各模块设计a)时钟模块模块示意图：模块功能：产生4个节拍，其中，当rst=1时，节拍跳转到T3，并将pc置0.接口说明：信号名位数方向来源/去向备注Clk1I处理器板系统时钟Rst1I处理器板高电平复位T4O取址，运算，4个节拍存储，回写模块b)取指模块模块示意图：模块功能：从内存取出指令。
Rst=1时，pc置0.取出的IR传送给运算，存储，回写模块提供数据，当IRreq=1时，开始从内存取出指令。
当pcupdate=1时，pc接收pcnew的数据，更新pc。
信号名位数方向来源/去向备注T01I时钟模块第一节拍T11I时钟模块第二节拍Rst1I处理器板高有效复位信号PCupdate1I回写模块PC更新信号PCnew16I回写模块PC更新值IRnew16I存储控制模块IR更新值IRreq1O取址模块IR允许信号IR16O存储控制模块导出IR到其他模块PC16O取址模块PC到运算模块c)运算模块模块示意图：模块功能：进行各种运算，并产生进位信号cy和零信号z。
VHDL试验报告
专用集成电路实验报告1 3 05 0 Z011 3 0 5 024237刘德文实验一开发平台软件安装与认知实验实验内容1、本实验以三线八线译码器(LS74 13 8)为例，在Xi 1 inx ISE 9、2软件平台上完成设计电路得VHDL文本输入、语法检査、编译、仿真、管脚分配与编程下载等操作。
下载芯片选择Xi linx 公司得Co o 1 Runner II系列XC2C25 6-7PQ 2 08作为目标仿真芯片。
2、用1中所设计得得三线八线译码器(LS74138)生成一个LS741 3 8元件，在Xilinx ISE 9。
2软件原理图设计平台上完成LS74 1 38元件得调用,用原理图得方法设计三线八线译码器(LS 7 4138),实现编译，仿真，管脚分配与编程下载等操作。
源程序：1 ibrary IEEE;use IEEE. S T L OGIC.l16 4. ALL;u se IEEEo STD_LOGIC_ARITH. ALL;use IEEE、STD_LOGIC_UNS I GNED。
ALL;-- Unm ent the folio wing lines to us e th e d ecl a r a tions t h at a repro vided for insta n tia t ing X i linx pr i mitive pone nts、——1 让:r ary UNI SIM;----- use UNISIMo VC om p o ne n ts® all;en t i ty 1 s 7 41 3 8 isPo r t ( g 1 : in st d _ I ogic;g2 : i n s td_logic;i n p : i n s t d_ 1 ogic_ve c tor (2 do wnt o 0 );y : out s t d _logic_v e ct o r ( 7 down to 0 ));end 1 s741 3 8;a r ch i t ect u re B e h a v ior a 1 of ls7 4 138 isbegi np ro c ess (gl, g2, i np)beg inif (( g 1 an d g 2 ) = * 1' ) thencase inp i swh e n "0 0 0"=> y〈二” 0 0 0 000 0 1 M ;o when ” 001= y (=' 0 0000 0 10";whe n 〃010"=>y〈 = " 0 0 0 001 0 0 ” ；。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
计算机硬件课程设计设计报告学号：姓名：成绩：学号：姓名：成绩：东南大学计算机科学与工程系二0 10 年12 月目录1.实验名称 (2)2.实验目的 (2)3.实验任务……………………………………………………………………… 2.4.主要特色 (2)5. 设计方案 (3)5.1 数据格式和指令系统 (3)5.2本设计的体系结构 (5)5.测试结果与性能分析 (20)6.课程设计总结 (22)1．实验名称微程序控制的模型计算机的设计与调试2．实验目的1．综合运用“计算机组成原理”和“数字电路”等课程的知识，通过对模型机的设计和调试，加深对计算机各部件工作原理的认识。
2．进一步掌握运用EDA技术进行设计和调试的工作方法。
3．掌握计算机硬件设计的思想，方法及工作过程，进一步培养工程设计的能力。
3．实验任务1．自行规定数据格式和指令格式，在所提供的条件范围内设计一台由微程序控制（也可以用其他方式如组合逻辑等）的模型计算机。
2．根据设计方案，将模型机调试成功。
3．整理出相关文件。
（1）数据格式和指令系统。
（2）总框图。
（3）详细电路图或有关电路的VHDL语言源程序。
（4）微指令格式和微程序。
（5）调试过程和测试结果（包括测试程序）。
4．主要特色1．增加了ROM的宽度，改为24位，使得可以在一个时钟内读出24位的微指令。
2．对电路进行了合理的修改，具体增加了SRC. DEST结合IR0,IR2,IR1,IR3到RA,RB的译码电路。
3．SRC. DEST结合IR0,IR2,IR1,IR3到WA,WB的译码电路，实现了对于源操作数的写入。
4．由微指令到8CPU中对应的端口译码。
5．重新构造了ROM，RAM，修改了时序电路，调整了M1,M2,M3,M4的时序。
6．除了书上要求的指令微程序以外，还对微程序进行了扩充，加了逻辑左移指令：SAL(每次执行左移一位)，以及乘法指令：MUL(8位与8位数据相乘，得到16位数据高8位写回源操作数，低8位写回目的操作数)7．修改了M1,M2,M3,M4的连接电路。
8．通过用软件模拟的方法，成功的构造了一个简单的CPU，更加熟练的学会使用EDA技术。
试验中结合了数字实验和组成原理部分内容。
9．用简单易读的方式排列24位控制信号，使得操作更加简便，如图所示5．设计方案5.1数据格式和指令系统（参考教材）采用8位数据通路，数据采用8位二进制定点表示。
7 6 5 4 3 2 1 0.设置7条机器指令和两条面板操作指令（1）面板操作指令（因为没有一BIOS 及操作系统，所以用面板指令进行初始化，启动机器）a.输入地址为PC置初始值，即输入程序的起始地址，当K1开关置“1”，K2开关置“0”时执行此操作。
b.输入程序将程序输入到内存的指定区域，当K1，K2开关均置“1”时，由面板输入开关输入程序c.本模型机设置K3开关，K3置1表示执行单步操作。
d.START表示启动开关。
（2）指令系统a.指令格式操作码寻址方式7 6 5 4 3 2 1 0有二种寻址方式寄存器寻址操作码R目R源7 6 5 4 3 2 1 0直接地址寻址由于地址要占用一个字节，所以此类指令为双字节指令。
操作码R目R源内存地址b.9条机器指令IN R；从开关输入数据送入到指定的寄存器R。
格式：0 0 0 1 R目0 0OUT R；从指定的寄存器R中取出数据送入到输出缓冲器，显示灯亮。
格式：0 0 1 0 0 0 R源LD R , address ；从内存指定单元取出数据，送入指定的寄存器R。
格式：0 0 1 1 R目0 0内存地址ST address, R; 从指定的寄存器R中取出数据，存入内存指定单元。
格式：0 1 0 0 0 0 R源内存地址ADD R1，R2；将两个寄存器中的数据相加，结果送到R1。
格式：0 1 0 1 R目R源JMP address; 无条件转移，即address PC。
格式：0 1 1 0 0 0 0 0内存地址HALT ；停机指令。
MUL R1，R2；将两个寄存器中的数据相乘，结果高8位送到R1，低8位送到R2。
格式：1 0 1 0 R目R源SAL R；将R中的数据左移一位，结果送到R1。
格式：1 0 0 1 R目5.2本设计的体系结构为了简单方便起见，我们采用单总线结构，总体机构和CPU内部结构设计如图所示总体结构图CPU内部结构1．数据通路设计（1）采用Quartus—II软件工具，先设计出运算器部分，如图所示.ALU.bdf，经时序仿真正确后，进行符号封装。
（2）采用Quartus—II软件工具，先设计出运算器部分，如图所示MUL.bdf，经时序仿真正确后，进行符号封装。
介绍数据通路时打开8CPU.bdf（2）根据指令系统，数据通路中应包括寄存器组，存储器等，采用单总线结构，截图一分为二（1）（2）其中为了做乘法，我们对8cpu加了6个控制信号，如图所示2．控制器设计（1）控制器总框图.控制信号（2）微指令格式和微命令首先对数据通路进行分析，需要22个控制信号。
此外还要2个信号：UPC （表示一段微程序结束），HALT（停机），共需要24个控制信号。
采用水平型格式表示。
控制数据通路的16个信号说明如下：G1，G2，G3，G4ramormul，cmul 分别控制6个多路开关A，B，C，D，EO，P，Q 分别控制对应的寄存器输入F 控制计数器PC的输入和计数I 控制指令寄存器的输入DEST 目的寄存器的读出控制信号SRC 源寄存器的读出控制信号WE 对RAM的写入信号GWN 通用寄存器组的写入信号LDN PC置初值的控制信号SRCWE 源或目的寄存器的写入信号（3）控存的安排和时序信号本方案采用的时序控制信号是由74393b产生的。
对于时序，本来是有六个时钟周期的，我们将其缩短在了四个，有效的提高了运行效率。
修改后的时序电路图时序脉冲（4）微地址入口电路的设计为简单起见，微地址采用8位，其高4位由指令操作码控制，低4位由一个4位的计数器控制。
将ROM的高段地址区用于存放面板指令的微程序，低段地址存储区存放一般指令的微程序，控制电路可参考图6。
图3-6 微地址入口电路（5）微命令译码电路a.本方案中寄存器组采用的是74670芯片，每次写入可以为源寄存器，也可以为目的寄存器，所以Wa,Wb要经过译码与IR2，IR3连接，读出时目的和源寄存器均可读出，所以依然要用译码电路。
电路设计如下：写寄存器译码电路读寄存器译码电路b.停机电路以下几种情况需停机：（a）总清. (b) 执行单指令操作，且一条指令执行完。
(c) 执行停机指令。
根据这三种情况可以设计出停机电路。
c.UPC微命令表示一段微程序结束，因此该命令要做的工作是：（a）置“0”微程序计数器（74161）。
（b）置“0”指令寄存器。
3．微程序和总电路图微程序定义如下：8cpu中的端口译码电路如下：Rom修改为24位，修改电路如下：24位重新排列微指令顺序8CPU重新封装效果图CPU总的电路图：（截成四部分）时序及upc产生部分8cpu及寄存器读写译码部分控制信号译码部分Rom及取微指令部分、6．测试结果与性能分析（测试程序、时序图、编译报告中资源使用情况）仿真：微程序和电路设计完成后，进行编译，并通过仿真来检验cup的各项功能。
仿真时，先用面板指令输入程序的起始地址和一段小程序。
我们输入的程序为：初始地址为00H，即Ram中程序如下：进行仿真，首先开关K1置1，K2置0，kdata为00H，为PC置初始值00即程序口地址，接着将K1置0，执行程序。
此时，我们置kdata始终为02H，通过IN指令输入到R0和R1中，然后继续执行程序！建立vwf文件如下:仿真结果如下:7．课程设计总结本实验是设计一个小型CPU，主要工作是在给定的CUP主体结构上完善电路，修正已有电路错误以及设计微程序。
本实验有相当的综合性：在实践过程中，我们充分使用了组成原理、微机接口、数字电路等相关知识。
通过本次实验，我们对CPU的结构和工作原理有了切实的认识。
尤其在总线，时序，微指令等方面，投入的时间不少，体会很深。
我们深刻理解了总线作为指令和数据传输的道路和桥梁，在CUP的工作过程中扮演的重要角色；弄懂了通过时序的调节解决总线的冲突的方法；在全面细致地分析了CUP结构和工作原理的基础上，我们掌握了编写微指令的方法与技巧。
通过组内讨论和求教于老师、同学，我们顺利的完成了基本的实验目标，并做了进一步研究。
利用加法指令，我们增加了SAL（左移一位）指令。
采用控制RA、RB读信号的控制思路，我们使得源、目的寄存器均可写入。
在此基础上，我们引入了8位乘法器，将结果——16位二进制数，成功写入源、目的寄存器。
对现有的24位控制信号，我们充分利用了每一位。
同时，我们注意到实验中还有很多可以改进的地方。
由于时间和给定CPU规格的限定，很多想法未能实施。
比如，编写微指令时，我们注意到：一条指令中的某条指令在M3时已经完成，空等一个M4，才取下一条。
这样的情况并不少见。
如果将执行微指令、取微指令等改为下降沿也能触发，就可以把下一条提到M4做，这就省了一个整个指令周期。
宏观的时间节省量自然也十分可观。
再如，实验提供的ROM为24位，这使得控制信号剩余不多，一旦想多加其它组件，就会为之苦恼。
我们想到自取名为“多面手控制信号”的解决方案：对于互斥的两条指令A和B（如ADD和MUL（肯定不会同时做）），可以根据需要，让A的控制型号同时控制B，所需做的额外工作是修改ROM中的微指令即可。
比起想法设法地扩展ROM，这种方法既快速，又充分利用资源。
实验提供的CPU中有不少这样的控制信号，值得好好利用。
当然，缺点也显而易见，由于控制信号一对多，修改、删除时得慎之再慎，增加了CUP维护的难度。
总之，通过本次实验，我们体会了学以致用的快乐，为进一步的深入的学习增添了几分信心。