基于FPGA的Viterbi译码器要点

毕业设计(论文)

基于FPGA的Viterbi译码器

姓 名： 学 院： 专 业： 班 级： 指导教师：

1

摘 要

卷积编码是深度空间通信系统和无线通信系统中常采用的一种编码方式,广泛应用于卫星通信、无线通信等多种通信系统。在1967年，Viterbi 提出了卷积码的Viterbi 译码算法，它是一种卷积码的最大似然译码算法，通过寻找译码器接收序列和卷积编码器的输出序列的最大似然函数来得出译码结果。该算法译码性能好、速度快，并且硬件实现结构比较简单，是最佳的卷积码译码算法。随着可编程逻辑技术的不断发展，使用FPGA实现viterbi译码器的设计方法逐渐称为主流。因此设计viterbi译码器，使其能够满足多种通信系统的应用要求，具有重要的现实意义。

本文的主要内容是基于FPGA 的Viterbi 译码器设计。在对viterbi译码算深入研究过程中，重点研究了Viterbi 译码器各个模块的主要功能。在本设计中，采用了硬判决计算输入信息码元与各状态的期望码元之间的分支度量值，用串行加比选碟型算法来寻找编码器网格图上的幸存路径，用回溯法(trace-back)算法来对幸存路径做处理得到译码输出，用乒乓方式对幸存路径进行存储。本论文设计输入是采用硬件描述语言VHDL来完成的，通过在各种EDA工具下的仿真和综合，验证了本文所设计的Viterbi 译码器的正确性和实用性。

关键词：卷积码；维特比；译码器；现场可编程门阵列

2

ABSTRACT

Convolutional coding has been used in communication systems including deep space communications and wireless communications,which are widely used in satellite communications and wireless communication. The Viterbi algorithm , proposed in 1967 by Viterbi ,is a maximum-likelihood algorithm for convolutional codes. The Viterbi decoder attempts to find the maximum-likelihood function of the decoded code word against received code word. This method is better decoding performance, fast, and relatively simple hardware architecture, is the best convolutional code decoding algorithm. With the continuous development of programmable logic technology, the use of FPGA implementation viterbi decoder design method called mainstream gradually. Therefore, the design viterbi decoder so that it can meet the application requirements of a variety of communication systems, has important practical significance.

The main content of this paper is to design a Viterbi decoder with FPGA technology. In-depth study of the viterbi decoding calculation process, focusing on the main functions of each module Viterbi decoder. In this paper, the parallel ACS (add-compare-select) Butterfly algorithm is used to find the survivor path in encoder trellis. We also use trace-back algorithm to dispose the survivor path and receive the decoded results. In addition, the behavior of a design is described in VHDL. The emulated and synthesized results of this design are received by all kinds of EDA tools. Through these results the Viterbi decoder’s correctness and practicability can be validated.

Key words：Convolutional Code; Viterbi; Viterbi; FPGA

3

目 录

绪 论 ............................................................................................................................ 5 第一章 纠错码的基本原理 ........................................................................................ 7

1.1 差错控制的基本方式 ...................................................................................... 7 1.2 纠错编码的基本原理 ...................................................................................... 8 1.3 纠错编码的分类 .......................................................................................... 10 第二章 卷积码和Viterbi算法 ................................................................................. 12

2.1 卷积码基础 .................................................................................................. 12

2.1.1 卷积码编码原理 .................................................................................. 12 2.1.2 卷积码的描述 ...................................................................................... 14 2.2 Viterbi译码原理 .......................................................................................... 17

2.2.1Viterbi算法描述 .................................................................................... 17 2.2.2Viterbi算法举例 .................................................................................... 18 2.2.3 Viterbi译码器的特点 ........................................................................... 22

第三章 Viterbi译码的FPGA实现 ......................................................................... 23

3.1 Viterbi译码器的基本结构 ........................................................................ 23 3.2 分支度量模块（BMU） ............................................................................... 25 3.3 加比选模块(ACS) ......................................................................................... 26

3.3.1状态间的蝶形运算关系 ....................................................................... 26 3.3.2 加比选的实现方式 ............................................................................ 29 3.3.3 溢出处理 .............................................................................................. 29 3.4 路径度量存储模块（PMU） ..................................................................... 30 3.5 幸存路径寄存模块（SMU） ....................................................................... 31

3.5.1 寄存器交换法 ...................................................................................... 32 3.5.2 回溯法 .................................................................................................. 33 3.6 回溯模块(TBU) ............................................................................................. 34 第四章 Viterbi译码器的设计与仿真结果 .......................................................... 36

4.1 卷积码编码器设计 ...................................................................................... 36 4.2 Viterbi 译码器的设计 ................................................................................. 37 第五章 结束语 ............................................................................................................ 39 参考文献 ...................................................................................................................... 40 附录 .............................................................................................................................. 41 英文文献 ...................................................................................................................... 57 谢 辞 ...................................................................................................................... 70

4

绪 论

随着现代通讯的发展，我们对通信的技术的质量跟速度提出了更高的要求。但是，由于信道的不理想以及加性噪声和人为干扰的影响，使得信号在信道传输过程中会因为各种干扰而产生失真现象，使得通信质量下降。不同的系统在信号传输过程中会受到不同的干扰，产生不同的差错率，进而使传输的可靠性也不同。随着传输速率的提高，可靠性问题更加突出。为了提高传输的可靠性，降低误码率，有两种方法：一是降低信道本身引起的误码，可采用的方法有选择高质量的传输线路、改善信道的传输特性、增加信号的发送能量、选择有较强抗干扰能力的调制解调方案等；另外一种方法就是采用差错控制编码，即信道编码。这种方法主要是对输入信息序列进行各种变换，使得原来相互的信息码元产生相关性，在接收端利用这些信息码元的相关性检测出错码就纠正过来。在许多情况下，信道的改善需要大量的能量与功率，实现起来比较困难与不经济，这时采用差错控制编码方法比较合理。而在 GSM、IS - 95、WCDMA 系统中有广泛应用的卷积码译码算法是 A. J.Viterbi 在 1967 年提出的Viterbi算法(VB 算法),该算法是针对卷积码的一种最佳的最大似然译码方法。本设计实现了在IS-95中的前项链路所使用的(2,1,9)卷积码，具有一定的实际意义。

FPGA以运行速度快、编程方便、可以实现系统集成、功耗低、价格低、可以反复地编程与擦除使用的优点，在通信领域越发显示出强大的优势，受到广大电子技术人员的青睐。

本设计具有以下特点：

在本设计中采用了串行的加比选单元结构，这样可以节省大量的资源，降低对硬件的要求。在对幸存路径的处理上，一般来说有寄存器交换法和回溯法两种处理手段，在本设计中采用了回溯法。

本设计中 Viterbi 译码器的设计输入是用硬件描述语言VHDL写的，设计平台使用的是Altera 公司的Quartus II 软件，本设计中的输入、功能仿真、综合、适配及时序仿真都是在这个平台上来完成的。

本论文的具体安排如下：

第一章对纠错码进行了简单的介绍。

第二章主要介绍了卷积码的基础知识以及Viterbi 译码的基本原理，并通过举例来具体说明。

第三章主要介绍了viterbi译码器的FPGA的实现设计思路，viterbi译码器总体框体，然后还介绍了各个模块的主要功能和实现方法。

5

第四章简要的介绍了FPGA的发展历程及特点，同时给出了FPGA的一般设计方法。给出了本设计的仿真验证，从而证明了本设计的正确性。

6

第一章 纠错码的基本原理

1.1 差错控制的基本方式

数字信号在传输过程中，由于加性噪声和人为干扰的影响，使得数字信号产生失真现象。由于剩性干扰引起的失真现象可以采用均衡方法来消除。而因为加性干扰引起的误码现象则需要采用其他方法来消除，可以首先考虑增加数字信号发送端的发送功率或采取合理的调制解调方案，使加性干扰不足以影响达到误码率要求。在仍不能满足要求时，就要考虑采用差错控制措施了。一些通用的系统，其误码率要求因用途而异，也可以把差错控制作为附加手段，在需要时加用。

根据加性干扰引起错码分布规律的不同，可以把信道分成三类：突发信道、随机信道和混合信道，在不同的信道中，应采用不同的差错控制方式。差错控制方式基本上分为两类，一类称为“反馈纠错”，另一类称为“前向纠错”。在这两类基础上又派生出一种称为 “混合纠错”，如图1-3所示。

图1-3 差错控制的基本方式

（1）检错重发ARQ

检错重发方式的发送端发出有一定检错能力的码，接收端接受到这些码元后，利用码元本身的检错能力进行检测，当检测到有错码时，接收端通过反向信道向发送端发送信息，要求发送端重发，直到接受到正确码元为止。ARQ只能检测到是否有错码，但检测到错码后，不知道如何纠正错码，要求发送端重新发送一遍。在二进制系统中，这种情况发生在不知道一组接收码元中哪个码元错了。

该方法是通过发送有一定检错能力的码元进行检错的，因此它的优点是只需要少量的多余码就可以降低误码率。另外，由于该方法的检错与纠错能力与信

7

道干扰情况没有关系，因此可以应用于各种类型的信道，适应性比较强，特别适合于短波、有线等干扰情况复杂而又要求误码率较低的场合。主要缺点是必须有反馈信道，不能进行同播。当信道干扰较大时，造成错码概率较大，系统可能就处于重发循环中，信息传输的实时性和连贯性就比较差。 （2）前向纠错FEC

前向纠错方式是在发送端发送具有纠错能力的码元，接收端的纠错译码器接受这些码元后，检测到错码后能及时把这些错码纠正过来。

该方式的优点是译码实时性好，不需要反馈信道，能够进行一个用户对多个用户的广播式通信，而且控制电路简单，特别适用于移动通信。缺点是译码设备比较复杂难以实现，而且所选用的纠错码必须与信道干扰情况相匹配，因而对信道变化的适应性差。为了获得较低的误码率，必须以最坏的信道条件来设计纠错码。

（3）反馈校验

反馈校验方式不需要在发送序列中加入差错控制码元。这种方式的基本思路是接收端将接受到的码字原封不动地发送到发送端，与发送端的码字逐一进行比较，如果检测到与发送端的码字不相同，就认为接收端收到的码字中有错码，发送端需要重新发送。这种技术的优点是原理和设备都很简单，缺点是需要双向信道，传输效率也较低，因为每个码元都需要占用两次的传输时间。 （4）检错删除

检错删除和检错重发的区别在于，在接收端发现错码后，立即将其删除，不要求重发。这种方法只适用在少数待定系统中，在那里发送码元中有大量多余度，删除部分接收码元不影响应用。例如，在循环重复发送某些遥测数据时。又如，用于多次重发仍然存在错码时，这时为了提高传输效率不再重发，而采取删除方法。这样做在接收端当然会有少许损失，但却能够及时接受后续的消息。 以上几种技术可以结合使用。例如，“混合纠错”就是“前向纠错”和“反馈纠错”两种方式的混合。当接收端出现少量错码并有能力纠正错码时，采用前向纠错技术；当接收端出现较多错码没有能力纠正时，采用检错重发技术。

1.2 纠错编码的基本原理

差错控制编码又称为纠错编码（error-correcting coding）。有的编码方法只能检错而不能纠错，不同的编码方法，其检错或纠错能力是不同的。一般来说，增加的监督码元个数越多，检（纠）错的能力越强。而通常有多余度来衡量增加

8

的监督码个数。例如，若编码序列中平均每三个信息码元就添加一个监督码元，则这种编码的多余度为1/4。或者说，这种码的编码效率（简称码率）为3/4。我们假设编码序列中总码元数为n，其中信息码元数量为k，则监督码元数量为n-k，则码率就是信息码元数量与总码元数量的比值k\\n；而冗余度就是监督码元数（n-k）和信息码元数k之比（n-k）/k。

先用一个例子说明纠错编码的基本原理。用一个由3位二进制数字构成的码组来表示各种天气，这些码组有8种可能的组合方式，表示天气情况如下表

表1-1 各种天气的表示方法

码组 天气 000 晴 001 云 010 阴 011 雨 100 雪 101 霜 110 雾 111 雹

其中任一码组在传输过程中若发生一个或多个错码，则将变成另一个信息码组，这时，接收端接受到的码字是错码，表示的天气信息跟发送端的完全不一样，接收端将无法发现其错误。但若上述8中码组只准使用其中4种来传送天气，例如：000表示天气晴，011表示天气云，101表示天气阴，110表示雨。这时，虽然只能传送4种不同的天气，但是在接收端有可能发现码组中的一个错码。例如，若011（云）在传输过程中发生一个错码，则接受码组将变成111或001或010。这3种码组是不能表示任何天气的，是禁止使用，称为禁用码组。接收端收到禁用码组后，就认为有错码。当传输过程中发生3个错码时，011变成100，100也是禁用码组，故接收端也能检测出3个错码。但如果011（云）中发生2个错码，接受码组就有可能变成000或110或101，这些都是许用码组，接收端就不能检测到错码，因此这种编码不能检测出2个错码。

上面这种编码只有检错能力，没有纠错能力。例如，如果接收端收到禁用码组111时，接收端能检测出发生错码，但不能纠正过来，因为011（云）、101（阴）、110（雨）发生一个错码都能变成111，天气晴000发生3个错码也能变成111，接收端无法判定是哪个码组发生错码得到的。要想能够纠正错误，还要增加多余度。例如，若规定许用码组只有两个：000表示天气晴，111表示天气雨，其他的码组都为禁用码组。这种编码方式不仅能检测出两个以下错码，还能纠正一个错码。例如，当接收端收到禁用码组001时，倘若该码组是在传输过程中发生一位错码，则接收端能够判断该码组是由000（晴）产生一位错码得来的，因为111（雨）产生一位错码无论如何都得不到001，接收端就可以纠正为000（晴）。但倘若发生错码的个数为1个或2个时，则接收端无法纠正过来，

9

因为111（雨）发生2个错码码组可以变成001，000（晴）发生一个错码也可以变成001，这时接收端只能检测到错码而无法纠正过来，因此这种编码方式只能纠正一个错码。

从上面的例子中，我们可以了解到关于“分组码”的一般概念。如果不要求有检（纠）错能力，为了传输4种不同的消息，用两位的码组就够了，即可以用：00、01、10、11。这些两位码称为信息位。而在上面中使用了3位码，增加的那位称为监督位。把这种将信息码分组，为每组新码附加若干监督码的编码称为分组码。

分组码一般用符号（n，k）表示，其中n是码组的总位数，又称为码组的长度（码长），k是码组中信息码元的数目，n-k=r为码组中的监督码元数目。在分组码中，把码组中“1”的个数目称为码组的重量，简称码重。把两个码组中对应位上数字不同的位数称为码组的距离，简称码距。码距又称为汉明距离。

1.3 纠错编码的分类

随着数字通信技术的发展，各种差错控制编码方案越来越多，其检错与纠错能力也是不一样的，数学模型也不一样，可以从不同的角度对差错控制编码进行分类。

根据对信息元处理方式的不同，可以将纠错码分为分组码与卷积码。分组码是将信息序列以k个码元为一组分成几组，每组又根据一定的编码规则生成若干个r个监督码元，输出一个码长为n=k+r的码组。分组码中的监督码元只与当前码组的信息元有关，与其他码组的信息元没有关系。卷积码则不一样，卷积码不对信息序列进行分组编码，而且卷积码中的监督码不仅与当前时刻的信息码元有关，还与之前时刻输入的信息码元有关。卷积码的缺点是目前还没有找到有效的数学工具和系统理论对卷积码进行分析，但它的实用性远远超过分组码，因此卷积码在数字通讯领域得到广泛的应用。

根据信息码元与监督码元之间的关系的不同，可以将纠错码分为线性码与非线性码。顾名思义，线性码就是指信息码元与监督码元之间呈一定的线性关系，即满足线性叠加原理；如果信息码元与监督码元不满足这种关系，则为非线性码。由于非线性码的分析比较困难，实现较为复杂，所以我们讨论多为线性码。

根据差错控制编码的功能不同，可分为检错码、纠错码和纠删码等。检错码只能检测出错码而无法纠正错码；纠错码不仅具备识别错码功能，同时具备纠正错码功能；纠删码则不仅具备纠错码的所有功能，即检测出错码并纠正错码，

10

而且当错码超过纠正范围无法纠正时，可以把无法纠正的信息删除。

根据每个码元取值不同，可以将纠错码分为二进制码和q进制码。根据信息码元在编码以后形式是否发生改变，可以分为系统码和非系统码。系统码是指信息码元在编码之后保持原来的形式不变，而在非系统码中，信息码元会改变其原有的信号序列。由于原有的码位发生了变化，使译码电路更为复杂，故较少选用。

11

卷积码是1955年由伊莱亚斯（Elias）提出一种非分组码。分组码编码是将输入的信息序列分成长度为k的分组，然后按照一定的编码规则，将长度为k的信息员附加上长度为r的监督元，生成长为n=k+r的码组。在一个码组中，r个监督元仅与本组的k个信息元有关，而与其他各码组均无关。分组译码时，也仅从本码组的码元内提取有关译码信息，而与其他码组无关。卷积码则不同，他先将信息序列分成长度为k的子组，然后编成长为n的子码，其中长为n-k的监督元不仅与本子码的k个信息码元有关，而且还与前面m子码的信息元密切相关。换句话说，各子码内的监督元不仅对本子码有监督作用，而且对前面m个子码内的信息元也有监督作用。因此常用（n，k，m）表示卷积码，其中m为编码记忆，它反映了输入信息元在编码器中需要存储的时间长短；N=m+1称为卷积码的约束度，单位是组，它是相互约束的子码的个数；N*n被称为约束长度，单位是位，它是相互约束的二进制码元的个数。

在线性分组码中，单位时间内进入编码器的信息序列一般都比较长，k可达8~100。因此，编出的码字n也较长。对于卷积码，考虑到编、译码器设备的可实现性，单位时间内进入编码器的信息码元的个数k通常比较小，一般不超过4，往往取k=1。

第二章 卷积码和Viterbi算法

2.1 卷积码基础 2.1.1 卷积码编码原理

我们可以通过一个例子来说明卷积码的编码原理，如图2-1是（3，1，2）卷积码编码器的原理框图。如图所示，（3，1，2）卷积码编码器主要是由两个移位寄存器（m j-1，m j-2）和两个模2加法器组成。编码前，各级移位寄存器清零，输入端依次输入信息序列m 1，m 2，。。。。 。m j，。。。。每输入一个信息码元m j时，输出端开关依次接到X1,j，X2,j和X3,j各端点一次。其中X1,j，X2,j和X3,j由下式决定

12

X1,j=m j

X2,j=m j+m j-2 （2.1.1） X3,j=m j+m j-1+m j-2

由式（2.1.1）中可以看出，编码器输出的信息码元X1,j，X2,j和X3,j不仅与当前时刻的信息码元m j相关，还跟之前时刻的两个信息码元m j-1、m j-2相关，因此编码记忆m=2，约束度N=m+1=3（组），约束长度N*n=9（位）。

X1,j 输入 X2,j 输出 m1,m2,...mj...

m j-1 m j-2 X3,j

图2-1 （3，1，2）卷积码编码器

表2-1 (3,1,2)编码器状态表

m j m j-1。m j-2 X1,j，X2,j.X3,j 状态 1 00 111 a 1 01 110 b 0 11 010 d 1 10 0 01 0 10 011 c 0 00 000 a 0 00 000 a 100 001 c b

表2-1列举了图2-1所示编码器的状态。其中a，b，c，d表示 m j-1m j-2的四种可能的状态：00，01，10，11。当第一位信息比特为1时，即m1=1，因移位寄存器的状态 m j-1。m j-2=00，故输出比特 X1,j，X2,j.X3,j=111；第二位信息比

13

特为1时，因m j-1。m j-2=01，故输出比特 X1,j，X2,j.X3,j=110；其余类推。为了保证输入的全部信息位为11010都能通过寄存器，还必须在信息位后加3个零。

卷积码编码时，信息码流按顺序依次输入进行编码。分组码却不一样，它需要先对信息码流进行分组，分组完后才能进行编码，因此卷积码编码只需要少量的缓冲和存储空间。

2.1.2 卷积码的描述

卷积编码有集中描述方法，其中使用比较多的是树状图、网络图和状态图，现在我们以（2，1，2）卷积码为例来说明各种卷积码的描述方法。

1、树状图

卷积码的树状图能形象的描述卷积码编译码的工程，图2-2画出(2,1,2)卷积码的树状图。树状图从节点so开始，此时移位寄存器状态为00。现在规定：输入信息位为“0”时，则状态往上支路移动；输入信息位为“1”时，则状态往支路移动。如图2-1所示，当第一个输入信息位m1=0时，输出码元为00，移位寄存器的状态仍为so=00；若第一个输入信息位m1=1时，输出码元为11，状态并转换到s1=01。因此从so出发有两条支路可供选择，m1=0时取上面一条支路，m1=1时则取下面一条支路。输入第二个信息位时，移位寄存器右移一位后，上支路情况下移位寄存器状态仍为so，下支路的状态为s1。新的一位输入信息位到来时，随着移位寄存器状态和输入信息位的不同，树状图继续分叉成4条支路，2条向上，两条向下。当输入第二个信息位时，若此时移位寄存器的状态仍为so，则由m2=“0”或“1”和寄存器的状态可得，输出码元为00或11，状态也传换到so或s1状态；若此时移位寄存器的状态为s1，则由m2=“0”或“1”和寄存器的状态可得，输出码元为10或01，状态也传换到s2=10或s3=11状态。如此继续，即可得到图2-2所示的二叉树图形。树状图中，每个树杈上所标注的码元为输出信息位，每个节点上标注的so，s1，s2，s3为移位寄存器的状态。显然，对于第j个输入信息位，有2j条支路，但在j=N≥3时，树状图的节点自上而下开始重复出现4中状态。

14

图2-2 （2，1，2）卷积码的树状图

设现在输入码元序列为1000时，根据上面所述，可得到输出码元为11，10，11，00，相对应的寄存器的状态为s1，s2，so，so，在2-2图中用一条粗黑线描绘出来。

2、状态图

由（2，1，2）编码器结构可知，输出码元不仅决定于当前输入信息位，还决定于前两位信息位。移位寄存器中就有四种可能的状态so=00，s1=01，s2=10，

s3=11，编码器相应的也有4种状态。当输入端依次输入信息序列时，编码器就

不断地从当前时刻的状态转移到下一时刻的状态，并输出信息码元。卷积码的状态图就是用来描述这种状态转移的过程。图2-3所描述就是卷积码（2，1，2）的状态图，虚线表示输入信息位为“1”时状态转变的路线，实线表示输入信息位为“0”时状态转变的路线，线条旁的数字如0/11表示输入信息位为0，输出

15

码元为11，各状态之间的连线与箭头表示状态转移方向。设编码器的初始状态为so，若输入信息位为“0”时，输出码元为00，状态仍为so，；若输入信息位为“1”时，输出码元为11，下一时刻状态仍为s1。随着信息序列的不断输入，编码器就会不断从一个状态转移到另外一个状态，利用这些转移路径不仅可以表示出该转移过程中对应的输出码元，还可以表示出所对应输入信息位。

图2-3 （2，1，2）卷积码的状态图

3、网络图

虽然状态转移图能够描述在不同的信息序列下，编码器的各个状态之间的转移关系，但是它不能描述编码器的状态和时间的关系。为了表示这种关系，我们引进了网络图，以时间为横坐标，编码器的状态为纵坐标，将一个平面划分成网格状，就可以得到卷积码的网络图。

图2-4 （2，1，2）卷积码网络图

16

上图表示是（2，1，2）卷积码网络图，它是由节点和分支组成，L=5，所以一共有L+m+1=8个节点（即时间单位），用0到7加以标号。在网络图中，把树状图中具有相同状态的节点合并在一起，每一状态都有两个输入分支和两个输出分支。上分支表示输入信息码元为“0”时状态转移路线，用实线表示；下分支表示输入信息码元为“1”时状态转移路线，用虚线表示。而每一分支上的n个数字(n=2)表示编码器输出信息序列。可以看出，在时间单位3以后的网络图形完全是重复2时间单位的图形，这就反映了该卷积码的约束长度为2。若编码器从状态so（00）开始，在6个时间单位后结束于状态so（00）。在（2，1，2）卷积码网络图中，由于约束长度为2，编码器在最开始的2个时间单位（t=0，t=1）状态由最开始的so状态向别的状态转移，因此t=1编码器的状态只有可能处于

so或s1状态中一个。编码器在最后的2个时间单位内（t=6，t=7），编码器的状态由别的状态返回so状态。为了在t=7时刻编码器的状态结束于so，编码器在t=6时状态只能为状态so或s2中的一个。而从t=2至第t=5时间单位中，编码器的状态可以处于4个状态s0，s1，s2，s3中的任意一个。一般情况下，网络图中

应有2N-1种状态，输入信息序列有2kL中可能，因而网络图中路径也可能有2kL条，相应于编码器输出的2kL个不同的码序列。例如若给出输入信息位为1101000时，则这时的输出编码序列是11 10 10 00 01 11 00。由上述可见，用网络图表示编码过程和输入输出关系比树状图更为简练。

2.2 Viterbi译码原理 2.2.1Viterbi算法描述

Viterbi算法是一种最大似然译码算法，它是通过计算累积码距，在卷积网络图上寻找一条与接受序列R具有最小码距的最大似然路径。假定编码器输入信息序列为C，经过离散无记忆信道传输后，译码器接受到的序列为R,输入信息序列C与接受信息序列R的关系为R=C+E，E是信息序列在信道传输过程中产生的错误序。译码器根据接受到的信息序列R，根据最大似然原则在卷积网络图上寻找到一条与接受序列R具有最小码距的最大似然路径，这个过程就是译码器寻找有“最大”度量的路径过程，也就是寻找最大似然函数Maxf=logbp(R/Cj),j=1,2,....2kL 的过程，其中L表示时间单位数，k表示输入的bit位数，p（*）表示概率。最大似然函数Maxf=logbp(R/Cj)是Cj的似然函数，也称为Cj的路径度量，Cj表示某一个可能的输入信息序列。对二进制同步信道

17

（BSC）来说，寻找具有最大路径度量的路径（即寻找最大似然函数）相当于寻找与接受序列R有着最小汉明距离的路径，即寻找

Minj=d(R,Cj), j=1,2,....2KL （2.2.1-2） 其中，d（*）是表示汉明距。

我们现在假定L=200，n=2，k=1时，那么卷积码的网络图中就有2200条路径，如果每一条路径都与接受序列R进行逐一比较后寻找最大度量路径，工作量太大啦，因此直接用上述方法进行译码难以实现。为了解决这一困难，Viterbi算法应用而生。Viterbi算法不需要把每一条路径都与接受序列R进行比较，而是接受一段，计算一段，比较一段，选择其中“最大”度量分支，再进行下一轮的比较。当接受完序列R时，幸存下来的那条路径就是我们要寻找的最大路径度量路径。Viterbi译码的总体流程是比较各分支的度量值，选择一段最可能的分支，更新状态的度量，并根据比较结果获得状态转移表，最后通过状态转移表的回溯算法完成译码，其具体步骤如下：

（1）从某一时间单位j=m开始，对每一状态路径长度为j段的路径计算其路径度量值，然后进行比较，对于每一个状态，选择其中有着最大度量的部分路径幸存下来，并存储该部分路径的度量值PM，保留下来的路径称为幸存路径SP。

（2）j+1，计算该时刻进入各个状态的分支度量值BM，把计算得到的分支度量值BM与上一步中幸存路径的路径度量值PM相加，然后进行比较，选择其中相加数最小的路径作为该状态的幸存路径，并更新状态的路径度量值PM，幸存路径就又延长了一个分支。

（3）若j2.2.2Viterbi算法举例

设卷积码编码器（2，1，2）输入信息序列为M=(1011100),经过卷积码编码器后，输出的序列C=(11,10,00,01,10,01,11)，而译码器接受到的序列为R=(10,10,00,01,11,01,11)，可见因为信道的干扰与噪声影响，已经产生了2个错码。下面对照网络图来说明维特比译码的方法。

图2-5描述的是维特比译码器译码的过程。图中d表示各个时刻进入每一个状态的幸存路径的度量值（即最小汉明距离），m表示与此相对应的译码器估计的信息序列。由图可以看出，在某一时刻，如j=3时刻，这一时刻接受到的子码R2=00。寻找S1状态的幸存路径方法如下：这时刻进入S1状态有两条分支，上分支是由前一时刻状态S2在编码器输入信息码元“1”转移而来的，这条路径的度

18

量值d0（S2，00）=d0（11，10,00）=ds2+0=1+0=1;下分支是由前一时刻由前一时刻状态S0在编码器输入信息码元“1”转移而来的，这条路径的度量值d1（S0，11）=d1（00，00,11）=ds0+2=2+2=4。根据最小汉明距离准测可得，进入S1状态应保留上分支，即第三时刻S1状态的幸存路径应为C（S2，00）=（11，10，00），这条路径的度量值是d=1，译码器估计的信息序列m=101。若某一时刻进入某一状态的两条路径有相同的度量，可以选择其中任意一条路径作为幸存路径，并不会影响译码结果的正确性。如第四时刻，进入S2状态的两条路径（11，10，00，10）和（00，11，01，01），它们的度量d都为3，故可任选一条作为S2状态的幸存路径，在图中选择（11，10，00，10）。在其他时刻及进入其余状态的幸存路径的选择与此完全相同。按照这种方法依次译码，到了L+m=7个时刻以后，4条幸存路径只剩一条，这条路径就是我们要找的具有最大似然函数的路径，译码器输出的估值序列C=（11，10，00，01，10，01，11），把接受信息序列R中的两个错误纠正过来啦，相应的估值信息序列M=(1011100),，译码结果跟编码器输入信息序列一样。

19

20

图2-5 维特比译码器的译码过程

21

2.2.3 Viterbi译码器的特点

综上所述，维特比译码器应具备如下特点：

（1）（n.k.m）卷积码编码器中寄存器共有2km个状态，每一个状态都应该配置一个路径存储器和一个PM存储器。路径存储器用来存储译码起点，PM存储器用来存储各个状态的PM值。因为维特比译码器的硬件资源和设置复杂度随约束长度k值呈指数增加，因此在实际应用中，为了避免viterbi译码器功耗过大和成本太高的问题，k一般小于10。

（2） 每个PM存储器存储路径的宽度是nL。L是卷积码译码时译码器需要存储的码序列节点总长度。若nL的取值过大，维特比译码器所占用存储资源的上升会给工程应用带来很多困难。而在一般实际情况中，经过5至6级节点后，各留选SP基本完全重和为一条SP。因此，XL的宽度不必很大，只需选择存储X段译码段即可满足译码需要。

（3）当译码器译码完第x段数据后，必须在所有数据仍为处理完毕前对存储器中SP进行截尾译码判决输出，虽然这样会使误码率稍高，但在工程应用的情况下，取x=(5-10)倍的约束长度，对译码器性能影响很小。

下面介绍截尾译码算法。由图2-5可以看出，当译码器译完第5级节点以后，每个状态留选路径的前几个分支已完全重合在一起，可以将相同的路径输出，从这一点我们可以得知:每个路径寄存器不必存储L很大的码序列(或信息序列M)，而只要存储τ<22

第三章 Viterbi译码的FPGA实现

3.1 Viterbi译码器的基本结构

Viterbi译码器的基本原理是就是将接受到的信息序列R与可能发送的信息序列进行比较，比如发送一个k位序列，那发送的信息序列就有2k种可能，然后将这2k种可能的发送信息序列与接收到的信息序列R进行比较，选择其中汉明距离最小的信息序列作为译码结果。当k值很大时，计算量太大，存储量也很大，不适合直接使用译码方法。维特比算法就解决了这个问题，它不需要比较所有可能的2k种信息序列，而是接受一段，计算和比较一段，选择其中汉明距离最小的码段，再进行下一轮比较，最终找到一个有着最大似然值的信息序列。维特比译码器主要由分支度量模块（BMU）、加比选模块（ACS）、路径度量存储模块（PMU）、幸存路径寄存模块（SMU）、回溯模块（TBU）构成，系统框架图如图3-1。

图3-1 Viterbi 译码器的内部结构图

系统工作过程可以分为以下几个步骤：

（1）首先从（2，1，9）卷积码编码器中输入相应的信息码元，编码器输出信息码元经过分支度量模块BMU，计算译码器接受的信息码元与各状态期望码元之间汉明距离，把计算得到的BM值送人ACS单元进行加比选操作。

23

（2）ACS单元从路径度量存储模块PMU单元中取出前一时刻幸存路径的度量值old_metric,然后与送人ACS单元的分支度量模块BMU的分支度量值累计相加比较，相加度量值较小的作为该状态新的路径度量值new_metric存入PMU单元以备下一时刻加比选使用，并产生幸存路径信息survivor_bit存入幸存路径寄存模块SMU。这个幸存信息表示在加比选操作中，该状态是由前一时刻进入该状态的哪条分支转移而来的，当survivor_bit=0时表示该状态是由偶状态（即上支路）转移而来，当survivor_bit=1时表示该状态是由奇状态（即下支路）转移而来。

（3）当达到回溯深度时，ACS单元会输出一个路径累加度量值最小的状态low_state送人TBU单元，TBU开始工作，同时SMU单元根据这个信号产生一个SMU地址lookup_state,根据这个地址可以从SMU单元中读出该状态的幸存信息

lookup_bit,进入TBU单元进行译码操作输出。同时，也可以根据这个幸存比特反推出这个最小状态是由前一时刻哪个状态转移而来的，而根据反推出来的状态又产生一个新SMU地址lookup_state，根据这个新的地址又可以从SMU单元中读出该状态的幸存信息lookup_bit,再进入TBU单元进行译码操作输出。如此循环下去，就可以得到在回溯深度这个时间段内将所有译码输出，再进行倒序处理，就可以得到正确的译码输出。系统工作操作流程如图3-2。

图3-2 译码器的工作流程图

24

3.2 分支度量模块（BMU）

分支度量模块是比较输入码元与状态分支间的似然函数值，然后将其按照加比选模块提供的地址信号输出相应的数值。由于信道特性的不同，可以分为硬判决跟软判决两种判决方式，硬判决是使用汉明距离来表示分支度量，软判决是使用欧式距离来表示分支度量，不同的判决方式计算接收码元序列跟期望序列之间的距离的计算方法也不一样。在硬判决中，需要设定一个门限值，高于这个门限值的就判决为1，低于这个门限值的就判决为0，因此硬判决只有两种距离,且这两种距离相差为1，这种判决较为简单。例如设期望序列v=｛v0，v1，....vn-1｝,

