Texas Instruments C28 Series User manual

Copyright © 2012 Texas Instruments Incorporated.FPU-DSP-LIB-UG-V131
USER’S GUIDE
C28x Floating Point Unit DSP Library

Copyright
Copyright © 2012 Texas Instruments Incorporated. All rights reserved. ControlSUITE is a registered trademark of Texas Instruments. Other names and
brands may be claimed as the property of others.
Please be aware that an important notice concerning availability, standard warranty, and use in critical applications of Texas Instruments semicon-
ductor products and disclaimers thereto appears at the end of this document.
Texas Instruments
12203 Southwest Freeway
Houston, TX 77477
http://www.ti.com/c2000
Revision Information
This is version V131 of this document, last updated on Sep 10, 2012.
Sep 10, 2012 2

Table of Contents
Table of Contents
Copyright ..................................................... 2
Revision Information ............................................... 2
1 Introduction ................................................. 5
2 Library Structure .............................................. 6
2.1 Build Options used to build the library ................................... 7
2.2 Header Files ................................................. 7
2.3 A Note about C functions and IQMath ................................... 8
3 Function Descriptions ........................................... 9
3.1 Complex Fast Fourier Transform ...................................... 12
3.2 Complex Fast Fourier Transform (Unaligned) ............................... 15
3.3 Complex Fast Fourier Transform Magnitude ................................ 17
3.4 Complex Fast Fourier Transform Magnitude (Scaled) ........................... 19
3.5 Complex Fast Fourier Transform Phase .................................. 21
3.6 Complex Fast Fourier Transform Twiddle Factors ............................. 23
3.7 Inverse Complex Fast Fourier Transform ................................. 25
3.8 Real Fast Fourier Transform ........................................ 28
3.9 Real Fast Fourier Transform (Unaligned) ................................. 31
3.10 Real Fast Fourier Transform with ADC Input ............................... 33
3.11 Real Fast Fourier Transform with ADC Input (Unaligned) ........................ 36
3.12 Real Fast Fourier Transform Magnitude .................................. 38
3.13 Real Fast Fourier Transform Magnitude (Scaled) ............................. 40
3.14 Real Fast Fourier Transform Phase .................................... 42
3.15 Real Fast Fourier Transform Twiddle Factors ............................... 44
3.16 Finite Impulse Response Filter ....................................... 46
3.17 Absolute Value of a Complex Vector .................................... 50
3.18 Absolute Value of an Even Length Complex Vector ............................ 51
3.19 Addition (Element-Wise) of a Complex Scalar to a Complex Vector ................... 52
3.20 Addition of Two Complex Vectors ...................................... 53
3.21 Inverse Absolute Value of a Complex Vector ............................... 54
3.22 Inverse Absolute Value of an Even Length Complex Vector ....................... 55
3.23 Index of Maximum Value of an Even Length Real Array ......................... 56
3.24 Mean of Real and Imaginary Parts of a Complex Vector ......................... 57
3.25 Median of a Real Valued Array of Floats (Preserved Inputs) ....................... 58
3.26 Median of a real array of floats ....................................... 60
3.27 Complex Multiply of Two Floating Point Numbers ............................. 61
3.28 Complex Multiply of Two Complex Vectors ................................ 62
3.29 Multiplication of a Complex Vector and the Complex Conjugate of another Vector ........... 63
3.30 Multiplication of a Real scalar and a Real Vector ............................. 64
3.31 Multiplication of a Real Scalar, a Real Vector, and another Real Vector ................. 65
3.32 Multiplication of a Real Vector and a Complex Vector .......................... 66
3.33 Multiplication of a Real Vector and a Real Vector ............................. 67
3.34 Sort an Array of Floats ........................................... 68
3.35 Rounding (Unbiased) of a Floating Point Scalar ............................. 69
3.36 Subtraction of a Complex Scalar from a Complex Vector ......................... 70
3.37 Subtraction of a Complex Vector and another Complex Vector ..................... 71
3.38 Fast Square Root .............................................. 72
3.39 Optimized Memory Copy .......................................... 73
3.40 Optimized Memory Set ........................................... 74
Sep 10, 2012 3

