2维FFT的FPGA实现_vivado有没有二维傅里叶变换吗资源-CSDN文库

共316个文件

didat：56个

c：38个

obj：38个

FPGA

2维FFT

5星 · 超过95%的资源需积分: 48 81 浏览量 2014-02-17 21:03:27 上传评论 26 收藏 8.76MB ZIP 举报

二维快速傅里叶变换（2维FFT）是数字信号处理中的关键算法，广泛应用于图像处理、频谱分析、通信系统等多个领域。在FPGA（Field-Programmable Gate Array）上实现2维FFT，可以充分利用硬件并行性，提高运算速度，降低延迟，这对于实时处理大量数据的应用尤其重要。我们需要理解FFT的基本原理。快速傅里叶变换是一种高效的计算离散傅里叶变换（DFT）的方法，通过分治策略将计算量从O(N^2)降低到O(NlogN)。在2维FFT中，我们对每个输入矩阵的行和列分别进行1维FFT，然后通过适当的复数乘法和排列组合得到最终结果。在FPGA实现2维FFT时，通常会采用以下步骤： 1. **预处理**：数据排列成适合并行处理的格式，如Bit-reversal重排。这一步是在FPGA内部完成，目的是优化数据流，减少内存访问的复杂性。 2. **1维FFT模块**：设计和实现1维FFT单元，这可以是蝶形结构，通过级联多个较小的FFT核来处理大尺寸的数据。每个FFT核负责一部分数据的变换。 3. **并行处理**：由于FPGA的并行特性，可以在同一时间处理多行或多列数据，从而极大地加速了计算过程。根据FPGA资源和需求，可以选择全并行或部分并行的方式。 4. **复数乘法**：2维FFT中涉及大量的复数乘法，FPGA可以通过硬逻辑乘法器或可配置逻辑实现这些操作，以获得高速度。 5. **后处理**：包括旋转因子的乘法和对结果的进一步排列，以获取正确的2维频谱。 Xilinx FPGA因其灵活性和高性能而被选为2维FFT实现的平台。Xilinx的VHDL或Verilog工具链允许设计者精确控制硬件逻辑，同时，IP核库提供了预构建的FFT模块，可以快速集成到设计中。提到的testbench代码是验证FPGA实现的关键部分。Testbench模拟了输入数据，并检查输出是否与期望的MATLAB仿真结果一致。MATLAB仿真通常作为 golden reference，确保FPGA实现的正确性和精度。文件"20140217"可能是包含源代码、仿真结果或其他相关资料的日期标记文件。为了深入理解并复现这个项目，需要查看这些文件的内容，包括硬件描述语言（VHDL或Verilog）代码、测试激励文件以及可能的MATLAB脚本。 2维FFT的FPGA实现涉及到数字信号处理理论、硬件描述语言编程和仿真验证等多个方面，是FPGA设计的一个重要实例，对于学习和掌握FPGA应用具有很高的价值。通过这样的实践，不仅可以提升数字信号处理的技能，还能深入了解FPGA的并行处理能力及其在实际问题中的应用。

资源推荐

资源详情

资源评论

收起资源包目录

2维FFT的FPGA实现（316个子文件）

_1 8.05MB

fft16.asy 1KB

fifo_i64_o64.asy 1KB

ram64.asy 779B

implement_synplify.bat 3KB

implement.bat 3KB

simulate_ncsim.bat 3KB

simulate_isim.bat 3KB

simulate_vcs.bat 3KB

simulate_isim.bat 3KB

simulate_vcs.bat 3KB

simulate_isim.bat 3KB

planAhead_ise.bat 3KB

simulate_mti.bat 2KB

implement.bat 1KB

simulate_mti.bat 114B

m_00000000001037948890_0769242303.c 4.22MB

m_00000000003277718179_0571924876.c 922KB

m_00000000003277718179_0068134981.c 922KB

