zhongxuanzhen/433_STM32
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

3.24_433_RX版本：封装RF433模块，完成开机进入TX/RX模式并在开发板验证成功

Browse Source
This commit is contained in:
zhongxuanzhen
2026-03-24 16:59:20 +08:00
commit e439dd465e
1311 changed files with 692196 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

334
Driver_RF433/Inc/rf433.h Normal file
View File

@ -0,0 +1,334 @@
/**
******************************************************************************
* @file rf433.h
* @brief RF433模块驱动主接口
* @note 基于原e32_demo.h重构，保持与原版设备兼容
******************************************************************************
*/
#ifndef __RF433_H__
#define __RF433_H__
#ifdef __cplusplus
extern "C" {
#endif
#include "rf433_config.h"
#include "rf433_hal.h"
#include <stdint.h>
#include <stdbool.h>
/* ============================================================================
* 错误码定义
* ============================================================================ */
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_NO_DATA = -7, // 无数据
} rf433_error_t;
/* ============================================================================
* 配置参数枚举（与原e32_demo.h保持一致）
* ============================================================================ */
typedef enum
{
RF433_OFF = 0x00,
RF433_ON = 0x01,
} rf433_on_off_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_WOR_PERIOD_250MS = 0x00,
RF433_WOR_PERIOD_500MS = 0x01,
RF433_WOR_PERIOD_750MS = 0x02,
RF433_WOR_PERIOD_1000MS = 0x03,
RF433_WOR_PERIOD_1250MS = 0x04,
RF433_WOR_PERIOD_1500MS = 0x05,
RF433_WOR_PERIOD_1750MS = 0x06,
RF433_WOR_PERIOD_2000MS = 0x07,
} rf433_wor_period_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_transmit_power_t;
/* ============================================================================
* 配置结构体（与原e32_register_t保持一致）
* ============================================================================ */
typedef struct
{
/* 00H是固定HEAD，无法修改 */
/* ======== 用户参数寄存器 01H ======== */
struct
{
uint8_t address_h; /* 模块地址 (用户参数寄存器地址: 01H、02H) 不同地址的模块无法直接互相通信(广播地址除外); 65535为广播地址，用于群发信息 */
}register_1;
/* ======== 用户参数寄存器 02H ======== */
struct
{
uint8_t address_l;
}register_2;
/* ======== 用户参数寄存器 03H ======== */
union {
uint8_t value;
struct
{
rf433_radio_rate_t radio_rate : 3; /* 空中速率 (寄存器地址: 03H Bit2-0) 速率越高，抗干扰性越差，传输距离越近；但传输速率越高，延迟越小 */
rf433_uart_rate_t uart_baud_rate : 3; /* 串口波特率 (寄存器地址: 03H Bit7-5) 省电模式(模式2)是强制固定波特率为9600；其他传输模式时为用户设置的串口波特率 */
rf433_uart_parity_t uart_parity : 2; /* 串口校验位 (寄存器地址: 03H Bit4-3) */
}field;
}register_3;
/* ======== 用户参数寄存器 04H ======== */
struct
{
uint8_t channel; /* 信道参数 (寄存器地址: 04H) 相邻信道间隔1MHz，模块通信频率与信道有关；通信频率 = 起始频率 + (1MHz x 信道参数) */
}register_4;
/* ======== 用户参数寄存器 05H ======== */
union {
uint8_t value;
struct
{
rf433_transmit_power_t tx_power : 2; /* 发射功率 (寄存器地址: 05H Bit1-0) 不同型号的模块的功率值可能不一样，具体值需要参考模块手册 */
rf433_on_off_t packet_fec : 1; /* 前向纠错FEC (寄存器地址: 05H Bit2 ) 收发双方必须一致，否则无法通信。开启后，抗干扰性明显提升，但传输速率会降低 */
rf433_wor_period_t wake_on_radio_period : 3; /* 无线唤醒WOR周期 (寄存器地址: 05H Bit2-0) 收发双方必须设置一致，否则无法通信 */
rf433_on_off_t reserve : 1; /* 保留 IO输出方式*/
rf433_on_off_t specify_target : 1; /* 指定目标传输，也叫定点传输模式 (寄存器地址: 05H Bit7 ) 用户在发送数据时，需要在数据的首字节写入目标地址和信道 */
}field;
}register_5;
}rf433_register_t;
/* ============================================================================
* 数据包结构体（与原e32_specify_target_buffer_t保持一致）
* ============================================================================ */
typedef struct
{
uint8_t address_h; // 目标地址高字节
uint8_t address_l; // 目标地址低字节
uint8_t channel; // 目标信道
uint8_t data[237]; // 数据（最大237字节）
} rf433_specify_target_buffer_t;
/* ============================================================================
* 命令枚举（与原request_cmd_t保持一致）
* ============================================================================ */
typedef enum
{
RF433_REQUEST_CMD_CONFIG = 0x00,
RF433_REQUEST_CMD_NAME ,
RF433_REQUEST_CMD_VERSION ,
} rf433_request_cmd_t;
/* ============================================================================
* 回调函数类型定义
* ============================================================================ */
/**
* @brief 数据接收回调函数类型
* @param data 接收到的数据
* @param length 数据长度
* @param user_data 用户数据
*/
typedef void (*rf433_rx_callback_t)(const uint8_t *data, uint16_t length, 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_register_t *config);
/**
* @brief 反初始化RF433模块
* @return RF433_OK 成功
*/
rf433_error_t rf433_deinit(void);
/**
* @brief 设置模块配置（基于原e32_demo_menu_config）
* @param config 配置参数
* @return RF433_OK 成功
* RF433_ERROR_BUSY 模块忙
* RF433_ERROR_TIMEOUT 超时
*/
rf433_error_t rf433_set_config(const rf433_register_t *config);
/**
* @brief 获取模块配置
* @param config 配置参数输出
* @return RF433_OK 成功
* RF433_ERROR_INVALID_PARAM 无效参数
*/
rf433_error_t rf433_get_config(rf433_register_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)
/**
* @brief 发送数据（透明传输模式，基于原e32_demo_transmit）
* @param buffer 数据指针
* @param length 数据长度
* @return RF433_OK 成功
* RF433_ERROR_BUSY 模块忙
* RF433_ERROR_TIMEOUT 超时
* RF433_ERROR_INVALID_PARAM 无效参数
*/
rf433_error_t rf433_transmit(uint8_t *buffer, uint16_t length);
/**
* @brief 发送数据包（指定目标模式）
* @param packet 数据包
* @return RF433_OK 成功
* RF433_ERROR_BUSY 模块忙
* RF433_ERROR_TIMEOUT 超时
* RF433_ERROR_INVALID_PARAM 无效参数
*/
rf433_error_t rf433_transmit_packet(const rf433_specify_target_buffer_t *packet);
#endif /* (RF433_MODE == RF433_MODE_TX) || (RF433_MODE == RF433_MODE_BOTH) */
#if (RF433_MODE == RF433_MODE_RX) || (RF433_MODE == RF433_MODE_BOTH)
/**
* @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 buffer 数据缓冲区
* @param max_length 最大接收长度
* @param actual_length 实际接收长度
* @param timeout 超时时间（ms）
* @return RF433_OK 成功
* RF433_ERROR_TIMEOUT 超时
* RF433_ERROR_INVALID_PARAM 无效参数
*/
rf433_error_t rf433_receive(uint8_t *buffer, uint16_t max_length, uint16_t *actual_length, uint32_t timeout);
/**
* @brief 检查是否有数据可读
* @param has_data 是否有数据输出
* @return RF433_OK 成功
*/
rf433_error_t rf433_rx_check_data(bool *has_data);
/**
* @brief 读取数据（非阻塞模式）
* @param buffer 数据缓冲区
* @param max_length 最大读取长度
* @param actual_length 实际读取长度
* @return RF433_OK 成功
* RF433_ERROR_NO_DATA 无数据
* RF433_ERROR_INVALID_PARAM 无效参数
*/
rf433_error_t rf433_rx_read(uint8_t *buffer, uint16_t max_length, uint16_t *actual_length);
/**
* @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);
#endif /* (RF433_MODE == RF433_MODE_RX) || (RF433_MODE == RF433_MODE_BOTH) */
#ifdef __cplusplus
}
#endif
#endif /* __RF433_H__ */