Table of Contents
4 Revision History .............................................. 75
IMPORTANT NOTICE ............................................... 76
Sep 10, 2012 4

Introduction
1 Introduction
The Texas Instruments TMS320C28x Floating Point Unit (FPU) Library is collection of highly opti-
mized application functions written for the C28x+FPU. These functions enable C/C++ programmers
to take full advantage of the performance potential of the C28x+FPU. This document provides a
description of each function included within the library.
Sep 10, 2012 5

Library Structure
2 Library Structure
Build Options used to build the library ..................................................................... 7
Header Files ..............................................................................................7
ANote aboutCfunctions and IQMath ..................................................................... 8
As installed, the C28x FPU Library is partitioned into a well-defined directory structure. By default,
the library and source code is installed into the default controlSUITE directory,
C:\TI\controlSUITE\libs\dsp\FPU\VERSION
VERSION indicates the current revision of the FPU library. Figure. 2.1 shows the directory structure
while the subsequent table 2.1 provides a description for each folder.
Figure 2.1: Directory Structure of the FPU Library
Sep 10, 2012 6

Library Structure
Folder Description
<base>Base install directory. By default this is
C:/TI/controlSUITE/libs/dsp/FPU/VERSION For the rest of
this document <base>will be omitted from the directory names
<base>/cmd Linker command files used in the examples
<base>/doc Documentation for the current revision of the library including re-
vision history
<base>/examples Examples that illustrate the library functions. At the time of writing
these examples were built for the F2833x device using CCS4 but
they can be imported into CCS5
<base>/include Header files for the FPU library. These include function proto-
types and structure definitions
<base>/lib Pre-built FPU libraries
<base>/source Source files and project for the library. Allows the user to recon-
figure, modify and re-build the library to suit their particular needs
<EXAMPLE>/matlab Matlab code for reference of debugging example project or lib
source code. FFT results in example projects can be compared
by the result in matlab code.
Table 2.1: FPU Library Directory Structure Description
2.1 Build Options used to build the library
The current version of the library was built with C28x Codegen Tools v6.0.1 with the following
options:
-v28 -mt -ml -g --diag_warning=225 --float_support=fpu32
2.2 Header Files
A library header file is supplied in the <base>/include folder. This file contains structure definitions
and function prototypes. The header file also includes the C28x data type definitions shown below:
#ifndef DSP28_DATA_TYPES
#define DSP28_DATA_TYPES
typedef int int16;
typedef long int32;
typedef long long int64;
typedef unsigned int Uint16;
typedef unsigned long Uint32;
typedef unsigned long long Uint64;
typedef float float32;
typedef long double float64;
#endif
Sep 10, 2012 7

Library Structure
2.3 A Note about C functions and IQMath
Most of the functions contained in the C28x FPU library are c-callable assembly. A few functions
may be written in C. These C functions are written using the IQMath pre-processor notation. This
allows these functions to be easily ported from fixed point to floating-point math. The included
IQMath header file, IQmathLib.h, controls whether the code is built for fixed point or floating-point.
You may choose to configure the file IQmathLib.h in the controlSUITE directory to generate floating-
point code. i.e. the MATH_TYPE in the file is defined as FLOAT_MATH.
For more information on the IQMath notation, please refer to C28x IQMath Library - A Virtual
Floating Point Engine (SPRC087) which can be downloaded from TI’s website.
Sep 10, 2012 8

Function Descriptions
3 Function Descriptions
DSP Routines
ComplexFast Fourier Transform ..........................................................................12
ComplexFast Fourier Transform (Unaligned) .............................................................15
ComplexFast Fourier Transform Magnitude ..............................................................17
ComplexFast Fourier Transform Magnitude (Scaled) .....................................................19
Complex Fast Fourier Transform Phase .................................................................. 21
ComplexFast Fourier Transform TwiddleFactors .........................................................23
Inverse Complex Fast FourierTransform ..................................................................25
RealFast Fourier Transform ..............................................................................28
RealFast Fourier Transform(Unaligned) ................................................................. 31
RealFast Fourier Transformwith ADCInput ..............................................................33
Real Fast Fourier Transform with ADC Input (Unaligned) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .36
RealFast Fourier TransformMagnitude ...................................................................38
Real Fast Fourier Transform Magnitude (Scaled) ......................................................... 40
RealFast Fourier TransformPhase .......................................................................42
Real Fast Fourier Transform Twiddle Factors ............................................................. 44
Finite ImpulseResponse Filter ...........................................................................46
Vector and Matrix Routines
Absolute Valueof aComplexVector ......................................................................50
Absolute Valueof an Even Length Complex Vector .......................................................51
Addition (Element-Wise) of a Complex Scalar to a Complex Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Addition ofTwoComplex Vectors .........................................................................53
Inverse AbsoluteValue of a Complex Vector ..............................................................54
Inverse Absolute Value of an Even Length Complex Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Index of Maximum Valueof an Even Length Real Array ...................................................56
Meanof RealandImaginaryParts of a Complex Vector ..................................................57
Median of a Real Valued Array of Floats (Preserved Inputs) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
Median of a realarray of floats ...........................................................................60
ComplexMultiply of Two FloatingPoint Numbers .........................................................61
ComplexMultiply of Two Complex Vectors ................................................................62
Multiplication of a Complex Vector and the Complex Conjugate of another Vector . . . . . . . . . . . . . . . . . . . . . . . . . 63
Multiplication ofaReal scalar and a Real Vector ..........................................................64
Multiplication of a Real Scalar, a Real Vector, and another Real Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .65
Multiplication ofaReal Vector and a ComplexVector .....................................................66
Multiplication ofaReal Vector and a RealVector .........................................................67
Sort an Array of Floats ...................................................................................68
Rounding (Unbiased) of a Floating Point Scalar .......................................................... 69
Subtraction of a Complex Scalar fromaComplex Vector ..................................................70
Subtraction of a Complex Vector and another Complex Vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Math Routines
Fast Square Root ........................................................................................72
Utility Routines
Optimized Memory Copy .................................................................................73
Optimized Memory Set ...................................................................................74
Sep 10, 2012 9

