无线通信与编码_MATLAB实现Turbo码的仿真_含仿真代码_Dr.WuYufei

本次Turbo码仿真代码使用的是Dr.WuYufei大佬的，将其中的部分注释修改为了中文（不恰当之处请多多指教），另外添加了一小段的绘图部分。

1、背景简介

1993 年两位法国教授Berrou、Glavieux 和他们的缅甸籍博士生Thitimajshima 提出的一种全新的编码方式——Turbo 码。它巧妙地将两个简单分量码通过伪随机交织器并行级联来构造具有伪随机特性的长码，并通过在两个软入/软出（SISO）译码器之间进行多次迭代实现了伪随机译码。
Turbo码依靠迭代译码解决计算复杂性问题，通过在编译码器中交织器和解交织器的使用，有效地实现随机性编译码的思想，通过短码的有效结合实现长码，达到了接近Shannon理论极限的性能。

2、Turbo码编码原理

典型的Turbo编码器如图1所示，主要由两个结构相同的RSC（带反馈的卷积编码器）和一个交织器并行实现，编码后的校验位通过删余阵，删余可以产生不同的码率。

信息序列一方面进入RSC1，另一方面经过交织器处理后进入RSC2，交织器的处理是输入序号至输出序号的一映射。为了提高码率，除了选用高码率的分量码外，还可以采取删余操作从两个校验序列中删除一些校验位，再与信息序列复用在一起输出。递归系统卷积码（RSC）不同于一般的卷积编码器在于其的反馈结构。

3、Turbo译码原理

Turbo码的译码算法主要分为两大类：一类是基于最大后验概率（Maximum A Posteriori，MAP）软输出算法，这类算法由标准MAP算法演化得来。对标准MAP算法取对数得到Log-MAP算法，对Log-MAP算法中的分支度量进行简化，得到MAX-Log-MAP算法。
另一类是基于Viterbi算法的软输出算法，是对卷积码的译码算法Viterbi的改进，使其满足SISO特性，软信息可以在两个分量译码器之间交换。这种改进的Viterbi算法为软输出Viterbi算法（SOVA）。
本次仿真主要采用Log-MAP译码算法，它是一类具有反馈结构的伪随机译码器，2个码可以交替互不影响的译码，并且还可以通过关于系统码信息位的软判决输出相互传递信息，进行递推式迭代译码。如果编码时进行了删余操作，那么分离两个校验序列时需要补零以保证三个序列的长度相同，三个序列在送入译码器之前还要进行信道置信度L_c的加权。

最大后验概率算法在译码时首先对接收信息进行处理，两个成员译码器之间外部信息的传递就形成了一个循环迭代的结构。由于外部信息的作用，一定信噪比下的误比特率将随着循环次数的增加而降低。但同时外部信息与接受序列间的相关性也随着译码次数的增加而逐渐增加，外部信息所提供的纠错能力也随之减弱，在一定的循环次数之后，译码性能将不再提高。本次仿真用到的Log-MAP算法实际上就是对标准MAP算法中的似然全部用对数似然度来表示，这样，乘法运算变成了加法运算，加快计算速度。

4、MATLAB仿真代码

关于代码的详细解读可以参考下面这位大佬的文章：

Turbo编译码原理

Turbo编译码Matlab仿真解读 – WuYufei_matlab

Turbo编译码Matlab仿真解读 （2）-- WuYufei_matlab

关于编译码原理也有很多的文章在讲解，大家可以自行查阅。

下面为主程序的代码，全部的代码已打包上传【可点击此处进行下载】，如果手中有原始代码应该也可以（各函数部分貌似没有作修改，记不清楚了），只需要把主程序替换一下就一样了。

% turbo_sys_demo.m
% BCJR算法引入简化运算：ln(e^x+e^y) = max(x,y) + ln(1+e^(-abs(x-y)))  max+查表
% 如果使用近似式：ln(e^x+e^y) = max(x,y),就变成了 MAX-Log-MAP算法

clc;clear
% diary turbo_logmap.txt % 将命令行窗口文本记录到日志文件中（开启）

% 选择译码算法
dec_alg = input(' 选择译码算法 (0:Log-MAP, 1:SOVA),默认 0 : ');
% Log-MAP算法用的不多，因为其计算量较大(对标准MAP算法中的似然全部用对数似然度来表示）
% 乘法运算变成加法运算，Log-MAP属于简化译码算法，性能略低于MAP译码算法
if isempty(dec_alg)
   dec_alg = 0; % 默认为0：Log-MAP
end

% 帧长度
L_total = input(' 输入帧长度 (= 信息长度 + 卷尾,默认 1024) : ');
if isempty(L_total)
   L_total = 1024;	 % 默认为1024
end

% Turbo码生成多项式
g = input(' 输入生成多项式( 默认: g = [1 1 1; 1 0 1 ] ) : ');
if isempty(g)
   g = [ 1 1 1;1 0 1 ];     % 即[7,5]
end
%g = [1 1 0 1; 1 1 1 1];
%g = [1 1 1 1 1; 1 0 0 0 1];

[n,K] = size(g); 
m = K - 1;      % 寄存器阶数m=矩阵g列数-1
nstates = 2^m;

puncture = input(' 选择是否打孔 (0/1),默认 0: ');
if isempty(puncture) 
    puncture = 0; % 未打孔默认码率为1/3,打孔后默认码率提高至1/2
end

% 码率
rate = 1/(2+puncture);   % 1/2

% AWGN 信道
a = 1; 

% 迭代次数
niter = input(' 选择帧迭代次数,默认 3: ');
if isempty(niter) 
   niter = 3;
end   
% N终止程序的帧错误次数
ferrlim = input(' 选择终止程序的帧错误次数,默认 15: ');
if isempty(ferrlim)
   ferrlim = 15; % 默认为15
end   

EbN0db = input(' 选择系统信噪比 Eb/N0（dB）,默认[0.5,1.0,1.5,2.0,2.5,3.0]: ');
if isempty(EbN0db)
   EbN0db = [0.5,1.0,1.5,2.0,2.5,3.0]; % 默认
end

fprintf('\n\n----------------------------------------------------\n'); 
if dec_alg == 0
   fprintf(' === Log-MAP 译码器 === \n');
else
   fprintf(' === SOVA 译码器 === \n');
end
fprintf(' 帧长度 = %6d\n',L_total);
fprintf(' Turbo码生成多项式: \n');
for i = 1:n
    for j = 1:K
        fprintf( '%6d', g(i,j));
    end
    fprintf('\n');
end        
if puncture==0
   fprintf(' 打孔, 码率 = 1/2 \n');
else
   fprintf(' 未打孔, 码率 = 1/3 \n');
end
fprintf(' 迭代次数 =  %6d\n', niter);
fprintf(' 终止程序的帧错误次数 = %6d\n', ferrlim);
fprintf(' Eb / N0 (dB) = ');
for i = 1:length(EbN0db)
    fprintf('%10.2f',EbN0db(i));
end
fprintf('\n----------------------------------------------------\n\n');
    
% fprintf('+ + + + Please be patient. Wait a while to get the result. + + + +\n');

for nEN = 1:length(EbN0db)
   en = 10^(EbN0db(nEN)/10); % 从dB转换为比值
   L_c = 4*a*en*rate; 	% reliability value of the channel
   sigma = 1/sqrt(2*rate*en); 	% standard deviation of AWGN noise

% 初始化：置零
   errs(nEN,1:niter) = zeros(1,niter);
   nferr(nEN,1:niter) = zeros(1,niter);

   nframe = 0;    % clear counter of transmitted frames
   while nferr(nEN, niter)<ferrlim
      nframe = nframe + 1;    
      x = round(rand(1, L_total-m));    % info. bits
      [temp, alpha] = sort(rand(1,L_total));        % random interleaver mapping
      % 使用sort产生Turbo编码所使用的交织器，仿真时倾向于采用LTE自带的交织器
      en_output = encoderm( x, g, alpha, puncture ) ; % 编码输出 (+1/-1)
          
      r = en_output+sigma*randn(1,L_total*(2+puncture)); % received bits
      yk = demultiplex(r,alpha,puncture); % demultiplex to get input for decoder 1 and 2
      
% 缩放接收比特      
      rec_s = 0.5*L_c*yk;

% Initialize extrinsic information      
      L_e(1:L_total) = zeros(1,L_total);
      
      for iter = 1:niter
% Decoder one
         L_a(alpha) = L_e;  % a priori info. 
         if dec_alg == 0
            L_all = logmapo(rec_s(1,:), g, L_a, 1);  % complete info.
         else   
            L_all = sova0(rec_s(1,:), g, L_a, 1);  % complete info.
         end   
         L_e = L_all - 2*rec_s(1,1:2:2*L_total) - L_a;  % extrinsic info.

% Decoder two         
         L_a = L_e(alpha);  % a priori info.
         if dec_alg == 0
            L_all = logmapo(rec_s(2,:), g, L_a, 2);  % complete info.  
         else
            L_all = sova0(rec_s(2,:), g, L_a, 2);  % complete info. 
         end
         L_e = L_all - 2*rec_s(2,1:2:2*L_total) - L_a;  % extrinsic info.
         
% Estimate the info. bits        
         xhat(alpha) = (sign(L_all)+1)/2;
% 纪录当前迭代对应的比特错误数
         err(iter) = length(find(xhat(1:L_total-m)~=x));
% 记录当前迭代次数对应的帧错误数
         if err(iter)>0
            nferr(nEN,iter) = nferr(nEN,iter)+1;
         end   
      end	%iter
      
% 迭代次数对应的总比特错误数
      errs(nEN,1:niter) = errs(nEN,1:niter) + err(1:niter);

      if rem(nframe,3)==0 | nferr(nEN, niter)==ferrlim
% Bit error rate
         ber(nEN,1:niter) = errs(nEN,1:niter)/nframe/(L_total-m);
% Frame error rate
         fer(nEN,1:niter) = nferr(nEN,1:niter)/nframe;

% 显示结果  
         fprintf('************** Eb/N0 =  %5.2f db **************\n', EbN0db(nEN));
         fprintf('帧长度 = %d, rate 1/%d. \n', L_total, 2+puncture);
         fprintf('%d 帧被传输, %d 帧存在错误.\n', nframe, nferr(nEN, niter));%nframe帧计数，nferr帧错误计数
         fprintf('比特错误率 (从1次迭代到%d次迭代):\n', niter);
         for i=1:niter
            fprintf('%8.4e    ', ber(nEN,i));
         end
         fprintf('\n');
         fprintf('帧错误率 (从1次迭代到%d次迭代):\n', niter);
         for i=1:niter
            fprintf('%8.4e    ', fer(nEN,i));
         end
         fprintf('\n');
         fprintf('***********************************************\n\n');

         save turbo_sys_demo EbN0db ber fer
         % ber:Bit error rate       fer:Frame error rate
      end   %iter
      
   end		
end 		
% 需要绘制不同迭代次数的结果，进行对比
for i=1:niter
    semilogy(EbN0db,ber(:,i));hold on
    title('不同迭代次数，Log-MAP算法，帧长1024');
    xlabel('E_s/N_0[dB]');ylabel('BLER');
end
% diary off % 关闭
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182

5、仿真结果

5.1 选用Log-MAP译码，SNR=[0.5,1.0,1.5,2.0,2.5,3.0,3.5]，删余rate=1/2
（由于迭代次数越多，仿真运行时间越长，所以这里只设置了3次迭代，大家如果设备性能够强的话可以把迭代次数以及SNR的范围设置的大一些，理论上是可以看到误码平台的出现）

分析：

5.2 选用Log-MAP译码，SNR=[0.5,1.0,1.5,2.0,2.5,3.0,3.5]，不删余rate=1/3

分析：

5.3 大家可以尝试在在SNR = 1dB，迭代次数为5，两种情况均删余，rate = 1/2的条件下，对比SOVA译码算法与Log-MAP译码算法的性能

-觉得还不错的话，麻烦点个赞呢 ：）