📄 rereiver.cpp

📁 单用户多载波时频域联合cdma扩频的仿真
💻 CPP
📖 第 1 页 / 共 2 页
字号:
上一页 12
	   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;    //交换操作和结果数据的指针
	}
	

	for(j = 0; j < Nfft; j++)  //将结果赋给频域数组
	{
		if(sign==1)  FreqDomain[j]=Temp1[j];
		else {
		//	real(TimeDomain)=real(Temp1[j])/Nfft;
        //    imag(TimeDomain)=-imag(Temp1[j])/Nfft;
			
           TimeDomain[j]=complex<double> (real(Temp1[j])/Nfft, -imag(Temp1[j])/Nfft);
		}
		
	}



	//释放内存
	delete Wn;
	delete Temp1;
	delete Temp2;
}
/////////////////////////////////////////////////////////
//                                                 ///
///              进行qpsk解调                        /////
////                                           //////
 ////       计算每个点到每个星座点的最短距离       ///
/////                                              ///////
//////////////////////////////////////////////////////////
void receiver::DEQPSK(int factor)
{
	int i,j,k;
	double min,dic[4],**fI,**fQ;
fI=Allocate2DArray(x1,x2);                       //动态2维数组分配内存
fQ=Allocate2DArray(x1,x2);                      //动态2维数组分配内存
for(k=0;k<factor;k++)        
{ for(i=0;i<numberofuserbit/2+numberofuserbit%2;i++)
{ 
  dic[0]=sqrt(sqr(TDespreadRealout[k][i]-1*sqrt(2)/2)+sqr(TDespreadImagout[k][i]-1*sqrt(2)/2));///0,0///
  dic[1]=sqrt(sqr(TDespreadRealout[k][i]+1*sqrt(2)/2)+sqr(TDespreadImagout[k][i]-1*sqrt(2)/2));///0,1///
  dic[2]=sqrt(sqr(TDespreadRealout[k][i]-1*sqrt(2)/2)+sqr(TDespreadImagout[k][i]+1*sqrt(2)/2));///1,0//
  dic[3]=sqrt(sqr(TDespreadRealout[k][i]+1*sqrt(2)/2)+sqr(TDespreadImagout[k][i]+1*sqrt(2)/2));///1,1//
  //cout<<"dic[0]="<<dic[0]<<" ";
 min=dic[0];
  for(j=0;j<4;j++)
  {  
	 
	  if(dic[j]<min)
          min= dic[j]; 
  }
 if(min==dic[0]) 
	 fI[k][i]=1*sqrt(2)/2,fQ[k][i]=1*sqrt(2)/2;
 else if(min==dic[1]) 
	 fI[k][i]=-1*sqrt(2)/2,fQ[k][i]=1*sqrt(2)/2;
 else if(min==dic[2]) 
	 fI[k][i]=1*sqrt(2)/2,fQ[k][i]=-1*sqrt(2)/2;
 else if(min==dic[3]) 
	 fI[k][i]=-1*sqrt(2)/2,fQ[k][i]=-1*sqrt(2)/2;
 //cout<<min<<" ";
}
//cout<<"\n";
}
  /////////////////////////////////////////////
 /*  cout<<"解调"<<"\n";
   cout<<"I支路"<<"\n";
for(i=0;i<factor;i++)
  
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<fI[i][j]<<" ";
    cout<<"\n";
}   
 cout<<"Q支路"<<"\n";
for(i=0;i<factor;i++)
{ for(j=0;j<numberofuserbit/2+numberofuserbit%2;j++) 
    cout<<fQ[i][j]<<" ";
    cout<<"\n";
} */
////////////////////合并IQ两路///////////////////////////////

for(k=0;k<factor;k++)
  for(i=1;i<numberofuserbit/2+numberofuserbit%2+1;i++)
  {
	  //cout<<int(fI[k][i-1]*sqrt(2)+2*fQ[k][i-1]*sqrt(2))<<" ";
   
	  if(int(fI[k][i-1]*sqrt(2)+2*fQ[k][i-1]*sqrt(2))==3)  Demodulation[k][i*2-2]=-1,Demodulation[k][i*2-1]=-1;
         
	  else if(int(fI[k][i-1]*sqrt(2)+2*fQ[k][i-1]*sqrt(2))==1) Demodulation[k][i*2-2]=-1,Demodulation[k][i*2-1]=1;
	  else if(int(fI[k][i-1]*sqrt(2)+2*fQ[k][i-1]*sqrt(2))==-1) Demodulation[k][i*2-2]=1,Demodulation[k][i*2-1]=-1;
	  else if(int(fI[k][i-1]*sqrt(2)+2*fQ[k][i-1]*sqrt(2))==-3) Demodulation[k][i*2-2]=1,Demodulation[k][i*2-1]=1;
	  //finde[k][i*2-2]=fI[k][i-1]*sqrt(2); 
      //finde[k][i*2-1]=fQ[k][i-1]*sqrt(2);  
   //cout<<finde[k][i*2-2]<<" ";

 }
 // cout<<"\n";
DeAllocate2DArray(fI,x1);                                   //释放内存
DeAllocate2DArray(fQ,x1);                                 //释放内存
}
/////////////////////////////////////////////////////////
//                                                  /////
//                    产生m序列扩频码             ///////
//////////////////////////////////////////////////////////
	void receiver::M_seq(int n)
    {
		int *zita,i,k,N;
		N=int(pow(2,n)-1);
		zita=new int[x2];
	for(i=0;i<n;i++)                    //对zita[k]赋初值
	{
      zita[i]=1;
	   Mseq[i]=1;
    }
	
	switch(n)
	{
	case 2: 
		    for(k=n+1;k<=x2;k++)
			{
               zita[k]=zita[k-n]^zita[k-1];	
               Mseq[k]=(2*zita[k]-1);
			 // cout<<Mseq[k]<<"  ";
			 
            }
		    break;
case 3: 
		    for(k=n;k<=20000;k++)
			{
               zita[k]=zita[k-n]^zita[k-2];	
               Mseq[k]=(2*zita[k]-1);
			   //cout<<Mseq[k]<<"  ";
			    
            }
		    break;
	case 4:
		    for(k=n;k<=20000;k++)
			{
               zita[k]=zita[k-n]^zita[k-3];	
               Mseq[k]=(2*zita[k]-1);
			  // cout<<Mseq[k]<<"  ";
			   
            }
		    break;
	case 5:
		    for(k=n+1;k<=x2;k++)
			{
               zita[k]=zita[k-n]^zita[k-3];	
               Mseq[k]=(2*zita[k]-1);
			  // cout<<Mseq[k]<<"  ";
			  
            }
		    break;
	case 6:
		     for(k=n+1;k<=x2;k++)
			{
               zita[k]=zita[k-n]^zita[k-5];	
               Mseq[k]=(2*zita[k]-1);
			  // cout<<Mseq[k]<<"  ";
			    
            }
		    break;
	case 7:
		    for(k=n+1;k<=x2;k++)
			{
               zita[k]=zita[k-n]^zita[k-4];	
               Mseq[k]=(2*zita[k]-1);
			  // cout<<Mseq[k]<<"  ";
			    
            }
		    break;
	case 9: 
		     for(k=n+1;k<=x2;k++)
			{
               zita[k]=zita[k-n]^zita[k-5];	
               Mseq[k]=(2*zita[k]-1);
			  // cout<<Mseq[k]<<"  ";
			   
            }
		    break;
	case 10: 
		     for(k=n+1;k<=x2;k++)
			{
               zita[k]=zita[k-n]^zita[k-7];	
               Mseq[k]=(2*zita[k]-1);
			 //  cout<<Mseq[k]<<"  ";
			   
            }
		    break;
	case 11:
		    for(k=n+1;k<=x2;k++)
			{
               zita[k]=zita[k-n]^zita[k-9];	
               Mseq[k]=(2*zita[k]-1);
			 //  cout<<Mseq[k]<<"  ";
			   
            }
		    break;   
	case 8:
		    for(k=n+1;k<=x2;k++)
			{
               zita[k]=zita[k-n]^zita[k-7]^zita[k-6]^zita[k-1];
               Mseq[k]=(2*zita[k]-1);
			 //  cout<<Mseq[k]<<"  "; 
			    
			}
			break;
	case 12:
		    for(k=n+1;k<=x2;k++)
			{
               zita[k]=zita[k-n]^zita[k-8]^zita[k-5]^zita[k-1];
               Mseq[k]=(2*zita[k]-1);
			 //  cout<<Mseq[k]<<"  "; 
			   
			}
			break;
	case 13:
		    for(k=n+1;k<=x2;k++)
			{
               zita[k]=zita[k-n]^zita[k-8]^zita[k-6]^zita[k-1];
               Mseq[k]=(2*zita[k]-1);
			//   cout<<Mseq[k]<<"  "; 
			    
			}
			break;
	default: 
		    cout<<"请重新输入2到13之间的数：";
			}
			delete zita;
	}
	/////////////////////////////////////////////////////////
