You have no items in your shopping cart.

Subtotal: 0.00

Aim

To perform the 8 point IDFT using DIT 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-icon and 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.
       -  Xr( Sequence output)

15. DEBUG ⇒ RUN.


16. DEBUG ⇒ HALT.


17. See output memory window. X(n)


                                       

0xC0001000 – 00000008 

0xC0001004 – 00000008

0xC0001008 – 00000008 

0xC000100C – 00000007

 

0xC0001010 – 00000000

0xC0001014 – 00000000

0xC0001018 – 00000000

            0xC000101C – 00000000


18. Or see the ouput at watch window.




idft8 dit output-watch-window


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


Program

 

#include <math.h>

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;

 

        Seq_out = (int *)0xC0001000;

        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 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(0xC0001000).