IDFT 8 Point DIT Using TMS320F2812 DSP

IDFT 8 Point DIT Using TMS320F2812 DSP

Tags: IDFT 8 point DIT implementation using TMS320F2812 ,idft8 point dif,idft 8 point source code,
Overall rating

Aim

To perform the 8 point IDFT using DIT process from a given discrete sequence in TMS320F2812 KIT.

Requirements

• CCS v3.3
• TMS320F2812 KIT
• USB Cable

Theory

The algorithm for ifft(X) is the same as the algorithm for fft(X), except for a sign change and a scale factor of n = length(X). As for fft, the execution time for ifft depends on the length of the transform. It is fastest for powers of two. It is almost as fast for lengths that have only small prime factors. It is typically several times slower for lengths that are prime or which have large prime factors.

FFT algorithms can be used to compute an inverse DFT without any change in algorithm. The inverse DFT of an N-point sequence X(k) , k = 0,1, 2, . . . . ., N-1 is defined as

Procedure

Note: Once you install the Code Composer Studio v 3.3 software, the two icons will display in desktop

• Setup Code Composer Studio v3.3
• Code Composer Studio

1. Open Setup Code Composer Studio v3.3.

2. In System Configuration, select the board then → Remove all → yes.

• In family, select C28xx.
• In platform, select xds100 usb emulator.
• In Endianness, select little.
• Select F2812 XDS100 USB Emulator add save & quit no.

Note: The above two steps only for first time to setup the processor in CCS.

3. Open Code Composer Studio v3.3.

4. Project → New.

• Project name : type the project name.
• Location : Browse, select the project location .
• Project Type : Executable(.out)
• Target : TMS320C28XX. Finish.

5. File → New → Source file.

• Type the program in untitled window.

6. File → Save.

• Browse our project location then type our project name.c ( .c extension is must) save.

7. Paste the following two cmd files in our project folder.

• F2812_EzDSP_RAM_lnk.cmd
• DSP281x_GlobalVariableDefs.c

8. Project Add files to project.

• In file of type : All files
• Ctrl + Select the following files
-  projectname.c
• DSP281x_GlobalVariableDefs.c
• F2812_EzDSP_RAM_lnk.cmd

9. Project → Build Option.

In compiler tab, select Preprocessor

• Include search path(-i): C:\tidcs\c28\DSP281x\v120\DSP281x_headers\include

In linker tab, select libraries

• Search path(-i): C:\CCStudio_v3.3\C2000\cgtools\lib
• Incl libraries(-l): rts2800_ml.lib.

In linker tab, select Basic.

• Stack Size(-stack) : 0x400  ok.

10. Project → Build (or) Rebuild all.

11. Connections for TMS320F2812 kit

• Connect 5v adpter to TMS320F2812 kit.
• Connect usb cable to TMS320F2812 kit from pc.
• Power on the TMS320F2812 kit.

12. Debug → connect.

13. File → Load Program → Browse and select the projectname.out file → open

14. Debug → Go main.

15. View → Watch window → watch1.

• Type the following array variable.
-  Xr( sequence output)

16. Debug → Run.

17. Debug → Halt

18. See the output at following location, View → memory Enter An Address:0x3F9200 Enter.

Type the input.

For example

• 0x3F9200 – 0x0008
• 0x3F9201 – 0x0008
• 0x3F9202 – 0x0008
• 0x3F9203 – 0x0007
• 0x3F9204 – 0x0008
• 0x3F9205 – 0x0008
• 0x3F9206 – 0x0008
• 0x3F9207 – 0x0000

19. Or see the ouput at watch window.

Note: watch window will show exact decimal values, processor memory location will show a hexadecimal values.

Program

#include "DSP281x_Device.h"

#include <math.h>

void InitSystem();

void Bit_reversal();

float xr[8],xi[8],s1r[8],s1i[8],s2r[8],s2i[8],Xr[8],Xi[8],Yr[8],Yi[8],tempr[8],tempi[8];

float tr[8] = {7, -0.707,  0, 0.707, 1,  0.707,  0, -0.707 };     // real part  input

float ti[8] = {0,  0.707,  1, 0.707, 0, -0.707, -1, -0.707 };     // imaginary part input

const float W0r = 1,

W0i = 0,

W1r = 0.707,

W1i = -0.707,

W2r = 0,

W2i = -1,

W3r = -0.707,

W3i = -0.707;

void main()

