编程技术分享

分享编程知识，探讨技术创新

0%

简介：基于RDA5807收发芯片的调频收音机制作

发表于 分类于 ， ，

好的，没问题！作为一名高级嵌入式软件开发工程师，我将基于您提供的RDA5807调频收音机项目，详细阐述最适合的代码设计架构，并提供具体的C代码实现。我将从需求分析开始，逐步深入到系统实现、测试验证和维护升级，确保建立一个可靠、高效且可扩展的系统平台。
关注微信公众号，提前获取相关推文

项目概述

本项目旨在开发一个基于RDA5807收发芯片的调频收音机。RDA5807是一款单芯片广播立体声调频接收器，具有体积小、功耗低、灵敏度高、噪声低等优点，非常适合用于便携式嵌入式设备。该项目将涵盖从硬件接口控制、音频信号处理到用户交互界面的软件开发，旨在构建一个完整的、可工作的FM收音机系统。

需求分析

一个基本的FM收音机需要具备以下核心功能：

  1. 调频接收: 能够接收87.5MHz - 108MHz频段的FM广播信号。
  2. 频率调节: 允许用户手动或自动调节接收频率。
    • 手动调频: 通过按钮或旋钮微调频率。
    • 自动搜台: 自动搜索可用的电台。
  3. 音量控制: 调节音频输出的音量大小。
  4. 音频输出: 通过耳机或扬声器输出音频信号。
  5. 静音/取消静音: 控制音频输出的开关。
  6. 显示 (可选，但建议):
    • 频率显示: 显示当前接收的频率。
    • 电台名称显示 (RDS功能，如果RDA5807支持且项目需要): 显示电台名称等信息。
  7. 电源管理: 低功耗设计，考虑电池供电情况。
  8. 按键操作: 通过按键进行各项功能操作 (电源开关、搜台、音量调节等)。
  9. 可靠性和稳定性: 系统应稳定可靠运行，不易崩溃。
  10. 可扩展性: 软件架构应易于扩展新功能，如RDS解码、预设电台等。

系统架构设计

为了实现上述需求，并确保系统的可靠性、高效性和可扩展性，我推荐采用分层架构的代码设计模式。分层架构将系统划分为多个独立的层，每一层只关注特定的功能，层与层之间通过清晰定义的接口进行通信。这种架构具有以下优点：

  • 模块化: 每个层都是一个独立的模块，易于开发、测试和维护。
  • 高内聚低耦合: 层内部模块之间高度内聚，层与层之间低耦合，降低了模块间的依赖性，提高了系统的可维护性和可复用性。
  • 可扩展性: 易于在不影响其他层的情况下，修改或扩展某一层的实现。
  • 代码复用: 底层模块可以被上层模块复用。
  • 易于测试: 可以独立测试每一层的功能。

基于分层架构，我为RDA5807调频收音机项目设计了以下层次结构：

  1. **硬件抽象层 (HAL, Hardware Abstraction Layer)**：

    • 功能: 直接与硬件交互，提供统一的硬件访问接口。
    • 模块:
      • I2C HAL: 封装I2C总线操作，用于与RDA5807芯片通信。
      • GPIO HAL: 封装GPIO操作，用于控制按键、LED指示灯等。
      • Audio HAL: 封装音频输出接口，如DAC或PWM音频输出。
      • Timer HAL: 封装定时器操作，用于系统定时和延时。
    • 优势: 屏蔽底层硬件差异，使上层软件无需关心具体的硬件细节，提高了代码的可移植性。如果更换硬件平台，只需要修改HAL层代码即可。

  2. **驱动层 (Driver Layer)**：

    • 功能: 基于HAL层提供的接口，实现特定硬件设备的功能驱动。
    • 模块:
      • RDA5807 驱动: 封装RDA5807芯片的控制逻辑，包括初始化、频率设置、音量控制、搜台、读取状态等。
      • 按键驱动: 检测按键输入，并提供按键事件处理接口。
      • 音频驱动: 配置音频输出，例如初始化DAC或PWM，设置音量等。
      • 显示驱动 (如果需要): 驱动显示屏，例如LCD或OLED，实现频率显示、电台名称显示等功能。
    • 优势: 将硬件操作逻辑封装在驱动层，使得上层应用层可以更方便地使用硬件功能。

  3. **服务层 (Service Layer)**：

    • 功能: 提供业务逻辑服务，将底层的驱动功能组合起来，实现更高层次的应用功能。
    • 模块:
      • FM 收音机服务: 实现FM收音机的核心业务逻辑，包括频率管理、搜台逻辑、音量控制逻辑、静音控制、电台预设 (可选) 等。
    • 优势: 将业务逻辑与硬件驱动分离，使得应用层可以专注于用户交互和应用流程，提高了代码的可读性和可维护性。

  4. **应用层 (Application Layer)**：

    • 功能: 实现用户交互界面和应用程序流程。
    • 模块:
      • 用户界面 (UI): 处理用户输入 (按键操作)，调用服务层提供的接口，并将结果反馈给用户 (例如通过显示屏或音频输出)。
      • 主应用程序: 初始化系统，启动各个服务，处理主循环逻辑，响应用户事件。
    • 优势: 专注于用户交互和应用逻辑，使得系统更易于使用和操作。

代码实现 (C语言)

下面我将逐步提供各个层次的具体C代码实现。为了代码的完整性和可运行性，我将尽可能详细地编写代码，并添加注释进行说明。请注意，以下代码示例是基于常见的嵌入式开发环境，可能需要根据具体的硬件平台和开发工具进行调整。

1. 硬件抽象层 (HAL)

首先，定义HAL层的头文件 hal.h，声明HAL层提供的接口函数。

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
// hal.h
#ifndef _HAL_H_
#define _HAL_H_

#include <stdint.h>
#include <stdbool.h>

// I2C HAL
typedef enum {
    HAL_I2C_OK,
    HAL_I2C_ERROR
} HAL_I2C_StatusTypeDef;

HAL_I2C_StatusTypeDef hal_i2c_init(void);
HAL_I2C_StatusTypeDef hal_i2c_write_byte(uint8_t dev_addr, uint8_t reg_addr, uint8_t data);
HAL_I2C_StatusTypeDef hal_i2c_read_bytes(uint8_t dev_addr, uint8_t reg_addr, uint8_t *p_data, uint16_t size);

