交织器

《数字系统设计》课程设计

题目：交织器解交织器

一、实验任务

卷积交织: 交织深度I=12 ，形成相互交迭的误码保护数据包，

1

以抵抗信道中突发的干扰。

二、实验要求

1. 请设计一个交织器和解交织器，完成二进制比特流的交织/ 解交织功能。

2. 设计测试基准，验证设计的功能是否正确。

三、设计卷积交织器目的

在数字传输系统中，因为存在噪声，信道衰落等干扰因素，会使

传输的信号发生错误，产生误码。虽然数字信号的传输为了防止误码而会进行信道编码，增加传输码的冗余，例如增加监督位等来克服信号在信道传输过程中的错误，但这种检错纠错能力是有限的。例如当出现突发错误，出现大片误码时，这时信道的纠错是为力的。而卷积交织器可以将原来的信息码打乱，这时尽管出现大面积突发性错误，这些可以通过解交织器来进行分散，从而将大面积的错误较为平均地分散到不同的码段，利于信道纠错的实现。

四、卷积交织的原理

卷积交织的原理其实是利用了延时的原理。例如总延时是T,交织器延时t1,解交织器延时为t2，则有T=t1+t2.

2

本次设计的交织器的交织深度为12，故交织器总共有12路，要进行卷积处理的数据分别循环的进入每一路，每一路延时不同的时间而后输出。不难想象，如果每一路都延时相同的时间，输入序列肯定跟输出序列一模一样，但交织器因为每一路延时的时间不同，从而将序列打乱了，看上去会很乱，例如你输入1,2,3,4…….20,输出就是1,0，0,0，…..13…….25…..。

那么经过交织器处理后打乱的数据如何恢复原状呢？很简单，因为每一个数据的总延时都是T，如果一个数据A在交织器中延时了t1，那么数据A只需在解交织器中延时T-t1即可。

五、设计过程

1.设计思路

以上讨论的是交织器与解交织器的算法，那么在硬件电路上如

何实现呢？由上讨论，交织器与解交织器都是利用了延时来实现的，而在硬件上实现延时一种很自然的想法就是利用移位寄存器来实现，延时T只需要T级的移位寄存器，在每个时钟的到来，将数据移位，例如数据‘1’经过5级的移位寄存器，经过5个时钟后，数据就经历了

3

寄存器每个寄存单元而输出。移位寄存器很容易理解，但用移位寄存器的方法有个不好的地方，那就是‘工程量很大’，每个时钟的到来，会有大量存在于移位寄存器中的数据移动，这会增加整个系统的功耗与效率。

为了克服移位寄存器的缺点，我们可以用ram来模仿移位寄存器的功能。例如定义一个长度为4的ram，那么模仿移位寄存器的过程是这样的。例如要对数据“ABCD“进行延时： 第一个时钟，将A数据写入1单元，读出2单元数据。 第二个时钟，将B数据写入2单元，读出3单元数据。 第三个时钟，将C数据写入3单元，读出4单元数据。

第四个时钟，将D数据写入4单元，读出1单元数据。这时就读出A数据了，刚好延时了四个时钟。

如此循环，“ABCD“就延时了四个时钟后输出，与4级移位功能相同，因为这种方法只是涉及了数据的读和写，所以克服了移位寄存器大量数据移位的缺点。

所以本系统使用ram来实现交织器与解交织器。具体来说，就是将ram分成12路，第一路无延时。第二路延时M时间，需要M+1个存储单元。第三路延时2M时间，需要2M+1个存储单元。第四路延时3M时间，

4

需要3M+1个存储单元。如此类推，第i路延时（i-1）M时间，需要（i-1）M+1；而解交织器相反，第十二路无延时。第十一路延时M，第十路延时2M，如此类推。下面介绍数据的流动，以交织器为例，每个时钟，数据进入不同的ram路，我们可以设置一个count_ram（1至12）进行循环计数，每个时钟count_ram就加1，数据进入第count_ram路。确定了数据进入哪一路ram后，还要确定数据进入这路ram中的哪一个单元，故每一路ram都要一个设置一个计数器coun1-count12，来控制读写哪一个单元，利用上面讨论的ram移位法实现延时，读的地址要比写的地址靠前一位，因为数据读出的时候同时要写入数据，所以ram要用双口ram实现。

