计组课设maxplus2

于 2024-07-13 12:36:11 发布
阅读量343 收藏 12
点赞数 11
文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fly11127/article/details/140395371
版权

目录

一、课设题目

二、系统的总体设计

2.1 嵌入式 CISC 模型机的数据通路框图

2.2 系统的操作控制器的逻辑框图

2.3  设计机器指令格式和指令系统

2.3.1机器指令格式和指令系统

2.3.2对Rs和Rd格式规定

2.3.3算数逻辑单元ALU的功能表

2.3.4程序计数器PC的功能表

2.3.5时序产生器

2.3.6数据格式

三、微程序控制器的设计全过程

3.1微程序控制器的设计

3.2地址转移逻辑电路的设计

 3.3汇编语言程序

3.4机器语言源程序

3.5微程序流程图如下所示：

3.6微指令的设计

四、MAX_PLUS2仿真软件清单

TOP.GDF

1.ALU

2.PSW

 3.LS273(即R0,R1,R2,R3等)

 4.PC

 5.ROM

 6.IR

7.RAM

 8.DECODER

 9.COUNTER

 10.CONVERT

11.FEN2

12.MUX3_1

13.MUX3_2

14.MUX4

 15.CROM.GDF

16.CONTROM

 17.CROM_F1

 18.CROM_F2

 19.CROM_F3

20.ADDR

 21.MCOMMAND

 22.AAA.GDF

23.MMM

一、课设题目

         设计一台嵌入式 CISC 模型计算机或嵌入式 RISC模型计算机(采用定长 CPU 周期或变
长 CPU周期)，并运行能完成一定功能的机器语言程序进行验证，输入包含十个整数（无符号数）的数组 M，按从小到大的顺序输 出这十个整数。

二、系统的总体设计

2.1 嵌入式 CISC 模型机的数据通路框图

图 1 嵌入式 CISC 模型机的数据通路框图

2.2 系统的操作控制器的逻辑框图

图 2 系统的操作控制器的逻辑框图

2.3  设计机器指令格式和指令系统

        为了完成这次课程设计的功能，本次设计设计了10条指令：LAD(将源寄存器所指向的地址单元中的数送入目的寄存器)，STO1(将源寄存器中的数据存储到目的寄存器所指向的地址单元)，MOV（将一个立即数数送入寄存器），INC(自加1)，DEC（自减1），JMP（无条件跳转），CMP（将目的寄存器和源寄存器所指向的地址单元中的数据进行比较）IN1（输入），JNS（大于跳转），OUT1（输出），如下用到的Rs和Rd分别表示源寄存器和目的寄存器。下表列出了每条指令的格式、汇编符号和指令功能。

2.3.1机器指令格式和指令系统

指令助记符

指令格式

功能

15-12

11-10

9-8

7-0

STO1 Rs (Rd)

0001

Rs

Rd

XXXXXXX

(Rs)->((Rd))

LAD (RS) Rd

0010

Rs

Rd

XXXXXXX

((Rs))->Rd

MOV imm Rd

0011

XX

Rd

imm

(imm)->Rd

INC Rd

0100

XX

Rd

XXXXXXX

(Rd)+1->Rd,锁存SF,ZF

DEC Rd

0101

XX

Rd

XXXXXXX

(Rd)-1->Rd,锁存SF,ZF

JMP addr

0110

XX

XX

addr

addr->PC

CMP Rs Rd

0111

Rs

Rd

XXXXXXX

(Rs)-(Rd)

JB addr

1000

XX

XX

addr

小于跳转，addr->PC

IN1 Rd

1001

XX

Rd

XXXXXXX

输入->Rd

OUT1 Rs

1010

Rs

XX

XXXXXXX

Rs->输出

2.3.2对Rs和Rd格式规定

Rs或Rd

选定的寄存器

0

R0

1

R1

10

R2

11

R3

2.3.3算数逻辑单元ALU的功能表

S2

S1

S0

功能

0

0

0

X+Y，修改SF和ZF

0

0

1

X-Y,修改SF和ZF

0

1

0

Y+1,修改SF和ZF

0

1

1

Y-1,修改SF和ZF

1

0

0

X∧Y,修改SF和ZF

1

0

1

X∨Y,修改SF和ZF

1

1

0

Y

2.3.4程序计数器PC的功能表

CLR

LOAD

LDPC

功能

0

X

X

将PC清0

1

0

↑

BUS-->PC

1

1

0

不装入，也不计数

1

1

↑

PC+1

2.3.5时序产生器

        本实验采用的是微程序控制器的时序产生器，如下图       

图3 微程序控制器的时序关系图

2.3.6数据格式

模型机规定数据的为无符号整数，且字长为8位，其格式如下：

7

6

5

4

3

2

1

0

数据

三、微程序控制器的设计全过程

3.1微程序控制器的设计

微程序控制器的设计包括以下几个阶段：

（1）根据微处理器结构图、指令格式和功能设计所有机器指令的微程序流程图，并确定每条微指令的微地址和后继微地址；

（2）设计微指令格式和微指令代码表；

（3）设计地址转移逻辑电路；

（4）设计微程序控制器中的其它逻辑单元电路，包括微地址寄存器、微命令寄存器和控制存储器；

（5）设计微程序控制器的顶层电路（由多个模块组成）。

3.2地址转移逻辑电路的设计

        地址转移逻辑电路是根据微程序流程图中的棱形框部分及多个分支微地址，利用微地址寄存器的异步置“1”端，实现微地址的多路转移。由于微地址寄存器中的触发器异步置“1”端低电平有效，与µA5～µA0对应的异步置“1”控制信号SE5～SE0的逻辑表达式为：

 3.3汇编语言程序

本题目为：输入包含10个整数（无符号数）的数组M，按从小到大的顺序输出这十个整数。

冒泡排序：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。

算法思想: 输入10个数,用R0存放最外层的循环次数,R1存放地址,R2和R3存放比较的两个数,从对应的R1的地址读入.R3存放大的数.如果有更大的数,则交换.最后下沉的就为一个最大的数.然后自减R0.进入下次循环.到循环结束.

汇编程序源码及对应注释如下：

//* 输入10个数 */
MOV  0AH  R0              //设置循环值10
MOV  00H   R1             //设置RAM的初始地址00
L1:  IN1	R2            //从开关输入任意一个整数到R2
STO1	R2	(R1)          //将R2存入地址为R1的RAM单元中
INC   R1                  //自增R1
CMP 	R1	 R0           //比较R1,R0的大小，R1小于R0跳转L1
JB	L1
//* 冒泡排序 */
MOV  0AH	R0            //设置外循环值为10
MOV  00H	R1            //设置RAM的初始地址00
L2:  LAD 	(R1)   R2     //取地址为R1的RAM内容到R2
INC	 R1                   //自增R1
CMP  R1    R0             //比较R0,R1的大小，R1>R0跳转L4
JB    L4                 
LAD  (R1)  R3             //取地址为R1的RAM内容到R3
CMP  R2    R3             //比较R3,R2的大小，R3小于R2跳转L3
JB  L3
JMP	 L2                   //无条件跳转L2
//* 交换两个数 */
L3:	STO1	R2  (R1)      //将R2存入地址为R1的RAM单元中
DEC   R1                  //自减R1
STO1  R3  (R1)            //将R3存入地址为R1的RAM单元中
INC   R1                  //自增R1
JMP  L2                   //无条件跳转L2
L4:  DEC   R0             //循环值自减1
MOV  00H   R1             //设置R1的值为0
CMP  R0	 R1               //比较R1和R0的大小，R1小于R0跳转L2
JB  L2
//* 输出 */
MOV	 0AH  R0               //设置循环值10
MOV	 00H  R1               //设置RAM的初始地址00
L5:  LAD  (R1)  R2         //取地址为R1的RAM内容到R2
INC		R1                 //自增R1
OUT1	 R2                //输出R2到LED

CMP		R0	 R1            //比较R1和R0的大小，R1小于R0跳转L5
JB 	L5
L6:  OUT1	 R2            //输出R2到LED
JMP L6                     //持续输出

3.4机器语言源程序

根据指令格式将汇编语言源程序手工汇编成机器代码如下表：

地址

汇编语言源程序

机器语言源程序

机器语言源程序

（十六进制）

（二进制）

（十六进制）

00

MOV  0AH  R0

0011 00 00 0000 1010

300A

01

MOV  00H   R1  

0011 00 01 0000 0000

3100

02

L1:  IN1   R2

1001 00 10 0000 0000

9200

03

STO1   R2   (R1)

0001 10 01 0000 0000

1900

04

INC   R1

0100 00 01 0000 0000

4100

05

CMP  R1  R0

0111 01 00 0000 0000

7400

06

JNS     L1

1000 00 00 0000 0010

8002

07

MOV  0AH   R0

0011 00 00 0000 1010

300A

08

MOV  00H   R1

0011 00 01 0000 0000

3100

09

L2:  LAD    (R1)   R2

0010 01 10 0000 0000

2600

0A

INC   R1

0100 00 01 0000 0000

4100

0B

CMP  R0    R1

0111 00 01 0000 0000

7100

0C

JB    L4

1000 00 00 0001 0110

8016

0D

LAD    (R1)    R3

0010 01 11 0000 0000

2700

0E

CMP     R3     R2

0111 11 10 0000 0000

7E00

0F

JB   L3

1000 00 00 0001 0001

8011

10

JMP   L2

0110 00 00 0000 1001

6009

11

L3: STO1    R2    (R1)

0001 10 01 0000 0000

1900

12

DEC   R1

0101 00 01 0000 0000

5100

13

STO1   R3   (R1)

0001 11 01 0000 0000

1000

14

INC   R1

0100 00 01 0000 0000

4100

15

JMP  L2

0110 00 00 1000 1001

6089

16

L4:  DEC   R0  

0101 00 00 0000 0000

5000

17

MOV  00H   R1

0011 00 00 0000 0000

3100

18

CMP  R1   R0

0111 01 00 0000 0000

7400

19

JB  L2

1000 00 00 0000 1001

8009

1A

MOV    0AH    R0  

0011 00 00 0000 1010

300A

1B

MOV   00H   R1   

0011 00 01 0000 0000

3100

1C

L5:  LAD   (R1)   R2

0010 01 10 0000 0000

2600

1D

INC     R1

0100 00 01 0000 0000

4100

1E

OUT1    R2

1010 10 00 0000 0000

A800

1F

CMP    R1    R0

0111 01 00 0000 0000

7400

20

JB   L5

1000 00 00 0001 1100

801C

21

L6:  OUT1     R2

1010 10 00 0000 0000

A800

22

JMP    L6

0110 00 00 0010 0001

6021

3.5微程序流程图如下所示：

图 4 微程序流程图标题

3.6微指令的设计

         CISC模型机系统使用的微指令采用全水平型微指令，字长位26位，其中微命令字段位18位，P字段2位，后继微地址为6位。

