C语言实现估计信号的幅度

思路：

1、对复序列做FFT变换
2、得到序列的幅度谱
3、找出幅度谱的最大值即为序列的幅度

matlab实现

close all;
clear all;
clc;

count=4;
y=[1+2i,3+4i,5+6i,7+8i];
y_FFT=fft(y,count)  % 傅里叶变换
P=abs(y_FFT)/count  %  幅度谱
u=max(P)            % 得到波束1接收到的信号的幅度值

仿真结果

C语言实现

/************FFT***********/
#include   <stdio.h>
#include   <math.h>
#include   <stdlib.h>

#define PI 3.1415926535897931
#define   N   1000
#define count 4  //输入序列的长度，只限2的N次方  count个复数
 
typedef   struct//结构体
 {
	double   real;
	double   img;
 }complex;
  
//complex   x[N];
complex  *W;//输出序列的值

complex  x[N] = {1.0, 2.0, 3.0, 4.0, 5,6, 7,8}; // 1+2i,3+4i,5+6i,7+8i   所有的数据按照 实部、虚部 依次放入数组中



/*****************************
            子函数
*****************************/
  void   fft(); /*快速傅里叶变换*/
  void   initW();
  void   change();
  void   add(complex   ,complex   ,complex   *);   /*复数加法*/   
  void   mul(complex   ,complex   ,complex   *);   /*复数乘法*/   
  void   sub(complex   ,complex   ,complex   *);   /*复数减法*/   
  void   divi(complex   ,complex   ,complex   *);/*复数除法*/   
  void   output(); /*输出结果*/

  double fun_1();



/*****************************
             主函数
*****************************/
int   main()
 {

	initW();
	fft();   

	output();
	fun_1();
	return 0;   
 }   
 
  
/*****************************
       基-2 FFT运算
*****************************/
void   fft()   
{   
  int   i=0,j=0,k=0,l=0;   
  complex   up,down,product;   
  change();   
  for(i=0;i<log(count)/log(2) ;i++)
  {       
	l=1<<i;   
	for(j=0;j<count;j+=2*l)
	{                           
		for(k=0;k<l;k++)
		{                 
			mul(x[j+k+l],W[count*k/2/l],&product);   
			add(x[j+k],product,&up);   
			sub(x[j+k],product,&down);   
			x[j+k]=up;   
			x[j+k+l]=down;   
		}   
	}   
  }   
}   
     
    
/*****************************
         
*****************************/
void   initW()   
 {   
	int   i;   
	W=(complex   *)malloc(sizeof(complex)   * count);   
	for(i=0;i<count;i++)   
	{   
		W[i].real=cos(2*PI/count*i);   
		W[i].img=-1*sin(2*PI/count*i);   
	}   
 }   
 
   
/*****************************
         
*****************************/
void   change()   
{   
	complex   temp;   
	unsigned   short   i=0,j=0,k=0;   
	double   t;   
	for(i=0;i<count;i++)   
	{   
		k=i;j=0;   
		t=(log(count)/log(2));   
		while(   (t--)>0   )   
		{   
			j=j<<1;   
			j|=(k   &   1);   
			k=k>>1;   
		}   
		if(j>i)   
		{   
			temp=x[i];   
			x[i]=x[j];   
			x[j]=temp;   
		}   
	}   
}   
    
/*****************************
         输出结果
*****************************/
void   output()   
{   
	int   i;   
	printf("FFT运算的结果为：\n");   
	for(i=0;i<count;i++)   
	{   
		printf("%.4f",x[i].real);   
		if(x[i].img>=0.0001)   
			printf("+%.4fj\n",x[i].img);   
		else   if(fabs(x[i].img)<0.0001)   
			printf("\n");   
		else     
			printf("%.4fj\n",x[i].img);   
	}   
} 


/*****************************
   函数功能：  根据FFT的计算结果得到该序列的幅度
*****************************/
double fun_1()
{
	int i;
	double u=0.0;
	double sum[count];
	for(i=0;i<count;i++)   
	{
		sum[i]=sqrt(x[i].real*x[i].real+x[i].img*x[i].img)/count;//幅度谱 P
		// printf("%.4f\n",sum[i]);
	}
	//找幅度谱的最大值的最大值
	for(i=0; i<count; i++)
	{
		if(sum[i]>u)
		{
			u = sum[i];
		}
	}
	printf("波束接收序列的幅度为%.4f\n",u);
	return u;
}




/*****************************
         复数加法
*****************************/  
void   add(complex   a,complex   b,complex   *c)   
{   
	c->real=a.real+b.real;   
	c->img=a.img+b.img;   
 }   
  
/*****************************
         复数乘法
*****************************/   
void   mul(complex   a,complex   b,complex   *c)   
{   
	c->real=a.real*b.real   -   a.img*b.img;   
	c->img=a.real*b.img   +   a.img*b.real;   
}
  
/*****************************
         复数减法
*****************************/ 
void   sub(complex   a,complex   b,complex   *c)   
{   
	c->real=a.real-b.real;   
	c->img=a.img-b.img;   
}
  
/*****************************
         复数除法
*****************************/ 
void   divi(complex   a,complex   b,complex   *c)   
{   
	c->real=(   a.real*b.real+a.img*b.img   )/( b.real*b.real+b.img*b.img);    
	c->img=(   a.img*b.real-a.real*b.img)/(b.real*b.real+b.img*b.img);   
}

仿真结果