编程技术分享

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

0%

简介：通过ESP32-C3芯片驱动0.96寸TFT屏幕、KT0803L芯片和RDA5807M模块，实现了在58~111MHz发射与接收广播。

发表于 分类于 ， ，

好的，作为一名高级嵌入式软件开发工程师，我将为您详细阐述这个基于ESP32-C3的广播收发器项目的设计架构和C代码实现。这个项目充分展示了从需求分析到最终产品实现的完整嵌入式系统开发流程，我们将重点关注如何构建一个可靠、高效、且易于扩展的系统平台。
关注微信公众号，提前获取相关推文

1. 需求分析与系统设计

1.1 项目目标

本项目旨在设计并实现一个基于ESP32-C3芯片的广播收发器。该设备能够接收和发射FM广播信号，频率范围覆盖58MHz至111MHz。用户可以通过0.96寸TFT屏幕进行交互，并使用KT0803L芯片进行FM发射，RDA5807M模块进行FM接收。

1.2 功能需求

  • FM接收功能:
    • 支持58MHz-111MHz频段的FM广播接收。
    • 自动频率扫描，搜索可用电台。
    • 手动频率微调。
    • 音量调节。
    • 静音功能。
    • 电台信号强度指示（可选，基于RDA5807M模块的RSSI）。
    • 支持立体声/单声道切换（RDA5807M模块支持）。
    • 电台列表存储与加载（可选，可以使用SPI Flash）。
  • FM发射功能:
    • 支持58MHz-111MHz频段的FM广播发射。
    • 频率设置。
    • 音频输入源选择（例如，麦克风输入）。
    • 发射功率调节（KT0803L模块支持，但需考虑法规限制）。
    • 调制模式选择（KT0803L模块支持）。
    • 音频预加重/去加重（KT0803L模块支持）。
  • 用户界面:
    • 0.96寸TFT屏幕显示系统状态、频率信息、电台列表、音量等。
    • 按键输入，用于频率调节、模式切换、菜单导航、音量控制等。
    • 直观友好的用户操作界面。
  • 系统配置与维护:
    • 固件在线升级（OTA，Over-The-Air）能力，方便后期维护和功能扩展。
    • 系统日志输出，便于调试和故障排查。

1.3 非功能需求

  • 可靠性: 系统应稳定可靠运行，避免死机、崩溃等问题。
  • 高效性: 代码运行效率高，资源占用低，保证实时性响应。
  • 可扩展性: 系统架构应易于扩展，方便添加新功能或支持新的硬件模块。
  • 易维护性: 代码结构清晰，注释完善，方便后期维护和升级。
  • 低功耗: 考虑到嵌入式设备的功耗敏感性，应尽量降低系统功耗。
  • 实时性: 音频处理和UI刷新应具有良好的实时性，避免卡顿。

1.4 硬件选型与连接

  • 主控芯片: ESP32-C3 (RISC-V 32位单核处理器, Wi-Fi & Bluetooth LE 5)。
  • TFT屏幕: 0.96寸 SPI接口彩色TFT LCD (例如 ST7735驱动芯片)。
  • FM发射芯片: KT0803L (I2C接口，支持FM发射)。
  • FM接收模块: RDA5807M (I2C接口，支持FM接收)。
  • 音频放大器: (可选，根据音频输出需求选择，例如 PAM8403)。
  • 按键: 多个GPIO连接的按键，用于用户输入。
  • 电源: USB供电或电池供电。
  • 天线: SMA接口天线，用于FM接收和发射。

硬件连接示意 (简略):

  • ESP32-C3 <-> TFT屏幕: SPI接口 (MOSI, MISO, CLK, CS, DC, RST, BL)。
  • ESP32-C3 <-> KT0803L: I2C接口 (SDA, SCL), GPIO (EN, INT)。
  • ESP32-C3 <-> RDA5807M: I2C接口 (SDA, SCL), GPIO (EN, RST, INT)。
  • ESP32-C3 <-> 按键: GPIO接口。
  • ESP32-C3 <-> 音频放大器 (可选): I2S或模拟音频输出 (根据ESP32-C3和放大器接口选择)。
  • KT0803L -> 天线: 射频输出。
  • RDA5807M -> 天线: 射频输入。
  • RDA5807M -> 音频放大器 (可选) 或 耳机接口: 音频输出。

2. 代码设计架构

为了满足可靠性、高效性、可扩展性和易维护性的需求，我们采用分层架构和模块化设计的思想来构建软件系统。同时，考虑到ESP32-C3的实时性和多任务处理能力，我们将使用FreeRTOS实时操作系统来管理任务和资源。

2.1 软件架构层级

我们的系统软件架构可以分为以下几个层次：

  • 硬件抽象层 (HAL - Hardware Abstraction Layer):
    • 封装底层硬件操作，提供统一的API接口给上层使用。
    • 主要包括GPIO驱动、SPI驱动、I2C驱动、定时器驱动、中断管理等。
    • 目标是屏蔽硬件差异，提高代码的可移植性。
  • 设备驱动层 (Device Drivers):
    • 基于HAL层，针对具体的硬件设备编写驱动程序。
    • 包括TFT屏幕驱动、KT0803L驱动、RDA5807M驱动、按键驱动等。
    • 负责设备的初始化、配置、数据读写等操作。
  • 中间件层 (Middleware):
    • 提供一些通用的软件组件和服务，简化应用开发。
    • 例如，UI组件库 (按钮、文本框、菜单等)、音频处理库 (可选，如果需要复杂音频处理)、文件系统 (可选，如果需要存储电台列表) 等。
  • 应用逻辑层 (Application Logic):
    • 实现系统的核心业务逻辑，即广播收发器的功能。
    • 包括FM接收模块、FM发射模块、频率扫描模块、音量控制模块、电台管理模块、模式切换模块等。
    • 使用状态机或事件驱动的方式管理系统状态和流程。
  • 用户界面层 (UI Layer):
    • 负责用户交互，处理用户输入，更新屏幕显示。
    • 包括UI界面设计、按键事件处理、屏幕刷新等。
    • 可以使用简单的状态机来管理UI界面切换。

2.2 模块划分

根据上述分层架构，我们将系统划分为以下模块：

  • hal 模块: 包含HAL层代码，例如 hal_gpio.c/h, hal_spi.c/h, hal_i2c.c/h, hal_timer.c/h, hal_interrupt.c/h 等。
  • drivers 模块: 包含设备驱动层代码，例如 tft_driver.c/h, kt0803l_driver.c/h, rda5807m_driver.c/h, button_driver.c/h 等。
  • middleware 模块: 包含中间件层代码 (本项目中可能比较简单，例如可以包含一个简单的UI库 ui_lib.c/h)。
  • app 模块: 包含应用逻辑层代码，例如 fm_receiver.c/h, fm_transmitter.c/h, frequency_scanner.c/h, volume_control.c/h, station_manager.c/h, mode_manager.c/h 等。
  • ui 模块: 包含用户界面层代码，例如 ui_manager.c/h, display_manager.c/h, input_manager.c/h 等。
  • main 模块: 包含 main.c 文件，负责系统初始化、FreeRTOS任务创建、系统启动等。

2.3 FreeRTOS 任务设计

为了实现系统的并发性和实时性，我们将使用FreeRTOS创建多个任务来分别负责不同的功能模块。例如：

  • UI任务 (UI Task): 负责用户界面刷新、按键事件处理。
  • 接收任务 (Receiver Task): 负责FM接收、音频解码、音量控制。
  • 发射任务 (Transmitter Task): 负责FM发射、音频编码、频率设置。
  • 扫描任务 (Scanner Task): 负责频率扫描和电台搜索。
  • 系统任务 (System Task): 负责系统监控、日志输出、OTA升级等 (可选)。

任务之间通过FreeRTOS提供的队列、信号量等机制进行通信和同步。

3. 具体C代码实现 (部分示例代码，完整代码超过3000行)

由于代码量较大，这里只提供核心模块的示例代码，展示代码结构和关键功能实现。完整的代码实现需要包括所有模块的详细代码，并进行充分的测试和调试。

3.1 HAL层代码示例 (hal_gpio.h & hal_gpio.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
// hal_gpio.h
#ifndef HAL_GPIO_H
#define HAL_GPIO_H

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

typedef enum {
    GPIO_MODE_INPUT,
    GPIO_MODE_OUTPUT
} gpio_mode_t;

typedef enum {
    GPIO_PULLUP_DISABLE,
    GPIO_PULLUP_ENABLE,
    GPIO_PULLDOWN_DISABLE,
    GPIO_PULLDOWN_ENABLE
} gpio_pull_mode_t;

void hal_gpio_init(int gpio_pin, gpio_mode_t mode, gpio_pull_mode_t pull_mode);
void hal_gpio_set_level(int gpio_pin, bool level);
bool hal_gpio_get_level(int gpio_pin);
void hal_gpio_toggle_level(int gpio_pin);

#endif // HAL_GPIO_H

// hal_gpio.c
#include "hal_gpio.h"
#include "driver/gpio.h" // ESP-IDF GPIO driver

void hal_gpio_init(int gpio_pin, gpio_mode_t mode, gpio_pull_mode_t pull_mode) {
    gpio_config_t io_conf;
    io_conf.intr_type = GPIO_INTR_DISABLE;
    io_conf.pin_bit_mask = (1ULL << gpio_pin);
    io_conf.mode = (mode == GPIO_MODE_OUTPUT) ? GPIO_MODE_OUTPUT : GPIO_MODE_INPUT;
    io_conf.pull_down_en = (pull_mode == GPIO_PULLDOWN_ENABLE);
    io_conf.pull_up_en = (pull_mode == GPIO_PULLUP_ENABLE);
    gpio_config(&io_conf);
}

void hal_gpio_set_level(int gpio_pin, bool level) {
    gpio_set_level(gpio_pin, level);
}

bool hal_gpio_get_level(int gpio_pin) {
    return gpio_get_level(gpio_pin);
}

void hal_gpio_toggle_level(int gpio_pin) {
    gpio_set_level(gpio_pin, !gpio_get_level(gpio_pin));
}

3.2 设备驱动层代码示例 (tft_driver.h & tft_driver.c, 简化的ST7735驱动)

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
// tft_driver.h
#ifndef TFT_DRIVER_H
#define TFT_DRIVER_H

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

#define TFT_WIDTH  128
#define TFT_HEIGHT 160

// 定义颜色宏
#define TFT_COLOR_BLACK       0x0000
#define TFT_COLOR_WHITE       0xFFFF
#define TFT_COLOR_RED         0xF800
#define TFT_COLOR_GREEN       0x07E0
#define TFT_COLOR_BLUE        0x001F
#define TFT_COLOR_YELLOW      0xFFE0

void tft_init(void);
void tft_set_rotation(uint8_t rotation);
void tft_fill_screen(uint16_t color);
void tft_draw_pixel(int16_t x, int16_t y, uint16_t color);
void tft_draw_line(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t color);
void tft_draw_rect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
void tft_fill_rect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color);
void tft_draw_char(char c, int16_t x, int16_t y, uint16_t color, uint16_t bgcolor, uint8_t size);
void tft_draw_string(char *str, int16_t x, int16_t y, uint16_t color, uint16_t bgcolor, uint8_t size);
void tft_set_cursor(int16_t x, int16_t y);
void tft_print(char *str); // 简化打印函数

#endif // TFT_DRIVER_H

// tft_driver.c (部分代码)
#include "tft_driver.h"
#include "hal_spi.h"
#include "hal_gpio.h"
#include "delay.h" // 需要实现一个简单的延时函数

#define TFT_RST_PIN   /* 定义 TFT RST 引脚 */
#define TFT_DC_PIN    /* 定义 TFT DC 引脚 */
#define TFT_CS_PIN    /* 定义 TFT CS 引脚 */
#define TFT_BL_PIN    /* 定义 TFT 背光引脚 (可选) */

// ST7735 命令
#define ST7735_NOP     0x00
#define ST7735_SWRESET 0x01
// ... 其他ST7735命令定义 ...

static void tft_write_command(uint8_t cmd) {
    hal_gpio_set_level(TFT_DC_PIN, 0); // DC 低电平表示命令
    hal_gpio_set_level(TFT_CS_PIN, 0); // CS 片选
    hal_spi_transfer(cmd);            // SPI 发送命令
    hal_gpio_set_level(TFT_CS_PIN, 1); // CS 取消片选
}

static void tft_write_data(uint8_t data) {
    hal_gpio_set_level(TFT_DC_PIN, 1); // DC 高电平表示数据
    hal_gpio_set_level(TFT_CS_PIN, 0); // CS 片选
    hal_spi_transfer(data);           // SPI 发送数据
    hal_gpio_set_level(TFT_CS_PIN, 1); // CS 取消片选
}

static void tft_write_data16(uint16_t data) {
    uint8_t data_h = (data >> 8) & 0xFF;
    uint8_t data_l = data & 0xFF;
    tft_write_data(data_h);
    tft_write_data(data_l);
}

void tft_init(void) {
    hal_gpio_init(TFT_RST_PIN, GPIO_MODE_OUTPUT, GPIO_PULLUP_DISABLE);
    hal_gpio_init(TFT_DC_PIN, GPIO_MODE_OUTPUT, GPIO_PULLUP_DISABLE);
    hal_gpio_init(TFT_CS_PIN, GPIO_MODE_OUTPUT, GPIO_PULLUP_DISABLE);
    // hal_gpio_init(TFT_BL_PIN, GPIO_MODE_OUTPUT, GPIO_PULLUP_DISABLE); // 可选背光引脚

    hal_spi_init(/* SPI 初始化参数 */);

    hal_gpio_set_level(TFT_RST_PIN, 1);
    delay_ms(5);
    hal_gpio_set_level(TFT_RST_PIN, 0);
    delay_ms(20);
    hal_gpio_set_level(TFT_RST_PIN, 1);
    delay_ms(150);

    // 发送 ST7735 初始化命令序列 (根据具体屏幕型号和驱动IC手册配置)
    tft_write_command(ST7735_SWRESET); // 软件复位
    delay_ms(150);
    tft_write_command(ST7735_SLPOUT);  // 退出睡眠模式
    delay_ms(50);
    tft_write_command(ST7735_COLMOD);  // 设置颜色模式
    tft_write_data(0x05);            // 16-bit color
    delay_ms(10);
    // ... 其他初始化命令 ...
    tft_write_command(ST7735_NORON);   // 正常显示模式
    delay_ms(10);
    tft_write_command(ST7735_DISPON);   // 显示开启
    delay_ms(50);

    tft_fill_screen(TFT_COLOR_BLACK); // 清屏黑色
    // hal_gpio_set_level(TFT_BL_PIN, 1); // 开启背光 (可选)
}

void tft_fill_screen(uint16_t color) {
    tft_fill_rect(0, 0, TFT_WIDTH, TFT_HEIGHT, color);
}

void tft_fill_rect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color) {
    // ... 设置窗口地址 ...
    tft_write_command(ST7735_RAMWR); // 写RAM命令
    for(int i=0; i < w * h; i++) {
        tft_write_data16(color);
    }
}

// ... 其他TFT驱动函数 (画点, 画线, 画字符, 字符串等) ...

3.3 RDA5807M 驱动代码示例 (rda5807m_driver.h & rda5807m_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
// rda5807m_driver.h
#ifndef RDA5807M_DRIVER_H
#define RDA5807M_DRIVER_H

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

typedef enum {
    RDA5807M_BAND_50_108MHZ,
    RDA5807M_BAND_65_108MHZ,
    RDA5807M_BAND_76_108MHZ,
    RDA5807M_BAND_87_108MHZ
} rda5807m_band_t;

typedef enum {
    RDA5807M_SPACE_100KHZ,
    RDA5807M_SPACE_50KHZ,
    RDA5807M_SPACE_25KHZ,
    RDA5807M_SPACE_10KHZ
} rda5807m_space_t;

void rda5807m_init(void);
bool rda5807m_set_frequency(float frequency_mhz); // 设置频率，单位MHz
float rda5807m_get_frequency(void);
bool rda5807m_set_volume(uint8_t volume); // 设置音量 (0-15)
uint8_t rda5807m_get_volume(void);
bool rda5807m_set_mute(bool mute);
bool rda5807m_is_muted(void);
bool rda5807m_seek_up(bool wrap_around); // 向上搜索电台
bool rda5807m_seek_down(bool wrap_around); // 向下搜索电台
uint8_t rda5807m_get_rssi(void); // 获取信号强度 (RSSI)
bool rda5807m_set_band(rda5807m_band_t band);
bool rda5807m_set_channel_spacing(rda5807m_space_t space);
bool rda5807m_set_stereo_mode(bool stereo);

#endif // RDA5807M_DRIVER_H

// rda5807m_driver.c (部分代码)
#include "rda5807m_driver.h"
#include "hal_i2c.h"
#include "delay.h"

#define RDA5807M_I2C_ADDR   0x11 // RDA5807M I2C 地址 (7-bit)

static uint16_t rda5807m_read_reg(uint8_t reg_addr);
static bool rda5807m_write_reg(uint8_t reg_addr, uint16_t reg_value);

void rda5807m_init(void) {
    hal_i2c_init(/* I2C 初始化参数 */);

    // 复位 RDA5807M (如果需要，可以使用RST引脚或者软件复位)
    // ...

    // 设置默认参数 (例如频段, 步进, 解加重等)
    rda5807m_set_band(RDA5807M_BAND_87_108MHZ);
    rda5807m_set_channel_spacing(RDA5807M_SPACE_100KHZ);
    rda5807m_set_volume(8); // 默认音量
    rda5807m_set_mute(false);
    rda5807m_set_stereo_mode(true);
}

bool rda5807m_set_frequency(float frequency_mhz) {
    if (frequency_mhz < 50.0 || frequency_mhz > 115.0) { // 频率范围检查
        return false;
    }
    uint16_t channel = (uint16_t)((frequency_mhz * 1000) / 10); // 计算频道值 (10kHz 步进)
    uint16_t reg02_value = (channel << 2) | (1 << 0); // CH[15:0] + TUNE 位
    return rda5807m_write_reg(0x02, reg02_value);
}

float rda5807m_get_frequency(void) {
    uint16_t reg0A_value = rda5807m_read_reg(0x0A);
    uint16_t channel = (reg0A_value >> 2) & 0x3FFF; // 提取频道值
    return (float)(channel * 10) / 1000.0; // 转换回 MHz
}

bool rda5807m_set_volume(uint8_t volume) {
    if (volume > 15) volume = 15;
    uint16_t reg05_value = rda5807m_read_reg(0x05);
    reg05_value &= ~(0xF << 0); // 清空音量位
    reg05_value |= (volume << 0); // 设置新的音量
    return rda5807m_write_reg(0x05, reg05_value);
}

uint8_t rda5807m_get_volume(void) {
    uint16_t reg05_value = rda5807m_read_reg(0x05);
    return (uint8_t)(reg05_value & 0x0F); // 提取音量值
}

bool rda5807m_set_mute(bool mute) {
    uint16_t reg05_value = rda5807m_read_reg(0x05);
    if (mute) {
        reg05_value |= (1 << 4); // 设置 MUTE 位
    } else {
        reg05_value &= ~(1 << 4); // 清除 MUTE 位
    }
    return rda5807m_write_reg(0x05, reg05_value);
}

bool rda5807m_is_muted(void) {
    uint16_t reg05_value = rda5807m_read_reg(0x05);
    return (reg05_value & (1 << 4)) != 0;
}

bool rda5807m_seek_up(bool wrap_around) {
    uint16_t reg02_value = rda5807m_read_reg(0x02);
    reg02_value |= (1 << 4) | (1 << 5); // SEEKUP + SEEK 位
    if (wrap_around) {
        reg02_value &= ~(1 << 6); // Wrap Around 禁用
    } else {
        reg02_value |= (1 << 6);  // Wrap Around 启用
    }
    return rda5807m_write_reg(0x02, reg02_value);
}

bool rda5807m_seek_down(bool wrap_around) {
    uint16_t reg02_value = rda5807m_read_reg(0x02);
    reg02_value |= (1 << 5); // SEEK 位
    if (wrap_around) {
        reg02_value &= ~(1 << 6); // Wrap Around 禁用
    } else {
        reg02_value |= (1 << 6);  // Wrap Around 启用
    }
    return rda5807m_write_reg(0x02, reg02_value);
}

uint8_t rda5807m_get_rssi(void) {
    uint16_t reg0B_value = rda5807m_read_reg(0x0B);
    return (uint8_t)(reg0B_value >> 8); // RSSI [15:8]
}

bool rda5807m_set_band(rda5807m_band_t band) {
    uint16_t reg00_value = rda5807m_read_reg(0x00);
    reg00_value &= ~(0x03 << 2); // 清空 BAND 位
    switch (band) {
        case RDA5807M_BAND_50_108MHZ: reg00_value |= (0x00 << 2); break;
        case RDA5807M_BAND_65_108MHZ: reg00_value |= (0x01 << 2); break;
        case RDA5807M_BAND_76_108MHZ: reg00_value |= (0x02 << 2); break;
        case RDA5807M_BAND_87_108MHZ: reg00_value |= (0x03 << 2); break;
        default: return false;
    }
    return rda5807m_write_reg(0x00, reg00_value);
}

bool rda5807m_set_channel_spacing(rda5807m_space_t space) {
    uint16_t reg00_value = rda5807m_read_reg(0x00);
    reg00_value &= ~(0x03 << 0); // 清空 SPACE 位
    switch (space) {
        case RDA5807M_SPACE_100KHZ: reg00_value |= (0x00 << 0); break;
        case RDA5807M_SPACE_50KHZ:  reg00_value |= (0x01 << 0); break;
        case RDA5807M_SPACE_25KHZ:  reg00_value |= (0x02 << 0); break;
        case RDA5807M_SPACE_10KHZ:  reg00_value |= (0x03 << 0); break;
        default: return false;
    }
    return rda5807m_write_reg(0x00, reg00_value);
}

bool rda5807m_set_stereo_mode(bool stereo) {
    uint16_t reg05_value = rda5807m_read_reg(0x05);
    if (stereo) {
        reg05_value &= ~(1 << 5); // 设置为立体声 (MONO 位清零)
    } else {
        reg05_value |= (1 << 5);  // 设置为单声道 (MONO 位置位)
    }
    return rda5807m_write_reg(0x05, reg05_value);
}


static uint16_t rda5807m_read_reg(uint8_t reg_addr) {
    uint8_t read_data[2];
    hal_i2c_master_read(RDA5807M_I2C_ADDR, reg_addr, read_data, 2); // I2C 读取两个字节
    return (read_data[0] << 8) | read_data[1];
}

static bool rda5807m_write_reg(uint8_t reg_addr, uint16_t reg_value) {
    uint8_t write_data[3];
    write_data[0] = reg_addr;
    write_data[1] = (reg_value >> 8) & 0xFF;
    write_data[2] = reg_value & 0xFF;
    return hal_i2c_master_write(RDA5807M_I2C_ADDR, write_data, 3); // I2C 写入三个字节 (地址 + 2字节数据)
}

3.4 KT0803L 驱动代码示例 (kt0803l_driver.h & kt0803l_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
// kt0803l_driver.h
#ifndef KT0803L_DRIVER_H
#define KT0803L_DRIVER_H

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

void kt0803l_init(void);
bool kt0803l_set_frequency(float frequency_mhz); // 设置发射频率，单位MHz
float kt0803l_get_frequency(void);
bool kt0803l_set_volume(uint8_t volume); // 设置音频输入音量 (0-15)
uint8_t kt0803l_get_volume(void);
bool kt0803l_set_mute(bool mute);
bool kt0803l_is_muted(void);
bool kt0803l_set_modulation_mode(uint8_t mode); // 设置调制模式
bool kt0803l_set_preemphasis(bool preemphasis); // 设置预加重
bool kt0803l_set_power_level(uint8_t level); // 设置发射功率等级

#endif // KT0803L_DRIVER_H

// kt0803l_driver.c (部分代码)
#include "kt0803l_driver.h"
#include "hal_i2c.h"
#include "hal_gpio.h"
#include "delay.h"

#define KT0803L_I2C_ADDR   0x70 // KT0803L I2C 地址 (7-bit)
#define KT0803L_EN_PIN     /* 定义 KT0803L EN 引脚 (使能引脚) */

static bool kt0803l_write_reg(uint8_t reg_addr, uint8_t reg_value);
static uint8_t kt0803l_read_reg(uint8_t reg_addr);

void kt0803l_init(void) {
    hal_i2c_init(/* I2C 初始化参数 */);
    hal_gpio_init(KT0803L_EN_PIN, GPIO_MODE_OUTPUT, GPIO_PULLUP_DISABLE);

    hal_gpio_set_level(KT0803L_EN_PIN, 1); // 使能 KT0803L

    // 软件复位 KT0803L
    kt0803l_write_reg(0x00, 0x00); // Reset Register
    delay_ms(10);

    // 设置默认参数 (例如预加重, 调制模式, 音频输入增益等)
    kt0803l_set_preemphasis(true); // 启用预加重
    kt0803l_set_modulation_mode(0); // 默认调制模式 (Mono)
    kt0803l_set_volume(8); // 默认音频输入音量
    kt0803l_set_mute(false);
    kt0803l_set_power_level(3); // 设置发射功率等级 (根据实际情况调整)
}

bool kt0803l_set_frequency(float frequency_mhz) {
    if (frequency_mhz < 58.0 || frequency_mhz > 111.0) { // 频率范围检查
        return false;
    }
    uint32_t freq_code = (uint32_t)((frequency_mhz * 1000000) / 10000); // 计算频率代码 (10kHz 步进)
    uint8_t freq_h = (freq_code >> 16) & 0xFF;
    uint8_t freq_m = (freq_code >> 8) & 0xFF;
    uint8_t freq_l = freq_code & 0xFF;

    kt0803l_write_reg(0x01, freq_h); // Frequency High Byte
    kt0803l_write_reg(0x02, freq_m); // Frequency Middle Byte
    kt0803l_write_reg(0x03, freq_l); // Frequency Low Byte
    return true;
}

float kt0803l_get_frequency(void) {
    uint8_t freq_h = kt0803l_read_reg(0x01);
    uint8_t freq_m = kt0803l_read_reg(0x02);
    uint8_t freq_l = kt0803l_read_reg(0x03);
    uint32_t freq_code = ((uint32_t)freq_h << 16) | ((uint32_t)freq_m << 8) | freq_l;
    return (float)(freq_code * 10000) / 1000000.0; // 转换回 MHz
}

bool kt0803l_set_volume(uint8_t volume) {
    if (volume > 15) volume = 15;
    return kt0803l_write_reg(0x04, volume); // Audio Input Volume Register
}

uint8_t kt0803l_get_volume(void) {
    return kt0803l_read_reg(0x04);
}

bool kt0803l_set_mute(bool mute) {
    uint8_t reg05_value = kt0803l_read_reg(0x05);
    if (mute) {
        reg05_value |= (1 << 7); // Set MUTE bit
    } else {
        reg05_value &= ~(1 << 7); // Clear MUTE bit
    }
    return kt0803l_write_reg(0x05, reg05_value); // Control Register 1
}

bool kt0803l_is_muted(void) {
    uint8_t reg05_value = kt0803l_read_reg(0x05);
    return (reg05_value & (1 << 7)) != 0;
}

bool kt0803l_set_modulation_mode(uint8_t mode) {
    // Mode: 0 = Mono, 1 = Stereo, 2 = Pilot Tone Stereo, 3 = Matrix Stereo
    if (mode > 3) mode = 0;
    uint8_t reg05_value = kt0803l_read_reg(0x05);
    reg05_value &= ~(0x03 << 5); // Clear Modulation Mode bits
    reg05_value |= (mode << 5);  // Set Modulation Mode bits
    return kt0803l_write_reg(0x05, reg05_value); // Control Register 1
}

bool kt0803l_set_preemphasis(bool preemphasis) {
    uint8_t reg05_value = kt0803l_read_reg(0x05);
    if (preemphasis) {
        reg05_value |= (1 << 4); // Enable Preemphasis
    } else {
        reg05_value &= ~(1 << 4); // Disable Preemphasis
    }
    return kt0803l_write_reg(0x05, reg05_value); // Control Register 1
}

bool kt0803l_set_power_level(uint8_t level) {
    if (level > 7) level = 7; // Power level 0-7
    uint8_t reg06_value = kt0803l_read_reg(0x06);
    reg06_value &= ~(0x07 << 0); // Clear Power Level bits
    reg06_value |= (level << 0); // Set Power Level bits
    return kt0803l_write_reg(0x06, reg06_value); // Control Register 2
}


static bool kt0803l_write_reg(uint8_t reg_addr, uint8_t reg_value) {
    uint8_t write_data[2];
    write_data[0] = reg_addr;
    write_data[1] = reg_value;
    return hal_i2c_master_write(KT0803L_I2C_ADDR, write_data, 2); // I2C 写入两个字节 (地址 + 数据)
}

static uint8_t kt0803l_read_reg(uint8_t reg_addr) {
    uint8_t read_data[1];
    hal_i2c_master_read(KT0803L_I2C_ADDR, reg_addr, read_data, 1); // I2C 读取一个字节
    return read_data[0];
}

3.5 应用逻辑层代码示例 (app/fm_receiver.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
// app/fm_receiver.c
#include "fm_receiver.h"
#include "rda5807m_driver.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"

#define RECEIVER_TASK_STACK_SIZE  2048
#define RECEIVER_TASK_PRIORITY     2

static TaskHandle_t receiver_task_handle = NULL;
static QueueHandle_t receiver_event_queue = NULL;

typedef enum {
    RECEIVER_EVENT_SCAN_START,
    RECEIVER_EVENT_SCAN_STOP,
    RECEIVER_EVENT_TUNE_FREQ,
    RECEIVER_EVENT_VOLUME_SET,
    RECEIVER_EVENT_MUTE_SET
} receiver_event_t;

typedef struct {
    receiver_event_t event_type;
    union {
        float frequency;
        uint8_t volume;
        bool mute_state;
    } data;
} receiver_event_message_t;

static void receiver_task(void *pvParameters) {
    rda5807m_init(); // 初始化 RDA5807M

    for (;;) {
        receiver_event_message_t event_msg;
        if (xQueueReceive(receiver_event_queue, &event_msg, portMAX_DELAY) == pdTRUE) {
            switch (event_msg.event_type) {
                case RECEIVER_EVENT_SCAN_START:
                    // ... 启动频率扫描逻辑 ...
                    break;
                case RECEIVER_EVENT_SCAN_STOP:
                    // ... 停止频率扫描逻辑 ...
                    break;
                case RECEIVER_EVENT_TUNE_FREQ:
                    rda5807m_set_frequency(event_msg.data.frequency);
                    break;
                case RECEIVER_EVENT_VOLUME_SET:
                    rda5807m_set_volume(event_msg.data.volume);
                    break;
                case RECEIVER_EVENT_MUTE_SET:
                    rda5807m_set_mute(event_msg.data.mute_state);
                    break;
                default:
                    break;
            }
        }
    }
}

bool fm_receiver_init(void) {
    receiver_event_queue = xQueueCreate(10, sizeof(receiver_event_message_t));
    if (receiver_event_queue == NULL) {
        return false;
    }
    if (xTaskCreate(receiver_task, "ReceiverTask", RECEIVER_TASK_STACK_SIZE, NULL, RECEIVER_TASK_PRIORITY, &receiver_task_handle) != pdPASS) {
        return false;
    }
    return true;
}

bool fm_receiver_tune_frequency(float frequency_mhz) {
    receiver_event_message_t event_msg;
    event_msg.event_type = RECEIVER_EVENT_TUNE_FREQ;
    event_msg.data.frequency = frequency_mhz;
    return xQueueSend(receiver_event_queue, &event_msg, 0) == pdTRUE;
}

bool fm_receiver_set_volume(uint8_t volume) {
    receiver_event_message_t event_msg;
    event_msg.event_type = RECEIVER_EVENT_VOLUME_SET;
    event_msg.data.volume = volume;
    return xQueueSend(receiver_event_queue, &event_msg, 0) == pdTRUE;
}

bool fm_receiver_set_mute(bool mute) {
    receiver_event_message_t event_msg;
    event_msg.event_type = RECEIVER_EVENT_MUTE_SET;
    event_msg.data.mute_state = mute;
    return xQueueSend(receiver_event_queue, &event_msg, 0) == pdTRUE;
}

// ... 其他接收器控制函数 (例如扫描开始/停止等) ...

3.6 应用逻辑层代码示例 (app/fm_transmitter.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
// app/fm_transmitter.c
#include "fm_transmitter.h"
#include "kt0803l_driver.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"

#define TRANSMITTER_TASK_STACK_SIZE 2048
#define TRANSMITTER_TASK_PRIORITY    2

static TaskHandle_t transmitter_task_handle = NULL;
static QueueHandle_t transmitter_event_queue = NULL;

typedef enum {
    TRANSMITTER_EVENT_TUNE_FREQ,
    TRANSMITTER_EVENT_VOLUME_SET,
    TRANSMITTER_EVENT_MUTE_SET,
    TRANSMITTER_EVENT_POWER_SET
} transmitter_event_t;

typedef struct {
    transmitter_event_t event_type;
    union {
        float frequency;
        uint8_t volume;
        bool mute_state;
        uint8_t power_level;
    } data;
} transmitter_event_message_t;

static void transmitter_task(void *pvParameters) {
    kt0803l_init(); // 初始化 KT0803L

    for (;;) {
        transmitter_event_message_t event_msg;
        if (xQueueReceive(transmitter_event_queue, &event_msg, portMAX_DELAY) == pdTRUE) {
            switch (event_msg.event_type) {
                case TRANSMITTER_EVENT_TUNE_FREQ:
                    kt0803l_set_frequency(event_msg.data.frequency);
                    break;
                case TRANSMITTER_EVENT_VOLUME_SET:
                    kt0803l_set_volume(event_msg.data.volume);
                    break;
                case TRANSMITTER_EVENT_MUTE_SET:
                    kt0803l_set_mute(event_msg.data.mute_state);
                    break;
                case TRANSMITTER_EVENT_POWER_SET:
                    kt0803l_set_power_level(event_msg.data.power_level);
                    break;
                default:
                    break;
            }
        }
    }
}

bool fm_transmitter_init(void) {
    transmitter_event_queue = xQueueCreate(10, sizeof(transmitter_event_message_t));
    if (transmitter_event_queue == NULL) {
        return false;
    }
    if (xTaskCreate(transmitter_task, "TransmitterTask", TRANSMITTER_TASK_STACK_SIZE, NULL, TRANSMITTER_TASK_PRIORITY, &transmitter_task_handle) != pdPASS) {
        return false;
    }
    return true;
}

bool fm_transmitter_tune_frequency(float frequency_mhz) {
    transmitter_event_message_t event_msg;
    event_msg.event_type = TRANSMITTER_EVENT_TUNE_FREQ;
    event_msg.data.frequency = frequency_mhz;
    return xQueueSend(transmitter_event_queue, &event_msg, 0) == pdTRUE;
}

bool fm_transmitter_set_volume(uint8_t volume) {
    transmitter_event_message_t event_msg;
    event_msg.event_type = TRANSMITTER_EVENT_VOLUME_SET;
    event_msg.data.volume = volume;
    return xQueueSend(transmitter_event_queue, &event_msg, 0) == pdTRUE;
}

bool fm_transmitter_set_mute(bool mute) {
    transmitter_event_message_t event_msg;
    event_msg.event_type = TRANSMITTER_EVENT_MUTE_SET;
    event_msg.data.mute_state = mute;
    return xQueueSend(transmitter_event_queue, &event_msg, 0) == pdTRUE;
}

bool fm_transmitter_set_power_level(uint8_t power_level) {
    transmitter_event_message_t event_msg;
    event_msg.event_type = TRANSMITTER_EVENT_POWER_SET;
    event_msg.data.power_level = power_level;
    return xQueueSend(transmitter_event_queue, &event_msg, 0) == pdTRUE;
}

3.7 UI层代码示例 (ui/ui_manager.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
// ui/ui_manager.c
#include "ui_manager.h"
#include "tft_driver.h"
#include "button_driver.h"
#include "fm_receiver.h"
#include "fm_transmitter.h"
#include "delay.h"

#define UI_UPDATE_INTERVAL_MS 100

typedef enum {
    UI_STATE_MAIN_MENU,
    UI_STATE_FM_RECEIVER,
    UI_STATE_FM_TRANSMITTER,
    UI_STATE_SETTINGS
} ui_state_t;

static ui_state_t current_ui_state = UI_STATE_MAIN_MENU;
static float current_frequency = 87.5f; // 默认频率
static uint8_t current_volume = 8;      // 默认音量
static bool is_muted = false;

static void ui_draw_main_menu(void);
static void ui_draw_fm_receiver_screen(void);
static void ui_draw_fm_transmitter_screen(void);
static void ui_handle_input(void);

void ui_manager_init(void) {
    tft_init();
    button_driver_init();
    fm_receiver_init();
    fm_transmitter_init();

    current_ui_state = UI_STATE_MAIN_MENU;
    ui_draw_main_menu();
}

void ui_manager_task(void *pvParameters) {
    TickType_t xLastWakeTime = xTaskGetTickCount();

    for (;;) {
        ui_handle_input();
        switch (current_ui_state) {
            case UI_STATE_MAIN_MENU:
                ui_draw_main_menu();
                break;
            case UI_STATE_FM_RECEIVER:
                ui_draw_fm_receiver_screen();
                break;
            case UI_STATE_FM_TRANSMITTER:
                ui_draw_fm_transmitter_screen();
                break;
            case UI_STATE_SETTINGS:
                // ... 绘制设置界面 ...
                break;
            default:
                break;
        }
        vTaskDelayUntil(&xLastWakeTime, pdMS_TO_TICKS(UI_UPDATE_INTERVAL_MS));
    }
}

static void ui_draw_main_menu(void) {
    tft_fill_screen(TFT_COLOR_BLACK);
    tft_draw_string("Main Menu", 10, 10, TFT_COLOR_WHITE, TFT_COLOR_BLACK, 2);
    tft_draw_string("1. FM Receiver", 10, 40, TFT_COLOR_WHITE, TFT_COLOR_BLACK, 1);
    tft_draw_string("2. FM Transmitter", 10, 60, TFT_COLOR_WHITE, TFT_COLOR_BLACK, 1);
    tft_draw_string("3. Settings", 10, 80, TFT_COLOR_WHITE, TFT_COLOR_BLACK, 1);
}

static void ui_draw_fm_receiver_screen(void) {
    tft_fill_screen(TFT_COLOR_BLUE); // 蓝色背景表示接收模式
    tft_draw_string("FM Receiver", 10, 10, TFT_COLOR_WHITE, TFT_COLOR_BLUE, 2);

    char freq_str[20];
    sprintf(freq_str, "Freq: %.2f MHz", current_frequency);
    tft_draw_string(freq_str, 10, 40, TFT_COLOR_WHITE, TFT_COLOR_BLUE, 1);

    char vol_str[15];
    sprintf(vol_str, "Vol: %d", current_volume);
    tft_draw_string(vol_str, 10, 60, TFT_COLOR_WHITE, TFT_COLOR_BLUE, 1);

    tft_draw_string(is_muted ? "Muted" : "Unmuted", 10, 80, TFT_COLOR_WHITE, TFT_COLOR_BLUE, 1);
}

static void ui_draw_fm_transmitter_screen(void) {
    tft_fill_screen(TFT_COLOR_GREEN); // 绿色背景表示发射模式
    tft_draw_string("FM Transmitter", 10, 10, TFT_COLOR_WHITE, TFT_COLOR_GREEN, 2);

    char freq_str[20];
    sprintf(freq_str, "Freq: %.2f MHz", current_frequency);
    tft_draw_string(freq_str, 10, 40, TFT_COLOR_WHITE, TFT_COLOR_GREEN, 1);

    char vol_str[15];
    sprintf(vol_str, "Vol: %d", current_volume);
    tft_draw_string(vol_str, 10, 60, TFT_COLOR_WHITE, TFT_COLOR_GREEN, 1);

    tft_draw_string(is_muted ? "Muted" : "Unmuted", 10, 80, TFT_COLOR_WHITE, TFT_COLOR_GREEN, 1);
}

static void ui_handle_input(void) {
    if (button_driver_is_pressed(/* 定义上按键 */)) {
        delay_ms(50); // 简单按键消抖
        if (current_ui_state == UI_STATE_FM_RECEIVER || current_ui_state == UI_STATE_FM_TRANSMITTER) {
            current_frequency += 0.1f; // 频率步进
            if (current_frequency > 111.0f) current_frequency = 58.0f; // 频率范围限制
            if (current_ui_state == UI_STATE_FM_RECEIVER) {
                fm_receiver_tune_frequency(current_frequency);
            } else if (current_ui_state == UI_STATE_FM_TRANSMITTER) {
                fm_transmitter_tune_frequency(current_frequency);
            }
        }
    }
    if (button_driver_is_pressed(/* 定义下按键 */)) {
        delay_ms(50);
        if (current_ui_state == UI_STATE_FM_RECEIVER || current_ui_state == UI_STATE_FM_TRANSMITTER) {
            current_frequency -= 0.1f;
            if (current_frequency < 58.0f) current_frequency = 111.0f;
            if (current_ui_state == UI_STATE_FM_RECEIVER) {
                fm_receiver_tune_frequency(current_frequency);
            } else if (current_ui_state == UI_STATE_FM_TRANSMITTER) {
                fm_transmitter_tune_frequency(current_frequency);
            }
        }
    }
    if (button_driver_is_pressed(/* 定义左按键 */)) {
        delay_ms(50);
        if (current_ui_state == UI_STATE_FM_RECEIVER || current_ui_state == UI_STATE_FM_TRANSMITTER) {
            if (current_volume > 0) current_volume--;
            if (current_ui_state == UI_STATE_FM_RECEIVER) {
                fm_receiver_set_volume(current_volume);
            } else if (current_ui_state == UI_STATE_FM_TRANSMITTER) {
                fm_transmitter_set_volume(current_volume);
            }
        }
    }
    if (button_driver_is_pressed(/* 定义右按键 */)) {
        delay_ms(50);
        if (current_ui_state == UI_STATE_FM_RECEIVER || current_ui_state == UI_STATE_FM_TRANSMITTER) {
            if (current_volume < 15) current_volume++;
            if (current_ui_state == UI_STATE_FM_RECEIVER) {
                fm_receiver_set_volume(current_volume);
            } else if (current_ui_state == UI_STATE_FM_TRANSMITTER) {
                fm_transmitter_set_volume(current_volume);
            }
        }
    }
    if (button_driver_is_pressed(/* 定义中间/确认按键 */)) {
        delay_ms(50);
        if (current_ui_state == UI_STATE_MAIN_MENU) {
            // 进入子菜单
            if (/* 判断当前选择的菜单项 */) {
                current_ui_state = UI_STATE_FM_RECEIVER;
            } else if (/* ... */) {
                current_ui_state = UI_STATE_FM_TRANSMITTER;
            } else if (/* ... */) {
                current_ui_state = UI_STATE_SETTINGS;
            }
        } else if (current_ui_state == UI_STATE_FM_RECEIVER || current_ui_state == UI_STATE_FM_TRANSMITTER) {
            is_muted = !is_muted;
            if (current_ui_state == UI_STATE_FM_RECEIVER) {
                fm_receiver_set_mute(is_muted);
            } else if (current_ui_state == UI_STATE_FM_TRANSMITTER) {
                fm_transmitter_set_mute(is_muted);
            }
        } else if (current_ui_state == UI_STATE_SETTINGS) {
            // ... 设置界面操作 ...
        }
    }
    if (button_driver_is_pressed(/* 定义返回/菜单按键 */)) {
        delay_ms(50);
        if (current_ui_state != UI_STATE_MAIN_MENU) {
            current_ui_state = UI_STATE_MAIN_MENU; // 返回主菜单
        }
    }
}

3.8 主程序 main.c 示例 (简化的 FreeRTOS 任务创建)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// main.c
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "ui_manager.h"

void app_main(void) {
    printf("FM Radio Transceiver System Startup...\n");

    ui_manager_init(); // 初始化 UI 管理器

    // 创建 UI 任务
    if (xTaskCreate(ui_manager_task, "UITask", 4096, NULL, 1, NULL) != pdPASS) {
        printf("Failed to create UI Task!\n");
    }

    // ... 可以创建其他任务，例如系统监控任务等 ...

    // 启动 FreeRTOS 调度器
    vTaskStartScheduler();
}

4. 测试与验证

在完成代码编写后，需要进行全面的测试和验证，包括：

  • 单元测试: 针对HAL层和驱动层模块进行单元测试，验证驱动程序的正确性。
  • 集成测试: 测试各个模块之间的协同工作，例如UI层与应用逻辑层的交互，驱动层与HAL层的交互。
  • 系统测试: 进行整体功能测试，验证FM接收、FM发射、UI交互等功能是否正常工作，是否满足需求。
  • 性能测试: 评估系统的实时性、响应速度、资源占用等性能指标。
  • 稳定性测试: 长时间运行测试，验证系统的可靠性和稳定性。
  • 射频测试: 使用频谱分析仪等设备进行射频性能测试，例如发射功率、频率精度、调制质量、接收灵敏度等 (需要专业设备和知识)。

5. 维护与升级

为了方便后期的维护和升级，我们应考虑以下方面：

  • 模块化设计: 清晰的模块划分和接口定义，方便模块的替换和升级。
  • 代码注释: 详细的代码注释，提高代码可读性和可维护性。
  • 版本控制: 使用Git等版本控制工具管理代码，方便代码回溯和版本管理。
  • OTA升级: 实现固件在线升级 (OTA) 功能，方便远程升级固件，修复bug或添加新功能。
  • 日志系统: 添加系统日志输出功能，方便调试和故障排查。

6. 实践验证的技术和方法

本项目中采用的各种技术和方法都是经过实践验证的，例如：

  • 分层架构和模块化设计: 是嵌入式系统开发中常用的架构模式，可以提高代码的可维护性和可扩展性。
  • FreeRTOS实时操作系统: 在资源受限的嵌入式系统中，RTOS可以有效地管理任务和资源，提高系统的实时性和并发性。
  • HAL硬件抽象层: 可以屏蔽底层硬件差异，提高代码的可移植性，方便更换硬件平台。
  • 事件驱动编程: 在UI交互和系统状态管理中，事件驱动编程可以提高系统的响应速度和效率。
  • 状态机: 使用状态机管理UI界面切换和系统状态，可以使系统逻辑更加清晰和可控。
  • C语言: C语言是嵌入式系统开发中最常用的编程语言，具有高效、灵活、可移植性强等优点。

总结

以上代码和架构设计提供了一个基于ESP32-C3的广播收发器项目的完整框架。实际开发中，需要根据具体硬件和需求进行详细设计和代码实现，并进行充分的测试和验证。 完整的代码实现将会超过3000行，包括更详细的驱动代码、更完善的UI界面、更丰富的功能实现以及错误处理和异常情况考虑。 希望这个详细的说明和示例代码能够帮助您理解嵌入式系统开发流程和代码架构设计。
Error executing command: Traceback (most recent call last):
File “/home/tong/bin/desc_img3.py”, line 82, in
response_text += chunk.text
TypeError: can only concatenate str (not “NoneType”) to str

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