Function Descriptions
The following functions are included in this release of the FPU Library. The source code for these
functions can be found in the source/C28x_FPU_LIB folder.
DSP
CFFT_f32 void CFFT_f32(CFFT_F32_STRUCT *);
CFFT_f32u void CFFT_f32u(CFFT_F32_STRUCT *);
CFFT_f32_mag void CFFT_f32_mag(CFFT_F32_STRUCT *);
CFFT_f32s_mag void CFFT_f32s_mag(CFFT_F32_STRUCT *);
CFFT_f32_phase void CFFT_f32_phase(CFFT_F32_STRUCT *);
CFFT_f32_sincostable void CFFT_f32_sincostable(CFFT_F32_STRUCT *);
ICFFT_f32 void ICFFT_f32(CFFT_F32_STRUCT *);
RFFT_f32 void RFFT_f32(RFFT_F32_STRUCT *);
RFFT_f32u void RFFT_f32u(RFFT_F32_STRUCT *);
RFFT_adc_f32 void RFFT_adc_f32(RFFT_ADC_F32_STRUCT *);
RFFT_adc_f32u void RFFT_adc_f32u(RFFT_ADC_F32_STRUCT *);
RFFT_f32_mag void RFFT_f32_mag(RFFT_F32_STRUCT *);
RFFT_f32s_mag void RFFT_f32s_mag(RFFT_F32_STRUCT *);
RFFT_f32_phase void RFFT_f32_phase(RFFT_F32_STRUCT *);
RFFT_f32_sincostable void RFFT_f32_sincostable(RFFT_F32_STRUCT *);
Filter
FIR_f32 void FIR_FP_calc(FIR_FP_handle);
Matrix and Vector
abs_SP_CV void abs_SP_CV(float32 *, const complex_float *, const Uint16);
abs_SP_CV_2 void abs_SP_CV_2(float32 *, const complex_float *, const
Uint16);
add_SP_CSxCV void add_SP_CSxCV(complex_float *, const complex_float *,
const complex_float, const Uint16);
add_SP_CVxCV void add_SP_CVxCV(complex_float *, const complex_float *,
const complex_float *, const Uint16);
iabs_SP_CV void iabs_SP_CV(float32 *, const complex_float *, const Uint16);
iabs_SP_CV_2 void iabs_SP_CV_2(float32 *, const complex_float *, const
Uint16);
maxidx_SP_RV_2 Uint16 maxidx_SP_RV_2(float32 *, Uint16);
mean_SP_CV_2 complex_float mean_SP_CV_2(const complex_float *, const
Uint16);
median_noreorder_SP_RV float32 median_noreorder_SP_RV(const float32 *, Uint16);
median_SP_RV float32 median_SP_RV(float32 *, Uint16);
mpy_SP_CSxCS complex_float mpy_SP_CSxCS(complex_float, complex_float);
mpy_SP_CVxCV void mpy_SP_CVxCV(complex_float *, const complex_float *,
const complex_float *, const Uint16);
mpy_SP_CVxCVC void mpy_SP_CVxCVC(complex_float *, const complex_float *,
const complex_float *, const Uint16);
mpy_SP_RSxRV_2 void mpy_SP_RSxRV_2(float32 *, const float32 *, const float32,
const Uint16);
mpy_SP_RSxRVxRV_2 void mpy_SP_RSxRVxRV_2(float32 *, const float32 *, const
float32 *, const float32, const Uint16);
mpy_SP_RVxCV void mpy_SP_RVxCV(complex_float *, const complex_float *,
const float32 *, const Uint16);
Continued on next page
Sep 10, 2012 10

Function Descriptions
Table 3.1 – continued from previous page
mpy_SP_RVxRV_2 void mpy_SP_RVxRV_2(float32 *, const float32 *, const float32
*, const Uint16);
qsort_SP_RV void qsort_SP_RV(void *, Uint16);
rnd_SP_RS float32 rnd_SP_RS(float32);
sub_SP_CSxCV void sub_SP_CSxCV(complex_float *, const complex_float *,
const complex_float, const Uint16);
sub_SP_CVxCV void sub_SP_CVxCV(complex_float *, const complex_float *,
const complex_float *, const Uint16);
Math
__ffsqrtf inline static float32 __ffsqrtf(float32 x);
Utility
memcpy_fast void memcpy_fast(void *, const void *, Uint16);
memset_fast void memset_fast(void*, int16, Uint16);
Table 3.1: List of Functions
The examples for each was built using CGT 6.0.1 with the following options:
-v28 -mt -ml -g --diag_warning=225 --float_support=fpu32
The only exception being the fast sqrt example built with the options
-v28 -mt -ml -g -O2 --diag_warning=225 --optimize_with_debug --float_support=fpu32
Each example has a script SetupDebugEnv.js that can be used with the scripting console in
CCS to setup the watch windows and graphs automatically in the debug session. Please see
CCS4:Scripting Console for more information
Sep 10, 2012 11

Function Descriptions
3.1 Complex Fast Fourier Transform
Description:
This module computes a 32-bit floating-point complex FFT including input bit reversing. This
version of the function requires input buffer memory alignment. If you do not wish to align the
input buffer, then use the CFFT_f32u function.
Header File:
FPU.h
Declaration:
void CFFT_f32 (CFFT_F32_STRUCT *)
Usage:
A pointer to the following structure is passed to the CFFT_f32 function:
typedef struct {
float32 *InPtr;
float32 *OutPtr;
float32 *CoefPtr;
float32 *CurrentInPtr;
float32 *CurrentOutPtr;
Uint16 Stages;
Uint16 FFTSize;
} CFFT_F32_STRUCT;
Table 3.2 describes each element
Alignment Requirements:
The input buffer must be aligned to a multiple of the 2*FFTSize*sizeof(float) i.e. 4*FFTSize.
For example, if the FFTSize is 128 you must align the buffer corresponding to InPtr to 4*128 =
512. An alignment to a smaller value will not work for the 128-pt complex FFT.
To align the input buffer, use the DATA_SECTION pragma to assign the buffer to a code section
and then align the buffer to the proper offset in the linker command file. In this code example
the buffer is assigned to the CFFTin1Buff section.
#define CFFT_STAGES 7
#define CFFT_SIZE (1 << CFFT_STAGES)
//Buffer alignment for the input array,
//CFFT_f32u (optional), CFFT_f32 (required)
//Output of FFT overwrites input if
//CFFT_STAGES is ODD
#pragma DATA_SECTION(CFFTin1Buff,"CFFTdata1");
float CFFTin1Buff[CFFT_SIZE*2];
In the project’s linker command file, the CFFTdata1 section is then aligned to a multiple of the
FFTSize as shown below:
CFFTdata1 : > RAML4, PAGE = 1, ALIGN(512)
The buffers referenced by InPtr and OutPtr are used in ping-pong fashion. At the first stage of
the FFT InPtr and CurrentInPtr both point to the input buffer and OutPtr and CurrentOutPtr point
Sep 10, 2012 12

Function Descriptions
Item Description Format Comment
InPtr Input data Pointer to 32-bit float array Input buffer alignment is required. Refer to
the alignment section.
OutPtr Output buffer Pointer to 32-bit float array
CoefPtr Twiddle factors Pointer to 32-bit float array Calculate using CFFT_f32_cossintable ( ).
CurrentInPtr Output Buffer Pointer to 32-bit float array Result of CFFT_f32. This buffer can then be
used as the input to the magnitude and phase
calculations. The output order for FFTSize =
N is:
CurrentInPtr[0] = real[0]
CurrentInPtr[1] = imag[0]
CurrentInPtr[2] = real[1]
...
CurrentInPtr[N] = real[N/2]
CurrentInPtr[N+1] = imag[N/2]
...
CurrentInPtr[2N-3] = imag[N-2]
CurrentInPtr[2N-2] = real[N-1]
CurrentInPtr[2N-1] = imag[N-1]
CurrentOutPtr Output Buffer Pointer to 32-bit float array Result of N-1 stage complex FFT.
Stages Number of stages Uint16 Stages = log2(FFTSize). Must larger than 3.
FFTSize FFT size Uint16 Must be a power of 2 greater than or equal to
8.
Table 3.2: Elements of the Data Structure
to the same output buffer. After bit reversing the input and computing the stage 1 butterflies the
output is stored at the location pointed to be cfft.CurrentOutPtr. The next step is to switch the
pointer cfft.CurrentInPtr with cfft.CurrentOutPtr so that the output from the nth stage becomes
the input to the n+ 1th stage while the previous (nth) stage’s input buffer will be used as the
output for the n+ 1th stage. In this manner the CurrentInPtr and CurrentOutPtr are switched
successively for each FFT stage.Therefore, If the number of stages is odd then at the end of
all the coputation we get:
currentInPtr=InPtr, currentOutPtr=OutPtr.
If number of stages is even then,
currentInPtr=OutPtr, currentOutPtr=InPtr.
Stage3 Stage4 Stage5 ... Stage N
N = odd N = even
InPtr (Buf1) CurrentInPtr CurrentOutPtr CurrentInPtr ... CurrentInPtr CurrentOutPtr
OutPtr (Buf2) CurrentOutPtr CurrentInPtr CurrentOutPtr ... CurrentOutPtr CurrentInPtr
Result Buf Buf1 Buf2 Buf1 ... Buf1 Buf2
Table 3.3: Input and Output Buffer Pointer Allocations
Sep 10, 2012 13

