完整word版matlab74汉明码和74循环码的编程设计Word格式.docx

完整word版matlab74汉明码和74循环码的编程设计Word格式.docx

《完整word版matlab74汉明码和74循环码的编程设计Word格式.docx》由会员分享，可在线阅读，更多相关《完整word版matlab74汉明码和74循环码的编程设计Word格式.docx（18页珍藏版）》请在冰豆网上搜索。

6）

式（6）可简化为HAT0T，H为监督矩阵，则由式（6）可得到监督矩阵

1110100

H1101010=[PIr]（7）

1011001

因为生成矩阵G=[IkQ]=[IkP'

]，所以由（7）得生成矩阵G如下：

1

11

GIkQ[I

kP'

]

10

01

然后利用信息位和生成矩阵

G相乘产生整个码组，

即有

A=a6a5a4a3a2a1a0a6a5a4a3G

（8）

其中A为整个码组矩阵，a6a5a4a3是信息位

根据上述原理可以得到（7,4）汉明码的整个码组。

（2）译码与检错、纠错原理当数字信号编码成汉明码后，由于信道噪声的存在，使得经过信道后的汉明码会发生差错，使得接收端接收到错码，因此需要多错码进行纠正，以提高通信系统的抗干扰能力及可靠性。

下面分析纠错译码原理。

设B为接收码组，它是一行7列的矩阵，即B=[b1b2b3b4b5b6b7]，B中可能含

有错码，错误图样EAB=[e7e6e5e4e3e2e1]，在E的表达式中，有

0当biai时

ei10当当bbiiaaii时时（i0,1,2,7）

若ei0，表示该码元没错；

若ei1，表示该码元为错码。

由EAB得

ABE（9）

（9）表示接收码组和错误图样之和等于正确码组U，通过（9）式就可以实现

纠错。

可以用标准阵来表示所有可能的2n个n元码组的接收矢量，（n,k）码的标准阵形式如下：

A1

A2

A3

A4

A5

E2

A2E2

A3E2

A4E2

A5E2

E3

A2E3

A3E3

A4E3

A5E3

Ej

A2Ej

A3Ej

A4Ej

A5Ej

E2nk

A2E2nk

A3E2nk

A4E2nk

A5E2nk

应该注意到，码组A1（全0码字）起两个作用：

既是其中一个正确码组，也是错误图样E1,代表A1所在行没有错误。

标准阵中的A1,E2,E3E2nk是陪集首，陪集首的选择是有规定的，第j行的陪集首是在前j-1行中没有出现的最小码组，即错误图样E，如果不选错误图样作为陪集首，译码将会产生错误。

对于（7,4）汉明码，其最小码重是3，设码的纠错能力为t，根据公式tdmin1

2得该码的纠错能力为1，即能纠错一位错码。

由于根据完备码的定义有

tn

2nkn（12）

j0j

将（7,4）码代入（12）可以得知，（7,4）汉明码为完备码组，只能纠错和检错一位错码。

对于正确码组A而言，有

AHT0（10）

当接收到错码变成码组B时，有

SBHT（AE）HTAHTEHTEHT（11）

其中S为校正子所构成的校正矩阵，由于S和E如（11）所示的一一对应的关系，对于（7,4）码，错误图样与伴随式的对应关系如下

表2.2伴随式查询表

错误图样

伴随式

0000000

00000001

0000010

0000100

0001000

0010000

0100000

1000000

通过伴随式查询表，可以由伴随式得到错误图样，从而实现检错，进而实现纠错。

3、实验内容

由于编码涉及到矩阵的运算，而matlab在处理矩阵运算方面有独特优势，所以这次选择用matlab工具来实现（7,4）汉明码的编码和译码。

（7,4）码的编码比较简单，已知监督矩阵H，可以通过函数求生成矩阵G，然后信息位和生成矩阵G相乘就可得到所有的码组，（7,4）汉明码的编码程序如下：

%%%（7,4）汉明码编码——2012.11.10

clearall;

clc;

H=[1110100;

1101010;

1011001];

%（7,4）码的监督矩阵

G=gen2par（H）%（7,4）码的生成矩阵

m=[0000;

0001;

0010;

0011;

0100;

0101;

0110;

0111;

1000;

1001;

1010;

1011;

1100;

1101;

1110;

1111];

%%所有的信息位

U=[rem（m*G,2）];

disp（'

（7,4）汉明码的编码结果：

'

）;

disp（U）;

由原理分析可知，要实现纠错和检错译码，关键在于伴随式查询表，因此如

何实现伴随式查询表是编程的关键，（7,4）汉明码的译码程序如下：

%%%下面是（7,4）码译码

A=input（'

请输入接收码组：

[r,l]=size（A）;

E=[0000000;

0000001;

0000010;

0000100;

0001

000;

0010000;

0100000;

1000000];

%%%%求%校正子，然后将其转化成十进制数

fori=1:

r

Sx=S（i,1）*4+S（i,2）*2+S（i,3）;

end

%%%%下面是（7,4）码检错

switch（Sx）

此接收码字没错'

）