{

int *Seq_out;

int i=0,j=0,k=1;

Seq_out = (int *)0x003F9200;

InitSystem();

Bit_reversal()        ;

// stage one process

s1r[0] = (xr[0] + xr[1]);

s1i[0] = (xi[0] + xi[1]);

s1r[1] = (xr[0] - xr[1]);

s1i[1] = (xi[0] - xi[1]);

s1r[2] = (xr[2] + xr[3]);

s1i[2] = (xi[2] + xi[3]);

s1r[3] = (xr[2] - xr[3]);

s1i[3] = (xi[2] - xi[3]);

s1r[4] = (xr[4] + xr[5]);

s1i[4] = (xi[4] + xi[5]);

s1r[5] = (xr[4] - xr[5]);

s1i[5] = (xi[4] - xi[5]);

s1r[6] = (xr[6] + xr[7]);

s1i[6] = (xi[6] + xi[7]);

s1r[7] = (xr[6] - xr[7]);

s1i[7] = (xi[6] - xi[7]);

// stage two process

s2r[0] = (s1r[0] + s1r[2]);

s2i[0] = (s1i[0] + s1i[2]);

tempr[0] = (s1r[3] * W2r) - (s1i[3] * W2i);

tempi[0] = (s1r[3] * W2i) + (s1i[3] * W2r);

s2r[1] = s1r[1] + tempr[0];

s2i[1] = s1i[1] + tempi[0];

s2r[2] = (s1r[0] - s1r[2]);

s2i[2] = (s1i[0] - s1i[2]);

s2r[3] = s1r[1] - tempr[0];

s2i[3] = s1i[1] - tempi[0];

s2r[4] = (s1r[4] + s1r[6]);

s2i[4] = (s1i[4] + s1i[6]);

tempr[1] = ((s1r[7] * W2r) - (s1i[7] * W2i));

tempi[1] = ((s1r[7] * W2i) + (s1i[7] * W2r));

s2r[5] = s1r[5] + tempr[1];

s2i[5] = s1i[5] + tempi[1];

s2r[6] = (s1r[4] - s1r[6]);

s2i[6] = (s1i[4] - s1i[6]);

s2r[7] = s1r[5] - tempr[1];

s2i[7] = s1i[5] - tempi[1];

//  output

// complex multiplication for B * Wn

Yr[0] = (s2r[4] * W0r) - (s2i[4] * W0i);

Yi[0] = (s2r[4] * W0i) + (s2i[4] * W0r);

Yr[1] = (s2r[5] * W1r) - (s2i[5] * W1i);

Yi[1] = (s2r[5] * W1i) + (s2i[5] * W1r);

Yr[2] = (s2r[6] * W2r) - (s2i[6] * W2i);

Yi[2] = (s2r[6] * W2i) + (s2i[6] * W2r);

Yr[3] = (s2r[7] * W3r) - (s2i[7] * W3i);

Yi[3] = (s2r[7] * W3i) + (s2i[7] * W3r);

// complex addition for A + BWn

for(i=0;i<4;i++)

{

Xr[i] = s2r[i] + Yr[i];

Xi[i] = s2i[i] + Yi[i];

}

// complex subtraction for A - BWn

j=0;

for(i=4;i<8;i++)

{

Xr[i] = s2r[j] - Yr[j];

Xi[i] = s2i[j] - Yi[j];

j++;

}

// sending output array to memory location

for(i=0;i<8;i++)

{

*Seq_out ++= Xr[i];

}

for(;;);

}

void InitSystem()

{

EALLOW;

SysCtrlRegs.WDCR= 0x0068;            // Setup the watchdog

// 0x0068  to disable the Watchdog , Prescaler = 1

// 0x00AF  to NOT disable the Watchdog, Prescaler = 64

SysCtrlRegs.SCSR = 0;                  // Watchdog generates a RESET

SysCtrlRegs.PLLCR.bit.DIV = 10;        // Setup the Clock PLL to multiply by 5

SysCtrlRegs.HISPCP.all = 0x1; // Setup Highspeed Clock Prescaler to divide by 2

SysCtrlRegs.LOSPCP.all = 0x2; // Setup Lowspeed CLock Prescaler to divide by 4

// Peripheral clock enables set for the selected peripherals.

SysCtrlRegs.PCLKCR.bit.EVAENCLK=0;

SysCtrlRegs.PCLKCR.bit.EVBENCLK=0;

SysCtrlRegs.PCLKCR.bit.SCIAENCLK=0;

SysCtrlRegs.PCLKCR.bit.SCIBENCLK=0;

SysCtrlRegs.PCLKCR.bit.MCBSPENCLK=0;

SysCtrlRegs.PCLKCR.bit.SPIENCLK=0;

SysCtrlRegs.PCLKCR.bit.ECANENCLK=0;

EDIS;

}

void Bit_reversal()

{

xr[0] = tr[0];

xr[1] = tr[4];

xr[2] = tr[2];

xr[3] = tr[6];

xr[4] = tr[1];

xr[5] = tr[5];

xr[6] = tr[3];

xr[7] = tr[7];

xi[0] = ti[0];

xi[1] = ti[4];

xi[2] = ti[2];

xi[3] = ti[6];

xi[4] = ti[1];

xi[5] = ti[5];

xi[6] = ti[3];

xi[7] = ti[7];

}

Result

Thus, the 8 point IDFT of given complex value has performed and the result is stored at memory location(0x3F9200).

Join the World's Largest Technical Community

we respect your privacy.