跳转至

第六章：芯片实现详解

深入解析蓝牙芯片的硬件实现：射频前端、频率合成器、基带处理器的架构设计与 Verilog 代码实现

6.1 蓝牙 SoC 总体架构

6.1.1 典型蓝牙 SoC 框图

 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
┌─────────────────────────────────────────────────────────────────┐
│                    蓝牙 SoC 芯片                                 │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                    射频前端 (RF)                         │   │
│  │  ┌───────┐  ┌───────┐  ┌───────┐  ┌───────┐            │   │
│  │  │  PA   │  │  LNA  │  │  Mixer│  │  PLL  │            │   │
│  │  │功率放大│  │低噪放大│  │ 混频器 │  │锁相环 │            │   │
│  │  └───────┘  └───────┘  └───────┘  └───────┘            │   │
│  └─────────────────────────────────────────────────────────┘   │
│                              │                                  │
│                              ▼                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                  模拟基带 (Analog BB)                    │   │
│  │  ┌───────┐  ┌───────┐  ┌───────┐  ┌───────┐            │   │
│  │  │  DAC  │  │  ADC  │  │  LPF  │  │  VGA  │            │   │
│  │  │数模转换│  │模数转换│  │低通滤波│  │可变增益│            │   │
│  │  └───────┘  └───────┘  └───────┘  └───────┘            │   │
│  └─────────────────────────────────────────────────────────┘   │
│                              │                                  │
│                              ▼                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                  数字基带 (Digital BB)                   │   │
│  │  ┌───────┐  ┌───────┐  ┌───────┐  ┌───────┐            │   │
│  │  │ GFSK  │  │  FEC  │  │  ARQ  │  │  CRC  │            │   │
│  │  │调制解调│  │编解码  │  │控制器 │  │ 引擎  │            │   │
│  │  └───────┘  └───────┘  └───────┘  └───────┘            │   │
│  │  ┌───────┐  ┌───────┐  ┌───────┐  ┌───────┐            │   │
│  │  │ 白化  │  │ 交织  │  │ 加密  │  │ 包处理 │            │   │
│  │  │ 器    │  │ 器    │  │ 引擎  │  │ 器    │            │   │
│  │  └───────┘  └───────┘  └───────┘  └───────┘            │   │
│  └─────────────────────────────────────────────────────────┘   │
│                              │                                  │
│                              ▼                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                    链路管理层 (LMP)                      │   │
│  │  ┌─────────────────────────────────────────────────┐    │   │
│  │  │              ARM Cortex-M 处理器                 │    │   │
│  │  │              (运行蓝牙协议栈)                    │    │   │
│  │  └─────────────────────────────────────────────────┘    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                              │                                  │
│                              ▼                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                    主机接口 (HCI)                        │   │
│  │     UART / USB / SPI / I2C / PCM                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                    电源管理 (PMU)                        │   │
│  │     LDO / DC-DC / 电池管理 / 低功耗模式                  │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

6.1.2 芯片工艺与集成度

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
现代蓝牙 SoC 集成度：

┌─────────────────────────────────────────────────────────┐
│                    Nordic nRF52840                      │
├─────────────────────────────────────────────────────────┤
│  工艺：55 nm CMOS                                        │
│  尺寸：5.5 × 5.5 mm (QFN73)                             │
│  集成：                                                  │
│  ├─ 2.4 GHz 多协议射频 (BLE/Bluetooth/Zigbee/Thread)    │
│  ├─ ARM Cortex-M4F @ 64 MHz                            │
│  ├─ 1 MB Flash + 256 KB RAM                            │
│  ├─ USB 2.0 (全速)                                     │
│  ├─ NFC 控制器                                         │
│  ├─ 电源管理单元                                       │
│  └─ 48 个 GPIO                                          │
│                                                         │
│  功耗：                                                  │
│  ├─ 发射：5.3 mA @ 0 dBm                               │
│  ├─ 接收：5.6 mA                                       │
│  ├─ 睡眠：3 μA                                         │
│  └─ 系统关闭：0.6 μA                                   │
└─────────────────────────────────────────────────────────┘

6.2 射频前端实现

6.2.1 发射链路设计

发射机架构：

 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
// 蓝牙发射机顶层模块
module bluetooth_transmitter (
    input wire clk,              // 系统时钟 (16/32 MHz)
    input wire reset_n,          // 复位
    input wire [7:0] tx_data,    // 发送数据
    input wire tx_enable,        // 发送使能
    input wire [15:0] freq_ctrl, // 频率控制字
    output wire rf_enable,       // RF 使能
    output wire pa_enable,       // 功率放大器使能
    output wire [1:0] pa_bias    // PA 偏置控制
);

// 内部模块实例化

// 1. 白化器
wire [7:0] whitened_data;
whitener u_whitener (
    .clk(clk),
    .reset_n(reset_n),
    .data_in(tx_data),
    .data_out(whitened_data),
    .enable(tx_enable)
);

// 2. FEC 编码器
wire [7:0] fec_data;
wire fec_valid;
fec_encoder u_fec (
    .clk(clk),
    .reset_n(reset_n),
    .data_in(whitened_data),
    .data_out(fec_data),
    .valid(fec_valid),
    .enable(tx_enable)
);

// 3. GFSK 调制器
wire signed [11:0] i_baseband, q_baseband;
gfsk_modulator u_modulator (
    .clk(clk),
    .reset_n(reset_n),
    .data_in(fec_data),
    .i_out(i_baseband),
    .q_out(q_baseband),
    .enable(fec_valid)
);

// 4. DAC 接口
wire [11:0] dac_i, dac_q;
dac_interface u_dac (
    .clk(clk),
    .reset_n(reset_n),
    .i_in(i_baseband),
    .q_in(q_baseband),
    .dac_i(dac_i),
    .dac_q(dac_q),
    .dac_clk(dac_clk),
    .enable(fec_valid)
);

// 5. 频率合成器控制
pll_controller u_pll (
    .clk(clk),
    .reset_n(reset_n),
    .freq_ctrl(freq_ctrl),
    .pll_enable(rf_enable),
    .locked(pll_locked)
);

// 6. PA 控制
pa_controller u_pa (
    .clk(clk),
    .reset_n(reset_n),
    .tx_enable(tx_enable & pll_locked),
    .pa_enable(pa_enable),
    .pa_bias(pa_bias)
);

endmodule

功率放大器 (PA) 设计：

 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
// 功率放大器控制模块
module pa_controller (
    input wire clk,
    input wire reset_n,
    input wire tx_enable,
    output reg pa_enable,
    output reg [1:0] pa_bias
);

// PA  ramp-up/ramp-down 控制
// 避免功率突变导致频谱扩散

reg [7:0] ramp_counter;
reg [3:0] power_level;  // 0-10: 功率等级

// 功率等级查找表
localparam [7:0] POWER_TABLE [0:10] = '{
    8'h00,   // -20 dBm
    8'h10,   // -16 dBm
    8'h20,   // -12 dBm
    8'h30,   // -8 dBm
    8'h40,   // -4 dBm
    8'h50,   // 0 dBm
    8'h60,   // +4 dBm
    8'h70,   // +8 dBm
    8'h80,   // +12 dBm
    8'h90,   // +16 dBm
    8'hA0    // +20 dBm
};

always @(posedge clk or negedge reset_n) begin
    if (!reset_n) begin
        pa_enable <= 1'b0;
        pa_bias <= 2'b00;
        ramp_counter <= 8'd0;
        power_level <= 4'd5;  // 默认 0 dBm
    end else begin
        if (tx_enable) begin
            // 开启 PA，ramp-up
            if (ramp_counter < 8'd10) begin
                ramp_counter <= ramp_counter + 1;
                pa_enable <= 1'b1;
                pa_bias <= ramp_counter[7:6];  // 逐步增加偏置
            end else begin
                pa_bias <= power_level[5:4];
            end
        end else begin
            // 关闭 PA，ramp-down
            if (ramp_counter > 8'd0) begin
                ramp_counter <= ramp_counter - 1;
                pa_bias <= ramp_counter[7:6];
            end else begin
                pa_enable <= 1'b0;
            end
        end
    end
end

endmodule

6.2.2 接收链路设计

接收机架构：

  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
// 蓝牙接收机顶层模块
module bluetooth_receiver (
    input wire clk,              // 系统时钟
    input wire reset_n,          // 复位
    input wire [11:0] adc_i,     // ADC I 路输入
    input wire [11:0] adc_q,     // ADC Q 路输入
    input wire rx_enable,        // 接收使能
    input wire [15:0] freq_ctrl, // 频率控制字
    output wire [7:0] rx_data,   // 接收数据
    output wire rx_valid,        // 数据有效
    output wire rssi_out,        // RSSI 输出
    output wire carrier_sense    // 载波检测
);

// 1. 数字下变频
wire signed [11:0] baseband_i, baseband_q;
digital_down_converter u_ddc (
    .clk(clk),
    .reset_n(reset_n),
    .adc_i(adc_i),
    .adc_q(adc_q),
    .baseband_i(baseband_i),
    .baseband_q(baseband_q),
    .freq_ctrl(freq_ctrl),
    .enable(rx_enable)
);

// 2. 低通滤波器
wire signed [11:0] filtered_i, filtered_q;
low_pass_filter u_lpf (
    .clk(clk),
    .reset_n(reset_n),
    .i_in(baseband_i),
    .q_in(baseband_q),
    .i_out(filtered_i),
    .q_out(filtered_q),
    .enable(rx_enable)
);

// 3. GFSK 解调器
wire demod_data;
wire demod_clk;
gfsk_demodulator u_demod (
    .clk(clk),
    .reset_n(reset_n),
    .i_in(filtered_i),
    .q_in(filtered_q),
    .data_out(demod_data),
    .symbol_clk(demod_clk),
    .enable(rx_enable)
);

// 4. 去交织器
wire [14:0] deinterleaved;
deinterleaver u_deinter (
    .clk(clk),
    .reset_n(reset_n),
    .data_in(demod_data),
    .data_out(deinterleaved),
    .clock(demod_clk),
    .enable(rx_enable)
);

// 5. FEC 解码器
wire [7:0] fec_decoded;
wire fec_valid;
fec_decoder u_fec_dec (
    .clk(clk),
    .reset_n(reset_n),
    .data_in(deinterleaved),
    .data_out(fec_decoded),
    .valid(fec_valid),
    .enable(rx_enable)
);

// 6. 去白化器
wire [7:0] dewhitened;
dewhitener u_dewhitener (
    .clk(clk),
    .reset_n(reset_n),
    .data_in(fec_decoded),
    .data_out(dewhitened),
    .valid(rx_valid),
    .enable(fec_valid)
);

// 7. RSSI 计算
rssicalculator u_rssi (
    .clk(clk),
    .reset_n(reset_n),
    .i_in(filtered_i),
    .q_in(filtered_q),
    .rssi(rssi_out),
    .enable(rx_enable)
);

// 8. 载波检测
carrier_detector u_cd (
    .clk(clk),
    .reset_n(reset_n),
    .rssi(rssi_out),
    .carrier_sense(carrier_sense),
    .enable(rx_enable)
);

assign rx_data = dewhitened;

endmodule

数字下变频 (DDC) 实现：

 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
// 数字下变频器
module digital_down_converter (
    input wire clk,
    input wire reset_n,
    input wire signed [11:0] adc_i,
    input wire signed [11:0] adc_q,
    output reg signed [11:0] baseband_i,
    output reg signed [11:0] baseband_q,
    input wire [15:0] freq_ctrl,
    input wire enable
);

// NCO (数控振荡器)
reg [15:0] nco_phase;
wire [11:0] nco_cos, nco_sin;

// 相位累加
always @(posedge clk or negedge reset_n) begin
    if (!reset_n)
        nco_phase <= 16'h0000;
    else if (enable)
        nco_phase <= nco_phase + freq_ctrl;
end

// CORDIC 或查找表生成正弦/余弦
cordic_lut u_cordic (
    .phase_in(nco_phase),
    .cos_out(nco_cos),
    .sin_out(nco_sin)
);

// 混频 (下变频)
wire signed [23:0] mix_i1, mix_i2, mix_q1, mix_q2;
wire signed [23:0] bb_i_sum, bb_q_sum;

assign mix_i1 = $signed(adc_i) * $signed(nco_cos);
assign mix_i2 = $signed(adc_q) * $signed(nco_sin);
assign mix_q1 = $signed(adc_q) * $signed(nco_cos);
assign mix_q2 = $signed(adc_i) * $signed(nco_sin);

assign bb_i_sum = mix_i1 - mix_i2;  // I = I×cos - Q×sin
assign bb_q_sum = mix_q1 + mix_q2;  // Q = Q×cos + I×sin

// 低通滤波并截断到 12 bit
always @(posedge clk) begin
    if (enable) begin
        baseband_i <= bb_i_sum[23:12];
        baseband_q <= bb_q_sum[23:12];
    end
end

endmodule

6.3 频率合成器实现

6.3.1 小数分频 PLL 架构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
PLL 框图：

参考时钟 ──► 参考分频器 (R) ──► 相位检测器 ──► 电荷泵 ──► 环路滤波 ──► VCO
    │                              ▲                                         │
    │                              │                                         │
    │                              └────── Σ-Δ 调制器 ◄──── 分频器 (N.F) ◄───┘
    │                                                           │
    └────────────────────── 频率控制字 ─────────────────────────┘

输出频率：f_out = (N + F/K) × f_ref / R

其中：
├── N: 整数分频比
├── F/K: 小数部分 (Σ-Δ 调制)
├── f_ref: 参考频率 (16 MHz 典型)
└── R: 参考分频比

PLL 控制模块：

 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
// 小数分频 PLL 控制器
module fractional_pll_controller (
    input wire clk,           // 参考时钟 (16 MHz)
    input wire reset_n,
    input wire [15:0] freq_ctrl,  // 频率控制字
    output wire pll_enable,       // PLL 使能
    output wire pll_locked,       // 锁定指示
    output reg [23:0] div_ratio,  // 分频比输出到 Σ-Δ 调制器
    input wire lock_detected      // 锁定检测输入
);

// 蓝牙频率映射
// freq_ctrl = 0 → 2402 MHz
// freq_ctrl = 78 → 2480 MHz

localparam REAL F_REF = 16.0;  // 16 MHz 参考
localparam REAL F_CHANNEL_STEP = 1.0;  // 1 MHz 信道间隔

reg [15:0] channel_num;
reg [23:0] integer_part;
reg [19:0] fractional_part;

// 频率计算
always @(*) begin
    // f_out = 2402 + channel_num (MHz)
    // N = f_out / f_ref = (2402 + ch) / 16

    integer_part = 24'd150 + (freq_ctrl * 24'd1);  // 150 = 2400/16
    fractional_part = 20'd0;  // 简化，实际需要根据精确频率计算

    div_ratio = {integer_part, fractional_part};
end

// 锁定检测同步
reg [2:0] lock_sync;
always @(posedge clk or negedge reset_n) begin
    if (!reset_n)
        lock_sync <= 3'b000;
    else
        lock_sync <= {lock_sync[1:0], lock_detected};
end

assign pll_locked = &lock_sync;  // 连续 3 次检测到锁定
assign pll_enable = 1'b1;  // 常开

endmodule

6.3.2 Σ-Δ 调制器

 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
// 三阶 Σ-Δ 调制器 (用于小数分频)
module sigma_delta_modulator (
    input wire clk,
    input wire reset_n,
    input wire [19:0] fractional_in,  // 小数部分输入
    output reg [2:0] modulator_out,   // 3 bit 输出
    input wire enable
);

// 三阶 MASH 结构
reg [19:0] acc1, acc2, acc3;
reg [19:0] diff1, diff2;
reg [2:0] out1, out2;

// 第一级
always @(posedge clk or negedge reset_n) begin
    if (!reset_n) begin
        acc1 <= 20'd0;
        out1 <= 3'd0;
    end else if (enable) begin
        acc1 <= acc1 + fractional_in;
        out1 <= acc1[19];  // 进位输出
        diff1 <= acc1 - {out1, 19'd0};
    end
end

// 第二级
always @(posedge clk or negedge reset_n) begin
    if (!reset_n) begin
        acc2 <= 20'd0;
        out2 <= 3'd0;
    end else if (enable) begin
        acc2 <= acc2 + {1'b0, diff1[18:0]};
        out2 <= acc2[19];
        diff2 <= acc2 - {out2, 19'd0};
    end
end

// 第三级
always @(posedge clk or negedge reset_n) begin
    if (!reset_n) begin
        acc3 <= 20'd0;
        modulator_out <= 3'd0;
    end else if (enable) begin
        acc3 <= acc3 + {1'b0, diff2[18:0]};
        // MASH 输出 = out1 + (out2-out1)z^-1 + (out3-out2)z^-2
        modulator_out <= out1 + out2 - out1 + out3 - out2;
    end
end

endmodule

6.4 基带处理器实现

6.4.1 包处理引擎

  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
// 蓝牙包处理引擎
module packet_processor (
    input wire clk,
    input wire reset_n,

    // TX 接口
    input wire [7:0] tx_payload,
    input wire tx_valid,
    input wire tx_start,
    input wire tx_end,
    output wire tx_ready,

    // RX 接口
    output wire [7:0] rx_payload,
    output wire rx_valid,
    output wire rx_start,
    output wire rx_end,
    input wire rx_ready,

    // 控制接口
    input wire [2:0] packet_type,
    input wire [2:0] am_addr,
    input wire [15:0] access_code,
    output wire rf_tx_enable,
    output wire rf_rx_enable,

    // 状态输出
    output wire [7:0] status,
    output wire crc_error,
    output wire carrier_lost
);

// 状态机
localparam STATE_IDLE = 3'd0;
localparam STATE_TX_PREPARE = 3'd1;
localparam STATE_TX_ACCESS = 3'd2;
localparam STATE_TX_HEADER = 3'd3;
localparam STATE_TX_PAYLOAD = 3'd4;
localparam STATE_RX_WAIT = 3'd5;
localparam STATE_RX_ACCESS = 3'd6;
localparam STATE_RX_HEADER = 3'd7;
localparam STATE_RX_PAYLOAD = 3'd8;

reg [2:0] state;
reg [4:0] bit_count;
reg [7:0] byte_count;

// TX FIFO
reg [7:0] tx_fifo [0:63];
reg [5:0] tx_fifo_wr_ptr, tx_fifo_rd_ptr;
wire tx_fifo_empty, tx_fifo_full;

// 访问码生成
reg [63:0] access_code_reg;
access_code_generator u_access_gen (
    .address(access_code),
    .access_code(access_code_reg)
);

// 头部生成
reg [53:0] header_encoded;
header_generator u_header_gen (
    .am_addr(am_addr),
    .packet_type(packet_type),
    .flow_ctrl(1'b1),
    .arqn(1'b1),
    .seqn(seq_num),
    .hec(hec_calc),
    .header_encoded(header_encoded)
);

// CRC 计算器
reg [23:0] crc_calc;
crc24_calculator u_crc (
    .clk(clk),
    .reset_n(reset_n),
    .data_in(tx_payload),
    .crc_out(crc_calc),
    .enable(tx_valid),
    .calc_start(tx_start),
    .calc_done(crc_done)
);

// 主状态机
always @(posedge clk or negedge reset_n) begin
    if (!reset_n) begin
        state <= STATE_IDLE;
        rf_tx_enable <= 1'b0;
        rf_rx_enable <= 1'b0;
        bit_count <= 5'd0;
        byte_count <= 8'd0;
    end else begin
        case (state)
            STATE_IDLE: begin
                if (tx_start) begin
                    state <= STATE_TX_PREPARE;
                    rf_tx_enable <= 1'b1;
                    byte_count <= 8'd0;
                end else begin
                    state <= STATE_RX_WAIT;
                    rf_rx_enable <= 1'b1;
                end
            end

            STATE_TX_PREPARE: begin
                // 发送前导码
                if (bit_count >= 5'd72) begin
                    state <= STATE_TX_ACCESS;
                    bit_count <= 5'd0;
                end else begin
                    bit_count <= bit_count + 1'b1;
                end
            end

            STATE_TX_ACCESS: begin
                // 发送访问码 (64 bit)
                if (bit_count >= 5'd64) begin
                    state <= STATE_TX_HEADER;
                    bit_count <= 5'd0;
                end else begin
                    bit_count <= bit_count + 1'b1;
                end
            end

            STATE_TX_HEADER: begin
                // 发送头部 (54 bit，含 FEC)
                if (bit_count >= 5'd54) begin
                    state <= STATE_TX_PAYLOAD;
                    bit_count <= 5'd0;
                end else begin
                    bit_count <= bit_count + 1'b1;
                end
            end

            STATE_TX_PAYLOAD: begin
                // 发送有效载荷
                if (tx_end && tx_fifo_empty) begin
                    state <= STATE_IDLE;
                    rf_tx_enable <= 1'b0;
                end
            end

            STATE_RX_WAIT: begin
                // 等待接收
                if (carrier_sense) begin
                    state <= STATE_RX_ACCESS;
                end
            end

            // ... RX 状态处理
        endcase
    end
end

endmodule

6.4.2 时序控制器

 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
// 蓝牙时序控制器
module timing_controller (
    input wire clk,           // 32 MHz 系统时钟
    input wire reset_n,

    // 时隙计数
    output reg [16:0] slot_count,  // 蓝牙时钟 (312.5 μs 分辨率)
    output reg [1:0] slot_phase,   // 时隙内相位

    // 跳频控制
    output reg [6:0] hop_channel,  // 当前信道
    input wire [63:0] bd_addr,     // 蓝牙地址
    input wire afh_map,            // AFH 映射表

    // 包时序
    input wire packet_start,
    input wire [4:0] packet_slots, // 包占用时隙数
    output wire tx_window,         // 发送窗口
    output wire rx_window,         // 接收窗口

    // 主从控制
    input wire is_master,
    output wire master_tx,         // 主设备发送指示
    output wire slave_tx           // 从设备发送指示
);

// 蓝牙时钟 (312.5 μs = 625 μs / 2)
// 32 MHz / 102400 = 312.5 μs
reg [16:0] clk_div;
localparam CLK_DIV_MAX = 17'd10240;

always @(posedge clk or negedge reset_n) begin
    if (!reset_n) begin
        clk_div <= 17'd0;
        slot_count <= 17'd0;
        slot_phase <= 2'b00;
    end else begin
        if (clk_div >= CLK_DIV_MAX) begin
            clk_div <= 17'd0;
            slot_count <= slot_count + 1'b1;
            slot_phase <= slot_phase + 1'b1;
        end else begin
            clk_div <= clk_div + 1'b1;
        end
    end
end

// 跳频序列生成
reg [6:0] next_channel;
always @(posedge clk) begin
    if (slot_phase == 2'b00) begin
        // 每个新时隙计算下一个频率
        next_channel <= hop_frequency(bd_addr, slot_count, afh_map);
    end
    hop_channel <= next_channel;
end

// 主从发送窗口
always @(*) begin
    if (is_master) begin
        master_tx = (slot_count[0] == 1'b0);  // 偶数时隙发送
        slave_tx = (slot_count[0] == 1'b1);   // 奇数时隙发送
    end else begin
        master_tx = (slot_count[0] == 1'b1);  // 从设备视角相反
        slave_tx = (slot_count[0] == 1'b0);
    end

    tx_window = master_tx & packet_start;
    rx_window = slave_tx;
end

// 跳频函数
function [6:0] hop_frequency;
    input [63:0] addr;
    input [16:0] clk;
    input [78:0] afh;

    // 简化跳频算法
    // 实际实现需要完整的蓝牙跳频序列生成
    reg [6:0] a, b;
    reg [6:0] result;

    a = addr[6:0];
    b = addr[13:7];

    result = ((a * clk[6:0]) + b) % 79;

    // AFH 映射
    if (!afh[result]) begin
        // 如果当前信道被排除，选择下一个可用信道
        result = (result + 1) % 79;
    end

    hop_frequency = result;
endfunction

endmodule

6.5 低功耗设计

6.5.1 时钟门控

 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
// 时钟门控单元
module clock_gating_cell (
    input wire clk_in,
    input wire enable,
    output wire clk_out
);

reg enable_reg;

// 负边沿触发，避免毛刺
always @(negedge clk_in or negedge enable) begin
    if (!enable)
        enable_reg <= 1'b0;
    else
        enable_reg <= 1'b1;
end

assign clk_out = clk_in & enable_reg;

endmodule

// 模块级时钟门控
module bluetooth_with_clock_gating (
    input wire clk,
    input wire reset_n,
    input wire [1:0] power_mode,  // 00=Active, 01=Sniff, 10=Hold, 11=Park
    // ... 其他端口
);

wire clk_rf, clk_bb, clk_lmp;

// 根据功耗模式门控时钟
assign clk_rf = (power_mode == 2'b00) ? clk : 1'b0;  // 仅 Active 开启 RF
assign clk_bb = (power_mode != 2'b11) ? clk : 1'b0;  // Park 关闭基带
assign clk_lmp = clk;  // LMP 始终运行

// 实例化带时钟门控的模块
rf_front_end u_rf (
    .clk(clk_rf),
    // ...
);

baseband_processor u_bb (
    .clk(clk_bb),
    // ...
);

endmodule

6.5.2 电源门控

 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
// 电源域控制
module power_domain_controller (
    input wire clk,
    input wire reset_n,
    input wire [1:0] sleep_mode,
    output wire pwr_rf,      // RF 电源使能
    output wire pwr_bb,      // 基带电源使能
    output wire pwr_pll,     // PLL 电源使能
    output wire pwr_io       // IO 电源使能
);

// 电源模式定义
localparam ACTIVE = 2'b00;
localparam SNIFF = 2'b01;
localparam HOLD = 2'b10;
localparam PARK = 2'b11;

always @(*) begin
    case (sleep_mode)
        ACTIVE: begin
            pwr_rf = 1'b1;
            pwr_bb = 1'b1;
            pwr_pll = 1'b1;
            pwr_io = 1'b1;
        end
        SNIFF: begin
            pwr_rf = 1'b0;  // 关闭 RF
            pwr_bb = 1'b1;  // 保持基带
            pwr_pll = 1'b0; // 关闭 PLL
            pwr_io = 1'b1;
        end
        HOLD: begin
            pwr_rf = 1'b0;
            pwr_bb = 1'b0;  // 关闭基带
            pwr_pll = 1'b0;
            pwr_io = 1'b1;
        end
        PARK: begin
            pwr_rf = 1'b0;
            pwr_bb = 1'b0;
            pwr_pll = 1'b0;
            pwr_io = 1'b0;  // 仅保留唤醒逻辑
        end
    endcase
end

endmodule

6.6 本章小结

本章深入讲解了蓝牙芯片的硬件实现：

  1. SoC 总体架构：RF、模拟基带、数字基带、处理器、接口
  2. 射频前端：发射链路、接收链路、PA 控制、DDC 实现
  3. 频率合成器：小数分频 PLL、Σ-Δ 调制器
  4. 基带处理器：包处理引擎、时序控制器
  5. 低功耗设计：时钟门控、电源门控、功耗模式

下一章将详细讲解安全加密机制的硬件实现和协议流程。

上一章：05-基带处理架构
下一章：07-安全加密机制