数字通信计算机仿真课程设计报告书.docx

数字通信计算机仿真课程设计报告书.docx

《数字通信计算机仿真课程设计报告书.docx》由会员分享，可在线阅读，更多相关《数字通信计算机仿真课程设计报告书.docx（21页珍藏版）》请在冰豆网上搜索。

数字通信计算机仿真课程设计报告书

（1）程序代码之头文件

//SigTranmit.h:

interfacefortheSigTranmitclass.

//

//////////////////////////////////////////////////////////////////////

#if!

defined（AFX_SIGTRANMIT_H__1E1D11BF_1E65_4834_9496_4E5CAA470F68__INCLUDED_）

#defineAFX_SIGTRANMIT_H__1E1D11BF_1E65_4834_9496_4E5CAA470F68__INCLUDED_

#if_MSC_VER>1000

#pragmaonce

#endif//_MSC_VER>1000

#definePI3.1415926

#defineN63

#defineT0.005

#defineM20

#definefreq4000

#definefh200

#definefc1000

classSigTranmit

{

public:

SigTranmit（）;

virtual~SigTranmit（）;

voidSetDigtal（intID,intIntensity）;

voidBasesignal（）;

voidLpf（）;

voidmodulate（）;

voidChannel（）;

voidBpf（）;

voidDemodulate（）;

voidAdjust（）;

voidDft（floatx[],intm）;

voidIdft（floath[]）;

voidHnc（）;

voidHmc（）;

voidBlkmc（）;

voidConv（floatarray1[],floatarray2[]）;

voidNoise（intinten）;

voidSetHl（floatH[]）;

voidSetHb（floatH[]）;

voidSetc（intMyc）;

intGetmyIntensity（）;

intGetc（）;

float*GetSa（）;

float*GetA（）;

float*GetHl（）;

float*GetH2（）;

float*GetHb（）;

float*GetNo（）;

private:

intmyID;

intmyIntensity;

intc;//用来存放创函数选择

intS0[16];

intS1[16];

floatMod[16*M];

floatSa[16*M];//用来存放信号

floatSal[16*M];

floatAR[16*M];

floatAI[16*M];

floatA[16*M];//用来存放频域幅值

floatHl[16*M];

floatH2[16*M];

floatNo[16*M];//用来存放生成的噪声

floatHb[N];//用来存放带通频域数据

floatP[N];

floatWn[N];

};

#endif//!

defined（AFX_SIGTRANMIT_H__1E1D11BF_1E65_4834_9496_4E5CAA470F68__INCLUDED_）

（2）程序代码之源文件

//SigTranmit.cpp:

implementationoftheSigTranmitclass.

//

//////////////////////////////////////////////////////////////////////

#include"stdafx.h"

#include"计算机仿真.h"

#include"SigTranmit.h"

#include"math.h"

#include"stdio.h"

#include"stdlib.h"

#include"iostream"

#ifdef_DEBUG

#undefTHIS_FILE

staticcharTHIS_FILE[]=__FILE__;

#definenewDEBUG_NEW

#endif

//////////////////////////////////////////////////////////////////////

//Construction/Destruction

//////////////////////////////////////////////////////////////////////

SigTranmit:

:

SigTranmit（）

{

c=0;

s=1;

}

SigTranmit:

:

~SigTranmit（）

{

}

voidSigTranmit:

:

SetDigital（intnMyID,intnIntensity）//初始化

{

MyID=nMyID;

myIntensity=nIntensity;

}

voidSigTranmit:

:

Basesignal（）//基带信号的编码与采样