2.设计步骤

①定义相关端口，状态及信号；

②每当时钟上升沿数据进入系统，根据state_count不同的值进入不同的路；

③将输入数据用modelsim仿真显示。

5

④ 将程序下载到板上用数码管观察。

3.相关端口设定

Clk：时钟信号输入 Outdata:数码管输入 Q：数码管位选 Ren，wen：读写使能端 Reset：置位端

六、设计中出现的问题与解决:

①.在交织器的设计过程过程中，也遇到了不少的困难。

在交织器的输出中，总会在输出的第二位出现一个零。如下图，例如是应该是输出4后马上输出2的，但是仿真时却发现输出时4,0,2。 分析：后来通过分析仿真图，可以发现直接输出的第一路超前一位时钟输出了，这是因为第一路的数据没有经过ram直接输出，故会超前一个时钟。

解决：在直接输出的那一路加上一个触发器，使输出同步。

6

②.用定义数组的方法定义ram，发现占掉许多的资源。

解决：用quartus自有的ipcore定制ram，发现节省了许多的资源。

③．在交织器与解交织器连起来后，输出有误。

解决：因为要经过相应数量后时钟，数据才能到达解交织器的入口，所以解交织器之前要写入一些无关的ram以达到同步。

七、实验结果及分析

1.交织器的仿真（输入1到256）

输入数据方式：1.用文件输入 2.计数器输出做输入 输出数据方式：1.用文件输出 2.直接观察波形图

1）.波形的方式

7

2）.用文件的方式

分析：用文件输出的方式更易于观察数据的数量。可以观察到输出的数据会越来越多。

2.解织器的仿真

8

分析：一开始输出很大段是‘0’，因为初始化的时候ram里面存的是‘0’。而输出完‘0’后就会输出解交织后的1到200. 下载：

芯片类型是四代cyclone的EP4CE22C8

9

管脚分配：

使用数码管进行显示。具体实现在视频中已经体现。

八、设计总结

通过本次课程设计，我在实践中加深了对相关知识（状态

机等）的理解与应用，将所学到的知识融会贯通，从而顺利完成设计目标，达到设计要求。最后，感谢姜小波老师在本学期数字系统设计课程中对我们耐心的指导及细心的讲解，也祝愿老师在以后能够一帆风顺，工作顺利！

十、代码

1.项目代码 1)解交织器代码：

LIBRARY IEEE; --导入库 USE IEEE.std_logic_11.ALL;

10

use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all;

ENTITY jie_jiaozhiqi IS PORT(

INDATA:IN STD_LOGIC_VECTOR(7 downto 0); --数据输入 OUTDATA:OUT STD_LOGIC_VECTOR(7 downto 0); --解交织数据输入

CLK:IN STD_LOGIC; --时钟 REN:IN STD_LOGIC; --读使能端 WEN:IN STD_LOGIC; --写使能端 RESET:IN STD_LOGIC --复位信号 );

END;

ARCHITECTURE BEHAV OF jie_jiaozhiqi IS

COMPONENT ram_jiejiaozhi IS --ipcore双口ram：ram_jiejiaozhi PORT ( clock : IN STD_LOGIC := '1'; --时钟 data : IN STD_LOGIC_VECTOR (7 DOWNTO 0); --ram输入 rdaddress : IN STD_LOGIC_VECTOR (10 DOWNTO 0); --读地址 rden : IN STD_LOGIC := '1'; --读使能 wraddress : IN STD_LOGIC_VECTOR (10 DOWNTO 0); --读地址 wren : IN STD_LOGIC := '0'; --写使能 q : OUT STD_LOGIC_VECTOR (7 DOWNTO 0) --ram输出 );

END COMPONENT;

SIGNAL STATE_COUNT:INTEGER RANGE -1 TO 13:=-1; --每一路转换的计数信号

SIGNAL RAM_OUTPUT:STD_LOGIC_VECTOR(7 downto 0); --ram输出的信号线 SIGNAL RAM_INPUT:STD_LOGIC_VECTOR(7 downto 0); --ram输入的信号线

