通信系统综合实验代码Word文档下载推荐.docx
《通信系统综合实验代码Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《通信系统综合实验代码Word文档下载推荐.docx（20页珍藏版）》请在冰点文库上搜索。
//功能选择位
/****输入信息序列***/
printf（"
通信系统综合实验--数字基带仿真实验--2/3FEC的实现\n"
）;
do
{
if（flag>
0）
printf（"
对不起，您的输入值超出范围！
\n"
flag++;
printf（"
请输入0---3FFH之间的十六进制数，并按回车！
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;
}
您输入的数转化为二进制后的编码前的序列：
（MSB--->
LSB）:
"
%d"
bit2[i]）;
/***2/3FEC编码***/
5;
i++）//移位寄存器的初始状态全清零
reg[i]=0;
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;
经2/3FEC编码后的二进制信息序列为（MSB-->
LSB）：
i++）//输出编码序列的高五位
code[i]=reg[i];
rbit2[i]=code[i];
code[i]）;
for（;
15;
i++）//输出编码序列的信息位
code[i]=bit2[i-5];
****************************************************************************\n"
2.2/3FEC译码
/***以下进入菜单选项，可以选择加误码、复原、译码和返回功能***/
while（sel!
=4）
功能菜单如下，您可以选择译码，加误码，复原，以及返回功能：
操作方法：
按1----->
译码，按2----->
误码，按3----->
复原，按0----->
返回\n"
请您选择功能！
sel）;
getchar（）;
switch（sel）//功能选择
{
//译码功能
case1:
err_num=0;
err_flag=0;
for（i=0;
i++）//移位寄存器内容全清0
reg[i]=0;
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;
printf（"
rbit2[i]）;
\n译码结果为:
else
{
if（reg[4]+reg[3]+（!
reg[2]）+reg[1]+（!
reg[0]）==5）//11010:
x^14modg
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）
信道传输产生1位错码!
可纠错!
该码位于第%d位,译码结果为：
15-err_flag）;
else
信道传输产生2位或2位以上错码!
超出2/3FEC码纠错范围，不可纠错!
译码结果为:
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;
printf（"
十六进制结果为：
%X%X%X\n"
decodemes[0],decodemes[1],decodemes[2]）;
********************************************************************\n"
break;
}
//误码功能
case2:
请您输入加入误码后的二进制序列（15位）,可以修改编码后的二进制序列的一位或多位！
误码序列：
"
gets（err_code）;
//输入误码
if（err_code[i]=='
0'
）//对某一个或某些位设置误码
rbit2[i]=0;
rbit2[i]=1;
break;
}
//复位功能
case3:
rbit2[i]=code[i];
//恢复正确的码
//返回功能
case4:
您即将退出，您真的要退出吗？
Y/N\n"
ch=getchar（）;
if（（ch=='
N'
）||（ch=='
n'
））
sel=0;
default:
您的操作序号输入有误,执行不了任何功能，请重新输入!
}
}
二、PCM编译码程序
3.PCM编码
externunsignedcharPCM_StudentAlawEncode（intInputValue）
unsignedcharOutputValue=0x0;
//初始化编码输出值
/*Addyourcodehere*/
/****************极性码编码*****************/
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;
//求在该段落占用的量化间隔数
elseif（InputValue>
=512）
OutputValue=OutputValue+0x60;
//当InputValue大于1024时，在第7段，段内码：
110
InputValue=（InputValue-512）/32;
//该段落占用的量化间隔数
=256）
OutputValue=OutputValue+0x50;
//当InputValue大于1024时，在第6段，段内码：
101
InputValue=（InputValue-256）/16;
=128）
OutputValue=OutputValue+0x40;
//当InputValue大于1024时，在第5段，段内码：
100
InputValue=（InputValue-128）/8;
=64）
OutputValue=OutputValue+0x30;
//当InputValue大于1024时，在第4段，段内码：
011
InputValue=（InputValue-64）/4;
=32）
OutputValue=OutputValue+0x20;
//当InputValue大于1024时，在第3段，段内码：
010
InputValue=（InputValue-32）/2;
=16）
OutputValue=OutputValue+0x10;
//当InputValue大于1024时，在第2段，段内码：
001
InputValue=InputValue-16;
OutputValue=OutputValue+0x00;
//当InputValue大于1024时，在第1段，段内码：
000
}
/****************段内码编码*****************/
OutputValue+=InputValue;
returnOutputValue;
//完成编码，返回编码值
4.PCM译码
externintPCM_StudentAlawDecode（unsignedcharCodeValue）
intDecodeValue=0;
/*Addyourcodehere*/
//将编码后的8位值分三部分，最高位极性码暂时不考虑，还有段内码和段落码
intcode_1=0;
intcode_2=0;
code_1=CodeValue&
0x70;
//code_1代表三位的段落码
code_2=CodeValue&
0x0f;
//code_2代表四位的段内码
//译码时只需判断它的段落码的值，根据段落码的值获得它的量化间隔和起始电平
//译码出来的值：
起始电平+量化间隔×
段内码
switch（code_1）
case0x70:
DecodeValue+=1024+64*code_2;
//起始电平：
1024，量化间隔：
64
case0x60:
DecodeValue+=512+32*code_2;
//起始电平512，量化间隔32
case0x50:
DecodeValue+=256+16*code_2;
//起始电平256，量化间隔16
case0x40:
DecodeValue+=128+8*code_2;
//起始电平128，量化间隔8
case0x30:
DecodeValue+=64+4*code_2;
//起始电平64，量化间隔4
case0x20:
DecodeValue+=32+2*code_2;
//起始电平32，量化间隔2
case0x10:
DecodeValue+=16+1*code_2;
//起始电平16，量化间隔1
case0x00:
DecodeValue+=0+1*code_2;
//起始电平0，量化间隔1
//根据极性码的值判断译码后的值的正负
if（（CodeValue&
0x80）==0x0）
DecodeValue=-DecodeValue;
else
DecodeValue=DecodeValue;
returnDecodeValue;
三、CVSD编译码程序
1.CVSD编码
externSTUDENT_CVSD*CVSD_StudentEncode（intAmplitude,intSampleTimes,intFrequency）
doubleSample[30];
inti;
for（i=0;
i<
SampleTimes;
i++）{/*64khzisthesamplefrequency*/
Sample[i]=Amplitude*sin（2*PI*Frequency*（double）i/（double）（64*1024））;
/*Addyourcodehere*/
/**************程序中变量的初始化*****************/
doubleh=1-（double）1/32;
//由y（k）到x（k）的估计的参数h
doublebeta=1-（double）1/1024;
//beta为控制量阶衰减的因子
intbk=0;
//编码值b（k）
doublestepmin=10;
//设定的最小量阶
doublestepmax=1024;
//设定的最大量阶
doublestep=10;
//程序设定的初始量阶
intcount1=0;
//编码值b（k）连续1的计数
intcount0=0;
//编码值b（k）连续0的计数
doubleymin;
doubleymax;
doubley=0;
doubley1=0;
doubletemp1=0;
doubletemp2=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;
SampleTimes;
//根据当前输入CGVSD编码器的采样值和前一个采样的估计值的大小关系计算编码值b（k）
if（Sample[i]>
Student_CVSD.Decode[i]）
bk=1;
elseif（Sample[i]==Student_CVSD.Decode[i]）
bk=0;
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<
temp2）
step=temp1;
else
step=temp2;
count1--;
//当连续0的个数等于或超过4时，增加量阶，将新量阶与最大量阶进行判断，取较小的作为新量阶
elseif（count0>
count0--;
//当没有连续4个0或者1出现时，让量阶进行衰减，将新量阶与最小量阶进行判断，取较大的作为新量阶
else
temp1=beta*step;
//新量阶为：
当前量阶×
控制量阶衰减的因子
temp2=stepmin;
if（temp1>
//计算y（k）的当前估计值，对此估计值进行判断让其在设定y（k）的最小值和最大值之间，不要超出范围
y1=Student_CVSD.Decode[i]+bk*step;
if（y1>
=0）
temp1=y1;
temp2=ymax;
y=temp1;
y=temp2;
temp2=ymin;
if（i==（SampleTimes-1））//停止采样，返回
continue;
Student_CVSD.Decode[i+1]=h*y;
//计算当前值的估计值
//保持y不超出给定范围
if（y>
ymax）
ymax=y;
if（y<
ymin）
ymin=y;
//保持量阶不超出给定的范围
if（step>
stepmax）
stepmax=step;
if（step<
stepmin=step;
return&
Student_CVSD;
2.CVSD译码
externSTUDENT_CVSD*CVSD_StudentDecode（intSampleTimes）
//定义变量以及相关变量初始化
intk;
inta=0;
intb[32];
doublex[30];
doubley[30];
double
升级会员 