n1接收到的序列为r=｛r0，r1，...rn-1｝,则汉明距离dHri-vi,而欧式距离为

n-1dE2rivi，如果收到序列r=｛0，1｝,期望序列v=｛1，0｝,使用硬判

i0决，分支度量值就为dHri-vi=|1-0|+|0-1|=2，若使用3比特软判决，1量化为7（111），0量化为（000），则上述所对应的接受序列为r=｛5（101），4（100）｝，

1列期望n序i0i0n-1dErviii02v=｛7，0｝，所以分支度量值则为=（(40)=20。由此可见使用软判决计算分支5-7）22度量值时既有平方运算又有开方运算，运算较复杂，会占用比较多的硬件资源，影响运算速度。本次实验采用硬判决。

对于码率为R=k/n的卷积码来说，每个状态都2k条分支进入，分支度量计算模块就要计算2k个分支度量值，对于（2，1，9）卷积码来说，共有28个即256个状态，每个状态又有2条分支进入，所以总共要计算512个分支度量值。但是，每一个状态的输出期望码元只可能是00，01，10，11这四个中的一个，而且同一时刻接受序列是相同的，所以所有状态的分支度量值也只有4种可能，所以分支度量模块不需要把所有状态的分支度量值都计算出来，只需要把这四种可能的分支度量值计算出来，然后存储到相应的寄存器中，以备不同状态的加比选模块选用。BM00表示期望码字00的分支度量值，BM01表示期望码字01的分支度量值，BM10表示期望码字10的分支度量值，BM11表示期望码字11的分支度量值。而对于码率R=1/3的卷积码来说，每一个状态输出期望码元只可能是000，001，010，011，100，101，110，111中的一个，同样，每一时刻接收到的序列是相同，因此所有状态的分支度量值也只可能有8中情况，分别为BM000，BM001，BM010，BM011，BM100，BM101，BM110，BM111。BM000表示期望码字000的分支度量值，BM001表示期望码字001的分支度量值，BM010表示期望码字010的分支度量值，BM011表示期望码字011的分支度量值，BM100表示期望码字100的分支度量值，BM101表示期望码字101的分支度量值，BM110表示期望码字110的分支度量值，BM111表示期望码字111的

25

分支度量值。

3.3 加比选模块(ACS)

加比选模块是整个viterbi译码器的核心部分，可以说它的性能直接决定着整个译码器的性能。它的主要功能是，把路径度量存储单元（PMU）中存储的各状态所处的路径度量与BMU中相应状态的各分支度量值相加，比较这些结果，选择最小的那个作为该状态幸存路径再存入PMU，并得到路径选择的标志位存入SMU。因此，加比选模块由加法器、比较器、选择器组成。同时，当达到回溯深度时，加比选模块还必须选出累积路径度量值最小的那个状态，在回溯模块TBU译码时使用。

3.3.1状态间的蝶形运算关系

比较哪条路径与发送码字更接近，就是比较它们谁具有更大的似然函数，对于硬判决来说，也即比较谁具有更小的欧氏距离。此时我们面临的主要问题，对于到达某一状态的两条路径来说，它们分别来自哪两个状态。对于（n，k，m）卷积码来说，每个状态有2k条分支进入，其加比选运算如下式

（3-1）

当k=1时，转移到每个状态的分支为2条，每个状态也只可能转移到两个状态中去，输入也只能是0或1，因此这类卷积码的网络结构是蝶形的。假设两个相邻的状态Si=Y0Y1Y30和SJ=Y0Y1Y31,当编码器输入0后，Si和SJ都转移到状态SP=OY0Y1Y3 去；同样地，当编码器输入1后， Si和SJ都转移到状态Sq=1Y0Y1Y3

去, 也就是说状态 SP可能来源Si或Sj，状态 Sq可能来源Si或SJ。可见这四种状态

具有一定的相关性，关系如下图

26

图3-3 ACS蝶形运算结构图

设编码器输入为x，当前状态变量为Y0Y1Y3a,则编码器的输出可以表示为 Vout=X  f(Y0Y1Y3)  a (3-2)

所以当源输入比特为“1”，编码器在状态Si=Y0Y1Y30时，卷积码编码器输出为

Vout=X  f(Y0Y1Y3)  a =1  f(Y0Y1Y3)  0 (3-3) 而当源输入比特为“0”，编码器在状态Sj=Y0Y1Y31时，卷积码编码器输出为

Vout=X  f(Y0Y1Y3)  a =0  f(Y0Y1Y3)  1 (3-4) 比较上述两式，可以看出来，卷积码编码器在当前状态Si时输入“1”时输出的码序列和在当前状态Sj时输入“0”时输出的码序列是一样的，因此译码器在这两个状态时所对应的不同分支具有相同的期望码序列。又由于译码器在同一时刻接收到的码序列是一样的，所以可以推出这两个相邻状态的所对应的不同分支具有相同的分支度量值，即Si状态的下分支的分支度量值跟Sj状态的上分支的分支度量值是一样的。同理可得，Si状态的上分支的分支度量值跟Sj状态的下分支的分支度量值是一样的。通过以上分析，源状态和目的状态之间满足如下关系：

27

（3-5）

ACS蝶形运算单元可以由图3-3所示的加比选电路结构构成，一个蝶形加

比选模块单元由两个基本的加比选单元组成，输入相邻状态的幸存路径，同时输入相应的分支度量值（根据上述的对称关系，只需要输入一个状态的分支度量值），进行累加比较，输出下一转移状态的幸存路径。SI是输出状态的幸存信息，当SI=0时，说明该状态是由前一时刻的偶状态转移而来的；当SI=1时，说明该状态是由前一时刻的奇状态转移过来的。例如当SIP=0时，说明状态SP是由上一时刻Si转移而来；当SIP=1时，说明状态SP是由上一时刻S j转移而来。

图3-4 蝶形加比选模块

28

3.3.2 加比选的实现方式

加比选ACS单元一般有全串行、全并行、串并行结合的三种实现方式，这三种实现方式分别适用不同的需求。全串行ACS方式只需要一个ACS单元，一次也只能处理一个状态的路径度量的加比选操作，总共需要2k个处理时钟周期才能完成对所有状态的路径度量的加比选操作，该方式实现起来简单，占用硬件资源少，但处理速度太慢，适用于硬件资源少而且对译码速度要求不是很高的卷积码译码。全并行ACS方式需要同状态数目相同个的ACS单元，一次性完成所有状态的路径度量的加比选操作，该方式处理速度很快，但占用硬件资源很大，不适用于约束长度大的卷积码译码，例如对于卷积码（2，1，9）来说，全并行ACS虽然一个处理时钟周期可以完成28=256个状态的路径度量的加比选操作，但需要28=256个ACS单元，硬件资源占用巨大。串并行结合的ACS，是把所有状态经过分组后分配给一定数目的ACS单元进行处理，这些ACS单元同时进行处理，每个处理时钟周期内没有一个ACS单元处于空闲状态，同时所有状态数M能够平均分到N个ACS单元（即M能够被N整除），因此完成所有状态的路径度量的加比选操作只需要M/N个处理时钟周期，这种传并行结合的方式既提高了译码的速度，又兼顾到了硬件资源的占用量。

3.3.3 溢出处理

在Viterbi译码过程中，ACS单元运算更新得到的路径度量值是通过不断累加得到的，因为每个状态的分支度量值都是非负的，随着译码过程的不断进行，路径度量值会不断的增加。但路径度量值是存储在有限容量的寄存器中，当路径度量值超过有限位长所能表示的最大值时，就会造成溢出错误，导致加比选模块出错，影响到译码结果。因此，为了避免发生溢出问题，我们需要对路径度量值做适当的处理，一般采用的方法有两种：普通归一化和求模归一化。普通归一化就是一个译码周期完成后，找到最小的路径度量值，然后将每个状态的路径度量值减去这个最小值，从而实现归一化。这种方法虽然可以有效地防止数据的溢出，但是在进行N次加比选操作后，要进行大量的比较工作才能找出其中最小的路径度量值，并且还要把各个状态的路径度量值减去这个最小值的结果存储起来，以备下一轮的加比选操作使用。这种方法运算比较复杂，其时钟和硬件资源比较浪费，不适用于约束长度k较长的卷积码译码。由于加比选操作是比较两个分支累加的路径度量值的大小，选择较小的作为当前时刻的路径度量值，因此ACS单元需要的是两个路径度量值的相对大小，而不关系其具体值的大小，可以利用

29

这个来解决数据溢出问题。具体实现如下：当检测到某个路径度量值大于阈值要溢出来时，在处理下一个译码码元时，把从PMU读出来的路径度量值都先右移一位再进行ACS运算，运算后存入PMU的数据还需要继续检测，若仍超过阈值，则处理第三个待译码元时仍需要先移位再进行运算。这就相当于当检测到路径度量值要溢出时，将所有的路径度量值都右移一位，虽然路径度量值的大小发生变化，但并没有改变路径度量值的相对大小。这种方法结构简单，又能节省硬件资源，更适合FPGA实现方式。

3.4 路径度量存储模块（PMU）

路径度量存储模块（PMU）是维特比译码器的很重要的部分，是用来存储路径度量值的。在每个处理时钟周期，它负责向ACS单元提供上一时刻各个状态的路径度量值，经过ACS加比选操作后，再存储新一段的各个状态的幸存路径度量，以备下一轮译码使用。因此，加比选模块和路径度量模块之间有效的存储方案对Viterbi译码器的性能十分重要。状态度量的更新有两种方式，一种是ping-pong模式，即乒乓模式；一种是原位模式。

乒乓模式指的是两组路径度量存储单元交替使用，一个用来保存更新后的路径度量值，然后另一个则用来存储旧的路径度量值。当前时刻加比选模块从一块存储器中读取前一时刻的路径度量，然后进行加比选运算，更新完的路径度量存入另一块存储器中，这样读写就不会发生冲突。兵兵模式的缺点是需要两块路径度量寄存器，占用的硬件资源较大，优点是控制电路比较简单。以卷积码（2，1，9）为例，假设每个路径度量宽度为10位，则路径度量存储单元总共需要2个10*256 bits的RAM。兵兵模式最大的特点就是在“输入数据选择单元”与“输出数据选择单元”之间进行相互切换，将数据缓冲区中的数据有条不紊地送到数据流运算处理模块进行处理，这样输入数据流和输出数据流都是连续的，不间断的。兵兵模式非常适合数据流流水线式处理方式，常常应用于流水线式算法，完成数据无缝处理与缓冲。

原位模式是指在ACS单元中运算出来的新的路径度量值立即写到读出来的前一时刻路径度量值的地址中去，因为前一时刻路径度量值在这一轮运算中是不需要的。因此原位更新模式只需要一块路径度量寄存器来进行度量的更新，每一次的更新量都覆盖前一时刻的路径度量。它的优点是只需要一块存储单元，使用的存储资源较少，缺点是它需要处理好存储地址的控制，不然更新后的路径度量会破坏掉先前有用的路径度量信息，地址的分配与控制就变得很复杂。使用原位

30

模式更新路径度量值存在以下几个问题：首先，对同一地址进行读写操作可能会发生冲突，由于器件固有的延时，可能会造成当前时刻的读出与前一时刻的写入造成重叠，使得译码发生错误；其次，读出和写入不是同一个状态，原位更新后，地址循环右移，这就增加了硬件实现的难度，这种方法虽然节省了硬件资源，但是以增大实现和控制的复杂度为代价的。

为了节省RAM资源，但同时又不增加控制和实现的复杂度，可以采用改进的“兵兵方式”对路径度量值进行存储和更新。在同一块RAM中读出一个状态的路径度量值，同时写入更新的路径度量值，为了要保证读出和写入的数据不被覆盖，地址控制成了关键。我们以（2，1，9）卷积码为例，它共有28=256个状态，使用双口RAM，读取和写入地址分开，同时进行，地址宽度为10。把RAM分成两个区，A区与B区，A区地址为0-255，B区地址为256-512。首先对A区RAM进行初始化，初始值为0。初始化完毕后，进行ACS加比选运算，运算得出的当前时刻的路径度量值存储到B区。按照蝶形地址规律，读地址为（0，1，2，....，255），写地址为（256，257，....，511）。在第一译码周期时，经过256个处理时钟周期，A区数据已经被读出，更新的路径度量值也被存储到B区，B区数据也即是下一个译码周期中需要读出的路径度量值。所以，在第二译码周期，A区与B区功能互换，A区为写数据区，B区为读数据区，此时读地址为256，257，....，511），写地址为（0，1，2，....，255）。ACS单元从B区中读出旧的状态路径度量值，把运算出来的当前时刻的路径度量值存入A区，经过256个处理时钟周期后，B区数据也被全部读出，A区数据为下一译码周期中需要读出的数据。到了第三译码周期，A区与B区读写功能又进行互换，A区为读数据区，B区为写数据区，读写地址跟第一个译码周期一样。如此循环下去，直到译码结束。

3.5 幸存路径寄存模块（SMU）

幸存路径存储模块是用来存储在ACS运算单元中产生的幸存信息比特的，通过这些幸存信息得到所有状态的幸存路径，选择其中一条合适的幸存路径作为输出，从而得到卷积码的译码结果。路径寄存器是整个译码器的关键部分，可以说它的实现结构接决定着整个译码器的复杂度。寻找幸存路径和译码输出有两种主要方法：寄存器交换法（RE）和回溯法（TB）。

31

3.5.1 寄存器交换法

寄存器交换方法RE是通过存储幸存比特信息，不断改变寄存器中的数据实现译码的。每一时刻都有两条分支进入当前状态，通过比较这两条分支的路径度量值，选择其中路径度量值较小的作为当前状态的路径度量值，并把该分支连同该分支之前的路径作为当前状态更新的幸存路径。而在ACS运算过程产生的幸存信息则表示当前状态是由前一时刻哪条分支转移而来的，当SI=0表示当前状态是由前一时刻的上分支转移而来的，当SI=1表示当前状态是由前一时刻的下分支转移而来的，因此可以根据前一时刻状态的幸存路径加上幸存信息就可以得到当前状态的幸存路径。寄存器交换法就是利用这个机理，把前一时刻状态的幸存路径信息存储到当前状态的所对应的幸存路径寄存器中，再加上跳转信息就相当于存储了当前状态的幸存路径信息。

图3-5 寄存器交换算法原理图

图3-5是寄存器交换算法原理图，每一状态用一个长度为译码深度的寄存器来存储幸存信息。若当前状态最高位为0，则该状态一定是由前一时刻状态输入0转移而来，即编码器输入为0，寄存器存储0；若当前状态最高位为1，则该状态一定是由前一时刻状态输入1转移而来，即编码器输入为1，寄存器存储1。选择器是由本状态的加比选单元输出的幸存信息控制，每个状态根据加比选单元输出的幸存信息来推断出前一个状态。每一时刻，把当前状态新的幸存比特从右端输入前一状态的幸存路径寄存器中，然后再把这复制到当前状态的幸存路径寄存器中，完成寄存器的交换。图3-5中，t=2时刻状态S2是由前一时刻S0转移而来的，前一时刻S0寄存器的值为0，将当前时刻S2新的幸存信息1从右边输入前

32

一时刻S0寄存器中得到01，然后复制到当前S2寄存器中，完成寄存器的交换。当寄存器达到译码深度时，该状态的幸存路径寄存器最左端就是译码的输出。

寄存器交换法优点是能立即输出译码结果，速度快，原理简单，译码延时小。缺点是所需寄存器资源会随着卷积码约束长度的增加呈指数增加，硬件资源占用巨大，同时大量的寄存器交换会造成很大的功耗，因此不适用于约束长度大的维特比译码。

3.5.2 回溯法

任一条幸存路径的当前状态和该时刻的幸存信息比特唯一地决定了该幸存路径在前一时刻的状态，从当前时刻逐步往前推进，就可以在网络图上当前时刻之前的各个时刻的状态，从而得到译码结果，这种方法就是回溯法。

图3-6 维特比译码回溯算法

图3-6表示出维特比译码回溯过程。如图所示，回溯从具有最大似然度量的S2（10）状态开始，当前时刻的幸存信息SI=1，可得当前状态S2（10）是由 前一时刻的下分支状态转移而来的，所以前一时刻状态是S1（01）状态。从状态S1（01）转移到状态S2（10），编码器输入为1，所以译码结果就为1。而状态S1此刻的幸存信息为SI=1，说明状态S1（01）是由前一时刻的奇状态转移而来， 所以前一时刻状态是S3（11）状态。从状态S3（11）转移到状态S1（01），编码

33

器输入为0，所以译码结果就为0。依次类推，回溯路径为

再做一个倒序处理，就可以得到正确的译码输出（101101）。

实际通信系统中使用截短译码，每个状态只存储a比特的幸存信息，所以幸存路径存储单元的存储空间RAM为ab，a为回溯深度，b为状态总数，当达到回溯深度时RAM存满，开始回溯操作。开始阶段的幸存路径还没有合并，只有合并后的幸存路径才是最大似然的，才能用回溯算法进行运算，因此实际应用中的回溯法包括回溯读操作、译码读操作和写入新数据操作三个过程。回溯读操作和译码读操作是从幸存路径存储单元RAM中读出数据，写入新数据操作是把更新的幸存路径数据存入RAM。

