通信系统实验程序

班级硕-011407

学号1401120522

西安电子科技大学

通信系统综合实验程序

学院：通信工程学院

班级：硕011407班

专业：电子与通信工程

姓名：董文欣

二○一四年十二月

一、2/3FEC编译码程序

1.2/3FEC编码

#include

void main()

{

/****变量定义以及初始化***/

int mes; //输入的16进制信息序列

int bit2[10]; //将输入的16进制数转换为2进制后的数

int reg[5]; //移位寄存器

int code[15]; //2/3FEC编码后的序列

int rbit2[15]; //接收序列（2进制形式）

int err_num; //误码数的统计

int err_flag;

int decodemes[3]; //将译码结果用16进制表示

char err_code[15]; //加误码的序列

char ch;

int flag=0;

int i,j,t,e,tt;

int sel=0; //功能选择位

/****输入信息序列***/

printf("通信系统综合实验--数字基带仿真实验--2/3FEC的实现\n");

do

{

if(flag>0)

printf("对不起，您的输入值超出范围！\n");

flag++;

printf("请输入0---3FFH之间的十六进制数，并按回车！\n");

scanf("%x",&mes);

} while((mes<0)||(mes>1023));

/***将输入的十六进制数转换为二进制数***/

for(i=0;i<10;i++)

{

bit2[9-i]=mes%2; //bit2[0]为MSB

mes=mes/2;

}

printf("您输入的数转化为二进制后的编码前的序列：（MSB--->LSB）: ");

for(i=0;i<10;i++)

printf("%d",bit2[i]);

printf("\n");

/*** 2/3 FEC编码***/

for(i=0;i<5;i++) //移位寄存器的初始状态全清零

reg[i]=0;

for(i=0;i<10;i++) //二进制bit2的从低位到高位的输入，按照编码器的电路图进行编码

{

t= reg[4]^bit2[9-i]; //g=x^5+x^4+x^2+1=(x+1)(x^4+x+1)

reg[4]= reg[3]^t;

reg[3]= reg[2];

reg[2]= reg[1]^t;

reg[1]= reg[0];

reg[0]= t;

}

printf("经2/3FEC编码后的二进制信息序列为(MSB-->LSB)：");

for(i=0;i<5;i++) //输出编码序列的高五位

{

code[i]=reg[i];

rbit2[i]=code[i];

printf("%d",code[i]);

}

printf(" ");

for(;i<15;i++) //输出编码序列的信息位

{

code[i]=bit2[i-5];

rbit2[i]=code[i];

printf("%d",code[i]);

}

printf("\n");

printf("*************************************************************************** *\n");

2.2/3FEC译码

/***以下进入菜单选项，可以选择加误码、复原、译码和返回功能***/

while(sel != 4)

{

printf("功能菜单如下，您可以选择译码，加误码，复原，以及返回功能：\n");

printf("操作方法：按1----->译码，按2----->误码，按3----->复原，按0----->返回\n");

printf("请您选择功能！\n");

scanf("%d",&sel);

getchar();

switch(sel) //功能选择

{

//译码功能

case 1:{

err_num=0;

err_flag=0;

for(i=0;i<5;i++) //移位寄存器内容全清0

reg[i]=0;

for(i=0;i<15;i++) //从接受序列的低位到高位的顺序

{

t= reg[4];

reg[4]= reg[3]^t;

reg[3]= reg[2];

reg[2]= reg[1]^t;

reg[1]= reg[0];

reg[0]= rbit2[14-i]^t;

}

if(reg[4]+reg[3]+reg[2]+reg[1]+reg[0] == 0)

{

printf("信道传输正确或产生不可检错的误码序列! 接收序列为: ");

for(i=0;i<15;i++)

printf("%d",rbit2[i]);

printf("\n 译码结果为: ");

}

else

{

for(i=0;i<15;i++)

{

if(reg[4]+reg[3]+(!reg[2])+reg[1]+(!reg[0]) == 5) //11010: x^14 mod g

e=1;

else

e=0;

err_num+=e;

if(err_num == 0)

err_flag++;

tt=rbit2[14]^e; //输出，并将此输出通过循环放到rbit2中

for(j=14;j>0;j--)

rbit2[j]=rbit2[j-1]; //序列移位

rbit2[0]=tt;

t= reg[4];

reg[4]= reg[3]^t;

reg[3]= reg[2];

reg[2]= reg[1]^t;

reg[1]= reg[0];

reg[0]= e^t; //纠错信号也反馈到伴随式计算电路的输入端（图7中虚线所示）对伴随式进行修正，以消去该错误对伴随式的影响

}

if(err_num == 1)

printf("信道传输产生1位错码!可纠错!该码位于第%d位, 译码结果为：",15-err_flag);

else

{

printf("信道传输产生2位或2位以上错码! 超出2/3FEC码纠错范围，不可纠错!\n");

printf(" 译码结果为: ");

}

}

decodemes[0] = rbit2[5] *2 + rbit2[6];

decodemes[1] = rbit2[7] *8 + rbit2[8] *4 + rbit2[9] *2 + rbit2[10];

decodemes[2] = rbit2[11]*8 + rbit2[12]*4 + rbit2[13]*2 + rbit2[14];

for(i=5;i<15;i++)

printf("%d",rbit2[i]);

printf("\n");

printf(" 十六进制结果为：%X%X%X\n",decodemes[0],decodemes[1],decodemes[2]);

printf("********************************************************************\n");

printf("********************************************************************\n");

break;

}

//误码功能

case 2:{

printf("请您输入加入误码后的二进制序列（15位）,可以修改编码后的二进制序列的一位或多位！\n");

printf("误码序列：");

gets(err_code); //输入误码

for(i=0;i<15;i++)

{

if(err_code[i] == '0') //对某一个或某些位设置误码

rbit2[i]=0;

else

rbit2[i]=1;

}

break;

}

//复位功能

case 3:{

for(i=0;i<15;i++)

rbit2[i]=code[i]; //恢复正确的码

break;

}

//返回功能

case 4:{

printf("您即将退出，您真的要退出吗？Y/N\n");

ch=getchar();

if((ch == 'N')||(ch == 'n'))

sel = 0;

break;

}

default: printf("您的操作序号输入有误,执行不了任何功能，请重新输入!\n");

}

}

}

