transmitter.cpp

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

#include <iostream>
using namespace std;
#include <complex>
#include "transmitter.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 transmitter::StartFdomaintransmit ( )
{
	//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,*a;
	double ni,nq;
	double n1,snr=2;
    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);
Userbit=new int[10000];
//////////这是测试数据/////////////////////
//for(i=0;i<1000;i++)
  //  Userbit[i]=-1;
 random(numberofuserbit);
   /*  cout<<"单双极性变换"<<"\n";
for(i=0; i<numberofuserbit; i++)
    cout<<Userbit[i]<<" ";
   cout<<"\n";*/
   ///////////////////////////
  /* Mseq=new int[10000];
M_seq(n);
/*cout<<"M序列"<<"\n";
for(i=0; i<100; i++)
    cout<<Mseq[i] <<" ";
   cout<<"\n";*/
////////////////////////////
 /*  SpreadOut=Allocate2DArray(x1,10000);           //动态2维数组分配内存
F_domainSpread(Fspreadfactor,a);
delete Mseq;
//////////////text////////
//for(i=0;i<Fspreadfactor;i++)
 //{for(j=0;j<numberofuserbit;j++) 
 //SpreadOut[i][j]*=1.0/Fspreadfactor;

//
 // }
//////////////////////////
/* cout<<"扩频"<<"\n";
for(i=0;i<Fspreadfactor;i++)
{ for(j=0;j<numberofuserbit;j++) 
    cout<<SpreadOut[i][j]<<" ";
 cout<<"\n";
}*/

//////////////////////////////
/*Ireal=Allocate2DArray(x1,10000);                       //动态2维数组分配内存
Qimag=Allocate2DArray(x1,10000);                      //动态2维数组分配内存
QPSK(Fspreadfactor);
DeAllocate2DArray(SpreadOut,x1);                //删除内存
/* cout<<"I支路"<<"\n";
for(i=0;i<Fspreadfactor;i++)
  
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<Ireal[i][j]<<" ";
    cout<<"\n";
}   
 cout<<"Q支路"<<"\n";
for(i=0;i<Fspreadfactor;i++)
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<Qimag[i][j]<<" ";
    cout<<"\n";
}  */
 