SIGNAL WD_ADD:std_logic_vector(10 downto 0):=\"11111111110\"; --读地址的信号线 SIGNAL RD_ADD:std_logic_vector(10 downto 0):=\"11111111100\"; --写地址的信号线

11

SIGNAL INDATA_derect:STD_LOGIC_VECTOR(7 downto 0); --数据直接输出，不经过ram的信号线

BEGIN

PROCESS(STATE_COUNT) --每一路的计数器 VARIABLE Branch_count_1:INTEGER RANGE 0 TO 18:=0;

VARIABLE Branch_count_2:INTEGER RANGE 0 TO 35:=0; VARIABLE Branch_count_3:INTEGER RANGE 0 TO 52:=0; VARIABLE Branch_count_4:INTEGER RANGE 0 TO 69:=0; VARIABLE Branch_count_5:INTEGER RANGE 0 TO 86:=0; VARIABLE Branch_count_6:INTEGER RANGE 0 TO 103:=0; VARIABLE Branch_count_7:INTEGER RANGE 0 TO 120:=0; VARIABLE Branch_count_8:INTEGER RANGE 0 TO 137:=0; VARIABLE Branch_count_9:INTEGER RANGE 0 TO 154:=0; VARIABLE Branch_count_10:INTEGER RANGE 0 TO 171:=0; VARIABLE Branch_count_11:INTEGER RANGE 0 TO 188:=0; BEGIN

CASE STATE_COUNT IS

--当STATE_COUNT计数到不同的值时，控制输入数据写入那一路的ram，读出那一路的ram，共有12路

WHEN 12=>

RD_ADD<=\"11111111110\"; WD_ADD<=\"11111111100\"; WHEN 11=>

WD_ADD<=conv_std_logic_vector(Branch_count_1 mod(18),11); RD_ADD<=conv_std_logic_vector((Branch_count_1+1) mod(18),11); if Branch_count_1=18 then Branch_count_1:=1; else

Branch_count_1:=Branch_count_1+1; end if;

WHEN 10=>

WD_ADD<=conv_std_logic_vector((Branch_count_2 mod(35))+18,11); RD_ADD<=conv_std_logic_vector((Branch_count_2+1) mod(35)+18,11); if Branch_count_2=35 then Branch_count_2:=1; else

Branch_count_2:=Branch_count_2+1;

12

end if;

WHEN 9=>

WD_ADD<=conv_std_logic_vector((Branch_count_3 mod(52))+53,11); RD_ADD<=conv_std_logic_vector((Branch_count_3+1) mod(52)+53,11); if Branch_count_3=52 then Branch_count_3:=1; else

Branch_count_3:=Branch_count_3+1; end if;

WHEN 8=>

WD_ADD<=conv_std_logic_vector((Branch_count_4 mod(69))+105,11); RD_ADD<=conv_std_logic_vector((Branch_count_4+1) mod(69)+105,11); if Branch_count_4=69 then Branch_count_4:=1; else

Branch_count_4:=Branch_count_4+1; end if;

WHEN 7=>

WD_ADD<=conv_std_logic_vector((Branch_count_5 mod(86))+174,11); RD_ADD<=conv_std_logic_vector((Branch_count_5+1) mod(86)+174,11); if Branch_count_5=86 then Branch_count_5:=1; else

Branch_count_5:=Branch_count_5+1; end if;

WHEN 6=>

WD_ADD<=conv_std_logic_vector((Branch_count_6 mod(103))+260,11); RD_ADD<=conv_std_logic_vector((Branch_count_6+1) mod(103)+260,11); if Branch_count_6=103 then Branch_count_6:=1; else

Branch_count_6:=Branch_count_6+1; end if;

WHEN 5=>

WD_ADD<=conv_std_logic_vector((Branch_count_7 mod(120))+363,11); RD_ADD<=conv_std_logic_vector((Branch_count_7+1) mod(120)+363,11); if Branch_count_7=120 then Branch_count_7:=1; else

Branch_count_7:=Branch_count_7+1;

13

end if;

WHEN 4=>

