fft.c

Calculates the FFT of any sequence and its written in C language

#include "xparameters.h"
#include "math.h"
#include "xtmrctr.h"
#include "xintc.h"


#define MAX 128


int m =0;
int n =MAX;
double rin[MAX];                     // Real part of input 
double iin[MAX];                     // Imaginary part of input


double cossine (double n)
{
  return cos(n);
}


double ssine (double p)
{
  return sin(p);
}

void fft()
{
  
  int i,j,k,n1,n2;
  double c,s,e,a,t1,t2;        
         
  
  j = 0; /* bit-reverse */
  n2 = n/2;
  for (i=1; i < n - 1; i++)
  {
    n1 = n2;
    while ( j >= n1 )
    {
     j = j - n1;
     n1 = n1/2;
    }
    j = j + n1;
               
    if (i < j)
    {
      t1 = rin[i];
      rin[i] = rin[j];
      rin[j] = t1;
      t1 = iin[i];
      iin[i] = iin[j];
      iin[j] = t1;
    }
   }
                                       
                                           
    n1 = 0; /* FFT */
    n2 = 1;
                                             
    for (i=0; i < m; i++)
    {
      n1 = n2;
      n2 = n2 + n2;
      e = -6.283185/n2;
      a = 0.0;
                                             
      for (j=0; j < n1; j++)
      {
         c = cossine(a);
         s = ssine(a);
         a = a + e;
                                            
            for (k=j; k < n; k=k+n2)
            {
                 t1 = c*rin[k+n1] - s*iin[k+n1];
                 t2 = s*rin[k+n1] + c*iin[k+n1];
                 rin[k+n1] = rin[k] - t1;
                 iin[k+n1] = iin[k] - t2;
                 rin[k] = rin[k] + t1;
                 iin[k] = iin[k] + t2;
            }
       }
      // xil_printf("num is %d \n",i);
    }
}


void ham()
{
  unsigned int l;

  for(l =0 ;l < MAX ;l++)
  {
     rin[l] = (0.46 -0.54 * cossine ((2* 3.14* l)/(MAX - 1)))* rin[l] ;
  }
}

void output()
{
  int a,b,c;
  
  for (a =0 ; a <MAX ; a++)
  {
    b = rin[a] *10000;
    c= iin[a]*10000;
    xil_printf("%d +j %d \n",b,c);
	    
  }

}   

int main()
{
  
  unsigned int m1,k; 
  
  xil_printf("mvalue initialization");
  k =MAX;
  while(k>0)
  {
    k =k/2;
	 m++;
  }	 

  
  XIntc_mMasterEnable(XPAR_XPS_INTC_0_BASEADDR);
  XIntc_SetIntrSvcOption(XPAR_XPS_INTC_0_BASEADDR, XIN_SVC_ALL_ISRS_OPTION);
  XIntc_mEnableIntr(XPAR_XPS_INTC_0_BASEADDR, 0x11111111);
  microblaze_enable_interrupts();

  for( m1 = 0 ; m1 <MAX ; m1++)
  {
    rin[m1] = 0.1 + .02*m;
    iin[m1] = 0.0;
  }
  
  xil_printf("hamming start\n");
  ham();                      //hamming window

  xil_printf("fft start\n");
  fft();

  xil_printf("done\n");
  return 0;

}