{

intd[4][4];

inte[16];

intm=0;

intb[4];

b[0]=MyID/1000;

b[1]=（MyID%1000）/100;

b[2]=（MyID%100）/10;

b[3]=MyID-b[0]*1000-b[1]*100-b[2]*10;

for（inti=0;i<4;i++）

{

switch（b[i]）

{

case0:

d[i][0]=0;

d[i][1]=0;

d[i][2]=0;

d[i][3]=0;

break;

case1:

d[i][0]=0;

d[i][1]=0;

d[i][2]=0;

d[i][3]=1;

break;

case2:

d[i][0]=0;

d[i][1]=0;

d[i][2]=1;

d[i][3]=0;

break;

case3:

d[i][0]=0;

d[i][1]=0;

d[i][2]=1;

d[i][3]=1;

break;

case4:

d[i][0]=0;

d[i][1]=1;

d[i][2]=0;

d[i][3]=0;

break;

case5:

d[i][0]=0;

d[i][1]=1;

d[i][2]=0;

d[i][3]=1;

break;

case6:

d[i][0]=0;

d[i][1]=1;

d[i][2]=1;

d[i][3]=0;

break;

case7:

d[i][0]=0;

d[i][1]=1;

d[i][2]=1;

d[i][3]=1;

break;

case8:

d[i][0]=1;

d[i][1]=0;

d[i][2]=0;

d[i][3]=0;

break;

case9:

d[i][0]=1;

d[i][1]=0;

d[i][2]=0;

d[i][3]=1;

break;

}

}

intk;

for（k=0;k<4;k++）

{

for（intj=0;j<4;j++）

{

S0[m]=d[k][j];

m++;

}

}

for（i=0;i<16;i++）

{

e[i]=S0[i];

if（e[i]==0）

{

e[i]=-1;

}

}

for（intj=0;j<16;j++）

{

for（k=0;k

{

Sa1[k+M*j]=e[j];

}

}

for（intn=0;n<16*M;n++）

{

Sa[n]=Sa1[n];

}

}

voidSigTranmit:

:

Dft（floatx[],intm）//DFT

{

for（intk=0;k

{

AR[k]=0.0;AI[k]=0.0;

for（intn=0;n

{

AR[k]=AR[k]+x[n]*cos（-2.0*PI*k*n/m）;

AI[k]=AI[k]+x[n]*sin（-2.0*PI*k*n/m）;

}

A[k]=sqrt（pow（AR[k],2）+pow（AI[k],2））;

}

}

voidSigTranmit:

:

Lpf（）//低通滤波

{

floathd[N];

inti;

floatwc=（2*PI*400）/fs;

floata=（N-1）/2;

for（i=0;i

{

hd[i]=0.0;

}

for（i=0;i

{

if（i==a）

hd[i]=wc/（double）PI;

else

hd[i]=sin（wc*（i-a））/（double）（PI*（i-a））;

}

switch（c）

{

case0:

for（i=0;i

{

Wn[i]=0.5*（1.0-cos（2.0*PI*i/（N-1）））;

};break;

case1:

for（i=0;i

{

Wn[i]=0.54-0.46*cos（2.0*PI*i/（N-1））;

};break;

case2:

for（i=0;i

{

Wn[i]=0.42-0.5*cos（2.0*PI*i/（N-1））+0.08*cos（4.0*PI*i/（N-1））;

};break;

case3:

for（i=0;i

{

Wn[i]=1;

};break;

}

for（i=0;i

H1[i]=hd[i]*Wn[i];

}

voidSigTranmit:

:

Modulate（）//调制

{

for（inti=0;i<16*M;i++）

Sa[i]=Sa[i]*cos（2*PI*fc*i/fs）;

}

voidSigTranmit:

:

Channel（）//信道

{

for（inti=0;i<16*M;i++）

Sa[i]=Sa[i]+GNoise（）;

}

voidSigTranmit:

:

Bpf（）//带通滤波

{

switch（s）

{

case0:

inti,ks1,kp1,ks2,kp2;//s=0;选择频率采样法。

floatf;

floatZ[N];

kp1=（int）700*N/fs;

ks1=（int）900*N/fs;

kp2=（int）1300*N/fs;

ks2=（int）1100*N/fs;

for（i=0;i

{

Hb[i]=0.0;

}

for（i=0;i

{

Z[i]=-（（N-1）*PI*i）/N;//线性相位

}

for（i=0;i<=kp1;i++）//N=127为奇数

{

Hb[i]=0;

Hb[N-i]=Hb[i];

}

for（i=kp1+1;i<=ks1;i++）

{

f=i*fs/（float）N;

Hb[i]=（f-700）/（float）200;

Hb[N-i]=Hb[i];

}

for（i=ks1+1;i<=ks2;i++）

{

f=i*fs/（float）N;

Hb[i]=1.0;

Hb[N-i]=Hb[i];

}

for（i=ks2+1;i<=kp2;i++）

{

f=i*fs/（float）N;

Hb[i]=（1300-f）/（float）200;

Hb[N-i]=Hb[i];

}

for（i=0;i

{

HbR[i]=Hb[i]*cos（Z[i]）;

HbI[i]=Hb[i]*sin（Z[i]）;

};

break;

case1:

floathd[N],hd1[N],hd2[N];//s=1,用窗函数法

floatwu=（2*PI*1400）/fs;

floatwl=（2*PI*600）/fs;

floata=（N-1）/2;

for（i=0;i

{

hd1[i]=0.0;

hd2[i]=0.0;

}

for（i=0;i

{

if（i==a）

hd1[i]=wl/（double）PI;

else

hd1[i]=sin（wl*（i-a））/（double）（PI*（i-a））;

}

for（i=0;i

{

if（i==a）

hd2[i]=wu/（double）PI;

else

hd2[i]=sin（wu*（i-a））/（double）（PI*（i-a））;

}

for（i=0;i

{

hd[i]=hd2[i]-hd1[i];

}

switch（c）

{

case0:

for（i=0;i

{

Wn[i]=0.5*（1.0-cos（2.0*PI*i/（N-1）））;

};break;

case1:

for（i=0;i

{

Wn[i]=0.54-0.46*cos（2.0*PI*i/（N-1））;

};break;

case2:

for（i=0;i

{

Wn[i]=0.42-0.5*cos（2.0*PI*i/（N-1））+0.08*cos（4.0*PI*i/（N-1））;

};break;

case3:

for（i=0;i

{

Wn[i]=1;

};break;

}

for（i=0;i

P[i]=hd[i]*Wn[i];

Dft（P,N）;

for（i=0;i

Hb[i]=A[i];

break;

}

}