WD_ADD<=conv_std_logic_vector((Branch_count_8 mod(137))+483,11); RD_ADD<=conv_std_logic_vector((Branch_count_8+1) mod(137)+483,11); if Branch_count_8=137 then Branch_count_8:=1; else

Branch_count_8:=Branch_count_8+1; end if;

WHEN 3=>

WD_ADD<=conv_std_logic_vector((Branch_count_9 mod(154))+620,11); RD_ADD<=conv_std_logic_vector((Branch_count_9+1) mod(154)+620,11); if Branch_count_9=154 then Branch_count_9:=1; else

Branch_count_9:=Branch_count_9+1; end if;

WHEN 2=>

WD_ADD<=conv_std_logic_vector((Branch_count_10 mod(171))+774,11); RD_ADD<=conv_std_logic_vector((Branch_count_10+1) mod(171)+774,11); if Branch_count_10=171 then Branch_count_10:=1; else

Branch_count_10:=Branch_count_10+1; end if;

WHEN 1=>

WD_ADD<=conv_std_logic_vector((Branch_count_11 mod(188))+945,11); RD_ADD<=conv_std_logic_vector((Branch_count_11+1) mod(188)+945,11); if Branch_count_11=188 then Branch_count_11:=1; else

Branch_count_11:=Branch_count_11+1; end if;

WHEN OTHERS=>--OUTDATA_reg<=\"00001111\";

RD_ADD<=\"11111111110\"; WD_ADD<=\"11111111100\"; END CASE; END PROCESS;

--二路选择器，选择解交织输出的数据是从ram输出的数据还是直接输入的数据

14

Out_choice:PROCESS(STATE_COUNT,RAM_OUTPUT,INDATA_derect) BEGIN

IF (STATE_COUNT=1)THEN OUTDATA<=INDATA_derect; ELSE

OUTDATA<=RAM_OUTPUT; END IF;

END PROCESS;

--特殊处理第一路，因为不能双口ram不能同时读写同一单元，故要设一支路让数据直接输入输出

PROCESS(CLK,STATE_COUNT) BEGIN

IF (STATE_COUNT=12)THEN IF RISING_EDGE(CLK)THEN INDATA_derect<=INDATA; END IF; END IF;

END PROCESS; --状态转换进程

State_conver：process(clk,RESET) begin

IF (RESET='1')THEN STATE_COUNT<=-1; ELSIF rising_EDGE(CLK) THEN if STATE_COUNT=12 then STATE_COUNT<=1;

else STATE_COUNT<=STATE_COUNT+1; end if; END IF; end process;

将双口ram与解交织器相连 u1 :nimei PORT MAP( clock=>CLK, data=>INDATA, rdaddress=>RD_ADD, wraddress=>WD_ADD, wren=>WEN, rden=>REN, q=>RAM_OUTPUT); --例化 END BEHAV;

2）、交织器代码：

15

LIBRARY IEEE; --导入库 USE IEEE.std_logic_11.ALL; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all;

ENTITY jiaozhiqi IS PORT(

INDATA:IN STD_LOGIC_VECTOR(7 downto 0); --数据输入 OUTDATA:OUT STD_LOGIC_VECTOR(7 downto 0); --解交织数据输入 CLK:IN STD_LOGIC; --时钟 REN:IN STD_LOGIC; --读使能端 WEN:IN STD_LOGIC; --写使能端 RESET:IN STD_LOGIC --复位信号 );

END;

ARCHITECTURE BEHAV OF jie_jiaozhiqi IS

COMPONENT ram_jiaozhi IS --ipcore双口ram：ram_jiejiaozhi PORT ( clock : IN STD_LOGIC := '1'; --时钟 data : IN STD_LOGIC_VECTOR (7 DOWNTO 0); --ram输入 rdaddress : IN STD_LOGIC_VECTOR (10 DOWNTO 0); --读地址 rden : IN STD_LOGIC := '1'; --读使能 wraddress : IN STD_LOGIC_VECTOR (10 DOWNTO 0); --读地址 wren : IN STD_LOGIC := '0'; --写使能 q : OUT STD_LOGIC_VECTOR (7 DOWNTO 0) --ram输出 );

