Subversion Repositories dblclockfft

\documentclass{gqtekspec}

\project{Double Clocked FFT}

\title{Specification}

\author{Dan Gisselquist, Ph.D.}

\email{dgisselq\at opencores.org}

\revision{Rev.~0.1}

\begin{document}

\pagestyle{gqtekspecplain}

\titlepage

\begin{license}

Copyright (C) \theyear\today, Gisselquist Technology, LLC

This project is free software (firmware): you can redistribute it and/or

modify it under the terms of  the GNU General Public License as published

by the Free Software Foundation, either version 3 of the License, or (at

your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT

ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License along

with this program.  If not, see \hbox{<http://www.gnu.org/licenses/>} for a copy.

\end{license}

\begin{revisionhistory}

0.1 & 3/3/2015 & Gisselquist & First Draft \\\hline

\end{revisionhistory}

% Revision History

% Table of Contents, named Contents

\tableofcontents

\listoffigures

\listoftables

\begin{preface}

This FFT comes from my attempts to design and implement a signal processing

algorithm inside a generic FPGA, but only on a limited budget.  As such,

I don't yet have the FPGA board I wish to place this algorithm onto, neither

do I have any expensive modeling or simulation capabilities.  I'm using

Verilator for my modeling and simulation needs.  This makes

using a vendor supplied IP core, such as an FFT, difficult if not impossible

to use.

My problem was made worse when I learned that the published maximum clock

speed for a device wasn't necessarily the maximum clock speed that I could

achieve.  My design needed to process the incoming signal at 500~MHz to be

commercially viable.  500~MHz is not necessarily a clock speed

that can be easily achieved.  250~MHz, on the other hand, is much more within

the realm of possibility.  Achieving a 500~MHz performance with a 250~MHz

clock, however, requires an FFT that accepts two samples per clock.

This, then, was and is the genesis of this project.

\end{preface}

\chapter{Introduction}

\pagenumbering{arabic}

\setcounter{page}{1}

The Double Clocked FFT project contains all of the software necessary to

create the IP to generate an arbitrary sized FFT that will clock two samples

in at each clock cycle, and after some pipeline delay it will clock two

samples out at every clock cycle.

The FFT generated by this approach is very configurable.  By simple adjustment

of a command line parameter, the FFT may be made to be a forward FFT or an

inverse FFT.  The number of bits processed, kept, and maintained by this

FFT are also configurable.  Even the number of bits used for the twiddle

factors, or whether or not to bit reverse the outputs, are all configurable

parts to this FFT core.

These features make the Double Clocked FFT very different and unique among the

other cores available on opencores.com.

For those who wish to get started right away, please download the package,

change into the {\tt sw} directory and run {\tt make}.  There is no need to

run a configure script, {\tt fftgen} is completely portable C++.  Then, once

built, go ahead and run {\tt fftgen} without any arguments.  This will cause

{\tt fftgen} to print a usage statement to the screen.  Review the usage

statement, and run {\tt fftgen} a second time with the arguments you need.

\chapter{Generation}

Creating a double clocked FFT core is as simple as running the program

{\tt fftgen}.  The program will then create a series of Verilog files, as

well as {\tt .hex} files suitable for use with a \textdollar readmemh, and

place them into an {\tt ./fft-core/} directory that {\tt fftgen} will create.

Creating the core you want takes a touch of configuring.

Therefore, the following lists the arguments that can be given to

{\tt fftgen} to adjust the core that it builds:

\begin{itemize}

\item[\hbox{-f size}]

        This specifies the size of the FFT core that {\tt fftgen} will build.

        The size must be a power of two.  The transform is given, within a

        scale factor, to,

        \begin{eqnarray*}

        X\left[k\right] &=& \sum_{n=0}^{N-1} x\left[n\right]

                e^{-j2\pi \frac{k}{N}n}

        \end{eqnarray*}

\item[\hbox{-1}]

        This specifies that the FFT will be an inverse FFT.  Specifically,

        it will calculate,

        \begin{eqnarray*}

        x\left[n\right] &=& \sum_{k=0}^{N-1} X\left[k\right] e^{j2\pi \frac{k}{N}n}

        \end{eqnarray*}

\item[\hbox{-0}]

        This specifies building a forward FFT.  However, since this is the

        default, this option never necessary.

\item[\hbox{-s}]

        This causes the core to skip the final bit reversal stage.  The

        outputs of the FFT will then come out in bit reversed order.

        This option is useful in those cases where someone wishes to

        multiply the coefficients coming out of an FFT by some product,

        and then to inverse FFT the results.  If the coefficients are also

        applied in bit--reversed order, then both the FFT and IFFT may

        skip their bit reversals.

\item[\hbox{-S}]

        Include the final bit reversal stage.  As this is also the default,

        specifying the option should not be necessary.

\item[\hbox{-d DIR}]

        Specifies the DIRectory to place the produced Verilog files.  By

        default, this will be in the `./fft-core/' directory, but it can

        be moved to any other directory as necessary.

\item[\hbox{-n bits}] Sets the number of input bits per sample.  Given this

        setting, each of the two samples clocked in at every clock cycle

        will have this many bits for their real portion, and again this many

        bits for their imaginary portion.  Thus, the data input to the

        FFT will be four times this many bits per clock.

\item[\hbox{-m bits}] This sets the maximum bit width of the output.

        By default, the FFT will gain bits as they accumulate within

        the FFT.  Bits are accumulated at roughly one bit for every two stages.

        However, if this value is set, bits are only accumulated up to this

        maximum width.  After this width, further accumulations are truncated.

\item[\hbox{-c bits}] The number of bits in each twiddle coefficient is given

        by the number of bits input to that stage plus this extra number of

        bits per coefficient.  By increasing the number of bits per coefficient

        above that of the input samples, truncation error is kept to the

        original error found within the original samples.

\end{itemize}

\chapter{Architecture}

As a component of another system the structure of this system is a simple

black box such as the one shown in Fig.~\ref{fig:black-box}.

\begin{figure}\begin{center}

\begin{pspicture}(-2.1in,0)(2.1in,2in)

% \rput(0,0){\psframe(-2.1in,0)(2.1in,2in)}

\rput(0,0){\rput(0,0){\psframe[linewidth=2\pslinewidth](-0.75in,0)(0.75in,2in)}

        \rput(0,1in){(I)FFT Core}

        \rput[r](-1.6in,1.8in){\tt i\_clk}

                \rput(-1.5in,1.8in){\psline{->}(0,0)(0.7in,0)}

        \rput[r](-1.6in,1.5in){\tt i\_rst}

                \rput(-1.5in,1.5in){\psline{->}(0,0)(0.7in,0)}

        \rput[r](-1.6in,1.2in){\tt i\_ce}

                \rput(-1.5in,1.2in){\psline{->}(0,0)(0.7in,0)}

        \rput[r](-1.6in,0.6in){\tt i\_left}

                \rput(-1.5in,0.6in){\psline{->}(0,0)(0.7in,0)}

                \rput(-1.15in,0.6in){\psline(-0.05in,-0.05in)(0.05in,0.05in)}

                \rput[br](-1.2in,0.6in){\scalebox{0.75}{$2N_i$}}

        \rput[r](-1.6in,0.3in){\tt i\_right}

                \rput(-1.5in,0.3in){\psline{->}(0,0)(0.7in,0)}

                \rput(-1.15in,0.3in){\psline(-0.05in,-0.05in)(0.05in,0.05in)}

                \rput[br](-1.2in,0.3in){\scalebox{0.75}{$2N_i$}}

        %

        \rput[l](1.6in,1.2in){\tt o\_sync}

                \rput(0.8in,1.2in){\psline{->}(0,0)(0.7in,0)}

        \rput[l](1.6in,0.6in){\tt o\_left}

                \rput(0.8in,0.6in){\psline{->}(0,0)(0.7in,0)}

                \rput(1.15in,0.6in){\psline(-0.05in,-0.05in)(0.05in,0.05in)}

                \rput[br](1.1in,0.6in){\scalebox{0.75}{$2N_o$}}

        \rput[l](1.6in,0.3in){\tt o\_right}

                \rput(0.8in,0.3in){\psline{->}(0,0)(0.7in,0)}

                \rput(1.15in,0.3in){\psline(-0.05in,-0.05in)(0.05in,0.05in)}

                \rput[br](1.1in,0.3in){\scalebox{0.75}{$2N_o$}}

        }

\end{pspicture}

\caption{(I)FFT Black Box Diagram}\label{fig:black-box}

\end{center}\end{figure}

The interface

is simple: strobe the reset line, and every clock thereafter set the clock

enable line when data is valid on the left and right input ports.  Likewise

for the outputs, when the {\tt o\_sync} line goes high the first data sample

is available.  Ever after that, one data sample will be available every clock

cycle that the {\tt i\_ce} line is high.

Internal to the FFT, things are a touch more complex.  Fig.~\ref{fig:white-box}

\begin{figure}\begin{center}

\begin{pspicture}(1.3in,-0.5in)(4.7in,5in)

        % \rput(0,0){\psframe(0,-0.5in)(\textwidth,5.25in)}

        \rput(0,0){\psframe[linewidth=2\pslinewidth](1.3in,-0.25in)(4.7in,5in)}

        \rput(0,5in){%

                \rput[r](1.95in,0.125in){\tiny\tt i\_left}

                \rput[l](4.05in,0.125in){\tiny\tt i\_right}

                \rput(2.0in,0){\psline{->}(0,0.25in)(0,0.0in)}

                \rput(4.0in,0){\psline{->}(0,0.25in)(0,0.0in)}

        }

        \rput(2in,0){%

                \rput(0,4.25in){\psframe(-0.5in,0)(0.5in,0.5in)%

                        \rput[r](-0.05in,0.675in){\tiny Left}

                        \rput(0.0in,0){\psline{->}(0,0.75in)(0,0.5in)}

                        \rput(0,0.25in){Evens, $N$}

                        \rput[r](-0.35in,-0.125in){\tiny Sync}

                        \rput[l](0.35in,-0.125in){\tiny Data}

                        \rput(-0.3in,0){\psline{->}(0,0)(0,-0.25in)}

                        \rput(0.3in,0){\psline{->}(0,0)(0,-0.25in)}}

                \rput(0,3.5in){\psframe(-0.5in,0)(0.5in,0.5in)%

                        \rput(0,0.25in){Evens, $N/2$}

                        \rput[r](-0.35in,-0.125in){\tiny Sync}

                        \rput[l](0.35in,-0.125in){\tiny Data}

                        \rput(-0.3in,0){\psline{->}(0,0)(0,-0.25in)}

                        \rput( 0.3in,0){\psline{->}(0,0)(0,-0.25in)}}

                % \rput(0,3in){\psframe(-0.5in,0)(0.5in,0.5in)%

                        % \rput(0,0.25in){Evens, $N$}}

                \rput(0,2.25in){\psframe(-0.5in,0)(0.5in,0.5in)%

                        \rput(0,0.25in){Evens, $8$}

                        \rput[r](-0.35in,-0.125in){\tiny Sync}

                        \rput[l](0.35in,-0.125in){\tiny Data}

                        \rput[r](-0.35in,0.675in){\tiny Sync}

                        \rput[l](0.35in,0.675in){\tiny Data}

                        \rput(-0.3in,0.9in){$\vdots$}

                        \rput( 0.3in,0.9in){$\vdots$}

                        \rput(-0.3in,0.75in){\psline{->}(0,0)(0,-0.25in)}

                        \rput( 0.3in,0.75in){\psline{->}(0,0)(0,-0.25in)}

                        \rput(-0.3in,0){\psline{->}(0,0)(0,-0.25in)}

                        \rput(0.3in,0){\psline{->}(0,0)(0,-0.25in)}}

                \rput(0,1.5in){\psframe(-0.5in,0)(0.5in,0.5in)%

                        \rput(0,0.25in){Qtrstage (Even)}

                        \rput[r](-0.35in,-0.125in){\tiny Sync}

                        \rput[lb](0.6in,-0.10in){\tiny Data}

                        \rput(-0.3in,0){\psline{->}(0,0)(0,-0.5in)(0.8in,-0.5in)}

                        \rput(0.3in,0){\psline{->}(0,0)(0,-0.125in)(0.4in,-0.125in)(0.4in,-0.25in)}}

                % \rput(0,0.75in){\psframe(-0.5in,0)(0.5in,0.5in)%

                        % \rput(0,0.25in){dblstage}}

                % \rput(0,0in){\psframe(-0.5in,0)(0.5in,0.5in)%

                        % \rput(0,0.25in){Bit Reversal}}

        }

        \rput(4in,0){%

                \rput(0,4.25in){\psframe(-0.5in,0)(0.5in,0.5in)%

                        \rput[l](0.05in,0.675in){\tiny Right}

                        \rput(0.0in,0){\psline{->}(0,0.75in)(0,0.5in)}

                        \rput(0,0.25in){Odds, $N$}

                        \rput[l](0.35in,-0.125in){\tiny Sync}

                        \rput[r](-0.35in,-0.125in){\tiny Data}

                        \rput(-0.3in,0){\psline{->}(0,0)(0,-0.25in)}

                        \rput(0.3in,0){\psline{->}(0,0)(0,-0.25in)}}

                \rput(0,3.5in){\psframe(-0.5in,0)(0.5in,0.5in)%

                        \rput(0,0.25in){Odds, $N/2$}

                        \rput[l](0.35in,-0.125in){\tiny Sync}

                        \rput[r](-0.35in,-0.125in){\tiny Data}

                        \rput(-0.3in,0){\psline{->}(0,0)(0,-0.25in)}

                        \rput(0.3in,0){\psline{->}(0,0)(0,-0.25in)}}

                % \rput(0,3in){\psframe(-0.5in,0)(0.5in,0.5in)%

                        % \rput(0,0.25in){Evens, $N$}}

                \rput(0,2.25in){\psframe(-0.5in,0)(0.5in,0.5in)%

                        \rput(0,0.25in){Odds, $8$}

                        \rput[l](0.35in,0.675in){\tiny Sync}

                        \rput[r](-0.35in,0.675in){\tiny Data}

                        \rput(-0.3in,0.9in){$\vdots$}

                        \rput( 0.3in,0.9in){$\vdots$}

                        \rput[l](0.35in,-0.125in){\tiny Sync}

                        \rput[r](-0.35in,-0.125in){\tiny Data}

                        \rput(-0.3in,0.75in){\psline{->}(0,0)(0,-0.25in)}

                        \rput(0.3in,0.75in){\psline{->}(0,0)(0,-0.25in)}

                        \rput(-0.3in,0){\psline{->}(0,0)(0,-0.25in)}

                        \rput(0.3in,0){\psline{->}(0,0)(0,-0.25in)}}

                \rput(0,1.5in){\psframe(-0.5in,0)(0.5in,0.5in)%

                        \rput(0,0.25in){Qtrstage (Odd)}

                        \rput[rb](-0.6in,-0.10in){\tiny Data}

                        \rput(0.3in,0){\psline{->}(0,0)(0,-0.25in)}

                                \rput[t](0.3in,-0.3in){\tiny NC}

                        \rput(-0.3in,0){\psline{->}(0,0)(0,-0.125in)(-0.4in,-0.125in)(-0.4in,-0.25in)}

                        }

        }

        \rput(3in,0.75in){\psframe(-0.5in,0)(0.5in,0.5in)%

                \rput(0,0.25in){Double Stage}

                        \rput[r](-0.35in,-0.125in){\tiny Sync}

                        \rput[l](0.35in,-0.125in){\tiny Right}

                        \rput[r](0.15in,-0.125in){\tiny Left}

                \rput(-0.3in,0){\psline{->}(0,0)(0,-0.25in)}

                \rput(0.2in,0){\psline{->}(0,0)(0,-0.25in)}

                \rput(0.3in,0){\psline{->}(0,0)(0,-0.25in)}}

        \rput(3in,0in){\psframe(-0.5in,0)(0.5in,0.5in)%

                \rput(0,0.25in){Bit Reversal}

                        \rput[r](-0.35in,-0.125in){\tiny Sync}

                        \rput[l](0.35in,-0.125in){\tiny Right}

                        \rput[r](0.15in,-0.125in){\tiny Left}

                \rput(-0.3in,0){\psline{->}(0,0)(0,-0.25in)}

                \rput(0.2in,0){\psline{->}(0,0)(0,-0.25in)}

                \rput(0.3in,0){\psline{->}(0,0)(0,-0.25in)}}

        \rput(3in,-0.25in){\rput[r](-0.35in,-0.125in){\tiny\tt o\_sync}

                        \rput[l](0.35in,-0.125in){\tiny\tt o\_right}

                        \rput[r](0.15in,-0.125in){\tiny\tt o\_left}

                \rput(-0.3in,0){\psline{->}(0,0)(0,-0.25in)}

                \rput(0.2in,0){\psline{->}(0,0)(0,-0.25in)}

                \rput(0.3in,0){\psline{->}(0,0)(0,-0.25in)}}

\end{pspicture}

\caption{Internal FFT Structure}\label{fig:white-box}

\end{center}\end{figure}

attempts to show some of this structure.  As you can see from the figure, the

FFT itself is composed of a series of stages.  These stages are split from the

beginning into an even stage and an odd stage.  Further, they are numbered

according to the size of the FFT they represent.  Therefore the first stage

is numbered $N$ and represents the first stage of an $N$ point FFT.  The

second stage is labeled $N/2$, then $N/$, and so on down to $N=8$.  The

four sample stage and the two sample stages are different, however.  These

two stages, representing three blocks on Fig.~\ref{fig:white-box}, can be

accomplished without any multiplies.  Therefore they have been accomplished

separately.  Likewise all of the stages, save the double stage at the bottom,

operate on one data sample per clock.  Only the last stage, prior to the

bit reversal stage, takes two data samples per clock as input, and outputs two

data samples per clock.  Finally, the bit reversal stage acts as the last

piece of the structure.

Internal to each of the FFT stages is a butterfly and a complex multiply,

as shown in Fig.~\ref{fig:fftstage}.

\begin{figure}\begin{center}

\begin{pspicture}(-0.25in,-1.8in)(3.25in,4.25in)

        % \rput(0,0){\psframe(0in,-2in)(3in,4.25in)}

        \rput(0,0){\psframe[linewidth=2\pslinewidth](-0.25in,-1.55in)(3.25in,4.0in)}

        \rput[r](1.625in,4.125in){\tt i\_data}

        \rput(1.675in,3.75in){\psline{->}(0,0.5in)(0,0in)%

                        \psline{->}(0,0)(-0.2in,-0.25in)%

                        \psarc{->}{0.15in}{200}{340}}

        \rput(0,2.75in){\rput(0,0){\psframe(0,0)(1.3in,0.25in)}

                        \rput(0,0){\psframe(0.1in,0)(0.2in,0.25in)}

                        \rput(0,0){\psframe(0.3in,0)(0.4in,0.25in)}

                        \rput(0,0){\psframe(0.5in,0)(0.6in,0.25in)}

                        \rput(0,0){\psframe(0.7in,0)(0.8in,0.25in)}

                        \rput(0,0){\psframe(0.9in,0)(1.0in,0.25in)}

                        \rput(0,0){\psframe(1.1in,0)(1.2in,0.25in)}

                        \rput(0,0){\psline{-}(0.7in,-0.05in)(1.1in,-0.25in)}

                        \rput(0,0){\psline{<-}(0.7in,0.3in)(1.5in,0.5in)(1.5in,0.75in)}}

        \rput(1.85in,2.75in){\psline(0,0.75in)(0,-0.25in)}

        \rput(0.6in,0.25in){\rput(0,0){\psframe[linewidth=2\pslinewidth](0,0)(2in,2.0in)}

                \rput(0.50in,2in){\psline{->}(0,0.25in)(0,0in)}

                \rput(1.25in,2in){\psline{->}(0,0.25in)(0,0in)}

                \rput(1.75in,2in){\psline{->}(0,0.25in)(0,0in)}

                \rput(0.5in,0){%

                        \rput(0in,0){\psline{->}(0,2.0in)(0,1.1in)}

                        \rput(0in,0){\psline{->}(0,1.75in)(0.65in,1.1in)}

                        \rput(-0.1in,1.1in){$+$}

                        \rput(0in,1.0in){$\bigoplus$}

                        \rput(0in,0){\psline{->}(0,0.9in)(0,0.75in)}

                        \rput(0in,0.5in){\psframe(-0.45in,-0.25in)(0.45in,0.25in)}

                        \rput(0in,0.5in){\parbox{0.8in}{Delay, and\\shift by $C-2$}}

                        \rput(0in,0){\psline{->}(0,0.25in)(0,0.0in)}}

                \rput(1.25in,0){%

                        \rput(0in,0){\psline{->}(0,2.0in)(0,1.1in)}

                        \rput(0in,0){\psline{->}(0,1.75in)(-0.65in,1.1in)}

                        \rput(0.1in,1.1in){$-$}

                        \rput(0in,1in){$\bigoplus$}

                        \rput(0in,0){\psline{->}(0,0.9in)(0,0.6in)}

                        \rput(0in,0.5in){$\bigotimes$}

                        \rput(0in,0){\psline{->}(0,0.4in)(0,0.0in)}}

                \rput(1.75in,0){%

                        \rput(0,0){\psline{->}(0,2.0in)(0,0.5in)(-0.4in,0.5in)}}

                \rput(0.50in,-0.25in){\psline{->}(0,0.25in)(0,-1.05in)}

                \rput(1.25in,-0.25in){\psline{-}(0,0.25in)(0,0in)}}

        \rput*[l](2.0in,0.5in){DIF Butterfly}

        \rput*[lb](1.95in,2.5in){Coefficient memory}

        % \rput(0,0){\psframe(1.3in,-0.25in)(4.7in,5in)}

        \rput(1.7in,-0.5in){\rput(0,0){\psframe(0,0)(1.3in,0.25in)}

                        \rput(0,0){\psframe(0.1in,0)(0.2in,0.25in)}

                        \rput(0,0){\psframe(0.3in,0)(0.4in,0.25in)}

                        \rput(0,0){\psframe(0.5in,0)(0.6in,0.25in)}

                        \rput(0,0){\psframe(0.7in,0)(0.8in,0.25in)}

                        \rput(0,0){\psframe(0.9in,0)(1.0in,0.25in)}

                        \rput(0,0){\psframe(1.1in,0)(1.2in,0.25in)}

                        \rput(0,0){\psline{<-}(0.7in,0.30in)(0.15in,0.5in)}

                        \rput(0,0){\psline{->}(0.7in,-0.05in)(-0.2in,-0.3in)(-0.2in,-0.55in)}}

        \rput(1.3in,-1.3in){\psline{->}(-0.2in,0.25in)(0,0)}

        \rput(1.3in,-1.3in){\psarcn{->}{0.15in}{150}{30}}

        \rput(1.3in,-1.3in){\psline{->}(0,0)(0,-0.5in)}

        \rput[l](1.35in,-1.675in){\tt o\_data}

\end{pspicture}

\caption{A Single FFT Stage, with Butterfly}\label{fig:fftstage}

\end{center}\end{figure}

These FFT stages are really no different than any other decimation in

frequency FFT, save only that the coefficients are alternated between the

two stages.  That is, the even stages get all the even coefficients, and

the odd stages get all of the odd coefficients.

Internally, each stage spends the first $N/4$ clocks storing its inputs

into memory, and then the next $N/4$ clocks pairing a stored input with

a single external input, so that both values become inputs to the butterfly.

Likewise, the butterfly coefficient is read from a small ROM table.

One trick to making the FFT stage work successfully is synchronization.  Since

the multiplies create a delay of (roughly) one clock cycle per bit of input,

there is a significant pipeline delay from the input to the output of the

butterfly routine.  To match this delay, the FFT stage places a

synchronization pulse into the butterfly.  When this synchronization pulse

comes out of the butterfly, the values of the butterfly then match the

first sample out of the stage.  The next synchronization problem comes from

the fact that the butterflies operate on two samples at a time, whereas the

FFT stage operates on a single sample at a time.  This means that half the

time the butterfly output will be invalid.  To keep things aligned, and to

avoid the invalid data half, a counter is started by the synchronization pulse

coming out of the butterfly in order to keep track.  Using this counter and

once the butterfly produces the first sync pulse, the next $N/4$ clock cycles

will produce valid butterfly outputs.  For these clock cycles, the left or

first output is sent immediately to the next FFT stage, whereas the right

or second output is saved into memory.  Once these cycles are complete, the

butterfly outputs will be invalid for the next $N/4$ clock cycles.  During

these invalid clock cycles, the FFT stage outputs data that had been stored

in memory.  In this fashion, data is always valid coming out of each FFT

stage once the initial synchronization pulse goes high.

The complex multiply itself, formed internal to the butterfly routine, is

formed from three very simple shift and add multiplies, whose output is

then transformed into a single complex output.  To avoid overflow, the

complex coefficients, $z_n$, for these multiplies are given by,

\begin{eqnarray}

z_n &=& c_n + js_n,\mbox{ where} \\

c_n &=& \left\lfloor 2^{C-2}\cos\left(2\pi \frac{n}{N}\right)+\frac{1}{2}\right\rfloor,\\

s_n &=& \left\lfloor 2^{C-2}\sin\left(2\pi \frac{n}{N}\right)+\frac{1}{2}\right\rfloor\mbox{, and}

\end{eqnarray}

$C$ is the number of bits allocated to the coefficient.

For those wishing to understand this operation further and in more depth, I

would commend them to the literature on how a decimation in frequency FFT is

constructed.

\chapter{Operation}

The core is actually really easy to use:

\begin{enumerate}

        \item Provide a system clock to the core every clock cycle.

        \item Set the {\tt i\_rst} line high for at least one clock cycle

                before you intend to use the core.

        \item From the time of reset until the first sample pair is available

                on the IO ports, {\tt i\_rst} may be kept low, but the clock

                enable line {\tt i\_ce} must also be kept low.

        \item On the clock containing the first sample pair, {\tt i\_left}

                and {\tt i\_right}, set {\tt i\_ce} high.

        \item Ever after, any time a valid pair of samples is available to

                the input of the FFT, place the first sample of the pair

                on the {\tt i\_left} line, the second on the {\tt i\_right}

                line, and set {\tt i\_ce} high.

        \item At the first valid output, the FFT core will set {\tt o\_sync}

                line high in addition to the output values {\tt o\_left}

                (the first of two), and {\tt o\_right} (the second of the two).

        \item Ever after, whenever {\tt i\_ce} is high, the FFT core will clock

                two samples in and two samples out.  On any valid first

                pair of samples coming out of the transform,

                {\tt o\_sync} will be high.  Otherwise {\tt o\_sync} will

                remain low.

\end{enumerate}

There are no special modes or states associated with this core.  If you wish

it to stop or pause, just turn off {\tt i\_ce}.  If you wish to flush the

core, just send zeros into the core.

\chapter{Registers}

Once built, the FFT routine has no capability for runtime configuration

or reconfiguration.  Therefore, this implementation maintains no user

configurable or readable registers.

This is a great advantage in many ways, simply because it greatly simplifies

the interface over other cores that are available out there.

\chapter{Clocks}

The FFT routines built by this core use one clock only.  The speed of this

clock will depend upon the speed your hardware is capable of.  If your data

rate is slower than your clock speed, just hold off on the {\tt i\_ce}

line as necessary so that every clock with the {\tt i\_ce} line high is a

valid sample.

\chapter{IO Ports}

The FFT core presents a small set of IO ports to its external interface.

These ports are listed in Table.~\ref{tbl:ioports}.

\begin{table}[htbp]

\begin{center}

\begin{portlist}

i\_clk & 1 & Input & The global clock driving the FFT. \\\hline

i\_rst & 1 & Input & An active high synchronous reset.\\\hline

i\_ce & 1 & Input & Clock Enable.  Set this high to clock data in and

                out.\\\hline

i\_left & $2N_i$ & Input & The first of two input complex input samples.  Bits

                [$\left(2N_i-1\right)$:$N_i$] of this value are the real

                portion, whereas bits [$\left(N_i-1\right)$:0] represent the

                imaginary portion.  Both portions are in signed twos complement

                integer format.  The number of bits, $N_i$, is configurable.

                \\\hline

i\_right & $2N_i$ & Input & The second of two input complex input samples.

                The format is the same as {\tt i\_left} above.\\\hline

o\_left & $2N_o$ & Output & The first of two input complex output samples.

                The format is the same, save only that $N_o$ bits are

                used for each twos complement portion instead of $N_i$.\\\hline

o\_right & $2N_o$ & Output & The second of two input complex output samples.

                The format is the same as for {\tt o\_left} above.\\\hline

o\_sync & 1 & Output & Signals the first output sample pair of any transform,

                zero otherwise.

                \\\hline

\end{portlist}

\caption{List of IO ports}\label{tbl:ioports}

\end{center}\end{table}

% Appendices

% Index

\end{document}