基于C语言的卷积编码实现 浅谈卷积和滤波之区别

本文主要是关于卷积编码的相关介绍，并就卷积编码简述了基于C语言的卷积编码实现方法，最后着重阐述了卷积和滤波的区别。

卷积编码

在信道编码研究的初期，人们探索、研究出各种各样的编码构造方法，其中包括卷积码。早在1955年，P.Elias首先提出了卷积码。但是它又经历了十几年的研究以后，才开始具备应用价值。在这十几年期间，J.M.Wozencraft提出了适合大编码约束度的卷积码的序列译码，J.L.Massey提出了实现简单的门限译码，A.J.Viterbi提出了适合小编码约束度的卷积码Viterbi算法。20年后，即1974年，L.R.Bahl等人又提出一种支持软输入软输出（SISO，Soft-Input Soft-Output）的最大后验概率（MAP，Maximum A Posteriori）译码——BCJR算法。其中，Viterbi算法有力地推动了卷积码的广泛应用，BCJR算法为后续Turbo码的发现奠定了基础。

基于C语言的卷积编码实现

实现(2, 1, 7)卷积码编码

信息序列1001 1010 1111 1100

生成序列g1 = 1011011;g2 = 1111001

初始状态全0.

以上参数可自行在main中修改。

/***This is an simple example program of convolutional encoder.

*The information sequence， the register initial states and the generation sequence

* can all be modified in the main function.

*/

#include《stdio.h》

#define LEN（array， len）{len=sizeof（array）/sizeof（array［0］）;}//Size of array

int encoder（int **gen， int n， int L， int reg［］， int m， int inf［］， int inf_len， int output［］）

/*encoder（int **gen， int n， int L， int reg［］， int m， int inf［］， int inf_len， int output［］）

*This function is a convolutional encoder.

*gen is the generation sequence， which is a two-dimension array，

and it is a two-dimension pointer，

*n is the number of bits out the encoder at each clock cycle，

*L is for the constraight length，

*reg is for the shift registers，

*m is for the number of registers，

*inf is for the information sequence，

*inf_len is for the inf length，

*output is for the output code.

*/

{

int inf_ex［inf_len + m］;

int i，j;//Index

for （i=0;i 《 inf_len + m;i++）//Extend the information sequence to include the last m bits

{

if（i 《 inf_len）

inf_ex［i］ = inf［i］;

else

inf_ex［i］ = 0;

}

for （i=0;i 《 inf_len + m;i++）//Foreach bit in extend information

{

for （j=0;j 《 n;j++）//Output n bits at each clock cycle

{

int out_tem=0;//Temp number

if （*（gen + L*j） == 1）//Judge whether the next information bit should paticipate in the Mod op

out_tem += inf_ex［i］;

int k;

for （k=0;k 《 m;k++）//Foreach registers

{

if （*（gen + L*j + k + 1） == 1）

out_tem += reg［k］;//Mod op according to the generation sequence

}

out_tem %= 2;//Mod 2

output［i*n + j］ = out_tem;

}

for （j=m - 1;j 》 0;j--）//Register shift

{

reg［j］ = reg［j - 1］;

}

reg［0］ = inf_ex［i］;//Input information bits into register

}

return 1;

}

main（）

{

int inf［］={1， 0， 0， 1， 1， 0， 1， 0， 1， 1， 1， 1， 1， 1， 0， 0};//Information sequence

int inf_len;//Information length

LEN（inf， inf_len）;

int gen［2］［7］={{1， 0， 1， 1， 0， 1， 1}， {1， 1， 1， 1， 0， 0， 1}};//Generation sequence

int n;//The number of bits out the encoder at each clock cycle

int L;//Constraight length

LEN（gen， n）;

LEN（gen［0］， L）;

int m=L - 1;//The number of shift registers

int init_s［］={0， 0， 0， 0， 0， 0}; //Initial states are all zero

int reg［m］;//Register

int i;//Index

for （i=0;i 《 m;i++）

{

reg［i］ = init_s［i］;

}

int output_len=（inf_len + m）*n;//Output length， every bit of input can generate n bits of output sequence

int output［（inf_len + m）*n］;//Output sequence

encoder（gen， n， L， reg， m， inf， inf_len， output）;//Encoder

for （i=0;i 《 output_len;i++）

{

printf（“%d”， output［i］）;

}

system（“pause”）;

}

卷积和滤波之区别

　　首先，从定义看，conv表示卷积，filter表示滤波。conv的定义公式如下：

　　y（n）=∑i=0N+M−1x（i）h（n−i）y（n）=∑i=0N+M−1x（i）h（n−i）

　　其中x（n）长度为N；h（n）长度为M；

　　fileter表示卷积，调用格式如下：

　　fileter（h，1，x）;

　　h=［1，2，3］;

　　123

　　表示差分方程：

　　y（n）=x（n）+2*x（n-1）+3*x（n-2）;

　　12

　　即

　　y（n）=x（n）*h（0）+x（n-1）*h（1）。..+x（0）*h（n）

　　=x（0）*h（n）+x（1）*h（n-1）。..+x（n）*h（0）

　　123

　　即

　　y（n）=∑i=0Nx（i）h（n−i）y（n）=∑i=0Nx（i）h（n−i）

　　所以，除了物理意义的不同之外，二者在计算上只是长度不同。

　　卷积的计算：

　　x=［1，2，5，4，8］;

　　h=［2，6，4］;

　　1 2 5 4 8

　　2 6 4

　　__________

　　4 8 20 16 32

　　6 12 30 24 48

　　2 4 10 8 16

　　---------------------

　　2 10 26 46 60 64 32

　　可以看出卷积的结果是［2 10 26 46 60 64 32］;

　　那么filter（滤波）的结果就是［2 10 26 46 60］;

　　接下来用MATLAB程序验证我们的计算结果：

　　》》 h=［2 6 4］;

　　》》 x=［1 2 5 4 8］;

　　》》 y1=conv（h，x）

　　y1 =

　　2 10 26 46 60 64 32

　　》》 y2=filter（h，1，x）

　　y2 =

　　2 10 26 46 60

　　在用C语言等其他语言进行实现是可以采用定义，利用两个for循环完成代码。

　　卷积的列表法计算 ：

结语

关于C语言下的卷积编码实现方法就介绍到这了，希望本文能让你对卷积编码有更深的认识。

相关阅读推荐：什么是卷积码

相关阅读推荐：什么是卷积