END COMPONENT;

SIGNAL STATE_COUNT:INTEGER RANGE -1 TO 13:=1; --每一路转换的计数信号

SIGNAL RAM_OUTPUT:STD_LOGIC_VECTOR(7 downto 0); --ram输出的信号线 SIGNAL RAM_INPUT:STD_LOGIC_VECTOR(7 downto 0); --ram输入的信号线

SIGNAL WD_ADD:std_logic_vector(10 downto 0):=\"11111111110\"; --读地址的信号线 SIGNAL RD_ADD:std_logic_vector(10 downto 0):=\"11111111100\"; --写地址的信号线 SIGNAL INDATA_derect:STD_LOGIC_VECTOR(7 downto 0); --数据直接输出，不经过ram的信号线

BEGIN

16

PROCESS(STATE_COUNT) --每一路的计数器 VARIABLE Branch_count_1:INTEGER RANGE 0 TO 18:=0; VARIABLE Branch_count_2:INTEGER RANGE 0 TO 35:=0; VARIABLE Branch_count_3:INTEGER RANGE 0 TO 52:=0; VARIABLE Branch_count_4:INTEGER RANGE 0 TO 69:=0; VARIABLE Branch_count_5:INTEGER RANGE 0 TO 86:=0; VARIABLE Branch_count_6:INTEGER RANGE 0 TO 103:=0; VARIABLE Branch_count_7:INTEGER RANGE 0 TO 120:=0; VARIABLE Branch_count_8:INTEGER RANGE 0 TO 137:=0; VARIABLE Branch_count_9:INTEGER RANGE 0 TO 154:=0; VARIABLE Branch_count_10:INTEGER RANGE 0 TO 171:=0; VARIABLE Branch_count_11:INTEGER RANGE 0 TO 188:=0; BEGIN

CASE STATE_COUNT IS

--当STATE_COUNT计数到不同的值时，控制输入数据写入那一路的ram，读出那一路的ram，共有12路

WHEN 1=>

RD_ADD<=\"11111111110\"; WD_ADD<=\"11111111100\";

WHEN 2=>

WD_ADD<=conv_std_logic_vector(Branch_count_1 mod(18),11); RD_ADD<=conv_std_logic_vector((Branch_count_1+1) mod(18),11); if Branch_count_1=18 then Branch_count_1:=1; else

Branch_count_1:=Branch_count_1+1; end if;

WHEN 3=>

WD_ADD<=conv_std_logic_vector((Branch_count_2 mod(35))+18,11); RD_ADD<=conv_std_logic_vector((Branch_count_2+1) mod(35)+18,11); if Branch_count_2=35 then Branch_count_2:=1; else

Branch_count_2:=Branch_count_2+1; end if;

WHEN 4=>

WD_ADD<=conv_std_logic_vector((Branch_count_3 mod(52))+53,11);

17

RD_ADD<=conv_std_logic_vector((Branch_count_3+1) mod(52)+53,11); if Branch_count_3=52 then Branch_count_3:=1; else

Branch_count_3:=Branch_count_3+1; end if;

WHEN 5=>

WD_ADD<=conv_std_logic_vector((Branch_count_4 mod(69))+105,11); RD_ADD<=conv_std_logic_vector((Branch_count_4+1) mod(69)+105,11); if Branch_count_4=69 then Branch_count_4:=1; else

Branch_count_4:=Branch_count_4+1; end if;

WHEN 6=>

WD_ADD<=conv_std_logic_vector((Branch_count_5 mod(86))+174,11); RD_ADD<=conv_std_logic_vector((Branch_count_5+1) mod(86)+174,11); if Branch_count_5=86 then Branch_count_5:=1; else

Branch_count_5:=Branch_count_5+1; end if;

WHEN 7=>

WD_ADD<=conv_std_logic_vector((Branch_count_6 mod(103))+260,11); RD_ADD<=conv_std_logic_vector((Branch_count_6+1) mod(103)+260,11); if Branch_count_6=103 then Branch_count_6:=1; else

Branch_count_6:=Branch_count_6+1; end if;

WHEN 8=>

