📄 transmitter.cpp
字号:
#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 100
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;
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);
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";
} */
}
/////////////////////////////////////////////////////////
// /////
// 产生随机数 ///////
//////////////////////////////////////////////////////////
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";*/
/////////////////单双极性变换/////////////////
for(i=0;i<bitnumber;i++)
{ Userbit[i]=Userbit[i]*2-1;
// Userbit[i]=Userbit[i];
}
}
/////////////////////////////////////////////////////////
// /////
// 产生m序列扩频码 ///////
//////////////////////////////////////////////////////////
void transmitter::M_seq(int n)
{
int zita[8200],i,k,N;
N=int(pow(2,n)-1);
for(i=0;i<n;i++) //对zita[k]赋初值
{
zita[i]=1;
Mseq[i]=1;
}
switch(n)
{
case 2:
for(k=n+1;k<=2041;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<=2041;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<=2041;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<=2041;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<=2041;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<=2041;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<=2041;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<=2041;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<=2041;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<=2047;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<=N;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<=N;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之间的数：";
}
}
/////////////////////////////////////////////////////////
// /////
// 进行频域扩频 ///////
//////////////////////////////////////////////////////////
void transmitter::F_domainSpread(int factor)
{
int **ab,i,j;
ab=intAllocate2DArray(x1,10000);
//////////////复制///////////////
for(i=0;i<factor;i=i++)
for(j=0;j<numberofuserbit;j++)
ab[i][j]= Userbit[j];
//////////////////////
/* cout<<"复制"<<"\n";
for(i=0; i<factor; i++)
{for(j=0; j<numberofuserbit; j++)
cout<<ab[i][j]<<" ";
cout<<"\n";
}
cout<<"\n";*/
/////////////////////扩频///////////
for(i=0;i<factor;i++)
{for(j=0;j<numberofuserbit;j++)
SpreadOut[i][j]=ab[i][j]*Mseq[i];
SpreadOut[i][j]=0;
}
intDeAllocate2DArray(ab,x1); //删除内存
}
/////////////////////////////////////////////////////////
// 调制 /////
// qpsk ///
/// 星座点映射 /////
//////////////////////////////////////////////////////////
void transmitter::QPSK(int factor)
{
int i,j,k;
for(k=0;k<factor;k++)
for(i=1;i<numberofuserbit/2+1+numberofuserbit%2;i++)
{ if(SpreadOut[k][i*2-2]+2*SpreadOut[k][2*i-1]==-3.0) Ireal[k][i-1]=1.0*sqrt(2)/2,Qimag[k][i-1]=1*sqrt(2)/2;
else if(SpreadOut[k][i*2-2]+2*SpreadOut[k][2*i-1]==-1.0) Ireal[k][i-1]=1.0*sqrt(2)/2,Qimag[k][i-1]=-1*sqrt(2)/2;
else if(SpreadOut[k][i*2-2]+2*SpreadOut[k][2*i-1]==1.0) Ireal[k][i-1]=-1.0*sqrt(2)/2,Qimag[k][i-1]=1*sqrt(2)/2;
else if(SpreadOut[k][i*2-2]+2*SpreadOut[k][2*i-1]==3.0) Ireal[k][i-1]=-1.0*sqrt(2)/2,Qimag[k][i-1]=-1*sqrt(2)/2;
}
////////////////////////
//cout<<SpreadOut[0][10];
/*cout<<"调相"<<"\n";
for(k=0;k<factor;k++)
{ for(i=1;i<numberofuserbit/2+1+numberofuserbit%2;i++)
cout<<SpreadOut[k][i*2-2]+2*SpreadOut[k][2*i-1]<<" ";
cout<<"\n";
} */
}
/////////////////////////////////////////////////////////
// ///
/// IFFT变换 /////
//////////////////////////////////////////////////////////
void transmitter::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; //交换操作和结果数据的指针
}
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;
}
// --------------------------------------------------------------------------
// 动态分配二维数组
// 使用方法(以int类型8行10列为例)： int **dyarr = Allocate2DArray<int>(8,10)
//template<double>
double ** transmitter:: 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 transmitter::DeAllocate2DArray(double **arr, size_t pm_Rows)
{
for (int i = 0; i < pm_Rows; i++)
delete[] arr[i];
delete[] arr;
}
int ** transmitter::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 transmitter::intDeAllocate2DArray(int **arr, size_t pm_Rows)
{
for (int i = 0; i < pm_Rows; i++)
delete[] arr[i];
delete[] arr;
}⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -