rereiver.cpp

多用户多载波时频域cdma扩频的仿真

#include <iostream>
using namespace std;
#include <complex>
#include "receiver.h"
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include<math.h>
#include<fstream>
#define PI 3.1415926535
#define sqr(x) ((x)*(x))
#define x1 8
#define x2 120000
#define x3 10

/////////////////////////////////////////////////////////
//                                                 ///
///              执行信息码时域扩频的接收过程      /////
//////////////////////////////////////////////////////////
void receiver::StartTdomainreceive ( )
{
	//int a[1000],b[1000]={0},ab[100][100],c[1000]={0},d[1000]={0},cd[100][100],z[100]={0},i,j,k,N2x;
	//FILE *fp;
	int i,j,k,N=10,n=3,number;
	
	double n1,**c,*d;
   complex<double> *TD=new complex<double>[x2];
    complex<double> *FD=new complex<double>[x2];
	n1=log(Fspreadfactor)/log(2);

 //////////////////////////////////////////////////////
 /*cout<<"\n";
 	cout<<"接收real"<<"\n";
	for(i=0;i<Fspreadfactor;i++)
	{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
       cout<<FFTRealIn[i][j]<<" ";
         cout<<"\n";
	}
	cout<<"\n";
 	cout<<"接收imag"<<"\n";
	for(i=0;i<Fspreadfactor;i++)
	{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
       cout<<FFTImagIn[i][j]<<" ";
         cout<<"\n";
	}

	*/



	FFTRealOut=Allocate2DArray(x1,x2);                         //动态2维数组分配内存,存放FFT变换的结果
     FFTImagOut=Allocate2DArray(x1,x2);                       //动态2维数组分配内存,存放FFT变换的结果

	 
 //cout<<"--------------FFT变换-------------------";
// cout<<"\n";
	 //cout<<numberofuserbit/2+numberofuserbit%2<<"\n";
	// cout<<Fspreadfactor<<"\n";
	// cout<<int(n1+0.5)<<"\n";
for(i=0;i<numberofuserbit/2+numberofuserbit%2;i++)          //进行FFT变换
{for( k=0;k<Fspreadfactor;k++)
 TD[k]=complex<double>(FFTRealIn[k][i], FFTImagIn[k][i]); 
//for( k=0;k<Fspreadfactor;k++)
// cout<<TD[k].real()<<"+"<<TD[k].imag()<<"i   ";
 // cout<<"\n"<<"-----------------------";
 FFT(TD,FD,int(n1+0.5),1);

  for( k=0;k<Fspreadfactor;k++)                               
  {FFTRealOut[k][i]=FD[k].real();                              //把变换的结果存入FFTRealOut
   FFTImagOut[k][i]=FD[k].imag();                              //把变换的结果存入FFTImagOut
  }
}

DeAllocate2DArray(FFTRealIn,x1);                                //释放内存FFTRealIn
DeAllocate2DArray(FFTImagIn,x1);                                //释放内存FFTImagIn
delete TD;
delete FD;


/////////////////////////////////////////输出////////////////////////////////////////////////////
/*cout<<"I支路FFT变换"<<"\n";
for(i=0;i<Fspreadfactor;i++)
  
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<FFTRealOut[i][j]<<" ";
    cout<<"\n";
}   
 cout<<"Q支路FFT变换"<<"\n";
for(i=0;i<Fspreadfactor;i++)
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<FFTImagOut[i][j]<<" ";
    cout<<"\n";
}*/
//////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////
/////////////////////////////

   Mseq=intAllocate2DArray(x3,x2);                        //为m序列分配内存
M_seq(4);                                             //产生m序列作为扩频码
for(j=1;j<numberofuser;j++)
  for(k=0;k<=20000;k++)
   Mseq[j][k]=Mseq[j-1][k+1];

  Walsh=intAllocate2DArray(x3,x2);                        //为Walsh序列分配内存
for(j=0;j<numberofuser;j++)
 walsh_gen(3,j);
/*cout<<"M序列"<<"\n";
for(j=0;j<numberofuser;j++)
{for(i=0; i<20; i++)
    cout<<Mseq[j][i] <<" ";
   cout<<"\n";
}

cout<<"Walsh序列"<<"\n";
for(j=0;j<numberofuser;j++)
{for(i=0; i<20; i++)
    cout<<Walsh[j][i] <<" ";
   cout<<"\n";
}*/
////////////////////////////




      c=Allocate2DArray(x1,x2);                                   //动态2维数组分配内存,为频域解扩用
    FDespreadRealout=Allocate2DArray(x1,x2);                       //动态2维数组分配内存,存放频域解扩的结果
    FDespreadImagout=Allocate2DArray(x1,x2);                       //动态2维数组分配内存,存放频域解扩的结果
      Despreadout=Allocate2DArray(x1,x2);                         //动态2维数组分配内存,为频域解扩用
for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
{ Despreadout[0][j]=0;
FDespreadRealout[0][j]=0;
FDespreadImagout[0][j]=0;
}
//cout<<Despreadout[0][0];
for(i=0;i<Fspreadfactor;i++)
   for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++)  
   {c[i][j]=FFTRealOut[i][j];                                     //把FFTRealOut赋予c
    //cout<<c[i][j]<<" ";
   }
 FdomainDespread(Fspreadfactor,c);                               //I支路频域解扩
