跳转至

03-LTE PDCCH 编码解码 - TBCC 编码与 Viterbi 解码

本文档详细解释 LTE PDCCH 的 TBCC 编码和解码流程

一、编码流程概述

1.1 完整编码链

1
2
3
4
5
DCI 编码流程 (eNB 发送):

DCI 比特 → CRC 附加 → RNTI 加扰 → TBCC 编码 → 速率匹配
   → 加扰 → QPSK 调制 → 层映射 → 预编码 → 块交织
   → 循环移位 → 资源映射 → OFDM 调制

1.2 编码参数

步骤 参数 说明
CRC 16 bits 错误检测
RNTI 16 bits 用户/功能标识
TBCC 码率 ⅓ 咬尾卷积码
调制 QPSK 2 bits/symbol
交织 块交织 (32 列) 频率分集

二、CRC 附加与加扰

2.1 CRC 计算

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
CRC-16 多项式:
g_CRC(x) = x^16 + x^12 + x^5 + 1

计算过程:
输入：DCI 比特序列 a_0, a_1, ..., a_{A-1}
输出：CRC 比特 p_0, p_1, ..., p_{15}

附加后:
b_0, ..., b_{A-1} = a_0, ..., a_{A-1} (DCI 比特)
b_A, ..., b_{A+15} = p_0, ..., p_{15} (CRC 比特)

2.2 RNTI 加扰

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
RNTI 加扰公式:
─────────────────────────────────────────────────────────
c_k = (b_k + r_k) mod 2

其中:
b_k = CRC 附加后的比特
r_k = RNTI 比特 (重复扩展到 CRC 长度)

RNTI 类型:
C-RNTI: 用户调度
SI-RNTI: 系统信息
P-RNTI: 寻呼
RA-RNTI: 随机接入
TPC-RNTI: 功率控制
─────────────────────────────────────────────────────────

示例:
CRC 比特：[1,0,1,1,0,0,1,0,1,1,0,1,0,0,1,1]
C-RNTI:   [1,0,0,1,1,0,1,0,0,1,1,0,1,0,0,1]
加扰后：  [0,0,1,0,1,0,0,0,1,0,1,1,1,0,1,0] (XOR)

三、TBCC 编码详解

3.1 咬尾卷积码原理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
咬尾卷积码 (Tail-biting Convolutional Code):

特点:
├─ 初始状态 = 最后 6 个信息比特
├─ 不需要尾部比特 (tail bits)
├─ 节省开销，提高效率
└─ 编码效率 = 信息比特 / 输出比特

编码器结构:
├─ 约束长度 K = 7
├─ 移位寄存器 6 级
├─ 3 个生成多项式
└─ 码率 R = 1/3

3.2 生成多项式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
生成多项式 (八进制 → 二进制):
─────────────────────────────────────────────────────────
g0 = 133 (八进制) = 1 011 011 (二进制)
g1 = 171 (八进制) = 1 111 001
g2 = 165 (八进制) = 1 110 101

连接图:
输入 → [D] → [D] → [D] → [D] → [D] → [D] → 输出
        ↓     ↓     ↓     ↓     ↓     ↓
       g0    g0    g0    g0    g0    g0
       g1    g1    g1    g1    g1    g1
       g2    g2    g2    g2    g2    g2

输出复用:
[d0(0), d1(0), d2(0), d0(1), d1(1), d2(1), ...]
─────────────────────────────────────────────────────────

3.3 编码示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
输入：60 bits (DCI + CRC)

编码过程:
1. 初始化移位寄存器
   初始状态 = 最后 6 个输入比特

2. 逐比特输入，计算 3 路输出
   输入比特 0 → 输出 [d0, d1, d2]
   输入比特 1 → 输出 [d0, d1, d2]
   ...

3. 输出比特数
   N_output = N_input × 3 = 60 × 3 = 180 bits

示例 (简化):
输入：[1, 0, 1, 1, 0, ...]
初始状态：[最后 6 比特]
输出：[d0_0, d1_0, d2_0, d0_1, d1_1, d2_1, ...]

3.4 编码伪代码

 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