WD_ADD<=conv_std_logic_vector((Branch_count_7 mod(120))+363,11); RD_ADD<=conv_std_logic_vector((Branch_count_7+1) mod(120)+363,11); if Branch_count_7=120 then Branch_count_7:=1; else

Branch_count_7:=Branch_count_7+1; end if;

WHEN 9=>

18

WD_ADD<=conv_std_logic_vector((Branch_count_8 mod(137))+483,11); RD_ADD<=conv_std_logic_vector((Branch_count_8+1) mod(137)+483,11); if Branch_count_8=137 then Branch_count_8:=1; else

Branch_count_8:=Branch_count_8+1; end if;

WHEN 10=>

WD_ADD<=conv_std_logic_vector((Branch_count_9 mod(154))+620,11); RD_ADD<=conv_std_logic_vector((Branch_count_9+1) mod(154)+620,11); if Branch_count_9=154 then Branch_count_9:=1; else

Branch_count_9:=Branch_count_9+1; end if;

WHEN 11=>

WD_ADD<=conv_std_logic_vector((Branch_count_10 mod(171))+774,11); RD_ADD<=conv_std_logic_vector((Branch_count_10+1) mod(171)+774,11); if Branch_count_10=171 then Branch_count_10:=1; else

Branch_count_10:=Branch_count_10+1; end if;

WHEN 12=>

WD_ADD<=conv_std_logic_vector((Branch_count_11 mod(188))+945,11); RD_ADD<=conv_std_logic_vector((Branch_count_11+1) mod(188)+945,11); if Branch_count_11=188 then Branch_count_11:=1; else

Branch_count_11:=Branch_count_11+1; end if;

WHEN OTHERS=>--OUTDATA_reg<=\"00001111\";

RD_ADD<=\"11111111110\"; WD_ADD<=\"11111111100\";

END CASE; END PROCESS;

--二路选择器，选择交织输出的数据是从ram输出的数据还是直接输入的数据

19

Out_choice:PROCESS(STATE_COUNT,RAM_OUTPUT,INDATA_derect) BEGIN

IF (STATE_COUNT=1)THEN OUTDATA<=INDATA_derect; ELSE

OUTDATA<=RAM_OUTPUT; END IF;

END PROCESS;

--特殊处理第一路，因为不能双口ram不能同时读写同一单元，故要设一支路让数据直接输入输出

PROCESS(CLK,STATE_COUNT) BEGIN

IF (STATE_COUNT=2)THEN IF RISING_EDGE(CLK)THEN INDATA_derect<=INDATA; END IF; END IF;

END PROCESS;

--状态转换进程

State_conver：process(clk,RESET) begin

IF (RESET='1')THEN STATE_COUNT<=0; ELSIF rising_EDGE(CLK) THEN if STATE_COUNT=12 then STATE_COUNT<=1;

else STATE_COUNT<=STATE_COUNT+1; end if; END IF; end process;

将双口ram与交织器相连 u1 :nimei PORT MAP( clock=>CLK, data=>INDATA, rdaddress=>RD_ADD, wraddress=>WD_ADD, wren=>WEN, rden=>REN, q=>RAM_OUTPUT); --例化 END BEHAV;

20

3）、顶层文件：

LIBRARY IEEE;

USE IEEE.std_logic_11.ALL; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all;

entity top is --顶层实体 PORT(

INDATA:IN STD_LOGIC_VECTOR(7 downto 0); --数据输入 OUTDATA:OUT STD_LOGIC_VECTOR(7 downto 0); --数据输出 CLK:IN STD_LOGIC; --时钟 REN:IN STD_LOGIC; --读使能 WEN:IN STD_LOGIC; --写使能 RESET:IN STD_LOGIC; --置位 Q:OUT BIT_VECTOR(2 DOWNTO 0) --数码管位选信号 ); end entity;

ARCHITECTURE BEHAV OF top IS

component jie_jiaozhiqi IS --解交织器元件 PORT(

INDATA:IN STD_LOGIC_VECTOR(7 downto 0); OUTDATA:OUT STD_LOGIC_VECTOR(7 downto 0); CLK:IN STD_LOGIC; REN:IN STD_LOGIC; WEN:IN STD_LOGIC; RESET:IN STD_LOGIC );