（1）回溯读操作：回溯读操作跟传统的回溯算法一样，它结合当前幸存路径状态信息和该时刻的幸存信息得到前一时刻的状态，但跟传统的回溯不一样，该过程不产生译码结果，因为开始阶段回溯的幸存路径还没有合并，不是最大似然路径。当回溯步数达到译码深度时，所有路径合并成一条路径才能找到最大似然路径，这样才能够得到较为精确的译码结果。

（2）译码读操作：译码读操作跟回溯读操作基本操作是一样的，但不同的是该过程产生译码结果。译码操作是从回溯操作中找到的最大似然路径的终点状态开始，回溯一步就输出一个译码结果，同时存储空间也随着释放，写入新数据。

（3）写入新数据操作：ACS单元不断产生新的幸存信息，把这些数据存储到相应状态的存储器中，以便后面译码和回溯操作使用。

由Viterbi译码算法可知，在网络图上经过大约5倍的约束长度时刻后，所有幸存路径大概都会合并成一条幸存路径，因此选择合适的回溯长度a开始回溯，当回溯到第a个节点时开始输出译码结果。

3.6 回溯模块(TBU)

回溯单元(TBU)是维特比译码器最后的一部分，它主要的作用也就是当需要判决的时候，进行路径寄存器的回溯，将所得到的信息序列作为译码比特进行输出。

它采用了3.4节所论述的具有较好性能的选择回溯作为回溯的方法，也就是先比较加比选模块中的各状态的路径度量寄存器中的值，从中选出一个具有最小度量值的状态，状态序号的二进制表示从低位到高位对应了译码序列的最后8个编码尾比特，按顺序将这8个比特放入判决模块的40比特输出寄存器中的后8位。并检测这一状态的对应于此时刻的路径寄存器中的比特是1还是0，从而

34

判断出它的上一状态。如此，便可逐级回溯，直到回溯到某一状态的路径寄存器的最低位。回溯模板框图如下图所示。

路径指针状态计算模块num为判决时具有最小路径度量的状态的序号numn路径寄存器二选一模块状态选择信号选择信号寄存器位置信号读写控制输出寄存器地址信号回溯控制模块来自控制模块输出TB 图3-7 回溯模块框图

状态计算模块是在已知此时刻的状态和路径指针的情况下要计算出上一时刻的状态。假设在时刻t的状态为Si,路径指针为x，则上一时刻的状态Sk为

Sk=(Si-Simod2)/2+128*x (3-5-1) 在计算完成后，状态度量寄存器会将新得到的状态存入寄存器中，用来在下次计算中使用。

回溯控制模块是整个回溯模块的核心，它控制着其它各个模块的时序。在收到来自控制模块的通知信号后，回溯控制模块便开始进入工作。

输出寄存器用来存储由回溯得到的幸存路径，其中每一时刻数据存储在什么位置是由回溯控制模块提供的地址信号来决定的。输出寄存器读入数据或向外输出数据是由读写控制信号来决定。回溯完成后，输出寄存器可在每一时钟输出一比元，在下次判决完成时刚好全部输出完毕，便可再进行下一轮的输出。这样译码延时可控制在48个码元周期，是非常小的。

35

整个系统使用Verilog HDL完成设计的，在Altera公司的quartusII软件上输入代码，进行综合编译和时序仿真。VHDL语言具有多层次描述系统硬件功能的能力，支持自上而下和基于库的设计方法。本次设计就是使用VHDL语言，用quartusII软件仿真的结果如下。

4.1 卷积码编码器设计

（2，1，9）卷积码编码框图如下图所示，其中D是寄存器，是模二运算。由卷积码编码框图可得（2，1，9）卷积码编码器输出的多项式表示为 Y1（x）=1+x+x+x+x Y2（x）=1+x+x+x+x+x+x

2

3

5

7

8

2

3

4

8

第四章 Viterbi译码器的设计与仿真结果

图4-1 （2，1，9）卷积码编码框图

(2,1,9)卷积码编码器的约束长度k=9，编码器的码率为1/2，即编码器输入1比特数据，输出为2比特的数据。它可以由寄存器和模二加法完成。

（2，1，9）卷积码编码器的综合图如4-2图所示。其中，Rst_n为低电平有效的复位信号，Clk为时钟输入信号,data_in是卷积码编码器的输入信号，data_out是卷积码编码器的输出信号。

36

图4-2 （2，1，9）卷积码编码器综合图

（2，1，9）卷积码编码器的仿真波形就如4-3所示

图4-3 （2，1，9）卷积码编码器仿真波形图

4.2 Viterbi 译码器的设计

为了保证本设计中VIterbi译码器的正确性，接下来将对其进行严格的仿真测试。本文设计的维特比译码器的一些参数如下：

(1) 采用硬判决，分支度量模块计算的是接受信息序列与各状态的期望信息序列的汉明距离。

(2) 加比选模块采用 ACS串行方式实现； (3) 路径度量存储单元采用乒乓方式实现；

(4) 采用回溯法进行译码，取回溯深度为：τ=，回溯的起点为每个时刻最小路径度量所对应的状态。

原始的信息序列利用随机函数rand()随机产生32个信息比特，然后再加上8个尾比特0，再经过卷积编码程序，输出卷积编码。

编码器输入信息序列为：

[1,0,1,0,1,1,0,0,1,0,1,1,1,1,0,0,1,1,0,1,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0]

37

接收端收到的信息比特为：

[3,3,0,3,0,0,3,0,3,2,0,0,0,0,0,0,0,2,2,3,3,0,1,0,0,3,0,0,3,3,3,0,0,0,0,0,0,3,0,3,3,0,3,3,0,3,3,0,0,0,0,0,2,3,0,3,0,3,2,2,0,1,0,3,0,0,2,3,3,0,0,3,0,3,0,0,0,3,3,3]

译码结果如下图5-2所示：

图4-4 维特比译码器的译码结果

38

第五章 结束语

本文设计的是一个(2,1,9)卷积码的Viterbi译码器，通过对Viterbi算法的分析和对FPGA设计知识的熟练掌握，以及对VHDL硬件描述语言的学习，本文的设计才得以完成。当然在对Viterbi译码器的FPGA设计中，熟练应用各种EDA工具也是非常必要的。在本设计中采用了串行的状态处理方法，并用了加比选蝶形算法和路径寄存器的回溯算法以及一种改进的路径度量处理方式，大大的节约了系统的逻辑资源，但系统的时钟频率和系统的译码速率却受到了一定的影响。在系统的设计中，速率和面积始终是一个矛盾，要想做到两者的平衡是非常困难的。

当然，在本文的设计中也有一些不足，如对一些新的Viterbi算法的研究和实现（如软判决等）；对系统进行更好的优化，以提高速度和减小面积，这些都是非常值得研究的。

39

参考文献

[1] 程晓江,马晓军,刘洛琨.卷积码Viterbi译码器的FPGA的设计与实现[J]. 通信技术. 2003(03)

[2] ,刘小林,匡镜明,王华.高速Viterbi译码器的FPGA实现[J]. 电讯技术. 2006(03)

[3] 刘阳美, 余宁梅, 宋连国, 王韬；一种串行Viterbi译码器的FPGA设计与实现[J].中国电子科学研究院学报.2006(05)

[4] 黄华柱,刘荣科,王闰昕. 一种串行结构的2,1,7卷积码维特比译码器的FPGA实现[J]. 遥测遥控. 2009(03)

[5]井小沛,武斌,张青春. 基于FPGA的卷积码的编/译码器设计[J]. 电子测量技术. 2008(02) [6]

Chakraborty,

D.

;

Raha,

P.

;

Bhattacharya,

A.

;

Dutta,

R.

Speed optimization of a FPGA based modified viterbi decoder . Computer Communication and Informatics (ICCCI), 2013 International Conference on , 10.1109/ICCCI.2013.66245: 1 - 6

[7] Man Guo ,Ahmad, M.O. ,Swamy, M.N.S. FPGA design and implementation of a

low-power systolic array-based adaptive Viterbi decoder .Circuits and Systems I: Regular Papers, IEEE Transactions on , 10.1109/TCSI.2004.838266: 350 - 365

[8] 刘虎. 基于FPGA的Viterbi译码器设计与实现[D]. 电子科技大学 2009 [9] 黄高峰. 维特比译码器的FPGA实现[D].成都理工大学 2010

[10] 张慎.卷积码编码器及Viterbi译码器的设计[D].电子科技大学 2008 [11] 庞永强. 基于FPGA的Viterbi译码器实现[D]. 电子科技大学 2006 [12]苗长云.现代通信原理及应用.北京电子工业出版社，2009 [13]潘松，黄继业.EDA技术实用教程.北京科学出版社，2006

[14] 罗常青,安建平. Viterbi译码器的通用结构及其FPGA实现[A]. 通信理论与信号处理新进展——2005年通信理论与信号处理年会论文集[C]. 2005 [15]王金明,杨吉斌. Viterbi译码器的FPGA实现[A]. 开创新世纪的通信技术——第七届全国青年通信学术会议论文集[C]. 2001

40

附录

附录一： 分支度量模块BMU的程序 BMU.VHD

library ieee ;

use iee .stdlog ic1 .a l l ;

use i e e e . s t d l o g i c a r i t h . a l l ; entity bmu is

port ( i0 , i1 , i 2 : in s t d l o g i c v e c t o r ( 2 downto 0 ) ; bmu000 , bmu001 , bmu010 , bmu011 , bmu100 , bmu101 , bmu110 , bmu111 : out s t d l o g i c v e c t o r ( 4 downto 0 ) ) ;

end bmu;

architecture r t l of bmu i s begin

process ( i0 , i2 , i 1 )

variable temp000 0 , temp000 1 : s t d l o g i c v e c t o r ( 4 downto 0 ) ; begin

temp000 0 := c o n v s t d l o g i c v e c t o r ( c o n v i n t e g e r ( s i gned ( i 0 ) )+ c o n v i n t e g e r ( s i gned ( i 1 ) ) , 5 ) ;

temp000 1 := c o n v s t d l o g i c v e c t o r ( c o n v i n t e g e r ( s i gned ( temp000 0 ))+ c o n v i n t e g e r ( s i gned ( i 2 ) ) , 5 ) ; bmu000<=temp000 1 ; end process ;

process ( i0 , i2 , i 1 )

variable temp000 0 , temp000 1 : s t d l o g i c v e c t o r ( 4 downto 0 ) ; begin

temp000 0 := c o n v s t d l o g i c v e c t o r ( c o n v i n t e g e r ( s i gned ( i 0 ) )+ c o n v i n t e g e r ( s i gned ( i 1 ) ) , 5 ) ;

temp000 1 := c o n v s t d l o g i c v e c t o r ( c o n v i n t e g e r ( s i gned ( temp000 0 ))− c o n v i n t e g e r ( s i gned ( i 2 ) ) , 5 ) ; bmu001<=temp000 1 ; end process ;

process ( i0 , i2 , i 1 )

variable temp000 0 , temp000 1 : s t d l o g i c v e c t o r ( 4 downto 0 ) ; begin

temp000 0 := c o n v s t d l o g i c v e c t o r ( c o n v i n t e g e r ( s i gned ( i 0 ))− c o n v i n t e g e r ( s i gned ( i 1 ) ) , 5 ) ;

temp000 1 := c o n v s t d l o g i c v e c t o r ( c o n v i n t e g e r ( s i gned ( temp000 0 ))+ c o n v i n t e g e r ( s i gned ( i 2 ) ) , 5 ) ; bmu010<=temp000 1 ; end process ;

process ( i0 , i2 , i 1 )

41

variable temp000 0 , temp000 1 : s t d l o g i c v e c t o r ( 4 downto 0 ) ; begin

temp000 0 := c o n v s t d l o g i c v e c t o r ( c o n v i n t e g e r ( s i gned ( i 0 ))− c o n v i n t e g e r ( s i gned ( i 1 ) ) , 5 ) ;

temp000 1 := c o n v s t d l o g i c v e c t o r ( c o n v i n t e g e r ( s i gned ( temp000 0 ))− c o n v i n t e g e r ( s i gned ( i 2 ) ) , 5 ) ; bmu011<=temp000 1 ; end process ;

process ( i0 , i2 , i 1 )

variable temp000 0 , temp000 1 : s t d l o g i c v e c t o r ( 4 downto 0 ) ; begin

temp000 0 := c o n v s t d l o g i c v e c t o r (−c o n v i n t e g e r ( s i gned ( i 0 ) )+ c o n v i n t e g e r ( s i gned ( i 1 ) ) , 5 ) ;

temp000 1 := c o n v s t d l o g i c v e c t o r ( c o n v i n t e g e r ( s i gned ( temp000 0 ))+ c o n v i n t e g e r ( s i gned ( i 2 ) ) , 5 ) ; 80

bmu100<=temp000 1 ; end process ;

process ( i0 , i2 , i 1 )

variable temp000 0 , temp000 1 : s t d l o g i c v e c t o r ( 4 downto 0 ) ; begin

temp000 0 := c o n v s t d l o g i c v e c t o r (−c o n v i n t e g e r ( s i gned ( i 0 ) )+ c o n v i n t e g e r ( s i gned ( i 1 ) ) , 5 ) ;

temp000 1 := c o n v s t d l o g i c v e c t o r ( c o n v i n t e g e r ( s i gned ( temp000 0 ))− c o n v i n t e g e r ( s i gned ( i 2 ) ) , 5 ) ; bmu101<=temp000 1 ; end process ;

process ( i0 , i2 , i 1 )

variable temp000 0 , temp000 1 : s t d l o g i c v e c t o r ( 4 downto 0 ) ; begin

temp000 0 := c o n v s t d l o g i c v e c t o r (−c o n v i n t e g e r ( s i gned ( i 0 ))− c o n v i n t e g e r ( s i gned ( i 1 ) ) , 5 ) ;

temp000 1 := c o n v s t d l o g i c v e c t o r ( c o n v i n t e g e r ( s i gned ( temp000 0 ))+ c o n v i n t e g e r ( s i gned ( i 2 ) ) , 5 ) ; bmu110<=temp000 1 ; end process ;

process ( i0 , i2 , i 1 )

variable temp000 0 , temp000 1 : s t d l o g i c v e c t o r ( 4 downto 0 ) ; begin

temp000 0 := c o n v s t d l o g i c v e c t o r (−c o n v i n t e g e r ( s i gned ( i 0 ))− conv i n t e g e r ( s i gned ( i 1 ) ) , 5 ) ;

temp000 1 := c o n v s t d l o g i c v e c t o r ( c o n v i n t e g e r ( s i gned ( temp000 0 ))− c o n v i n t e g e r ( s i gned ( i 2 ) ) , 5 ) ; bmu111<=temp000 1 ;

42

end process ; end r t l；

附录二：加比选模块程序 ACSU.VHD

l ibrary i e e e ;

use i e e e . s t d l o g i c 1 1 6 4 . a l l ; use i e e e . s t d l o g i c a r i t h . a l l ; entity acsu i s

port (PMi , BMip , PMj , BMjp , clk , r e s e t c a r r y , c l k sub : in s t d l o g i c ; PM, comp out : out s t d l o g i c ) ; 82

end acsu ; −− This module r e p r e s ent s one uni t of the add compare s e l e c t ope rat ion . architecture r t l of acsu i s

signal r e s u l t c , r e s u l t a i n t e r n a l , r e s u l t a b a r , c ina : s t d l o g i c ; signal r e s u l t b i n t e r n a l , c inb : s t d l o g i c ; signal c inc , s e l e c t i o n , c l k da t a : s t d l o g i c ;

signal r e s u l t a , r e s u l t b : s t d l o g i c v e c t o r ( 0 to 7 ) ; begin

c lk dat a <= c l k ; −− This proc e s s r e p r e s ent s the f i r s t and second FIFO and the l a t c h e s −− f o r the car ry of the t h r e e FAs and a l s o the s e l e c t i o n of the −− sma l l e r PM according to the MSB of the s u b t r a c t i o n .

process ( c lk dat a , r e s u l t c , r e s u l t a b a r , BMjp , PMj , r e s u l t a b a r , s e l e c t i o n , cinb , c inc , c lk sub , r e s e t c a r r y , clk , BMip , PMi , cina ,

r e s u l t a i n t e r n a l , r e s u l t b i n t e r n a l , r e su l t a , r e s u l t b ) begin

i f r e s e t c a r r y = ’1 ’ then cina <=’0 ’ ; cinb <=’0 ’ ; c inc <=’0 ’ ;

e l s i f c l k da t a =’0 ’and c lk dat a ’ event then

cina <= ((PMi AND BMip ) OR ( c ina AND PMi ) OR ( c ina AND BMip ) ) ; cinb <= ((PMj AND BMjp ) OR ( c inb AND PMj ) OR ( c inb AND BMjp ) ) ;

c inc <= (( r e s u l t a b a r AND r e s u l t b i n t e r n a l ) OR ( c inc AND r e s u l t a b a r ) OR ( c inc AND r e s u l t b i n t e r n a l ) ) ; end i f ;

i f c l k = ’1 ’ then −− f i r s t FA

r e s u l t a i n t e r n a l <=PMi XOR BMip XOR ( c ina ) ; r e s u l t a b a r<=not (PMi XOR BMip XOR ( c ina ) ) ; −− second FA

r e s u l t b i n t e r n a l <=PMj XOR BMjp XOR ( c inb ) ;

43

−− t h i r d FA, which a c t s as a s u b t r a c t o r

r e s u l t c <= r e s u l t a b a r XOR r e s u l t b i n t e r n a l XOR ( c inc ) ; end i f ;

end process ;