case1

注意：

此接收码字的第一位有错，请纠正'

case2

此接收码字的第二位有错，请纠正'

）case4

此接收码字的第三位有错，请纠正'

case3

此接收码字的第四位有错，请纠正'

case5

此接收码字的第五位有错，请纠正'

case6

此接收码字的第六位有错，请纠正'

case7

此接收码字的第七位有错，请纠正'

）end

%%%下面为在知道哪位出错的情况下，进行纠正

case0

B（i,:

）=A（i,:

）+E（1,:

）;

case1

）+E（2,:

case2

）+E（3,:

case4

）+E（4,:

case3

）+E（5,:

case5

）+E（6,:

case6

）+E（7,:

case7

）+E（8,:

B=rem（B,2）;

纠错后的码字'

disp（B）;

由于可能在纠错过程中会产生错误，在此，我们设计了检错纠错是否产生错误的程序，程序如下：

%%%%下面为检查纠错是否产生错误

k=1;

fork=1:

16

if（U（k,:

）==B）flag=1;

break

ifflag==1

纠错无误'

else

纠错有误，请检查'

End

由于译码的目的就是找出信息位c，所以，需要从纠错后的码组中提取出信息位，提取信息位的程序如下：

%%%下面为提取码的信息位

forj=1:

c（:

j）=B（:

j）;

信息位c如下：

disp（c）

4、实验结果分析

运行编码程序后，得到如下结果

通过理论计算，可以得出实验结果和理论编码结果吻合，

可以发现，

（7,4）

码的最小码重是3。

当接收码组为[1101100]时，译码结果如下

运行程序后，可以看到：

当接收码组为[1101100]时，会出现“注意：

此接收码字的第六位有错，请纠正”的提示，在程序中，为防止纠错错误，我设置了纠错后的码和编码结果的比较，如果纠错后的码和编码结果当中的某个码组相同，说明纠错无误，否则纠错有误。

当接收码组为[1101100]时，经过纠错后出现纠错无误的结果，说明纠错后的码是正确码组。

然后提取纠错后的码组的信息位c，从运行结果可以看出，c=1001。

当接收码组为[0101101]时，运行结果如下：

此接收码组本来就是一个正确码组，所以通过运行程序后，会出现“此接收码字没错”的提示，纠错后的码字和接收的码组是相同的，检查到纠错无误，然后提取信息位c，信息位c=0101，整个译码完成。

5、改进建议

（7,4）汉明码的编码与译码相对比较简单，可以通过matlab编程实现对信道编码性能的分析，可以编程实现比较编码后的误码率和没编码的误码率，也可以编程实现在有噪声的情况下来进行译码。

创新实验二：

（7,4）循环码的编码与译码

1．实验编码原理：

根据循环码的代数性质建立系统编码的过程，可以把消

息矢量用如下多项式表示：

m（x）mk1xk1mk2xk2...m1xm0

要编码成系统循环码形式，把消息比特移入码字寄存器的最右边k位，而把监督比特加在最左边的n-k个中，则要用xnk乘以m（x）得到xnkm（x）=

n1n2nk1nk

mk1xmk2x...m1xm0x

nk

xm（x）=q（x）g（x）+p（x），其中p（x）可以表示为

nk1nk

p（x）=pnk1x...p1xp0，则p（x）+xm（x）

n1n2nk1nknk1

=mk1xmk2x...m1xm0x+pnk1x...p1xp0

，pnk1，m0，m1，·

·

，

另U（x）=p（x）+xm（x），则U=（p0，p1，p2，

mk1）

本实验根据以上原理，用matlab实现书上例6.8系统形式的循环码，生成多

项式为g（x）=1xx

2．实验译码原理：

译码的实验原理g（x）=，在（n3，k）循环码中，

n1xx3由于g（x）能除尽,因此xn1可分解成g（x）和其他因式的乘积，记为

即可写成

监督矩阵多项式可表示为

x2h**（x）

H（x）xh*（x）

*

h*（x）

3．（7,4）循环码的编码（4位）的程序：

clear;

a=input（'

请输入消息矢量：

%高次项系数在前的生成多项式Gx=[1011];

%将数组a的高位依次放在数组Data的低位Data=zeros（1,7）;

Data

（1）=a（4）;

Data

（2）=a（3）;

Data（3）=a

（2）;

Data（4）=a

（1）;

%Data除以Gx得到余数Rx[Qx,Rx]=deconv（Data,Gx）;

b=Rx+Data;

%将数组b的高位放在后面c=b

（1）;

b

（1）=b（7）;

b（7）=c;

c=b

（2）;

b

（2）=b（6）;

b（6）=c;

c=b（3）;

b（3）=b（5）;

b（5）=c;

%将数组b校正fori=1:

7

ifrem（abs（b（i））,2）==0b（i）=0;

endendfori=1:

ifrem（abs（b（i））,2）==1b（i）=1;

endenddisp（'

输入序列：

adisp（'

编码输出序列：

b程序运行结果为：

运行结果的编码如下：

序号

输入序列

输出序列

0000

0000000

9