Function Descriptions
Notes:
1. This function is not re-entrant as it uses global variables to store arguments; these
will be overwritten if the function is invoked while it is currently processing.
2. If the input buffer is not properly aligned, then the output will be unpredictable.
3. If you do not wish to align the input buffer, then you must use the CFFT_f32u func-
tion. This version of the function does not have any input buffer alignment require-
ments. Using CFFT_f32u will, however, result in lower cycle performance.
4. All buffers and stack are placed in internal memory (zero-wait states in data space).
Example:
The following sample code obtains the complex FFT of the input.
#include "FPU.h"
#define CFFT_STAGES 7
#define CFFT_SIZE (1 << CFFT_STAGES)
/*CFFTin1Buff section to 4*FFT_SIZE in the linker file */
#pragma DATA_SECTION(CFFTin1Buff,"CFFTdata1");
float CFFTin1Buff[CFFT_SIZE*2];
#pragma DATA_SECTION(CFFToutBuff,"CFFTdata3");
float CFFToutBuff[CFFT_SIZE*2];
#pragma DATA_SECTION(CFFTF32Coef,"CFFTdata4");
float CFFTF32Coef[CFFT_SIZE];
CFFT_F32_STRUCT cfft;
main()
{
cfft.InPtr = CFFTin1Buff; /*Input data buffer */
cfft.OutPtr = CFFToutBuff; /*FFT output buffer */
cfft.CoefPtr = CFFTF32Coef; /*Twiddle factor buffer */
cfft.FFTSize = CFFT_SIZE; /*FFT length */
cfft.Stages = CFFT_STAGES; /*FFT Stages */
... ...
CFFT_f32_sincostable(&cfft); /*Initialize twiddle buffer */
CFFT_f32(&cfft); /*Calculate output */
}
Benchmark Information:
The following table provides benchmark numbers for the function. Note that these include the
cycles used in the call/return from the function
FFTSize C-Callable ASM (Cycle Count)
32 1121
64 2331
128 5029
256 11023
512 24249
1024 53219
Table 3.4: Benchmark Information
Sep 10, 2012 14

Function Descriptions
3.2 Complex Fast Fourier Transform (Unaligned)
Description:
This module computes a 32-bit floating-point complex FFT including input bit reversing. This
version of the function does not have any buffer alignment requirements. If you can align the
input buffer, then use the CFFT_f32 function for improved performance
Header File:
FPU.h
Declaration:
void CFFT_f32u (CFFT_F32_STRUCT *)
Usage:
A pointer to the following structure is passed to the CFFT_f32 function.It is the same structure
described in the CFFT_f32 section:
typedef struct {
float32 *InPtr;
float32 *OutPtr;
float32 *CoefPtr;
float32 *CurrentInPtr;
float32 *CurrentOutPtr;
Uint16 Stages;
Uint16 FFTSize;
} CFFT_F32_STRUCT;
Table 3.2 describes each element describes each element with the exception that the input
buffer does not require alignment.
Alignment Requirements:
None
Notes:
1. This function is not re-entrant as it uses global variables to store arguments; these
will be overwritten if the function is invoked while it is currently processing.
2. If you can align the input buffer to a 4*FFTSize, then consider using the CFFT_f32
function which has input buffer alignment requirements, but it is more cycle efficient
3. All buffers and stack are placed in internal memory (zero-wait states in data space).
Sep 10, 2012 15

Function Descriptions
Example:
The following sample code obtains the complex FFT of the input.
#include "FPU.h"
#define CFFT_STAGES 7
#define CFFT_SIZE (1 << CFFT_STAGES)
float CFFTin1Buff[CFFT_SIZE*2];
float CFFTin2Buff[CFFT_SIZE*2];
float CFFToutBuff[CFFT_SIZE*2];
float CFFTF32Coef[CFFT_SIZE];
CFFT_F32_STRUCT cfft;
main()
{
cfft.InPtr = CFFTin1Buff; /*Input data buffer */
cfft.OutPtr = CFFToutBuff; /*FFT output buffer */
cfft.CoefPtr = CFFTF32Coef; /*Twiddle factor buffer */
cfft.FFTSize = CFFT_SIZE; /*FFT length */
cfft.Stages = CFFT_STAGES; /*FFT Stages */
... ...
CFFT_f32_sincostable(&cfft); /*Initialize twiddle */
/*buffer */
CFFT_f32u(&cfft); /*Calculate output */
}
Benchmark Information:
The following table provides benchmark numbers for the function. Note that these include the
cycles used in the call/return from the function
FFTSize C-Callable ASM (Cycle Count)
32 1351
64 2785
128 5931
256 12821
512 27839
1024 60393
Table 3.5: Benchmark Information
Sep 10, 2012 16