def tbcc_encode(input_bits):
    """
    TBCC 编码实现
    """
    # 生成多项式 (八进制转二进制)
    g0 = [1, 0, 1, 1, 0, 1, 1]  # 133
    g1 = [1, 1, 1, 1, 0, 0, 1]  # 171
    g2 = [1, 1, 1, 0, 1, 0, 1]  # 165

    # 初始化移位寄存器 (咬尾)
    shift_reg = input_bits[-6:]  # 最后 6 比特

    output_bits = []

    # 逐比特编码
    for bit in input_bits:
        # 移位
        shift_reg = [bit] + shift_reg[:-1]

        # 计算 3 路输出
        d0 = sum([s & g for s, g in zip(shift_reg, g0)]) % 2
        d1 = sum([s & g for s, g in zip(shift_reg, g1)]) % 2
        d2 = sum([s & g for s, g in zip(shift_reg, g2)]) % 2

        # 复用输出
        output_bits.extend([d0, d1, d2])

    return output_bits

四、速率匹配

4.1 速率匹配目的

1
2
3
4
5
6
7
速率匹配目的:
├─ 匹配可用 CCE 容量
├─ 支持不同聚合等级
└─ 实现 HARQ 软合并

输入：TBCC 编码输出 (180 bits)
输出：匹配 CCE 容量 (如 144 bits for AL-2)

4.2 子块交织

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
子块交织流程:
─────────────────────────────────────────────────────────
TBCC 输出分为 3 个子块:
块 0: [d0_0, d0_1, d0_2, ...]
块 1: [d1_0, d1_1, d1_2, ...]
块 2: [d2_0, d2_1, d2_2, ...]

每块独立交织:
1. 写入矩阵 (32 列)
2. 列置换
3. 读出 (跳过空位)

交织后 3 块级联:
[交织块 0, 交织块 1, 交织块 2]
─────────────────────────────────────────────────────────

4.3 比特收集与速率匹配

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
循环缓冲器:
─────────────────────────────────────────────────────────
输入：子块交织输出 (180 bits)
缓冲器大小：根据最大 CCE 容量

速率匹配输出:
N_output = N_CCE × N_bits_per_CCE

AL-1: 72 bits
AL-2: 144 bits
AL-4: 288 bits
AL-8: 576 bits

从循环缓冲器读取:
如果 N_output < N_input: 打孔 (puncturing)
如果 N_output > N_input: 重复 (repetition)
─────────────────────────────────────────────────────────

五、加扰与调制

5.1 加扰

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
小区特定加扰:
─────────────────────────────────────────────────────────
c_n = (b_n + s_n) mod 2

其中:
b_n = 速率匹配输出比特
s_n = 加扰序列 (小区特定)

加扰序列生成:
s_n = (x1_n + x2_n) mod 2
x1_{n+31} = (x1_{n+3} + x1_n) mod 2
x2_{n+31} = (x2_{n+3} + x2_{n+2} + x2_{n+1} + x2_n) mod 2

初始化:
x1: [0,0,...,0,1] (31 位)
x2: 小区 ID 相关
─────────────────────────────────────────────────────────

5.2 QPSK 调制

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
QPSK 调制映射:
─────────────────────────────────────────────────────────
比特对 → 符号
[0,0] → (1 + j) / √2
[0,1] → (-1 + j) / √2
[1,0] → (1 - j) / √2
[1,1] → (-1 - j) / √2

示例:
输入比特：[0,0,0,1,1,0,1,1]
输出符号：[(1+j)/√2, (-1+j)/√2, (1-j)/√2, (-1-j)/√2]
─────────────────────────────────────────────────────────

六、块交织与循环移位

6.1 块交织

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
LTE PDCCH 块交织 (特有):

目的：获得额外频率分集

交织过程:
─────────────────────────────────────────────────────────
1. 写入：按行写入矩阵 (32 列)

   行 0:  b0   b1   b2   ... b31
   行 1:  b32  b33  b34  ... b63
   行 2:  b64  b65  b66  ... b95
   ...

2. 列置换：按特定模式置换列

   置换模式：[0, 16, 8, 24, 4, 20, 12, 28, ...]

3. 读出：按列读出

   输出：[b0, b32, b64, ..., b16, b48, b80, ...]
─────────────────────────────────────────────────────────

6.2 循环移位

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
小区特定循环移位:

目的：小区间干扰随机化

移位量计算:
─────────────────────────────────────────────────────────
shift = f(N_cell_ID, 子帧号)

移位操作:
output[i] = input[(i + shift) mod N]

示例:
输入：[b0, b1, b2, b3, b4, b5]
shift = 2
输出：[b2, b3, b4, b5, b0, b1]
─────────────────────────────────────────────────────────

七、解码流程 (UE 接收)

7.1 完整解码链

1
2
3
4
5
PDCCH 解码流程 (UE 接收):

OFDM 解调 → 信道估计 → 均衡 → QPSK 解调 → 解扰
   → 解交织 → 速率恢复 → TBCC 解码 (Viterbi)
   → CRC 校验 → RNTI 解扰 → DCI 提取

7.2 Viterbi 解码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
Viterbi 解码算法:
─────────────────────────────────────────────────────────
输入：软比特 (LLR - Log Likelihood Ratio)
输出：解码比特

步骤:
1. 计算分支度量 (Branch Metric)
   BM = |LLR - expected|^2

2. 加路径度量 (Path Metric)
   PM_new = PM_old + BM

3. 选择幸存路径 (Add-Compare-Select)
   选择 PM 最小的路径

4. 追溯 (Traceback)
   从最终状态追溯 K 步
   输出解码比特

复杂度:
状态数 = 2^(K-1) = 2^6 = 64 状态
─────────────────────────────────────────────────────────

7.3 咬尾处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
咬尾 Viterbi 解码:

问题：初始状态未知

解决方案:
1. 循环解码 (Circular Decoding)
   - 多次迭代
   - 初始状态 = 上次迭代的最终状态

2. 最大似然 (Maximum Likelihood)
   - 对所有可能初始状态解码
   - 选择 CRC 通过的路径

3. 简化方法
   - 用最后 6 比特初始化
   - 单次解码

八、解码伪代码

 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
def viterbi_decode(llr_bits, constraint_length=7):
    """
    Viterbi 解码实现 (简化版)
    """
    num_states = 2 ** (constraint_length - 1)

    # 初始化路径度量
    path_metrics = [0] * num_states
    paths = [[] for _ in range(num_states)]

    # 处理每个输入比特组
    for i in range(0, len(llr_bits), 3):
        new_metrics = [float('inf')] * num_states
        new_paths = [[] for _ in range(num_states)]

        # 对每个状态
        for state in range(num_states):
            # 计算可能的输入 (0 或 1)
            for input_bit in [0, 1]:
                # 计算下一状态
                next_state = calculate_next_state(state, input_bit)

                # 计算期望输出
                expected = calculate_output(state, input_bit)

                # 计算分支度量
                bm = branch_metric(llr_bits[i:i+3], expected)

                # 更新路径度量
                pm = path_metrics[state] + bm
                if pm < new_metrics[next_state]:
                    new_metrics[next_state] = pm
                    new_paths[next_state] = paths[state] + [input_bit]

        path_metrics = new_metrics
        paths = new_paths

    # 选择最佳路径
    best_state = argmin(path_metrics)
    return paths[best_state]

九、CRC 校验与 RNTI 解扰

9.1 CRC 校验

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
CRC 校验流程:
─────────────────────────────────────────────────────────
1. 提取解码比特
   前 A 比特 = DCI
   后 16 比特 = CRC

2. 重新计算 CRC
   CRC_calc = CRC_16(DCI 比特)

3. 比较
   如果 CRC_received == CRC_calc:
       CRC 通过
   否则:
       CRC 失败，尝试下一 Candidate
─────────────────────────────────────────────────────────

9.2 RNTI 解扰

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
RNTI 解扰:
─────────────────────────────────────────────────────────
尝试 RNTI 列表:
[C-RNTI, SI-RNTI, P-RNTI, RA-RNTI, ...]

对每个 RNTI:
1. 用 RNTI 解扰 CRC
   CRC_descrambled = CRC_received XOR RNTI

2. 重新计算 CRC
   CRC_calc = CRC_16(DCI 比特)

3. 比较
   如果 CRC_descrambled == CRC_calc:
       RNTI 匹配，DCI 有效
       返回 DCI 和 RNTI 类型
─────────────────────────────────────────────────────────

十、本章小结

关键要点

  1. TBCC 编码: 咬尾卷积码，码率 ⅓，K=7
  2. 生成多项式: g0=133, g1=171, g2=165 (八进制)
  3. 速率匹配: 子块交织 + 循环缓冲器
  4. 块交织: 32 列矩阵，获得频率分集
  5. 循环移位: 小区间干扰随机化
  6. Viterbi 解码: 64 状态，最大似然解码

下一章预告

下一章 04-LTE-PDCCH-资源映射.md 将深入讲解: - CCE 到 REG 的映射 - REG 分布模式 - 资源映射公式 - 实例分析

文档版本：v1.0
最后更新：2026-03-27
作者：AI Assistant