m_00000000003277718179_0525069997.c 922KB

m_00000000003277718179_4116158594.c 922KB

m_00000000001132708225_2596337637.c 464KB

m_00000000001780117803_2513253454.c 371KB

m_00000000002198664114_3825300825.c 301KB

m_00000000001347610518_1484263714.c 148KB

m_00000000003864230214_3890139102.c 95KB

m_00000000001784029001_3082820122.c 62KB

m_00000000001108370118_3277662444.c 57KB

m_00000000001773747898_2336946039.c 47KB

m_00000000001291582275_4137523035.c 40KB

m_00000000000674169006_2548851385.c 30KB

m_00000000001358910285_2042290304.c 30KB

m_00000000001358910285_1246041523.c 30KB

m_00000000004221170615_0679316750.c 19KB

m_00000000003835799563_1852623124.c 18KB

m_00000000001155118101_3330347818.c 16KB

m_00000000001603977570_0549690308.c 14KB

m_00000000000608754652_3931052239.c 13KB

m_00000000000905158087_1335204964.c 13KB

m_00000000002601448656_3367321443.c 12KB

m_00000000000129024098_1730278898.c 8KB

m_00000000004134447467_2073120511.c 8KB

m_00000000003405408344_3841093685.c 7KB

m_00000000002444920515_2091797430.c 7KB

m_00000000001508379050_3852734344.c 6KB

fft2d_0214_isim_beh.exe_main.c 4KB

m_00000000003848737514_1058825862.c 2KB

m_00000000003927721830_1593237687.c 2KB

m_00000000003317509437_1759035934.c 2KB

m_00000000001687936702_2953301624.c 2KB

m_00000000000909115699_2771340377.c 2KB

m_00000000000236260522_2449448540.c 2KB

m_00000000003242318736_3661165077.c 1KB

m_00000000003102318674_0550473994.c 1KB

coregen.cgp 239B

fuseRelaunch.cmd 232B

isim.cmd 45B

netId.dat 92B

ISimEngine-DesignHierarchy.dbg 14.24MB

m_00000000001132708225_2596337637.didat 4.87MB

m_00000000001037948890_0769242303.didat 65KB

m_00000000001291582275_4137523035.didat 61KB

m_00000000003277718179_4116158594.didat 35KB

m_00000000003277718179_0571924876.didat 35KB

m_00000000003277718179_0525069997.didat 35KB

m_00000000003277718179_0068134981.didat 35KB

m_00000000003864230214_3890139102.didat 33KB

m_00000000001780117803_2513253454.didat 32KB

m_00000000003242318736_3661165077.didat 29KB

m_00000000002198664114_3825300825.didat 27KB

m_00000000003835799563_1852623124.didat 25KB

m_00000000001603977570_0549690308.didat 20KB

m_00000000000674169006_2548851385.didat 19KB

m_00000000003102318674_0550473994.didat 9KB

m_00000000001358910285_2042290304.didat 6KB

m_00000000001358910285_1246041523.didat 6KB

m_00000000004134447467_2073120511.didat 5KB

m_00000000004221170615_0679316750.didat 5KB

m_00000000001687936702_2953301624.didat 4KB

m_00000000000608754652_3931052239.didat 4KB

m_00000000002601448656_3367321443.didat 4KB

m_00000000001155118101_3330347818.didat 4KB

m_00000000000129024098_1730278898.didat 4KB

m_00000000003405408344_3841093685.didat 3KB

m_00000000001347610518_1484263714.didat 3KB

m_00000000001347610518_0590943574.didat 3KB

m_00000000001508379050_3852734344.didat 3KB

m_00000000001508379050_0372621018.didat 3KB

m_00000000000905158087_1335204964.didat 3KB

m_00000000001784029001_3082820122.didat 3KB

m_00000000001784029001_2507684592.didat 3KB

m_00000000001784029001_0776177928.didat 3KB

m_00000000001784029001_2024903922.didat 3KB

m_00000000001784029001_2833516221.didat 3KB

m_00000000001784029001_2804875123.didat 3KB

共 316 条

DS260 March 1, 2011 www.xilinx.com 1

Product Specification

United States and other countries. MATLAB is a registered trademark of The MathWorks, Inc. All other trademarks are the property of their respective owners.

Introduction

The Xilinx LogiCORE™ IP Fast Fourier Transform

(FFT) implements the Cooley-Tukey FFT algorithm, a

computationally efficient method for calculating the

Discrete Fourier Transform (DFT).

Features

• Drop-in module for Kintex™-7, Virtex

-7, Virtex®-6,

Virtex-5, Virtex-4, Spartan®-6, Spartan-3/XA,

Spartan-3E/XA and Spartan-3A/XA/AN/3A DSP

FPGAs

• Forward and inverse complex FFT, run-time

configurable

• Transform sizes N = 2

, m = 3 – 16

• Data sample precision b

= 8 – 34

• Phase factor precision b

= 8 – 34

• Arithmetic types:

¨ Unscaled (full-precision) fixed-point

¨ Scaled fixed-point

¨ Block floating-point

• Fixed-point or floating-point interface

• Rounding or truncation after the butterfly

• Block RAM or Distributed RAM for data and

phase-factor storage

• Optional run-time configurable transform point

size

• Run-time configurable scaling schedule for scaled

fixed-point cores

• Bit/digit reversed or natural output order

• Optional cyclic prefix insertion for digital

communications systems

• Four architectures offer a trade-off between core

size and transform time

• Bit-accurate C model and MEX function for system

modeling available for download

• For use with Xilinx CORE Generator™ software

and Xilinx System Generator for DSP v13.1

LogiCORE IP

Fast Fourier Transform v7.1

DS260 March 1, 2011 Product Specification

LogiCORE IP Facts Table

Core Specifics

Supported

Device Family

(1)

1. For a complete listing of supported devices, see the release notes

for this core.

Virtex-7 and Kintex-7,

Virtex-6, Virtex-5, Virtex-4,

Spartan-6, Spartan-3/XA, Spartan-3E/XA,

Spartan-3A/3AN/3A DSP/XA

Supported User

Interfaces

Not Applicable

Resources

(2)

2. Resources listed here are for Virtex-6 devices. For more complete

device performance numbers, see Table 7-Table 10.

Frequency

Configuration LUTs FFs

DSP

Slices

Block

RAMs

(3)

3. Based on 18K block RAMs.

Max.

Freq.

(4)

4. Performance numbers listed are for Virtex-6 FPGAs. For more

complete performance data, see Table 7-Table 10.

Radix-2,

2048-point,

variable point

size, 16-bit

data/phase

factors, scaled,

convergent

rounding

1092 1265 3 5 395 MHz

Provided with Core

Documentation

Product Specification

Design Files Netlist

Example Design Not Provided

Test Bench Not Provided

Constraints File Not Applicable

Simulation

Model

VHDL behavioral model in the xilinxcorelib library

VHDL UniSim structural model

Verilog UniSim structural model

Tested Design Tools

Design Entry

Tools

CORE Generator tool 13.1

System Generator for DSP 13.1

Simulation

Mentor Graphics ModelSim 6.6d

Cadence Incisive Enterprise Simulator (IES) 10.2

Synopsys VCS and VCS MX 2010.06

ISIM 13.1

Synthesis Tools N/A

Support

Provided by Xilinx, Inc.

DS260 March 1, 2011 www.xilinx.com 2

Product Specification

LogiCORE IP Fast Fourier Transform v7.1

Overview

The FFT core computes an N-point forward DFT or inverse DFT (IDFT) where N can be 2

, m = 3–16.

For fixed-point inputs, the input data is a vector of N complex values represented as dual b

-bit two’s-complement

numbers, that is, b