Function Descriptions
3.3 Complex Fast Fourier Transform Magnitude
Description:
This module computes the complex FFT magnitude. The output from CFFT_f32_mag matches
the magnitude output from the FFT found in common mathematics software and Code Com-
poser Studio FFT graphs.
If instead a normalized magnitude like that performed by the fixed-point TMS320C28x IQmath
FFT library is required, then the CFFT_f32s_mag function can be used. In fixed-point
algorithms scaling is performed to avoid overflowing data. Floating-point calculations do not
need this scaling to avoid overflow and therefore the CFFT_f32_mag function can be used
instead.
Header File:
FPU.h
Declaration:
void CFFT_f32_mag (CFFT_F32_STRUCT *)
Usage:
A pointer to the following structure is passed to the CFFT_f32_mag function.It is the same
structure described in the CFFT_f32 section:
typedef struct {
float32 *InPtr;
float32 *OutPtr;
float32 *CoefPtr;
float32 *CurrentInPtr;
float32 *CurrentOutPtr;
Uint16 Stages;
Uint16 FFTSize;
} CFFT_F32_STRUCT;
Table 3.2 describes each element.
Alignment Requirements:
The Magnitude buffer requires no alignment but the input buffer to the complex FFT routine will
need alignment if using the CFFT_f32().
Notes:
1. All buffers and stack are placed in internal memory (zero-wait states in data space).
2. The magnitude calculation calls the sqrt function within the runtime-support library.
The magnitude function has not been optimized at this time.
3. The use of the sqrt function in the FPUfastRTS library will speed up this routine. The
example for the CFFT has an alternate build configuration(Debug_FASTRTS) where
the rts2800_fpu32_fast_supplement.lib is used in place of the standard runtime li-
brary rts2800_fpu32.lib.
Sep 10, 2012 17

Function Descriptions
Example:
The following sample code obtains the complex FFT magnitude.
#include "FPU.h"
#define CFFT_STAGES 7
#define CFFT_SIZE (1 << CFFT_STAGES)
/*CFFTin1Buff section to 4*FFT_SIZE in the linker file */
#pragma DATA_SECTION(CFFTin1Buff,"CFFTdata1");
float CFFTin1Buff[CFFT_SIZE*2];
#pragma DATA_SECTION(CFFTin2Buff,"CFFTdata2");
float CFFTin2Buff[CFFT_SIZE*2];
#pragma DATA_SECTION(CFFToutBuff,"CFFTdata3");
float CFFToutBuff[CFFT_SIZE*2];
#pragma DATA_SECTION(CFFTF32Coef,"CFFTdata4");
float CFFTF32Coef[CFFT_SIZE];
CFFT_F32_STRUCT cfft;
main()
{
cfft.InPtr = CFFTin1Buff; /*Input data buffer */
cfft.OutPtr = CFFToutBuff; /*FFT output buffer */
cfft.CoefPtr = CFFTF32Coef; /*Twiddle factor buffer */
cfft.FFTSize = CFFT_SIZE; /*FFT length */
cfft.Stages = CFFT_STAGES; /*FFT Stages */
... ...
CFFT_f32_sincostable(&cfft); /*Initialize twiddle */
/*buffer */
CFFT_f32(&cfft); /*Calculate output */
CFFT_f32_mag(&cfft); /*Calculate Magnitude */
}
Benchmark Information:
The following table provides benchmark numbers for the function. Note that these include the
cycles used in the call/return from the function.
FFTSize C-Callable ASM (Cycle Count)
Standard Runtime Lib Fast Runtime Lib
32 2717 1436
64 5405 2844
128 10781 5660
256 21533 11292
512 43037 22556
1024 86045 45084
Table 3.6: Benchmark Information
Sep 10, 2012 18

