You have no items in your shopping cart.

Subtotal: 0.00

IDFT 8 POINT DIF USING TMS320C6745 DSP

Aim

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


Requirements


 
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

IDFT 8 DIT formula
Procedure

1. Open Code Composer Studio v4 .


2. In WorkSpace Launcher.


  • BROWSE → Select the project location and make one new folder, MAKE NEW FOLDER → Type the Workspace name, OK → OK.

3. FILE ⇒ NEW ⇒ CCS PROJECT


  • Project name: Type your project name.
  • Tick use default location. → NEXT
  • Project type C6000.
  • Tick Debug And Release. → NEXT → NEXT.
  • Output type: Executable.
  • Device Variant : generic - TMS320C6745.
  • Device Endianness : little
  • Code Generation Tools: TI v6.1.12.
  • Run time support library: automatic.
  • Target content: none. →FINISH

4.FILE ⇒ NEW ⇒ SOURCE FILE

  • Source file: Type your projectname.c( .c extension is must ).
  • Type the program.
  • FILE → SAVE.

5. Paste the following board library files in workspace location.


  • Common folder (contains header files)
  • Gel folder (contains gel file)
  • Library folder(contains library files)

6. Paste the Linker file in the project location.(linker file is available in cd)


Note: Those folders and linker file are availble at cd.


7. PROJECT ⇒ PROPERTIES ⇒ C/C++ BUILD → BASIC OPTION


  • Target processor version(--silicon version, -mv)    :   6400+ OK.
  • IN C/C++ BUILD, INCLUDE OPTIONS (Add dir to #include search path(--include_path,-I)) select this add icon add iconand add the following three path by indivdually
       -  "${Diag}../../common/header"
       -  "${XDAIS_CG_ROOT}/packages/ti/xdais"
       -  "${C6000_CSL_CG_ROOT}/include"

8. FILE ⇒ NEW ⇒ TARGET CONFIGURATION FILE


  • file name: projectname. ccxml (.ccxml extension is must)
  • Connection: Texas Instrument XDS100 v1 USB Emulator.
  • Device: TMS320C6745. (Tick the TMS320C6745)→ SAVE → TARTGET CONFIGURATION → C674X_0 → BROWSE, browse the workspace location, open the gel folder and select the GEL file. → OPEN → SAVE.

9. In C/C++ Project window, Right click the project ⇒ REBUILD PROJECT.


10. Connections


  • Connect the usb cable, PC to TMS320C6745 KIT.
  • Connect the 5v adapter.
  • Power on the kit.

11. TARGET ⇒ DEBUG ACTIVE PROJECT.


12. VIEW ⇒ MEMORY


13. In right side, memory window will open. Type the adrress to see th results.


  • Enter An Address:0xC0001000 Enter.(Sequence output)

Note : Result will display after the run and halt the processor.


14. View ⇒ Watch window ⇒ watch1.


  • Type the following array variable.    -  tr( Sequence output)

15. DEBUG ⇒ RUN.


16. DEBUG ⇒ HALT.


17. See output at memory window.

X(n)                                        

0xC0001000 – 00000008 

0xC0001004 – 00000007

0xC0001008 – 00000008 

0xC000100C – 00000007

0xC0001010 – 00000000

0xC0001014 – 00000000

0xC0001018 – 00000000

0xC000101C – 00000000

18. Or see the ouput at watch window.

ouput at watch window

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


Program
#include 

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

const float xr[8] = {4,      1,  0,     1,  0,      1,  0,      1 }; // real part input

const float xi[8] = {0,  2.414,  0, 0.414,  0, -0.414,  0, -2.414 }; // 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;

        Seq_out = (int *)0xC0001000;

// stage one process

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

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

 

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

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

 

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

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

 

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

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

 

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

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

 

                tempr[0] = (xr[1] - xr[5]);

                tempi[0] = (xi[1] - xi[5]);

        s1r[5] = ((tempr[0] * W1r) - (tempi[0] * W1i));

        s1i[5] = ((tempr[0] * W1i) + (tempi[0] * W1r));

 

                tempr[1] = (xr[2] - xr[6]);

                tempi[1] = (xi[2] - xi[6]);

        s1r[6] = ((tempr[1] * W2r) - (tempi[1] * W2i));

        s1i[6] = ((tempr[1] * W2i) + (tempi[1] * W2r));

 

                tempr[2] = (xr[3] - xr[7]);

                tempi[2] = (xi[3] - xi[7]);

        s1r[7] = ((tempr[2] * W3r) - (tempi[2] * W3i));

        s1i[7] = ((tempr[2] * W3i) + (tempi[2] * W3r));

 

// stage two process

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

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

 

        s2r[1] = (s1r[1] + s1r[3]);

        s2i[1] = (s1i[1] + s1i[3]);

 

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

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

       

                tempr[3] = (s1r[1] - s1r[3]);

                tempi[3] = (s1i[1] - s1i[3]);

        s2r[3] = ((tempr[3] * W2r) - (tempi[3] * W2i));

        s2i[3] = ((tempr[3] * W2i) + (tempi[3] * W2r));

 

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

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

 

        s2r[5] = (s1r[5] + s1r[7]);

        s2i[5] = (s1i[5] + s1i[7]);

 

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

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

 

                tempr[4] = s1r[5] - s1r[7];

                tempi[4] = s1i[5] - s1i[7];

        s2r[7] = ((tempr[4] * W2r) - (tempi[4] * W2i));

        s2i[7] = ((tempr[4] * W2i) + (tempi[4] * W2r));

 

//  output

; Xr[0] = (s2r[0] + s2r[1]);

Xi[0] = (s2i[0] + s2i[1]);

Xr[1] = (s2r[0] - s2r[1]);;

Xi[1] = (s2i[0] - s2i[1]);

Xr[2] = (s2r[2] + s2r[3]);

Xi[2] = (s2i[2] + s2i[3]);

Xr[3] = (s2r[2] - s2r[3]);

Xi[3] = (s2i[2] - s2i[3]);

Xr[4] = (s2r[4] + s2r[5]);

Xi[4] = (s2i[4] + s2i[5]);

Xr[5] = (s2r[4] - s2r[5]);

Xi[5] = (s2i[4] - s2i[5]);

Xr[6] = (s2r[6] + s2r[7]);

Xi[6] = (s2i[6] + s2i[7]);

Xr[7] = (s2r[6] - s2r[7]);

Xi[7] = (s2i[6] - s2i[7]);

 

// bit reversal

tr[0] = Xr[0];

ti[0] = Xi[0];

tr[1] = Xr[4];

ti[1] = Xi[4];

tr[2] = Xr[2];

ti[2] = Xi[2];

tr[3] = Xr[6];

ti[3] = Xi[6];

tr[4] = Xr[1];

ti[4] = Xi[1];

tr[5] = Xr[5];

ti[5] = Xi[5];

tr[6] = Xr[3];

ti[6] = Xi[3];

tr[7] = Xr[7];

ti[7] = Xi[7];

 

// sending output array to memory location        

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

        {      

                *Seq_out ++= tr[i];

        }

                for(;;);

}
Result

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