本文博客链接:http://blog.csdn.net/jdh99,作者:jdh,转载请注明.
环境：
开发环境:MDK5.23
说明：
编写NRF52832射频驱动，本设计中射频模块一直处于接收，如果有发送，等发送完毕后也会自动转为接收。
NRF52832开发：射频驱动
NRF52832开发：射频驱动
射频模块状态机：
源代码：
drv_radio.h
/**
* Copyright (c), 2015-2025
* @file drv_radio.h
* @brief 射频模块驱动层头文件
* @author jdh
* @date 2017/6/28
* @update 2017/8/17
* @update 2017/8/28
*/
#ifndef _DRV_RADIO_H_
#define _DRV_RADIO_H_
/*********************************************************************
* 头文件
**********************************************************************/
#include "def.h"
/*********************************************************************
* 宏定义
**********************************************************************/
/**
* @brief 缓存字节数
*/
#define RADIO_BUF_SIZE 256
/*********************************************************************
* 数据结构
**********************************************************************/
/**
* @brief 发送功率
*/
typedef enum
{
RADIO_TXPOWER_0DBM = 0x00,
RADIO_TXPOWER_POS3DBM = 0x03,
RADIO_TXPOWER_POS4DBM = 0x04,
RADIO_TXPOWER_NEG40DBM = 0xD8,
RADIO_TXPOWER_NEG20DBM = 0xEC,
RADIO_TXPOWER_NEG16DBM = 0xF0,
RADIO_TXPOWER_NEG12DBM = 0xF4,
RADIO_TXPOWER_NEG8DBM = 0xF8,
RADIO_TXPOWER_NEG4DBM = 0xFC
} TxPower;
/**
* @brief 波特率
*/
typedef enum
{
RADIO_BAUDRATE_1M = 0,
RADIO_BAUDRATE_2M = 1
} RadioBaudrate;
/**
* @brief 中断类型
*/
typedef enum
{
RADIO_IRQ_NULL = 0,
RADIO_IRQ_EVENTS_READY = 1,
RADIO_IRQ_EVENTS_END = 2,
RADIO_IRQ_EVENTS_DISABLED = 3
} RadioIrqEvents;
/**
* @brief 射频状态
*/
typedef enum
{
RADIO_STATE_DISABLE = 0,
RADIO_STATE_RXRU = 1,
RADIO_STATE_RXIDLE = 2,
RADIO_STATE_RX = 3,
RADIO_STATE_RXDISABLE = 4,
RADIO_STATE_TXRU = 9,
RADIO_STATE_TXIDLE = 10,
RADIO_STATE_TX = 11,
RADIO_STATE_TXDISABLE = 12
} RadioState;
/*********************************************************************
* 函数
**********************************************************************/
/**
* @brief 设置射频模块发射功率
* @param txpower: 发射功率
*/
void drv_radio_set_txpower(TxPower tx_power);
/**
* @brief 读取射频模块发射功率
* @retval 发射功率
*/
TxPower drv_radio_get_txpower(void);
/**
* @brief 设置射频模块频点
* @param 工作频率.范围:[2360,2500]
*/
void drv_radio_set_frequency(uint16_t frequency);
/**
* @brief 读取射频模块频点
* @retval 工作频率
*/
uint16_t drv_radio_get_frequency(void);
/**
* @brief 设置射频模块通讯速率
* @param baudrate: 波特率
*/
void drv_radio_set_baudrate(RadioBaudrate baudrate);
/**
* @brief 读取射频模块通讯速率
* @retval 通讯速率
*/
RadioBaudrate drv_radio_get_baudrate(void);
/**
* @brief 设置射频模块通讯地址
* @param address: 地址
*/
void drv_radio_set_address(uint32_t address);
/**
* @brief 设置射频模块通讯地址
* @retval 地址
*/
uint32_t drv_radio_get_address(void);
/**
* @brief 设置载荷长度
* @param length: 载荷字节数
*/
void drv_radio_set_playload_length(uint8_t length);
/**
* @brief 读取载荷长度
* @retval 字节数
*/
uint8_t drv_radio_get_playload_length(void);
/**
* @brief 使能crc
*/
void drv_radio_enable_crc(void);
/**
* @brief 禁止crc
*/
void drv_radio_disable_crc(void);
/**
* @brief 使能中断
* @note 使能EVENTS_READY,EVENTS_END,EVENTS_DISABLED中断
*/
void drv_radio_enable_irq(void);
/**
* @brief 向buf中写入数据
* @param buf: 发送数据
* @param length: 数据长度
*/
void drv_radio_write_buf(uint8_t *buf, uint8_t length);
/**
* @brief 从buf中读取数据
* @param buf: 读取数据存放缓存
* @param length: 数据长度
*/
void drv_radio_read_buf(uint8_t *buf, uint8_t length);
/**
* @brief 使能发送
* @note 使能成功后产生事件EVENTS_READY
*/
void drv_radio_enable_tx(void);
/**
* @brief 开始工作
* @note 成功后产生事件EVENTS_END
*/
void drv_radio_start_work(void);
/**
* @brief 关闭射频模块
* @note 关闭成功后产生事件EVENTS_DISABLED
*/
void drv_radio_disable(void);
/**
* @brief 使能接收
* @note 使能成功后产生事件EVENTS_READY
*/
void drv_radio_enable_rx(void);
/**
* @brief 读取射频状态
* @retval 射频状态
*/
RadioState drv_radio_get_state(void);
/**
* @brief 读取接收RSSI
* @retval RSSI.单位-1dBm
*/
uint8_t drv_radio_get_rssi(void);
///**
//* @brief 中断处理
//* @retval 中断类型
//*/
//RadioIrqEvents drv_radio_irq_handle(void);
/**
* @brief 配置射频模块
* @param tx_power: 发射功率
* @param frequency: 通讯频点
* @param baudrate: 通讯波特率
* @param address: 地址
* @param playload_length: 载荷长度
*/
void drv_radio_config(TxPower tx_power, uint16_t frequency, RadioBaudrate baudrate, uint32_t address, uint8_t playload_length);
/**
* @brief 设置回调函数: 射频中断
* @param function: 回调函数.回调函数的第一个参数有效,值为RadioIrqEvents
*/
void drv_radio_set_callback_irq_handle(T_Callback function);
#endif drv_radio.c
/**
* Copyright (c), 2015-2025
* @file drv_radio.c
* @brief 射频模块驱动层主文件
* @author jdh
* @date 2017/6/28
* @update 2017/8/17
* @update 2017/8/28
* @update 2017/10/11
*/
#include "drivers.h"
#include "drivers/drv_rfx2401c.h"
/**
* @brief 基础频率.单位MHz
*/
#define BASE_FREQUENCY1 2360
#define BASE_FREQUENCY2 2400
/**
* @brief S0, S1设置
*/
#define PACKET_S1_FIELD_SIZE 0
#define PACKET_S0_FIELD_SIZE 0
#define PACKET_LENGTH_FIELD_SIZE 0
#define PACKET_BASE_ADDRESS_LENGTH 4
#define PACKET_PAYLOAD_MAXSIZE 255
/**
* @brief 发送接收缓存
*/
static uint8_t radio_buf[RADIO_BUF_SIZE] = {0};
static T_Callback Callback = 0;
static RadioIrqEvents deal_irq_handle(void);
/**
* @brief 设置射频模块发射功率
* @param txpower: 发射功率
*/
void drv_radio_set_txpower(TxPower tx_power)
{
NRF_RADIO->TXPOWER = tx_power;
}
/**
* @brief 读取射频模块发射功率
* @retval 发射功率
*/
TxPower drv_radio_get_txpower(void)
{
return (TxPower)NRF_RADIO->TXPOWER;
}
/**
* @brief 设置射频模块频点
* @param frequency: 工作频率.范围:[2360,2500]
*/
void drv_radio_set_frequency(uint16_t frequency)
{
uint8_t mode;
uint8_t offset;
if (frequency >= BASE_FREQUENCY2)
{
mode = 0;
offset = frequency - BASE_FREQUENCY2;
}
else
{
mode = 1;
offset = frequency - BASE_FREQUENCY1;
}
NRF_RADIO->FREQUENCY = ((mode << 8) + offset) & 0xffff;
}
/**
* @brief 读取射频模块频点
* @retval 工作频率
*/
uint16_t drv_radio_get_frequency(void)
{
uint16_t value = NRF_RADIO->FREQUENCY;
if (value & 0x100)
{
value &= 0xff;
return BASE_FREQUENCY1 + value;
}
else
{
return BASE_FREQUENCY2 + value;
}
}
/**
* @brief 设置射频模块通讯速率
* @param baudrate: 波特率
*/
void drv_radio_set_baudrate(RadioBaudrate baudrate)
{
NRF_RADIO->MODE = baudrate;
}
/**
* @brief 读取射频模块通讯速率
* @retval 通讯速率
*/
RadioBaudrate drv_radio_get_baudrate(void)
{
return (RadioBaudrate)NRF_RADIO->MODE;
}
/**
* @brief 设置射频模块通讯地址
* @param address: 地址
*/
void drv_radio_set_address(uint32_t address)
{
NRF_RADIO->BASE0 = address;
NRF_RADIO->BASE1 = address;
NRF_RADIO->PREFIX0 = 0;
NRF_RADIO->PREFIX1 = 0;
NRF_RADIO->TXADDRESS = 0x0;
NRF_RADIO->RXADDRESSES = 0x1;
}
/**
* @brief 读取射频模块通讯地址
* @retval 地址
*/
uint32_t drv_radio_get_address(void)
{
return NRF_RADIO->BASE0;
}
/**
* @brief 设置载荷长度
* @param length: 载荷字节数
*/
void drv_radio_set_playload_length(uint8_t length)
{
uint32_t value = NRF_RADIO->PCNF1;
value &= ~RADIO_PCNF1_STATLEN_Msk;
value |= (length << RADIO_PCNF1_STATLEN_Pos);
NRF_RADIO->PCNF1 = value;
}
/**
* @brief 读取载荷长度
* @retval 字节数
*/
uint8_t drv_radio_get_playload_length(void)
{
return ((NRF_RADIO->PCNF1 & RADIO_PCNF1_STATLEN_Msk) >> RADIO_PCNF1_STATLEN_Pos);
}
/**
* @brief 使能crc
*/
void drv_radio_enable_crc(void)
{
NRF_RADIO->CRCCNF = (RADIO_CRCCNF_LEN_Two << RADIO_CRCCNF_LEN_Pos);
NRF_RADIO->CRCINIT = 0xFFFFUL; // Initial value
NRF_RADIO->CRCPOLY = 0x11021UL; // CRC poly: x^16+x^12^x^5+1
}
/**
* @brief 禁止crc
*/
void drv_radio_disable_crc(void)
{
NRF_RADIO->CRCCNF = (RADIO_CRCCNF_LEN_Disabled << RADIO_CRCCNF_LEN_Pos);
}
/**
* @brief 使能中断
* @note 使能EVENTS_READY,EVENTS_END,EVENTS_DISABLED中断
*/
void drv_radio_enable_irq(void)
{
NVIC_SetPriority(RADIO_IRQn, IRQ_PRIORITY_LOW);
NVIC_EnableIRQ(RADIO_IRQn);
NRF_RADIO->INTENSET = (RADIO_INTENSET_READY_Enabled << RADIO_INTENSET_READY_Pos) |
(RADIO_INTENSET_END_Enabled << RADIO_INTENSET_END_Pos) |
(RADIO_INTENSET_DISABLED_Enabled << RADIO_INTENSET_DISABLED_Pos);
}
/**
* @brief 向buf中写入数据
* @param buf: 发送数据
* @param length: 数据长度
*/
void drv_radio_write_buf(uint8_t *buf, uint8_t length)
{
memcpy(radio_buf, buf, length);
}
/**
* @brief 从buf中读取数据
* @param buf: 读取数据存放缓存
* @param length: 数据长度
*/
void drv_radio_read_buf(uint8_t *buf, uint8_t length)
{
memcpy(buf, radio_buf, length);
}
/**
* @brief 使能发送
* @note 使能成功后产生事件EVENTS_READY
*/
void drv_radio_enable_tx(void)
{
drv_rfx2401c_disable_rx();
drv_rfx2401c_enable_tx();
NRF_RADIO->EVENTS_READY = 0;
NRF_RADIO->TASKS_TXEN = 1;
}
/**
* @brief 开始工作
* @note 成功后产生事件EVENTS_END
*/
void drv_radio_start_work(void)
{
NRF_RADIO->EVENTS_END = 0;
NRF_RADIO->TASKS_START = 1;
}
/**
* @brief 关闭射频模块
* @note 关闭成功后产生事件EVENTS_DISABLED
*/
void drv_radio_disable(void)
{
drv_rfx2401c_disable_rx();
drv_rfx2401c_disable_tx();
NRF_RADIO->EVENTS_DISABLED = 0;
NRF_RADIO->TASKS_DISABLE = 1;
}
/**
* @brief 使能接收
* @note 使能成功后产生事件EVENTS_READY
*/
void drv_radio_enable_rx(void)
{
drv_rfx2401c_enable_rx();
drv_rfx2401c_disable_tx();
NRF_RADIO->EVENTS_READY = 0;
NRF_RADIO->TASKS_RXEN = 1;
}
/**
* @brief 读取射频状态
* @retval 射频状态
*/
RadioState drv_radio_get_state(void)
{
return (RadioState)NRF_RADIO->STATE;
}
/**
* @brief 读取接收RSSI
* @retval RSSI.单位-1dBm
*/
uint8_t drv_radio_get_rssi(void)
{
return NRF_RADIO->RSSISAMPLE;
}
/**
* @brief 配置射频模块
* @param tx_power: 发射功率
* @param frequency: 通讯频点
* @param baudrate: 通讯波特率
* @param address: 地址
* @param playload_length: 载荷长度
*/
void drv_radio_config(TxPower tx_power, uint16_t frequency, RadioBaudrate baudrate, uint32_t address, uint8_t playload_length)
{
drv_rfx2401c_init();
drv_radio_set_txpower(tx_power);
drv_radio_set_frequency(frequency);
drv_radio_set_baudrate(baudrate);
drv_radio_set_address(address);
NRF_RADIO->PCNF0 = (PACKET_S1_FIELD_SIZE << RADIO_PCNF0_S1LEN_Pos) |
(PACKET_S0_FIELD_SIZE << RADIO_PCNF0_S0LEN_Pos) |
(PACKET_LENGTH_FIELD_SIZE << RADIO_PCNF0_LFLEN_Pos);
NRF_RADIO->PCNF1 = (RADIO_PCNF1_WHITEEN_Disabled << RADIO_PCNF1_WHITEEN_Pos) |
(RADIO_PCNF1_ENDIAN_Big << RADIO_PCNF1_ENDIAN_Pos) |
(PACKET_BASE_ADDRESS_LENGTH << RADIO_PCNF1_BALEN_Pos) |
(playload_length << RADIO_PCNF1_STATLEN_Pos) |
(PACKET_PAYLOAD_MAXSIZE << RADIO_PCNF1_MAXLEN_Pos);
NRF_RADIO->SHORTS = RADIO_SHORTS_ADDRESS_RSSISTART_Enabled << RADIO_SHORTS_ADDRESS_RSSISTART_Pos;
drv_radio_enable_crc();
drv_radio_enable_irq();
NRF_RADIO->PACKETPTR = (uint32_t) radio_buf;
}
/**
* @brief 设置回调函数: 射频中断
* @param function: 回调函数.回调函数的第一个参数有效,值为RadioIrqEvents
*/
void drv_radio_set_callback_irq_handle(T_Callback function)
{
Callback = function;
}
void RADIO_IRQHandler()
{
if (Callback != 0)
{
Callback(deal_irq_handle(), NULL, 0);
}
}
static RadioIrqEvents deal_irq_handle(void)
{
if (NRF_RADIO->EVENTS_READY && (NRF_RADIO->INTENSET & RADIO_INTENSET_READY_Msk))
{
NRF_RADIO->EVENTS_READY = 0;
return RADIO_IRQ_EVENTS_READY;
}
if (NRF_RADIO->EVENTS_END && (NRF_RADIO->INTENSET & RADIO_INTENSET_END_Msk))
{
NRF_RADIO->EVENTS_END = 0;
return RADIO_IRQ_EVENTS_END;
}
if (NRF_RADIO->EVENTS_DISABLED && (NRF_RADIO->INTENSET & RADIO_INTENSET_DISABLED_Msk))
{
NRF_RADIO->EVENTS_DISABLED = 0;
return RADIO_IRQ_EVENTS_DISABLED;
}
return RADIO_IRQ_NULL;
}
radio.h
/**
* Copyright (c), 2015-2025
* @file radio.h
* @brief 射频模块头文件
* @author jdh
* @verbatim
* Change Logs:
* Date Author Notes
* 2017-12-14 jdh 新建
* @endverbatim
*/
#ifndef _RADIO_H_
#define _RADIO_H_
#include "drivers.h"
#include "clock.h"
#pragma pack(1)
/**
* @brief 接收数据结构
*/
struct _Radio_Rx
{
uint8_t buf[RADIO_BUF_SIZE];
uint8_t length;
uint8_t rssi;
// 本地周期时间
uint32_t local_cycle_time;
T_Time local_time;
};
#pragma pack()
typedef enum
{
RADIO_EVENTS_TX_END,
RADIO_EVENTS_RX_END
} RadioEvents;
/**
* @brief 观察者模式: 射频模块事件处理函数指针
* @note 在事件是接收完成时接收数据参数有效
* @param events: 中断事件
* @param rx: 接收数据
*/
typedef void (*T_Radio_Deal_Event)(RadioEvents events, struct _Radio_Rx rx);
/**
* @brief 模块载入
*/
void radio_load(void);
/**
* @brief 模块运行
*/
void radio_run(void);
/**
* @brief 注册观察者
* @param function: 回调函数指针
*/
void radio_register_observer(T_Radio_Deal_Event function);
/**
* @brief 设置接收参数
* @param frequency: 接收频点.单位:MHz
* @param length: 接收数据定长
*/
void radio_set_rx_parameter(uint16_t frequency, uint8_t length);
/**
* @brief 射频模块是否空闲状态
* @param true: 是.0: 否
*/
bool radio_is_free(void);
/**
* @brief 射频模块是否接收状态
* @param true: 是.0: 否
*/
bool radio_is_rx(void);
/**
* @brief 射频模块是否发送状态
* @param true: 是.0: 否
*/
bool radio_is_tx(void);
/**
* @brief 射频模块停止工作
* @note 发送之前必须调用本函数
*/
void radio_stop(void);
/**
* @brief 发送数据
* @note 调用本函数前必须调用radio_stop()函数
* @param frequency: 接收频点.单位:MHz
* @param buf: 发送数据
* @param length: 数据长度
*/
void radio_send(uint16_t frequency, uint8_t *buf, uint8_t length);
#endif radio.c
/**
* Copyright (c), 2015-2025
* @file radio.c
* @brief 射频模块主文件
* @author jdh
* @verbatim
* 说明:
* 为提高效率,由本模块将需要转发的数据存储到仓库
*
* Change Logs:
* Date Author Notes
* 2017-12-14 jdh 新建
* 2018-01-17 jdh 将需要转发的数据存储到仓库
* @endverbatim
*/
#include "framework.h"
#include "repository/node_repository.h"
/**
* @brief 观察者最大个数
*/
#define MAX_OBSERVER 4
enum
{
S_FREE,
S_TX,
S_RX
} State_Machine = S_FREE;
/**
* @brief 接收数据观察者列表
*/
static T_Radio_Deal_Event Observer[MAX_OBSERVER];
static uint8_t Len_Observer = 0;
/**
* @brief 接收参数
*/
static uint16_t Rx_Frequency;
static uint8_t Rx_Len;
/**
* @brief 中断参数
*/
static RadioEvents Radio_Events;
static struct _Radio_Rx Radio_Rx;
static bool Is_Irq = false;
static void deal_radio_irq(uint8_t index, uint8_t *buf, uint8_t len);
static void deal_events_ready(void);
static void deal_events_end(void);
static void deal_rx(struct _Radio_Rx *rx);
static void deal_events_disabled(void);
static void enable_rx(void);
static void save_repository(void);
/**
* @brief 模块载入
*/
void radio_load(void)
{
drv_radio_set_callback_irq_handle(deal_radio_irq);
}
static void deal_radio_irq(uint8_t index, uint8_t *buf, uint8_t len)
{
switch (index)
{
case RADIO_IRQ_EVENTS_READY:
{
deal_events_ready();
break;
}
case RADIO_IRQ_EVENTS_END:
{
deal_events_end();
break;
}
case RADIO_IRQ_EVENTS_DISABLED:
{
deal_events_disabled();
break;
}
default:
{
break;
}
}
}
static void deal_events_ready(void)
{
switch (State_Machine)
{
case S_FREE:
{
drv_radio_disable();
break;
}
case S_TX:
{
drv_radio_start_work();
break;
}
case S_RX:
{
drv_radio_start_work();
break;
}
}
}
static void deal_events_end(void)
{
switch (State_Machine)
{
case S_FREE:
{
drv_radio_disable();
break;
}
case S_TX:
{
if (!Is_Irq)
{
Radio_Events = RADIO_EVENTS_TX_END;
Is_Irq = true;
}
drv_radio_disable();
break;
}
case S_RX:
{
if (!Is_Irq)
{
deal_rx(&Radio_Rx);
if (Radio_Rx.length > 0)
{
Radio_Events = RADIO_EVENTS_RX_END;
Is_Irq = true;
}
}
drv_radio_start_work();
//drv_radio_disable();
break;
}
}
}
static void deal_rx(struct _Radio_Rx *rx)
{
if (NRF_RADIO->CRCSTATUS == 1)
{
rx->local_cycle_time = get_local_cycle_time();
rx->local_time = get_local_time();
rx->rssi = drv_radio_get_rssi();
rx->length = drv_radio_get_playload_length();
if (rx->length > PTRUP_LEN_FRAME_HEAD)
{
drv_radio_read_buf(rx->buf, rx->length);
}
log_add_num_radio_rx();
}
else
{
rx->length = 0;
}
}
static void deal_events_disabled(void)
{
switch (State_Machine)
{
case S_FREE:
{
break;
}
case S_TX:
{
enable_rx();
State_Machine = S_RX;
break;
}
case S_RX:
{
enable_rx();
break;
}
}
}
static void enable_rx(void)
{
drv_radio_set_frequency(Rx_Frequency);
drv_radio_set_playload_length(Rx_Len);
drv_radio_enable_rx();
}
/**
* @brief 模块运行
*/
void radio_run(void)
{
if (Is_Irq)
{
save_repository();
for (uint8_t i = 0;i < Len_Observer;i++)
{
Observer[i](Radio_Events, Radio_Rx);
}
Is_Irq = false;
}
}
static void save_repository(void)
{
T_Link_Node_Ptr node = link_list_init_node();
node->device = Radio_Rx.buf[PTRUP_SRC_DEVICE_POS];
node->channel = Rx_Frequency;
node->rssi = Radio_Rx.rssi;
node->slot = get_system_time() / SLOT_TIME;
node->body_len = Radio_Rx.length - PTRUP_LEN_FRAME_HEAD;
node->time = get_local_time_us();
node->body = malloc(node->body_len);
memcpy(node->body, Radio_Rx.buf + PTRUP_LEN_FRAME_HEAD, node->body_len);
node_repository_append(true, node);
}
/**
* @brief 注册观察者
* @param function: 回调函数指针
*/
void radio_register_observer(T_Radio_Deal_Event function)
{
Observer[Len_Observer++] = function;
}
/**
* @brief 设置接收参数
* @param frequency: 接收频点.单位:MHz
* @param length: 接收数据定长
*/
void radio_set_rx_parameter(uint16_t frequency, uint8_t length)
{
radio_stop();
Rx_Frequency = frequency;
Rx_Len = length;
State_Machine = S_RX;
enable_rx();
}
/**
* @brief 射频模块是否空闲状态
* @param true: 是.0: 否
*/
bool radio_is_free(void)
{
return State_Machine == S_RX;
}
/**
* @brief 射频模块是否接收状态
* @param true: 是.0: 否
*/
bool radio_is_rx(void)
{
return State_Machine == S_RX;
}
/**
* @brief 射频模块是否发送状态
* @param true: 是.0: 否
*/
bool radio_is_tx(void)
{
return State_Machine == S_TX;
}
/**
* @brief 射频模块停止工作
* @note 发送之前必须调用本函数
*/
void radio_stop(void)
{
if (State_Machine != S_FREE)
{
State_Machine = S_FREE;
drv_radio_disable();
while (drv_radio_get_state() != RADIO_STATE_DISABLE){}
}
}
/**
* @brief 发送数据
* @note 调用本函数前必须调用radio_stop()函数
* @param frequency: 接收频点.单位:MHz
* @param buf: 发送数据
* @param length: 数据长度
*/
void radio_send(uint16_t frequency, uint8_t *buf, uint8_t length)
{
if (State_Machine != S_FREE)
{
return;
}
State_Machine = S_TX;
drv_radio_set_frequency(frequency);
drv_radio_write_buf(buf, length);
drv_radio_set_playload_length(length);
drv_radio_enable_tx();
log_add_num_radio_tx();
}
测试代码：初始化
drv_radio_config(RADIO_TXPOWER_POS4DBM,
config_para.listen_channel + RADIO_BASE_FREQUENCY,
RADIO_BAUDRATE_1M, RADIO_ADDRESS,
config_para.listen_len);
测试代码：发送
static void uart_forward_radio(void)
{
if (!radio_is_free())
{
return;
}
uint64_t time_now = get_local_time_us();
while (1)
{
node_repository_get(false, &_node);
if (_node.body_len == 0)
{
return;
}
if (time_now - _node.time < _downstream_timeout_us)
{
break;
}
log_add_num_radio_tx_timeout();
}
memcpy(_buffer.buf + PTRDP_LEN_FRAME_HEAD, _node.body, _node.body_len);
_buffer.len = PTRDP_LEN_FRAME_HEAD + _node.body_len;
radio_stop();
_buffer.buf[PTRDP_DST_DEVICE_POS] = _node.device;
uint32_t time = get_system_time();
_buffer.buf[PTRDP_TIMESTAMP_POS] = time >> 16;
_buffer.buf[PTRDP_TIMESTAMP_POS + 1] = time >> 8;
_buffer.buf[PTRDP_TIMESTAMP_POS + 2] = time;
radio_send(_node.channel, _buffer.buf, _buffer.len);
}