/*
IFFTrealout=Allocate2DArray(x1,10000);                       //动态2维数组分配内存
IFFTimagout=Allocate2DArray(x1,10000);                      //动态2维数组分配内存
 //cout<<"--------------IFFT变换-------------------";
 //cout<<"\n";
for(i=0;i<numberofuserbit/2+numberofuserbit%2;i++)
{for( k=0;k<Fspreadfactor;k++)
 FD[k]=complex<double>(Ireal[k][i], Qimag[k][i]); 
  for( k=0;k<Fspreadfactor;k++)
 //cout<<FD[k].real()<<"+ "<<FD[k].imag()<<"i   ";
  //cout<<"\n------------------\n";
FFT(TD,FD,int(n1+0.5),-1);

  for( k=0;k<Fspreadfactor;k++)
  {IFFTrealout[k][i]=TD[k].real();
   IFFTimagout[k][i]=TD[k].imag();
  }

}
DeAllocate2DArray(Ireal,x1);                                   //删除内存
DeAllocate2DArray(Qimag,x1);                                   //删除内存
/*cout<<"I支路"<<"\n";
for(i=0;i<Fspreadfactor;i++)                                  
  
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<IFFTrealout[i][j]<<" ";
    cout<<"\n";
}   
 cout<<"Q支路"<<"\n";
for(i=0;i<Fspreadfactor;i++)
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<IFFTimagout[i][j]<<" ";
    cout<<"\n";
} */


}
/////////////////////////////////////////////////////////
//                                                  /////
//                   时域扩频的传送过程ds-cdma     ///////
//////////////////////////////////////////////////////////
void transmitter::StartTdomaintransmit ( )
{
	int i,j,k,N=10,n=3,Fs;
	double n1=0,snr=2,*b,*a;
    complex<double> *TD=new complex<double>[x2];
    complex<double> *FD=new complex<double>[x2];
//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);
	Fs=Fspreadfactor;                                 //储存频域扩频系数
	Fspreadfactor=1;                                  //在时域扩频时,令频域扩频因子为1
Userbit=new int[x2];                                  //为Userbit分配内存
b=new double[x2];                                      //分配内存，为时域扩频用
a=new double[x2];                                      //分配内存，为频域扩频用
 random(numberofuserbit);                              //产生随机数，给Userbit副职并实现串并转换
 /////////////////////////////////////////输出///////////////////////////////////////////////
    /*cout<<"单双极性变换"<<"\n";                        //输出结果
for(i=0; i<numberofuserbit; i++)
    cout<<Userbit[i]<<" ";
   cout<<"\n";*/
   /////////////////////////////////////////////////////////////////////////////////////
Ireal=Allocate2DArray(x1,x2);                       //动态2维数组分配内存,存放QPSK调制的结果
Qimag=Allocate2DArray(x1,x2);                      //动态2维数组分配内存,存放QPSK调制的结果
QPSK(1);                                          //进行QPSK调制

//intDeAllocate2DArray(SpreadOut,1);                //删除内存
/////////////////////////////////////////输出///////////////////////////////////////////////
/*cout<<"I支路"<<"\n";                               //输出结果
for(i=0;i<1;i++)
  
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<Ireal[i][j]<<" ";
    cout<<"\n";
}   
 cout<<"Q支路"<<"\n";
for(i=0;i<1;i++)
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<Qimag[i][j]<<" ";
    cout<<"\n";
}   */
 ////////////////////////////////////////////////////////////////////////////////////////////////////////
TSpreadOutReal=new double[x2];                          //分配内存，存放时域扩频的结果
TSpreadOutImag=new double[x2];                          //分配内存，存放时域扩频的结果
for(i=0; i<numberofuserbit/2+numberofuserbit%2; i++)   //把I支路的值赋给b
{b[i]=Ireal[0][i];
 //cout<<b[i]<<" ";
}
  Mseq=new int[2*x2];                                   //为m序列分配内存
M_seq(n);                                             //产生m序列作为扩频码
/*cout<<"M序列"<<"\n";
for(i=0; i<2000; i++)
    cout<<Mseq[i] <<" ";
   cout<<"\n";*/
////////////////////////////
 SpreadOut=Allocate2DArray(x1,x2);           //动态2维数组分配内存,存放时域扩频后的数组
T_domainSpread(Tspreadfactor,b);            //对I支路进行时域扩频
for(i=0; i<(numberofuserbit/2+numberofuserbit%2)*Tspreadfactor; i++)
  TSpreadOutReal[i]=SpreadOut[0][i];          //把结果赋给SpreadOutReal


//cout<<"\n";
for(i=0; i<numberofuserbit/2+numberofuserbit%2; i++) 
{b[i]=Qimag[0][i];                              //把Q支路的值赋给b
}
T_domainSpread(Tspreadfactor,b);                 //对Q支路进行时域扩频
for(i=0; i<(numberofuserbit/2+numberofuserbit%2)*Tspreadfactor; i++)
  TSpreadOutImag[i]=SpreadOut[0][i];               //把结果赋给SpreadOutImag
//cout<<"Mseq[256*8]="<<Mseq[256*8];
delete Mseq;                                       //删除内存Mseq
delete b;                                          //删除内存b 
DeAllocate2DArray(Ireal,x1);                    //删除内存Ireal
DeAllocate2DArray(Qimag,x1);                    //删除内存Qimag
numberofuserbit=(numberofuserbit+numberofuserbit%2)*(Tspreadfactor);   //把numberofuserbit转换为时域扩频后的值
/////////////////////////////////////////输出///////////////////////////////////////////////
/*cout<<"时域扩频I"<<"\n";                             //输出结果

{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<< TSpreadOutReal[j]<<" ";
 cout<<"\n";
}
cout<<"时域扩频Q"<<"\n";

{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<< TSpreadOutImag[j]<<" ";
 cout<<"\n";
}*/
 //////////////////////////////////////////////////////////////////////////////////////////////////////// 
//cout<<"SpreadOut[0][256*8]="<<SpreadOut[0][256*8-1];
  Mseq=new int[2*x2];                                   //为m序列分配内存
M_seq(4);                                             //产生m序列作为扩频码
 FSpreadOutReal=Allocate2DArray(x1,x2);           //动态2维数组分配内存,存放频域扩频后的数组
FSpreadOutImag=Allocate2DArray(x1,x2);           //动态2维数组分配内存,存放频域扩频后的数组

for(i=0; i<numberofuserbit/2+numberofuserbit%2; i++)   //把I支路的值赋给a
{a[i]=TSpreadOutReal[i];
 //cout<<a[i]<<" ";
}
F_domainSpread(Fs,a);                               //对I支路进行频域扩频
//////////////////////////

for(i=0;i<Fs;i++)
 for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
	   FSpreadOutReal[i][j]=SpreadOut[i][j];
 
for(i=0; i<numberofuserbit/2+numberofuserbit%2; i++)   //把Q支路的值赋给a
{a[i]=TSpreadOutImag[i];                                   
 //cout<<a[i]<<" ";
}
F_domainSpread(Fs,a);                                 //对Q支路进行频域扩频
for(i=0;i<Fs;i++)
 for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
	   FSpreadOutImag[i][j]=SpreadOut[i][j];
 /////////////////////////////////////////输出///////////////////////////////////////////////
/*cout<<"I支路频域扩频"<<"\n";
for(i=0;i<Fs;i++)
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<FSpreadOutReal[i][j]<<" ";
 cout<<"\n";
}
cout<<"Q支路频域扩频"<<"\n";
for(i=0;i<Fs;i++)
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<FSpreadOutImag[i][j]<<" ";
 cout<<"\n";
}*/
 //////////////////////////////////////////////////////////////////////////////////////////////////////// 
delete Mseq;                                       //删除内存Mseq
delete a;                                          //删除内存a
delete TSpreadOutReal;                             //删除内存 TSpreadOutReal
delete TSpreadOutImag;                             //删除内存 TSpreadOutImag
DeAllocate2DArray(SpreadOut,x1);                   //删除内存SpreadOut
Fspreadfactor=Fs;                                  //恢复频域扩频系数的值


IFFTrealout=Allocate2DArray(x1,x2);                       //动态2维数组分配内存,存放IFFT变换的结果
IFFTimagout=Allocate2DArray(x1,x2);                      //动态2维数组分配内存,存放IFFT变换的结果
 //cout<<"--------------IFFT变换-------------------";
 //cout<<"\n";
for(i=0;i<numberofuserbit/2+numberofuserbit%2;i++)
{for( k=0;k<Fspreadfactor;k++)
 FD[k]=complex<double>(FSpreadOutReal[k][i], FSpreadOutImag[k][i]); 
  for( k=0;k<Fspreadfactor;k++)
 //cout<<FD[k].real()<<"+"<<FD[k].imag()<<"i   ";
 // cout<<"\n------------------\n";
  //cout<<int(n1+0.5);
FFT(TD,FD,int(n1+0.5),-1);

  for( k=0;k<Fspreadfactor;k++)
  {IFFTrealout[k][i]=TD[k].real();
   IFFTimagout[k][i]=TD[k].imag();
  }

}
DeAllocate2DArray(FSpreadOutReal,x1);                                   //删除内存
DeAllocate2DArray(FSpreadOutImag,x1);                                   //删除内存
/////////////////////////////////////////输出///////////////////////////////////////////////
/*cout<<"I支路"<<"\n";
for(i=0;i<Fspreadfactor;i++)                                  
  
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<IFFTrealout[i][j]<<" ";
    cout<<"\n";
}   
 cout<<"Q支路"<<"\n";

for(i=0;i<Fspreadfactor;i++)
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<IFFTimagout[i][j]<<" ";
    cout<<"\n";
} */
 /////////////////////////////////////////////////////////////////////////////////////////
delete TD;
delete    FD;

}



/////////////////////////////////////////////////////////
//                                                  /////
//                    产生随机数                   ///////
//////////////////////////////////////////////////////////
void transmitter::random(int bitnumber)
{  int i;
   time_t t;
   srand((unsigned) time(&t));
   
   for(i=0; i<bitnumber; i++)
   {  Userbit[i]=rand() % (2);
  
   }
   /* cout<<"原始数据"<<"\n";
for(i=0; i<numberofuserbit; i++)
    cout<<Userbit[i]<<" ";
   cout<<"\n";*/
  Userbit[i]=0;//最末位为0
   /////////////////单双极性变换/////////////////
   for(i=0;i<bitnumber;i++)
	   Userbit[i]=Userbit[i]*2-1;
Userbit[i]=-1;//最末位为0
}
/////////////////////////////////////////////////////////
//                                                  /////
//                    产生m序列扩频码             ///////
//////////////////////////////////////////////////////////
	void transmitter::M_seq(int n)
    {
		int *zita,i,k,N;
		zita=new int[x2];
		N=int(pow(2,n)-1);
	for(i=0;i<n;i++)                    //对zita[k]赋初值
	{