for(i=0;i<Fspreadfactor;i++)
for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++)               //把I支路频域解扩的结果赋予TDespreadRealout
      FDespreadRealout[0][j]+=Despreadout[i][j];
 for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++)               //把I支路频域解扩的结果赋予TDespreadRealout
      FDespreadRealout[0][j]/=Fspreadfactor;               
//cout<<"\n";
for(i=0;i<Fspreadfactor;i++)                                     //把FFTImagOut赋予c
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
  {c[i][j]=FFTImagOut[i][j];
   // cout<<a[i][j]<<" ";
	}
} 
FdomainDespread(Fspreadfactor,c);                                 //Q支路频域解扩           
for(i=0;i<Fspreadfactor;i++)
for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
      FDespreadImagout[0][j]+=Despreadout[i][j];                   //把I支路频域解扩的结果赋予TDespreadImagout
for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++)               //把I支路频域解扩的结果赋予TDespreadImagout
      FDespreadImagout[0][j]/=Fspreadfactor;               
//cout<<"\n";
DeAllocate2DArray(Despreadout,x1);                                   //释放内存Despreadout
DeAllocate2DArray(c,x1);                                           //释放内存c
/////////////////////////////////////////输出////////////////////////////////////////////////////
/*cout<<"频域解扩I支路"<<"\n";
for(i=0;i<1;i++)
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
            cout<<FDespreadRealout[i][j]<<" ";
 cout<<"\n";
}
cout<<"频域域解扩Q支路"<<"\n";
for(i=0;i<1;i++)
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
            cout<<FDespreadImagout[i][j]<<" ";
 cout<<"\n";
}*/
//////////////////////////////////////////////////////////////////////////////////////////////////

 intDeAllocate2DArray(Mseq,x3);                                                          //释放内存Mseq  
    intDeAllocate2DArray(Walsh,x3);                       //删除内存Walsh
  DeAllocate2DArray(FFTRealOut,x1);                                   //释放内存FFTRealOut
DeAllocate2DArray(FFTImagOut,x1);                                   //释放内存FFTImagOut

                                               
Mseq=intAllocate2DArray(x3,x2);                        //为时域解扩的扩频码分配内存
M_seq(4);                                                            //产生m序列作为扩频码
for(j=1;j<numberofuser;j++)
  for(k=0;k<=20000;k++)
   Mseq[j][k]=Mseq[j-1][k+1];  

  Walsh=intAllocate2DArray(x3,x2);                        //为Walsh序列分配内存
for(j=0;j<numberofuser;j++)
 walsh_gen(3,j);

d=new double[x2];                                               //分配内存,用于时域扩频
TDespreadRealout=Allocate2DArray(x1,x2);                       //动态2维数组分配内存，存放时域扩频的结果
TDespreadImagout=Allocate2DArray(x1,x2);                       //动态2维数组分配内存，存放时域扩频的结果
Despreadout=Allocate2DArray(x1,x2);                           //动态2维数组分配内存，用于时域扩频                                                        //生成时域扩频码
 number=numberofuserbit/Tspreadfactor;

for(i=0;i<1;i++)
{ 

  for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++)                //令Despreadout初值为0
      Despreadout[0][j]=0;
  for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++)               //把FFTRealOut[i]的值赋予d
        d[j]=FDespreadRealout[i][j];
      /*for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
  cout<<d[j]<<" ";
  cout<<"\n";*/

  TdomainDespread(Tspreadfactor,d);                               //进行I支路时域解扩
  for(j=0;j<number/2+number%2;j++) 
     TDespreadRealout[i][j]=Despreadout[0][j];                     //把Despreadout[i]的值赋予DespreadRealout[i]
  
  for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
      Despreadout[0][j]=0;
  for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
  {  d[j]=FDespreadImagout[i][j];
  //cout<<d[j]<<" ";
  }
  TdomainDespread(Tspreadfactor,d);
  for(j=0;j<number/2+number%2;j++) 
  {TDespreadImagout[i][j]=Despreadout[0][j];
  //cout<<Despreadout[0][j];
  }


}
 numberofuserbit=number;
 intDeAllocate2DArray(Mseq,x3);                                    //释放内存Mseq  
  intDeAllocate2DArray(Walsh,x3);                                  //删除内存Walsh
 delete d;                                                        //释放内存d    
 DeAllocate2DArray(Despreadout,x1);                                //释放内存Despreadout
 DeAllocate2DArray(FDespreadRealout,x1);                           //释放内存FDespreadRealout
 DeAllocate2DArray(FDespreadImagout,x1);                           //释放内存FDespreadImagout