//                                                  /////
//                    进行频域解扩                  ///////
//////////////////////////////////////////////////////////
void receiver::FdomainDespread(int factor,double **c)
{
	int i,j,k,**sp;
//sp=intAllocate2DArray(x1,1000);                       //动态2维数组分配内存
for(k=0;k<factor;k++) 
for(i=0;i<numberofuserbit/2+numberofuserbit%2;i++)
{ Despreadout[k][i]=c[k][i]*Mseq[k];
  
  //cout<<Despreadout[k][i];
}
 //for(k=0;k<n2-1;k++) 
//for(j=0;j<10;j++)
 //for(i=0;i<r;i++)
   // sp2[k][j]=sp2[k][j]+sp[k][i+r*j];
 //for(i=0;i<10;i++)
//	 if(de2[i]>0) de2[i]=1;
//	 else de2[i]=0;
////////////////////////
/*  cout<<"解扩"<<"\n";
 for(i=0;i<factor;i++)
{ for(j=0;j<numberofuserbit;j++) 
    cout<<sp[i][j]<<" ";
 cout<<"\n";
}*/
 //////////////////
/*for(i=0;i<numberofuserbit;i++)
{Despreadout[i]=0;                              
for(k=0;k<factor;k++) 
{   
	Despreadout[i]= Despreadout[i]+sp[k][i];
//cout<<Despreadout[i];
}
}
intDeAllocate2DArray(sp,x1);                                   //释放内存
for(i=0;i<numberofuserbit;i++)
if( Despreadout[i]>0) Despreadout[i]=1;
   else  Despreadout[i]=0;
*/
}

	/////////////////////////////////////////////////////////
//                                                  /////
//                    进行时域解扩ds－cdma          ///////
//////////////////////////////////////////////////////////
void receiver::TdomainDespread(int factor,double *d)
{
	int i,j,k,number;
	double *sp;
sp=new double[x2];                       //动态2维数组分配内存

for(i=0;i<numberofuserbit/2+numberofuserbit%2;i++)
	 sp[i]=d[i]*Mseq[i];
//for(i=0;i<numberofuserbit/2+numberofuserbit%2;i++)
 // cout<<sp[i]<<" ";
//cout<<"\n";
number=numberofuserbit/factor;
//cout<<numberofuserbit<<" "<<factor;
//cout<<"\n";
for(j=0;j<number/2+number%2;j++)
 {for(i=0;i<factor;i++)
  {Despreadout[0][j]=Despreadout[0][j]+sp[i+factor*j];
//cout<<Despreadout[0][j]<<" "; 
 
  }
  Despreadout[0][j]/=factor;
}
 delete sp;
 /*for(i=0;i<numberofuserbit;i++)
	 if(Despreadout[i]>0) Despreadout[i]=1;
	 else Despreadout[i]=0;*/
////////////////////////
 /* cout<<"解扩"<<"\n";
{ for(j=0;j<numberofuserbit;j++) 
    cout<<Despreadout[j]<<" ";
 cout<<"\n";
}*/
 //////////////////
/*for(i=0;i<N;i++)
for(k=0;k<N2-1;k++) 
z[i]=z[i]+sp[k][i];
for(i=0;i<N;i++)
if(z[i]>0) z[i]=1;
   else z[i]=0;
   ////////////////////////
  cout<<"最终信号"<<"\n";
 
 for(i=0;i<N;i++) 
    cout<<z[i]<<" ";
 cout<<"\n";
*/
}








// --------------------------------------------------------------------------
// 动态分配二维数组
// 使用方法(以int类型8行10列为例)： int **dyarr = Allocate2DArray<int>(8,10)
//template<double>
 double ** receiver::  Allocate2DArray(size_t pm_Rows, size_t pm_Cols)
{
    double **arr = new double*[pm_Rows];
    for (int i = 0; i < pm_Rows; i++)
        arr[i] = new double[pm_Cols];
    return arr;
}

// --------------------------------------------------------------------------
// 释放动态分配的二维数组
// 使用方法(以int类型8行10列为例)： Allocate2DArray<int>(dyarr,8)
//template<double>
void receiver::DeAllocate2DArray(double **arr, size_t pm_Rows)
{
    for (int i = 0; i < pm_Rows; i++)
        delete[] arr[i];
    delete[] arr;
}

int ** receiver::intAllocate2DArray(size_t pm_Rows, size_t pm_Cols)
{
    int **arr = new int*[pm_Rows];
    for (int i = 0; i < pm_Rows; i++)
        arr[i] = new int[pm_Cols];
    return arr;
}

// --------------------------------------------------------------------------
// 释放动态分配的二维数组
// 使用方法(以int类型8行10列为例)： Allocate2DArray<int>(dyarr,8)
//template<double>
void receiver::intDeAllocate2DArray(int **arr, size_t pm_Rows)
{
    for (int i = 0; i < pm_Rows; i++)
        delete[] arr[i];
    delete[] arr;
}
上一页 12
💿 文件大小 38 K
👤 上传用户 sy780415
📂 所属分类通讯/手机编程
🏷️ 相关标签

#cdma #单用户 #仿真 #多载波
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -