TMS320C6748: Real time FFT

	
 
 *=============================================================*
 * DESCRIPTION                                                 *
 *                                                             * 
 *															   *
 *                                                             *
 *   Number of points for FFT (PTS) 256                        *              *
 *     														   *
 *                                                             * 
 * 															   *
 * ============================================================*/






#define PTS 256			    //# of points for FFT
typedef struct {float real,imag;} COMPLEX;
extern COMPLEX w[PTS];       	    //twiddle constants stored in w

void FFT(COMPLEX *Y, int N)      //input sample array, # of points     
{
 COMPLEX temp1,temp2;             //temporary storage variables          
 int i,j,k;                       //loop counter variables               
 int upper_leg, lower_leg;   	    //index of upper/lower butterfly leg   
 int leg_diff;                    //difference between upper/lower leg   
 int num_stages = 0;              //number of FFT stages (iterations)
 int index, step;                 //index/step through twiddle constant
 i = 1;                           //log(base2) of N points= # of stages  
 do
  {
   num_stages +=1;
   i = i*2;
  }while (i!=N);
 leg_diff = N/2; 		     	    //difference between upper&lower legs
 step = (PTS*2)/N;   		     	    //step between values in twiddle.h   // 512           
 for (i = 0;i < num_stages; i++)  //for N-point FFT                 
  {
   index = 0;
   for (j = 0; j < leg_diff; j++)
    {
     for (upper_leg = j; upper_leg < N; upper_leg += (2*leg_diff))
      {   
       lower_leg = upper_leg+leg_diff;
	 temp1.real = (Y[upper_leg]).real + (Y[lower_leg]).real;
       temp1.imag = (Y[upper_leg]).imag + (Y[lower_leg]).imag;
       temp2.real = (Y[upper_leg]).real - (Y[lower_leg]).real;
       temp2.imag = (Y[upper_leg]).imag - (Y[lower_leg]).imag;
       (Y[lower_leg]).real = temp2.real*(w[index]).real
				    -temp2.imag*(w[index]).imag;
       (Y[lower_leg]).imag = temp2.real*(w[index]).imag
				    +temp2.imag*(w[index]).real;
       (Y[upper_leg]).real = temp1.real;
       (Y[upper_leg]).imag = temp1.imag;
      }
   index += step;
    }
     leg_diff = leg_diff/2;
     step *= 2;
      }
       j = 0;
       for (i = 1; i < (N-1); i++)     //bit reversal for resequencing data
      {
     k = N/2;
     while (k <= j)
      {
       j = j - k;
       k = k/2;
      }
     j = j + k;
     if (i<j)
      {
       temp1.real = (Y[j]).real;
       temp1.imag = (Y[j]).imag;
       (Y[j]).real = (Y[i]).real;
       (Y[j]).imag = (Y[i]).imag;
       (Y[i]).real = temp1.real;
       (Y[i]).imag = temp1.imag;
      }
    }
   return;
}

*******************************************************************************
 *=============================================================*
 * DESCRIPTION                                                 *
 *                                                             * 
 *															   *
 *                                                             *
 *   Number of points for FFT (PTS) 256                        *              *
 *     														   *
 *   iobuffer --> input signal                                                             * 
 * 	 sample --> output of FFT function (don't use on graoh window)
 *   x1 --> use in graph window 														   *
 * ============================================================*/


//FFT256c.c FFT implementation calling a C-coded FFT function 

#include <math.h>                          
#define PTS 256		    //# of points for FFT
#define PI 3.14159265358979
typedef struct {float real,imag;} COMPLEX;
void FFT(COMPLEX *Y, int n);	    //FFT prototype
float iobuffer[PTS];   		    //as input and output buffer
float x1[PTS];         		    //intermediate buffer 
short i;               		    //general purpose index variable                  
short buffercount = 0;     	    //number of new samples in iobuffer         
short flag = 0;        		    //set to 1 by ISR when iobuffer full   
COMPLEX w[PTS];       		    //twiddle constants stored in w 
COMPLEX samples[PTS];  		    //primary working buffer                                              

main()
{
 for (i = 0 ; i<PTS ; i++)	    // set up twiddle constants in w 
  {
   w[i].real = cos(2*PI*i/(PTS*2.0)); //Re component of twiddle constants
   w[i].imag =-sin(2*PI*i/(PTS*2.0)); //Im component of twiddle constants
  }
  
   
   for (i = 0 ; i < PTS ; i++)    //swap buffers
    {
   
     iobuffer[i] = sin(2*PI*30*i/PTS);/*10- > freq,100 -> sampling freq*/
     samples[i].real=0.0;
     samples[i].imag=0.0;
    } 
   

   for (i = 0 ; i < PTS ; i++)    //swap buffers
    {
     samples[i].real=iobuffer[i]; //buffer with new data
   /*  iobuffer[i] = x1[i];         //processed frame to iobuffer*/
    } 
   for (i = 0 ; i < PTS ; i++)
     samples[i].imag = 0.0;	    //imag components = 0

   FFT(samples,PTS);              //call function FFT.c

   for (i = 0 ; i < PTS ; i++)    //compute magnitude
    {
     x1[i] = sqrt(samples[i].real*samples[i].real 
	     + samples[i].imag*samples[i].imag);///32;
    }

  
} 					    //end of main