133
Driver_RF433/Inc/rf433_config.h Normal file
View File

@ -0,0 +1,133 @@
/**
******************************************************************************
* @file rf433_config.h
* @brief RF433模块配置文件
******************************************************************************
*/
#ifndef __RF433_CONFIG_H__
#define __RF433_CONFIG_H__
#ifdef __cplusplus
extern "C" {
#endif
/* ============================================================================
* 编译模式选择
* ============================================================================ */
/**
* @brief 编译模式选择
* @note 必须在包含此头文件之前定义
* RF433_MODE_TX - 仅编译TX功能
* RF433_MODE_RX - 仅编译RX功能
* RF433_MODE_BOTH - 编译TX和RX功能（默认）
*/
#define RF433_MODE_TX 1
#define RF433_MODE_RX 2
#define RF433_MODE_BOTH 3
#ifndef RF433_MODE
#define RF433_MODE RF433_MODE_RX
#endif
/* ============================================================================
* 默认配置参数
* ============================================================================ */
/**
* @brief 默认工作模式（运行时选择）
* @note 1: TX模式
* 2: RX模式
* 3: 双模模式
*/
#ifndef RF433_DEFAULT_WORK_MODE
#define RF433_DEFAULT_WORK_MODE RF433_MODE_TX
#endif
/**
* @brief 默认发送间隔（ms）
*/
#ifndef RF433_DEFAULT_TX_INTERVAL
#define RF433_DEFAULT_TX_INTERVAL 1000
#endif
/**
* @brief 默认发送次数
*/
#ifndef RF433_DEFAULT_TX_COUNT
#define RF433_DEFAULT_TX_COUNT 100
#endif
/* ============================================================================
* 缓冲区大小配置
* ============================================================================ */
/**
* @brief FIFO缓冲区大小
*/
#ifndef RF433_FIFO_SIZE
#define RF433_FIFO_SIZE 1024
#endif
/**
* @brief 最大数据包长度
*/
#ifndef RF433_MAX_PACKET_SIZE
#define RF433_MAX_PACKET_SIZE 237
#endif
/**
* @brief 默认超时时间（ms）
*/
#ifndef RF433_DEFAULT_TIMEOUT
#define RF433_DEFAULT_TIMEOUT 100
#endif
/* ============================================================================
* 硬件配置
* ============================================================================ */
/**
* @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
/* ============================================================================
* 调试配置
* ============================================================================ */
/**
* @brief 是否启用调试输出
*/
#ifndef RF433_DEBUG_ENABLE
#define RF433_DEBUG_ENABLE 0
#endif
/**
* @brief 调试输出函数
*/
#if RF433_DEBUG_ENABLE
#ifndef RF433_DEBUG_PRINTF
#define RF433_DEBUG_PRINTF(fmt, ...) printf("[RF433] " fmt "\r\n", ##__VA_ARGS__)
#endif
#else
#define RF433_DEBUG_PRINTF(fmt, ...)
#endif
#ifdef __cplusplus
}
#endif
#endif /* __RF433_CONFIG_H__ */