// GPIO HAL
typedef enum {
    HAL_GPIO_OK,
    HAL_GPIO_ERROR
} HAL_GPIO_StatusTypeDef;

typedef enum {
    HAL_GPIO_MODE_INPUT,
    HAL_GPIO_MODE_OUTPUT
} HAL_GPIO_ModeTypeDef;

typedef enum {
    HAL_GPIO_PIN_RESET,
    HAL_GPIO_PIN_SET
} HAL_GPIO_PinStateTypeDef;

HAL_GPIO_StatusTypeDef hal_gpio_init(uint32_t pin, HAL_GPIO_ModeTypeDef mode);
HAL_GPIO_StatusTypeDef hal_gpio_write_pin(uint32_t pin, HAL_GPIO_PinStateTypeDef state);
HAL_GPIO_PinStateTypeDef hal_gpio_read_pin(uint32_t pin);

// Audio HAL (简化的示例，实际可能需要更复杂的音频配置)
typedef enum {
    HAL_AUDIO_OK,
    HAL_AUDIO_ERROR
} HAL_AUDIO_StatusTypeDef;

HAL_AUDIO_StatusTypeDef hal_audio_init(void);
HAL_AUDIO_StatusTypeDef hal_audio_set_volume(uint8_t volume); // 0-100 范围

// Timer HAL (简化的延时函数)
void hal_delay_ms(uint32_t ms);

#endif // _HAL_H_

然后，实现HAL层的代码 hal.c。这里以模拟I2C和简单的GPIO操作为例，实际项目中需要根据具体的硬件平台进行实现。音频和定时器HAL也提供简单的示例。

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
// hal.c
#include "hal.h"
#include <stdio.h> // For printf (调试用)

// *** I2C HAL (模拟 I2C，实际项目应使用硬件 I2C) ***
#define I2C_SDA_PIN   // 定义 SDA 引脚
#define I2C_SCL_PIN   // 定义 SCL 引脚

// 模拟 I2C 初始化 (需要配置 GPIO 引脚为输出)
HAL_I2C_StatusTypeDef hal_i2c_init(void) {
    // 初始化 SDA 和 SCL 引脚为输出，并设置为高电平 (空闲状态)
    // ... (具体 GPIO 初始化代码，例如配置寄存器) ...
    printf("I2C HAL initialized (模拟).\r\n");
    return HAL_I2C_OK;
}

// 模拟 I2C 起始信号
static void i2c_start(void) {
    // ... (模拟 I2C 起始信号时序) ...
}

// 模拟 I2C 停止信号
static void i2c_stop(void) {
    // ... (模拟 I2C 停止信号时序) ...
}

// 模拟 I2C 发送一个字节
static HAL_I2C_StatusTypeDef i2c_send_byte(uint8_t data) {
    // ... (模拟 I2C 发送字节时序，包括 ACK/NACK 检查) ...
    return HAL_I2C_OK; // 简化，实际需要处理 ACK/NACK
}

// 模拟 I2C 读取一个字节
static uint8_t i2c_receive_byte(bool ack) {
    // ... (模拟 I2C 接收字节时序，并发送 ACK/NACK) ...
    return 0; // 简化，实际需要返回接收到的字节
}

// HAL I2C 写字节函数
HAL_I2C_StatusTypeDef hal_i2c_write_byte(uint8_t dev_addr, uint8_t reg_addr, uint8_t data) {
    i2c_start();
    if (i2c_send_byte((dev_addr << 1) | 0x00) != HAL_I2C_OK) { // 发送设备地址 + 写命令
        i2c_stop();
        return HAL_I2C_ERROR;
    }
    if (i2c_send_byte(reg_addr) != HAL_I2C_OK) { // 发送寄存器地址
        i2c_stop();
        return HAL_I2C_ERROR;
    }
    if (i2c_send_byte(data) != HAL_I2C_OK) { // 发送数据
        i2c_stop();
        return HAL_I2C_ERROR;
    }
    i2c_stop();
    return HAL_I2C_OK;
}

// HAL I2C 读字节数组函数
HAL_I2C_StatusTypeDef hal_i2c_read_bytes(uint8_t dev_addr, uint8_t reg_addr, uint8_t *p_data, uint16_t size) {
    i2c_start();
    if (i2c_send_byte((dev_addr << 1) | 0x00) != HAL_I2C_OK) { // 发送设备地址 + 写命令 (用于指定寄存器地址)
        i2c_stop();
        return HAL_I2C_ERROR;
    }
    if (i2c_send_byte(reg_addr) != HAL_I2C_OK) { // 发送寄存器地址
        i2c_stop();
        return HAL_I2C_ERROR;
    }

    i2c_start(); // 重复启动信号，用于切换到读模式
    if (i2c_send_byte((dev_addr << 1) | 0x01) != HAL_I2C_OK) { // 发送设备地址 + 读命令
        i2c_stop();
        return HAL_I2C_ERROR;
    }

    for (uint16_t i = 0; i < size; i++) {
        p_data[i] = i2c_receive_byte(i < size - 1); // 最后一个字节发送 NACK，否则发送 ACK
    }
    i2c_stop();
    return HAL_I2C_OK;
}


// *** GPIO HAL (简化的示例) ***
// 定义 GPIO 引脚宏 (实际项目应根据硬件定义)
#define GPIO_PIN_POWER     // 电源控制引脚
#define GPIO_PIN_SEEK_UP   // 搜台+ 按键引脚
#define GPIO_PIN_SEEK_DOWN // 搜台- 按键引脚
#define GPIO_PIN_VOL_UP    // 音量+ 按键引脚
#define GPIO_PIN_VOL_DOWN  // 音量- 按键引脚

HAL_GPIO_StatusTypeDef hal_gpio_init(uint32_t pin, HAL_GPIO_ModeTypeDef mode) {
    // 初始化 GPIO 引脚为输入或输出模式
    // ... (具体 GPIO 初始化代码，例如配置寄存器) ...
    printf("GPIO HAL initialized for pin %lu, mode %d.\r\n", pin, mode);
    return HAL_GPIO_OK;
}

HAL_GPIO_StatusTypeDef hal_gpio_write_pin(uint32_t pin, HAL_GPIO_PinStateTypeDef state) {
    // 设置 GPIO 引脚输出高/低电平
    // ... (具体 GPIO 写操作代码，例如配置寄存器) ...
    printf("GPIO HAL write pin %lu, state %d.\r\n", pin, state);
    return HAL_GPIO_OK;
}