微地址LOADLDPCLDARLIRLREGLPSWRS_BS2S1S0ALU_BSW_BLED_BRD_DCS_DRAM_BCS_IADR_BP1P2uA5~uA0
0011010010001111110110000000
sto1 0110100011100111111100001011
lad 0210100000001111111100001100
mov0310001010001111111000000000
inc0410001110100111111100000000
dec0510001110110111111100000000
jmp0601000010001111111000000000
cmp071000011001111111100000000
jb空格0810000010001111111101000000
in10910001010001011111100000000
out10A10000000001101111100000000
sto 第2步0B10000000001110011100000000
lad 第2步0C10001010001111001100000000
jns 第2步1001000010001111111000000000
有效1111110S2S1S000000000p1p2

四、MAX_PLUS2仿真软件清单

TOP.GDF

1.ALU

LIBRARY IEEE;                                          
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_ARITH.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;

ENTITY ALU IS
PORT(
     X: IN STD_LOGIC_VECTOR(7 DOWNTO 0);
     Y: IN STD_LOGIC_VECTOR(7 DOWNTO 0);
     S2,S1,S0: IN STD_LOGIC;
     ALUOUT: OUT STD_LOGIC_VECTOR(7 DOWNTO 0) ;
     CF,ZF: OUT STD_LOGIC
    );
END ALU;

ARCHITECTURE A OF ALU IS
SIGNAL AA,BB,TEMP:STD_LOGIC_VECTOR(8 DOWNTO 0);
SIGNAL TEMP1:STD_LOGIC_VECTOR(7 DOWNTO 0);
BEGIN 
    PROCESS
    BEGIN 
        IF(S2='0' AND S1='0' AND S0='0') THEN	--ADD
            AA<='0'&X;
            BB<='0'&Y;
            TEMP<=AA+BB;
            ALUOUT<=TEMP(7 DOWNTO 0);
            CF<=TEMP(8);
            IF (TEMP="100000000" OR TEMP="000000000") THEN
                ZF<='1';
            ELSE
                ZF<='0';
            END IF;
        ELSIF(S2='0' AND S1='0' AND S0='1') THEN    --CMP(SUB)
            ALUOUT<=X-Y;
            IF(X<Y) THEN
               CF<='1';
               ZF<='0';
            ELSIF(X=Y) THEN
               CF<='0';
               ZF<='1';
            ELSE 
               CF<='0';
               ZF<='0';
            END IF;
      ELSIF(S2='0' AND S1='1' AND S0='0') THEN     --INC
            AA<='0'&Y;
            TEMP<=AA+1;
            ALUOUT<=TEMP(7 DOWNTO 0);
            CF<=TEMP(8);
            IF (TEMP="100000000") THEN
                ZF<='1';
            ELSE
                ZF<='0';
            END IF;
       ELSIF(S2='0' AND S1='1' AND S0='1') THEN     --DEC
            AA<='0'&Y;
            TEMP<=AA-1;
            ALUOUT<=TEMP(7 DOWNTO 0);
            CF<=TEMP(8);
            IF (TEMP="000000000") THEN
                ZF<='1';
            ELSE
                ZF<='0';
            END IF;

        ELSIF(S2='1' AND S1='0' AND S0='0') THEN     --AND
            TEMP1<=X AND Y;
            ALUOUT<=TEMP1;
            CF<='0';
            IF (TEMP1="00000000") THEN
                ZF<='1';
            ELSE
                ZF<='0';
            END IF;
        ELSIF(S2='1' AND S1='0' AND S0='1') THEN     --OR
            TEMP1<=X OR Y;
            ALUOUT<=TEMP1;
            CF<='0';
            IF (TEMP1="00000000") THEN
                ZF<='1';
            ELSE
                ZF<='0';
            END IF;
        ELSIF(S2='1' AND S1='1' AND S0='0') THEN     --Rd->BUS
            ALUOUT<=Y;
        ELSE
            ALUOUT<="00000000" ;
            CF<='0';
            ZF<='0';
        END IF;
    END PROCESS;
END A;

2.PSW

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY PSW IS
PORT(
    C,Z:IN STD_LOGIC;
    LDPSW:IN STD_LOGIC;
    CF,ZF:OUT STD_LOGIC
    );
END PSW;

