rereiver.cpp

单用户dscdma的仿真

#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 128
#define X2 30000
/////////////////////////////////////////////////////////
//                                                 ///
///              执行信息码频域扩频的接收过程      /////
//////////////////////////////////////////////////////////
void receiver::StartFdomainreceive ( )
{
	//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,**c;
	double n1;
    complex<double> *TD=new complex<double>[12800];
    complex<double> *FD=new complex<double>[12800];
//double e[1000],f[10000],g[1000]={0},md[10][1000],de[10][1000],ee[10][100]={0},sp[10][100],I[10][100],Q[10][100],rI[10][1000],rQ[10][1000];
  // double dic[4],min,fI[10][1000],fQ[10][1000],finde[10][1000]={0},n;
 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维数组分配内存
     FFTImagOut=Allocate2DArray(X1,X2);                       //动态2维数组分配内存
cout<<"\n";
 cout<<"--------------FFT变换-------------------";
 cout<<"\n";
for(i=0;i<numberofuserbit/2+numberofuserbit%2;i++)
{for( k=0;k<Fspreadfactor;k++)
 TD[k]=complex<double>(FFTRealIn[k][i], FFTImagIn[k][i]); 
for( k=0;k<8;k++)
 cout<<TD[k].real()<<"+"<<TD[k].imag()<<"i   ";
  cout<<"\n"<<"-----------------------";
 FFT(TD,FD,int(n1+0.5),1);
for( k=0;k<8;k++)
 cout<<FD[k].real()<<"+J"<<FD[k].imag()<<"   ";
  cout<<"\n";
  for( k=0;k<Fspreadfactor;k++)
  {FFTRealOut[k][i]=FD[k].real();
   FFTImagOut[k][i]=FD[k].imag();
  }
}
DeAllocate2DArray(FFTRealIn,X1);                                   //释放内存
DeAllocate2DArray(FFTImagIn,X1);                                   //释放内存
 cout<<"I支路"<<"\n";
for(i=0;i<Fspreadfactor;i++)
  
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<FFTRealOut[i][j]<<" ";
    cout<<"\n";
}   
 cout<<"Q支路"<<"\n";
for(i=0;i<Fspreadfactor;i++)
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<FFTImagOut[i][j]<<" ";
    cout<<"\n";
} 
/////////////////////////////
 Demodulation=intAllocate2DArray(X1,X2);                       //动态2维数组分配内存
DEQPSK(Fspreadfactor);
cout<<"解调合并"<<"\n";
for(i=0;i<Fspreadfactor;i++)
{ for(j=0;j<numberofuserbit;j++) 
    cout<<Demodulation[i][j]<<" ";
 cout<<"\n";
}
DeAllocate2DArray(FFTRealOut,X1);                                   //释放内存
DeAllocate2DArray(FFTImagOut,X1);                                   //释放内存
  /////////////////////////////////////////////////
c=intAllocate2DArray(X1,X2); 
for(i=0;i<Fspreadfactor;i++)
 for(j=0;j<numberofuserbit;j++) 
      c[i][j]=Demodulation[i][j];
 intDeAllocate2DArray(Demodulation,X1);                                   //释放内存
Mseq=new int[30000];
M_seq(n);
/*cout<<"M序列"<<"\n";
for(i=0; i<100; i++)
    cout<<Mseq[i] <<" ";
   cout<<"\n";
*/
////////////////////////////
  /*Despreadout=new int[30000];
   Despreadout[0]=0;
FdomainDespread(Fspreadfactor,c);
  delete Mseq;
  intDeAllocate2DArray(c,X1);                                   //释放内存
  cout<<"\n";
   cout<<"最终信号"<<"\n";
  for(i=0;i<numberofuserbit;i++) 
    cout<<Despreadout[i]<<" ";
 cout<<"\n";
FinalOut=new int[30000];
for(i=0;i<numberofuserbit;i++) 
   FinalOut[i]=Despreadout[i];
delete Despreadout;
 //cout<<"最终信号"<<"\n";
 // for(i=0;i<numberofuserbit;i++) 
   // cout<<FinalOut[i]<<" ";
 cout<<"\n";*/
}
/////////////////////////////////////////////////////////
//                                                 ///
///              执行信息码时域扩频的接收过程      /////
//////////////////////////////////////////////////////////
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;
	
	double n1,*d;
    complex<double> *TD=new complex<double>[15000];
    complex<double> *FD=new complex<double>[15000];
//double e[1000],f[10000],g[1000]={0},md[10][1000],de[10][1000],ee[10][100]={0},sp[10][100],I[10][100],Q[10][100],rI[10][1000],rQ[10][1000];
  // double dic[4],min,fI[10][1000],fQ[10][1000],finde[10][1000]={0},n;
// 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维数组分配内存
     FFTImagOut=Allocate2DArray(X1,X2);                       //动态2维数组分配内存

	 
 //cout<<"--------------FFT变换-------------------";