217
Driver_RF433/Inc/rf433_hal.h Normal file
View File

@ -0,0 +1,217 @@
/**
******************************************************************************
* @file rf433_hal.h
* @brief RF433硬件抽象层接口
* @note 基于原e32_hal.c重构，保持与原版设备兼容
******************************************************************************
*/
#ifndef __RF433_HAL_H__
#define __RF433_HAL_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <stdint.h>
#include <stdbool.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
/* ============================================================================
* 错误码定义
* ============================================================================ */
typedef enum
{
RF433_HAL_OK = 0, // 成功
RF433_HAL_ERROR = -1, // 通用错误
RF433_HAL_ERROR_TIMEOUT = -2, // 超时
RF433_HAL_ERROR_INVALID_PARAM = -3, // 无效参数
RF433_HAL_ERROR_BUSY = -4, // 模块忙
} rf433_hal_error_t;
/* ============================================================================
* 工作模式枚举（与原e32_hal.h保持一致）
* ============================================================================ */
typedef enum
{
RF433_WORK_MODE_TRANSPARENT = 0x00, // 一般模式（透明传输）
RF433_WORK_MODE_WAKE_ON_RADIO_MASTER = 0x01, // WOR主模式
RF433_WORK_MODE_WAKE_ON_RADIO_SLAVE = 0x02, // WOR从模式
RF433_WORK_MODE_CONFIG_AND_SLEEP = 0x03, // 配置/睡眠模式
} rf433_work_mode_t;
/* ============================================================================
* HAL初始化函数
* ============================================================================ */
/**
* @brief 初始化硬件抽象层
* @return RF433_HAL_OK 成功
* RF433_HAL_ERROR 失败
*/
rf433_hal_error_t rf433_hal_init(void);
/**
* @brief 反初始化硬件抽象层
* @return RF433_HAL_OK 成功
*/
rf433_hal_error_t rf433_hal_deinit(void);
/* ============================================================================
* UART通信函数
* ============================================================================ */
/**
* @brief UART发送数据（基于原e32_hal_uart_tx）
* @param buffer 数据缓冲区
* @param length 数据长度
* @return RF433_HAL_OK 成功
* RF433_HAL_ERROR_TIMEOUT 超时
*/
rf433_hal_error_t rf433_hal_uart_tx(uint8_t *buffer, uint16_t length);
/**
* @brief UART接收数据（中断模式）
* @param data 接收到的数据
* @param length 数据长度
* @note 此函数由UART中断回调调用
*/
void rf433_hal_uart_rx_callback(uint8_t *data, uint16_t length);
/**
* @brief UART接收完成回调函数（由HAL_UART_RxCpltCallback调用）
* @retval 无
*/
void rf433_hal_uart_rxcplt_callback(void);
/* ============================================================================
* GPIO控制函数
* ============================================================================ */
/**
* @brief 等待AUX引脚变为空闲（基于原e32_hal_aux_wait）
* @return RF433_HAL_OK 成功
* RF433_HAL_ERROR_TIMEOUT 超时
*/
rf433_hal_error_t rf433_hal_aux_wait(void);
/**
* @brief 设置工作模式（基于原e32_hal_work_mode）
* @param mode 工作模式
* @return RF433_HAL_OK 成功
* RF433_HAL_ERROR_TIMEOUT 超时
*/
rf433_hal_error_t rf433_hal_set_work_mode(rf433_work_mode_t mode);
/**
* @brief 复位模块（基于原e32_hal_reset）
* @return RF433_HAL_OK 成功
*/
rf433_hal_error_t rf433_hal_reset(void);
/* ============================================================================
* FIFO操作函数
* ============================================================================ */
/**
* @brief 写入FIFO
* @param data 数据指针
* @param length 数据长度
* @return RF433_HAL_OK 成功
* RF433_HAL_ERROR_FULL FIFO满
*/
rf433_hal_error_t rf433_hal_fifo_write(const uint8_t *data, uint16_t length);
/**
* @brief 读取FIFO
* @param data 数据缓冲区
* @param length 期望读取长度
* @param actual_length 实际读取长度
* @return RF433_HAL_OK 成功
* RF433_HAL_ERROR_EMPTY FIFO空
*/
rf433_hal_error_t rf433_hal_fifo_read(uint8_t *data, uint16_t length, uint16_t *actual_length);
/**
* @brief 获取FIFO数据长度
* @param length 数据长度输出
* @return RF433_HAL_OK 成功
*/
rf433_hal_error_t rf433_hal_fifo_get_length(uint16_t *length);
/**
* @brief 清空FIFO
* @return RF433_HAL_OK 成功
*/
rf433_hal_error_t rf433_hal_fifo_clear(void);
/* ============================================================================
* 定时器回调函数
* ============================================================================ */
/**
* @brief 1ms定时器回调（用于超时检测）
* @note 此函数需要在1ms定时器中断中调用
*/
void rf433_hal_1ms_callback(void);
/* ============================================================================
* 兼容函数声明（用于保持与原代码的兼容性）
* ============================================================================ */
/**
* @brief UART接收超时1ms回调（兼容原uart1_rx_timeout_1ms_callback）
* @note 此函数需要在1ms定时器中断中调用
*/
void uart1_rx_timeout_1ms_callback(void);
/**
* @brief UART等待响应（阻塞模式，兼容原uart1_wait_response_blocked）
* @param buffer 数据缓冲区
* @param length 数据长度输出
* @note 与main.h中的声明保持一致，返回void
*/
void uart1_wait_response_blocked(uint8_t *buffer, uint16_t *length);
/**
* @brief UART检查接收完成（兼容原uart1_check_rx_done）
* @param buffer 数据缓冲区
* @param length 数据长度输出（uint32_t*，与main.h中的声明保持一致）
* @return true 接收到数据
* false 无数据
*/
bool uart1_check_rx_done(uint8_t *buffer, uint32_t *length);
/**
* @brief 检查接收完成标志（用于RF433应用层）
* @return true 接收完成
* false 接收未完成
*/
bool rf433_hal_check_rx_done(void);
#ifdef __cplusplus
}
#endif
#endif /* __RF433_HAL_H__ */