ARCHITECTURE A OF PSW IS
BEGIN
    PROCESS(LDPSW)
    BEGIN
        IF(LDPSW'EVENT AND LDPSW='1')THEN
            CF<=C;
            ZF<=Z;
        END IF;
    END PROCESS;
END A;

 3.LS273(即R0,R1,R2,R3等)

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY LS273 IS
PORT(
    D:IN STD_LOGIC_VECTOR(7 DOWNTO 0);
    CLK:IN STD_LOGIC;
    O:OUT STD_LOGIC_VECTOR(7 DOWNTO 0)
    );
END LS273;
ARCHITECTURE A OF LS273 IS
BEGIN
       PROCESS(CLK)
       BEGIN
          IF(CLK'EVENT AND CLK='1')THEN
            O<=D;
          END IF;
      END PROCESS;
END A ;

 4.PC

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_ARITH.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;
ENTITY PC IS
PORT(
    LOAD,LDPC,CLR:IN STD_LOGIC;
    D:IN STD_LOGIC_VECTOR(7 DOWNTO 0);
    O:OUT STD_LOGIC_VECTOR(7 DOWNTO 0)
    );
END PC;
ARCHITECTURE A OF PC IS
SIGNAL QOUT:STD_LOGIC_VECTOR(7 DOWNTO 0);
BEGIN
    PROCESS(LDPC,CLR,LOAD)
	BEGIN
    	IF(CLR='0')THEN
    		QOUT<="00000000";
		ELSIF(LDPC'EVENT AND LDPC='1')THEN
			IF(LOAD='0')THEN
    			QOUT<=D;
			ELSE
    			QOUT<=QOUT+1;
			END IF;
		END IF;
	END PROCESS;
O<=QOUT;
END A;

 5.ROM

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_ARITH.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;
ENTITY ROM IS
PORT(
   DOUT:OUT STD_LOGIC_VECTOR(15 DOWNTO 0);
   ADDR:IN STD_LOGIC_VECTOR(7 DOWNTO 0);
   CS_I:IN STD_LOGIC
   );
END ROM ;

ARCHITECTURE A OF ROM IS
BEGIN
DOUT<=
	"0011000000001010" WHEN ADDR="00000000" AND CS_I='0' ELSE
	"0011000100000000" WHEN ADDR="00000001" AND CS_I='0' ELSE
	"1001001000000000" WHEN ADDR="00000010" AND CS_I='0' ELSE
	"0001100100000000" WHEN ADDR="00000011" AND CS_I='0' ELSE
	"0100000100000000" WHEN ADDR="00000100" AND CS_I='0' ELSE
	"0111010000000000" WHEN ADDR="00000101" AND CS_I='0' ELSE
	"1000000000000010" WHEN ADDR="00000110" AND CS_I='0' ELSE
	"0011000000001010" WHEN ADDR="00000111" AND CS_I='0' ELSE
	"0011000100000000" WHEN ADDR="00001000" AND CS_I='0' ELSE
	"0010011000000000" WHEN ADDR="00001001" AND CS_I='0' ELSE
	"0100000100000000" WHEN ADDR="00001010" AND CS_I='0' ELSE
	"0111000100000000" WHEN ADDR="00001011" AND CS_I='0' ELSE
	"1000000000010110" WHEN ADDR="00001100" AND CS_I='0' ELSE
	"0010011100000000" WHEN ADDR="00001101" AND CS_I='0' ELSE
	"0111111000000000" WHEN ADDR="00001110" AND CS_I='0' ELSE
	"1000000000010001" WHEN ADDR="00001111" AND CS_I='0' ELSE
	"0110000000001001" WHEN ADDR="00010000" AND CS_I='0' ELSE
	"0001100100000000" WHEN ADDR="00010001" AND CS_I='0' ELSE
	"0101000100000000" WHEN ADDR="00010010" AND CS_I='0' ELSE
	"0001110100000000" WHEN ADDR="00010011" AND CS_I='0' ELSE
	"0100000100000000" WHEN ADDR="00010100" AND CS_I='0' ELSE
	"0110000000001001" WHEN ADDR="00010101" AND CS_I='0' ELSE
	"0101000000000000" WHEN ADDR="00010110" AND CS_I='0' ELSE
	"0011000100000000" WHEN ADDR="00010111" AND CS_I='0' ELSE
	"0111010000000000" WHEN ADDR="00011000" AND CS_I='0' ELSE
	"1000000000001001" WHEN ADDR="00011001" AND CS_I='0' ELSE
	"0011000000001011" WHEN ADDR="00011010" AND CS_I='0' ELSE
	"0011000100000000" WHEN ADDR="00011011" AND CS_I='0' ELSE
	"0010011000000000" WHEN ADDR="00011100" AND CS_I='0' ELSE
	"0100000100000000" WHEN ADDR="00011101" AND CS_I='0' ELSE
	"1010100000000000" WHEN ADDR="00011110" AND CS_I='0' ELSE
	"0111010000000000" WHEN ADDR="00011111" AND CS_I='0' ELSE
	"1000000000011100" WHEN ADDR="00100000" AND CS_I='0' ELSE
	"1010100000000000" WHEN ADDR="00100001" AND CS_I='0' ELSE
	"0110000000100001" WHEN ADDR="00100010" AND CS_I='0' ELSE
	"0000000000000000";
END A;

 6.IR

 

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY IR IS
PORT(
    D:IN STD_LOGIC_VECTOR(15 DOWNTO 0);
    CLK:IN STD_LOGIC;
    O:OUT STD_LOGIC_VECTOR(15 DOWNTO 0)
    );
END IR;
ARCHITECTURE A OF IR IS
BEGIN
    PROCESS(CLK)
    BEGIN
        IF(CLK'EVENT AND CLK='1')THEN
            O<=D;
        END IF;
    END PROCESS;
END A;

7.RAM

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_ARITH.ALL;
USE IEEE.STD_LOGIC_SIGNED.ALL;
ENTITY RAM IS
PORT(
     RD_D,CS_D:IN STD_LOGIC;
     DIN:IN STD_LOGIC_VECTOR(7 DOWNTO 0);
 	 ADDR:IN STD_LOGIC_VECTOR(7 DOWNTO 0);
	 DOUT:OUT STD_LOGIC_VECTOR(7 DOWNTO 0)
	);
END RAM;
ARCHITECTURE A OF RAM IS
TYPE MEMORY IS ARRAY(0 TO 31) OF STD_LOGIC_VECTOR(7 DOWNTO 0);
BEGIN
   PROCESS(CS_D)
   VARIABLE MEM:MEMORY;
   BEGIN
      IF(CS_D'EVENT AND CS_D='0') THEN
	      IF(RD_D='0') THEN												--?RAM
			  MEM(CONV_INTEGER(ADDR(4 DOWNTO 0))):=DIN;
          ELSE															--?RAM
			 DOUT<=MEM(CONV_INTEGER(ADDR(4 DOWNTO 0)));
          END IF;
      END IF;
  END PROCESS;
END A;

 8.DECODER

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY DECODER IS
PORT(
    I9,I8:IN STD_LOGIC;
    Y0,Y1,Y2,Y3:OUT STD_LOGIC
    );
END DECODER;
ARCHITECTURE A OF DECODER IS
BEGIN
    PROCESS(I9,I8)
    BEGIN
        IF(I9='0' AND I8='0')THEN
            Y0<='1';
            Y1<='0';
            Y2<='0';
            Y3<='0';
        ELSIF(I9='0' AND I8='1')THEN
            Y0<='0';
            Y1<='1';
            Y2<='0';
            Y3<='0';
        ELSIF(I9='1' AND I8='0')THEN
            Y0<='0';
            Y1<='0';
            Y2<='1';
            Y3<='0';
        ELSE
            Y0<='0';
            Y1<='0';
            Y2<='0';
            Y3<='1';
        END IF;
    END PROCESS;
END A;

 9.COUNTER

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_ARITH.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;
ENTITY COUNTER IS
PORT(
     CLK,CLR: IN STD_LOGIC;
     T2,T3,T4: OUT STD_LOGIC
    );
END COUNTER;

ARCHITECTURE A OF COUNTER IS
SIGNAL X:STD_LOGIC_VECTOR(1 DOWNTO 0):="00";
BEGIN
     PROCESS(CLK,CLR)
     BEGIN
          IF(CLR='0') THEN
               T2<='0';
               T3<='0';
               T4<='0';
               X<="00";
          ELSIF(CLK'EVENT AND CLK='1') THEN
               X<=X+1;
               T2<=(NOT X(1))AND X(0);
               T3<=X(1) AND(NOT X(0));
               T4<=X(1) AND X(0);
          END IF;
     END PROCESS;
END A;

 10.CONVERT

 

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY CONVERT IS
PORT(
  IRCODE:IN STD_LOGIC_VECTOR(15 DOWNTO 0);
OP:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
I11,I10,I9,I8:OUT STD_LOGIC;
A:OUT STD_LOGIC_VECTOR(7 DOWNTO 0)
);
END CONVERT;
ARCHITECTURE A OF CONVERT IS
BEGIN
   OP<=IRCODE(15 DOWNTO 12);
   I11<=IRCODE(11);
   I10<=IRCODE(10);
   I9<=IRCODE(9);
   I8<=IRCODE(8);
   A<=IRCODE(7 DOWNTO 0);
END A;

11.FEN2

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY FEN2 IS
PORT(
	LED_B:IN STD_LOGIC;
	DBUS:IN STD_LOGIC_VECTOR(7 DOWNTO 0);
	FENOUT,OUTBUS:OUT STD_LOGIC_VECTOR(7 DOWNTO 0)
);
END FEN2;

ARCHITECTURE A OF FEN2 IS
BEGIN
    PROCESS
     BEGIN 
       IF(LED_B='0') THEN     			
            OUTBUS<=DBUS; 
	   ELSE 
	        FENOUT<=DBUS; 
	   END IF;
    END PROCESS;
END A;

12.MUX3_1

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY MUX3_1 IS
PORT(
	INBUS,RAMOUT,FEN2OUT:IN STD_LOGIC_VECTOR(7 DOWNTO 0);
	SW_B,RAM_B:IN STD_LOGIC;
	DBUS:OUT STD_LOGIC_VECTOR(7 DOWNTO 0)
);
END MUX3_1;

ARCHITECTURE A OF MUX3_1 IS
BEGIN
    PROCESS
     BEGIN 
       IF(SW_B='0') THEN     			
            DBUS<=INBUS;
	   ELSIF(RAM_B='0')THEN 
			DBUS<=RAMOUT;			
	   ELSE
			DBUS<=FEN2OUT;
		END IF;
    END PROCESS;
END A;

13.MUX3_2

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY MUX3_2 IS
PORT(
     ALUOUT,RSOUT,AOUT:IN STD_LOGIC_VECTOR(7 DOWNTO 0);
     ALU_B,RS_B,ADDR_B:IN STD_LOGIC;
     DBUS:OUT STD_LOGIC_VECTOR(7 DOWNTO 0)
	 );
END MUX3_2;
ARCHITECTURE A OF MUX3_2 IS
BEGIN
   PROCESS
   BEGIN
      IF(ALU_B='0') THEN
          DBUS<=ALUOUT;
      ELSIF(RS_B='0') THEN
          DBUS<=RSOUT;
      ELSIF(ADDR_B='0') THEN
          DBUS<=AOUT;
      ELSE
	      DBUS<="00000000";
      END IF;
  END PROCESS;
END A;

14.MUX4

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY MUX4 IS
PORT(
	A,B:IN STD_LOGIC;
	X0,X1,X2,X3:IN STD_LOGIC_VECTOR(7 DOWNTO 0);
	W:OUT STD_LOGIC_VECTOR(7 DOWNTO 0)
);
END MUX4;
ARCHITECTURE A OF MUX4 IS
BEGIN
	PROCESS
	BEGIN
		IF(A='0'AND B='0')THEN
			W<=X0;
		ELSIF(A='0'AND B='1')THEN
			W<=X1;
		ELSIF(A='1'AND B='0')THEN
			W<=X2;
		ELSE
			W<=X3;
		END IF;
	END PROCESS;
END A;

 15.CROM.GDF

 

16.CONTROM

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_ARITH.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;
ENTITY CONTROM IS
PORT(
     ADDR:IN STD_LOGIC_VECTOR(5 DOWNTO 0);
     UA:OUT STD_LOGIC_VECTOR(5 DOWNTO 0);
     D:OUT STD_LOGIC_VECTOR(19 DOWNTO 0)
   );
END CONTROM;
ARCHITECTURE A OF CONTROM IS
SIGNAL DATAOUT:STD_LOGIC_VECTOR(25 DOWNTO 0);
BEGIN
    PROCESS(ADDR)
     BEGIN
       CASE ADDR IS
		WHEN "000000"=>DATAOUT<="11010010001111110110000000";
		WHEN "000001"=>DATAOUT<="10100011100111111100001011";
		WHEN "000010"=>DATAOUT<="10100000001111111100001100";
		WHEN "000011"=>DATAOUT<="10001010001111111000000000";
		WHEN "000100"=>DATAOUT<="10001110100111111100000000";
		WHEN "000101"=>DATAOUT<="10001110110111111100000000";
		WHEN "000110"=>DATAOUT<="01000010001111111000000000";
		WHEN "000111"=>DATAOUT<="10000110011111111100000000";
		WHEN "001000"=>DATAOUT<="10000010001111111101000000";
		WHEN "001001"=>DATAOUT<="10001010001011111100000000";
		WHEN "001010"=>DATAOUT<="10000000001101111100000000";
		WHEN "001011"=>DATAOUT<="10000000001111001100000000";
		WHEN "001100"=>DATAOUT<="10001010001110011100000000";
		WHEN "010000"=>DATAOUT<="01000010001111111000000000";
		WHEN OTHERS=>NULL;                      
   	   END CASE;
   UA(5 DOWNTO 0)<=DATAOUT(5 DOWNTO 0);
   D(19 DOWNTO 0)<=DATAOUT(25 DOWNTO 6);
  END PROCESS;
END A;

 17.CROM_F1

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY CROM_F1 IS
PORT(
    UA5,UA4,UA3,UA2,UA1,UA0:IN STD_LOGIC;
    D:OUT STD_LOGIC_VECTOR(5 DOWNTO 0)
    );
END CROM_F1;
ARCHITECTURE A OF CROM_F1 IS
BEGIN 
     D(5)<=UA5;
     D(4)<=UA4;
     D(3)<=UA3;
     D(2)<=UA2;
     D(1)<=UA1;
     D(0)<=UA0;
END A;

 18.CROM_F2

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY CROM_F2 IS
PORT(
    D:IN STD_LOGIC_VECTOR(5 DOWNTO 0);
    UA5,UA4,UA3,UA2,UA1,UA0:OUT STD_LOGIC
    );
END CROM_F2;
ARCHITECTURE A OF CROM_F2 IS
BEGIN
     UA5<=D(5);
     UA4<=D(4);
     UA3<=D(3);
     UA2<=D(2);
     UA1<=D(1);
     UA0<=D(0);
END A;

 19.CROM_F3

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY CROM_F3 IS 
PORT(
    D:IN STD_LOGIC_VECTOR(3 DOWNTO 0);
    UA3,UA2,UA1,UA0: OUT STD_LOGIC
    );
END CROM_F3;
ARCHITECTURE A OF CROM_F3 IS
BEGIN
    UA3<=D(3);
    UA2<=D(2);
    UA1<=D(1);
    UA0<=D(0);
END A;

20.ADDR

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY ADDR IS
PORT(
    I15,I14,I13,I12:IN STD_LOGIC;
    CF,ZF,T4,P1,P2:IN STD_LOGIC;
    SE5,SE4,SE3,SE2,SE1,SE0:OUT STD_LOGIC
    );
END ADDR;
ARCHITECTURE A OF ADDR IS
BEGIN
    SE5<='1';
    SE4<=NOT((NOT ZF) AND CF AND P2 AND T4);
    SE3<=NOT(I15 AND P1 AND T4);
    SE2<=NOT(I14 AND P1 AND T4);
    SE1<=NOT(I13 AND P1 AND T4);
    SE0<=NOT(I12 AND P1 AND T4);
END A;

 21.MCOMMAND

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_ARITH.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;
ENTITY MCOMMAND IS
PORT(
     T2,T3,T4:IN STD_LOGIC;
     D:IN STD_LOGIC_VECTOR(19 DOWNTO 0);
    P1,P2,LOAD,LDPC,LDAR,LDIR,LDRI,LDPSW,RS_B,S2,S1,S0,
ALU_B,SW_B,LED_B,RD_D,CS_D,RAM_B,CS_I,ADDR_B:OUT STD_LOGIC 
    );
END  MCOMMAND;
ARCHITECTURE A OF MCOMMAND IS
SIGNAL DATAOUT:STD_LOGIC_VECTOR(19 DOWNTO 0);
BEGIN
PROCESS(T2)
    BEGIN
        IF(T2'EVENT AND T2='1') THEN
           DATAOUT(19 DOWNTO 0)<=D(19 DOWNTO 0);
        END IF;
        LOAD<=DATAOUT(19);
        LDPC<=DATAOUT(18) AND T4;
        LDAR<=DATAOUT(17) AND T3;
        LDIR<=DATAOUT(16) AND T3;
        LDRI<=DATAOUT(15) AND T4;
        LDPSW<=DATAOUT(14) AND T4;
        RS_B<=DATAOUT(13);
        S2<=DATAOUT(12);
        S1<=DATAOUT(11);
        S0<=DATAOUT(10);
        ALU_B<=DATAOUT(9);
        SW_B<=DATAOUT(8);
        LED_B<=DATAOUT(7);
 		RAM_B<=DATAOUT(6);
        CS_D<=NOT(NOT DATAOUT(5) AND T3);
        RD_D<=NOT(NOT DATAOUT(4) AND (T2 OR T3));
        CS_I<=DATAOUT(3);
        ADDR_B<=DATAOUT(2);
        P1<=DATAOUT(1);
        P2<=DATAOUT(0);
    END PROCESS;
END A;

 22.AAA.GDF

23.MMM

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY MMM IS 
PORT(
     SE:IN STD_LOGIC;    
     CLK:IN STD_LOGIC;    
     D:IN STD_LOGIC;     
     CLR:IN STD_LOGIC;   
     UA:OUT STD_LOGIC    
);
END MMM;
ARCHITECTURE A OF MMM IS
BEGIN
     PROCESS(CLR,SE,CLK)
     BEGIN
          IF(CLR='0') THEN 
               UA<='0';
          ELSIF(SE='0')THEN 
               UA<='1';
          ELSIF(CLK'EVENT AND CLK='1') THEN 
               UA<=D;
          END IF;
     END PROCESS;
END A;

 五、仿真过程及结果

输入

        本实验的输入指令为9200，在此范围区间内可以输入数字，可以输入十个无符号整数，并需检查输入的数值是否存到MEM中。最后能在outbus中输出排完序的大小。至于仿真end time问题，可能每个人的电脑仿真时间都不相同，刚开始可以设计久一点的，看自己的程序运行到什么时候结束，再修改。如果出现问题，首先可以检查gdf图是否连接正确，其中代码是否正确，或者跟着指令走一遍，看看每条指令是否都实现其功能，如果检查出错误，修正应该就可以了。如果还是检查不出来错误，可以将跟着数据通路走一遍，在输入输出的地方增加output，看某个数据经过这块是否有异常，或是一些信号是否出现毛刺，包括这个软件的一些使用规范问题等等等等都有可能导致结果不呈现。不要急，耐心点，可以自己解决掉这些bug，应该会很有成就感的！

结果

fly11127
关注
  • 11
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2020山东大学计算机组成原理课程设计报告
xdl229的博客
10-28 1万+
《计算机组成原理》 课程设计报告 微指令模型机实现 班级： 姓名： 学号： 小组成员： 完成日期：2020.10.16 一、计算机的功能和用途 通过该课程设计的学习，我们设计一台模型机，该模型机运行在FPGA平台上，可以模拟真正的计算机设备的一部分功能，通过微指令进行实现，使其可以完成一些基本操作，包括：加法、自增、减法、判断全0和判断进位，还有包括存储器读取写入等操作。具体实现了（1）（A1）+（A2）->A3。将A1、A2地址的数分别存到R0、R1寄存器，再通过ALU将加法.
MaxPlus2软件 MaxPlus2软件
04-04
1、支持MAX+PLUS II全部功能，包括原理图输入、VHDL/AHDL输入、编译、仿真、定时分析、编程。为方便下载，这一版本仅提供对EPM7000/EPM7000S/...3、C:\maxplus2下面的maxplus2.exe是其可执行文件，可快捷方式到桌面。
X96 Max Plus 刷atv 教程
aaaak_的博客
03-27 1万+
确定自己 设备型号 X96 Max Plus。BT完全不存在-这是它的主要区别。没有第二个5.2G天线。您可以以编程方式检查它，并且没有1000Mb芯片板载以太网，只有一根天线。有一个4GB RAM X96 Max Plus 2 1000MB以太网RTL8211F。您可以通过连接到支持1Gb的设备或使用Device Info HW来确保，或者通过板上存在芯片的外观来确保。天线2个 无线电模块8822CS 有2/4GB的RAM X96 Max Plus Q1 =不带1000Mb芯片。LAN 100，
记录win10下maxplus安装
Never Give Up
09-30 2455
在看国外的一本数电教材时发现了maxplus的使用介绍，图形化界面连线不错，好奇下载来看看 下载几个需要安装的版本，无法进行安装，鼠标不停转圈但安装界面无法打开，或者安装完成后提示无法运行缺少dll文件 此版本资源https://download.csdn.net/download/langqiyu/4600861上传时间2012年，看评论解压缩即可使用，但我下载下来运行兼容性也无法打开软件 右键打开快捷方式的文件所在位置，点击上方的max2win.exe成功打开 根据大佬的实验说明..
计算机组成原理-课设
hrdate(菜菜菜带带带)
04-26 4975
目录 一.课设性质，目的，任务 《计算机组成与系统结构课程设计》是计算机学院各专业集中实践性环节之一，是学习完《计算机组成与系统结构》课程后进行的一次全面的综合练习。其目的是综合运用所学计算机原理知识，设计并实现一台模型计算机，以便巩固所学的知识，提高分析问题和解决问题的能力。 二.课设基本理论 1、掌握算术、逻辑、移位运算实验，熟悉ALU运算控制位的运用。 2、掌握存储器组织、读写方式及与总路线组成的数据通路，掌握地址总线、数据总线的工作原理。 3、掌握指令结构和指令取指、执行工作过程。 4、掌握CPU的
计网课设 C++实现 FTP客户端 和 服务器端
Authur_gyc
06-25 1万+
文章目录一、FTP课本知识1.1 概述1.2 基本工作原理二、课设要求三、课设完成流程四、一些知识点五、代码六、参考知识 一、FTP课本知识 计算机网络第七版 谢希仁编著 1.1 概述 FTP提供交互式访问，允许客户指明文件的类型和格式，允许文件具有存取权限。FTP屏蔽了各计算机系统的细节，因此适合于异构网络中任意计算机之间传送文件。RFC959很早就成为了互联网的正式标准。 1.2 基本工作原理 FTP采用客户服务器模式，即Client-Server(C/S)结构。 一个FTP服务器进程可以同时为多个客户
MAX Plus II 仿真波形图为红色 解决方案
小龙王2010
05-15 4667
今天用MAX Plus II 做仿真   截图波形图是红色 截图如下： 其实这个不是什么错误引起的， 而是在仿真的时候 选择了Check Output s选项导致的红色，那么不要勾选这个选项就可以了，如图
mybatis-plus max函数，sum函数的使用
光滑的秃头
02-19 2万+
最近在使用mybatis-plus,发现在对于一些简单函数的使用，官方文档上面没有说明，特此记录下自己的使用方式 max,min,sum函数的使用 QueryWrapper<MemberLevel> queryWrapper = new QueryWrapper<>(); queryWrapper.select("max(level_sort) as levelSort"); 相当于sql : select max(level_sort) as levelSort from m
torch.nn.MaxPool2d详解
Medlen
11-22 8万+
注意：这里展示的是本篇博文写时的版本最新的实现，但是后续会代码可能会迭代更新，建议对照官方文档进行学习。 先来看源码： # 这个类是是许多池化类的基类，这里有必要了解一下 class _MaxPoolNd(Module): __constants__ = ['kernel_size', 'stride', 'padding', 'dilation', 'return_indices', 'ceil_mode'] return_indices: boo
MAX-Plus algebra最大加代数
hairangburangzhucea的博客
12-17 2202
首先给出Max-Plus定义： 设，在R*上定义两个运算：,,则称是Max-Plus代数。 Max-Plus代数主要用于解决非线性问题，例如调度理论等离散系统。 Max-Plus在矩阵中的一些计算：基础运算： 两个矩阵,乘运算的结果为一个矩阵,C中的每一个元素满足下面的公式： 也就是说，C中的第 i 行,第 j 列元素对应的A中的第i行和B中的第j列的数各自相加，取最...
sup, inf 与 min, max 的区别
热门推荐
天天向上的专栏
07-27 19万+
以前优化函数时的决策目标总是： min 或 max。最近读论文时，发现不少高质量的论文中总是写成： inf 或 sup。 inf 是 infimum 的简称，sup 是 supremum 的简称。 使用 inf 或 sup 总能保证一个函数的 inf 或 sup 存在，而函数的 min 或 max 有时候不存在。 例如函数： f(x)=sin(x)/xf(x)=sin⁡(x)/xf(x)=...
dianzizhong.rar_MAX plus2
09-22
标题中的“dianzizhong.rar_MAX plus2”可能是指一个使用Max Plus II设计的电子钟项目的压缩文件，其中包含了相关的设计文件和资料。 Max Plus II是由Xilinx公司开发的，它是基于Max-plus algebra（最大加法代数）...
MaxPlus2软件的使用
04-04
MaxPlus2是一款由 Synopsis 公司推出的集成电路设计与分析工具，它主要用于逻辑综合、仿真、时序分析以及逻辑优化等任务。在电子设计自动化（EDA）领域，MaxPlus2是工程师们常用的一款软件，尤其在数字电路设计流程...
maxplus 2 教程
05-08
完整maxplus 2 教程，完整maxplus 2 教程，完整maxplus 2 教程，完整maxplus 2 教程，完整maxplus 2 教程，完整maxplus 2 教程，完整maxplus 2 教程，完整maxplus 2 教程，完整maxplus 2 教程，完整maxplus 2 教程，...
计算机组成原理实验 maxplus实现存储器
01-16
本次实验的主题是使用MaxPlus工具来模拟和实现存储器系统。MaxPlus是一种符号计算工具，常用于硬件描述语言(HDL)的设计与分析，特别是在时序逻辑电路的建模上。通过这个实验，我们将深入学习存储器的工作原理，包括...
【排序算法】快速排序（详解+各版本实现）
2301_80555259的博客
07-09 1072
快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序②时间复杂度：O(N*logN)关于时间复杂度，可以这样简单解释：若递归调用的展开是二分的，就很类似于二叉树的结构，那么就存在logN层，每层遍历的时间复杂度为O(N),因此总的时间复杂度可以看为O(N*logN),当然这只是一种简单的解释，方便记忆。
基数排序算法Python实现
最新发布
PeterClerk的博客
07-09 518
基数排序算法实现
快速排序算法Python实现
PeterClerk的博客
07-08 429
快速排序算法
数据结构：排序
2402_82667241的博客
07-09 893
排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。内部排序：数据元素全部放在内存中的排序。外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不断地在内外存之间移动数据的排序。排序的运用：一、常见的排序算法。
maxplus2计组课设仿真
07-13
maxplus2是一种常用的计算机硬件描述语言，用于实现数字逻辑电路的仿真和设计。在计组课设中，通过maxplus2进行仿真可以帮助我们更好地理解和学习计算机组成原理。 计组课设中的仿真主要包括以下几个方面： 首先，我们可以使用maxplus2来搭建数学算术逻辑单元（ALU）的电路，通过仿真可以验证ALU的正确性和功能。ALU是计算机中一个重要的组成部分，能够进行各种算术和逻辑运算。通过maxplus2的仿真，我们可以观察ALU在不同输入情况下的输出结果，进一步验证其设计是否正确和完善。 其次，我们还可以使用maxplus2来进行存储器的仿真。计组课设中经常会涉及到存储器的设计和使用，通过maxplus2的仿真，我们可以模拟存储器的读写操作和数据存储过程，验证存储器的正确性和性能。 此外，maxplus2还可以帮助我们进行时序电路的仿真。时序电路是计算机中各个部件之间相互协调工作的关键，通过maxplus2的仿真，我们可以模拟时钟信号的变化过程以及各个时序电路的运行情况，帮助我们更好地理解时序电路的工作原理和时钟信号的作用。 总之，使用maxplus2进行计组课设的仿真可以帮助我们更深入地理解和学习计算机组成原理的各个方面。通过仿真的实验，我们可以验证电路设计的正确性和性能，提高我们的实践能力和设计能力。同时，也能够增强我们对计算机硬件的理解，为进一步的学习打下坚实的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值