// cout<<"\n";
	 
for(i=0;i<numberofuserbit/2+numberofuserbit%2;i++)
{for( k=0;k<Fspreadfactor;k++)
 TD[k]=complex<double>(FFTRealIn[k][i], FFTImagIn[k][i]); 

 FFT(TD,FD,int(0),1);

  for( k=0;k<Fspreadfactor;k++)
  {FFTRealOut[k][i]=FD[k].real();
   FFTImagOut[k][i]=FD[k].imag();
  }
}
DeAllocate2DArray(FFTRealIn,1);                                   //释放内存
DeAllocate2DArray(FFTImagIn,1);                                   //释放内存
delete TD;
delete FD;
	
/*
cout<<"I支路"<<"\n";
for(i=0;i<Fspreadfactor;i++)
  
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<FFTRealOut[i][j]<<" ";
    cout<<"\n";
}   
 cout<<"Q支路"<<"\n";
for(i=0;i<Fspreadfactor;i++)
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<FFTImagOut[i][j]<<" ";
    cout<<"\n";
} */
/////////////////////////////
/////////////////////////////
	
Mseq=new int[30000];
M_seq(n);
/*cout<<"M序列"<<"\n";
for(i=0; i<100; i++)
    cout<<Mseq[i] <<" ";
   cout<<"\n";
*/

////////////////////////////
	
   d=new double[30000];
    DespreadRealout=Allocate2DArray(X1,X2);                       //动态2维数组分配内存
    DespreadImagout=Allocate2DArray(X1,X2);                       //动态2维数组分配内存
      Despreadout=Allocate2DArray(X1,X2);                       //动态2维数组分配内存
for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
      Despreadout[0][j]=0;
//cout<<Despreadout[0][0];
   for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
        d[j]=FFTRealOut[0][j];
  /*for(j=0;j<numberofuserbit;j++) 
  cout<<d[j]<<" ";
  cout<<"\n";*/
	
TdomainDespread(Tspreadfactor,d);
for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
     DespreadRealout[0][j]=Despreadout[0][j];
 //cout<<"\n";
  
numberofuserbit=numberofuserbit*Tspreadfactor;
for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
      Despreadout[0][j]=0;
for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
{  d[j]=FFTImagOut[0][j];
//cout<<d[j]<<" ";
}
//cout<<"\n";
TdomainDespread(Tspreadfactor,d);
for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
{DespreadImagout[0][j]=Despreadout[0][j];
//cout<<Despreadout[0][j];
}
  delete Mseq;
  delete d;
  DeAllocate2DArray(Despreadout,X1);                                   //释放内存
  DeAllocate2DArray(FFTRealOut,X1);                                   //释放内存
  DeAllocate2DArray(FFTImagOut,X1);                                   //释放内存

  //cout<<"\n";
/*cout<<"I支路"<<"\n";
for(i=0;i<Fspreadfactor;i++)
  
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<DespreadRealout[i][j]<<" ";
    cout<<"\n";
}   
cout<<"Q支路"<<"\n";
for(i=0;i<Fspreadfactor;i++)
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<DespreadImagout[i][j]<<" ";
    cout<<"\n";
} */


 Demodulation=intAllocate2DArray(X1,X2);                       //动态2维数组分配内存
DEQPSK(Fspreadfactor);
/*cout<<"解调合并"<<"\n";
for(i=0;i<Fspreadfactor;i++)
{ for(j=0;j<numberofuserbit;j++) 
    cout<<Demodulation[i][j]<<" ";
 cout<<"\n";
}*/

 DeAllocate2DArray(DespreadRealout,X1);                                   //释放内存
  DeAllocate2DArray(DespreadImagout,X1);                                   //释放内存

  /////////////////////////////////////////////////
/*Mseq=new int[30000];
M_seq(n);
/*cout<<"M序列"<<"\n";
for(i=0; i<100; i++)
    cout<<Mseq[i] <<" ";
   cout<<"\n";
*/
////////////////////////////
 /*  d=new int[30000];
   Despreadout=new int[30000];
for(j=0;j<numberofuserbit;j++) 
      Despreadout[j]=0;
   for(j=0;j<numberofuserbit;j++) 
        d[j]=Demodulation[0][j];
  /*for(j=0;j<numberofuserbit;j++) 
  cout<<d[j]<<" ";
  cout<<"\n";*/
/*TdomainDespread(Tspreadfactor,d);
  delete Mseq;
  delete d;
  cout<<"\n";
   *//*cout<<"最终信号"<<"\n";
  for(i=0;i<numberofuserbit;i++) 
    cout<<Demodulation[0][i]<<" ";
 cout<<"\n";*/

FinalOut=new int[30000];
for(i=0;i<numberofuserbit;i++) 
   FinalOut[i]=Demodulation[0][i];
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