1000

1101000

0001

1010001

1001

0111001

0010

1110010

1010

0011010

0011

0100011

12

1001011

5

0100

0110100

13

1100

1011100

6

0101

1100101

14

1101

0001101

0110

1000110

15

0101110

8

0111

0010111

1111

1111111

改变输入序列

4．相对应的译码和纠错（7位）程序：

r=[1001111];

h=[1,0,0;

1,1,0;

1,1,1;

0,1,1;

1,0,1;

0,1,0;

0,0,1];

b=flipud（h）;

s=r*b;

ifrem（abs（s（i））,2）==0

s（i）=0;

endfori=1:

ifrem（abs（s（i））,2）==1s（i）=1;

endend

ifs==[000]e=[0000000];

elseifs==[100]e=[0000001];

elseifs==[110]e=[0000010];

elseifs==[111]e=[0000100];

elseifs==[011]e=[0001000];

elseifs==[101]e=[0010000];

elseifs==[010]e=[0100000];

elses==[001]e=[1000000];

u=r+e;

fori=1:

ifrem（abs（u（i））,2）==0u（i）=0;

ifrem（abs（u（i））,2）==1u（i）=1;

endendData=zeros（1,4）;

Data

（1）=u（4）;

Data

（2）=u（5）;

Data（3）=u（6）;

Data（4）=u（7）;

ife==[0000000]disp（'

没有错误：

）k=0,elsedisp（'

第几位错误：

）k=find（e）

;

enddisp（'

接收码字'

）

disp（'

译码输出序列：

Data

k=5接收码字

r=1001111译码输出序列：

Data=1011

以上编码有个缺点，就是它只能对一个消息矢量（4位）进行编码，我又在这个基础上编写了一个可以同时对位数是4的倍数的消息矢量进行编码。

5．多位循环码（4的倍数）的编码程序如下：

clear;

a=[11001011];

[X,N]=size（a）;

%将信息码分为M帧，1帧4个信息码

M=ceil（N/4）;

d=zeros（1,4）;

b=zeros（1,7*M）;

Data=zeros（1,7）;

M

d（j）=a（j+（k-1）*4）;

%生成多项式

Gx=[1011];

Data

（1）=d（4）;

Data

（2）=d（3）;

Data（3）=d

（2）;

Data（4）=d

（1）;

%Data除以Gx得到余数Rx

[Qx,Rx]=deconv（Data,Gx）;

e=Rx+Data;

b（7*k-6:

7*k）=e（1:

7）;

c=b（1+（k-1）*7）;

b（1+（k-1）*7）=b（7+（k-1）*7）;

b（7+（k-1）*7）=c;

c=b（2+（k-1）*7）;

b（2+（k-1）*7）=b（6+（k-1）*7）;

b（6+（k-1）*7）=c;

c=b（3+（k-1）*7）;

b（3+（k-1）*7）=b（5+（k-1）*7）;

b（5+（k-1）*7）=c;

M*7

输入序列：

adisp（'

编码输出序列：

b程序运行结果如下：

a=

11001011编码输出序列：

b=

Columns1through13

1011100100101

Column14

6．多位译码（7的倍数）纠错程序：

r=[10011001001001];

[X,N]=size（r）;

%将接收到的码分为M帧，1帧7个信息位M=ceil（N/7）;

d=zeros（1,7）;

U=zeros（1,4*M）;

Data1=zeros（1,7*M）;

Data=zeros（1,7*M）;

7d（j）=r（j+（i-1）*7）;

ends=d*b;

ifrem（abs（s（k））,2）==0s（k）=0;

ifrem（abs（s（k））,2）==1s（k）=1;

ifs==[000]

e=[0000000];

elseifs==[100]

e=[0000001];

elseifs==[110]

e=[0000010];

elseifs==[111]

e=[0000100];

elseifs==[011]

e=[0001000];

elseifs==[101]

e=[0010000];

elseifs==[010]

e=[0100000];

elses==[001]

e=[1000000];

endu=d+e;

fork=1:

ifrem（abs（u（k））,2）==0u（k）=0;

endendfork=1:

ifrem（abs（u（k））,2）==1u（k）=1;

endendData（1+7*（i-1））=e

（1）;

Data（2+7*（i-1））=e

（2）;

Data（3+7*（i-1））=e（3）;

Data（4+7*（i-1））=e（4）;

Data（5+7*（i-1））=e（5）;

Data（6+7*（i-1））=e（6）;

Data（7+7*（i-1））=e（7）;

U（1+（i-1）*4）=u（4）;

U（2+（i-1）*4）=u（5）;

U（3+（i-1）*4）=u（6）;

U（4+（i-1）*4）=u（7）;

endifData==Data1disp（'

）m=0,elsedisp（'

）m=find（Data）

接收到的码字：

rdisp（'

U

运行结果：

第几位错误：

m=313接收到的码字：

r=Columns1through13

1001100100100

1译码输出序列：

U=11001011若把接受序列r改为r=[1011001]，即1100的编码1011100的第5位和第7位同时该变，则运行结果为：

第几位错误