/////////////////////////////////////////输出////////////////////////////////////////////////////
/*cout<<"时域I支路"<<"\n";
for(i=0;i<1;i++)
  
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<TDespreadRealout[i][j]<<" ";
    cout<<"\n";
}  
cout<<"时域域Q支路"<<"\n";
for(i=0;i<1;i++)
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<TDespreadImagout[i][j]<<" ";
    cout<<"\n";
} */
//////////////////////////////////////////////////////////////////////////////////////////////////


 Demodulation=intAllocate2DArray(x1,x2);                       //动态2维数组分配内存,存放QPSK解调后的信号
DEQPSK(1);                                         //进行QPSK解调
/////////////////////////////////////////输出////////////////////////////////////////////////////
/*cout<<"解调合并"<<"\n";
for(i=0;i<1;i++)
{ for(j=0;j<numberofuserbit;j++) 
    cout<<Demodulation[i][j]<<" ";
 cout<<"\n";
}*/
//////////////////////////////////////////////////////////////////////////////////////////////////

 DeAllocate2DArray(TDespreadRealout,x1);                                   //释放内存
  DeAllocate2DArray(TDespreadImagout,x1);                                   //释放内存
FinalOut=new int[x2];
for(j=0;j<numberofuserbit;j++) 
 FinalOut[j]=0;
  for(j=0;j<numberofuserbit;j++) 
 { for(i=0;i<1;i++)
	 { FinalOut[j]+=Demodulation[i][j];
	 }
     if( FinalOut[j]>0) FinalOut[j]=1;
		 else FinalOut[j]=0;
 }
   

intDeAllocate2DArray(Demodulation,x1);                                   //释放内存
 /*cout<<"最终信号"<<"\n";
  for(i=0;i<numberofuserbit;i++) 
    cout<<FinalOut[i]<<" ";
 cout<<"\n";
 */
}
/////////////////////////////////////////////////////////
//                                                 ///
///               FFT变换                        /////
//////////////////////////////////////////////////////////

void receiver::FFT(complex<double> * TimeDomain, complex<double> * FreqDomain, int ex,int sign)
{
	
	long Nfft;        //进行傅立叶变换的数据个数
	int	i,j,k;     //定义循环变量
	int	Block;     //划分子块的大小
	int OffSet;    //计算偏移量
	double Angle;  //相位角度
	complex<double> *Wn,*Temp1,*Temp2,*Temp; //定义数据指针

	Nfft = 1 << ex; // 计算付立叶变换点数
	
	// 分配运算所需存储器
	Wn  = new complex<double>[Nfft / 2];
	Temp1 = new complex<double>[Nfft];
	Temp2 = new complex<double>[Nfft];
	
	for(i = 0; i < Nfft / 2; i++) //计算加权系数Wn
	{
		Angle = -i * PI * 2 / Nfft;  //计算相应的角度
		Wn[i] = complex<double> (cos(Angle), sin(Angle)); //计算对应的复数
	}

	for(j = 0; j < Nfft; j++)            //重新排列傅立叶变换结果的次序
	{
		OffSet = 0;                   //初始化原来的数据处理后的新位置
		for(i = 0; i < ex; i++)       //对位置序号的二进制进行倒序反转
		{
			if (j&(1<<i))             //提取二进制的位信息
			{
				OffSet+=1<<(ex-i-1);  //反转二进制位序
			}
		}
	   if(sign==1)	 Temp1[j]=TimeDomain[OffSet]; 
	   else {
		   Temp1[j]=FreqDomain[OffSet];
	   
	      // -imag (Temp1[j])->imag (Temp1[j]);
	    
		     Temp1[j]= complex<double> (real(Temp1[j]), -imag(Temp1[j]))  ;                      //按照新位序将结果重排
	         }     
	   
     	}

	// 采用时间抽取的蝶形算法进行快速傅立叶变换
	for(k = 0; k < ex; k++)  //迭代次数
	{
		for(j = 0; j < 1 << (ex-k-1); j++)  //每次迭代分块
		{
			Block = 1 << (k+1);  //块内数据量
			for(i = 0; i < Block / 2; i++)  //块内进行蝶形计算
			{
				OffSet = j * Block;  //计算偏移量
				Temp2[i + OffSet] = Temp1[i + OffSet] + Temp1[i + OffSet + Block / 2] * Wn[i * (1<<(ex-k-1))]; // A=a+b*Wn
				Temp2[i + OffSet + Block / 2] = Temp1[i + OffSet] - Temp1[i + OffSet + Block / 2] * Wn[i * (1<<(ex-k-1))]; //B=a-b*Wn
			}
		}
		Temp = Temp1;    Temp1 = Temp2;    Temp2 = Temp;    //交换操作和结果数据的指针
	}