bits for each of the real and imaginary components of the data sample, where b

is in the range

8 to 34 bits inclusive. Similarly, the phase factors b

can be 8 to 34 bits wide.

For single-precision floating-point inputs, the input data is a vector of N complex values represented as dual 32-bit

floating-point numbers with the phase factors represented as 24- or 25-bit fixed-point numbers.

All memory is on-chip using either block RAM or distributed RAM. The N element output vector is represented

using b

bits for each of the real and imaginary components of the output data. Input data is presented in natural

order and the output data can be in either natural or bit/digit reversed order. The complex nature of data input and

output is intrinsic to the FFT algorithm, not the implementation.

Three arithmetic options are available for computing the FFT:

• Full-precision unscaled arithmetic

• Scaled fixed-point, where the user provides the scaling schedule

• Block floating-point (run-time adjusted scaling)

The point size N, the choice of forward or inverse transform, the scaling schedule and the cyclic prefix length are

run-time configurable. Transform type (forward or inverse), scaling schedule and cyclic prefix length can be

changed on a frame-by-frame basis. Changing the point size resets the core.

Four architecture options are available: Pipelined, Streaming I/O, Radix-4, Burst I/O, Radix-2, Burst I/O, and

Radix-2 Lite, Burst I/O. For detailed information about each architecture, see "Architecture Options."

Theory of Operation

The FFT is a computationally efficient algorithm for computing a Discrete Fourier Transform (DFT) of sample sizes

that are a positive integer power of 2. The DFT of a sequence is defined as

Equation 1

where N is the transform size and . The inverse DFT (IDFT) is given by

Equation 2

Algorithm

The FFT core uses the Radix-4 and Radix-2 decompositions for computing the DFT. For Burst I/O architectures, the

decimation-in-time (DIT) method is used, while the decimation-in-frequency (DIF) method is used for the Pipe-

lined, Streaming I/O architecture. When using Radix-4 decomposition, the N-point FFT consists of log

(N) stages,

with each stage containing N/4 Radix-4 butterflies. Point sizes that are not a power of 4 need an extra Radix-2 stage

for combining data. An N-point FFT using Radix-2 decomposition has log

(N) stages, with each stage containing

N/2 Radix-2 butterflies.

The inverse FFT (IFFT) is computed by conjugating the phase factors of the corresponding forward FFT.

(), 0, , 1Xk k N=−K

(), 0, , 1xn n N=−K

() () 0, , 1

jnk N

Xk xne k N

−

==−

∑

1j =−

() () 0, , 1

jnk N

xn Xke n N

−

==−

∑

DS260 March 1, 2011 www.xilinx.com 3

Product Specification

LogiCORE IP Fast Fourier Transform v7.1

Finite Word Length Considerations

The Burst I/O architectures process an array of data by successive passes over the input data array. On each pass,

the algorithm performs Radix-4 or Radix-2 butterflies, where each butterfly picks up four or two complex numbers,

respectively, and returns four or two complex numbers to the same memory. The numbers returned to memory by

the core are potentially larger than the numbers picked up from memory. A strategy must be employed to accom-

modate this dynamic range expansion. A full explanation of scaling strategies and their implications is beyond the

scope of this document; for more information about this topic; see [Ref 1] and [Ref 2].

For a Radix-4 DIT FFT, the values computed in a butterfly stage can experience growth by a factor of up to

. This implies a bit growth of up to 3 bits.

For Radix-2, the growth is by a factor of up to . This implies a bit growth of up to 2 bits. This bit

growth can be handled in three ways:

• Performing the calculations with no scaling and carrying all significant integer bits to the end of the

computation

• Scaling at each stage using a fixed-scaling schedule

• Scaling automatically using block floating-point

All significant integer bits are retained when using full-precision unscaled arithmetic. The width of the data path

increases to accommodate the bit growth through the butterfly. The growth of the fractional bits created from the

