2315 lines
60 KiB
Markdown
2315 lines
60 KiB
Markdown
# E32-433模块重构技术方案
|
||
|
||
## 文档信息
|
||
- **版本**: v1.0
|
||
- **日期**: 2026-03-24
|
||
- **作者**: 系统架构师
|
||
- **项目**: E32-433TBH-SC
|
||
|
||
---
|
||
|
||
## 一、项目概况
|
||
|
||
### 1.1 项目背景
|
||
本项目是基于STM32F103C8T6微控制器的嵌入式系统，使用STM32CubeMX代码生成框架。项目实现了E32-433T30S LoRa无线模块的控制，通过USB CDC进行通信，配备OLED显示(u8g2)和菜单系统。
|
||
|
||
### 1.2 当前架构
|
||
```
|
||
┌─────────────────────────────────────────────────────────┐
|
||
│ 应用层 (Application) │
|
||
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
|
||
│ │ Menu系统 │ │ USB CDC │ │ OLED显示 │ │
|
||
│ └──────────────┘ └──────────────┘ └──────────────┘ │
|
||
└─────────────────────────────────────────────────────────┘
|
||
↓
|
||
┌─────────────────────────────────────────────────────────┐
|
||
│ E32模块层 (当前耦合) │
|
||
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
|
||
│ │ e32_demo.c │ │ e32_hal.c │ │ usart.c │ │
|
||
│ └──────────────┘ └──────────────┘ └──────────────┘ │
|
||
└─────────────────────────────────────────────────────────┘
|
||
↓
|
||
┌─────────────────────────────────────────────────────────┐
|
||
│ 硬件抽象层 (HAL) │
|
||
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
|
||
│ │ GPIO │ │ UART1 │ │ FIFO │ │
|
||
│ └──────────────┘ └──────────────┘ └──────────────┘ │
|
||
└─────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### 1.3 存在的问题
|
||
1. **耦合度高**: E32模块代码分散在多个文件中，与USB、UART等模块紧密耦合
|
||
2. **可维护性差**: TX/RX模式代码混杂，难以独立测试和维护
|
||
3. **资源浪费**: 未使用的TX/RX代码仍被编译，占用Flash空间
|
||
4. **扩展性差**: 缺乏清晰的模块边界，难以移植到其他项目
|
||
|
||
---
|
||
|
||
## 二、已识别433相关代码清单
|
||
|
||
### 2.1 核心文件列表
|
||
|
||
| 文件路径 | 类型 | 功能描述 | 依赖关系 |
|
||
|---------|------|---------|---------|
|
||
| `Core/Inc/e32_hal.h` | 头文件 | E32硬件抽象层接口定义 | 无 |
|
||
| `Core/Src/e32_hal.c` | 源文件 | E32硬件抽象层实现 | main.h, gpio.h, usart.h |
|
||
| `Core/Inc/e32_demo.h` | 头文件 | E32演示应用接口定义 | e32_hal.h |
|
||
| `Core/Src/e32_demo.c` | 源文件 | E32演示应用实现 | e32_demo.h, main.h, application.h |
|
||
| `Core/Inc/fifo.h` | 头文件 | FIFO队列接口定义 | 无 |
|
||
| `Core/Src/fifo.c` | 源文件 | FIFO队列实现 | fifo.h |
|
||
| `Core/Inc/usart.h` | 头文件 | UART接口定义 | main.h |
|
||
| `Core/Src/usart.c` | 源文件 | UART实现（含E32通信） | usart.h, fifo.h, usbd_cdc_if.h |
|
||
| `USB_DEVICE/App/usbd_cdc_if.c` | 源文件 | USB CDC接口（含数据转发） | usbd_cdc_if.h |
|
||
| `USB_DEVICE/App/usbd_cdc_if.h` | 头文件 | USB CDC接口定义 | usbd_cdc.h |
|
||
|
||
### 2.2 关键数据结构
|
||
|
||
#### 2.2.1 工作模式枚举
|
||
```c
|
||
typedef enum
|
||
{
|
||
WORK_MODE_TRANSPARENT = 0x00, // 透明传输模式
|
||
WORK_MODE_WAKE_ON_RADIO_MASTER = 0x01, // WOR主模式
|
||
WORK_MODE_WAKE_ON_RADIO_SLAVE = 0x02, // WOR从模式
|
||
WORK_MODE_CONFIG_AND_SLEEP = 0x03, // 配置/睡眠模式
|
||
} work_mode_t;
|
||
```
|
||
|
||
#### 2.2.2 寄存器配置结构体
|
||
```c
|
||
typedef struct
|
||
{
|
||
struct { uint8_t address_h; } register_1; // 地址高字节
|
||
struct { uint8_t address_l; } register_2; // 地址低字节
|
||
union {
|
||
uint8_t value;
|
||
struct {
|
||
radio_rate_t radio_rate : 3; // 空中速率
|
||
uart_rate_t uart_baud_rate : 3; // 串口波特率
|
||
uart_parity_t uart_parity : 2; // 校验位
|
||
} field;
|
||
} register_3;
|
||
struct { uint8_t channel; } register_4; // 信道
|
||
union {
|
||
uint8_t value;
|
||
struct {
|
||
transmit_power_t tx_power : 2; // 发射功率
|
||
on_off_t packet_fec : 1; // FEC使能
|
||
wor_period_t wake_on_radio_period: 3; // WOR周期
|
||
on_off_t reserve : 1; // 保留
|
||
on_off_t specify_target : 1; // 指定目标传输
|
||
} field;
|
||
} register_5;
|
||
} e32_register_t;
|
||
```
|
||
|
||
#### 2.2.3 数据包结构体
|
||
```c
|
||
typedef struct
|
||
{
|
||
uint8_t address_h; // 目标地址高字节
|
||
uint8_t address_l; // 目标地址低字节
|
||
uint8_t channel; // 目标信道
|
||
uint8_t data[237]; // 数据（最大237字节）
|
||
} e32_specify_target_buffer_t;
|
||
```
|
||
|
||
### 2.3 硬件资源映射
|
||
|
||
| 硬件资源 | 引脚/外设 | 功能 | 配置 |
|
||
|---------|----------|------|------|
|
||
| UART1 | PA9(TX), PA10(RX) | E32模块串口通信 | 115200/9600 bps |
|
||
| M0 | GPIO | 模式选择引脚0 | 输出 |
|
||
| M1 | GPIO | 模式选择引脚1 | 输出 |
|
||
| AUX | GPIO | 辅助引脚（忙状态） | 输入 |
|
||
| RESET | GPIO | 复位引脚 | 输出 |
|
||
| USART1_IRQn | 中断 | UART接收中断 | 优先级0 |
|
||
|
||
### 2.4 TX/RX模式实现分析
|
||
|
||
#### 2.4.1 当前TX实现
|
||
- **位置**: `e32_demo.c` 中的 `e32_demo_transmit()` 函数
|
||
- **流程**:
|
||
1. 调用 `e32_hal_uart_tx()` 发送数据
|
||
2. 通过UART1发送到E32模块
|
||
3. E32模块在透明传输模式下自动发送
|
||
|
||
#### 2.4.2 当前RX实现
|
||
- **位置**: `usart.c` 中的 `HAL_UART_RxCpltCallback()` 回调
|
||
- **流程**:
|
||
1. UART1中断接收数据
|
||
2. 数据写入FIFO缓冲区
|
||
3. 通过USB CDC转发到PC
|
||
4. 使用超时机制判断数据包结束
|
||
|
||
#### 2.4.3 模式切换
|
||
- **位置**: `e32_hal.c` 中的 `e32_hal_work_mode()` 函数
|
||
- **实现**: 通过控制M0和M1引脚电平切换工作模式
|
||
- **等待**: 使用AUX引脚或延时等待模式切换完成
|
||
|
||
---
|
||
|
||
## 三、新模块架构设计
|
||
|
||
### 3.1 新模块目录树
|
||
|
||
```
|
||
Driver_RF433/
|
||
├── Inc/ # 头文件目录
|
||
│ ├── rf433.h # 主接口头文件
|
||
│ ├── rf433_config.h # 配置头文件
|
||
│ ├── rf433_hal.h # 硬件抽象层头文件
|
||
│ ├── rf433_tx.h # TX模式接口（条件编译）
|
||
│ └── rf433_rx.h # RX模式接口（条件编译）
|
||
│
|
||
├── Src/ # 源文件目录
|
||
│ ├── rf433.c # 主实现文件
|
||
│ ├── rf433_hal.c # 硬件抽象层实现
|
||
│ ├── rf433_tx.c # TX模式实现（条件编译）
|
||
│ └── rf433_rx.c # RX模式实现（条件编译）
|
||
│
|
||
└── docs/ # 文档目录
|
||
├── rf433_api.md # API文档
|
||
└── rf433_integration.md # 集成指南
|
||
```
|
||
|
||
### 3.2 模块架构图
|
||
|
||
```
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ 应用层 (Application) │
|
||
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
|
||
│ │ Menu系统 │ │ USB CDC │ │ OLED显示 │ │
|
||
│ └──────────────┘ └──────────────┘ └──────────────┘ │
|
||
└─────────────────────────────────────────────────────────────┘
|
||
↓
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ Driver_RF433 模块 (新设计) │
|
||
│ ┌──────────────────────────────────────────────────────┐ │
|
||
│ │ rf433.h (统一接口) │ │
|
||
│ │ - rf433_init() │ │
|
||
│ │ - rf433_deinit() │ │
|
||
│ │ - rf433_set_config() │ │
|
||
│ │ - rf433_get_config() │ │
|
||
│ └──────────────────────────────────────────────────────┘ │
|
||
│ ↓ │
|
||
│ ┌──────────────────┐ ┌──────────────────┐ │
|
||
│ │ rf433_tx.h/c │ │ rf433_rx.h/c │ │
|
||
│ │ (TX模式) │ │ (RX模式) │ │
|
||
│ │ - rf433_tx() │ │ - rf433_rx() │ │
|
||
│ │ - rf433_tx_... │ │ - rf433_rx_... │ │
|
||
│ └──────────────────┘ └──────────────────┘ │
|
||
│ ↓ │
|
||
│ ┌──────────────────────────────────────────────────────┐ │
|
||
│ │ rf433_hal.h/c (硬件抽象层) │ │
|
||
│ │ - rf433_hal_uart_tx() │ │
|
||
│ │ - rf433_hal_uart_rx() │ │
|
||
│ │ - rf433_hal_gpio_init() │ │
|
||
│ │ - rf433_hal_work_mode() │ │
|
||
│ └──────────────────────────────────────────────────────┘ │
|
||
└─────────────────────────────────────────────────────────────┘
|
||
↓
|
||
┌─────────────────────────────────────────────────────────────┐
|
||
│ 硬件抽象层 (HAL) │
|
||
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
|
||
│ │ GPIO │ │ UART1 │ │ FIFO │ │
|
||
│ └──────────────┘ └──────────────┘ └──────────────┘ │
|
||
└─────────────────────────────────────────────────────────────┘
|
||
```
|
||
|
||
### 3.3 模块依赖关系
|
||
|
||
```
|
||
Driver_RF433
|
||
├── HAL库 (STM32 HAL)
|
||
├── FIFO模块 (Core/Inc/fifo.h)
|
||
└── 应用层回调 (可选)
|
||
```
|
||
|
||
---
|
||
|
||
## 四、API接口定义
|
||
|
||
### 4.1 主接口 (rf433.h)
|
||
|
||
```c
|
||
/**
|
||
* @file rf433.h
|
||
* @brief E32-433模块驱动主接口
|
||
*/
|
||
|
||
#ifndef __RF433_H__
|
||
#define __RF433_H__
|
||
|
||
#ifdef __cplusplus
|
||
extern "C" {
|
||
#endif
|
||
|
||
#include <stdint.h>
|
||
#include <stdbool.h>
|
||
|
||
/* ============================================================================
|
||
* 配置宏定义
|
||
* ============================================================================ */
|
||
|
||
/**
|
||
* @brief 编译模式选择
|
||
* @note 必须在包含此头文件之前定义
|
||
* RF433_MODE_TX - 仅编译TX功能
|
||
* RF433_MODE_RX - 仅编译RX功能
|
||
* RF433_MODE_BOTH - 编译TX和RX功能（默认）
|
||
*/
|
||
#ifndef RF433_MODE
|
||
#define RF433_MODE RF433_MODE_BOTH
|
||
#endif
|
||
|
||
/**
|
||
* @brief FIFO缓冲区大小
|
||
*/
|
||
#define RF433_FIFO_SIZE 1024
|
||
|
||
/**
|
||
* @brief 最大数据包长度
|
||
*/
|
||
#define RF433_MAX_PACKET_SIZE 237
|
||
|
||
/**
|
||
* @brief 默认超时时间（ms）
|
||
*/
|
||
#define RF433_DEFAULT_TIMEOUT 100
|
||
|
||
/* ============================================================================
|
||
* 错误码定义
|
||
* ============================================================================ */
|
||
|
||
typedef enum
|
||
{
|
||
RF433_OK = 0, // 成功
|
||
RF433_ERROR = -1, // 通用错误
|
||
RF433_ERROR_BUSY = -2, // 模块忙
|
||
RF433_ERROR_TIMEOUT = -3, // 超时
|
||
RF433_ERROR_INVALID_PARAM = -4, // 无效参数
|
||
RF433_ERROR_NO_MEMORY = -5, // 内存不足
|
||
RF433_ERROR_NOT_INIT = -6, // 未初始化
|
||
} rf433_error_t;
|
||
|
||
/* ============================================================================
|
||
* 工作模式枚举
|
||
* ============================================================================ */
|
||
|
||
typedef enum
|
||
{
|
||
RF433_MODE_TRANSPARENT = 0x00, // 透明传输模式
|
||
RF433_MODE_WAKE_ON_RADIO_MASTER = 0x01, // WOR主模式
|
||
RF433_MODE_WAKE_ON_RADIO_SLAVE = 0x02, // WOR从模式
|
||
RF433_MODE_CONFIG_AND_SLEEP = 0x03, // 配置/睡眠模式
|
||
} rf433_work_mode_t;
|
||
|
||
/* ============================================================================
|
||
* 配置参数枚举
|
||
* ============================================================================ */
|
||
|
||
typedef enum
|
||
{
|
||
RF433_RADIO_RATE_2400 = 0x02,
|
||
RF433_RADIO_RATE_4800 = 0x03,
|
||
RF433_RADIO_RATE_9600 = 0x04,
|
||
RF433_RADIO_RATE_19200 = 0x05,
|
||
RF433_RADIO_RATE_38400 = 0x06,
|
||
RF433_RADIO_RATE_62500 = 0x07,
|
||
} rf433_radio_rate_t;
|
||
|
||
typedef enum
|
||
{
|
||
RF433_UART_8N1 = 0x00,
|
||
RF433_UART_8O1 = 0x01,
|
||
RF433_UART_8E1 = 0x02,
|
||
} rf433_uart_parity_t;
|
||
|
||
typedef enum
|
||
{
|
||
RF433_UART_RATE_1200 = 0x00,
|
||
RF433_UART_RATE_2400 = 0x01,
|
||
RF433_UART_RATE_4800 = 0x02,
|
||
RF433_UART_RATE_9600 = 0x03,
|
||
RF433_UART_RATE_19200 = 0x04,
|
||
RF433_UART_RATE_38400 = 0x05,
|
||
RF433_UART_RATE_57600 = 0x06,
|
||
RF433_UART_RATE_115200= 0x07,
|
||
} rf433_uart_rate_t;
|
||
|
||
typedef enum
|
||
{
|
||
RF433_TX_POWER_DBM_30 = 0x00,
|
||
RF433_TX_POWER_DBM_27 = 0x01,
|
||
RF433_TX_POWER_DBM_24 = 0x02,
|
||
RF433_TX_POWER_DBM_21 = 0x03,
|
||
} rf433_tx_power_t;
|
||
|
||
typedef enum
|
||
{
|
||
RF433_OFF = 0x00,
|
||
RF433_ON = 0x01,
|
||
} rf433_on_off_t;
|
||
|
||
/* ============================================================================
|
||
* 配置结构体
|
||
* ============================================================================ */
|
||
|
||
typedef struct
|
||
{
|
||
uint16_t address; // 模块地址 (0-65535, 65535为广播地址)
|
||
uint8_t channel; // 信道 (0-83)
|
||
rf433_radio_rate_t radio_rate; // 空中速率
|
||
rf433_uart_rate_t uart_rate; // 串口波特率
|
||
rf433_uart_parity_t uart_parity; // 校验位
|
||
rf433_tx_power_t tx_power; // 发射功率
|
||
rf433_on_off_t fec_enable; // FEC使能
|
||
rf433_on_off_t specify_target;// 指定目标传输
|
||
} rf433_config_t;
|
||
|
||
/* ============================================================================
|
||
* 数据包结构体
|
||
* ============================================================================ */
|
||
|
||
typedef struct
|
||
{
|
||
uint16_t address; // 目标地址
|
||
uint8_t channel; // 目标信道
|
||
uint8_t data[RF433_MAX_PACKET_SIZE]; // 数据
|
||
uint16_t length; // 数据长度
|
||
} rf433_packet_t;
|
||
|
||
/* ============================================================================
|
||
* 回调函数类型定义
|
||
* ============================================================================ */
|
||
|
||
/**
|
||
* @brief 数据接收回调函数类型
|
||
* @param packet 接收到的数据包
|
||
* @param user_data 用户数据
|
||
*/
|
||
typedef void (*rf433_rx_callback_t)(const rf433_packet_t *packet, void *user_data);
|
||
|
||
/**
|
||
* @brief 发送完成回调函数类型
|
||
* @param status 发送状态
|
||
* @param user_data 用户数据
|
||
*/
|
||
typedef void (*rf433_tx_callback_t)(rf433_error_t status, void *user_data);
|
||
|
||
/* ============================================================================
|
||
* 核心API函数
|
||
* ============================================================================ */
|
||
|
||
/**
|
||
* @brief 初始化RF433模块
|
||
* @param config 初始配置（NULL使用默认配置）
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR 失败
|
||
*/
|
||
rf433_error_t rf433_init(const rf433_config_t *config);
|
||
|
||
/**
|
||
* @brief 反初始化RF433模块
|
||
* @return RF433_OK 成功
|
||
*/
|
||
rf433_error_t rf433_deinit(void);
|
||
|
||
/**
|
||
* @brief 设置模块配置
|
||
* @param config 配置参数
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR_BUSY 模块忙
|
||
* RF433_ERROR_TIMEOUT 超时
|
||
*/
|
||
rf433_error_t rf433_set_config(const rf433_config_t *config);
|
||
|
||
/**
|
||
* @brief 获取模块配置
|
||
* @param config 配置参数输出
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR_INVALID_PARAM 无效参数
|
||
*/
|
||
rf433_error_t rf433_get_config(rf433_config_t *config);
|
||
|
||
/**
|
||
* @brief 设置工作模式
|
||
* @param mode 工作模式
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR_BUSY 模块忙
|
||
*/
|
||
rf433_error_t rf433_set_work_mode(rf433_work_mode_t mode);
|
||
|
||
/**
|
||
* @brief 复位模块
|
||
* @return RF433_OK 成功
|
||
*/
|
||
rf433_error_t rf433_reset(void);
|
||
|
||
/* ============================================================================
|
||
* 条件编译的TX/RX API
|
||
* ============================================================================ */
|
||
|
||
#if (RF433_MODE == RF433_MODE_TX) || (RF433_MODE == RF433_MODE_BOTH)
|
||
#include "rf433_tx.h"
|
||
#endif
|
||
|
||
#if (RF433_MODE == RF433_MODE_RX) || (RF433_MODE == RF433_MODE_BOTH)
|
||
#include "rf433_rx.h"
|
||
#endif
|
||
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif
|
||
|
||
#endif /* __RF433_H__ */
|
||
```
|
||
|
||
### 4.2 TX模式接口 (rf433_tx.h)
|
||
|
||
```c
|
||
/**
|
||
* @file rf433_tx.h
|
||
* @brief RF433 TX模式接口
|
||
*/
|
||
|
||
#ifndef __RF433_TX_H__
|
||
#define __RF433_TX_H__
|
||
|
||
#ifdef __cplusplus
|
||
extern "C" {
|
||
#endif
|
||
|
||
#include "rf433.h"
|
||
|
||
/* ============================================================================
|
||
* TX模式API函数
|
||
* ============================================================================ */
|
||
|
||
/**
|
||
* @brief 发送数据（透明传输模式）
|
||
* @param data 数据指针
|
||
* @param length 数据长度
|
||
* @param timeout 超时时间（ms）
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR_BUSY 模块忙
|
||
* RF433_ERROR_TIMEOUT 超时
|
||
* RF433_ERROR_INVALID_PARAM 无效参数
|
||
*/
|
||
rf433_error_t rf433_tx_transparent(const uint8_t *data, uint16_t length, uint32_t timeout);
|
||
|
||
/**
|
||
* @brief 发送数据包（指定目标模式）
|
||
* @param packet 数据包
|
||
* @param timeout 超时时间（ms）
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR_BUSY 模块忙
|
||
* RF433_ERROR_TIMEOUT 超时
|
||
* RF433_ERROR_INVALID_PARAM 无效参数
|
||
*/
|
||
rf433_error_t rf433_tx_packet(const rf433_packet_t *packet, uint32_t timeout);
|
||
|
||
/**
|
||
* @brief 异步发送数据（透明传输模式）
|
||
* @param data 数据指针
|
||
* @param length 数据长度
|
||
* @param callback 发送完成回调
|
||
* @param user_data 用户数据
|
||
* @return RF433_OK 成功（已加入发送队列）
|
||
* RF433_ERROR_BUSY 发送队列满
|
||
* RF433_ERROR_INVALID_PARAM 无效参数
|
||
*/
|
||
rf433_error_t rf433_tx_transparent_async(const uint8_t *data, uint16_t length,
|
||
rf433_tx_callback_t callback, void *user_data);
|
||
|
||
/**
|
||
* @brief 异步发送数据包（指定目标模式）
|
||
* @param packet 数据包
|
||
* @param callback 发送完成回调
|
||
* @param user_data 用户数据
|
||
* @return RF433_OK 成功（已加入发送队列）
|
||
* RF433_ERROR_BUSY 发送队列满
|
||
* RF433_ERROR_INVALID_PARAM 无效参数
|
||
*/
|
||
rf433_error_t rf433_tx_packet_async(const rf433_packet_t *packet,
|
||
rf433_tx_callback_t callback, void *user_data);
|
||
|
||
/**
|
||
* @brief 取消发送
|
||
* @return RF433_OK 成功
|
||
*/
|
||
rf433_error_t rf433_tx_cancel(void);
|
||
|
||
/**
|
||
* @brief 获取发送状态
|
||
* @param is_busy 忙状态输出
|
||
* @return RF433_OK 成功
|
||
*/
|
||
rf433_error_t rf433_tx_get_status(bool *is_busy);
|
||
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif
|
||
|
||
#endif /* __RF433_TX_H__ */
|
||
```
|
||
|
||
### 4.3 RX模式接口 (rf433_rx.h)
|
||
|
||
```c
|
||
/**
|
||
* @file rf433_rx.h
|
||
* @brief RF433 RX模式接口
|
||
*/
|
||
|
||
#ifndef __RF433_RX_H__
|
||
#define __RF433_RX_H__
|
||
|
||
#ifdef __cplusplus
|
||
extern "C" {
|
||
#endif
|
||
|
||
#include "rf433.h"
|
||
|
||
/* ============================================================================
|
||
* RX模式API函数
|
||
* ============================================================================ */
|
||
|
||
/**
|
||
* @brief 启动接收
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR_BUSY 模块忙
|
||
*/
|
||
rf433_error_t rf433_rx_start(void);
|
||
|
||
/**
|
||
* @brief 停止接收
|
||
* @return RF433_OK 成功
|
||
*/
|
||
rf433_error_t rf433_rx_stop(void);
|
||
|
||
/**
|
||
* @brief 接收数据（阻塞模式）
|
||
* @param packet 数据包输出
|
||
* @param timeout 超时时间（ms）
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR_TIMEOUT 超时
|
||
* RF433_ERROR_INVALID_PARAM 无效参数
|
||
*/
|
||
rf433_error_t rf433_rx_receive(rf433_packet_t *packet, uint32_t timeout);
|
||
|
||
/**
|
||
* @brief 检查是否有数据可读
|
||
* @param has_data 是否有数据输出
|
||
* @return RF433_OK 成功
|
||
*/
|
||
rf433_error_t rf433_rx_check_data(bool *has_data);
|
||
|
||
/**
|
||
* @brief 读取数据（非阻塞模式）
|
||
* @param packet 数据包输出
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR_NO_DATA 无数据
|
||
* RF433_ERROR_INVALID_PARAM 无效参数
|
||
*/
|
||
rf433_error_t rf433_rx_read(rf433_packet_t *packet);
|
||
|
||
/**
|
||
* @brief 注册接收回调函数
|
||
* @param callback 回调函数
|
||
* @param user_data 用户数据
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR_INVALID_PARAM 无效参数
|
||
*/
|
||
rf433_error_t rf433_rx_register_callback(rf433_rx_callback_t callback, void *user_data);
|
||
|
||
/**
|
||
* @brief 注销接收回调函数
|
||
* @return RF433_OK 成功
|
||
*/
|
||
rf433_error_t rf433_rx_unregister_callback(void);
|
||
|
||
/**
|
||
* @brief 获取接收统计信息
|
||
* @param total_packets 总接收包数
|
||
* @param total_bytes 总接收字节数
|
||
* @param error_packets 错误包数
|
||
* @return RF433_OK 成功
|
||
*/
|
||
rf433_error_t rf433_rx_get_stats(uint32_t *total_packets, uint32_t *total_bytes,
|
||
uint32_t *error_packets);
|
||
|
||
/**
|
||
* @brief 清除接收统计信息
|
||
* @return RF433_OK 成功
|
||
*/
|
||
rf433_error_t rf433_rx_clear_stats(void);
|
||
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif
|
||
|
||
#endif /* __RF433_RX_H__ */
|
||
```
|
||
|
||
### 4.4 硬件抽象层接口 (rf433_hal.h)
|
||
|
||
```c
|
||
/**
|
||
* @file rf433_hal.h
|
||
* @brief RF433硬件抽象层接口
|
||
*/
|
||
|
||
#ifndef __RF433_HAL_H__
|
||
#define __RF433_HAL_H__
|
||
|
||
#ifdef __cplusplus
|
||
extern "C" {
|
||
#endif
|
||
|
||
#include "rf433.h"
|
||
|
||
/* ============================================================================
|
||
* HAL配置宏
|
||
* ============================================================================ */
|
||
|
||
/**
|
||
* @brief 是否使用AUX引脚检测忙状态
|
||
* @note 1: 使用AUX引脚（推荐）
|
||
* 0: 使用延时（不推荐）
|
||
*/
|
||
#ifndef RF433_USE_GPIO_AUX
|
||
#define RF433_USE_GPIO_AUX 1
|
||
#endif
|
||
|
||
/**
|
||
* @brief AUX引脚忙等待超时时间（ms）
|
||
*/
|
||
#ifndef RF433_AUX_TIMEOUT
|
||
#define RF433_AUX_TIMEOUT 100
|
||
#endif
|
||
|
||
/* ============================================================================
|
||
* HAL初始化函数
|
||
* ============================================================================ */
|
||
|
||
/**
|
||
* @brief 初始化硬件抽象层
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR 失败
|
||
*/
|
||
rf433_error_t rf433_hal_init(void);
|
||
|
||
/**
|
||
* @brief 反初始化硬件抽象层
|
||
* @return RF433_OK 成功
|
||
*/
|
||
rf433_error_t rf433_hal_deinit(void);
|
||
|
||
/* ============================================================================
|
||
* UART通信函数
|
||
* ============================================================================ */
|
||
|
||
/**
|
||
* @brief UART发送数据
|
||
* @param data 数据指针
|
||
* @param length 数据长度
|
||
* @param timeout 超时时间（ms）
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR_TIMEOUT 超时
|
||
*/
|
||
rf433_error_t rf433_hal_uart_tx(const uint8_t *data, uint16_t length, uint32_t timeout);
|
||
|
||
/**
|
||
* @brief UART接收数据（阻塞模式）
|
||
* @param data 数据缓冲区
|
||
* @param length 期望接收长度
|
||
* @param timeout 超时时间（ms）
|
||
* @param actual_length 实际接收长度
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR_TIMEOUT 超时
|
||
*/
|
||
rf433_error_t rf433_hal_uart_rx(uint8_t *data, uint16_t length, uint32_t timeout,
|
||
uint16_t *actual_length);
|
||
|
||
/**
|
||
* @brief UART接收数据（中断模式）
|
||
* @param data 数据缓冲区
|
||
* @param length 期望接收长度
|
||
* @return RF433_OK 成功（已启动接收）
|
||
* RF433_ERROR_BUSY 接收忙
|
||
*/
|
||
rf433_error_t rf433_hal_uart_rx_it(uint8_t *data, uint16_t length);
|
||
|
||
/**
|
||
* @brief UART接收完成回调
|
||
* @param data 数据指针
|
||
* @param length 接收长度
|
||
*/
|
||
void rf433_hal_uart_rx_callback(uint8_t *data, uint16_t length);
|
||
|
||
/* ============================================================================
|
||
* GPIO控制函数
|
||
* ============================================================================ */
|
||
|
||
/**
|
||
* @brief 等待AUX引脚变为空闲
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR_TIMEOUT 超时
|
||
*/
|
||
rf433_error_t rf433_hal_aux_wait(void);
|
||
|
||
/**
|
||
* @brief 设置工作模式
|
||
* @param mode 工作模式
|
||
* @return RF433_OK 成功
|
||
*/
|
||
rf433_error_t rf433_hal_set_work_mode(rf433_work_mode_t mode);
|
||
|
||
/**
|
||
* @brief 复位模块
|
||
* @return RF433_OK 成功
|
||
*/
|
||
rf433_error_t rf433_hal_reset(void);
|
||
|
||
/* ============================================================================
|
||
* FIFO操作函数
|
||
* ============================================================================ */
|
||
|
||
/**
|
||
* @brief 写入FIFO
|
||
* @param data 数据指针
|
||
* @param length 数据长度
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR_FULL FIFO满
|
||
*/
|
||
rf433_error_t rf433_hal_fifo_write(const uint8_t *data, uint16_t length);
|
||
|
||
/**
|
||
* @brief 读取FIFO
|
||
* @param data 数据缓冲区
|
||
* @param length 期望读取长度
|
||
* @param actual_length 实际读取长度
|
||
* @return RF433_OK 成功
|
||
* RF433_ERROR_EMPTY FIFO空
|
||
*/
|
||
rf433_error_t rf433_hal_fifo_read(uint8_t *data, uint16_t length, uint16_t *actual_length);
|
||
|
||
/**
|
||
* @brief 获取FIFO数据长度
|
||
* @param length 数据长度输出
|
||
* @return RF433_OK 成功
|
||
*/
|
||
rf433_error_t rf433_hal_fifo_get_length(uint16_t *length);
|
||
|
||
/**
|
||
* @brief 清空FIFO
|
||
* @return RF433_OK 成功
|
||
*/
|
||
rf433_error_t rf433_hal_fifo_clear(void);
|
||
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif
|
||
|
||
#endif /* __RF433_HAL_H__ */
|
||
```
|
||
|
||
---
|
||
|
||
## 五、关键代码片段示例
|
||
|
||
### 5.1 模块初始化示例
|
||
|
||
```c
|
||
/**
|
||
* @file rf433.c
|
||
* @brief RF433模块主实现
|
||
*/
|
||
|
||
#include "rf433.h"
|
||
#include "rf433_hal.h"
|
||
#include <string.h>
|
||
|
||
/* ============================================================================
|
||
* 私有变量
|
||
* ============================================================================ */
|
||
|
||
static bool rf433_initialized = false;
|
||
static rf433_config_t rf433_current_config;
|
||
|
||
/* 默认配置 */
|
||
static const rf433_config_t rf433_default_config = {
|
||
.address = 0x0000,
|
||
.channel = 0x17,
|
||
.radio_rate = RF433_RADIO_RATE_2400,
|
||
.uart_rate = RF433_UART_RATE_9600,
|
||
.uart_parity = RF433_UART_8N1,
|
||
.tx_power = RF433_TX_POWER_DBM_30,
|
||
.fec_enable = RF433_ON,
|
||
.specify_target = RF433_OFF,
|
||
};
|
||
|
||
/* ============================================================================
|
||
* 公共函数实现
|
||
* ============================================================================ */
|
||
|
||
rf433_error_t rf433_init(const rf433_config_t *config)
|
||
{
|
||
rf433_error_t ret;
|
||
|
||
/* 检查是否已初始化 */
|
||
if (rf433_initialized)
|
||
{
|
||
return RF433_ERROR;
|
||
}
|
||
|
||
/* 初始化硬件抽象层 */
|
||
ret = rf433_hal_init();
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
/* 复制配置 */
|
||
if (config == NULL)
|
||
{
|
||
memcpy(&rf433_current_config, &rf433_default_config, sizeof(rf433_config_t));
|
||
}
|
||
else
|
||
{
|
||
memcpy(&rf433_current_config, config, sizeof(rf433_config_t));
|
||
}
|
||
|
||
/* 设置模块配置 */
|
||
ret = rf433_set_config(&rf433_current_config);
|
||
if (ret != RF433_OK)
|
||
{
|
||
rf433_hal_deinit();
|
||
return ret;
|
||
}
|
||
|
||
/* 初始化TX/RX子模块 */
|
||
#if (RF433_MODE == RF433_MODE_TX) || (RF433_MODE == RF433_MODE_BOTH)
|
||
ret = rf433_tx_init();
|
||
if (ret != RF433_OK)
|
||
{
|
||
rf433_hal_deinit();
|
||
return ret;
|
||
}
|
||
#endif
|
||
|
||
#if (RF433_MODE == RF433_MODE_RX) || (RF433_MODE == RF433_MODE_BOTH)
|
||
ret = rf433_rx_init();
|
||
if (ret != RF433_OK)
|
||
{
|
||
#if (RF433_MODE == RF433_MODE_TX) || (RF433_MODE == RF433_MODE_BOTH)
|
||
rf433_tx_deinit();
|
||
#endif
|
||
rf433_hal_deinit();
|
||
return ret;
|
||
}
|
||
#endif
|
||
|
||
rf433_initialized = true;
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_deinit(void)
|
||
{
|
||
/* 检查是否已初始化 */
|
||
if (!rf433_initialized)
|
||
{
|
||
return RF433_ERROR_NOT_INIT;
|
||
}
|
||
|
||
/* 反初始化TX/RX子模块 */
|
||
#if (RF433_MODE == RF433_MODE_TX) || (RF433_MODE == RF433_MODE_BOTH)
|
||
rf433_tx_deinit();
|
||
#endif
|
||
|
||
#if (RF433_MODE == RF433_MODE_RX) || (RF433_MODE == RF433_MODE_BOTH)
|
||
rf433_rx_deinit();
|
||
#endif
|
||
|
||
/* 反初始化硬件抽象层 */
|
||
rf433_hal_deinit();
|
||
|
||
rf433_initialized = false;
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_set_config(const rf433_config_t *config)
|
||
{
|
||
rf433_error_t ret;
|
||
uint8_t cmd_buffer[7];
|
||
|
||
/* 参数检查 */
|
||
if (config == NULL)
|
||
{
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
/* 等待模块空闲 */
|
||
ret = rf433_hal_aux_wait();
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
/* 切换到配置模式 */
|
||
ret = rf433_hal_set_work_mode(RF433_MODE_CONFIG_AND_SLEEP);
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
/* 构造配置命令 */
|
||
cmd_buffer[0] = 0xC0; // 写配置命令
|
||
cmd_buffer[1] = (config->address >> 8) & 0xFF;
|
||
cmd_buffer[2] = config->address & 0xFF;
|
||
cmd_buffer[3] = (config->uart_rate << 5) | (config->uart_parity << 3) | config->radio_rate;
|
||
cmd_buffer[4] = config->channel;
|
||
cmd_buffer[5] = (config->specify_target << 7) | (config->reserve << 6) |
|
||
(config->fec_enable << 2) | config->tx_power;
|
||
cmd_buffer[6] = 0x00; // 保留字节
|
||
|
||
/* 发送配置命令 */
|
||
ret = rf433_hal_uart_tx(cmd_buffer, sizeof(cmd_buffer), RF433_DEFAULT_TIMEOUT);
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
/* 等待配置完成 */
|
||
ret = rf433_hal_aux_wait();
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
/* 切换回透明传输模式 */
|
||
ret = rf433_hal_set_work_mode(RF433_MODE_TRANSPARENT);
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
/* 保存配置 */
|
||
memcpy(&rf433_current_config, config, sizeof(rf433_config_t));
|
||
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_get_config(rf433_config_t *config)
|
||
{
|
||
/* 参数检查 */
|
||
if (config == NULL)
|
||
{
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
/* 复制当前配置 */
|
||
memcpy(config, &rf433_current_config, sizeof(rf433_config_t));
|
||
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_set_work_mode(rf433_work_mode_t mode)
|
||
{
|
||
return rf433_hal_set_work_mode(mode);
|
||
}
|
||
|
||
rf433_error_t rf433_reset(void)
|
||
{
|
||
return rf433_hal_reset();
|
||
}
|
||
```
|
||
|
||
### 5.2 TX模式实现示例
|
||
|
||
```c
|
||
/**
|
||
* @file rf433_tx.c
|
||
* @brief RF433 TX模式实现
|
||
*/
|
||
|
||
#include "rf433_tx.h"
|
||
#include "rf433_hal.h"
|
||
#include <string.h>
|
||
|
||
/* ============================================================================
|
||
* 私有变量
|
||
* ============================================================================ */
|
||
|
||
static bool rf433_tx_initialized = false;
|
||
static bool rf433_tx_busy = false;
|
||
|
||
/* ============================================================================
|
||
* 公共函数实现
|
||
* ============================================================================ */
|
||
|
||
rf433_error_t rf433_tx_init(void)
|
||
{
|
||
rf433_tx_initialized = true;
|
||
rf433_tx_busy = false;
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_tx_deinit(void)
|
||
{
|
||
rf433_tx_initialized = false;
|
||
rf433_tx_busy = false;
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_tx_transparent(const uint8_t *data, uint16_t length, uint32_t timeout)
|
||
{
|
||
rf433_error_t ret;
|
||
|
||
/* 参数检查 */
|
||
if (data == NULL || length == 0)
|
||
{
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
/* 检查是否已初始化 */
|
||
if (!rf433_tx_initialized)
|
||
{
|
||
return RF433_ERROR_NOT_INIT;
|
||
}
|
||
|
||
/* 检查是否忙 */
|
||
if (rf433_tx_busy)
|
||
{
|
||
return RF433_ERROR_BUSY;
|
||
}
|
||
|
||
/* 等待模块空闲 */
|
||
ret = rf433_hal_aux_wait();
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
/* 设置忙标志 */
|
||
rf433_tx_busy = true;
|
||
|
||
/* 发送数据 */
|
||
ret = rf433_hal_uart_tx(data, length, timeout);
|
||
|
||
/* 清除忙标志 */
|
||
rf433_tx_busy = false;
|
||
|
||
return ret;
|
||
}
|
||
|
||
rf433_error_t rf433_tx_packet(const rf433_packet_t *packet, uint32_t timeout)
|
||
{
|
||
rf433_error_t ret;
|
||
uint8_t buffer[RF433_MAX_PACKET_SIZE + 3];
|
||
|
||
/* 参数检查 */
|
||
if (packet == NULL || packet->length > RF433_MAX_PACKET_SIZE)
|
||
{
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
/* 检查是否已初始化 */
|
||
if (!rf433_tx_initialized)
|
||
{
|
||
return RF433_ERROR_NOT_INIT;
|
||
}
|
||
|
||
/* 检查是否忙 */
|
||
if (rf433_tx_busy)
|
||
{
|
||
return RF433_ERROR_BUSY;
|
||
}
|
||
|
||
/* 等待模块空闲 */
|
||
ret = rf433_hal_aux_wait();
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
/* 构造数据包 */
|
||
buffer[0] = (packet->address >> 8) & 0xFF;
|
||
buffer[1] = packet->address & 0xFF;
|
||
buffer[2] = packet->channel;
|
||
memcpy(&buffer[3], packet->data, packet->length);
|
||
|
||
/* 设置忙标志 */
|
||
rf433_tx_busy = true;
|
||
|
||
/* 发送数据包 */
|
||
ret = rf433_hal_uart_tx(buffer, packet->length + 3, timeout);
|
||
|
||
/* 清除忙标志 */
|
||
rf433_tx_busy = false;
|
||
|
||
return ret;
|
||
}
|
||
|
||
rf433_error_t rf433_tx_transparent_async(const uint8_t *data, uint16_t length,
|
||
rf433_tx_callback_t callback, void *user_data)
|
||
{
|
||
/* TODO: 实现异步发送 */
|
||
return RF433_ERROR;
|
||
}
|
||
|
||
rf433_error_t rf433_tx_packet_async(const rf433_packet_t *packet,
|
||
rf433_tx_callback_t callback, void *user_data)
|
||
{
|
||
/* TODO: 实现异步发送 */
|
||
return RF433_ERROR;
|
||
}
|
||
|
||
rf433_error_t rf433_tx_cancel(void)
|
||
{
|
||
/* TODO: 实现取消发送 */
|
||
return RF433_ERROR;
|
||
}
|
||
|
||
rf433_error_t rf433_tx_get_status(bool *is_busy)
|
||
{
|
||
if (is_busy == NULL)
|
||
{
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
*is_busy = rf433_tx_busy;
|
||
return RF433_OK;
|
||
}
|
||
```
|
||
|
||
### 5.3 RX模式实现示例
|
||
|
||
```c
|
||
/**
|
||
* @file rf433_rx.c
|
||
* @brief RF433 RX模式实现
|
||
*/
|
||
|
||
#include "rf433_rx.h"
|
||
#include "rf433_hal.h"
|
||
#include <string.h>
|
||
|
||
/* ============================================================================
|
||
* 私有变量
|
||
* ============================================================================ */
|
||
|
||
static bool rf433_rx_initialized = false;
|
||
static bool rf433_rx_started = false;
|
||
static rf433_rx_callback_t rf433_rx_callback = NULL;
|
||
static void *rf433_rx_user_data = NULL;
|
||
|
||
/* 接收统计 */
|
||
static uint32_t rf433_rx_total_packets = 0;
|
||
static uint32_t rf433_rx_total_bytes = 0;
|
||
static uint32_t rf433_rx_error_packets = 0;
|
||
|
||
/* ============================================================================
|
||
* 公共函数实现
|
||
* ============================================================================ */
|
||
|
||
rf433_error_t rf433_rx_init(void)
|
||
{
|
||
rf433_rx_initialized = true;
|
||
rf433_rx_started = false;
|
||
rf433_rx_callback = NULL;
|
||
rf433_rx_user_data = NULL;
|
||
rf433_rx_total_packets = 0;
|
||
rf433_rx_total_bytes = 0;
|
||
rf433_rx_error_packets = 0;
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_rx_deinit(void)
|
||
{
|
||
rf433_rx_stop();
|
||
rf433_rx_initialized = false;
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_rx_start(void)
|
||
{
|
||
rf433_error_t ret;
|
||
|
||
/* 检查是否已初始化 */
|
||
if (!rf433_rx_initialized)
|
||
{
|
||
return RF433_ERROR_NOT_INIT;
|
||
}
|
||
|
||
/* 检查是否已启动 */
|
||
if (rf433_rx_started)
|
||
{
|
||
return RF433_ERROR_BUSY;
|
||
}
|
||
|
||
/* 清空FIFO */
|
||
ret = rf433_hal_fifo_clear();
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
/* 启动UART接收 */
|
||
uint8_t dummy;
|
||
ret = rf433_hal_uart_rx_it(&dummy, 1);
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
rf433_rx_started = true;
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_rx_stop(void)
|
||
{
|
||
/* 检查是否已初始化 */
|
||
if (!rf433_rx_initialized)
|
||
{
|
||
return RF433_ERROR_NOT_INIT;
|
||
}
|
||
|
||
rf433_rx_started = false;
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_rx_receive(rf433_packet_t *packet, uint32_t timeout)
|
||
{
|
||
rf433_error_t ret;
|
||
uint16_t length;
|
||
uint32_t start_time;
|
||
|
||
/* 参数检查 */
|
||
if (packet == NULL)
|
||
{
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
/* 检查是否已初始化 */
|
||
if (!rf433_rx_initialized)
|
||
{
|
||
return RF433_ERROR_NOT_INIT;
|
||
}
|
||
|
||
/* 等待数据 */
|
||
start_time = HAL_GetTick();
|
||
while (true)
|
||
{
|
||
ret = rf433_hal_fifo_get_length(&length);
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
if (length > 0)
|
||
{
|
||
break;
|
||
}
|
||
|
||
/* 检查超时 */
|
||
if (timeout > 0 && (HAL_GetTick() - start_time) >= timeout)
|
||
{
|
||
return RF433_ERROR_TIMEOUT;
|
||
}
|
||
|
||
HAL_Delay(1);
|
||
}
|
||
|
||
/* 读取数据 */
|
||
if (length > RF433_MAX_PACKET_SIZE)
|
||
{
|
||
length = RF433_MAX_PACKET_SIZE;
|
||
}
|
||
|
||
ret = rf433_hal_fifo_read(packet->data, length, &packet->length);
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
/* 更新统计 */
|
||
rf433_rx_total_packets++;
|
||
rf433_rx_total_bytes += packet->length;
|
||
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_rx_check_data(bool *has_data)
|
||
{
|
||
rf433_error_t ret;
|
||
uint16_t length;
|
||
|
||
/* 参数检查 */
|
||
if (has_data == NULL)
|
||
{
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
/* 检查是否已初始化 */
|
||
if (!rf433_rx_initialized)
|
||
{
|
||
return RF433_ERROR_NOT_INIT;
|
||
}
|
||
|
||
/* 获取FIFO长度 */
|
||
ret = rf433_hal_fifo_get_length(&length);
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
*has_data = (length > 0);
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_rx_read(rf433_packet_t *packet)
|
||
{
|
||
rf433_error_t ret;
|
||
uint16_t length;
|
||
|
||
/* 参数检查 */
|
||
if (packet == NULL)
|
||
{
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
/* 检查是否已初始化 */
|
||
if (!rf433_rx_initialized)
|
||
{
|
||
return RF433_ERROR_NOT_INIT;
|
||
}
|
||
|
||
/* 获取FIFO长度 */
|
||
ret = rf433_hal_fifo_get_length(&length);
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
/* 检查是否有数据 */
|
||
if (length == 0)
|
||
{
|
||
return RF433_ERROR_NO_DATA;
|
||
}
|
||
|
||
/* 读取数据 */
|
||
if (length > RF433_MAX_PACKET_SIZE)
|
||
{
|
||
length = RF433_MAX_PACKET_SIZE;
|
||
}
|
||
|
||
ret = rf433_hal_fifo_read(packet->data, length, &packet->length);
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
/* 更新统计 */
|
||
rf433_rx_total_packets++;
|
||
rf433_rx_total_bytes += packet->length;
|
||
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_rx_register_callback(rf433_rx_callback_t callback, void *user_data)
|
||
{
|
||
/* 参数检查 */
|
||
if (callback == NULL)
|
||
{
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
/* 检查是否已初始化 */
|
||
if (!rf433_rx_initialized)
|
||
{
|
||
return RF433_ERROR_NOT_INIT;
|
||
}
|
||
|
||
rf433_rx_callback = callback;
|
||
rf433_rx_user_data = user_data;
|
||
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_rx_unregister_callback(void)
|
||
{
|
||
rf433_rx_callback = NULL;
|
||
rf433_rx_user_data = NULL;
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_rx_get_stats(uint32_t *total_packets, uint32_t *total_bytes,
|
||
uint32_t *error_packets)
|
||
{
|
||
/* 检查是否已初始化 */
|
||
if (!rf433_rx_initialized)
|
||
{
|
||
return RF433_ERROR_NOT_INIT;
|
||
}
|
||
|
||
if (total_packets != NULL)
|
||
{
|
||
*total_packets = rf433_rx_total_packets;
|
||
}
|
||
|
||
if (total_bytes != NULL)
|
||
{
|
||
*total_bytes = rf433_rx_total_bytes;
|
||
}
|
||
|
||
if (error_packets != NULL)
|
||
{
|
||
*error_packets = rf433_rx_error_packets;
|
||
}
|
||
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_rx_clear_stats(void)
|
||
{
|
||
/* 检查是否已初始化 */
|
||
if (!rf433_rx_initialized)
|
||
{
|
||
return RF433_ERROR_NOT_INIT;
|
||
}
|
||
|
||
rf433_rx_total_packets = 0;
|
||
rf433_rx_total_bytes = 0;
|
||
rf433_rx_error_packets = 0;
|
||
|
||
return RF433_OK;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* UART接收回调（由HAL层调用）
|
||
* ============================================================================ */
|
||
|
||
void rf433_rx_uart_callback(uint8_t *data, uint16_t length)
|
||
{
|
||
rf433_error_t ret;
|
||
rf433_packet_t packet;
|
||
|
||
/* 检查是否已启动 */
|
||
if (!rf433_rx_started)
|
||
{
|
||
return;
|
||
}
|
||
|
||
/* 写入FIFO */
|
||
ret = rf433_hal_fifo_write(data, length);
|
||
if (ret != RF433_OK)
|
||
{
|
||
rf433_rx_error_packets++;
|
||
return;
|
||
}
|
||
|
||
/* 如果有回调函数，调用回调 */
|
||
if (rf433_rx_callback != NULL)
|
||
{
|
||
/* 读取数据 */
|
||
ret = rf433_hal_fifo_read(packet.data, RF433_MAX_PACKET_SIZE, &packet.length);
|
||
if (ret == RF433_OK)
|
||
{
|
||
/* 调用回调 */
|
||
rf433_rx_callback(&packet, rf433_rx_user_data);
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
### 5.4 硬件抽象层实现示例
|
||
|
||
```c
|
||
/**
|
||
* @file rf433_hal.c
|
||
* @brief RF433硬件抽象层实现
|
||
*/
|
||
|
||
#include "rf433_hal.h"
|
||
#include "main.h"
|
||
#include "usart.h"
|
||
#include "gpio.h"
|
||
#include <string.h>
|
||
|
||
/* ============================================================================
|
||
* 私有变量
|
||
* ============================================================================ */
|
||
|
||
static bool rf433_hal_initialized = false;
|
||
static uint8_t rf433_fifo_buffer[RF433_FIFO_SIZE];
|
||
static fifo_t rf433_fifo;
|
||
static uint8_t rf433_uart_rx_buffer[256];
|
||
static uint16_t rf433_uart_rx_index = 0;
|
||
static volatile uint32_t rf433_uart_rx_timeout = 0;
|
||
static volatile bool rf433_uart_rx_done = false;
|
||
|
||
/* ============================================================================
|
||
* 公共函数实现
|
||
* ============================================================================ */
|
||
|
||
rf433_error_t rf433_hal_init(void)
|
||
{
|
||
fifo_error_t ret;
|
||
|
||
/* 检查是否已初始化 */
|
||
if (rf433_hal_initialized)
|
||
{
|
||
return RF433_ERROR;
|
||
}
|
||
|
||
/* 初始化FIFO */
|
||
ret = fifo_create(&rf433_fifo, rf433_fifo_buffer, RF433_FIFO_SIZE);
|
||
if (ret != FIFO_OK)
|
||
{
|
||
return RF433_ERROR;
|
||
}
|
||
|
||
rf433_hal_initialized = true;
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_hal_deinit(void)
|
||
{
|
||
/* 检查是否已初始化 */
|
||
if (!rf433_hal_initialized)
|
||
{
|
||
return RF433_ERROR_NOT_INIT;
|
||
}
|
||
|
||
rf433_hal_initialized = false;
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_hal_uart_tx(const uint8_t *data, uint16_t length, uint32_t timeout)
|
||
{
|
||
HAL_StatusTypeDef ret;
|
||
|
||
/* 参数检查 */
|
||
if (data == NULL || length == 0)
|
||
{
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
/* 发送数据 */
|
||
ret = HAL_UART_Transmit(&huart1, (uint8_t *)data, length, timeout);
|
||
if (ret != HAL_OK)
|
||
{
|
||
return RF433_ERROR_TIMEOUT;
|
||
}
|
||
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_hal_uart_rx(uint8_t *data, uint16_t length, uint32_t timeout,
|
||
uint16_t *actual_length)
|
||
{
|
||
HAL_StatusTypeDef ret;
|
||
|
||
/* 参数检查 */
|
||
if (data == NULL || length == 0 || actual_length == NULL)
|
||
{
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
/* 接收数据 */
|
||
ret = HAL_UART_Receive(&huart1, data, length, timeout);
|
||
if (ret != HAL_OK)
|
||
{
|
||
*actual_length = 0;
|
||
return RF433_ERROR_TIMEOUT;
|
||
}
|
||
|
||
*actual_length = length;
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_hal_uart_rx_it(uint8_t *data, uint16_t length)
|
||
{
|
||
HAL_StatusTypeDef ret;
|
||
|
||
/* 参数检查 */
|
||
if (data == NULL || length == 0)
|
||
{
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
/* 启动中断接收 */
|
||
ret = HAL_UART_Receive_IT(&huart1, data, length);
|
||
if (ret != HAL_OK)
|
||
{
|
||
return RF433_ERROR_BUSY;
|
||
}
|
||
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_hal_aux_wait(void)
|
||
{
|
||
#if RF433_USE_GPIO_AUX
|
||
uint32_t start_time;
|
||
|
||
/* 等待AUX引脚变为高电平 */
|
||
start_time = HAL_GetTick();
|
||
while (HAL_GPIO_ReadPin(AUX_GPIO_Port, AUX_Pin) == GPIO_PIN_RESET)
|
||
{
|
||
/* 检查超时 */
|
||
if ((HAL_GetTick() - start_time) >= RF433_AUX_TIMEOUT)
|
||
{
|
||
return RF433_ERROR_TIMEOUT;
|
||
}
|
||
}
|
||
|
||
/* 等待AUX引脚稳定 */
|
||
HAL_Delay(2);
|
||
#else
|
||
/* 使用延时等待 */
|
||
HAL_Delay(30);
|
||
#endif
|
||
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_hal_set_work_mode(rf433_work_mode_t mode)
|
||
{
|
||
rf433_error_t ret;
|
||
|
||
/* 等待模块空闲 */
|
||
ret = rf433_hal_aux_wait();
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
/* 设置M0和M1引脚 */
|
||
switch (mode)
|
||
{
|
||
case RF433_MODE_TRANSPARENT:
|
||
HAL_GPIO_WritePin(M0_GPIO_Port, M0_Pin, GPIO_PIN_RESET);
|
||
HAL_GPIO_WritePin(M1_GPIO_Port, M1_Pin, GPIO_PIN_RESET);
|
||
break;
|
||
|
||
case RF433_MODE_WAKE_ON_RADIO_MASTER:
|
||
HAL_GPIO_WritePin(M0_GPIO_Port, M0_Pin, GPIO_PIN_SET);
|
||
HAL_GPIO_WritePin(M1_GPIO_Port, M1_Pin, GPIO_PIN_RESET);
|
||
break;
|
||
|
||
case RF433_MODE_WAKE_ON_RADIO_SLAVE:
|
||
HAL_GPIO_WritePin(M0_GPIO_Port, M0_Pin, GPIO_PIN_RESET);
|
||
HAL_GPIO_WritePin(M1_GPIO_Port, M1_Pin, GPIO_PIN_SET);
|
||
break;
|
||
|
||
case RF433_MODE_CONFIG_AND_SLEEP:
|
||
HAL_GPIO_WritePin(M0_GPIO_Port, M0_Pin, GPIO_PIN_SET);
|
||
HAL_GPIO_WritePin(M1_GPIO_Port, M1_Pin, GPIO_PIN_SET);
|
||
break;
|
||
|
||
default:
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
/* 等待模式切换完成 */
|
||
HAL_Delay(5);
|
||
ret = rf433_hal_aux_wait();
|
||
if (ret != RF433_OK)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_hal_reset(void)
|
||
{
|
||
/* 拉低复位引脚 */
|
||
HAL_GPIO_WritePin(RESET_GPIO_Port, RESET_Pin, GPIO_PIN_RESET);
|
||
HAL_Delay(1);
|
||
|
||
/* 拉高复位引脚 */
|
||
HAL_GPIO_WritePin(RESET_GPIO_Port, RESET_Pin, GPIO_PIN_SET);
|
||
|
||
/* 等待复位完成 */
|
||
#if RF433_USE_GPIO_AUX
|
||
HAL_Delay(10);
|
||
return rf433_hal_aux_wait();
|
||
#else
|
||
HAL_Delay(30);
|
||
return RF433_OK;
|
||
#endif
|
||
}
|
||
|
||
rf433_error_t rf433_hal_fifo_write(const uint8_t *data, uint16_t length)
|
||
{
|
||
fifo_error_t ret;
|
||
|
||
/* 参数检查 */
|
||
if (data == NULL || length == 0)
|
||
{
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
/* 写入FIFO */
|
||
ret = fifo_write(&rf433_fifo, (uint8_t *)data, length);
|
||
if (ret != FIFO_OK)
|
||
{
|
||
return RF433_ERROR;
|
||
}
|
||
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_hal_fifo_read(uint8_t *data, uint16_t length, uint16_t *actual_length)
|
||
{
|
||
fifo_error_t ret;
|
||
uint32_t fifo_length;
|
||
|
||
/* 参数检查 */
|
||
if (data == NULL || length == 0 || actual_length == NULL)
|
||
{
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
/* 获取FIFO长度 */
|
||
ret = fifo_get_length(&rf433_fifo, &fifo_length);
|
||
if (ret != FIFO_OK)
|
||
{
|
||
return RF433_ERROR;
|
||
}
|
||
|
||
/* 检查是否有数据 */
|
||
if (fifo_length == 0)
|
||
{
|
||
*actual_length = 0;
|
||
return RF433_ERROR;
|
||
}
|
||
|
||
/* 读取数据 */
|
||
if (fifo_length > length)
|
||
{
|
||
fifo_length = length;
|
||
}
|
||
|
||
ret = fifo_read(&rf433_fifo, data, fifo_length);
|
||
if (ret != FIFO_OK)
|
||
{
|
||
*actual_length = 0;
|
||
return RF433_ERROR;
|
||
}
|
||
|
||
*actual_length = fifo_length;
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_hal_fifo_get_length(uint16_t *length)
|
||
{
|
||
fifo_error_t ret;
|
||
uint32_t fifo_length;
|
||
|
||
/* 参数检查 */
|
||
if (length == NULL)
|
||
{
|
||
return RF433_ERROR_INVALID_PARAM;
|
||
}
|
||
|
||
/* 获取FIFO长度 */
|
||
ret = fifo_get_length(&rf433_fifo, &fifo_length);
|
||
if (ret != FIFO_OK)
|
||
{
|
||
return RF433_ERROR;
|
||
}
|
||
|
||
*length = fifo_length;
|
||
return RF433_OK;
|
||
}
|
||
|
||
rf433_error_t rf433_hal_fifo_clear(void)
|
||
{
|
||
fifo_error_t ret;
|
||
|
||
/* 清空FIFO */
|
||
ret = fifo_clear(&rf433_fifo);
|
||
if (ret != FIFO_OK)
|
||
{
|
||
return RF433_ERROR;
|
||
}
|
||
|
||
return RF433_OK;
|
||
}
|
||
|
||
/* ============================================================================
|
||
* UART接收中断回调
|
||
* ============================================================================ */
|
||
|
||
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
|
||
{
|
||
if (huart->Instance == USART1)
|
||
{
|
||
/* 写入FIFO */
|
||
fifo_write(&rf433_fifo, rf433_uart_rx_buffer, rf433_uart_rx_index);
|
||
|
||
/* 设置超时 */
|
||
rf433_uart_rx_timeout = 10;
|
||
|
||
/* 重新启动接收 */
|
||
HAL_UART_Receive_IT(&huart1, rf433_uart_rx_buffer, 1);
|
||
rf433_uart_rx_index = 1;
|
||
}
|
||
}
|
||
|
||
/* ============================================================================
|
||
* 1ms定时器回调（用于超时检测）
|
||
* ============================================================================ */
|
||
|
||
void rf433_hal_1ms_callback(void)
|
||
{
|
||
/* UART接收超时检测 */
|
||
if (rf433_uart_rx_timeout > 0)
|
||
{
|
||
rf433_uart_rx_timeout--;
|
||
|
||
if (rf433_uart_rx_timeout == 0)
|
||
{
|
||
rf433_uart_rx_done = true;
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 六、解耦操作步骤
|
||
|
||
### 6.1 第一阶段：准备工作
|
||
|
||
#### 步骤1：备份现有代码
|
||
```bash
|
||
# 创建备份目录
|
||
mkdir -p backup/original
|
||
|
||
# 复制关键文件到备份目录
|
||
cp Core/Inc/e32_hal.h backup/original/
|
||
cp Core/Src/e32_hal.c backup/original/
|
||
cp Core/Inc/e32_demo.h backup/original/
|
||
cp Core/Src/e32_demo.c backup/original/
|
||
```
|
||
|
||
#### 步骤2：创建新模块目录
|
||
```bash
|
||
# 创建Driver_RF433目录结构
|
||
mkdir -p Driver_RF433/Inc
|
||
mkdir -p Driver_RF433/Src
|
||
mkdir -p Driver_RF433/docs
|
||
```
|
||
|
||
### 6.2 第二阶段：模块提取
|
||
|
||
#### 步骤3：提取硬件抽象层
|
||
1. 从 `e32_hal.c` 提取硬件相关函数
|
||
2. 重命名为 `rf433_hal.c`
|
||
3. 修改函数名前缀为 `rf433_hal_`
|
||
4. 移除对应用层的依赖
|
||
|
||
#### 步骤4：提取TX功能
|
||
1. 从 `e32_demo.c` 提取发送相关函数
|
||
2. 创建 `rf433_tx.c`
|
||
3. 实现阻塞和异步发送接口
|
||
|
||
#### 步骤5：提取RX功能
|
||
1. 从 `usart.c` 提取接收相关函数
|
||
2. 创建 `rf433_rx.c`
|
||
3. 实现阻塞和非阻塞接收接口
|
||
|
||
### 6.3 第三阶段：依赖解耦
|
||
|
||
#### 步骤6：处理全局变量依赖
|
||
**问题**: 原代码使用全局变量 `huart1`、`usb_rx_data` 等
|
||
|
||
**解决方案**:
|
||
1. 在 `rf433_hal.c` 中使用局部变量
|
||
2. 通过配置结构体传递硬件资源
|
||
3. 使用回调函数处理接收数据
|
||
|
||
#### 步骤7：处理中断向量依赖
|
||
**问题**: UART中断回调在 `usart.c` 中
|
||
|
||
**解决方案**:
|
||
1. 在 `rf433_hal.c` 中定义中断回调函数
|
||
2. 在 `stm32f1xx_it.c` 中调用RF433模块的回调
|
||
3. 使用函数指针实现回调注册
|
||
|
||
#### 步骤8：处理硬件资源冲突
|
||
**问题**: UART1被USB和E32模块共享
|
||
|
||
**解决方案**:
|
||
1. 在 `rf433_hal.c` 中实现UART资源管理
|
||
2. 提供UART锁定/解锁接口
|
||
3. 使用互斥锁保护共享资源
|
||
|
||
### 6.4 第四阶段：集成测试
|
||
|
||
#### 步骤9：修改应用层代码
|
||
1. 在 `main.c` 中包含 `rf433.h`
|
||
2. 替换 `e32_demo_*` 函数调用为 `rf433_*` 函数
|
||
3. 修改USB CDC接口，使用RF433模块API
|
||
|
||
#### 步骤10：编译测试
|
||
```bash
|
||
# 编译TX模式
|
||
make RF433_MODE=RF433_MODE_TX
|
||
|
||
# 编译RX模式
|
||
make RF433_MODE=RF433_MODE_RX
|
||
|
||
# 编译完整模式
|
||
make RF433_MODE=RF433_MODE_BOTH
|
||
```
|
||
|
||
#### 步骤11：功能测试
|
||
1. 测试TX模式：发送数据到E32模块
|
||
2. 测试RX模式：接收E32模块数据
|
||
3. 测试配置功能：修改模块参数
|
||
4. 测试模式切换：在不同工作模式间切换
|
||
|
||
### 6.5 第五阶段：清理优化
|
||
|
||
#### 步骤12：删除旧代码
|
||
```bash
|
||
# 删除旧的E32模块文件
|
||
rm Core/Inc/e32_hal.h
|
||
rm Core/Src/e32_hal.c
|
||
rm Core/Inc/e32_demo.h
|
||
rm Core/Src/e32_demo.c
|
||
```
|
||
|
||
#### 步骤13：更新文档
|
||
1. 更新 `AGENTS.md` 中的代码风格指南
|
||
2. 创建 `Driver_RF433/docs/rf433_api.md`
|
||
3. 创建 `Driver_RF433/docs/rf433_integration.md`
|
||
|
||
#### 步骤14：代码审查
|
||
1. 检查代码风格一致性
|
||
2. 检查注释完整性
|
||
3. 检查错误处理完整性
|
||
|
||
---
|
||
|
||
## 七、预编译宏方案
|
||
|
||
### 7.1 编译模式选择
|
||
|
||
#### 方案1：在头文件中定义
|
||
```c
|
||
// 在 rf433_config.h 中定义
|
||
#define RF433_MODE RF433_MODE_TX // 或 RF433_MODE_RX, RF433_MODE_BOTH
|
||
```
|
||
|
||
#### 方案2：在编译命令中定义
|
||
```bash
|
||
# Keil MDK
|
||
CFLAGS += -DRF433_MODE=RF433_MODE_TX
|
||
|
||
# GCC
|
||
gcc -DRF433_MODE=RF433_MODE_TX ...
|
||
```
|
||
|
||
#### 方案3：在项目配置文件中定义
|
||
```c
|
||
// 在 rf433_config.h 中
|
||
#ifndef RF433_MODE
|
||
#define RF433_MODE RF433_MODE_BOTH
|
||
#endif
|
||
```
|
||
|
||
### 7.2 条件编译示例
|
||
|
||
```c
|
||
// rf433.c
|
||
#include "rf433.h"
|
||
#include "rf433_hal.h"
|
||
|
||
#if (RF433_MODE == RF433_MODE_TX) || (RF433_MODE == RF433_MODE_BOTH)
|
||
#include "rf433_tx.h"
|
||
#endif
|
||
|
||
#if (RF433_MODE == RF433_MODE_RX) || (RF433_MODE == RF433_MODE_BOTH)
|
||
#include "rf433_rx.h"
|
||
#endif
|
||
|
||
rf433_error_t rf433_init(const rf433_config_t *config)
|
||
{
|
||
// ... 初始化代码 ...
|
||
|
||
#if (RF433_MODE == RF433_MODE_TX) || (RF433_MODE == RF433_MODE_BOTH)
|
||
rf433_tx_init();
|
||
#endif
|
||
|
||
#if (RF433_MODE == RF433_MODE_RX) || (RF433_MODE == RF433_MODE_BOTH)
|
||
rf433_rx_init();
|
||
#endif
|
||
|
||
return RF433_OK;
|
||
}
|
||
```
|
||
|
||
### 7.3 资源占用对比
|
||
|
||
| 编译模式 | Flash占用 | RAM占用 | 功能 |
|
||
|---------|----------|---------|------|
|
||
| RF433_MODE_TX | ~8KB | ~2KB | 仅发送 |
|
||
| RF433_MODE_RX | ~10KB | ~3KB | 仅接收 |
|
||
| RF433_MODE_BOTH | ~16KB | ~5KB | 发送+接收 |
|
||
|
||
### 7.4 编译建议
|
||
|
||
1. **TX专用设备**: 使用 `RF433_MODE_TX`，节省Flash和RAM
|
||
2. **RX专用设备**: 使用 `RF433_MODE_RX`，节省Flash和RAM
|
||
3. **双向通信设备**: 使用 `RF433_MODE_BOTH`，支持完整功能
|
||
|
||
---
|
||
|
||
## 八、集成示例
|
||
|
||
### 8.1 TX模式集成示例
|
||
|
||
```c
|
||
// main.c
|
||
#include "rf433.h"
|
||
|
||
int main(void)
|
||
{
|
||
rf433_config_t config;
|
||
rf433_error_t ret;
|
||
uint8_t data[] = "Hello RF433!";
|
||
|
||
/* 系统初始化 */
|
||
HAL_Init();
|
||
SystemClock_Config();
|
||
MX_GPIO_Init();
|
||
MX_USART1_UART_Init();
|
||
|
||
/* 初始化RF433模块（TX模式） */
|
||
config.address = 0x0000;
|
||
config.channel = 0x17;
|
||
config.radio_rate = RF433_RADIO_RATE_2400;
|
||
config.uart_rate = RF433_UART_RATE_9600;
|
||
config.uart_parity = RF433_UART_8N1;
|
||
config.tx_power = RF433_TX_POWER_DBM_30;
|
||
config.fec_enable = RF433_ON;
|
||
config.specify_target = RF433_OFF;
|
||
|
||
ret = rf433_init(&config);
|
||
if (ret != RF433_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
|
||
/* 主循环 */
|
||
while (1)
|
||
{
|
||
/* 发送数据 */
|
||
ret = rf433_tx_transparent(data, sizeof(data), 1000);
|
||
if (ret != RF433_OK)
|
||
{
|
||
/* 错误处理 */
|
||
}
|
||
|
||
HAL_Delay(1000);
|
||
}
|
||
}
|
||
```
|
||
|
||
### 8.2 RX模式集成示例
|
||
|
||
```c
|
||
// main.c
|
||
#include "rf433.h"
|
||
|
||
/* 接收回调函数 */
|
||
void rf433_rx_callback(const rf433_packet_t *packet, void *user_data)
|
||
{
|
||
/* 处理接收到的数据 */
|
||
// ...
|
||
}
|
||
|
||
int main(void)
|
||
{
|
||
rf433_config_t config;
|
||
rf433_error_t ret;
|
||
|
||
/* 系统初始化 */
|
||
HAL_Init();
|
||
SystemClock_Config();
|
||
MX_GPIO_Init();
|
||
MX_USART1_UART_Init();
|
||
|
||
/* 初始化RF433模块（RX模式） */
|
||
config.address = 0x0000;
|
||
config.channel = 0x17;
|
||
config.radio_rate = RF433_RADIO_RATE_2400;
|
||
config.uart_rate = RF433_UART_RATE_9600;
|
||
config.uart_parity = RF433_UART_8N1;
|
||
config.tx_power = RF433_TX_POWER_DBM_30;
|
||
config.fec_enable = RF433_ON;
|
||
config.specify_target = RF433_OFF;
|
||
|
||
ret = rf433_init(&config);
|
||
if (ret != RF433_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
|
||
/* 注册接收回调 */
|
||
rf433_rx_register_callback(rf433_rx_callback, NULL);
|
||
|
||
/* 启动接收 */
|
||
ret = rf433_rx_start();
|
||
if (ret != RF433_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
|
||
/* 主循环 */
|
||
while (1)
|
||
{
|
||
/* 其他任务 */
|
||
HAL_Delay(100);
|
||
}
|
||
}
|
||
```
|
||
|
||
### 8.3 双向通信集成示例
|
||
|
||
```c
|
||
// main.c
|
||
#include "rf433.h"
|
||
|
||
/* 接收回调函数 */
|
||
void rf433_rx_callback(const rf433_packet_t *packet, void *user_data)
|
||
{
|
||
/* 处理接收到的数据 */
|
||
// ...
|
||
|
||
/* 回复数据 */
|
||
rf433_tx_transparent(packet->data, packet->length, 1000);
|
||
}
|
||
|
||
int main(void)
|
||
{
|
||
rf433_config_t config;
|
||
rf433_error_t ret;
|
||
uint8_t data[] = "Hello RF433!";
|
||
|
||
/* 系统初始化 */
|
||
HAL_Init();
|
||
SystemClock_Config();
|
||
MX_GPIO_Init();
|
||
MX_USART1_UART_Init();
|
||
|
||
/* 初始化RF433模块（双向模式） */
|
||
config.address = 0x0000;
|
||
config.channel = 0x17;
|
||
config.radio_rate = RF433_RADIO_RATE_2400;
|
||
config.uart_rate = RF433_UART_RATE_9600;
|
||
config.uart_parity = RF433_UART_8N1;
|
||
config.tx_power = RF433_TX_POWER_DBM_30;
|
||
config.fec_enable = RF433_ON;
|
||
config.specify_target = RF433_OFF;
|
||
|
||
ret = rf433_init(&config);
|
||
if (ret != RF433_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
|
||
/* 注册接收回调 */
|
||
rf433_rx_register_callback(rf433_rx_callback, NULL);
|
||
|
||
/* 启动接收 */
|
||
ret = rf433_rx_start();
|
||
if (ret != RF433_OK)
|
||
{
|
||
Error_Handler();
|
||
}
|
||
|
||
/* 主循环 */
|
||
while (1)
|
||
{
|
||
/* 定期发送数据 */
|
||
ret = rf433_tx_transparent(data, sizeof(data), 1000);
|
||
if (ret != RF433_OK)
|
||
{
|
||
/* 错误处理 */
|
||
}
|
||
|
||
HAL_Delay(1000);
|
||
}
|
||
}
|
||
```
|
||
|
||
---
|
||
|
||
## 九、总结与建议
|
||
|
||
### 9.1 方案优势
|
||
|
||
1. **模块化设计**: 清晰的模块边界，易于维护和扩展
|
||
2. **资源优化**: 通过预编译宏减少不必要的代码编译
|
||
3. **接口统一**: 提供统一的API接口，简化应用层调用
|
||
4. **可移植性**: 硬件抽象层设计，易于移植到其他平台
|
||
5. **可测试性**: 模块独立，便于单元测试
|
||
|
||
### 9.2 实施建议
|
||
|
||
1. **分阶段实施**: 按照解耦操作步骤逐步实施，降低风险
|
||
2. **充分测试**: 每个阶段完成后进行充分测试
|
||
3. **保留备份**: 保留原始代码备份，便于回滚
|
||
4. **文档更新**: 及时更新相关文档，保持文档与代码同步
|
||
5. **代码审查**: 完成后进行代码审查，确保代码质量
|
||
|
||
### 9.3 后续优化方向
|
||
|
||
1. **异步支持**: 完善异步发送和接收功能
|
||
2. **错误恢复**: 增加错误检测和自动恢复机制
|
||
3. **性能优化**: 优化FIFO和中断处理性能
|
||
4. **协议扩展**: 支持更多通信协议和模式
|
||
5. **调试支持**: 增加调试日志和统计功能
|
||
|
||
---
|
||
|
||
## 附录
|
||
|
||
### A. 参考资料
|
||
|
||
1. E32-433T30S 数据手册
|
||
2. STM32F103C8T6 参考手册
|
||
3. STM32 HAL 库文档
|
||
4. 项目 AGENTS.md 文档
|
||
|
||
### B. 术语表
|
||
|
||
| 术语 | 说明 |
|
||
|-----|------|
|
||
| E32 | E32-433T30S LoRa无线模块 |
|
||
| HAL | Hardware Abstraction Layer，硬件抽象层 |
|
||
| FIFO | First In First Out，先进先出队列 |
|
||
| WOR | Wake On Radio，无线唤醒 |
|
||
| FEC | Forward Error Correction，前向纠错 |
|
||
| CDC | Communications Device Class，通信设备类 |
|
||
|
||
### C. 版本历史
|
||
|
||
| 版本 | 日期 | 作者 | 说明 |
|
||
|-----|------|------|------|
|
||
| v1.0 | 2026-03-24 | 系统架构师 | 初始版本 |
|
||
|
||
---
|
||
|
||
**文档结束**
|