HAL_GPIO_PinStateTypeDef hal_gpio_read_pin(uint32_t pin) {
    // 读取 GPIO 引脚电平
    // ... (具体 GPIO 读操作代码，例如读取寄存器) ...
    printf("GPIO HAL read pin %lu.\r\n", pin);
    return HAL_GPIO_PIN_RESET; // 简化，实际应返回读取到的状态
}


// *** Audio HAL (简化的示例) ***
HAL_AUDIO_StatusTypeDef hal_audio_init(void) {
    // 初始化音频输出 (例如 DAC 或 PWM)
    // ... (具体音频初始化代码) ...
    printf("Audio HAL initialized.\r\n");
    return HAL_AUDIO_OK;
}

HAL_AUDIO_StatusTypeDef hal_audio_set_volume(uint8_t volume) {
    // 设置音频输出音量 (例如控制 DAC 或 PWM 占空比)
    // volume 范围 0-100
    // ... (具体音量设置代码) ...
    printf("Audio HAL set volume: %d.\r\n", volume);
    return HAL_AUDIO_OK;
}


// *** Timer HAL (简化的延时函数) ***
void hal_delay_ms(uint32_t ms) {
    // 简单的软件延时，实际项目应使用硬件定时器或操作系统的延时函数
    // ... (简单的延时循环) ...
    volatile uint32_t count;
    for (count = 0; count < ms * 1000; count++) { // 粗略延时，实际需要精确校准
        __asm("nop"); // 简单指令，消耗时间
    }
    printf("Delay %lu ms.\r\n", ms);
}

2. 驱动层 (Driver Layer)

接下来，实现驱动层。首先是 RDA5807 驱动 rda5807_driver.h 头文件。

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
// rda5807_driver.h
#ifndef _RDA5807_DRIVER_H_
#define _RDA5807_DRIVER_H_

#include <stdint.h>
#include <stdbool.h>
#include "hal.h"

// RDA5807 寄存器地址 (部分常用寄存器)
#define RDA5807_REG_CHIPID        0x00 // Chip ID & Version Information
#define RDA5807_REG_CTRL          0x02 // Control Register
#define RDA5807_REG_TUNE_STATUS    0x03 // Tune/Status Register
#define RDA5807_REG_RADIO_DATA_SYSTEM_MODE_CONTROL 0x04 // RDS Control Register
#define RDA5807_REG_RADIO_DATA_SYSTEM_BLOCK_A 0x05 // RDS Block A
#define RDA5807_REG_RADIO_DATA_SYSTEM_BLOCK_B 0x06 // RDS Block B
#define RDA5807_REG_RADIO_DATA_SYSTEM_BLOCK_C 0x07 // RDS Block C
#define RDA5807_REG_RADIO_DATA_SYSTEM_BLOCK_D 0x08 // RDS Block D
#define RDA5807_REG_READ_CHANNEL    0x0A // Read Channel Register
#define RDA5807_REG_RSSI           0x0B // RSSI & Stereo Indicator
#define RDA5807_REG_VOLUME_CONTROL  0x05 // Volume Control (与 RDS Block A 地址冲突，实际使用时需注意)
#define RDA5807_REG_AUDIO_CONTROL   0x0A // Audio Control (与 Read Channel 地址冲突，实际使用时需注意)

// RDA5807 设备 I2C 地址 (通常是 0x11 或 0x10，需要根据实际硬件确定)
#define RDA5807_I2C_ADDR  0x11

typedef enum {
    RDA5807_OK,
    RDA5807_ERROR
} RDA5807_StatusTypeDef;

// RDA5807 初始化
RDA5807_StatusTypeDef rda5807_init(void);

// 设置频率 (单位 kHz)
RDA5807_StatusTypeDef rda5807_set_frequency(uint16_t frequency_khz);

// 获取当前频率 (单位 kHz)
uint16_t rda5807_get_frequency(void);

// 设置音量 (0-15, 0 静音, 15 最大音量)
RDA5807_StatusTypeDef rda5807_set_volume(uint8_t volume);

// 音量增大
RDA5807_StatusTypeDef rda5807_volume_up(void);

// 音量减小
RDA5807_StatusTypeDef rda5807_volume_down(void);

// 静音
RDA5807_StatusTypeDef rda5807_mute(void);

// 取消静音
RDA5807_StatusTypeDef rda5807_unmute(void);

// 自动搜台 (向上搜)
RDA5807_StatusTypeDef rda5807_seek_up(void);

// 自动搜台 (向下搜)
RDA5807_StatusTypeDef rda5807_seek_down(void);

// 获取 RSSI (接收信号强度指示)
uint8_t rda5807_get_rssi(void);

// 获取立体声状态
bool rda5807_is_stereo(void);

#endif // _RDA5807_DRIVER_H_

然后是 RDA5807 驱动的实现文件 rda5807_driver.c。

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
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
// rda5807_driver.c
#include "rda5807_driver.h"
#include "hal.h"
#include <stdio.h> // For printf (调试用)

static uint16_t current_frequency_khz = 87500; // 默认频率 87.5MHz
static uint8_t current_volume = 5; // 默认音量

// RDA5807 初始化
RDA5807_StatusTypeDef rda5807_init(void) {
    uint16_t chip_id = 0;

    // 复位 RDA5807 (如果需要，根据硬件连接方式实现复位)
    // ... (复位代码，例如 GPIO 控制复位引脚) ...

    hal_delay_ms(100); // 延时等待芯片稳定

    // 读取 Chip ID 寄存器，验证芯片是否正常工作
    uint8_t reg_data[2];
    if (hal_i2c_read_bytes(RDA5807_I2C_ADDR, RDA5807_REG_CHIPID, reg_data, 2) != HAL_I2C_OK) {
        printf("RDA5807 I2C read error.\r\n");
        return RDA5807_ERROR;
    }
    chip_id = (reg_data[0] << 8) | reg_data[1];
    printf("RDA5807 Chip ID: 0x%04X\r\n", chip_id);

    if ((chip_id & 0xFFF0) != 0x5800) { // 验证 Chip ID 高12位是否为 0x580
        printf("RDA5807 Chip ID verification failed.\r\n");
        return RDA5807_ERROR;
    }

    // 初始化控制寄存器 (CTRL)
    // 使能芯片, 使能时钟输出, 不使能静音, 正常工作模式, ... (根据需要配置)
    uint16_t ctrl_reg_value = (1 << 0) | (1 << 11); // ENABLE=1, DMUTE=1
    uint8_t ctrl_reg_bytes[2] = {(ctrl_reg_value >> 8) & 0xFF, ctrl_reg_value & 0xFF};
    if (hal_i2c_write_byte(RDA5807_I2C_ADDR, RDA5807_REG_CTRL, ctrl_reg_bytes[0]) != HAL_I2C_OK ||
        hal_i2c_write_byte(RDA5807_I2C_ADDR, RDA5807_REG_CTRL + 1, ctrl_reg_bytes[1]) != HAL_I2C_OK) {
        printf("RDA5807 CTRL register write error.\r\n");
        return RDA5807_ERROR;
    }

    // 设置默认音量
    rda5807_set_volume(current_volume);

    printf("RDA5807 driver initialized.\r\n");
    return RDA5807_OK;
}

// 设置频率 (单位 kHz)
RDA5807_StatusTypeDef rda5807_set_frequency(uint16_t frequency_khz) {
    if (frequency_khz < 87500 || frequency_khz > 108000) {
        printf("Invalid frequency: %d kHz, range: 87500-108000 kHz.\r\n", frequency_khz);
        return RDA5807_ERROR;
    }

    current_frequency_khz = frequency_khz;

    // 计算频道间隔 (通常为 100 kHz)
    uint16_t channel_spacing_khz = 100;
    // 计算频道号 (Channel = (Frequency - 87.5MHz) / Channel Spacing)
    uint16_t channel = (frequency_khz - 87500) / channel_spacing_khz;

    // 设置 Tune/Status 寄存器 (TUNE)
    uint16_t tune_reg_value = (channel << 6) | (1 << 2); // CHAN[10:0], TUNE=1
    uint8_t tune_reg_bytes[2] = {(tune_reg_value >> 8) & 0xFF, tune_reg_value & 0xFF};
    if (hal_i2c_write_byte(RDA5807_I2C_ADDR, RDA5807_REG_TUNE_STATUS, tune_reg_bytes[0]) != HAL_I2C_OK ||
        hal_i2c_write_byte(RDA5807_I2C_ADDR, RDA5807_REG_TUNE_STATUS + 1, tune_reg_bytes[1]) != HAL_I2C_OK) {
        printf("RDA5807 TUNE register write error.\r\n");
        return RDA5807_ERROR;
    }

    hal_delay_ms(50); // 等待调谐完成 (实际应用中应读取状态寄存器确认)

    printf("Set frequency to %d kHz.\r\n", frequency_khz);
    return RDA5807_OK;
}

// 获取当前频率 (单位 kHz)
uint16_t rda5807_get_frequency(void) {
    return current_frequency_khz;
}

// 设置音量 (0-15, 0 静音, 15 最大音量)
RDA5807_StatusTypeDef rda5807_set_volume(uint8_t volume) {
    if (volume > 15) {
        volume = 15;
    }
    current_volume = volume;

    // 设置 Volume Control 寄存器 (VOLUME)
    uint8_t volume_reg_value = volume & 0x0F; // VOL[3:0]
    if (hal_i2c_write_byte(RDA5807_I2C_ADDR, RDA5807_REG_VOLUME_CONTROL, volume_reg_value) != HAL_I2C_OK) {
        printf("RDA5807 VOLUME register write error.\r\n");
        return RDA5807_ERROR;
    }

    printf("Set volume to %d.\r\n", volume);
    return RDA5807_OK;
}

// 音量增大
RDA5807_StatusTypeDef rda5807_volume_up(void) {
    if (current_volume < 15) {
        current_volume++;
        rda5807_set_volume(current_volume);
    }
    return RDA5807_OK;
}

// 音量减小
RDA5807_StatusTypeDef rda5807_volume_down(void) {
    if (current_volume > 0) {
        current_volume--;
        rda5807_set_volume(current_volume);
    }
    return RDA5807_OK;
}

// 静音
RDA5807_StatusTypeDef rda5807_mute(void) {
    // 设置 Control 寄存器 (CTRL) 的 DMUTE 位为 0
    uint8_t ctrl_reg_data[2];
    if (hal_i2c_read_bytes(RDA5807_I2C_ADDR, RDA5807_REG_CTRL, ctrl_reg_data, 2) != HAL_I2C_OK) {
        printf("RDA5807 CTRL register read error.\r\n");
        return RDA5807_ERROR;
    }
    uint16_t ctrl_reg_value = (ctrl_reg_data[0] << 8) | ctrl_reg_data[1];
    ctrl_reg_value &= ~(1 << 11); // 清除 DMUTE 位
    ctrl_reg_bytes[0] = (ctrl_reg_value >> 8) & 0xFF;
    ctrl_reg_bytes[1] = ctrl_reg_value & 0xFF;
    if (hal_i2c_write_byte(RDA5807_I2C_ADDR, RDA5807_REG_CTRL, ctrl_reg_bytes[0]) != HAL_I2C_OK ||
        hal_i2c_write_byte(RDA5807_I2C_ADDR, RDA5807_REG_CTRL + 1, ctrl_reg_bytes[1]) != HAL_I2C_OK) {
        printf("RDA5807 CTRL register write error (mute).\r\n");
        return RDA5807_ERROR;
    }
    printf("Mute.\r\n");
    return RDA5807_OK;
}

// 取消静音
RDA5807_StatusTypeDef rda5807_unmute(void) {
    // 设置 Control 寄存器 (CTRL) 的 DMUTE 位为 1
    uint8_t ctrl_reg_data[2];
    if (hal_i2c_read_bytes(RDA5807_I2C_ADDR, RDA5807_REG_CTRL, ctrl_reg_data, 2) != HAL_I2C_OK) {
        printf("RDA5807 CTRL register read error.\r\n");
        return RDA5807_ERROR;
    }
    uint16_t ctrl_reg_value = (ctrl_reg_data[0] << 8) | ctrl_reg_data[1];
    ctrl_reg_value |= (1 << 11); // 设置 DMUTE 位
    ctrl_reg_bytes[0] = (ctrl_reg_value >> 8) & 0xFF;
    ctrl_reg_bytes[1] = ctrl_reg_value & 0xFF;
    if (hal_i2c_write_byte(RDA5807_I2C_ADDR, RDA5807_REG_CTRL, ctrl_reg_bytes[0]) != HAL_I2C_OK ||
        hal_i2c_write_byte(RDA5807_I2C_ADDR, RDA5807_REG_CTRL + 1, ctrl_reg_bytes[1]) != HAL_I2C_OK) {
        printf("RDA5807 CTRL register write error (unmute).\r\n");
        return RDA5807_ERROR;
    }
    printf("Unmute.\r\n");
    return RDA5807_OK;
}

// 自动搜台 (向上搜)
RDA5807_StatusTypeDef rda5807_seek_up(void) {
    // 设置 Tune/Status 寄存器 (TUNE) 的 SEEK 位和 SEEKUP 位
    uint16_t tune_reg_value = (1 << 5) | (1 << 4); // SEEK=1, SEEKUP=1
    uint8_t tune_reg_bytes[2] = {(tune_reg_value >> 8) & 0xFF, tune_reg_value & 0xFF};
    if (hal_i2c_write_byte(RDA5807_I2C_ADDR, RDA5807_REG_TUNE_STATUS, tune_reg_bytes[0]) != HAL_I2C_OK ||
        hal_i2c_write_byte(RDA5807_I2C_ADDR, RDA5807_REG_TUNE_STATUS + 1, tune_reg_bytes[1]) != HAL_I2C_OK) {
        printf("RDA5807 TUNE register write error (seek up).\r\n");
        return RDA5807_ERROR;
    }

    hal_delay_ms(100); // 等待搜台完成 (实际应用中应读取状态寄存器确认)

    // 读取当前频率
    uint8_t read_channel_reg_data[2];
    if (hal_i2c_read_bytes(RDA5807_I2C_ADDR, RDA5807_REG_READ_CHANNEL, read_channel_reg_data, 2) != HAL_I2C_OK) {
        printf("RDA5807 READ_CHANNEL register read error.\r\n");
        return RDA5807_ERROR;
    }
    uint16_t channel = ((read_channel_reg_data[0] & 0x03) << 8) | read_channel_reg_data[1];
    current_frequency_khz = 87500 + channel * 100; // 重新计算频率

    printf("Seek up, found station at %d kHz.\r\n", current_frequency_khz);
    return RDA5807_OK;
}

// 自动搜台 (向下搜)
RDA5807_StatusTypeDef rda5807_seek_down(void) {
    // 设置 Tune/Status 寄存器 (TUNE) 的 SEEK 位，SEEKUP 位为 0 (默认向下搜)
    uint16_t tune_reg_value = (1 << 5) ; // SEEK=1, SEEKUP=0
    uint8_t tune_reg_bytes[2] = {(tune_reg_value >> 8) & 0xFF, tune_reg_value & 0xFF};
    if (hal_i2c_write_byte(RDA5807_I2C_ADDR, RDA5807_REG_TUNE_STATUS, tune_reg_bytes[0]) != HAL_I2C_OK ||
        hal_i2c_write_byte(RDA5807_I2C_ADDR, RDA5807_REG_TUNE_STATUS + 1, tune_reg_bytes[1]) != HAL_I2C_OK) {
        printf("RDA5807 TUNE register write error (seek down).\r\n");
        return RDA5807_ERROR;
    }

    hal_delay_ms(100); // 等待搜台完成 (实际应用中应读取状态寄存器确认)

    // 读取当前频率
    uint8_t read_channel_reg_data[2];
    if (hal_i2c_read_bytes(RDA5807_I2C_ADDR, RDA5807_REG_READ_CHANNEL, read_channel_reg_data, 2) != HAL_I2C_OK) {
        printf("RDA5807 READ_CHANNEL register read error.\r\n");
        return RDA5807_ERROR;
    }
    uint16_t channel = ((read_channel_reg_data[0] & 0x03) << 8) | read_channel_reg_data[1];
    current_frequency_khz = 87500 + channel * 100; // 重新计算频率

    printf("Seek down, found station at %d kHz.\r\n", current_frequency_khz);
    return RDA5807_OK;
}

// 获取 RSSI (接收信号强度指示)
uint8_t rda5807_get_rssi(void) {
    uint8_t rssi_reg_data;
    if (hal_i2c_read_bytes(RDA5807_I2C_ADDR, RDA5807_REG_RSSI, &rssi_reg_data, 1) != HAL_I2C_OK) {
        printf("RDA5807 RSSI register read error.\r\n");
        return 0; // 返回 0 表示错误或无信号
    }
    return rssi_reg_data & 0x3F; // RSSI[5:0]
}

// 获取立体声状态
bool rda5807_is_stereo(void) {
    uint8_t rssi_reg_data;
    if (hal_i2c_read_bytes(RDA5807_I2C_ADDR, RDA5807_REG_RSSI, &rssi_reg_data, 1) != HAL_I2C_OK) {
        printf("RDA5807 RSSI register read error (stereo).\r\n");
        return false; // 返回 false 表示错误或非立体声
    }
    return (rssi_reg_data & (1 << 7)) != 0; // STERO 指示位
}

接下来是按键驱动 button_driver.h 和 button_driver.c。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// button_driver.h
#ifndef _BUTTON_DRIVER_H_
#define _BUTTON_DRIVER_H_

#include <stdint.h>
#include <stdbool.h>
#include "hal.h"

typedef enum {
    BUTTON_POWER,
    BUTTON_SEEK_UP,
    BUTTON_SEEK_DOWN,
    BUTTON_VOL_UP,
    BUTTON_VOL_DOWN,
    BUTTON_NONE // 无按键事件
} ButtonEventTypeDef;

// 初始化按键驱动
void button_driver_init(void);

// 获取按键事件
ButtonEventTypeDef button_driver_get_event(void);

#endif // _BUTTON_DRIVER_H_
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
// button_driver.c
#include "button_driver.h"
#include "hal.h"
#include <stdio.h> // For printf (调试用)

// 定义按键 GPIO 引脚 (与 hal.c 中定义的宏对应)
#define BUTTON_PIN_POWER     GPIO_PIN_POWER
#define BUTTON_PIN_SEEK_UP   GPIO_PIN_SEEK_UP
#define BUTTON_PIN_SEEK_DOWN GPIO_PIN_SEEK_DOWN
#define BUTTON_PIN_VOL_UP    GPIO_PIN_VOL_UP
#define BUTTON_PIN_VOL_DOWN  GPIO_PIN_VOL_DOWN

// 按键消抖延时 (ms)
#define BUTTON_DEBOUNCE_DELAY_MS  50

void button_driver_init(void) {
    // 初始化按键 GPIO 引脚为输入模式，并使能上拉/下拉电阻 (根据硬件设计选择)
    hal_gpio_init(BUTTON_PIN_POWER, HAL_GPIO_MODE_INPUT);
    hal_gpio_init(BUTTON_PIN_SEEK_UP, HAL_GPIO_MODE_INPUT);
    hal_gpio_init(BUTTON_PIN_SEEK_DOWN, HAL_GPIO_MODE_INPUT);
    hal_gpio_init(BUTTON_PIN_VOL_UP, HAL_GPIO_MODE_INPUT);
    hal_gpio_init(BUTTON_PIN_VOL_DOWN, HAL_GPIO_MODE_INPUT);

    printf("Button driver initialized.\r\n");
}

ButtonEventTypeDef button_driver_get_event(void) {
    static HAL_GPIO_PinStateTypeDef last_button_state[5] = {HAL_GPIO_PIN_SET, HAL_GPIO_PIN_SET, HAL_GPIO_PIN_SET, HAL_GPIO_PIN_SET, HAL_GPIO_PIN_SET}; // 假设默认按键未按下时为高电平
    static ButtonEventTypeDef last_event = BUTTON_NONE;

    ButtonEventTypeDef current_event = BUTTON_NONE;

    // 检测 POWER 按键
    HAL_GPIO_PinStateTypeDef power_button_state = hal_gpio_read_pin(BUTTON_PIN_POWER);
    if (power_button_state == HAL_GPIO_PIN_RESET && last_button_state[0] == HAL_GPIO_PIN_SET) { // 按键按下 (低电平有效)
        hal_delay_ms(BUTTON_DEBOUNCE_DELAY_MS); // 消抖延时
        if (hal_gpio_read_pin(BUTTON_PIN_POWER) == HAL_GPIO_PIN_RESET) { // 再次确认按键按下
            current_event = BUTTON_POWER;
        }
    }
    last_button_state[0] = power_button_state;

    // 检测 SEEK_UP 按键
    HAL_GPIO_PinStateTypeDef seek_up_button_state = hal_gpio_read_pin(BUTTON_PIN_SEEK_UP);
    if (seek_up_button_state == HAL_GPIO_PIN_RESET && last_button_state[1] == HAL_GPIO_PIN_SET) {
        hal_delay_ms(BUTTON_DEBOUNCE_DELAY_MS);
        if (hal_gpio_read_pin(BUTTON_PIN_SEEK_UP) == HAL_GPIO_PIN_RESET) {
            current_event = BUTTON_SEEK_UP;
        }
    }
    last_button_state[1] = seek_up_button_state;

    // 检测 SEEK_DOWN 按键
    HAL_GPIO_PinStateTypeDef seek_down_button_state = hal_gpio_read_pin(BUTTON_PIN_SEEK_DOWN);
    if (seek_down_button_state == HAL_GPIO_PIN_RESET && last_button_state[2] == HAL_GPIO_PIN_SET) {
        hal_delay_ms(BUTTON_DEBOUNCE_DELAY_MS);
        if (hal_gpio_read_pin(BUTTON_PIN_SEEK_DOWN) == HAL_GPIO_PIN_RESET) {
            current_event = BUTTON_SEEK_DOWN;
        }
    }
    last_button_state[2] = seek_down_button_state;

    // 检测 VOL_UP 按键
    HAL_GPIO_PinStateTypeDef vol_up_button_state = hal_gpio_read_pin(BUTTON_PIN_VOL_UP);
    if (vol_up_button_state == HAL_GPIO_PIN_RESET && last_button_state[3] == HAL_GPIO_PIN_SET) {
        hal_delay_ms(BUTTON_DEBOUNCE_DELAY_MS);
        if (hal_gpio_read_pin(BUTTON_PIN_VOL_UP) == HAL_GPIO_PIN_RESET) {
            current_event = BUTTON_VOL_UP;
        }
    }
    last_button_state[3] = vol_up_button_state;

    // 检测 VOL_DOWN 按键
    HAL_GPIO_PinStateTypeDef vol_down_button_state = hal_gpio_read_pin(BUTTON_PIN_VOL_DOWN);
    if (vol_down_button_state == HAL_GPIO_PIN_RESET && last_button_state[4] == HAL_GPIO_PIN_SET) {
        hal_delay_ms(BUTTON_DEBOUNCE_DELAY_MS);
        if (hal_gpio_read_pin(BUTTON_PIN_VOL_DOWN) == HAL_GPIO_PIN_RESET) {
            current_event = BUTTON_VOL_DOWN;
        }
    }
    last_button_state[4] = vol_down_button_state;

    if (current_event != BUTTON_NONE) {
        last_event = current_event;
        printf("Button event: %d\r\n", current_event);
        return current_event;
    } else {
        return BUTTON_NONE;
    }
}

音频驱动 audio_driver.h 和 audio_driver.c (简化的示例)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// audio_driver.h
#ifndef _AUDIO_DRIVER_H_
#define _AUDIO_DRIVER_H_

#include <stdint.h>
#include <stdbool.h>
#include "hal.h"

typedef enum {
    AUDIO_DRIVER_OK,
    AUDIO_DRIVER_ERROR
} AudioDriverStatusTypeDef;

// 初始化音频驱动
AudioDriverStatusTypeDef audio_driver_init(void);

// 设置音量 (0-100 范围)
AudioDriverStatusTypeDef audio_driver_set_volume(uint8_t volume);

#endif // _AUDIO_DRIVER_H_
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// audio_driver.c
#include "audio_driver.h"
#include "hal.h"
#include <stdio.h> // For printf (调试用)

AudioDriverStatusTypeDef audio_driver_init(void) {
    if (hal_audio_init() != HAL_AUDIO_OK) {
        printf("Audio HAL initialization failed.\r\n");
        return AUDIO_DRIVER_ERROR;
    }
    printf("Audio driver initialized.\r\n");
    return AUDIO_DRIVER_OK;
}

AudioDriverStatusTypeDef audio_driver_set_volume(uint8_t volume) {
    if (hal_audio_set_volume(volume) != HAL_AUDIO_OK) {
        printf("Audio HAL set volume failed.\r\n");
        return AUDIO_DRIVER_ERROR;
    }
    printf("Audio driver set volume: %d.\r\n", volume);
    return AUDIO_DRIVER_OK;
}

3. 服务层 (Service Layer)

FM 收音机服务 fm_radio_service.h 和 fm_radio_service.c。

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
// fm_radio_service.h
#ifndef _FM_RADIO_SERVICE_H_
#define _FM_RADIO_SERVICE_H_

#include <stdint.h>
#include <stdbool.h>
#include "rda5807_driver.h"
#include "audio_driver.h"

typedef enum {
    FM_RADIO_SERVICE_OK,
    FM_RADIO_SERVICE_ERROR
} FMRadioServiceStatusTypeDef;

// 初始化 FM 收音机服务
FMRadioServiceStatusTypeDef fm_radio_service_init(void);

// 调谐到指定频率 (kHz)
FMRadioServiceStatusTypeDef fm_radio_service_tune_frequency(uint16_t frequency_khz);

// 获取当前频率 (kHz)
uint16_t fm_radio_service_get_current_frequency(void);

// 设置音量 (0-100 范围)
FMRadioServiceStatusTypeDef fm_radio_service_set_volume(uint8_t volume);

// 音量增大
FMRadioServiceStatusTypeDef fm_radio_service_volume_up(void);

// 音量减小
FMRadioServiceStatusTypeDef fm_radio_service_volume_down(void);

// 静音
FMRadioServiceStatusTypeDef fm_radio_service_mute(void);

// 取消静音
FMRadioServiceStatusTypeDef fm_radio_service_unmute(void);

// 搜台 (向上)
FMRadioServiceStatusTypeDef fm_radio_service_seek_up(void);

// 搜台 (向下)
FMRadioServiceStatusTypeDef fm_radio_service_seek_down(void);

#endif // _FM_RADIO_SERVICE_H_
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
// fm_radio_service.c
#include "fm_radio_service.h"
#include "rda5807_driver.h"
#include "audio_driver.h"
#include <stdio.h> // For printf (调试用)

// 音量范围映射 (服务层 0-100 映射到 RDA5807 驱动层 0-15)
#define MAX_SERVICE_VOLUME 100
#define MAX_DRIVER_VOLUME  15

FMRadioServiceStatusTypeDef fm_radio_service_init(void) {
    if (rda5807_init() != RDA5807_OK) {
        printf("RDA5807 driver initialization failed.\r\n");
        return FM_RADIO_SERVICE_ERROR;
    }
    if (audio_driver_init() != AUDIO_DRIVER_OK) {
        printf("Audio driver initialization failed.\r\n");
        return FM_RADIO_SERVICE_ERROR;
    }
    printf("FM radio service initialized.\r\n");
    return FM_RADIO_SERVICE_OK;
}

FMRadioServiceStatusTypeDef fm_radio_service_tune_frequency(uint16_t frequency_khz) {
    if (rda5807_set_frequency(frequency_khz) != RDA5807_OK) {
        printf("RDA5807 set frequency failed.\r\n");
        return FM_RADIO_SERVICE_ERROR;
    }
    printf("FM radio service tuned to %d kHz.\r\n", frequency_khz);
    return FM_RADIO_SERVICE_OK;
}

uint16_t fm_radio_service_get_current_frequency(void) {
    return rda5807_get_frequency();
}

FMRadioServiceStatusTypeDef fm_radio_service_set_volume(uint8_t volume) {
    if (volume > MAX_SERVICE_VOLUME) {
        volume = MAX_SERVICE_VOLUME;
    }
    uint8_t driver_volume = (uint8_t)((float)volume / MAX_SERVICE_VOLUME * MAX_DRIVER_VOLUME); // 映射音量范围
    if (audio_driver_set_volume(volume) != AUDIO_DRIVER_OK) {
        printf("Audio driver set volume failed.\r\n");
        return FM_RADIO_SERVICE_ERROR;
    }
    if (rda5807_set_volume(driver_volume) != RDA5807_OK) {
        printf("RDA5807 set volume failed.\r\n");
        return FM_RADIO_SERVICE_ERROR;
    }
    printf("FM radio service set volume: %d (driver volume: %d).\r\n", volume, driver_volume);
    return FM_RADIO_SERVICE_OK;
}

FMRadioServiceStatusTypeDef fm_radio_service_volume_up(void) {
    // 服务层音量增大逻辑 (例如步进大小，边界处理等)
    static uint8_t current_volume = 50; // 默认音量
    if (current_volume < MAX_SERVICE_VOLUME) {
        current_volume += 10; // 音量步进
        if (current_volume > MAX_SERVICE_VOLUME) {
            current_volume = MAX_SERVICE_VOLUME;
        }
        fm_radio_service_set_volume(current_volume);
    }
    return FM_RADIO_SERVICE_OK;
}

FMRadioServiceStatusTypeDef fm_radio_service_volume_down(void) {
    // 服务层音量减小逻辑
    static uint8_t current_volume = 50; // 默认音量
    if (current_volume > 0) {
        current_volume -= 10; // 音量步进
        if (current_volume < 0) {
            current_volume = 0;
        }
        fm_radio_service_set_volume(current_volume);
    }
    return FM_RADIO_SERVICE_OK;
}

FMRadioServiceStatusTypeDef fm_radio_service_mute(void) {
    if (rda5807_mute() != RDA5807_OK) {
        printf("RDA5807 mute failed.\r\n");
        return FM_RADIO_SERVICE_ERROR;
    }
    printf("FM radio service muted.\r\n");
    return FM_RADIO_SERVICE_OK;
}

FMRadioServiceStatusTypeDef fm_radio_service_unmute(void) {
    if (rda5807_unmute() != RDA5807_OK) {
        printf("RDA5807 unmute failed.\r\n");
        return FM_RADIO_SERVICE_ERROR;
    }
    printf("FM radio service unmuted.\r\n");
    return FM_RADIO_SERVICE_OK;
}

FMRadioServiceStatusTypeDef fm_radio_service_seek_up(void) {
    if (rda5807_seek_up() != RDA5807_OK) {
        printf("RDA5807 seek up failed.\r\n");
        return FM_RADIO_SERVICE_ERROR;
    }
    uint16_t frequency = rda5807_get_frequency();
    printf("FM radio service seek up, found station at %d kHz.\r\n", frequency);
    return FM_RADIO_SERVICE_OK;
}

FMRadioServiceStatusTypeDef fm_radio_service_seek_down(void) {
    if (rda5807_seek_down() != RDA5807_OK) {
        printf("RDA5807 seek down failed.\r\n");
        return FM_RADIO_SERVICE_ERROR;
    }
    uint16_t frequency = rda5807_get_frequency();
    printf("FM radio service seek down, found station at %d kHz.\r\n", frequency);
    return FM_RADIO_SERVICE_OK;
}

4. 应用层 (Application Layer)

主应用程序 main.c。

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
// main.c
#include "hal.h"
#include "button_driver.h"
#include "fm_radio_service.h"
#include <stdio.h> // For printf (调试用)

int main() {
    printf("Starting FM Radio Application...\r\n");

    // 初始化 HAL 层
    hal_i2c_init();
    // GPIO HAL 初始化在 button_driver 中完成
    hal_audio_init();

    // 初始化驱动层
    button_driver_init();
    audio_driver_init(); // 再次初始化，确保顺序正确

    // 初始化服务层
    if (fm_radio_service_init() != FM_RADIO_SERVICE_OK) {
        printf("FM Radio Service initialization failed. Application exiting.\r\n");
        return -1;
    }

    // 设置初始频率和音量
    fm_radio_service_tune_frequency(98800); // 调谐到 98.8 MHz
    fm_radio_service_set_volume(50); // 设置音量为 50%

    printf("FM Radio initialized and running.\r\n");

    // 主循环
    while (1) {
        ButtonEventTypeDef event = button_driver_get_event();

        switch (event) {
            case BUTTON_POWER:
                printf("Power button pressed (功能未实现).\r\n");
                // 在实际项目中，这里可以实现电源开关功能
                break;
            case BUTTON_SEEK_UP:
                printf("Seek Up button pressed.\r\n");
                fm_radio_service_seek_up();
                break;
            case BUTTON_SEEK_DOWN:
                printf("Seek Down button pressed.\r\n");
                fm_radio_service_seek_down();
                break;
            case BUTTON_VOL_UP:
                printf("Volume Up button pressed.\r\n");
                fm_radio_service_volume_up();
                break;
            case BUTTON_VOL_DOWN:
                printf("Volume Down button pressed.\r\n");
                fm_radio_service_volume_down();
                break;
            case BUTTON_NONE:
                // 无按键事件，可以执行其他后台任务，例如显示频率等 (这里简化处理)
                break;
            default:
                break;
        }

        hal_delay_ms(10); // 适当延时，降低 CPU 占用
    }

    return 0;
}

代码编译和运行

将上述代码文件 (hal.h, hal.c, rda5807_driver.h, rda5807_driver.c, button_driver.h, button_driver.c, audio_driver.h, audio_driver.c, fm_radio_service.h, fm_radio_service.c, main.c) 放到同一个目录下，使用C编译器 (例如 GCC for ARM Cortex-M 系列 MCU) 进行编译。编译时需要根据实际的硬件平台配置编译选项，例如指定目标架构、包含路径、链接库等。

编译成功后，将生成的可执行文件烧录到嵌入式设备的MCU中。连接好硬件电路 (RDA5807芯片、按键、音频输出等)，上电运行程序。

测试验证

完成代码编写和编译后，需要进行全面的测试验证，确保系统的功能和性能符合需求。

  1. 单元测试: 针对每个模块 (例如 RDA5807 驱动、按键驱动、FM 服务等) 编写单元测试用例，验证模块的功能是否正确。可以使用模拟硬件环境或在实际硬件上进行单元测试。
  2. 集成测试: 将各个模块组合起来进行集成测试，验证模块之间的接口和协作是否正常。例如，测试按键输入是否能够正确触发 FM 服务的功能，音频输出是否正常等。
  3. 系统测试: 在完整的硬件系统上进行系统测试，验证整个FM收音机系统的功能和性能。测试内容包括：
    • 频率接收: 验证是否能够接收FM广播信号，手动和自动搜台功能是否正常。
    • 音量控制: 验证音量调节和静音功能是否正常。
    • 音频输出: 验证音频输出质量是否良好，是否有噪声或失真。
    • 稳定性测试: 长时间运行测试，验证系统是否稳定可靠，不会崩溃或出现异常。
    • 功耗测试: 如果项目有功耗要求，需要进行功耗测试，验证是否满足低功耗设计目标。
  4. 用户体验测试: 邀请用户试用FM收音机，收集用户反馈，根据用户反馈改进产品。

维护升级

嵌入式软件的维护升级是一个持续的过程。在项目完成后，还需要进行维护和升级，以修复Bug、添加新功能、优化性能等。

  1. Bug修复: 及时修复用户反馈的Bug，发布软件更新版本。
  2. 功能升级: 根据用户需求或市场变化，添加新的功能，例如 RDS 解码、电台预设、音频均衡器等。
  3. 性能优化: 持续优化软件性能，例如提高搜台速度、降低功耗、优化音频处理算法等。
  4. 安全更新: 如果软件涉及到网络功能或数据安全，需要及时进行安全更新，修复安全漏洞。
  5. 版本管理: 使用版本管理工具 (例如 Git) 管理代码，方便代码维护和版本控制。
  6. 文档维护: 及时更新软件文档，包括用户手册、开发文档、API 文档等，方便用户使用和二次开发。

总结

通过上述分层架构的代码设计和详细的代码实现，我们建立了一个基于RDA5807芯片的可靠、高效且可扩展的FM收音机系统平台。这种分层架构使得代码模块化、易于维护和升级。在实际项目开发中，还需要根据具体的硬件平台和需求进行调整和完善。例如，可以添加显示屏驱动，实现频率和电台名称显示；可以扩展FM服务层，添加电台预设、RDS解码等功能；可以优化音频驱动层，提高音频输出质量。

希望这份详细的解答和代码示例能够帮助您理解嵌入式系统开发流程和代码设计架构。如果您有任何疑问或需要进一步的帮助，请随时提出。

欢迎关注我的其它发布渠道