CN1249099A - 使用正交频分复用的数字接收机的单片超大规模集成电路实现 - Google Patents

Abstract

本发明提供一种用于多载波信号的数字接收机的单片实现;该多载波信号通过正交频分复用来发送。提供改进的信道估计和校正电路。接收机具有高精度的采样速率控制和频率控制电路。各tps数据载波的BCH解码使用最少资源来实现,其结构包括小的Galois域乘法器。改进的FFT窗口同步电路被耦合到再采样电路,用于定位与信号的有效帧一起发送的保护区间的边界。实时流水线式FFT处理器在操作上与FFT窗口同步电路关联,并且以缩小的存储器要求来操作。

Description

使用正交频分复用的数字接收机的 单片超大规模集成电路实现

本发明涉及使用多载波调制的电磁信号的接收机，特别涉及一种数字接收机，它实现在单片VLSI(超大规模集成电路)上，用于接收使用正交频分复用的传输，并且适于接收数字视频广播。

编码正交频分复用(coded orthogonal frequency division multiplexing，COFDM)已被提议用于数字音频和数字视频广播，两者都要求有效利用有限的带宽，并且要求传输方法在多种影响面前很可靠。例如，典型信道的脉冲响应可以被建模为具有不同延迟的多个狄拉克(Dirac)脉冲的总和。每个脉冲都要乘以一个因子，其幅度通常符合瑞利分布(Rayleigh law)。这种脉冲串可以延伸几个微秒，使得高比特率的未编码传输不可靠。除了随机噪声、脉冲噪声、和衰落之外，高数据率的数字地面传输的其他主要困难包括：多径传播、和邻道干扰，其中附近的频率具有高度相关的信号变化。COFDM特别适用于这些应用。在实际的COFDM设备中，相对少量的数据被调制到频率间隔紧密的大量载波中的每一个载波。随着载波或子信道的数目增加，数据符号的持续时间也以相同比率增加，这样符号间干扰被大大降低了。

COFDM复用示于图1和2，其中单个COFDM载波或子信道的频谱由线2表示。一组载波频率由图2中的叠加的波形表示，其中满足正交性条件。通常，如果满足下式，则两个实数值函数正交： $\underset{a}{\overset{b}{\∫}}{\mathrm{\ψ}}_p\left(t\right){\mathrm{\ψ}}_q^{*}\left(t\right)\mathrm{dt}=K---\left(1\right)$ 其中，K是常数，并且p≠0时K＝0；p＝q时K≠0。COFDM的实际信号编码和解码在很大程度上依赖于快速傅立叶变换(fast Fourier transform，FFT)，这可从下面各式中看出。

载波信号c由下式给出： $s_c\left(t\right)=A_c\left(t\right)e^{j{[w}_{c}t+{\mathrm{\Φ}}_c\left(t\right)]}---\left(2\right)$ 其中A_c是时间t的数据，ω_t是载波的频率，而φ_c是相位。COFDM信号中的N个载波由下式给出： $s_s\left(t\right)=(1/N)\underset{n=0}{\overset{N}{\mathrm{\Σ}}}{A}_n\left(t\right)e^{j[w_{c}t+{\mathrm{\Φ}}_n\left(t\right)]}---\left(3\right)$

w_n＝w₀+nΔw                                                 (4)在一个符号周期中采样，则

Φ_c(t)Φ_n                                                 (5)

A_c(t)A_n                                                   (6)采样频率是1/T，则产生的信号由下式表示： $s_s\left(t\right)=(1/N)\underset{n=0}{\overset{N}{\mathrm{\Σ}}}{A}_n\left(t\right)e^{j[(w_n+\mathrm{n\Δw})\mathrm{kT}+{\mathrm{\Φ}}_n\left(t\right)]}---\left(7\right)$ 在一个数据符号τ＝NT的周期内采样，并且ω₀＝0， $s_s\left(\mathrm{kT}\right)=(1/N)\underset{n=0}{\overset{N-1}{\mathrm{\Σ}}}{A}_n\left(t\right)e^{j{\mathrm{\Φ}}_n}{e}^{j\left(\mathrm{n\Δw}\right)\mathrm{kT}}---\left(8\right)$ 其与逆离散傅立叶变换的通式相比： $g\left(\mathrm{kT}\right)=(1/N)\underset{n=0}{\overset{N-1}{\mathrm{\Σ}}}G(n/\left(\mathrm{kT}\right))e^{\mathrm{j\Πn}(k/N)}---\left(9\right)$ 在上式中，A_ne^jφ _n是采样的频域的输入信号，而s_s(kT)是时域表示。已知FFT的长度增加将提供更长的符号持续时间，并且对于超过保护区间(guardinterval)的长度的回波来说，提高了系统的坚固性。然而，计算复杂度按照Nlog₂N增加，这是实际的限制。

在存在传输信道引起的符号间干扰的情况下，不能保持信号之间的正交性。解决该问题的一个方法是，通过在时域上在每个符号之前加上一个区间来有意牺牲一些发射能量，该区间超过信道的记忆时间、和任何多径延迟。所选择的“保护区间”要足够大，以吸收任何符号间干扰，并且是通过在每个符号之前复制其一部分来建立的。该复制典型地是符号末端部分的周期延拓。参照图3，数据符号4具有有效区间6，该有效区间6包含在符号中发送的所有数据。在该符号的开头重复有效区间6的末端部分8，作为保护区间10。COFDM信号由实线12表示。也可以在符号的结尾周期性地重复有效区间6的初始部分。

COFDM数据的传输可以根据图4所示的已知通用方案来进行。串行数据流14在串并转换器18中被转换为一系列并行流16。每个并行流16被成组为x比特，每个组形成一个复数，其中x决定其关联的并行流的信号星座。在模块20中进行外部编码和交织之后，经信号映射器22插入导频载波，用于接收机中的同步和信道估计。导频载波典型地有两种类型。连续导频载波在每个符号中的相同位置发送，具有相同的相位和幅度。在接收机中，将其用于相位噪声抵消、自动频率控制、和时间/采样同步。散射导频载波分布在整个符号中，它们的位置典型地随符号的不同而改变。它们主要用于信道估计。接着，在模块24中通过逆快速傅立叶变换(IFFT)在基带对该复数进行调制。然后在模块26中插入保护区间。然后在模块28中将离散符号转换为模拟信号、典型地是低通滤波过的模拟信号，然后上变频到射频。然后通过信道30发送信号，并且在接收机32中进行接收。如本技术领域所熟知的那样，接收机进行传输处理的逆处理，以获得发送的信息。具体地说，进行FFT以对信号进行解调。

在欧洲电信标准ETS 300 744(1997年3月)中提议的COFDM的现代应用规定了数字地面电视的成帧结构、信道编码、和调制。该规定用于在现存的模拟传输频谱分配内实现数字地面电视，并且提供足够的保护以抵抗高电平的共道干扰和邻道干扰。规定了灵活的保护区间，使得系统可以支持各种网络配置，同时保持高的频谱效率、和足够的保护以抵抗来自现存的PAL/SECAM业务的共道干扰和邻道干扰。所述欧洲电信标准定义了两种操作模式。“2K模式”适用于单发送机操作、和具有有限的发送机距离的小的单频网络。“8K模式”可以用于单发送机操作或大的单频网络。支持各种电平的正交调幅(quadrature amplitude modulation，QAM)、以及不同的内部码率，以便在比特率和坚固性之间取得平衡。该系统用于实现运动图像专家组(Moving Picture Experts Group，MPEG)的传输层，并且与MPEG-2编码TV信号(ISO/IEC 13818)直接兼容。

在所述欧洲电信标准中，COFDM帧中的数据载波可以是四相移相键控(quadrature phase shift keyed，QPSK)、16-QAM、64-QAM、非均匀16-QAM、或使用Gray映射的非均匀64-QAM。

接收COFDM传输的主要问题是，由于传输之前的上变频、接收机中的下变频、调谐器中的前端振荡器(该振荡器典型地是压控振荡器)所引起的相位噪声和抖动，难以保持同步。除了提供导频载波来帮助解调中的同步之外，所述欧洲电信标准中没有具体解决这些问题，而是留给实现者来解决。

相位干扰基本上有两种类型。第一，在多载波系统中干扰相邻载波的噪声分量被称为“外来噪声分量(foreign noise contribution，FNC)”。第二，干扰自己载波的噪声分量被称为“自有噪声分量(own noise contribution)”。

参照图5，理想的星座样本的位置由“x”符号34表示。外来噪声分量的效果随机的，导致类高斯(Gaussian-like)噪声。这种受扰样本在图5中由圆圈36表示。自有噪声分量的效果是所有星座点的共同旋转，由每个“x”符号34及其关联的圆圈36之间的位移表示。这称为“共同相位误差”，随符号而有很大变化，因此必须在每个符号周期T_S重新进行计算。共同相位误差可以被解释为符号周期T_S内的平均相位偏差。

为了接收机32能在实际的系统中处理数据符号，对表示每个数据符号的复数信号进行数学运算。这通常是FFT。为了获得有效结果，要求特定形式的定时同步，以便将FFT区间与接收到的数据符号对齐。

因此，本发明的主要目的是提供一种实现在VLSI单片上的高集成、低成本的装置，用于接收数字广播、例如地面数字视频广播。

本发明的另一个目的是提供一种改进的方法和装置，用于将接收到的数据符号与根据COFDM发送的信号中的FFT窗口进行同步。

本发明的另一个目的是改善数字多载波接收机在信道估计方面的稳定性。

本发明的另一个目的是改善多载波数字接收机中所用的自动频率控制电路。

本发明的另一个目的是改善多载波数字接收机中所用的自动采样速率控制电路。

本发明提供一种用于多载波信号的数字接收机，该多载波信号通过正交频分复用来发送。该多载波信号携带具有有效区间、保护区间的数据符号流，其中该保护区间是有效区间的部分复制。在该接收机中，模数转换器被耦合到前端放大器。I/Q解调器用于从由模数转换器采样的数据中恢复同相和正交分量，而自动增益控制电路被耦合到模数转换器。在从I/Q解调器接受I和Q数据的低通滤波器中，该I和Q数据被抽取，并且被提供给再采样电路。该再采样电路中的内插器以第一速率接受抽取过的I和Q数据，并且以第二速率输出再采样过的I和Q数据。FFT窗口同步电路被耦合到再采样电路，用于定位保护区间的边界。实时流水线式FFT处理器在操作上与FFT窗口同步电路关联。该FFT电路的每一级具有复数系数乘法器、和关联的存储器，该存储器具有定义在其中的查找表，用于在复数系数乘法器中将被乘数相乘。查找表中的每个被乘数的值是独一无二的。监视器电路响应FFT窗口同步电路，用于检测预定的指示，即已经检测到有效符号和保护区间之间的边界。

根据本发明的一个方面，该FFT窗口同步电路具有第一延迟单元，用于接受当前到达的再采样过的I和Q数据，并且输出延迟过的再采样过的I和Q数据。减法器产生代表当前到达的再采样过的I和Q数据、与延迟过的再采样过的I和Q数据之差的信号。在第一电路中，该减法器输出信号被转换为具有单极量值的信号，该量值最好是该减法器提供的信号的绝对值。第二延迟单元存储该第一电路的输出信号，而第三延迟单元接收第二延迟单元延迟过的输出。在第二电路中，计算存储在该第二延迟单元中的数据、和存储在该第三延迟单元中的数据之间的统计关系。该FFT窗口同步电路的输出代表该统计关系。最好，该统计关系是F比率。该FFT处理器能够以2K模式和8K模式操作。

FFT处理器具有用于每一级存储器的地址发生器，它接受表示当前要求的被乘数的顺序关系的信号，并产生该存储器的地址，在该存储器中存储有当前要求的被乘数。在本发明的另一个方面中，每个被乘数按照其相应的顺序关系被存储在查找表中，以便由该复数系数乘法器进行乘法，使得该被乘数的该顺序关系定义一个增量序列。该地址发生器具有：累加器，用于存储由其产生的前一地址；用于响应该增量序列、计算当前要求的被乘数的增量值的电路；以及加法器，用于将该增量值加到该前一地址上。

在本发明的另一个方面中，有多个增量序列。被乘数以行的顺序被存储，其中在第一行中，第一增量序列是0，在第二行中，第二增量序列是0，在第三行中，第三增量序列的第一和第二断点B1、B2分别由下式决定： ${B1}_{M_N}=4^N{B1}_{M_N}-\underset{n=0}{\overset{N-1}{\mathrm{\Σ}}}{4}^n$ ${B2}_{M_N}=\underset{n=0}{\overset{N}{\mathrm{\Σ}}}{4}^n$ 并且在第四行中，第三增量序列的第三断点B3由下式决定： ${B3}_{M_N}=2\×4^N+2$ 其中M_N表示该FFT处理器的第N级的存储器。

该接收机提供信道估计和校正电路。导频定位电路从该FFT处理器接收表示帧的变换过的数字信号，并且识别其中导频载波的位置。该导频载波在变换过的数字信号的载波频谱上互相间隔K，并且具有预定的量值。该导频定位电路具有第一电路，用于计算该变换过的数字信号中的载波的阶数，所述载波的位置被进行模K计算。有K个累加器被耦合到该第二电路，用于累加该变换过的数字信号中的各载波的量值，该累加过的量值定义一个组。相关电路用于将K组累加过的量值与预定量值进行相关。在该相关中，第一成员从该帧的开始位置偏移一个独特的偏移量，该第一成员具有在K组的每组中进行过模K计算的位置。

根据本发明的另一个方面，该导频定位电路还具有比特翻转电路，用于对该变换过的数字信号的比特顺序进行翻转。

根据本发明的另一个方面，幅度用于表示载波的量值。最好，载波的量值和预定量值是绝对值。

在本发明的另一个方面中，该相关电路还具有峰值跟踪电路，用于决定K组累加过的量值的第一峰值和第二峰值之间的间隔，其中该第一峰值是最大量值，而该第二峰值是次最高量值。

该信道估计和校正电路还具有：内插滤波器，用于估计导频载波之间的信道响应；以及乘法电路，用于将该FFT处理器输出的数据载波乘以该内插滤波器产生的校正系数。

该信道估计和校正电路还具有相位提取电路，用于从FFT处理器接受相位未校正过的I和Q数据的数据流，并且产生代表未校正过的数据的相位角的信号。该相位提取电路包括用于连续的相位未校正过的I和Q数据的相位角的累加器。

根据本发明的一个方面，该信道估计和校正电路包括耦合到该相位提取电路的自动频率控制电路，其中存储器存储该相位未校正过的I和Q数据中携带的第一符号的累加过的共同相位误差。累加器被耦合到该存储器，并且累加第二符号中多个导频载波的共同相位误差、与该第一符号中相应导频载波的共同相位误差之差。该累加器的输出被滤波，并且被耦合到该I/Q解调器。

根据本发明的另一个方面，该自动频率控制电路的累加器的耦合输出只在接收保护区间的过程中才在该I/Q解调器中被允许。

根据本发明的另一个方面，该信道估计和校正电路还具有耦合到该相位提取电路的自动采样速率控制电路，其中存储器存储该相位未校正的I和Q数据中携带的第一符号中的导频载波的各累加过的相位误差。累加器被耦合到该存储器，并且累加第二符号中各导频载波的相位误差、和该第一符号中相应导频载波的相位误差之差，以定义多个累加过的符号间载波相位误差差分。相位斜率由第一累加过的符号间载波相位差分、和第二累加过的符号间载波相位差分之差定义。该累加器的输出被滤波，并且被耦合到该I/Q解调器。

根据本发明的一个方面，该采样速率控制电路存储多个累加过的符号间相位误差差分，并且计算其间的最佳拟合线。

根据本发明的另一个方面，该自动采样速率控制电路的累加器的耦合输出信号只在接收保护区间的过程中在该再采样电路中被允许。

根据本发明的一个方面，用于存储相位提取电路输出的共用存储器被耦合到该自动频率控制电路和自动采样速率控制电路。

根据本发明的另一个方面，该相位提取电路还具有流水线式电路，用于根据下列级数迭代计算旋转角的反正切： ${\tan }^{-1}\left(x\right)=x-\frac{x^3}{3}+\frac{x^5}{5}-\frac{x^7}{7}+\frac{x^9}{9}-\&hellip;,\left|x\right|<1$ 其中x是相位未校正的I和Q数据的比率。

该流水线式电路包括常数系数乘法器、和用于选择该级数的多个常数系数中的一个的多路复用器。该多路复用器的输出被连接到该常数系数乘法器的输入。

根据本发明的另一个方面，该流水线式电路具有乘法器、用于存储数量x²的第一存储器，其中该第一存储器被耦合到该乘法器的第一输入端，该流水线式电路还具有用于保持该乘法器输出的第二存储器。在该第二存储器和该乘法器的第二输入端之间提供反馈连接。该流水线式电路还具有用于存储该级数值的第三存储器。在耦合到该第三存储器的控制电路的指导下，该流水线式电路计算该级数的N项，并且还计算该级数的N+1项。平均电路还被耦合到该第三存储器，并且计算该级数的N项和N+1项的平均。

在多载波信号的导频载波中发送的数据根据代码产生多项式h(x)被进行BCH编码。解调器对该BCH编码过的数据进行运算，它包括迭代流水线式BCH解码电路。该BCH解码电路耦合到该解调器的电路。它形成该多项式的Galois(伽罗瓦)域，并且计算其多个校正子。该BCH解码电路包括：多个存储寄存器，每个存储相应的一个校正子；以及多个反馈移位寄存器，每个从相应的一个该存储寄存器接受数据。该BCH解码电路具有多个Galois域乘法器。每个该乘法器被连接在反馈环中，该反馈环经过该反馈移位寄存器中相应的一个，并且每个该乘法器将其关联的反馈移位寄存器的输出乘以Galois域的α值。输出Galois域乘法器将两个该反馈移位寄存器的输出相乘。

逻辑网络形成检测电路，连接到该反馈移位寄存器和该输出Galois域乘法器。该检测电路的输出指示数据当前比特中的误差，并且反馈线被该检错逻辑允许，并且连接到该存储寄存器。使用该反馈线，该反馈移位寄存器输出的数据被写回到该存储寄存器中，用于第二次迭代。

根据本发明的一个方面，该输出Galois域乘法器具有：第一寄存器，初始存储第一被乘数A；常数系数乘法器，连接到该第一寄存器，用于乘以值α。该常数系数乘法器的输出被连接到该第一寄存器，以定义第一反馈环，从而在时钟驱动的操作的第k个周期，该第一寄存器包含Galois域积Aα^k。第二寄存器用于存储第二被乘数B。“与”门被连接到该第二寄存器和该常数系数乘法器的输出端。加法器具有第一输入端，连接到该“与”门的输出。累加器被连接到该加法器的第二输入端，而该Galois域积AB由该加法器输出。

本发明提供一种用于估计信道频率响应的方法。它是通过从信道接收具有多个数据载波和散射导频载波的模拟多载波信号来进行的。该散射导频载波互相间隔N，并且以与数据载波的发送功率不同的功率被发送。该模拟多载波相互被转换为其数字表示。对该多载波信号的数字表示进行傅立叶变换，以产生变换过的数字信号。该变换过的数字信号的比特顺序被翻转，以产生比特顺序翻转过的信号。该比特翻转过的信号中的载波的量值被循环累加在N个累加器中，并且累加过的量值与散射导频载波的功率进行相关。响应该相关，产生同步信号，用于识别该多载波信号、最好是有效载波的载波位置。

根据本发明的另一个方面，累加量值的步骤通过将比特顺序翻转过的信号的实部分量的绝对值加到其虚部分量的相应绝对值上来进行，以产生总和，并且分别将该总和存储到N个累加器中。

根据本发明的另一个方面，对累加过的量值进行相关的步骤如下进行，即，识别在其中存储的N个值中具有最高值的第一累加器，该最高值表示第一载波位置，并且识别在其中存储的N个值中具有次最高值的第二累加器，该次最高值表示第二载波位置。然后确定该第一载波位置和该第二载波位置之间的间隔。

为了验证载波位置识别的一致性，将比特顺序翻转过的信号的第一符号的载波位置与其中第二符号的相应载波位置进行比较。

最好，在导频载波之间进行内插，以确定位于其间的相应中间数据载波的校正因子，并且根据该校正因子分别调整该中间数据载波的量值。

根据本发明的一个方面，确定该变换过的数字信号的连续符号的相应导频载波之间的平均相位差。提供表示该平均相位差的第一控制信号，以控制多载波信号的接收频率。只在接收保护区间的过程中才允许该第一控制信号。

最好，对多载波的符号间相位差确定最佳拟合线，以定义相位斜率。

为了更好地理解本发明的这些和其他目的，下面参照附图详细描述本发明的示例，其中：

图1示出COFDM子信道的频谱；

图2示出COFDM信号中的多个载波的频谱；

图3是COFDM信号的示意图，并且示出数据符号格式；

图4是基于COFDM系统的FFT的方框图；

图5示出COFDM信号星座中的某些扰动；

图6是本发明优选实施例的定时同步方法的流程图；

图7是为了进行粗定时同步而对几个数据符号进行的F比率测试的曲线图；

图8不同自由度的不完整的beta函数曲线图；

图9是有助于理解本发明的统计显著性(significance)测试的曲线图；

图10是本发明可替换实施例的同步电路的电路图；

图11是本发明另一个可替换实施例的同步电路的电路图；

图12是本发明的数字接收机的单片实施例的方框图；

图13是图12所示的数字接收机的前端的更详细的方框图；

图14是图12所示的数字接收机的FFT电路、信道估计和校正电路的方框图；

图15是图12所示的数字接收机的另一部分的方框图；

图16是图14所示的信道估计和校正电路的更详细的方框图；

图17是图12所示的数字接收机的自动增益控制电路的电路图；

图18是图12所示的数字接收机的I/Q解调器的电路图；

图19更详细地示出图13所示的低通滤波器；

图20示出图19所示的低通滤波器的响应；

图21示出图12所示的数字接收机的再采样电路；

图22示出图21的再采样电路中的内插器的一部分；

图23是图14所示的FFT窗口电路的更详细的方框图；

图24是图14所示的FFT计算电路中的蝶形单元的电路图；

图25和26是现有技术的蝶形单元的电路图；

图27是本发明的基2²+2 FFT处理器的电路图；

图28是图27所示的FFT处理器的32点流图；

图29是本发明的可配置2K/8K基2²+2单路径、延迟反馈流水线式FFT处理器的电路图；

图30是图29所示的电路中所用的复数乘法器的详细电路图；

图31是图29所示的电路中所用的复数乘法器的可替换实施例的详细电路图；

图32是图29所示的电路中的每个乘法器的旋转(twiddle)因子的组织的另一个示意图；

图33示出图29所示的电路中的每个乘法器的旋转因子的组织；

图34是图29所示的电路中所用的地址发生器的电路图；

图35是图34所示的地址发生器的泛化示意图；

图36是图16所示的信道估计和校正电路进行的导频位置处理的流程图；

图37是本发明的导频本地化的实施例的流程图；

图38是图14所示的电路的tps序列模块的更详细的方框图；

图39是图38所示的tps处理电路中所用的BCH解码器的电路图；

图40是图39所示的伽罗瓦(Galois)域乘法器的更详细的电路图；

图41是图12所示的数字接收机的自动采样控制和自动频率控制环路的一般性的方框图；

图42是图41所示的自动采样控制和自动频率控制环路的更详细的方框图；

图43是图42所示的电路的相位提取模块的更详细的方框图；

图44是图43所示的方框图中计算反正切所用的电路的电路图；

图45是泰勒(Taylor)展开到32项的不同α值的方差的曲线图；

图46是泰勒展开到31项的不同α值的方差的曲线图；

图47是泰勒展开到31和32项的平均的不同α值的方差的曲线图；

图48是具有所示最适曲线的导频载波的相位差的曲线图；

图49是图41所示的自动采样控制和自动频率控制环路的可替换实施例的更详细的方框图；

图50示出图15的解映射(demapping)电路中所用的编码星座格式；

图51示出将I、Q数据转换为使用图50所示的格式的二进制数据值；

图52是图15所示的符号解交织(deinterleaving)电路更详细的方框图；

图53是图15所示的比特解交织电路的更详细的方框图；

图54示出图53所示的比特解交织电路将编码星座格式转换为24比特软I/Q格式；

图55是图12所示的接收机的微处理器接口的更详细的方框图；

图56是图12所示的接收机的系统控制器的更详细的方框图；以及

图57是图56所示的接收机的系统控制器中的信道采集的有关状态图。

FFT窗口的对齐

再参照图3和4，根据本发明，将统计方法应用于COFDM信号，以找出保护区间10的结尾。该方法是结合上述的欧洲电信标准来解释的，但是也可以应用于具有前缀式或后缀式保护区间的许多频分复用形式。它可以在只给出接收到的采样过的复数信号(实线12)和有效区间6长度的情况下，使接收机32能找出保护区间的结尾。该方法依赖于下述事实，即，保护区间10是数据符号4的最后部分的复制。在接收机32中，由于来自信道的回波和噪声以及本地振荡器中的误差，保护区间10和数据符号4的最后部分将会不同。如果引入的噪声是随机的，则可以应用统计方法。根据本发明，以与发送机中使用的速率近似相等的速率对接收到的复数信号进行采样。计算接收到的一对样本的差值信号，该一对样本之间的时间间隔尽可能接近有效区间6。该间隔应该等于施加快速傅立叶变换(FFT)的长度(即2048或8192个样本)。令

S_i＝|S_i|-|S_i-fftsize|                       (14)其中S_i是差值信号；s_i和s_i-fftsize是当前和前一复数输入样本，对该样本取模。即，下标“i”标引输入值的线性时间序列。假设输入信号是随机的，则S_i也是随机的。在保护区间中s_i和s_i-fftsize将是类似的，尽管由于信道的影响而不是相同的。因此，S_i将是一个具有很小扩散(dispersion)的随机信号。这里的术语“扩散”大体是指值的扩散，而不限于特定的数学定义。通常，一个符号的有效部分与下一个符号的有效部分无关。在保护区间之外，S_i将是随机的，具有相当大的扩散。为了找出保护区间的结尾，对差值信号S_i的扩散进行监视，以寻找其在保护区间10和有效区间6的边界上出现的显著增加。本发明人还观察到，在保护区间10的开头可以看到扩散的大的减少。

根据本发明的优选实施例，输入信号的样本在包括至少一个符号周期T_S的区间内被存储。在一个样本块中计算差值信号S_i的扩散。该块在在时间上后移多个(n个)样本，重新计算扩散。这两个块在这里被成为“比较块”。求出第一比较块中的当前扩散、和前一比较块中的扩散的比率。然后，使用F比率显著性测试来求两个比较块的扩散的显著差值(significantdifferences)。F比率被定义为： $F=\frac{\mathrm{VAR}\left(i\right)}{\mathrm{VAR}(i-n)}---\left(15\right)$ 其中n是正整数，i标引输入样本，而VAR(i)是长度为N的样本值块的方差。方差可以被定义为： $\mathrm{VAR}\left(i\right)=\frac{1}{N}\underset{j=0}{\overset{N}{\mathrm{\&Sigma;}}}{\left(S_{i-j}\right)}^2-{\left(\frac{1}{N}\underset{j=0}{\overset{N}{\mathrm{\&Sigma;}}}{S}_{i-j}\right)}^2---\left(16\right)$ 尽管在优选实施例中使用F比率显著性测试，但是也可以使用给出与扩散变化有关的信号的、两个扩散值的其他函数。有许多这样的函数。F比率的优点是，对于随机输入信号，它具有已知的概率分布，使得能够进行方便的统计分析，以便进行性能分析和系统设计。此外，F比率本身对信号进行归一化，使得结果不依赖于信号电平。

下面结合图6说明该方法，其中，在步骤38测量当前评价块中样本对(pair)的第一成员。在步骤40经历一个有效区间6(图3)的延迟。这可以通过数字延迟、例如FIFO来实现，或者等价地通过在存储器中将样本缓冲一个有效区间的时间并存取存储器的适当单元来实现。在步骤42测量样本对的第二成员，并且在步骤44确定和存储第一和第二成员之间的差值。在决策步骤46测试当前块的结尾。评价块的长度不应该超过保护区间的长度，并且可以比其小很多。在没有到达当前块结尾的情况下，在步骤48采集下一个样本，并且控制返回到步骤38。

如果已到达当前块的结尾，则在步骤50测量当前块的扩散，并且作为两个数据比较块处理。在决策步骤52进行测试，以确定两个比较块的组是否已被评价。如果该测试是否定的，则在步骤54采集下一个数据块，此后控制返回到步骤38。其他数据块不必与已完成的块连续。

在决策步骤52的测试是肯定的情况下，在步骤56对两个比较块的组计算F比率。在步骤56获得的结果被交给步骤60进行峰值检测。峰值检测可任选地包括显著性的统计测试，如上所述。

如果检测到峰值，则在步骤62建立保护区间的边界，用于下一步信号重构所需的FFT窗口的同步。如果未检测到峰值，则用从数据流的另一部分取出的样本块重复上述处理。例1：

现在参照图7，根据上述欧洲电信标准使用随机数发生器来产生复数信号，并且通过具有加性白高斯噪声(SNR＝3.7)的莱斯(Ricean)信道模型进行发送。然后根据上述方法对数据符号进行分析。结果产生的6个数据符号如图7所示，其中为了便于表示而在对数轴上用线64画出F比率，因为保护区间开头和结尾的尖峰66、68非常大。

尽管从图7可明显看出，保护区间的结尾容易使用几种熟知的峰值检测器来找出，有可能应用统计测试来更精确地回答此问题：两个样本块具有相同的扩散？这是一个虚(null)假设H₀，即，扩散是相同的，而观察到的F中的尖峰只是随机波动引起的。如果H₀具有非常低的概率，则可将其抛弃，这将对应于保护区间的开头或结尾的检测。从COFDM符号的构造方式来看，可以期望H₀对完全落在保护区间内或有效区间内的比较块为真，但是当比较块跨过保护区间的开头或结尾的边界时其为假。如果随机样本的比较块取自相同的总体(population)，则F的概率表示为： $Q\left(F\right|v_1,v_2)=I_x(\frac{v_1}{2},\frac{v_2}{2})---\left(17\right)$ 其中I()是不完全Beta函数， $x=\frac{v_2}{v_1+v_{2}F}---\left(18\right)$ 而v1和v2是自由度，用该自由度来估计第一和第二扩散。在本例中，如果n＞＝N则v1＝v2＝(N-1)。该函数的形状示于图8。从统计的观点来看，n应该足够大，以便两个块不重叠，即n＞＝N。如果块确实重叠了，则第二扩散的计算将使用用于计算第一扩散的样本。这将有效地减少自由度的数目，从而减少结果的意义。已经确定设置n＝N效果很好。

式(13)中的函数Q()实际上给出了单尾(one-tailed)概率。如果F非常大或非常小，则H₀可以抛弃，并且要求双尾(two-tailed)测试。实际上，两个尾部是相同的，因此对于双尾测试，概率是式(13)给出的概率的两倍。然而，这导致概率值大于F＜1时的概率值。因此概率p如下计算： $p=2I_x(\frac{v_1}{2},\frac{v_2}{2})---\left(19\right)$ 因此，如果(p＞1)，则p＝2-p。此概率反映了H₀的可行性(viability)。这样，如果p小，则H₀可抛弃，并且可以说，对于指定的确信度，来自各样本总体的比较块具有不同的扩散。上述欧洲电信标准规格规定，块长度N对相关算法应该是32。N＝{32，64}被成功地尝试过。使用N的这些值而获得的概率函数示于图9。在优选实施例中，设定p＜＝0.05时可抛弃H₀。

精确的实现是计算F，然后计算x，然后计算不完全Beta函数，然后计算p，然后施加门限测试。此算法很难用硬件实现，因为Beta函数非常复杂。在优选实施例中，设置接受门限和N参数、从而定义F的上限和下限则简单得多，并且给出相同结果。因此只需计算F，并且将其与极限进行比较。为了简单地找出保护区间的结尾，则可以安全地假设F＞1。只需F的上限。为了精确地计算F的极限，可以使用合适的求根法，例如Newton-Raphson(牛顿-拉弗森)法。典型值在表1中给出。

                       表1

p门限	v1＝v2＝31		v1＝v2＝63
					F_lower(下限)	F_upper(上限)	F_lower	F_upper
	0.2	0.627419	1.593832	0.722591					1.383909
0.1					0.548808	1.822132	0.658620	1.518326
	0.05	0.488143	2.048582	0.607525					1.646022
0.01					0.386894	2.584689	0.518205	1.929738
	0.005	0.354055	2.824422	0.487936					2.049448
0.001					0.293234	3.410251	0.429794	2.326695
	10-4		4.337235
10-5						5.393528
	10-6		6.605896
10-7						8.002969
	10-8		9.616664

此方法被使用具有加性白高斯噪声(SNR＝3.7)的指定信道模型成功测试过。

式(12)给出的扩散公式在硅实现时要求乘法器。F的计算是除法，其中只要两个块具有相同的长度，则(N-1)归一化常数互相抵消。精确的乘法和除法的硅实现将会很昂贵。在优选实施例中，进行了简化，这将给出不太精确、但仍可行的F值。可以假设S_i具有零均值，从而无需计算样本块的均值。这也将自由度的数目从(N-1)增加到N。不是使用标准平方和公式来计算方差，而是可以通过平均绝对偏差来估计扩散。VAR(i)的公式变为： $\mathrm{VAR}\left(i\right)={\left(\frac{1}{N}\underset{j=0}{\overset{N-1}{\mathrm{\&Sigma;}}}\right|S_{i-j}\left|\right)}^2---\left(20\right)$ 如果两个块具有相同的长度，则(1/N)因子能除尽。但是还剩下所需的两个扩散的除法和求平方。这些可以使用以2为底的对数来解决。将式(16)代入式(11)得： $F={\left(\frac{\underset{j=0}{\overset{N-1}{\mathrm{\&Sigma;}}}\left|S_{i-j}\right|}{\underset{j=0}{\overset{N-1}{\mathrm{\&Sigma;}}}\left|S_{i-n-j}\right|}\right)}^2={\left(\frac{S_a}{S_b}\right)}^2---\left(21\right)$ 取以2为底的对数得：

log F＝2(log s_a-log s_b)＝y                         (22)因此，只需计算y，并且将其与F上限的以2为底的对数进行比较。该比较可以通过从2(log₂s_a-log₂s_b)中减去极限并与零进行比较来进行。因子2可以被吸收进该极限。

如果对数值以定点小数的形式来存储，则以2为底的对数的计算在硬件上相对简单。该小数可以被分解为指数和小数底数：x＝A2^B。取以2为底的对数给出logx＝logA+B。由于A是小数，所以可行的方法是使用查找表来求其对数。指数B可以从MSB的位置来求出(因为s_a和s_b将都是正整数)。

因此，可将计算简化为只需加法和减法运算。如果使用此方法，则也应该使用v1＝v2＝N重新计算极限。在实际中，对于特定的应用，有意义的电平可以根据经验来设定，最好p＝0.05。

本领域的技术人员可以理解，在不脱离本发明精神的情况下，可以使用各种扩散测量方法，例如标准偏差、歪斜(skew)、各种矩、直方图、和其他本领域熟知的计算。

在本发明的第一可替换实施例中，使用信号的实部或虚部中的一个、而不是模来应用上述方法。此实施例在硬件实现上很经济。

在本发明的第二可替换实施例中，式(11)的n参数已被优化。在保护区间的结尾，两个块跨过向有效区间过渡的更多部分，使得扩散清楚地增加。使用任何n＞2的值的缺点是，随着后一块接近边界，几个连续点将显著增加。这个小问题很容易通过在检测到边界后引入死期(dead period)来克服。即，一旦检测到尖峰，则在企图定位另一个尖峰之前，接受长度等于FFT窗口的一组样本。死期的另一个好处是不引入假尖峰。当使用更大的n值时，尖峰66、68(图7)增加，而H₀噪声F信号依然照旧。例2：

已经系统地测量了作为n的函数的最大F尖峰高度，同时测量了F中的背景变化(variation)。结果示于表2。

                       表2

(1)

(2)

(3)

(4)

(5)

n	＜F＞	Fs.d	Fmax	(4)/3
					3	1.0009	0.07	7.5	107
5	1.0012	0.10	10.7	107
					10	1.0011	0.14	12.9	92
15	1.0014	0.17	16.7	98
					20	1.0014	0.19	19.3	102
30	1.0012	0.23	20.9	91
					40	0.9975	0.24	22.0	92
50	0.9926	0.25	20.4	81.6

表2是使用图7中分析过的信号的前5帧而算出的。表2的栏(2)和(3)中的统计是通过排除F＞＝3.0的任何点而进行的，以便在计算中排除尖峰。否则，尖峰会影响均值和标准偏差，尽管它们来自不同的统计总体。

结果表明，F中的背景变化F_s.d.受n影响，渐进地增加到接近0.28的值。这有可能是重叠块的影响。例如，对于N＝64和n＜64，计算扩散的多个块将包含一些相同值，从而这些扩散是相关的。为了测试该理论，对于n＞N，评价F_s.d.，其结果示于表3。

                       表3

n	Fs.d
		60	0.258
70	0.266
		80	0.270
90	0.278
		100	0.285
128	0.297
		256	0.366

在n＞＝N/2处，依赖性成为线性的。如果每n个样本、而不是每个样本计算一次F，则该依赖性会减少。然而，小的保护区间要冒的危险是不能使第一块整个落在保护区间内，也不能使第二块整个落在有效区间内。

下面，参照图10来描述本发明的第三个可替换实施例，图10示意性地示出定时同步电路70。该电路接受复数输入信号72，并且包括计算其输入的模的电路模块74，该输入取自节点83。电路模块74保证下一个处理的值是无符号数。电路模块74的输入是减法器75算出的差值信号，减法器75将输入信号72、和已经通过延迟电路79处理过的输入信号72的延迟版本作为输入，延迟电路79最好实现为长度为L的FIFO(先入先出)77，其中L是FFT窗口的长度。如上所述，也可以在输入信号72是实数、虚数、或复数、甚至是复数的模时操作该电路。在输入信号72是实数、或虚数的情况下，可以修改电路模块74，并且可以是任何除去减法器75输出的符号的已知电路，或者等价地设置符号，以使得输出单调积累；即，电路具有单极性输出。电路模块74的输出最终受时钟控制地输入到数字延迟器，该数字延迟器最好实现为FIFO 78。当FIFO 78满时，断言信号SIG180，并且FIFO 78的输出可用，这由“与”门82指示。加法器/减法器电路84还被连接到节点76，并且其输出被存储到寄存器86。加法器/减法器电路84的输出的延迟版本取自寄存器86，并且作为第二输入从线88上反馈到加法器/减法器电路84。在信号SIG1 80已被断言的情况下，从节点76的信号中减去电路模块74的输出的被延迟第一预定区间N的版本，其中N是比较块中的样本数。

线88上的信号是查找表的索引，最好实现为只读存储器(ROM)，如ROM90所示。ROM90的地址包含线88上的信号量值的以2为底的对数，该对数接着出现在节点92上。节点92被连接到减法器94，并且被连接到延迟电路，如FIFO98所示，该延迟电路用于算出式(17)中间项的分母。

减法器94产生的信号在比较电路106中与预定门限值F_LIMIT的log2进行比较，为了简单，比较电路106示为连接到比较器110的加法器108。当定位到保护区间的边界时，断言输出信号SYNC 112。

尽管没有在本优选实施例中实施，但是也可以动态配置FIFO 77的长度，使得被评价的区间的长度可以根据操作条件来调节。这可以通过将值存储到RAM 114中的节点92上以计算其扩散来方便地实现。

在参照图11说明的本发明的第四可替换实施例中，与图10所示的实施例的部件类似的部件具有相同的标号。定时同步电路116类似于定时同步电路70，只是现在延迟电路79被实现为FIFO 77和另一个FIFO 100，由复用器102选择其中的一个。FIFO 77、100提供相同的延迟；然而两者的容量不同。FIFO 100用于存储取自与FFT窗口的长度相等的区间的样本，并且通常在第一操作模式中被选择，例如在信道采集的过程中，当有必要评价整个符号以便定位保护区间的边界时。在所述欧洲电信标准中，要求多至8K的数据存储器，并且要求相应的资源。在下一操作中，可以从前面的多个符号的历史得知保护区间边界的近似位置。因此，在第二操作模式中，只需评价小得多区间，以确认保护区间边界的精确位置。计算扩散所用的样本数目被保持到小的数目，最好是32或64，相应地选择更小的FIFO 77以保存计算出的值。从而保存的资源可以用于解调器中的其他功能，并且较大的FIFO 100所用的存储器还可以被再分配用于其他目的。

控制模块81任选地使评价区间超前于连续符号的数据流中的符号边界，并且还可以用于死期的延迟。最终，移动的评价区间跨过当前符号的保护区间的边界，然后确定同步。选择评价区间的长度以尽量减少存储器的使用，同时使其足够大以获得评价区间中的统计显著性。评价区间和FIFO77的评价区间可以静态地或动态地配置。COFDM解调器的单片实现概述

首先参照图12，该图示出本发明的多载波数字接收机的高级方框图。下述实施例符合ETS 300 744电信标准(2K模式)，但是本领域的技术人员可以对其进行修改以便在不脱离本发明精神的情况下用其他标准操作。从信道例如天线128将射频信号接收到调谐器130，调谐器130是传统的调谐器，最好具有第一和第二中频放大器。第二中频放大器(未示出)的输出通过线132传导到模数转换器(ADC)134。模数转换器134的数字化输出被提供给模块136，其中进行I/Q解调、FFT、信道估计和校正、内部和外部解交织、以及前向纠错。载波和定时恢复是在模块136中整个在数字域中进行的，至调谐器130的唯一反馈是线138上提供的自动增益控制(AGC)信号。线140上的稳定的20 MHz时钟被用作外部模数转换器134的采样时钟。主微处理器接口142可以是并行的或串行的。本系统的设计是使其以尽量小的主处理器支持来操作。特别是信道采集可以无需主处理器干预来进行。

为了便于表示，模块136内进行的功能被分成下列各组：前端(图13)、FFT和信道校正组(图14)、以及后端(图15)。

如图13所示，IQ解调器144以20兆样本每秒的速率从总线146上的模数转换器134(图12)接收I/Q样本。AGC电路148也从总线146取得其输入。使用数字控制振荡器(numerically controlled oscillator)150来实现频率速率控制环，数字控制振荡器150接收线152上的频率误差信号、和线154上的频率误差更新信息。频率和采样速率控制是根据导频载波信息在频域进行的。稍后将详细说明从导频载波导出的频率误差信号、和频率误差更新信息。IQ解调器144输出的I和Q数据都经过相同的低通滤波器156，被抽取到10兆样本每秒，然后提供给sinc(内插函数)内插器158。样本速率控制是使用数字控制振荡器160来进行的，数字控制振荡器160在线162上接收从导频信号导出的样本速率控制信息，并且在线164上接收样本误差更新定时信息。

如图14所示，FFT窗口的采集和控制在模块166中进行，模块166从sinc内插器158(图13)接收信号。在FFT计算电路168中进行FFT计算。信道估计和校正在信道估计和校正模块170中进行，并且涉及导频载波的本地化，这将在下面详述。在导频本地化的过程中获得的tps信息在tps序列提取模块172中被处理。信道估计和校正模块170将未校正的导频载波提供给校正电路174，校正电路174算出采样速率误差和频率误差信号，将其反馈到数字控制振荡器150、160(图13)。

参照图15，信道估计和校正模块170输出的校正过的I和Q数据被提供给解映射电路176。从tps数据导出的当前星座和分层星座(hierarchicalconstellation)参数也被输入到线178、180。产生的符号在符号解交织器182中使用1512×13的存储器被解交织。存储器中的每个单元的一个比特用于具有信号强度不足以可靠进行信道校正的标志载波。然后，比特解交织器184将解交织过的I和Q数据提供给Viterbi(维特比)解码器186，Viterbi解码器丢弃标志载波，以便不可靠的载波不会影响追溯量度(tracebackmetrics)。Forny(弗尔纳)解交织器188接受Viterbi解码器186的输出，并且耦合到Reed-Solomon(里德-索罗门)解码器190。依赖Viterbi和Reed-Solomon解码器提供的前向纠错来恢复标志载波的情况下丢失的数据。

参照图16，在本优选实施例中，在模块192中参照前一符号计算未校正的载波的均值。数据载波的内插过的信道响应小于该均值的一部分、最好是该均值的0.2倍，该数据载波将被标以bad_carrier(坏载波)标志194。bad_carrier标志194经过解映射电路176、符号解交织器182、和比特解交织器184被提供给Viterbi解码器186，在Viterbi解码器186中，该标志用于丢弃与不可靠的载波有关的数据。用于设置bad_carrier标志194的参数可以由微处理器接口142来改变。

输出接口196产生一个输出，该输出可以是MPEG-2传输流(transportstream)。符号解交织器182、和比特解交织器184是传统的。Viterbi解码器186、Forney解交织器188、Reed-Solomon解码器190、和输出接口196是传统的。它们可以是下述申请中所公开的部件：即，1996年4月26日提交的、题为“An Error Detection and Correction System for a Stream ofEncoded Data(编码数据流的检错和纠错系统)”的待审的申请No.638,273；1995年6月7日提交的、题为“Signal Processing System(信号处理系统)”的申请No.480,976；1995年6月7日提交的、题为“Signal ProcessingApparatus and Method(信号处理装置和方法)”的申请No.481,107。所有这些都包括在此作为参考。多载波数字接收机126(图12)的操作由系统控制器198控制。

任选地，分层星座参数可以被编程、而不是从tps数据导出，以加速信道采集。

多载波数字接收机126的输入、输出信号和寄存器映射分别在表4、和5中描述。自动增益控制

AGC电路148(图13)的目的是产生控制信号，以便在模数转换之前改变输入到该装置的COFDM输入信号的增益。如图17更详细所示，Sigma-Delta调制器200用于提供一个信号，该信号在由外部R-C网络低通滤波之后，可用作调谐器增益控制的信号。

控制电压信号202的量值由下式给出：

control_voltage＝control_voltage-error               (23)其中

error＝K(|data|-mean)                                (24)其中K是常数(通常K＜＜1)，它决定AGC控制环的增益。均值可由高斯噪声的统计来确定，它是COFDM输入信号的特性的较好的近似，其中输入数据被乘以+/-1。当信号resync(重新同步)204被设置为低时，这指示发生信道变化或其他需要重新同步的事件，则控制电压信号202被设置回其初始值。

AGC电路148的微处理器(μp)接口142的输入和输出信号以及寄存器分别示于表6、7、和8。IQ解调器

IQ解调器144(图13)的功能是恢复接收到的采样过的数据的同相和正交分量。它更详细地示于图18。

数字控制振荡器150以(32/7)MHz的速率产生同相和正交正弦信号，并且在乘法器206中将其乘以数据样本。地址发生器208线性地增加相位。频率误差输入210递增或递减相位增加值。在乘法器206中使用10比特×10比特乘法运算将样本乘以正弦信号。在一个实施例中，IQ解调器144以20MHz进行操作，然后在再定时模块212中被再定时到40 MHz。在优选实施例中，IQ解调器144以40MHz进行操作，此时省略再定时模块212。

正弦信号由地址发生器208在线214、216上产生。相位值用作查找表ROM218的地址。为了节省空间，在查找表ROM 218中只存储1/4个周期。通过对来自ROM 218的数据进行运算、并且在负周期时对数据进行反号，可以由存储的1/4个周期来产生整个周期。对每个输入样本，从查找表ROM 218读出两个值-余弦和正弦，它们相位差90度。

IQ解调器144的输入和输出信号分别在表9和10中描述。低通滤波器

低通滤波器156(图13)的目的是在IQ解调之后去除混叠的频率-高于32/7 MHz第二IF的频率被抑制40 dB。I和Q信号被分别滤波。输出数据被抽取到10兆个样本每秒(Msps)，因为滤波器去除了高于原始20 Msps采样速率的1/4的任何频率。该滤波器具有大约60个抽头，这些抽头中心对称，使得滤波器结构被优化，以减少乘法器220的数目。图19是一个低通滤波器156的方框图，其他滤波器与此相同。图19示出代表性的对称抽头222和中心抽头224。低通滤波器156所需的滤波器响应示于图20。

低通滤波器156的输入和输出信号分别在表11和12中描述。再采样

参照图13，再采样的目的是将低通滤波器156输出的10Msps数据流降低到(64/7)Msps的速率，即发送机中的地面数字视频广播(DVB-T)调制器的标称样本速率。

再采样在sinc内插器158、和数字控制振荡器160中进行。后者产生标称值为64/7 MHz的信号。再采样电路更详细地示于图21。数字控制振荡器160在线226上产生有效脉冲，并且产生信号228，信号228表示每个40 MHz时钟周期的内插距离，在40 MHz的时钟周期中应该产生应该64/7 MHz的样本。内插距离用于选择内插滤波器系数的合适的设置，这些系数被存储在系数ROM 230中。应该注意，只有I数据的sinc内插器示于图21中。用于Q数据的结构与此相同。

图22示出内插距离和有效脉冲的产生。作为标称值，T_S＝1/10 Msps，而T＝1/(64/7)Msps。可以通过适当调整工作频率，来使用公开于前述申请No.08/638,273的sinc内插电路。

sinc内插器158的输入和输出信号以及数字控制振荡器160分别在表13和14中描述。FFT窗口

如上面详细所述，FFT窗口函数的功能是定位COFDM符号的“有效区间”，该“有效区间”有别于“保护区间”。该函数在此方便地称为“FFT窗口”。在本实施例中，有效区间包含2048个载波的时域表示，这些载波将由FFT本身进行恢复。

FFT窗口以两种模式进行操作：采集和跟踪。在采集模式中，搜索整个输入样本流，以找出保护区间/有效区间边界。如上所述，这由F比率达到峰值来指示。一旦定位到该边界，则窗口定时被触发，并且再次搜索输入样本流，以找出下一个保护区间/有效区间边界。当定位到此边界时，则可知保护区间的长度，并且可以预测下一个保护/有效边界的期望的位置。然后，FFT窗口函数切换到跟踪模式。

本实施例在跟踪模式方面类似于上述的第四可替换实施例。在跟踪模式中，只搜索被期望是保护/有效边界的点周围的一小部分输入样本流。有效区间的位置缓慢漂移，这是受计算FFT之前的前端中的IF频率和采样速率偏移的影响。跟踪该漂移并校正FFT窗口定时，该校正只在保护区间的过程中进行。

本领域的技术人员应该理解，在如这里公开的实际的单片实现中，就芯片面积而言，存储器是昂贵的资源，因此必须尽量减少存储器。参照图23，在采集模式中，FFT计算处理没有激活，所以应该在FFT窗口和FFT计算之间共享硬件，最主要的是将1024×22 RAM 232用作FFT窗口的FIFO，并且由复用器236选择该存储器用于接收线234上的FFT数据。一旦在跟踪模式中，则FFT计算处理激活，使得用于恢复采样速率的其他控制环和依赖于FFT数据(例如COFDM符号中的导频)可以初始化。因此，跟踪模式要求专用的跟踪FIFO 238，FIFO 238由复用器240进行选择。

图23所示的FFT窗口电路的输入和输出信号、以及与微处理器接口142有关的信号分别在表15、16、和17中描述。

在一个实施例中，根据统计设置的门限电平用于F比率信号(见图7)，以便检测分别在保护区间的开头和结尾出现的负尖峰和正尖峰。两个尖峰的距离用于估计保护区间长度。重复检测正尖峰用于确认正确的同步。然而，如果在噪声条件下采用该方法，则F比率信号就会含噪声，因而不是总能可靠地检测到尖峰。

在另一个实施例中，峰值检测用于找出F比率中的尖峰。已经发现，只有在或超过大约12 dB的载波噪声(C/N)比时，固定门限才可靠。峰值检测通常更灵敏，更具体，通常在6-7 dB时能够进行可靠的操作。最大值应该在保护区间的结尾出现。针对可能的保护区间长度，检查两个最大值之间的时间差。考虑到噪声，该时间差指示最可能的保护区间长度，而这些最大值本身则很好地指示出符号有效部分的开头。

最好，对多个符号重复该处理以确认检测，并且当C/N比低时，该处理可望改善性能。

数据流被传递到累加器242、244，每个累加器进行模64运算。转换为对数、和对数的减法在模块246中进行。在峰值检测器模块248中检测峰值。在模块250中进行符号峰值的平均。

在噪声条件下，由于噪声，最大值可能给出保护区间长度和有效符号开头的不精确的指示。对付该问题的总的战略是进行有限次重试。

目前，F比率的计算是飞速(on the fly)进行的，即，在每个点只进行一次。只由64个值来计算方差估计。在噪声条件下，方差估计含噪声，峰值可能变得模糊。在任选的变形中，该问题是通过获得更多的方差估计值、通过在每个可能的T+G_max点的采集过程中将方差估计存储到存储模块256来解决的。方差估计本身可以通过累加每个点的方差、然后在多个符号的时间内进行滤波来形成。移动平均滤波器或无限脉冲响应(IIR)滤波器很适合。符号的移动游程最好在16和32之间，该游程在模块252中被积分，这提高了噪声条件下峰值检测的可靠性。搜索保持积分过的F比率值的存储模块256，以找出最大值。该搜索的长度是T+G_max，其中G_max是最大保护区间长度T/4。最好存储模块256的存储器是根据处于采集模式还是处于跟踪模式来动态分配的。任何未用的存储器被释放给其他处理。类似地，在跟踪模式中，积分过的数据流被存储到跟踪积分缓冲器254中。

用多至4个符号、未使用IIR滤波器测试了该方法，发现峰值可以被恢复。然而，这种方法无需增加存储器。FFT处理器

离散傅立叶变换(DFT)具有下述著名公式： $x\left(k\right)=\frac{1}{L}\underset{n=0}{\overset{L-1}{\mathrm{\&Sigma;}}}x\left(n\right)W^{\mathrm{nk}---}k=\mathrm{0,1},\&hellip;,N-1---\left(25\right)$ 其中N＝DFT中的点数；

x(k)＝频域中的第k个输出；

x(n)＝时域中的第n个输出；并且 $W_L^{\mathrm{nk}}=e^{-j\left(2\mathrm{\&Pi;nkL}\right)}---\left(26\right)$

W又称为“旋转因子”。

对于N＞1000，DFT的计算负担很重，不是实际可行的。转而使用下式给出的连续傅立叶变换： $x\left(k\right)=\underset{t=-\&infin;}{\overset{t=+\&infin;}{\&Integral;}}x\left(t\right)e^{-\mathrm{j\&omega;t}}\mathrm{dt}---\left(27\right)$ 当根据熟知的FFT算法来计算时，连续傅立叶变换将原始的N点序列分解成两个更短的序列。在本发明中，FFT是使用图24所示的基本蝶形单元258来实现的。输出C和D表示方程C＝A+B、和D＝(A-B)W^k。蝶形单元258利用了W的幂实际上只是复数加法或减法这一事实。

作为FFT计算电路168(图14)而实现的实时FFT处理器是多载波数字接收机126(图12)的实现中的关键部件。已知的8K流水线FFT芯片用1.5M个晶体管来实现，根据Bi和Jones架构，在0.5μ技术中要求100mm²的面积。即使使用3个晶体管的数字延迟线技术来实现存储器，也需要1M多个晶体管。根据文献“A New Approach to Pipeline FFT Processor(流水线FFT处理器的新的实现方法)”，Shousheng He and Mats Torkelson，TeracomSvensk RundRadio，DTTV-SA 180，TM 1547的报告，采用可替换架构可将其进一步减少到0.6M。该文献提出面向硬件的基2²算法，具有基4的乘法复杂度。然而本发明中的FFT计算要求实现基2²+2 FFT处理器。

参照图25和图26，该图示出由著名的Torkelson的文献可知的蝶形结构BF21 260和BF211 262。蝶形结构BF211 262与蝶形结构BF21 260的不同之处在于，蝶形结构BF211 262具有逻辑264并且具有跨接266，用于交叉实部和虚部输入以方便乘以-j的乘法。

图27示出本发明的基2²+2 FFT处理器268的再定时的架构，它是全流水线式，包括多级，即级0 270至级6 272。除了级0 270，每个级包括一个蝶形结构BF21 260和一个蝶形结构BF211 262、以及与其结合的存储RAM 274、276。级0 270只具有单个蝶形结构BF21 260。该架构进行简单的32点FFT。级6 272具有与其结合的控制逻辑，包括分用器(demultiplexer)278和复用器280，使得级6 272可以被旁路，从而提供FFT的2K实现。计数器282配置蝶形结构BF21 260和BF211 262以选择两个可能的对角计算中的一个，在此期间，数据同时写入存储器RAM274、276和从存储器RAM 274、276读出。

图28示出使用基2²+2流水线架构的FFT处理器268的32点流图。使用8个4点FFT和4个8点FFT来进行计算。进而将它们分解为2个4点FFT和4个2点FFT。

图29示出可配置的2K/8K基22+2单路径延迟反馈流水线式FFT处理器284的再定时的架构，其中与图27类似的元件标有相同的标号。各级具有多个流水线寄存器286，这是在各级中对蝶形结构BF21 260和BF211 262进行适当定时所需的。可以看出，每加入一个流水线级，会将FFT的范围乘以因子4。有6个复数乘法器288、290、292、294、296、298并行操作。该处理器每4个快速时钟周期计算一对I/Q数据点，该4个快速时钟周期等价于样本速率时钟。使用0.35μm技术，吞吐量的最坏情况是2K模式操作为140μs，8K模式为550μs，超过ETS 300 744电信标准的要求。数据从图29的左侧进入流水线，并且出现在右侧。中间存储要求对I数据是2K/8K，对Q数据是2K/8K，这依赖于模式。在实际中，基4级被实现为两个修改的基2级的级联，该修改的基2级采用基4算法以减少所需的复数乘法器的数目。

图30是乘法器288、290、292、294、296、298的一个实施例的示意图，这些乘法器进行乘法C＝A×B，其中A是数据，而B是系数。因为FFT处理器284具有6个复数乘法器，每个乘法器要求3个硬件乘法器300，所以总共要求18个硬件乘法器300。最好使用图31的实施例，其中有些硬件乘法器300由乘法器302、304取代。

再回到图29，图中有多个RAM 306、308、310、312、314、316，它们最好实现为ROM，并且包含查找表，该查找表包含分别用于乘法器288、290、292、294、296、298的余弦值的复数系数。已经发现，通过根据特定的寻址方案寻址RAM 306、308、310、312、314、316，可显著减少这些RAM的长度。从级3318开始在寻址电路的复杂度和RAM长度的减少之间进行折衷是有利的。再参照图28，图中有两个列320、322。列320保持值W²-W¹⁴，接着是W¹-W⁷，然后是W³-W²¹。根据特定乘法器290的要求，这些系数被存储到RAM 308中。列322包含值W⁸、W⁴、W¹²，它们重复3次。请再注意，在值W⁸、W⁴和W⁴、W¹²之间有连接324、326连接到前面的位于列328中的蝶形单元。在实际中，连接324、326被实现为乘以W⁰的乘法。在图29中，向左从一个乘法器移动到另一个乘法器时，查找表空间以每级乘以4的幂的幅度增加。在图32的表330中，乘法器M³的查找表包含512项。它可以通过外差来导出，这使得乘法器M⁵必须包含8192个旋转因子，对应于FFT处理器284(图29)进行FFT的长度。

在更详细地讨论查找表空间之前，考虑多个水平线332是有帮助的。从图28的顶部下移，起始于x(3)的线延伸到W⁸，W⁸是所需的第一个旋转因子，位于流图中的第三有效步骤。图33和32示出每个乘法器的旋转因子的组织，其中术语M_k表示与第k级结合的乘法器。这样，表334与乘法器M₀有关。W值(旋转因子)的标记法示于方格336中。右下端的下标“B”表示时戳，它是要求旋转因子的顺序关系(order dependency)。上标“A”表示旋转因子在其查找表中的地址。上标“N”是旋转因子的索引。

这样，在表334中，可以看出，在时间0时要求W⁰，在时间1时要求W¹，而在时间2时又要求W⁰。从图33、32的其他表中可进一步看出，每个表中一半的项是冗余的。通过消除冗余项，可将查找表的存储要求减少50％。这是通过以索引的升序组织W值来实现的，使得值可以以升序存储到存储器中。这样，在表338的情况下，索引值的范围为0至21，在11、13、16、17、19、和20处有间隙。

组织查找表的过程、和存取旋转因子的寻址方案是参照表338来解释的，但是也适用于图33(1)中的其他表。(1)如图所示，每行被附以一个行号。(2)每个旋转因子被附以一个顺序关系，注在表338中的其相应单元的右下端。(3)假设缩减的表338只包含独特的旋转因子，该旋转因子在存储器地址空间中以索引的升序排列。从而，每个旋转因子被附以一个存储器地址，如其相应单元的左上端所示。

在地址产生的过程中，对于表338的行3，地址只是保持在0。对于行1，地址在该行的结尾增加1。然而行0和2包含非无效(non-trivial)地址序列。请看表340，对于包含64个值的行0，可以观察到，地址序列根据间隔2、2、2、2变化，后来又以间隔1、1、2、1、1、2...变化。对于行2，地址首先增加3，然后增加2，最后增加1。地址增量变化的位置在这里被称为“断点”。这些断点值的范围为0和行的最后位置之间，其中0对应于行2的第一个点。

可以看出，第一个断点的出现因表而异，符合下面的递推关系： ${B1}_{M_N}={4B1}_{M_{N-1}}---\left(28\right)$ 其初始条件是： ${B1}_{M_0}=1---\left(29\right)$ 其中M_N是FFT处理器284的第N级的乘法器。将该递推关系展开得： ${B1}_{M_N}=((({4B1}_{M_0}-1)\&times;4-1)\&times;4-1)...---\left(30\right)$ ${B1}_{M_N}=4^N{B1}_{M_0}-4^{N-3}-4^{N-2}...-4^0---\left(31\right)$ ${B1}_{M_N}=4^N{B1}_{M_N}-\underset{n=0}{\overset{N-1}{\mathrm{\&Sigma;}}}{4}^n---\left(32\right)$ 类似地，行2的第二个断点B2由下面的递推关系确定： ${B2}_{M_N}={4B2}_{M_{N-1}}+1---\left(33\right)$ 其初始条件是： ${B2}_{M_0}=1---\left(34\right)$ 或 ${B2}_{M_N}=(((4B{2}_{M_0}+1)\&times;4-1)\&times;4-1)...---\left(35\right)$ ${B2}_{M_N}=\underset{n=0}{\overset{N-1}{\mathrm{\&Sigma;}}}{4}^n---\left(36\right)$

在行0的断点B3处序列的增量样式从2、2、2、2、变化为1、1、2、1、1、2...，通过查看表338、340、和330可以定位行0的断点B3。在表338中，断点B3在行中出现得很晚，使得第二个序列只出现前两个元素。通过检查更大的标注的表中的地址位置，可以导出，断点B3的位置与特定表中的项号有关，符合下式的关系： $B3=\frac{K}{4}+2---\left(37\right)$ 其中K是表中的项号。在图29的表中，K＝8，32，128，2048，8192。因此，对第N个复数乘法器来说，断点B3可以表示为： ${B3}_{M_N}=2\&times;4^N+2---\left(38\right)$ 其中N≥0。

地址发生器342、344、346、348用于RAM 310、312、314、316中的查找表。采用更小的表308、306能节省的硅面积太小了，使得不值得采用此方案。

图34示意性地示出用于上述地址产生方案的地址发生器342，专用于表340和乘法器M₂。在线in Addr 350上接受128个可能的输入状态，而复用器352选择两个最高有效位以解码4个值中的一个。复用器352的输出与输入状态的行号有关。实际上，该输出是可用于输入状态的行号的地址增量，并且用于控制计数器354，计数器354的增量地址根据线356上的值而改变。这样，表340的行3的增量被提供给线358上的复用器352，并且具有值零，如上所述。类似地，表340的行1的增量被提供给复用器352，并且具有值1。

行0和行2的状况更为复杂。对于行0，解码逻辑362的输出由复用器364提供，并且具有增量值2或复用器366的输出。后者可以是1或2，取决于2位计数器368的状态，计数器368反馈值0或1作为信号计数370。

解码逻辑372解码表340的行2的状态。当前输入状态与行2的两个断点的关系由比较器374、376进行测试。断点实际上被设置得比比较器输出超前一个样本，以便进行再定时。比较器374、376的输出分别是复用器378、380的选择子。

保持在累加器382中的当前地址由加法器384加上复用器352的输出。简单的逻辑电路386通过在表340的每行完成时断言信号rst 390，来复位包含在寄存器ACC 388中的输出地址。这保证了在下一行的开头，地址指向旋转因子W⁰。新地址被输出到6位总线out Address 392上，它比输入in Addr 350小一位。

图35是地址发生器342(图34)的泛化，其中输入地址具有B位的路径。与图34和35类似的元件被附以相同的标号。地址发生器394的结构类似于地址发生器342的结构，除了现在输入in_addr 396和输出out_addr[B-2：0]398的各线被标上B项。这样，图35中的复用器(MUX)352由输入in_addr[B-1：B-2]400来选择。类似地，比较器(COMP)374和比较器376的输入中的一个是in_addr[B-3：0]402。Out_addr[B-2：0]398形成输出。该结构的优点是将查找表RAM的长度减少了50％。

FFT计算电路168(图14)公开于Verilog代码列表1-17。地址发生器394的Verilog代码是通用的，可以实现任何4的幂的表。信道估计和校正

示于信道估计和校正模块170(图14)中的信道估计和校正电路的功能是根据接收到的ETS 300 744电信标准规定的连续和散射导频值来估计信道的频率响应，并且产生补偿系数，用于校正信道影响，从而重构发送的频谱。信道估计和校正模块170的更详细的方框图示于图16。

在采集模式中，信道估计和校正模块170需要在进行任何信道估计之前定位导频。该电路对2048个载波进行卷积，以定位散射导频的位置，该位置总是均匀间隔的，相隔12个载波。在找出散射导频之后，可以定位连续导频；一旦完成这之后，就知道FFT计算电路168(图14)的2048个输出中的1705个有效载波(active carriers)。然后可以初始化该模块中的定时发生器404，于是定时发生器产生参考定时脉冲，以定位导频，用于信道估计计算和用于解调器的其他功能。

信道估计是通过使用均匀间隔的散射导频、然后在它们之间进行内插以产生信道的频率响应来进行的。接收到的载波(导频和数据)被复数除以内插过的信道响应以产生校正过的频谱。完整的符号被保持在缓冲器406中。这可以校正从FFT计算电路168接收到的数据的码位倒置顺序。应该注意，频率和采样速率误差电路要求原始的、未校正过的数据。

在频域中将从FFT计算电路168(图14)接收到的数据同步到OFDM符号的任务以散射和连续导频的本地化开始，该本地化在导频定位模块408中进行。根据ETS 300 744电信标准，散射导频每隔12个数据样本出现，相对于每个连续帧中的帧的开头偏移3个样本。因为导频载波的功率是任何数据载波的最大功率的4/3倍，使用以12个间隔分开的多组载波来进行一系列相关。12个可能的组中的一个与增强的导频载波功率高度相关。

现在参照图36和16来说明导频搜索过程的第一实施例。应该注意，散射导频搜索过程是飞速进行的，只需进行下述的下一步的连续导频定位所需的存储量。在步骤410，在断言信号resync 204之后，信号pilot_lock 412被设置为低，该断言通常发生在信道变化或上电之后。然后，在步骤414，处理等待线416上来自FFT计算电路168(图14)的、表示第一个符号开始的第一个符号脉冲。第一个符号脉冲被接收和存储。在导频搜索过程的一个实施例中，0至2047的每个点被依次读取，在12个累加器(未示出)中的一个中累加每个值(|I|+|Q|)。这些累加器以12为周期被依次选择，从而卷积可能的散射导频位置。两个熟知的峰值跟踪器指示具有最高值(Peak1)的累加器和具有次最高值(Peak2)的累加器。具有最高值的累加器对应于散射导频定向。跟踪次最高值是为了能够将最高峰值和次最高峰值之差用作“质量”量度。在决策步骤418，如果两个峰值相隔不够远，则在决策步骤420测试全程扫频是否完成。如果测试失败，则在步骤422报告散射导频搜索的失败。否则，在步骤424，通过递增控制信号freq_sweep 426的量值，将IQ解调器LO频率增加+1/8个载波间隔。然后，在步骤428延迟3个符号之后重复散射导频的搜索，以便使变化影响有时间传播到FFT计算电路168和各缓冲器。峰值差值门限可以由控制微处理器经微处理器接口142和模块430来改变。

在第一实施例的一个变形中，只有单个峰值跟踪器，它指示具有最高值的累加器，该最高值对应于散射导频定向。这样找出的真正的散射导频定向是12个可能的定向中的一个。

如果决策步骤418的测试成功，则在步骤432通过根据下式从存储FFT数据的RAM中的0位置建立初始导频偏移，来开始连续导频的搜索：

pilot offset＝(accumulator#mod 3)                    (39)这样，如果散射导频峰值在累加器0、3、6或9中，则导频偏移为0。如果散射导频峰值在累加器1、4、7或10中，则导频偏移为1，等等。然后读取连续导频的期望的45个载波位置，将导频偏移值加到该地址上，并且累加(|I|+|Q|)值。重复该过程，直至搜索完前115个连续导频开始位置。根据ETS 300 744电信标准，落在载波0和载波2047之间的连续块中的有效载波中的可能的前些个载波位置可以简单地计算为(2048-1705)/3≈115，如下所述。这样，就保证了有效区间始于前(2048-1705)个载波位置。对应于存储的峰值的载波是符号中的第一有效载波。

在完成连续导频搜索之后，在步骤434，定时发生器404被复位，以同步到第一有效载波和散射导频相位。然后，在步骤436将信号pilot_lock412设置到高，指示这些导频已被成功定位，然后在步骤436，定时发生器404被复位，以同步到第一有效载波和散射导频相位。

在跟踪模式操作中，如步骤438所示，周期性地重复散射导频搜索，并且在决策步骤440中对其进行评价。这可以逐个符号进行，或者不太频繁地进行，而这取决于传播条件。散射导频相关峰值的预测移动由定时发生器404中的合适的定时来反映，并且可以被用作定时已经保持同步的测试。在步骤442报告决策步骤440的测试失败，并且将信号pilot_lock 412设置为低。

下面参照图16和37说明导频搜索过程的第二实施例。在步骤444断言信号resync 204，这通常在信道变化或上电时发生，将信号pilot_lock 412设置为低。然后，在步骤446，接受符号以用于评价。在步骤448进行散射导频的搜索，它是根据上述任何一个过程进行的。然后，在步骤450如上所述地进行连续导频的搜索。在决策步骤452，确定是否已经处理了两个符号。如果测试失败，则控制返回步骤446，并且处理另一个符号。如果在步骤454测试成功，则进行另一个测试，以便使两个符号中的散射和连续导频的位置一致。如果在步骤454测试失败，则以与前面参照图36所述的方式相同的方式，进行始于决策步骤420的过程。如果步骤454的测试成功，则在步骤456，定时发生器404被复位，以同步到第一有效载波和散射导频相位。然后，在步骤458将信号pilott_lock412设置为高，指示导频已经被成功定位。

在跟踪模式操作中，如步骤460所示，周期性地重复散射导频搜索，并且在决策步骤462对其进行评价。这可以在每个操作周期进行，或不太频繁地进行，这取决于传播条件。散射导频相关峰值的预测移动由定时发生器404中的合适的定时反映，并且可以被用作定时已经保持同步的测试。在步骤464报告决策步骤462的测试失败，并且将信号pilot_llock 412设置为低。

应该理解，在散射导频被定位以后，定位连续导频的任务被大大简化。在连续导频被插入到已知的位置序列以后，相对于帧的开头，将第一个连续导频偏移3个位置的倍数，如ETS 300 744电信标准规定的那样。因此可以立即排除数据空间中的3个可能的位置中的2个，只需搜索第三组。从而重复连续导频搜索，每次重复始于比上次重复高3个载波的位置。如果新的累加值和当前开始位置大于前一累加值，则存储新的累加值和当前开始位置。重复此操作，直至搜索到连续导频开始位置。存储的对应于最大峰值的载波将是符号中的第一有效载波。不必评价连续导频相关峰值的“质量”。散射导频搜索表示142个样本的相关，比45个连续导频搜索具有更高的抗干扰度。如果散射导频搜索完全成功，则连续导频搜索几乎肯定会成功。

上述序列在1/4个符号周期内定位散射导频位置，假设以40MHz进行累加，并且在小于1个符号周期(假设以40MHz操作则为45×115个时钟周期)内定位连续导频。

I和Q数据被FFT检索电路168(图14)以比特翻转顺序在线416上提供给导频定位模块408。这使得在导频本地化期间计算相关时使用最少量RAM的问题复杂化。从而输入地址被比特翻转，并且被进行模12计算，以便决定12个可能的箱(bins)中的哪个用于存储数据。为了避免逼近载波幅度所需的平方根函数，转而将数据的绝对值求和以作为实际的逼近。“飞速”确定散射导频。在定位过散射导频的各帧之后的各帧中定位连续导频。

下面更详细地说明定时发生器404的操作。RAM缓冲器406的寻址序列由来自FFT计算电路168(图14)的符号脉冲同步。一旦在FFT窗口采集之后接收到第一符号，则连续运行FFT计算处理。对连续符号寻址在比特翻转和线性寻址之间交替。定时发生器404也产生所有的读写定时脉冲。

信号u_symbol 466和c_symbol 468是表示新的未校正过的符号或校正过的符号的开头的定时脉冲。信号u_symbol 466由内插滤波器470和复数乘法器472的等待时间(latency)进行延迟，它同步到RAM地址序列定时。

对于载波定时，信号c_carrier0 474、导频定时信号us_pilot(+)476、uc_pilot(+)478、c_tps_pilot(^*)480和odd_symbol脉冲482都参照共同的开始脉冲序列。基定时计数器(未示出)由导频定位同步定时脉冲484同步，从而偏移符号定时。导频定时输出也被同步到缓冲器406输出的未校正的符号、或内插滤波器470和复数乘法器472延迟输出的校正过的符号。在断言信号resync 204时，所有定时输出被设置到无效(inactive)状态，直至接收到第一符号。令载波k上发送的导频为P_k，而接收到的导频为P′_k，

P_k ^′＝H_k·W_k·P_k                                    (40)其中P_k如下所述，并且

P_k ^′＝I_k+jQ_k                                         (41)其中k标引导频载波，H_k是信道响应，而w_k是参考序列。内插H_k以便为接收到的数据载波产生补偿值D′_k：

D_k′＝I_k+jQ_k                                          (42) $D_k=\frac{D_k^{\&prime;}}{H_k}---\left(43\right)$ 其中k标引数据载波。接收到的导频可以使用本地产生的参考序列被解调，然后被传递给内插滤波器。

内插滤波器470在本实施例中用6个抽头和12个系数实现，内插滤波器470用于估计散射导频之间的信道部分。如上所述，导频以相对于数据载波的已知功率电平被发送，并且根据ETS 300 744电信标准用已知参考序列进行调制。发送的导频载波幅度是标称数据载波功率的±4/3(+4/3用于参考比特1，-4/3用于参考比特0；在两种情况下正交分量都＝0)。从同步到数据可用性的定时发生器404中的0-11周期计数中选择内插系数。合适的校正因子可以被选择用于数据点，以提供飞速校正。系数因散射导频相位而异。由于参考导频的位置不同，因此用于补偿给定数据载波的系数也不同。

输入和输出信号、和与信道估计和校正模块170的微处理器接口142有关的信号分别描述于表18、19和20。信道估计和校正模块170的电路描述于Verilog代码列表18和19。TPS序列提取

尽管tps序列提取模块172(图14)作为分离模块以便于说明，它实际上部分包括在信道估计和校正模块170中。它恢复68个符号的OFDM帧中携带的68比特TPS数据，更详细地示于图38。每个比特在COFDM符号中的17个差分二进制相移键控(differential binary phase shift keyed，DBPSK)已调载波、tps导频中被重复，以提供高鲁棒的传输信道。68比特tps序列包括用BCH码产生的14个奇偶校验比特，这在ETS 300 744电信标准中有规定。当然，本领域的技术人员可以对其进行适当的修改以用于具有不同的BCH编码的其他标准，并且用于2K模式以外的模式。

限幅器486将输入校正过的频谱数据限幅到±1。可以任选地评价符号比特，以获得限幅的结果。在比较模块488中，限幅过的接收到的tps导频符号与参考序列输入进行比较。在所述实施例中，参考序列中的0值与导频中的-1匹配，而参考序列中的1值与导频中的+1匹配。多数表决比较用于提供整个+1或-1结果。+1结果说明采用了与参考序列相同的调制，而-1结果说明采用了相反的调制。

DBPSK解调器490将+/-1序列从多数表决形式转换为二进制形式。如果当前和前一符号相同，则序列转换为0值，而如果连续符号之间的调制相反，则序列转换为1值。

从未初始化的状况开始，在帧同步器模块492中，在68比特tps序列(4x68比特＝1个超帧)中搜索两个同步字中的一个。超帧中的同步字如下所示：

0011010111101110    帧1和3的同步字

1100101000010001    帧2和4的同步字在获得一个同步字之后，在下一个OFDM帧的适当位置搜索另一个同步字。在找到第二个同步字之后，通过提升信号tps_sync 494来宣布同步。然后将数据传递到BCH解码器496，它用OFDM帧结尾的14个奇偶校验比特来校验帧中的接收到的数据。必要时进行纠错。

解码过的数据被提供给输出存储模块498，它存储在整个OFDM帧中找到的tps数据。输出存储模块498只在OFDM帧结尾处被更新。只能得到有关的30比特。目前，这些比特中的某些比特被保留，以供将来使用。不保持长度指示符。

BCH解码器496的实现方式不必进行BCH解码中传统的Berlekamp算法和Chien搜索。BCH解码器496中所用的Galois域乘法器是我们的同时待审的美国申请No.08/801,544中描述的Galois域乘法器的改进。

保护tps序列的特定BCH码在ETS 300 744电信标准中规定为BCH(67，53，t＝2)，具有代码生成多项式

h(x)＝x¹⁴+x⁹+x⁸+x⁶+x⁵+x⁴+x²+x+1               (44)或者等价地

h(x)＝(x⁷+x³+x¹)(x⁷+x³+x²+x+1)                 (45)左边的因子用于产生检错所需的Galois域。参照图39，这是在校正子(syndrome)计算模块500中进行计算的，校正子计算模块500可以使用传统的反馈移位寄存器来实现，以产生各α值。然后，通过将接收到的信号R(x)除以α¹、α²、和α³，并且再次使用传统的反馈移位寄存器实现，来计算前3个校正子，这在BCH解码的技术领域是熟知的。可知该校正子为： $S_0={\left({\mathrm{\&alpha;}}^1\right)}^{e_0}+{\left({\mathrm{\&alpha;}}^1\right)}^{e_1}---\left(46\right)$ $S_1={\left({\mathrm{\&alpha;}}^2\right)}^{e_0}+{\left({\mathrm{\&alpha;}}^2\right)}^{e_1}---\left(47\right)$ $S_2={\left({\mathrm{\&alpha;}}^3\right)}^{e_0}+{\left({\mathrm{\&alpha;}}^3\right)}^{e_1}---\left(48\right)$

在校正子计算的过程中，该校正子被存储到存储寄存器R[2：0]502中。

当S₀是0时，则可以立即得出结论：在当前tps序列中没有差错，并且在检错模块506上所设的线504上断言一个信号，根据检错模块506在线508上的输出，接收到的信号R(x)的数据或者未加改变、或者翻转后输出。如下所述，如果

S₁⊙S₀＝S₂                                        (49)则正好存在一个差错，这种状况在线510上被通知给检错模块506。否则，认为存在两个差错。在本实现中，不能检测多于两个的差错。

为了解上述3个非线性方程组，用指示帧结尾的信号EOF 514来允许从寄存器R[2：0]502到搜索模块512的数据流。在反馈环中具有用于α¹-α³的相应的Galois域乘法器522、524、526的3个反馈移位寄存器516、518、520被初始化为50H、20H、和3dH(其中，符号“H”表示十六进制数)。每当有新的数据比特时，反馈移位寄存器516、518、520受时钟驱动。校正子和反馈移位寄存器516、518、520的输出作为时钟输入到搜索模块，该搜索模块使用迭代搜索技术来搜索差错位置，下面将对此进行说明。在Galois域乘法器中将反馈移位寄存器516、518的输出相乘。

考虑一个差错的情况，最好使用XOR门网络530，将S₀通过模2加法加到第一反馈移位寄存器516的输出上。如果关系式 $(S_0+{\mathrm{\&alpha;}}_{{\mathrm{gen}}_0})=0---\left(50\right)$ 成立，则得出结论：在当前数据比特中没有差错。当前从帧存储器中输出的比特被翻转。中止该搜索，并且从帧存储器中输出该数据。

考虑两个差错的情况，如果下述关系式成立，则在帧存储器输出的当前比特中存在差错：

现在需要将上式计算的3项存储到寄存器R[2：0]502中，该寄存器先前存储着校正子S₀-S₂。这由线532表示。

继续该处理，现在寻找第二个差错，并且重用寄存器R[2：0]502中的数据，该寄存器现在保存着由上次迭代调整过的校正子。该调整过的校正子被标为S₀′-S₂′。 $S_0^{\&prime;}=(S_0+{\mathrm{\&alpha;}}_{{\mathrm{gen}}_0})$ ；等                                                     (52)现在，如果 $(S_0^{\&prime;}+{\mathrm{\&alpha;}}_{{\mathrm{gen}}_0})=0---\left(53\right)$ 则找到第二个差错，并且当前从帧存储器输出的比特由XOR门534进行翻转。如果该搜索失败，则可能存在多于两个的差错，并且设置出错信号(未示出)。

Galois域乘法器528是时钟驱动的数字电路，在图40中描述。相对于多载波数字接收机126中的其他处理，tps数据被非常缓慢地接收。因此有可能缓慢地执行迭代搜索，并且Galois域乘法器设计成尽量减少空间使用。它们不需要α发生器，但是依赖于小的常数系数乘法器，具有迭代反馈，以产生所需的α值。这种结构利用了Galois域计算的关系式

αⁿ＝α¹·α^n-1                                   (54)在由选择乘法器538、540的信号init 536初始化之后，被乘数A 542被累加在寄存器544中，并且重复地在乘法器546中乘以值α¹。线548上的输出被重复地和移位寄存器550中保持的被乘数B按比特进行逻辑“与”。移位寄存器的输出在一比特线552上被提供给门554。使用加法器558将门554的输出累加在寄存器556中。

输入和输出信号以及与tps序列提取模块172有关的信号描述于表21、22、和23中。tps序列提取模块电路172和BCH解码器496描述于Verilog代码列表20和21中。自动精细频率控制和自动采样速率控制

正交频分复用(OFDM)的信号的传输链中的非理想的振荡器影响OFDM符号中的所有载波。由于有噪声的本地振荡器，这些OFDM载波具有相同的相位和频率扰动。本地振荡器的频率变化导致相位漂移，从而导致DFDM符号中正交性的丧失。因此，在接收机中要求合格的自动频率控制，以跟踪相对于发送机的频率偏移，以便尽量减少这些相位漂移，从而保持正交性。

OFDM中的所有载波都同样受相位漂移的影响。这类似于相位噪声造成的共同相位误差。所有载波中的共同相位误差用于产生自动频率控制(AFC)信号，它完全在数字域，因为I/Q解调在数字域中进行。采用的方法是对每个OFDM符号计算共同相位误差。这是通过使用参考导频来实现的。在一段时间中测量共同相位误差中的变化，以检测频率偏移，并且该变化用于导出AFC控制信号。下面描述的AFC控制环和自动采样速率控制环的通用方法示于图41。

当接收机的主时钟与发送机的主时钟没有对齐时，要求自动采样速率控制。未对齐造成两个问题：(1)解调载波具有不正确的间隔；以及(2)FFT计算的间隔也是错误的。

该定时误差的影响会对解调过的OFDM数据引入相位斜率(phaseslope)。该相位斜率与定时误差成比例。该相位斜率可以通过使用参考导频计算连续OFDM符号之间的相位差、并且估计这些相位差的斜率来确定。最小二乘法用于直线拟合。ASC信号被低通滤波，并且反馈到sinc内插器(图13)。

连续OFDM符号中的参考导频之间的平均相位差用于计算频率偏差。假设本地振荡器的频率偏差是恒定的，则相位以α旋转，其中α＝2∏f_dmT_t弧度。这里f_d是频率偏差，m是相同导频位置重复之间的符号数，而T_t是包括有效区间和保护区间之和的时段。通过对α进行低通滤波，来在时间上产生AFC信号。然后，频率偏差的值用于控制IQ解调器144(图13)。

只有当线154(图13)上的信号IQGI的断言指示经过保护区间时，AFC和ASC控制信号才有效。这防止了符号在两种不同的条件下被处理。

校正电路174(图14)更详细地示于图42。线560上输出的频率误差值是通过确定当前符号和前一符号之间相应导频的相位值之差的平均来计算的。结果产生的频率误差值在被反馈到IQ解调器144(图13)之前，在低通滤波器562中被滤波。任选地，还评价连续导频，以便对付更大的频率误差。线564上输出的采样速率误差是通过观察符号中的导频和前一符号中的相同导频之间的相位差来确定的。该差值随符号变化，给出多个点，通过这些点可以使用已知的最小二乘回归法来拟合一条直线。该直线的斜率指示采样速率误差的量值和方向。这样导出的采样速率误差在被反馈到sinc内插器158(图13)之前，在低通滤波器566中被滤波。

用于包含在4个符号中的散射导频的分离存储器568由频率误差部570和采样速率误差部572共享。从而方便了散射导频符号的直接比较，因为散射导频相位每4个符号重复一次。在可替换实施例中，散射导频用于提供控制信息，必须对4个符号提供存储。在优选实施例中，控制信息是从连续导频中导出的，只需要对1个符号进行存储。

从I和Q数据中恢复旋转角α是在相位提取模块574中进行的，其中

α＝tan^-1(Q/I)                                      (55)在当前的优选实施例中，以14比特的分辨率进行计算。相位提取模块574更详细地示于图43。首先在模块576中确定α的象限。I和Q具有零量值或I＝Q的特例由线578上的信号断言来解决。如果Q的量值超过I的量值，则在模块580中使用控制信号582进行商倒置。在除法模块584中进行正整数除法。尽管该操作需要11个时钟周期，分配给相位提取以满足该操作的时间绰绰有余。商的反正切计算通过在模块586中对下述泰勒级数进行流水线式、截尾迭代计算来实现： ${\tan }^{-1}\left(x\right)=x-\frac{x^3}{3}+\frac{x^5}{5}-\frac{x^7}{7}+\frac{x^9}{9}-...,\left|x\right|<1---\left(56\right)$ 模块586更详细地示于图44的电路图。在模块588中计算值x²一次，并且存储以供下次迭代使用。然后使用反馈线590和乘法器592来迭代计算x的幂。使用常数乘法器594来计算除法，在乘法器594中，系数是硬连线的。使用加法器/减法器596来累加总和。整个计算需要47-48个40 MHz的时钟周期。

再参照图43，象限映射和特例的输出在模块576的控制下在模块598中进行。可以看到，泰勒展开的结果的平方误差随着α接近45度而迅速增加，如图45和图46所示，该图是分别泰勒展开到32和31项的在α的不同值上的平方误差的曲线图。对31项和32项的泰勒展开进行平均，则可显著降低该平方误差，如图47所示。用于保持平均计算的中间值的存储器(未示出)设置在模块598中。

所有散射导频中的恒定相位误差是由于IQ解调器中的频率偏移造成的。频率误差可以定义为 $f_{\mathrm{err}}=\frac{\mathrm{\&alpha;}}{2\mathrm{\&Pi;m}{T}_i}---\left(57\right)$ 其中α、m和T_t具有与上面相同的含义。α是通过对当前符号、和延迟m个符号周期的符号之间相应的导频的相位值之差进行平均来确定的。在上式中，在连续导频的情况下，m＝1。该计算使用累加模块600，累加模块600对当前符号减去4个符号前的符号的总和进行累加。计算模块602具有x乘数，其中x可为1至最少142(在ETS 300 744电信标准的2K模式中)。低通滤波器562、566可以被实现为具有10-20个抽头的移动平均滤波器。可从累加模块602获得的数据是每隔m个符号采样的导频相位的累加总和。频率误差可以由下式来计算： $f_{\mathrm{err}}=\frac{\mathrm{Acc}\{\mathrm{new}-\mathrm{old}\}}{\left(N\right)\left(2\right)\mathrm{\&Pi;m}{T}_i}---\left(58\right)$

假设采用ETS 300 744电信标准的2K模式操作，则在散射导频的情况下，N＝142，而在连续导频的情况下，N＝45。用于确定采样速率误差的技术示于图48，其中与载波的频率相对应，画出导频载波的相位差，该相位差是根据每隔4个符号(S_n-S_n-4)的差值来计算的。线604指示最佳拟合线。0斜率指示没有采样速率误差。

在从导频定位模块408(图14)接收到控制信号606之后，由模块608启动频率扫描，模块608使用加法器610向低通滤波过的频率误差输出插入一个偏移量。类似地，由模块612启动频率扫描，模块612使用加法器614向低通滤波过的采样速率误差输出插入一个偏移量。频率扫描是线性的，其增量为1/8个载波间隔步长，从0-3.5 kHz，对应于控制信号值0×0-0×7。

校正电路174(图14)的优选实施例更详细地示于图49。连续导频、而不是散射导频被以14比特分辨率保持在存储器616中。产生乘数x以用于累加模块618中的计算更复杂，因为根据上述ETS 300 744电信标准，连续导频不是像散射导频那样均匀间隔。然而，现在只需评价45个连续导频(在ETS 300 744电信标准的2K模式中)。在本实施例中，只需将一个符号的连续导频存储到存储器616中。计算符号T_t的整个持续时间需要包括保护区间长度，在线620上从FFT窗口电路(模块166，图14)接收该长度。

输入和输出信号以及与图42所示的电路的微处理器接口142分别描述于表24、25、26和表27中。该电路还描述于Verilog代码列表24-35。解映射器(Demapper)

为清楚起见，解映射电路176(图15)被表示为分离模块，但是实际上它被集成到信道估计和校正电路中。它将12比特分辨率的I和Q数据转换为解映射过的12比特编码星座格式(3比特I、I软比特、3比特Q、Q软比特)。编码星座示于图50和图51。对于64-QAM，该3比特用于I和Q值，16-QAM为2比特，而QPSK为1比特。

例如，在图51中，值I＝6.2、Q＝3.7将被解映射到：I数据＝001；I软比特＝011；Q数据＝101；Q软比特＝101。

解映射电路176的输入和输出信号分别描述于表28和29。符号解交织器

符号解交织器182(图15)进行与发送信号的符号交织处理相反的处理。如图52所示，解交织器要求1512×13存储器，如模块622所示。地址发生器624产生地址。用于以线性序列写入交织过的数据和读出数据。在实际中，地址发生器624被实现为读地址发生器和分离的写地址发生器。读和写以不同的瞬时速率发生，以便减少数据流的突发性。对于每个新的COFDM符号，通过符号定时脉冲626来重新同步地址发生器624。标引为0的载波由carrier0脉冲628标注。这些地址应该相对于存储该载波的地址来产生。

符号解交织器182的输入和输出信号分别描述于表30和31。符号解交织器182的电路描述于Verilog代码列表22。比特解交织器

参照图54，比特解交织器184(图15)进行与发送信号的按比特交织处理的相反的处理，并且更详细地示于图53。在软编码电路630中，将输入数据从编码星座格式重新格式化为24比特软I/Q格式。为清楚起见，软编码电路630是与比特解交织器184一起来描述的，但是它被实现为上述符号解交织器的一部分。解交织地址发生器632产生地址，以便根据ETS 300744电信标准从126×24存储器634中读取6个适当的软比特。对于每个新的COFDM符号，通过符号定时脉冲626来重新同步解交织地址发生器632。

输出接口636组合来自从存储器634读取的软比特的I和Q输出数据流。在每次解交织操作时，从存储器634提取3个I软比特和3个Q软比特，并且进行并行-串行转换，以便向Viterbi解码器186(图15)提供输入数据流。

比特解交织器184的输入和输出信号分别描述于表32和33。比特解交织器184的电路描述于Verilog代码列表23。主微处理器接口

微处理器接口142的功能是使主微处理器能够存取多载波数字接收机126(图12)中的控制和状态信息。微处理器接口142更详细地示于图55。提供串行接口638和并行接口640，后者主要用于测试和调试。串行接口638属于已知的类型，与12C兼容。微处理器接口142包括可屏蔽中断能力，使得接收机可以被配置，以根据内部条件请求处理器干预。应该指出，多载波数字接收机126在其正常操作的任意部分不依赖于微处理器接口142的干预。

下面描述从主处理器看到的中断的使用。术语“事件”用于描述用户可能想要观察的片内条件。一个事件可以指示出错条件，也可以向用户软件提供信息。有两个单比特寄存器(未示出)与每个中断或事件关联。它们是条件事件寄存器和条件屏蔽寄存器。

条件事件寄存器是一比特读/写寄存器，其值被电路中发生的条件设置为1。即使该条件只是瞬态存在，该寄存器也被设置为1。然后保证条件事件寄存器保持设置为1，直至用户软件对其进行复位，或整个芯片被复位。通过写入值1，将条件事件寄存器清除为0。将0写入到条件事件寄存器不会改变该寄存器。在观察该条件的另一次发生之前，必须将条件事件寄存器设置为0。

条件屏蔽寄存器是一比特读/写寄存器，如果对应的条件事件寄存器被置位，则它允许中断请求的产生。如果当1被写入到条件屏蔽寄存器时该条件事件已经被置位，则立即产生中断请求。值1允许中断。在芯片复位时条件屏蔽存储器清除到0。除非特别指出，否则在产生中断请求之后，模块将停止操作，并且在条件事件寄存器或条件屏蔽寄存器被清除之后立即重新启动。

在寄存器映射中，事件比特和屏蔽比特总是被组合到连续字节中相应的比特位置。这使得中断服务软件可以使用从屏蔽寄存器读取的值作为事件寄存器中值的屏蔽，以鉴别哪个事件产生了该中断。有单个全局事件比特来总结片内事件活动。芯片事件寄存器表示片内相应屏蔽比特为1的所有事件的逻辑“或”。芯片屏蔽比特中的值1允许芯片产生中断。芯片屏蔽比特中的值0防止任何片内事件产生中断请求。向芯片事件寄存器写入1或0没有效果。只有当由其相应的屏蔽比特中的1允许的所有事件已经被清除之后，芯片事件寄存器才被清除。

如果芯片事件比特和芯片事件屏蔽比特都被置位，则断言IRQ信号162。IRQ信号642为低有效，“集电极开路”输出要求片外上拉电阻。当有效时，IRQ输出被100Ω或更小的阻抗下拉。约4kΩ的上拉电阻是合适的。

微处理器接口142的输入和输出信号分别描述于表34和35。系统控制器

系统控制器198(图15)控制多载波数字接收机126(图12)的操作，特别是信道采集和出错条件处理，更详细地示于图56。

参照图57中的状态图，信道采集序列由4个超时(timeouts)来驱动。

(1)AGC采集超时。保留20ms(80个符号)以供AGC提高信号电平，如步骤644所示。然后，FFT窗口被允许，以启动模块646中的采集搜索。

(2)符号采集超时：分配200个符号周期、即最大保护区间加有效符号长度，以便在步骤648中采集FFT窗口。分配另35个符号周期，以便在步骤650进行导频定位。处理2K个OFDM符号需要大约50ms。一种选择是一旦定位到导频，则立即退出步骤650，以便在非极端情况下节省采集时间。

(3)控制环稳定超时：分配表示大约40个符号的另10ms，以便使得控制环在步骤652趋向稳定。一种选择是如果控制环稳定超时发生，如果导频已经丢失，则退出步骤652，并且返回到初始步骤resync(重新同步)654。

(4)Vieterbi同步超时：在模块656中分配大约150个符号周期，用于最坏情况的tps同步，这由步骤658指示，并且分配大约100个符号周期给Viterbi解码器186(图15)以同步到发送穿孔速率，如步骤660所示。这大约是65ms。在合理的条件下，无需等待如此长的时间。一旦建立Viterbi同步，则转移到system_lock状态662。有可能通过在接收机参数寄存器中设置参数(见下表)并将set_rx_parameters设置为1，来绕过tps同步要求。

如果采集在任何阶段失败，则处理自动返回到步骤resync 654以便重试。

在获得锁定之后，系统将保持在锁定状态，除非Reed-Solomon过载事件发生，即，在任1秒时段内，具有不可校正差错的Reed-Solomon分组的数目超过预定值(rso_limit值)。如果采集序列中的4个同步状态机中的任一个、FFT窗口(步骤648)、导频定位(步骤650)、tps同步(步骤658)和Viterbi同步(步骤660)在信道采集时丢失同步，则不采取行动，直至一个事件rso_event发生，并且步骤resync 654被自动触发。

在恶劣的信号条件下，采集可能很困难，尤其是Viterbi同步。因此，任选地在微处理器接口142(图12)中提供一个比特，当其被置位时，将超时扩展为4倍。

输入和输出信号、以及系统控制器198的微处理器接口寄存器分别描述于表36、37、38、和39。表

管脚名	I/O	说明
			调谐器/ADC接口
SCLK	O	ADC的样本时钟
			IDATA[9：0]	I	输入ADC数据总线(10比特)
AGC	O	对调谐器的自动增益控制(Sigma-Delta输出)
			XTC[2：0]	O	外部调谐器控制输出
MPEG-2传输接口
			OUTDAT[7：0]	O	MPEG-2传输流数据总线
OUTCLK	O	MPEG传输流输出时钟
			SYNC	O	MPEG传输流同步脉冲(每188字节1个)
VALID	O	MPEG传输流有效数据标志
			ERROR	O	MPEG传输流出错数据标志
串行主微处理器接口
			SD	I/O	串行接口数据
SC	I	串行接口时钟
			SDT	I/O	串行数据直通
SCT	O	串行时钟直通(当DEBUG为高时，40MHz时钟输出)
			SADDR[2：0]	I	串行地址输入(硬连线外部值)，当DEBUG为高时，用作TSEL管脚
并行主微处理器接口

管脚名	I/O	说明
			MA[5：0]	I	微处理器地址总线
MD[7：0]	I/O	微处理器数据总线2比特/DEBUG数据@40MHz时钟输出
			MWE	I	微处理器写允许
MCE	I	微处理器芯片允许
			NOTIRQ	O	中断请求
JTAG测试接入端口
			TCK	I	JTAG测试时钟
TMS	I	JTAG测试模式选择
			TDI	I	JTAG测试数据输入
TDO	O	JTAG测试数据输出
			NTRST	I	JTAGTAP控制器复位
杂项管脚
			NRESET	I	同步复位
CLK40	I	40MHz输入时钟
			TSTRI	I	传输流接口三态控制
TA(MA[6])	I	测试地址比特探测器(snooper)接入(上地址总线的比特7)
			DEBUG	I	测试管脚
TSEL[2：0]/SADDR[2：0]	I	内部测试输入(将内部数据多路选择到MD[7：0])0＝正常  upi.1＝fft输入数据(24比特)，2＝fft输出数据(24比特)，3＝信道校正输出数据(24比特)，4＝fec输入数据。(2×3比特软比特)所有数据按时钟输出@40MHz，4字节中的24比特数据。时钟在SCT管脚输出，以便方便。数据中由标记比特指示的符号定时/其他同步信号。
			TLOOP	I	测试输入

                           表4

地址(十六进制)	比特号	直接复位	寄存器名	说明
					0×00	事件寄存器
0	R/W/0	chip_event	中断允许(未屏蔽)的所有事件的“或”
				1		R/W/0	lock_failed_event	如果信道采集序列失败，则设置为1
2	R/W/0	rs_overload_event	如果Reed-Solomon解码器在1秒时段内超过设置门限，则设置为1
				0×01		屏蔽寄存器
0	R/W/0	chip_mask	设置到1，以允许IPQ输出
					1	R/W/0	lock_failed_mask	设置到1，以允许信道采集失败时的中断
2	R/W/0	rs_overload_mask	设置到1，以允许超过RS误差门限时的中断
					0×02	状态寄存器
0	R/0	system_locked	当系统成功采集信道时，设置到1
				1		R/0	vitebi_sync	当Viterbi被同步时，设置到1
2	R/0	tps_sync	当携带TPS数据的OFDM帧已经同步时，设置到1
				3		R/0	pilot_loc	当COFDM符号中的导频已经被定位到并同步时，设置到1
4	R/0	fft_loc	当保护区间已经被定位到并同步时，设置到1
				7：5		R/1	viterbi_rate	接收到的Viterbi码率
0×04-0×05	控制寄存器
					0	R/W/0	change_channel	当设置到1时，将器件保持在“复位”状态。清除此比特将启动信道变化

地址(十六进制)	比特号	直接复位	寄存器名	说明
						1	R/W/0	agc_invert	翻转AGC Sigma-Delta输出。缺省设置意味着与降低的AGC增益关联的低输出。
2	R/W/0	o_clk_phase	设置到1，以翻转输出时钟的相位。缺省条件：输出数据在输出时钟的下降沿改变
				3		R/W/0	set_rx_parameters	设置到1，以便从接收机参数寄存器获取接收机参数数据。缺省条件：从TPS数据获取的设置(更长的信道采集时间)
4	R/W/0	extend_agc	设置到1，以便将采集序列保持在agc_acquire状态
				5		R/W/0	extend_fs	设置到1，以便将采集序列保持在fs_acquire状态
6	R/W/0	extend_settle	设置到1，以便将采集序列保持在fs_settle状态
				7		R/W/0	extend_sync	设置到1，以便将采集序列保持在vit_sync状态
	10：8	R/W/0	xtc						外部调谐器控制比特(外部管脚XTC[2：0])
				11	R/W/0	i2c_gate	12C“门”信号；设置为1将允许“处理器端12C”总线和“调谐器端”12C之间的隔离缓冲器，使得处理器可以通过COFDM装置存取调谐器。设置到0将关闭“门”，以防止12C总线噪声影响敏感的RF。

地址(十六进制)	比特号	直接复位	寄存器名	说明
						12	R/W/(TSTRI)	ts_tri	传输流三态控制-设置到1对MPEG TS接口进行三态控制(例如多路复用QPSK装置到相同的MPEG多路分解器)。TS输出的上电状态由外部管脚TSTRI控制
13	R/W/0)	fast_ber	设置到1，以减少BER计数器、vit_ill_state计数器和rso_counter，计数器周期从lsec到100ms
				15		R/W/0	soft_reset	软件复位-设置到1，以复位除upi之外的所有模块。设置到0以释放。
0×06-0×07	接收机参数寄存器：
						15：14	R/W/2	upi_constellation	解映射器和比特解交织器的星座图案(复位条件＝64-QAM)
13：12	R/W/0	upi_guard	保护区间：00＝1/32，01＝1/16，10＝1/8，11＝1/4
				11：9		R/W/0	upi_alpha	分层传输模式或“α”值(复位条件＝非分层模式)
7：5	R/W/0	upi_hp_rate	HP流的Viterbi码率-在非分层模式中，将其作为Viterbi码率(复位条件＝1/2速率代码)
				4：2		R/W/0	upi_lp_rate	LP流的Viterbi码率(复位条件＝1/2速率代码)
1：0	R/W/0	upi_tx_mode	传输模式(00＝2K，01＝8K，其他保留)
				0×08		7：0	R/W/0	rso_limit	每秒出错分组极限(对于rs_overload_event比特)

地址(十六进制)	比特号	直接复位	寄存器名	说明
					0×09	7：0	R/0	rso_count	每秒的不可校正传输分组计数(在255饱和)。写入寄存器以锁存稳定计数值，然后可读回该值
0×0a-0×0b	15：0	R/0	ber	从1秒周期内的RS较正导出的BER(在Rs之前)-对于7/8、64-QAM、1/32GI的最大可校正比特差错～1.35M/sec(等价于假设有用比特率为31.67e6时的43.e-3 BER)。只有21比特计数器的高16比特为可视-分辨率～le-6，依赖于码率、星座长度。写入寄存器以锁存稳定计数值，然后可读回该值。
					0×0c0×0d	15：0	R/0	agc_level	AGC“控制电压”(msb’s)
0×0e-0×0f	11：0	R/0	freq_error	IQ解调器频率误差(来自反馈环)
					0×10-0×13	TPS数据(包括未来使用比特)
	1：0	R/0	tps_frame	最后接收到的超帧中的完整OFDM帧的数目
					3：2	R/0	tps_constellation	来自TPS数据的星座图案
	7：5	R/0	tps_alpha	分层传输信息
						10：8	R/0	tps_hp_rate	高优先级流的Viterbi码率(在非分层模式，这是整个流的码率)
13：11	R/0	tps_lp_rate	低优先级流的Viterbi码率
				15：14		R/0	tps_guard_int	保护区间

地址(十六进制)	比特号	直接复位		寄存器名	说明
							17：16	R/0		tps_tx_mode	传输模式
31：19	R/0		tps_future	分配给将来使用的未定义比特
					***调试接入      ***
0×20-0×21	15	R/W/0		agc_open							设置到1，以断开AGC控制环
					11：0	R/W/0		agc_twiddle	AGC旋转因子
	0×22-0×23		R/W/0							agc_loop_bw	AGC控制环参数
0×24-0×25					15	R/W/0		freq_open	设置到1，以断开频率控制环
	14	R/W/0		freq_nogi						设置到1，以允许任何时间更新频率，而不只是在保护区间期间
					11：0	R/W/0		freq_twiddle	IQ解调旋转因子
	0×26-0×27									freq_loop_bw	频率控制环参数
0×28-0×29					15	R/W/0		sample_open	设置到1，以断开样本控制环
	14	R/W/0		sample_nogi						设置到1，以允许任何时间更新样本，而不只是在保护区间期间
					11：0	R/W/0		sample_twiddle	采样速率旋转因子
	0×2a-0×2b		R/W/0							sample_loop_bw	采样速率控制环参数
0×2c-0×2d					11：0	R/0		sampling_rate_err	采样速率误差(来自反馈环)
	0×30-0×31	15	R/W/0							lock_fft_window	设置到1，以防止跟踪模式中的fft_window移动
14					R/W/0		inc_fft_window	写入1，以便将fft_window位置移动到一个样本周期以后(单次(one-shot)模式)
		13	R/W/0						dec_fft_window	写入1，以便将fft_window位置移动到一个样本周期以前(单次模式)
12：0					R/0		fft_window	FFT窗口位置

地址(十六进制)	比特号	直接复位	寄存器名	说明
						7：0	R/W/0	fft_win_thresh	FFT窗口门限
0×34-0×35	15	R/W/0	set_carrier_0	设置到1，以便将carrier_0值用作设置
					11：0	R/W/0	carrier_0	载波0位置；读回导频定位算法检测的值，或通过覆盖其来强制写入一值
	0×36	7：0	R/W/	csi_thresh					信道状态信息门限-平均电平的一部分，在该平均电平以下，数据载波由bad_carrier标志来标记。标称值为0.2(用于2/3码率)
0×37
	0×38-0×39	11：0	R/0	vit_ill_states					Viterbi非法状态速率(每秒)。写入寄存器以锁存计数值，然后可读回该值
*****  探测器    *****  (外部测试地址比特TA[6]＝1)
					0×40-0×41	15：1411：0	R/WR/W	T，IQGIFreq_error[11：0]	IQ解调探测器(注意：比特0＝最高寻址字节的lsb，21)
0×44-0×47	31：3027：1611：0	R/WR/WR/W	T，ValidQ-data[11：0]I-data[11：0]	低通滤波器探测器
					0×48-0×4d	47：4643：323127：1611：0	R/WR/WR/WR/WR/W	T，SincGISample_err[11：0]ValidQ-data[11：0]I-data[11：0]	再采样器探测器
0×50-0×53	31：2927：1611：0	R/WR/WR/W	T，Valid，ResyncQ-data[11：0]I-data[11：0]	FFT探测器
					0×54-0×57	31：3029：2827：1611：0	R/WR/WR/WR/W	T，Valid，Symbol，ResyncQ-data[11：0]I-data[11：0]	信道估计和校正探测器
0×58-0×5b	31：3029：2827：1611：0	R/WR/WR/WR/W	T，Resyncu_symbol，uc_pilotQ-data[11：0]I-data[11：0]	频率和采样误差探测器

地址(十六进制)	比特号		直接复位		旨拇嫫髅	说明
							0×5c-0×5f	31：3029：2827：161511：0		R/WR/WR/WR/WR/W		T，Resyncc_symbol，tps_pil.Q-data[11：0]reference_seqI-data[11：0]	TPS序列提取探测器
0×60-0×65	3936：3534：3227：1615：141311：0		R/WR/WR/WR/WR/WR/WR/W		TconstellationalphaQ-data[11：0]Valid，c_symbolc_carrierOI-data[11：0]	解映射探测器
							0×68-0×6a	23：2221：201911：0		R/WR/WR/WR/W		T，valid symbol，carrie0odd_symbol[11：0]	符号解交织探测器
0×6c-0×6e	23：2120：1918：1611：0		R/WR/WR/WR/W		T，valid，symbolconstellationalphasymdi_data[11：0]	比特解交织器探测器
							0×70-0×71	15：136：42：0		R/WR/WR/W		T，valid，resyncI-data[2：0]	Viterbi探测器
0×72-0×73	15：1413：127：0		R/WR/WR/W		T，valid，resync，eopvit_data[7：0]	Forney解交织器探测器
							0×74-0×75	15：1413：127：0		R/WR/WR/W		T，valid，resvnc，eopdeint_data[7：0]	Reed-Solomon探测器
0×76-0×77	15：1413：1211：07：0		R/WR/WR/WR/W		T，valid，resync，eoperror_val，errordeint_data[7：0]	输出接口探测器
							0×78-0×7b	3130：2019：1817161413：86：54：32：0		R/WR/WR/WR/WR/WR/WR/WR/WR/WR/W		Ttps_data[10：0]pkt_err，err_valvit_ill_statevit_ill_valrs_corr_valrs_correct[5：0]vit_sync，tps_syncpilot_loc，fft_locvit_rate[2：0]	系统控制器探测器

                           表5

信号	说明
		clk	40MHz主时钟
clk20M	20MHz样本时钟(用作“有效”信号，以指示何时接收到有效输入样本)
		data[9：0]	从ADC输入的采样数据
agc_resync	控制输入；在信道变化时保持低-在转移到高时AGC应该对其进行复位，并且为新信道累加新控制电压
		lupdata[7：0](bi-di)	内部微处理器数据总线
upaddr[2：0]	内部微处理器地址总线(只要求2比特)
		upwstr	内部微处理器写探针
uprstr	内部微处理器读探针
		upsel1	内部地址解码输出(对于0×0c-0×0d，高＝有效)
upsel2	内部地址解码输出(对于0×20-0×23，高＝有效)
		te，tdin	扫描输入

                           表6

信号	说明
		agc	信号-Delta调制输出信号；当由外部RC积分时，它提供内部数字“控制电压”valueInterpolated输出数据的模拟表示
tdout	扫描输出

                           表7

地址(十六进制)	比特号	直接复位	寄存器名	说明
					0×0c-0×0d	15：0	R/0	agc_level	AGC“控制电压”(msb’s)
0×20-0×21	15	R/W/0	agc_open	设置到1，以断开AGC控制环
					11：0	R/W/0	agc_twiddle	AGC旋转因子
	0×22-0×23		R/W/0	agc_loop_bw					AGC控制环参数

                           表8

信号	说明
		clk	40MHz主时钟
nrst	低有效同步复位
		clk20M	20MHz样本时钟(用作“有效”信号以指示何时输入数据样本有效)
sample[9：0]	来自ADC的输入数据样本。(AGC应该保证此类白噪声信号被比例变换到满动态范围)
		freq_err[11：0]	频率误差输入-在+/-0.5载波间隔上精确调节1Hz
IQGI	有效脉冲，用于允许频率误差信号。频率控制环的效果被关闭，直至保护区间经过IQ解调模式。(IQGI由FFT窗口产生，并且指示何时保护区间经过)
		te，tdin	扫描测试输入

                           表9

信号	说明
		I-data[11：0]	I数据流将被低通滤波(40MHz定时)
Q-data[11：0]	Q数据流将被低通滤波(40MHz定时)
		valid	有效输出数据指示符；如果数据在此时钟周期正被输出则为高(40MHz定时)
tdout	扫描测试输出

                           表10

信号	说明
		clk	40MHz时钟(2x样本时钟)
nrst	低有效同步复位
		valid_in	高脉冲，指示来自IQ解调器的有效数据(40MHz定时)
i-data[11：0]，q_data[11：0]	来自IQ解调器的输入数据(20Msps)
		te，tdin	扫描测试输入

                           表11

信号	说明
		i_out[11：0]，q_out[11：0]	低通滤波过的输出数据

信号	说明
		valid	输出脉冲，指示有效数据输出(抽取到10Msps)
tdout	扫描测试输出

                           表12

毙藕	说明
		clk40M	40MHz主时钟(2x样本时钟)
valid_in	输入数据有效信号；当有效为低时，输入数据应该被忽略
		i_data[11：0]q_data[11：0]	来自低通滤波器的输入数据(抽取到10Msps)
sr_err[11：0]	来自频率/采样误差模块的采样速率误差反馈
		SincGI	误差信号的有效脉冲；采样速率控制环的效果被关闭，直至保护区间经过Sinc内插器。FFT窗口模块在适当时间产生此信号。
te，tdin	扫描测试信号

                           表13

信号	说明
		i_out[11：0]，q_out[11：0]	内插过的输出数据
valid	输出脉冲，指示有效数据输出
		tdout	扫描测试输出

                           表14

信号	说明
		clk40M	40MHz时钟(2x样本时钟)
valid_in	输入数据有效信号；当有效为低，输入数据应该被忽略
		i_data[11：0]	来自前端的输入数据(忽略此块的正交数据)
resync	控制信号；当脉冲变为高时，迫使同步FSM返回采集模式
		guard[1：0]	期望的保护区间；由主微处理器编程，以帮助fft_window采集，00＝1/32，01＝1/16，10＝1/8，11＝1/4

信号	说明
		lupdata[7：0](bi-di)	内部微处理器数据总线(双向)
upaddr[0]	内部微处理器地址总线(只要求1比特)
		upwstr	内部微处理器写探针
uprstr	内部微处理器读探针
		upsel	地址解码输出，用于选择FFT窗口块

                           表15

信号	说明
		FFT_Window	定时输出脉冲；对于2048个样本为低，指示有效区间
fft_lock	输出脉冲，指示同步FSM的状态；1＝要求符号
		rx_guard[1：0]	接收到的保护区间长度：00＝1/32，01＝1/16，10＝1/8，11＝1/4
IQGI	定时脉冲，指示何时保护区间应该到达IQ解调器(只在保护区间中校正频率误差)
		SincGI	定时脉冲，指示何时保护区间应该到达Sinc内插器(只在保护区间校正采样误差)
sr_sweep[3：0]	采样速率扫描输出；4比特输出由频率和采样误差模块使用，以便在FFT窗口采集期间产生采集速率“乒乓”扫描。

                           表16

地址十六进制)	比特号	直接复位	寄存器名	说明
					0×30-0×32	15	R/W/0	lock_fft_window	设置到1，以防止fft_window在跟踪模式移动
14	R/W/0	inc_fft_window	写入1，以便将fft_window位置移动到一个样本周期以后(单次操作)
				13		R/W/0	dec_fft_window	写入1，以便将fft_window位置移动到一个样本周期以前(单次操作)
12：0	F/0	fft_window	FFT窗口位置

地址十六进制)	比特号	直接复位	寄存器名	说明
						7：0	R/W/0

                           表17

信号	说明
		clk40M	40MHz时钟(2x样本时钟)
nrst	同步复位(低有效)
		valid_in	输入数据有效信号；当有效为低时，输入数据应该被忽略
i_data[11：0]，q_data[11：0]	来自FFT的输入数据
		symbol	来自FFT的符号定时脉冲；对于新符号的第一有效数据值为高
resync	重新同步输入，在例如信道变化时被触发。脉冲变化到高指示返回到采集模式(在开始导频搜索之前在重新同步之后等待第一符号脉冲)
		lupdata[7：0](bi-di)	内部微处理器数据总线
upaddr[0]	内部微处理器地址总线(只要求1比特)
		upwstr	内部微处理器写探针
uprstr	内部微处理器读探针
		upsel	内部地址解码器输出；对地址0×032-0×033为高

                           表18

信号	说明
		ui_data[11：0]，uq_data[11：0]	未校正的频谱数据，从RAM缓中器(对于频率/采样误差模块)读出
u_symbol	未校正的符号开始；对于未校正的符号的第一载波为高
		us_pilot	对于未校正的符号中的作为散射导频的任何载波为高
ci_data[11：0]，cq_data[11：0]	校正过的频谱数据；从复数乘法器输出
		valid	对于有效的校正的符号为高-只是数据载波
bad_carrier	如果该载波的内插过的信道响应低于前一符号的各载波的平均值的预定部分时为高-Viterbi将抛弃该载波携带的数据

信号	说明
		c_symbol	对于校正过的符号中的第一载波为高
c_carrier0	对于校正过的符号中的第一有效载波为高(连续导频对应于载波标引值0)
		c_tps_pilot	对于作为TPS导频的校正过的符号中的任何载波为高
pilot_lock	如果在导频采集阶段的结尾处成功地定位到导频，则输出高
		odd_symbol	如果符号在帧中为奇数(从散射导频阶段确定)则符号周期为高
c_reference_seq	输出到TPS序列块的参考序列
		freq_sweep[2：0]	频率扫描控制；增量3比特计数，该计数递增频率和采样模块中的IQ解调器L0偏移量。以0.125载波间隔步长扫描0-0.875载波间隔偏移量

                           表19

地址(十六进制)	比特号	直接复位	寄存器名	说明
					0×32-0×33	15	R/W/0	set_carrier_0	设置到1，以便将carrier_0用作设置
11：0	R/W/0	carrier_0	载波0位置
				0×36		7：0	R/W/	csi_thresh	信道状态信息门限-平均电平的一部分，低于该平均电平的数据载波由bad_carrier标志标记。标称值为0.2(对于2/3码率)。值0将CSI关闭，以进行比较测试。
0×37	7：0

                           表20

信号	说明
		clk40M	40MHz时钟(2x样本时钟)
ci_data[11：0]	由信道估计和校正校正过的导频数据(只需I数据，因为校正过的导频应该只使Im分量无意义；-只需符号比特)
		tps_pilot	当数据输入是tps_pilot时在单个时钟周期内为高-用作有效信号
reference_seq	从信道估计和校正输入的参考序列PRBS-对于非tps_pilot值则忽略
		c_symbol	定时脉冲，对于新符号中的第一载波在1个时钟周期内为高(不管载波是否为有效)
lupdata[7：0](bi-di)	内部微处理器数据总线
		upaddr[1：0]	内部微处理器地址总线(只要求2比特)
upwstr	内部微处理器写探针
		uprstr	内部微处理器读探针
upsel	内部地址解码输出；对于地址0×10-0×13为高

                           表21

信号	说明
		tps_data[29：0]	输出tps数据(在1个OFDM帧内保持静态)tps_data[1：0]＝帧号tps_data[3：2]＝星座tps_data[6：4]＝层次tps_data[9：7]＝码率，HP流tps_data[12：10]＝码率，LP流tps_data[14：13]＝保护区间tps_data[16：15]＝传输模式tps data[29：17]＝未来使用比特注意，参数为下一帧而发送；输出应该被双缓冲，以便参数在正确帧中在模块输出端出现(由解映射器和符号/比特解交织模块使用，以解码输入数据)
tps_sync	来自帧同步FSM的状态输出-当FSM被同步时，即当在期望的位置上接收到2个有效同步字、并且在模块输出端可得到正确的TPS数据时，设置到1

                           表22

0×10-0×13	TPS数据(包括未来使用比特)
					1：0	R/0	tps_frame	在超帧中最后接收到的完整的OFDM帧的号码

0×10-0×13	TPS数据(包括未来使用比特)
						3：2	R/0	tps_constellation	来自TPS数据的星座图案
7：5	R/0	tps_alpha	分层传输信息
				10：8		R/0	tps_hp_rate	高优先级流的Viterbi码率(在非分层模式中，这是整个流的码率)
13：11	R/0	tps_lp_rate	低优先级流的Viterbi码率
				15：14		R/0	tps_guard_int	保护区间
17：16	F/0	tps_tx_mode	传输模式
				31：19		R/0	tps_future	分配给未来使用的未定义比特

                           表23

信号	说明
		clk40M	40MHz时钟(2x样本时钟)
nrst	低有效复位
		us_pilot	输入数据有效信号；当散射导频从信道估计和校正模块输出时为高
guard[1：0]	保护区间，从该保护区间可导出Tt：00＝1/32(Tt＝231us)，01＝1/16(238us)，10＝1/8(252us)，11＝1/4(280us)
		ui_data[11：0]，uq_data[11：0]	来自信道估计和校正的输入数据(未校正的频谱)
u_symbol	来自信道校正和校正的符号定时脉冲；对于新符号的第一有效数据值(未校正的频谱)为高
		resync	重新同步输入，在例如信道变化时被触发。脉冲变化到高，以指示返回采集模式(在开始导频搜索之前在重新同步之后等待第一符号脉冲)
sr_sweep[3：0]	来自FFT窗口块的采样速率扫描控制；0＝0Hz偏移，1＝+500Hz，2＝-500Hz，3＝+1000Hz，4＝-1000Hz，5＝+1500Hz，6＝-1500Hz，7＝+2000Hz，8＝-2000Hz
		freq_sweep[3：0]	来自信道估计和校正模块的频率扫描控制；表示0-7范围的号码n频率偏移量＝n×500Hz

信号	说明
		lupdata[7：0](bi-di)	内部微处理器数据总线
upaddr[3：0]	内部微处理器地址总线(只要求4比特)
		upwstr	内部微处理器写探针
uprstr	内部微处理器读探针
		upsel1	内部地址解码输出；对于地址0×0e-0×0f为高
upsel2	范围0×24-0×2d的地址的地址解码

                           表24

信号	说明
		frequency_error	频率误差输出(至IQ解码器)
sampling_rate_error	采样速率误差输出(至Sinc内插器)
		freq_lock	状态输出；如果频率误差低则为高
sample_lock	状态输出；如果采样速率误差低则为高

                           表25

地址(十六进制)	比特号	直接复位	寄存器名	说明
					0×0e-0×0f	11：0	F/0	freq_error	IQ解调器频率误差(来自反馈环)

                           表26

地址(十六进制)	比特号	直接复位	寄存器名	说明
					0×24-0×25	15	R/W/0	freq_open	设置到1，以断开频率控制环
14	R/W/0	freq_nogi	设置到1，以允许任何时间更新频率，而不只是在保护区间期间
				11：0		R/W/0	freq_twiddle	IQ解调旋转因子
0×26-0×27			freq_loop_bw						频率控制环参数
				0×28-0×29	15	R/W/0	sample_open	设置到1，以断开样本控制环

地址(十六进制)	比特号	直接复位	寄存器名	说明
						14	R/W/0	sample_nogi	设置到1，以允许任何时间更新样本，而不只是在保护区间期间
11：0	R/W/0	sample_twiddle	采样速率旋转因子
				0×2a-0×2b			R/W/0	sample_loop_bw	采样速率控制环参数
0×2c-0×2d	11：0	R/0	sampling_rate_err		采样速率误差(来自反馈环)

                           表27

信号	说明
		clk40M	40MHz时钟(2x样本时钟)
valid_in	输入数据有效信号；当有效为低时，输入数据应该被忽略
		i_data[11：0]，q_data[11：0]	来自信道估计和校正的输入数据
bad_carrier_in	载波状态标志-如果载波落到可接受的电平以下，则置位；指示Viterbi，来自该载波的数据应该在纠错计算中抛弃
		c_symbol	定时同步信号-对于校正过的COFDM符号中的第一数据样本为高
constellation[1：0]	控制信号，定义星座：00＝QPSK，01＝16-QAM，10＝64-QAM
		alpha[2：0]	控制信号，定义分层传输参数α：000＝非分层传输，001＝α值1，010＝α值2，011＝α值4(注意芯片的第一次发布将不支持分层传输)

                           表28

信号	说明
		out_data[11：0]	解交织过的输出数据6I、6Q格式
bad_carrier	bad_carrier标志，经过解映射处理而不改变
		valid	有效输出数据指示符；如果数据在此时钟周期正被输出则为高

信号	说明
		d_symbol	符号定时脉冲，被再定时以与out_data同步

                           表29

信号	说明
		clk40M	40MHz时钟(2x样本时钟)
valid_in	输入数据有效信号；当有效为低时，输入数据应该被忽略
		demap_data[11：0]	来自解映射器的输入数据。数据为6比特I、6比特Q格式(对于64_QAM)
bad_carrier_in	载波状态信号-如果载波落到极限以下则置位；指示Viterbi，数据应该被忽略。作为附加比特与数据一起被携带通过解交织器存储器
		symbol	定时同步信号-对于COFDM符号中第一数据样本为高。用于重新同步地址产生。
carrier0	定时脉冲-对于符号中的第一有效载波为高(对应于载波标引值0)
		odd_symbol	如果符号在帧中为奇数则为高(在68符号帧中，奇、偶符号的交织图案不同)

                           表30

信号	说明
		out_data[11：0]	解交织过的输出数据解码星座格式
bad_carrier	经过解交织RAM的坏载波输出
		valid	有效输出数据指示符；如果数据在此时钟周期正被输出则为高
d_symbol	输出定时同步信号-对于解交织过的COFDM符号中的第一数据样本为高

                           表31

信号	说明
		clk40M	40MHz时钟(2x样本时钟)
valid_in	输入数据有效信号；当有效为低时，输入数据应该被忽略；有效“扩展”以平滑整个符号的数据速率-每6个40MHz周期平均1个数据有效。Viterbi输入端的有效数据速率降低到20MHz
		sdi_data[11：0]	来自符号解交织器的输入数据。数据为6比特I、6比特Q格式(对于64_QAM)

信号	说明
		bad_carrier	如果传递数据的载波落到可接受的极限以下，则设置到1；指示Viterbi，此数据应该被忽略
symbol	定时同步信号-对于COFDM符号中的第一数据样本。用于重新同步地址产生
		constellation[1：0]	星座类型指示符：10＝64-QAM，01＝16-QAM，00＝QPSK
alpha[2：0]	分层传输控制：000＝非分层，001＝α值1，010＝α值2，011＝α值4(注意：在本器件的本第一版本中，只支持非分层模式)

                           表32

信号	说明
		I-data[2：0]	至Viterbi的I软比特
discard-I	标志比特，由bad_carrier信号驱动；如果置位，则Viterbi将忽略此软比特。(由于交织，每个软比特将重复坏比特)
		Q-data[2：0]	至Viterbi的Q软比特
discard-Q	标志比特；如果置位，Viterbi将忽略此软比特
		valid	有效输出数据指示符；如果数据在此时钟周期中正被输出则为高

                           表33

信号	说明
		MD[7：0](bi-di)	微处理器数据总线(双向)
MA[5：0]	微处理器地址总线
		MR/W	微处理器读/写控制
SCL	串行接口时钟
		SDA(bi-di)	串行接口数据I/Q(双向-与MD[0]相同的管脚)
SADDR[2：0]	串行接口地址
		S/P	串行/并行接口选择

                           表34

信号	说明
		nupdata[7：0](bi-di)	内部处理器数据总线(翻转)(双向)

信号	说明
		upaddr[5：0]	内部地址总线(解码，以便为各功能块中的各寄存器组提供各选择)
upgrstr	内部读探针
		upgwstr	内部写探针
IRQ	中断请求(低有效，集电极开路)

                           表35

信号	说明
		pad_clk40	来自输入脚的未控制的40MHz时钟
lupdata[7：0](bi-di)	内部微处理器数据总线(双向)
		upaddr[3：0]	内部微处理器地址总线(只有与系统控制内的寄存器有关的比特)
uprstr	内部微处理器读探针
		upwstr	内部微处理器写探针
upsel1	从微处理器接口解码的块选择(1＝允许存取此块)，对于地址0×00-0×0b有效
		upsel2	对于0×38-0×39范围进行地址解码
tps_data[10：0]	在OFDM帧中接收到的TPS数据(1：0＝tps_constellation；4：2＝tps_alpha；7：5＝tps_hp_rate；10：8＝tps_lp_rate)(不必理会保护区间-这些参数只影响后端模块)
		rs_correct[5：0]	每个RS分组中校正过的比特的计数(对于BER值在1秒内累加)
rs_corr_val	有效脉冲；当rs_correct值有效时为高
		pkt_err	设置到1，以指示RS分组未校正；具有＞64比特差错或以某种方式讹误
err_val	设置到1，以指示何时pkt_err信号有效
		vit_ill_state	Viterbi_illegal状态脉冲；(累加，以产生Viterbi非法状态计数)
vit_ill_val	现在不需要-Viterbi非法状态有效脉冲
		vit_sync	状态信号-如果Viterbi被同步则为1
tps_sync	状态信号-如果TPS被同步则为1
		pilot_loc	状态信号-如果导频定位成功完成(found_pilots)则为1
fft_loc	状态信号-如果FFT窗口正确定位到则为1
		vit_rate[2：0]	接收到的Viterbi穿孔速率

信号	说明
		tck	JTAG测试时钟-用于测试模式中的时钟控制
njreset	JTAG测试复位-用于时钟控制模块
		jshift	JTAG测试寄存器移位控制-用于时钟控制模块
j_ctrl_in	JTAG测试数据输入

                           表36

信号	说明
		clk40	测试控制的主时钟
clk20	测试控制的样本时钟(输入到IQ解调器和AGC)
		lupdata[7：0](bi-di)	内部处理器数据总线(双向)
nirq	低有效中断请求比特(从chip_event导出)
		constellation[1：0]	内部地址总线(解码，以便为功能块中的各寄存器组提供各选择)
alpha[2：0]	分层模式信息
		hp_rate[2：0]	高优先级信道的Viterbi码率(在非分层模式，这是整个信道的码率)
lp_rate[2：0]	低优先级信道的Viterbi码率
		upi_tx_mode[1：0]	传输模式(2K或8K)
upi_guard[1：0]	保护区间
		rxp_valid	如果主接口已将rx_para数据置位，则设置到1-用作rx_para数据的“有效”信号(在TPS数据用tps_sync的情况下)
o_clk_phase	控制线；设置到1，以翻转输出时钟相位
		xtc[2：0]	外部调谐器控制比特
i2c_gate	12C“门”控制
		ts_tri	传输流接口三态控制
soft_reset	软件复位(设置到1，以复位除upi之外的一切部分)
		agc_invert	控制线：设置到1，以翻转AGC sigma-delta输出的读出
agc_resync	控制线：当设置到低时，AGC保持在初始状态。重新同步转移到高便开始AGC采集序列

信号	说明
		fft_resync	控制线：保持低，以重新初始化FFT、信道估计和校正、频率/采样误差和TPS模块。转移到高则开始FFT窗口定位、导频定位和TPS同步。
viterbi_resync	控制线；保持低，以重新初始化EEC后端。转移到高则开始Viterbi同步。
		j_ctrl_out	JTAG测试数据输出-来自时钟控制模块。

                            表37

地址(十六进制)	比特号	直接复位	寄存器名	说明
					0×00	事件寄存器
	0	R/W/0	chip_event	中断允许(未屏蔽)的所有事件的逻辑“或”
					1	R/W/0	ock_failed_event	如果信道允许采集序列失败则设置到1
	2	R/W/0	rs_overload_event	如果Reed_Solomon解码器在1秒时段内超过设置门限则设置为1
					0×01	屏蔽寄存器
	0	R/W/0	chip_mask	设置到1，以允许IRQ输出
					1	R/W/0	lock_failed_mask	设置到1，以便在信道采集失败时允许中断
	2	R/W/0	rs_overload_mask	设置到1，以便在超过RS误差门限时允许中断
					0×02	状态寄存器
	0	F/0	system_locked	当系统成功采集信道时，则设置到1
					1	F/0	vitebi_sync	当Viterbi被同步时，则设置到1
		2	F/0	tps_sync					当携带TPS数据的OFDM帧已经被同步时，则设置到1

地址(十六进制)	比特号	直接复位	寄存器名	说明
						3	R/0	pilot_loc	当COFDM中的导频已经定位到并同步，则设置到1
4	R/0	fft_loc	当保护区间已经定位到并同步，则设置到1
				7：5		R/1	viterbi_rate	接收到的Viterbi码率
0×04-0×05	控制寄存器
						0	R/W/0	change_channel	当设置到1，则将器件保持在“复位”状态。清除此比特将启动信道变化
1	R/W/0	agc_invert	翻转AGC Sigma-Delta输出。缺省设置意味着与降低的AGC增益关联的低输出
				2		R/W/0	o_clk_phase	设置到1，以翻转输出时钟的相位。缺省条件：输出数据在输出时钟的下降沿改变
3	R/W/0	sey_rx_parameters	时钟到1，以便从接收机参数寄存器接收接收机参数数据。缺省条件：从TPS数据接收设置(更长的信道采集时间)
				4		R/W/0	extend_agc	设置到1，以便将采集序列保持在agc_acquire状态
5	R/W/0	extend_fs	设置到1，以便将采集序列保持在fs_acquire状态
				6		R/W/0	extend_settle	设置到1，以便将采集序列保持在fs_settle状态
7	R/W/0	extend_syn	当设置到1时，将采集序列保持在vit_sync状态

地址(十六进制)	比特号	直接复位		寄存器名		说明
								10：8	R/W/0		xtc		外部调谐器控制比特(外部管脚XTC[2：0])
	11	R/W/0		i2c_gate		12C“门”信号；将此设置到1允许“处理器端”12C总线和“调谐器端”12C之间的隔离缓冲器，使得处理器可以通过COFDM装置存取调谐器。设置到0将关闭该“门”，以防止12C总线噪声影响敏感的RF。
							12	R/W/0		ts_tri		传输流三态控制-设置到1，以便对MPEG TS接口进行三态控制(例如将QPSK装置多路复用到相同的MPEG多路分解器)。TS输出的上电状态由外部管脚控制-在某种意义上！！！
	13	R/W/0		fast_ber		设置到1以减少BER计数器、vit_ill_state计数器和rso_counter，计数器周期从1sec到100ms
								15	R/W/0		soft_reset		软件复位-设置到1以复位除upi之外的所有模块。设置到0以释放。
	0×06-0×07	接收机参数寄存器：
			15：14	R/W/2		upi_constellation		解映射器和比特解交织器的星座图案(复位条件＝64-QAM)
	13：12	R/W/0							upi_guard		保护区间：00＝1/32，01＝1/16，10＝1/8，11＝1/4

地址(十六进制)	比特号		直接复位	寄存器名	说明
							11：9		R/W/0	upi_alpha	分层传输模式或“α”值(复位条件＝非分层模式)
	7：5		R/W/0	upi_hp_rate	HP流的Viterbi码率-在非分层模式中，这用作Viterbi码率(复位条件＝1/2速率代码)
							4：2		R/W/0	upi_lp_rate	LP流的Viterbi码率(复位条件＝1/2速率代码)
1：0		R/W/0	upi_tx_mode	传输模式(00＝2K，01＝8K，其他保留)
					0×08		7：0		R/W/0	rso_limit	每秒的出错分组极限(对于rs_overload_event比特)
0×09	7：0		R/0	rso_count		每秒的不可校正的传输分组计数(在255饱和)。写入寄存器以锁存稳定计数值，然后可读回该值。
					0×0a-0×0b		15：0		R/0	ber	在1秒时段内从RS校正导出的BER(在RS之前)-最大可校正比特差错～对7/8、64-QAM、1/32GI为1.35M/sec(等价于假设有用比特率为31.67e6时的43.e-3 BER)。只有21比特计数器的高16比特为可视-分辨率～le-6，依赖于码率、星座GI长度。写入寄存器以锁存稳定计数值，然后可读回该值。

                                   表38

0×38-0×39

11：0

R/0

vit_ill_states

Viterbi非法状态速率(每秒)。写入寄存器以锁存计数值，然后可读回该值

                                表39

                                          Listing 1

∥Sccsld： ％W％ ％G％
*****************************************************************************

Copyright (c)1997 Pioneer Digital Design Centre Limited
Author：Dawood Alam.
Description：Verilog code for butterfly processor BF2I.(RTL)
Notes：Computes first stage in radix 4 calculation.
******************************************************************************/
`timescale 1ns/100ps
module fft_bf2I(clk，enable_1，in_x1r，in_x1i，in_x2r，in_x2i，in_s，

out_z1r，out_z1i，out_z2r，out_z2i，out_ovf)；
parameter      wordlength＝5；    ∥Data wordlength.
input   clk，      ∥ Master clock.

    enable_1，     ∥Enable on clock 3.

     in_s；      ∥ Control line.
input[wordlength-1：0] in_x1r，     ∥Input I from memory.

    in_x1i，     ∥Input Q from memory.

      in_x2r，    ∥ Input I stage n-1.

      in_x2i；   ∥Input Q stage n-1.
output      out ovf；   ∥ Overflow flag.
output [wordlength-1：0] out_z1r，  ∥Output I to stage n+1

     out_z1i，    ∥Output Q to stage n+1

       out_z2r，    ∥ Output I to memory.

       out_z2i；    ∥Output Q to memory.
wire [wordlength-1：0] in_x1r，

    in_x1i，

    in_x2r，

    in_x2i，

   out_z1r，

    out_z1i，

    out_z2r，

    out_z2i；
wire     in_s，

   enable_1，

   out_ovf；
reg [wordlength-1：0] z1r_tmp1，

    z1i_tmp1，

     z2r_tmp1，

     z2i_tmp1，

    z1r_tmp2，

     z1i_tmp2，

     z2r_tmp2，
				
				
       z2i_tmp2；
reg        ovf_tmp，

     ovf_tmp0，

     ovf_tmp1，

       ovf_tmp2，

       ovf_tmp3，

     ex_reg0，

       ex_reg1，

       ex_reg2，

       ex_reg3；
always@(in_s or in_x1r or in_x1i or in_x2r or in_x2i)
begin
{ex_reg0，z1r_tmp1}＝in_x1r+in_x2r；
ovf_tmp0＝in_x1r[wordlength-1]&&          ∥Overflow check.

  in_2r[wordlength-1]&&

   ～z1i_tmp1[wordlength-1]||

  ～in_x1i[wordlength-1]&&

   ～in_x2i[wordlength-1]&&

   z1i_tmp1[wordlength-1]；
if (ovf_tmp1)          ∥Saturate logic.
z1i_tmp1＝(ex_reg1)？{1′b1，{wordlength-1{1′b0}}}：

    {1′b0，{wordlength-1{1′b1}}}；
{ex_reg2，z2r_tmp1}＝in_x1r-in_x2r；
ovf_tmp2＝in_x1r[wordlength-1]&&         ∥Overflow check.

  ～in_x2r[wordlength-1]&&

    ～z2r_tmp1[wordlength-1]||

  ～in_x1r[wordlength-1]&&

   in_x2r[wordlength-1]&&

  z2r_tmp1[wordlength-1]；
if(ovf_tmp2)            ∥Saturate logic.
  z2r_tmp1＝(ex_reg2)？{1′b1，{wordlength-1{1′b0}}}：

    {1′b0，{wordlength-1{1′b1}}}；
{ex_reg3，z2i_tmp1}＝in_x1i-in_x2i；
ovf_tmp3＝in_x1i[wordlength-1]_&&          ∥Overflow check.

  ～in_x2i[wordlength-1]&&

  ～z2i_tmp1[wordlength-1]||

  ～in_x1i[wordlength-1]&&

  in_x2i[wordlength-1]&&

   z2i_tmp1[wordlength-1]；
if(ovf_tmp3)             ∥ Saturate logic.
  z2i_tmp1＝(ex_reg3)？{1′b1，{wordlength-1{1′b0}}}：

     {1′b0，{wordlength-1{1′b1}}}；
				
				
∥Output stage with two channel mux.
if(！in_s)
begin：mux_passthru

  z1r_tmp2＝in_x1r；

  z1i_tmp2＝in x1i；

  z2r_tmp2＝in_x2r；

  z2i_tmp2＝in_x2i；
 end
else
 begin：mux_computing

  z1r_tmp2＝z1r_tmp1；

  z1i_tmp2＝z1i_tmp1；

  z2r_tmp2＝z2r_tmp1；

  z2i_tmp2＝z2i_tmp1；
 end
end
assign out_z1r＝z1r_tmp2；
assign out_z1i＝z1i_tmp2；
assign out_z2r＝z2r_tmp2；
assign out_z2i＝z2i_tmp2；
always @(posedge clk)
 if(enable_1) ∥ Butterfly completes at the end of clock cycle 0.
  ovf_tmp＜＝in_s &&(ovf_tmp0||ovf_tmp1||ovf_tmp2||ovf_tmp3)；
assign out_ovf＝ovf_tmp；
`ifdef OVERFLOW DEBUG LOW LEVEL
∥Debug code to display overflow output of a particular adder.
∥Concurrently monitor overflow flag and halt on overflow.
always @(ovf_tmp or ovf_tmp0 or ovf_tmp1 or ovf_tmp2 or ovf_tmp3)
 if(ovf_tmp)
  begin
   if(ovf_tmp0)$display(″ovf_tmp0 on BF2I＝″，ovf_tmp0)；

   if(ovf_tmp1)$display(″ovf_tmp1 on BF2I＝″，ovf_tmp1)；

   if(ovf_tmp2)$display(″ovf_tmp2 on BF2I＝″，ovf_tmp2)；

   if(ovf_tmp3)$display(″ovf_tmp3 on BF2I＝″，ovf_tmp3)；

   $stop；
 end
`endif
endmodule

                                 Listing 2

∥ Sccsld：％W％ ％G％
/*******************************************************************************

   Copyright(c)1997 Pioneer Digital Design Centre Limited
Author：Dawood Alam.
Description：Verilog code for butterfly processor BF2II.(RTL)
Notes：Computes second stage in radix 4 calculation.
				
				
******************************************************************************/

`timescale 1ns/100ps

module fft_bf2II(clk，enable_1，in_x1r，in_x1i，in_x2r，in_x2i，in_s，in_t，

     out_z1r，out_z1i，out_z2r，out_z2i，out_ovf)；

parameter       wordlength＝5；     ∥Data wordlength.

input      clk，       ∥Master clock.

      enable_1，       ∥ Enable on clock 3.

       in_s，         ∥Control line.

       in_t；        ∥Control line.

input[wordlength-1：0]in_x1r，      ∥Input I from memory.

      in_x1i，      ∥Input Q from memory.

       in_x2r，       ∥ Input I stage n-1.

       in_x2i；      ∥Input Q stage n-1.

output    out_ovf；     ∥ Overflow flag.

output[wordlength-1：0]out_z1r，     ∥Output I to stage n+1

      out_z1i，       ∥ Output Q to stage n+1

       out_z2r，        ∥Output I to memory.

       out_z2i；       ∥Output Q to memory.
wire[wordlength-1：0]in_x1r，

      in_x1i，

        in_x2r，

        in_x2i，

       out_z1r，

        out_z1i，

        out_z2r，

        out_z2i；

 wire    in_s，

      in_t，

        enable_1，

        out_ovf，

        control；

 reg[wordlength-1：0]z1r_tmp1，

      z1i_tmp1，

       z2r_tmp1，

       z2i_tmp1，

      z1r_tmp2，

       z1i_tmp2，

       z2r_tmp2，

       z2i_tmp2，

      x2ri_tmp1，

       x2ri_tmp2；

 reg   ovf_tmp，

       ovf_tmp0，

       ovf_tmp1，

         ovf_tmp2，

         ovf_tmp3，

       ex_reg0，

        ex_reg 1，

        ex_reg2，
				
				
     ex_reg3；
assign control＝in_s &&！in_t；
always@(in_s or control or in_x1r or in_x1i or in_x2r or in_x2i)
begin
∥Crosspoint switch，used in computing complexj values.
if(control)
 begin：switch crossed
  x2ri_tmp1＝in_x2i；∥i-＞r.
  x2ri_tmp2＝in_x2r；∥r-＞i.
 end
else
 begin：switch thru
  x2ri_tmp1＝in_x2r；∥r-＞r.
  x2ri_tmp2＝in_x2i；∥i-＞i.
 end
{ex_reg0，z1r_tmp1}＝in_x1r+x2ri_tmp1；
ovf_tmp0＝in_x1r[wordlength-1]&&      ∥Overflow check.

 x2ri_tmp1[wordlength-1]&&

   ～z1r_tmp1[wordlength-1]||

 ～in_x1r[wordlength-1]&&

   ～x2ri_tmp1[wordlength-1]&&

   z1r_tmp1[wordlength-1]；
 if(ovf_tmp0)             ∥Saturate logic.
  z1r_tmp1＝(ex_reg0)？{1′b1，{wordlength-1{1′b0}}}：

    {1′b0，{wordlength-1{1′b1}}}；
{ex_reg1，z1i_tmp1}＝(control)？in_x1i-x2ri_tmp2：in_x1i+x2ri_tmp2；
ovf_tmp1＝in_x1i[wordlength-1]&&         ∥ Overflow check.
   (control^x2ri_tmp2[wordlength-1])&&    ∥Deals with a

    ～z1i_tmp1[wordlength-1]||     ∥+/-input.
   ～in_x1i[wordlength-1]&&

    ～(control^x2ri_tmp2[wordlength-1])&&

    z1i_tmp1[wordlength-1]；
 if(ovf_tmp1)           ∥Saturate logic.
  z1i_tmp1＝(ex_reg1)？{1′b1，{wordlength-1{1′b0}}}：

    {1′b0，{wordlength-1{1′b1}}}；
 {ex_reg2，z2r_tmp1}＝in_x1r-x2ri_tmp1；
 ovf_tmp2＝in_x1r[wordlength-1]&&          ∥Overflow check.

    ～x2ri_trrp1[wordlength-1]&&      ∥Deals with a

    ～z2r_tmp1[wordlength-1]||      ∥-input.

  ～in_x1r[wordlength-1]&&

   x2ri_tmp1[wordlength-1]&&

   z2r_tmp1[wordlength-1]；
 if(ovf_tmp2)           ∥Saturate logic.
  z2r_tmp1＝(ex_reg2)？{1′b1，{wordlength-1{1′b0}}}：

    {1′b0，{wordlength-1{1′b1}}}；
 {ex_reg3，z2i_tmp1}＝(control)？in_x1i+x2ri_tmp2：in_x1i-x2ri_tmp2；
 ovf_tmp3＝in_x1i[wordlength-1]&&        ∥Overflow check.

   ～(control^x2ri_tmp2[wordlength-1])&&  ∥Deals with a

     ～z2i_tmp1[wordlength-1]||    ∥-/+input.

   ～in_x1i[wordlength-1]&&
				
				
    (control^x2ri_tmp2[wordlength-1])&&

    z2i_tmp1[wordlength-1]；
if(ovf_tmp3)            ∥Saturate logic.
z2i_tmp1＝(ex_reg3)？{1′b1，{wordlength-1{1′b0}}}：

     {1′b0，{wordlength-1{1′b1}}}；
∥Output stage with two channel mux.
if(！in_s)
 begin：mux_passthru
   z1r_tmp2＝in_x1r；
   z1i_tmp2＝in x1i；
   z2r_tmp2＝x2ri_tmp1；
   z2i_tmp2＝x2ri_tmp2；
 end
else
 begin：mux_computing
   z1r_tmp2＝z1r_tmp1；
   z1i_tmp2＝z1i_tmp1；
   z2r_tmp2＝z2r_tmp1；
   z2i_tmp2＝z2i_tmp1；
 end
end
assign out_z1r＝z1r_tmp2；
assign out_z1i＝z1i_tmp2；
assign out_z2r＝z2r_tmp2；
assign out_z2i＝z2i_tmp2；
always @(posedge clk)
 if(enable_1) ∥Butterfly completes at the end of clock cycle 0.
 ovf_tmp＜＝in_s &&(ovf_tmp0||ovf_tmp1||ovf_tmp2||ovf_tmp3)；
assign out_ovf＝ovf_tmp；
`ifdef OVERFLOW DEBUG LOW LEVEL
∥Debug code to display overflow output of a particular adder.
∥Concurrently monitor overflow flag and halt on overflow.
always @(ovf_tmp or ovf_tmp0 or ovf_tmp1 or ovf_tmp2 or ovf_tmp3)
 if(ovf_tmp)
 begin

   if(ovf_tmp0)$display(″ovf_tmp0 on BF2II＝″，ovf_tmp0)；

   if(ovf_tmp1)$display(″ovf_tmp1 on BF2II＝″，ovf_tmp1)；

   if(ovf_tmp2)$display(″ovf_tmp2 on BF2II＝″，ovf_tmp2)；

   if(ovf_tmp3)$display(″ovf_tmp3 on BF2II＝″，ovf_tmp3)；

   $stop；
 end
 `endif
endmodule

                                 Listing 3

∥Sccsld：％W％ ％G％
/******************************************************************************

    Copyright(c)1997 Pioneer Digital Design Centre Limited
				
				
Author：Dawood Alam.
Description：Verilog code for a variable size ROM with complex data store.
   (RTL)
Notes：Used to store complex Twiddle factors.
*******************************************************************************/
`timescale 1ns/100ps
module fft_rom(clk，enable_3，address，rom_data)；
parameter      c_wordlength＝1；  ∥Coeff wordlength.
parameter      rom_AddressSize＝1； ∥Address size.
parameter FILE＝″../../../fft/src/lookup_tables/lu_10bit_2048pt_scaleX″；
             ∥Lookup tab filename.(Listings 16，17)
input      clk，

     enable_3；
input[rom_AddressSize-1：0]address；
output[c_wordlength-1：0]rom_data；
reg[c_wordlength*2-1：0]rom[0：(1＜＜rom_AddressSize)-1]；
reg[c_wordlength*2-1：0]b_tmp1，

    rom_data；
always @(address)
 b_tmp1＝rom[address]；
always @(posedge clk)
 if(enable_3)
  rom_data＜＝b_tmp1；
initial
 $readmemb(FILE，rom)；
endmodule

                                 Listing 4

∥Sccsld：％W％ ％G％
/*******************************************************************************

   Copyright(c)1997 Pioneer Digital Design Centre Limited
Author：Dawood Alam.
Description：Verilog code for variable length single bit shift register.
Notes：Used to delay pipeline control signals by ″length″clocks.
*******************************************************************************/
`timescale 1ns/100ps
				
				
module fft_sr_1bit(clk，enable_3，in_data，out_data)；
parameter       length＝1；    ∥Shift reg length.
input       clk，     ∥Master clock；

      enable_3；    ∥Enable on clock 3.
input       in_data；    ∥Input data.
output        out_data；    ∥Output data.
reg     shift_reg[length-1：0]；∥Shift register.
wire     out_data；
wire     clk，

    enable_3；
integer    i；
 always @(posedge clk)
  if(enable_3)
  begin

   for(i＝(length-1)；i＞＝0；i＝i-1)

    if(i＝＝0)

     shift_reg[0]＜＝in_data；      ∥Force input to SR.

    else

    shift_reg[i]＜＝shift_reg[i-1]； ∥Shift data once.
  end
 assign out_data＝shift_reg[length-1]；
endmodule

                                  Listing 5

∥Sccsld：％W％ ％G％
/********************************************************************************

   Copyright(c)1997 Pioneer Digital Design Centre Limited
Author：Dawood Alam.
Description：Verilog code for a dual-port FIFO.(RTL)
Notes：Used as a pipeline register to delay address into the address

   decoder.
*****************************************************************************/
`timescale 1ns/100ps
module fft_sr_addr(clk，enable_3，in_data，out_data)；
parameter      wordlength＝1；   ∥Data wordlength I/Q.
parameter      length＝1；    ∥Shift reg length.
input     clk，      ∥Master clock；

      enable_3；     ∥Enable on clock 3.
input[wordlength-1：0]in_data；    ∥SR input data.
output[wordlength-1：0]out_data；    ∥ SR output data.
				
				
reg [wordlength-1：0] shift_reg [length-1：0]； ∥Shift register.
wire [wordlength-1：0] out_data；
wire       clk，

     enable_3；
integer     i；
always @(posedge clk)
 if (enable_3)
 begin
  for (i＝(length-1)；i＞＝0；i＝i-1)

    if (i＝＝0)

    shift_reg[0]＜＝in_data；     ∥Force input to SR.
  else

    shift_reg[i]＜＝shift_reg[i-1]；∥Shift data once.
  end
 assign out_data＝shift_reg[length-1]；
endmodule

                                  Listing 6

∥Sccsld：％W％ ％G％
/* Copyright(c)1997 Pioneer Digital Design Centre Ltd.
 Author：Dawood Alam.
 Description：Verilog code for an signed twiddle factor multiplier.(RTL)
 Notes：Single multiplexed multiplier and 2 adders employed to

    perform 3 multiplies and 5 additions. Pipeline depth＝2.

    ar/ai＝Complex data， br/bi＝Complex coefficient.

    bi+/-br could be pre-calculated in the ROM lookup，however

    in this implementation it is NOT an overhead as this path is

        shared by ar+ai.*/
`timescale 1ns/100ps
module fft_complex_mult_mux(clk，c2，in_ar，in_ai，in_br，in_bi，

          out_cr，out_ci，out_ovf)；
parameter      wordlength＝12；    ∥Data wordlength.
parameter      c_wordlength＝10；   ∥Coeff wordlength.
parameter      mult_scale＝4；   ∥multiplier scalling，

               ∥1＝/4096，2＝/2048，

               ∥3＝/1024，4＝/512.
input [wordlength-1：0]in_ar，  ∥Data input I.

      in_ai；     ∥Data input Q.
input[c_wordlength-1：0]in_br，   ∥Coefficient input I.

      in_bi；     ∥Coefficient input Q.
input      clk；    ∥ Master clock.
input[1：0]   c2；     ∥Two bit count line.
output      out_ovf；    ∥Qverflow flag.
output[wordlength-1：0] out_cr，    ∥Data output I.

      out_ci；     ∥Data output Q.
				
				
wire[wordlength-1：0]in_ar，

   in_ai，

     br_tmp，

     bi_tmp，

     out_cr，

     out_ci；
wire[c_wordlength-1：0]in_br，

   in_bi；
wire      enable_0，

     enable_1，

     enable_2，

     enable_3；
wire[1：0]  c2；
reg[wordlength-1：0]in_ai_tmp，

   in_ar_tmp，

     abr_tmp，

     abi_tmp，

      abri_tmp1，

      abri_tmp2，

      abri_tmp4，

      coeff_tmp1，

     mpy_tmp1，

      sum_tmp0，

       sum_tmp1，

       sum_tmp2，

       acc_tmp，

       store_tmp，

       cr_tmp，

       ci_tmp；
reg[wordlength*2-1：0]abri_tmp3，

   mpy_tmp2，

    coeff_tmp2；
reg    ovf_tmp0，

     ovf_tmp1，

       ovf_tmp2，

       ovf_tmp3，

     ex_reg0，

       ex_reg1，

       c1，c3，c4；
∥Enable signals for registers.
 assign enable_0＝～c2[1]&&～c2[0]；
 assign enable_1＝～c2[1]&&c2[0]；
 assign enable_2＝  c2[1]&&～c2[0]；
 assign enable_3＝  c2[1]&&c2[0]；
 ∥Sign extend coefficients from c_wordlength bits to wordlength.
 assign br_tmp＝{{(wordlength-c_wordlength){in_br[c_wordlength-1]}}，in_br}；
 assign bi_tmp＝{{(wordlength-c_wordlength){in_bi[c_wordlength-1]}}，in_bi}；
 ∥Combinational logic before pipeline register.
 always @(in_ar or br_tmp or in_ai or bi_tmp or c2)
 begin
				
				
c1＝c2[0]||c2[1]；
c3＝c2[1]；
if(！c1)
   begin

   abr_tmp＝in_ar；

   abi_tmp＝in_ai；
  end
else
  begin
   abr_tmp＝br_tmp；
   abi_tmp＝bi_tmp；
  end
if(c3)
  {ex_reg0，abri_tmp4}＝abi_tmp-abr_tmp；
else
  {ex_reg0，abri_tmp4}＝abi_tmp+abr_tmp；
ovf_tmp0＝abi_tmp[wordlength-1]&&     ∥Overflow check.

   (c3^abr_tmp[wordlength-1])&&    ∥Deals with a

   ～abri_tmp4[wordlength-1]||  ∥+/-input.

   ～abi_tmp[wordlength-1]&&

   ～(c3^abr_tmp[wordlength-1])&&

   abri_tmp4[wordlength-1]；
if(ovf_tmp0)           ∥Saturate logic.
   abri_tmp1＝(ex_reg0)？{1′b1，{wordlength-1{1′b0}}}：

     {1′b0，{wordlength-1{1′b1}}}；
 else
   abri_tmp1＝abri_tmp4；
end
∥Combinational logic after pipeline register.
always @(in_ar_tmp or in_ai_tmp or br_tmp or c2 or store_tmp or abri_tmp2)
begin
 c4＝c2[1]&&～c2[0]；
 case(c2)
 2′b00：
  begin

    coeff_tmp1＝in_ar_tmp；

    sum_tmp0＝store_tmp；
   end
 2′b01：
  begin

    coeff_tmp1＝br_tmp；

    sum_tmp0＝{wordlength-1{1′b0}}；

   end
 2′b10：
  begin

    coeff_tmp1＝in_ai_tmp；

    sum_tmp0＝store_tmp；

   end
 2′b11：
				
				
 begin

   coeff_tmp1＝in_ar_tmp；

   sum_tmp0＝store_tmp；
  end
 endcase
 abri_tmp3＝{{wordlength{abri_tmp2[wordlength-1]}}，abri_tmp2}；∥extnd
 coeff_tmp2＝{{wordlength{coeff_tmp1[wordlength-1]}}，coeff_tmp 1}；∥extnd
 mpy_tmp2＝(abri_tmp3*coeff_tmp2)；
 mpy_tmp1＝mpy_tmp2[wordlength*2-mult_scale：wordlength-(mult_scale-1)]；
 if(c4)
   {ex_reg1，sum_tmp2}＝sum_tmp0-mpy_tmp1-mpy_tmp2[wordlength-mult_scale]；
 else
   {ex_reg1，sum_tmp2}      ＝    mpy_tmp1       +     sum_tmp0          +
mpy_tmp2[wordlength-mult_scale]；
  ovf_tmp1＝(c4^mpy_tmp1[wordlength-1])&& ∥Overflow check.

    sum_tmp0[wordlength-1]&&   ∥Deals with a

    ～sum_tmp2[wordlength-1]||∥+/-input.

    ～(c4^mpy_tmp1[wordlength-1])&&

    ～sum_tmp0[wordlength-1]&&

    sum_tmp2[wordlength-1]；
  if(ovf_tmp1)          ∥Saturate logic.

    sum_tmp1＝(ex_reg1)？{1′b1，{wordlength-1{1′b0}}}：

       {1′b0，{wordlength-1{1′b1}}}；
  else

    sum_tmp1＝sum_tmp2；
 end
 ∥Pipeline registers for I/Q data paths and intermediate registers.
 always @(posedge clk)
  begin

    if(enable_2)∥Enable on 2nd clock.

    acc_tmp＜＝sum_tmp1；         ∥Temp store.

    if(enable_3)∥Enable on 3rd clock.

    cr_tmp＜＝acc_tmp；         ∥Pipeline reg cr

    if(enable_3)∥Enable on 3rd clock.

    ci_tmp＜＝sum_tmp1；        ∥Pipeline reg ci

    if(enable_1)

  store_tmp＜＝sum_tmp1；        ∥Temp store.

  if(enable_2)

  in_ar_tmp＜＝in_ar；        ∥ Reg i/p to mpy.

  if(enable_1)

  in_ai_tmp＜＝in_ai；       ∥Reg i/p to mpy.

  if(enable_0||enable_1||enable_2)

  abri_tmp2＜＝abri_tmp1；    ∥Pipeline reg.
 end
				
				
∥Register ovf outputs before final OR，else whole complex multiplier is
∥treated as combinational，and the intermediate pipeline reg is ignored.
always @(posedge clk)
∥if(enable_0||enable_1||enable_2)
  ovf_tmp2＜＝ovf_tmp0；
always @(posedge clk)
 ovf_tmp3＜＝ovf_tmp1；
assign out_ovf＝ovf_tmp2||ovf_tmp3；
`ifdef OVERFLOW DEBUG LOW LEVEL
∥Debug code to display overflow output of a particular adder.
∥Concurrently monitor overflow flag and halt on overflow.
always @(posedge clk)
 if(out_ovf)
  begin
   if(ovf_tmp2)$display(″ovf_tmp0 on complex multiplier＝″，ovf_tmp2)；
   if(ovf_tmp3)$display(″ovf_tmp1 on complex multiplier＝″，ovf_tmp3)；
   $stop；
  end
 `else
 `endif
 assign out_cr＝cr_tmp；
 assign out_ci＝ci_tmp；
endmodule

                                  Listing 7

∥Sccsld：％W％ ％G％
/******************************************************************************
   Copyright(c)1997 Pioneer Digital Design Centre Limited
Author：Dawood Alam.
Description：Verilog code for a dual-port FIFO with complex data store.(RTL)
Notes：A variable bitwidth FIFO shift register for intermediate I/Q
   calculations.
******************************************************************************/
`timescale 1ns/100ps
module fft_sr_iq(clk，enable_3，in_xr，in_xi，out_xr，out_xi)；
parameter       wordlength＝1；    ∥Data wordlength I/Q.
parameter       length＝1；    ∥Shift reg length.
input      clk，      ∥Master clock；

     enable_3；     ∥Enable on clock 3.
input[wordlength-1：0]in_xr，    ∥SR input data，I.

   in_xi；     ∥SR input data，Q.
				
				
output[wordlength-1：0]out_xr，     ∥SR output data I.

    out_xi；     ∥SR output data Q.
reg[wordlength-1：0]shift_r[length-1：0]； ∥SR for I data.
reg[wordlength-1：0]shift_i[length-1：0]； ∥SR for Q data/
wire[wordlength-1：0]out_xr，

   out_xi；
wire     clk，

   enable_3；
integer   i；
always @(posedge clk)
 if(enable_3)
 begin

   for(i＝(length-1)；i＞＝0；i＝i-1)

   begin

   if(i＝＝0)

   begin

 shift_r[0]＜＝in_xr；     ∥Force input I to SR.

    shift_i[0]＜＝in_xi；    ∥Force input Q to SR.

  end

 else

  begin

shift_r[i]＜＝shift_r[i-1]；   ∥Shift data I once.

     shift_i[i]＜＝shift_i[i-1]； ∥Shift data Q once.

  end

 end
  end
assign out_xr＝shift_r[length-1]；
assign out_xi＝shift_i[length-1]；
endmodule

                                  Listing 8

∥Sccsld：％W％ ％G％
/******************************************************************************
   Copyright(c)1997 Pioneer Digital Design Centre Limited
Author：Dawood Alam.
Description：Verilog code for 8 hardwired coefficients in a lookup table，of
   which 4 are unique values.
Notes：Used to store complex Twiddle factors. 8 point FFT twiddle factor

   coefficients(Radix 4+2).Coefficients stored as non-fractional

   10 bit integers.Real Coefficient(cosine value)is coefficient

   high-byte.Imaginary Coefficient(sine value)is coefficient

   low-byte.Coefficient addresses are delayed by a pipeline depth

   of5，i.e.equivalent to case table values being advanced by 5.
******************************************************************************/
timescale 1ns/100ps
				
				
module fft_hardwired_lu0(clk，enable_3，address，out_br，out_bi)；
parameter       c_wordlength＝10；  ∥Coeff wordlength.
parameter       rom_AddressSize＝3； ∥Address bus size.
input      clk，

     enable_3；
input[rom_AddressSize-1：0]address；
output[c_wordlength-1：0] out_br，out_bi；
reg[c_wordlength*2-1：0]b_tmp1，

   b_tmp2；
 always @(address)
 case(address)
 3′d6：b_tmp1＝20′b0000000000_1000000000；∥W2_8＝+0.000000-1.000000
 3′d0：b_tmp1＝20′b0101101010_1010010110；∥W1_8＝+0.707107-0.707107
 3′d2：b_tmp1＝20′b1010010110_1010010110；∥W3_8＝-0.707107-0.707107
 default：b_tmp1＝20′b0111111111_0000000000；∥W0_8＝+1.000000 -0.000000
 endcase
always @(posedge clk)
 if(enable_3)
 b_tmp2＜＝b_tmp1；
assign out_br＝b_tmp2[c_wordlength*2-1：c_wordlength]；
assign out_bi＝b_tmp2[c_wordlength-1：0]；
endmodule

                                  Listing 9

∥Sccsld：％W％ ％G％
/*****************************************************************************

Copyright(c)1997 Pioneer Digital Design Centre Limited
Author：Dawood Alam.
Description：Verilog code for 32 hardwired coefficients in a lookup table，of
   which 16 are unique values.
Notes：Used to store complex Twiddle factors. 32 point FFT twiddle
   factor coefficients(Radix 4+2).Coefficients stored as
   non-fractional 10 bit integers.Real Coefficient(cosine value)
   is coefficient high-byte.Imaginary Coefficient(sine value)is
   coefficient low-byte. Coefficient addresses are delayed by a
   pipeline depth of 4，i.e. equivalent to case table values being
   advanced by 4.
******************************************************************************/
`timescale 1ns/100ps
module fft_hardwired_lu1(clk，enable_3，address，out_br，out_bi)；
				
				
parameter     c_wordlength＝10；  ∥Coeff wordlength.
parameter     rom_AddressSize＝5； ∥Address bus size.
input    clk，

   enable_3；
input[rom_AddressSize-1：0]address；
output[c_wordlength-1：0]out_br，out_bi；
reg[c_wordlength*2-1：0]b_tmp1，

   b_tmp2；
always @(address)
case (address)
 5′d5，
 5′d14：b_tmp1＝20′b0111011001_1100111100；∥W02_32＝+0.923880-0.382683
 5′d6，
 5′d16：b_tmp1＝20′b0101101010_1010010110；∥W04_32＝+0.707107-0.707107
 5′d7，
 5′d18，
 5′d22：b_tmp1＝20′b0011000100_1000100111；∥W06_32＝+0.382683-0.923880
 5′d8：b_tmp1＝20′b0000000000_1000000000；∥W08 32＝+0.000000-1.000000
 5′d9：b_tmp1＝20′b1 100111100_1000100111 ；∥W10_32＝-0.382683-0.923880
 5′d10，
 5′d24：b_tmp1＝20′b1010010110_1010010110；∥W12_32＝-0.707107-0.707107
 5′d11：b_tmp1＝20′b1000100111_1100111100；∥W14_32＝-0.923880-0.382683
 5′d13：b_tmp1＝20′b0111110110_1110011100；∥W01_32＝+0.980785-0.195090
 5′d15，
 5′d21：b_tmp1＝20′b0110101010 1011100100；∥W03 32＝+0.831470-0.555570
 5′d17：b_tmp1＝20′b0100011100_1001010110；∥W05_32＝+0.555570-0.831470
 5′d19：b_tmp1＝20′b0001100100_1000001010；∥W07_32＝+0.195090-0.980785
 5′d23：b_tmp1＝20′b1110011100_1000001010；∥W09_32＝-0.195090-0.980785
 5′d25：b_tmp1＝20′b1000001010_1110011100；∥W15_32＝-0.980785-0.195090
 5′d26：b_tmp1＝20′b1000100111_0011000100；∥W18_32＝-0.923880+0.382683
 5′d27：b_tmp1＝20′b1011100100_0110101010；∥W21_32＝-0.555570+0.831470
 default：b_tmp1＝20′b0111111111_0000000000；∥W00_32＝+1.000000-0.000000
 endcase
 always @(posedge clk)
 if(enable_3)
  b_tmp2＜＝b_tmp1；
 assign out_br＝b_tmp2[c_wordlength*2-1：c_wordlength]；
 assign out_bi＝b_tmp2[c_wordlength-1：0]；
endmodule

                                  Listing 10

∥Sccsld：％W％ ％G％
/******************************************************************************

    Copyright(c)1997 Pioneer Digital Design Centre Limited
Author：Dawood Alam.
				
				
Description：Verilog code for 128 hardwired coefficients in a lookup table，
   of which 64 are unique values.
Notes：Used to store complex Twiddle factors.128 point FFT twiddle
   factor coefficients (Radix 4+2). Coefficients stored as
   non-fractional 10 bit integers. Real Coefficient (cosine value)
   is coefficient high-byte. Imaginary Coefficient (sine value) is
   coefficient low-byte. Coefficient addresses are delayed by a
   pipeline depth of 3，i.e. equivalent to case table values being
   advanced by 3.
******************************************************************************/
`timescale 1ns/100ps
module fft_hardwired_lu2(clk，enable_3，address，out_br，out_bi)；
parameter       c_wordlength＝10；   ∥Coeff wordlength.
parameter       rom_AddressSize＝7；  ∥Address bus size.
input      clk，

     enable_3；
input[rom_AddressSize-1：0]address；
output[c_wordlength-1：0]out_br，out_bi；
reg[c_wordlength*2-1：0]b_tmp1，

   b_tmp2；
always @(address)
case(address)
 7′d36：b_tmp1＝20′b0111111111_1111100111； ∥W01_128＝+0.998795-0.049068
 7′d4，
 7′d 37：b_tmp1＝20′b0111111110_1111001110；∥W02_128＝+0.995185-0.098017
 7′d38，
 7′d68：b_tmp1＝20′b0111111010_1110110101；∥W03_128＝+0.989177-0.146730
 7′d5，
 7′d39：b_tmp1＝20′b0111110110_1110011100；∥W04_128＝+0.980785-0.195090
 7′d40：b_tmp1＝20′b0111110001_1110000100；∥W05_128＝+0.970031-0.242980
 7′d6，
 7′d41，
 7′d69：b_tmp1＝20′b0111101010_1101101011；∥W06_128＝+0.956940-0.290285
 7′d42：b_tmp1＝20′b0111100010_1101010100；∥W07_128＝+0.941544-0.336890
 7′d7，
 7′d43：b_tmp1＝20′b0111011001_1100111100；∥W08_128＝+0.923880-0.382683
 7′d44，
 7′d70：b_tmp1＝20′b0111001111_1100100101；∥W09_128＝+0.903989-0.427555
 7′d8，
 7′d45：b_tmp1＝20′b0111000100_1100001111；∥W10_128＝+0.881921-0.471397
 7′d46：b_tmp1＝20′b0110110111_1011111001；∥W11_128＝+0.857729-0.514103
 7′d9，
 7′d47，
 7′d71：b_tmp1＝20′b0110101010_1011100100；∥W12_128＝+0.831470-0.555570
 7′d48：b_tmp1＝20′b0110011011_1011001111；∥W13_128＝+0.803208-0.595699
 7′d10，
				
				
7′d49：b_tmp1＝20′b0110001100_1010111011；∥W14_128＝+0.773010-0.634393
7′d50，
7′d72：b_tmp1＝20′b0101111011_1010101000；∥W15_128＝+0.740951-0.671559
7′d11，
7′d51：b_tmp1＝20′b0101101010_1010010110；∥W16_128＝+0.707107-0.707107
7′d52：b_tmp1＝20′b0101011000_1010000101；∥W17_128＝+0.671559-0.740951
7′d12，
7′d73，
7′d53：b_tmp1＝20′b0101000101_1001110100；∥W18_128＝+0.634393-0.773010
7′d54：b_tmp1＝20′b0100110001_1001100101；∥W19_128＝+0.595699-0.803208
7′d13，
7′d55：b_tmp1＝20′b0100011100_1001010110；∥W20_128＝+0.555570-0.831470
7′d74，
7′d56：b_tmp1＝20′b0100000111_1001001001；∥W21_128＝+0.514103-0.857729
7′d14，
7′d57：b_tmp1＝20′b0011110001_1000111100；∥W22_128＝+0.471397-0.881921
7′d58：b_tmp1＝20′b0011011011_1000110001；∥W23_128＝+0.427555-0.903989
7′d15，
7′d75，
7′d59：b_tmp1＝20′b0011000100_1000100111；∥W24_128＝+0.382683-0.923880
7′d60：b_tmp1＝20′b0010101100_1000011110；∥W25_128＝+0.336890-0.941544
7′d16，
7′d61：b_tmp1＝20′b0010010101_1000010110；∥W26_128＝+0.290285-0.956940
7′d76，
7′d62：b_tmp1＝20′b0001111100_1000001111；∥W27_128＝+0.242980-0.970031
7′d17，
7′d63：b_tmp1＝20′b0001100100_1000001010；∥W28_128＝+0.195090-0.980785
7′d64：b_tmp1＝20′b0001001011_1000000110；∥W29_128＝+0.146730-0.989177
7′d18，
7′d77，
7′d65：b_tmp1＝20′b0000110010_1000000010；∥W30_128＝+0.098017-0.995185
7′d66：b_tmp1＝20′b0000011001_1000000001；∥W31_128＝+0.049068-0.998795
7′d19：b_tmp1＝20′b0000000000_1000000000；∥W32_128＝+0.000000-1.000000
7′d78：b_tmp1＝20′b1111100111_1000000001；∥W33_128＝-0.049068-0.998795
7′d20：b_tmp1＝20′b1111001110_1000000010；∥W34_128＝-0.098017-0.995185
7′d79，
7′d21：b_tmp1＝20′b1110011100_1000001010；∥W36_128＝-0.195090-0.980785
7′d22：b_tmp1＝20′b1101101011_1000010110；∥W38_128＝-0.290285-0.956940
7′d80：b_tmp1＝20′b1101010100_1000011110；∥W39_128＝-0.336890-0.941544
7′d23：b_tmp1＝20′b1100111100_1000100111；∥W40_128＝-0.382683-0.923880
7′d81，
7′d24：b_tmp1＝20′b1100001111_1000111100；∥W42_128＝-0.471397-0.881921
7′d25：b_tmp1＝20′b1011100100_1001010110；∥W44_128＝-0.555570-0.831470
7′d82：b_tmp1＝20′b1011001111_1001100101；∥W45_128＝-0.595699-0.803208
7′d26：b_tmp1＝20′b1010111011_1001110100；∥W46_128＝-0.634393-0.773010
7′d83，
7′d27：b_tmp1＝20′b1010010110-1010010110；∥W48_128＝-0.707107-0.707107
7′d28：b_tmp1＝20′b1001110100_1010111011；∥W50_128＝-0.773010-0.634393
7′d84：b_tmp1＝20′b1001100101_1011001111；∥W51_128＝-0.803208-0.595699
7′d29：b_tmp1＝20′b1001010110_1011100100；∥W52_128＝-0.831470-0.555570
7′d85，
7′d30：b_tmp1＝20′b1000111100_1100001111；∥W54_128＝-0.881921-0.471397
7′d31：b_tmp1＝20′b1000100111_1100111100；∥W56_128＝-0.923880-0.382683
7′d86：b_tmp1＝20′b1000011110_1101010100；∥W57_128＝-0.941544-0.336890
7′d32：b_tmp1＝20′b1000010110_1101101011；∥W58_128＝-0.956940-0.290285
7′d87，
				
				
7′d33：b_tmp1＝20′b1000001010-1110011100；∥W60-128＝-0.980785-0.195090
7′d34：b_tmp1＝20′b1000000010_1111001110；∥W62_128＝-0.995185-0.098017
7′d88：b_tmp1＝20′b1000000001_1111100111；∥W63_128＝-0.998795-0.049068
7′d89：b_tmp1＝20′b1000000010_0000110010；∥W66_128＝-0.995185+0.098017
7′dg0：b_tmp1＝20′b1000001111_0001111100；∥W69_128＝-0.970031+0.242980
7′d91：b_tmp1＝20′b1000100111_0011000100；∥W72_128＝-0.923880+0.382683
7′d92：b_tmp1＝20′b1001001001_0100000111；∥W75_128＝-0.857729+0.514103
7′d93：b_tmp1＝20′b1001110100_0101000101；∥W78_128＝-0.773010+0.634393
7′d94：b_tmp1＝20′b1010101000_0101111011；∥W81_128＝-0.671559+0.740951
7′d95：b_tmp1＝20′b1011100100_0110101010；∥W84_128＝-0.555570+0.831470
7′d96：b_tmp1＝20′b1100100101_0111001111；∥W87_128＝-0.427555+0.903989
7′d97：b_tmp1＝20′b1101101011_0111101010；∥W90_128＝-0.290285+0.956940
7′d98：b_tmp1＝20′b1110110101_0111111010；∥W93_128＝-0.146730+0.989177
default：b_tmp1＝20′b0111111111_0000000000；∥W00_128＝+1.000000-0.000000
endcase
always @(posedge clk)
 if(enable_3)
  b_tmp2＜＝b_tmp1；
 assign out_br＝b_tmp2[c_wordlength*2-1：c_wordlength]；
 assign out_bi＝b_tmp2[c_wordlength-1：0]；
endmodule

                                  Listing 11

∥Sccsld：％W％ ％G％
/******************************************************************************

    Copyright(c)1997 Pioneer Digital Design Centre Limited
Author：Dawood Alam.
Description：Verilog code for a lookup table decoder.
Notes：Used to generate addresses for each coefficient，based on the
   in Address. Addresses are dependent on one of 4 rows
   (see figures)and on the sequence length (rom_AddressSize).Each
   row gives rise to a unique address sequence based on an
   algorithm. N refers to the index of the twiddle factor，NOT the

 absolute address. Breakpoints determine where inc values change
   on line 2.
******************************************************************************/
`timescale 1ns/100ps
module fft_coeff_dcd(clk，enable_3，in_address，out_address，nrst)；
parameter        rom_AddressSize＝1； ∥Twice ROM address.
parameter        break_point2＝1；  ∥2nd break pt line 2
parameter        break_point3＝1；  ∥3rd break pt line 2
input [rom_AddressSize-1：0]in_address；
input       clk，
     nrst，
				
				
        enable_3；
output[rom_AddressSize-2：0]out_address；
wire[rom_AddressSize-2：0]out_address；
wire[1：0]  line_number；
wire      nrst；
reg[rom_AddressSize-2：0]out_address_tmp；
reg[1：0]  inc，count；
reg      rst；
∥Decode which of the 4 lines are being addressed and assign it a line no.
∥Only need upper two bits of in address since 4 lines in sequence length.
assign line_number＝{in_address[rom_AddressSize-1]，

   in_address[rom_AddressSize-2]}；
∥Check for end of line and force out_address to zero on next clock edge.
always @(in_address)
 if(in_address[rom_AddressSize-3：0]＝＝{rom_AddressSize-2{1′b1}})
 rst＝0；
 else
  rst＝1；
∥Check for line number and decode appropriate out_address using algorithm
∥derived by studying coefficient tables for mpys M0，M1 and M2.
always @(line_number or in_address or count)
case(line_number)
∥----------------------------------------------------------------
2′d0：∥LINE 0，inc by 2，then run the inc sequence 1，1，2，1，1，2...
begin
  if(in_address[rom_AddressSize-3]&(|in_address[rom_AddressSize-4：0]))

  begin

  if(count＝＝2′d1|count＝＝2′d0)

   inc＝2′d1；

  else

   inc＝2′d2；

  end
 else

  inc＝2′d2；
end
∥-----------------------------------------------------------------------------------------
2′d1：∥LlNE 1，inc by 1.
inc＝1：
∥--------------------------------------------------------------------------------------------------
2′d2：∥LINE 2 inc by 3，(inc by 2 at N/4+1)，(inc by 1 at N/2-1).
begin   if(in_address[rom_AddressSize-3：0]＞＝break_point3)
   inc＝2′d1；       ∥Third stage，inc by 1.
   else if(in_address[rom_AddressSize-3：0]＞＝break_point2)

　　inc＝2′d2；       ∥Second stage，inc by 2.
   else

    inc＝2′d3；       ∥First stage，inc by 3.
end
∥--------------------------------------------------------------------------------------------------------------------
2′d3：∥LINE 3，fixed at address 0.
				
				
inc＝2′d0；
∥----------------------------------------------------------------
endcase
always @(posedge clk)
if(enable_3)
begin
 if(！nrst||！rst)  ∥out_address＝0 at end of line or pwr Reset.
   out_address_tmp＜＝0；
 else
   out_address_tmp＜＝out_address_tmp+inc；
 ∥Only count if at the correct point on line 2.
 if(in_address[rom_AddressSize-3]&(|in_address[rom_AddressSize-4：0]))

　　count＜＝((count＝＝2′d2)？2′d0：count+2′d1)；∥Only count to 2.
 else

   count＜＝2′d0；
 end
assign out_address＝out_address_tmp；
endmodule

                             Listing 12

∥Sccsld：％W％ ％G％
/*****************************************************************************
   Copyright(c)1997 Pioneer Digital Design Centre Limited
Author：Dawood Alam.
Description：Verilog code for a configurable 2K/8K radix 2^2+2，

　　singlepath-delay-feedback，decimation in frequency，

　　(r22+2sdf DIF) Fast Fourier Transform (FFT) processor.(RTL)
Notes：This FFT processor computes one pair of I/Q data points every 4

　　fast clk cycles. A synchronous active-low reset flushes the

　　  entire pipeline and resets the FFT. Therefore the next pair of

　　  valid inputs are assumed to be the start of the active interval

　　  of the next symbol. There is a latency of 2048/8192 sample

　　  points+7slow clock cycles. This equates to (2048/8192+7)*4

　　  fast clk cycles. When the out_ovf flag is raised an overflow has

　　  occured and saturation is performed on the intermediate

　　  calculation upon which the overflow has occured. If the valid_in

　　flag is held low，the entire pipeline is halted and the

　　valid out_flag is also held low. valid out is also held low

　　until the entire pipeline is full(after the above number of

　　clock cycles).

　　To Do：RAM control(MUX)，

　　  ROM lookup(quadrant lookup)，

　　    Change BF code for unique saturation nets for synthesis.

　　  ovf_detection(correct)register o/p

　　     ovf_detection(correct)for mpy and BFs

　　   ROM/RAM test stuff.
******************************************************************************/
				
				
`timescale 1ns/100ps
module fft_r22sdf   (in_xr，

　　     in_xi

　　     clk，

　　     nrst，

　　        in_2k8k，

　　        valid_in，

　　     out_xr，

　　      out_xi，

　　       out_ovf，

　　     enable_0，

　　       enable_1，

　　       enable_2，

　　       enable_3，

　　        valid_out，

　　       ram_address，

　　       ram_enable，

　　       address_rom3，
　　       address_rom4，

　　      z2r_4，z2i_4， ∥RAM input ports.

　　         z2r_5，z2i_5，∥Output data from this

　　         z2r_6，z2i_6，∥module.

　　         z2r_7，z2i_7，

　　         z2r_8，z2i_8，

　　         z2r_9，z2i_9，

　　         z2r_10 z2i_10，

　　         x1r_4 x1i_4 ，   ∥RAM output ports.

　　         x1r_5，x1i_5，   ∥Input data to this

　　         x1r_6，x1i_6，   ∥module.

　　         x1r_7，x1i_7，

　　         x1r_8，x1i_8，

　　         x1r_9，x1i_9，

　　         x1r_10 x1i_10，

　　         br_3，bi_3，

　　         br_4，bi_4)；
∥----------------------------------------------------------------
∥    Parameter definitions.
∥----------------------------------------------------------------
parameter    wordlength＝12；  ∥Data wordlength.
parameter    c_wordlength＝10；  ∥Coeff wordlength.
parameter    AddressSize＝13；  ∥Size of address bus.
parameter    rom_AddressSize＝13； ∥ROM address bus size.
parameter    mult_scale＝3；∥Multiplier scalling：

　　         ∥1＝/4096，2＝/2048，

　　         ∥3＝/1024，4＝/512.
parameter    s12_wdlength＝11； ∥Sectn 12 wordlength.
parameter    s11_wdlength＝12； ∥Sectn 11 wordlength.

　　          ∥s11＞＝s12＞＝wordlen
∥-----------------------------------------------
∥    Input/Output ports.
∥-----------------------------------------------
				
				
input     clk，     ∥Master clock.

　　   nrst，     ∥Power-up reset.

　　     in_2k8k，    ∥2K mode active low.

　　     valid_in；   ∥Input data valid.
input[9：0]  in_xr，    ∥FFT input data，I.

　　     in_xi；  ∥FFT input data， Q.
input [wordlength-1：0]x1r_4，x1i_4， ∥RAM output ports.

　　     x1r_5，x1i_5，

　　       x1r_6，x1i_6，

　　       x1r_7，x1i_7，

　　       x1r_8，x1i_8，

　　       x1r_9，x1i_9，

　　       x1r_10 x1i_10；
input[c_wordlength-1：0]br_3，bi_3，

　　    br_4，bi_4；
output      out_ovf，    ∥Overflow flag.

　　     enable_0，    ∥Enable clock 0.

　　     enable_1，    ∥Enable clock 1.

　　     enable_2，    ∥Enable clock 2.

　　     enable_3，    ∥Enable clock 3.

　　      valid_out，   ∥Output data valid.

　　      ram_enable；
output[wordlength-1：0]out_xr，   ∥FFT output data，I.

　　     out_xi；     ∥FFT output data，Q.
output[wordlength-1：0]z2r_4，z2i_4，   ∥RAM input ports.

　　        z2r_5，z2i_5，

　　        z2r_6，z2i_6，

　　      z2r_7，z2i_7，

　　　      z2r_8，z2i_8，
　　        z2r_9，z2i_9，

 　　     z2r_10，z2i_10；
output[rom_AddressSize-6：0]address_rom3；
output[rom_AddressSize-4：0]address_rom4；
output[AddressSize-1：0]ram_address；
∥----------------------------------------------------------------
∥      Wire/register declarations.
∥----------------------------------------------------------------
wire[1：0]     control；  ∥clk decode.
wire[AddressSize-1：0] address，    ∥FFT main address bus.

　　   s，     ∥Pipeline SRs to BFs.

　　     ram_address；    ∥RAM address bus.
wire[wordlength-1：0]x1r_0，x1i_0，∥Couples the I/Q data

　　     x1r_1，x1i_1，∥outputs from the

　　     x1r_2，x1i_2，∥memory to the

　　     x1r_3，x1i_3，∥respective butterfly

　　     x1r_4，x1i_4，∥processors，via an
				
				
　　    x1r_5，x1i_5，   ∥input register.

　　      x1r_6，x1i_6，

　　      x1r_7，x1i_7，

　　      x1r_8，x1i_8，

　　      x1r_9，x1i_9，

　　      x1r_10，x1i_10，

　　     x2r_0，x2i_0，  ∥Couples the I/Q data

　　       x2r_1，x2i_1， ∥outputs from BF2I

　　       x2r_2，x2i_2， ∥to the I/Q inputs of

　　       x2r_3，x2i_3， ∥BF2II. Also connects

　　     x2r_4，x2i_4，  ∥the I/Q ouputs of the

　　     x2r_5，x2i_5，  ∥complex multiplier

　　     x2r_6，x2i_6，  ∥to the inputs of the

　　     x2r_7，x2i_7，  ∥next radix 2^2 stage.

　　       x2r_8，x2i_8，

　　       x2r_9，x2i_9，

　　       x2r_10，x2i_10；
reg[wordlength-1：0]x1r_4_tmp，x1i_4_tmp，∥Registered inputs

　　     x1r_5_tmp，x1i_5_tmp，∥from RAM.

　　       x1r_6_tmp，x1i_6_tmp，

　　       x1r_7_tmp，x1i_7_tmp，

　　       x1r_8_tmp，x1i_8_tmp，

　　       x1r_9_tmp，x1i_9_tmp，

　　       x1r_10_tmp，x1i_10_tmp；
wire[s11_wdlength-1：0]x1r_11，x1i_11，   ∥Different bit-widths

　　   x2r_11，x2i_11；   ∥for I/Q lines，but
wire[s12_wdlength-1：0]x1r_12，x1i_12；    /similar to the above.
wire[wordlength-1：0]ar_0，ai_0， ∥Couples the I/Q data

　　   ar_1，ai_1，    ∥outputs of the

　　     ar_2，ai_2，    ∥previous radix 2^2

　　     ar_3，ai_3，    ∥stage into the

　　   ar_4，ai_4，    ∥complex multiplier

　　     ar_5，ai_5；   ∥of the next stage.
wire[c_wordlength-1：0]br_0，bi_0，    ∥Couples the I/Q

　　      br_1，bi_1， ∥coefficient outputs

　　        br_2，bi_2， ∥from the ROM demapper

　　        br_3，bi_3， ∥to the complex

　　      br_4，bi_4， ∥multiplier.

　　        br_5，bi_5；
wire[wordlength-1：0]z2r_0，z2i_0，

　　   z2r_1，z2i_1，

　　     z2r_2，z2i_2，

　　   z2r_3，z2i_3；
reg[wordlength-1：0]z2r_4，z2i_4，   ∥Registered outputs

　　   z2r_5，z2i_5， ∥to RAM.

　　     z2r_6，z2i_6，

　　   z2r_7，z2i_7，

　　     z2r_8，z2i_8，

　　     z2r_9，z2i_9；
				
				
wire[wordlength-1：0]z2r_10，z2i_10； ∥WILL CHANGE WHEN RAM RIGHT 2 rg
wire[wordlength-1：0]z2r_4_tmp，z2i_4_tmp， ∥Couple the I/Q data

　　   z2r_5_tmp， z2i_5_tmp， ∥outputs of each BF

　　     z2r_6_tmp， z2i_6_tmp， ∥processor to their

　　   z2r_7_tmp，z2i_7_tmp， ∥respective memory

　　     z2r_8_tmp，z2i_8_tmp， ∥inputs via an output

　　     z2r_9_tmp，z2i_9_tmp， ∥register.

　　   z2r_10_tmp，z2i_10_tmp；
wire[s11_wdlength-1：0]z2r_11，z2i_11；   ∥ Different bit-widths
wire[s12_wdlength-1：0]z2r_12，z2i_12；   ∥for the 1st 2 stages.
wire[rom_AddressSize-8：0]address_rom2；     ∥Couples the address
wire[rom_AddressSize-6：0]address_rom3；     ∥decoders outputs to
wire[rom_AddressSize-4：0]address_rom4；     ∥respective ROMs.
wire[rom_AddressSize-2：0]address_rom5；
wire[rom_AddressSize-7：0]dcd_address2；     ∥Couples part of the
wire[rom_AddressSize-5：0]dcd_address3；     ∥address bus to the
wire[rom_AddressSize-3：0]dcd_address4；     ∥coefficient decoder.
wire[rom_AddressSize-1：0]dcd_address5；
wire     ovf_0，ovf_1，  ∥Couples overflow

　　   ovf_2，ovf_3， ∥flag outputs from

　　     ovf_4，ovf_5，   ∥each butterfly

　　     ovf_6，ovf_7，   ∥processor and complex

　　     ovf_8，ovf_9，   ∥multiplier into one

　　     ovf_10，ovf_11，   ∥overflow status flag

　　     ovf_12，ovf_13，   ∥called ″out_ovf″.

　　     ovf_14，ovf_15，

　　     ovf_16，ovf_17，

　　     ovf_18；
wire      clk，

　　    nrst，

　　      in_2k8k，

　　    ovf_2k，

　　     out_ovf，

　　     enable_0，

　　     enable_1，

　　     enable_2，

　　     enable_3，

　　   ram_enable；    ∥RAM enable signal.
 reg     ovf_tmp1，

　　   ovf_tmp2，

　　   fft_cycle_complete，  ∥End of 1st FFT cycle.

　　      output_valid；  ∥Output valid flag.
 reg[3：0]   pipeline_count； ∥Counts pipeline regs.
 reg[AddressSize-1：0]q，t；
 reg[1：0]   r；
 reg[wordlength-1：0]x1r_0_reg，x1i_0_reg，

　　     xr_tmp2，    ∥Output data reg，I.

　　       xi_tmp2；  ∥Output data reg，Q.
 reg[s12_wdlength-1：0] in_xr_tmp，in_xi_tmp；
				
				
reg[9：0]    xr_reg，     ∥Input data reg，I.

　　    xi_reg；     ∥Input data reg，Q.
re9[wordlength-1：0]x2r_10_tmp2，x2i_10_tmp2，

　　   x2r_10_tmp3，x2i_10_tmp3；
wire[wordlength-1：0]xr_tmp1， ∥Final BF2I(0) out，I.

　　   xi_tmp1；     ∥Final BF2I(0) out，Q.
wire[wordlength-1：0]x2r_10_tmp1，x2i_10_tmp1；
wire[s12_wdlength-1：0]x2r_11_tmp，x2i_11_tmp；
∥----------------------------------------------------------------
∥ Address decoders/Quadrant mappers+pipeline shift registers.
∥----------------------------------------------------------------
/* fft_sr_addr #(rom_AddressSize-6，3)sr_addr_2

　　          (clk，enable_3，

　　          address[6：0]，∥Input.

　　          dcd_address2)； ∥Output.
fft_coeff_dcd #(rom_AddressSize-6，11，21)
coeff_dcd_2(clk，enable_3，dcd_address2，address_rom2，nrst)；*/
∥-------------------------------------------------
fft_sr_addr #(rom_AddressSize-4，2) sr_addr_3

　　        (clk，enable_3，

　　         address[8：0]，∥Input.

　　         dcd_address3)；∥Output.
fft_coeff_dcd #(rom_AddressSize-4，43，85)
coeff_dcd_3(clk，enable_3，dcd_address3，address_rom3，nrst)；
∥-------------------------------------------------
fft_sr_addr #(rom_AddressSize-2，1)sr_addr_4

　　        (clk，enable_3，

　　        address[10：0]，∥Input.

　　        dcd_address4)；∥Output.
fft_coeff_dcd #(rom_AddressSize-2，171，341)
coeff_dcd_4(clk，enable_3，dcd_address4，address_rom4，nrst)；
∥-------------------------------------------------
/*fft_coeff_dcd #(rom_AddressSize，683，1365)
coeff_dcd_5(clk，enable_3，address，address_rom5，nrst)；*/
∥-------------------------------------------------
∥        ROM lookup tables.
∥-------------------------------------------------
fft_hardwired_lu0 #(c_wordlength，rom_AddressSize-10)∥Case table instance
rom0(clk，enable_3，address[2：0]，br_0，bi_0)；∥for a hardwired ROM.
fft_hardwired_lu1 #(c_wordlength，rom_AddressSize-8)∥Case table instance
rom1(clk，enable_3，address[4：0]，br_1，bi_1)；∥for a hardwired ROM.
				
				
fft_hardwired_lu2 #(c_wordlength，rom_AddressSize-6) ∥Case table instance
rom2(clk，enable_3，address[6：0]，br_2，bi_2)； ∥for a hardwired ROM.
/*fft_hardwired_lu3 #(c_wordlength，rom_AddressSize-4)∥Case table instance
rom3(clk，enable_3，address[8：0]，br_3，bi_3)； ∥for a hardwired ROM.*/
/*fft_hardwired_lu3 #(c_wordlength，rom_AddressSize-5)∥Case table instance
rom3(clk，enable_3，address_rom3，br_3，bi_3)； ∥for a hardwired ROM.*/
/*fft_rom #(c_wordlength，rom_AddressSize-6，
   ″../../../fft/src/lookup_tables/lu_10bit_128pt_scale1″)
 rom2(address[6：0]，br_2，bi_2)； ∥128 addresses x 20 bits，no decode. */
/*fft_rom #(c_wordlength，rom_AddressSize-7，
   ″../../../fft/src/lookup_tables/lu_10bit_128pt_scale1″)
 rom2(address_rom2，br_2，bi_2)； ∥64 addresses x 20 bits，coeff decode. */
/*fft_rom #(c_wordlength，rom_AddressSize-4，
   ″../../../fft/src/lookup_tables/lu_10bit_512pt_scale1″)
 rom3(address[8：0]，br_3，bi_3)； ∥512 addresses x 20 bits，no decode. */
/* fft_rom #(c_wordlength，rom_AddressSize-5，
   ″../../../fft/src/lookup_tables/lu_10bit_512pt_scale1″)
rom3(clk，enable_3，address_rom3，br_3，bi_3)； ∥256 addresses x 20 bits.*/
/*fft_rom #(c_wordlength，rom_AddressSize-2，
   ″../../../fft/src/lookup_tables/lu_10bit_2048pt_scale1″)
rom4(address[10：0]，br_4，bi_4)； ∥2048 addresses x 20 bits，no decode.*/
/* fft_rom #(c_wordlength，rom_AddressSize-3，

　　 ″../../../fft/src/lookup_ta bles/lu_10bit_2048pt_scale1″)
rom4(clk，enable_3，address_rom4，br_4，bi_4)； ∥1024 addresses x 20 bits.*/
/*fft_rom #(c_wordlength，rom_AddressSize，
   ″../../../fft/src/lookup_tables/lu_10bit_8192pt_scale1″)
rom5(address，br_5，bi_5)；∥8192 addresses x 20 bits，no decode. */
/* fft_rom #(c_wordlength，rom_AddressSize-1，

　　 ″../../../fft/src/lookup_tables/lu_10bit_8192pt_scale1″)
rom5(clk，enable_3，address_rom5，br_5，bi_5)； ∥4096 addresses x 20 bits.*/
∥---------------------------------------------------
∥ Section 12 and 11，tail end of FFT pipeline(input stage).
∥Section 12 is 11 bits wide and incorporates the 2K/8K control logic.
∥---------------------------------------------------
always @(xr_reg or xi_reg or in_2k8k or x2r_10_tmp1 or x2i_10_tmp1

　　        or x2r_10_tmp3 or x2i_10_tmp3)
if(！in_2k8k)∥Configuring for 2K mode.
 begin

　　x2r_10_tmp2＝x2r_10_tmp3；

　　x2i_10_tmp2＝x2i_10_tmp3；

　　in_xr_tmp＝0；

　　in_xi_tmp＝0；
 end
else    ∥Configuring for 8K mode.
				
				
 begin
   x2r_10_tmp2＝x2r_10_tmp1；
   x2i_10_tmp2＝x2i_10_tmp1；
   ∥Sign extend from 10 bits，as section 12 is s12_wdlength bits.
   in_xr_tmp＝{{(s12_wdlength-9){xr_reg[9]}}，xr_reg[8：0]}；
   in_xi_tmp＝{{(s12_wdlength-9){xi_reg[9]}}，xi_reg[8：0]}；
 end
always @(posedge clk) ∥Pipeline register to enable correct operation in
 if(enable_3)  ∥2K mode without retiming the entire pipeline since
  begin   ∥8K mode introduces 1 additional pipeline register.

　　∥Sign extend 10 bit inputs to wordlength bit inputs.

　　∥for bypass lines into stage 5.

　　x2r_10_tmp3＜＝{{(wordlength-9){xr_reg[9]}}，xr_reg[8：0]}；

　　x2i_10_tmp3＜＝{{(wodlength-9){xi_reg[9]}}，xi_reg[8：0]}；
  end
assign x2r_10＝x2r_10_tmp2；
assign x2i_10＝x2i_10_tmp2；
∥Sign extend from s12_wdlength bits to s11_wdlength bits between
∥sections 12 and 11.Uncomment below ifs 11＜＞s 12.
assign x2r_11＝{{(s11_wdlength-s12_wdlength+1)

　　 {x2r_11_tmp[s12_wdlength-1]}}，x2r_11_tmp[s12_wdlength-2：0]}；
assign x2i_11＝{{(s11_wdlength-s12_wdlength+1)

　　  {x2i_11_tmp[s12_wdlength-1]}}，x2i_11_tmp[s12_wdlength-2：0]}；
∥Uncomment below if s_11＝s_12.
/* assign x2r_11＝x2r_11_tmp；
assign x2i_11＝x2i_11_tmp；*/
fft_bf2I #(s12_wdlength)bf2I_6

　　     (clk，enable_1，

　　       x1r_12，x1i_12，in_xr_tmp，in_xi_tmp， ∥Ext In.

　　     s[12]，

　　     x2r_11_tmp，x2i_11_tmp，z2r_12，z2i_12，∥Outputs.

　　     ovf_18)；
/* fft_ram #(s12_wdlength，12) ram_12(clk，enable_1，enable_3，

　　         ram_address[11：0]，  ∥4096 addrs.

　　         z2r_12，z2i_12，   ∥Inputs.

　　         x1r_12，x1i_12)；   ∥Outputs.*/
 fft_bf2II #(s11_wdlength)bf2II_6

　　       (clk，enable_1，

　　         x1r_11，x1i_11，x2r_11，x2i_11，  ∥Inputs.

　　       s[11]，s[12]，

　　       ar_5，ai_5，z2r_11，z2i_11，   ∥Outputs.

　　       ovf_17)；
 fft_sr_1bit#(1)sr_1bit_11(clk，enable_3，address[11]， s[11])；∥SR 11.
 fft_sr_1bit #(1)sr_1bit_12(clk，enable_3，address[12]，s[12])；∥SR 12.
/* fft_ram #(s11_wdlength，11)ram_11(clk，enable_1，enable_3，

　　         ram_address[10：0]，∥2048 addrs.

　　         z2r_11，z2i_11， ∥Inputs.

　　         x1r_11，x1i_11)；∥Outputs. */
				
				
∥---------------------------------------------------
∥      Section 10 and 9.
∥---------------------------------------------------
fft_complex_mult_mux #(wordlength，c_wordlength，mult_scale) m5
　　   (clk，control，

　　       ar_5，ai_5，br_5，bi_5，∥Inputs.

　　   x2r_10_tmp1，x2i_10_tmp1，   ∥Outputs.

　　   ovf_16)；
fft_bf2I #(wordlength)bf2I_5(clk，enable_1，

　　       x1r_10，x1i_10，∥Inputs.

　　        x2r_10，x2i_10，

　　       s[10]，

　　       x2r_9，x2i_9，  ∥Outputs.

　　        z2r_10，z2i_10，

　　       ovf_15)；
fft_bf2II #(wordlength) bf2II_5(clk，enable_1，

　　       x1r_9_tmp，x1i_9_tmp，    ∥Inputs.

　　         x2r_9，x2i_9，

　　       s[9]，s[10]，

　　       ar_4，ai_4，    ∥Outputs.

　　        z2r_9_tmp，z2i_9_tmp，

　　       ovf_14)；
fft_sr_1bit #(2)sr_1bit_9(clk，enable_3，address[9]，s[9])；∥SR 9.
fft_sr_1bit #(2)sr_1bit_10(clk，enable_3，address[10]，s[10])；∥SR 10.
∥---------------------------------------------------
∥          Section 8 and 7.
∥---------------------------------------------------
fft_complex_mult_mux #(wordlength，c_wordlength，mult_scale)m4

　　   (clk，control，

　　       ar_4，ai_4，br_4，bi_4，∥Inputs.

　　    x2r_8，x2i_8，      ∥Outputs.

　　    ovf_13)；
fft_bf2I #(wordlength)bf2I_4(clk，enable_1，

　　      x1r_8_tmp，x1i_8_tmp，  ∥Inputs.

　　        x2r_8，x2i_8，

　　      s[8]，

　　      x2r_7，x2i_7，    ∥Outputs.

　　        z2r_8_tmp，z2i_8_tmp，

　　      ovf_12)；
fft_bf2II #(wordlength)bf2II_4(clk，enable_1，

　　       x1r_7_tmp，x1i_7_tmp，   ∥Inputs.

　　        x2r_7，x2i_7，

　　       s[7]，s[8]，

　　       ar_3，ai_3，     ∥Outputs.

　　        z2r_7_tmp，z2i_7_tmp，

　　       ovf_11)；
				
				
fft_sr_1bit #(3)sr_1bit_7(clk，enable_3，address[7]，s[7])；∥SR 7.
fft_sr_1bit #(3)sr_1bit_8(clk，enable_3，address[8]，s[8])； ∥SR 8.
∥--------------------------------------------------
∥          Section 6 and 5.
∥--------------------------------------------------
fft_complex_mult_mux #(wordlength，c_wordlength，mult_scale) m3

　　   (clk，control，

　　     ar_3，ai_3，br_3，bi_3，∥Inputs.

　　     x2r_6，x2i_6，      ∥Outputs.

　　     ovf_10)；
fft_bf2I #(wordlength)bf2I_3(clk，enable_1，

　　       x1r_6_tmp，x1i_6_tmp，  ∥Inputs.

　　         x2r_6，x2i_6，

　　       s[6]，

　　       x2r_5，x2i_5，   ∥Outputs.

　　         z2r_6_tmp，z2i_6_tmp，

　　       ovf_9)；
fft_bf2II #(wordlength)bf2II_3(clk，enable_1，

　　       x1r_5_tmp，x1i_5_tmp，   ∥Inputs.

　　         x2r_5，x2i_5，

　　       s[5]，s[6]，

　　       ar_2，ai_2，    ∥Outputs.

　　         z2r_5_tmp，z2i_5_tmp，

　　       ovf_8)；
 fft_sr_1bit #(4)sr_1bit_5(clk，enable_3，address[5]， s[5])；∥SR 5.
 fft_sr_1bit #(4)sr_1bit_6(clk，enable_3，address[6]，s[6])；∥SR 6.
 ∥--------------------------------------------------
 ∥          Section 4 and 3.
 ∥--------------------------------------------------
 fft_complex_mult_mux #(wordlength，c_wordlength，mult_scale) m2

　　    (clk，control，

　　        ar_2，ai_2，br_2，bi_2，  ∥Inputs.

　　    x2r_4，x2i_4，        ∥Outputs.

　　    ovf_7)；
 fft_bf2I #(wordlength)bf2I_2(clk，enable_1，

　　       x1r_4_tmp，x1i_4_tmp， ∥Inputs.

　　         x2r_4，x2i_4，

　　       s[4]，

　　       x2r_3，x2i_3，  ∥Outputs.

　　         z2r_4_tmp，z2i_4_tmp，

　　       ovf_6)；
 fft_bf2II #(wordlength)bf2II_2(clk，enable_1，

　　        x1r_3，x1i_3，    ∥Inputs.

　　         x2r_3，x2i_3，

　　        s[3]，s[4]，

　　        ar_1，ai_1，     ∥Outputs.
				
				
　　        z2r_3，z2i_3，

　　    ovf_5)；
fft_sr_1bit #(5)sr_1bit_3(clk，enable_3，address[3]，s[3])；∥SR 3.
fft_sr_1bit #(5)sr_1bit_4(clk，enable_3，address[4]，s[4])；∥SR 4.
fft_sr_iq #(wordlength，8)sr_iq_3(clk，enable_3，  ∥Length＝8.

　　        z2r_3，z2i_3，  ∥Inputs.

　　        x1r_3，x1i_3)； ∥Outputs.
∥--------------------------------------------------
∥        Section 2 and 1.
∥--------------------------------------------------
fft_complex_mult_mux #(wordlength，c_wordlength，mult_scale)m1

　　   (clk，control，

　　       ar_1，ai_1，br_1，bi_1，∥Inputs.

　　   x2r_2，x2i_2，       ∥Outputs.

　　   ovf_4)；
fft_bf2I #(wordlength)bf2I_1(clk，enable_1，

　　       x1r_2，x1i_2，  ∥Inputs.

　　         x2r_2，x2i_2，

　　       s[2]，

　　       x2r_1，x2i_1，  ∥Outputs.

　　         z2r_2，z2i_2，

　　       ovf_3)；
fft_sr_iq #(wordlength，4)sr_iq_2(clk，enable_3，  ∥Length＝4.

　　        z2r_2，z2i_2，  ∥Inputs.

　　        x1r_2，x1i_2)； ∥Outputs.
fft_bf2II #(wordlength)bf2II_1(clk，enable_1，

　　      x1r_1，x1i_1，    ∥Inputs.

　　        x2r_1，x2i_1，

　　      s[1]，s[2]，

　　      ar_0，ai_0，    ∥Outputs.

　　        z2r_1，z2i_1，

　　      ovf_2)；
assign s[1]＝～address[1]；∥Invert s[1](see count sequence)，SR1 not req.
∥fft_sr_1bit #(6)sr_1bit_1(clk，enable_3，address[1]，s[1])；∥SR 1.
fft_sr_1bit #(6)sr_1bit_2(clk，enable_3，address[2]，s[2])；∥SR 2.
fft_sr_iq #(wordlength，2)sr_iq_1(clk，enable_3，  ∥Length＝2.

　　        z2r_1，z2i_1，  ∥Inputs.

　　        x1r_1，x1i_1)； ∥Outputs.
∥--------------------------------------------------
∥  Section 0，front end of FFT pipeline(output stage)，mult_scale＝4.
∥--------------------------------------------------
fft_complex_mult_mux #(wordlength，c_wordlength，4)m0

　　   (clk，control，

　　       ar_0，ai_0，br_0，bi_0，∥Inputs.

　　   x2r_0，x2i_0，        ∥Outputs.
				
				
　　   ovf_1)；
fft_bf2I #(wordlength)bf2I_0(clk，enable_1，

　　      x1r_0，x1i_0，    ∥Inputs.

　　        x2r_0，x2i_0，

　　      s[0]，

　　      xr_tmp1，xi_tmp1，   ∥Outputs.

　　       z2r_0，z2i_0，

　　      ovf_0)；
assign s[0]＝～address[0]； ∥Invert s[0](see count sequence)， SR0 not req.
∥fft_sr_1bit #(7)sr_1bit_0(clk，enable_3，address[0]，s[0])；∥SR 0.
∥ Last stage should be just a single register as only 1 location needed.
always @(posedge clk)∥No reset required as data clocked through registers.
 if(enable_3)
  begin

　　x1r_0_reg＜＝z2r_0；

　　x1i_0_reg＜＝z2i_0；
  end
assign x1r 0＝x1r_0_reg；
assign x1i_0＝x1i_0_reg；
∥--------------------------------------------------
∥       Register Inputs/Outputs.
∥--------------------------------------------------
`ifdef BIN SHIFT
always @(posedge clk)   ∥Registered inputs.
 if(enable_3&&！address[0]) ∥＝＝freq bin shift by pi.
  begin

　　xr_reg＜＝in_xr；

　　xi_reg＜＝in_xi；
  end
 else if (enable_3 && address[0])∥＝＝freq bin shift by pi.
  begin

　　xr_reg＜＝～in_xr+1′b1； ∥This is equivalent to multiplying by

　　xi_reg＜＝～in_xi+1′b1； ∥exp(-j* pi * n)＝＝(-1)^n.
  end
`else
always @(posedge clk)        ∥Registered inputs.
 if(enable_3)
  begin

　　xr_reg＜＝in_xr；

　　xi_reg＜＝in_xi；
  end
`endif
always @(posedge clk)   ∥Registered outputs.
 if(enable_3)
  begin

　　xr_tmp2＜＝xr_tmp1；

　　xi_tmp2＜＝xi_tmp1；
  end
				
				
assign out_xr＝xr_tmp2；
assign out_xi＝xi_tmp2；
always @(posedge clk)   ∥RAMs are latched on outputs so no
 begin       ∥need to enable.
  z2r_4＜＝z2r_4_tmp； ∥ Register FFT outputs to RAM.
  z2i_4＜＝z2i_4_tmp；
  z2r_5＜＝z2r_5_tmp；
  z2i_5＜＝z2i_5_tmp；
  z2r_6＜＝z2r_6_tmp；
  z2i_6＜＝z2i_6_tmp；
  z2r_7＜＝z2r_7_tmp；
  z2i_7＜＝z2i_7_tmp；
  z2r_8＜＝z2r_8_tmp；
  z2i_8＜＝z2i_8_tmp；
  z2r_9＜＝z2r_9_tmp；
  z2i_9＜＝z2i_9_tmp；
∥ z2r_10＜＝z2r_10_tmp；
∥ z2i_10＜＝z2i_10_tmp；
   x1r_4_tmp＜＝x1r_4；  ∥Register FFT inputs from RAM.
   x1i_4_tmp＜＝x1i_4；
   x1r_5_tmp＜＝x1r_5；
   x1i_5_tmp＜＝x1i_5；
   x1r_6_tmp＜＝x1r_6；
   x1i_6_tmp＜＝x1i_6；
   x1r_7_tmp＜＝x1r_7；
   x1i_7_tmp＜＝x1i_7；
   x1r_8_tmp＜＝x1r_8；
   x1i_8_tmp＜＝x1i_8；
   x1r_9_tmp＜＝x1r_9；
   x1i_9_tmp＜＝x1i_9；
 ∥ x1r_10_tmp＜＝x1r_10；
 ∥ x1i_10_tmp＜＝x1i_10；
   end
∥--------------------------------------------------
∥       Synchronous butterfly controller.
∥--------------------------------------------------
always @(posedge clk)
if(！nrst)      ∥Synchronous power-up reset.
 q＜＝0；
else if(enable_3)
 q＜＝q+1′b1；
assign address＝q；
∥--------------------------------------------------
∥    Synchronous RAM address generator.
∥--------------------------------------------------
always @(posedge clk)
if (！nrst)     ∥Synchronous power-up reset.
 t＜＝0；
else if(enable_2)
				
				
 t＜＝t+1′b1；
assign ram_address＝t；
assign ram_enable＝enable_3||enable_2；  ∥ram enable signal.
∥--------------------------------------------------
∥      valid_out status flag generation.
∥--------------------------------------------------
always @(posedge clk)
if(！nrst)
 fft_cycle_complete＜＝1′b0； ∥Detect end of 1st fft cycle i.e. 2K or 8K.
else if((～in_2k8k && &address[10：0])||(in_2k8k && &address[12：0]))
 fft_cycle_complete＜＝1′b1；
else
 fft_cycle_complete＜＝fft_cycle_complete；
always @(posedge clk)   ∥Account for pipeline and I/O registers.
 if(！nrst)
 pipeline_count＜＝4′b0； ∥Stop at pipeline_depth-1.
 else if(enable_3 && fft_cycle_complete & pipeline_count＜8)∥pipe depth＝8
 pipeline_count＜＝pipeline_count+1′b1；
always @(posedge clk)     ∥Test if the pipeline is full and the input
 if(！nrst)  ∥is valid before asserting valid_out.
  output_valid＜＝1′b0；
 else if (enable_2 && pipeline_count[3])
  output_valid＜＝1′b1；
 else
  output_valid＜＝1′b0；
assign valid_out＝output_valid；
∥--------------------------------------------------
∥   Fast 40 MHz clock decoder and valid_in control.
∥--------------------------------------------------
always @(posedge clk)
if(！nrst)       ∥Synchronous power-up reset.
 r＜＝0；
else if (valid_in)    ∥Count if input data valid.
 r＜＝r+1′b1；
assign control＝{valid_in & r[1]，valid_in & r[0]}；
assign enable_0＝valid_in & (～r[1] & ～r[0])； ∥Gate valid_in with
assign enable_1＝valid_in & (～r[1] & r[0])； ∥decoded enable signals
assign enable_2＝valid_in & (r[1] & ～r[0])； ∥to control all reg′s.
assign enable_3＝valid_in & (r[1] & r[0])；
∥--------------------------------------------------
∥Overflow detection，OR oveflows from each stage to give oveflow flag.
∥--------------------------------------------------
assign ovf_2k＝ovf_0||ovf_1||ovf_2||ovf_3||ovf_4||

　　ovf_5||ovf_6||ovf_7||ovf_8||ovf_9||
				
			
　　     ovf_10||ovf_11||ovf_12||ovf_13||ovf_14||

　　  ovf_15；
∥2k/8k Overflow flag configuration.
always @(in_2k8k or ovf_16 or ovf_17 or ovf_18 or ovf_2k)
 if(in_2k8k)
 ovf_tmp1＝ovf_2k||ovf_16||ovf_17||ovf_18；
 else
 ovf_tmp1＝ovf_2k；
always @(posedge clk)           ∥Register overflow
 if(enable_3 && fft_cycle_complete)   ∥ flag to change when
 ovf_tmp2＜＝ovf_tmp1；        ∥I/Q samples are valid

　　           ∥from FFT processor.
assign out_ovf＝ovf_tmp2；
`ifdef OVERFLOW DEBUG
∥Debug code to display overflow output of a particular instance.
∥Concurrently monitor overflow flag and halt on overflow.
always @(out_ovf)∥ovf_x wires are all registered at lower level.
 if(out_ovf)
 begin

　　$display(″Overflow has occurred，type.to continue.″)；

　　$display(″Overflow flag，out ovf＝″，out_ovf)；

　　if(ovf_18)$display(″Overflow on port ovf_18″)；

　　if(ovf_17)$display(″Overflow on port ovf_17″)；

　　if(ovf_16)$display(″Overflow on port ovf_16″)；

　　if(ovf_15)$display(″Overflow on port ovf_15″)；

　　if(ovf_14)$display(″Overflow on port ovf_14″)；

　　if(ovf_13)$display(″Overflow on port ovf_13″)；

　　if(ovf_12)$display(″Overflow on port ovf_12″)；

　　if(ovf_11)$display(″Overflow on port ovf_11″)；

　　if(ovf_10)$display(″Overflow on port ovf_10″)；

　　if(ovf_9)$display(″Overflow on port ovf_9″)；

　　if(ovf_8)$display(″Overflow on port ovf_8″)；

　　if(ovf_7)$display(″Overflow on port ovf_7″)；

　　if(ovf_6)$display(″Overflow on port ovf_6″)；

　　if(ovf_5)$display(″Overflow on port ovf_5″)；

　　if(ovf_4)$display(″Overflow on port ovf_4″)；

　　if(ovf_3)$display(″Overflow on port ovf_3″)；

　　if(ovf_2)$display(″Overflow on port ovf_2″)；

　　if(ovf_1)$display(″Overflow on port ovf_1″)；

　　if(ovf_0)$display(″Overflow on port ovf_0″)；

　　$stop；
 end
`endif
endmodule

                                  Listing 13

∥Sccsld：％W％ ％G％    
/******************************************************************************

　　Copyright(c)1997 Pioneer Digital Design Centre Limited
 Author：Dawood Alam.
Description：Verilog code for the window lookup table，used to determine the
				
				
　　variance of the data and hence the F_ratio.
Notes：
******************************************************************************/
`timescale 1ns/100ps
module fft_window_lu(clk，enable_3，in_address，out_data)；
parameter      r_wordlength＝10；   ∥Data wordlength.
parameter      lu_AddressSize＝13； ∥Address bus size.
input     clk，

　　   enable_3；
input[lu_AddressSize-1：0] in_address；
output[r_wordlength-1：0] out_data；
 reg[r_wordlength-1：0]data_tmp1，

　　    data_tmp2；
 always @(in_address)
 casez (in_address)
13′b0000000000000：data_tmp1＝10′b1000000000；
13′b0000000000001：data_tmp1＝10′b0000000000；
13′b0000000000010：data_tmp1＝10′b0000100111；
13′b0000000000011：data_tmp1＝10′b0000111110；
13′b0000000000100：data_tmp1＝10′b0001001110；
13′b0000000000101：data_tmp1＝10′b0001011011；
13′b0000000000110：data_tmp1＝10′b0001100110；
13′b0000000000111：data_tmp1＝10′b0001101110；
13′b0000000001000：data_tmp1＝10′b0001110110；
13′b0000000001001：data_tmp1＝10′b0001111101；
13′b0000000001010：data_tmp1＝10′b0010000011；
13′b0000000001011：data_tmp1＝10′b0010001000；
13′b0000000001100：data_tmp1＝10′b0010001101；
13′b0000000001101：data_tmp1＝10′b0010010001；
13′b0000000001110：data_tmp1＝10′b0010010110；
13′b0000000001111：data_tmp1＝10′b0010011010；
				
				
13′b0000000010000：data_tmp1＝10′b0010011101；
13′b0000000010001：data_tmp1＝10′b0010100001；
13′b0000000010010：data_tmp1＝10′b0010100100；
13′b0000000010011：data_tmp1＝10′b0010100111；
13′b0000000010100：data_tmp1＝10′b0010101010；
13′b0000000010101：data_tmp1＝10′b0010101101；
13′b0000000010110：data_tmp1＝10′b0010101111；
13′b0000000010111：data_tmp1＝10′b0010110010；
13′b0000000011000：data_tmp1＝10′b0010110100；
13′b0000000011001：data_tmp1＝10′b0010110111；
13′b0000000011010：data_tmp1＝10′b0010111001；
13′b0000000011011：data_tmp1＝10′b0010111011；
13′b0000000011100：data_tmp1＝10′b0010111101；
13′b0000000011101：data_tmp1＝10′b0010111111；
13′b0000000011110：data_tmp1＝10′b0011000001；
13′b0000000011111：data_tmp1＝10′b0011000011；
13′b0000000100000：data_tmp1＝10′b0011000101；
13′b0000000100001：data_tmp1＝10′b0011000110；
13′b0000000100010：data_tmp1＝10′b0011001000；
13′b0000000100011：data_tmp1＝10′b0011001010；
13′b0000000100100：data_tmp1＝10′b0011001011；
13′b0000000100101：data_tmp1＝10′b0011001101；
13′b0000000100110：data_tmp1＝10′b0011001110；
13′b0000000100111：data_tmp1＝10′b0011010000；
13′b0000000101000：data_tmp1＝10′b0011010001；
13′b0000000101001：data_tmp1＝10′b0011010011；
13′b0000000101010：data_tmp1＝10′b0011010100；
13′b0000000101011：data_tmp1＝10′b0011010101；
				
				
13′b0000000101100：data_tmp1＝10′b0011010111；
13′b0000000101101：data_tmp1＝10′b0011011000；
13′b0000000101110：data_tmp1＝10′b0011011001；
13′b0000000101111：data_tmp1＝10′b0011011010；
13′b0000000110000：data_tmp1＝10′b0011011100；
13′b0000000110001：data_tmp1＝10′b0011011101；
13′b0000000110010：data_tmp1＝10′b0011011110；
13′b0000000110011：data_tmp1＝10′b0011011111；
13′b0000000110100：data_tmp1＝10′b0011100000；
13′b0000000110101：data_tmp1＝10′b0011100001；
13′b0000000110110：data_tmp1＝10′b0011100010；
13′b0000000110111：data_tmp1＝10′b0011100011；
13′b0000000111000：data_tmp1＝10′b0011100100；
13′b0000000111001：data_tmp1＝10′b0011100101；
13′b0000000111010：data_tmp1＝10′b0011100110；
13′b0000000111011：data_tmp1＝10′b0011100111；
13′b0000000111100：data_tmp1＝10′b0011101000；
13′b0000000111101：data_tmp1＝10′b0011101001；
13′b0000000111110：data_tmp1＝10′b0011101010；
13′b0000000111111：data_tmp1＝10′b0011101011；
13′b0000001000000：data_tmp1＝10′b0011101100；
13′b0000001000001：data_tmp1＝10′b0011101101；
13′b0000001000010：data_tmp1＝10′b0011101110；
13′b0000001000011：data_tmp1＝10′b0011101111；
13′b0000001000100：data_tmp1＝10′b0011101111；
13′b0000001000101：data_tmp1＝10′b0011110000；
13′b0000001000110：data_tmp1＝10′b0011110001；
13′b0000001000111：data_tmp1＝10′b0011110010；
13′b000000100100z：data_tmp1＝10′b0011110011；
				
				
13′b0000001001010：data_tmp1＝10′b0011110100；
13′b0000001001011：data_tmp1＝10′b0011110101；
13′b000000100110z：data_tmp1＝10′b0011110110；
13′b0000001001110：data_tmp1＝10′b0011110111；
13′b0000001001111：data_tmp1＝10′b0011111000；
13′b000000101000z：data_tmp1＝10′b0011111001；
13′b0000001010010：data_tmp1＝10′b0011111010；
13′b0000001010011：data_tmp1＝10′b0011111011；
13′b0000001010100：data_tmp1＝10′b0011111011；
13′b0000001010101：data_tmp1＝10′b0011111100；
13′b000000101011z：data_tmp1＝10′b0011111101；
13′b0000001011000：data_tmp1＝10′b0011111110；
13′b0000001011001：data_tmp1＝10′b0011111111；
13′b0000001011010：data_tmp1＝10′b0011111111；
13′b0000001011011：data_tmp1＝10′b0100000000；
13′b000000101110z：data_tmp1＝10′b0100000001；
13′b000000101111z：data_tmp1＝10′b0100000010；
13′b0000001100000：data_tmp1＝10′b0100000011；
13′b0000001100001：data_tmp1＝10′b0100000100；
13′b0000001100010：data_tmp1＝10′b0100000100；
13′b0000001100011：data_tmp1＝10′b0100000101；
13′b0000001100100：data_tmp1＝10′b0100000101；
13′b0000001100101：data_tmp1＝10′b0100000110；
13′b0000001100110：data_tmp1＝10′b0100000110；
13′b0000001100111：data_tmp1＝10′b0100000111；
13′b000000110100z：data_tmp1＝10′b0100001000；
13′b000000110101z：data_tmp1＝10′b0100001001；
13′b000000110110z：data_tmp1＝10′b0100001010；
13′b000000110111z：data_tmp1＝10′b0100001011；
13′b000000111000z：data_tmp1＝10′b0100001100；
13′b000000111001z：data_tmp1＝10′b0100001101；
				
				
13′b000000111010z：data_tmp1＝10′b0100001110；
13′b000000111011z：data_tmp1＝10′b0100001111；
13′b000000111100z：data_tmp1＝10′b0100010000；
13′b000000111101z：data_tmp1＝10′b0100010001；
13′b000000111110z：data_tmp1＝10′b0100010010；
13′b0000001111110：data_tmp1＝10′b0100010010；
13′b0000001111111：data_tmp1＝10′b0100010011；
13′b0000010000000：data_tmp1＝10′b0100010011；
13′b0000010000001：data_tmp1＝10′b0100010100；
13′b0000010000010：data_tmp1＝10′b0100010100；
13′b0000010000011：data_tmp1＝10′b0100010101；
13′b0000010000100：data_tmp1＝10′b0100010101；
13′b00000100001z1：data_tmp1＝10′b0100010110；
13′b0000010000110：data_tmp1＝10′b0100010110；
13′b000001000100z：data_tmp1＝10′b0100010111；
13′b000001000101z：data_tmp1＝10′b0100011000；
13′b0000010001100：data_tmp1＝10′b0100011000；
13′b0000010001101：data_tmp1＝10′b0100011001；
13′b0000010001110：data_tmp1＝10′b0100011001；
13′b0000010001111：data_tmp1＝10′b0100011010；
13′b000001001000z：data_tmp1＝10′b0100011010；
13′b000001001001z：data_tmp1＝10′b0100011011；
13′b000001001010z：data_tmp1＝10′b0100011100；
13′b0000010010110：data_tmp1＝10′b0100011100；
13′b0000010010111：data_tmp1＝10′b0100011101；
13′b000001001100z：data_tmp1＝10′b0100011101
13′b000001001101z：data_tmp1＝10′b0100011110
13′b000001001110z：data_tmp1＝10′b0100011111
13′b0000010011110：data_tmp1＝10′b0100011111
13′b0000010011111：data_tmp1＝10′b0100100000
13′b000001010000z：data_tmp1＝10′b0100100000
13′b000001010001z：data_tmp1＝10′b0100100001
13′b0000010100100：data_tmp1＝10′b0100100001
13′b00000101001z1：data_tmp1＝10′b0100100010；
13′b0000010100110：data_tmp1＝10′b0100100010；
				
				
13′b000001010100z：data_tmp1＝10′b0100100011；
13′b0000010101010：data_tmp1＝10′b0100100011；
13′b0000010101011：data_tmp1＝10′b0100100100；
13′b000001010110z：data_tmp1＝10′b0100100100；
13′b000001010111z：data_tmp1＝10′b0100100101；
13′b0000010110000：data_tmp1＝10′b0100100101；
13′b00000101100z1：data_tmp1＝10′b0100100110；
13′b0000010110010：data_tmp1＝10′b0100100110；
13′b000001011010z：data_tmp1＝10′b0100100111；
13′b0000010110110：data_tmp1＝10′b0100100111；
13′b0000010110111：data_tmp1＝10′b0100101000；
13′b000001011100z：data_tmp1＝10′b0100101000；
13′b000001011101z：data_tmp1＝10′b0100101001；
13′b000001011110z：data_tmp1＝10′b0100101001；
13′b000001011111z：data_tmp1＝10′b0100101010；
13′b0000011000000：data_tmp1＝10′b0100101010；
13′b00000110000z1：data_tmp1＝10′b0100101011；
13′b0000011000010：data_tmp1＝10′b0100101011；
13′b00000110001zz：data_tmp1＝10′b0100101100；
13′b000001100100z：data_tmp1＝10′b0100101101；
13′b0000011001010：data_tmp1＝10′b0100101101；
13′b0000011001011：data_tmp1＝10′b0100101110；
13′b000001100110z：data_tmp1＝10′b0100101110；
13′b0000011001110：data_tmp1＝10′b0100101110；
13′b0000011001111：data_tmp1＝10′b0100101111；
13′b000001101000z：data_tmp1＝10′b0100101111；
13′b0000011010010：data_tmp1＝10′b0100101111；
13′b0000011010011：data_tmp1＝10′b0100110000；
13′b000001101010z：data_tmp1＝10′b0100110000；
13′b000001101011z：data_tmp1＝10′b0100110001；
13′b000001101100z：data_tmp1＝10′b0100110001；
13′b000001101101z：data_tmp1＝10′b0100110010；
13′b000001101110z：data_tmp1＝10′b0100110010；
13′b000001101111z：data_tmp1＝10′b0100110011；
13′b000001110000z：data_tmp1＝10′b0100110011；
13′b000001110001z：data_tmp1＝10′b0100110100；
13′b000001110010z：data_tmp1＝10′b0100110100；
13′b000001110011z：data_tmp1＝10′b0100110101；
				
				
13′b000001110100z：data_tmp1＝10′b0100110101；
13′b000001110101z：data_tmp1＝10′b0100110110；
13′b000001110110z：data_tmp1＝10′b0100110110；
13′b000001110111z：data_tmp1＝10′b0100110111；
13′b000001111000z：data_tmp1＝10′b0100110111；
13′b000001111001z：data_tmp1＝10′b0100111000；
13′b000001111010z：data_tmp1＝10′b0100111000；
13′b0000011110110：data_tmp1＝10′b0100111000；
13′b0000011110111：data_tmp1＝10′b0100111001；
13′b000001111100z：data_tmp1＝10′b0100111001；
13′b0000011111010：data_tmp1＝10′b0100111001；
13′b0000011111011：data_tmp1＝10′b0100111010；
13′b000001111110z：data_tmp1＝10′b0100111010；
13′b0000011111110：data_tmp1＝10′b0100111010；
13′b0000011111111：data_tmp1＝10′b0100111011；
13′b00001000000zz：data_tmp1＝10′b0100111011；
13′b00001000001zz：data_tmp1＝10′b0100111100；
13′b0000100001000：data_tmp1＝10′b0100111100；
13′b00001000010z1：data_tmp1＝10′b0100111101；
13′b0000100001010：data_tmp1＝10′b0100111101；
13′b0000100001100：data_tmp1＝10′b0100111101；
13′b00001000011z1：data_tmp1＝10′b0100111110；
13′b0000100001110：data_tmp1＝10′b0100111110；
13′b000010001000z：data_tmp1＝10′b0100111110；
13′b000010001001z：data_tmp1＝10′b0100111111；
13′b000010001010z：data_tmp1＝10′b0100111111；
13′b0000100010110：data_tmp1＝10′b0100111111；
13′b0000100010111：data_tmp1＝10′b0101000000；
13′b00001000110zz：data_tmp1＝10′b0101000000；
13′b00001000111zz：data_tmp1＝10′b0101000001；
13′b0000100100000：data_tmp1＝10′b0101000001；
13′b00001001000z1：data_tmp1＝10′b0101000010；
13′b0000100100010：data_tmp1＝10′b0101000010；
13′b000010010010z：data_tmp1＝10′b0101000010；
13′b000010010011z：data_tmp1＝10′b0101000011；
13′b000010010100z：data_tmp1＝10′b0101000011；
13′b0000100101010：data_tmp1＝10′b0101000011；
13′b0000100101z11：data_tmp1＝10′b0101000100；
13′b000010010110z：data_tmp1＝10′b0101000100；
13′b0000100101110：data_tmp1＝10′b0101000100；
13′b0000100110000：data_tmp1＝10′b0101000100；
				
				
13′b00001001100z1：data_tmp1＝10′b0101000101；
13′b0000100110010：data_tmp1＝10′b0101000101；
13′b000010011010z：data_tmp1＝10′b0101000101；
13′b000010011011z：data_tmp1＝10′b0101000110；
13′b000010011100z：data_tmp1＝10′b0101000110；
13′b0000100111010：data_tmp1＝10′b0101000110；
13′b0000100111z11：data_tmp1＝10′b0101000111；
13′b000010011110z：data_tmp1＝10′b0101000111；
13′b0000100111110：data_tmp1＝10′b0101000111；
13′b0000101000000：data_tmp1＝10′b0101000111；
13′b00001010000z1：data_tmp1＝10′b0101001000；
13′b0000101000z10：data_tmp1＝10′b0101001000；
13′b000010100010z：data_tmp1＝10′b0101001000；
13′b0000101000111：data_tmp1＝10′b0101001001；
13′b00001010010zz：data_tmp1＝10′b0101001001；
13′b0000101001100：data_tmp1＝10′b0101001001；
13′b00001010011z1：data_tmp1＝10′b0101001010；
13′b0000101001110：data_tmp1＝10′b0101001010；
13′b000010101000z：data_tmp1＝10′b0101001010；
13′b0000101010z1z：data_tmp1＝10′b0101001011；
13′b000010101010z：data_tmp1＝10′b0101001011；
13′b00001010110zz：data_tmp1＝10′b0101001100；
13′b000010101110z：data_tmp1＝10′b0101001100；
13′b0000101011110：data_tmp1＝10′b0101001100；
13′b0000101011111：data_tmp1＝10′b0101001101；
13′b00001011000zz：data_tmp1＝10′b0101001101；
13′b0000101100100：data_tmp1＝10′b0101001101；
13′b00001011001z1：data_tmp1＝10′b0101001110；
13′b0000101100110：data_tmp1＝10′b0101001110；
13′b000010110100z：data_tmp1＝10′b0101001110；
13′b0000101101010：data_tmp1＝10′b0101001110；
13′b0000101101z11：data_tmp1＝10′b0101001111；
13′b000010110110z：data_tmp1＝10′b0101001111；
13′b0000101101110：data_tmp1＝10′b0101001111；
13′b0000101110000：data_tmp1＝10′b0101001111；
13′b00001011100z1：data_tmp1＝10′b0101010000；
13′b0000101110z10：data_tmp1＝10′b0101010000；
13′b000010111010z：data_tmp1＝10′b0101010000；
13′b0000101110111：data_tmp1＝10′b0101010000；
13′b00001011110zz：data_tmp1＝10′b0101010001；
13′b000010111110z：data_tmp1＝10′b0101010001；
13′b0000101111110：data_tmp1＝10′b0101010001；
13′b0000101111111：data_tmp1＝10′b0101010010；
				
				
13′b00001100000zz： data_tmp1＝10′b0101010010；
13′b000011000010z： data_tmp1＝10′b0101010010；
13′b000011000011z： data_tmp1＝10′b0101010011；
13′b00001100010zz： data_tmp1＝10′b0101010011；
13′b00001100011zz： data_tmp1＝10′b0101010100；
13′b000011001000z： data_tmp1＝10′b0101010100；
13′b0000110010010： data_tmp1＝10′b0101010100；
13′b0000110010z11： data_tmp1＝10′b0101010101；
13′b000011001010z： data_tmp1＝10′b0101010101；
13′b0000110010110： data_tmp1＝10′b0101010101；
13′b000011001100z： data_tmp1＝10′b0101010101；
13′b0000110011010： data_tmp1＝10′b0101010101；
13′b0000110011z11： data_tmp1＝10′b0101010110；
13′b000011001110z： data_tmp1＝10′b0101010110；
13′b0000110011110： data_tmp1＝10′b0101010110；
13′b000011010000z： data_tmp1＝10′b0101010110；
13′b0000110100z1z： data_tmp1＝10′b0101010111；
13′b000011010010z： data_tmp1＝10′b0101010111；
13′b0000110101000： data_tmp1＝10′b0101010111；
13′b00001101010z1： data_tmp1＝10′b0101011000；
13′b0000110101z10： data_tmp1＝10′b0101011000；
13′b000011010110z： data_tmp1＝10′b0101011000；
13′b0000110101111： data_tmp1＝10′b0101011000；
13′b0000110110000： data_tmp1＝10′b0101011000；
13′b00001101100z1： data_tmp1＝10′b0101011001；
13′b0000110110z10： data_tmp1＝10′b0101011001；
13′b000011011010z： data_tmp1＝10′b0101011001；
13′b0000110110111： data_tmp1＝10′b0101011001；
13′b0000110111000： data_tmp1＝10′b0101011001；
13′b00001101110z1： data_tmp1＝10′b0101011010；
13′b0000110111z10： data_tmp1＝10′b0101011010；
13′b000011011110z： data_tmp1＝10′b0101011010；
13′b0000110111111： data_tmp1＝10′b0101011010；
13′b0000111000zzz： data_tmp1＝10′b0101011011；
13′b0000111001zzz： data_tmp1＝10′b0101011100；
13′b0000111010zzz： data_tmp1＝10′b0101011101；
13′b0000111011000： data_tmp1＝10′b0101011101；
13′b00001110110z1： data_tmp1＝10′b0101011110；
13′b0000111011z10： data_tmp1＝10′b0101011110；
13′b000011101110z： data_tmp1＝10′b0101011110；
13′b0000111011111： data_tmp1＝10′b0101011110；
13′b0000111100000： data_tmp1＝10′b0101011110；
13′b00001111000z1： data_tmp1＝10′b0101011111；
				
				
13′b0000111100z10：data_tmp1＝10′b0101011111；
13′b000011110010z：data_tmp1＝10′b0101011111；
13′b0000111100111：data_tmp1＝10′b0101011111；
13′b000011110100z：data_tmp1＝10′b0101011111；
13′b0000111101z1z：data_tmp1＝10′b0101100000；
13′b000011110110z：data_tmp1＝10′b0101100000；
13′b000011111000z：data_tmp1＝10′b0101100000；
13′b0000111110z1z：data_tmp1＝10′b0101100001；
13′b000011111010z：data_tmp1＝10′b0101100001；
13′b000011111100z：data_tmp1＝10′b0101100001；
13′b0000111111010：data_tmp1＝10′b0101100001；
13′b0000111111z11：data_tmp1＝10′b0101100010；
13′b000011111110z：data_tmp1＝10′b0101100010；
13′b0000111111110：data_tmp1＝10′b0101100010；
13′b00010000000zz：data_tmp1＝10′b0101100010；
13′b00010000001zz：data_tmp1＝10′b0101100011；
13′b00010000010zz：data_tmp1＝10′b0101100011；
13′b0001000001100：data_tmp1＝10′b0101100011；
13′b00010000011z1：data_tmp1＝10′b0101100100；
13′b0001000001110：data_tmp1＝10′b0101100100；
13′b00010000100zz：data_tmp1＝10′b0101100100；
13′b000100001010z：data_tmp1＝10′b0101100100；
13′b0001000010110：data_tmp1＝10′b0101100100；
13′b000100001z111：data_tmp1＝10′b0101100101；
13′b00010000110zz：data_tmp1＝10′b0101100101；
13′b000100001110z：data_tmp1＝10′b0101100101；
13′b0001000011110：data_tmp1＝10′b0101100101；
13′b0001000100zzz：data_tmp1＝10′b0101100110；
13′b000100010100z：data_tmp1＝10′b0101100110；
13′b0001000101z1z：data_tmp1＝10′b0101100111；
13′b000100010110z：data_tmp1＝10′b0101100111；
13′b00010001100zz：data_tmp1＝10′b0101100111；
13′b00010001101zz：data_tmp1＝10′b0101101000；
13′b00010001110zz：data_tmp1＝10′b0101101000；
13′b000100011110z：data_tmp1＝10′b0101101000；
13′b000100011111z：data_tmp1＝10′b0101101001；
13′b0001001000zzz：data_tmp1＝10′b0101101001；
13′b0001001001zzz：data_tmp1＝10′b0101101010；
13′b000100101000z：data_tmp1＝10′b0101101010；
13′b0001001010z1z：data_tmp1＝10′b0101101011；
13′b000100101010z：data_tmp1＝10′b0101101011；
13′b00010010110zz：data_tmp1＝10′b0101101011；
13′b0001001011100：data_tmp1＝10′b0101101011；
				
				
13′b00010010111z1：data_tmp1＝10′b0101101100；
13′b0001001011110：data_tmp1＝10′b0101101100；
13′b00010011000zz：data_tmp1＝10′b0101101100；
13′b000100110010z：data_tmp1＝10′b0101101100；
13′b0001001100110：data_tmp1＝10′b0101101100；
13′b000100110z111：data_tmp1＝10′b0101101101；
13′b00010011010zz：data_tmp1＝10′b0101101101；
13′b000100110110z：data_tmp1＝10′b0101101101；
13′b0001001101110：data_tmp1＝10′b0101101101；
13′b000100111000z：data_tmp1＝10′b0101101101；
13′b0001001110z1z：data_tmp1＝10′b0101101110；
13′b000100111010z：data_tmp1＝10′b0101101110；
13′b00010011110zz：data_tmp1＝10′b0101101110；
13′b0001001111100：data_tmp1＝10′b0101101110；
13′b00010011111z1：data_tmp1＝10′b0101101111；
13′b0001001111110：data_tmp1＝10′b0101101111；
13′b0001010000zzz：data_tmp1＝10′b0101101111；
13′b0001010001000：data_tmp1＝10′b0101101111；
13′b00010100010z1：data_tmp1＝10′b0101110000；
13′b0001010001z10：data_tmp1＝10′b0101110000；
13′b000101000110z：data_tmp1＝10′b0101110000；
13′b0001010001111：data_tmp1＝10′b0101110000；
13′b00010100100zz：data_tmp1＝10′b0101110000；
13′b000101001z1zz：data_tmp1＝10′b0101110001；
13′b00010100110zz：data_tmp1＝10′b0101110001；
13′b0001010100zzz：data_tmp1＝10′b0101110010；
13′b00010101010zz：data_tmp1＝10′b0101110010；
13′b00010101011zz：data_tmp1＝10′b0101110011；
13′b0001010110zzz：data_tmp1＝10′b0101110011；
13′b0001010111zzz：data_tmp1＝10′b0101110100；
13′b00010110000zz：data_tmp1＝10′b0101110100；
13′b000101100z1zz：data_tmp1＝10′b0101110101；
13′b00010110010zz：data_tmp1＝10′b0101110101；
13′b0001011010000：data_tmp1＝10′b0101110101；
13′b00010110100z1：data_tmp1＝10′b0101110110；
13′b0001011010z10：data_tmp1＝10′b0101110110；
13′b000101101z10z：data_tmp1＝10′b0101110110；
13′b0001011010111：data_tmp1＝10′b0101110110；
13′b00010110110zz：data_tmp1＝10′b0101110110；
13′b000101101111z：data_tmp1＝10′b0101110111；
13′b0001011100zzz：data_tmp1＝10′b0101110111；
13′b000101110100z：data_tmp1＝10′b0101110111；
13′b0001011101010：data_tmp1＝10′b0101110111；
13′b0001011101z11：data_tmp1＝10′b0101111000；
				
				
13′b000101110110z：data_tmp1＝10′b0101111000；
13′b0001011101110：data_tmp1＝10′b0101111000；
13′b0001011110zzz：data_tmp1＝10′b0101111000；
13′b0001011111zzz：data_tmp1＝10′b0101111001；
13′b00011000000zz：data_tmp1＝10′b0101111001；
13′b0001100000100：data_tmp1＝10′b0101111001；
13′b00011000001z1：data_tmp1＝10′b0101111010；
13′b000110000z110：data_tmp1＝10′b0101111010；
13′b00011000010zz：data_tmp1＝10′b0101111010；
13′b000110000110z：data_tmp1＝10′b0101111010；
13′b0001100001111：data_tmp1＝10′b0101111010；
13′b000110001000z：data_tmp1＝10′b0101111010；
13′b0001100010010：data_tmp1＝10′b0101111010；
13′b0001100010z11：data_tmp1＝10′b0101111011；
13′b000110001z10z：data_tmp1＝10′b0101111011；
13′b000110001z110：data_tmp1＝10′b0101111011；
13′b00011000110zz：data_tmp1＝10′b0101111011；
13′b0001100011111：data_tmp1＝10′b0101111011；
13′b0001100100000：data_tmp1＝10′b0101111011；
13′b00011001000z1：data_tmp1＝10′b0101111100；
13′b0001100100z10：data_tmp1＝10′b0101111100；
13′b000110010z10z：data_tmp1＝10′b0101111100；
13′b0001100100111：data_tmp1＝10′b0101111100；
13′b00011001010zz：data_tmp1＝10′b0101111100；
13′b0001100101110：data_tmp1＝10′b0101111100；
13′b0001100101111：data_tmp1＝10′b0101111101；
13′b0001100110zzz：data_tmp1＝10′b0101111101；
13′b00011001110zz：data_tmp1＝10′b0101111101；
13′b000110011110z：data_tmp1＝10′b0101111101；
13′b000110011111z：data_tmp1＝10′b0101111110；
13′b0001101000zzz：data_tmp1＝10′b0101111110；
13′b00011010010zz：data_tmp1＝10′b0101111110；
13′b0001101001100：data_tmp1＝10′b0101111110；
13′b00011010011z1：data_tmp1＝10′b0101111111；
13′b0001101001110：data_tmp1＝10′b0101111111；
13′b0001101010zzz：data_tmp1＝10′b0101111111；
13′b00011010110zz：data_tmp1＝10′b0101111111；
13′b00011010111zz：data_tmp1＝10′b0110000000；
13′b0001101100zzz：data_tmp1＝10′b0110000000；
13′b000110110100z：data_tmp1＝10′b0110000000；
13′b0001101101010：data_tmp1＝10′b0110000000；
13′b0001101101z11：data_tmp1＝10′b0110000001；
13′b000110110110z：data_tmp1＝10′b0110000001；
13′b0001101101110：data_tmp1＝10′b0110000001；
13′b0001101110zzz：data_tmp1＝10′b0110000001；
13′b000110111100z：data_tmp1＝10′b0110000001；
				
				
13′b0001101111z1z：data_tmp1＝10′b0110000010；
13′b000110111110z：data_tmp1＝10′b0110000010；
13′b0001110000zzz：data_tmp1＝10′b0110000010；
13′b000111000100z：data_tmp1＝10′b0110000010；
13′b0001110001z1z：data_tmp1＝10′b0110000011；
13′b000111000110z：data_tmp1＝10′b0110000011；
13′b0001110010zzz：data_tmp1＝10′b0110000011；
13′b000111001100z：data_tmp1＝10′b0110000011；
13′b0001110011z1z：data_tmp1＝10′b0110000100；
13′b000111001110z：data_tmp1＝10′b0110000100；
13′b0001110100zzz：data_tmp1＝10′b0110000100；
13′b000111010100z：data_tmp1＝10′b0110000100；
13′b0001110101010：data_tmp1＝10′b0110000100；
13′b0001110101z11：data_tmp1＝10′b0110000101；
13′b000111010110z：data_tmp1＝10′b0110000101；
13′b0001110101110：data_tmp1＝10′b0110000101；
13′b0001110110zzz：data_tmp1＝10′b0110000101；
13′b000111011100z：data_tmp1＝10′b0110000101；
13′b0001110111010：data_tmp1＝10′b0110000101；
13′b0001110111z11：data_tmp1＝10′b0110000110；
13′b000111011110z：data_tmp1＝10′b0110000110；
13′b0001110111110：data_tmp1＝10′b0110000110；
13′b0001111000zzz：data_tmp1＝10′b0110000110；
13′b00011110010zz：data_tmp1＝10′b0110000110；
13′b00011110011zz：data_tmp1＝10′b0110000111；
13′b0001111010zzz：data_tmp1＝10′b0110000111；
13′b00011110110zz：data_tmp1＝10′b0110000111；
13′b0001111011100：data_tmp1＝10′b0110000111；
13′b00011110111z1：data_tmp1＝10′b0110001000；
13′b0001111011110：data_tmp1＝10′b0110001000；
13′b0001111100zzz；data_tmp1＝10′b0110001000；
13′b00011111010zz：data_tmp1＝10′b0110001000；
13′b000111110110z：data_tmp1＝10′b0110001000；
13′b0001111101110：data_tmp1＝10′b0110001000；
13′b00011111z1111：data_tmp1＝10′b0110001001；
13′b0001111110zzz：data_tmp1＝10′b0110001001；
13′b00011111110zz：data_tmp1＝10′b0110001001；
13′b000111111110z：data_tmp1＝10′b0110001001；
13′b0001111111110：data_tmp1＝10′b0110001001；
13′b0010000000000：data_tmp1＝10′b0110001001；
13′b00100000000z1：data_tmp1＝10′b0110001010；
13′b0010000000z10：data_tmp1＝10′b0110001010；
13′b001000000z10z：data_tmp1＝10′b0110001010；
13′b001000000z111：data_tmp1＝10′b0110001010；
13′b00100000010zz：data_tmp1＝10′b0110001010；
13′b0010000001110：data_tmp1＝10′b0110001010；
13′b001000001000z：data_tmp1＝10′b0110001010；
13′b0010000010010：data_tmp1＝10′b0110001010；
				
				
13′b0010000010z11：data_tmp1＝10′b0110001011；
13′b001000001z10z：data_tmp1＝10′b0110001011；
13′b001000001z110：data_tmp1＝10′b0110001011；
13′b00100000110zz：data_tmp1＝10′b0110001011；
13′b0010000011111：data_tmp1＝10′b0110001011；
13′b00100001000zz：data_tmp1＝10′b0110001011；
13′b001000010010z：data_tmp1＝10′b0110001011；
13′b001000010z11z：data_tmp1＝10′b0110001100；
13′b00100001010zz：data_tmp1＝10′b0110001100；
13′b001000010110z：data_tmp1＝10′b0110001100；
13′b0010000110zzz：data_tmp1＝10′b0110001100；
13′b0010000111zzz：data_tmp1＝10′b0110001101；
13′b0010001000zzz：data_tmp1＝10′b0110001101；
13′b00100010010zz：data_tmp1＝10′b0110001101；
13′b00100010011zz：data_tmp1＝10′b0110001110；
13′b0010001010zzz：data_tmp1＝10′b0110001110；
13′b00100010110zz：data_tmp1＝10′b0110001110；
13′b001000101110z：data_tmp1＝10′b0110001110；
13′b0010001011110：data_tmp1＝10′b0110001110；
13′b0010001011111：data_tmp1＝10′b0110001111
13′b001000110zzzz：data_tmp1＝10′b0110001111
13′b001000111000z：data_tmp1＝10′b0110001111；
13′b0010001110010：data_tmp1＝10′b0110001111
13′b0010001110z11：data_tmp1＝10′b0110010000
13′b001000111z10z：data_tmp1＝10′b0110010000
13′b001000111z110：data_tmp1＝10′b0110010000
13′b00100011110zz：data_tmp1＝10′b0110010000
13′b0010001111111：data_tmp1＝10′b0110010000
13′b00100100000zz：data_tmp1＝10′b0110010000
13′b001001000010z：data_tmp1＝10′b0110010000
13′b0010010000110：data_tmp1＝10′b0110010000；
13′b001001000z111：data_tmp1＝10′b0110010001；
13′b00100100z10zz：data_tmp1＝10′b0110010001；
13′b001001000110z：data_tmp1＝10′b0110010001；
13′b0010010001110：data_tmp1＝10′b0110010001；
13′b0010010010zzz：data_tmp1＝10′b0110010001；
13′b00100100111zz：data_tmp1＝10′b0110010010；
13′b001001010zzzz：data_tmp1＝10′b0110010010；
13′b0010010110000：data_tmp1＝10′b0110010010；
13′b00100101100z1：data_tmp1＝10′b0110010011；
13′b0010010110z10：data_tmp1＝10′b0110010011；
13′b001001011z10z：data_tmp1＝10′b0110010011；
13′b001001011z111：data_tmp1＝10′b0110010011；
13′b00100101110zz：data_tmp1＝10′b0110010011；
13′b0010010111110：data_tmp1＝10′b0110010011；
13′b00100110000zz：data_tmp1＝10′b0110010011；
13′b001001100010z：data_tmp1＝10′b0110010011；
				
				
13′b001001100z11z：data_tmp1＝10′b0110010100；
13′b00100110z10zz：data_tmp1＝10′b0110010100；
13′b001001100110z：data_tmp1＝10′b0110010100；
13′b0010011010zzz：data_tmp1＝10′b0110010100；
13′b00100110111zz：data_tmp1＝10′b0110010101；
13′b001001110zzzz：data_tmp1＝10′b0110010101；
13′b001001111000z：data_tmp1＝10′b0110010101；
13′b0010011110z1z：data_tmp1＝10′b0110010110；
13′b001001111z10z：data_tmp1＝10′b0110010110；
13′b00100111110zz：data_tmp1＝10′b0110010110；
13′b001001111111z：data_tmp1＝10′b0110010110；
13′b0010100000zzz：data_tmp1＝10′b0110010110；
13′b0010100001zzz：data_tmp1＝10′b0110010111；
13′b0010100010zzz：data_tmp1＝10′b0110010111；
13′b00101000110zz：data_tmp1＝10′b0110010111；
13′b001010001110z：data_tmp1＝10′b0110010111；
13′b0010100011110：data_tmp1＝10′b0110010111；
13′b0010100011111：data_tmp1＝10′b0110011000；
13′b001010010zzzz：data_tmp1＝10′b0110011000；
13′b00101001100zz：data_tmp1＝10′b0110011000；
13′b001010011010z：data_tmp1＝10′b0110011000；
13′b001010011z11z：data_tmp1＝10′b0110011001；
13′b00101001110zz：data_tmp1＝10′b0110011001；
13′b001010011110z：data_tmp1＝10′b0110011001；
13′b0010101000zzz：data_tmp1＝10′b0110011001；
13′b00101010010zz：data_tmp1＝10′b0110011001；
13′b001010100110z：data_tmp1＝10′b0110011001；
13′b00101010z111z：data_tmp1＝10′b0110011010；
13′b0010101010zzz：data_tmp1＝10′b0110011010；
13′b00101010110zz：data_tmp1＝10′b0110011010；
13′b001010101110z：data_tmp1＝10′b0110011010；
13′b00101011000zz：data_tmp1＝10′b0110011010；
13′b001010110010z：data_tmp1＝10′b0110011010；
13′b001010110z11z：data_tmp1＝10′b0110011011；
13′b00101011z10zz：data_tmp1＝10′b0110011011；
13′b00101011z110z：data_tmp1＝10′b0110011011；
13′b0010101110zzz：data_tmp1＝10′b0110011011；
13′b0010101111110：data_tmp1＝10′b0110011011；
13′b0010101111111：data_tmp1＝10′b0110011100；
13′b001011000zzzz：data_tmp1＝10′b0110011100；
13′b0010110010zzz：data_tmp1＝10′b0110011100；
13′b0010110011zzz：data_tmp1＝10′b0110011101；
13′b001011010zzzz：data_tmp1＝10′b0110011101；
13′b0010110110000：data_tmp1＝10′b0110011101；
13′b00101101100z1：data_tmp1＝10′b0110011110；
13′b0010110110z10：data_tmp1＝10′b0110011110；
				
				
13′b001011011z10z：data_tmp1＝10′b0110011110；
13′b001011011z111：data_tmp1＝10′b0110011110；
13′b00101101110zz：data_tmp1＝10′b0110011110；
13′b0010110111110：data_tmp1＝10′b0110011110；
13′b0010111000zzz：data_tmp1＝10′b0110011110；
13′b001011100100z：data_tmp1＝10′b0110011110；
13′b0010111001010：data_tmp1＝10′b0110011110；
13′b0010111001z11：data_tmp1＝10′b0110011111；
13′b00101110z110z：data_tmp1＝10′b0110011111；
13′b00101110z1110：data_tmp1＝10′b0110011111；
13′b0010111010zzz：data_tmp1＝10′b0110011111；
13′b00101110110zz：data_tmp1＝10′b0110011111；
13′b0010111011111：data_tmp1＝10′b0110011111；
13′b00101111000zz：data_tmp1＝10′b0110011111；
13′b0010111100100：data_tmp1＝10′b0110011111；
13′b00101111001z1：data_tmp1＝10′b0110100000；
13′b001011110z110：data_tmp1＝10′b0110100000；
13′b00101111z10zz：data_tmp1＝10′b0110100000；
13′b00101111z110z：data_tmp1＝10′b0110100000；
13′b00101111z1111：data_tmp1＝10′b0110100000；
13′b0010111110zzz：data_tmp1＝10′b0110100000；
13′b0010111111110：data_tmp1＝10′b0110100000；
13′b001100000zzzz：data_tmp1＝10′b0110100001；
13′b0011000010zzz：data_tmp1＝10′b0110100001；
13′b00110000110zz：data_tmp1＝10′b0110100001；
13′b00110000111zz：data_tmp1＝10′b0110100010；
13′b001100010zzzz：data_tmp1＝10′b0110100010；
13′b00110001100zz：data_tmp1＝10′b0110100010；
13′b001100011010z：data_tmp1＝10′b0110100010；
13′b0011000110110：data_tmp1＝10′b0110100010；
13′b001100011z111：data_tmp1＝10′b0110100011；
13′b00110001110zz：data_tmp1＝10′b0110100011；
13′b001100011110z：data_tmp1＝10′b0110100011；
13′b0011000111110：data_tmp1＝10′b0110100011；
13′b001100100zzzz：data_tmp1＝10′b0110100011；
13′b00110010100zz：data_tmp1＝10′b0110100011；
13′b001100101z1zz：data_tmp1＝10′b0110100100；
13′b00110010110zz：data_tmp1＝10′b0110100100；
13′b001100110zzzz：data_tmp1＝10′b0110100100；
13′b001100111zzzz：data_tmp1＝10′b0110100101；
13′b0011010000zzz：data_tmp1＝10′b0110100101；
13′b00110100010zz：data_tmp1＝10′b0110100101；
13′b001101000110z：data_tmp1＝10′b0110100101；
13′b00110100z111z：data_tmp1＝10′b0110100110；
13′b0011010010zzz：data_tmp1＝10′b0110100110；
13′b00110100110zz：data_tmp1＝10′b0110100110；
13′b001101001110z：data_tmp1＝10′b0110100110；
13′b0011010100zzz：data_tmp1＝10′b0110100110；
				
				
13′b001101010100z：data_tmp1＝10′b0110100110；
13′b0011010101010：data_tmp1＝10′b0110100110；
13′b0011010101z11：data_tmp1＝10′b0110100111；
13′b00110101z110z：data_tmp1＝10′b0110100111；
13′b00110101z1110：data_tmp1＝10′b0110100111；
13′b0011010110zzz：data_tmp1＝10′b0110100111；
13′b00110101110zz：data_tmp1＝10′b0110100111；
13′b0011010111111：data_tmp1＝10′b0110100111；
13′b0011011000zzz：data_tmp1＝10′b0110100111；
13′b001101100100z：data_tmp1＝10′b0110100111；
13′b0011011001z1z：data_tmp1＝10′b0110101000；
13′b00110110z110z：data_tmp1＝10′b0110101000；
13′b0011011010zzz：data_tmp1＝10′b0110101000；
13′b00110110110zz：data_tmp1＝10′b0110101000；
13′b001101101111z：data_tmp1＝10′b0110101000；
13′b0011011100zzz：data_tmp1＝10′b0110101000；
13′b0011011101000：data_tmp1＝10′b0110101000；
13′b00110111010z1：data_tmp1＝10′b0110101001；
13′b0011011101z10：data_tmp1＝10′b0110101001；
13′b00110111z110z：data_tmp1＝10′b0110101001；
13′b00110111z1111：data_tmp1＝10′b0110101001；
13′b0011011110zzz：data_tmp1＝10′b0110101001；
13′b00110111110zz：data_tmp1＝10′b0110101001；
13′b0011011111110：data_tmp1＝10′b0110101001；
13′b0011100000zzz：data_tmp1＝10′b0110101001；
13′b00111000z1zzz：data_tmp1＝10′b0110101010；
13′b0011100010zzz：data_tmp1＝10′b0110101010；
13′b0011100100zzz：data_tmp1＝10′b0110101010；
13′b00111001z1zzz：data_tmp1＝10′b0110101011；
13′b0011100110zzz；data_tmp1＝10′b0110101011；
13′b0011101000zzz：data_tmp1＝10′b0110101011；
13′b00111010z1zzz：data_tmp1＝10′b0110101100；
13′b0011101010zzz：data_tmp1＝10′b0110101100；
13′b0011101100zzz：data_tmp1＝10′b0110101100；
13′b0011101101000：data_tmp1＝10′b0110101100；
13′b00111011010z1：data_tmp1＝10′b0110101101；
13′b0011101101z10：data_tmp1＝10′b0110101101；
13′b00111011z110z：data_tmp1＝10′b0110101101；
13′b00111011z1111：data_tmp1＝10′b0110101101；
13′b0011101110zzz：data_tmp1＝10′b0110101101；
13′b00111011110zz：data_tmp1＝10′b0110101101；
13′b0011101111110：data_tmp1＝10′b0110101101；
13′b0011110000zzz：data_tmp1＝10′b0110101101；
13′b001111000100z：data_tmp1＝10′b0110101101；
13′b0011110001010：data_tmp1＝10′b0110101101；
13′b0011110001z11：data_tmp1＝10′b0110101110；
13′b00111100z110z：data_tmp1＝10′b0110101110；
13′b00111100z1110：data_tmp1＝10′b0110101110；
				
				
13′b0011110010zzz：data_tmp1＝10′b0110101110；
13′b00111100110zz：data_tmp1＝10′b0110101110；
13′b0011110011111：data_tmp1＝10′b0110101110；
13′b0011110100zzz：data_tmp1＝10′b0110101110；
13′b00111101010zz：data_tmp1＝10′b0110101110；
13′b0011110101100：data_tmp1＝10′b0110101110；
13′b00111101011z1：data_tmp1＝10′b0110101111；
13′b00111101z1110：data_tmp1＝10′b0110101111；
13′b0011110110zzz：data_tmp1＝10′b0110101111；
13′b00111101110zz：data_tmp1＝10′b0110101111；
13′b001111011110z：data_tmp1＝10′b0110101111；
13′b0011110111111：data_tmp1＝10′b0110101111；
13′b001111100zzzz：data_tmp1＝10′b0110101111；
13′b001111101zzzz：data_tmp1＝10′b0110110000；
13′b001111110zzzz：data_tmp1＝10′b0110110000；
13′b00111111100zz：data_tmp1＝10′b0110110000；
13′b001111111z1zz：data_tmp1＝10′b0110110001；
13′b00111111110zz：data_tmp1＝10′b0110110001；
13′b010000000zzzz：data_tmp1＝10′b0110110001；
13′b0100000010zzz：data_tmp1＝10′b0110110001；
13′b0100000011zzz：data_tmp1＝10′b0110110010；
13′b010000010zzzz：data_tmp1＝10′b0110110010；
13′b0100000110zzz：data_tmp1＝10′b0110110010；
13′b01000001110zz：data_tmp1＝10′b0110110010；
13′b0100000111100：data_tmp1＝10′b0110110010；
13′b01000001111z1：data_tmp1＝10′b0110110011；
13′b0100000111110：data_tmp1＝10′b0110110011；
13′b01000010zzzzz：data_tmp1＝10′b0110110011；
13′b010000110000z：data_tmp1＝10′b0110110011；
13′b0100001100z1z：data_tmp1＝10′b0110110100；
13′b010000110z10z：data_tmp1＝10′b0110110100；
13′b01000011z10zz：data_tmp1＝10′b0110110100；
13′b01000011z111z：data_tmp1＝10′b0110110100；
13′b0100001110zzz：data_tmp1＝10′b0110110100；
13′b010000111110z：data_tmp1＝10′b0110110100；
13′b0100010000zzz：data_tmp1＝10′b0110110100；
13′b01000100z1zzz：data_tmp1＝10′b0110110101；
13′b0100010010zzz：data_tmp1＝10′b0110110101；
13′b0100010100zzz：data_tmp1＝10′b0110110101；
13′b01000101010zz：data_tmp1＝10′b0110110101；
13′b010001010110z：data_tmp1＝10′b0110110101；
13′b0100010101110：data_tmp1＝10′b0110110101；
13′b01000101z1111：data_tmp1＝10′b0110110110；
13′b0100010110zzz：data_tmp1＝10′b0110110110；
13′b01000101110zz：data_tmp1＝10′b0110110110；
13′b010001011110z：data_tmp1＝10′b0110110110；
13′b0100010111110：data_tmp1＝10′b0110110110；
13′b010001100zzzz：data_tmp1＝10′b0110110110；
				
				
13′b01000110100zz：data_tmp1＝10′b0110110110；
13′b010001101010z：data_tmp1＝10′b0110110110；
13′b0100011010110：data_tmp1＝10′b0110110110；
13′b010001101z111：data_tmp1＝10′b0110110111；
13′b0100011z110zz：data_tmp1＝10′b0110110111；
13′b0100011z1110z：data_tmp1＝10′b0110110111；
13′b0100011z11110：data_tmp1＝10′b0110110111；
13′b010001110zzzz：data_tmp1＝10′b0110110111；
13′b0100011110zzz：data_tmp1＝10′b0110110111；
13′b0100011111111：data_tmp1＝10′b0110111000；
13′b01001000zzzzz：data_tmp1＝10′b0110111000；
13′b0100100100zzz：data_tmp1＝10′b0110111000；
13′b01001001z1zzz：data_tmp1＝10′b0110111001；
13′b0100100110zzz：data_tmp1＝10′b0110111001；
13′b010010100zzzz：data_tmp1＝10′b0110111001；
13′b0100101010000：data_tmp1＝10′b0110111001；
13′b01001010100z1：data_tmp1＝10′b0110111010；
13′b0100101010z10：data_tmp1＝10′b0110111010；
13′b010010101z10z：data_tmp1＝10′b0110111010；
13′b010010101z111：data_tmp1＝10′b0110111010；
13′b0100101z110zz：data_tmp1＝10′b0110111010；
13′b0100101011110：data_tmp1＝10′b0110111010；
13′b010010110zzzz：data_tmp1＝10′b0110111010；
13′b0100101110zzz：data_tmp1＝10′b0110111010；
13′b01001011111zz：data_tmp1＝10′b0110111011；
13′b01001100zzzzz：data_tmp1＝10′b0110111011；
13′b01001101000zz：data_tmp1＝10′b0110111011；
13′b010011010010z：data_tmp1＝10′b0110111011；
13′b0100110100110：data_tmp1＝10′b0110111011；
13′b010011010z111：data_tmp1＝10′b0110111100；
13′b01001101z10zz：data_tmp1＝10′b0110111100；
13′b01001101z110z：data_tmp1＝10′b0110111100；
13′b01001101z1110：data_tmp1＝10′b0110111100；
13′b0100110110zzz：data_tmp1＝10′b0110111100；
13′b0100110111111：data_tmp1＝10′b0110111100；
13′b010011100zzzz：data_tmp1＝10′b0110111100；
13′b010011101000z：data_tmp1＝10′b0110111100；
13′b0100111010010：data_tmp1＝10′b0110111100；
13′b0100111010z11：data_tmp1＝10′b0110111101；
13′b010011101z10z：data_tmp1＝10′b0110111101；
13′b010011101z110：data_tmp1＝10′b0110111101；
13′b0100111z110zz：data_tmp1＝10′b0110111101；
13′b0100111011111：data_tmp1＝10′b0110111101；
13′b010011110zzzz：data_tmp1＝10′b0110111101；
13′b0100111110zzz：data_tmp1＝10′b0110111101；
13′b010011111110z：data_tmp1＝10′b0110111101；
13′b0100111111110：data_tmp1＝10′b0110111101；
13′b0100111111111：data_tmp1＝10′b0110111110；
				
				
13′b01010000zzzzz：data_tmp1＝10′b0110111110；
13′b0101000100zzz：data_tmp1＝10′b0110111110；
13′b01010001010zz：data_tmp1＝10′b0110111110；
13′b0101000101100：data_tmp1＝10′b0110111110；
13′b01010001011z1：data_tmp1＝10′b0110111111；
13′b01010001z1110：data_tmp1＝10′b0110111111；
13′b0101000110zzz：data_tmp1＝10′b0110111111；
13′b01010001110zz：data_tmp1＝10′b0110111111；
13′b010100011110z：data_tmp1＝10′b0110111111；
13′b0101000111111：data_tmp1＝10′b0110111111；
13′b010100100zzzz：data_tmp1＝10′b0110111111；
13′b0101001010zzz：data_tmp1＝10′b0110111111；
13′b010100101100z：data_tmp1＝10′b0110111111；
13′b0101001011010：data_tmp1＝10′b0110111111；
13′b0101001011z11：data_tmp1＝10′b0111000000；
13′b0101001z1110z：data_tmp1＝10′b0111000000；
13′b0101001z11110：data_tmp1＝10′b0111000000；
13′b010100110zzzz：data_tmp1＝10′b0111000000；
13′b0101001110zzz：data_tmp1＝10′b0111000000；
13′b01010011110zz：data_tmp1＝10′b0111000000；
13′b0101001111111：data_tmp1＝10′b0111000000；
13′b0101010000zzz：data_tmp1＝10′b0111000000；
13′b010101000100z：data_tmp1＝10′b0111000000；
13′b0101010001z1z：data_tmp1＝10′b0111000001；
13′b01010100z110z：data_tmp1＝10′b0111000001；
13′b0101010z10zzz：data_tmp1＝10′b0111000001；
13′b01010100110zz：data_tmp1＝10′b0111000001；
13′b010101001111z：data_tmp1＝10′b0111000001；
13′b010101010zzzz：data_tmp1＝10′b0111000001；
13′b010101011100z：data_tmp1＝10′b0111000001；
13′b0101010111z1z：data_tmp1＝10′b0111000010；
13′b010101011110z：data_tmp1＝10′b0111000010；
13′b01010110zzzzz：data_tmp1＝10′b0111000010；
13′b0101011100zzz：data_tmp1＝10′b0111000010；
13′b010101110100z：data_tmp1＝10′b0111000010；
13′b0101011101010：data_tmp1＝10′b0111000010；
13′b0101011101z11：data_tmp1＝10′b0111000011；
13′b01010111z110z：data_tmp1＝10′b0111000011；
13′b01010111z1110：data_tmp1＝10′b0111000011；
13′b0101011110zzz：data_tmp1＝10′b0111000011；
13′b01010111110zz：data_tmp1＝10′b0111000011；
13′b0101011111111：data_tmp1＝10′b0111000011；
13′b010110000zzzz：data_tmp1＝10′b0111000011；
13′b0101100010zzz：data_tmp1＝10′b0111000011；
13′b01011000110zz：data_tmp1＝10′b0111000011；
13′b0101100z111zz：data_tmp1＝10′b0111000100；
13′b010110010zzzz：data_tmp1＝10′b0111000100；
13′b0101100110zzz：data_tmp1＝10′b0111000100；
13′b01011001110zz：data_tmp1＝10′b0111000100；
13′b0101101000zzz：data_tmp1＝10′b0111000100；
				
				
13′b01011010010zz：data_tmp1＝10′b0111000100；
13′b010110100110z：data_tmp1＝10′b0111000100；
13′b0101101001110：data_tmp1＝10′b0111000100；
13′b01011010z1111：data_tmp1＝10′b0111000101；
13′b0101101z10zzz：data_tmp1＝10′b0111000101；
13′b0101101z110zz：data_tmp1＝10′b0111000101；
13′b0101101z1110z：data_tmp1＝10′b0111000101；
13′b0101101z11110：data_tmp1＝10′b0111000101；
13′b010110110zzzz：data_tmp1＝10′b0111000101；
13′b0101101111111：data_tmp1＝10′b0111000101；
13′b010111000000z：data_tmp1＝10′b0111000101；
13′b0101110000z1z：data_tmp1＝10′b0111000110；
13′b010111000z10z：data_tmp1＝10′b0111000110；
13′b01011100z10zz：data_tmp1＝10′b0111000110；
13′b01011100z111z：data_tmp1＝10′b0111000110；
13′b0101110010zzz：data_tmp1＝10′b0111000110；
13′b010111001110z：data_tmp1＝10′b0111000110；
13′b010111010zzzz：data_tmp1＝10′b0111000110；
13′b01011101100zz：data_tmp1＝10′b0111000110；
13′b010111011010z：data_tmp1＝10′b0111000110；
13′b0101110110110：data_tmp1＝10′b0111000110；
13′b010111011z111：data_tmp1＝10′b0111000111；
13′b01011101110zz：data_tmp1＝10′b0111000111；
13′b010111011110z：data_tmp1＝10′b0111000111；
13′b0101110111110：data_tmp1＝10′b0111000111；
13′b01011110zzzzz：data_tmp1＝10′b0111000111；
13′b0101111100zzz：data_tmp1＝10′b0111000111；
13′b01011111010zz：data_tmp1＝10′b0111000111；
13′b01011111z11zz：data_tmp1＝10′b0111001000；
13′b0101111110zzz：data_tmp1＝10′b0111001000；
13′b01011111110zz：data_tmp1＝10′b0111001000；
13′b01100000zzzzz：data_tmp1＝10′b0111001000；
13′b011000010000z：data_tmp1＝10′b0111001000；
13′b0110000100z1z：data_tmp1＝10′b0111001001；
13′b011000010z10z：data_tmp1＝10′b0111001001；
13′b01100001z10zz：data_tmp1＝10′b0111001001；
13′b01100001z111z：data_tmp1＝10′b0111001001；
13′b0110000110zzz：data_tmp1＝10′b0111001001；
13′b011000011110z：data_tmp1＝10′b0111001001；
13′b011000100zzzz：data_tmp1＝10′b0111001001；
13′b0110001010zzz：data_tmp1＝10′b0111001001；
13′b0110001011000：data_tmp1＝10′b0111001001；
13′b01100010110z1：data_tmp1＝10′b0111001010；
13′b0110001011z10：data_tmp1＝10′b0111001010；
13′b0110001z1110z：data_tmp1＝10′b0111001010；
13′b0110001z11111：data_tmp1＝10′b0111001010；
13′b011000110zzzz：data_tmp1＝10′b0111001010；
13′b0110001110zzz：data_tmp1＝10′b0111001010；
13′b01100011110zz：data_tmp1＝10′b0111001010；
13′b0110001111110：data_tmp1＝10′b0111001010；
				
				
13′b011001000zzzz：data_tmp1＝10′b0111001010；
13′b0110010010000：data_tmp1＝10′b0111001010；
13′b01100100100z1：data_tmp1＝10′b0111001011；
13′b0110010010z10：data_tmp1＝10′b0111001011；
13′b011001001z10z：data_tmp1＝10′b0111001011；
13′b011001001z111：data_tmp1＝10′b0111001011；
13′b0110010z110zz：data_tmp1＝10′b0111001011；
13′b0110010z11110：data_tmp1＝10′b0111001011；
13′b011001010zzzz：data_tmp1＝10′b0111001011；
13′b0110010110zzz：data_tmp1＝10′b0111001011；
13′b011001011110z：data_tmp1＝10′b0111001011；
13′b0110010111111：data_tmp1＝10′b0111001011；
13′b0110011000zzz：data_tmp1＝10′b0111001011；
13′b011001100100z：data_tmp1＝10′b0111001011；
13′b0110011001010：data_tmp1＝10′b0111001011；
13′b0110011001z11：data_tmp1＝10′b0111001100；
13′b01100110z110z：data_tmp1＝10′b0111001100；
13′b01100110z1110：data_tmp1＝10′b0111001100；
13′b0110011z10zzz：data_tmp1＝10′b0111001100；
13′b0110011z110zz：data_tmp1＝10′b0111001100；
13′b0110011z11111：data_tmp1＝10′b0111001100；
13′b011001110zzzz：data_tmp1＝10′b0111001100；
13′b011001111110z：data_tmp1＝10′b0111001100；
13′b0110011111110：data_tmp1＝10′b0111001100；
13′b01101000000zz：data_tmp1＝10′b0111001100；
13′b0110100000100：data_tmp1＝10′b0111001100；
13′b01101000001z1：data_tmp1＝10′b0111001101；
13′b011010000z110：data_tmp1＝10′b0111001101；
13′b01101000z10zz：data_tmp1＝10′b0111001101；
13′b01101000z110z：data_tmp1＝10′b0111001101；
13′b01101000z1111：data_tmp1＝10′b0111001101；
13′b0110100z10zzz：data_tmp1＝10′b0111001101；
13′b0110100z11110：data_tmp1＝10′b0111001101；
13′b011010010zzzz：data_tmp1＝10′b0111001101；
13′b01101001110zz：data_tmp1＝10′b0111001101；
13′b011010011110z：data_tmp1＝10′b0111001101；
13′b0110100111111：data_tmp1＝10′b0111001101；
13′b01101010zzzzz：data_tmp1＝10′b0111001110；
13′b011010110zzzz：data_tmp1＝10′b0111001110；
13′b0110101110zzz：data_tmp1＝10′b0111001110；
13′b01101011110zz：data_tmp1＝10′b0111001110；
13′b01101011111zz：data_tmp1＝10′b0111001111
13′b01101100zzzzz：data_tmp1＝10′b0111001111
13′b011011010zzzz：data_tmp1＝10′b0111001111；
13′b0110110110zzz：data_tmp1＝10′b0111001111；
13′b0110110111000：data_tmp1＝10′b0111001111；
13′b01101101110z1：data_tmp1＝10′b0111010000；
13′b0110110111z10：data_tmp1＝10′b0111010000；
13′b011011011110z：data_tmp1＝10′b0111010000；
13′b0110110111111：data_tmp1＝10′b0111010000；
				
				
13′b01101110zzzzz：data_tmp1＝10′b0111010000；
13′b011011110zzzz：data_tmp1＝10′b0111010000；
13′b0110111110zzz：data_tmp1＝10′b0111010000；
13′b0110111111zzz：data_tmp1＝10′b0111010001；
13′b01110000zzzzz：data_tmp1＝10′b0111010001；
13′b011100010zzzz：data_tmp1＝10′b0111010001；
13′b01110001100zz：data_tmp1＝10′b0111010001；
13′b011100011010z：data_tmp1＝10′b0111010001；
13′b0111000110110：data_tmp1＝10′b0111010001；
13′b011100011z111：data_tmp1＝10′b0111010010；
13′b01110001110zz：data_tmp1＝10′b0111010010；
13′b011100011110z：data_tmp1＝10′b0111010010；
13′b0111000111110：data_tmp1＝10′b0111010010；
13′b01110010zzzzz：data_tmp1＝10′b0111010010；
13′b011100110zzzz：data_tmp1＝10′b0111010010；
13′b0111001110zzz：data_tmp1＝10′b0111010010；
13′b0111001111zzz：data_tmp1＝10′b0111010011；
13′b01110100zzzzz：data_tmp1＝10′b0111010011；
13′b011101010zzzz：data_tmp1＝10′b0111010011；
13′b0111010110zzz：data_tmp1＝10′b0111010011；
13′b011101011100z：data_tmp1＝10′b0111010011；
13′b0111010111z1z：data_tmp1＝10′b0111010100；
13′b011101011110z：data_tmp1＝10′b0111010100；
13′b01110110zzzzz：data_tmp1＝10′b0111010100；
13′b011101110zzzz：data_tmp1＝10′b0111010100；
13′b0111011110zzz：data_tmp1＝10′b0111010100；
13′b01110111110zz：data_tmp1＝10′b0111010100；
13′b0111011111100：data_tmp1＝10′b0111010100；
13′b01110111111z1：data_tmp1＝10′b0111010101；
13′b0111011111110：data_tmp1＝10′b0111010101；
13′b0111100zzzzzz：data_tmp1＝10′b0111010101；
13′b0111101000000：data_tmp1＝10′b0111010101；
13′b01111010000z1：data_tmp1＝10′b0111010110；
13′b0111101000z10：data_tmp1＝10′b0111010110；
13′b011110100z10z：data_tmp1＝10′b0111010110；
13′b011110100z111：data_tmp1＝10′b0111010110；
13′b01111010z10zz：data_tmp1＝10′b0111010110；
13′b01111010z1110：data_tmp1＝10′b0111010110；
13′b0111101z10zzz：data_tmp1＝10′b0111010110；
13′b0111101z1110z：data_tmp1＝10′b0111010110；
13′b0111101z11111：data_tmp1＝10′b0111010110；
13′b011110110zzzz：data_tmp1＝10′b0111010110；
13′b01111011110zz：data_tmp1＝10′b0111010110；
13′b0111101111110：data_tmp1＝10′b0111010110；
13′b01111100000zz：data_tmp1＝10′b0111010110；
13′b011111000010z：data_tmp1＝10′b0111010110；
13′b011111000z11z：data_tmp1＝10′b0111010111；
13′b01111100z10zz：data_tmp1＝10′b0111010111；
13′b01111100z110z：data_tmp1＝10′b0111010111；
				
				
13′b0111110z10zzz：data_tmp1＝10′b0111010111；
13′b0111110z1111z：data_tmp1＝10′b0111010111；
13′b011111010zzzz：data_tmp1＝10′b0111010111；
13′b01111101110zz：data_tmp1＝10′b0111010111；
13′b011111011110z：data_tmp1＝10′b0111010111；
13′b0111111000zzz：data_tmp1＝10′b0111010111；
13′b01111110010zz：data_tmp1＝10′b0111010111；
13′b0111111001100：data_tmp1＝10′b0111010111；
13′b01111110011z1：data_tmp1＝10′b0111011000；
13′b01111110z1110：data_tmp1＝10′b0111011000；
13′b0111111z10zzz：data_tmp1＝10′b0111011000；
13′b0111111z110zz：data_tmp1＝10′b0111011000；
13′b0111111z1110z：data_tmp1＝10′b0111011000；
13′b0111111z11111：data_tmp1＝10′b0111011000；
13′b011111110zzzz：data_tmp1＝10′b0111011000；
13′b0111111111110：data_tmp1＝10′b0111011000；
13′b100000000zzzz：data_tmp1＝10′b0111011000；
13′b10000000100zz：data_tmp1＝10′b0111011000；
13′b100000001z1zz：data_tmp1＝10′b0111011001；
13′b1000000z110zz：data_tmp1＝10′b0111011001；
13′b100000010zzzz：data_tmp1＝10′b0111011001；
13′b1000000110zzz：data_tmp1＝10′b0111011001；
13′b10000001111zz：data_tmp1＝10′b0111011001；
13′b100000100zzzz：data_tmp1＝10′b0111011001；
13′b1000001010zzz：data_tmp1＝10′b0111011001；
13′b10000010110zz：data_tmp1＝10′b0111011001；
13′b100000101110z：data_tmp1＝10′b0111011001；
13′b1000001z1111z：data_tmp1＝10′b0111011010；
13′b100000110zzzz：data_tmp1＝10′b0111011010；
13′b1000001110zzz：data_tmp1＝10′b0111011010；
13′b10000011110zz：data_tmp1＝10′b0111011010；
13′b100000111110z：data_tmp1＝10′b0111011010；
13′b10000100zzzzz：data_tmp1＝10′b0111011010；
13′b1000010100zzz：data_tmp1＝10′b0111011010；
13′b10000101z1zzz：data_tmp1＝10′b0111011011；
13′b1000010110zzz：data_tmp1＝10′b0111011011；
13′b10000110zzzzz：data_tmp1＝10′b0111011011；
13′b100001110zzzz：data_tmp1＝10′b0111011011；
13′b10000111100zz：data_tmp1＝10′b0111011011；
13′b100001111z1zz：data_tmp1＝10′b0111011100；
13′b10000111110zz：data_tmp1＝10′b0111011100；
13′b1000100zzzzzz：data_tmp1＝10′b0111011100；
13′b1000101000000：data_tmp1＝10′b0111011100；
13′b10001010000z1：data_tmp1＝10′b0111011101；
13′b1000101000z10：data_tmp1＝10′b0111011101；
13′b100010100z10z：data_tmp1＝10′b0111011101；
13′b100010100z111：data_tmp1＝10′b0111011101；
13′b10001010z10zz：data_tmp1＝10′b0111011101；
13′b10001010z1110：data_tmp1＝10′b0111011101；
13′b1000101z10zzz：data_tmp1＝10′b0111011101；
				
				
13′b1000101z1110z：data_tmp1＝10′b0111011101；
13′b1000101z11111：data_tmp1＝10′b0111011101；
13′b100010110zzzz：data_tmp1＝10′b0111011101；
13′b10001011110zz：data_tmp1＝10′b0111011101；
13′b1000101111110：data_tmp1＝10′b0111011101；
13′b1000110000zzz：data_tmp1＝10′b0111011101；
13′b10001100010zz：data_tmp1＝10′b0111011101；
13′b100011000110z：data_tmp1＝10′b0111011101；
13′b1000110001110：data_tmp1＝10′b0111011101；
13′b10001100z1111：data_tmp1＝10′b0111011110；
13′b1000110z10zzz：data_tmp1＝10′b0111011110；
13′b1000110z110zz：data_tmp1＝10′b0111011110；
13′b1000110z1110z：data_tmp1＝10′b0111011110；
13′b1000110z11110：data_tmp1＝10′b0111011110；
13′b100011010zzzz：data_tmp1＝10′b0111011110；
13′b1000110111111：data_tmp1＝10′b0111011110；
13′b100011100zzzz：data_tmp1＝10′b0111011110；
13′b1000111010zzz：data_tmp1＝10′b0111011110；
13′b10001110110zz：data_tmp1＝10′b0111011110；
13′b100011101110z：data_tmp1＝10′b0111011110；
13′b1000111011110：data_tmp1＝10′b0111011110；
13′b1000111z11111：data_tmp1＝10′b0111011111；
13′b100011110zzzz：data_tmp1＝10′b0111011111；
13′b1000111110zzz：data_tmp1＝10′b0111011111；
13′b10001111110zz：data_tmp1＝10′b0111011111；
13′b100011111110z：data_tmp1＝10′b0111011111；
13′b1000111111110：data_tmp1＝10′b0111011111；
13′b10010000zzzzz：data_tmp1＝10′b0111011111；
13′b100100010zzzz：data_tmp1＝10′b0111011111；
13′b100100z11zzzz：data_tmp1＝10′b0111100000；
13′b10010010zzzzz：data_tmp1＝10′b0111100000；
13′b100100110zzzz：data_tmp1＝10′b0111100000；
13′b100101000000z：data_tmp1＝10′b0111100000；
13′b1001010000010：data_tmp1＝10′b0111100000；
13′b1001010000z11：data_tmp1＝10′b0111100001；
13′b100101000z10z：data_tmp1＝10′b0111100001；
13′b100101000z110：data_tmp1＝10′b0111100001；
13′b10010100z10zz：data_tmp1＝10′b0111100001；
13′b10010100z1111：data_tmp1＝10′b0111100001；
13′b1001010z10zzz：data_tmp1＝10′b0111100001；
13′b1001010z1110z：data_tmp1＝10′b0111100001；
13′b1001010z11110：data_tmp1＝10′b0111100001；
13′b100101010zzzz：data_tmp1＝10′b0111100001；
13′b10010101110zz：data_tmp1＝10′b0111100001；
13′b1001010111111：data_tmp1＝10′b0111100001；
13′b100101100zzzz：data_tmp1＝10′b0111100001；
13′b10010110100zz：data_tmp1＝10′b0111100001；
13′b100101101010z：data_tmp1＝10′b0111100001；
13′b1001011010110：data_tmp1＝10′b0111100001；
13′b100101101z111：data_tmp1＝10′b0111100010；
13′b1001011z110zz：data_tmp1＝10′b0111100010；
				
				
13′b1001011z1110z：data_tmp1＝10′b0111100010；
13′b1001011z11110：data_tmp1＝10′b0111100010；
13′b100101110zzzz：data_tmp1＝10′b0111100010；
13′b1001011110zzz：data_tmp1＝10′b0111100010；
13′b1001011111111：data_tmp1＝10′b0111100010；
13′b10011000zzzzz：data_tmp1＝10′b0111100010；
13′b1001100100zzz：data_tmp1＝10′b0111100010；
13′b10011001010zz：data_tmp1＝10′b0111100010；
13′b1001100101100：data_tmp1＝10′b0111100010；
13′b10011001011z1：data_tmp1＝10′b0111100011；
13′b10011001z1110：data_tmp1＝10′b0111100011；
13′b100110z110zzz：data_tmp1＝10′b0111100011；
13′b100110z1110zz：data_tmp1＝10′b0111100011；
13′b100110z11110z：data_tmp1＝10′b0111100011；
13′b100110z111111：data_tmp1＝10′b0111100011；
13′b10011010zzzzz：data_tmp1＝10′b0111100011；
13′b100110110zzzz：data_tmp1＝10′b0111100011；
13′b1001101111110：data_tmp1＝10′b0111100011；
13′b10011100000zz：data_tmp1＝10′b0111100011；
13′b100111000z1zz：data_tmp1＝10′b0111100100；
13′b10011100z10zz：data_tmp1＝10′b0111100100；
13′b1001110z10zzz：data_tmp1＝10′b0111100100；
13′b1001110z111zz：data_tmp1＝10′b0111100100；
13′b100111010zzzz：data_tmp1＝10′b0111100100；
13′b10011101110zz：data_tmp1＝10′b0111100100；
13′b100111100zzzz：data_tmp1＝10′b0111100100；
13′b1001111010zzz：data_tmp1＝10′b0111100100；
13′b10011110110zz：data_tmp1＝10′b0111100100；
13′b1001111011100：data_tmp1＝10′b0111100100；
13′b10011110111z1：data_tmp1＝10′b0111100101；
13′b1001111z11110：data_tmp1＝10′b0111100101；
13′b100111110zzzz：data_tmp1＝10′b0111100101；
13′b1001111110zzz：data_tmp1＝10′b0111100101；
13′b10011111110zz：data_tmp1＝10′b0111100101；
13′b100111111110z：data_tmp1＝10′b0111100101；
13′b1001111111111：data_tmp1＝10′b0111100101；
13′b10100000zzzzz：data_tmp1＝10′b0111100101；
13′b101000010zzzz：data_tmp1＝10′b0111100101；
13′b10100001100zz：data_tmp1＝10′b0111100101；
13′b101000011010z：data_tmp1＝10′b0111100101；
13′b1010000110110：data_tmp1＝10′b0111100101；
13′b101000011z111：data_tmp1＝10′b0111100110；
13′b101000z1110zz：data_tmp1＝10′b0111100110；
13′b101000z11110z：data_tmp1＝10′b0111100110；
13′b101000z111110：data_tmp1＝10′b0111100110；
13′b10100010zzzzz：data_tmp1＝10′b0111100110；
13′b101000110zzzz：data_tmp1＝10′b0111100110；
13′b1010001110zzz：data_tmp1＝10′b0111100110；
13′b1010001111111：data_tmp1＝10′b0111100110；
13′b101001000zzzz：data_tmp1＝10′b0111100110；
13′b101001001000z：data_tmp1＝10′b0111100110；
13′b1010010010010：data tmp1＝10′b0111100110；
				
				
13′b1010010010z11：data_tmp1＝10′b0111100111；
13′b101001001z10z：data_tmp1＝10′b0111100111；
13′b101001001z110：data_tmp1＝10′b0111100111；
13′b1010010z110zz：data_tmp1＝10′b0111100111；
13′b1010010z11111：data_tmp1＝10′b0111100111；
13′b101001z10zzzz：data_tmp1＝10′b0111100111；
13′b1010010110zzz：data_tmp1＝10′b0111100111；
13′b101001011110z：data_tmp1＝10′b0111100111；
13′b1010010111110：data_tmp1＝10′b0111100111；
13′b10100110zzzzz：data_tmp1＝10′b0111100111；
13′b101001111zzzz：data_tmp1＝10′b0111101000；
13′b1010100zzzzzz：data_tmp1＝10′b0111101000；
13′b101010100zzzz：data_tmp1＝10′b0111101000；
13′b1010101z1zzzz：data_tmp1＝10′b0111101001；
13′b101010110zzzz：data_tmp1＝10′b0111101001；
13′b10101100zzzzz：data_tmp1＝10′b0111101001；
13′b101011010zzzz：data_tmp1＝10′b0111101001；
13′b101011z11zzzz：data_tmp1＝10′b0111101010；
13′b10101110zzzzz：data_tmp1＝10′b0111101010；
13′b101011110zzzz：data_tmp1＝10′b0111101010；
13′b101100000zzzz：data_tmp1＝10′b0111101010；
13′b101100001000z：data_tmp1＝10′b0111101010；
13′b1011000010010：data_tmp1＝10′b0111101010；
13′b1011000010z11：data_tmp1＝10′b0111101011；
13′b101100001z10z：data_tmp1＝10′b0111101011；
13′b101100001z110：data_tmp1＝10′b0111101011；
13′b1011000z110zz：data_tmp1＝10′b0111101011；
13′b1011000z11111：data_tmp1＝10′b0111101011；
13′b101100z10zzzz：data_tmp1＝10′b0111101011；
13′b1011000110zzz：data_tmp1＝10′b0111101011；
13′b101100011110z：data_tmp1＝10′b0111101011；
13′b1011000111110：data_tmp1＝10′b0111101011；
13′b10110010zzzzz：data_tmp1＝10′b0111101011；
13′b10110011100zz：data_tmp1＝10′b0111101011；
13′b101100111010z：data_tmp1＝10′b0111101011；
13′b1011001110110：data_tmp1＝10′b0111101011；
13′b101100111z111：data_tmp1＝10′b0111101100；
13′b10110011110zz：data_tmp1＝10′b0111101100；
13′b101100111110z：data_tmp1＝10′b0111101100；
13′b1011001111110：data_tmp1＝10′b0111101100；
13′b1011010zzzzzz：data_tmp1＝10′b0111101100；
13′b101101100zzzz：data_tmp1＝10′b0111101100；
13′b1011011010zzz：data_tmp1＝10′b0111101100；
13′b10110110110zz：data_tmp1＝10′b0111101100；
13′b101101101110z：data_tmp1＝10′b0111101100；
13′b1011011z1111z：data_tmp1＝10′b0111101101；
13′b101101110zzzz：data_tmp1＝10′b0111101101；
13′b1011011110zzz：data_tmp1＝10′b0111101101；
13′b10110111110zz：data_tmp1＝10′b0111101101；
13′b101101111110z：data_tmp1＝10′b0111101101；
				
				
13′b1011100zzzzzz：data_tmp1＝10′b0111101101；
13′b10111010000zz：data_tmp1＝10′b0111101101；
13′b101110100010z：data_tmp1＝10′b0111101101；
13′b101110100z11z：data_tmp1＝10′b0111101110；
13′b10111010z10zz：data_tmp1＝10′b0111101110；
13′b10111010z110z：data_tmp1＝10′b0111101110；
13′b1011101z10zzz：data_tmp1＝10′b0111101110；
13′b1011101z1111z：data_tmp1＝10′b0111101110；
13′b101110110zzzz：data_tmp1＝10′b0111101110；
13′b10111011110zz：data_tmp1＝10′b0111101110；
13′b101110111110z：data_tmp1＝10′b0111101110；
13′b10111100zzzzz：data_tmp1＝10′b0111101110；
13′b1011110100zzz：data_tmp1＝10′b0111101110；
13′b10111101010zz：data_tmp1＝10′b0111101110；
13′b101111010110z：data_tmp1＝10′b0111101110；
13′b1011110101110：data_tmp1＝10′b0111101110；
13′b10111101z1111：data_tmp1＝10′b0111101111；
13′b101111z110zzz：data_tmp1＝10′b0111101111；
13′b101111z1110zz：data_tmp1＝10′b0111101111；
13′b101111z11110z：data_tmp1＝10′b0111101111；
13′b101111z111110：data_tmp1＝10′b0111101111；
13′b10111110zzzzz：data_tmp1＝10′b0111101111；
13′b101111110zzzz：data_tmp1＝10′b0111101111；
13′b1011111111111：data_tmp1＝10′b0111101111；
13′b110000000zzzz：data_tmp1＝10′b0111101111；
13′b1100000010zzz：data_tmp1＝10′b0111101111；
13′b110000001100z：data_tmp1＝10′b0111101111；
13′b1100000011010：data_tmp1＝10′b0111101111；
13′b1100000011z11：data_tmp1＝10′b0111110000；
13′b1100000z1110z：data_tmp1＝10′b0111110000；
13′b1100000z11110：data_tmp1＝10′b0111110000；
13′b110000z10zzzz：data_tmp1＝10′b0111110000；
13′b110000z110zzz：data_tmp1＝10′b0111110000；
13′b110000z1110zz：data_tmp1＝10′b0111110000；
13′b110000z111111：data_tmp1＝10′b0111110000；
13′b11000010zzzzz：data_tmp1＝10′b0111110000；
13′b110000111110z：data_tmp1＝10′b0111110000；
13′b1100001111110：data_tmp1＝10′b0111110000；
13′b1100010000zzz：data_tmp1＝10′b0111110000；
13′b1100010001000：data_tmp1＝10′b0111110000；
13′b11000100010z1：data_tmp1＝10′b0111110001；
13′b1100010001z10：data_tmp1＝10′b0111110001；
13′b11000100z110z：data_tmp1＝10′b0111110001；
13′b11000100z1111：data_tmp1＝10′b0111110001；
13′b1100010z10zzz：data_tmp1＝10′b0111110001；
13′b1100010z110zz：data_tmp1＝10′b0111110001；
13′b1100010z11110：data_tmp1＝10′b0111110001；
13′b110001z10zzzz：data_tmp1＝10′b0111110001；
13′b110001011110z：data_tmp1＝10′b0111110001；
13′b1100010111111：data_tmp1＝10′b0111110001；
13′b11000110zzzzz：data_tmp1＝10′b0111110001；
13′b1100011110zzz：data_tmp1＝10′b0111110001；
				
				
13′b1100011111zzz：data_tmp1＝10′b0111110010；
13′b1100100zzzzzz：data_tmp1＝10′b0111110010；
13′b11001010zzzzz：data_tmp1＝10′b0111110010；
13′b1100101100zzz：data_tmp1＝10′b0111110010；
13′b110010110100z：data_tmp1＝10′b0111110010；
13′b1100101101z1z：data_tmp1＝10′b0111110011；
13′b11001011z110z：data_tmp1＝10′b0111110011；
13′b1100101110zzz：data_tmp1＝10′b0111110011；
13′b11001011110zz：data_tmp1＝10′b0111110011；
13′b110010111111z：data_tmp1＝10′b0111110011；
13′b1100110zzzzzz：data_tmp1＝10′b0111110011；
13′b110011100zzzz：data_tmp1＝10′b0111110011；
13′b1100111010zzz：data_tmp1＝10′b0111110011；
13′b11001110110zz：data_tmp1＝10′b0111110011；
13′b1100111011100：data_tmp1＝10′b0111110011；
13′b11001110111z1：data_tmp1＝10′b0111110100；
13′b1100111z11110：data_tmp1＝10′b0111110100；
13′b110011110zzzz：data_tmp1＝10′b0111110100；
13′b1100111110zzz：data_tmp1＝10′b0111110100；
13′b11001111110zz：data_tmp1＝10′b0111110100；
13′b110011111110z：data_tmp1＝10′b0111110100；
13′b1100111111111：data_tmp1＝10′b0111110100；
13′b1101000zzzzzz：data_tmp1＝10′b0111110100；
13′b110100100zzzz：data_tmp1＝10′b0111110100；
13′b110100101000z：data_tmp1＝10′b0111110100；
13′b1101001010010：data_tmp1＝10′b0111110100；
13′b1101001010z11：data_tmp1＝10′b0111110101；
13′b110100101z10z：data_tmp1＝10′b0111110101；
13′b110100101z110：data_tmp1＝10′b0111110101；
13′b1101001z110zz：data_tmp1＝10′b0111110101；
13′b1101001z11111：data_tmp1＝10′b0111110101；
13′b110100110zzzz：data_tmp1＝10′b0111110101；
13′b1101001110zzz：data_tmp1＝10′b0111110101；
13′b110100111110z：data_tmp1＝10′b0111110101；
13′b1101001111110：data_tmp1＝10′b0111110101；
13′b1101010zzzzzz：data_tmp1＝10′b0111110101；
13′b1101011000zzz：data_tmp1＝10′b0111110101；
13′b110101100100z：data_tmp1＝10′b0111110101；
13′b1101011001z1z：data_tmp1＝10′b0111110110；
13′b11010110z110z：data_tmp1＝10′b0111110110；
13′b1101011z10zzz：data_tmp1＝10′b0111110110；
13′b1101011z110zz：data_tmp1＝10′b0111110110；
13′b1101011z1111z：data_tmp1＝10′b0111110110；
13′b110101110zzzz：data_tmp1＝10′b0111110110；
13′b110101111110z：data_tmp1＝10′b0111110110；
13′b1101100zzzzzz：data_tmp1＝10′b0111110110；
13′b11011010000zz：data_tmp1＝10′b0111110110；
13′b110110100z1zz：data_tmp1＝10′b0111110111；
13′b11011010z10zz：data_tmp1＝10′b0111110111；
13′b1101101z10zzz：data_tmp1＝10′b0111110111；
13′b1101101z111zz：data_tmp1＝10′b0111110111；
				
				
13′b110110110zzzz：data_tmp1＝10′b0111110111；
13′b11011011110zz：data_tmp1＝10′b0111110111；
13′b1101110zzzzzz：data_tmp1＝10′b0111110111；
13′b1101111zzzzzz：data_tmp1＝10′b0111111000；
13′b11100000zzzzz：data_tmp1＝10′b0111111000；
13′b111000010zzzz：data_tmp1＝10′b0111111000；
13′b1110000110zzz：data_tmp1＝10′b0111111000；
13′b11100001110zz：data_tmp1＝10′b0111111000；
13′b111000011110z：data_tmp1＝10′b0111111000；
13′b111000z11111z：data_tmp1＝10′b0111111001；
13′b11100010zzzzz：data_tmp1＝10′b0111111001；
13′b111000110zzzz：data_tmp1＝10′b0111111001；
13′b1110001110zzz：data_tmp1＝10′b0111111001；
13′b11100011110zz：data_tmp1＝10′b0111111001；
13′b111000111110z：data_tmp1＝10′b0111111001；
13′b11100100zzzzz：data_tmp1＝10′b0111111001；
13′b111001010zzzz：data_tmp1＝10′b0111111001；
13′b1110010110zzz：data_tmp1＝10′b0111111001；
13′b11100101110zz：data_tmp1＝10′b0111111001；
13′b111001011110z：data_tmp1＝10′b0111111001；
13′b1110010111110：data_tmp1＝10′b0111111001；
13′b111001z111111：data_tmp1＝10′b0111111010；
13′b11100110zzzzz：data_tmp1＝10′b0111111010；
13′b111001110zzzz：data_tmp1＝10′b0111111010；
13′b1110011110zzz：data_tmp1＝10′b0111111010；
13′b11100111110zz：data_tmp1＝10′b0111111010；
13′b111001111110z：data_tmp1＝10′b0111111010；
13′b1110011111110：data_tmp1＝10′b0111111010；
13′b1110100zzzzzz：data_tmp1＝10′b0111111010；
13′b111010100000z：data_tmp1＝10′b0111111010；
13′b1110101000z1z：data_tmp1＝10′b0111111011；
13′b111010100z10z：data_tmp1＝10′b0111111011；
13′b11101010z10zz：data_tmp1＝10′b0111111011；
13′b11101010z111z：data_tmp1＝10′b0111111011；
13′b1110101z10zzz：data_tmp1＝10′b0111111011；
13′b1110101z1110z：data_tmp1＝10′b0111111011；
13′b111010110zzzz：data_tmp1＝10′b0111111011；
13′b11101011110zz：data_tmp1＝10′b0111111011；
13′b111010111111z：data_tmp1＝10′b0111111011；
13′b1110110zzzzzz：data_tmp1＝10′b0111111011；
13′b11101110000zz：data_tmp1＝10′b0111111011；
13′b111011100010z：data_tmp1＝10′b0111111011；
13′b1110111000110：data_tmp1＝10′b0111111011；
13′b111011100z111：data_tmp1＝10′b0111111100；
13′b11101110z10zz：data_tmp1＝10′b0111111100；
13′b11101110z110z：data_tmp1＝10′b0111111100；
13′b11101110z1110：data_tmp1＝10′b0111111100；
13′b1110111z10zzz：data_tmp1＝10′b0111111100；
13′b1110111z11111：data_tmp1＝10′b0111111100；
13′b111011110zzzz：data_tmp1＝10′b0111111100；
13′b11101111110zz：data_tmp1＝10′b0111111100；
				
				
13′b111011111110z：data_tmp1＝10′b0111111100；
13′b1110111111110：data_tmp1＝10′b0111111100；
13′b1111000zzzzzz：data_tmp1＝10′b0111111100；
13′b1111001000zzz：data_tmp1＝10′b0111111100；
13′b11110010010zz：data_tmp1＝10′b0111111100；
13′b111100100110z：data_tmp1＝10′b0111111100；
13′b11110010z111z：data_tmp1＝10′b0111111101；
13′b1111001z10zzz：data_tmp1＝10′b0111111101；
13′b1111001z110zz：data_tmp1＝10′b0111111101；
13′b1111001z1110z：data_tmp1＝10′b0111111101；
13′b111100110zzzz：data_tmp1＝10′b0111111101；
13′b111100111111z：data_tmp1＝10′b0111111101；
13′b1111010zzzzzz：data_tmp1＝10′b0111111101；
13′b111101100zzzz：data_tmp1＝10′b0111111101；
13′b1111011010zzz：data_tmp1＝10′b0111111101；
13′b1111011z11zzz：data_tmp1＝10′b0111111110；
13′b111101110zzzz：data_tmp1＝10′b0111111110；
13′b1111011110zzz：data_tmp1＝10′b0111111110；
13′b1111100zzzzzz：data_tmp1＝10′b0111111110；
13′b11111010zzzzz：data_tmp1＝10′b0111111110；
13′b11111011000zz：data_tmp1＝10′b0111111110；
13′b111110110z1zz：data_tmp1＝10′b0111111111；
13′b11111011z10zz：data_tmp1＝10′b0111111111；
13′b11111z1110zzz：data_tmp1＝10′b0111111111；
13′b11111z11111zz：data_tmp1＝10′b0111111111；
13′b1111110zzzzzz：data_tmp1＝10′b0111111111；
13′b11111110zzzzz：data_tmp1＝10′b0111111111；
13′b111111110zzzz：data_tmp1＝10′b0111111111；
13′b11111111110zz：data_tmp1＝10′b0111111111；
default：data_tmp1＝10′bxxxxxxxxxx；
 endcase
 always @(posedge clk)
 if(enable_3)
  data_tmp2＜＝data_tmp1；
 assign out_data＝data_tmp2；
endmodule

                            Listing 14

∥Sccsld：％W％ ％G％
/******************************************************************************

　　Copyright(c)1997 Pioneer Digital Design Centre Limited
Author：Dawood Alam.
Description：Verilog code for windowing algorithm to enable detection of the

　　″active interval″ of the COFDM symbol for guard values of：

　　  64，128，256，512 and an active interval of 2048.(RTL)
Notes：This module generates the window signal for the FFT in the form
				
				
of valid in and provides the necessary signals for the I/Q
  demodulator，sync interpolator and error handler.
To DO：Check between successive symbol acquires for consistency
   in timing.
   Window timing pulse
   tracking mode，filter peaks
   IQ and sync interpolator guard pulses.
   Override functions for timing.
   Gain confidence by comparing symbol_acq vs retrys
******************************************************************************/
`timescale 1ns/100ps
module fft window(in_xr，

　　   in_xi，

　　       clk，

　　       nrst，

　　       valid_in，

　　       valid_out，

　　       in_resync，

　　    out_iqgi，

　　       out_sincgi，

　　       out_rx_guard，

　　        out_acquired，

　　        out_fft_window，

　　        enable_3_4，

　　        out_test，

　　        track_ram_address，

　　        xri_tmp1，

　　        xri_tmp5，

　　        track_ram_rnotw，

　　        track_ram_enable，

　　        ram_addr，

　　        ram_enable，

　　        ram_rnotw，

　　        ram10_in，

　　         ram10_out，

　　         x1r_10，        ∥To FFT datapath (I).

　　         x1i_10，        ∥To FFT datapath (Q).

　　         z2r_10，        ∥From FFT datapath (I)

　　         z2i_10，        ∥From FFT datapath (Q)

　　         fft_ram_rnotw，    ∥From FFT addr gen.

　　         fft_ram_enable，   ∥From FFT addr gen.

　　         fft_ram_addr)；    ∥From FFT addr gen.
∥--------------------------------------------------
∥    Parameter definitions.
∥--------------------------------------------------
parameter     wordlength＝12；     ∥Data wordlength.parameter     r_wordlength＝10；    ∥ROM data wordlength.
parameter     AddressSize＝3；      ∥Size of address bus.
parameter     FIFO_L＝256；    ∥Tracking FIFO length.
parameter     FIFO_L_bits＝8；  ∥Track FIFO addr bits
				
				
parameter     FIFO_N＝64；   ∥Acclength S(i-j).
parameter     FIFO_n＝64；   ∥Acclength S(i-n-j).
parameter     FIFO_A＝32；   ∥t offset dly FIFO+1.
parameter     FIFO_A_bits＝5；  ∥Track FIFO bits.
parameter     lu_AddressSize＝15； ∥log lu address size.
parameter     delta＝20；   ∥Gu threshold distance
parameter     acquired_symbols＝2；∥Acq symbls before trk
parameter     pos_threshold＝3；∥For info only.
parameter     t_offset_threshold＝10；∥t_offset valid thresh
parameter     w_advance＝10；     ∥win trig frm boundary
parameter     sincint_latency＝2；∥Latency to sinc intep
parameter     iqdemod_latency＝168； ∥Latency to IQ demod.
parameter     start＝3′b000，∥Search for neg peak.

　　       peak1＝3′b001，  ∥1st pos peak found.

　　       peak2＝3′b010，  ∥2nd pos peak found.

　　       peak3＝3′b011，  ∥3rd pos peak found.

　　       track1＝3′b100， ∥Tracking mode1.

　　       track2＝3′b101； ∥Tracking mode1.
∥--------------------------------------------------
∥      Input/Output ports.
∥--------------------------------------------------
input     clk，     ∥Master clock.

　　   nrst，     ∥Power-up reset.

　　     valid_in，  ∥Input data valid.

　　     in_resync，  ∥Sync FSM into Acqure.

　　     fft_ram_rnotw，

　　     fft_ram_enable；
input[AddressSize-1：0]fft_ram_addr；
input[wordlength-3：0]in_xr，    ∥FFT input data，I.

　　    in_xi，     ∥FFT input data，Q.

　　      xri_tmp5；    ∥Track RAM output.
input[wordlength*2-1：0]ram10_out；   ∥From 1K x 24 bit RAM.
input[wordlength-1：0]z2r_10，z2i_10； ∥From FFT datapath.
output[wordlength*2-1：0]ram10_in；    ∥To 1K x 24 bit RAM.
output[wordlength-3：0] xri_tmp1；    ∥Track RAM input.
output[14：0]   out_test；       ∥Temp testpin output.
output     out_iqgi，       ∥I/Q demod guard info.

　　       out_sincgi，   ∥Sinc int. guard info.

　　       out_acquired，  ∥Symbol acquired flag.

　　       out fft window， ∥FFT processor st/stp

　　       enable_3_4，

　　        valid_out，

　　        track_ram_rnotw，

　　        track_ram_enable，

　　        ram_enable，
				
				
　　       ram_rnotw；
output[FIFO_L_bits-1：0]track_ram_address；  ∥Tracking ram address
output[1：0]  out_rx_guard；    ∥Acquired gu length.
output[AddressSize-1：0] ram_addr；
output[wordlength-1：0] x1r_10，x1i_10；  ∥To FFT datapath.
∥--------------------------------------------------
∥      Wire/register declarations.
∥--------------------------------------------------
reg       out_acquired，     ∥Symbol acquired flag.

　　     out_fft_window，   ∥FFT window signal.

　　       tracking，    ∥Tracking mode data.

　　       acc_add，     ∥Acc add only flag.

　　       acc_add_sub，   ∥Acc add/sub flag.

　　       fifo_a_add_sub，  ∥FIFO_A add/sub flag.

　　     f_ratio_valid， ∥F ratio is valid

　　       read，     ∥Track FIFO read flag.

　　       write，    ∥Track FIFO write flag

　　       track_mode，   ∥Track∥Acq status flag

　　       dpctl_reset，  ∥Datapath control rst.

　　       t_reset，    ∥Timing counter reset.

　　       g_a_reset，    ∥Guard_active cnt rst.

　　       guard_valid，   ∥Guard signal is valid

　　     t_retime_acq，   ∥Retime timing counter

　　       t_retime_trk，  ∥Retiming for tracking 

　　       t_offset_valid， ∥Peak offset valid.

　　       t_offset_avg_valid，∥Average offset valid.

　　       pulse，     ∥Pulse on states 4 & 5

　　       enable_fft，  ∥FFT enabled flag.

　　       out_sincgi，  ∥Guard int to sincint.

　　       out_iqgi，   ∥Guard int to iq demod

　　       ram_enable，

　　       ram_rnotw；
reg[14：0]    guard_active；   ∥Guard+active length.
reg[3：0]     retry，   ∥No failed retry′s.

　　     acq_symbols；   ∥No of acquired symbls
reg[wordlength-2：0]xri_tmp7；    ∥Delayed difference.
reg[wordlength-3：0]xr_reg，     ∥(10 bits)

　　      xi_reg，

　　        xri_tmp1，    ∥Sum of|I|+|Q|.

　　        xri_tmp3，    ∥Delayed |difference|.

　　        xri_tmp6；    ∥FIFO 2K/L output.
reg[FIFO_L_bits-1：0]read_address，    ∥Track FIFO read addr.

　　    write_address，   ∥Track FIFO write adr.

　　    track_ram_address；  ∥Tracking ram address；
reg[lu_AddressSize-1：0]acc；     ∥Holds input variance.
reg[wordlength-4：0]xr_tmp1，    ∥|I|.

　　   xi_tmp1；    ∥|Q|.
				
				
reg[2：0]    r；      ∥Clock decode counter.
reg[1：0]    out_rx_guard；    ∥Determined guard.
reg[r_wordlength：0] f_ratio；    ∥Statistical F ratio.
reg[10：0]   fft_valid_count；  ∥Counts no of FFT vlds
reg[AddressSize-1：0]window_ram_addr，      ∥ram_address counter.

　　   ram_addr；
reg[14：0]  t_count，    ∥Window timing count.

　　    t_offset； ∥ Peak offset from t_ct
reg[14：0]    g_a_count；   ∥Guard_active counter.
reg[14：0]    dp_count；   ∥Datapath timing count
reg[14：0]    t_offset_avg；∥Averaged offset.
reg[2：0]     state，    ∥Acq/Track FSM state.

　　     old_state；   ∥Old tracking state.
reg[9：0]    guard_length；   ∥Thresholded guard len
reg[FIFO_A_bits：0] fifo_a_count；   ∥Count till fifo_a ful

　　          ∥1 bit more-＞retime
reg[r_wordlength-1：0]max_peak；    ∥Maximum positive peak
reg[wordlength-1：0]msb_out_tmp，   ∥Temporary stores for

　　     lsb_in_tmp； ∥even symbols to RAM.
wire[AddressSize-1：0]fft_ram_addr； ∥From FFT RAM addr gen
wire      clk，     ∥Master clock.

　　    nrst，     ∥ Power-up reset.

　　      enable_0_4，   ∥Clock enable 0 in 4.

　　    enable_1_4，   ∥Clock enable 1 in 4.

　　      enable_2_4，   ∥Clock enable 2 in 4.

　　      enable_3_4，    ∥Clock enable 3 in 4.

　　      enable_0_8，    ∥Clock enable 0 in 8.

　　     enable_1_8，    ∥Clock enable 1 in 8.

　　       enable_2_8，   ∥Clock enable 2 in 8.

　　       enable_3_8，    ∥Clock enable 3 in 8.

　　       enable_4_8，    ∥ Clock enable 4 in 8.

　　     enable_5_8，    ∥Clock enable 5 in 8.

　　       enable_6_8，    ∥Clock enable 6 in 8.

　　       enable_7_8，    ∥Clock enable 7 in 8.

　　       ram_enable_8，   ∥Acq FIFO enable.

　　       track_ram_enable，  ∥Tracking RAM enable

　　       track_ram_rnotw，  ∥Tracking RAM rnotw.

　　       even_symbol，   ∥valid on even symbols

　　       in_resync，    ∥Resync to acqn mode.

　　       pos_peak，     ∥+ve peak，ref only！

　　       dp_control，   ∥Datapath acq/trk ctl.

　　       t_offset_ctl， ∥Trk averager dp ctl.

　　       fft_ram_rnotw，

　　       fft_ram_enable；
wire[lu_AddressSize-1：0]lu_address；
wire[r_wordlength-1：0]lu_data，

　　   xri_tmp9；
wire[wordlength-3：0]xri_tmp2，

　　   xri_tmp4，

　　   xri_tmp5，

　　   in_q，

　　     out_q；
				
				
wire[wordlength-1：0]ram_in；
reg[wordlength-1：0]lsb_out，

　　     msb_out；
reg[wordlength-1：0]ram_out，

　　   msb_in，

　　    lsb_in；
wire[wordlength*2-1：0]ram10_out；
reg[wordlength*2-1：0]ram10_in；
reg[wordlength-1：0]x1r_10，x1i_10；
wire[wordlength-1：0]z2r_10，z2i_10；
wire[14：0]  out_test；
wire[14：0]  t_offset_diff， ∥Actual+/-difference

　　      t_offset_thresh， ∥Valid offset (maybe)

　　      t_offset_dly，   ∥Delayed of above.

　　      t_offset_scalled， ∥Scalled to t_offset.

　　      read_pos，     ∥ read trig，+ve offset

　　      read_neg，     ∥ read trig，-ve offset

　　      write_pos，    ∥ write trg，+ve offset

　　      write_neg；    ∥write trg，-ve offset
assign out_test＝t_offset_diff；
∥--------------------------------------------------
∥    Fast 40 MHz clock decoder and valid in control.
∥--------------------------------------------------
always @(posedge clk)
if(！nrst)        ∥ Synchronous power-up reset.
 r＜＝0；
else if(valid_in)      ∥Count if input data valid.
 r＜＝r+1′b1；
assign enable_0_4＝valid_in & (～r[1] &～r[0])； ∥Gate valid_in with
assign enable_1_4＝valid_in & (～r[1] & r[0])；∥decoded enable signals
assign enable_2_4＝valid_in & (r[1] & ～r[0])；∥to control all reg′s.
assign enable_3_4＝valid_in & (r[1] & r[0])； ∥ Enables every 4 clk′s
assign enable_1_8＝valid_in & (～r[2] &～r[1] & r[0])；
assign enable_2_8＝valid_in & (～r[2] & r[1] & ～r[0])；
assign enable_3_8＝valid_in & (～r[2] & r[1] & r[0])；
assign enable_4_8＝valid_in & (r[2] & ～r[1] & ～r[0])；∥Enables every 8
assign enable_5_8＝valid_in & (r[2] & ～r[1] & r[0])；∥clk′s
assign enable_6_8＝valid_in & (r[2] & r[1] & ～r[0])；
assign enable_7_8＝valid_in & (r[2] & r[1] & r[0])；
∥--------------------------------------------------
∥The entire data path incorporating the FIFO′s，ROM and comparators.
∥--------------------------------------------------
∥Register the data inputs to the windowing module.
always @(posedge clk)
if(in_resync||nrst)
				
				
begin
   xr_reg＜＝in_xr；
   xi_reg＜＝in_xi；
 end
else if(enable_3_4)
 begin
   xr_reg＜＝in_xr；
   xi_reg＜＝in_xi；
 end
∥Take the modulus of in_xr and in_xi and add together (|in_xr|+|in_xi|).
always @(xr_reg or xi_reg)
begin
 if(xr_reg[wordlength-3])    ∥Checking MSB for negative number.
   xr_tmp1＝-xr_reg；
 else
   xr_tmp1＝xr_reg；
 if(xi_reg[wordlength-3])   ∥Checking MSB for negative number.

　　xi_tmp1＝-xi_reg；
 else

　　xi_tmp1＝xi_reg；
 xri_tmp1＝xr_tmp1+xi_tmp1；
 end
assign even_symbol＝r[2]；
always @(even_symbol or msb_out_tmp or ram_in or lsb_out)∥Mux MSB/LSB to
 if(even_symbol)          ∥allow 1K RAM
  begin           ∥to act as a 2K

　　ram_out＝lsb out；        ∥FIFO，possible

　　lsb_in_tmp＝ram_in；        ∥since data
  end             ∥bitwidth is 2b
 else             ∥bits wide in
  begin            ∥the 1K RAM and

　　ram_out＝msb_out_tmp；        ∥only b bits are

　　msb_in＝ram_in；         ∥required in the

  end             ∥data path.
 always @(posedge clk)         ∥Delay even
 begin             ∥symbols by one
  if(enable_5_8)        ∥symbol so that

　　 lsb_in＜＝lsb_in_tmp；  ∥two symbols are
  if(enable_7_8)            ∥written & read

　　 msb_out_tmp＜＝msb_out；           ∥to the ram.
  end
 assign xri_tmp2＝ram_out；           ∥Map RAM I/O
 assign ram_in＝xri_tmp1；          ∥to dp wires.
 always @(ram10_out or msb_in or lsb_in or z2r_10 or z2i_10

　　    or ram_enable_8 or enable_3_8

　　       or fft_ram_enable or fft_ram_rnotw

　　       or window_ram_addr or fft_ram_addr

　　       or tracking)    ∥FFT/WINDOW FIFO
				
				
begin               ∥RAM Mux code.
if(！tracking)        ∥ In window acq
   begin            ∥mode.

　　msb_out＝ram10_out[2*wordlength-1：wordlength]；

　　lsb_out＝ram10_out[wordlength-1：0]； ∥Connect window

　　ram10_in[2*wordlength-1：wordlength]＝msb_in；∥datapath & RAM

　　ram10_in[wordlength-1：0]＝lsb_in；   ∥control signals

　　ram_enable＝ram_enable_8；

　　ram_rnotw＝enable_3_8；

　　ram_addr＝window_ram_addr；
   end
 else             ∥In tracking
   begin           ∥mode，therefore

　　x1r_10＝ram10_out[2*wordlength-1：wordlength]； ∥FFT functional.

　　x1i_10＝ram10_out[wordlength-1：0]；

　　ram10_in[2*wordlength-1：wordlength]＝z2r_10； ∥Connect FFT

　　ram10_in[wordlength-1：0]＝z2i_10；    ∥datapath & RAM

　　ram_enable＝fft_ram_enable；      ∥control signals

　　ram_rnotw＝fft_ram_rnotw；

　　ram_addr＝fft_ram_addr；

   end
end
assign track ram rnotw＝enable_3_4 & read；
assign track_ram_enable＝(enable_3_4 & read)||(enable_1_4 & write)；
∥Select which FIFO we read data from depending on tracking or acquire mode.
always @(xri_tmp5 or xri_tmp2 or tracking)
 if(tracking)
 xri_tmp6＝xri_tmp5；         ∥ Tracking mode
else               ∥data.
 xri_tmp6＝xri_tmp2；         ∥ Acquisition

　　              ∥ mode data.
∥ Perform computation of s(i-j)
always @(xri_tmp1 or xri_tmp6)
 xri_tmp7＝xri_tmp1-xri_tmp6；
∥Take the modulus of xri_tmp7；
always @(xri_tmp7)
 if (xri_tmp7[wordlength-2])       ∥ Check MSB for
 xri_tmp3＝-xd_tmp7；        ∥ neg number.
 else
  xri_tmp3＝xri_tmp7；
∥ Setup FIFO to perform moving summation of s(i-j) values.
fft_sr_addr #(wordlength-2，FIFO_N)sr_N(clk，dp_control，∥Length＝FIFO_N.

　　            xri_tmp3，  ∥Input.

　　            xri_tmp4)；  ∥Output.
∥Compute the moving summation i.e S(i-j)＝s(i-1，j-1)+s(i-2，j-2)+...
∥We must NOT truncate or round acc as the error will grow across a symbol.
always @(posedge clk)
 if (in_resync||！nrst||dpctl_reset)  ∥Clear accumulator at
  acc＜＝0；          ∥power-up or Resync or trk.
 else if (dp_control & acc_add)     ∥Wait until acc data valid.
  ∥Subtract as well as add when 2K/8K FIFO is full.
				
				
 acc＜＝acc+xri_tmp3-((acc_add_sub)？xri_tmp4：0)；
assign lu_address＝acc； ∥Ensure lu_address is large enough to

　　       ∥accomodate acc number range.
fft_window_lu #(r_wordlength，lu_AddressSize)  ∥Case table instance
log_lu(clk，dp_control，lu_address，lu_data)；∥for a log lookup.
∥Setup 5 bit FIFO to determine the delayed variance.
fft_sr_addr #(r_wordlength，FIFO_n)sr_n(clk，dp_control，∥Length＝FIFO_n

　　          lu_data，  ∥Input.

　　          xri_tmp9)；∥Output.
∥Determine difference of logs and hence the f_ratio when it is valid.
always @(lu_data or xri_tmp9 or f_ratio_valid)
f_ratio＝(f_ratio_valid)？lu_data-xri_tmp9：1′b0；
∥--------------------------------------------------
∥       Positive threshold (for information only)
∥--------------------------------------------------
assign pos_peak＝((f_ratio＞＝pos_threshold &&

　　   f_ratio＜(1＜＜r_wordlength))？1′b1：1′b0)；
∥--------------------------------------------------
∥     FFT window datapath control registers.
∥--------------------------------------------------
always @(posedge clk)
 if(in_resync||！nrst||dpctl_reset)    ∥Synchronous reset.
  begin

　　f_ratio_valid＜＝1′b0；      ∥Initalise datapath

　　acc_add＜＝1′b0；         ∥control registers.

　　 acc_add_sub＜＝1′b0；
  end
 else if(enable_3_4 &&～read)       ∥Acquisition mode
  begin             ∥ Use 2K/8K FIFO.

　　 if(dp_count＝＝2047+FIFO_N+FIFO_n+1+1)∥f_ratio only valid

　　 f_ratio_valid＜＝1′b1； ∥after sum of FIFO

　　 if(dp_count＝＝2047)       ∥+acc+ROM latencys

　　 acc_add＜＝1′b1；      ∥Add if acc full.

　　 if(dp_count＝＝2047+FIFO_N)      ∥Add/sub when FIFO

　　  acc_add_sub＜＝1′b1；    ∥N is full.

  end
  else if(enable_3_4 && read)     ∥Tracking mode
  begin              ∥Use FIFO L.

　　 if(dp_count＝＝FIFO_L+FIFO_N+FIFO_n+1+1)∥f_ratio only valid

　　  f_ratio_valid＜＝1′b1；      ∥after sum of FIFO

　　 if(dp_count＝＝FIFO_L)           ∥+acc+ROM latencys

　　  acc_add＜＝1′b1；        ∥Add if acc full.

　　 if(dp_count＝＝FIFO_L+FIFO_N)           ∥Add/sub when FIFO

　　  acc_add_sub＜＝1′b1；     ∥N is full.
  end
 always @(posedge clk)
  if(in_resync||！nrst)        ∥Synchronous reset.
				
				
 fifo_a_add_sub＜＝0；
else if(enable_3_4 && fifo_a_count＝＝FIFO_A)  ∥fifo_a is full
 fifo_a_add_sub＜＝1；         ∥so add and sub.
always @(posedge clk)
if(in_resync||！nrst)        ∥Synchronous reset.
 t_offset_avg_valid＜＝1′b0；     ∥Average value is
else if(enable_3_4 && fifo_ac_ount＝＝FIFO_A+1)    ∥valid one cycle
 t_offset_avg_valid＜＝1′b1；   ∥after add_sub sig.
assign dp_control＝enable_3_4 &&         ∥Datapath enable

　　   (～track_mode||track_mode && read)；∥in acq/track mode.
assign t_offset_ctl＝enable_3_4 && t_offset_valid∥clock averager

　　    && pulse &&！read && tracking； ∥dp control signal.
∥-------------------------------------------------------
∥ FFT window timing and sync acquisition/tracking timing counters.
∥-------------------------------------------------------
always @(posedge clk)
 if(in_resync||Inrst||t_reset)   ∥Synchronous power-up reset.
 t_count＜＝ 0；       ∥Reset main timing counter.
 else if(enable_3_4 && t_retime_acq)  ∥Retime to count from last
 t_count＜＝t_count-guard_active；  ∥peak to current time.
 else if(enable_3_4 &&～track_mode)  ∥Count if not in track mode
 t_count＜＝t count+1′b1；
 else if(enable_3_4 && t_retime_trk)  ∥Otherwise must be in track
  t_count＜＝t_count-guard_active   ∥so advance timing for acq

　　  +(2*FIFO_N+FIFO_n+2)；∥FIFO_L read trig point then
 else if(enable_3_4)
  begin         ∥wrap round t count at

　　if(t_count＝＝2047+guard_length)  ∥end of guard+active length.

　　 t_count＜＝0；      ∥ Needed as a reference to

　　else          ∥track peak movement in

　　 t_count＜＝t_count+1′b1；   ∥capture window.
  end
always @(posedge clk)
 if(in_resync||！nrst||g_a_reset)  ∥Synchronous power-up reset.
  g_a_count＜＝0；       ∥Reset guard_active counter.
 else if(enable_3_4 && f_ratio_valid)  ∥g_a count when f ratio vald
  g_a_count＜＝g_a_count+1′b1；     ∥ Guard active timing counter
always @(posedge clk)       ∥Datapath timing counter.
 if(in_resync||！nrst||dpctl_reset)  ∥ Synchronous reset.
  dp_count＜＝ 0；        ∥Reset datapath control.
 else if(enable_3_4 && ～track_mode)  ∥Always count in acquire
  dp_count＜＝dp_count+1′b1；    ∥mode on clk 0.
 else if(enable_3_4 && track_mode && read) ∥Count when reading data in
  dp_count＜＝dp_count+1′b1；    ∥tracking mode.
 always @(posedge clk)
 if(in_resync||！nrst)      ∥Synchronous reset.
  fifo_a_count＜＝0；
 else if(enable_3_4 && t_offset_ctl)  ∥Only clock averager if Trk
				
				
 fifo_a_count＜＝fifo a count+1′b1；  ∥and t_offset is valid.
always @(posedge clk)      ∥Create pulse on entering
if(enable_3_4)       ∥track 4 or track 5 to clk
 begin         ∥t_offset_ctl once per state
   if((state＝＝track1&&   ∥transition. We need to

　　 old_state！＝track1)||   ∥clock the averager only

　　 (state＝＝track2 &&    ∥once on entering state 4 or

　　 old_state！＝track2))    ∥state 5 hence t_offset_ctl

　　pulse＜＝1′b1；      ∥is gated with pulse.
   else

　　pulse＜＝1′b0；
   old_state＜＝state；
 end
always @(posedge clk)
 if(in_resync||！nrst)
 tracking＜＝1′b0；      ∥Read from 2K/8K FIFO first.
 else if(enable_3_4 && track_mode

　　 && dp_count＝＝FIFO_L+1)  ∥Check if FIFO_L full in trk
 tracking＜＝1′b1；      ∥then read tracking FIFO_L.
∥----------------------------------------------------
∥   FFT window timing and sync acquisition/tracking FSM
∥----------------------------------------------------
always @(posedge clk)      ∥Acquisition mode FSM.
 if(in_resync||！nrst)     ∥ Synchronous power-up reset.
  begin

　　state＜＝start；      ∥FSM starts in resync.

　　track mode＜＝1′b0；     ∥Start in acquisition mode.

　　t_reset＜＝1′b0；      ∥Reset main timing counter.
  dpctl_reset＜＝1′b0；     ∥dp_ctl out of reset.

　　g_a_reset＜＝1′b0；      ∥Reset guard_active counter.

　　max_peak＜＝1′b0；      ∥Reset max peak value.

　　retry＜＝0；         ∥Reset no of retry′s.

　　acq_symbols＜＝0；      ∥Reset acquired no symbols.

　　guard_valid＜＝1′b0；      ∥Guard data is valid.

　　t_retime_acq＜＝1′b0；     ∥Do not retime at resync.

　　t_retime_trk＜＝1′b0；     ∥Do not retime at resync.
   end
 else if(enable_3_4)
  case (state)
/*S0*/ start：begin

　　  g_a_reset＜＝1′b0；     ∥g_a_reset out of rst

　　     t_reset＜＝1′b0；     ∥t_count out of reset.

　　     guard_valid＜＝1′b0；    ∥Guard invalid.

　　     ∥MUST ACT ON RETRYS TOO！！

　　     state＜＝peak1；     ∥Enter peak1 state.

　　     end
/*S1*/  peak1：begin

　　  t_reset＜＝1′b0；      ∥t_count out of reset.

　　  if(g_a_count＜2048+512)   ∥Search for pos peak1

　　      begin

　　    if (f_ratio＞max_peak &&
				
				
　　       f_ratio＜(1_＜＜r_wordlength))∥Is new peak larger？

　　       begin

　　      max_peak＜＝f_ratio；  ∥If so assign max_peak

　　      t_reset＜＝ 1；    ∥Reset timing counter.

　　        end

　　     end

　　     else        ∥First block complete.

　　     begin

　　      t_reset＜＝1′b0；    ∥t_count out of reset.

　　      g_a_reset＜＝1′b1；    ∥ Reset g_a_count.

　　      max_peak＜＝1′b0；    ∥Reset max peak value.

　　      state＜＝peak2；    ∥Next block search.

　　      end

　　    end
/*S2*/ peak2：begin

　　  g_a_reset＜＝1′b0；     ∥Next block start cnt

　　     if(g_a_count＜2048+512)      ∥Search for pos peak2

　　      begin

　　   if(f_ratio＞max_peak &&

　　       f_ratio＜(1＜＜r_wordlength)) ∥Is new peak larger？

　　        begin

　　        max_peak＜＝f_ratio；  ∥If so assign max_peak

　　        guard_active＜＝t_count； ∥Assign guard_active.

　　         end

　　      end        ∥Second block complete

　　     else if(∥First，one peak per block situation (large guards)

　　        (guard_active＜(2560+delta)&& ∥Test for 2048+512

　　     guard_active＞(2560-delta))||∥pt guard length.

　　       (guard_active＜(2304+delta)&& ∥Test for 2048+256

　　       guard_active＞(2304-delta))||∥pt guard length.

　　       (guard_active＜(2176+delta)&& ∥Test for 2048+128

　　        guard_active＞(2176-delta))||∥pt guard length.

　　       (guard_active＜(2112+delta)&& ∥Test for 2048+64

　　        guard_active＞(2112-delta))||∥pt guard length.

　　       ∥ Now two peaks per block situation (small guards)

　　       (guard_active＜(5120+delta)&& ∥Test 4096+512+512

　　      guard_active＞(5120-delta))||∥pt guard length.

　　       (guard_active＜(4608+delta)&& ∥Test 4096+256+256

　　       guard_active＞(4608-delta))||∥pt guard length.

　　       (guard_active＜(4352+delta)&& ∥Test 4096+128+128

　　        guard_active＞(4352-delta))||∥pt guard length.

　　       (guard_active＜(4224+delta)&& ∥Test 4096+64+64

　　        guard_active＞(4224-delta))) ∥pt guard length.

　　       begin

　　       state＜＝peak3；    ∥Next peak search.

　　          g_a_reset＜＝1′b1；   ∥Reset g_a_count.

　　       max_peak＜＝1′b0；   ∥Reset maximum peak.

　　       guard_valid＜＝1′b1；
				
				
　　      t_retime_acq＜＝1′b1；

　　       end

　　     else        ∥Acquisition failed so

　　     begin       ∥jump to start and

　　      state＜＝start；∥increment the retry

　 　     retry＜＝retry+1′b1；   ∥counter.

　　      t_reset＜＝1′b1；   ∥Reset t_count.

　　      g_a_reset＜＝1′b1；    ∥Reset g_a_count.

　　      max_peak＜＝1′b0；    ∥Reset maximum peak.

　　     end

　　    end
/*S3*/ peak3：begin

　　  t_retime_acq＜＝1′b0；

　　     g_a_reset＜＝1′b0；     ∥Next block start cnt

　　     if(g_a_count＜2048+512)   ∥Search for pos peak2

　　      begin

　　   if (f_ratio＞max_peak &&

　　       f_ratio＜(1＜＜r_wordlength))∥Is new peak larger？

　　        begin

　　        max_peak＜＝f_ratio；  ∥If so assign max_peak

　　        guard_active＜＝t_count； ∥Assign guard_active.

　　         end

　　      end        ∥third block complete

　　     else if(∥First，one peak per block situation (large guards)

　　        (guard_active＜(2048+guard_length∥Peak test 2048

　　             +delta)&& ∥+guard length.

　　     guard_active＞(2048+guard_length

　　             delta))||

　　       ∥Now two peaks per block situation (small guards)

　　       (guard_active＜(4096+(2*guard_length)∥Peak 4096+2

　　             +delta)&& ∥*guard length.

　　       guard_active＞(4096+(2*guard_length)

　　             -delta)))

　　      begin

　　       acq_symbols＜＝acq_symbols+1′b1 ；∥Another sym acqurd

　　          g_a_reset＜＝1′b1；   ∥Reset g_a_count.

　　       max_peak＜＝1′b0；   ∥Reset maximum peak.

　　       t_retime_trk＜＝1′b1；  ∥Retimet_count to trk

　　       track_mode＜＝1′b1；  ∥Enter track mode.

　　     dpctl_reset＜＝1′b1；  ∥Reset datapath count

　　          state＜＝track1；   ∥Enter track1 state.

　　       end

　　     else             ∥Acquisition failed so

　　      begin           ∥jump to start and

　　       state＜＝start；    ∥increment the retry

　　       retry＜＝retry+1′b1；   ∥counter.

　　       t_reset＜＝1′b1；     ∥Reset t_count.

　　       g_a_reset＜＝′b1；     ∥Reset g_a_count.

　　       max_peak ＜＝1′b0；     ∥Reset maximum peak.

　　      end

　　  end
/*S4*/track1： begin

　　     t_retime_trk＜＝1′b0；    ∥t_count out retime.
				
				
　　    dpctl_reset＜＝1′b0；    ∥dp ctl out of reset.

　　     if (read && f_ratio_valid)  ∥Peak detect on rd&vld

　　     begin

　　   if(f_ratio＞max_peak &&

　　       f_ratio＜(1＜＜r_wordlength)) ∥Is new peak larger？

　　       begin

　　      max_peak＜＝f_ratio；  ∥If so assign max_peak

　　      t_offset＜＝t_count；  ∥Store peak offset.

　　        end

　　      if(read_address＝＝FIFO_L-1) ∥If at end of FIFO_L

　　      begin       ∥ move to next state.

　　      state＜＝track2；    ∥(read_Addr＜＞FIFO_L)

　　      max_peak＜＝1′b0；   ∥Reset max peak value.

　　      end

　　     end

　　     else

　　      state＜＝track1；     ∥else wait in track1.

　　    end
/*S5*/track2：begin

　　     if (read && f_ratio_valid)   ∥Peak detect on rd&vid

　　      begin

　　   if (f_ratio＞max_peak &&

　　       f_ratio＜(1＜＜r_wordlength)) ∥Is new peak larger？

　　       begin

　　       max_peak＜＝f_ratio；  ∥If so assign max_peak

　　      t_offset＜＝t_count；  ∥Store peak offset

　　         end

　　       if (read_address＝＝FIFO_L-1) ∥At end of FIFO_L

　　      begin      ∥move to next state.

　　       state＜＝track1；    ∥(read_Addr＜＞FIFO_L)

　　       max_peak＜＝1′b0；   ∥Reset max peak value.

　　      end

　　      end

　　     else

　　      state＜＝track2；     ∥Wait in this state.

　　     end

　　default：state＜＝3′bXXX；
  endcase
∥----------------------------------------------------
∥    FFT window output decode logic.
∥----------------------------------------------------
always @(posedge clk)
if(in_resync||！nrst)       ∥Synchronous reset.
 out_iqgi＜＝0；
else if (enable_3_4 && tracking &&

　　t_count＝＝15′d0-iqdemod_latency)  ∥iqgi guard start.
 out_iqgi＜＝1′b1；
else if(enable_3_4 && tracking &&

　　    t_count＝＝iqdemod_latency)∥iqgi guard stop.
 out_iqgi＜＝1′b0；
always @(posedge clk)
				
				
if(in_resync||！nrst)       ∥Synchronous reset.
 out_sincgi＜＝0；
else if(enable_3_4 && tracking &&

　　t_count＝＝15′d0 -sincint_latency)  ∥sincgi guard start.
 out_sincgi＜＝1′b1；
else if(enable_3_4 && tracking &&∥TO COMPLETE LATENCY STUFF

　　     t_count＝＝sincint_latency)∥sincgi guard stop.
 out_sincgi＜＝1′b0；
always @(posedge clk)        ∥Count over active
if (in_resync‖！nrst)       ∥interval to generate
 enable fft＜＝1′b0；       ∥FFT valid pulse.
else if (enable_3_4 && tracking &&
  t count ＝ guard_length + FIFO L/2_w_advance)∥FFT start point is
 enablefft＜＝1′b1；       /in middle of write
else if(enable_3_4 && tracking &&    ∥into FIFO L+advced.

　　      fft_valid_count＝＝2047) ∥ FFT stop after 2048
 enable_fft＜＝1′b0；       ∥samples.
always @(posedge clk)
 if(in_resync‖！nrst)       ∥Synchronous reset.
 fft_valid_count＜＝0；
 else if(enable_3_4 && tracking &&～enable_fft) ∥Valid count ＝ 0.
 fft_valid_count＜＝ 0；       ∥until fft is enabled.
 elseif(enable_3_4 && tracking && enable_fft)
 fft_valid_count＜＝ fi_valid_count+1′b1；  ∥Count when enabled.
assign valid_out＝enable_fft & valid_in； ∥MUST SYNCHROS Vld every 3 clks？
∥----------------------------------
∥     Synchronous RAM address generators.
∥---------------------------------
always @(posedge clk)      ∥ Acqsition FIFO address gen.
 if (！nrst ‖ in_resync)     ∥Synchronous reset.
  window ram addr ＜＝ 0；     ∥ Address gen for acq mode.
 else if (enable_2_8)
  window_ram_addr ＜＝ window_ram_addr + 1′b1；
assign ram enable 8 ＝enable 2 8‖ enable 3 8‖

　　     enabe 4 8‖ enable_5_8；
always @(posedge clk)       ∥Tracking FIFO address gen.
 begin
  if (！nrst ‖ in_resync)

　　begin

　　 read address ＜＝ 0；     ∥Reset track FIFO read addr.

　　 writeaddress ＜＝ 0；     ∥Reset track FIFO write addr

　　 write＜＝ 1′b0；      ∥Track FIFO， write disabled.

　　 read ＜＝ 1′b0；      ∥Track FIFO， read disabled.

　　 end
  else if (enable 3 4)

　　 begin

　　 if (track_mode && t_count ＝＝ 0)     ∥Track FIFO read

　　  read ＜＝ 1′b1；         ∥trigger point.
				
				
   if (read)          ∥Read if `read′

　　begin           ∥ flag is set.

　　 if(read_address＝＝FIFO_L-1)    ∥Stop read at

　　   begin         ∥end of FIFO.

　　    read_address＜＝0；

　　    read＜＝1′b0；       ∥Clr read flag.

　　   end

　　 else

　　 read_address＜＝read_address+1′b1；  ∥Inc r address.

　　end
  if(track_mode && t_count＝＝guard_length+1) ∥Write if the

　　write＜＝1′b1；         ∥read is guard

　　             ∥ depth into FIFO
  if(write)

　　begin

　　 if(write_address＝＝FIFO_L-1)    ∥Stop write at

　　   begin          ∥end of FIFO.

　　    write_address＜＝0；

　　    write＜＝1′b0；

　　   end

　　 else

　　   write_address＜＝ write_address+1′b1；  ∥Inc w address.
   end
   end
end
always @(enable_1_4 or enable_3_4 or read or write or ∥Assign read and
   read_address or write_address)    ∥write addresses
if(enable_3_4 && read)        ∥onto common
 track_ram_address＝read_address；     ∥address bus
else if(ena_ble_1_4 && write)       ∥for tracking
 track_ram_address＝write_address；       ∥tsyncram RAM.
∥-----------------------------------------------------
∥  Thresholding function to determine precise guard interval.
∥-----------------------------------------------------
always @(posedge clk)
if(enable_3_4 && guard_valid)
 begin
   ∥First，one peak per block situation (large guards)
   if(guard_active＜(2560+delta)&&   ∥Test for 2048+512

　　 guard_active＞(2560-delta))    ∥pt guard length.

　　begin

　　 out_rx_guard＜＝2′b11；

　　 guard_length＜＝512；

　　end
   if(guard_active＜(2304+delta)&&   ∥Test for 2048+256

　　 guard_active＞(2304-delta))    ∥pt guard length.

　　begin

　　 out_rx_guard＜＝2′b10；

　　 guard_length＜＝256；

　　end
				
				
if(guard_active＜(2176+delta)&&   ∥Test for 2048+128
  guard_active＞(2176-delta))  ∥pt guard length.
 begin
  out_rx_guard＜＝2′b01；
  guard_length＜＝128；
 end
 if(guard_active＜(2112+delta)&&   ∥Test for 2048+64
  guard_active＞(2112-delta))   ∥pt guard length.
 begin
  out_rx_guard＜＝2′b00；
  guard_length＜＝64；
 end
 ∥Now two peaks per block situation (small guards)
 if(guard_active＜(5120+delta)&&   ∥Test for 4096+512+512
  guard_active＞(5120-delta))    ∥512 pt guard length.
  begin
  out_rx_guard＜＝2′b11；
  guard_length＜＝512；
  end
 if(guard_active＜(4608+delta)&&   ∥Test for 4096+256+256
  guard_active＞(4608-delta))   ∥256 pt guard length.
  begin
   out_rx_guard＜＝2′b10；
   guard_length＜＝256；
  end
 if(guard_active＜(4352+delta)&&   ∥Test for 4096+128+128
   guard_active＞(4352-delta))    ∥128 pt guard length.
  begin
   out_rx_guard＜＝2′b01；
   guard_length＜＝128；
  end
  if(guard_active＜(4224+delta)&&   ∥Test for 4096+64+64
   guard_active＞(4224-delta))   ∥64 pt guard length.
  begin
   out_rx_guard＜＝2′b00；
   guard_length＜＝64；
  end
end
∥-----------------------------------------------------
∥    Averager for t_offset in tracking mode.
∥-----------------------------------------------------
assign t_offset_diff＝t_offset-(2*FIFO_N+FIFO_n)；∥dly 2 for latency？
always @(posedge clk)
if(in_resync||！nrst)∥NEED TO ENABLE THIS！！！！！！
 t_offset_valid＜＝0；
else if((t_offset_diff＜(1＜＜14+1)-t_offset_threshold &&∥Neg

　　t_offset_diff＞(1＜＜14-1))||

　　 (t_offset_diff＞t_offset_threshold &&     ∥Pos
				
				
　　  t_offset_diff＜(1＜＜14))∥CORRECT TO DETECT vld＝1not 0

　　)
 t_offset_valid＜＝0；
else
 t_offset_valid＜＝1；

assign t_offset_thresh＝(t_offset_valid)？t_offset_diff：0；
∥Setup FIFO to perform moving summation of t_offset values.
fft_sr_addr #(15，FIFO_A) sr_A(clk，t_offset_ctl，

　　          t_offset_thresh，  ∥Input.

　　          t_offset_dly)；  ∥Output.
∥Compute the moving summation i.et_offset(i-1)+t_offset(i-2)+...
∥We must NOT truncate or round acc as the error will grow across a symbol.
always @(posedge clk)
 if(in_resync||！nrst)      ∥Clear accumulator at
 t_offset_avg＜＝0；       ∥power-up or Resync.
 else if(t_offset_ctl)     ∥Wait until t_offset valid.
 ∥Subtract as well as add when averager is full.
 t_offset_avg＜＝t_offset_avg+t_offset_thresh

　　      -((fifo_a_add_sub)？t_offset_dly：0)；
assign t_offset_scalled＝
   {{(FIFO_A_bits){t_offset_avg[14]}}，t_offset_avg[14：FIFO_A_bits]}；
∥-----------------------------------------------------
∥Code to determine conditions for advancing/retarding tracking window.
∥-----------------------------------------------------
assign read_pos＝t_offset_scalled；      ∥+ve(late)so

　　             ∥delay read
assign read_neg＝2047+guard_length+1-    ∥-ve(early) so

　　(～t_offset_scalled+1)； ∥advance read
assign write_pos＝guard_length+1+     ∥+ve(late)so

　　 t_offset_scalled；      ∥delay write
∥PROBLEMS WHEN offset＞guard_length+1
∥(should not happen as we range check peaks in acq mode)
assign write_neg＝guard_length+1-    ∥-ve(early)so

　　 (～t_offset_scalled+1)；  ∥advance write
endmodule

                                  Listing 15

∥Sccsld：％W％ ％G％
/***************************************************************************

　　Copyright(c)1997 Pioneer Digital Design Centre Limited
Author：Dawood Alam.
Description：Verilog code for a structural netlist coupling the Fast Fourier

　　Transform(FFT)processor to the window acquisition hardware.
				
				
Notes：
****************************************************************************/
`timescale 1ns/100ps
module fft_top   (i_data，

　　     q_data，

　　       clk，

　　       nrst，

　　       in_resync，

　　       in 2k8k，

　　       valid_in，

　　       ram4_in，

　　     ram5_in，

　　     ram6_in，

　　     ram7_in，

　　     ram8_in，

　　     ram9_in，

　　       ram10_in，

　　     i_out，

　　       q_out，

　　       out_ovf，

　　     enable_0，

　　       enable_1，

　　       enable_2，

　　       enable_3，

　　     valid_out，

　　       ram4_out，

　　     ram5_out，

　　       ram6_out，

　　     ram7_out，

　　       ram8_out，

　　       ram9 out，

　　       ram10_out，

　　       ram_addr，

　　       ram_enable，

　　       ram_rnotw，

　　       rom3_addr，

　　       rom4_addr，

　　       rom3_data，

　　       rom4_data，

　　       track_addr，

　　       track_data_in，

　　      track_data_out，

　　        track_rnw，

　　      track_ram_enable，

　　        out_rx_guard，

　　        out_iqgi，

　　      out_sincgi，

　　        out_test)；
 ∥-----------------------------------------------------
 ∥      Parameter definitions.
 ∥-----------------------------------------------------
				
				
parameter    wordlength＝12；  ∥Data wordlength.
parameter    c_wordlength＝10；  ∥Coeff wordlength.
parameter    AddressSize＝13；  ∥Size of address bus.
parameter    rom_AddressSize＝13； ∥ROM address bus size.
parameter    mult_scale＝3； ∥Multiplier scalling：

　　          ∥1＝/4096，2＝/2048，

　　          ∥3＝/1024，4＝/512.
parameter    r_wordlength＝10； ∥ROM data wordlength.
parameter    FIFO_L＝256；   ∥Tracking FIFO length.
parameter    FIFO_L_bits＝8；  ∥Track FIFO addr bits
parameter    FIFO_N＝64；   ∥Acc length S(i-j).
parameter    FIFO_n＝64；   ∥Acc length S(i-n-j).
parameter    FIFO_A＝32；   ∥t_offset delay FIFO.
parameter    FIFO_A_bits＝5； ∥Track FIFO bits.
parameter    lu_AddressSize＝15；∥log rom address size.
parameter    data＝20；    ∥Gu threshold distance
parameter    acquired_symbols＝2；∥Acq symbls before trk
parameter    pos_threshold＝3； ∥for info only.
parameter    t_offset_threshold＝10；∥t offset valid thresh
parameter    w advance＝10；     ∥win trig frm boundary
parameter    sincint_latency＝2；∥Latency to sinc intep
parameter    iqdemod_latency＝168； ∥Latency to IQ demod.
∥-------------------------------------------------
∥     Input/Output ports.
∥-------------------------------------------------
input    clk，      ∥Master clock.

　　  nrst，     ∥Power-up reset.

　　    in_2k8k，    ∥2K mode active low.

　　    valid_in，   ∥Input data valid.

　　    in_resync；
input[9：0]i_data，     ∥FFT input data，I.

　　     q_data；   ∥ FFT input data，Q.
input[wordlength-3：0] track_data_out；
input[wordlength*2-1：0] ram4_out，    ∥Couple the I/Q data

　　    ram5_out，       ∥outputs from the

　　      ram6_out，      ∥memory to the

　　    ram7_out，      ∥respective butterfly

　　      ram8_out，     ∥processors.

　　      ram9_out，

　　      ram10_out；
 input[c_wordlength*2-1：0]rom3_data，

　　     rom4_data；
 output[rom_AddressSize-6：0]rom3_addr；
 output[rom_AddressSize-4：0]rom4_addr；
 output[14：0]   out_test；   ∥Temp testpin output.
 output[1：0]    out_rx_guard；  ∥Acquired gu length.
				
				
output [wordlength-3：0] track_data_in；
output [wordlength*2-1：0] ram4_in，    ∥Couple the I/Q data

　　      ram5_in，    ∥outputs of each BF

　　      ram6_in，    ∥processor to their

　　      ram7_in，     ∥respective memory

　　      ram8_in，    ∥inputs.

　　       ram9_in，

　　          ram10_in；
output[AddressSize-1：0]ram_addr；       ∥RAM address bus.
output     out_ovf，    ∥Overflow flag.

　　    enable_0，    ∥ Enable clock 0.

　　    enable_1，    ∥ Enable clock 1.

　　    enable_2，    ∥ Enable clock 2.

　　    enable_3，    ∥ Enable clock 3.

　　     valid_out，    ∥ Output data valid.

　　     ram_enable，    ∥RAM enable.

　　     ram_motw，

　　     track_rnw，

　　   track_ram_enable，

　　     out_iqgi，

　　   out_sincgi；
 output[FIFO_L_bits-1：0]track_addr；
 output[wordlength-1：0]i_out，     ∥FFT output data， I.

　　       q_out；     ∥FFT output data，Q.
 ∥-----------------------------------------------------
 ∥        Wire/register declarations.
 ∥-----------------------------------------------------
 wire[9：0]       i_data，     ∥FFT/WIN input I.

　　      q_data；       ∥FFT/WIN output Q.
 wire[wordlength-1：0]i_out，     ∥FFT output data，I.

　　      q_out；     ∥FFT output data，Q.
 wire[wordlength*2-1：0]ram4_in，

　　    ram5_in，

　　    ram6_in，

　　    ram7_in，

　　    ram8_in，

　　    ram9_in，

　　      ram10_in；
 wire[wordlength*2-1：0]ram4_out，

　　    ram5_out，
　　      ram6_out，

　　    ram7_out，

　　      ram8_out，

　　      ram9_out，

　　      ram10_out；
				
				
wire[AddressSize-1：0]ram_addr，     ∥RAM address bus.

　　   ram_addr_fft_2_win；
wire      clk，

　　   nrst，

　　     in_2k8k，

　　   in_resync，

　　   valid_in，

　　     out_ovf，

　　     enable_0，

　　     enable_1，

　　     enable_2，

　　     enable_3，

　　    valid_out，

　　    ram_enable，    ∥RAM enable signal.

　　      ram_rnotw，

　　    valid_win_2_fft，

　　      ram_rnotw_fft_2_win，

　　      ram_enable_fft_2_win，

　　    track_rnw，

　　    track_ram_enable，

　　      out_iqgi，

　　    out_sincgi；
wire[wordlength-1：0]x1r_10，x1i_10，

　　   z2r_10，z2i_10；
 wire[wordlength-3：0]track_data_in，

　　    track_data_out；
 wire[FIFO_L_bits-1：0]track_addr；
 wire[1：0]  out_rx_guard；    ∥Determined guard.
 wire[c_wordlength*2-1：0]rom3_data，

　　    rom4_data；
 wire[rom_AddressSize-6：0]rom3_addr；
 wire[rom_AddressSize-4：0]rom4_addr；
 wire[14：0] out_test；
∥-----------------------------------------------------
∥    Instance FFT processor.
∥-----------------------------------------------------
fft_r22sdf   #(wordlength，

　　     c_wordlength，

　　       AddressSize，

　　     rom_AddressSize，

　　       mult_scale)

　　      fft(.in_xr(i_data)，   ∥FFT input data，I.

　　      .in_xi(q_data)，   ∥FFT input data，Q

　　      .clk(clk)，    ∥Master clock.

　　      .nrst(nrst)，    ∥Power-up reset.

　　         .in_2k8k(in_2k8k)，   ∥2K active low.
				
				
   .valid_in(valid_win_2_fft)，∥Input valid.
.out_xr(i_out)，   ∥FFT output data，I.
  .out_xi(q_out)，   ∥FFT output data，Q.
   .out_ovf(out_ovf)，  ∥Overflow flag.
.enable_0(enable_0)，
  .enable_1(enable_1)，
  .enable_2(enable_2)，
  .enable_3(ram_rnotw_fft_2_win)，
   .valid_out(valid_out)，
  .ram_address(ram_addr_fft_2_win)，
  .ram_enable(ram_enable_fft_2_win)，
  .address_rom3(rom3_addr)，
  .address_rom4(rom4_addr)，
  ∥RAM input ports.
   .z2r_4(ram4_in[wordlength-1：0])，
  .z2i_4(rom4_in[wordlength*2-1：wordlength])，
   .z2r_5(ram5_in[wordlength-1：0])，
  .z2i_5(ram5_in[wordlength*2-1：wordlength])，
   .z2r_6(ram6_in[wordlength-1：0])，
  .z2i_6(rom6_in[wordlength*2-1：wordlength])，
   .z2r_7(ram7_in[wordlength-1：0])，
  .z2i_7(ram7_in[wordlength*2-1：wordlength])，
   .z2r_8(ram8_in[wordlength-1：0])，
  .z2i_8(rom8_in[wordlength*2-1：wordlength])，
   .z2r_9(ram9_in[wordlength-1：0])，
  .z2i_9(ram9_in[wordlength*2-1：wordlength])，

　　.z2r_10(z2r_10)，∥Frm FFT datapath to window (I).
  .z2i_10(z2i_10)，∥Frm FFT datapath to window (Q).
  ∥RAM output ports.

　　.x1r_4(ram4_out[wordlength-1：0])，
  .x1i_4(ram4_out[wordlength*2-1：wordlength])，

　　.x1r_5(ram5_out[wordlength-1：0])，
  .x1i_5(ram5_out[wordlength*2-1：wordlength])，

　　.x1r_6(ram6_out[wordlength-1：0])，
  .x1i_6(ram6_out[wordlength*2-1：wordlength])，

　　.x1r_7(ram7_out[wordlength-1：0])，
   .x1i_7(ram7_out[wordlength*2-1：wordlength])，

　　.x1r_8(ram8_out[wordlength-1：0])，
   .x1i_8(ram8_out[wordlength*2-1：wordlength])，

　　.x1r_9(ram9_out[wordlength-1：0])，
   .x1i_9(ram9_out[wordlength*2-1：wordlength])，

　　.x1r_10(x1r_10)，∥To FFT datapath frm window (I).
   .x1i_10(x1i_10)，∥To FFT datapath frm window (Q).
   ∥ROM output ports.
   . br_3(rom3_data[c_wordlength*2-1：c_wordlength])，
   .bi_3(rom3_data[c_wordlength-1：0])，
   .br_4(rom4_data[c_wordlength*2-1：c_wordlength])，
   .bi_4(rom4_data[c_wordlength-1：0]))；
∥-----------------------------------------------------
∥ Instance FFT window processor.
∥-----------------------------------------------------
				
				
fft_window    #(wordlength，

　　     r_wordlength，

　　       AddressSize，

　　     FIFO_L，

　　     FIFO_L_bits，

　　     FIFO_N，

　　     FIFO_n，

　　     FIFO_A，

　　     FIFO_A_bits，

　　     lu_AddressSize，

　　     delta，

　　     acquired_symbols，

　　     pos_threshold，

 　　    t_offset_threshold，

　　       w_advance，

　　       sincint_latency，

　　       iqdemod_latency)

　　   window(.in_xr(i_data)，

　　      .in_xi(q_data)，

　　      .clk(clk)，

　　      .nrst(nrst)，

　　      .valid_in(valid_in)，

　　      .valid_out(valid_win_2_fft)，

　　      .in_resync(in_resync)，

　　      .out_iqgi(out_iqgi)，

　　      .out_sincgi(out_sincgi)，

　　      .out_rx_guard(out_rx_guard)，

　　      .out_acquired(out_acquired)，

　　      .out_fft_window(out_fft_window)，

　　      .enable_3_4(enable_3)，

　　      .out_test(out_test)，

　　       .track_ram_address(track_addr)，

　　       .xri_tmp1(track_data_in)，

　　       .xri_tmp5(track_data_out)，

　　       .track_ram_rnotw(track_rnw)，

　　       .track_ram_enable(track_ram_enable)，

　　         .ram_addr(ram_addr)，

　　            .ram_enable(ram_enable)，

　　            .ram_rnotw(ram_rnotw)，

　　         .ram10_in(ram10_in)， ∥To 1K x 24 bit RAM.

　　            .ram10_out(ram10_out)， ∥From 1K x 24 bit RAM.

　　            .x1r_10(x1r_10)，  ∥To FFTdatapath (I).

　　            .x1i_10(x1i_10)，  ∥To FFT datapath (Q).

　　            .z2r_10(z2r_10)，  ∥From FFT datapath (I)

　　            .z2i_10(z2i_10)，  ∥From FFT datapath (Q)

　　         .fft_ram_rnotw(ram_rnotw_fft_2_win)，

　　         .fft_ram_enable(ram_enable_fft_2_win)，

　　         .fft_ram_addr(ram_addr_fft_2_win))；
 endmodule

                                      Listing 16

　　  ∥2048 point FFT twiddle factor coefficients (Radix 4+2).

　　  ∥Coefficients stored as non-fractional 10 bit integers (scale 1).

　　  ∥Real Coefficient (cosine value) is coefficient high-byte.

　　  ∥Imaginary Coefficient (sine value) is coefficient low-byte.
				
				
0111111111_0000000000 ∥W0000_2048＝+1.000000   -0.000000
0111111111_1111111110 ∥W0001_2048＝+0.999995   -0.003068
0111111111_1111111101 ∥W0002_2048＝+0.999981   -0.006136
0111111111_1111111011 ∥W0003_2048＝+0.999958   -0.009204
0111111111_1111111010 ∥W0004_2048＝+0.999925   -0.012272
0111111111_1111111000 ∥W0005_2048＝+0.999882   -0.015339
0111111111_1111110111 ∥W0006_2048＝+0.999831   -0.018407
0111111111_1111110101 ∥W0007_2048＝+0.999769   -0.021474
0111111111_1111110011 ∥W0008_2048＝+0.999699   -0.024541
0111111111_1111110010 ∥W0009_2048＝+0.999619   -0.027608
0111111111_1111110000 ∥W0010_2048＝+0.999529   -0.030675
0111111111_1111101111 ∥W0011_2048＝+0.999431   -0.033741
0111111111_1111101101 ∥W0012_2048＝+0.999322   -0.036807
0111111111_1111101100 ∥W0013_2048＝+0.999205   -0.039873
0111111111_1111101010 ∥W0014_2048＝+0.999078   -0.042938
0111111111_1111101000 ∥W0015_2048＝+0.998941   -0.046003
0111111111_1111100111 ∥W0016_2048＝+0.998795   -0.049068
0111111111_1111100101 ∥W0017_2048＝+0.998640   -0.052132
0111111111_1111100100 ∥W0018_2048＝+0.998476   -0.055195
0111111111_1111100010 ∥W0019_2048＝+0.998302   -0.058258
0111111111_1111100001 ∥W0020_2048＝+0.998118   -0.061321
0111111111_1111011111 ∥W0021_2048＝+0.997925   -0.064383
0111111111_1111011101 ∥W0022_2048＝+0.997723   -0.067444
0111111111_1111011100 ∥W0023_2048＝+0.997511   -0.070505
0111111111_1111011010 ∥W0024_2048＝+0.997290   -0.073565
0111111110_1111011001 ∥W0025_2048＝+0.997060   -0.076624
0111111110_1111010111 ∥W0026_2048＝+0.996820   -0.079682
0111111110_1111010110 ∥W0027_2048＝+0.996571   -0.082740
0111111110_1111010100 ∥W0028_2048＝+0.996313   -0.085797
0111111110_1111010011 ∥W0029_2048＝+0.996045   -0.088854
0111111110_1111010001 ∥W0030_2048＝+0.995767   -0.091909
0111111110_1111001111 ∥W0031_2048＝+0.995481   -0.094963
0111111110_1111001110 ∥W0032_2048＝+0.995185   -0.098017
0111111101_1111001100 ∥W0033_2048＝+0.994879   -0.101070
0111111101_1111001011 ∥W0034_2048＝+0.994565   -0.104122
0111111101_1111001001 ∥W0035_2048＝+0.994240   -0.107172
0111111101_1111001000 ∥W0036_2048＝+0.993907   -0.110222
0111111101_1111000110 ∥W0037_2048＝+0.993564   -0.113271
0111111101_1111000100 ∥W0038_2048＝+0.993212   -0.116319
0111111100_1111000011 ∥W0039_2048＝+0.992850   -0.119365
0111111100_1111000001 ∥W0040_2048＝+0.992480   -0.122411
0111111100_1111000000 ∥W0041_2048＝+0.992099   -0.125455
0111111100_1110111110 ∥W0042_2048＝+0.991710   -0.128498
0111111100_1110111101 ∥W0043_2048＝+0.991311   -0.131540
0111111011_1110111011 ∥W0044_2048＝+0.990903   -0.134581
0111111011_1110111010 ∥W0045_2048＝+0.990485   -0.137620
0111111011_1110111000 ∥W0046_2048＝+0.990058   -0.140658
0111111011_1110110110 ∥W0047_2048＝+0.989622   -0.143695
0111111010_1110110101 ∥W0048_2048＝+0.989177   -0.146730
0111111010_1110110011 ∥W0049_2048＝+0.988722   -0.149765
0111111010_1110110010 ∥W0050_2048＝+0.988258   -0.152797
0111111010_1110110000 ∥W0051_2048＝+0.987784   -0.155828
0111111001_1110101111 ∥W0052_2048＝+0.987301   -0.158858
0111111001_1110101101 ∥W0053_2048＝+0.986809   -0.161886
0111111001_1110101100 ∥W0054_2048＝+0.986308   -0.164913
0111111001_1110101010 ∥W0055_2048＝+0.985798   -0.167938

				
				
0111111000_1110101000 ∥W0056_2048＝+0.985278   -0.170962
0111111000_1110100111 ∥W0057_2008＝+0.984749   -0.173984
0111111000_1110100101 ∥W0058_2048＝+0.984210   -0.177004
0111111000_1110100100 ∥W0059_2048＝+0.983662   -0.180023
0111110111_1110100010 ∥W0060_2048＝+0.983105   -0.183040
0111110111_1110100001 ∥W0061_2048＝+0.982539   -0.186055
0111110111_1110011111 ∥W0062_2048＝+0.981964   -0.189069
0111110110_1110011110 ∥W0063_2048＝+0.981379   -0.192080
0111110110_1110011100 ∥W0064_2048＝+0.980785   -0.195090
0111110110_1110011011 ∥W0065_2048＝+0.980182   -0.198098
0111110110_1110011001 ∥W0066_2048＝+0.979570   -0.201105
0111110101_1110010111 ∥W0067_2048＝+0.978948   -0.204109
0111110101_1110010110 ∥W0068_2048＝+0.978317   -0.207111
0111110101_1110010100 ∥W0069_2048＝+0.977677   -0.210112
0111110100_1110010011 ∥W0070_2048＝+0.977028   -0.213110
0111110100_1110010001 ∥W0071_2048＝+0.976370   -0.216107
0111110100_1110010000 ∥W0072_2048＝+0.975702   -0.219101
0111110011_1110001110 ∥W0073_2048＝+0.975025   -0.222094
0111110011_1110001101 ∥W0074_2048＝+0.974339   -0.225084
0111110011_1110001011 ∥W0075_2048＝+0.973644   -0.228072
0111110010_1110001010 ∥W0076_2048＝+0.972940   -0.231058
0111110010_1110001000 ∥W0077_2048＝+0.972226   -0.234042
0111110001_1110000111 ∥W0078_2048＝+0.971504   -0.237024
0111110001_1110000101 ∥W0079_2048＝+0.970772   -0.240003
0111110001_1110000100 ∥W0080_2048＝+0.970031   -0.242980
0111110000_1110000010 ∥W0081_2048＝+0.969281   -0.245955
0111110000_1110000001 ∥W0082_2048＝+0.968522   -0.248928
0111101111_1101111111 ∥W0083_2048＝+0.967754   -0.251898
0111101111_1101111110 ∥W0084_2048＝+0.966976   -0.254866
0111101111_1101111100 ∥W0085_2048＝+0.966190   -0.257831
0111101110_1101111010 ∥W0086_2048＝+0.965394   -0.260794
0111101110_1101111001 ∥W0087_2048＝+0.964590   -0.263755
0111101101_1101110111 ∥W0088_2048＝+0.963776   -0.266713
0111101101_1101110110 ∥W0089_2048＝+0.962953   -0.269668
0111101101_1101110100 ∥W0090_2048＝+0.962121   -0.272621
0111101100_1101110011 ∥W0091_2048＝+0.961280   -0.275572
0111101100_1101110001 ∥W0092_2048＝+0.960431   -0.278520
0111101011_1101110000 ∥W0093_2048＝+0.959572   -0.281465
0111101011_1101101110 ∥W0094_2048＝+0.958703   -0.284408
0111101010_1101101101 ∥W0095_2048＝+0.957826   -0.287347
0111101010_1101101011 ∥W0096_2048＝+0.956940   -0.290285
0111101001_1101101010 ∥W0097_2048＝+0.956045   -0.293219
0111101001_1101101000 ∥W0098_2048＝+0.955141   -0.296151
0111101001_1101100111 ∥W0099_2048＝+0.954228   -0.299080
0111101000_1101100101 ∥W0100_2048＝+0.953306   -0.302006
0111101000_1101100100 ∥W0101_2048＝+0.952375   -0.304929
0111100111_1101100010 ∥W0102_2048＝+0.951435   -0.307850
0111100111_1101100001 ∥W0103_2048＝+0.950486   -0.310767
0111100110_1101011111 ∥W0104_2048＝+0.949528   -0.313682
0111100110_1101011110 ∥W0105_2048＝+0.948561   -0.316593
0111100101_1101011100 ∥W0106_2048＝+0.947586   -0.319502
0111100101_1101011011 ∥W0107_2048＝+0.946601   -0.322408
0111100100_1101011001 ∥W0108_2048＝+0.945607   -0.325310
111100100_1101011000 ∥W0109_2048＝+0.944605    -0.328210
0111100011_1101010110 ∥W0110_2048＝+0.943593   -0.331106
0111100011_1101010101 ∥W0111_2048＝+0.942573   -0.334000
				
				
0111100010_1101010100 ∥W0112_2048＝+0.941544  -0.336890
0111100010_1101010010 ∥W0113_2048＝+0.940506  -0.339777
0111100001_1101010001 ∥W0114_2048＝+0.939459  -0.342661
0111100000_1101001111 ∥W0115_2048＝+0.938404  -0.345541
0111100000_1101001110 ∥W0116_2048＝+0.937339  -0.348419
0111011111_1101001100 ∥W0117_2048＝+0.936266  -0.351293
0111011111_1101001011 ∥W0118_2048＝+0.935184  -0.354164
0111011110_1101001001 ∥W0119_2048＝+0.934093  -0.357031
0111011110_1101001000 ∥W0120_2048＝+0.932993  -0.359895
0111011101_1101000110 ∥W0121_2048＝+0.931884  -0.362756
0111011101_1101000101 ∥W0122_2048＝+0.930767  -0.365613
0111011100_1101000011 ∥W0123_2048＝+0.929641  -0.368467
0111011011_1101000010 ∥W0124_2048＝+0.928506  -0.371317
0111011011_1101000000 ∥W0125_2048＝+0.927363  -0.374164
0111011010_1100111111 ∥W0126_2048＝+0.926210  -0.377007
0111011010_1100111110 ∥W0127_2048＝+0.925049  -0.379847
0111011001_1100111100 ∥W0128_2048＝+0.923880  -0.382683
0111011000_1100111011 ∥W0129_2048＝+0.922701  -0.385516
0111011000_1100111001 ∥W0130_2048＝+0.921514  -0.388345
0111010111_1100111000 ∥W0131_2048＝+0.920318  -0.391170
0111010111_1100110110 ∥W0132_2048＝+0.919114  -0.393992
0111010110_1100110101 ∥W0133_2048＝+0.917901  -0.396810
0111010101_1100110011 ∥W0134_2048＝+0.916679  -0.399624
0111010101_1100110010 ∥W0135_2048＝+0.915449  -0.402435
0111010100_1100110001 ∥W0136_2048＝+0.914210  -0.405241
0111010011_1100101111 ∥W0137_2048＝+0.912962  -0.408044
0111010011_1100101110 ∥W0138_2048＝+0.911706  -0.410843
0111010010_1100101100 ∥W0139_2048＝+0.910441  -0.413638
0111010001_1100101011 ∥W0140_2048＝+0.909168  -0.416430
0111010001_1100101001 ∥W0141_2048＝+0.907886  -0.419217
0111010000_1100101000 ∥W0142_2048＝+0.906596  -0.422000
0111010000_1100100111 ∥W0143_2048＝+0.905297  -0.424780
0111001111_1100100101 ∥W0144_2048＝+0.903989  -0.427555
0111001110_1100100100 ∥W0145_2048＝+0.902673  -0.430326
0111001101_1100100010 ∥W0146_2048＝+0.901349  -0.433094
0111001101_1100100001 ∥W0147_2048＝+0.900016  -0.435857
0111001100_1100011111 ∥W0148_2048＝+0.898674  -0.438616
0111001011_1100011110 ∥W0149_2048＝+0.897325  -0.441371
0111001011_1100011101 ∥W0150_2048＝+0.895966  -0.444122
0111001010_1100011011 ∥W0151_2048＝+0.894599  -0.446869
0111001001_1100011010 ∥W0152_2048＝+0.893224  -0.449611
0111001001_1100011000 ∥W0153_2048＝+0.891841  -0.452350
0111001000_1100010111 ∥W0154_2048＝+0.890449  -0.455084
0111000111_1100010110 ∥W0155_2048＝+0.889048  -0.457813
0111000110_1100010100 ∥W0156_2048＝+0.887640  -0.460539
0111000110_1100010011 ∥W0157_2048＝+0.886223  -0.463260
0111000101_1100010001 ∥W0158_2048＝+0.884797  -0.465976
0111000100_1100010000 ∥W0159_2048＝+0.883363  -0.468689
0111000100_1100001111 ∥W0160_2048＝+0.881921  -0.471397
0111000011_1100001101 ∥W0161_2048＝+0.880471  -0.474100
0111000010_1100001100 ∥W0162_2048＝+0.879012  -0.476799
0111000001_1100001010 ∥W0163_2048＝+0.877545  -0.479494
0111000001_1100001001 ∥W0164_2048＝+0.876070  -0.482184
0111000000_1100001000 ∥W0165_2048＝+0.874587  -0.484869
0110111111_1100000110 ∥W0166_2048＝+0.873095  -0.487550
0110111110_1100000101 ∥W0167_2048＝+0.871595  -0.490226
				
				
0110111101_1100000100 ∥W0168_2048＝+0.870087   -0.492898
0110111101_1100000010 ∥W0169_2048＝+0.868571   -0.495565
0110111100_1100000001 ∥W0170_2048＝+0.867046   -0.498228
0110111011_1100000000 ∥W0171_2048＝+0.865514   -0.500885
0110111010_1011111110 ∥W0172_2048＝+0.863973   -0.503538
0110111010_1011111101 ∥W0173_2048＝+0.862424   -0.506187
0110111001_1011111011 ∥W0174_2048＝+0.860867   -0.508830
0110111000_1011111010 ∥W0175_2048＝+0.859302   -0.511469
0110110111_1011111001 ∥W0176_2048＝+0.857729   -0.514103
0110110110_1011110111 ∥W0177_2048＝+0.856147   -0.516732
0110110110_1011110110 ∥W0178_2048＝+0.854558   -0.519356
0110110101_1011110101 ∥W0179_2048＝+0.852961   -0.521975
0110110100_1011110011 ∥W0180_2048＝+0.851355   -0.524590
0110110011_1011110010 ∥W0181_2048＝+0.849742   -0.527199
0110110010_1011110001 ∥W0182_2048＝+0.848120   -0.529804
0110110001_1011101111 ∥W0183_2048＝+0.846491   -0.532403
0110110001_1011101110 ∥W0184_2048＝+0.844854   -0.534998
0110110000_1011101101 ∥W0185_2048＝+0.843208   -0.537587
0110101111_1011101011 ∥W0186_2048＝+0.841555   -0.540171
0110101110_1011101010 ∥W0187_2048＝+0.839894   -0.542751
0110101101_1011101001 ∥W0188_2048＝+0.838225   -0.545325
0110101100_1011100111 ∥W0189_2048＝+0.836548   -0.547894
0110101011_1011100110 ∥W0190_2048＝+0.834863   -0.550458
0110101011_1011100101 ∥W0191_2048＝+0.833170   -0.553017
0110101010_1011100100 ∥W0192_2048＝+0.831470   -0.555570
0110101001_1011100010 ∥W0193_2048＝+0.829761   -0.558119
0110101000_1011100001 ∥W0194_2048＝+0.828045   -0.560662
0110100111_1011100000 ∥W0195_2048＝+0.826321   -0.563199
0110100110_1011011110 ∥W0196_2048＝+0.824589   -0.565732
0110100101_1011011101 ∥W0197_2048＝+0.822850   -0.568259
0110100100_1011011100 ∥W0198_2048＝+0.821103   -0.570781
0110100100_1011011010 ∥W0199_2048＝+0.819348   -0.573297
0110100011_1011011001 ∥W0200_2048＝+0.817585   -0.575808
0110100010_1011011000 ∥W0201_2048＝+0.815814   -0.578314
0110100001_1011010111 ∥W0202_2048＝+0.814036   -0.580814
0110100000_1011010101 ∥W0203_2048＝+0.812251   -0.583309
0110011111_1011010100 ∥W0204_2048＝+0.810457   -0.585798
0110011110_1011010011 ∥W0205_2048＝+0.808656   -0.588282
0110011101_1011010010 ∥W0206_2048＝+0.806848   -0.590760
0110011100_1011010000 ∥W0207_2048＝+0.805031   -0.593232
0110011011_1011001111 ∥W0208_2048＝+0.803208   -0.595699
0110011010_1011001110 ∥W0209_2048＝+0.801376   -0.598161
0110011001_1011001100 ∥W0210_2048＝+0.799537   -0.600616
0110011000_1011001011 ∥W0211_2048＝+0.797691   -0.603067
0110010111_1011001010 ∥W0212_2048＝+0.795837   -0.605511
0110010111_1011001001 ∥W0213_2048＝+0.793975   -0.607950
0110010110_1011000111 ∥W0214_2048＝+0.792107   -0.610383
0110010101_1011000110 ∥W0215_2048＝+0.790230   -0.612810
0110010100_1011000101 ∥W0216_2048＝+0.788346   -0.615232
0110010011_1011000100 ∥W0217_2048＝+0.786455   -0.617647
0110010010_1011000011 ∥W0218_2048＝+0.784557   -0.620057
0110010001_1011000001 ∥W0219_2048＝+0.782651   -0.622461
0110010000_1011000000 ∥W0220_2048＝+0.780737   -0.624859
0110001111_1010111111 ∥W0221_2048＝+0.778817   -0.627252
0110001110_1010111110 ∥W0222_2048＝+0.776888   -0.629638
0110001101_1010111100 ∥W0223_2048＝+0.774953   -0.632019
				
				
0110001100_1010111011 ∥W0224_2048＝+0.773010   -0.634393
0110001011_1010111010 ∥W0225_2048＝+0.771061   -0.636762
0110001010_1010111001 ∥W0226_2048＝+0.769103   -0.639124
0110001001_1010111000 ∥W0227_2048＝+0.767139   -0.641481
0110001000_1010110110 ∥W0228_2048＝+0.765167   -0.643832
0110000111_1010110101 ∥W0229_2048＝+0.763188   -0.646176
0110000110_1010110100 ∥W0230_2048＝+0.761202   -0.648514
0110000101_1010110011 ∥W0231_2048＝+0.759209   -0.650847
0110000100_1010110010 ∥W0232_2048＝+0.757209   -0.653173
0110000011_1010110000 ∥W0233_2048＝+0.755201   -0.655493
0110000010_1010101111 ∥W0234_2048＝+0.753187   -0.657807
0110000001_1010101110 ∥W0235_2048＝+0.751165   -0.660114
0110000000_1010101101 ∥W0236_2048＝+0.749136   -0.662416
0101111111_1010101100 ∥W0237_2048＝+0.747101   -0.664711
0101111101_1010101010 ∥W0238_2048＝+0.745058   -0.667000
0101111100_1010101001 ∥W0239_2048＝+0.743008   -0.669283
0101111011_1010101000 ∥W0240_2048＝+0.740951   -0.671559
0101111010_1010100111 ∥W0241_2048＝+0.738887   -0.673829
0101111001_1010100110 ∥W0242_2048＝+0.736817   -0.676093
0101111000_1010100101 ∥W0243_2048＝+0.734739   -0.678350
0101110111_1010100100 ∥W0244_2048＝+0.732654   -0.680601
0101110110_1010100010 ∥W0245_2048＝+0.730563   -0.682846
0101110101_1010100001 ∥W0246_2048＝+0.728464   -0.685084
0101110100_1010100000 ∥W0247_2048＝+0.726359   -0.687315
0101110011_1010011111 ∥W0248_2048＝+0.724247   -0.689541
0101110010_1010011110 ∥W0249_2048＝+0.722128   -0.691759
0101110001_1010011101 ∥W0250_2048＝+0.720003   -0.693971
0101110000_1010011100 ∥W0251_2048＝+0.717870   -0.696177
0101101110_1010011010 ∥W0252_2048＝+0.715731   -0.698376
0101101101_1010011001 ∥W0253_2048＝+0.713585   -0.700569
0101101100_1010011000 ∥W0254_2048＝+0.711432   -0.702755
0101101011_1010010111 ∥W0255_2048＝+0.709273   -0.704934
0101101010_1010010110 ∥W0256_2048＝+0.707107   -0.707107
0101101001_1010010101 ∥W0257_2048＝+0.704934   -0.709273
0101101000_1010010100 ∥W0258_2048＝+0.702755   -0.711432
0101100111_1010010011 ∥W0259_2048＝+0.700569   -0.713585
0101100110_1010010010 ∥W0260_2048＝+0.698376   -0.715731
0101100100_1010010000 ∥W0261_2048＝+0.696177   -0.717870
0101100011_1010001111 ∥W0262_2048＝+0.693971   -0.720003
0101100010_1010001110 ∥W0263_2048＝+0.691759   -0.722128
0101100001_1010001101 ∥W0264_2048＝+0.689541   -0.724247
0101100000_1010001100 ∥W0265_2048＝+0.687315   -0.726359
0101011111_1010001011 ∥W0266_2048＝+0.685084   -0.728464
0101011110_1010001010 ∥W0267_2048＝+0.682846   -0.730563
0101011100_1010001001 ∥W0268_2048＝+0.680601   -0.732654
0101011011_1010001000 ∥W0269_2048＝+0.678350   -0.734739
0101011010_1010000111 ∥W0270_2048＝+0.676093   -0.736817
0101011001_1010000110 ∥W0271_2048＝+0.673829   -0.738887
0101011000_1010000101 ∥W0272_2048＝+0.671559   -0.740951
0101010111_1010000100 ∥W0273_2048＝+0.669283   -0.743008
0101010110_1010000011 ∥W0274_2048＝+0.667000   -0.745058
0101010100_1010000001 ∥W0275_2048＝+0.664711   -0.747101
0101010011_1010000000 ∥W0276_2048＝+0.662416   -0.749136
0101010010_1001111111 ∥W0277_2048＝+0.660114   -0.751165
0101010001_1001111110 ∥W0278_2048＝+0.657807   -0.753187
0101010000_1001111101 ∥W0279_2048＝+0.655493   -0.755201

				
				
0101001110_1001111100 ∥W0280_2048＝+0.653173   -0.757209
0101001101_1001111011 ∥W0281_2048＝+0.650847   -0.759209
0101001100_1001111010 ∥W0282_2048＝+0.648514   -0.761202
0101001011_1001111001 ∥W0283_2048＝+0.646176   -0.763188
0101001010_1001111000 ∥W0284_2048＝+0.643832   -0.765167
0101001000_1001110111 ∥W0285_2048＝+0.641481   -0.767139
0101000111_1001110110 ∥W0286_2048＝+0.639124   -0.769103
0101000110_1001110101 ∥W0287_2048＝+0.636762   -0.771061
0101000101_1001110100 ∥W0288_2048＝+0.634393   -0.773010
0101000100_1001110011 ∥W0289_2048＝+0.632019   -0.774953
0101000010_1001110010 ∥W0290_2048＝+0.629638   -0.776888
0101000001_1001110001 ∥W0291_2048＝+0.627252   -0.778817
0101000000_1001110000 ∥W0292_2048＝+0.624859   -0.780737
0100111111_1001101111 ∥W0293_2048＝+0.622461   -0.782651
0100111101_1001101110 ∥W0294_2048＝+0.620057   -0.784557
0100111100_1001101101 ∥W0295_2048＝+0.617647   -0.786455
0100111011_1001101100 ∥W0296_2048＝+0.615232   -0.788346
0100111010_1001101011 ∥W0297_2048＝+0.612810   -0.790230
0100111001_1001101010 ∥W0298_2048＝+0.610383   -0.792107
0100110111_1001101001 ∥W0299_2048＝+0.607950   -0.793975
0100110110_1001101001 ∥W0300_2048＝+0.605511   -0.795837
0100110101_1001101000 ∥W0301_2048＝+0.603067   -0.797691
0100110100_1001100111 ∥W0302_2048＝+0.600616   -0.799537
0100110010_1001100110 ∥W0303_2048＝+0.598161   -0.801376
0100110001_001100101  ∥W0304_2048＝+0.595699   -0.803208
0100110000_1001100100 ∥W0305_2048＝+0.593232   -0.805031
0100101110_1001100011 ∥W0306_2048＝+0.590760   -0.806848
0100101101_1001100010 ∥W0307_2048＝+0.588282   -0.808656
0100101100_1001100001 ∥W0308_2048＝+0.585798   -0.810457
0100101011_1001100000 ∥W0309_2048＝+0.583309   -0.812251
0100101001_1001011111 ∥W0310_2048＝+0.580814   -0.814036
0100101000_1001011110 ∥W0311_2048＝+0.578314   -0.815814
0100100111_1001011101 ∥W0312_2048＝+0.575808   -0.817585
0100100110_1001011100 ∥W0313_2048＝+0.573297   -0.819348
0100100100_1001011100 ∥W0314_2048＝+0.570781   -0.821103
0100100011_1001011011 ∥W0315_2048＝+0.568259   -0.822850
0100100010_1001011010 ∥W0316_2048＝+0.565732   -0.824589
0100100000_1001011001 ∥W0317_2048＝+0.563199   -0.826321
0100011111_1001011000 ∥W0318_2048＝+0.560662   -0.828045
0100011110_1001010111 ∥W0319_2048＝+0.558119   -0.829761
0100011100_1001010110 ∥W0320_2048＝+0.555570   -0.831470
0100011011_1001010101 ∥W0321_2048＝+0.553017   -0.833170
0100011010_1001010101 ∥W0322_2048＝+0.550458   -0.834863
0100011001_1001010100 ∥W0323_2048＝+0.547894   -0.836548
0100010111_1001010011 ∥W0324_2048＝+0.545325   -0.838225
0100010110_1001010010 ∥W0325_2048＝+0.542751   -0.839894
0100010101_1001010001 ∥W0326_2048＝+0.540171   -0.841555
0100010011_1001010000 ∥W0327_2048＝+0.537587   -0.843208
0100010010_1001001111 ∥W0328_2048＝+0.534998   -0.844854
0100010001_1001001111 ∥W0329_2048＝+0.532403   -0.846491
0100001111_1001001110 ∥W0330_2048＝+0.529804   -0.848120
0100001110_1001001101 ∥W0331_2048＝+0.527199   -0.849742
0100001101_1001001100 ∥W0332_2048＝+0.524590   -0.851355
0100001011_1001001011 ∥W0333_2048＝+0.521975   -0.852961
0100001010_1001001010 ∥W0334_2048＝+0.519356   -0.854558
0100001001_1001001010 ∥W0335_2048＝+0.516732   -0.856147
				
				
0100000111_1001001001  ∥W0336_2048＝+0.514103       -0.857729
0100000110_1001001000  ∥W0337_2048＝+0.511469       -0.859302
0100000101_1001000111  ∥W0338_2048＝+0.508830       -0.860867
0100000011_1001000110  ∥W0339_2048＝+0.506187       -0.862424
0100000010_1001000110  ∥W0340_2048＝+0.503538       -0.863973
0100000000_1001000101  ∥W0341_2048＝+0.500885       -0.865514
0011111111_1001000100  ∥W0342_2048＝+0.498228       -0.867046
0011111110_1001000011  ∥W0343_2048＝+0.495565       -0.868571
0011111100_1001000011  ∥W0344_2048＝+0.492898       -0.870087
0011111011_1001000010  ∥W0345_2048＝+0.490226       -0.871595
0011111010_1001000001  ∥W0346_2048＝+0.487550       -0.873095
0011111000_1001000000  ∥W0347_2048＝+0.484869       -0.874587
0011110111_1000111111  ∥W0348_2048＝+0.482184       -0.876070
0011110110_1000111111  ∥W0349_2048＝+0.479494       -0.877545
0011110100_1000111110  ∥W0350_2048＝+0.476799       -0.879012
0011110011_1000111101  ∥W0351_2048＝+0.474100       -0.880471
0011110001_1000111100  ∥W0352_2048＝+0.471397       -0.881921
0011110000_1000111100  ∥W0353_2048＝+0.468689       -0.883363
0011101111_1000111011  ∥W0354_2048＝+0.465976       -0.884797
0011101101_1000111010  ∥W0355_2048＝+0.463260       -0.886223
0011101100_1000111010  ∥W0356_2048＝+0.460539       -0.887640
0011101010_1000111001  ∥W0357_2048＝+0.457813       -0.889048
0011101001_1000111000  ∥W0358_2048＝+0.455084       -0.890449
0011101000_1000110111  ∥W0359_2048＝+0.452350       -0.891841
0011100110_1000110111  ∥W0360_2048＝+0.449611       -0.893224
0011100101_1000110110  ∥W0361_2048＝+0.446869       -0.894599
0011100011_1000110101  ∥W0362_2048＝+0.444122       -0.895966
0011100010_1000110101  ∥W0363_2048＝+0.441371       -0.897325
0011100001_1000110100  ∥W0364_2048＝+0.438616       -0.898674
0011011111_1000110011  ∥W0365_2048＝+0.435857       -0.900016
0011011110_1000110011  ∥W0366_2048＝+0.433094       -0.901349
0011011100_1000110010  ∥W0367_2048＝+0.430326       -0.902673
0011011011_1000110001  ∥W0368_2048＝+0.427555       -0.903989
0011011001_1000110000  ∥W0369_2048＝+0.424780       -0.905297
0011011000_1000110000  ∥W0370_2048＝+0.422000       -0.906596
0011010111_1000101111  ∥W0371_2048＝+0.419217       -0.907886
0011010101_1000101111  ∥W0372_2048＝+0.416430       -0.909168
0011010100_1000101110  ∥W0373_2048＝+0.413638       -0.910441
0011010010_1000101101  ∥W0374_2048＝+0.410843       -0.911706
0011010001_1000101101  ∥W0375_2048＝+0.408044       -0.912962
0011001111_1000101100  ∥W0376_2048＝+0.405241       -0.914210
0011001110_1000101011  ∥W0377_2048＝+0.402435       -0.915449
0011001101_1000101011  ∥W0378_2048＝+0.399624       -0.916679
0011001011_1000101010  ∥W0379_2048＝+0.396810       -0.917901
0011001010_1000101001  ∥W0380_2048＝+0.393992       -0.919114
0011001000_1000101001  ∥W0381_2048＝+0.391170       -0.920318
0011000111_1000101000  ∥W0382_2048＝+0.388345       -0.921514
0011000101_1000101000  ∥W0383_2048＝+0.385516       -0.922701
0011000100_1000100111  ∥W0384_2048＝+0.382683       -0.923880
0011000010_1000100110  ∥W0385_2048＝+0.379847       -0.925049
0011000001_1000100110  ∥W0386_2048＝+0.377007       -0.926210
0011000000_1000100101  ∥W0387_2048＝+0.374164       -0.927363
0010111110_1000100101  ∥W0388_2048＝+0.371317       -0.928506
0010111101_1000100100  ∥W0389_2048＝+0.368467       -0.929641
0010111011_1000100011  ∥W0390_2048＝+0.365613       -0.930767
0010111010_1000100011  ∥W0391_2048＝+0.362756       -0.931884


				
				
0010111000_1000100010 ∥W0392_2048＝+0.359895        -0.932993
0010110111_1000100010 ∥W0393_2048＝+0.357031        -0.934093
0010110101_1000100001 ∥W0394_2048＝+0.354164        -0.935184
0010110100_1000100001 ∥W0395_2048＝+0.351293        -0.936266
0010110010_1000100000 ∥W0396_2048＝+0.348419        -0.937339
0010110001_1000100000 ∥W0397_2048＝+0.345541        -0.938404
0010101111_1000011111 ∥W0398_2048＝+0.342661        -0.939459
0010101110_1000011110 ∥W0399_2048＝+0.339777        -0.940506
0010101100_1000011110 ∥W0400_2048＝+0.336890        -0.941544
0010101011_1000011101 ∥W0401_2048＝+0.334000        -0.942573
0010101010_1000011101 ∥W0402_2048＝+0.331106        -0.943593
0010101000_1000011100 ∥W0403_2048＝+0.328210        -0.944605
0010100111_1000011100 ∥W0404_2048＝+0.325310        -0.945607
0010100101_1000011011 ∥W0405_2048＝+0.322408        -0.946601
0010100100_1000011011 ∥W0406_2048＝+0.319502        -0.947586
0010100010_1000011010 ∥W0407_2048＝+0.316593        -0.948561
0010100001_1000011010 ∥W0408_2048＝+0.313682        -0.949528
0010011111_1000011001 ∥W0409_2048＝+0.310767        -0.950486
0010011110_1000011001 ∥W0410_2048＝+0.307850        -0.951435
0010011100_1000011000 ∥W0411_2048＝+0.304929        -0.952375
0010011011_1000011000 ∥W0412_2048＝+0.302006        -0.953306
0010011001_1000010111 ∥W0413_2048＝+0.299080        -0.954228
0010011000_1000010111 ∥W0414_2048＝+0.296151        -0.955141
0010010110_1000010111 ∥W0415_2048＝+0.293219        -0.956045
0010010101_1000010110 ∥W0416_2048＝+0.290285        -0.956940
0010010011_1000010110 ∥W0417_2048＝+0.287347        -0.957826
0010010010_1000010101 ∥W0418_2048＝+0.284408        -0.958703
0010010000_1000010101 ∥W0419_2048＝+0.281465        -0.959572
0010001111_1000010100 ∥W0420_2048＝+0.278520        -0.960431
0010001101_1000010100 ∥W0421_2048＝+0.275572        -0.961280
0010001100_1000010011 ∥W0422_2048＝+0.272621        -0.962121
0010001010_1000010011 ∥W0423_2048＝+0.269668        -0.962953
0010001001_1000010011 ∥W0424_2048＝+0.266713        -0.963776
0010000111_1000010010 ∥W0425_2048＝+0.263755        -0.964590
0010000110_1000010010 ∥W0426_2048＝+0.260794        -0.965394
0010000100_1000010001 ∥W0427_2048＝+0.257831        -0.966190
0010000010_1000010001 ∥W0428_2048＝+0.254866        -0.966976
0010000001_1000010001 ∥W0429_2048＝+0.251898        -0.967754
0001111111_1000010000 ∥W0430_2048＝+0.248928        -0.968522
0001111110_1000010000 ∥W0431_2048＝+0.245955        -0.969281
0001111100_1000001111 ∥W0432_2048＝+0.242980        -0.970031
0001111011_1000001111 ∥W0433_2048＝+0.240003        -0.970772
0001111001_1000001111 ∥W0434_2048＝+0.237024        -0.971504
0001111000_1000001110 ∥W0435_2048＝+0.234042        -0.972226
0001110110_1000001110 ∥W0436_2048＝+0.231058        -0.972940
0001110101_1000001101 ∥W0437_2048＝+0.228072        -0.973644
0001110011 1000001101 ∥W0438_2048＝+0.225084        -0.974339
0001110010_1000001101 ∥W0439_2048＝+0.222094        -0.975025
0001110000_1000001100 ∥W0440_2048＝+0.219101        -0.975702
0001101111_1000001100 ∥W0441_2048＝+0.216107        -0.976370
0001101101_1000001100 ∥W0442_2048＝+0.213110        -0.977028
0001101100_1000001011 ∥W0443_2048＝+0.210112        -0.977677
0001101010_1000001011 ∥W0444_2048＝+0.207111        -0.978317
0001101001_1000001011 ∥W0445_2048＝+0.204109        -0.978948
0001100111_1000001010 ∥W0446_2048＝+0.201105        -0.979570
0001100101_1000001010 ∥W0447_2048＝+0.198098        -0.980182
				
				
0001100100_1000001010 ∥W0448_2048＝+0.195090        -0.980785
0001100010_1000001010 ∥W0449_2048＝+0.192080        -0.981379
0001100001_1000001001 ∥W0450_2048＝+0.189069        -0.981964
0001011111_1000001001 ∥W0451_2048＝+0.186055        -0.982539
0001011110_1000001001 ∥W0452_2048＝+0.183040        -0.983105
0001011100_1000001000 ∥W0453_2048＝+0.180023        -0.983662
0001011011_1000001000 ∥W0454_2048＝+0.177004        -0.984210
0001011001_1000001000 ∥W0455_2048＝+0.173984        -0.984749
0001011000_1000001000 ∥W0456_2048＝+0.170962        -0.985278
0001010110_1000000111 ∥W0457_2048＝+0.167938        -0.985798
0001010100_1000000111 ∥W0458_2048＝+0.164913        -0.986308
0001010011_1000000111 ∥W0459_2048＝+0.161886        -0.986809
0001010001_1000000111 ∥W0460_2048＝+0.158858        -0.987301
0001010000_1000000110 ∥W0461_2048＝+0.155828        -0.987784
0001001110_1000000110 ∥W0462_2048＝+0.152797        -0.988258
0001001101_1000000110 ∥W0463_2048＝+0.149765        -0.988722
0001001011_1000000110 ∥W0464_2048＝+0.146730        -0.989177
0001001010_1000000101 ∥W0465_2048＝+0.143695        -0.989622
0001001000_1000000101 ∥W0466_2048＝+0.140658        -0.990058
0001000110_1000000101 ∥W0467_2048＝+0.137620        -0.990485
0001000101_1000000101 ∥W0468_2048＝+0.134581        -0.990903
0001000011_1000000100 ∥W0469_2048＝+0.131540        -0.991311
0001000010_1000000100 ∥W0470_2048＝+0.128498        -0.991710
0001000000_1000000100 ∥W0471_2048＝+0.125455        -0.992099
0000111111_1000000100 ∥W0472_2048＝+0.122411        -0.992480
0000111101_1000000100 ∥W0473_2048＝+0.119365        -0.992850
0000111100_1000000011 ∥W0474_2048＝+0.116319        -0.993212
0000111010_1000000011 ∥W0475_2048＝+0.113271        -0.993564
0000111000_1000000011 ∥W0476_2048＝+0.110222        -0.993907
0000110111_1000000011 ∥W0477_2048＝+0.107172        -0.994240
0000110101_1000000011 ∥W0478_2048＝+0.104122        -0.994565
0000110100_1000000011 ∥W0479_2048＝+0.101070        -0.994879
0000110010_1000000010 ∥W0480_2048＝+0.098017        -0.995185
0000110001_1000000010 ∥W0481_2048＝+0.094963        -0.995481
0000101111_1000000010 ∥W0482_2048＝+0.091909        -0.995767
0000101101_1000000010 ∥W0483_2048＝+0.088854        -0.996045
0000101100_1000000010 ∥W0484_2048＝+0.085797        -0.996313
0000101010_1000000010 ∥W0485_2048＝+0.082740        -0.996571
0000101001_1000000010 ∥W0486_2048＝+0.079682        -0.996820
0000100111_1000000010 ∥W0487_2048＝+0.076624        -0.997060
0000100110_1000000001 ∥W0488_2048＝+0.073565        -0.997290
0000100100_1000000001 ∥W0489_2048＝+0.070505        -0.997511
0000100011_1000000001 ∥W0490_2048＝+0.067444        -0.997723
0000100001_1000000001 ∥W0491_2048＝+0.064383        -0.997925
0000011111_1000000001 ∥W0492_2048＝+0.061321        -0.998118
0000011110_1000000001 ∥W0493_2048＝+0.058258        -0.998302
0000011100_1000000001 ∥W0494_2048＝+0.055195        -0.998476
0000011011_1000000001 ∥W0495_2048＝+0.052132        -0.998640
0000011001_1000000001 ∥W0496_2048＝+0.049068        -0.998795
0000011000_1000000001 ∥W0497_2048＝+0.046003        -0.998941
0000010110_1000000000 ∥W0498_2048＝+0.042938        -0.999078
0000010100_1000000000 ∥W0499_2048＝+0.039873        -0.999205
0000010011_1000000000 ∥W0500_2048＝+0.036807        -0.999322
0000010001_1000000000 ∥W0501_2048＝+0.033741        -0.999431
0000010000_1000000000 ∥W0502_2048＝+0.030675        -0.999529
0000001110_1000000000 ∥W0503_2048＝+0.027608        -0.999619
				
				
0000001101_1000000000 ∥W0504_2048＝+0.024541        -0.999699
0000001011_1000000000 ∥W0505_2048＝+0.021474        -0.999769
0000001001_1000000000 ∥W0506_2048＝+0.018407        -0.999831
0000001000_1000000000 ∥W0507_2048＝+0.015339        -0.999882
0000000110_1000000000 ∥W0508_2048＝+0.012272        -0.999925
0000000101_1000000000 ∥W0509_2048＝+0.009204        -0.999958
0000000011_1000000000 ∥W0510_2048＝+0.006136        -0.999981
0000000010_1000000000 ∥W0511_2048＝+0.003068        -0.999995
0000000000_1000000000 ∥W0512_2048＝+0.000000        -1.000000
1111111110_1000000000 ∥W0513_2048＝-0.003068        -0.999995
1111111101_1000000000 ∥W0514_2048＝-0.006136        -0.999981
1111111010_1000000000 ∥W0516_2048＝-0.012272        -0.999925
1111110111_1000000000 ∥W0518_2048＝-0.018407        -0.999831
1111110101_1000000000 ∥W0519_2048＝-0.021474        -0.999769
1111110011_1000000000 ∥W0520_2048＝-0.024541        -0.999699
1111110000_1000000000 ∥W0522_2048＝-0.030675        -0.999529
1111101101_1000000000 ∥W0524_2048＝-0.036807        -0.999322
1111101100_1000000000 ∥W0525_2048＝-0.039873        -0.999205
1111101010_1000000000 ∥W0526_2048＝-0.042938        -0.999078
1111100111_1000000001 ∥W0528_2048＝-0.049068        -0.998795
1111100100_1000000001 ∥W0530_2048＝-0.055195        -0.998476
1111100010_1000000001 ∥W0531_2048＝-0.058258        -0.998302
1111100001_1000000001 ∥W0532_2048＝-0.061321        -0.998118
1111011101_1000000001 ∥W0534_2048＝-0.067444        -0.997723
1111011010_1000000001 ∥W0536_2048＝-0.073565        -0.997290
1111011001_1000000010 ∥W0537_2048＝-0.076624        -0.997060
1111010111_1000000010 ∥W0538_2048＝-0.079682        -0.996820
1111010100_1000000010 ∥W0540_2048＝-0.085797        -0.996313
1111010001_1000000010 ∥W0542_2048＝-0.091909        -0.995767
1111001111_1000000010 ∥W0543_2048＝-0.094963        -0.995481
1111001110_1000000010 ∥W0544_2048＝-0.098017        -0.995185
1111001011_1000000011 ∥W0546_2048＝-0.104122        -0.994565
1111001000_1000000011 ∥W0548_2048＝-0.110222        -0.993907
1111000110_1000000011 ∥W0549_2048＝-0.113271        -0.993564
1111000100_1000000011 ∥W0550_2048＝-0.116319        -0.993212
1111000001_1000000100 ∥W0552_2048＝-0.122411        -0.992480
1110111110_1000000100 ∥W0554_2048＝-0.128498        -0.991710
1110111101_1000000100 ∥W0555_2048＝-0.131540        -0.991311
1110111011_1000000101 ∥W0556_2048＝-0.134581        -0.990903
1110111000_1000000101 ∥W0558_2048＝-0.140658        -0.990058
1110110101_1000000110 ∥W0560_2048＝-0.146730        -0.989177
1110110011_1000000110 ∥W0561_2048＝-0.149765        -0.988722
1110110010_1000000110 ∥W0562_2048＝-0.152797        -0.988258
1110101111_1000000111 ∥W0564_2048＝-0.158858        -0.987301
1110101100_1000000111 ∥W0566_2048＝-0.164913        -0.986308
1110101010_1000000111 ∥W0567_2048＝-0.167938        -0.985798
1110101000_1000001000 ∥W0568_2048＝-0.170962        -0.985278
1110100101_1000001000 ∥W0570_2048＝-0.177004        -0.984210
1110100010_1000001001 ∥W0572_2048＝-0.183040        -0.983105
1110100001_1000001001 ∥W0573_2048＝-0.186055        -0.982539
1110011111_1000001001 ∥W0574_2048＝-0.189069        -0.981964
1110011100_1000001010 ∥W0576_2048＝-0.195090        -0.980785
1110011001_1000001010 ∥W0578_2048＝-0.201105        -0.979570
1110010111_1000001011 ∥W0579_2048＝-0.204109        -0.978948
1110010110_1000001011 ∥W0580_2048＝-0.207111        -0.978317
1110010011_1000001100 ∥W0582_2048＝-0.213110        -0.977028


				
				
1110010000_1000001100  ∥W0584_2048＝-0.219101       -0.975702
1110001110_1000001101  ∥W0585_2048＝-0.222094       -0.975025
1110001101_1000001101  ∥W0586_2048＝-0.225084       -0.974339
1110001010_1000001110  ∥W0588_2048＝-0.231058       -0.972940
1110000111_1000001111  ∥W0590_2048＝-0.237024       -0.971504
1110000101_1000001111  ∥W0591_2048＝-0.240003       -0.970772
1110000100_1000001111  ∥W0592_2048＝-0.242980       -0.970031
1110000001_1000010000  ∥W0594_2048＝-0.248928       -0.968522
1101111110_1000010001  ∥W0596_2048＝-0.254866       -0.966976
1101111100_1000010001  ∥W0597_2048＝-0.257831       -0.966190
1101111010_1000010010  ∥W0598_2048＝-0.260794       -0.965394
1101110111_1000010011  ∥W0600_2048＝-0.266713       -0.963776
1101110100_1000010011  ∥W0602_2048＝-0.272621       -0.962121
1101110011_1000010100  ∥W0603_2048＝-0.275572       -0.961280
1101110001_1000010100  ∥W0604_2048＝-0.278520       -0.960431
1101101110_1000010101  ∥W0606_2048＝-0.284408       -0.958703
1101101011_1000010110  ∥W0608_2048＝-0.290285       -0.956940
1101101010_1000010111  ∥W0609_2048＝-0.293219       -0.956045
1101101000_1000010111  ∥W0610_2048＝-0.296151       -0.955141
1101100101_1000011000  ∥W0612_2048＝-0.302006       -0.953306
1101100010_1000011001  ∥W0614_2048＝-0.307850       -0.951435
1101100001_1000011001  ∥W0615_2048＝-0.310767       -0.950486
1101011111_1000011010  ∥W0616_2048＝-0.313682       -0.949528
1101011100_1000011011  ∥W0618_2048＝-0.319502       -0.947586
1101011001_1000011100  ∥W0620_2048＝-0.325310       -0.945607
1101011000_1000011100  ∥W0621_2048＝-0.328210       -0.944605
1101010110_1000011101  ∥W0622_2048＝-0.331106       -0.943593
1101010100_1000011110  ∥W0624_2048＝-0.336890       -0.941544
1101010001_1000011111  ∥W0626_2048＝-0.342661       -0.939459
1101001111_1000100000  ∥W0627_2048＝-0.345541       -0.938404
1101001110_1000100000  ∥W0628_2048＝-0.348419       -0.937339
1101001011_1000100001  ∥W0630_2048＝-0.354164       -0.935184
1101001000_1000100010  ∥W0632_2048＝-0.359895       -0.932993
1101000110_1000100011  ∥W0633_2048＝-0.362756       -0.931884
1101000101_1000100011  ∥W0634_2048＝-0.365613       -0.930767
1101000010_1000100101  ∥W0636_2048＝-0.371317       -0.928506
1100111111_1000100110  ∥W0638_2048＝-0.377007       -0.926210
1100111110_1000100110  ∥W0639_2048＝-0.379847       -0.925049
1100111100_1000100111  ∥W0640_2048＝-0.382683       -0.923880
1100111001_1000101000  ∥W0642_2048＝-0.388345       -0.921514
1100110110_1000101001  ∥W0644_2048＝-0.393992       -0.919114
1100110101_1000101010  ∥W0645_2048＝-0.396810       -0.917901
1100110011_1000101011  ∥W0646_2048＝-0.399624       -0.916679
1100110001_1000101100  ∥W0648_2048＝-0.405241       -0.914210
1100101110_1000101101  ∥W0650_2048＝-0.410843       -0.911706
1100101100_1000101110  ∥W0651_2048＝-0.413638       -0.910441
1100101011_1000101111  ∥W0652_2048＝-0.416430       -0.909168
1100101000_1000110000  ∥W0654_2048＝-0.422000       -0.906596
1100100101_1000110001  ∥W0656_2048＝-0.427555       -0.903989
1100100100_1000110010  ∥W0657_2048＝-0.430326       -0.902673
1100100010_1000110011  ∥W0658_2048＝-0.433094       -0.901349
1100011111_1000110100  ∥W0660_2048＝-0.438616       -0.898674
1100011101_1000110101  ∥W0662_2048＝-0.444122       -0.895966
1100011011_1000110110  ∥W0663_2048＝-0.446869       -0.894599
1100011010_1000110111  ∥W0664_2048＝-0.449611       -0.893224
1100010111_1000111000  ∥W0666_2048＝-0.455084       -0.890449


				
				
1100010100_1000111010 ∥W0668_2048＝-0.460539    -0.887640
1100010011_1000111010 ∥W0669_2048＝-0.463260    -0.886223
1100010001_1000111011 ∥W0670_2048＝-0.465976    -0.884797
1100001111_1000111100 ∥W0672_2048＝-0.471397    -0.881921
1100001100_1000111110 ∥W0674_2048＝-0.476799    -0.879012
1100001010_1000111111 ∥W0675_2048＝-0.479494    -0.877545
1100001001_1000111111 ∥W0676_2048＝-0.482184    -0.876070
1100000110_1001000001 ∥W0678_2048＝-0.487550    -0.873095
1100000100_1001000011 ∥W0680_2048＝-0.492898    -0.870087
1100000010_1001000011 ∥W0681_2048＝-0.495565    -0.868571
1100000001_1001000100 ∥W0682_2048＝-0.498228    -0.867046
1011111110_1001000110 ∥W0684_2048＝-0.503538    -0.863973
1011111011_1001000111 ∥W0686_2048＝-0.508830    -0.860867
1011111010_1001001000 ∥W0687_2048＝-0.511469    -0.859302
1011111001_1001001001 ∥W0688_2048＝-0.514103    -0.857729
1011110110_1001001010 ∥W0690_2048＝-0.519356    -0.854558
1011110011_1001001100 ∥W0692_2048＝-0.524590    -0.851355
1011110010_1001001101 ∥W0693_2048＝-0.527199    -0.849742
1011110001_1001001110 ∥W0694_2048＝-0.529804    -0.848120
1011101110_1001001111 ∥W0696_2048＝-0.534998    -0.844854
1011101011_1001010001 ∥W0698_2048＝-0.540171    -0.841555
1011101010_1001010010 ∥W0699_2048＝-0.542751    -0.839894
1011101001_1001010011 ∥W0700_2048＝-0.545325    -0.838225
1011100110_1001010101 ∥W0702_2048＝-0.550458    -0.834863
1011100100_1001010110 ∥W0704_2048＝-0.555570    -0.831470
1011100010_1001010111 ∥W0705_2048＝-0.558119    -0.829761
1011100001_1001011000 ∥W0706_2048＝-0.560662    -0.828045
1011011110_1001011010 ∥W0708_2048＝-0.565732    -0.824589
1011011100_1001011100 ∥W0710_2048＝-0.570781    -0.821103
1011011010_1001011100 ∥W0711_2048＝-0.573297    -0.819348
1011011001_1001011101 ∥W0712_2048＝-0.575808    -0.817585
1011010111_1001011111 ∥W0714_2048＝-0.580814    -0.814036
1011010100_1001100001 ∥W0716_2048＝-0.585798    -0.810457
1011010011_1001100010 ∥W0717_2048＝-0.588282    -0.808656
1011010010_1001100011 ∥W0718_2048＝-0.590760    -0.806848
1011001111_1001100101 ∥W0720_2048＝-0.595699    -0.803208
1011001100_1001100111 ∥W0722_2048＝-0.600616    -0.799537
1011001011_1001101000 ∥W0723_2048＝-0.603067    -0.797691
1011001010_1001101001 ∥W0724_2048＝-0.605511    -0.795837
1011000111_1001101010 ∥W0726_2048＝-0.610383    -0.792107
1011000101_1001101100 ∥W0728_2048＝-0.615232    -0.788346
1011000100_1001101101 ∥W0729_2048＝-0.617647    -0.786455
1011000011_1001101110 ∥W0730_2048＝-0.620057    -0.784557
1011000000_1001110000 ∥W0732_2048＝-0.624859    -0.780737
1010111110_1001110010 ∥W0734_2048＝-0.629638    -0.776888
1010111100_1001110011 ∥W0735_2048＝-0.632019    -0.774953
1010111011_1001110100 ∥W0736_2048＝-0.634393    -0.773010
1010111001_1001110110 ∥W0738_2048＝-0.639124    -0.769103
1010110110_1001111000 ∥W0740_2048＝-0.643832    -0.765167
1010110101_1001111001 ∥W0741_2048＝-0.646176    -0.763188
1010110100_1001111010 ∥W0742_2048＝-0.648514    -0.761202
1010110010_1001111100 ∥W0744_2048＝-0.653173    -0.757209
1010101111_1001111110 ∥W0746_2048＝-0.657807    -0.753187
1010101110_1001111111 ∥W0747_2048＝-0.660114    -0.751165
1010101101_1010000000 ∥W0748_2048＝-0.662416    -0.749136
1010101010_1010000011 ∥W0750_2048＝-0.667000    -0.745058

				
				
1010101000_1010000101  ∥W0752_2048＝-0.671559       -0.740951
1010100111_1010000110  ∥W0753_2048＝-0.673829       -0.738887
1010100110_1010000111  ∥W0754_2048＝-0.676093       -0.736817
1010100100_1010001001  ∥W0756_2048＝-0.680601       -0.732654
1010100001_1010001011  ∥W0758_2048＝-0.685084       -0.728464
1010100000_1010001100  ∥W0759_2048＝-0.687315       -0.726359
1010011111_1010001101  ∥W0760_2048＝-0.689541       -0.724247
1010011101_1010001111  ∥W0762_2048＝-0.693971       -0.720003
1010011010_1010010010  ∥W0764_2048＝-0.698376       -0.715731
1010011001_1010010011  ∥W0765_2048＝-0.700569       -0.713585
1010011000_1010010100  ∥W0766_2048＝-0.702755       -0.711432
1010010110_1010010110  ∥W0768_2048＝-0.707107       -0.707107
1010010100_1010011000  ∥W0770_2048＝-0.711432       -0.702755
1010010011_1010011001  ∥W0771_2048＝-0.713585       -0.700569
1010010010_1010011010  ∥W0772_2048＝-0.715731       -0.698376
1010001111_1010011101  ∥W0774_2048＝-0.720003       -0.693971
1010001101_1010011111  ∥W0776_2048＝-0.724247       -0.689541
1010001100_1010100000  ∥W0777_2048＝-0.726359       -0.687315
1010001011_1010100001  ∥W0778_2048＝-0.728464       -0.685084
1010001001_1010100100  ∥W0780_2048＝-0.732654       -0.680601
1010000111_1010100110  ∥W0782_2048＝-0.736817       -0.676093
1010000110_1010100111  ∥W0783_2048＝-0.738887       -0.673829
1010000101_1010101000  ∥W0784_2048＝-0.740951       -0.671559
1010000011_1010101010  ∥W0786_2048＝-0.745058       -0.667000
1010000000_1010101101  ∥W0788_2048＝-0.749136       -0.662416
1001111111_1010101110  ∥W0789_2048＝-0.751165       -0.660114
1001111110_1010101111  ∥W0790_2048＝-0.753187       -0.657807
1001111100_1010110010  ∥W0792_2048＝-0.757209       -0.653173
1001111010_1010110100  ∥W0794_2048＝-0.761202       -0.648514
1001111001_1010110101  ∥W0795_2048＝-0.763188       -0.646176
1001111000_1010110110  ∥W0796_2048＝-0.765167       -0.643832
1001110110_1010111001  ∥W0798_2048＝-0.769103       -0.639124
1001110100_1010111011  ∥W0800_2048＝-0.773010       -0.634393
1001110011_1010111100  ∥W0801_2048＝-0.774953       -0.632019
1001110010_1010111110  ∥W0802_2048＝-0.776888       -0.629638
1001110000_1011000000  ∥W0804_2048＝-0.780737       -0.624859
1001101110_1011000011  ∥W0806_2048＝-0.784557       -0.620057
1001101101_1011000100  ∥W0807_2048＝-0.786455       -0.617647
1001101100_1011000101  ∥W0808_2048＝-0.788346       -0.615232
1001101010_1011000111  ∥W0810_2048＝-0.792107       -0.610383
1001101001_1011001010  ∥W0812_2048＝-0.795837       -0.605511
1001101000_1011001011  ∥W0813_2048＝-0.797691       -0.603067
1001100111_1011001100  ∥W0814_2048＝-0.799537       -0.600616
1001100101_1011001111  ∥W0816_2048＝-0.803208       -0.595699
1001100011_1011010010  ∥W0818_2048＝-0.806848       -0.590760
1001100010_1011010011  ∥W0819_2048＝-0.808656       -0.588282
1001100001_1011010100  ∥W0820_2048＝-0.810457       -0.585798
1001011111_1011010111  ∥W0822_2048＝-0.814036       -0.580814
1001011101_1011011001  ∥W0824_2048＝-0.817585       -0.575808
1001011100_1011011010  ∥W0825_2048＝-0.819348       -0.573297
1001011100_1011011100  ∥W0826_2048＝-0.821103       -0.570781
1001011010_1011011110  ∥W0828_2048＝-0.824589       -0.565732
1001011000_1011100001  ∥W0830_2048＝-0.828045       -0.560662
1001010111_1011100010  ∥W0831_2048＝-0.829761       -0.558119
1001010110_1011100100  ∥W0832_2048＝-0.831470       -0.555570
1001010101_1011100110  ∥W0834_2048＝-0.834863       -0.550458
				
				
1001010011_1011101001    ∥W0836_2048＝-0.838225     -0.545325
1001010010_1011101010    ∥W0837_2048＝-0.839894     -0.542751
1001010001_1011101011    ∥W0838_2048＝-0.841555     -0.540171
1001001111_1011101110    ∥W0840_2048＝-0.844854     -0.534998
1001001110_1011110001    ∥W0842_2048＝-0.848120     -0.529804
1001001101_1011110010    ∥W0843_2048＝-0.849742     -0.527199
1001001100_1011110011    ∥W0844_2048＝-0.851355     -0.524590
1001001010_1011110110    ∥W0846_2048＝-0.854558     -0.519356
1001001001_1011111001    ∥W0848_2048＝-0.857729     -0.514103
1001001000_1011111010    ∥W0849_2048＝-0.859302     -0.511469
1001000111_1011111011    ∥W0850_2048＝-0.860867     -0.508830
1001000110_1011111110    ∥W0852_2048＝-0.863973     -0.503538
1001000100_1100000001    ∥W0854_2048＝-0.867046     -0.498228
1001000011_1100000010    ∥W0855_2048＝-0.868571     -0.495565
1001000011_1100000100    ∥W0856_2048＝-0.870087     -0.492898
1001000001_1100000110    ∥W0858_2048＝-0.873095     -0.487550
1000111111_1100001001    ∥W0860_2048＝-0.876070     -0.482184
1000111111_1100001010    ∥W0861_2048＝-0.877545     -0.479494
1000111110_1100001100    ∥W0862_2048＝-0.879012     -0.476799
1000111100_1100001111    ∥W0864_2048＝-0.881921     -0.471397
1000111011_1100010001    ∥W0866_2048＝-0.884797     -0.465976
1000111010_1100010011    ∥W0867_2048＝-0.886223     -0.463260
1000111010_1100010100    ∥W0868_2048＝-0.887640     -0.460539
1000111000_1100010111    ∥W0870_2048＝-0.890449     -0.455084
1000110111_1100011010    ∥W0872_2048＝-0.893224     -0.449611
1000110110_1100011011    ∥W0873_2048＝-0.894599     -0.446869
1000110101_1100011101    ∥W0874_2048＝-0.895966     -0.444122
1000110100_1100011111    ∥W0876_2048＝-0.898674     -0.438616
1000110011_1100100010    ∥W0878_2048＝-0.901349     -0.433094
1000110010_1100100100    ∥W0879_2048＝-0.902673     -0.430326
1000110001_1100100101    ∥W0880_2048＝-0.903989     -0.427555
1000110000_1100101000    ∥W0882_2048＝-0.906596     -0.422000
1000101111_1100101011    ∥W0884_2048＝-0.909168     -0.416430
1000101110_1100101100    ∥W0885_2048＝-0.910441     -0.413638
1000101101_1100101110    ∥W0886_2048＝-0.911706     -0.410843
1000101100_1100110001    ∥W0888_2048＝-0.914210     -0.405241
1000101011_1100110011    ∥W0890_2048＝-0.916679     -0.399624
1000101010_1100110101    ∥W0891_2048＝-0.917901     -0.396810
1000101001_1100110110    ∥W0892_2048＝-0.919114     -0.393992
1000101000_1100111001    ∥W0894_2048＝-0.921514     -0.388345
1000100111_1100111100    ∥W0896_2048＝-0.923880     -0.382683
1000100110_1100111110    ∥W0897_2048＝-0.925049     -0.379847
1000100110_1100111111    ∥W0898_2048＝-0.926210     -0.377007
1000100101_1101000010    ∥W0900_2048＝-0.928506     -0.371317
1000100011_1101000101    ∥W0902_2048＝-0.930767     -0.365613
1000100011_1101000110    ∥W0903_2048＝-0.931884     -0.362756
1000100010_1101001000    ∥W0904_2048＝-0.932993     -0.359895
1000100001_1101001011    ∥W0906_2048＝-0.935184     -0.354164
1000100000_1101001110    ∥W0908_2048＝-0.937339     -0.348419
1000100000_1101001111    ∥W0909_2048＝-0.938404     -0.345541
1000011111_1101010001    ∥W0910_2048＝-0.939459     -0.342661
1000011110_1101010100    ∥W0912_2048＝-0.941544     -0.336890
1000011101_1101010110    ∥W0914_2048＝-0.943593     -0.331106
1000011100_1101011000    ∥W0915_2048＝-0.944605     -0.328210
1000011100_1101011001    ∥W0916_2048＝-0.945607     -0.325310
1000011011_1101011100    ∥W0918_2048＝-0.947586     -0.319502
				
				
1000011010_1101011111    ∥W0920_2048＝-0.949528     -0.313682
1000011001_1101100001    ∥W0921_2048＝-0.950486     -0.310767
1000011001_1101100010    ∥W0922_2048＝-0.951435     -0.307850
1000011000_1101100101    ∥W0924_2048＝-0.953306     -0.302006
1000010111_1101101000    ∥W0926_2048＝-0.955141     -0.296151
1000010111_1101101010    ∥W0927_2048＝-0.956045     -0.293219
1000010110_1101101011    ∥W0928_2048＝-0.956940     -0.290285
1000010101_1101101110    ∥W0930_2048＝-0.958703     -0.284408
1000010100_1101110001    ∥W0932_2048＝-0.960431     -0.278520
1000010100_1101110011    ∥W0933_2048＝-0.961280     -0.275572
1000010011_1101110100    ∥W0934_2048＝-0.962121     -0.272621
1000010011_1101110111    ∥W0936_2048＝-0.963776     -0.266713
1000010010_1101111010    ∥W0938_2048＝-0.965394     -0.260794
1000010001_1101111100    ∥W0939_2048＝-0.966190     -0.257831
1000010001_1101111110    ∥W0940_2048＝-0.966976     -0.254866
1000010000_1110000001    ∥W0942_2048＝-0.968522     -0.248928
1000001111_1110000100    ∥W0944_2048＝-0.970031     -0.242980
1000001111_1110000101    ∥W0945_2048＝-0.970772     -0.240003
1000001111_1110000111    ∥W0946_2048＝-0.971504     -0.237024
1000001110_1110001010    ∥W0948_2048＝-0.972940     -0.231058
1000001101_1110001101    ∥W0950_2048＝-0.974339     -0.225084
1000001101_1110001110    ∥W0951_2048＝-0.975025     -0.222094
1000001100_1110010000    ∥W0952_2048＝-0.975702     -0.219101
1000001100_1110010011    ∥W0954_2048＝-0.977028     -0.213110
1000001011_1110010110    ∥W0956_2048＝-0.978317     -0.207111
1000001011_1110010111    ∥W0957_2048＝-0.978948     -0.204109
1000001010_1110011001    ∥W0958_2048＝-0.979570     -0.201105
1000001010_1110011100    ∥W0960_2048＝-0.980785     -0.195090
1000001001_1110011111    ∥W0962_2048＝-0.981964     -0.189069
1000001001_1110100001    ∥W0963_2048＝-0.982539     -0.186055
1000001001_1110100010    ∥W0964_2048＝-0.983105     -0.183040
1000001000_1110100101    ∥W0966_2048＝-0.984210     -0.177004
1000001000_1110101000    ∥W0968_2048＝-0.985278     -0.170962
1000000111_1110101010    ∥W0969_2048＝-0.985798     -0.167938
1000000111_1110101100    ∥W0970_2048＝-0.986308     -0.164913
1000000111_1110101111    ∥W0972_2048＝-0.987301     -0.158858
1000000110_1110110010    ∥W0974_2048＝-0.988258     -0.152797
1000000110_1110110011    ∥W0975_2048＝-0.988722     -0.149765
1000000110_1110110101    ∥W0976_2048＝-0.989177     -0.146730
1000000101_1110111000    ∥W0978_2048＝-0.990058     -0.140658
1000000101_1110111011    ∥W0980_2048＝-0.990903     -0.134581
1000000100_1110111101    ∥W0981_2048＝-0.991311     -0.131540
1000000100_1110111110    ∥W0982_2048＝-0.991710     -0.128498
1000000100_1111000001    ∥W0984_2048＝-0.992480     -0.122411
1000000011_1111000100    ∥W0986_2048＝-0.993212     -0.116319
1000000011_1111000110    ∥W0987_2048＝-0.993564     -0.113271
1000000011_1111001000    ∥W0988_2048＝-0.993907     -0.110222
1000000011_1111001011    ∥W0990_2048＝-0.994565     -0.104122
1000000010_1111001110    ∥W0992_2048＝-0.995185     -0.098017
1000000010_1111001111    ∥W0993_2048＝-0.995481     -0.094963
1000000010_1111010001    ∥W0994_2048＝-0.995767     -0.091909
1000000010_1111010100    ∥W0996_2048＝-0.996313     -0.085797
1000000010_1111010111    ∥W0998_2048＝-0.996820     -0.079682
1000000010_1111011001    ∥W0999_2048＝-0.997060     -0.076624
1000000001_1111011010    ∥W1000_2048＝-0.997290     -0.073565
1000000001_1111011101    ∥W1002_2048＝-0.997723     -0.067444


				
				
1000000001_1111100001   ∥W1004_2048＝-0.998118      -0.061321
1000000001_1111100010   ∥W1005_2048＝-0.998302      -0.058258
1000000001_1111100100   ∥W1006_2048＝-0.998476      -0.055195
1000000001_1111100111   ∥W1008_2048＝-0.998795      -0.049068
1000000000_1111101010   ∥W1010_2048＝-0.999078      -0.042938
1000000000_1111101100   ∥W1011_2048＝-0.999205      -0.039873
1000000000_1111101101   ∥W1012_2048＝-0.999322      -0.036807
1000000000_1111110000   ∥W1014_2048＝-0.999529      -0.030675
1000000000_1111110011   ∥W1016_2048＝-0.999699      -0.024541
1000000000_1111110101   ∥W1017_2048＝-0.999769      -0.021474
1000000000_1111110111   ∥W1018_2048＝-0.999831      -0.018407
1000000000_1111111010   ∥W1020_2048＝-0.999925      -0.012272
1000000000_1111111101   ∥W1022_2048＝-0.999981      -0.006136
1000000000_1111111110   ∥W1023_2048＝-0.999995      -0.003068
1000000000_0000000011   ∥W1026_2048＝-0.999981      +0.006136
1000000000_0000001000   ∥W1029_2048＝-0.999882      +0.015339
1000000000_0000001101   ∥W1032_2048＝-0.999699      +0.024541
1000000000_0000010001   ∥W1035_2048＝-0.999431      +0.033741
1000000000_0000010110   ∥W1038_2048＝-0.999078      +0.042938
1000000001_0000011011   ∥W1041_2048＝-0.998640      +0.052132
1000000001_0000011111   ∥W1044_2048＝-0.998118      +0.061321
1000000001_0000100100   ∥W1047_2048＝-0.997511      +0.070505
1000000010_0000101001   ∥W1050_2048＝-0.996820      +0.079682
1000000010_0000101101   ∥W1053_2048＝-0.996045      +0.088854
1000000010_0000110010   ∥W1056_2048＝-0.995185      +0.098017
1000000011_0000110111   ∥W1059_2048＝-0.994240      +0.107172
1000000011_0000111100   ∥W1062_2048＝-0.993212      +0.116319
1000000100_0001000000   ∥W1065_2048＝-0.992099      +0.125455
1000000101_0001000101   ∥W1068_2048＝-0.990903      +0.134581
1000000101_0001001010   ∥W1071_2048＝-0.989622      +0.143695
1000000110_0001001110   ∥W1074_2048＝-0.988258      +0.152797
1000000111_0001010011   ∥W1077_2048＝-0.986809      +0.161886
1000001000_0001011000   ∥W1080_2048＝-0.985278      +0.170962
1000001000_0001011100   ∥W1083_2048＝-0.983662      +0.180023
1000001001_0001100001   ∥W1086_2048＝-0.981964      +0.189069
1000001010_0001100101   ∥W1089_2048＝-0.980182      +0.198098
1000001011_0001101010   ∥W1092_2048＝-0.978317      +0.207111
1000001100_0001101111   ∥W1095_2048＝-0.976370      +0.216107
1000001101_0001110011   ∥W1098_2048＝-0.974339      +0.225084
1000001110_0001111000   ∥W1101_2048＝-0.972226      +0.234042
1000001111_0001111100   ∥W1104_2048＝-0.970031      +0.242980
1000010001_0010000001   ∥W1107_2048＝-0.967754      +0.251898
1000010010_0010000110   ∥W1110_2048＝-0.965394      +0.260794
1000010011_0010001010   ∥W1113_2048＝-0.962953      +0.269668
1000010100_0010001111   ∥W1116_2048＝-0.960431      +0.278520
1000010110_0010010011   ∥W1119_2048＝-0.957826      +0.287347
1000010111_0010011000   ∥W1122_2048＝-0.955141      +0.296151
1000011000_0010011100   ∥W1125_2048＝-0.952375      +0.304929
1000011010_0010100001   ∥W1128_2048＝-0.949528      +0.313682
1000011011_0010100101   ∥W1131_2048＝-0.946601      +0.322408
1000011101_0010101010   ∥W1134_2048＝-0.943593      +0.331106
1000011110_0010101110   ∥W1137_2048＝-0.940506      +0.339777
1000100000_0010110010   ∥W1140_2048＝-0.937339      +0.348419
1000100010_0010110111   ∥W1143_2048＝-0.934093      +0.357031
1000100011_0010111011   ∥W1146_2048＝-0.930767      +0.365613
1000100101_0011000000   ∥W1149_2048＝-0.927363      +0.374164
				
				
1000100111_0011000100 ∥W1152_2048＝-0.923880   +0.382683
1000101001_0011001000 ∥W1155_2048＝-0.920318   +0.391170
1000101011_0011001101 ∥W1158_2048＝-0.916679   +0.399624
1000101101_0011010001 ∥W1161_2048＝-0.912962   +0.408044
1000101111_0011010101 ∥W1164_2048＝-0.909168   +0.416430
1000110000_0011011001 ∥W1167_2048＝-0.905297   +0.424780
1000110011_0011011110 ∥W1170_2048＝-0.901349   +0.433094
1000110101_0011100010 ∥W1173_2048＝-0.897325   +0.441371
1000110111_0011100110 ∥W1176_2048＝-0.893224   +0.449611
1000111001_0011101010 ∥W1179_2048＝-0.889048   +0.457813
1000111011_0011101111 ∥W1182_2048＝-0.884797   +0.465976
1000111101_0011110011 ∥W1185_2048＝-0.880471   +0.474100
1000111111_0011110111 ∥W1188_2048＝-0.876070   +0.482184
1001000010_0011111011 ∥W1191_2048＝-0.871595   +0.490226
1001000100_0011111111 ∥W1194_2048＝-0.867046   +0.498228
1001000110_0100000011 ∥W1197_2048＝-0.862424   +0.506187
1001001001_0100000111 ∥W1200_2048＝-0.857729   +0.514103
1001001011_0100001011 ∥W1203_2048＝-0.852961   +0.521975
1001001110_0100001111 ∥W1206_2048＝-0.848120   +0.529804
1001010000_0100010011 ∥W1209_2048＝-0.843208   +0.537587
1001010011_0100010111 ∥W1212_2048＝-0.838225   +0.545325
1001010101_0100011011 ∥W1215_2048＝-0.833170   +0.553017
1001011000_0100011111 ∥W1218_2048＝-0.828045   +0.560662
1001011011_0100100011 ∥W1221_2048＝-0.822850   +0.568259
1001011101_0100100111 ∥W1224_2048＝-0.817585   +0.575808
1001100000_0100101011 ∥W1227_2048＝-0.812251   +0.583309
1001100011_0100101110 ∥W1230_2048＝-0.806848   +0.590760
1001100110_0100110010 ∥W1233_2048＝-0.801376   +0.598161
1001101001_0100110110 ∥W1236_2048＝-0.795837   +0.605511
1001101011_0100111010 ∥W1239_2048＝-0.790230   +0.612810
1001101110_0100111101 ∥W1242_2048＝-0.784557   +0.620057
1001110001_0101000001 ∥W1245_2048＝-0.778817   +0.627252
1001110100_0101000101 ∥W1248_2048＝-0.773010   +0.634393
1001110111_0101001000 ∥W1251_2048＝-0.767139   +0.641481
1001111010_0101001100 ∥W1254_2048＝-0.761202   +0.648514
1001111101_0101010000 ∥W1257_2048＝-0.755201   +0.655493
1010000000_0101010011 ∥W1260_2048＝-0.749136   +0.662416
1010000100_0101010111 ∥W1263_2048＝-0.743008   +0.669283
1010000111_0101011010 ∥W1266_2048＝-0.736817   +0.676093
1010001010_0101011110 ∥W1269_2048＝-0.730563   +0.682846
1010001101_0101100001 ∥W1272_2048＝-0.724247   +0.689541
1010010000_0101100100 ∥W1275_2048＝-0.717870   +0.696177
1010010100_0101101000 ∥W1278_2048＝-0.711432   +0.702755
1010010111_0101101011 ∥W1281_2048＝-0.704934   +0.709273
1010011010_0101101110 ∥W1284_2048＝-0.698376   +0.715731
1010011110_0101110010 ∥W1287_2048＝-0.691759   +0.722128
1010100001_0101110101 ∥W1290_2048＝-0.685084   +0.728464
1010100101_0101111000 ∥W1293_2048＝-0.678350   +0.734739
1010101000_0101111011 ∥W1296_2048＝-0.671559   +0.740951
1010101100_0101111111 ∥W1299_2048＝-0.664711   +0.747101
1010101111_0110000010 ∥W1302_2048＝-0.657807   +0.753187
1010110011_0110000101 ∥W1305_2048＝-0.650847   +0.759209
1010110110_0110001000 ∥W1308_2048＝-0.643832   +0.765167
1010111010_0110001011 ∥W1311_2048＝-0.636762   +0.771061
1010111110_0110001110 ∥W1314_2048＝-0.629638   +0.776888
1011000001_0110010001 ∥W1317_2048＝-0.622461   +0.782651
				
				
1011000101_0110010100 ∥W1320_2048＝-0.615232    +0.788346
1011001001_0110010111 ∥W1323_2048＝-0.607950    +0.793975
1011001100_0110011001 ∥W1326_2048＝-0.600616    +0.799537
1011010000_0110011100 ∥W1329_2048＝-0.593232    +0.805031
1011010100_0110011111 ∥W1332_2048＝-0.585798    +0.810457
1011011000_0110100010 ∥W1335_2048＝-0.578314    +0.815814
1011011100_0110100100 ∥W1338_2048＝-0.570781    +0.821103
1011100000_0110100111 ∥W1341_2048＝-0.563199    +0.826321
1011100100_0110101010 ∥W1344_2048＝-0.555570    +0.831470
1011100111_0110101100 ∥W1347_2048＝-0.547894    +0.836548
1011101011_0110101111 ∥W1350_2048＝-0.540171    +0.841555
1011101111_0110110001 ∥W1353_2048＝-0.532403    +0.846491
1011110011_0110110100 ∥W1356_2048＝-0.524590    +0.851355
1011110111_0110110110 ∥W1359_2048＝-0.516732    +0.856147
1011111011_0110111001 ∥W1362_2048＝-0.508830    +0.860867
1100000000_0110111011 ∥W1365_2048＝-0.500885    +0.865514
1100000100_0110111101 ∥W1368_2048＝-0.492898    +0.870087
1100001000_0111000000 ∥W1371_2048＝-0.484869    +0.874587
1100001100_0111000010 ∥W1374_2048＝-0.476799    +0.879012
1100010000_0111000100 ∥W1377_2048＝-0.468689    +0.883363
1100010100_0111000110 ∥W1380_2048＝-0.460539    +0.887640
1100011000_0111001001 ∥W1383_2048＝-0.452350    +0.891841
1100011101_0111001011 ∥W1386_2048＝-0.444122    +0.895966
1100100001_0111001101 ∥W1389_2048＝-0.435857    +0.900016
1100100101_0111001111 ∥W1392_2048＝-0.427555    +0.903989
1100101001_0111010001 ∥W1395_2048＝-0.419217    +0.907886
1100101110_0111010011 ∥W1398_2048＝-0.410843    +0.911706
1100110010_0111010101 ∥W1401_2048＝-0.402435    +0.915449
1100110110_0111010111 ∥W1404_2048＝-0.393992    +0.919114
1100111011_0111011000 ∥W1407_2048＝-0.385516    +0.922701
1100111111_0111011010 ∥W1410_2048＝-0.377007    +0.926210
1101000011_0111011100 ∥W1413_2048＝-0.368467    +0.929641
1101001000_0111011110 ∥W1416_2048＝-0.359895    +0.932993
1101001100_0111011111 ∥W1419_2048＝-0.351293    +0.936266
1101010001_0111100001 ∥W1422_2048＝-0.342661    +0.939459
1101010101_0111100011 ∥W1425_2048＝-0.334000    +0.942573
1101011001_0111100100 ∥W1428_2048＝-0.325310    +0.945607
1101011110_0111100110 ∥W1431_2048＝-0.316593    +0.948561
1101100010_0111100111 ∥W1434_2048＝-0.307850    +0.951435
1101100111_0111101001 ∥W1437_2048＝-0.299080    +0.954228
1101101011_0111101010 ∥W1440_2048＝-0.290285    +0.956940
1101110000_0111101011 ∥W1443_2048＝-0.281465    +0.959572
1101110100_0111101101 ∥W1446_2048＝-0.272621    +0.962121
1101111001_0111101110 ∥W1449_2048＝-0.263755    +0.964590
1101111110_0111101111 ∥W1452_2048＝-0.254866    +0.966976
1110000010_0111110000 ∥W1455_2048＝-0.245955    +0.969281
1110000111_0111110001 ∥W1458_2048＝-0.237024    +0.971504
1110001011_0111110011 ∥W1461_2048＝-0.228072    +0.973644
1110010000_0111110100 ∥W1464_2048＝-0.219101    +0.975702
1110010100_0111110101 ∥W1467_2048＝-0.210112    +0.977677
1110011001_0111110110 ∥W1470_2048＝-0.201105    +0.979570
1110011110_0111110110 ∥W1473_2048＝-0.192080    +0.981379
1110100010_0111110111 ∥W1476_2048＝-0.183040    +0.983105
1110100111_0111111000 ∥W1479_2048＝-0.173984    +0.984749
1110101100_0111111001 ∥W1482_2048＝-0.164913    +0.986308
1110110000_0111111010 ∥W1485_2048＝-0.155828    +0.987784


				
				
1110110101_0111111010 ∥W1488_2048＝-0.146730   +0.989177
1110111010_0111111011 ∥W1491_2048＝-0.137620   +0.990485
1110111110_0111111100 ∥W1494_2048＝-0.128498   +0.991710
1111000011_0111111100 ∥W1497_2048＝-0.119365   +0.992850
1111001000_0111111101 ∥W1500_2048＝-0.110222   +0.993907
1111001100_0111111101 ∥W1503_2048＝-0.101070   +0.994879
1111010001_0111111110 ∥W1506_2048＝-0.091909   +0.995767
1111010110_0111111110 ∥W1509_2048＝-0.082740   +0.996571
1111011010_0111111111 ∥W1512_2048＝-0.073565   +0.997290
1111011111_0111111111 ∥W1515_2048＝-0.064383   +0.997925
1111100100_0111111111 ∥W1518_2048＝-0.055195   +0.998476
1111101000_0111111111 ∥W1521_2048＝-0.046003   +0.998941
1111101101_0111111111 ∥W1524_2048＝-0.036807   +0.999322
1111110010_0111111111 ∥W1527_2048＝-0.027608   +0.999619
1111110111_0111111111 ∥W1530_2048＝-0.018407   +0.999831
1111111011_0111111111 ∥W1533_2048＝-0.009204   +0.999958

                        Listing 17

　　 ∥512 point FFT twiddle factor coefficients(Radix 4+2).

　　 ∥Coefficients stored as non-fractional 10 bit integers(scale 1).

　　 ∥Real Coefficient(cosine value)is coefficient high-byte.

　　 ∥Imaginary Coefficient(sine value)is coefficient low-byte.
0111111111_0000000000 ∥W0000_0512＝+1.000000   -0.000000
0111111111_1111111010 ∥W0001_0512＝+0.999925   -0.012272
0111111111_1111110011 ∥W0002_0512＝+0.999699   -0.024541
0111111111_1111101101 ∥W0003_0512＝+0.999322   -0.036807
0111111111_1111100111 ∥W0004_0512＝+0.998795   -0.049068
0111111111_1111100001 ∥W0005_0512＝+0.998118   -0.061321
0111111111_1111011010 ∥W0006_0512＝+0.997290   -0.073565
0111111110_1111010100 ∥W0007_0512＝+0.996313   -0.085797
0111111110_1111001110 ∥W0008_0512＝+0.995185   -0.098017
0111111101_1111001000 ∥W0009_0512＝+0.993907   -0.110222
0111111100_1111000001 ∥W0010_0512＝+0.992480   -0.122411
0111111011_1110111011 ∥W0011_0512＝+0.990903   -0.134581
0111111010_1110110101 ∥W0012_0512＝+0.989177   -0.146730
0111111001_1110101111 ∥W0013_0512＝+0.987301   -0.158858
0111111000_1110101000 ∥W0014_0512＝+0.985278   -0.170962
0111110111_1110100010 ∥W0015_0512＝+0.983105   -0.183040
0111110110_1110011100 ∥W0016_0512＝+0.980785   -0.195090
0111110101_1110010110 ∥W0017_0512＝+0.978317   -0.207111
0111110100_1110010000 ∥W0018_0512＝+0.975702   -0.219101
0111110010_1110001010 ∥W0019_0512＝+0.972940   -0.231058
0111110001_1110000100 ∥W0020_0512＝+0.970031   -0.242980
0111101111_1101111110 ∥W0021_0512＝+0.966976   -0.254866
0111101101_1101110111 ∥W0022_0512＝+0.963776   -0.266713
0111101100_1101110001 ∥W0023_0512＝+0.960431   -0.278520
0111101010_1101101011 ∥W0024_0512＝+0.956940   -0.290285
0111101000_1101100101 ∥W0025_0512＝+0.953306   -0.302006
0111100110_1101011111 ∥W0026_0512＝+0.949528   -0.313682
0111100100_1101011001 ∥W0027_0512＝+0.945607   -0.325310
0111100010_1101010100 ∥W0028_0512＝+0.941544   -0.336890
0111100000_1101001110 ∥W0029_0512＝+0.937339   -0.348419
0111011110_1101001000 ∥W0030_0512＝+0.932993   -0.359895
0111011011_1101000010 ∥W0031_0512＝+0.928506   -0.371317
				
				
0111011001_1100111100 ∥W0032_0512＝+0.923880   -0.382683
0111010111_1100110110 ∥W0033_0512＝+0.919114   -0.393992
0111010100_1100110001 ∥W0034_0512＝+0.914210   -0.405241
0111010001_1100101011 ∥W0035_0512＝+0.909168   -0.416430
0111001111_1100100101 ∥W0036_0512＝+0.903989   -0.427555
0111001100_1100011111 ∥W0037_0512＝+0.898674   -0.438616
0111001001_1100011010 ∥W0038_0512＝+0.893224   -0.449611
0111000110_1100010100 ∥W0039_0512＝+0.887640   -0.460539
0111000100_1100001111 ∥W0040_0512＝+0.881921   -0.471397
0111000001_1100001001 ∥W0041_0512＝+0.876070   -0.482184
0110111101_1100000100 ∥W0042_0512＝+0.870087   -0.492898
0110111010_1011111110 ∥W0043_0512＝+0.863973   -0.503538
0110110111_1011111001 ∥W0044_0512＝+0.857729   -0.514103
0110110100_1011110011 ∥W0045_0512＝+0.851355   -0.524590
0110110001_1011101110 ∥W0046_0512＝+0.844854   -0.534998
0110101101_1011101001 ∥W0047_0512＝+0.838225   -0.545325
0110101010_1011100100 ∥W0048_0512＝+0.831470   -0.555570
0110100110_1011011110 ∥W0049_0512＝+0.824589   -0.565732
0110100011_1011011001 ∥W0050_0512＝+0.817585   -0.575808
0110011111_1011010100 ∥W0051_0512＝+0.810457   -0.585798
0110011011_1011001111 ∥W0052_0512＝+0.803208   -0.595699
0110010111_1011001010 ∥W0053_0512＝+0.795837   -0.605511
0110010100_1011000101 ∥W0054_0512＝+0.788346   -0.615232
0110010000_1011000000 ∥W0055_0512＝+0.780737   -0.624859
0110001100_1010111011 ∥W0056_0512＝+0.773010   -0.634393
0110001000_1010110110 ∥W0057_0512＝+0.765167   -0.643832
0110000100_1010110010 ∥W0058_0512＝+0.757209   -0.653173
0110000000_1010101101 ∥W0059_0512＝+0.749136   -0.662416
0101111011_1010101000 ∥W0060_0512＝+0.740951   -0.671559
0101110111_1010100100 ∥W0061_0512＝+0.732654   -0.680601
0101110011_1010011111 ∥W0062_0512＝+0.724247   -0.689541
0101101110_1010011010 ∥W0063_0512＝+0.715731   -0.698376
0101101010_1010010110 ∥W0064_0512＝+0.707107   -0.707107
0101100110 1010010010 ∥W0065_0512＝+0.698376   -0.715731
0101100001_1010001101 ∥W0066_0512＝+0.689541   -0.724247
0101011100_1010001001 ∥W0067_0512＝+0.680601   -0.732654
0101011000_1010000101 ∥W0068_0512＝+0.671559   -0.740951
0101010011_1010000000 ∥W0069_0512＝+0.662416   -0.749136
0101001110_1001111100 ∥W0070_0512＝+0.653173   -0.757209
0101001010_1001111000 ∥W0071_0512＝+0.643832   -0.765167
0101000101_1001110100 ∥W0072_0512＝+0.634393   -0.773010
0101000000_1001110000 ∥W0073_0512＝+0.624859   -0.780737
0100111011_1001101100 ∥W0074_0512＝+0.615232   -0.788346
0100110110_1001101001 ∥W0075_0512＝+0.605511   -0.795837
0100110001_1001100101 ∥W0076_0512＝+0.595699   -0.803208
0100101100_1001100001 ∥W0077_0512＝+0.585798   -0.810457
0100100111_1001011101 ∥W0078_0512＝+0.575808   -0.817585
0100100010_1001011010 ∥W0079_0512＝+0.565732   -0.824589
0100011100_1001010110 ∥W0080_0512＝+0.555570   -0.831470
0100010111_1001010011 ∥W0081_0512＝+0.545325   -0.838225
0100010010_1001001111 ∥W0082_0512＝+0.534998   -0.644854
0100001101_1001001100 ∥W0083_0512＝+0.524590   -0.851355
0100000111_1001001001 ∥W0084_0512＝+0.514103   -0.857729
0100000010_1001000110 ∥W0085_0512＝+0.503538   -0.863973
0011111100_1001000011 ∥W0086_0512＝+0.492898   -0.870087
0011110111_1000111111 ∥W0087_0512＝+0.482184   -0.876070
				
				
0011110001_1000111100  ∥W0088_0512＝+0.471397   -0.881921
0011101100_1000111010  ∥W0089_0512＝+0.460539   -0.887640
0011100110_1000110111  ∥W0090_0512＝+0.449611   -0.893224
0011100001_1000110100  ∥W0091_0512＝+0.438616   -0.898674
0011011011_1000110001  ∥W0092_0512＝+0.427555   -0.903989
0011010101_1000101111  ∥W0093_0512＝+0.416430   -0.909168
0011001111_1000101100  ∥W0094_0512＝+0.405241   -0.914210
0011001010_1000101001  ∥W0095_0512＝+0.393992   -0.919114
0011000100_1000100111  ∥W0096_0512＝+0.382683   -0.923880
0010111110_1000100101  ∥W0097_0512＝+0.371317   -0.928506
0010111000_1000100010  ∥W0098_0512＝+0.359895   -0.932993
0010110010_1000100000  ∥W0099_0512＝+0.348419   -0.937339
0010101100_1000011110  ∥W0100_0512＝+0.336890   -0.941544
0010100111_1000011100  ∥W0101_0512＝+0.325310   -0.945607
0010100001_1000011010  ∥W0102_0512＝+0.313682   -0.949528
0010011011_1000011000  ∥W0103_0512＝+0.302006   -0.953306
0010010101_1000010110  ∥W0104_0512＝+0.290285   -0.956940
0010001111_1000010100  ∥W0105_0512＝+0.278520   -0.960431
0010001001_1000010011  ∥W0106_0512＝+0.266713   -0.963776
0010000010_1000010001  ∥W0107_0512＝+0.254866   -0.966976
0001111100_1000001111  ∥W0108_0512＝+0.242980   -0.970031
0001110110_1000001110  ∥W0109_0512＝+0.231058   -0.972940
0001110000_1000001100  ∥W0110_0512＝+0.219101   -0.975702
0001101010_1000001011  ∥W0111_0512＝+0.207111   -0.978317
0001100100_1000001010  ∥W0112_0512＝+0.195090   -0.980785
0001011110_1000001001  ∥W0113_0512＝+0.183040   -0.983105
0001011000_1000001000  ∥W0114_0512＝+0.170962   -0.985278
0001010001_1000000111  ∥W0115_0512＝+0.158858   -0.987301
0001001011_1000000110  ∥W0116_0512＝+0.146730   -0.989177
0001000101_1000000101  ∥W0117_0512＝+0.134581   -0.990903
0000111111_1000000100  ∥W0118_0512＝+0.122411   -0.992480
0000111000_1000000011  ∥W0119_0512＝+0.110222   -0.993907
0000110010_1000000010  ∥W0120_0512＝+0.098017   -0.995185
0000101100_1000000010  ∥W0121_0512＝+0.085797   -0.996313
0000100110_1000000001  ∥W0122_0512＝+0.073565   -0.997290
0000011111_1000000001  ∥W0123_0512＝+0.061321   -0.998118
0000011001_1000000001  ∥W0124_0512＝+0.049068   -0.998795
0000010011_1000000000  ∥W0125_0512＝+0.036807   -0.999322
0000001101_1000000000  ∥W0126_0512＝+0.024541   -0.999699
0000000110_1000000000  ∥W0127_0512＝+0.012272   -0.999925
0000000000_1000000000  ∥W0128_0512＝+0.000000   -1.000000
1111111010_1000000000  ∥W0129_0512＝-0.012272   -0.999925
1111110011_1000000000  ∥W0130_0512＝-0.024541   -0.999699
1111100111_1000000001  ∥W0132_0512＝-0.049068   -0.998795
1111011010_1000000001  ∥W0134_0512＝-0.073565   -0.997290
1111010100_1000000010  ∥W0135_0512＝-0.085797   -0.996313
1111001110_1000000010  ∥W0136_0512＝-0.098017   -0.995185
1111000001_1000000100  ∥W0138_0512＝-0.122411   -0.992480
1110110101_1000000110  ∥W0140_0512＝-0.146730   -0.989177
1110101111_1000000111  ∥W0141_0512＝-0.158858   -0.987301
1110101000_1000001000  ∥W0142_0512＝-0.170962   -0.985278
1110011100_1000001010  ∥W0144_0512＝-0.195090   -0.980785
1110010000_1000001100  ∥W0146_0512＝-0.219101   -0.975702
1110001010_1000001110  ∥W0147_0512＝-0.231058   -0.972940
1110000100_1000001111  ∥W0148_0512＝-0.242980   -0.970031
1101110111_1000010011  ∥W0150_0512＝-0.266713   -0.963776
				
				
1101101011_1000010110   ∥W0152_0512＝-0.290285    -0.956940
1101100101_1000011000   ∥W0153_0512＝-0.302006    -0.953306
1101011111_1000011010   ∥W0154_0512＝-0.313682    -0.949528
1101010100_1000011110   ∥W0156_0512＝-0.336890    -0.941544
1101001000_1000100010   ∥W0158_0512＝-0.359895    -0.932993
1101000010_1000100101   ∥W0159_0512＝-0.371317    -0.928506
1100111100_1000100111   ∥W0160_0512＝-0.382683    -0.923880
1100110001_1000101100   ∥W0162_0512＝-0.405241    -0.914210
1100100101_1000110001   ∥W0164_0512＝-0.427555    -0.903989
1100011111_1000110100   ∥W0165_0512＝-0.438616    -0.898674
1100011010_1000110111   ∥W0166_0512＝-0.449611    -0.893224
1100001111_1000111100   ∥W0168_0512＝-0.471397    -0.881921
1100000100_1001000011   ∥W0170_0512＝-0.492898    -0.870087
1011111110_1001000110   ∥W0171_0512＝-0.503538    -0.863973
1011111001_1001001001   ∥W0172_0512＝-0.514103    -0.857729
1011101110_1001001111   ∥W0174_0512＝-0.534998    -0.844854
1011100100_1001010110   ∥W0176_0512＝-0.555570    -0.831470
1011011110_1001011010   ∥W0177_0512＝-0.565732    -0.824589
1011011001_1001011101   ∥W0178_0512＝-0.575808    -0.817585
1011001111_1001100101   ∥W0180_0512＝-0.595699    -0.803208
1011000101_1001101100   ∥W0182_0512＝-0.615232    -0.788346
1011000000_1001110000   ∥W0183_0512＝-0.624859    -0.780737
1010111011_1001110100   ∥W0184_0512＝-0.634393    -0.773010
1010110010_1001111100   ∥W0186_0512＝-0.653173    -0.757209
1010101000_1010000101   ∥W0188_0512＝-0.671559    -0.740951
1010100100_1010001001   ∥W0189_0512＝-0.680601    -0.732654
1010011111_1010001101   ∥W0190_0512＝-0.689541    -0.724247
1010010110_1010010110   ∥W0192_0512＝-0.707107    -0.707107
1010001101_1010011111   ∥W0194_0512＝-0.724247    -0.689541
1010001001_1010100100   ∥W0195_0512＝-0.732654    -0.680601
1010000101_1010101000   ∥W0196_0512＝-0.740951    -0.671559
1001111100_1010110010   ∥W0198_0512＝-0.757209    -0.653173
1001110100_1010111011   ∥W0200_0512＝-0.773010    -0.634393
1001110000_1011000000   ∥W0201_0512＝-0.780737    -0.624859
1001101100_1011000101   ∥W0202_0512＝-0.788346    -0.615232
1001100101_1011001111   ∥W0204_0512＝-0.803208    -0.595699
1001011101_1011011001   ∥W0206_0512＝-0.817585    -0.575808
1001011010_1011011110   ∥W0207_0512＝-0.824589    -0.565732
1001010110_1011100100   ∥W0208_0512＝-0.831470    -0.555570
1001001111_1011101110   ∥W0210_0512＝-0.844854    -0.534998
1001001001_1011111001   ∥W0212_0512＝-0.857729    -0.514103
1001000110_1011111110   ∥W0213_0512＝-0.863973    -0.503538
1001000011_1100000100   ∥W0214_0512＝-0.870087    -0.492898
1000111100_1100001111   ∥W0216_0512＝-0.881921    -0.471397
1000110111_1100011010   ∥W0218_0512＝-0.893224    -0.449611
1000110100_1100011111   ∥W0219_0512＝-0.898674    -0.438616
1000110001_1100100101   ∥W0220_0512＝-0.903989    -0.427555
1000101100_1100110001   ∥W0222_0512＝-0.914210    -0.405241
1000100111_1100111100   ∥W0224_0512＝-0.923880    -0.382683
1000100101_1101000010   ∥W0225_0512＝-0.928506    -0.371317
1000100010_1101001000   ∥W0226_0512＝-0.932993    -0.359895
1000011110_1101010100   ∥W0228_0512＝-0.941544    -0.336890
1000011010_1101011111   ∥W0230_0512＝-0.949528    -0.313682
1000011000_1101100101   ∥W0231_0512＝-0.953306    -0.302006
1000010110_1101101011   ∥W0232_0512＝-0.956940    -0.290285
1000010011_1101110111   ∥W0234_0512＝-0.963776    -0.266713
				
				
1000001111_1110000100 ∥W0236_0512＝-0.970031   -0.242980
1000001110_1110001010 ∥W0237_0512＝-0.972940   -0.231058
1000001100_1110010000 ∥W0238_0512＝-0.975702   -0.219101
1000001010_1110011100 ∥W0240_0512＝-0.980785   -0.195090
1000001000_1110101000 ∥W0242_0512＝-0.985278   -0.170962
1000000111_1110101111 ∥W0243_0512＝-0.987301   -0.158858
1000000110_1110110101 ∥W0244_0512＝-0.989177   -0.146730
1000000100_1111000001 ∥W0246_0512＝-0.992480   -0.122411
1000000010_1111001110 ∥W0248_0512＝-0.995185   -0.098017
1000000010_1111010100 ∥W0249_0512＝-0.996313   -0.085797
1000000001_1111011010 ∥W0250_0512＝-0.997290   -0.073565
1000000001_1111100111 ∥W0252_0512＝-0.998795   -0.049068
1000000000_1111110011 ∥W0254_0512＝-0.999699   -0.024541
1000000000_1111111010 ∥W0255_0512＝-0.999925   -0.012272
1000000000_0000001101 ∥W0258_0512＝-0.999699   +0.024541
1000000001_0000011111 ∥W0261_0512＝-0.998118   +0.061321
1000000010_0000110010 ∥W0264_0512＝-0.995185   +0.098017
1000000101_0001000101 ∥W0267_0512＝-0.990903   +0.134581
1000001000_0001011000 ∥W0270_0512＝-0.985278   +0.170962
1000001011_0001101010 ∥W0273_0512＝-0.978317   +0.207111
1000001111_0001111100 ∥W0276_0512＝-0.970031   +0.242980
1000010100_0010001111 ∥W0279_0512＝-0.960431   +0.278520
1000011010_0010100001 ∥W0282_0512＝-0.949528   +0.313682
1000100000_0010110010 ∥W0285_0512＝-0.937339   +0.348419
1000100111_0011000100 ∥W0288_0512＝-0.923880   +0.382683
1000101111_0011010101 ∥W0291_0512＝-0.909168   +0.416430
1000110111_0011100110 ∥W0294_0512＝-0.893224   +0.449611
1000111111_0011110111 ∥W0297_0512＝-0.876070   +0.482184
1001001001_0100000111 ∥W0300_0512＝-0.857729   +0.514103
1001010011_0100010111 ∥W0303_0512＝-0.838225   +0.545325
1001011101_0100100111 ∥W0306_0512＝-0.817585   +0.575808
1001101001_0100110110 ∥W0309_0512＝-0.795837   +0.605511
1001110100_0101000101 ∥W0312_0512＝-0.773010   +0.634393
1010000000_0101010011 ∥W0315_0512＝-0.749136   +0.662416
1010001101_0101100001 ∥W0318_0512＝-0.724247   +0.689541
1010011010_0101101110 ∥W0321_0512＝-0.698376   +0.715731
1010101000_0101111011 ∥W0324_0512＝-0.671559   +0.740951
1010110110_0110001000 ∥W0327_0512＝-0.643832   +0.765167
1011000101_0110010100 ∥W0330_0512＝-0.615232   +0.788346
1011010100_0110011111 ∥W0333_0512＝-0.585798   +0.810457
1011100100_0110101010 ∥W0336_0512＝-0.555570   +0.831470
1011110011_0110110100 ∥W0339_0512＝-0.524590   +0.851355
1100000100_0110111101 ∥W0342_0512＝-0.492898   +0.870087
1100010100_0111000110 ∥W0345_0512＝-0.460539   +0.887640
1100100101_0111001111 ∥W0348_0512＝-0.427555   +0.903989
1100110110_0111010111 ∥W0351_0512＝-0.393992   +0.919114
1101001000_0111011110 ∥W0354_0512＝-0.359895   +0.932993
1101011001_0111100100 ∥W0357_0512＝-0.325310   +0.945607
1101101011_0111101010 ∥W0360_0512＝-0.290285   +0.956940
1101111110_0111101111 ∥W0363_0512＝-0.254866   +0.966976
1110010000_0111110100 ∥W0366_0512＝-0.219101   +0.975702
1110100010_0111110111 ∥W0369_0512＝-0.183040   +0.983105
1110110101_0111111010 ∥W0372_0512＝-0.146730   +0.989177
1111001000_0111111101 ∥W0375_0512＝-0.110222   +0.993907
1111011010_0111111111 ∥W0378_0512＝-0.073565   +0.997290
1111101101_0111111111 ∥W0381_0512＝-0.036807   +0.999322

                                  Listing 18

/*FOLDBEGINS00″Copyright″*
/***************************************************************
Copyright (c)Pioneer Digital Design Centre Limited
NAME：pilloc_rtl.v
PURPOSE：Pilot location
CREATED：June 1997 BY：T. Foxcroft
MODIFIED：
USED IN PROJECTS：cofdm only.
***************************************************************/
/*FOLDENDS*/
/*FOLDBEGINS00 ″Defines″*/
`define FFTSIZE  2048
`define DATABINS  1705
`define SCATNUM  45
`define SCALEFACTOR64Q 3792∥3x8192/sqrt(42)
`define SCALEFACTOR16Q 3886∥3x8192/sqrt(10)*2
`define SCALEFACTORQPS 2172∥3x8192/sqrt(2)*
`define AVERAGESF  12′hc49∥0.04x4096x32768/1705＝3145
/*FOLDENDS*/
module chanest (clk，resync，in_valid，in_data，constellation，

　　                 u_symbol，us_pilots，uc_pilots，ct_pilots， out_tps， tps_valid，

　　                 uncorrected_iq，

　　                 out_valid，outi，outq，c_symbol，incfreq，wrstrb，ramindata，

　　                 ramoutdata，ramaddr)；
/*FOLDBEGINS00 ″i/o″*/
input clk，resync，in_valid；
input [23：0]in_data；
input [1：0]constellation；
output u_symbol；
output us_pilots，uc_pilots，ct_pilots；
output out_tps，tps_valid；
output [23：0]uncorrected_iq；
output out_valid；
output [7：0]outi；
output [7：0]outq；
output c_symbol；
output incfreq；
output wrstrb；
output [23：0]ramindata；
input [23：0]ramoutdata；
output [10：0]ramaddr；
/*FOLDENDS*/
/*FOLDBEGINS00 ″TPS location″*/
reg [10：0]tpsloc；
reg [4：0]tpscount；
				
				
always @(tpscount)
begin
  case(tpscount)
  5′b00000：tpsloc＝34；
  5′b00001：tpsloc＝50；
  5′b00010：tpsloc＝209；
  5′b00011：tpsloc＝346；
  5′b00100：tpsloc＝413；
  5′b00101：tpsloc＝569；
  5′b00110：tpsloc＝595；
  5′b00111：tpsloc＝688；
  5′b01000：tpsloc＝790；
  5′b01001：tpsloc＝901；
  5′b01010：tpsloc＝1073；
  5′b01011：tpsloc＝1219；
  5′b01100：tpsloc＝1262；
  5′b01101：tpsloc＝1286；
  5′b01110：tpsloc＝1469；
  5′b01111：tpsloc＝1594；
  default：tpsloc＝1687；
  endcase
end
/*FOLDENDS*/
/*FOLDBEGINS00 ″continuous pilot location″*/
reg [10：0]contloc；
reg [5：0]contloccount；
always @(contloccount)
begin
   case(contloccount)
   6′b000000：contloc＝0；
   6′b000001：contloc＝48；
   6′b000010：contloc＝54；
   6′b000011：contloc＝87；
   6′b000100：contloc＝141；
   6′b000101：contloc＝156；
   6′b000110：contloc＝192；
   6′b000111：contloc＝201；
   6′b001000：contloc＝255；
   6′b001001：contloc＝279；
   6′b001010：contloc＝282；
   6′b001011：contloc＝333；
   6′b001100：contloc＝432；
   6′b001101：contloc＝450；
   6′b001110：contloc＝483；
   6′b001111：contloc＝525；
   6′b010000：contloc＝531；
   6′b010001：contloc＝618；
   6′b010010：contloc＝636；
   6′b010011：contloc＝714；
   6′b010100：contloc＝759；
   6′b010101：contloc＝765；
   6′b010110：contloc＝780；
   6′b010111：contloc＝804；
   6′b011000：contloc＝873；
   6′b011001：contloc＝888；
   6′b011010：contloc＝918；
				
				
  6′b011011：contloc＝939；
  6′b011100：contloc＝942；
  6′b011101：contloc＝969；
  6′b011110：contloc＝984；
  6′b011111：contloc＝1050；
  6′b100000：contloc＝1101；
  6′b100001：contloc＝1107；
  6′b100010：contloc＝1110；
  6′b100011：contloc＝1137；
  6′b100100：contloc＝1140；
  6′b100101：contloc＝1146；
  6′b100110：contloc＝1206；
  6′b100111：contloc＝1269；
  6′b101000：contloc＝1323；
  6′b101001：contloc＝1377；
  6′b101010：contloc＝1491；
  6′b101011：contloc＝1683；
  default：contloc＝1704；
   endcase
end
/*FOLDENDS*/
/*FOLDBEGINS00 ″continuous pilot location″*/
/*reg [10：0]contloc[44：0]；
reg [5：0]contloccount；
initial
begin
   contloc[0]＝0；contloc[1]＝48；contloc[2]＝54； contloc[3]＝87；contloc[4]＝141；
   contloc[5]＝156；contloc[6]＝192； contloc[7]＝201； contloc[8]＝255；contloc[9]＝
   279；
   contloc[10]＝282；contloc[11]＝333； contloc[12]＝432；contloc[13]＝450；
   contloc[14]＝483；
   contloc[15]＝525；contloc[16]＝531； contloc[17]＝618； contloc[18]＝636；
   contloc[19]＝714；
   contloc[20]＝759；contloc[21]＝765； contloc[22]＝780；contloc[23]＝804；
   contloc[24]＝873；
   contloc[25]＝888；contloc[26]＝918； contloc[27]＝939；contloc[28]＝942；
   contloc[29]＝969；
   contloc[30]＝984；contloc[31]＝1050； contloc[32]＝1101；contloc[33]＝1107；
   contloc[34]＝1110；
   contloc[35]＝1137；contloc[36]＝1140；contloc[37]＝1146；contloc[38]＝1206；
   contloc[39]＝1269；
   contloc[40]＝1323；contloc[41]＝1377；contloc[42]＝1491；contloc[43]＝1683；
   contloc[44]＝1704；
end */
/*FOLDENDS*/
/*FOLDBEGINS00 ″Control vars″*/
reg [1：0]constell；
reg resynch；
reg valid，valid0，valid1，valid2，valid3，valid4，valid5，valid6，valid7，valid8；
reg [1：0]whichsymbol；
reg [1：0]pwhichsymbol；
reg incwhichsymbol；
reg [23：0]fftdata；
reg [10：0]fftcount；
reg [10：0]tapcount；
reg [3：0]count12；
				
				
reg [3：0]dcount12；
reg ramdatavalid；
reg tapinit；
reg tapinit1，tapinit2；
reg [7：0]nscat；
reg pilot；
reg tapload；∥controls when the taps are loaded
reg tapload2；
reg shiftinnewtap；
reg filtgo；
/*FOLDENDS*/
/*FOLDBEGINS00 ″Channel Est vars″*/
reg [11：0]tapi[5：0]；
reg [11：0]tapq[5：0]；
reg [27：0]sumi；
reg [27：0]sumq；
reg [11：0]chani；
reg [11：0]chanq；
wire [27：0]chani_；
wire [27：0]chanq_；
reg [11：0]idata；
reg [11：0]qdata；
/*FOLDENDS*/
/*FOLDBEGINS00 ″RAM vars″*/
reg [10：0]ramaddr；
reg [10：0]pilotaddr；
wire [10：0]ramaddr_；
wire [10：0]ramaddrrev_；
reg [23：0]ramindata；
wire [23：0]ramoutdata；
reg [23：0]ramout；
reg [23：0]ramot；
reg wrstrb；
reg rwtoggle；
reg framedata，framedata0；
reg frav，firstfrav；
reg [23：0]avchannel；
reg [11：0]avchan；
reg avlow；
wire [23：0]avchan_；
/*FOLDENDS*/
/*FOLDBEGINS00 ″Channel calc vars″*/
reg chan_val；
reg chan_val0，chan_val1，chan_val2，chan_val3，chan_val4，out_valid；
reg [23：0]sum；
reg [11：0]sumsq；
reg [11：0]sumsqtemp；
reg [11：0]topreal；
reg [11：0]topimag；
reg [7：0]outi；
reg [7：0]outitemp；
reg [5：0]outitem；
reg [7：0]outq；
reg [10：0]prbs；
∥integer intsumi，intsumq，intsumsq，intouti，intoutq；
/*FOLDENDS*/
				
				
/*FOLDBEGINS00 ″uncorrected pilot vars″*/
reg u_symbol；
reg us_pilots；
reg uc_pilots；
reg [23：0]uncorrected_iq；
reg [2：0]tps_pilots；
reg [5：0]tpsmajcount；
wire [5：0]tpsmajcount_；
reg ct_pilots；
reg out_tps，tps_valid；
reg [1：0] pilotdata；
/*FOLDENDS*/
/*FOLDBEGINS00 ″pilot locate vars″*/
wire [1：0] which_symbol；
wire [10：0] cpoffset；
wire [10：0] pilotramaddr_；
wire [23：0] pilotramin_；
wire pilotwrstrb_；
wire found_pilots；
reg pilotlocated；
/*FOLDENDS*/
/*FOLDBEGINS00 ″sync function arrays″*/
reg [11：0] sync0；
reg [11：0] sync1；
reg [11：0] sync2；
reg [3：0] syncoffset；
always @(dcount12 or valid1 or valid2)
begin
   if(valid1||valid2)
   syncoffset＝4′hc-dcount12；
   else
   syncoffset＝dcount12；
/*FOLDBEGINS02″″*/
case(syncoffset)
4′h1：
begin

　　  sync0＝4046；sync1＝272；sync2＝95；

　　  end

　　  4′h2：

　　  begin

　　  sync0＝3899；sync1＝476；sync2＝168；

　　  end

　　  4′h3：

　　  begin

　　  sync0＝3661；sync1＝614；sync2＝217；

　　  end

　　  4′h4：

　　  begin

　　  sync0＝3344；sync1＝687；sync2＝243；

　　  end

　　  4′h5：

　　  begin

　　  sync0＝2963；sync1＝701；sync2＝248；

　　  end

　　  4′h6：
				
				
　　  begin

　　  sync0＝2534；sync1＝665；sync2＝234；

　　  end

　　  4′h7：

　　  begin

　　  sync0＝2076；sync1＝590；sync2＝205；

　　  end

　　  4′h8：

　　  begin

　　  sync0＝1609；sync1＝486；sync2＝167；

　　  end

　　  4′h9：

　　  begin

　　  sync0＝1152；sync1＝364；sync2＝123；

　　  end

　　  4′ha：

　　  begin

　　  sync0＝722；sync1＝237；sync2＝78；

　　  end

　　  default

　　  begin

　　  sync0＝334；sync1＝113；sync2＝36；

　　  end

　　  endcase

　　  /*FOLDENDS*/
end
/*FOLDENDS*/
always @(posedge clk)
begin
/*FOLDBEGINS02″Control″*/
   constell＜＝constellation；
   resynch＜＝resync；
   if(resynch)
   begin
   /*FOLDBEGINS02″″*/

　　  valid＜＝1′b0；

　　  valid0＜＝1′b0；

　　  valid1＜＝1′b0；

　　  valid2＜＝1′b0；

　　  valid3＜＝1′b0；

　　  valid4＜＝1′b0；

　　  valid5＜＝1′b0；

　　  valid6＜＝1′b0；

　　  valid7＜＝1′b0；

　　  valid8＜＝1′b0；

　　  fftcount＜＝11′b0；

　　  ramdatavalid＜＝1′b0；

　　  chan_val＜＝1′b0；

　　  tapinit＜＝1′b0；

　　  tapinit1＜＝1′b0；

　　  tapinit2＜＝1′b0；

　　  rwtoggle＜＝1′b0；

　　  /*FOLDENDS*/
   end
   else
				
				
begin
/*FOLDBEGINS02 ″″*/
   valid＜＝in_valid；
   valid0＜＝valid&&pilotlocated；
   valid1＜＝valid0；
   valid2＜＝valid1；
   valid3＜＝valid2；
   valid4＜＝valid3；
   valid5＜＝valid4；
   valid6＜＝valid5；
   valid7＜＝valid6；
   valid8＜＝valid7；
   if(valid2)

　　 fftcount＜＝fftcount+1′b1；

　　  chan_val＜＝valid4&&filtgo&&framedata；

　　  incwhichsymbol＜＝valid1&&(fftcount＝＝(`FFTSIZE-1))；

　　  if(incwhichsymbol)

　　  begin

　　  rwtoggle＜＝！rwtoggle；

　　  tapinit＜＝1′b1；

　　  ramdatavalid＜＝1′b1；
   end
   else if(valid6)

　　  tapinit＜＝1′b0；
   tapinit1＜＝tapinit；
   tapinit2＜＝tapinit1；
   /*FOLDENDS*/
end
fftdata＜＝in_data；
/*FOLDBEGINS00 ″frame averager″*/
if(resynch)
begin
   frav＜＝1′b0；
   firstfrav＜＝1′b0；
end
else
begin
   if(chan_val&&framedata)
   frav＜＝1′b1；
   else if(！framedata&&framedata0)
   frav＜＝1′b0；
   if(chan_val&&framedata&&！frav)
   firstfrav＜＝1′b1；
   else if(chan_val)
   firstfrav＜＝1′b0；
/*FOLDBEGINS02 ″calculate 0.2x mean channel amplitude″*/
if(chan_val0)
begin

　　 if(firstfrav)

　　 begin

　　   avchannel＜＝avmult(sumsqtemp)；

　　     avchan＜＝avchan_[11：0]；

　　 end
				
				
　　 else

　　    avchannel＜＝avmult(sumsqtemp)+avchannel；

　　    end

　　    /*FOLDENDS*/

　　    if(chan_val1)

　　 avlow＜＝(sumsqtemp＜avchan)？1：0；
end
/*FOLDENDS*/
if(resynch)
begin
   framedata＜＝1′b0；
   framedata0＜＝1′b0；
   tapload  ＜＝1′b0；
end
else
begin
   framedata0＜＝framedata；
   if(incwhichsymbol&&(cpoffset＝＝0))

　　  framedata＜＝1；

　　  else if(ramdatavalid&&valid2&&(fftcount＝＝(cpoffset-1)))

　　  framedata＜＝1；

　　  else if(valid2&&(fftcount＝＝(cpoffset+`DATABINS)))

　　  framedata＜＝0；

　　  tapload＜＝framedata；
end
filtgo＜＝ramdatavalid&&(valid2？tapload：filtgo)；
tapload2＜＝valid&&tapload&&(count12＝＝11)&&(fftcount！＝0)；
pilot＜＝(countl2＝＝0)；
dcount12＜＝count12；
shiftinnewtap＜＝！((nscat＝＝139)||(nscat＝＝140)||(nscat＝＝141))；
if(incwhichsymbol)
begin
   if(！ramdatavalid)
   begin

　　  whichsymbol＜＝pwhichsymbol；

　　  tapcount＜＝pwhichsymbol*2′b11+cpoffset；
   end
   else
   begin

　　  whichsymbol＜＝whichsymbol+1′b1；

　　  tapcount   ＜＝{whichsymbol[1]^whichsymbol[0]，！whichsymbol[0]}*2′b11

　　  cpoffset；
   end

　　end

　　else

　　if(framedata)

　　begin

　　if(fftcount＝＝cpoffset)

　　begin
 /*FOLDBEGINS04″set up the counters″*/
 ∥count12＜＝((4-whichsymbol)&4′b0011)*3；
 count12＜＝{whichsymbol[1]^whichsymbol[0]，whichsymbol[0]}*2′b11；
 if(valid0)
				
				
　　     nscat＜＝8′b0；

　　     /*FOLDENDS*/

　　end

　　else

　　begin
  /*FOLDBEGINS 04 ″″*/
  if(valid)
  begin

　　      count12＜＝(count12＝＝11)？4′b0：count12+1′b1；

　　      tapcount＜＝tapcount+1′b1；

　　      if(count12＝＝11)

　　         nscat＜＝nscat+1′b1；

　　         end

　　   /*FOLDENDS*/

　　   end
  end
  else
  begin

　　if(tapinit2&&valid5)

　　nscat＜＝8′b0；

　　if(tapinit)

　　begin

　　  if(valid3||valid4||valid5&&(whichsymbol＝＝2′b0))

　　  tapcount＜＝tapcount+4′hc；

　　  else

　　  if(valid6)

　　         tapcount＜＝tapcount+

　　{whichsymbol[1]＾whichsymbol[0]，whichsymbol[0]}*2′b11+1′b1；

　　         end
  end
  /*FOLDENDS*/
/*FOLDBEGINS 0 2 ″Channel Estimation″*/
if(tapinit2)
begin
  /*FOLDBEGINS 0 4 ″Read in first 3 or 4 taps″*/
  if(valid5)

　　       prbs＜＝alpha12(alpha(whichsymbol))；

　　       else

　　       if(valid6||valid7||(valid8&&(whichsymbol＝＝2′b0)))

　　       prbs＜＝alpha12(prbs)；

　　       if(valid5)

　　       begin

　　       tapi[0]＜＝pseudo(ramout[23：12]，1′b1)；

　　       tapi[1]＜＝pseudo(ramout[23：12]，1 ′b1)；

　　       tapi[2]＜＝pseudo(ramout[23：12]，1 ′b1)；

　　       tapi[3]＜＝pseudo(ramout[23：12]，1′b1)；

　　       tapq[0]＜＝pseudo(ramout[11：0]，1′b1)；

　　       tapq[1]＜＝pseudo(ramout[11：0]，1′b1)；

　　       tapq[2]＜＝pseudo(ramout[11：0]，1 ′b1)；

　　       tapq[3]＜＝pseudo(ramout[11：0]，1′b1)；

　　     end

　　     else if(！((whichsymbol！＝2′b0)&&valid8))

　　     begin

　　     tapi[5]＜＝tapi[4]；

　　     tapi[4]＜＝tapi[3]；
				
				
　　 tapi[3]＜＝tapi[2]；

　　 tapi[2]＜＝tapi[1]；

　　 tapi[1]＜＝tapi[0]；

　　 tapi[0]＜＝pseudo(ramout[23：12]，prbs[0])；

　　 tapq[5]＜＝tapq[4]；

　　 tapq[4]＜＝tapq[3]；

　　 tapq[3]＜＝tapq[2]；

　　 tapq[2]＜＝tapq[1]；

　　 tapq[1]＜＝tapq[0]；

　　 tapq[0]＜＝pseudo(ramout[11：0]，prbs[0])；

　　 end

　　 /*FOLDENDS*/
   end
   else if(framedata)
   begin
/*FOLDBEGINS 0 4 ″update taps in normal op.″*/
if(tapload2)
begin

　　     prbs＜＝alpha12(prbs)；

　　     tapi[5]＜＝tapi[4]；

　　     tapi[4]＜＝tapi[3]；

　　     tapi[3]＜＝tapi[2]；

　　     tapi[2]＜＝tapi[1]；

　　     tapi[1]＜＝tapi[0]；

　　     if(shiftinnewtap)

　　         tapi[0]＜＝pseudo(ramout[23：12]，prbs[0])；

　　         tapq[5]＜＝tapq[4]；

　　         tapq[4]＜＝tapq[3]；

　　         tapq[3]＜＝tapq[2]；

　　         tapq[2]＜＝tapq[1]；

　　         tapq[1]＜＝tapq[0]；

　　         if(shiftinnewtap)

　　         tapq[0]＜＝pseudo(ramout[11：0]，prbs[0])；

　　         end

　　         /*FOLDENDS*/
/*FOLDBEGINS 0 4 ″Channel interpolate″*/
if(pilot)
begin

　　  if(valid4)

　　  begin

　　    chani＜＝tapi[3]；

　　    chanq＜＝tapq[3]；

　　  end

　　  if(valid3)

　　  begin

　　    idata＜＝ramot[23：12]；

　　    qdata＜＝ramot[11：0]；

　　  end

　　  end

　　  else

　　  begin

　　  if(valid1)

　　  begin

　　    sumi＜＝mult(tapi[0]，sync2)-mult(tapi[1]，sync1)；

　　    sumq＜＝mult(tapq[0]，sync2)；
				
				
　　      end

　　      else if(valid2)

　　      begin

　　        sumi＜＝sumi+mult(tapi[2]，sync0)；

　　        sumq＜＝sumq+mult(tapq[2]，sync0)-mult(tapq[1]，sync1)；

　　      end

　　      else if(valid3)

　　      begin

　　        sumi＜＝sumi+mult(tapi[3]，sync0)-mult(tapi[4]，sync1)；

　　        sumq＜＝sumq+mult(tapq[3]，sync0)+12′h800；//2048 for final round-

　　        ing

　　        idata＜＝ramot[23：12]；

　　        qdata＜＝ramot[11：0]；

　　      end

　　      else if(valid4)

　　      begin

　　        chani＜＝chani_[23：12]；

　　        chanq＜＝chanq_[23：12]；

　　      end

　　      end

　　      //intsumi＝(chani[11])？{20′hfffff，chani[11：0]}：chani；

　　      //intsumq＝(chanq[11])？{20′hfffff，chanq[11：0]}：chanq；

　　      //if(chan_val)$display(intsumi*intsumi+intsumq*intsumq)；

　　      /*FOLDENDS*/

　　end

　　end

　　assign chani_＝sumi+mult(tapi[5]，sync2)+12′h800；

　　assign chanq_＝sumq+mult(tapq[5]，sync2)-mult(tapq[4]，sync1)；

　　assign avchan_＝avchannel+24′h000800；

　　/*FOLDENDS*/
/*FOLDBEGINS 0 2″Calculate channel″*/
always @(posedge clk)
begin

　　 if(resynch)

　　 begin

　　   chan_val0＜＝1′b0；

　　   chan_val1＜＝1′b0；

　　   chan_val2＜＝1′b0；

　　   chan_val3＜＝1′b0；

　　   chan_val4＜＝1′b0；

　　   out_valid＜＝1′b0；

　　 end

　　 else

　　 begin

　　   chan_val0＜＝chan_val；

　　   chan_val1＜＝chan_val0；

　　   chan_val2＜＝chan_val1；

　　   chan_val3＜＝chan_val2；

　　   chan_val4＜＝chan_val3；

　　   //out_valid＜＝chan_val4；

　　   out_valid＜＝chan_val4&&ramdatavalid&&！pilotdata[1]；

　　 end

　　 if(chan_val)

　　     sumsqtemp＜＝sum[22：11]；

　　     if(chan_val0)
				
				
　　   topreal＜＝sum[23：12]；

　　   if(chan_val1)

　　   topimag＜＝sum[23：12]；

　　   if(chan_val2)

　　   sumsq＜＝sum[23：12]；

　　   if(chan_val3)

　　   begin

　　   outitemp＜＝divider(topreal，sumsq，(constell＝＝0))；

　　   outitem＜＝divplussoft(topreal，sumsq，constell)；

　　 end

　　 if(chan_val4)

　　 begin

　　   outq＜＝divider(topimag，sumsq，(constell＝＝0))；

　　   outi＜＝outitemp；

　　 end

　　 //intouti＝(outi[7])？{24′hffffff，outi[7：0]}：outi；

　　 //intoutq＝(outq[7])？{24′hffffff，outq[7：0]}：outq；

　　 //if(chan_val&&ramdatavalid)$display(intsumi)；

　　 //if(chan_val4&&ramdatavalid)$displayb(outitemp，，outitem)；

　　 end

　　 always @(chan_val or chan_val0 or chan_val1 or chani or chanq or constell

　　          or idata or qdata or sumsqtemp)

　　          begin

　　 if(chan_val)

　　 sum＝smult(chani，chani，1)+smult(chanq，chanq，1)+24′h000400；

　　 else if(chan_val0)

　　 sum＝smult(idata，chani，1)+smult(qdata，chanq，1)+24′h000800；

　　 else if(chan_val1)

　　 sum＝smult(qdata，chani，1)-smult(idata，chanq，1)+24′h000800；

　　 else//chan_val2

　　 begin

　　   case(constell)

　　   2′b00：

　　       sum＝smult(sumsqtemp，`SCALEFACTORQPS，0)+24′h000800；

　　       2′b01：

　　       sum＝smult(sumsqtemp，`SCALEFACTOR16Q，0)+24′h000800；

　　       default：

　　       sum＝smult(sumsqtemp，`SCALEFACTOR64Q，0)+24′h000800；

　　       endcase

　　 end

　　 end

　　 /*FOLDENDS*/
/*FOLDBEGINS 0 2″Extract Continual and scattered pilots for Freq+Sampling Error
   Block″*/
always @(posedge clk)
begin

　　 if(resynch)

　　 contloccount＜＝6′b0；

　　 else

　　 if(ramdatavalid&&valid2&&(pilotaddr＝＝contloc))

　　     contloccount＜＝(contloccount＝＝44)？6′b0：contloccount+1′b1；

　　     if(ramdatavalid&&valid2&&((pilotaddr＝＝contloc)||pilot))

　　     uncorrected_iq＜＝ramot；

　　     uc_pilots＜＝

　　 ramdatavalid&&framedata&&(pilotaddr＝＝contloc)&&valid2&&！resynch；
				
				
　　     us_pilots＜＝ramdatavalid&&framedata&&pilot&&valid2&&！resynch；

　　     u_symbol＜＝！resynch&&ramdatavalid&&(valid2？(pilotaddr＝＝0)：u_symbol)；

　　     //$display(pilotaddr，，ramot[23：12]，，valid2，，contloccount，，uncorrected_iq[

　　 23：12]，，uncorrected_iq[11：0]，，uc_pilots，，us_pilots)；
   end
   */FOLDENDS*/
/*FOLDBEGINS 0 2″Extract TPS pilots″*/
always @(posedge clk)
begin

　　 if(resynch)

　　 begin

　　   tpscount＜＝5′b0；

　　   tps_pilots＜＝3′b0；

　　   tps_valid＜＝1′b0；

　　   ct_pilots＜＝1′b0；

　　 end

　　 else

　　 begin

　　  if(ramdatavalid&&valid2&&(pilotaddr＝＝tpsloc))

　　  tpscount＜＝(tpscount[4])？5′b0：tpscount+1′b1；

　　  tps_pilots[0]＜＝valid2？ramdatavalid&&framedata&&(pilotaddr＝＝tpsloc)：

　　   tps_pilots[0]；

　　  tps_pilots[1]＜＝(chan_val？tps_pilots[0]：tps_pilots[1])；

　　  tps_pilots[2]＜＝tps_pilots[1]&&chan_val3；

　　  tps_valid＜＝(tpscount＝＝0)&&tps_pilots[2]；

　　  ct_pilots＜＝tps_pilots[2]；

　　 end

　　 if(resynch)

　　     tpsmajcount＜＝6′b0；

　　     else

　　     begin

　　     if(tps_pilots[2])

　　     begin

　　       if(tpscount＝＝0)

　　       begin

　　            tpsmajcount＜＝6′b0；

　　            out_tps＜＝tpsmajcount_[5]；

　　       end

　　       else

　　            tpsmajcount＜＝tpsmajcount_；

　　            end

　　 end

　　 if(resynch)

　　     pilotdata＜＝2′b0；

　　     else

　　     begin

　　   if(valid2)

　　   pilotdata[0]＜＝ramdatavalid&&framedata&&(

　　                            (pilotaddr＝＝tpsloc)||

　　                            (pilotaddr＝＝contloc)||

　　                            pilot

　　                            )；

　　     pilotdata[1]＜＝chan_val0？pilotdata[0]：pilotdata[1]；

　　     end
				
				
　　 //$display(pilotaddr，，ramot[23：12]，，valid2，，contloccount，，uncorrected_iq[2

　　 3：12]，，uncorrected_iq[11：0]，，uc_pilots，，us_pilots)；
//$display(valid2，，pilotdata[0]，，pilotdata[1]，，pilotdata[2]，，ct_pilots，，，，
，，out_valid，，pilotaddr)；

　　 end

　　 assign tpsmajcount_＝tps(topreal[11]，tpscount，tpsmajcount)；

　　 /*FOLDENDS*/

　　 /*FOLDBEGINS 1 2″pilot locate control″*/

　　 always @(posedge clk)

　　 begin

　　   if(resynch)

　　   pilotlocated＜＝1′b0；

　　   else

　　   if(found_pilots)

　　   begin

　　        pilotlocated＜＝1′b1；

　　        pwhichsymbol＜＝which_symbol+2′b10；

　　      end

　　      end

　　      /*FOLDENDS*/
/*FOLDBEGINS 0 2 ″RAM″*/
always @(posedge clk)
begin

　　 if(pilotlocated)

　　 begin

　　   wrstrb＜＝！valid0；

　　   if(valid)

　　       ramindata＜＝fftdata；

　　       pilotaddr＜＝ramaddr_-cpoffset；

　　       ramaddr＜＝rwtoggle？ramaddr_ ：ramaddrrev_；

　　       if(valid5)ramot＜＝ramout；

　　  end

　　  else

　　  begin
   /*FOLDBEGINS 0 4″″*/
   wrstrb＜＝pilotwrstrb_；
   ramindata＜＝pilotramin_；
   ramaddr＜＝pilotramaddr_；
   /*FOLDENDS*/

　　  end

　　  ramout＜＝ramoutdata；

　　end

　　assign ramaddr_＝(tapinit||framedata&&(valid2&&(count12＝＝11)))？tapcount：

　　fftcount；

　　assign ramaddrrev_＝

　　{ramaddr_[0]，ramaddr_[1]，ramaddr_[2]，ramaddr_[3]，ramadd r_[4]，ramaddr_[5]，

　　ramaddr_[6]，ramaddr_[7]，ramaddr_[8]，ramaddr_[9]，ramaddr_[10]}；

　　                             /*FOLDENDS*/

　　                             assign c_symbol＝whichsymbol[0]；
/*FOLDBEGINS 0 0″″*/
always @(posedge clk)
begin
				
				
  //$display(chan_val，，framedata，，frav，，firstfrav，，，，valid2，，valid4，，out_valid
  ，，avchannel，，avchan，，sumsqtemp，，，avlow，，chan_val1，，)；
  //$display(tps_valid，，out_tps，，tpscount，，tps_pilots[2])；
  //$display(in_data，，filtgo，，valid4，，tapload，，，nscat，，count12，，fftcount，，incw
  hichsymbol，，，
  //tapcount，，ramaddr，，wrstrb，，rwtoggle
  //)；
  //(resynch，，valid，，fftcount，，ramaddr，，ramindata[23：12]，，ramoutdata[23：12]，，t
  apinit，，tapinit2，，tapcount，，ramout[23：12],
  //tapi[0]，，tapi[1]，，tapi[2]，，tapi[3]，，tapi[4]，，tapi[5])；
  //$display(tapcount，，tapinit2，，valid4，，valid，，valid2，，wrstrb，，fftcount，，fram
  edata，，count12，，tapi[0]，，tapi[1]，，tapi[2]，，tapi[3]，，tapi[4]，，tapi[5])；
  //$display(，，，，intouti，，intoutq，，out_valid，，，，valid4，，valid2，，chan_val，，filt
  go，，framedata，，fftcount，，ramindata[23：12])；
  //if(whichsymbol＝＝1)
  $display(tapinit，，tapcount，，fftcount，，ramindata[23：12]，，，，tapcount，，tapi[0]
  ，，tapi[1]，，tapi[2]，，tapi[3]，，tapi[4]，，tapi[5]，，intsumi，，intsumq，，idata，，qda ta)；
  //$display(framedata，，pilotaddr，，fftcount，，tapcount，，ramaddr，，ramout[23：12]，
  ，ramindata[23：12]，，prbs，，us_pilots，，uc_pilots，，ct_pilots，，out_valid，，，contl occount，，
  //tps_pilots[0]，，tps_pilots[1]，，tps_pilots[2])；
end
/*FOLDENDS*/
pilloc pilloc (.clk(clk)，.resync(resync)，.in_valid(in_valid)， .in_data(in_data)，
.found_pilots(found_pilots)，.which_symbol(which_symbol)，

　　               .cpoffset(cpoffset)，.incfreq(incfreq)，

　　               .ramaddr(pilotramaddr_)，.ramin(pilotramin_)，.ramout(ramout)，

　　               .wrstrb(pilotwrstrb_))；
/*FOLDBEGINS 0 2″functions″*/
/*FOLDBEGINS 0 0″tps demod″*/
function[5：0]tps；
input tpssign；
input[4：0]tpscount；
input[5：0]tpsmajcount；
reg tpsflip；
begin

　　 case(tpscount)

　　  5′b00001，5′b00011，5′b00100，5′b00110，5′b01011，5′b01110：

　　        tpsflip＝0；//added1 since tpscount already incremented

　　        default：

　　        tpsflip＝1；

　　        endcase

　　        tps＝(tpsflip^tpssign)？tpsmajcount-1′b1：tpsmajcount+1′b1；
   end
   endfunction
   /*FOLDENDS*/
   /*FOLDBEGINS 0 0″pseudo function″*/
   function[11：0]pseudo；
   input[11：0]data；
   input flip；
   begin

　　 pseudo＝flip？～data+1′b1：data；

　　 end

　　 endfunction

　　 /*FOLDENDS*/

　　 /*FOLDBEGINS 0 0″averager multiplier″*/
				
				
  function[11：0]avmult；
  input[11：0]i；
  reg[23：0]res；
  begin
  res＝(i*`AVERAGESF)+23′h000800；//multiply and round
  avmult＝res[23：12]；
end
endfunction
/*FOLDENDS*/
/*FOLDBEGINS 0 0″filter tap multiplier″*/
function[27：0]mult；
input[11：0]i；
input[11：0]j；
reg[23：0]res；
reg[11：0]modi；
reg[11：0]invi；
begin
  invi＝～i+1′b1；
  modi＝i[11]？invi：i；
  res＝(modi*j)；//multiply and round
  mult＝i[11]？{4′hf，～res}+1′b1：res；
end
endfunction
/*FOLDENDS*/
/*FOLDBEGINS 0 0″signed multiplier″*/
function[23：0]smult；
input[11：0]i；
input[11：0]j；
input signedj；
reg[23：0]res；
reg[11：0]modi；
reg[11：0]modj；
begin
  modi＝i[11]？～i+1′b1：i；
  modj＝(j[11]&&signedj)？～j+1′b1：j；
  res＝(modi*modj)；
  smult＝(i[11]＾(j[11]&&signedj))？～res+1′b1：res；
end
endfunction
/*FOLDENDS*/
/*FOLDBEGINS 0 0″divider function″*/
function[7：0]divider；
input[11：0]dividend；
input[11：0]divisor；
input qpsk；
reg[11：0]moddividend；
reg signresult；
reg[12：0]intval；
reg[12：0]carry；
reg[7：0]divide；
reg[8：0]signeddivide；
integer i；
begin
  signresult＝dividend[11]；
  moddividend＝dividend[11]？～dividend+1′b1：dividend；
				
				
   divide＝0；
   carry＝qpsk？{1′b0，moddividend}：{moddividend，1′b0}；
/*FOLDBEGINS 0 2″″*/
for(i＝0；i＜8；i＝i+1)
begin

　　 intval＝carry-divisor；

　　 divide[7-i]＝！intval[12]；

　　 carry＝(intval[12])？{carry[11：0]，1 ′b0}：{intval[11：0]，1′b0}；
   end
   /*FOLDENDS*/
   //signeddivide＝signresuit？～divide+2′b10：divide+1′b1；
   signeddivide＝signresult？{1′b1 ，～divide}+2′b10：{1′b0，divide}+1′b1；
   //$displayb(signeddivide，，divide，，signresult，，constellation，，)；
   divider＝signeddivide[8：1]；
end
endfunction
/*FOLDENDS*/
/*FOLDBEGINS 0 0″divider function with soft decisions added″*/
function[5：0]divplussoft；
input[11：0]dividend；
input[11：0]divisor；
input[1：0]constellation；
reg[11：0]moddividend；
reg signresult；
reg[12：0]intval；
reg[12：0]carry；
reg[8：0]divide；
reg[10：0]signeddivide；
reg[11：0]fracdivide；
integer i；
begin
  signresult＝dividend[11]；
  moddividend＝dividend[11]？～dividend+1′b1：dividend；
  divide＝0；
  carry＝(constellation＝＝0)？{1′b0，moddividend}：{moddividend，1′b0}；
/*FOLDBEGINS 0 2″″*/
for(i＝0；i＜9；i＝i+1)
begin

　　 intval＝carry-divisor；

　　 divide[8-i]＝！intval[12]；

　　 carry＝(intval[12])？{carry[11：0]，1′b0}：{intval[11：0]，1′b0}；
   end
   /*FOLDENDS*/
   signeddivide＝signresult？{2′b11，～divide}+1′b1：{2′b0，divide}；
   //$displayb(signeddivide，，divide，，signresult，，constellation，，)；
/*FOLDBEGINS 0 2″qpsk″*/
if(constellation＝＝2′b0)
begin

　　 //$writeh(，，signeddivide，，，，)；

　　 signeddivide＝signeddivide+8′h80；

　　 //$writeh(signeddivide，，，，)；

　　 if(signeddivide[10])

　　     fracdivide＝9′h0；

　　     else

　　     if(signeddivide[9]||signeddivide[8])
				
				
　　  fracdivide＝12′h700；

　　  else

　　  begin

　　  fracdivide＝signeddivide[7：0]+{signeddivide[7：0]，1′b0}+

　　  {signeddivide[7：0]，2′b0}；//*7

　　  fracdivide＝fracdivide+8′h80；

　　end

　　divplussoft＝{3′b0，fracdivide[10：8]}；
  end
  else
  /*FOLDENDS*/
/*FOLDBEGINS 0 2″16qam″*/
if(constellation＝＝2′b01)
begin

　　 $writeh(，，signeddivide，，，，)；

　　 signeddivide＝signeddivide+8′hc0；

　　 $writeh(，，signeddivide，，，，)；

　　 if(signeddivide[10])

　　 begin

　　   signeddivide＝10′b0；

　　   fracdivide＝9′h0；

　　 end

　　 else

　　 if(signeddivide[9]||(signeddivide[8：7]＝＝2′b11))

　　 begin

　　   fracdivide＝12′h380；

　　   signeddivide＝10′h100；

　　 end

　　 else

　　 begin

　　   fracdivide＝signeddivide[6：0]+{signeddivide[6：0]，1′b0}+

　　   {signeddivide[6：0]，2′b0}；//*7

　　   fracdivide＝fracdivide+8′h40；

　　 end

　　 divplussoft＝{1′b0，signeddivide[8：7]，fracdivide[9：7]}；
   end
   /*FOLDENDS*/
/*FOLDBEGINS 0 2″32qam″*/
else
begin

　　 signeddivide＝signeddivide+8′he0；

　　 if(signeddivide[10])

　　 begin

　　   signeddivide＝10′b0；

　　   fracdivide＝9′h0；

　　 end

　　 else

　　 if(signeddivide[9]||(signeddivide[8：6]＝＝3′b111))

　　 begin

　　   signeddivide＝10′h180；

　　   fracdivide＝9′h1c0；

　　 end

　　 else

　　 begin
				
				
　　  fracdivide＝signeddivide[5：0]+{signeddivide[5：0]，1′b0}+

　　  {signeddivide[5：0]，2′b0}；//*7

　　  fracdivide＝fracdivide+8′h20；

　　end

　　divplussoft＝{signeddivide[8：6]，fracdivide[8：6]}；
  end
  /*FOLDENDS*/
end
endfunction
/*FOLDENDS*/
/*FOLDBEGINS 0 0″PRBS alpha3/6/9/12 multiplier″*/
function [10：0] alpha；
input [1：0] which_symbol；
begin
  case(which_symbol)
  2′b0：
  alpha＝11′b11111111111；
  2′b01：
  alpha＝11′b00011111111；
  2′b10：
  alpha＝11′b00000011111；
  2′b11：
  alpha＝11′b00000000011；
  endcase
end
endfunction
/*FOLDENDS*/
/*FOLDBEGINS 0 0″PRBS alpha12 multiplier″*/
function[10：0]alpha12；
input[10：0]prbsin；
reg[10：0]prbs0；
reg[10：0]prbs1；
reg[10：0]prbs2；
reg[10：0]prbs3；
reg[10：0]prbs4；
reg[10：0]prbs5；
reg[10：0]prbs6；
reg[10：0]prbs7；
reg[10：0]prbs8；
reg[10：0]prbs9；
reg[10：0]prbs10；
begin
  prbs0＝{prbsin[0]＾prbsin[2]，prbsin[10：1]}；
  prbs1＝{prbs0[0]＾prbs0[2]，prbs0[10：1]}；
  prbs2＝{prbs1[0]＾prbs1[2]，prbs1[10：1]}；
  prbs3＝{prbs2[0]＾prbs2[2]，prbs2[10：1]}；
  prbs4＝{prbs3[0]＾prbs3[2]，prbs3[10：1]}；
  prbs5＝{prbs4[0]＾prbs4[2]，prbs4[10：1]}；
  prbs6＝{prbs5[0]＾prbs5[2]，prbs5[10：1]}；
  prbs7＝{prbs6[0]＾prbs6[2]，prbs6[10：1]}；
  prbs8＝{prbs7[0]＾prbs7[2]，prbs7[10：1]}；
  prbs9＝{prbs8[0]＾prbs8[2]，prbs8[10：1]}；
  prbs10＝{prbs9[0]＾prbs9[2]，prbs9[10：1]}；
  alpha12＝{prbs10[0]＾prbs10[2]，prbs10[10：1]}；
end
				
				
  endfunction
  /*FOLDENDS*/
  /*FOLDENDS*/
endmodule

                                 Listing 19

/*FOLDBEGINS 0 0″Copyright″*/
/********************************************************
Copyright(c)Pioneer Digital Design Centre Limited
NAME：pilloc_rtl.v
PURPOSE：Pilot location
CREATED：June 1997 BY：J.Parker(C code)
MODIFIED： BY：T.Foxcroft
USED IN PROJECTS：cofdm only.
********************************************************/
/*FOLDENDS*/
`define FFTSIZE 2048
`define SCATNUM 45
module pilloc(clk，resync，in_valid，in_data，found_pilots，which_symbol，cpoffset，
incfreq，

　　                   ramaddr，ramin，ramout，wrstrb)；

　　                   /*FOLDBEGINS 0 0″i/o″*/

　　                   input clk，resync，in_valid；

　　                   input[23：0]in_data；

　　                   output found_pilots；

　　                   output[1：0]which_symbol；

　　                   output[10：0]cpoffset；

　　                   output incfreq；

　　                   /*FOLDENDS*/

　　                   /*FOLDBEGINS 0 0″ram i/o″*/

　　                   output[10：0]ramaddr；

　　                   reg[10：0]ramaddr_；

　　                   output[23：0]ramin；

　　                   input[23：0]ramout；

　　                   output wrstrb；

　　                   reg[10：0]ramaddr；

　　                   reg[23：0]ramin；

　　                   reg wrstrb；

　　                   /*FOLDENDS*/

　　                   /*FOLDBEGINS 0 0″vars″*/

　　                   reg found_pilots；

　　                   reg[1：0]which_symbol；

　　                   reg[1：0]which_symbolcount；

　　                   reg[1：0]which_symbol_；

　　                   reg[10：0]cpoffset；

　　                   reg incfreq；
				
				
　　                   reg found_pilot；

　　                   reg[19：0] v；

　　                   reg[19：0]sum；

　　                   reg[3：0]splocoffset；

　　                   wire[10：0]carrier_number；

　　                   reg[10：0]continual_pilot_offset；
reg resynch；
reg[3：0]valid；
reg[23：0]fftdata；
reg[10：0]fftcount；
reg contcomplete；
reg firstcontsearch；
reg finishedsearch；
reg[4：0]firstscatcomplete；
reg[4：0]failedtolock；
reg[2：0]spmax；
reg[2：0]spmaxfirst；
reg[10：0]pilot_offset；
reg[1：0]sploc1zero；
reg[10：0]sploc0；
reg[5：0]sploc1；
reg[10：0]splocmaxcount；
reg[3：0]spoffset；
reg[19：0]sumscat[11：0]；
reg[19：0]sumscatmax；
reg[3：0]sumscatmaxno0；
reg[3：0]sumscatmaxno1；
wire[19：0]sumscat1；
wire[19：0]sumscat3；
wire[19：0]sumscat5；
reg[11：0]sumscaffirst；
reg[4：0]fftfinished；
reg ramwritestop；//botch for development purposes
wire[3：0]mod12fftcount；
/*FOLDENDS*/
/*FOLDBEGINS 0 0″continuous pilot location″*/
reg[10：0]contloc；
always @(sploc1)
begin
  case(sploc1)
  6′b000000：contloc＝0；
  6′b000001：contloc＝48；
  6′b000010：contloc＝54；
  6′b000011：contloc＝87；
  6′b000100：contloc＝141；
  6′b000101：contloc＝156；
  6′b000110：contloc＝192；
  6′b000111：contloc＝201；
  6′b001000：contloc＝255；
  6′b001001：contloc＝279；
  6′b001010：contloc＝282；
  6′b001011：contloc＝333；
  6′b001100：contloc＝432；
  6′b001101：contloc＝450；
				
				
  6′b001110：contloc＝483；
  6′b001111：contloc＝525；
  6′b010000：contloc＝531；
  6′b010001：contloc＝618；
  6′b010010：contloc＝636；
  6′b010011：contloc＝714；
  6′b010100：contloc＝759；
  6′b010101：contloc＝765；
  6′b010110：contloc＝780；
  6′b010111：contloc＝804；
  6′b011000：contloc＝873；
  6′b011001：contloc＝888；
  6′b011010：contloc＝918；
  6′b011011：contloc＝939；
  6′b011100：contloc＝942；
  6′b011101：contloc＝969；
  6′b011110：contloc＝984；
  6′b011111：contloc＝1050；
  6′b100000：contloc＝1101；
  6′b100001：contloc＝1107；
  6′b100010：contloc＝1110；
  6′b100011：contloc＝1137；
  6′b100100：contloc＝1140；
  6′b100101：contloc＝1146；
  6′b100110：contloc＝1206；
  6′b100111：contloc＝1269；
  6′b101000：contloc＝1323；
  6′b101001：contloc＝1377；
  6′b101010：contloc＝1491；
  6′b101011：contloc＝1683；
  default： contloc＝1704；
  endcase
end
/*FOLDENDS*/
always @(posedge clk)
begin
  resynch＜＝resync；
  if(resynch)
  begin

　　valid     ＜＝4′b0；

　　fftcount   ＜＝11′b0；

　　firstscatcomplete   ＜＝5′b0；

　　sum       ＜＝20′b0；

　　sploc0     ＜＝11′b0；

　　sploc1     ＜＝6′b0；

　　contcomplete      ＜＝1′b0；

　　failedtolock    ＜＝5′b0；

　　spmax         ＜＝1′b0；

　　spmaxfirst      ＜＝1′b0；

　　ramwritestop      ＜＝1′b0；

　　found_pilots     ＜＝1′b0；

　　found_pilot     ＜＝1 ′b0；

　　firstcontsearch   ＜＝1′b0；

　　finishedsearch    ＜＝1′b0；

　　which_symbolcoun    ＜＝2′b0；
				
				
　　incfreq    ＜＝1′b0；
  end
  else
  begin

　　incfreq＜＝！failedtolock[1]&&failedtolock[0]&&fftfinished[4]；

　　found_pilots＜＝！found_pilot&&finishedsearch；

　　found_pilot＜＝finishedsearch；

　　valid[0]＜＝in_valid；

　　valid[1]＜＝valid[0]；

　　valid[2]＜＝valid[1]；

　　valid[3]＜＝valid[2]；

　　fftdata＜＝in_data；

　　if(valid[0]&&！finishedsearch)

　　   fftcount＜＝fftcount+1′b1；

　　   //if(fftfinished[0])

　　   //$display(″frame″，，fftcount)；

　　   //if(incfreq)

　　   //$display(″tweek″)；
/*FOLDBEGINS 0 4″locate continual pilots″*/
spmax[1]＜＝spmax[0]；
spmax[2]＜＝spmax[1]；
spmaxfirst[1]＜＝spmaxfirst[0]；
spmaxfirst[2]＜＝spmaxfirst[1]；
//if(fitfinished[3])
//$display(spoffset，，which_symbol)；

　　 if(fftfinished[3])

　　 begin

　　   failedtolock[1]＜＝failedtolock[0]；

　　   failedtolock[2]＜＝failedtolock[1]；

　　   failedtolock[3]＜＝failedtolock[2]；

　　   failedtolock[4]＜＝failedtolock[3]；

　　   if(failedtolock[0])

　　   begin

　　/*FOLDBEGINS 0 2″″*/

　　if(failedtolock[4])

　　          failedtolock[0]＜＝1′b0；

　　          firstscatcomplete  ＜＝5′b0；

　　          ramwritestop    ＜＝1′b0；

　　          firstcontsearch   ＜＝1′b0；

　　      /*FOLDENDS*/

　　      end

　　      else

　　      begin

　　   /*FOLDBEGINS 04″″*/

　　   firstscatcomplete[0]＜＝1′b1；

　　   firstcontsearch＜＝！firstscatcomplete[0]；

　　   ramwritestop＜＝！ramwritestop｜｜finishedsearch；

　　   contcomplete＜＝ramwritestop；

　　   if(！finishedsearch&&firstscatcomplete[0]&&ramwritestop)

　　   begin

　　              finishedsearch＜＝firstcontsearch？1′b0：

　　              (cpoffset＝＝contin_ual_pilot_offset)；

　　              cpoffset＜＝continual_pilot_offset；
				
				
　　    failedtolock[0]＜＝！firstcontsearch&&(cpoffset！＝continual_pilot_offset)；

　　  end

　　  /*FOLDENDS*/
   end
   end
   else
   begin
   firstscatcomplete[1]＜＝firstscatcomplete[0]&&！contcomplete；
   firstscatcomplete[2]＜＝firstscatcomplete[1]；
   if(firstscatcomplete[0]&&！finishedsearch&&！contcomplete&&！finishedsearc h

　　     &&(sploc1＝＝44)&&(sploc0＝＝splocmaxcount))

　　     contcomplete＜＝1′b1；
end
if(found_pilots)

　　 $display(which_symbol，，cpoffset，，spoffset)；

　　//$display(sum，，contcomplete，，ramwritestop，，which_symbol，，spoffset，，，splo
c0，，splocmaxcount，，v，，，，，，fftfinished[3]，，finishedsearch)；

　　//$display(fftcount，，firstscatcomplete[0]，，ramwritestop，，spoffset，，sumsca
tmaxno1，，，，finishedsearch，，found_pilots，，

　　//，，，，，，，，

　　//pilot_offset，，which_symbol，，，，cpoffset，，failedtolock )；

　　sploc1zero[0]＜＝(sploc1＝＝0)；

　　sploc1zero[1]＜＝sploc1zero[0]；
if(firstscatcomplete[0]&&！finishedsearch&&！contcomplete&&！finishedsearch)

　　 begin
   if(sploc1＝＝44)
   begin
/*FOLDBEGINS 0 4″″*/
//$display(sploc0，，splocmaxcount)；
pilot_offset＜＝sploc0+splocoffset；
which_symbol＜＝which_symbol_-which_symbolcount；
if(sploc0＝＝splocmaxcount)
begin

　　     sploc0　　＜＝11′b0；

　　     //contcomplete＜＝1′b1；

　　     which_symbolcount＜＝2′b0；

　　   end

　　   else

　　   begin

　　     sploc0＜＝sploc0+2′b11；

　　     which_symbolcount＜＝which_symbolcount+1′b1；

　　   end

　　   if(sploc0＝＝0)

　　       spmaxfirst[0]＜＝1′b1；

　　       sploc1＜＝6′b0；

　　       spmax[0]＜＝1′b1；

　　       /*FOLDENDS*/
   end
   else
   begin
/*FOLDBEGINS 0 4″″*/
sploc1＜＝sploc1+1′b1；
spmax[0]＜＝1′b0；
spmaxfirst[0]＜＝1′b0；
				
				
　　 /*FOLDENDS*/

　　    end

　　    end

　　    if(firstscatcomplete[2])

　　    begin

　　    if(sploc1zero[1])

　　    sum＜＝modulus(ramout[23：12]，ramout[11：0])；

　　    else

　　    sum＜＝modulus(ramout[23：12]，ramout[11：0])+sum；

　　  end

　　  /*FOLDENDS*/

　　end

　　/*FOLDBEGINS 0 2″search for largest continous pilot correlation″*/

　　if(spmax[2])

　　begin

　　  if(spmaxfirst[2])

　　  begin

　　    v＜＝sum；

　　    continual_pilot_offset＜＝pilot_offset；

　　  end

　　  else

　　  begin

　　    if(sum＞v)

　　    begin

　　      v＜＝sum；

　　      continual_pilot_offset＜＝pilot_offset；

　　    end

　　    end

　　    //$display(sum，，continual_pilot_offset，，contcomplete，，ramwritestop，，which

　　_symbol，，spoffset，，，sploc0，，splocmaxcount，，v)；

　　   //$display(sum)；
  end
  /*FOLDENDS*/
end
assign carrier_number＝contloc+sploc0+splocoffset；
/*FOLDBEGINS 0 0″scattered pilot offset mod 3″*/
always @(spoffset)
begin
  splocoffset＝2′b0；
  splocmaxcount＝342；
  which_symbol_＝2′b0；
  case(spoffset)

　　4′b0000，4′b0011，4′b0110，4′b1001：

　　begin

　　  splocoffset＝2′b0；

　　  splocmaxcount＝342；

　　end

　　4′b0001，4′b0100，4′b0111，4′b1010：

　　begin

　　  splocoffset＝2′b01；

　　  splocmaxcount＝339；

　　end

　　//4′b0010，4′b0101，4′b1000，4′b1011：

　　default：

　　begin
				
				
　　   splocoffset＝2′b10；

　　   splocmaxcount＝339；

　　 end

　　 endcase

　　 case(spoffset)

　　 4′b0000，4′b0001，4′b0010：

　　 which_symbol_＝2′b0；

　　 4′b0011，4′b0100，4′b0101：

　　 which_symbol_＝2′b01；

　　 4′b0110，4′b0111，4′b 1000：

　　 which_symbol_＝2′b10；

　　 //4′b1001，4′b1010，4′b1011：

　　 default：

　　    which_symbol_＝2′b11；

　　    endcase
end
/*FOLDENDS*/
/*FOLDBEGINS 10″Search for scattered pilots″*/
always @(posedge clk)
begin
  if(resynch)
  sumscatfirst＜＝12′hfff；
  else
  begin
  if(valid[0]&&！finishedsearch)
/*FOLDBEGINS 12″do the accumulations″*/
case(mod 12fftcount)
4′h0：
begin

　　 sumscat[0]＜＝(sumscatfirst[0])？modulus(fftdata[23：12]，fftdata[11：0])：

　　 sumscat[0]+modulus(fftdata[23：12]，fftdata[11：0])；

　　 sumscatfirst[0]＜＝1′b0；
   end
   4′h1：
   begin

　　 sumscat[1]＜＝(sumscatfirst[1])？modulus(fftdata[23：12]，fftdata[11：0])：

　　 sumscat[1]+modulus(fftdata[23：12]，fftdata[11：0])；

　　 sumscatfirst[1]＜＝1′b0；
   end
   4′h2：
   begin

　　 sumscat[2]＜＝(sumscatfirst[2])？modulus(fftdata[23：12]，fftdata[11：0])

　　 sumscat[2]+modulus(fftdata[23：12]，fftdata[11：0])；

　　 sumscatfirst[2]＜＝1′b0；
   end
   4′h3：
   begin

　　 sumscat[3]＜＝(sumscatfirst[3])？modulus(fftdata[23：12]，fftdata[11：0])

　　 sumscat[3]+modulus(fftdata[23：12]，fftdata[11：0])；

　　 sumscatfirst[3]＜＝1′b0；
   end
   4′h4：
   begin
				
				
　　sumscat[4]＜＝(sumscatfirst[4])？modulus(fftdata[23：12]，fftdata[11：0]) ：

　　sumscat[4]+modulus(fftdata[23：12]，fftdata[11：0])；

　　sumscatfirst[4]＜＝1′b0；
  end
  4′h5：
  begin

　　sumscat[5]＜＝(sumscatfirst[5])？modulus(fftdata[23：12]，fftdata[11：0])：

　　sumscat[5]+modulus(fftdata[23：12]，fftdata[11：0])；

　　sumscatfirst[5]＜＝1′b0；
  end
  4′h6：
  begin

　　sumscat[6]＜＝(sumscatfirst[6])？modulus(fftdata[23：12]，fftdata[11：0])：

　　sumscat[6]+modulus(fftdata[23：12]，fftdata[11：0])；

　　sumscatfirst[6]＜＝1′b0；
  end
  4′h7：
  begin

　　sumscat[7]＜＝(sumscatfirst[7])？modulus(fftdata[23：12]，fftdata[11：0])：

　　sumscat[7]+modulus(fftdata[23：12]，fftdata[11：0])：

　　sumscatfirst[7]＜＝1′b0；
  end
  4′h8：
  begin

　　sumscat[8]＜＝(sumscatfirst[8])？modulus(fffdata[23：12]，fftdata[11：0])：

　　sumscat[8]+modulus(fffdata[23：12]，fftdata[11：0])；

　　sumscatfirst[8]＜＝1′b0；
  end
  4′h9：
  begin

　　sumscat[9]＜＝(sumscatfirst[9])？modulus(fftdata[23：12]，fftdata[11：0])：

　　sumscat[9]+modulus(fftdata[23：12]，fftdata[11：0])；

　　sumscatfirst[9]＜＝1′b0；
  end
  4′ha：
  begin

　　sumscat[10]＜＝(sumscatfirst[10])？modulus(fftdata[23：12]，fftdata[11：0])：

　　sumscat[10]+modulus(fftdata[23：12]，fftdata[11：0])；

　　sumscatfirst[10]＜＝1′b0；
  end
  default：
  begin

　　sumscat[11]＜＝(sumscatfirst[11])？modulus(fftdata[23：12]，fftdata[11：0]) ：

　　sumscat[11]+modulus(fftdata[23：12]，fftdata[11：0])；

　　sumscatfirst[11]＜＝1′b0；
  end
  endcase
  /*FOLDENDS*/
  else if(fftfinished[0])

　　 sumscatfirst＜＝12′hfff；

　　 end
/*FOLDBEGINS 10″Find offset″*/
if(resynch)

　　  fftfinished＜＝5′b0；

　　  else
				
				
   begin
   fftfinished[0]＜＝valid[0]&&！finishedsearch&&(fftcount＝＝2047)；
   fftfinished[1]＜＝fftfinished[0]；
   fftfinished[2]＜＝fftfinished[1]；
   fftfinished[3]＜＝fftfinished[2]；
   fftfinished[4]＜＝fftfinished[3]；
 end
 if(！eamwritestop)
 begin
   if(fftfinished[0])
   begin

　　 sumscat[0]＜＝(sumscat[0]＞sumscat[1])？sumscat[0]：sumscat[1]；

　　 sumscat[1]＜＝(sumscat[0]＞sumscat[1])？0：1；

　　 sumscat[2]＜＝(sumscat[2]＞sumscat[3])？sumscat[2]：sumscat[3]；

　　 sumscat[3]＜＝(sumscat[2]＞sumscat[3])？2：3；

　　 sumscat[4]＜＝(sumscat[4]＞sumscat[5])？sumscat[4]：sumscat[5]；

　　 sumscat[5]＜＝(sumscat[4]＞sumscat[5])？4：5；

　　 sumscat[6]＜＝(sumscat[6]＞sumscat[7])？sumscat[6]： sumscat[7]；

　　 sumscat[7]＜＝(sumscat[6]＞sumscat[7])？6：7；

　　 sumscat[8]＜＝(sumscat[8]＞sumscat[9])？sumscat[8]： sumscat[9]；

　　 sumscat[9]＜＝(sumscat[8]＞sumscat[9])？8：9；

　　 sumscat[10]＜＝(sumscat[10]＞sumscat[11])？sumscat[10]： sumscat[11]；

　　 sumscat[11]＜＝(sumscat[10]＞sumscat[11])？10：11；
   end
   if(fftfinished[1])
   begin

　　 sumscat[0]＜＝(sumscat[0]＞sumscat[2])？sumscat[0]：sumscat[2]；

　　 sumscat[1]＜＝(sumscat[0]＞sumscat[2])？sumscat[1]：sumscat[3]；

　　 sumscat[2]＜＝(sumscat[4]＞sumscat[6])？sumscat[4]：sumscat[6]；

　　 sumscat[3]＜＝(sumscat[4]＞sumscat[6])？sumscat[5]：sumscat[7]；

　　 sumscat[4]＜＝(sumscat[8]＞sumscat[10])？sumscat[8]：sumscat[10]；

　　 sumscat[5]＜＝(sumscat[8]＞sumscat[10])？sumscat[9]：sumscat[11]；
   end
   if(fftfinished[2]&&！ramwritestop)

　　   spoffset＜＝sumscatmaxno1；

　　   end

　　   if(fftfinished[0])

　　   begin

　　$display(sumscat[0])；

　　$display(sumscat[1])；

　　$display(sumscat[2])；

　　$display(sumscat[3])；

　　$display(sumscat[4])；

　　$display(sumscat[5])；

　　$display(sumscat[6])；

　　$display(sumscat[7])；

　　$display(sumscat[8])；

　　$display(sumscat[9])；

　　$display(sumscat[10])；

　　$display(sumscat[11])；

　　$display()；
  end
end
				
				
always @(sumscat[0] or sumscat[1] or sumscat[2] or sumscat[3] or sumscat[4] or
sumscat[5]

　　      or sumscat1 or sumscat3 or sumscat5)

　　      begin
  sumscatmax＝(sumscat[0]＞sumscat[2])？ sumscat[0]：sumscat[2]；
  sumscatmaxno0＝(sumscat[0]＞sumscat[2])？sumscat1[3：0]：sumscat3[3：0]；
  sumscatmaxno1＝(sumscatmax＞sumscat[4])？sumscatmaxno0：sumscat5[3：0]；
end
assign mod 12fftcount＝mod12(fftcount)；
assign sumscat1＝sumscat[1]；
assign sumscat3＝sumscat[3]；
assign sumscat5＝sumscat[5]；
/*FOLDENDS*/
/*FOLDENDS*/
/*FOLDBEGINS 0 0″ram″*/
always @(posedge clk)
   ramaddr_＜＝ramaddr；
   always @(ramwritestop or valid or finishedsearch or fftcount or carrier_number or
ramwritestop or ramaddr_ or fftdata)
  begin
  ramaddr＝ramaddr_；
  if(！ramwritestop)
  begin

　　if(valid[0]&&！finishedsearch)

　　ramaddr＝{fftcount[0]，fftcount[1]，fftcount[2]，fftcount[3]，fftcount[4]，fftcount[

　　  5]，fftcount[6]，

　　                fftcount[7]，fftcount[8]，fftcount[9]，fftcount[10]}；

　　                end

　　                else

　　   ramaddr＝carrier_number；

　　   ramin＝fftdata；

　　   wrstrb＝！(！ramwritestop&&valid[1])；
end
/*FOLDENDS*/
/*FOLDBEGINS 0 0″modulus approximation function″*/
function[11：0]modulus；
input[11：0]i；
input[11：0]j；
reg[11：0]modi；
reg[11：0]modj；
begin
  modi＝(i[11]？～i：i)+i[11]；
  modj＝(j[11]？～j：j)+j[11]；
  modulus＝modi+modj；
end
endfunction
/*FOLDENDS*/
/*FOLDBEGINS 0 0″mod12″*/
function[3：0]mod12；
input[10：0]count；
reg[14：0]onetwelfth；
reg[7：0]modulus12；
parameter TWELFTH＝12′haab；
				
				
begin
  onetwelfth＝{count[0]，count[1]，count[2]，count[3]，count[4]，count[5]，count[6]，
  count[7]，count[8]，count[9]，count[10]}*TWELFTH；
  modulus12＝{onetwelfth[14：9]，1′b0}+onetwelfth[14：9]+4′h8；//*12
  mod12＝modulus12[7：4]；
end
/*FOLDENDS*/
endfunction
endmodule

                            Listing 20

//Sccsld：@(#)bch_decode.v   1.28/22/97
/*FOLDBEGINS 0 0″copyright″*/
//**********************************************************
//Copyright(c)1997 Pioneer Digital Design Centre Limited
//
//NAME：BCH_rtl.v
//
//PURPOSE：BCH decoder for TPS pilots.Flags up to two error
//  positions using search technique.
//
//************************************************************
/*FOLDENDS*/
`define DATA0_SIZE 7′b0110100
`define DATA1_SIZE 7′b0110111
module bch_decode(clk，resync，in_data，in_valid，in_finalwrite，out_valid，out_data)；
/*FOLDBEGINS 0 0″l/Os″*/
input clk，resync；
input in_data，in_ valid，in_finalwrite；
output out_valid；
output out_data；
reg out_data；
reg out_valid；
/*FOLDENDS*/
/*FOLDBEGINS 0 0″variables″*/
reg resynch；
reg valid；
reg finalwrite；
reg indata；
reg[6：0]S0；
reg[6：0]S1；
reg[6：0]S2；
reg[6：0]count；
reg search1error，found2error，oneerror，twoerror；
wire twoerror_；
reg noerrors；
reg delay0，delay1，delay2；
reg[6：0]Gs0；
reg[6：0]Gs1；
reg[6：0]Gs2；
/*FOLDENDS*/
always @(posedge clk)
begin
				
				
/*FOLDBEGINS 0 2″read in data and calculate syndromes″*/
  resynch＜＝resync；
  if(resynch)
  begin
   valid  ＜＝1′b0；
   S0   ＜＝7′b0；
   S1   ＜＝7′b0；
   S2   ＜＝7′b0；
  end
  else
  begin
   valid＜＝in_valid；
   if(delay1&&twoerror_)
   begin
   /*FOLDBEGINS 0 4″update after one in two errors found″*/

　　 S0＜＝S0＾Gs0；

　　 S1＜＝S1＾Gs1；

　　 S2＜＝S2＾Gs2；

　　   /*FOLDENDS*/

　　   end

　　   else if(valid)

　　   begin

　　 S0＜＝indata＾MULTA1(S0)；

　　 S1＜＝indata＾MULTA2(S1)；

　　 S2＜＝indata＾MULTA3(S2)；

　　end

　　end

　　indata＜＝in_data；

　　/*FOLDENDS*/

　　/*FOLDBEGINS 0 2″out_valid control″*/
  if(resynch)
  begin
   delay0  ＜＝1′b0；
   delay1  ＜＝1′b0；
   delay2  ＜＝1′b0；
   out_valid  ＜＝1′b0；
   finalwrite ＜＝1′b0；
  end
  else
  begin
   finalwrite＜＝in_finalwrite；
   if(valid&&finalwrite)

　　  delay0＜＝1′b1；

　　  else

　　  if(count＝＝`DATA1_SIZE-4)

　　  delay0 ＜＝1′b0；

　　 delay1  ＜＝delay0；

　　 delay2  ＜＝delay1；

　　 out_valid ＜＝delay2；
   end 
   /*FOLDENDS*/
 /*FOLDBEGINS 0 2″error search algorithm″*/
 if(delay0&&！delay1)
 begin
   noerrors＜＝(S0＝＝7′b0)；
				
				
  search1error＜＝(GFULL(S0，S1)＝＝S2)；
  found2error＜＝1′b0；
  twoerror＜＝1′b0；
  count＜＝7′b0；
  Gs0＜＝7′h50；
  Gs1＜＝7′h20；
  Gs2＜＝7′h3d；
 end
 else
 if(delay1)
 begin
  oneerror＜＝((S0＾Gs0)＝＝7′b0)&&search1error；
  twoerror＜＝twoerror_；
  if(twoerror_)
  begin
   search1error＜＝1′b1；
   found2error＜＝1′b1；
  end
  Gs0＜＝DIV1(Gs0)；
  Gs1＜＝DIV2(Gs1)；
  Gs2＜＝DIV3(Gs2)；
  count＜＝count+1′b1；
 end
 out_data＜＝(twoerror||oneerror)&&！noerrors；
  /*FOLDENDS*/
  end
  assign twoerror_＝(GFULL((S0＾Gs0)，(S1＾Gs1))＝＝
(S2＾Gs2))&&！found2error&&！twoerror；
  /*FOLDBEGINS 0 0″functions″*/
  /*FOLDBEGINS 0 0″GFULL function″*/
  function[6：0]GFULL；
 input[6：0]X；
 input[6：0]Y；
 reg[6：0]A0，A1，A2，A3，A4，A5，A6；
 integer i；
 begin
  A0＝X；
  A1＝{A0[5]，A0[4]，A0[3]，A0[2]＾A0[6]，A0[1]，A0[0]，A0[6]}；
  A2＝{A1[5]，A1[4]，A1[3]，A1[2]＾A1[6]，A1[1]，A1[0]，A1[6]}；
  A3＝{A2[5]，A2[4]，A2[3]，A2[2]＾A2[6]，A2[1]，A2[0]，A2[6]}；
  A4＝{A3[5]，A3[4]，A3[3]，A3[2]＾A3[6]，A3[1]，A3[0]，A3[6]}；
  A5＝{A4[5]，A4[4]，A4[3]，A4[2]＾A4[6]，A4[1]，A4[0]，A4[6]}；
  A6＝{A5[5]，A5[4]，A5[3]，A5[2]＾A5[6]，A5[1]，A5[0]，A5[6]}；
  for(i＝0；i＜7；i＝i+1)
  begin
   A0[i]＝A0[i]&&Y[0]；
   A1[i]＝A1[i]&&Y[1]；
   A2[i]＝A2[i]&&Y[2]；
   A3[i]＝A3[i]&&Y[3]；
   A4[i]＝A4[i]&&Y[4]；
   A5[i]＝A5[i]&&Y[5]；
   A6[i]＝A6[i]&&Y[6]；
  end
  GFULL＝A0＾A1＾A2＾A3＾A4＾A5＾A6；
				
				
 end
 endfunction
 /*FOLDENDS*/
 /*FOLDBEGINS 0 0″MULTA1 function″*/
 function[6：0]MULTA1；
 input[6：0]X；
 begin
  MULTA1＝{X[5]，X[4]，X[3]，X[2]＾X[6]，X[1]，X[0]，X[6]}；
  end
endfunction
/*FOLDENDS*/
/*FOLDBEGINS 0 0″MULTA2 function″*/
function[6：0]MULTA2；
 input[6：0]X；
 begin
  MULTA2＝{X[4]，X[3]，X[2]＾X[6]，X[1]＾X[5]，X[0]，X[6]，X[5]}；
  end
endfunction
/*FOLDENDS*/
/*FOLDBEGINS 0 0″MULTA3 function″*/
function[6：0]MULTA3；
 input[6：0]X；
 begin
  MULTA3＝{X[3]，X[2]＾X[6]，X[1]＾X[5]，X[0]＾X[4]，X[6]，X[5]，X[4]}；
  end
endfunction
/*FOLDENDS*/
/*FOLDBEGINS 0 0″DIV1 function″*/
function[6：0]DIV1；
 input[6：0]X；
 begin
  DIV1＝{X[0]，X[6]，X[5]，X[4]，X[3]＾X[0]，X[2]，X[1]}；
  end
endfunction
/*FOLDENDS*/
/*FOLDBEGINS 0 0″DIV2 function″*/
function[6：0]DIV2；
 input[6：0]X；
 begin
  DIV2＝{X[1]，X[0]，X[6]，X[5]，X[4]＾X[1]，X[3]＾X[0]，X[2]}；
  end
endfunction
/*FOLDENDS*/
/*FOLDBEGINS 0 0″DIV3 function″*/
function[6：0]DIV3；
 input[6：0]X；
 begin
  DIV3＝{X[2]，X[1]，X[0]，X[6]，X[5]＾X[2]，X[4]＾X[1]，X[3]＾X[0]}；
  end
endfunction
/*FOLDENDS*/
/*FOLDENDS*/
/*FOLDBEGINS 0 0″″*/
//always @(posedge clk)
//$display(in_valid，，in_data，，in_finalwrite，，，，out_valid，，out_data，，，S0，，S1 ，，S2 ，，，)；
//always @(psedge clk)
				
				
//$display(resynch，，in_valid，，in_data，，out_valid，，S0，，S1，，，，count，，，delay0，，del
ay1，，delay2
//，，，，delay2，，noerrors，，oneerror，，twoerror，，out_data，，out_valid)；
//always @(posedge clk)
//$display(in_valid，，in_data，，，，out_valid，，out_data，，，S0，，S1 ，，S2，，，)；
//always @(posedge clk)
//$display(in_valid，，in_data，，，，out_valid，，out_data，，，S0，，S1 ，，S2，，，)；
/*FOLDENDS*/
endmodule

                              Listing 21

//Sccsld：@(#)tps.v     1.29/15/97
/*FOLDBEGINS 0 0″copyright″*/
//**********************************************************
//Copyright(c)1997 Pioneer Digital Design Centre Limited
//
//NAME：tps_rtl.v
//
//PURPOSE：Demodulates TPS pilots using DPSK.Finds sync bits.
//  Corrects up to two errors using BCH.
//  (DPSK produces two errors for each transmission error)
//HISTORY：
//15/9/97 PK Added scan IO ports，te，tdin，tdout
//
//***********************************************************
/*FOLDENDS*/
`define SYNCSEQ0 16′b0111011110101100
`define SYNCSEQ1 16′b1000100001010011
module tps(resync，clk，tps_valid，tps_pilot，tps_sync，tps_data，upsel，upaddr，
uprstr，lupdata，

　　            te，tdin，tdout)；

　　            /*FOLDBEGINS 0 0″i/os″*/

　　            input resync，clk，tps_valid，tps_pilot，upsel，uprstr，te，tdin；

　　            input[1：0]upaddr；

　　            inout[7：0]lupdata；

　　            output tps_sync，tdout；

　　            output[30：0]tps_data；

　　            /*FOLDENDS*/

　　            /*FOLDBEGINS 0 0″registers″*/

　　            reg resynch；

　　            reg[1：0]foundsync；

　　            reg[66：0]tpsreg；

　　            reg[15：0]syncreg；

　　            reg[1：0]tpsvalid；

　　            reg[1：0]pilot；

　　            reg tps_sync；

　　            reg[7：0]bch_count；

　　            reg[2：0]bch_go；

　　            reg bch_finalwrite；

　　            wire bch_data；

　　            wire bch_valid；

　　            wire bch_error；

　　            integer i；

　　            wire upsel0；

　　            wire upsel1；
				
				
　　         wire upsel2；

　　         wire upsel3；

　　         /*FOLDENDS*/
always @(posedge clk)
begin
/*FOLDBEGINS 0 2″Synchronise to TPS″*/
   resynch＜＝resync；
   if(tpsvalid[0]&&！(foundsync[0]||foundsync[1]||tps_sync))
   begin

　　 tpsreg[66]＜＝pilot[1]＾pilot[0]；

　　 for(i＝0；i＜66；i＝i+1)

　　    tpsreg[i]＜＝tpsreg[i+1]；

　　    end

　　    else

　　 if(bch_valid&&bch_error)

　　 tpsreg[bch_count]＜＝！tpsreg[bch_count]；
   if(tpsvalid[0]&&(foundsync[0]||foundsync[1]))
   begin

　　 syncreg[15]＜＝pilot[1]＾pilot[0]；

　　 for(i＝0；i＜15；i＝i+1)

　　    syncreg[i]＜＝syncreg[i+1]；

　　    end
   pilot[0]＜＝tps_pilot；
   pilot[1]＜＝pilot[0]；
   if(resynch)
   begin

　　 tpsvalid   ＜＝2′b0；

　　 tps_sync     ＜＝1′b0；

　　 bch_go     ＜＝3′b0；

　　 bch_finalwrite ＜＝1′b0；

　　 bch_count    ＜＝ 8′b0；

　　 foundsync    ＜＝ 2′b0；
   end
   else
   begin

　　 tpsvalid[0]＜＝tps_valid；

　　 tpsvalid[1]＜＝tpsvalid[0]；

　　 bch_go[1]＜＝bch_go[0]；

　　 bch_go[2]＜＝bch_go[1]；

　　 bch_finalwrite＜＝(bch_count＝＝65)&&bch_go[2]；

　　 if((bch_count＝＝52)&&bch_valid)

　　     tps_sync＜＝1′b1；

　　     /*FOLDBEGINS 0 2″counter″*/

　　 if(bch_count＝＝66)

　　 bch_count＜＝8′b0；

　　 else if(tpsvalid[1]&&！(foundsync[0]||foundsync[1]))

　　 begin

　　   if(tpsreg[15：0]＝＝`SYNCSEQ1)

　　   bch_count＜＝8′hfe；   //-2

　　   if(tpsreg[15：0]＝＝`SYNCSEQ0)

　　   bch_count＜＝8′hfe；   //-2

　　 end

　　 else if(tpsvalid[1]&&(bch_count＝＝15)&&(foundsync[0]||foundsync[1]))
				
				
　　    bch_count＜＝8′hfe；   //-2

　　    else

　　    begin

　　 if(bch_valid||bch_go[0]||((foundsync[0]||foundsync[1])&&tpsvalid[0]))

　　 bch_count＜＝bch_count+1′b1；
   end
   /*FOLDENDS*/
 /*FOLDBEGINS 0 2″BCH+second SYNC reg control″*/
 if(bch_count＝＝66)
 begin

　　  bch_go＜＝3′b0；

　　  end

　　  else if(tpsvalid[1])

　　  begin

　　  if(foundsync[0]||foundsync[1])

　　  begin

　　    if(bch_count＝＝15)

　　    begin

　　      if(((syncreg[15：0]＝＝`SYNCSEQ0)&&foundsync[1])||((syncreg[15：0]

　　          ＝＝` SYNCSEQ1)&&foundsync[0]))

　　      bch_go[0]＜＝1′b1；

　　      else

　　      foundsync＜＝2′b0；

　　    end

　　    end

　　    else

　　    begin

　　    if(tpsreg[15：0]＝＝`SYNCSEQ1)

　　    foundsync[1]＜＝1′b1；

　　    if(tpsreg[15：0]＝＝`SYNCSEQ0)

　　    foundsync[0]＜＝1′b1；

　　  end

　　  end

　　  /*FOLDENDS*/
  end
  /*FOLDENDS*/
end
assign bch_data＝tpsreg[bch_count]；
/*FOLDBEGINS 0 0″″*/
//always @(posedge clk)
//begin
//$write(tps_valid，，tps_sync，，tps_pilot，，tpsvalid[1]，，pilot
//bch_finalwrite，，，，，，bch_go[2]，，bch_data，，bch_valid，，bch_error，，bch_count，，tps
_sync，，，，，)；
//$displayb(tpsreg，，syncreg，，foundsync)；
//end
/*FOLDENDS*/
/*FOLDBEGINS 0 0″micro access″*/
assign upsel0＝upsel&&uprstr&&！upaddr[1]&&！upaddr[0]；
assign upsel1＝upsel&&uprstr&&！upaddr[1]&& upaddr[0]；
assign upsel2＝upsel&&uprstr&& upaddr[1]&&！upaddr[0]；
assign upsel3＝upsel&&uprstr&& upaddr[1]&& upaddr[0]；
assign lupdata＝upsel0？{1′b0，tps_data[30：24]}：8′bz，

　　     lupdata＝upsel1？tps_data[23：16]：8′bz，

　　     lupdata＝upsel2？tps_data[15：8] ：8′bz，
				
				
　　   lupdata＝upsel3？tps_data[7：0]：8′bz；
/*FOLDENDS*/
assign tps_data＝tpsreg[52：22]；
bch_decode bch1(.clk(clk)，.resync(resync)，.in_valid(bch_go[2])，
.in_finalwrite(bch_finalwrite)，.in_data(bch_data)，

　　                   .out_valid(bch_valid)，.out_data(bch_error))；

　　                   endmodule

                             Listing 22

//SccslD＝％W％  ％G％
//FOLDBEGINS 0 0″Copyright(c)1997 Pioneer Digital Design Centre Limited ...″
/*-------------------------------------------------

　　 Copyright(c)1997 Pioneer Digital Design Centre Limited
NAME：sydint_rtl.v
PURPOSE：＜a one line description＞
CREATED： Thu 14 Aug 1997 BY：Paul(Paul McCloy)
MODIFICATION HISTORY：
15/9/97 PK Increased width to 13 to allow for bad_carrier flag
-------------------------------------------------------*/
//FOLDENDS
//FOLDBEGINS 0 0″module symdint...＜-top level″
//////////////////////////////////////////
module symdint
//FOLDBEGINS 0 0″pins...″
(

　　out_data，

　　valid，

　　d_symbol，

　　valid_in，

　　demap_data，

　　odd_symbol，
　　symbol，

　　carrier0，

　　constellation，
//FOLDBEGINS 0 3″ram pins...″
ram_a，
ram_di，
ram_do，
ram_wreq，
//FOLDENDS
//FOLDBEGINS 0 3″scan pins...″
tdin，
tdout，
				
				
te，
//FOLDENDS
　　nrst，

　　clk
)；
//FOLDENDS
   parameter WIDTH＝13；//Modified by PK 15/9/97；12-＞13
   parameter ADDR_WlDTH＝11；
//FOLDBEGINS 0 2″outputs...″
output tdout；
   output valid；
   output[17：0]out_data；
   output d_symbol；
   output[ADDR_WIDTH-1：0]ram_a；
   output[WIDTH-1：0]ram_di；
   output ram_wreq；
   //FOLDENDS
//FOLDBEGINS 0 2″inputs...″
   input valid_in；
   input[WIDTH-1：0]demap_data；
   input odd_symbol；
   input symbol；
   input carrier0；
   input[WIDTH-1：0]ram_do；
   input[1：0]constellation；
   input tdin，te；
   input nrst，clk；
   //FOLDENDS
//FOLDBEGINS 0 2″regs/wires...″
   //FOLDBEGINS 0 0″inputs regs...″
   reg valid_in_reg；
   reg[WIDTH-1：0]demap_data_reg；
   reg odd_symbol_reg；
   reg symbol_reg；
   reg[WIDTH-1：0]ram_do_reg；
   reg[1：0]constellation_reg；
   //FOLDENDS
   //FOLDBEGINS 0 0″output regs...″
   reg valid；
   reg[17：0]out_data；
   reg d_symbol；
   reg[ADDR_WIDTH-1：0]ram_a；
   reg[WIDTH-1：0]ram_di；
				
				
reg ram_wreq；
//FOLDENDS
//FOLDBEGINS 0 0″instate_reg...″
parameter INSTATE_WAIT_SYMBOL＝2′d0；
parameter INSTATE_WAIT_VALID＝2′d1；
parameter INSTATE_WRITE＝2′d2；
parameter INSTATE_WRITE_RAM＝2′d3；
reg[1：0]instate_reg；
//FOLDENDS
//FOLDBEGINS 0 0″outstate_reg...″
parameter OUTSTATE_WAIT_WRITEFINISHED＝3′d0；
parameter OUTSTATE_WAIT0    ＝3′d1；
parameter OUTSTATE_WAIT1    ＝3′d2；
parameter OUTSTATE_READRAM       ＝3′d3；
parameter OUTSTATE_WAIT2    ＝3′d4；
parameter OUTSTATE_OUTPUTDATA        ＝ 3′d5；
parameter OUTSTATE_WAIT3    ＝ 3′d6；
reg[2：0]outstate_reg；
//FOLDENDS
reg[ADDR_WIDTH-1：0]read_addr_reg；
reg[WIDTH-1：0]data_reg；
reg next_read_reg，next_write_reg；
reg frist_data_reg；
reg odd_read_reg，odd_write_reg；
rag sym_rst_read_reg，sym_rst_write_reg；
reg[17：0]demapped；
reg[3：0]iminus；
reg[3：0]qminus；
reg[8：0]outi；
reg[8：0]outq；
reg[5：0]demap；
//FOLDBEGINS 0 0″wires...″
wire[ADDR_WIDTH-1：0]address_read，address_write；
wire finished_read，finished_write；
wire valid_read，write_valid；
wire[5：0]ini，inq；
//FOLDENDS
//FOLDENDS
ag #(ADDR_WIDTH)r
//FOLDBEGINS 0 2″pins...″
(
.address(address_read)，
.finished(finished_read)，
.next(next_read_reg)，
				
				
  .random(odd_read_reg)，
  .sym_rst(sym_rst_read_reg)，
  .nrst(nrst)，
  .clk(clk)

　　 )；

　　 //FOLDENDS
  ag #(ADDR_WIDTH)w
  //FOLDBEGINS 0 2″pins...″
  (
  .address(address_write)，
  .finished(finished_write)，
  .next(next_write_reg)，
  .random(～odd_write_reg)，
  .sym_rst(sym_rst_write_reg)，
  .nrst(nret)，
  .clk(clk)

　　 )；

　　 //FOLDENDS
//FOLDBEGINS 0 2″latch inputs...″
always @(posedge clk)
begin

　　 valid_in_reg＜＝valid_in；

　　 demap_data_reg＜＝demap_data；

　　 odd_symbol_reg＜＝odd_symbol；

　　 symbol_reg＜＝symbol；

　　 ram_do_reg＜＝ram_do；

　　 constellation_reg＜＝constellation；
   end
   //FOLDENDS
   always @(posedge clk)
   begin

　　 if(～nrst )

　　 //FOLDBEGINS 0 4″reset...″

　　 begin

　　 instate_reg＜＝INSTATE_WAIT_SYMBOL；

　　 outstate_reg＜＝OUTSTATE_WAIT_WRITEFINISHED；

　　 next_read_reg＜＝0；

　　 end

　　 //FOLDENDS

　　 else

　　 begin
//FOLDBEGINS 0 4″input state machine...″
//$write(″DB(％0d ％m)：instate_reg＝％0d fw＝％b\n″，
//     $time，instate_reg，finished_write)；
case(instate_reg)

　　   INSTATE_WAIT_SYMBOL：begin

　　   sym_rst_write_reg＜＝1；

　　   next_write_reg＜＝0；

　　   ram_wreq＜＝0；

　　   if(symbol_reg)

　　   begin
				
				
　　   //$write(″DB(％0d ％m)：GOT＝％x(NEW SYMBOL)\n″，$time，

　　         demap_data_reg)；

　　   $write(″DB(％0d ％m)：START WRITE\n″，$time)；

　　            odd_write_reg＜＝odd_symbol_reg；

　　            data_reg＜＝demap_data_reg；

　　            instate_reg＜＝INSTATE_WRITE；

　　          end

　　          end

　　   INSTATE_WAIT_VALID：begin

　　   ram_wreq＜＝0；

　　   next_write_reg＜＝0；

　　   if(finished_write)

　　   begin 

　　            $write(″DB(％0d％m)：END(1)WRITE\n″，$time)；

　　            instate_reg＜＝INSTATE_WAIT_SYMBOL；

　　          end

　　          else

　　          begin

　　            if(valid_in_reg)

　　            begin

　　              data_reg＜＝demap_data_reg；

　　              instate_reg＜＝INSTATE_WRITE；

　　            end

　　            end

　　     end

　　     INSTATE_WRITE：begin

　　       sym_rst_write_reg＜＝0；

　　       next_write_reg＜＝1；

　　       ram_a＜＝address_write；

　　       //$write(″DB(％0d ％m)：RWrite[％x]＝％x\n″，$time，address_write，

　　       data_reg)；

　　       ram_di＜＝data_reg；

　　       ram_wreq＜＝1；

　　       if(finished_write)

　　       begin

　　         $write(″DB(％0d ％m)：END(2)WRITE\n″，$time)；

　　         instate_reg＜＝INSTATE_WAIT_SYMBOL；

　　         ram_wreq＜＝0；

　　       end

　　       else

　　         instate_reg＜＝INSTATE_WAIT_VALID；

　　         end

　　 endcase

　　 //FOLDENDS
//FOLDBEGINS 0 4″output state machine...″
//$write(″DB(％0d ％m)：outstate_reg＝％0d nr：％br：％b\n″，
//  $time，outstate_reg，next_read_reg，odd_symbol_reg)；
case(outstate_reg)

　　   OUTSTATF_WAIT_WRITEFINISHED：begin

　　   sym_rst_read_reg＜＝1；

　　   frist_data_reg＜＝1；

　　   valid＜＝0；

　　   if(finished_write)

　　   begin

　　             odd_read_reg＜＝odd_write_reg；
				
				
　　     outstate_reg＜＝OUTSTATE_WAIT0；

　　     $write(″DB(％0d ％m)：START READ\n″，$time)；

　　     //$write(″DB(％0d ％m)：Read(NEW SYMBOL)\n″，$time，

　　     address_read)；

　　   end

　　   end

　　OUTSTATE_WAIT0：begin

　　sym_rst_read_reg＜＝0；

　　outstate_reg＜＝OUTSTATE_WAIT1；

　　end

　　OUTSTATE_WAIT1：begin

　　   outstate_reg＜＝OUTSTATE_READRAM；

　　   end

　　   OUTSTATE_READRAM：begin

　　   //$write(″DB(％0d ％m)：Read[％x]\n″，$time，address_read)；

　　   ram_a＜＝address_read；

　　   ram_wreq＜＝0；

　　   next_read_reg＜＝1；

　　   outstate_reg＜＝OUTSTATE_WAIT2；

　　end

　　OUTSTATE_WAIT2：begin

　　  next_read_reg＜＝0；

　　  outstate_reg＜＝OUTSTATE_OUTPUTDATA；

　　end

　　OUTSTATE_OUTPUTDATA：begin

　　   out_data＜＝{outi[8：6]，outq[8：6]，outi[5：3]，

　　   outq[5：3]，outi[2：0]，outq[2：0]}；

　　   valid＜＝1；

　　   d_symbol＜＝frist_data_reg；

　　   frist_data_reg＜＝0；

　　   outstate_reg＜＝OUTSTATE_WAIT3；

　　end

　　OUTSTATE_WAIT3：begin

　　   valid＜＝0；

　　   if(finished_read)

　　   begin

　　     outstate_reg＜＝OUTSTATE_WAIT_WRITEFINISHED；

　　     $write(″DB(％0d ％m)：END READ\n″，$time)；

　　   end

　　   else

　　      outstate_reg＜＝OUTSTATE_WAIT0；

　　      end
  endcase
  //FOLDENDS
  end
end
always @(constellation_reg or ini or inq)
//FOLDBEGINS 0 2″demapper...″
begin
//FOLDBEGINS 0 2″coarse demapping″
   iminus＝{ini[5：3]，1 ′b0}-2′d3；
   qminus＝{inq[5：3]，1′b0}-2′d3；
   if(constellation_reg＝＝2′b01)
   begin
				
				
　　demap＝{ 2′b0

　　iminus[2]，

　　qminus[2]，

　　！(iminus[2]＾iminus[1])，

　　！(qminus[2]＾qminus[1])

　　               }；

　　               //$writeb(demap，，)；

　　               //$display(iminus，，ini[5：3])；
  end
  else if(constellation_reg＝＝2′b10)
  begin

　　iminus＝{ini[5：3]，1′b0} -3′d7；

　　qminus＝{inq[5：3]，1′b0} -3′d7；

　　demap＝{iminus[3]，

　　               qminus[3]，

　　               ！(iminus[3]＾iminus[2])，

　　               ！(qminus[3]＾qminus[2])，

　　               (iminus[2]＾iminus[1])，

　　               (qminus[2]＾qminus[1])

　　               }；
  end
  else

　　     demap＝6′b0；
  //FOLDENDS
  if(constellation_reg＝＝2′b01)
  begin
//FOLDBEGINS 0 4″16QAM″
if(！iminus[1]&&iminus[0])
begin

　　      outi[8：6]＝3′b0；

　　      outi[5：3]＝demap[3]？3′b111：3′b0；

　　      outi[2：0]＝iminus[2]？ini[2：0]：～ini[2：0]；

　　    end

　　    else

　　    begin

　　      outi[8：6]＝3′b0；

　　      outi[5：3]＝～ini[2：0]；

　　      outi[2：0]＝3′b111；

　　    end

　　    if(！qminus[1]&&qminus[0])

　　    begin

　　      outq[8：6]＝3′b0；

　　      outq[5：3]＝demap[2]？3′b111：3′b0；

　　      outq[2：0] ＝ qminus[2]？ inq[2：0]： ～inq[2：0]；

　　    end

　　    else

　　    begin

       　 outq[8：6]＝3′b0；

　　      outq[5：3]＝～inq[2：0]；

　　      outq[2：0]＝3′b111；

　　    end

　　    //FOLDENDS
				
				
　　 end

　　 else if(constellation_reg＝＝2′b10)

　　 begin
//FOLDBEGINS 0 4″64QAM″
if(！iminus[1])
begin

　　   outi[8：6]＝demap[5]？3′b111：3′b0；

　　   outi[5：3]＝demap[3]？3′b111：3′b0；

　　   outi[2：0]＝iminus[2]？～ini[2：0]：ini[2：0]；

　　 end

　　 else if(！iminus[2])

　　 begin

　　   outi[8：6]＝demap[5]？3′b111：3′b0；

　　   outi[5：3]＝iminus[3]？ini[2：0]：～ini[2：0]；

　　   outi[2：0]＝demap[1]？3′b111：3′b0；

　　 end

　　 else

　　 begin

　　   outi[8：6]＝～ini[2：0]；

　　   outi[5：3]＝demap[3]？3′b111：3′b0；

　　   outi[2：0]＝demap[1]？3′b111：3′b0；

　　 end

　　 if(！qminus[1])

　　 begin

　　   outq[8：6]＝demap[4]？3′b111：3′b0；

　　   outq[5：3]＝demap[2]？3′b111：3′b0；

　　   outq[2：0]＝qminus[2]？～inq[2：0]：inq[2：0]；

　　 end

　　 else if(！qminus[2])

　　 begin

　　   outq[8：6]＝demap[4]？3′b111：3′b0；

　　   outq[5：3]＝qminus[3]？inq[2：0]：～inq[2：0]；

　　   outq[2：0]＝demap[0]？3′b111：3′b0；

　　 end

　　 else

　　 begin

　　   outq[8：6]＝～inq[2：0]；

　　   outq[5：3]＝demap[2]？3′b111：3′b0；

　　   outq[2：0]＝demap[0]？3′b111：3′b0；

　　 end

　　 //FOLDENDS
   end
   else
   begin
//FOLDBEGINS 0 4″QPSK″
outi＝{6′b0，～ini[2：0]}；
outq＝{6′b0，～inq[2：0]}；
//FOLDENDS
   end
   end
   //FOLDENDS
assign ini＝ram_do_reg[11：6]；
assign inq＝ram_do_reg[5：0]；
				
				
endmodule
//FOLDENDS
//FOLDBEGINS 0 0″module ag(address gereration)...″
////////////////////////////////////////////////////////////////////////
module ag
//FOLDBEGINS 0 0″pins...″
(

　　address，

　　finished，

　　next，

　　random，

　　sym_rst，

　　nrst，

　　clk
  )；
  //FOLDENDS
  parameter ADDR_WIDTH＝12；
//FOLDBEGINS 0 2″outputs...″
output[ADDR_WIDTH-1：0]address；
output finished；
//FOLDENDS
//FOLDBEGINS 0 2″inputs...″
input next；
input random；
input sym_rst；
input nrst，clk；
//FOLDENDS
//FOLDBEGINS 0 2″regs...″
integer i；
   reg finished；
   reg[9：0]prsr_reg；
   reg[11：0]count_reg；
   wire address_valid；
   //FOLDENDS
   always @(posedge clk)
   begin

　　 if(～nrst )

　　 begin

　　   count_reg＜＝0；

　　   prsr_reg＜＝10′d0；

　　 end

　　 else

　　 begin

　　   if(sym_rst)

　　   begin

　　     finished＜＝0；
				
				
　　    count_reg＜＝0；

　　  end

　　  else

　　  if(next|(！address_valid & random))

　　  begin

　　    //$wrie(″DB(％0d ％m)：Next(r：％d)\n″，$time，random)；

　　    if(random)
//FOLDBEGINS 0 8″do the random stuff...″
begin

　　      if(！address_valid)

　　      begin

　　   //FOLDBEGINS 0 4″drive the prsr...″

　　   if(count_reg＝＝11′d0)

　　           prsr_reg＜＝10′d0；

　　           else

　　           if(count_reg＝＝11′d1)

　　           prsr_reg＜＝10′d1；

　　           else

　　           begin

　　           for(i＝0；i＜9；i＝i+1)

　　           prsr_reg[i]＜＝prsr_reg[i+1]；

　　           prsr_reg[9]＜＝prsr_reg[0]＾prsr_reg[3]；

　　           end

　　        //FOLDENDS

　　        count_reg＜＝count_reg+1；

　　        //$write(″DB(％0d ％m)：count＝％0d Rand(Retry)\n″，$time，

　　        count_reg)；

　　      end

　　      else

　　      begin

　　        if(count_reg＝＝11′d2047)

　　        begin

　　          //$write(″DB(％0d ％m)：***FINISHED Rand\n″，$time)；

　　          finished＜＝1；

　　          count_reg＜＝0；

　　          prsr_reg＜＝10′d0；

　　        end

　　        else

　　        begin

　　   //FOLDBEGINS 0 6″drive the prsr...″

　　   if(count_reg＝＝11′d0)

　　             prsr_reg＜＝10′d0；

　　             else

　　             if(count_reg＝＝11′d1)

　　             prsr_reg＜＝10′d1；

　　             else

　　             begin

　　             for(i＝0；i＜9；i＝i+1)

　　             prsr_reg[i]＜＝prsr_reg[i+1]；

　　             prsr_reg[9]＜＝prsr_reg[0]＾prsr_reg[3]；

　　             end

　　             //FOLDENDS

　　             count_reg＜＝count_reg+1；
				
				
　　            //$write(″DB(％0d ％m)：count＝％0d Rand\n″，$time，count_reg)；

　　            finished＜＝0；

　　         end

　　         end

　　    end

　　    //FOLDENDS

　　    else
//FOLDBEGINS 0 8″do the sequential stuff...″
begin

　　      if(count_reg！＝11′d1511)

　　      begin

　　        //$write(″DB(％0d ％m)：count＝％0d Sequ\n″，$time，count_reg)；

　　        count_reg＜＝count_reg+1；

　　        finished＜＝0；

　　      end

　　      else

　　      begin

　　        //$write(″DB(％0d ％m)：***FINISHED Sequ\n″，$time)；

　　        finished＜＝1；

　　        count_reg＜＝0；

　　      end

　　      end

　　      //FOLDENDS

　　  end

　　  end
   end
//FOLDBEGINS 0 2″assign address...″
assign address＝(random)？({count_reg[0]，//10

　　                                 prsr_reg[2]，//9

　　                                 prsr_reg[5]，//8

　　                                 prsr_reg[8]，//7

　　                                 prsr_reg[3]，//6

　　                                 prsr_reg[7]，//5

　　                                 prsr_reg[0]，//4

　　                                 prsr_reg[1]，//3

　　                                 prsr_reg[4]，//2

　　                                 prsr_reg[6]，//1

　　                                 prsr_reg[9]})：//0

　　                                 count_reg；

　　                                 //FOLDENDS
   assign address_valid＝(address＜11′d1512)；
   endmodule
   //FOLDENDS

                                  Listing 23

 //SccslD：″@(#)bitdeint.v 1.49/14/97″
 //FOLDBEGINS 0 0″Copyright(c)1997 Pioneer Digital Design Centre Limited″
 /********************************************************

　　  Copyright(c)1997 Pioneer Digital Design Centre Limited
   NAME：bitdeint_rtl.v
   PURPOSE：bit deinterleaver
				
				
  CREATED：Wed 23 Jul 1997 BY：Paul(Paul McCloy)
  MODIFICATION HISTORY：
********************************************************/
//FOLDENDS
module bitdeint
//FOLDBEGINS 0 2″pins...″
   (
   i_data，
   q_data，
   discard_i，
   discard_q，

　　  valid，//output
   //FOLDBEGINS 0 2″ram0 pins...″

　　  ram0_a，

　　  ram0_di，

　　  ram0_do，

　　  ram0_wreq，

　　  ram0_ce，

　　  //FOLDENDS
   //FOLDBEGINS 0 2″ram1 pins...″

　　  ram1_a，

　　  ram1_di，

　　  ram1_do，

　　  ram1_wreq，

　　  ram1_ce，

　　  //FOLDENDS
   //FOLDBEGINS 0 2″ram2 pins...″

　　  ram2_a，

　　  ram2_di，

　　  ram2_do，

　　  ram2_wreq，

　　  ram2_ce，

　　  //FOLDENDS

　　  bad_carrier，

　　  valid_in，

　　  data_in，

　　  symbol，

　　  constellation，//constellation

　　  alpha，//does not do anything yet
   //FOLDBEGINS 0 2″scan pins...″
   tdin，
   tdout，
   te，
   //FOLDENDS

　　  nrst，
				
				
　　  clk
   )；
   //FOLDENDS
   parameter SBW＝3；//soft bit width
//FOLDBEGINS 0 2″outputs...″
//FOLDBEGINS 0 0″ram0 outputs...″
output[6：0]ram0_a；
output[((SBW+1)＜＜1)- 1：0]ram0_di；
output ram0_ce；
output ram0_wreq；
//FOLDENDS
//FOLDBEGINS 0 0″ram1 outputs...″
output[6：0]ram1_a；
output[((SBW+1)＜＜1)-1：0]ram1_di；
output ram1_ce；
output ram1_wreq；
//FOLDENDS
//FOLDBEGINS 0 0″ram2 outputs...″
output[6：0]ram2_a；
output[((SBW+1)＜＜1)-1：0]ram2_di；
output ram2_ce；
output ram2_wreq；
//FOLDENDS
   output tdout；
   output[SBW-1：0]i_data；
   output[SBW-1：0]q_data；
   output discard_i；
   output discard_q；
   output valid；
   //FOLDENDS
   //FOLDBEGINS 0 2″inputs...″
   input[((SBW+1)＜＜1)-1：0]ram0_do；
   input[((SBW+1)＜＜1)-1：0]ram1_do；
   input[((SBW+1)＜＜1)-1：0]ram2_do；
   input bad_carrier；
   input valid_in；
   input[((SBW＜＜2)+(SBW＜＜1))-1：0]data_in；//6*SBW bits
   input symbol；
   input[1：0]constellation；
   input[2：0]alpha；
   input tdin，te；
   input nrst，clk；
   //FOLDENDS
//FOLDBEGINS 0 2″reg/wire...″
//FOLDBEGINS 0 0″outputs...″
				
				
//FOLDBEGINS 0 0″ram0 regs...″
reg[6：0]ram0_a；
reg[((SBW+1)＜＜1)-1：0]ram0_di；
reg ram0_ce；
reg ram0_wreq；
//FOLDENDS
//FOLDBEGINS 0 0″ram1 regs...″
reg[6：0]ram1_a；
reg[((SBW+1)＜＜1)-1：0]ram1_di；
reg ram1_ce；
reg ram1_wreq；
//FOLDENDS
//FOLDBEGINS 0 0″ram2 regs...″
reg[6：0]ram2_a；
reg[((SBW+1)＜＜1)-1：0]ram2_di；
reg ram2_ce；
reg ram2_wreq；
//FOLDENDS
   reg[SBW-1：0]i_data；
   reg[SBW-1：0]q_data；
   reg discard_i；
   reg discard_q；
   reg valid；
   //FOLDENDS
   //FOLDBEGINS 0 0″inputs...″
   reg valid_in_reg；
   reg[((SBW＜＜2)+(SBW＜＜1))-1：0]data_in_reg；//6*SBW bits
   reg symbol_reg，bad_carrier_reg；
   reg[1：0]constellation_reg；
   reg[2：0]alpha_reg；
   reg[((SBW+1)＜＜1)-1：0]ram0_do_reg；
   reg[((SBW+1)＜＜1)-1：0]ram1_do_reg；
   reg[((SBW+1)＜＜1)-1：0]ram2_do_reg；
   //FOLDENDS
   reg[6：0]i0_adr_reg；
   reg[6：0]i1_adr_reg；
   reg[6：0]i2_adr_reg；
   reg[6：0]i3_adr_reg；
   reg[6：0]i4_adr_reg；
   reg[6：0]i5_adr_reg；
   reg[2：0]mode_reg；
   reg[(SBW＜＜2)+(SBW＜＜1)-1：0]data_reg；//6*(SBW)bits
   reg[((SBW+1)＜＜1)+SBW：0]i_out_buf_reg，q_out_buf_reg；//3*(SBW+1)bits
   reg ram_filled_reg，out_buf_full_reg，bad_car_reg；
   wire[SBW：0]i0_in，q0_in，i1_in，q1_in，i2_in，q2_in；
   wire[SBW：0]i0_ram，q0_ram，i1_ram，q1_ram，i2_ram，q2_ram；
   //FOLDENDS
				
				
//FOLDBEGINS 0 2 ″latch inputs...″
always @(posedge clk)
begin

　　 bad_carrier_reg    ＜＝bad_carrier；

　　 valid_in_reg   ＜＝valid_in；

　　 data_in _reg   ＜＝data_in；

　　 symbol_reg     ＜＝symbol；

　　 constellation_reg  ＜＝constellation；

　　 alpha_reg     ＜＝alpha；

　　 ram0_do_reg       ＜＝ram0_do；

　　 ram1_do_reg       ＜＝ram1_do；

　　 ram2_do_reg       ＜＝ram2_do；
   end
   //FOLDENDS
   always @(posedge clk)
   begin

　　 if(～nrst )

　　 //FOLDBEGINS 0 4 ″reset ...″

　　 begin

　　 mode_reg＜＝2′b00；

　　 valid＜＝0；

　　 i0_adr_reg＜＝0；

　　 i1_adr_reg＜＝63；

　　 i2_adr_reg＜＝105；

　　 i3_adr_reg＜＝42；

　　 i4_adr_reg＜＝21；

　　 i5_adr_reg＜＝84；

　　    i_out_buf_reg＜＝0；

　　    q_out_buf_reg＜＝0；

　　    ram_filled_reg＜＝0；

　　    out_buf_full_reg＜＝0；

　　  end

　　  //FOLDENDS

　　  else

　　  begin

　　    if(valid_in_reg)

　　    //FOLDBEGINS 0 6″start cycle...″

　　    begin

　　      data_reg＜＝data_in_reg；

　　      bad_car_reg＜＝bad_carrier_reg；

　　      //$write(″DB(％0d ％m)：data_reg＝％X(％b.％b.％b)\n″，$time，data_in_reg，

　　      //  bad_carrier，bad_carrier_reg，bad_car_reg)；

　　      //FOLDBEGINS 0 2″logic to read i0，1，2...″

　　      ram0_a＜＝i0_adr_reg；

　　      ram0_wreq＜＝0；

　　        ram1_a＜＝i1_adr_reg；

　　        ram1_wreq＜＝0；

　　        ram2_a＜＝i2_adr_reg；

　　        ram2_wreq＜＝0；

　　        //FOLDENDS
				
				
  ram0_ce＜＝1；
  ram1_ce＜＝(constellation_reg＝＝2′b10)

　　           (constellation_reg＝＝2′b01)；

　　           ram2_ce＜＝(constellation_reg＝＝2′b10)；
//FOLDBEGINS 0 2″outputi1 and q1...″
if(out_buf_full_reg & (constellation_reg！＝2′b00))
begin

　　 valid＜＝1；

　　 i_data＜＝i_out_buf_reg[((SBW+1)＜＜1)-2：(SBW+1)]；

　　 discard_i＜＝i_out_buf_reg[((SBW+1)＜＜1)-1]；

　　 q_data＜＝q_out_buf_reg[((SBW+1)＜＜1)-2：(SBW+1)]；

　　 discard_q＜＝q_out_buf_reg[((SBW+1)＜＜1)-1]；

　　 //$write(″DB(％0d ％m)：OUT(1)：％x ％x\n″，$time，

　　 //      i_out_buf_reg[((SBW+1)＜＜1)-2：(SBW+1)]，

　　 //      q_out_buf_reg[((SBW+1)＜＜1)-2：(SBW+1)])；
   end
   //FOLDENDS
   mode_reg＜＝3′b001；
   end
   //FOLDENDS
   else
   begin
   //$write(″DB(％0d ％m)：m＝％b\n″，$time，mode_reg)；
   case(mode_reg)
   //FOLDBEGINS 0 8″3′b001：...″
   3′b001：begin
   //FOLDBEGINS 0 4″logic to read q0，1，2...″

　　    ram0_a＜＝i3_adr_reg；

　　    ram0_wreq＜＝0；

　　    ram1_a＜＝i4_adr_reg；

　　    ram1_wreq＜＝0；

　　    ram2_a＜＝i5_adr_reg；

　　    ram2_wreq＜＝0；

　　    //FOLDENDS

　　    valid＜＝0；

　　    mode_reg＜＝3′b010；

　　    end
   //FOLDENDS
   //FOLDBEGINS 0 8″3′b010：...″
   3′b010：begin
   mode_reg＜＝3′b011；
   //FOLDBEGINS 0 4″output i2 and q2...″
   if(out_buf_full_reg & (constellation_reg＝＝2′b10))
   begin

　　       valid＜＝1；

　　       i_data＜＝i_out_buf_reg[SBW-1：0]；

　　       discard_i＜＝i_out_buf_reg[SBW]；
				
				
　　   q_data＜＝q_out_buf_reg[SBW-1：0]；

　　   discard_q＜＝q_out_buf_reg[SBW]；

　　   //$write(″DB(％0d ％m)：OUT(2)：％x ％x\n″，$time，

　　   //      i_out_buf_reg[SBW-1：0]，

　　   //      q_out_buf_reg[SBW-1：0])；

　　 end

　　 //FOLDENDS

　　 end
//FOLDENDS
//FOLDBEGINS 0 8″3′b011：...″
3′b011：begin
valid＜＝0；

　　 //$write(″DB(％0d ％m)：ram read i0：％x i1：％x i2：％x\n，

　　 //      $time，

　　 //      ram0_do_reg[((SBW+1)＜＜1)-1：SBW+1]，

　　 //      ram1_do_reg[((SBW+1)＜＜1)-1：SBW+1]，

　　 //     ram2_do_reg[((SBW+1)＜＜1)-1：SBW+1])；

　　 i_out_buf_reg＜＝{ram0_do_reg[((SBW+1)＜＜1)-1：SBW+1]，

　　 ram1_do_reg[((SBW+1)＜＜1)-1：SBW+1]，

　　 ram2_do_reg[((SBW+1)＜＜1)-1：SBW+1]}；
//FOLDBEGINS 0 4″logic to write new i0，1，2...″
ram0_a＜＝i0_adr_reg；
ram0_wreq＜＝1；
ram0_di＜＝{i0_in，q0_ram}；

　　 ram1_a＜＝i1_adr_reg；

　　 ram1_wreq＜＝1；

　　 ram1_di＜＝{i1_in，q1_ram}；

　　 ram2_a＜＝i2_adr_reg；

　　 ram2_wreq＜＝1；

　　 ram2_di＜＝{i2_in，q2_ram}；

　　 //FOLDENDS

　　 mode_reg＜＝3′b100；

　　 end
//FOLDENDS
//FOLDBEGINS 0 8″3′b100：...″
3′b100：begin

　　 //$write(″DB(％0d ％m)：ram read q0：％x q1：％x q2：％x\n″，

　　 //       $time，

　　 //       ram0_do_reg[SBW：0]，

　　 //       ram1_do_reg[SBW：0]，

　　 //       ram2_do_reg[SBW：0])；

　　 q_out_buf_reg＜＝{ram0_do_reg[SBW：0]，

　　 ram1_do_reg[SBW：0]，

　　 ram2_do_reg[SBW：0]}；

　　 out_buf_full_reg＜＝ram_filled_reg；

　　 //FOLDBEGINS 0 4″logic to write new q0，1，2...″
				
				
　　 ram0_a＜＝i3_adr_reg；

　　 ram0_wreq＜＝1；

　　 ram0_di＜＝{i0_ram，q0_in}；

　　 ram1_a＜＝i4_adr_reg；

　　 ram1_wreq＜＝1；

　　 ram1_di＜＝{i1_ram，q1_in}；

　　 ram2_a＜＝i5_adr_reg；

　　 ram2_wreq＜＝1；

　　 ram2_di＜＝{i2_ram，q2_in}；

　　 //FOLDENDS
//FOLDBEGINS 0 4″output i0 and q0...″
if(out_buf_full_reg)
begin

　　    valid＜＝1；

　　    i_data＜＝i_out_buf_reg[((SBW+1)＜＜1)+SBW-1：((SBW+1)＜＜1)]；

　　    discard_i＜＝i_out_buf_reg[((SBW+1)＜＜1)+SBW]；

　　    q_data＜＝q_out_buf_reg[((SBW+1)＜＜1 )+SBW-1：((SBW+1)＜＜1)]；

　　    discard_q＜＝q_out_buf_reg[((SBW+1)＜＜1)+SBW]；

　　    //$write(″DB(％0d ％m)：OUT(0)：％x ％x\n″，$time，

　　    //  i_out_buf_reg[((SBW+1)＜＜1)+SBW-1：((SBW+1)＜＜1)]，

　　    //  q_out_buf_reg[((SBW+1)＜＜1)+SBW-1：((SBW+1)＜＜1)])；

　　  end

　　  //FOLDENDS

　　  mode_reg＜＝3′b101；

　　  end
//FOLDENDS
//FOLDBEGINS 0 8″3′b101：...″
3′b101：begin
valid＜＝0；
//FOLDBEGINS 0 4″increment ram address...″

　　 if(i0_adr_reg＝＝7′d125)

　　 begin

　　   i0_adr_reg＜＝0；

　　   //FOLDBEGINS 0 2″do i1_adr_reg(63 offset)...″

　　   i1_adr_reg＜＝(i1_adr_reg＝＝7′d20)？7′d84：

　　   (i1_adr_reg＝＝7′d41)？7′d105：

　　   (i1_adr_reg＝＝7′d62)？7′d0：

　　   (i1_adr_reg＝＝7′d83)？7′d21：

　　   (i1_adr_reg＝＝7′d104)？7′d42：

　　                                                         7′d63；

　　                                                         //FOLDENDS

　　 //FOLDBEGINS 0 2″do i2_adr_reg(105 offset)...″

　　 i2_adr_reg＜＝(i2_adr_reg＝＝7′d20)？7′d42：

　　                     (i2_adr_reg＝＝7′d41)？7′d63：

　　                     (i2_adr_reg＝＝7′d62)？7′d84：

　　                     (i2_adr_reg＝＝7′d83)？7′d105：

　　                     (i2_adr_reg＝＝7′d104)？7′d0：

　　                                                         7′d21；

　　                                                         //FOLDENDS
				
				
　　          //FOLDBEGINS 0 2″do i3_adr_reg(42 offset)...″

　　          i3_adr_reg＜＝(i3_adr_reg＝＝7′d20)？7′d105：

　　                              (i3_adr_reg＝＝7′d41)？7′d0：

　　                              (i3_adr_reg＝＝7′d62)？7′d21：

　　                              (i3_adr_reg＝＝7′d83)？7′d42：

　　                              (i3_adr_reg＝＝7′d104)？7′d63：

　　                                                                           7′d84；

　　                                                                           //FOLDENDS

　　          //FOLDBEGINS 0 2″do i4_adr_reg(21 offset)...″

　　          i4_adr_reg＜＝(i4_adr_reg＝＝7′d20)？7′d0：

　　                              (i4_adr_reg＝＝7′d41)？7′d21

　　                              (i4_adr_reg＝＝7′d62)？7′d42

　　                              (i4_adr_reg＝＝7′d83)？7′d63

　　                              (i4_adr_reg＝＝7′d104)？7′d84：

　　                                                                           7′d105；

　　                                                                           //FOLDENDS

　　          //FOLDBEGINS 0 2 ″do i5_adr_reg(84 offset)...″

　　          i5_adr_reg＜＝(i5_adr_reg＝＝7′d20)？7′d63：

　　                              (i5_adr_reg＝＝7′d41)？7′d84：

　　                              (i5_adr_reg＝＝7′d62)？7′d105：

　　                              (i5_adr_reg＝＝7′d83)？7′d0：

　　                              (i5_adr_reg＝＝7′d104)？7′d21：

　　                                                                           7′d42；

　　                                                                           //FOLDENDS

　　           ram_filled_reg＜＝1；

　　           end

　　           else

　　           begin

　　           i0_adr_reg＜＝ i0_adr_reg + 1；

　　           i1_adr_reg＜＝(i1_adr_reg＝＝7′d125)？0：i1_adr_reg+1；

　　           i2_adr_reg＜＝(i2_adr_reg＝＝7′d125)？0：i2_adr_reg+1；

　　           i3_adr_reg＜＝(i3_adr_reg＝＝7′d125)？0：i3_adr_reg+1；

　　           i4_adr_reg＜＝(i4_adr_reg＝＝7′d125)？0：i4_adr_reg+1；

　　           i5_adr_reg＜＝(i5_adr_reg＝＝7′d125)？0：i5_adr_reg+1；

　　         end

　　        //FOLDENDS

　　        end

　　   //FOLDENDS

　　   endcase

　　 end

　　 end
end
assign i0_in＝{bad_car_reg，
data_reg[(SBW＜＜2)+(SBW＜＜1)-1：(SBW＜＜2)+SBW]}；
assign q0_in＝{bad_car_reg，
data_reg[(SBW＜＜2)+SBW-1：SBW＜＜2]}；
assign i1_in＝{bad_car_reg，
data_reg[(SBW＜＜2)-1：(SBW＜＜1)+SBW]}；
assign q1_in＝{bad_car_reg，
data_reg[(SBW＜＜1)+SBW-1：SBW＜＜1]}；
assign i2_in＝{bad_car_reg，
data_reg[(SBW＜＜1)-1：SBW]}；
assign q2_in＝{bad_car_reg，
				
				
  data_reg[SBW-1        ：0]}；
  assign i0_ram＝i_out_buf_reg[((SBW+1)＜＜1)+SBW：((SBW+1)＜＜1)]；
  assign q0_ram＝q_out_buf_reg[((SBW+1)＜＜1)+SBW：((SBW+1)＜＜1)]；
  assign i1_ram＝i_out_buf_reg[((SBW+1)＜＜1)-1：SBW+1]；
  assign q1_ram＝q_out_buf_reg[((SBW+1)＜＜1)-1：SBW+1]；
  assign i2_ram＝i_out_buf_reg[SBW：0]；
  assign q2_ram＝q_out_buf_reg[SBW：0]；
endmodule

                                      Listing 24

//Sccsld：％W％ ％G％
/**************************************************************
  Copyright(c)1997 Pioneer Digital Design Centre Limited
**************************************************************/
module acc_prod(clk，resync，load，symbol，new_phase，old_phase，xcount，

　　 acc_out)；
input clk，resync，load，symbol；
input[10：0]xcount；
input[13：0]new_phase，old_phase；
output[29：0]acc_out；
reg[29：0]acc_out；
reg[29：0]acc_int；
reg[14：0]diff；
reg[25：0]xdiff；
reg sign；
reg[14：0]mod_diff；
reg[25：0]mod_xdiff；
always @(posedge clk)
begin
 if(resync)
 begin
  acc_out＜＝0；
  acc_int＜＝0；
 end 
 else 
  begin
  if(load)
  acc_int＜＝acc_int+{xdiff[25]，xdiff[25]，//sign extend

　　     xdiff25]，xdiff[25]，xdiff}；
  if(symbol)
  begin
   acc_out＜＝acc_int；
   acc_int＜＝0；
  end
				
				
end
end
always @(new_phase or old_phase or xcount)
begin
 diff＝{new_phase[13]，new_phase}//sign extend up to allow

　　-{old_phase[13]，old_phase}；//differences up to 360
 sign＝diff[14]；
 mod_diff＝sign？(～diff+1)：diff；
 mod_xdiff＝mod_diff*{4′b0，xcount}；
 xdiff＝sign？(～mod_xdiff+1)：mod_xdiff；
end
endmodule

                                           Listing 25

//Sccsld：％W％ ％G％
/**************************************************************
  Copyright(c)1997 Pioneer Digital Design Centre Limited
**************************************************************/
module acc_simple(clk，resync，load，symbol，new_phase，old_phase，acc_out)；
 input clk，resync，load，symbol；
 input[13：0]new_phase，old_phase；
 output[20：0]acc_out；
 reg[20：0]acc_out；
 reg[20：0]acc_int；
 reg[14：0]diff；
 always @(posedge clk)
 begin
  if(resync)
  begin
   acc_out＜＝0；
   acc_int＜＝0；
  end
  else
  begin
   if(load)
   acc_int＜＝acc_int+{diff[14]，diff[14]，//sign extend

　　      diff[14]，diff[14]，

　　      diff[14]，diff[14]，diff}；
   if(symbol)
   begin

　　acc_out＜＝acc_int；

　　acc_int＜＝0；
   end
  end
				
				
end
always@(new_phase or old_phase)
diff＝{new_phase[13]，new_phase}//sign extend up to allow
   -{old_phase[13]，old_phase}；//differences up to 360
always @(diff or load)
begin：display
 reg[14：0]real_diff；
 if(load)
 begin
 if(diff[14])
 begin
  real_diff＝(～diff+1)；
  $display(″diff＝-％0d″，real_diff)；
 end
 else
  $display(″diff＝％0d″，diff)；
 end
end//display
endmodule

                                      Listing 26

//Sccsld：％W％ ％G％
/**************************************************************
  Copyright(c)1997 Pioneer Digital Design Centre Limited
**************************************************************/
module addr_gen(clk，resync，u_symbol，uc_pilot，got_phase，en，load，guard，

　　 addr，xcount，guard_reg，symbol)；
 input clk，resync，u_symbol，uc_pilot，got_phase；
 input[1：0]guard；
 output en，load，symbol；
 output[1：0]guard_reg；
 output[9：0]addr；
 output[10：0]xcount；
 reg en，load，load_p，inc_count2，symbol；
 reg[1：0]guard_reg；
 reg[5：0]count45；
 reg[10：0]xcount；
 reg[9：0]addr；
 always @(posedge clk)
 begin
  if(resync)
  begin
   count45＜＝0；
				
				
 load_p＜＝0；
 load＜＝0；
 inc_count2＜＝0；
 syrmbol＜＝0；
 guard_reg＜＝0；
end
else
begin
 if(u_symbol)
 begin
  inc_count2＜＝1；
  guard_reg＜＝gard；
 end
  if(inc_count2 && uc_pilot)
  begin
   inc_count2＜＝0；
   count45＜＝0；
  end
  if(got_phase)
   count45＜＝count45+1；
  load_p＜＝en；
  load＜＝load_p；
  symbol＜＝(inc_count2 && uc_pilot)；
  addr＜＝count45；
  en＜＝got_phase &&！resync && (count45＜45)；//！！45？
 end
end
always @(count45)
 case(count45)
   1：xcount＝1；
   2：xcount＝49；
   3：xcount＝55；
   4：xcount＝88；
   5：xcount＝142；
   6：xcount＝157；
   7：xcount＝193；
   8：xcount＝202；
   9：xcount＝256；
   10：xcount＝280；
   11：xcount＝283；
   12：xcount＝334；
   13：xcount＝433；
   14：xcount＝451；
   15：xcount＝484；
   16：xcount＝526；
   17：xcount＝532；
   18：xcount＝619；
   19：xcount＝637；
   20：xcount＝715；
   21：xcount＝760；
   22：xcount＝766；
   23：xcount＝781；
   24：xcount＝805；
				
				
   25：xcount＝874；
   26：xcount＝889；
   27：xcount＝919；
   28：xcount＝940；
   29：xcount＝943；
   30：xcount＝970；
   31：xcount＝985；
   32：xcount＝1051；
   33：xcount＝1102；
   34：xcount＝1108；
   35：xcount＝1111；
   36：xcount＝1138；
   37：xcount＝1141；
   38：xcount＝1147；
   39：xcount＝1207；
   40：xcount＝1270；
   41：xcount＝1324；
   42：xcount＝1378；
   43：xcount＝1492；
   44：xcount＝1684；
   45：xcount＝1705；
  default：xcount＝0；
 endcase
endmodule

                                      Listing 27

//Sccsld：％W％％G％
/**************************************************************
  Copyright(c)1997 Pioneer Digital Design Centre Limited
*************************************************************/
module avg_8(clk，resync，symbol，in_data，avg_out)；
 parameter phase_width＝12；
 input clk，resync，symbol；
 input[phase_width-2：0]in_data；
 output[phase_width-2：0]avg_out；
 reg[phase_width-2：0]avg_out；
 reg[phase_width-2：0]store[7：0]；
 wire[phase_width-2：0]store7＝store[7]；
 wire[phase_width-2：0]store6＝store[6]；
 wire[phase_width-2：0]store5＝store[5]；
 wire[phase_width-2：0]store4＝store[4]；
 wire[phase_width-2：0]store3＝store[3]；
 wire[phase_width-2：0]store2＝store[2]；
 wire[phase_width-2：0]store1＝store[1]；
 wire[phase_width-2：0]store0＝store[0]；
				
				
wire[phase_width+1：0]sum＝({store7[phase_width-2]，store7[phase_width-2]，
store7[phase_width-2]，store7}

　　     +{store6[phase_width-2]，store6[phase_width-2]，store6[phase_width-2]，
store6}

　　     +{store5[phase_width-2]，store5[phase_width-2]，store5[phase_width-2]，
store5}

　　     +{store4[phase_width-2]，store4[phase_width-2]，store4[phase_width-2]，
store4}

　　     +{store3[phase_width-2]，store3[phase_width-2]，store3[phase_width-2]，
store3}

　　     +{store2[phase_width-2]，store2[phase_width-2]，store2[phase_width-2]，
store2}

　　     +{store1[phase_width-2]，store1[phase_width-2]，store1[phase_width-2]，
store1}

　　     +{store0[phase_width-2]，store0[phase_width-2]，store0[phase_width-2]，
store0})；
always @(posedge clk)
begin
 if(resync)
 begin
  store[7]＜＝0；
  store[6]＜＝0；
  store[5]＜＝0；
  store[4]＜＝0；
  store[3]＜＝0；
  store[2]＜＝0；
  store[1]＜＝0；
  store[0]＜＝0；
  avg_out＜＝0；
 end
 else if(symbol)
 begin
  store[7]＜＝store[6]；
  store[6]＜＝store[5]；
  store[5]＜＝store[4]；
  store[4]＜＝store[3]；
  store[3]＜＝store[2]；
  store[2]＜＝store[1]；
  store[1]＜＝store[0]；
  store[0]＜＝in_data；
  avg_out＜＝sum＞＞3；
  end
 end
 endmodule

                                          Listing 28

//Sccsld：％W％ ％G％
/**************************************************************
  Copyright(c)1997 Pioneer Digital Design Centre Limited
**************************************************************/
module twowire26(clk，rst，in_valid，din，out_accept，out_valid，in_accept，
				
				
　　 dout，set)；
input clk，rst，set，in_valid，out_accept；
input[25：0]din；
output in_accept，out_valid；
output[25：0]dout；
reg in_accept，out_valid，acc_int，acc_int_reg，in_valid_reg，val_int；
reg[25：0]dout，din_reg；
always @(posedge clk)
begin
if(rst)
 out_valid＜＝0；
else if(acc_int||set)
 out_valid＜＝val_int；
if(in_accept)
 begin
  in_valid_reg＜＝in_valid；
  din_reg＜＝din；
 end
 if(acc_int)
  dout＜＝in_accept？din；din_reg；
 if(set)
  acc_int_reg＜＝1；
 else
  acc_int_reg＜＝acc_int；
end
always @(out_accept or out_valid or acc_int_reg or in_valid or in_valid_reg)
begin
 acc_int＝out_accept||！out_valid；
 in_accept＝acc_int_reg||！in_valid_reg；
 val_int＝in_accept？in_valid：in_valid_reg；
end
endmodule
module buffer(clk，nrst，resync，u_symbol_in，uc_pilot_in，ui_data_in，

　　uq_data_in，u_symbol_out，uc_pilot_out，ui_data_out，

　　uq_data_out，got_phase)；
 input clk，nrst，resync，u_symbol_in，uc_pilot_in，got_phase；
 input[11：0]ui_data_in，uq_data_in；
 output u_symbol_out，uc_pilot_out；
 output[11：0]ui_data_out，uq_data_out；
 reg u_symbol_out，uc_pilot_out，accept；
 wire u_symbol_o，uc_pilot_o；
 reg[11：0]ui_data_out，uq_data_out；
 wire[11：0]ui_data_o，uq_data_o；
 wire a，v；
				
				
wire[25：0]d；
wire in_valid＝u_symbol_in||uc_pilot_in；
wire rst＝！nrst||resync；
twowire26 tw1(.clk(clk)，.rst(rst)，.in_valid(in_valid)，.din({u_symbol_in，

　　 uc_pilot_in，ui_data_in，uq_data_in})，.out_accept(a)，

　　 .out_valid(v)，.in_accept()，.dout(d)，.set(1′b0))；
twowire26 tw2(.clk(clk)，.rst(rst)，.in_valid(v)，.din(d)，

　　.out_accept(accept)，.out_valid(out_valid)，.in_accept(a)，

　　.dout({u_symbol_o，uc_pilot_o，ui_data_o，uq_data_o})，

　　.set(1′b0))；
always @(u_symbol_o or uc_pilot_o or ui_data_o or uq_data_o or out_valid or
   accept)
begin
 if(out_valid && accept)
 begin
  u_symbol_out＝u_symbol_o；
  uc_pilot_out＝uc_pilot_o；
  ui_data_out＝ui_data_o；
  uq_data_out＝uq_data_o；
 end
 else
 begin
  u_symbol_out＝0；
  uc_pilot_out＝0；
  ui_data_out＝0；
  uq_data_out＝0；
 end
end
always @(posedge clk)
begin
 if(rst||got_phase)
  accept＜＝1；
 else if(uc_pilot_out)
  accept＜＝0；
 end
endmodule

                                      Listing 29

//Sccsld：％W％ ％G％
/**************************************************************
  Copyright(c)1997 Pioneer Digital Design Centre Limited
**************************************************************/
module divide(clk，go，numer，denom，answ，got)；
				
				
/**************************************************************************
 this divider is optimised on the principal that the answer will always be
 less than 1 -ie denom＞numer
*************************************************************************/
 input clk，go；
 input[10：0]numer，denom；
 output got；
 output[10：0]answ；
 reg got；
 reg[10：0]answ；
 reg[20：0]sub，internal；
 reg[3：0]dcount；
 always @(posedge clk)
 begin
  if(go)
  begin
   dcount＜＝0；
   internal＜＝numer＜＜10；
   sub＜＝denom＜＜9；
  end
  if(dcount＜11)
  begin
   if(internal＞sub)
   begin

　　internal＜＝internal-sub；

　　answ[10-dcount]＜＝1；
   end
   else
   begin

　　internal＜＝internal；

　　answ[10-dcount]＜＝0；
   end
   sub＜＝sub＞＞1；
   dcount＜＝dcount+1；
  end
  got＜＝(dcount＝＝10)；
 end
endmodule

                                     Listing 30

//Sccsld：％W％ ％G％
/**************************************************************
  Copyright(c)1997 Pioneer Digital Design Centre Limited
**************************************************************/
module fserr_str(clk，nrst，resync，u_symbol，uc_pilot，ui_data，uq_data，guard，
				
				
　　 freq_sweep，sr_sweep，lupdata，upaddr，upwstr，uprstr，upsel1，

　　 upsel2，ram_di，te，tdin，freq_err，samp_err，ram_rnw，

　　 ram_addr，ram_do，tdout)；
input clk，nrst，resync，u_symbol，uc_pilot，upwstr，uprstr，te，tdin，upsel1，
  upsel2；
input[1：0]guard；
input[3：0]freq_sweep，sr_sweep，upaddr；
input[11：0]ui_data，uq_data；
input[13：0]ram_do；
output ram_rnw，tdout；
output[9：0]ram_addr；
output[12：0]freq_err，samp_err；
output[13：0]ram_di；
inout[7：0]lupdata；
wire got_phase，en，load，symbol，u_symbol_buf，uc_pilot_buf；
wire freq_open，sample_open；
wire[1：0]guard_reg；
wire[10：0]xcount；
wire[11：0]ui_data_buf，uq_data_buf；
wire[13：0]phase_in，phase_out；
wire[20：0]acc_out_simple；
wire[29：0]acc_out_prod；
wire[12：0]freq_err_uf，samp_err_uf；
wire[12：0]freq_err_fil，samp_err_fil，freq_twiddle，

　　   sample_twiddle；
buffer buffer(.clk(clk)，.nrst(nrst)，.resync(resync)，.u_symbol_in(u_symbol)，

　　 .uc_pilot_in(uc_pilot)，.ui_data_in(ui_data)，

　　 .uq_data_in(uq_data)，.u_symbol_out(u_symbol_buf)，

　　 .uc_pilot_out(uc_pilot_buf)，.ui_data_out(ui_data_buf)，

　　 .uq_data_out(uq_data_buf)，.got_phase(got_phase))；
tan_taylor phase_extr(.clk(clk)，.nrst(nrst)，.resync(resync)，

　　    .uc_pilot(uc_pilot_buf)，.ui_data(ui_data_buf)，

　　    .uq_data(uq_data_buf)，.phase(phase_in)，

　　    .got_phase(got_phase))；
addr_gen addr_gen(.clk(clk)，.resync(resync)，.u_symbol(u_symbol_buf)，

　　  .uc_pilot(uc_pilot_buf)，.got_phase(got_phase)，.en(en)，

　　  .load(load)，.guard(guard)，.addr(ram_addr)，.xcount(xcount)，

　　  .guard_reg(guard_reg)，.symbol(symbol))；
pilot_store pilot_store(.clk(clk)，.en(en)，.ram_do(ram_do)，

　　     .phase_in(phase_in)，.ram_rnw(ram_rnw)，

　　     .ram_di(ram_di)，.phase_out(phase_out))；
acc_simple acc_simple(.clk(clk)，.resync(resync)，.load(load)，

　　   .symbol(symbol)，.new_phase(phase_in)，

　　   .old_phase(phase_out)，.acc_out(acc_out_simple))；
acc_prod acc_prod(.clk(clk)，.resync(resync)，.load(load)，

　　 .symbol(symbol)，.new_phase(phase_in)，

　　 .old_phase(phase_out)，.xcount(xcount)，
				
				
　　  .acc_out(acc_out_prod))；
slow_arith slow_arith(.acc_simple(acc_out_simple)，.acc_prod(acc_out_prod)，

　　   .guard(guard_reg)，.freq_err_uf(freq_err_uf)，

　　   .samp_err_uf(samp_err_uf))；
avg_8 #(14)
   lpf_freq(.clk(clk)，.resync(resync)，.symbol(symbol)，

　　  .in_data(freq_err_uf)，.avg_out(freq_err_fil))；
avg_8 #(14)
  lpf_samp(.clk(clk)，.resync(resync)，.symbol(symbol)，

　　 .in_data(samp_err_uf)，.avg_out(samp_err_fil))；
/*median_filter #(14)
   lpf_freq(.clk(clk)，.nrst(nrst)，.in_valid(symbol)，

　　   .din(freq_err_uf)，.dout(freq_err_fil))；
median_filter #(14)
  lpf_samp(.clk(clk)，.nrst(nrst)，.in_valid(symbol)，

　　 .din(samp_err_uf)，.dout(samp_err_fil))；    */
sweep_twiddle sweep_twiddle(.freq_err_fil(freq_err_fil)，

　　    .samp_err_fil(samp_err_fil)，

　　    .freq_sweep(freq_sweep)，

　　    .sr_sweep(sr_sweep)，.freq_open(freq_open)，

　　    .sample_open(sample_open)，

　　    .freq_twiddle(freq_twiddle)，

　　    .sample_twiddle(sample_twiddle)，

　　    .freq_err_out(freq_err)，

　　    .samp_err_out(samp_err))；
lupidec lupidec(.clk(clk)，.nrst(nrst)，.resync(resync)，.upaddr(upaddr)，

　　  .upwstr(upwstr)，.uprstr(uprstr)，.lupdata(lupdata)，

　　  .freq_open(freq_open)，.sample_open(sample_open)，

　　  .freq_twiddle(freq_twiddle)，.sample_twiddle(sample_twiddle)，

 　　 .sample_loop_bw()，.freq_loop_bw()，.freq_err(freq_err)，

　　  .samp_err(samp_err)，.f_err_update()，.s_err_update())；
endmodule

                                     Listing 31

//Sccsld：％W％ ％G％
/**************************************************************
  Copyright(c)1997 Pioneer Digital Design Centre Limited
**************************************************************/
module lupidec(clk，nrst，resync，upaddr，upwstr，uprstr，lupdata，freq_open，
   sample_open，freq_twiddle，sample_twiddle，sample_loop_bw，
   freq_loop_bw，freq_err，samp_err，f_err_update，
   s_err_update)；
input clk，nrst，resync，upwstr，uprstr，f_err_update，s_err_update；
				
				
input[3：0]upaddr；
input[12：0]freq_err，samp_err；
inout[7：0]lupdata；
output freq_open，sample_open；
output[12：0]freq_twiddle，sample_twiddle，sample_loop_bw， freq_loop_bw；
reg freq_open，sample_open；
reg[12：0]freq_twiddle，sample_twiddle，sample_loop_bw，freq_loop_bw；
wire wr_str；
wire[3：0]wr_addr；
wire[7：0]wr_data；
/*FOLDBEGINS 0 2″address decode″*/
 /*FOLDBEGINS 0 0″read decode″*/
 wire f_err_h_ren＝(upaddr＝＝4′he)；
 wire f_err_l_ren＝(upaddr＝＝4′hf)；
 wire s_err_h_ren＝(upaddr＝＝4′hc)；
 wire s_err_l_ren＝(upaddr＝＝4′hd)；
 wire f_twd_h_ren＝(upaddr＝＝4′h4)；
 wire f_twd_l_ren＝(upaddr＝＝4′h5)；
 wire s_twd_h_ren＝(upaddr＝＝4′h8)；
 wire s_twd_l_ren＝(upaddr＝＝4′h9)；
 wire f_lbw_h_ren＝(upaddr＝＝4′h6)；
 wire f_lbw_l_ren＝(upaddr＝＝4′h7)；
 wire s_ lbw_h_ren＝(upaddr＝＝4′ha)；
 wire s_lbw_l_ren＝(upaddr＝＝4′hb)；
 /*FOLDENDS*/
 /*FOLDBEGINS 0 0″write decode″*/
 wire f_twd_h_wen＝(wr_addr＝＝4′h4)；
 wire f_twd_l_wen＝(wr_addr＝＝4′h5)；
 wire s_twd_h_wen＝(wr_addr＝＝4′h8)；
 wire s_twd_l_wen＝(wr_addr＝＝4′h9)；
 wire f_lbw_h_wen＝(wr_addr＝＝4′h6)；
 wire f_lbw_l_wen＝(wr_addr＝＝4′h7)；
 wire s_lbw_h_wen＝(wr_addr＝＝4′ha)；
 wire s_lbw_l_wen＝(wr_addr＝＝4′hb)；
 /*FOLDENDS*/
 /*FOLDENDS*/
/*FOLDBEGINS 0 2″upi regs″*/
 /*FOLDBEGINS 0 0″freq error status reg″*/
 upi_status_reg2 fr_err(.clk(clk)，.nrst(nrst)，.status_value({3′b0，freq_err})，

　　     .capture_strobe(f_err_update)，.read_strobe(uprstr)，

　　     .reg_select_l(f_ err_l_ren)，.reg_select_h(f_err_h_ren)，

　　     .lupdata(lupdata))；
 /*FOLDENDS*/
 /*FOLDBEGINS 0 0″sample error status reg″*/
 upi_status_reg2 sr_err(.clk(clk)，.nrst(nrst)，.status_value({3′b0，samp_err})，

　　     .capture_strobe(s_err_update)，.read_strobe(uprstr)，

　　     .reg_select_l(s_err_l_ren)，.reg_select_h(s_err_h_ren)，

　　     .lupdata(lupdata))；
 /*FOLDENDS*/
				
				
/*FOLDBEGINS 0 0″control regs write latch″*/
upi_write_latch #(3)

　　write_lat(.clk(clk)，.nrst(nrst)，.lupdata(lupdata)，.upaddr(upaddr)，

　　    .write_strobe(upwstr)，.write_data(wr_data)，

　　    .write_address(wr_addr)，.write_sync(wr_str))；
/*FOLDENDS*/
/*FOLDBEGINS 0 0″freq twiddle etc rdbk regs″*/
upi_rdbk_reg freq_r_upper(.control_value({freq_open，2′b0，freq_twiddle[12：8]})，

　　    .read_strobe(uprstr)，.reg_select(f_twd_h_ren)，

　　    .lupdata(lupdata))；
upi_rdbk_reg freq_r_lower(.control_value(freq_twiddle[7：0])，.read_strobe(uprstr)，

　　    .reg_select(f_twd_l_ren)，.lupdata(lupdata))；
/*FOLDENDS*/
/*FOLDBEGINS 0 0″samp twiddle etc rdbk regs″*/
upi_rdbk_reg samp_r_upper(.control_value({sample_open，2′b0，
sample_twiddle[12：8]})，

　　    .read_strobe(uprstr)，.reg_select(s_twd_h_ren)，

　　    .lupdata(lupdata))；
upi_rdbk_reg samp_r_lower(.control_value(sample_twiddle[7：0])，
.read_strobe(uprstr)，

　　     .reg_select(s_twd_l_ren)，.lupdata(lupdata))；
 /*FOLDENDS*/
 /*FOLDBEGINS 0 0″freq loop bw rdbk regs″*/
 upi_rdbk_reg fr_lp_r_upper(.control_value({3′b0，freq_loop_bw[12：8]})，

　　     .read_strobe(uprstr)，.reg_select(f_lbw_h_ren)，

　　     .lupdata(lupdata))；
 upi_rdbk_reg fr_lp_r_lower(.control_value(freq_loop_bw[7：0])，

　　      .read_strobe(uprstr)；.reg_select(f_lbw_l_ren)，

　　     .lupdata(lupdata))；
 /*FOLDENDS*/
 /*FOLDBEGINS 0 0″samp loop bw rdbk regs″*/
 upi_rdbk_reg sr_lp_r_upper(.control_value({3′b0，sample_loop_bw[12：8]})，

　　     .read_strobe(uprstr)，.reg_select(s_lbw_h_ren)，

　　     .lupdata(lupdata))；
 upi_rdbk_reg sr_lp_r_lower(.control_value(sample_loop_bw[7：0])，

　　     .read_strobe(uprstr)，.reg_select(s_lbw_l_ren)，

　　     .lupdata(lupdata))；
 /*FOLDENDS*/
 /*FOLDENDS*/
/*FOLDBEGINS 0 2″control regs″*/
 always @(posedge clk)
 begin
  if(！nrst)
  begin
   freq_open＜＝0；
   sample_open＜＝0；
				
				
 freq_twiddle＜＝0；
 sample_twiddle＜＝0；
 sample_loop_bw＜＝0；//？？？？
 freq_loop_bw＜＝0；//？？？？
end
else
begin
 if(wr_str)
 begin
  if(f_twd_h_wen)
  begin
  freq_open＜＝wr_data[7]；
  freq_twiddle[12：8]＜＝wr_data[4：0]；
  end
  if(f_twd_l_wen)
   freq_twiddle[7：0]＜＝wr_data[7：0]；
  if(s_twd_h_wen)
  begin
   sample_open＜＝wr_data[7]；
   sample_twiddle[12：8]＜＝wr_data[4：0]；
  end
  if(s_twd_l_wen)
   sample_twiddle[7：0]＜＝wr_data[7：0]；
  if(f_lbw_h_wen)
   freq_loop_bw[12：8]＜＝wr_data[4：0]；
  if(f_lbw_l_wen)
   freq_loop_bw[7：0]＜＝wr_data[7：0]；
  if(s_lbw_h_wen)
   sample_loop_bw[12：8]＜＝wr_data[4：0]；
  if(s_lbw_l_wen)
   sample_loop_bw[7：0]＜＝wr_data[7：0]；
  end
 end
end
/*FOLDENDS*/
endmodule

                                     Listing 32

//Sccsld：％W％ ％G％
/**************************************************************
  Copyright(c)1997 Pioneer Digital Design Centre Limited
**************************************************************/
				
				
module pilot_store(clk，en，ram_do，phase_in，ram_rnw，ram_di，phase_out)；
 input clk，en；
 //input[9：0]addr；
 input[13：0]phase_in；
 input[13：0]ram_do；
 output ram_mw；
 output[13：0]ram_di，phase_out；
 wire ram_mw；
 //reg en_d1；
 //reg[9：0]addr_reg；
 //reg[13：0]mem[579：0]；
 reg[13：0]phase_out；//，phase_in_reg；
 wire[13：0]ram_di；
 always @(posedge clk)
 begin
  //en_d1＜＝en；
  if(en)
  begin
 //phase_in_reg＜＝phase_in；
 //addr_reg＜＝addr；
  phase_out＜＝ram_do；
 //phase_out＜＝mem[addr]；
  end
 //if(en_d1)
 //mem[addr_reg]＜＝phase_in_reg；
 end
 assign ram_di＝phase_in；
 assign ram_mw＝！en；
endmodule

                                      Listing 33

//Sccsld：％W％ ％G％
/***************************************************************
  Copyright(c)1997 Pioneer Digital Design Centre Limited
***************************************************************/
module slow_arith (acc_simple，acc_prod，guard，freq_err_uf，samp_err_uf)；
 input[1：0]guard；
 input[20：0]acc_simple；
 input[29：0]acc_prod；
 output[12：0]freq_err_uf，samp_err_uf；
 reg[12：0]freq_err_uf，samp_err_uf；
 reg[20：0]freq_scale；
 reg[38：0]inter_freq；
				
				
reg sign；
reg[20：0]mod_acc；
reg[38：0]mod_trunc_sat；
reg[41：0]mod；
reg sign_a sign_b，sign_inter_sr；
reg[20：0]mod_acc_s；
reg[29：0]mod_acc_p；
reg[35：0]a，mod_a；
reg[35：0]b，mod_b；
reg[36：0]mod_diff，diff；
reg[46：0]inter_sr，mod_inter_sr；
parameter sp＝45，acc_x＝33927，samp_scale＝11′b10100100110；
always @(guard)
 case(guard)
  2′b00：freq_scale＝21′b011110100111110001011；//guard＝＝64
  2′b01：freq_scale＝21′b011101101110001000011；//guard＝＝128
  2′b10：freq_scale＝21′b011100000100011101010；//guard＝＝256
  2′b11：freq_scale＝21′b011001010000110011111；//guard＝＝512
 endcase
always @(acc_simple or freq_scale)
begin
 sign＝acc_simple[20]；
 mod_acc＝sign？(～acc_simple+1)：acc_simple；
 mod＝(freq_scale * mod_acc)；
//inter_freq＝sign？(～mod+1)：mod；
 if(mod[41：38]＞0)
 begin
  mod_trunc_sat＝39′h3fffffffff，
  $display(″feq_err saturated″)；
 end
 else
  mod_trunc_sat＝mod[38：0]；
 inter_freq＝sign？(～mod_trunc_sat+1)：mod_trunc_sat；
 freq_err_uf＝inter_freq＞＞26；
end
always @(acc_simple or acc_prod)
begin
 sign_a＝acc_prod[29]；
 mod_acc_p＝sign_a？(～acc_prod+1)：acc_prod；
 mod_a＝sp * mod_acc_p；
 a＝sign_a？(～mod_a+1)：mod_a；
 sign_b＝acc_simple[20]；
 mod_acc_s＝sign_b？(～acc_simple+1)：acc_simple；
 mod_b＝acc_x * mod_acc_s；
				
				
 b＝sign_b？(～mod_b+1)：mod_b；
 diff＝{a[35]，a}-{b[35]，b}；//sign extend
 sign_inter_sr＝diff[36]；
 mod_diff＝sign_inter_sr？(～diff+1)：diff；
 mod_inter_sr＝(mod_diff * samp_scale)；
 inter_ sr＝sign_inter_sr？(～mod_inter_sr+1)：mod_inter_sr；
 samp_err_uf＝inter_sr＞＞34；//！！scaling！！
end
endmodule

                                      Listing 34

//Sccsld：％W％ ％G％
/***************************************************************
  Copyright(c)1997 Pioneer Digital Design Centre Limited
***************************************************************/
module sweep_twiddle(freq_err_fil，samp_err_fil，freq_sweep，sr_sweep，

　　  freq_open，sample_open，freq_twiddle，sample_twiddle，

　　  freq_err_out，samp_err_out)；
 input freq_open，sample_open；
 input[3：0]freq_sweep，sr_sweep；
 input[12：0]freq_err_fil，samp_err_fil，freq_twiddle，sample_twiddle；
 output[12：0]freq_err_out，samp_err_out；
 reg[12：0]freq_err_out，samp_err_out；
 reg[12：0]freq_err_swept，samp_err_swept；
 always @(freq_sweep or freq_err_fil)
 case(freq_sweep)
  4′b0000：freq_err_swept＝freq_err_fil；
  4′b0001：freq_err_swept＝freq_err_fil+500；
  4′b0010：freq_err_swept＝freq_err_fil+1000；
  4′b0011：freq_err_swept＝freq_err_fil+1500；
  4′b0100：freq_err_swept＝freq_err_fil+2000；
  4′b0101：freq_err_swept＝freq_err_fil+2500；
  4′b0110：freq_err_swept＝freq_err_fil+3000；
  4′b0111：freq_err_swept＝freq_err_fil+3500；
  default：freq_err_swept＝freq_err_fil；
 endcase
 always @(sr_sweep or samp_err_fil)
 case(sr_sweep)
  4′b0000：samp_err_swept＝samp_err_fil；
  4′b0001：samp_err_swept＝samp_err_fil+500；
  4′b0010：samp_err_swept＝samp_err_fil-500；
  4′b0011：samp_err_swept＝samp_err_fil+1000；
  4′b0100：samp_err_swept＝samp_err_fil-1000；
  4′b0101：samp_err_swept＝samp_err_fil+1500；
  4′b0110：samp_err_swept＝samp_err_fil-1500；
  4′b0111：samp_err_swept＝samp_err_fil+2000；
				
				
 4′b1000：samp_err_swept＝samp_err_fil-2000；
 default：samp_err_swept＝samp_err_fil；
endcase
always @(freq_err_swept or freq_open or freq_twiddle)
if(freq_open)
 freq_err_out＝freq_twiddle；
else
 freq_err_out＝freq_err_swept+freq_twiddle；
always @(samp_err_swept or sample_open or sample_twiddle)
if(sample_open)
 samp_err_out＝sample_twiddle；
else
 samp_err_out＝samp_err_swept+sample_twiddle；
endmodule

                                      Listing 35

//Sccsld：％W％ ％G％
/****************************************************************
  Copyright(c)1997 Pioneer Digital Design Centre Limited
****************************************************************/
module tan_taylor(clk，nrst，resync，uc_pilot，ui_data，uq_data，phase，

　　 got_phase)；
 input clk，nrst，resync，uc_pilot；
 input[11：0]ui_data，uq_data；
 output got_phase；
 output[13：0]phase；
 reg got_phase；
 reg[13：0]phase；
 reg add，qgti，modqeqi，i_zero_reg，q_zero_reg，go；
 reg[1：0]quadrant；
 reg[6：0]count，count_d1；
 reg[10：0]mod_i，mod_q，coeff，numer，denom；
 reg[21：0]x_sqd，x_pow，next_term，sum，flip，next_term_unshift，prev_sum，

　　x_sqd_unshift，x_pow_unshift；
 wire got；
 wire[10：0]div；
 parameter pi＝6434，pi_over2＝3217，minus_pi_o2＝13167，pi_over4＝1609；
 divide div1(clk，go，numer，denom，div，got)；
 always @(posedge clk)
 begin
  if(！nrst||resync)
  count＜＝7′b1111111；
				
				
else
begin
if(uc_pilot)
begin
 mod_i＜＝ui_data[11]？(～ui_data[10：0]+1)：ui_data[10：0]；
 mod_q＜＝uq_data[11]？(～uq_data[10：0]+1)：uq_data[10：0]；
 quadrant＜＝{uq_data[11]，ui_data[11]}；
 count＜＝0；
 go＜＝0；
end
else
begin
 if(count＝＝0)
 begin
  qgti＜＝(mod_q＞mod_i)；
  modqeqi＜＝(mod_q＝＝mod_i)；
  i_zero_reg＜＝(mod_i＝＝0)；
  q_zero_reg＜＝(mod_q＝＝0)；
  add＜＝0；
  go＜＝1；
  count＜＝1；
 end
 if((count＞＝3)&&(count＜71))
  count＜＝count+2；
 if(count＝＝1)
 begin
  go＜＝0；
  if(got)
  begin
   sum＜＝div；
   x_pow＜＝div；
   x_sqd＜＝x_sqd_unshift＞＞11；
   count＜＝3；
  end
 end
 if((count＞1)&&(count＜69))
  x_pow＜＝x_pow_unshift＞＞11；
 if((count＞3)&&(count＜69))
  next_term＜＝next_term_unshift＞＞12；
 if((count＞5)&&(count＜69))
 begin
  prev_sum＜＝sum；
  sum＜＝add？(sum+next_term)：(sum-next_term)；
  add＜＝！add；
 end
end
if(count＝＝67)
 sum＜＝(prev_sum+sum)＞＞1；
if(count＝＝69)
casex({i_zero_reg，q_zero_reg，qgti，modqeqi，quadrant})
 6′b1xx0_0x：phase＜＝pi_over2；
 6′b1xx0_1x：phase＜＝minus_pi_o2；
				
				
  6′b01x0_x0：phase＜＝0；
  6′b01x0_x1：phase＜＝pi；
  6′b0010_00：phase＜＝{2′b00，flip[11：0]}；
  6′b0010_01：phase＜＝pi-{2′b00，flip[11：0]}；
  6′b0010_10：phase＜＝0-{2′b00，flip[11：0]}；
  6′b0010_11：phase＜＝{2′b00，flip[11：0]}-pi；
  6′b0000_00：phase＜＝{2′b00，sum[11：0]}；
  6′b0000_01：phase＜＝pi-{2′b00，sum[11：0]}；
  6′b0000_10：phase＜＝0-{2′b00，sum[11：0]}；
  6′b0000_11：phase＜＝{2′b00，sum[11：0]}-pi；
  6′bxxx1_00：phase＜＝pi_over4；
  6′bxxx1_01：phase＜＝pi-pi_over4；
  6′bxxx1_10：phase＜＝0-pi_over4；
  6′bxxx1_11：phase＜＝pi_over4-pi；
  endcase
  count_d1＜＝count；
  got_phase＜＝(count＝＝69)；
 end
end
always @(div)
 x_sqd_unshift＝div * div；//had to do this in order to stop synthesis throwing away！
always @(x_pow or coeff)
 next_term_unshift＝(x_pow * coeff)；//compass dp_cell mult_booth_csum
always @(x_pow or x_sqd)
 x_pow_unshift＝(x_pow * x_sqd)；//compass dp_cell mult_booth_csum
always @(count_d1)
case(count_d1)
  3：coeff＝11′b10101010101；
  5：coeff＝11′b01100110011；
  7：coeff＝11′b01001001001；
  9：coeff＝11′b00111000111；
  11：coeff＝11′b00101110100；
  13：coeff＝11′b00100111011；
  15：coeff＝11′b00100010001；
  17：coeff＝11′b00011110001；
  19：coeff＝11′b00011010111；
  21：coeff＝11′b00011000011；
  23：coeff＝11′b00010110010；
  25：coeff＝11′b00010100011；
  27：coeff＝11′b00010010111；
  29：coeff＝11′b00010001101；
  31：coeff＝11′b00010000100；
  33：coeff＝11′b00001111100；
  35：coeff＝11′b00001110101；
  37：coeff＝11′b00001101110；
  39：coeff＝11′b00001101001；
  41：coeff＝11′b00001100100；
  43：coeff＝11′b00001011111；
				
   45：coeff＝11′b00001011011；
   47：coeff＝11′b00001010111；
   49：coeff＝11′b00001010011；
   51：coeff＝11′b00001010000；
   53：coeff＝11′b00001001101；
   55：coeff＝11′b00001001010；
   57：coeff＝11′b00001000111；
   59：coeff＝11′b00001000101；
   61：coeff＝11′b00001000011；
   63：coeff＝11′b00001000001；
  //65：coeff＝11′b00000111111；
  //67：coeff＝11′b00000111101；
  //69：coeff＝11′b00000111011；
  //71：coeff＝11′b00000111001；
  //73：coeff＝11′b00000111000；
  //75：coeff＝11′b00000110110；
  //77：coeff＝11′b00000110101；
 default：coeff＝11′bx；
endcase
always @(mod_q or mod_i or qgti)
begin
 numer＝qgti？mod_i：mod_q；
 dehom＝qgti？mod_q：mod_i；
end
 always @(sum)
 flip＝pi_over2-sum；
//always @(got)
//if(got)
//$display(″numer was ％d，denom was ％d，div then ％d″，numer，denom，div)；
//always @(count)
//if(count＜68)$display(″as far as x to the ％0d term，approx＝％d″，(count-6)，
sum)；
always @(got_phase)
 begin：display
 reg[13：0]real_phase；
  if(phase[13])
  begin
   real_phase＝(～phase+1)；
   if(got_phase)$display(″％t：got phase，phase＝-％0d″，$time，real_phase)；
  end
  else
  begin
   if(got_phase)$display(″％t：got phase，phase＝％0d″，$time，phase)；
  end
 end//display
endmodule

尽管本发明是参照这里描述的结构进行说明的，但是它并不限于这里给出的细节，本申请将覆盖所附权利要求书的范围内的任何变形和修改。

Claims (35)

1、一种用于多载波信号的数字接收机，包括：

放大器，接受模拟多载波信号，其中所述多载波信号包括具有符号周期T_S的数据符号流，其中该符号包括有效区间、保护区间、和两者之间的边界，所述保护区间是所述有效区间的部分复制；

模数转换器，耦合到所述放大器；

I/Q解调器，用于从所述模数转换器采样过的数据中恢复同相和正交分量；

自动增益控制电路，耦合到所述模数转换器，用于对所述放大器提供增益控制信号；

低通滤波器电路，从所述I/Q解调器接受I和Q数据，其中所述I和Q数据被进行抽取；

再采样电路，以第一速率接收所述抽取过的I和Q数据，并且以第二速率输出再采样过的I和Q数据；

FFT窗口同步电路，耦合到所述再采样电路，用于定位所述保护区间的边界；

实时流水线式FFT处理器，在操作上与所述FFT窗口同步电路关联，其中所述FFT处理器包括至少一级，所述级包括：

    复数系数乘法器；以及

    存储器，具有定义在其中的查找表，用于在所述复数系数乘法器

中将被乘数相乘，每个所述被乘数的值在所述查找表中是独一无二

的；以及

监视器电路，响应所述FFT窗口同步电路，用于检测预定事件，从而所述事件指示已经定位到有效符号和保护区间之间的边界。

2、如权利要求1所述的接收机，其中所述FFT窗口同步电路包括：

第一延迟单元，接受当前到达的再采样过的I和Q数据，并且输出延迟过的再采样过的I和Q数据；

减法器，用于产生代表所述当前到达的再采样过的I和Q数据、与所述延迟过的再采样过的I和Q数据之差的差值信号；

第一电路，用于产生具有单极量值的输出信号，该量值代表所述减法器的所述差值信号；

第二延迟单元，用于存储所述第一电路的所述输出信号；

第三延迟单元，接收所述第二延迟单元延迟过的输出；以及

第二电路，用于计算存储在所述第二延迟单元中的数据、和存储在所述第三延迟单元中的数据之间的统计关系，并且具有代表所述统计关系的输出。

3、如权利要求2所述的接收机，其中所述统计关系包括F比率。

4、如权利要求1所述的接收机，其中所述FFT处理器以8K模式操作。

5、如权利要求1所述的接收机，其中所述FFT处理器还包括用于所述存储器的定时发生器，所述地址发生器接受表示当前要求的被乘数的顺序关系的信号，并且输出所述存储器的地址，其中所述当前要求的被乘数被存储在所述存储器中。

6、如权利要求5所述的接收机，其中每个所述被乘数按照其相应的顺序关系被存储在所述查找表中，用于由所述复数系数乘法器进行乘法，所述被乘数的所述顺序关系定义增量序列，并且所述地址发生器包括：

累加器，用于存储所述地址发生器产生的前一地址；

用于计算所述当前要求的被乘数的增量值的电路；以及

加法器，用于将所述增量值加到所述前一地址上。

7、如权利要求6所述的接收机，其中所述查找表包括多个行，并且所述增量序列包括多个增量序列，所述被乘数被按照行的顺序存储，其中

在第一行中，第一增量序列是0；

在第二行中，第二增量序列是1；

在第三行中，第三增量序列的第一和第二断点B1、B2分别由下列关系决定： ${B1}_{M_N}=4^N{B1}_{M_N}-\underset{n=0}{\overset{N-1}{\mathrm{\&Sigma;}}}{4}^n$ ${B2}_{M_N}=\underset{n=0}{\overset{N}{\mathrm{\&Sigma;}}}{4}^n$ ；以及

在第四行中，第三增量序列的第三个断点B3由下列关系决定： ${B3}_{M_N}=2\&times;4^N+2$ 其中M_N表示所述FFT处理器的第N级的存储器。

8、如权利要求1所述的接收机，还包括信道估计和校正电路，该信道估计和校正电路包括：

导频定位电路，接收用于定位其中的导频载波的变换过的数字信号，该变换过的数字信号表示来自所述FFT处理器的帧，其中所述导频载波在所述变换过的数字信号的载波频谱上以间隔K分开，并且具有预定量值，所述导频定位电路包括：

第一电路，用于计算所述变换过的数字信号中的载波模K的阶数；

K个累加器，耦合到所述第二电路，用于累加所述变换过的数字信号中的所述载波的量值，所述累加过的量值定义一个组；以及

相关电路，用于将K组累加过的量值与所述预定量值进行相关，其中具有在所述K组的每组中模K计算出的位置的第一成员独特地从所述帧的开头位置偏移。

9、如权利要求8所述的接收机，其中所述导频定位电路还包括比特翻转电路，用于翻转所述变换过的数字信号的比特顺序。

10、如权利要求7所述的接收机，其中所述载波的所述量值和所述预定量值是幅度。

11、如权利要求7所述的接收机，其中所述载波的所述量值和所述预定量值是绝对值。

12、如权利要求7所述的接收机，其中所述相关电路还包括峰值跟踪电路，用于确定所述K组累加过的量值的第一峰值和第二峰值之间的间隔。

13、如权利要求7所述的接收机，其中所述信道估计和校正电路还包括：

内插滤波器，用于估计所述导频载波之间的信道响应；以及

乘法电路，用于将所述FFT处理器输出的数据载波乘以所述内插滤波器产生的校正系数。

14、如权利要求7所述的接收机，其中所述信道估计和校正电路还包括：

相位提取电路，从所述FFT处理器接受相位未校正的I和Q数据的数据流，并且产生代表所述未校正的数据的相位角的信号，所述相位提取电路包括累加器，该累加器用于累加连续的相位未校正的I和Q数据的相位角。

15、如权利要求14所述的接收机，所述信道估计和校正电路还包括：

自动频率控制电路，耦合到所述相位提取电路和所述累加器，它包括：

存储器，用于存储所述相位未校正的I和Q数据中携带的第一符号的累加过的共同相位误差；

其中所述累加器被耦合到所述存储器，并且累加第二符号中的多个导频载波的共同相位误差、和所述第一符号中的相应导频载波的共同相位误差之差；

所述累加器的输出被耦合到所述I/Q解调器。

16、如权利要求15所述的接收机，其中只在接收保护区间的过程中在所述I/Q解调器中允许所述累加器的所述被耦合的输出。

17、如权利要求14所述的接收机，所述信道估计和校正电路还包括耦合到所述相位提取电路的自动采样速率控制电路，包括：

存储器，用于存储所述相位未校正的I和Q数据中携带的第一符号中的导频载波的累加过的相位误差；

其中所述累加器被耦合到所述存储器，并且累加第二符号中的导频载波的相位误差、和所述第一符号中相应的导频载波的相位误差之差，以定义多个累加过的符号间载波相位误差差分，相位斜率由第一累加过的符号间载波相位差分、和第二累加过的符号间载波相位差分之差来定义；

所述累加器的输出被耦合到所述I/Q解调器。

18、如权利要求17所述的接收机，其中所述采样速率控制电路存储多个累加过的符号间载波相位误差差分，并且计算其间的最佳拟合线。

19、如权利要求17所述的接收机，其中只在接收保护区间的过程中在所述再采样电路中允许所述累加器的所述被耦合的输出信号。

20、如权利要求17所述的接收机，其中用于存储所述相位提取电路的输出的共用存储器被耦合到所述自动频率控制电路和所述自动采样速率控制电路。

21、如权利要求14所述的接收机，其中所述相位提取电路还包括：

流水线式电路，用于根据下列级数迭代地计算旋转角的反正切： ${\tan }^{-1}\left(x\right)=x-\frac{x^3}{3}+\frac{x^5}{5}-\frac{x^7}{7}+\frac{x^9}{9}-\&hellip;,\left|x\right|<1$ 其中x是所述相位未校正的I和Q数据的比率。

22、如权利要求21所述的接收机，其中所述流水线式电路包括：

常数系数乘法器；以及

多路复用器，用于选择所述级数的多个常数系数中的一个，所述多路复用器的一个输出被连接到所述常数系数乘法器的一个输出。

23、如权利要求21所述的接收机，其中所述流水线式电路包括：

乘法器；

第一存储器，用于存储数量x²，所述第一存储器被耦合到所述乘法器的第一输入端；

第二存储器，用于保持所述乘法器的输出；以及

所述第二存储器和所述乘法器的第二输入端之间的反馈连接。

24、如权利要求21所述的接收机，其中所述流水线式电路还包括：

第三存储器，用于存储所述级数的值；

控制电路，耦合到所述第三存储器，其中所述流水线式电路计算所述级数的N项，并且所述流水线式电路计算所述级数的N+1项，其中N是整数；

求平均电路，耦合到所述第三存储器，用于计算所述级数的所述N项和所述N+1项的平均。

25、如权利要求1所述的接收机，其中在所述多载波信号的导频载波中发送的数据根据代码产生多项式h(x)被进行BCH编码，还包括：

解调器，对所述BCH编码过的数据进行处理；

迭代流水线式BCH解码电路，包括：

    耦合到所述解调器的电路，用于形成所述多项式的Galois域，并

且用其计算多个校正子；

    多个存储寄存器，每个所述存储寄存器存储所述校正子中的相应

一个；

    多个反馈移位寄存器，每个所述反馈移位寄存器从所述存储寄存

器中的相应一个接受数据，并且具有输出；

    多个Galois域乘法器，每个所述乘法器被连接在反馈环中，该反

馈环穿过所述反馈移位寄存器中相应的一个，并且将其关联的反馈移

位寄存器的输出乘以所述Galois域的α值；

    输出Galois域乘法器，用于将所述反馈移位寄存器中的两个的所

述输出相乘；

    检错电路，连接到所述反馈移位寄存器和所述输出Galois域乘法

器，其中所述检错电路的输出信号指示数据的当前比特的差错；以及

反馈线，由所述检错电路允许，并且连接到所述存储寄存器，其

中所述反馈移位寄存器的输出被写入到所述存储寄存器。

26、如权利要求25所述的接收机，其中所述输出Galois域乘法器包括：

第一寄存器，初始地存储第一被乘数A；

常数系数乘法器，连接到所述寄存器，用于乘以值α，所述常数系数乘法器的输出被连接到所述第一寄存器，以定义第一反馈环，从而在时钟驱动的操作的第k个周期，所述第一寄存器包含Galois域积Aα^k；

第二寄存器，用于存储第二被乘数B；

“与”门，连接到所述第二寄存器，并且连接到所述常数系数乘法器的所述输出；

加法器，具有连接到所述“与”门的输出端的第一输入；

累加器，连接到所述加法器的第二输入端；其中所述加法器的输出被连接到所述累加器，以定义第二反馈环；从而由所述加法器输出Galois域积AB。

27、一种估计信道频率响应的方法，包括下列步骤：

从信道接收具有多个数据载波和散射导频载波的多载波信号，所述散射导频载波以第一间隔N分开，并且以不同于所述数据载波发送功率的功率发送；

将所述多载波信号转换为其数字表示；

对所述多载波信号的所述数字表示进行傅立叶变换，以产生变换过的数字信号；

翻转所述变换过的数字信号的比特顺序，以产生比特顺序翻转过的信号；

在N个累加器中循环累加所述比特顺序翻转过的信号中载波的量值；

将所述累加过的量值与所述散射导频载波的所述功率进行相关；

响应所述相关步骤，产生标识所述多载波信号的载波的同步信号。

28、如权利要求27所述的方法，其中所述累加量值的步骤包括下列步骤：

将所述比特顺序翻转过的信号的实部分量的绝对值加到其虚部分量的相应绝对值上，以产生各总和；

分别将所述各总和存储到所述各累加器中。

29、如权利要求27所述的方法，其中所述对所述累加过的量值进行相关的步骤还包括下列步骤：

标识第一累加器，该第一累加器中存储有表示第一载波位置的最高值。

30、如权利要求29所述的方法，其中所述对所述累加过的量值进行相关的步骤还包括下列步骤：

标识第二累加器，该第二累加器中存储有标识第二载波位置的次最高值；以及

确定所述第一载波位置和所述第二载波位置之间的间隔。

31、如权利要求27所述的方法，还包括下列步骤：

将所述比特顺序翻转过的信号中的第一符号的载波位置、与其中的第二符号的载波位置进行比较。

32、如权利要求27所述的方法，还包括下列步骤：

在各导频载波之间进行内插，以确定位于其之间的相应中间数据载波的校正因子；以及

根据所述校正因子，分别调整所述中间数据载波的量值。

33、如权利要求27所述的方法，还包括下列步骤：

确定所述变换过的数字信号中被发送的各连续符号的各相应导频载波之间的平均相位差；以及

响应所述平均相位差，产生第一控制信号；以及

响应所述第一控制信号，调整所述多载波信号的接收频率。

34、如权利要求33所述的方法，还包括下列步骤：

确定所述被发送的数据载波中的第一符号的第一数据载波、和其中的第二符号的所述第一数据载波之间的第一相位差；

确定所述第一符号的第二数据载波、和所述第二符号的所述第二数据载波之间的第二相位差；以及

确定所述第一相位差和所述第二相位差之差，以定义所述第一数据载波和所述第二数据载波之间的相位斜率；

响应所述相位斜率，产生第二控制信号；以及

响应所述第二控制信号，调整所述多载波信号的采样频率。

35、如权利要求34所述的方法，其中所述确定所述第一相位差和所述第二相位差之差的步骤包括计算最佳拟合线。

Images