超级会员免费看
信道容量与编码技术详解
1. 信道编码基础
在有噪声的信道中进行通信时，错误是不可避免的。为了减少错误的影响并实现可靠通信，需要传输尽可能不同的序列，这样信道噪声就不会将一个序列变成另一个序列。这意味着要引入一些冗余来提高通信的可靠性，但这也会导致传输额外的比特，从而降低传输速率。
信道编码方案通常可分为两类：分组码和卷积码。
-
分组码
：长度为 $k$ 的二进制源输出序列被映射为长度为 $n$ 的二进制信道输入序列，所得码的速率为 $k/n$ 比特/传输，称为 $(n, k)$ 分组码，由 $2^k$ 个长度为 $n$ 的码字组成。信息源输出到信道输入的映射是独立进行的，编码器的输出仅取决于当前长度为 $k$ 的输入序列，而与先前的输入序列无关。
-
卷积码
：长度为 $k_0$ 的源输出被映射为 $n_0$ 个信道输入，但信道输入不仅取决于最近的 $k_0$ 个源输出，还取决于编码器的最后 $(L - 1)k_0$ 个输入。
2. 简单重复码
简单重复码是最简单的分组码之一。在二进制对称信道中传输两个消息时，不直接传输 0 和 1，而是传输两个序列，一个全为 0，另一个全为 1，序列长度选择为奇数 $n$。
-
编码过程
：
- $0 \to 00 \cdots 00$（$n$ 个 0）
- $1 \to 11 \cdots 11$（$n$ 个 1）
-
解码过程
：采用简单的多数表决解码。如果接收到的符号中多数为 1，则解码器判定为 1；如果多数为 0，则判定为 0。
-
错误概率
：当至少 $(n + 1) / 2$ 个传输符号接收错误时，就会发生错误。由于信道是具有交叉概率 $\epsilon$ 的二进制对称信道，错误概率可表示为：
$P_e = \sum_{k = (n + 1) / 2}^{n} \binom{n}{k} \epsilon^k (1 - \epsilon)^{n - k}$
例如，当 $n = 5$ 且 $\epsilon = 0.001$ 时，$P_e = \sum_{k = 3}^{5} 0.001^k (0.999)^{5 - k} = 9.99 \times 10^{-10} \approx 10^{-9}$。这表明通过使用信道 5 次而不是 1 次，可以将错误概率从 0.001 降低到 $10^{-9}$，但代价是传输速率降低，系统复杂度增加。
3. 线性分组码
线性分组码是最重要且广泛使用的分组码类别。如果任意两个码字的线性组合仍是码字，则该分组码为线性码。在二进制情况下，这意味着任意两个码字的和仍是码字。线性分组码的码字构成 $n$ 维空间的 $k$ 维子空间。
线性分组码由生成矩阵 $G$ 描述，$G$ 是一个 $k \times n$ 的二进制矩阵，每个码字 $c$ 可以写成 $c = uG$ 的形式，其中 $u$ 是长度为 $k$ 的二进制数据序列（编码器输入）。显然，长度为 $n$ 的全 0 序列始终是 $(n, k)$ 线性分组码的码字。
线性分组码的一个重要参数是最小（汉明）距离 $d_{min}$，它定义为任意两个不同码字之间的最小汉明距离，对于线性码，最小距离等于码的最小重量，即任何非零码字中 1 的最小数量。
3.1 示例：$(10, 4)$ 线性分组码
给定 $(10, 4)$ 线性分组码的生成矩阵 $G$ 为：
$G = \begin{bmatrix}
1 & 0 & 0 & 1 & 1 & 1 & 0 & 1 & 1 & 1 \
1 & 1 & 1 & 0 & 0 & 0 & 1 & 1 & 1 & 0 \
0 & 1 & 1 & 0 & 1 & 1 & 0 & 1 & 0 & 1 \
1 & 1 & 0 & 1 & 1 & 1 & 1 & 0 & 0 & 1
\end{bmatrix}$
为了获得所有码字，需要使用所有长度为 4 的信息序列并找到相应的编码序列。由于长度为 4 的二进制序列共有 16 个，因此会有 16 个码字。通过 $C = UG$ 计算得到码字矩阵 $C$，经检查可知该码的最小距离 $d_{min} = 2$。
以下是求解该问题的 MATLAB 脚本：
% Generate U, denoting all information sequences.
k = 4;
for i = 1:2^k
for j = k:-1:1
if rem(i - 1, 2^(-j + k + 1)) >= 2^(-j + k)
u(i, j) = 1;
else
u(i, j) = 0;
end
end
end
% Define G, the generator matrix.
g = [1 0 0 1 1 1 0 1 1 1;
1 1 1 0 0 0 1 1 1 0;
0 1 1 0 1 1 0 1 0 1;
1 1 0 1 1 1 1 0 0 1];
% Generate codewords.
c = rem(u * g, 2);
% Find the minimum distance.
w_min = min(sum((c(2:2^k, :))'));
3.2 系统形式的线性分组码
如果线性分组码的生成矩阵 $G$ 具有以下形式，则该码为系统形式：
$G = \begin{bmatrix}
1 & 0 & 0 & P_{1,1} & P_{1,2} & \cdots & P_{1,n - k} \
0 & 1 & 0 & P_{2,1} & P_{2,2} & \cdots & P_{2,n - k} \
\vdots & \vdots & \vdots & \vdots & \vdots & \ddots & \vdots \
0 & 0 & 1 & P_{k,1} & P_{k,2} & \cdots & P_{k,n - k}
\end{bmatrix} = [I_k | P]$
其中 $I_k$ 是 $k \times k$ 的单位矩阵，$P$ 是 $k \times (n - k)$ 的矩阵。在系统码中，码字的前 $k$ 个二进制符号是信息比特，其余 $n - k$ 个二进制符号是奇偶校验符号。
4. 汉明码
汉明码是 $(2^m - 1, 2^m - m - 1)$ 线性分组码，最小距离为 3，具有非常简单的奇偶校验矩阵。奇偶校验矩阵是一个 $m \times (2^m - 1)$ 的矩阵，其列是除全 0 序列外的所有长度为 $m$ 的二进制序列。
例如，当 $m = 3$ 时，$(7, 4)$ 码的系统形式奇偶校验矩阵 $H$ 为：
$H = \begin{bmatrix}
0 & 1 & 1 & 1 & 0 & 0 & 0 \
1 & 0 & 1 & 0 & 1 & 0 & 0 \
1 & 1 & 1 & 0 & 0 & 1 & 0
\end{bmatrix}$
由此可得生成矩阵 $G$ 为：
$G = \begin{bmatrix}
1 & 0 & 0 & 0 & 1 & 1 & 0 \
0 & 1 & 0 & 0 & 0 & 1 & 1 \
0 & 0 & 1 & 0 & 1 & 1 & 1 \
0 & 0 & 0 & 1 & 1 & 1 & 0
\end{bmatrix}$
4.1 示例：$(15, 11)$ 汉明码
对于 $(15, 11)$ 汉明码，奇偶校验矩阵 $H$ 为：
$H = \begin{bmatrix}
1 & 0 & 0 & 1 & 1 & 0 & 1 & 0 & 1 & 1 & 1 & 1 & 0 & 0 & 0 \
1 & 1 & 0 & 0 & 0 & 1 & 1 & 0 & 0 & 0 & 1 & 1 & 1 & 0 & 1 \
1 & 1 & 1 & 0 & 1 & 1 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \
0 & 0 & 1 & 1 & 1 & 0 & 1 & 1 & 1 & 0 & 1 & 0 & 0 & 1 & 0 \
0 & 0 & 0 & 1 & 0 & 1 & 1 & 0 & 1 & 1 & 1 & 1 & 0 & 0 & 0 \
0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 1 & 0 & 1 & 1 & 0 & 1 & 1 \
0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 1 & 0 & 1 & 1 & 1 & 1
\end{bmatrix}$
生成矩阵 $G$ 为：
$G = \begin{bmatrix}
1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 & 0 & 0 \
0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 & 0 \
0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 \
0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \
0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 1 \
0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 1 \
0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 1 & 1 & 1 & 0 \
0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 1 & 1 & 1 \
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 1 & 0 & 1 & 1 \
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 1 & 1 & 0 & 1 \
0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 1 & 1 & 1 & 1
\end{bmatrix}$
通过 MATLAB 脚本可以验证其最小距离等于 3：
k = 11;
for i = 1:2^k
for j = k:-1:1
if rem(i - 1, 2^(-j + k + 1)) >= 2^(-j + k)
u(i, j) = 1;
else
u(i, j) = 0;
end
end
end
g = [1 0 0 0 0 0 0 0 0 0 0 1 1 0 0;
0 1 0 0 0 0 0 0 0 0 0 0 1 1 0;
0 0 1 0 0 0 0 0 0 0 0 0 0 1 1;
0 0 0 1 0 0 0 0 0 0 0 1 0 1 0;
0 0 0 0 1 0 0 0 0 0 0 1 0 0 1;
0 0 0 0 0 1 0 0 0 0 0 0 1 0 1;
0 0 0 0 0 0 1 0 0 0 0 1 1 1 0;
0 0 0 0 0 0 0 1 0 0 0 0 1 1 1;
0 0 0 0 0 0 0 0 1 0 0 1 0 1 1;
0 0 0 0 0 0 0 0 0 1 0 1 1 0 1;
0 0 0 0 0 0 0 0 0 0 1 1 1 1 1];
c = rem(u * g, 2);
w_min = min(sum((c(2:2^k, :))'));
5. 线性分组码的性能
线性分组码可以使用软判决解码或硬判决解码。
-
硬判决解码
：首先对码字的分量进行逐位判决，然后根据最小汉明距离准则进行解码。该解码方案的性能取决于码的距离结构，但在高信噪比下，可以根据码的最小距离获得一个紧密的上界。消息错误概率 $P_e$ 上界为：
$P_e \leq (M - 1) [4p(1 - p)]^{d_{min} / 2}$
其中 $p$ 表示二进制信道的错误概率（解调中的错误概率），$M = 2^k$ 是码字的数量。
-
软判决解码
：将接收到的信号映射到与其对应信号的欧几里得距离最小的码字。消息错误概率 $P_e$ 上界为：
$P_e \leq (M - 1) Q \left(\sqrt{\frac{d_E E}{N_0}}\right)$
其中 $M = 2^k$ 是码字的数量，$N_0$ 是单边噪声功率谱密度，$d_E$ 是码的最小欧几里得距离，$E$ 表示每个码字分量的能量。
以下是计算硬判决解码且采用反相信号时线性分组码消息错误概率上界的 MATLAB 函数：
function [p_err, gamma_db] = p_e_hd_a(gamma_db_l, gamma_db_h, k, n, d_min)
gamma_db = (gamma_db_l:(gamma_db_h - gamma_db_l) / 20:gamma_db_h);
gamma_b = 10.^(gamma_db / 10);
R_c = k / n;
p_b = q(sqrt(2 * R_c * gamma_b));
p_err = (2^k - 1) .* (4 * p_b .* (1 - p_b)).^(d_min / 2);
end
通过以下 MATLAB 脚本可以绘制 $(15, 11)$ 汉明码在硬判决解码和反相信号下消息错误概率与 $\gamma_b = E_b / N_0$ 的关系图：
[p_err_ha, gamma_b] = p_e_hd_a(10, 16, 11, 15, 3);
semilogy(gamma_b, p_err_ha);
6. 卷积码
在分组码中，每个长度为 $k$ 的信息比特序列以固定方式映射到长度为 $n$ 的信道输入序列，而与先前的信息比特无关。在卷积码中，每个长度为 $k_0$ 的信息比特序列映射到长度为 $n_0$ 的信道输入序列，但编码器的输出序列不仅取决于最近的 $k_0$ 个信息比特，还取决于编码器的最后 $(L - 1)k_0$ 个输入。因此，编码器具有有限状态机的结构，二进制卷积码是一个具有 $2^{k_0(L - 1)}$ 个状态的有限状态机。
例如，对于 $k_0 = 2$，$n_0 = 3$，$L = 4$ 的卷积码，信息比特每次 2 位加载到移位寄存器中，最后两位信息比特移出。三个编码比特按图中所示计算并通过信道传输，该码的速率 $R = \frac{k_0}{n_0} = \frac{2}{3}$。
卷积码通常由生成序列 $g_1, g_2, \cdots, g_{n_0}$ 定义。$g_j$ 的第 $i$ 个分量（$1 \leq i \leq k_0L$ 且 $1 \leq j \leq n_0$）在移位寄存器的第 $i$ 个元素连接到对应于输出第 $j$ 位的组合器时为 1，否则为 0。
例如，对于上述卷积码，生成序列为：
$g_1 = [0 0 1 0 1 0 0 1]$
$g_2 = [0 0 0 0 0 0 0 1]$
$g_3 = [1 0 0 0 0 0 0 1]$
生成矩阵 $G$ 为：
$G = \begin{bmatrix}
0 & 0 & 1 & 0 & 1 & 0 & 0 & 1 \
0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \
1 & 0 & 0 & 0 & 0 & 0 & 0 & 1
\end{bmatrix}$
以下是生成卷积编码器输出序列的 MATLAB 函数：
function output = cnv_encd(g, k0, input)
if rem(length(input), k0) > 0
input = [input, zeros(size(1:k0 - rem(length(input), k0)))];
end
n = length(input) / k0;
if rem(size(g, 2), k0) > 0
error('Error, g is not of the right size.');
end
l = size(g, 2) / k0;
n0 = size(g, 1);
u = [zeros(size(1:(l - 1) * k0)), input, zeros(size(1:(l - 1) * k0))];
ul = u(l * k0:-1:1);
for i = 1:n + l - 2
ul = [ul, u((i + l) * k0:-1:i * k0 + 1)];
end
uu = reshape(ul, l * k0, n + l - 1);
output = reshape(rem(g * uu, 2), 1, n0 * (l + n - 1));
end
6.1 示例：卷积编码器输出计算
当信息序列为 $10011100110000111$ 时，由于长度为 17，不是 $k_0 = 2$ 的倍数，需要添加一个 0 使其长度变为 18。生成矩阵 $G$ 如上所示，$n_0 = 3$，$L = 4$，输出序列长度为 $(9 + 4 - 1) \times 3 = 36$。经过零填充后，序列变为 $000000100111001100001110000000$，使用
cnv_encd.m
函数得到输出序列为 $000001101111101011100110100100111111$。
以下是求解该问题的 MATLAB 脚本：
k0 = 2;
g = [0 0 1 0 1 0 0 1; 0 0 0 0 0 0 0 1; 1 0 0 0 0 0 0 1];
input = [1 0 0 1 1 1 0 0 1 1 0 0 0 0 1 1 1];
output = cnv_encd(g, k0, input);
7. 卷积码的表示
卷积码可以通过编码器的结构或生成矩阵 $G$ 来表示，也可以表示为有限状态机，用状态转移图描述。更广泛使用的表示方法是网格图，它是随时间绘制的状态转移图。
例如，对于 $k_0 = 1$，$n_0 = 2$，$L = 3$ 的卷积码，其网格图由每个时钟周期对应四个状态的黑点和表示状态之间转换的分支组成。每个连接两个状态的分支上的两个二进制符号表示对应转换的编码器输出。码字对应于从全 0 状态开始并返回全 0 状态的网格路径。
8. 卷积码的转移函数
卷积码的转移函数 $T(D, N, J)$ 给出了从全 0 状态开始并首次返回该状态的网格路径的信息。每个 $T(D, N, J)$ 的项对应于从全 0 状态开始并结束于全 0 状态的网格路径。$J$ 的指数表示该路径跨越的分支数，$D$ 的指数表示对应码字中 1 的数量（或与全 0 码字的汉明距离），$N$ 的指数表示输入信息序列中 1 的数量。
例如，对于上述 $k_0 = 1$，$n_0 = 2$，$L = 3$ 的卷积码，转移函数为：
$T(D, N, J) = \frac{D^5 N J^3}{1 - D N J - D N J^2}$
展开后可以看出，存在一个汉明重量为 5 的码字，两个汉明重量为 6 的码字等。转移函数展开式中 $D$ 的最小幂次称为卷积码的自由距离 $d_{free}$，在此例中 $d_{free} = 5$。
9. 卷积码的解码
卷积码有多种解码算法，维特比算法是最广泛使用的解码方法之一。它是一种最大似然解码算法，接收信道输出后，在网格中搜索最有可能生成接收到的序列的路径。
-
硬判决解码 ：选择与量化接收序列 $y$ 的汉明距离最小的网格路径。假设路径跨越 $m$ 个分支，每个分支对应编码器输出的 $n_0$ 位，码字 $c$ 和接收序列 $y$ 的总位数为 $mn_0$。汉明距离为：
$d(c, y) = \sum_{i = 1}^{m} d(c_i, y_i)$ -
软判决解码 ：与硬判决解码类似，但有三个区别：
- 直接处理最优（匹配滤波器类型或相关器类型）数字解调器的向量输出 $r$。
- 处理对应序列 $c’$，$c’ {ij} = \begin{cases} \sqrt{E}, & \text{if } c {ij} = 1 \ -\sqrt{E}, & \text{if } c_{ij} = 0 \end{cases}$
-
使用欧几里得距离代替汉明距离。欧几里得距离为：
$d_E(c’, r) = \sum_{i = 1}^{m} d_E(c’_i, r_i)$
维特比算法的步骤如下：
1. 将接收到的序列解析为 $m$ 个长度为 $n_0$ 的子序列。
2. 为所研究的码绘制深度为 $m$ 的网格图。对于网格的最后 $L - 1$ 阶段，仅绘制对应全 0 输入序列的路径。
3. 设置 $l = 1$，并将初始全 0 状态的度量设置为 0。
4. 计算接收到的序列的第 $l$ 个子序列与连接网格第 $l$ 阶段状态到第 $(l + 1)$ 阶段状态的所有分支的距离。
5. 将这些距离添加到第 $l$ 阶段状态的度量中，得到第 $(l + 1)$ 阶段状态的度量候选值。对于第 $(l + 1)$ 阶段的每个状态，有 $2^{k_0}$ 个候选度量，每个对应于结束于该状态的一个分支。
6. 对于第 $(l + 1)$ 阶段的每个状态，选择最小的候选度量，并将对应于该最小值的分支标记为幸存者，其他分支删除。
7. 如果 $l = m$，转到下一步；否则，将 $l$ 增加 1 并转到步骤 4。
8. 从第 $(m + 1)$ 阶段的全 0 状态开始，沿着幸存者路径返回到初始全 0 状态。该路径是最优路径，对应的输入比特序列是最大似然解码的信息序列。为了获得输入比特序列的最佳估计，从该序列中删除最后 $k_0(L - 1)$ 个 0。
9.1 示例：维特比解码
假设硬判决解码中量化接收序列为 $y = 01101111010001$，卷积码为上述 $k_0 = 1$，$n_0 = 2$，$L = 3$ 的码。接收序列长度为 14，$m = 7$，需要绘制深度为 7 的网格图。由于输入信息序列填充了 $k_0(L - 1) = 2$ 个 0，最终两个阶段的网格仅绘制对应全 0 输入的分支。实际输入序列长度为 5，填充后为 7。
通过维特比算法，得到最优路径对应的输入比特序列为 $1100000$，最后两个 0 不是信息比特，因此信息序列为 $11000$。所选路径对应的码字为 $11101011000000$，与接收序列的汉明距离为 4。
以下是使用维特比算法解码信道输出的 MATLAB 函数：
function [decoder_output, survivor_state, cumulated_metric] = viterbi(G, k, channel_output)
n = size(G, 1);
if rem(size(G, 2), k) ~= 0
error('Size of G and k do not agree');
end
if rem(size(channel_output, 2), n) ~= 0
error('channel output not of the right size');
end
L = size(G, 2) / k;
number_of_states = 2^((L - 1) * k);
for j = 0:number_of_states - 1
for l = 0:2^k - 1
[next_state, memory_contents] = nxL_stat(j, l, L, k);
input(j + 1, next_state + 1) = l;
branch_output = rem(memory_contents * G', 2);
nextstate(j + 1, l + 1) = next_state;
output(j + 1, l + 1) = bin2deci(branch_output);
end
end
state_metric = zeros(number_of_states, 2);
depth_of_trellis = length(channel_output) / n;
channel_output_matrix = reshape(channel_output, n, depth_of_trellis);
survivor_state = zeros(number_of_states, depth_of_trellis + 1);
for i = 1:depth_of_trellis - L + 1
flag = zeros(1, number_of_states);
if i <= L
step = 2^((L - i) * k);
else
step = 1;
end
for j = 0:step:number_of_states - 1
for l = 0:2^k - 1
branch_metric = 0;
binary_output = deci2bin(output(j + 1, l + 1), n);
for ll = 1:n
branch_metric = branch_metric + metric(channel_output_matrix(ll, i), binary_output(ll));
end
if ((state_metric(nextstate(j + 1, l + 1) + 1, 2) > state_metric(j + 1, 1) + branch_metric) || flag(nextstate(j + 1, l + 1) + 1) == 0)
state_metric(nextstate(j + 1, l + 1) + 1, 2) = state_metric(j + 1, 1) + branch_metric;
survivor_state(nextstate(j + 1, l + 1) + 1, i + 1) = j;
flag(nextstate(j + 1, l + 1) + 1) = 1;
end
end
end
state_metric = state_metric(:, 2:-1:1);
end
for i = depth_of_trellis - L + 2:depth_of_trellis
flag = zeros(1, number_of_states);
last_stop = number_of_states / (2^((i - depth_of_trellis + L - 2) * k));
for j = 0:last_stop - 1
branch_metric = 0;
binary_output = deci2bin(output(j + 1, 1), n);
for ll = 1:n
branch_metric = branch_metric + metric(channel_output_matrix(ll, i), binary_output(ll));
end
if ((state_metric(nextstate(j + 1, 1) + 1, 2) > state_metric(j + 1, 1) + branch_metric) || flag(nextstate(j + 1, 1) + 1) == 0)
state_metric(nextstate(j + 1, 1) + 1, 2) = state_metric(j + 1, 1) + branch_metric;
survivor_state(nextstate(j + 1, 1) + 1, i + 1) = j;
flag(nextstate(j + 1, 1) + 1) = 1;
end
end
state_metric = state_metric(:, 2:-1:1);
end
state_sequence = zeros(1, depth_of_trellis + 1);
state_sequence(1, depth_of_trellis) = survivor_state(1, depth_of_trellis + 1);
for i = 1:depth_of_trellis
state_sequence(1, depth_of_trellis - i + 1) = survivor_state((state_sequence(1, depth_of_trellis + 2 - i) + 1), depth_of_trellis - i + 2);
end
decoder_output_matrix = zeros(k, depth_of_trellis - L + 1);
for i = 1:depth_of_trellis - L + 1
dec_output_deci = input(state_sequence(1, i) + 1, state_sequence(1, i + 1) + 1);
dec_output_bin = deci2bin(dec_output_deci, k);
decoder_output_matrix(:, i) = dec_output_bin(k:-1:1)';
end
decoder_output = reshape(decoder_output_matrix, 1, k * (depth_of_trellis - L + 1));
cumulated_metric = state_metric(1, 1);
end
function distance = metric(x, y)
if x == y
distance = 0;
else
distance = 1;
end
end
function [next_state, memory_contents] = nxL_stat(current_state, input, L, k)
binary_state = deci2bin(current_state, k * (L - 1));
binary_input = deci2bin(input, k);
next_state_binary = [binary_input, binary_state(1:(L - 2) * k)];
next_state = bin2deci(next_state_binary);
memory_contents = [binary_input, binary_state];
end
function y = bin2deci(x)
l = length(x);
y = (l - 1:-1:0);
y = 2.^y;
y = x * y';
end
function y = deci2bin(x, l)
y = zeros(1, l);
i = 1;
while x >= 0 && i <= l
y(i) = rem(x, 2);
x = (x - y(i)) / 2;
i = i + 1;
end
y = y(l:-1:1);
end
通过以下脚本可以使用上述函数进行解码：
G = [0 1 0 1 0 0 0 1; 0 0 0 0 0 0 0 1; 1 0 0 0 0 0 0 1];
k = 1;
channel_output = [0 1 1 0 1 1 1 1 0 1 0 0 0 1];
[decoder_output, ~, cumulated_metric] = viterbi(G, k, channel_output);
10. 卷积码的错误概率界
卷积码的错误性能界的求解方法与分组码不同，因为这里处理的是非常长的序列，且卷积码的自由距离通常较小，最终会出现一些错误。错误的数量是一个随机变量，取决于信道特性（软判决解码中的信噪比和硬判决解码中的交叉概率）和输入序列的长度。输入序列越长，出错的概率越高。因此，将比特错误数归一化到输入序列的长度是有意义的。通常用于比较卷积码性能的指标是每个输入比特的期望错误比特数。
为了找到每个输入比特的平均错误比特数的界，首先推导每个长度为 $k$ 的输入序列的平均错误比特数的界。假设发送全 0 序列，在解码的第 $l$ 阶段之前没有错误。现在 $k$ 个信息比特进入编码器并导致在网格中移动到下一阶段。我们感兴趣的是找到由于这个长度为 $k$ 的输入块可能发生的期望错误数的界。
如果在第 $(l + 1)$ 阶段，另一条网格路径的度量小于全 0 路径，则会发生错误。这种事件称为首次错误事件，相应的概率称为首次错误事件概率。
首次错误事件概率 $P_e$ 的界为：
$P_e \leq \sum_{d = d_{free}}^{\infty} a_d P_2(d)$
其中 $P_2(d)$ 表示与全 0 路径汉明距离为 $d$ 的路径的错误概率，$a_d$ 表示与全 0 路径汉明距离为 $d$ 的路径的数量。$P_2(d)$ 的值取决于使用的是软判决解码还是硬判决解码。
-
软判决解码
：如果使用反相信号（二进制 PSK），有：
$P_2(d) = Q \left(\sqrt{\frac{d E}{N_0}}\right)$
使用 $Q$ 函数的上界可得：
$P_2(d) \leq \frac{1}{2} e^{-\frac{d E}{2 N_0}}$
最终得到首次错误事件概率的界为：
$P_e \leq T_1(D) \big|_{D = e^{-\frac{R_c E_b}{N_0}}}$
其中 $T_1(D) = T(D, N, J) \big|_{N = J = 1}$。
每个输入比特的平均错误比特数 $P_b$ 的界为：
$P_b \leq \frac{1}{2k} \frac{\partial T_2(D, N)}{\partial N} \big|_{N = 1, D = e^{-\frac{R_c E_b}{N_0}}}$
其中 $T_2(D, N) = T(D, N, J) \big|_{J = 1}$。
-
硬判决解码
：$P_2(d)$ 可以被上界为：
$P_2(d) \leq \left[4p(1 - p)\right]^{d / 2}$
因此，硬判决解码中错误概率的上界为：
$P_b \leq \frac{1}{k} \frac{\partial T_2(D, N)}{\partial N} \big|_{N = 1, D = \sqrt{4p(1 - p)}}$
综上所述，信道容量与编码技术在通信系统中起着至关重要的作用。分组码和卷积码各有特点，通过合理选择编码方案和解码算法，可以在保证通信可靠性的同时，尽可能提高传输效率。同时，对于不同的应用场景，需要综合考虑信道条件、系统复杂度等因素，以实现最优的通信性能。
信道容量与编码技术详解
11. 不同编码方式对比总结
为了更清晰地了解分组码和卷积码的特点，下面通过表格进行对比：
| 编码类型 | 编码原理 | 解码方式 | 错误概率控制 | 复杂度 | 适用场景 |
| — | — | — | — | — | — |
| 分组码 | 长度为 (k) 的二进制源输出序列映射为长度为 (n) 的二进制信道输入序列，映射独立进行 | 硬判决解码或软判决解码 | 通过增加冗余度和选择合适的最小距离来控制 | 相对较低，尤其是简单分组码 | 对传输速率要求不高，对解码复杂度有一定限制的场景 |
| 卷积码 | 长度为 (k_0) 的源输出映射为 (n_0) 个信道输入，输出依赖当前和前 ((L - 1)k_0) 个输入 | 如维特比算法等 | 通过自由距离和转移函数来控制 | 相对较高，尤其是约束长度较大时 | 对传输可靠性要求高，能承受一定解码复杂度的场景 |
通过这个表格，我们可以根据具体的通信需求来选择合适的编码方式。
12. 编码技术的应用案例
在实际通信系统中，编码技术有着广泛的应用。例如在卫星通信中，由于信号传输距离远，信道噪声大，需要采用高可靠性的编码方式。卷积码因其能够有效降低错误概率，常被用于卫星通信中。下面是一个简单的卫星通信编码流程的 mermaid 流程图：
graph LR
A[信息源] --> B[卷积编码器]
B --> C[调制器]
C --> D[卫星信道]
D --> E[解调器]
E --> F[维特比解码器]
F --> G[信息输出]
在这个流程中，信息源产生的信号首先经过卷积编码器进行编码，增加冗余信息以提高可靠性。然后经过调制器将信号调制到合适的载波上，通过卫星信道进行传输。接收到信号后，先经过解调器进行解调，再通过维特比解码器进行解码，最终得到原始信息。
13. 编码技术的优化方向
随着通信技术的不断发展，对编码技术的要求也越来越高。以下是一些可能的优化方向：
-
降低复杂度
：对于卷积码，随着约束长度的增加，解码复杂度会呈指数级增长。可以研究新的解码算法，在保证解码性能的前提下，降低复杂度。例如，采用近似解码算法，通过牺牲一定的性能来换取复杂度的大幅降低。
-
提高传输效率
：在增加冗余度以降低错误概率的同时，要尽量减少对传输速率的影响。可以设计更高效的编码结构，使得在相同的冗余度下，能够传输更多的信息。
-
适应新的信道环境
：随着 5G、物联网等技术的发展，信道环境变得更加复杂。编码技术需要能够适应不同的信道特性，如多径衰落、干扰等。可以研究自适应编码技术，根据信道状态实时调整编码参数。
14. 编码技术的未来发展趋势
未来，编码技术将朝着更高效、更智能的方向发展。
-
与人工智能结合
：利用人工智能算法，如深度学习、强化学习等，来优化编码和解码过程。例如，通过深度学习模型自动学习信道特性，从而动态调整编码参数，提高通信性能。
-
量子编码
：随着量子技术的发展，量子编码有望成为未来的研究热点。量子编码利用量子比特的特性，能够提供更高的安全性和可靠性，为未来的通信系统带来新的突破。
15. 总结
信道容量与编码技术是通信领域的核心内容。通过本文的介绍，我们了解了分组码和卷积码的基本原理、解码方式、性能分析以及错误概率界的求解方法。同时，通过实际应用案例和优化方向的探讨，我们认识到编码技术在实际通信系统中的重要性和发展潜力。在未来的通信发展中，编码技术将不断创新和完善，为我们带来更高效、更可靠的通信体验。
在实际应用中，我们需要根据具体的通信需求和信道条件，选择合适的编码方式和解码算法。同时，要关注编码技术的发展趋势，积极探索新的编码方法和优化策略，以适应不断变化的通信环境。希望本文能够为读者在信道编码技术的学习和应用中提供有益的参考。
扫一扫
63
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