END component;

component SHUMAGUAN is --数码管 port(

CLK:IN STD_LOGIC;

INDATA: IN STD_LOGIC_VECTOR(7 DOWNTO 0); OUTDATA:OUT STD_LOGIC_VECTOR(6 DOWNTO 0); Q:OUT BIT_VECTOR(2 DOWNTO 0); FENPIN_CLK_1s:OUT STD_LOGIC );

END component;

21

component jiaozhiqi IS --交织器元件 PORT(

INDATA:IN STD_LOGIC_VECTOR(7 downto 0); OUTDATA:OUT STD_LOGIC_VECTOR(7 downto 0); CLK:IN STD_LOGIC; REN:IN STD_LOGIC; WEN:IN STD_LOGIC; RESET:IN STD_LOGIC );

END component;

component count200 IS --计数器 PORT ( clock : IN STD_LOGIC ; q : OUT STD_LOGIC_VECTOR (7 DOWNTO 0) );

END component;

signal jiao_jie_connect:STD_LOGIC_VECTOR(7 downto 0); --解交织器与交织器的连线 signal count_out:STD_LOGIC_VECTOR(7 downto 0); --计数器输出与交织器输入连线 signal shumaguan_input:STD_LOGIC_VECTOR(7 downto 0); --解交织器与数码管的连续 signal fenpin:std_logic; --分频输出信号 begin --连线 jiaozhiqi_component:jiaozhiqi

portmap(INDATA=>count_out,OUTDATA=>jiao_jie_connect,CLK=>fenpin,REN=>REN,WEN=>WEN,RESET=>RESET);

jie_jiaozhiqi_component:jie_jiaozhiqi

portmap(INDATA=>jiao_jie_connect,OUTDATA=>shumaguan_input,CLK=>fenpin,REN=>REN,WEN=>WEN,RESET=>RESET);

counter_component:count200 port map(clock=> fenpin,q=>count_out); shumaguan_component:SHUMAGUAN

portmap(CLK=>CLK,INDATA=>shumaguan_input,OUTDATA=>OUTDATA,Q=>Q,FENPIN_CLK_1s=>fenpin);

end behav;

编译

22

2.仿真测试代码

library ieee;

use ieee.std_logic_11.all; use ieee.std_logic_arith.all; use ieee.std_logic_unsigned.all;

ENTITY top_vhd_tst IS END top_vhd_tst;

ARCHITECTURE top_arch OF top_vhd_tst IS

-- constants -- signals SIGNAL CLK : STD_LOGIC;

SIGNAL OUTDATA : STD_LOGIC_VECTOR(7 DOWNTO 0); --SIGNAL Q : STD_LOGIC_VECTOR(2 DOWNTO 0); SIGNAL REN : STD_LOGIC; SIGNAL RESET : STD_LOGIC; SIGNAL WEN : STD_LOGIC; COMPONENT top PORT ( CLK : IN STD_LOGIC; OUTDATA : OUT STD_LOGIC_VECTOR(7 DOWNTO 0); -- Q : OUT STD_LOGIC_VECTOR(2 DOWNTO 0); REN : IN STD_LOGIC; RESET : IN STD_LOGIC; WEN : IN STD_LOGIC );

END COMPONENT; BEGIN i1 : top

23

PORT MAP (

-- list connections between master ports and signals CLK => CLK, OUTDATA => OUTDATA, -- Q => Q, REN => REN, RESET => RESET, WEN => WEN );

always : PROCESS --时钟

BEGIN CLK<='1';

WAIT FOR 50 PS; CLK<='0';

WAIT FOR 50 PS;

-- code executes for every event on sensitivity list END PROCESS always;

rst_en:process—使能与置位 begin

RESET<='0'; WEN<='1';

REN<='1';--ENABLE WAIT FOR 500 PS; RESET<='1'; WAIT ;

END PROCESS rst_en;

inputee:process(clk)—数据输入 BEGIN

If RISING_EDGE(CLK)THEN INDATA<=INDATA+1; END IF;

END PROCESS;

END top_arch;

24