process ( c lk dat a , r e s u l t c , r e s u l t a b a r ,BMjp , PMj , r e s u l t a b a r , s e l e c t i o n , cinb ,

c inc , c lk sub , r e s e t c a r r y , clk , BMip , PMi , cina , r e s u l t a i n t e r n a l , r e s u l t b i n t e r n a l , r e su l t a , r e s u l t b ) begin

i f c l k = ’0 ’ and clk ’ event then

r e s u l t a ( 0 to 7)<= r e s u l t a i n t e r n a l&r e s u l t a ( 0 to 6 ) ; r e s u l t b ( 0 to 7)<= r e s u l t b i n t e r n a l&r e s u l t b ( 0 to 6 ) ; i f c l k sub = ’1 ’ then 83

s e l e c t i o n <= not ( r e s u l t c ) ; −− comp out <=not ( r e s u l t c ) ; end i f ; end i f ;

end process ;

comp out<=s e l e c t i o n ;

PM<=r e s u l t a ( 7 ) when s e l e c t i o n = ’1 ’ el se r e s u l t b ( 7 ) ; end r t l ;

l ibrary i e e e ;

use i e e e . s t d l o g i c 1 1 6 4 . a l l ; entity a c s u p a i r i s

port (PMi , BMip , PMj , BMjp , clk , r e s e t c a r r y : in s t d l o g i c ; msb BMjp , comp enable , reset PM : in s t d l o g i c ; PMp, PMq, termi , termj , de c i , de c j : out s t d l o g i c ) ;

end a c s u p a i r ; −− This module r e p r e s ent s one b u t t e r f l y uni t , which contains a pai r −− of the ACSU components . architecture r t l of a c s u p a i r i s component acsu

port (PMi , BMip , PMj , BMjp , clk , r e s e t c a r r y , c l k sub : in s t d l o g i c ; PM, comp out : out s t d l o g i c ) ;

end component ;

signal PMi int e rnal , PMj inte rnal , comp1 , comp2 : s t d l o g i c ; begin

acsu1 : acsu port map( PMi int e rnal , BMip , PMj inte rnal , BMjp , clk , r e s e t c a r r y , comp enable , PMp, comp1 ) ;

acsu2 : acsu port map( PMi int e rnal , BMjp , PMj inte rnal , BMip , clk , r e s e t c a r r y , comp enable , PMq, comp2 ) ;

44

process (PMi , PMj , reset PM , c l k ) begin

I f ( c l k = ’1 ’ and clk ’ event ) then −− (PMi and PMj need to be r e s e t wi th each r e s e t of the decoder ) PMi int e rnal<=PMi AND reset PM ; PMj inte rnal<=PMj AND reset PM ; end i f ;

end process ;

termi<=(not ( comp1 ) ) and ( not ( comp2 ) ) ; termj<=comp1 and comp2 ;

de c i<=(not ( comp1 ) and comp2 ) or (msb BMjp and ( not ( comp1 ) ) and ( not ( comp2 ) ) ) or ( (msb BMjp ) and comp1 and comp2 ) ;

decj<=(not ( comp2 ) and comp1 ) or ( not (msb BMjp ) and ( not ( comp1 ) )and(not ( comp2 ) ) ) or ( not (msb BMjp ) and comp1 and comp2 ) ; end r t l ;

l ibrary i e e e ;

use i e e e . s t d l o g i c 1 1 6 4 . a l l ; entity a c su bl o ck i s

port (BM, msb BMjp : s t d l o g i c v e c t o r ( 0 to 7 ) ; 84

clk , r e s e t c a r r y : in s t d l o g i c ; comp enable , reset PM : in s t d l o g i c ;

term , dec : out s t d l o g i c v e c t o r ( 0 to 2 5 5 ) ) ;

end a c su bl o ck ; −− This module r e p r e s ent s the whole ACSU. I t contains 126 uni t s of the −− acsu component .

architecture s t r u c t of a c su bl o ck i s component a c s u p a i r

port (PMi , BMip , PMj , BMjp , clk , r e s e t c a r r y : in s t d l o g i c ; msb BMjp , comp enable , reset PM : in s t d l o g i c ; PMp, PMq, termi , termj , de c i , de c j : out s t d l o g i c ) ;

end component ;

signal PM: s t d l o g i c v e c t o r ( 0 to 2 5 5 ) ; begin

a c su pa i r 1 : a c s u p a i r port map