multiplication are truncated (or rounded) after the multiplication. The width of the output is (input width +

log

(transform length) + 1). This accommodates the worst case scenario for bit growth.

Consider an unscaled Radix-2 DIT FFT: the data path in each stage must grow by 1 bit as the adder and subtractor

in the butterfly may add/subtract two full-scale values and produce a sample which has grown in width by 1 bit.

This yields the log

(transform length) part of the increase in the output width relative to the input width. The com-

plex multiplier preserves the magnitude of an input (as it applies a rotation on the complex plane), but can theoret-

ically produce bit-growth when the magnitude of the input is greater than 1 (for example, 1+j has a magnitude of

1.414). This means that the complex multiplier bit growth must only be considered once in the entire FFT process,

yielding the additional +1 increase in the output width relative to the input width. For example, a 1024-point trans-

form with an input of 16 bits consisting of 1 integer bit and 15 fractional bits has an output of 27 bits with 12 integer

bits and 15 fractional bits. Note that the core does not have a specific location for the binary point. The output sim-

ply maintains the same binary point location as the input. For the preceding example, a 16 bit input with 3 integer

bits and 13 fractional bits would have an unscaled output of 27 bits with 14 integer bits and 13 fractional bits.

When using scaling, a scaling schedule is used to divide by a factor of 1, 2, 4, or 8 in each stage. If scaling is insuffi-

cient, a butterfly output may grow beyond the dynamic range and cause an overflow. As a result of the scaling

applied in the FFT implementation, the transform computed is a scaled transform. The scale factor s is defined as

Equation 3

where b

is the scaling (specified in bits) applied in stage i.

The scaling results in the final output sequence being modified by the factor 1/s. For the forward FFT, the output

sequence X’ (k), k = 0,...,N - 1 computed by the core is defined as

Equation 4

132 5.242≈+

122.414+≈

log 1

−

∑

'2/

() () () 0, , 1

jnk N

Xk Xk xne k N

−

== =−

∑

DS260 March 1, 2011 www.xilinx.com 4

Product Specification

LogiCORE IP Fast Fourier Transform v7.1

For the inverse FFT, the output sequence is

Equation 5

If a Radix-4 algorithm scales by a factor of 4 in each stage, the factor of 1/s is equal to the factor of 1/N in the inverse

FFT equation (Equation 2). For Radix-2, scaling by a factor of 2 in each stage provides the factor of 1/N.

With block floating-point, each stage applies sufficient scaling to keep numbers in range, and the scaling is tracked

by a block exponent.

As with unscaled arithmetic, for scaled and block floating-point arithmetic, the core does not have a specific loca-

tion for the binary point. The location of the binary point in the output data is inherited from the input data and

then shifted by the scaling applied.

Floating-Point Considerations

The FFT core optionally accepts data in IEEE-754 single-precision format with 32-bit words consisting of a 1-bit

sign, 8-bit exponent, and 23-bit fraction. The construction of the word matches that of the

Xilinx Floating-Point Operator core.

Implementing full floating-point on an FPGA can be expensive in terms of the resources required. The float-

ing-point option in the Xilinx FFT core utilizes a higher precision fixed-point FFT internally to achieve similar noise

performance to a full floating-point FFT, with significantly fewer resources. Figure 1 illustrates the two levels of

noise performance possible by selecting either 24 bits or 25 bits for the phase factor width. By increasing the phase

factor width to 25 bits, more resources may be required, depending on the target FPGA device.

X-Ref Target - Figure 1

Figure 1: Comparison of Two Levels of Noise Performance

() () 0, , 1

jnk N

xn X ke n N

−

==−

∑

DS260 March 1, 2011 www.xilinx.com 5

Product Specification

LogiCORE IP Fast Fourier Transform v7.1

Figure 1 shows the ratio of the RMS difference between various models and the double-precision MATLAB® FFT to