二、PCM编译码程序

3.PCM编码

extern unsigned char PCM_StudentAlawEncode(int InputValue)

{

unsigned char OutputValue = 0x0; //初始化编码输出值

/*Add your code here*/

/****************极性码编码*****************/

if(InputValue<0) //当InputValue小于0时，对它取相反数，并将极性码设为0

{

InputValue=-InputValue;

OutputValue=0x00;

}

else

OutputValue=0x80; //当InputValue大于0时，将极性码设为1 /****************段落码编码*****************/

//根据InputValue与各段量化区间（共8个量化区间）的起始电平的比较，进行段落码编码//计算出在所在量化区间占用的量化间隔数,用于段内编码

if(InputValue>=1024)

{

OutputValue=OutputValue+0x70; //当InputValue大于1024时，在第8段，段内码：111 InputValue=(InputValue-1024)/64; //求在该段落占用的量化间隔数

}

else if(InputValue>=512)

{

OutputValue=OutputValue+0x60; //当InputValue大于1024时，在第7段，段内码：110

InputValue=(InputValue-512)/32; //该段落占用的量化间隔数

}

else if(InputValue>=256)

{

OutputValue=OutputValue+0x50; //当InputValue大于1024时，在第6段，段内码：101 InputValue=(InputValue-256)/16; //求在该段落占用的量化间隔数

}

else if(InputValue>=128)

{

OutputValue=OutputValue+0x40; //当InputValue大于1024时，在第5段，段内码：100 InputValue=(InputValue-128)/8; //求在该段落占用的量化间隔数

}

else if(InputValue>=64)

{

OutputValue=OutputValue+0x30; //当InputValue大于1024时，在第4段，段内码：011 InputValue=(InputValue-64)/4; //求在该段落占用的量化间隔数

}

else if(InputValue>=32)

{

OutputValue=OutputValue+0x20; //当InputValue大于1024时，在第3段，段内码：010 InputValue=(InputValue-32)/2; //求在该段落占用的量化间隔数

}

else if(InputValue>=16)

{

OutputValue=OutputValue+0x10; //当InputValue大于1024时，在第2段，段内码：001 InputValue=InputValue-16; //求在该段落占用的量化间隔数

}

else

{

OutputValue=OutputValue+0x00; //当InputValue大于1024时，在第1段，段内码：000 }

/****************段内码编码*****************/

OutputValue+=InputValue;

return OutputValue; //完成编码，返回编码值

}

4.PCM译码

extern int PCM_StudentAlawDecode(unsigned char CodeValue)

{

int DecodeValue = 0;

/*Add your code here*/

//将编码后的8位值分三部分，最高位极性码暂时不考虑，还有段内码和段落码

int code_1=0;

int code_2=0;

code_1=CodeValue & 0x70; //code_1代表三位的段落码

code_2=CodeValue & 0x0f; //code_2代表四位的段内码

//译码时只需判断它的段落码的值，根据段落码的值获得它的量化间隔和起始电平

//译码出来的值：起始电平+量化间隔×段内码

switch(code_1)

{

case 0x70:DecodeValue+=1024+64*code_2;

break; //起始电平：1024，量化间隔：64

case 0x60:DecodeValue+=512+32*code_2; break; //起始电平512，量化间隔32

case 0x50:DecodeValue+=256+16*code_2; break; //起始电平256，量化间隔16

case 0x40:DecodeValue+=128+8*code_2; break; //起始电平128，量化间隔8

case 0x30:DecodeValue+=64+4*code_2; break; //起始电平64，量化间隔4

case 0x20:DecodeValue+=32+2*code_2; break; //起始电平32，量化间隔2

case 0x10:DecodeValue+=16+1*code_2; break; //起始电平16，量化间隔1

case 0x00:DecodeValue+=0+1*code_2; //起始电平0，量化间隔1 }

//根据极性码的值判断译码后的值的正负

if((CodeValue&0x80)==0x0)

DecodeValue=-DecodeValue;

else

DecodeValue=DecodeV alue;

return DecodeV alue;

}

三、CVSD编译码程序

1.CVSD编码

extern STUDENT_CVSD* CVSD_StudentEncode(int Amplitude, int SampleTimes, int Frequency) {

double Sample[30];

int i;

for(i = 0; i < SampleTimes; i ++){ /*64khz is the sample frequency*/

Sample[i] = Amplitude * sin(2 * PI * Frequency * (double)i /(double)(64*1024));

}

/*Add your code here*/

/**************程序中变量的初始化*****************/

double h=1-(double)1/32; //由y（k）到x（k）的估计的参数h

double beta=1-(double)1/1024; //beta为控制量阶衰减的因子

int bk=0; //编码值b（k）

double stepmin=10; //设定的最小量阶

double stepmax=1024; //设定的最大量阶

double step=10; //程序设定的初始量阶

int count1=0; //编码值b（k）连续1的计数

int count0=0; //编码值b（k）连续0的计数

double ymin;

double ymax;

double y=0;

double y1=0;

double temp1=0;

double temp2=0;

ymin=-pow(2,15)-1; //设定y（k）的最小值

ymax=pow(2,15)-1; //设定y（k）的最大值

Student_CVSD.Encode[0]=1;

Student_CVSD.Decode[0]=0;

Student_CVSD.Decode[1]=0;

for(i=1;i

{

//根据当前输入CGVSD编码器的采样值和前一个采样的估计值的大小关系计算编码值b （k）

if(Sample[i]>Student_CVSD.Decode[i])

bk=1;

else if(Sample[i]==Student_CVSD.Decode[i])

bk=0;

else

bk=-1;

//判断b（k）值的大小，若是1，则相应编码结果是1，且将连续1个数计数，清连续0的个数的计数

if(bk>=1)

{

Student_CVSD.Encode[i]=1;

count1++;

count0=0;

}

else //判断b（k）值的大小，若不是1，则相应编码结果是0，且将连续0个数计数，清连续1的个数的计数

{

Student_CVSD.Encode[i]=0;

count0++;

count1=0;

}

//当连续1的个数等于或超过4时，增加量阶，将新量阶与最大量阶进行判断，取较小的作为新量阶

if(count1>=4)

temp1=step+stepmin;

temp2=stepmax;

if(temp1

step=temp1;

else

step=temp2;

count1--;

}

//当连续0的个数等于或超过4时，增加量阶，将新量阶与最大量阶进行判断，取较小的作为新量阶

else if(count0>=4)

{

temp1=step+stepmin;

temp2=stepmax;

if(temp1

step=temp1;

else

step=temp2;

count0--;

}

//当没有连续4个0或者1出现时，让量阶进行衰减，将新量阶与最小量阶进行判断，取较大的作为新量阶

else

{

temp1=beta*step; //新量阶为：当前量阶×控制量阶衰减的因子

temp2=stepmin;

if(temp1>temp2)

step=temp1;

else

step=temp2;

}

//计算y（k）的当前估计值，对此估计值进行判断让其在设定y（k）的最小值和最大值之间，不要超出范围

y1=Student_CVSD.Decode[i]+bk*step;

if(y1>=0)

{

temp1=y1;

temp2=ymax;

if(temp1

y=temp1;

else

y=temp2;

}

{

temp1=y1;

temp2=ymin;

if(temp1>temp2)

y=temp1;

else

y=temp2;

}

if(i==(SampleTimes-1)) //停止采样，返回

continue;

Student_CVSD.Decode[i+1]=h*y; //计算当前值的估计值

//保持y不超出给定范围

if(y>ymax)

ymax=y;

if(y

ymin=y;

//保持量阶不超出给定的范围

if(step>stepmax)

stepmax=step;

if(step

stepmin=step;

}

return &Student_CVSD;

}

2.CVSD译码

extern STUDENT_CVSD* CVSD_StudentDecode(int SampleTimes) {

/*Add your code here*/

//定义变量以及相关变量初始化

int i;

int k;

int a=0;

int b[32];

double h=1-(double)1/32;

double beta=1-(double)1/1024;

double x[30];

double y[30];

double d[31];

x[0]=0;

d[1]=0;

for(i = 0; i

b[i+1]=Student_CVSD.Encode[i]; //获得编码值b（k）

if (b[1]==1)

y[1]=x[0]+d[1];

else

y[1]=x[0]-d[1];

x[1]=h*y[1]; //根据估计值获得译码的x（k）的值

for(k=2;k

{

if(k>4) //判断是否有连续四个0或者1的编码值，是的话将变量a置1；否则a=0 {

if((b[k]==1)&&(b[k-1]==1)&&(b[k-2]==1)&&(b[k-3]==1)) a=1;

else if((b[k]==0)&&(b[k-1]==0)&&(b[k-2]==0)&&(b[k-3]==0)) a=1;

else a=0;

}

if(a==1)

{

//当a=1时，在量阶不超过最大量阶1024的情况下，将量阶加10

if(d[k-1]+10>1024) d[k]=1024;

else d[k]=d[k-1]+10;

}

else

{

//当a=0时，在量阶不小于最小量阶10的情况下，让量阶衰减，衰减因子为beta

if((beta*d[k-1])>10) d[k]=beta*d[k-1];

else d[k]=10;

}

//计算y（k）的当前估计值

if(b[k]==1)

y[k]=x[k-1]+d[k];

else

y[k]=x[k-1]-d[k];

//得出当前值的估计值，即译码的x（k）的值

x[k]=h*y[k];

}

for (i = 0; i

Student_CVSD.Decode[i]=x[i]; //将译码后的值赋给Student_CVSD.Decode return &Student_CVSD;

}