(PM( 0 ) , BM( 0 ) , PM( 1 2 8 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable , reset PM , PM( 0 ) , PM( 1 ) , term ( 0 ) , term ( 1 2 8 ) , dec ( 0 ) , dec ( 1 2 8 ) ) ; a c su pa i r 2 : a c s u p a i r port map

(PM( 1 ) , BM( 3 ) , PM( 1 2 9 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp enable , reset PM , PM( 2 ) , PM( 3 ) , term ( 1 ) , term ( 1 2 9 ) , dec ( 1 ) , dec ( 1 2 9 ) ) ; a c su pa i r 3 : a c s u p a i r port map

(PM( 2 ) , BM( 5 ) , PM( 1 3 0 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable ,

45

reset PM , PM( 4 ) , PM( 5 ) , term ( 2 ) , term ( 1 3 0 ) , dec ( 2 ) , dec ( 1 3 0 ) ) ; a c su pa i r 4 : a c s u p a i r port map

(PM( 3 ) , BM( 6 ) , PM( 1 3 1 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable , reset PM , PM( 6 ) , PM( 7 ) , term ( 3 ) , term ( 1 3 1 ) , dec ( 3 ) , dec ( 1 3 1 ) ) ; a c su pa i r 5 : a c s u p a i r port map

(PM( 4 ) , BM( 6 ) , PM( 1 3 2 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable , reset PM , PM( 8 ) , PM( 9 ) , term ( 4 ) , term ( 1 3 2 ) , dec ( 4 ) , dec ( 1 3 2 ) ) ; a c su pa i r 6 : a c s u p a i r port map

(PM( 5 ) , BM( 5 ) , PM( 1 3 3 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable , reset PM , PM( 1 0 ) , PM( 1 1 ) , term ( 5 ) , term ( 1 3 3 ) , dec ( 5 ) , dec ( 1 3 3 ) ) ; a c su pa i r 7 : a c s u p a i r port map

(PM( 6 ) , BM( 3 ) , PM( 1 3 4 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp enable , reset PM , PM( 1 2 ) , PM( 1 3 ) , term ( 6 ) , term ( 1 3 4 ) , dec ( 6 ) , dec ( 1 3 4 ) ) ; a c su pa i r 8 : a c s u p a i r port map

(PM( 7 ) , BM( 0 ) , PM( 1 3 5 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable , reset PM , PM( 1 4 ) , PM( 1 5 ) , term ( 7 ) , term ( 1 3 5 ) , dec ( 7 ) , dec ( 1 3 5 ) ) ; a c su pa i r 9 : a c s u p a i r port map

(PM( 8 ) , BM( 2 ) , PM( 1 3 6 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable , reset PM , PM( 1 6 ) , PM( 1 7 ) , term ( 8 ) , term ( 1 3 6 ) , dec ( 8 ) , dec ( 1 3 6 ) ) ; a c su pa i r 1 0 : a c s u p a i r port map

(PM( 9 ) , BM( 1 ) , PM( 1 3 7 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable , reset PM , PM( 1 8 ) , PM( 1 9 ) , term ( 9 ) , term ( 1 3 7 ) , dec ( 9 ) , dec ( 1 3 7 ) ) ; a c su pa i r 1 1 : a c s u p a i r port map

(PM( 1 0 ) , BM( 7 ) , PM( 1 3 8 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp enable ,

reset PM , PM( 2 0 ) , PM( 2 1 ) , term ( 1 0 ) , term ( 1 3 8 ) , dec ( 1 0 ) , dec ( 1 3 8 ) ) ; a c su pa i r 1 2 : a c s u p a i r port map

(PM( 1 1 ) , BM( 4 ) , PM( 1 3 9 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 2 2 ) , PM( 2 3 ) , term ( 1 1 ) , term ( 1 3 9 ) , dec ( 1 1 ) , dec ( 1 3 9 ) ) ; a c su pa i r 1 3 : a c s u p a i r port map

(PM( 1 2 ) , BM( 4 ) , PM( 1 4 0 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 2 4 ) , PM( 2 5 ) , term ( 1 2 ) , term ( 1 4 0 ) , dec ( 1 2 ) , dec ( 1 4 0 ) ) ; a c su pa i r 1 4 : a c s u p a i r port map 85

(PM( 1 3 ) , BM( 7 ) , PM( 1 4 1 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp enable ,

reset PM , PM( 2 6 ) , PM( 2 7 ) , term ( 1 3 ) , term ( 1 4 1 ) , dec ( 1 3 ) , dec ( 1 4 1 ) ) ; a c su pa i r 1 5 : a c s u p a i r port map

(PM( 1 4 ) , BM( 1 ) , PM( 1 4 2 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable ,

reset PM , PM( 2 8 ) , PM( 2 9 ) , term ( 1 4 ) , term ( 1 4 2 ) , dec ( 1 4 ) , dec ( 1 4 2 ) ) ; a c su pa i r 1 6 : a c s u p a i r port map

46

(PM( 1 5 ) , BM( 2 ) , PM( 1 4 3 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable ,

reset PM , PM( 3 0 ) , PM( 3 1 ) , term ( 1 5 ) , term ( 1 4 3 ) , dec ( 1 5 ) , dec ( 1 4 3 ) ) ; a c su pa i r 1 7 : a c s u p a i r port map

(PM( 1 6 ) , BM( 5 ) , PM( 1 4 4 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable ,

reset PM , PM( 3 2 ) , PM( 3 3 ) , term ( 1 6 ) , term ( 1 4 4 ) , dec ( 1 6 ) , dec ( 1 4 4 ) ) ; a c su pa i r 1 8 : a c s u p a i r port map

(PM( 1 7 ) , BM( 6 ) , PM( 1 4 5 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable ,

reset PM , PM( 3 4 ) , PM( 3 5 ) , term ( 1 7 ) , term ( 1 4 5 ) , dec ( 1 7 ) , dec ( 1 4 5 ) ) ; a c su pa i r 1 9 : a c s u p a i r port map

(PM( 1 8 ) , BM( 0 ) , PM( 1 4 6 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable ,

reset PM , PM( 3 6 ) , PM( 3 7 ) , term ( 1 8 ) , term ( 1 4 6 ) , dec ( 1 8 ) , dec ( 1 4 6 ) ) ; a c su pa i r 2 0 : a c s u p a i r port map

(PM( 1 9 ) , BM( 3 ) , PM( 1 4 7 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp enable ,

reset PM , PM( 3 8 ) , PM( 3 9 ) , term ( 1 9 ) , term ( 1 4 7 ) , dec ( 1 9 ) , dec ( 1 4 7 ) ) ; a c su pa i r 2 1 : a c s u p a i r port map

(PM( 2 0 ) , BM( 3 ) , PM( 1 4 8 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp enable ,

reset PM , PM( 4 0 ) , PM( 4 1 ) , term ( 2 0 ) , term ( 1 4 8 ) , dec ( 2 0 ) , dec ( 1 4 8 ) ) ; a c su pa i r 2 2 : a c s u p a i r port map

(PM( 2 1 ) , BM( 0 ) , PM( 1 4 9 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable ,

reset PM , PM( 4 2 ) , PM( 4 3 ) , term ( 2 1 ) , term ( 1 4 9 ) , dec ( 2 1 ) , dec ( 1 4 9 ) ) ; a c su pa i r 2 3 : a c s u p a i r port map

(PM( 2 2 ) , BM( 6 ) , PM( 1 5 0 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable ,

reset PM , PM( 4 4 ) , PM( 4 5 ) , term ( 2 2 ) , term ( 1 5 0 ) , dec ( 2 2 ) , dec ( 1 5 0 ) ) ; a c su pa i r 2 4 : a c s u p a i r port map

(PM( 2 3 ) , BM( 5 ) , PM( 1 5 1 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable ,

reset PM , PM( 4 6 ) , PM( 4 7 ) , term ( 2 3 ) , term ( 1 5 1 ) , dec ( 2 3 ) , dec ( 1 5 1 ) ) ; a c su pa i r 2 5 : a c s u p a i r port map

(PM( 2 4 ) , BM( 7 ) , PM( 1 5 2 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp enable ,

reset PM , PM( 4 8 ) , PM( 4 9 ) , term ( 2 4 ) , term ( 1 5 2 ) , dec ( 2 4 ) , dec ( 1 5 2 ) ) ; a c su pa i r 2 6 : a c s u p a i r port map

(PM( 2 5 ) , BM( 4 ) , PM( 1 5 3 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 5 0 ) , PM( 5 1 ) , term ( 2 5 ) , term ( 1 5 3 ) , dec ( 2 5 ) , dec ( 1 5 3 ) ) ; a c su pa i r 2 7 : a c s u p a i r port map

47

(PM( 2 6 ) , BM( 2 ) , PM( 1 5 4 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable ,

reset PM , PM( 5 2 ) , PM( 5 3 ) , term ( 2 6 ) , term ( 1 5 4 ) , dec ( 2 6 ) , dec ( 1 5 4 ) ) ; a c su pa i r 2 8 : a c s u p a i r port map

(PM( 2 7 ) , BM( 1 ) , PM( 1 5 5 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable ,

reset PM , PM( 5 4 ) , PM( 5 5 ) , term ( 2 7 ) , term ( 1 5 5 ) , dec ( 2 7 ) , dec ( 1 5 5 ) ) ; a c su pa i r 2 9 : a c s u p a i r port map

(PM( 2 8 ) , BM( 1 ) , PM( 1 5 6 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable ,

reset PM , PM( 5 6 ) , PM( 5 7 ) , term ( 2 8 ) , term ( 1 5 6 ) , dec ( 2 8 ) , dec ( 1 5 6 ) ) ; a c su pa i r 3 0 : a c s u p a i r port map

(PM( 2 9 ) , BM( 2 ) , PM( 1 5 7 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable ,

reset PM , PM( 5 8 ) , PM( 5 9 ) , term ( 2 9 ) , term ( 1 5 7 ) , dec ( 2 9 ) , dec ( 1 5 7 ) ) ; a c su pa i r 3 1 : a c s u p a i r port map

(PM( 3 0 ) , BM( 4 ) , PM( 1 5 8 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 6 0 ) , PM( 6 1 ) , term ( 3 0 ) , term ( 1 5 8 ) , dec ( 3 0 ) , dec ( 1 5 8 ) ) ; a c su pa i r 3 2 : a c s u p a i r port map

(PM( 3 1 ) , BM( 7 ) , PM( 1 5 9 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp enable ,

reset PM , PM( 6 2 ) , PM( 6 3 ) , term ( 3 1 ) , term ( 1 5 9 ) , dec ( 3 1 ) , dec ( 1 5 9 ) ) ; a c su pa i r 3 3 : a c s u p a i r port map

(PM( 3 2 ) , BM( 4 ) , PM( 1 6 0 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 6 4 ) , PM( 6 5 ) , term ( 3 2 ) , term ( 1 6 0 ) , dec ( 3 2 ) , dec ( 1 6 0 ) ) ; 86

a c su pa i r 3 4 : a c s u p a i r port map

(PM( 3 3 ) , BM( 7 ) , PM( 1 6 1 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp enable ,

reset PM , PM( 6 6 ) , PM( 6 7 ) , term ( 3 3 ) , term ( 1 6 1 ) , dec ( 3 3 ) , dec ( 1 6 1 ) ) ; a c su pa i r 3 5 : a c s u p a i r port map

(PM( 3 4 ) , BM( 1 ) , PM( 1 6 2 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable ,

reset PM , PM( 6 8 ) , PM( 6 9 ) , term ( 3 4 ) , term ( 1 6 2 ) , dec ( 3 4 ) , dec ( 1 6 2 ) ) ; a c su pa i r 3 6 : a c s u p a i r port map

(PM( 3 5 ) , BM( 2 ) , PM( 1 6 3 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable ,

reset PM , PM( 7 0 ) , PM( 7 1 ) , term ( 3 5 ) , term ( 1 6 3 ) , dec ( 3 5 ) , dec ( 1 6 3 ) ) ; a c su pa i r 3 7 : a c s u p a i r port map

(PM( 3 6 ) , BM( 2 ) , PM( 1 6 4 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable ,

reset PM , PM( 7 2 ) , PM( 7 3 ) , term ( 3 6 ) , term ( 1 6 4 ) , dec ( 3 6 ) , dec ( 1 6 4 ) ) ;

48

a c su pa i r 3 8 : a c s u p a i r port map

(PM( 3 7 ) , BM( 1 ) , PM( 1 6 5 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable ,

reset PM , PM( 7 4 ) , PM( 7 5 ) , term ( 3 7 ) , term ( 1 6 5 ) , dec ( 3 7 ) , dec ( 1 6 5 ) ) ; a c su pa i r 3 9 : a c s u p a i r port map

(PM( 3 8 ) , BM( 7 ) , PM( 1 6 6 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp enable ,

reset PM , PM( 7 6 ) , PM( 7 7 ) , term ( 3 8 ) , term ( 1 6 6 ) , dec ( 3 8 ) , dec ( 1 6 6 ) ) ; a c su pa i r 4 0 : a c s u p a i r port map

(PM( 3 9 ) , BM( 4 ) , PM( 1 6 7 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 7 8 ) , PM( 7 9 ) , term ( 3 9 ) , term ( 1 6 7 ) , dec ( 3 9 ) , dec ( 1 6 7 ) ) ; a c su pa i r 4 1 : a c s u p a i r port map

(PM( 4 0 ) , BM( 6 ) , PM( 1 6 8 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable ,

reset PM , PM( 8 0 ) , PM( 8 1 ) , term ( 4 0 ) , term ( 1 6 8 ) , dec ( 4 0 ) , dec ( 1 6 8 ) ) ; a c su pa i r 4 2 : a c s u p a i r port map

(PM( 4 1 ) , BM( 5 ) , PM( 1 6 9 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable ,

reset PM , PM( 8 2 ) , PM( 8 3 ) , term ( 4 1 ) , term ( 1 6 9 ) , dec ( 4 1 ) , dec ( 1 6 9 ) ) ; a c su pa i r 4 3 : a c s u p a i r port map

(PM( 4 2 ) , BM( 3 ) , PM( 1 7 0 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp enable ,

reset PM , PM( 8 4 ) , PM( 8 5 ) , term ( 4 2 ) , term ( 1 7 0 ) , dec ( 4 2 ) , dec ( 1 7 0 ) ) ; a c su pa i r 4 4 : a c s u p a i r port map

(PM( 4 3 ) , BM( 0 ) , PM( 1 7 1 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable ,

reset PM , PM( 8 6 ) , PM( 8 7 ) , term ( 4 3 ) , term ( 1 7 1 ) , dec ( 4 3 ) , dec ( 1 7 1 ) ) ; a c su pa i r 4 5 : a c s u p a i r port map

(PM( 4 4 ) , BM( 0 ) , PM( 1 7 2 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable ,

reset PM , PM( 8 8 ) , PM( 8 9 ) , term ( 4 4 ) , term ( 1 7 2 ) , dec ( 4 4 ) , dec ( 1 7 2 ) ) ; a c su pa i r 4 6 : a c s u p a i r port map

(PM( 4 5 ) , BM( 3 ) , PM( 1 7 3 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp enable ,

reset PM , PM( 9 0 ) , PM( 9 1 ) , term ( 4 5 ) , term ( 1 7 3 ) , dec ( 4 5 ) , dec ( 1 7 3 ) ) ; a c su pa i r 4 7 : a c s u p a i r port map

(PM( 4 6 ) , BM( 5 ) , PM( 1 7 4 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable ,

reset PM , PM( 9 2 ) , PM( 9 3 ) , term ( 4 6 ) , term ( 1 7 4 ) , dec ( 4 6 ) , dec ( 1 7 4 ) ) ; a c su pa i r 4 8 : a c s u p a i r port map

(PM( 4 7 ) , BM( 6 ) , PM( 1 7 5 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable ,

reset PM , PM( 9 4 ) , PM( 9 5 ) , term ( 4 7 ) , term ( 1 7 5 ) , dec ( 4 7 ) , dec ( 1 7 5 ) ) ;

49

a c su pa i r 4 9 : a c s u p a i r port map

(PM( 4 8 ) , BM( 1 ) , PM( 1 7 6 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable ,

reset PM , PM( 9 6 ) , PM( 9 7 ) , term ( 4 8 ) , term ( 1 7 6 ) , dec ( 4 8 ) , dec ( 1 7 6 ) ) ; a c su pa i r 5 0 : a c s u p a i r port map

(PM( 4 9 ) , BM( 2 ) , PM( 1 7 7 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable ,

reset PM , PM( 9 8 ) , PM( 9 9 ) , term ( 4 9 ) , term ( 1 7 7 ) , dec ( 4 9 ) , dec ( 1 7 7 ) ) ; a c su pa i r 5 1 : a c s u p a i r port map

(PM( 5 0 ) , BM( 4 ) , PM( 1 7 8 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 1 0 0 ) , PM( 1 0 1 ) , term ( 5 0 ) , term ( 1 7 8 ) , dec ( 5 0 ) , dec ( 1 7 8 ) ) ; a c su pa i r 5 2 : a c s u p a i r port map

(PM( 5 1 ) , BM( 7 ) , PM( 1 7 9 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp enable ,

reset PM , PM( 1 0 2 ) , PM( 1 0 3 ) , term ( 5 1 ) , term ( 1 7 9 ) , dec ( 5 1 ) , dec ( 1 7 9 ) ) ; a c su pa i r 5 3 : a c s u p a i r port map

(PM( 5 2 ) , BM( 7 ) , PM( 1 8 0 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp enable , 87

reset PM , PM( 1 0 4 ) , PM( 1 0 5 ) , term ( 5 2 ) , term ( 1 8 0 ) , dec ( 5 2 ) , dec ( 1 8 0 ) ) ; a c su pa i r 5 4 : a c s u p a i r port map

(PM( 5 3 ) , BM( 4 ) , PM( 1 8 1 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 1 0 6 ) , PM( 1 0 7 ) , term ( 5 3 ) , term ( 1 8 1 ) , dec ( 5 3 ) , dec ( 1 8 1 ) ) ; a c su pa i r 5 5 : a c s u p a i r port map

(PM( 5 4 ) , BM( 2 ) , PM( 1 8 2 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable ,

reset PM , PM( 1 0 8 ) , PM( 1 0 9 ) , term ( 5 4 ) , term ( 1 8 2 ) , dec ( 5 4 ) , dec ( 1 8 2 ) ) ; a c su pa i r 5 6 : a c s u p a i r port map

(PM( 5 5 ) , BM( 1 ) , PM( 1 8 3 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable ,

reset PM , PM( 1 1 0 ) , PM( 1 1 1 ) , term ( 5 5 ) , term ( 1 8 3 ) , dec ( 5 5 ) , dec ( 1 8 3 ) ) ; a c su pa i r 5 7 : a c s u p a i r port map

(PM( 5 6 ) , BM( 3 ) , PM( 1 8 4 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp enable ,

reset PM , PM( 1 1 2 ) , PM( 1 1 3 ) , term ( 5 6 ) , term ( 1 8 4 ) , dec ( 5 6 ) , dec ( 1 8 4 ) ) ; a c su pa i r 5 8 : a c s u p a i r port map

(PM( 5 7 ) , BM( 0 ) , PM( 1 8 5 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable ,

reset PM , PM( 1 1 4 ) , PM( 1 1 5 ) , term ( 5 7 ) , term ( 1 8 5 ) , dec ( 5 7 ) , dec ( 1 8 5 ) ) ; a c su pa i r 5 9 : a c s u p a i r port map

(PM( 5 8 ) , BM( 6 ) , PM( 1 8 6 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable ,

50

reset PM , PM( 1 1 6 ) , PM( 1 1 7 ) , term ( 5 8 ) , term ( 1 8 6 ) , dec ( 5 8 ) , dec ( 1 8 6 ) ) ; a c su pa i r 6 0 : a c s u p a i r port map

(PM( 5 9 ) , BM( 5 ) , PM( 1 8 7 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable ,

reset PM , PM( 1 1 8 ) , PM( 1 1 9 ) , term ( 5 9 ) , term ( 1 8 7 ) , dec ( 5 9 ) , dec ( 1 8 7 ) ) ; a c su pa i r 6 1 : a c s u p a i r port map

(PM( 6 0 ) , BM( 5 ) , PM( 1 8 8 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable ,

reset PM , PM( 1 2 0 ) , PM( 1 2 1 ) , term ( 6 0 ) , term ( 1 8 8 ) , dec ( 6 0 ) , dec ( 1 8 8 ) ) ; a c su pa i r 6 2 : a c s u p a i r port map

(PM( 6 1 ) , BM( 6 ) , PM( 1 8 9 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable ,

reset PM , PM( 1 2 2 ) , PM( 1 2 3 ) , term ( 6 1 ) , term ( 1 8 9 ) , dec ( 6 1 ) , dec ( 1 8 9 ) ) ; a c su pa i r 6 3 : a c s u p a i r port map

(PM( 6 2 ) , BM( 0 ) , PM( 1 9 0 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable ,

reset PM , PM( 1 2 4 ) , PM( 1 2 5 ) , term ( 6 2 ) , term ( 1 9 0 ) , dec ( 6 2 ) , dec ( 1 9 0 ) ) ; a c su pa i r 6 4 : a c s u p a i r port map

(PM( 6 3 ) , BM( 3 ) , PM( 1 9 1 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp enable ,

reset PM , PM( 1 2 6 ) , PM( 1 2 7 ) , term ( 6 3 ) , term ( 1 9 1 ) , dec ( 6 3 ) , dec ( 1 9 1 ) ) ; a c su pa i r 6 5 : a c s u p a i r port map

(PM( 6 4 ) , BM( 6 ) , PM( 1 9 2 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable ,

reset PM , PM( 1 2 8 ) , PM( 1 2 9 ) , term ( 6 4 ) , term ( 1 9 2 ) , dec ( 6 4 ) , dec ( 1 9 2 ) ) ; a c su pa i r 6 6 : a c s u p a i r port map

(PM( 6 5 ) , BM( 5 ) , PM( 1 9 3 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable ,

reset PM , PM( 1 3 0 ) , PM( 1 3 1 ) , term ( 6 5 ) , term ( 1 9 3 ) , dec ( 6 5 ) , dec ( 1 9 3 ) ) ; a c su pa i r 6 7 : a c s u p a i r port map

(PM( 6 6 ) , BM( 3 ) , PM( 1 9 4 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp enable ,

reset PM , PM( 1 3 2 ) , PM( 1 3 3 ) , term ( 6 6 ) , term ( 1 9 4 ) , dec ( 6 6 ) , dec ( 1 9 4 ) ) ; a c su pa i r 6 8 : a c s u p a i r port map

(PM( 6 7 ) , BM( 0 ) , PM( 1 9 5 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable ,

reset PM , PM( 1 3 4 ) , PM( 1 3 5 ) , term ( 6 7 ) , term ( 1 9 5 ) , dec ( 6 7 ) , dec ( 1 9 5 ) ) ; a c su pa i r 6 9 : a c s u p a i r port map

(PM( 6 8 ) , BM( 0 ) , PM( 1 9 6 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable ,

reset PM , PM( 1 3 6 ) , PM( 1 3 7 ) , term ( 6 8 ) , term ( 1 9 6 ) , dec ( 6 8 ) , dec ( 1 9 6 ) ) ; a c su pa i r 7 0 : a c s u p a i r port map

(PM( 6 9 ) , BM( 3 ) , PM( 1 9 7 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp enable ,

51

reset PM , PM( 1 3 8 ) , PM( 1 3 9 ) , term ( 6 9 ) , term ( 1 9 7 ) , dec ( 6 9 ) , dec ( 1 9 7 ) ) ; a c su pa i r 7 1 : a c s u p a i r port map

(PM( 7 0 ) , BM( 5 ) , PM( 1 9 8 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable ,

reset PM , PM( 1 4 0 ) , PM( 1 4 1 ) , term ( 7 0 ) , term ( 1 9 8 ) , dec ( 7 0 ) , dec ( 1 9 8 ) ) ; a c su pa i r 7 2 : a c s u p a i r port map

(PM( 7 1 ) , BM( 6 ) , PM( 1 9 9 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable ,

reset PM , PM( 1 4 2 ) , PM( 1 4 3 ) , term ( 7 1 ) , term ( 1 9 9 ) , dec ( 7 1 ) , dec ( 1 9 9 ) ) ; a c su pa i r 7 3 : a c s u p a i r port map 88

(PM( 7 2 ) , BM( 4 ) , PM( 2 0 0 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 1 4 4 ) , PM( 1 4 5 ) , term ( 7 2 ) , term ( 2 0 0 ) , dec ( 7 2 ) , dec ( 2 0 0 ) ) ; a c su pa i r 7 4 : a c s u p a i r port map

(PM( 7 3 ) , BM( 7 ) , PM( 2 0 1 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp enable ,

reset PM , PM( 1 4 6 ) , PM( 1 4 7 ) , term ( 7 3 ) , term ( 2 0 1 ) , dec ( 7 3 ) , dec ( 2 0 1 ) ) ; a c su pa i r 7 5 : a c s u p a i r port map

(PM( 7 4 ) , BM( 1 ) , PM( 2 0 2 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable ,

reset PM , PM( 1 4 8 ) , PM( 1 4 9 ) , term ( 7 4 ) , term ( 2 0 2 ) , dec ( 7 4 ) , dec ( 2 0 2 ) ) ; a c su pa i r 7 6 : a c s u p a i r port map

(PM( 7 5 ) , BM( 2 ) , PM( 2 0 3 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable ,

reset PM , PM( 1 5 0 ) , PM( 1 5 1 ) , term ( 7 5 ) , term ( 2 0 3 ) , dec ( 7 5 ) , dec ( 2 0 3 ) ) ; a c su pa i r 7 7 : a c s u p a i r port map

(PM( 7 6 ) , BM( 2 ) , PM( 2 0 4 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable ,

reset PM , PM( 1 5 2 ) , PM( 1 5 3 ) , term ( 7 6 ) , term ( 2 0 4 ) , dec ( 7 6 ) , dec ( 2 0 4 ) ) ; a c su pa i r 7 8 : a c s u p a i r port map

(PM( 7 7 ) , BM( 1 ) , PM( 2 0 5 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable ,

reset PM , PM( 1 5 4 ) , PM( 1 5 5 ) , term ( 7 7 ) , term ( 2 0 5 ) , dec ( 7 7 ) , dec ( 2 0 5 ) ) ; a c su pa i r 7 9 : a c s u p a i r port map

(PM( 7 8 ) , BM( 7 ) , PM( 2 0 6 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp enable ,

reset PM , PM( 1 5 6 ) , PM( 1 5 7 ) , term ( 7 8 ) , term ( 2 0 6 ) , dec ( 7 8 ) , dec ( 2 0 6 ) ) ; a c su pa i r 8 0 : a c s u p a i r port map

(PM( 7 9 ) , BM( 4 ) , PM( 2 0 7 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 1 5 8 ) , PM( 1 5 9 ) , term ( 7 9 ) , term ( 2 0 7 ) , dec ( 7 9 ) , dec ( 2 0 7 ) ) ; a c su pa i r 8 1 : a c s u p a i r port map

(PM( 8 0 ) , BM( 3 ) , PM( 2 0 8 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp

52

enable ,

reset PM , PM( 1 6 0 ) , PM( 1 6 1 ) , term ( 8 0 ) , term ( 2 0 8 ) , dec ( 8 0 ) , dec ( 2 0 8 ) ) ; a c su pa i r 8 2 : a c s u p a i r port map

(PM( 8 1 ) , BM( 0 ) , PM( 2 0 9 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable ,

reset PM , PM( 1 6 2 ) , PM( 1 6 3 ) , term ( 8 1 ) , term ( 2 0 9 ) , dec ( 8 1 ) , dec ( 2 0 9 ) ) ; a c su pa i r 8 3 : a c s u p a i r port map

(PM( 8 2 ) , BM( 6 ) , PM( 2 1 0 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable ,

reset PM , PM( 1 6 4 ) , PM( 1 6 5 ) , term ( 8 2 ) , term ( 2 1 0 ) , dec ( 8 2 ) , dec ( 2 1 0 ) ) ; a c su pa i r 8 4 : a c s u p a i r port map

(PM( 8 3 ) , BM( 5 ) , PM( 2 1 1 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable ,

reset PM , PM( 1 6 6 ) , PM( 1 6 7 ) , term ( 8 3 ) , term ( 2 1 1 ) , dec ( 8 3 ) , dec ( 2 1 1 ) ) ; a c su pa i r 8 5 : a c s u p a i r port map

(PM( 8 4 ) , BM( 5 ) , PM( 2 1 2 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable ,

reset PM , PM( 1 6 8 ) , PM( 1 6 9 ) , term ( 8 4 ) , term ( 2 1 2 ) , dec ( 8 4 ) , dec ( 2 1 2 ) ) ; a c su pa i r 8 6 : a c s u p a i r port map

(PM( 8 5 ) , BM( 6 ) , PM( 2 1 3 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable ,

reset PM , PM( 1 7 0 ) , PM( 1 7 1 ) , term ( 8 5 ) , term ( 2 1 3 ) , dec ( 8 5 ) , dec ( 2 1 3 ) ) ; a c su pa i r 8 7 : a c s u p a i r port map

(PM( 8 6 ) , BM( 0 ) , PM( 2 1 4 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable ,

reset PM , PM( 1 7 2 ) , PM( 1 7 3 ) , term ( 8 6 ) , term ( 2 1 4 ) , dec ( 8 6 ) , dec ( 2 1 4 ) ) ; a c su pa i r 8 8 : a c s u p a i r port map

(PM( 8 7 ) , BM( 3 ) , PM( 2 1 5 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp enable ,

reset PM , PM( 1 7 4 ) , PM( 1 7 5 ) , term ( 8 7 ) , term ( 2 1 5 ) , dec ( 8 7 ) , dec ( 2 1 5 ) ) ; a c su pa i r 8 9 : a c s u p a i r port map

(PM( 8 8 ) , BM( 1 ) , PM( 2 1 6 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable ,

reset PM , PM( 1 7 6 ) , PM( 1 7 7 ) , term ( 8 8 ) , term ( 2 1 6 ) , dec ( 8 8 ) , dec ( 2 1 6 ) ) ; a c su pa i r 9 0 : a c s u p a i r port map

(PM( 8 9 ) , BM( 2 ) , PM( 2 1 7 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable ,

reset PM , PM( 1 7 8 ) , PM( 1 7 9 ) , term ( 8 9 ) , term ( 2 1 7 ) , dec ( 8 9 ) , dec ( 2 1 7 ) ) ; a c su pa i r 9 1 : a c s u p a i r port map

(PM( 9 0 ) , BM( 4 ) , PM( 2 1 8 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 1 8 0 ) , PM( 1 8 1 ) , term ( 9 0 ) , term ( 2 1 8 ) , dec ( 9 0 ) , dec ( 2 1 8 ) ) ; a c su pa i r 9 2 : a c s u p a i r port map

(PM( 9 1 ) , BM( 7 ) , PM( 2 1 9 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp

53

enable ,

reset PM , PM( 1 8 2 ) , PM( 1 8 3 ) , term ( 9 1 ) , term ( 2 1 9 ) , dec ( 9 1 ) , dec ( 2 1 9 ) ) ;

a c su pa i r 9 3 : a c s u p a i r port map

(PM( 9 2 ) , BM( 7 ) , PM( 2 2 0 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp enable ,

reset PM , PM( 1 8 4 ) , PM( 1 8 5 ) , term ( 9 2 ) , term ( 2 2 0 ) , dec ( 9 2 ) , dec ( 2 2 0 ) ) ; a c su pa i r 9 4 : a c s u p a i r port map

(PM( 9 3 ) , BM( 4 ) , PM( 2 2 1 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 1 8 6 ) , PM( 1 8 7 ) , term ( 9 3 ) , term ( 2 2 1 ) , dec ( 9 3 ) , dec ( 2 2 1 ) ) ; a c su pa i r 9 5 : a c s u p a i r port map

(PM( 9 4 ) , BM( 2 ) , PM( 2 2 2 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable ,

reset PM , PM( 1 8 8 ) , PM( 1 8 9 ) , term ( 9 4 ) , term ( 2 2 2 ) , dec ( 9 4 ) , dec ( 2 2 2 ) ) ; a c su pa i r 9 6 : a c s u p a i r port map

(PM( 9 5 ) , BM( 1 ) , PM( 2 2 3 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable ,

reset PM , PM( 1 9 0 ) , PM( 1 9 1 ) , term ( 9 5 ) , term ( 2 2 3 ) , dec ( 9 5 ) , dec ( 2 2 3 ) ) ; a c su pa i r 9 7 : a c s u p a i r port map

(PM( 9 6 ) , BM( 2 ) , PM( 2 2 4 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable ,

reset PM , PM( 1 9 2 ) , PM( 1 9 3 ) , term ( 9 6 ) , term ( 2 2 4 ) , dec ( 9 6 ) , dec ( 2 2 4 ) ) ; a c su pa i r 9 8 : a c s u p a i r port map

(PM( 9 7 ) , BM( 1 ) , PM( 2 2 5 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable ,

reset PM , PM( 1 9 4 ) , PM( 1 9 5 ) , term ( 9 7 ) , term ( 2 2 5 ) , dec ( 9 7 ) , dec ( 2 2 5 ) ) ; a c su pa i r 9 9 : a c s u p a i r port map

(PM( 9 8 ) , BM( 7 ) , PM( 2 2 6 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp enable ,

reset PM , PM( 1 9 6 ) , PM( 1 9 7 ) , term ( 9 8 ) , term ( 2 2 6 ) , dec ( 9 8 ) , dec ( 2 2 6 ) ) ; a c su pa i r 1 0 0 : a c s u p a i r port map

(PM( 9 9 ) , BM( 4 ) , PM( 2 2 7 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 1 9 8 ) , PM( 1 9 9 ) , term ( 9 9 ) , term ( 2 2 7 ) , dec ( 9 9 ) , dec ( 2 2 7 ) ) ; a c su pa i r 1 0 1 : a c s u p a i r port map

(PM( 1 0 0 ) , BM( 4 ) , PM( 2 2 8 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 2 0 0 ) , PM( 2 0 1 ) , term ( 1 0 0 ) , term ( 2 2 8 ) , dec ( 1 0 0 ) , dec ( 2 2 8 ) ) ; a c su pa i r 1 0 2 : a c s u p a i r port map

(PM( 1 0 1 ) , BM( 7 ) , PM( 2 2 9 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp enable ,

reset PM , PM( 2 0 2 ) , PM( 2 0 3 ) , term ( 1 0 1 ) , term ( 2 2 9 ) , dec ( 1 0 1 ) , dec ( 2 2 9 ) ) ; a c su pa i r 1 0 3 : a c s u p a i r port map

(PM( 1 0 2 ) , BM( 1 ) , PM( 2 3 0 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable ,

reset PM , PM( 2 0 4 ) , PM( 2 0 5 ) , term ( 1 0 2 ) , term ( 2 3 0 ) , dec ( 1 0 2 ) , dec ( 2 3 0 ) ) ; a c su pa i r 1 0 4 : a c s u p a i r port map

(PM( 1 0 3 ) , BM( 2 ) , PM( 2 3 1 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable ,

reset PM , PM( 2 0 6 ) , PM( 2 0 7 ) , term ( 1 0 3 ) , term ( 2 3 1 ) , dec ( 1 0 3 ) , dec ( 2 3 1 ) ) ; a c su pa i r 1 0 5 : a c s u p a i r port map

(PM( 1 0 4 ) , BM( 0 ) , PM( 2 3 2 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable ,

reset PM , PM( 2 0 8 ) , PM( 2 0 9 ) , term ( 1 0 4 ) , term ( 2 3 2 ) , dec ( 1 0 4 ) , dec ( 2 3 2 ) ) ; a c su pa i r 1 0 6 : a c s u p a i r port map

(PM( 1 0 5 ) , BM( 3 ) , PM( 2 3 3 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp enable ,

reset PM , PM( 2 1 0 ) , PM( 2 1 1 ) , term ( 1 0 5 ) , term ( 2 3 3 ) , dec ( 1 0 5 ) , dec ( 2 3 3 ) ) ; a c su pa i r 1 0 7 : a c s u p a i r port map

(PM( 1 0 6 ) , BM( 5 ) , PM( 2 3 4 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable ,

reset PM , PM( 2 1 2 ) , PM( 2 1 3 ) , term ( 1 0 6 ) , term ( 2 3 4 ) , dec ( 1 0 6 ) , dec ( 2 3 4 ) ) ; a c su pa i r 1 0 8 : a c s u p a i r port map

(PM( 1 0 7 ) , BM( 6 ) , PM( 2 3 5 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable ,

reset PM , PM( 2 1 4 ) , PM( 2 1 5 ) , term ( 1 0 7 ) , term ( 2 3 5 ) , dec ( 1 0 7 ) , dec ( 2 3 5 ) ) ; a c su pa i r 1 0 9 : a c s u p a i r port map

(PM( 1 0 8 ) , BM( 6 ) , PM( 2 3 6 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable ,

reset PM , PM( 2 1 6 ) , PM( 2 1 7 ) , term ( 1 0 8 ) , term ( 2 3 6 ) , dec ( 1 0 8 ) , dec ( 2 3 6 ) ) ; a c su pa i r 1 1 0 : a c s u p a i r port map

(PM( 1 0 9 ) , BM( 5 ) , PM( 2 3 7 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable ,

reset PM , PM( 2 1 8 ) , PM( 2 1 9 ) , term ( 1 0 9 ) , term ( 2 3 7 ) , dec ( 1 0 9 ) , dec ( 2 3 7 ) ) ; a c su pa i r 1 1 1 : a c s u p a i r port map

(PM( 1 1 0 ) , BM( 3 ) , PM( 2 3 8 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp enable ,

reset PM , PM( 2 2 0 ) , PM( 2 2 1 ) , term ( 1 1 0 ) , term ( 2 3 8 ) , dec ( 1 1 0 ) , dec ( 2 3 8 ) ) ; a c su pa i r 1 1 2 : a c s u p a i r port map

(PM( 1 1 1 ) , BM( 0 ) , PM( 2 3 9 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable , 90

reset PM , PM( 2 2 2 ) , PM( 2 2 3 ) , term ( 1 1 1 ) , term ( 2 3 9 ) , dec ( 1 1 1 ) , dec ( 2 3 9 ) ) ; a c su pa i r 1 1 3 : a c s u p a i r port map

(PM( 1 1 2 ) , BM( 7 ) , PM( 2 4 0 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp enable ,

reset PM , PM( 2 2 4 ) , PM( 2 2 5 ) , term ( 1 1 2 ) , term ( 2 4 0 ) , dec ( 1 1 2 ) , dec ( 2 4 0 ) ) ;

55

a c su pa i r 1 1 4 : a c s u p a i r port map

(PM( 1 1 3 ) , BM( 4 ) , PM( 2 4 1 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 2 2 6 ) , PM( 2 2 7 ) , term ( 1 1 3 ) , term ( 2 4 1 ) , dec ( 1 1 3 ) , dec ( 2 4 1 ) ) ; a c su pa i r 1 1 5 : a c s u p a i r port map

(PM( 1 1 4 ) , BM( 2 ) , PM( 2 4 2 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable ,

reset PM , PM( 2 2 8 ) , PM( 2 2 9 ) , term ( 1 1 4 ) , term ( 2 4 2 ) , dec ( 1 1 4 ) , dec ( 2 4 2 ) ) ; a c su pa i r 1 1 6 : a c s u p a i r port map

(PM( 1 1 5 ) , BM( 1 ) , PM( 2 4 3 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable ,

reset PM , PM( 2 3 0 ) , PM( 2 3 1 ) , term ( 1 1 5 ) , term ( 2 4 3 ) , dec ( 1 1 5 ) , dec ( 2 4 3 ) ) ; a c su pa i r 1 1 7 : a c s u p a i r port map

(PM( 1 1 6 ) , BM( 1 ) , PM( 2 4 4 ) , BM( 6 ) , clk , r e s e t c a r r y , msb BMjp ( 6 ) , comp enable ,

reset PM , PM( 2 3 2 ) , PM( 2 3 3 ) , term ( 1 1 6 ) , term ( 2 4 4 ) , dec ( 1 1 6 ) , dec ( 2 4 4 ) ) ; a c su pa i r 1 1 8 : a c s u p a i r port map

(PM( 1 1 7 ) , BM( 2 ) , PM( 2 4 5 ) , BM( 5 ) , clk , r e s e t c a r r y , msb BMjp ( 5 ) , comp enable ,

reset PM , PM( 2 3 4 ) , PM( 2 3 5 ) , term ( 1 1 7 ) , term ( 2 4 5 ) , dec ( 1 1 7 ) , dec ( 2 4 5 ) ) ; a c su pa i r 1 1 9 : a c s u p a i r port map

(PM( 1 1 8 ) , BM( 4 ) , PM( 2 4 6 ) , BM( 3 ) , clk , r e s e t c a r r y , msb BMjp ( 3 ) , comp enable ,

reset PM , PM( 2 3 6 ) , PM( 2 3 7 ) , term ( 1 1 8 ) , term ( 2 4 6 ) , dec ( 1 1 8 ) , dec ( 2 4 6 ) ) ; a c su pa i r 1 2 0 : a c s u p a i r port map

(PM( 1 1 9 ) , BM( 7 ) , PM( 2 4 7 ) , BM( 0 ) , clk , r e s e t c a r r y , msb BMjp ( 0 ) , comp enable ,

reset PM , PM( 2 3 8 ) , PM( 2 3 9 ) , term ( 1 1 9 ) , term ( 2 4 7 ) , dec ( 1 1 9 ) , dec ( 2 4 7 ) ) ; a c su pa i r 1 2 1 : a c s u p a i r port map

(PM( 1 2 0 ) , BM( 5 ) , PM( 2 4 8 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable ,

reset PM , PM( 2 4 0 ) , PM( 2 4 1 ) , term ( 1 2 0 ) , term ( 2 4 8 ) , dec ( 1 2 0 ) , dec ( 2 4 8 ) ) ; a c su pa i r 1 2 2 : a c s u p a i r port map

(PM( 1 2 1 ) , BM( 6 ) , PM( 2 4 9 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable ,

reset PM , PM( 2 4 2 ) , PM( 2 4 3 ) , term ( 1 2 1 ) , term ( 2 4 9 ) , dec ( 1 2 1 ) , dec ( 2 4 9 ) ) ; a c su pa i r 1 2 3 : a c s u p a i r port map

(PM( 1 2 2 ) , BM( 0 ) , PM( 2 5 0 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable ,

reset PM , PM( 2 4 4 ) , PM( 2 4 5 ) , term ( 1 2 2 ) , term ( 2 5 0 ) , dec ( 1 2 2 ) , dec ( 2 5 0 ) ) ; a c su pa i r 1 2 4 : a c s u p a i r port map

(PM( 1 2 3 ) , BM( 3 ) , PM( 2 5 1 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp enable ,

reset PM , PM( 2 4 6 ) , PM( 2 4 7 ) , term ( 1 2 3 ) , term ( 2 5 1 ) , dec ( 1 2 3 ) , dec ( 2 5 1 ) ) ;

56

a c su pa i r 1 2 5 : a c s u p a i r port map

(PM( 1 2 4 ) , BM( 3 ) , PM( 2 5 2 ) , BM( 4 ) , clk , r e s e t c a r r y , msb BMjp ( 4 ) , comp enable ,

reset PM , PM( 2 4 8 ) , PM( 2 4 9 ) , term ( 1 2 4 ) , term ( 2 5 2 ) , dec ( 1 2 4 ) , dec ( 2 5 2 ) ) ; a c su pa i r 1 2 6 : a c s u p a i r port map

(PM( 1 2 5 ) , BM( 0 ) , PM( 2 5 3 ) , BM( 7 ) , clk , r e s e t c a r r y , msb BMjp ( 7 ) , comp enable ,

reset PM , PM( 2 5 0 ) , PM( 2 5 1 ) , term ( 1 2 5 ) , term ( 2 5 3 ) , dec ( 1 2 5 ) , dec ( 2 5 3 ) ) ; a c su pa i r 1 2 7 : a c s u p a i r port map

(PM( 1 2 6 ) , BM( 6 ) , PM( 2 5 4 ) , BM( 1 ) , clk , r e s e t c a r r y , msb BMjp ( 1 ) , comp enable ,

reset PM , PM( 2 5 2 ) , PM( 2 5 3 ) , term ( 1 2 6 ) , term ( 2 5 4 ) , dec ( 1 2 6 ) , dec ( 2 5 4 ) ) ; a c su pa i r 1 2 8 : a c s u p a i r port map

(PM( 1 2 7 ) , BM( 5 ) , PM( 2 5 5 ) , BM( 2 ) , clk , r e s e t c a r r y , msb BMjp ( 2 ) , comp enable ,

reset PM , PM( 2 5 4 ) , PM( 2 5 5 ) , term ( 1 2 7 ) , term ( 2 5 5 ) , dec ( 1 2 7 ) , dec ( 2 5 5 ) ) ;

英文文献

FPGA IMPLEMENTATION AND POWER MODELLING OF THE FASTWALSH TRANSFORM

S.Chandrasekaran and A.Amira

Electronic and Computer Engineering, School of Engineering and Design Brunel University, West London, UB8 3PH, UK

Email: shrutisagar.chandrasekaran@brunel.ac.uk, abbes.amira@brunel.ac.uk

In this paper we present a novel design for an efficient FPGA architecture of Fast Walsh Transform (FWT) for hardware implementation of pattern analysis techniques such as projection kernel calculation and feature extraction. The proposed

architecture is based on Distributed Arithmetic (DA) principles using ROM ACcumulate (RAC) technique and sparse matrix factorisation. The implementation has been carried out using a hybrid design approach based on Celoxica Handel-C which is used as a wrapper for highly optimized VHDL cores.The algorithm has been implemented and verified on the Xilinx Virtex-2000E FPGA. An evaluation has also been reported based on maximum system frequency and chip area for different system parameters, and have been shown to outperform existing work in all key performance

57

measures. Additionally, a novel Functional Level Power Analysis and Modelling (FLPAM) methodology has been proposed to enable a high level estimation of power consumption.

1. INTRODUCTION

Discrete Orthogonal Transforms (DOTs) have been widely used in a number of image and signal processing applications.Walsh Transform (WT) is one of the important members of the class of DOTs that has is used in many signal processing algorithms and includes applications in the fields of communications, pattern recognition and data compression[1]. The (Fast Walsh Transform) FWT is similar to the DFT and is globally recursive requiring global communication for the shuffling between different stages of the process [2]. Although it is faster than sinusoidal-like transforms as it can be decomposed into a combination of additions and subtractions, there is a real need of dedicated processors for high speed computation of the transform coefficients to meet the requirements of real time signal processing and digital multimedia communication systems. A survey of literature

shows that a number of existing architectures for FWT and the computationally similar FHT, and their hardware implementation have been proposed [2][3][4][5][6][7].

It is the aim of this paper to develop efficient Distributed Arithmetic (DA) [8] based architectures for the FWT suitable for implementation on Field Programmable Gate Arrays (FPGAs). ROM size for DA has been reduced by novel implementation of sparse matrix factorisation techniques resulting in compact, high speed, and power efficient design.A novel high level power estimation methodology called Functional Level Power Analysis and Modelling (FLPAM) for the FWT core developed has also been proposed. Implementation has been carried out on the Celoxica RC1000 development board equipped with the Xilinx Virtex-E FPGA [9][10]. The composition of the rest of the paper is as follows. Mathematical model for the FWT is described in section II. A description of the proposed architecture and implementation results are presented in section III. Power analysis and modelling results are presented in section IV. Concluding remarks are given in section V. 2. MATHEMATICAL BACKGROUND

Typically, a Walsh matrix of sizeN×N is defined iteratively as:

58

Recursively expanding this expression, we get:

where S is the sequency operator, ◦ denotes the Kronecker product between two matrices and Ii is an identity matrix of size i × i. The above expression yields K sparse matrices on complete decomposition. If the transform length N is a power of two, this decomposition yields a FWT algorithm (similar to FFT) which can be used for its fast computation.The sequency k of a walsh function is defined as half the number of zero crossings in one cycle of the time base. In sequency order , each row of the Walsh matrix A has one more colour change (sign change) than the preceding row.Let the input data and the transformed data be represented by the two vectors X and Y of size N. Then Y can be written as follows:

where Xk’s are written in the fractional format as shown in Equation (7):

where xk,m is mth bit of xk (which are zero or one) and xk,n−1 is the sign bit and n is the word-length. Substituting (7) in (6):

Define:

59

The output result is given by:

Since the termWm depends on the xk,m values and has only2N possible values, it is possible to precompute and storethese values in a ROM. The set of bits (x1,m ……, xN,m) isused as an address to retrieve the correspondingWm values. To reduce the number of arithmetic operations and to speed up the process, the symmetry in the FWT matrix coefficients and a sparse matrix factorisation are exploited as shown in Equation (12). The matrix multiplication described in Equation (5) is now performed using DA.

where T = W2NX, W4N and W2Nare uniformly sparse factors of WN with 2 and 4 non-zero coefficients respectively; for the case N = 8, n = 8. Walsh basis functions for N = 8 are shown in Fig. 1.

Fig. 1. Projection vectors of the Walsh transform of order 8. Black represents +1 and white represents -1.

3. PROPOSED ARCHITECTURE FOR FWT DESIGN AND EVALUATION In this section, the novel architecture designed for the implementation of FWT is

described followed by a tabular comparison of the various parameters of the proposed architecture with other existing architectures in place.

3.1. Architecture Description

60

The architecture for the 1-D FWT is shown in Fig. 2. The W = 8 bit inputs to the circuit are fed in byte-serial fashion from the input port. The ADD/SUB block in the input module operates on every odd clock pulse, and their output is appended to the input buffer two words at a time (one addition value and one subtraction value) on every even clock pulse in a systolic manner, until the full vector to be transformed has been read. During the first 9 cycles, eight bit-

serial outputs for each even vector are produced in parallel,and during the second 9 cycles eight bit-serial outputs for each odd vector are produced in parallel. For the first 8 clock cycles the ADD/SUB module operates in addition mode. During the 9th clock pulse in each iteration, the invert flag is set to high, and the ADD/SUB block in the DA module performs subtraction. The Odd + / Even – selector multiplexes the odd/even index values in the input buffer to the DA module. Each odd row vector is redundant as it is the shifted version of each preceding row vector. By splitting the column vector T into two sets of odd and even vectors, the same set of 4 row vectors can be used in place of the 8x8 matrix W4N. The odd and even vectors obtained have a vector-length of 4 words each thereby reducing the size of the ROM for each vector to 16 words instead of 256i.e. ROM size for each vector used in the DA based implementation is reduced from 2N to 2N/2. Additionally, the same ROM can be used to perform the DA based vector multiplication of each odd row, and the following even row due to identical coefficients. For example, it can be seenin Fig. 2 that

“ROM34” is used for the dot product of the3rd and 4th rows respectively. The novel architecture thus obtained has an area complexity that is reduced by orders of magnitude in terms of ROM area required. At the end of each iteration, the DA module generates output vectors of length N/2, for the even and odd vectors in

alternation.These vectors are buffered at the output section and written to the output pads in a word serial manner. The contents of the ROMs in the DA module are also shown in Fig.2; where W0 = W48,i(6+i mod 2), W1 = W48,i(4+i mod 2),W2 = W48,i(2+i mod 2) 和 W3 = W48,i(0+i mod 2)

61

3.2. Comparison with Existing Architectures

Design parameters such as Time Complexity (TC), Area Complexity (AC) and I/O type of the proposed design with existing architectures are presented in Table 1. It is worth noting that the time complexities of DA based FWT architecture in the

proposed design and for the FWT in [4], are dependant only on the number of bits used to represent each word in thevector, and not on the

vector length. Thus, the latency of the design, and the number of clock cycles remains constant for a given input wordlength for all vector sizes. On the other hand, in all the other architectures referenced in Table 1, the computation time increases with the vector length. Comparison of the results with existing work is presented in Table 2. Architectures corresponding to * and ** have N = 8 and

n = 1 respectively. Effective bit-level throughput of [7] and [5] is therefore 1/8th times that of the other architectures in the table. Taking this factor into account, and making a fair comparison, we can see that the proposed architecture outperforms the existing architectures in all key performance metrics.

4. POWER ANALYSIS

Power consumption depends on the design, and is influenced by a number of factors such as clock frequency, design density (number of interconnects), activity rates, logic block and interconnect structure of the specific FPGA, power supply voltage levels and output loading. Some of these factors are system variables, and can be modelled. The modeling methodology and results obtained are explained below.

62

4.1. Power Modelling Primer

FLPAM for FPGAs is a novel concept that has been implemented for this FHT core. The steps involved in buildinga mathematical model that incorporates all the system variables,enabling the user to perform high level estimation of the power and energy metrics of the core for a given set of parameters early on in the design cycle itself are as follows:

1) Create a power chart by measuring power for each individual component of dynamic power, i.e. signal, logic, clock, I/O; 2) Identify all variables in the system, including user customisable ones, and internal system parameters, eg. frequency, vector length, area and voltage; 3) Define empirical arelationship between all the system variables; and 4) Derive the coefficients for the model of each individual power component by performing non-linear regression analysis on the power estimation data. BY substitution of the coefficients in the models, and combining them, a global powermodel is obtained.

4.1.1. Area Model

The area occupied by the design in terms of number of slices depends on two components in the architecture: control logic area and the ROM area. The area

occupied by ROM increases exponentially with vector length. It is also proportional to logarithm of vector length. The area occupied by the control logic is proportional to the vector length. Based on these observations, the area model is described as follows:

where TA is the Total Area occupied, α1_, α2_ are constantcoefficients, and α1, α2 are the scaling coefficients in thearea model. Final estimates of the scaling coefficients obtainedare: α1 = 0.0425212072, α2 = 20.1587911. It is worth

mentioning that the area model perfectly relates to the area data presented in table 2 accurately.

4.1.2. Dynamic On-Chip Power Model

The components that contribute to dynamic on-chip power are clock, signal and logic power. Clock power in FPGAs depends on the distribution of the clock nets (which depends on the chip area over which the design is spread out). Other factors influencing clock power are chip frequency f, and voltage v. Signal power is proportional to the number and length of nets over which signal switching occurs. It also depends on the voltage levels between which the switching occurs, as well as the frequency of switching. Logic power consumption is a function of the number of slices occupied, chip frequency and voltage. Output power also increases with N due

63

to increased capacitance of the output pins. Taking these factors into consideration, the Dynamic Power (DP) model for the FWT can be defined as follows:

where d1, d2, d3 and d4 are the scaling coefficients in the model. The final estimate of the scaling coefficients is obtained as follows: d1 = 0.00376852024, d2 = 0.773173737, d3 = −0.0799198372, d4 = −0.363191983

5. CONCLUSION

A novel and efficient IP core for FWT based on DA principles and sparse matrix factorisation technique has been proposed. Evaluation of the implementation results has shown that the proposed architecture outperforms existing implementations in all key performance metrics. A novel high

level power estimationmethodology (FLPAM) has also been introduced.

中文翻译

基于FPGA的沃尔什-哈达码变换信号处理

摘要：本文提出了一种新颖的设计建立一个高效率的FPGA架构的快速Walsh变换（ FWT ）的硬件实现模式分析技术，如投影核心计算和特征提取。 拟议的架构是基于分布式算法（ DA ）的原则，使用光盘积累（集群）技术和稀疏矩阵factorisation 。 的执行情况进行了使用混合设计方法的基础上Celoxica公司韩德尔碳是用作包装高度优化的VHDL内核。 该算法已实施和验证的Xilinx Virtex - 2000E的FPGA 。 一个评价中也出现了基于最大系统频率和芯片面积为不同的系统参数，并已显示出超越现有的工作在所有关键性能的措施。 此外，

一种新型的功能级别功率分析和模拟（ FLPAM ）方法，提出了以使高水平估计耗电量。

离散正交变换已被广泛应用于图像数字特征和信号处理方面的应用。沃尔什变换是离散正交变换中很重要的成员，它在信号处理算法和通信领域，模式识别，数据压缩等都有应用。快速沃尔什变换同离散傅里叶变换一样在是整体递推供在全局通信重组的不同阶段使用。它不仅在速度方面和sinusoidal-like变换一样的快捷而且它可以压缩成加入或减去的部分，在实时新信号处理和数字多媒体通信的系统中需要专用的处理器高速计算和传输来满足要求。文献调查结果表明，已经有提议因为一些现有FWT的架构和FHT的结构相类似，他们的硬件实现也应该采取同类方法。

这篇论文意在基于FPGA开发适用高效分布式算法的快速沃尔什变换的架构。光盘大小符合分布式算法（ DA ）的原则，并有稀疏矩阵factorisation技术减小其容量，由此`产生了压缩，高速，节能的设计。这种新型的高等级电力评估的方法叫做功能级别功率分析和模拟方法，也可称为快速沃尔什变换核。该方案已被Celoxica公司采用并应用于在Xilinx Virtex - 2000E FPGA封装技术。具体内容如下文陈述。对于快速沃尔什变换来说数字模型被描述成第二部分。提出的结构和实现方案在第三部分描述。电源分析和调制结果呈现在第四部分。结语在第五五部分。

2数学背景

一般来说，沃尔什矩阵的大小是N*N被定义成迭代矩阵如下：

推倒扩展我们得到如下

S :序列算子

O : 克罗内克尔乘积，即两个矩阵相乘。 Ii :被定义为i*i的大小的矩阵。 K被被定义为i递增的上限。

如果变换长度N（功率）>=2上述式子才可以被用于快速沃尔什变换。

65

Walsh函数中的序列k被定义成0交叉的半个周期。在序列的规则中，在Walsh 矩阵中每一行都比前一行多一个颜色变换。让输入的数据和传输数据代表由x和y 的n维向量表示。 Y向量表示如下：

Xk’s被表示成如下分数格式：

（7）-（6）式如下

定义：

输出的结果：

因为项Wm由xk,m的值决定且只能取2n的值，它可能是之前计算的或是存在随机存储器里的值。这串字符(x1,m……xN,m)被用于做反演和对应Walsh值的地址。减少算法操作数量加快进程速度，沃尔什变换矩阵系数的对称性和稀疏矩阵factorisation都被表述以下等式。这个矩阵用分布式算法增值被描述为等式(5)。

T = W2NX, W4N 和 W2N均为WN稀疏因素由2维和4维非零矩阵对应代表；因为

66

N=8，n=8，Walsh基函数的 N=8 若下图Fig.1表示。

8位向量Walsh变换 黑色代表+1 白色代表-1.

3 提出的快速沃尔什变化结构设计和仿真

在这部分，一种新型沃尔什变换结构设计由各种被提出的结构元素以表格对比的方式描述。0

3.1 结构描述

1维快速沃尔什变换结构显示如图Fig.2。当W=8位时以字节格式输入到芯片的输入端口。在输入模块中加/减法分支模块在每一个奇时钟脉冲时进行操作，和它们的输出是以收缩方式附加到输入缓冲器中，需要花费两个字的时间（ 1除了价值和一个减法值）在每一个偶时钟，直到全部转化载体已读。在前9个周期，8位字符串输出产生平行的偶向量， 并在第二次9周期8位串行输出平行的奇向量。

首先8时钟周期加/减模块在附加模式工作。在第9次时钟脉冲在每个迭代间的反转标志设定为高，加/减分块中在分布式算法模块进行减法。奇/偶-选择器在输入缓冲器复用奇/偶数据值并传输到分布式算法模块中。每个奇数行向量是冗余的， 因为它是每一个行向量的偏移向量。通过列向量T成两组奇向量和偶向量，

67

相同的一组4行向量可用于代替8x8矩阵W4N 。获得奇/偶数向量有4个字组成的向量，因此减小了随机存储器的大小有16字代替了256，随机存储器大小为在分布式算法所用到的每个响亮由2N减小至2N/2。此外， 同样的随机存储器可用基于分布式算法执行向量乘法使奇数行相乘，和下面的偶行向量相乘相同的系数。例如，可以看出在Fig.2“ ROM34 ”用于结果第3和第4行分别点积。新的结构因此获得面积复杂，减少了随机存储器可用区域的大小。最后，每个迭代，生成的分布式算法模块因为奇偶矢量交替输出长度为N/2的向量。 这些向量的缓冲输出部分以文字串行方式写出。该内容在分布式算法模块显示如图Fig.2;

W0 = W48,i(6+i mod 2), W1 = W48,i(4+i mod 2),W2 = W48,i(2+i mod 2) 和 W3 = W48,i(0+i mod 2)

3.2 与已存在的结构对比

设计参数，如时间复杂度（热电偶） ，区域复杂性（交流电）和I / O类型的建议的设计方案与现有的架构列于Table 1。

值得指出的是，分布式算法的时间复杂性的基础快速沃尔什变换的结构在拟定的快速沃尔什变换设计中，只依赖于位数来代表矢量中的每个字 ，而不是矢量的长度。因此，延迟的设计，以及一些时钟周期保持不变，为给定向量大小输入字长。另一方面，在所有其他架构中引用Table1,计算时间随向量长度的增加。与现有的工作结果的对比是列于Table 2。相应的结构*和**分别有N=和

n=1 有效位级别的吞吐量是其他架构的1/8th倍列在表格中。考虑到这一因素，并进行公平的比较，我们可以看到，拟议结构优于现有的架构所有关键性能指标。

68

4电源分析

电源说明依赖于设计，和很多时钟序列因素的影响，设计密度，活动频率，逻辑时钟和特殊FPGA的间联结构，电源供压水平和载入输出。其中的一些因素和系统可变性都可模块化。这种模块化的方法和得到的结果及解释如下。

4.1 电源模块引言

在FPGA设计中功能级别功率分析和模拟是一个新的概念，它曾应用于快速hartley变换(fht)核。数字模型结合了所有的系统变量，建立数学模型的步骤，它结合了所有的系统变量， 使用户可以进行高级别估计电力和能源的核心指标，下面为一组设计周期本身给定的参数：

1 ）建立一个功率表，测量功率为每一个部分的动态功耗，即信号，逻辑， 时钟和I / O。

2 ）确定所有变量系统，包括用户可定制的，和内部系统参数，如：频率，向量长度，面积和电压。

3 ）定义所有的系统变量关系。

4 ）推导系数的模型，每个电源部分执行非线性回归分析电力估计数据。替代模型的系数，并结合他们得到整体电源模型。

4.1.1 。区域模型

设计被占据的区域取决于两个组成部分的结构：控制逻辑地区和随机存储器区域。随机存储器大小随指数向量的长度增加。也是与对数矢量的长度成正比。控制逻辑与矢量长度成正比。基于对这些因素区模型描述如下：

T A 占据全部区域,a1’,a2’是常因数，a1,a2是在区域模块的范围因数。最后的估计 a1=0.0425212072,a2=20.1587911。它是值得一提的是区域模型完全涉及到的精确数据列于table 2

4.1.2 动态片上电源模型

时钟元件有助于片上电源，信号和逻辑力量。FPGA的时钟取决于分配时钟网（这取决于在芯片领域的设计）。其他影响因素是芯片时钟电源频率f，电压v，信号电源电压与网的的数量和长度成正比并超过该信号开关提供的。它还依赖于电压等级之间的转换发生，以及频率的开关。逻辑能耗是一个函数的数目片区域， 芯片频率和电压。输出功率也随之增加与N由于增加电容输出引脚。考虑到这些因素，动态率模型FWT可以定义如下：

69

d1 d2 d3 d4模块的区域因数，最后的估计 d1=0.0376852024,d2=0.773173737。d=-0.0799198372 d=-0.363191983

5结论

一种新的基于有效的IP核心和F快速沃尔什变换和稀疏矩阵factorisation技术的基础上提出。 执行情况评价结果表明拟议的架构优于现有的实现的所有关键性能指标。一种新型功能级别功率分析和模拟也已介绍。

谢 辞

在本次毕业设计中，首先要感谢我的指导老师邢林海老师对我细心指导。老师严谨的治学态度和科学的工作方法给了我极大的帮助和影响。在老师的指导下，我认认真真地研究维特比译码器的原理和实现方法，遇到难解处时老师终是能耐心地解答我疑惑，使得我事半功倍，在此衷心感谢老师对我的关心和指导。老师对于我的科研工作和论文也提出了许多的宝贵意见，在学习上和生活上都给予了我很大的关心和帮助，在此向老师表示衷心的谢意。

我还有感谢我们学院给我们提供的先进的实验设备和浓厚的学习环境，让我在这大学期间学习专业知识提供良好的条件。同时也要感谢在这次毕设中给予我很大鼓励和帮助的小伙伴们，我们一起发现问题，探讨问题，解决问题，很谢谢你们给我意见与建议，让我更懂得团队的重要性。还有感谢通信1102班的全体同学，因为有你们，我的大学才精彩，谢谢你们一路的陪伴。

70