the data set peak amplitude. The models shown are the single-precision MATLAB FFT function (calculated by

casting the input data to single-precision floating-point type), the Xilinx FFT core using a 24-bit phase factor width,

and the Xilinx FFT core using a 25-bit phase factor width. To calculate the error signal, a randomized impulse (in

magnitude and time) was used as the input signal, with the RMS error averaged over five simulation runs.

All optimization options (memory types and XtremeDSP™ slice optimization) remain available when float-

ing-point input data is selected, allowing the user to trade off resources with transform time.

Transform time for Burst I/O architectures is increased by approximately N, the number of points in the transform,

due to the input normalization requirements. For the Pipelined, Streaming I/O architecture, the initial latency to fill

the pipeline is increased, but data still streams through the core with no gaps.

Denormalized Numbers

The floating-point interface to the FFT core does not support denormalized numbers. To match the behavior of the

Xilinx Floating-Point Operator core, the core treats denormalized operands as zero, with a sign taken from the

denormalized number.

NaNs and ± Infinity

If the core detects a NaN or ± Infinity value on the input, all output samples associated with the current input frame

are set to NaN. The sign bit is set to zero and all exponent and fraction bits are set to 1.

Real-Valued Input Data

The FFT core accepts complex data samples, but can perform a transform on real-valued data by setting all imagi-

nary input samples to zero.

Due to the finite wordlength effects described previously, noise is introduced during the transform, resulting in the

output data not being perfectly symmetric. The DIT and DIF FFT algorithms have different noise effects due to the

different calculation order.

For a thorough treatment of this topic, see [Ref 3] and [Ref 4].

The asymmetry between the two halves of the result is more noticeable at larger point sizes. In addition, the noise

is more prominent in the lower frequency bins. Therefore, Xilinx recommends that the upper half (N/2+1 to N

points) of the output data is used when performing a real-valued FFT.

Rounding Implementation

An option is available, in all architectures, to apply convergent rounding to the data after the butterfly stage. How-

ever, selecting this option does not apply convergent rounding to all points in the data path where wordlength

reduction occurs.

In particular, the outputs of all complex multipliers in the FFT data path are truncated to reduce data path width

(while still maintaining adequate precision) and a simple rounding constant added to the fractional bits. This con-

stant implements non-symmetric, round-towards-minus-infinity rounding, and can introduce a small bias to the

FFT results over a large number of samples.

评论收藏

内容反馈

zl201110

2014-03-11

很好，挺有用的
zcf287

2015-11-03

挺好的，对应博客，学习了
yj391016

2017-10-23

看看吧，不知道对不对
普通网友

2015-09-10

ASDSDASD第三方斯蒂芬
whenli

2014-04-04

很好，对于信号分析非常实用。

前往

页

兔美酱xz

粉丝: 265
资源: 3

2维FFT的FPGA实现

基于FPGA的二维FFT实现

FPGA实现FFT

FFT算法的一种FPGA实现

基于FPGA的 FFT实现

基于fpga快速傅里叶变换（FFT）的IP核设计（含程序）

图像二维FFT

FPGA实现FFT (设计报告+源代码)

FFT核调用实现及Verilog HDL 版本的testbench.v文件

FFT浮点运算的FPGA实现（源代码）

FFT的FPGA实现

用FPGA实现FFT算法

FPGA实现FFT算法

vga的fpga实现

FFT处理器的FPGA设计

fpga pal实现

基于FPGA的高速fft运算

实数二维FFT及其改进算法的FPGA实现.pdf

利用FPGA实现的FFT变换设计.pdf

基于FPGA的快速并行FFT及应用

fpga FFT算法论文

FFT的FPGA实现（源代码）

用FPGA实现FFT，强大的VHDL源程序（附详细过程及原理说明）

基于单比特和近似核FFT的瞬时测频算法及FPGA实现_袁俊榆.caj

利用自编一维FFT实现二维FFT的matlab程序

最新资源