voidSigTranmit:

:

Demodulate（）//相干解调

{

for（inti=0;i<16*M;i++）

Sa[i]=Sa[i]*cos（2*PI*fc*i/fs）;

}

voidSigTranmit:

:

Adjust（）//恢复判决

{

for（inti=0;i<16;i++）

{

S1[i]=（float）Sa[20+40*i];

if（S1[i]>0）

S1[i]=1;

else

S1[i]=-1;

}

for（intj=0;j<16;j++）

{

for（intk=0;k

{

Sa[k+M*j]=S1[j];

}

}

}

voidSigTranmit:

:

Idft（floath[]）//IDFT

{

intk;

switch（s）

{case0:

for（k=0;k

{

HbR[k]=0.0;HbI[k]=0.0;

for（intn=0;n

{

HbR[k]=（float）HbR[k]+h[n]*cos（（2.0*k-126）*PI*n/N）;//?

P[k]=HbR[k]/127;

}

};break;

case1:

break;

}

}

voidSigTranmit:

:

Conv（floatarray1[16*M],floatarray2[N]）//卷积

{

intI;

floatb[16*M+N];

I=16*M+N;

for（inti=0;i

{

b[i]=0;

for（intj=0;j<（16*M）;j++）

{

if（（i-j）<0||（i-j）>N）

b[i]=b[i]+0;

else

b[i]=b[i]+array1[j]*array2[i-j];

}

}

for（intk=0;k<（16*M）;k++）

{

H2[k]=b[k+（N-1）/2];

}

}

floatSigTranmit:

:

GNoise（）//高斯白噪声

{

floatb,q,randi=0.0;

q=RAND_MAX;

for（inti=0;i<12;i++）

randi+=rand（）/q;

b=myIntensity*（randi-6）;

b/=10;

returnb;

}

voidSigTranmit:

:

Noise（）

{

for（intj=0;j<16*M;j++）

{No[j]=0;}

for（inti=0;i<16*M;i++）

{

No[i]+=GNoise（）;

}

}

voidSigTranmit:

:

SetH1（floatH[]）

{

for（inti=0;i

H1[i]=H[i];

}

voidSigTranmit:

:

SetHb（floatH[]）

{

for（inti=0;i

Hb[i]=H[i];

}

voidSigTranmit:

:

SetSa（floatH[]）

{

for（inti=0;i<16*M;i++）

Sa[i]=H[i];

}

voidSigTranmit:

:

Setc（intMyc）

{

c=Myc;

}

voidSigTranmit:

:

Sets（intMys）

{

s=Mys;

}

intSigTranmit:

:

GetmyIntensity（）

{

returnmyIntensity;

}

intSigTranmit:

:

Getc（）

{

returnc;

}

float*SigTranmit:

:

GetSa（）

{

returnSa;

}

float*SigTranmit:

:

GetA（）

{

returnA;

}

float*SigTranmit:

:

GetH1（）

{

returnH1;

}

float*SigTranmit:

:

GetH2（）

{

returnH2;

}

float*SigTranmit:

:

GetHb（）

{

returnHb;

}

float*SigTranmit:

:

GetNo（）

{

returnNo;

}

float*SigTranmit:

:

GetP（）

{

returnP;

}

float*SigTranmit:

:

GetS1（）

{

returnS1;

}