652
Driver_RF433/Src/rf433.c Normal file
View File

@ -0,0 +1,652 @@
/**
******************************************************************************
* @file rf433.c
* @brief RF433模块驱动主实现
* @note 基于原e32_demo.c重构，保持与原版设备兼容
******************************************************************************
*/
#include "rf433.h"
#include "rf433_hal.h"
#include <string.h>
#include "stm32f1xx_hal.h"
/* ============================================================================
* 私有变量
* ============================================================================ */
static bool rf433_initialized = false;
static rf433_register_t rf433_current_config;
/* E32-433T30S 默认配置（与原register_default保持一致） */
static const rf433_register_t rf433_default_config =
{
.register_1 = {
.address_h = 0x00,
},
.register_2 = {
.address_l = 0x00,
},
.register_3.field = {
.radio_rate = RF433_RADIO_RATE_2400,
.uart_baud_rate = RF433_UART_RATE_9600,
.uart_parity = RF433_UART_8N1,
},
.register_4 = {
.channel = 0x17,
},
.register_5.field = {
.tx_power = RF433_TX_POWER_DBM_30,
.packet_fec = RF433_ON,
.wake_on_radio_period = RF433_WOR_PERIOD_250MS,
.reserve = RF433_OFF,
.specify_target = RF433_OFF,
},
};
/* 模块数据缓冲区 */
static uint8_t rf433_buffer[1024];
/* ============================================================================
* 私有函数声明
* ============================================================================ */
/**
* @brief 向模块写入配置参数指令（基于原e32_send_config_command）
* @param config 配置信息
*/
static void rf433_send_config_command(const rf433_register_t *config);
/**
* @brief 向模块写入查询指令（基于原e32_send_request_command）
* @param cmd 查询命令
*/
static void rf433_send_request_command(rf433_request_cmd_t cmd);
/**
* @brief (查询指令)模块响应数据校验（基于原e32_response_command_check）
* @param cmd 查询命令
* @param buffer 指向响应数据缓冲区
* @param length 响应数据长度
* @return bool 正确返回true; 否则返回false
*/
static bool rf433_response_command_check(rf433_request_cmd_t cmd, uint8_t *buffer, uint8_t length);
/* ============================================================================
* 私有函数实现
* ============================================================================ */
/**
* @brief 向模块写入配置参数指令
*/
static void rf433_send_config_command(const rf433_register_t *config)
{
/* 第1字节：写入指令
C0：写入配置参数指令 */
rf433_buffer[0] = 0xC0;
/* 第2~6字节开始：写入用户参数寄存器 */
memcpy(&rf433_buffer[1], (uint8_t*)config, sizeof(rf433_register_t));
/* 发送写入 */
rf433_hal_uart_tx(rf433_buffer, sizeof(rf433_register_t) + 1);
}
/**
* @brief 向模块写入查询指令
*/
static void rf433_send_request_command(rf433_request_cmd_t cmd)
{
/* 获取配置参数 */
static const uint8_t request_config[3] = {0xC1, 0xC1, 0xC1};
/* AT指令 获取设备类型 */
static const char request_name[] = "AT+DEVTYPE=?";
/* AT指令 获取固件版本 */
static const char request_version[] = "AT+FWCODE=?";
switch (cmd)
{
/* 获取配置参数 */
case RF433_REQUEST_CMD_CONFIG:
rf433_hal_uart_tx((uint8_t*)request_config, sizeof(request_config));
break;
/* 获取设备类型 */
case RF433_REQUEST_CMD_NAME:
rf433_hal_uart_tx((uint8_t*)request_name, strlen(request_name));
break;
/* 获取固件版本 */
case RF433_REQUEST_CMD_VERSION:
rf433_hal_uart_tx((uint8_t*)request_version, strlen(request_version));
break;
}
}
/**
* @brief (查询指令)模块响应数据校验
*/
static bool rf433_response_command_check(rf433_request_cmd_t cmd, uint8_t *buffer, uint8_t length)
{
bool ret = false;
switch (cmd)
{
/* 获取配置参数 */
case RF433_REQUEST_CMD_CONFIG:
/* 先校验 数据长度为6字节*/
if (length == 6)
{
/* 数据校验 帧头必须为0xC1 */
if (buffer[0] == 0xC1)
{
ret = true;
}
}
break;
/* 获取设备类型 */
case RF433_REQUEST_CMD_NAME:
/* 数据校验 */
if (strncmp("DEVTYPE=", (char*)buffer, 8) == 0)
{
ret = true;
}
break;
/* 获取固件版本 */
case RF433_REQUEST_CMD_VERSION:
/* 数据校验 */
if (strncmp("FWCODE=", (char*)buffer, 7) == 0)
{
ret = true;
}
break;
}
return ret;
}
/* ============================================================================
* 公共函数实现
* ============================================================================ */
/**
* @brief 初始化RF433模块
*/
rf433_error_t rf433_init(const rf433_register_t *config)
{
rf433_hal_error_t ret;
/* 检查是否已初始化 */
if (rf433_initialized)
{
return RF433_ERROR;
}
/* 初始化硬件抽象层 */
ret = rf433_hal_init();
if (ret != RF433_HAL_OK)
{
return RF433_ERROR;
}
/* 复制配置 */
if (config == NULL)
{
memcpy(&rf433_current_config, &rf433_default_config, sizeof(rf433_register_t));
}
else
{
memcpy(&rf433_current_config, config, sizeof(rf433_register_t));
}
/* 设置模块配置 */
ret = rf433_set_config(&rf433_current_config);
if (ret != RF433_OK)
{
rf433_hal_deinit();
return ret;
}
rf433_initialized = true;
return RF433_OK;
}
/**
* @brief 反初始化RF433模块
*/
rf433_error_t rf433_deinit(void)
{
/* 检查是否已初始化 */
if (!rf433_initialized)
{
return RF433_ERROR_NOT_INIT;
}
/* 反初始化硬件抽象层 */
rf433_hal_deinit();
rf433_initialized = false;
return RF433_OK;
}
/**
* @brief 设置模块配置（基于原e32_demo_menu_config）
*/
rf433_error_t rf433_set_config(const rf433_register_t *config)
{
rf433_hal_error_t ret;
/* 参数检查 */
if (config == NULL)
{
return RF433_ERROR_INVALID_PARAM;
}
/* 等待模块空闲 */
ret = rf433_hal_aux_wait();
if (ret != RF433_HAL_OK)
{
return RF433_ERROR_TIMEOUT;
}
/* 切换到配置模式 */
ret = rf433_hal_set_work_mode(RF433_WORK_MODE_CONFIG_AND_SLEEP);
if (ret != RF433_HAL_OK)
{
return RF433_ERROR_TIMEOUT;
}
/* 向模块串口写入配置 */
rf433_send_config_command(config);
/* 等待模块响应 */
/* 注意：这里需要实现uart1_wait_response_blocked的等效功能 */
/* 暂时使用延时等待 */
HAL_Delay(100);
/* 切换回透明传输模式 */
ret = rf433_hal_set_work_mode(RF433_WORK_MODE_TRANSPARENT);
if (ret != RF433_HAL_OK)
{
return RF433_ERROR_TIMEOUT;
}
/* 保存配置 */
memcpy(&rf433_current_config, config, sizeof(rf433_register_t));
return RF433_OK;
}
/**
* @brief 获取模块配置
*/
rf433_error_t rf433_get_config(rf433_register_t *config)
{
/* 参数检查 */
if (config == NULL)
{
return RF433_ERROR_INVALID_PARAM;
}
/* 复制当前配置 */
memcpy(config, &rf433_current_config, sizeof(rf433_register_t));
return RF433_OK;
}
/**
* @brief 设置工作模式
*/
rf433_error_t rf433_set_work_mode(rf433_work_mode_t mode)
{
rf433_hal_error_t ret;
ret = rf433_hal_set_work_mode(mode);
if (ret != RF433_HAL_OK)
{
return RF433_ERROR_TIMEOUT;
}
return RF433_OK;
}
/**
* @brief 复位模块
*/
rf433_error_t rf433_reset(void)
{
rf433_hal_error_t ret;
ret = rf433_hal_reset();
if (ret != RF433_HAL_OK)
{
return RF433_ERROR;
}
return RF433_OK;
}
/* ============================================================================
* TX模式实现
* ============================================================================ */
#if (RF433_MODE == RF433_MODE_TX) || (RF433_MODE == RF433_MODE_BOTH)
/**
* @brief 发送数据（透明传输模式，基于原e32_demo_transmit）
*/
rf433_error_t rf433_transmit(uint8_t *buffer, uint16_t length)
{
rf433_hal_error_t ret;
/* 参数检查 */
if (buffer == NULL || length == 0)
{
return RF433_ERROR_INVALID_PARAM;
}
/* 检查是否已初始化 */
if (!rf433_initialized)
{
return RF433_ERROR_NOT_INIT;
}
/* 发送写入 */
ret = rf433_hal_uart_tx(buffer, length);
if (ret != RF433_HAL_OK)
{
return RF433_ERROR_TIMEOUT;
}
return RF433_OK;
}
/**
* @brief 发送数据包（指定目标模式）
*/
rf433_error_t rf433_transmit_packet(const rf433_specify_target_buffer_t *packet)
{
rf433_hal_error_t ret;
uint16_t length;
/* 参数检查 */
if (packet == NULL)
{
return RF433_ERROR_INVALID_PARAM;
}
/* 检查是否已初始化 */
if (!rf433_initialized)
{
return RF433_ERROR_NOT_INIT;
}
/* 计算数据包长度（3字节头 + 数据长度） */
length = 3 + 237; // address_h + address_l + channel + data[237]
/* 发送数据包 */
ret = rf433_hal_uart_tx((uint8_t*)packet, length);
if (ret != RF433_HAL_OK)
{
return RF433_ERROR_TIMEOUT;
}
return RF433_OK;
}
#endif /* (RF433_MODE == RF433_MODE_TX) || (RF433_MODE == RF433_MODE_BOTH) */
/* ============================================================================
* RX模式实现
* ============================================================================ */
#if (RF433_MODE == RF433_MODE_RX) || (RF433_MODE == RF433_MODE_BOTH)
static bool rf433_rx_started = false;
static rf433_rx_callback_t rf433_rx_callback = NULL;
static void *rf433_rx_user_data = NULL;
/**
* @brief 启动接收
*/
rf433_error_t rf433_rx_start(void)
{
rf433_hal_error_t ret;
/* 检查是否已初始化 */
if (!rf433_initialized)
{
return RF433_ERROR_NOT_INIT;
}
/* 检查是否已启动 */
if (rf433_rx_started)
{
return RF433_ERROR_BUSY;
}
/* 清空FIFO */
ret = rf433_hal_fifo_clear();
if (ret != RF433_HAL_OK)
{
return RF433_ERROR;
}
/* 启动UART接收（由HAL层处理） */
/* 注意：UART接收由HAL_UART_Receive_IT启动，在HAL_UART_RxCpltCallback中调用rf433_hal_uart_rxcplt_callback */
rf433_rx_started = true;
return RF433_OK;
}
/**
* @brief 停止接收
*/
rf433_error_t rf433_rx_stop(void)
{
/* 检查是否已初始化 */
if (!rf433_initialized)
{
return RF433_ERROR_NOT_INIT;
}
rf433_rx_started = false;
return RF433_OK;
}
/**
* @brief 接收数据（阻塞模式）
*/
rf433_error_t rf433_receive(uint8_t *buffer, uint16_t max_length, uint16_t *actual_length, uint32_t timeout)
{
rf433_hal_error_t ret;
uint16_t fifo_length;
uint32_t start_time;
/* 参数检查 */
if (buffer == NULL || max_length == 0 || actual_length == NULL)
{
return RF433_ERROR_INVALID_PARAM;
}
/* 检查是否已初始化 */
if (!rf433_initialized)
{
return RF433_ERROR_NOT_INIT;
}
/* 等待数据 */
start_time = HAL_GetTick();
while (true)
{
ret = rf433_hal_fifo_get_length(&fifo_length);
if (ret != RF433_HAL_OK)
{
return RF433_ERROR;
}
if (fifo_length > 0)
{
break;
}
/* 检查超时 */
if (timeout > 0 && (HAL_GetTick() - start_time) >= timeout)
{
return RF433_ERROR_TIMEOUT;
}
HAL_Delay(1);
}
/* 读取数据 */
if (fifo_length > max_length)
{
fifo_length = max_length;
}
ret = rf433_hal_fifo_read(buffer, fifo_length, actual_length);
if (ret != RF433_HAL_OK)
{
return RF433_ERROR;
}
return RF433_OK;
}
/**
* @brief 检查是否有数据可读
*/
rf433_error_t rf433_rx_check_data(bool *has_data)
{
rf433_hal_error_t ret;
uint16_t length;
/* 参数检查 */
if (has_data == NULL)
{
return RF433_ERROR_INVALID_PARAM;
}
/* 检查是否已初始化 */
if (!rf433_initialized)
{
return RF433_ERROR_NOT_INIT;
}
/* 获取FIFO长度 */
ret = rf433_hal_fifo_get_length(&length);
if (ret != RF433_HAL_OK)
{
return RF433_ERROR;
}
*has_data = (length > 0);
return RF433_OK;
}
/**
* @brief 读取数据（非阻塞模式）
*/
rf433_error_t rf433_rx_read(uint8_t *buffer, uint16_t max_length, uint16_t *actual_length)
{
rf433_hal_error_t ret;
uint16_t length;
/* 参数检查 */
if (buffer == NULL || max_length == 0 || actual_length == NULL)
{
return RF433_ERROR_INVALID_PARAM;
}
/* 检查是否已初始化 */
if (!rf433_initialized)
{
return RF433_ERROR_NOT_INIT;
}
/* 获取FIFO长度 */
ret = rf433_hal_fifo_get_length(&length);
if (ret != RF433_HAL_OK)
{
return RF433_ERROR;
}
/* 检查是否有数据 */
if (length == 0)
{
return RF433_ERROR_NO_DATA;
}
/* 读取数据 */
if (length > max_length)
{
length = max_length;
}
ret = rf433_hal_fifo_read(buffer, length, actual_length);
if (ret != RF433_HAL_OK)
{
return RF433_ERROR;
}
return RF433_OK;
}
/**
* @brief 注册接收回调函数
*/
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_initialized)
{
return RF433_ERROR_NOT_INIT;
}
rf433_rx_callback = callback;
rf433_rx_user_data = user_data;
return RF433_OK;
}
/**
* @brief 注销接收回调函数
*/
rf433_error_t rf433_rx_unregister_callback(void)
{
rf433_rx_callback = NULL;
rf433_rx_user_data = NULL;
return RF433_OK;
}
/**
* @brief UART接收完成回调（由HAL层调用）
*/
void rf433_rx_uart_callback_internal(uint8_t *data, uint16_t length)
{
/* 检查是否已启动 */
if (!rf433_rx_started)
{
return;
}
/* 如果有回调函数，调用回调 */
if (rf433_rx_callback != NULL)
{
rf433_rx_callback(data, length, rf433_rx_user_data);
}
}
#endif /* (RF433_MODE == RF433_MODE_RX) || (RF433_MODE == RF433_MODE_BOTH) */

503
Driver_RF433/Src/rf433_hal.c Normal file
View File

@ -0,0 +1,503 @@
/**
******************************************************************************
* @file rf433_hal.c
* @brief RF433硬件抽象层实现
* @note 基于原e32_hal.c重构，保持与原版设备兼容
******************************************************************************
*/
#include "rf433_hal.h"
/* 与单片机平台相关 */
#include "main.h"
#include "gpio.h"
#include "usart.h"
#include "fifo.h"
/* ============================================================================
* 私有变量
* ============================================================================ */
static bool rf433_hal_initialized = false;
/* FIFO缓冲区 */
static uint8_t rf433_fifo_buffer[1024];
static fifo_t rf433_fifo;
/* UART接收相关变量 */
static uint8_t rf433_uart_rx_tmp;
static volatile uint32_t rf433_uart_rx_timeout = 0;
static volatile bool rf433_uart_rx_done = false;
/* ============================================================================
* 公共函数实现
* ============================================================================ */
/**
* @brief 初始化硬件抽象层
*/
rf433_hal_error_t rf433_hal_init(void)
{
fifo_error_t ret;
/* 检查是否已初始化 */
if (rf433_hal_initialized)
{
return RF433_HAL_ERROR;
}
/* 初始化FIFO */
ret = fifo_create(&rf433_fifo, rf433_fifo_buffer, sizeof(rf433_fifo_buffer));
if (ret != FIFO_OK)
{
return RF433_HAL_ERROR;
}
rf433_hal_initialized = true;
return RF433_HAL_OK;
}
/**
* @brief 反初始化硬件抽象层
*/
rf433_hal_error_t rf433_hal_deinit(void)
{
/* 检查是否已初始化 */
if (!rf433_hal_initialized)
{
return RF433_HAL_ERROR;
}
rf433_hal_initialized = false;
return RF433_HAL_OK;
}
/**
* @brief UART发送数据（基于原e32_hal_uart_tx）
*/
rf433_hal_error_t rf433_hal_uart_tx(uint8_t *buffer, uint16_t length)
{
HAL_StatusTypeDef ret;
/* 参数检查 */
if (buffer == NULL || length == 0)
{
return RF433_HAL_ERROR_INVALID_PARAM;
}
/* 发送数据 */
ret = HAL_UART_Transmit(&huart1, buffer, length, 0xFFFF);
if (ret != HAL_OK)
{
return RF433_HAL_ERROR_TIMEOUT;
}
return RF433_HAL_OK;
}
/**
* @brief UART接收回调（由中断调用）
*/
void rf433_hal_uart_rx_callback(uint8_t *data, uint16_t length)
{
/* 写入FIFO */
fifo_write(&rf433_fifo, data, length);
/* 设置超时 */
rf433_uart_rx_timeout = 10;
}
/**
* @brief 等待AUX引脚变为空闲（基于原e32_hal_aux_wait）
*/
rf433_hal_error_t rf433_hal_aux_wait(void)
{
#if RF433_USE_GPIO_AUX
uint32_t start_time;
/* 等待AUX引脚变为高电平 */
if (HAL_GPIO_ReadPin(AUX_GPIO_Port, AUX_Pin) == GPIO_PIN_RESET)
{
/* 等到模块的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_HAL_ERROR_TIMEOUT;
}
}
/* 此时是检测到AUX信号有上升沿，需要再等待1~2ms */
HAL_Delay(2);
}
#else
/* 不使用AUX引脚，使用延时等待 */
HAL_Delay(30);
#endif
return RF433_HAL_OK;
}
/**
* @brief 设置工作模式（基于原e32_hal_work_mode）
*/
rf433_hal_error_t rf433_hal_set_work_mode(rf433_work_mode_t mode)
{
rf433_hal_error_t ret;
#if RF433_USE_GPIO_AUX
/* 等待模块空闲 */
ret = rf433_hal_aux_wait();
if (ret != RF433_HAL_OK)
{
return ret;
}
#endif
/* 设置M0和M1引脚 */
switch (mode)
{
/* 模式0：一般模式 (M0=0 M1=0) */
case RF433_WORK_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;
/* 模式1：唤醒模式 (M0=1 M1=0) */
case RF433_WORK_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;
/* 模式2：省电模式 (M0=0 M1=1) */
case RF433_WORK_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;
/* 模式3：配置模式 (M0=1 M1=1) */
case RF433_WORK_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_HAL_ERROR_INVALID_PARAM;
}
#if RF433_USE_GPIO_AUX
/* 切换模式后，模块的AUX信号不会立即变为低电平，需要等待一段时间再进行检测 */
HAL_Delay(5);
ret = rf433_hal_aux_wait();
if (ret != RF433_HAL_OK)
{
return ret;
}
#else
/* 这里保留一定延时，确保模式切换完成 */
HAL_Delay(50);
#endif
return RF433_HAL_OK;
}
/**
* @brief 复位模块（基于原e32_hal_reset）
*/
rf433_hal_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
/* 注意：硬件复位时，可能会出现AUX引脚输出低电平，需要等待一段时间再开启AUX检测 */
HAL_Delay(10);
return rf433_hal_aux_wait();
#else
/* E32-V2 (V8.2) 版本 */
HAL_Delay(30);
return RF433_HAL_OK;
#endif
}
/**
* @brief 写入FIFO
*/
rf433_hal_error_t rf433_hal_fifo_write(const uint8_t *data, uint16_t length)
{
fifo_error_t ret;
/* 参数检查 */
if (data == NULL || length == 0)
{
return RF433_HAL_ERROR_INVALID_PARAM;
}
/* 写入FIFO */
ret = fifo_write(&rf433_fifo, (uint8_t *)data, length);
if (ret != FIFO_OK)
{
return RF433_HAL_ERROR;
}
return RF433_HAL_OK;
}
/**
* @brief 读取FIFO
*/
rf433_hal_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_HAL_ERROR_INVALID_PARAM;
}
/* 获取FIFO长度 */
ret = fifo_get_length(&rf433_fifo, &fifo_length);
if (ret != FIFO_OK)
{
return RF433_HAL_ERROR;
}
/* 检查是否有数据 */
if (fifo_length == 0)
{
*actual_length = 0;
return RF433_HAL_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_HAL_ERROR;
}
*actual_length = fifo_length;
return RF433_HAL_OK;
}
/**
* @brief 获取FIFO数据长度
*/
rf433_hal_error_t rf433_hal_fifo_get_length(uint16_t *length)
{
fifo_error_t ret;
uint32_t fifo_length;
/* 参数检查 */
if (length == NULL)
{
return RF433_HAL_ERROR_INVALID_PARAM;
}
/* 获取FIFO长度 */
ret = fifo_get_length(&rf433_fifo, &fifo_length);
if (ret != FIFO_OK)
{
return RF433_HAL_ERROR;
}
*length = fifo_length;
return RF433_HAL_OK;
}
/**
* @brief 清空FIFO
*/
rf433_hal_error_t rf433_hal_fifo_clear(void)
{
fifo_error_t ret;
/* 清空FIFO */
ret = fifo_clear(&rf433_fifo);
if (ret != FIFO_OK)
{
return RF433_HAL_ERROR;
}
return RF433_HAL_OK;
}
/**
* @brief 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;
}
}
}
/* ============================================================================
* UART中断回调（需要在stm32f1xx_it.c中调用）
* ============================================================================ */
/**
* @brief UART接收完成回调
* @note 此函数需要在HAL_UART_RxCpltCallback中调用
*/
void rf433_hal_uart_rxcplt_callback(void)
{
uint8_t data;
/* 读取接收到的数据 */
data = huart1.Instance->DR;
/* 写入FIFO */
fifo_write(&rf433_fifo, &data, 1);
/* 设置超时 */
rf433_uart_rx_timeout = 10;
/* 重新启动接收 */
HAL_UART_Receive_IT(&huart1, &rf433_uart_rx_tmp, 1);
}
/* ============================================================================
* 兼容函数（用于保持与原代码的兼容性）
* ============================================================================ */
/**
* @brief UART接收超时1ms回调（兼容原uart1_rx_timeout_1ms_callback）
* @note 此函数需要在1ms定时器中断中调用
*/
void uart1_rx_timeout_1ms_callback(void)
{
/* 调用RF433模块的1ms回调 */
rf433_hal_1ms_callback();
}
/**
* @brief UART等待响应（阻塞模式，兼容原uart1_wait_response_blocked）
* @param buffer 数据缓冲区
* @param length 数据长度输出
* @note 与main.h中的声明保持一致，返回void
*/
void uart1_wait_response_blocked(uint8_t *buffer, uint16_t *length)
{
uint32_t start_time;
uint16_t fifo_length;
rf433_hal_error_t ret;
/* 参数检查 */
if (buffer == NULL || length == NULL)
{
return;
}
/* 等待数据 */
start_time = HAL_GetTick();
while (true)
{
ret = rf433_hal_fifo_get_length(&fifo_length);
if (ret != RF433_HAL_OK)
{
return;
}
if (fifo_length > 0)
{
break;
}
/* 检查超时 */
if ((HAL_GetTick() - start_time) >= 1000)
{
return;
}
HAL_Delay(1);
}
/* 读取数据 */
ret = rf433_hal_fifo_read(buffer, 255, length);
if (ret != RF433_HAL_OK)
{
return;
}
}
/**
* @brief UART检查接收完成（兼容原uart1_check_rx_done）
* @param buffer 数据缓冲区
* @param length 数据长度输出（uint32_t*，与main.h中的声明保持一致）
* @return true 接收到数据
* false 无数据
*/
bool uart1_check_rx_done(uint8_t *buffer, uint32_t *length)
{
rf433_hal_error_t ret;
uint16_t fifo_length;
/* 参数检查 */
if (buffer == NULL || length == NULL)
{
return false;
}
/* 检查超时标志 */
if (!rf433_uart_rx_done)
{
return false;
}
/* 获取FIFO长度 */
ret = rf433_hal_fifo_get_length(&fifo_length);
if (ret != RF433_HAL_OK)
{
return false;
}
/* 检查是否有数据 */
if (fifo_length == 0)
{
return false;
}
/* 读取数据 */
ret = rf433_hal_fifo_read(buffer, 255, (uint16_t*)length);
if (ret != RF433_HAL_OK)
{
return false;
}
/* 清除超时标志 */
rf433_uart_rx_done = false;
return true;
}
/**
* @brief 检查接收完成标志（用于RF433应用层）
* @return true 接收完成
* false 接收未完成
*/
bool rf433_hal_check_rx_done(void)
{
return rf433_uart_rx_done;
}