corre.cpp

扩频通信中采用的线性调频算法用的复相关算法

//**********************************************************************************************
//                              未减采样
//**********************************************************************************************
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <fstream.h>
#include <iostream.h>

#define pi 3.14159265359
#define B 2000.0       //带宽
#define f0 10000.0      //中心频率
#define T 0.02

#define k1 (-1*B/T)
#define k2 (0.75*B/T)
#define k3 (-0.75*B/T)
#define k4 (0.5*B/T)
//#define k5 (1*B/T)
#define f 100000.0     //采样频率
#define len 37000      //小于等于（读入数据的长度－一个Pattern的长度） 
#define Length 40000   //小于等于读入数据的长度
#define ReferLength 2000

//#define WindowLength 2000

//滤波器调用函数
void filter(int length, double a[6], double b[6], double* x, double* y);
//滤波器调用函数完毕

void main()
{
	int i,j,k;
 
    double a[6]={1.0000, -4.5880, 8.5748, -8.1528, 3.9413, -0.7749};
	double b[6]={0.000014, 0.0000701, 0.0001403, 0.0001403, 0.0000701, 0.000014};
	double c[6]={1.0000, -3.9845, 6.4349, -5.2536, 2.1651, -0.3599};
    double d[6]={0.0000598, 0.000299, 0.000598, 0.000598, 0.000299, 0.0000598};

    double *ReceivedISignal = new double[Length];
    double *ReceivedQSignal = new double[Length];

    double *ReferSignalIOne = new double[ReferLength];
    double *ReferSignalQOne = new double[ReferLength];
    double *ReferSignalITwo = new double[ReferLength];
    double *ReferSignalQTwo = new double[ReferLength];
    double *ReferSignalIThree = new double[ReferLength];
    double *ReferSignalQThree = new double[ReferLength];
    double *ReferSignalIFour = new double[ReferLength];
    double *ReferSignalQFour = new double[ReferLength];
//    double *ReferSignalIFive = new double[ReferLength];
//    double *ReferSignalQFive = new double[ReferLength];
    

	
	double *dataIn = new double[Length];               //读入的数据
    double *BeforFilterI = new double[Length];         //中频解调之后的数据I路
    double *BeforFilterQ = new double[Length];         //中频解调之后的数据Q路


    
	double *ReceiveddataI = new double[ReferLength];
    double *ReceiveddataQ = new double[ReferLength];
	
    double CorrelationIIOne_x;    
    double CorrelationQQOne_x;
	double CorrelationIQOne_x;
	double CorrelationQIOne_x;
	double CorrelationIOne_y;
	double CorrelationQOne_y;
	double CorrelationOne;

	double CorrelationIITwo_x;    
    double CorrelationQQTwo_x;
	double CorrelationIQTwo_x;
	double CorrelationQITwo_x;
	double CorrelationITwo_y;
	double CorrelationQTwo_y;
	double CorrelationTwo;

	double CorrelationIIThree_x;    
    double CorrelationQQThree_x;
	double CorrelationIQThree_x;
	double CorrelationQIThree_x;
	double CorrelationIThree_y;
	double CorrelationQThree_y;
	double CorrelationThree;

	double CorrelationIIFour_x;    
    double CorrelationQQFour_x;
	double CorrelationIQFour_x;
	double CorrelationQIFour_x;
	double CorrelationIFour_y;
	double CorrelationQFour_y;
	double CorrelationFour;

//	double CorrelationIIFive_x;    
//    double CorrelationQQFive_x;
//	double CorrelationIQFive_x;
//	double CorrelationQIFive_x;
//	double CorrelationIFive_y;
//	double CorrelationQFive_y;
//	double CorrelationFive;

	///////////////////////////////////////////////////////////////////////////////////////////
	/////////////////////////////////////////////////////////////////////////////////////////////
	/////////////////////////////////////////////////////////////////////////////////////////////
	

   
	for(i=0;i<ReferLength;i++)
	{
        *(ReferSignalIOne+i)=cos(pi*k1*(i-ReferLength/2)*(i-ReferLength/2)/f/f);
        *(ReferSignalQOne+i)=sin(pi*k1*(i-ReferLength/2)*(i-ReferLength/2)/f/f);
        *(ReferSignalITwo+i)=cos(pi*k2*(i-ReferLength/2)*(i-ReferLength/2)/f/f);
        *(ReferSignalQTwo+i)=sin(pi*k2*(i-ReferLength/2)*(i-ReferLength/2)/f/f);
        *(ReferSignalIThree+i)=cos(pi*k3*(i-ReferLength/2)*(i-ReferLength/2)/f/f);
        *(ReferSignalQThree+i)=sin(pi*k3*(i-ReferLength/2)*(i-ReferLength/2)/f/f);
        *(ReferSignalIFour+i)=cos(pi*k4*(i-ReferLength/2)*(i-ReferLength/2)/f/f);
        *(ReferSignalQFour+i)=sin(pi*k4*(i-ReferLength/2)*(i-ReferLength/2)/f/f);
//	    *(ReferSignalIFive+i)=cos(pi*k5*(i-ReferLength/2)*(i-ReferLength/2)/f/f);
//        *(ReferSignalQFive+i)=sin(pi*k5*(i-ReferLength/2)*(i-ReferLength/2)/f/f);

	}

	
	/*写数据*/
	ifstream in("buf.txt");
	for(i=0;i<Length;i++)
	{	
		in>>dataIn[i];
	}
	in.close();

		
	
	/*中频解调和滤波器*/
	for(i=0;i<Length;i++)
	{
		*(BeforFilterI+i)=(*(dataIn+i))*cos(2*pi*f0*i*0.00001);
		*(BeforFilterQ+i)=(*(dataIn+i))*sin(2*pi*f0*i*0.00001);

		
		*(ReceivedISignal+i)=*(BeforFilterI+i);
		*(ReceivedQSignal+i)=*(BeforFilterQ+i);
		
	}
		
	filter(Length, a, b, BeforFilterI, ReceivedISignal);
	filter(Length, c, d, BeforFilterQ, ReceivedQSignal);
		
	for(i=0;i<Length;i++)
	{
		ReceivedISignal[i]=-ReceivedISignal[i];
		ReceivedQSignal[i]=ReceivedQSignal[i];
	}

  	for(k=0;k<len;k++)
	{   


		for(i=0;i<ReferLength;i++)
		{
			ReceiveddataI[i]=ReceivedISignal[k+i];
			ReceiveddataQ[i]=ReceivedQSignal[k+i];
		}
        CorrelationIIOne_x = 0.0;    
        CorrelationQQOne_x = 0.0;
		CorrelationIQOne_x = 0.0;
		CorrelationQIOne_x = 0.0;
		CorrelationIOne_y = 0.0;
		CorrelationQOne_y = 0.0;
		CorrelationOne = 0.0;

		CorrelationIITwo_x = 0.0;    
        CorrelationQQTwo_x = 0.0;
		CorrelationIQTwo_x = 0.0;
		CorrelationQITwo_x = 0.0;
		CorrelationITwo_y = 0.0;
		CorrelationQTwo_y = 0.0;
		CorrelationTwo = 0.0;

		CorrelationIIThree_x = 0.0;    
        CorrelationQQThree_x = 0.0;
		CorrelationIQThree_x = 0.0;
		CorrelationQIThree_x = 0.0;
		CorrelationIThree_y = 0.0;
		CorrelationQThree_y = 0.0;
		CorrelationThree = 0.0;

		CorrelationIIFour_x = 0.0;    
        CorrelationQQFour_x = 0.0;
		CorrelationIQFour_x = 0.0;
		CorrelationQIFour_x = 0.0;
		CorrelationIFour_y = 0.0;
		CorrelationQFour_y = 0.0;
		CorrelationFour = 0.0;

//    	CorrelationIIFive_x = 0.0;    
//        CorrelationQQFive_x = 0.0;
//		CorrelationIQFive_x = 0.0;
//		CorrelationQIFive_x = 0.0;
//		CorrelationIFive_y = 0.0;
//		CorrelationQFive_y = 0.0;
//		CorrelationFive = 0.0;



		for(j=0;j<ReferLength;j++)
		{
			
			CorrelationIIOne_x = CorrelationIIOne_x + ReferSignalIOne[j]*ReceiveddataI[j];
			CorrelationQQOne_x = CorrelationQQOne_x + ReferSignalQOne[j]*ReceiveddataQ[j];
			CorrelationIQOne_x = CorrelationIQOne_x + ReferSignalQOne[j]*ReceiveddataI[j];
			CorrelationQIOne_x = CorrelationQIOne_x + ReferSignalIOne[j]*ReceiveddataQ[j];
			
			CorrelationIITwo_x = CorrelationIITwo_x + ReferSignalITwo[j]*ReceiveddataI[j];
			CorrelationQQTwo_x = CorrelationQQTwo_x + ReferSignalQTwo[j]*ReceiveddataQ[j];
			CorrelationIQTwo_x = CorrelationIQTwo_x + ReferSignalQTwo[j]*ReceiveddataI[j];
			CorrelationQITwo_x = CorrelationQITwo_x + ReferSignalITwo[j]*ReceiveddataQ[j];
		
			CorrelationIIThree_x = CorrelationIIThree_x + ReferSignalIThree[j]*ReceiveddataI[j];
			CorrelationQQThree_x = CorrelationQQThree_x + ReferSignalQThree[j]*ReceiveddataQ[j];
			CorrelationIQThree_x = CorrelationIQThree_x + ReferSignalQThree[j]*ReceiveddataI[j];
			CorrelationQIThree_x = CorrelationQIThree_x + ReferSignalIThree[j]*ReceiveddataQ[j];

			CorrelationIIFour_x = CorrelationIIFour_x + ReferSignalIFour[j]*ReceiveddataI[j];
			CorrelationQQFour_x = CorrelationQQFour_x + ReferSignalQFour[j]*ReceiveddataQ[j];
			CorrelationIQFour_x = CorrelationIQFour_x + ReferSignalQFour[j]*ReceiveddataI[j];
			CorrelationQIFour_x = CorrelationQIFour_x + ReferSignalIFour[j]*ReceiveddataQ[j];

//			CorrelationIIFive_x = CorrelationIIFive_x + ReferSignalIFive[j]*ReceiveddataI[j];
//			CorrelationQQFive_x = CorrelationQQFive_x + ReferSignalQFive[j]*ReceiveddataQ[j];
//			CorrelationIQFive_x = CorrelationIQFive_x + ReferSignalQFive[j]*ReceiveddataI[j];
//			CorrelationQIFive_x = CorrelationQIFive_x + ReferSignalIFive[j]*ReceiveddataQ[j];

		}
		CorrelationIOne_y = CorrelationIIOne_x + CorrelationQQOne_x;
		CorrelationQOne_y = CorrelationQIOne_x - CorrelationIQOne_x;
		CorrelationOne = (CorrelationIOne_y*CorrelationIOne_y + CorrelationQOne_y*CorrelationQOne_y)/10000000.0;

		CorrelationITwo_y = CorrelationIITwo_x + CorrelationQQTwo_x;
		CorrelationQTwo_y = CorrelationQITwo_x - CorrelationIQTwo_x;
		CorrelationTwo = (CorrelationITwo_y*CorrelationITwo_y + CorrelationQTwo_y*CorrelationQTwo_y)/10000000.0;

		CorrelationIThree_y = CorrelationIIThree_x + CorrelationQQThree_x;
		CorrelationQThree_y = CorrelationQIThree_x - CorrelationIQThree_x;
		CorrelationThree = (CorrelationIThree_y*CorrelationIThree_y + CorrelationQThree_y*CorrelationQThree_y)/10000000.0;

		CorrelationIFour_y = CorrelationIIFour_x + CorrelationQQFour_x;
		CorrelationQFour_y = CorrelationQIFour_x - CorrelationIQFour_x;
		CorrelationFour = (CorrelationIFour_y*CorrelationIFour_y + CorrelationQFour_y*CorrelationQFour_y)/10000000.0;

//		CorrelationIFive_y = CorrelationIIFive_x + CorrelationQQFive_x;
//		CorrelationQFive_y = CorrelationQIFive_x - CorrelationIQFive_x;
//		CorrelationFive = (CorrelationIFive_y*CorrelationIFive_y + CorrelationQFive_y*CorrelationQFive_y)/100000000.0;
		
  
 //      CorrelationOne = fabs(CorrelationIOne+CorrelationQOne);
	   
//	   CorrelationTwo = fabs(CorrelationITwo+CorrelationQTwo);
		
//       CorrelationThree = fabs(CorrelationIThree+CorrelationQThree);
		
//       CorrelationFour = fabs(CorrelationIFour+CorrelationQFour);
        ofstream out1("CorrelationOne.txt",ios::ate);
		out1<<CorrelationOne<<endl;
		out1.close();
		ofstream out2("CorrelationTwo.txt",ios::ate);
		out2<<CorrelationTwo<<endl;
		out2.close();
		ofstream out3("CorrelationThree.txt",ios::ate);
		out3<<CorrelationThree<<endl;
		out3.close();
		ofstream out4("CorrelationFour.txt",ios::ate);
		out4<<CorrelationFour<<endl;
		out4.close();
//		ofstream out5("CorrelationFive.txt",ios::ate);
//		out5<<CorrelationFive<<endl;
//		out5.close();

/*		if(k==32+180+2000)
		{
			for(i=0;i<ReferLength;i++)
			{
				out<<ReceivedISignal[i+k+2000]<<endl;
			}
	        out.close();
			ofstream out5("ReceivedQSignal.txt");
			for(i=0;i<ReferLength;i++)
			{
				out5<<ReceivedQSignal[i+k+2000]<<endl;
			}
	        out5.close();
		}
/*		if(k==32+2000)
			cout<<CorrelationTwo<<endl;
		else if(k==32+2000+180)
			cout<<CorrelationTwo<<endl;
		else if(k==32+2000+180+2000)
		{
		//	cout<<CorrelationThree<<endl;
		 //   cout<<ReceivedISignal[k]<<endl;
		//	cout<<ReceivedISignal[k+1]<<endl;
	//	cout<<ReceivedISignal[k+1999]<<endl;
			ofstream out("ReceivedISignal.txt");
			for(i=0;i<ReferLength;i++)
			{
				out<<ReceivedISignal[k+i]<<endl;
			}
	        out.close();
	        ofstream out5("ReceivedQSignal.txt");
			for(i=0;i<ReferLength;i++)
			{
				out5<<ReceivedQSignal[i+k]<<endl;
			}
	        out5.close();
		}
		else if(k==32+2000+180+2000+180)
			cout<<CorrelationThree<<endl;
		else if(k==32+2000+180+2000+2000)
			cout<<CorrelationFour<<endl;
		else if(k==32+2000+180+2000+2000+180)
			cout<<CorrelationFour<<endl;
*/

		
	}
	//	cout<<CorrelationTwo<<endl;


	delete [] ReceivedISignal;
    delete [] ReceivedQSignal;
	
    delete [] ReferSignalQOne;
    delete [] ReferSignalITwo;
    delete [] ReferSignalQTwo;
    delete [] ReferSignalIThree;
    delete [] ReferSignalQThree;
    delete [] ReferSignalIFour;
    delete [] ReferSignalQFour;
//    delete [] ReferSignalIFive;
//    delete [] ReferSignalQFive;
    
	delete [] dataIn;
    delete [] BeforFilterI;
    delete [] BeforFilterQ;

 	delete [] ReceiveddataI;
    delete [] ReceiveddataQ;

}

//////////////////////////////////滤波器调用函数/////////////////////////////////
void filter(int length, double a[6], double b[6], double* x, double* y)
{
    y[0]=b[0]*x[0];
    y[1]=b[0]*x[1]+b[1]*x[0]-a[1]*y[0];
    y[2]=b[0]*x[2]+b[1]*x[1]+b[2]*x[0]-a[1]*y[1]-a[2]*y[0];
    y[3]=b[0]*x[3]+b[1]*x[2]+b[2]*x[1]+b[3]*x[0]-a[1]*y[2]-a[2]*y[1]-a[3]*y[0];
    y[4]=b[0]*x[4]+b[1]*x[3]+b[2]*x[2]+b[3]*x[1]+b[4]*x[0]-a[1]*y[3]-a[2]*y[2]-a[3]*y[1]-a[4]*y[0];
    for(int i=0;i<length-5;i++)
	{
		y[i+5]=b[0]*x[i+5]+b[1]*x[i+4]+b[2]*x[i+3]+b[3]*x[i+2]+b[4]*x[i+1]+b[5]*x[i]-a[1]*y[i+4]-a[2]*y[i+3]-a[3]*y[i+2]-a[4]*y[i+1]-a[5]*y[i];
	}
}