Function Descriptions
3.4 Complex Fast Fourier Transform Magnitude (Scaled)
Description:
This module computes the scaled complex FFT magnitude. The scaling is 1
[2F F T _ST AGES−1],
and is done to match the normalization performed by the fixed-point TMS320C28x IQmath
FFT library for overflow avoidance. Floating-point calculations do not need this scaling to avoid
overflow and therefore the CFFT_f32_mag function can be used instead. The output from
CFFT_f32_mag matches the magnitude output from the FFT found in common mathematics
software and Code Composer Studio FFT graphs.
Header File:
FPU.h
Declaration:
void CFFT_f32s_mag (CFFT_F32_STRUCT *)
Usage:
A pointer to the following structure is passed to the CFFT_f32s_mag function.It is the same
structure described in the CFFT_f32 section:
typedef struct {
float32 *InPtr;
float32 *OutPtr;
float32 *CoefPtr;
float32 *CurrentInPtr;
float32 *CurrentOutPtr;
Uint16 Stages;
Uint16 FFTSize;
} CFFT_F32_STRUCT;
Table 3.2 describes each element
Alignment Requirements:
The Magnitude buffer requires no alignment but the input buffer to the complex FFT routine will
need alignment if using the CFFT_f32().
Notes:
1. All buffers and stack are placed in internal memory (zero-wait states in data space).
2. The magnitude calculation calls the sqrt function within the runtime-support library.
The magnitude function has not been optimized at this time.
3. The use of the sqrt function in the FPUfastRTS library will speed up this routine. The
example for the CFFT has an alternate build configuration (Debug_FASTRTS) where
the rts2800_fpu32_fast_supplement.lib is used in place of the standard runtime li-
brary rts2800_fpu32.lib.
Sep 10, 2012 19

Function Descriptions
Example:
The following sample code obtains the scaled FFT magnitude.
#include "FPU.h"
#define CFFT_STAGES 7
#define CFFT_SIZE (1 << CFFT_STAGES)
/*CFFTin1Buff section to 4*FFT_SIZE in the linker file */
#pragma DATA_SECTION(CFFTin1Buff,"CFFTdata1");
float CFFTin1Buff[CFFT_SIZE*2];
#pragma DATA_SECTION(CFFTin2Buff,"CFFTdata2");
float CFFTin2Buff[CFFT_SIZE*2];
#pragma DATA_SECTION(CFFToutBuff,"CFFTdata3");
float CFFToutBuff[CFFT_SIZE*2];
#pragma DATA_SECTION(CFFTF32Coef,"CFFTdata4");
float CFFTF32Coef[CFFT_SIZE];
CFFT_F32_STRUCT cfft;
main()
{
cfft.InPtr = CFFTin1Buff; /*Input data buffer */
cfft.OutPtr = CFFToutBuff; /*FFT output buffer */
cfft.CoefPtr = CFFTF32Coef; /*Twiddle factor buffer */
cfft.FFTSize = CFFT_SIZE; /*FFT length */
cfft.Stages = CFFT_STAGES; /*FFT Stages */
... ...
CFFT_f32_sincostable(&cfft);/*Initialize twiddle */
/*buffer */
CFFT_f32(&cfft); /*Calculate output */
CFFT_f32s_mag(&cfft); /*Calculate Magnitude */
}
Benchmark Information:
The following table provides benchmark numbers for the function. Note that these include the
cycles used in the call/return from the function.
FFTSize C-Callable ASM (Cycle Count)
Standard Runtime Lib Fast Runtime Lib
32 2906 1534
64 5760 3013
128 11462 5964
256 22860 11859
512 45650 23642
1024 91224 47201
Table 3.7: Benchmark Information
Sep 10, 2012 20