MARVEL/pwm32e_pro
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

V1.0

Browse Source
This commit is contained in:
moyuhai
2026-06-09 16:39:17 +08:00
commit 41a602f89c
3057 changed files with 771495 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
project/example/2.4g/RF24_ACK_Payload/app/src/main.c
+506
View File
@@ -0,0 +1,506 @@
/*!
* \file main.c
*
* \brief Target main implementation
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include "main.h"
#include "xc6xxx_rf_2_4g.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
bool rf_send_timer_flag = false;
uint8_t recv_ack_buff[BUFF_LEN] = {0};
uint8_t ack_buff[BUFF_LEN] = {0};
uint32_t ack_payload_cnt = 0;
uint32_t ack_payload_error = 0;
/*------------------------------------------------------------------------------------
Func Prototype
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
/**
****************************************************************************************
* @brief
*
* @param[in]
* @param[in]
****************************************************************************************
*/
void timer_init(uint8_t timer_id, uint32_t timer_cnt)
{
LOGI("timer_init\r\n");
uint32_t timerx_us = timer_cnt * 1000;
Timer_InitCfg_t timer_cfg;
timer_cfg.timer_src_clk = TIMER_CLK_SRC_32M_DIV;
timer_cfg.timer_div_clk = TIMER_DIV_CLK_1MHzOr1K;
timer_cfg.timer_mode = TIMER_MODE_CYCLE;
xc_timer_init(timer_id, &timer_cfg);
xc_timer_set_value(timer_id, timerx_us);
xc_timer_start(timer_id);
}
/**
* @brief Timer0_Callback
* @param void * - context
*
* @retval void
*/
void timer0_callback(void *context)
{
#if !(XINCX_RF_MODE)
rf_send_timer_flag = true;
#endif // !(XINCX_RF_MODE)
}
/**
****************************************************************************************
* @brief Clock Initialization
*
* @param[in]
* @param[in]
****************************************************************************************
*/
void clock_init(void)
{
CLOCK_InitCfg_t clock_cfg;
clock_cfg.hfclk_src = CLOCK_HFCLK_SRC_XTAL;
clock_cfg.hfclk_in = CLOCK_HFCLK_IN_32M;
#if (RC_32K)
clock_cb.lfclk_src = CLOCK_LFCLK_SRC_RC;
#endif //(RC_32K)
#if (XTAL_32K)
clock_cb.lfclk_src = CLOCK_LFCLK_SRC_XTAL;
#endif // (XTAL_32K)
#if (XTAL_32768K)
clock_cb.lfclk_src = CLOCK_LFCLK_SRC_XTAL;
#endif // (XTAL_32768K)
if (clock_cfg.lfclk_src == CLOCK_LFCLK_SRC_XTAL) {
clock_cfg.lfclk_in = CLOCK_LFCLK_IN_32768;
} else if (clock_cfg.lfclk_src == CLOCK_LFCLK_SRC_RC) {
clock_cfg.lfclk_in = CLOCK_LFCLK_IN_32K;
}
xc_clock_init_cfg(&clock_cfg);
SysTick_Config(xc_clock_hfclk_in_get() / 100);
SysTick->CTRL &= ~SysTick_CTRL_TICKINT_Msk;
}
/**
* @brief Rf 2.4g dump log
* @param void
*
* @retval void
*/
#ifdef DEBUG_LOG
void rf_dump_log(void)
{
LOGI("***************** 2.4G Param ******************\n");
LOGI("CFG_TOP: 0x%08x\r\n", XC_RF_2_4G->CFG_TOP);
LOGI("EN_AA: 0x%08x\r\n", XC_RF_2_4G->EN_AA);
LOGI("EN_RXADDR: 0x%08x\r\n", XC_RF_2_4G->EN_RXADDR);
LOGI("SETUP_AW: 0x%08x\r\n", XC_RF_2_4G->SETUP_AW);
LOGI("SETUP_RETR: 0x%08x\r\n", XC_RF_2_4G->SETUP_RETR);
LOGI("RF_CH: 0x%08x\r\n", XC_RF_2_4G->RF_CH);
LOGI("SETUP_RF: 0x%08x\r\n", XC_RF_2_4G->SETUP_RF);
LOGI("STATUS: 0x%08x\r\n", XC_RF_2_4G->STATUS);
LOGI("OBSERVE_TX: 0x%08x\r\n", XC_RF_2_4G->OBSERVE_TX);
LOGI("RSSI: 0x%08x\r\n", XC_RF_2_4G->RSSI);
LOGI("RX_ADDR_P0: 0x%02x%08x\r\n", 0xFF & (XC_RF_2_4G->RX_ADDR_P0_H), XC_RF_2_4G->RX_ADDR_P0_L);
LOGI("RX_ADDR_P1: 0x%02x %08x\r\n", 0xFF & (XC_RF_2_4G->RX_ADDR_P1_H), XC_RF_2_4G->RX_ADDR_P1_L);
LOGI("RX_ADDR_P2TOP5:0x%08x\r\n", XC_RF_2_4G->RX_ADDR_P2TOP5);
LOGI("BER_RESULT: 0x%08x%08x\r\n", XC_RF_2_4G->BER_ERR_CNT, XC_RF_2_4G->BER_RECV_CNT);
LOGI("AGC_SETTING: 0x%08x\r\n", XC_RF_2_4G->AGC_SETTING);
LOGI("PGA_SETTING: 0x%02x%08x\r\n", ((XC_RF_2_4G->TX_ADDR_H) & 0xFF00) >> 8, XC_RF_2_4G->PGA_SETTING);
LOGI("TX_ADDR: 0x%02x%08x\r\n", ((XC_RF_2_4G->TX_ADDR_H) & 0xFF), XC_RF_2_4G->TX_ADDR_L);
LOGI("RX_PW_PX: 0x%04x %08x\r\n", 0xFFFF & (XC_RF_2_4G->RX_PW_Px_H), XC_RF_2_4G->RX_PW_Px_L);
LOGI("STATUS_FIFO: 0x%08x\r\n", XC_RF_2_4G->STATUS_FIFO);
LOGI("RSSIREC: 0x%08x\r\n", XC_RF_2_4G->RSSIREC);
LOGI("TXPROC_CFG: 0x%08x\r\n", XC_RF_2_4G->TXPROC_CFG);
LOGI("RXPROC_CFG: 0x%02x%08x\r\n", 0xFF & (XC_RF_2_4G->RXPROC_CFG_H), XC_RF_2_4G->RXPROC_CFG_L);
LOGI("DYNPD: 0x%08x\r\n", XC_RF_2_4G->DYNPD);
LOGI("FEATURE: 0x%08x\r\n", XC_RF_2_4G->FEATURE);
LOGI("PGA_SETTING_H: 0x%08x\r\n", XC_RF_2_4G->TX_ADDR_H);
LOGI("TX_POWER 0x%08x\r\n", (XC_BT_RF->ana21_reg_l >> 6) & 0x3f);
LOGI("ana11_reg_l: 0x%08x\r\n", XC_BT_RF->ana11_reg_l);
LOGI("***********************************************\n");
LOGI("\r\n");
}
#endif
/**
* @brief RF 2.4g data config
* @param uint8_t * - buff
* uint8 - len
* @retval uint8_t - 0
*/
uint8_t rf_data_config(uint8_t *buff, uint8_t len)
{
if (len == 0) {
return FAIL;
}
for (uint8_t i = 0; i < len; i++) {
buff[i] = i;
}
return SUCCESS;
}
/**
* @brief RF ack payload config
* @param void
* @retval void
*/
void rf_ack_payload_config(void)
{
#if (XINCX_RF_TRANS_RATE == RATE_250K)
XC_RF_2_4G->SETUP_RETR = 0xf0;
#endif //(XINCX_RF_TRANS_RATE == RATE_250K)
}
/**
* @brief RF ack tx fifo
* @param uint8_t * - ack_buff
* @param uint8_t - buff_len
* @retval void
*/
void rf_ackpayload_tx_fifo(uint8_t *rx_send_ack_buff, uint8_t buff_len)
{
for (uint8_t i = 0; i < RF_SEND_CMD_CNT; i++)
XC_RF_2_4G->CMD_CFG = CMD_DONE | W_ACK_PLOAD;
for (uint8_t i = 0; i < buff_len; i++) {
XC_RF_2_4G->TX_FIFO_DATA = rx_send_ack_buff[i];
}
}
/**
* @brief RF ack recv event
* @param uint8_t * - ack_buff
* @param uint8_t - buff_len
* @retval void
*/
uint8_t rf_recv_ackpayload_event(uint8_t *tx_recv_ack_buff)
{
XC_RF_2_4G->CMD_CFG = CMD_DONE | R_RX_PL_WID;
uint8_t ack_len = XC_RF_2_4G->RX_FIFO_LEN & 0xff;
if (ack_len) {
for (uint8_t i = 0; i < RF_RECV_CMD_CNT; i++) {
nop_cnt(16);
XC_RF_2_4G->CMD_CFG = CMD_DONE | R_RX_PLOAD;
nop_cnt(16);
}
for (uint8_t i = 0; i < ack_len; i++) {
tx_recv_ack_buff[i] = XC_RF_2_4G->RX_FIFO_DATA;
}
}
XC_RF_2_4G->CMD_CFG = FLUSH_RX | CMD_DONE;
XC_RF_2_4G->STATUS = MASK_RX_DR;
return ack_len;
}
/**
* @brief RF 2.4g tx manage
* @param rf_data_typedef_t * - rf_data
* @retval uint8_t - cnt
*/
uint32_t rf_tx_manage(rf_data_typedef_t *rf_data)
{
uint8_t ack_status = TX_DATA_INVALID;
uint8_t ack_len = 0;
static uint32_t ack_cnt = 0;
#ifdef XC_SEND_NUM // Limited number of transmissions
if (rf_data->cnt == XC_SEND_NUM) {
rf_data->cnt += 1;
LOGI("SEND END\r\n");
/* Turn off the send timer */
xc_timer_stop(RF_TX_TIMERx);
}
if ((rf_data->cnt < XC_SEND_NUM) && (rf_send_timer_flag)) {
#else // Timed transmission
if (rf_send_timer_flag) {
#endif // XC_SEND_NUM
rf_send_timer_flag = false;
rf_data->cnt += 1;
/* Filling in software frame number */
rf_data->buff[0] = rf_data->cnt;
LOGI("send_cnt:%d\r\n", rf_data->cnt);
/* data transmission */
ack_status = rf_tx_event(rf_data->buff, rf_data->data_length);
/* Response data processing */
if (ack_status == TX_DATA_OK) {
ack_status = TX_DATA_INVALID;
ack_len = rf_recv_ackpayload_event(ack_buff);
// LOGI("ack_len:%d\r\n", ack_len);
XC_RF_2_4G->STATUS = MASK_ALL_INTER;
}
if (ack_len != 0) {
ack_cnt += 1;
LOGI("ack :%d\r\n", ack_cnt);
for (uint8_t i = 0; i < ack_len; i++) {
// LOGI("%0d ", ack_buff[i]);
}
LOGI("\r\n");
ack_len = 0;
/* Clear response data*/
memset(ack_buff, 0, sizeof(ack_buff));
}
}
return rf_data->cnt;
}
/**
* @brief RF 2.4g rx manage
* @param rf_data_typedef_t * - rf_data
* @retval uint32_t - 0
*/
#if !(XINCX_RF_NVIC_MODE)
uint32_t rf_rx_manage(rf_data_typedef_t *rf_data)
{
static uint32_t conut = 0;
static uint32_t recv_cnt = 0;
static uint32_t recv_err = 0;
/* Receive event processing */
uint8_t len = rf_rx_event(rf_data->buff);
/* Receiving end polling data processing */
if (len != 0) {
/* Entering standby mode */
CE_CTL_LOW;
/* ack payoad */
rf_ackpayload_tx_fifo(rf_data->buff, 32);
/* Receive Count */
conut += 1;
LOGI("recv:%d\r\n", conut);
/* Receiving data processing */
if (rf_data->buff[RF_CONFIRMED_VALUE] == RF_CONFIRMED_VALUE) {
LOGI("%d\r\n", recv_cnt);
recv_cnt += 1;
} else {
recv_err += 1;
}
rf_buff_info(rf_data->buff, len);
/* Receive read data buffer reset */
memset(rf_data->buff, 0, len);
len = 0;
/* Entering the receiver */
CE_CTL_HIGH;
}
return 0;
}
#else
uint32_t rf_rx_manage(rf_data_typedef_t *rf_data)
{
static uint32_t conut = 0;
static uint32_t recv_cnt = 0;
static uint32_t recv_err = 0;
uint8_t len = recv_len;
if (rf24g_handler_flag) {
/* Entering standby mode */
CE_CTL_LOW;
rf24g_handler_flag = false;
/* Ack payoad */
memcpy(recv_ack_buff, recv_buf, len);
rf_ackpayload_tx_fifo(recv_ack_buff, len);
if ((len != 0) && (recv_buf[RF_CONFIRMED_VALUE] == RF_CONFIRMED_VALUE)) {
recv_cnt += 1;
} else {
recv_err += 1;
}
// rf_buff_info(recv_buf, len);
/* Receive Count */
conut += 1;
xc_timer_set_value(RF_RX_TIMERx, 3000000);
xc_timer_start(RF_RX_TIMERx);
LOGI("recv:%d\r\n", conut);
/* Receive read data buffer reset */
memset(recv_buf, 0, len);
len = 0;
recv_len = 0;
/* Entering the receiver */
CE_CTL_HIGH;
}
return 0;
}
#endif //!(XINCX_RF_NVIC_MODE)
/**
* @brief RF 2.4g buff info
* @param uint8_t * - buff
* uint8_t len
* @retval void
*/
void rf_buff_info(uint8_t *buff, uint8_t len)
{
for (uint8_t i = 0; i < len; i++)
LOGI("%d ", buff[i]);
LOGI("\r\n");
}
void app_uart_init(void)
{
GPIO_InitCfg_t gpio_cfg = {0};
gpio_cfg.Mux = GPIO_Mux0;
gpio_cfg.Pull = GPIO_PULLUP;
gpio_cfg.Int = NOT_INT;
gpio_cfg.FunSel = UART0_TX;
gpio_cfg.Pin = GPIO_18;
gpio_cfg.Dir = GPIO_DIR_OUTPUT;
xc_gpio_init(&gpio_cfg);
gpio_cfg.FunSel = UART0_RX;
gpio_cfg.Pin = GPIO_19;
gpio_cfg.Dir = GPIO_DIR_INPUT;
xc_gpio_init(&gpio_cfg);
UART_InitCfg_t uart_cfg = {0};
uart_cfg.Parity = UART_PARITY_DISABLE;
uart_cfg.StopBits = UART_STOP_1_BITS;
uart_cfg.WordLength = UART_DATA_8_BITS;
uart_cfg.BaudRate = UART_BAUDRATE_115200;
uart_cfg.HardwareFlowControl = UART_HWFC_DISABLE;
xc_uart_init(UART0_IDX, &uart_cfg);
}
/**
* @brief main
* @details
* @param[in] void
* @param[out] void
* @retval int - 0
* @retval void
* @par identifier
* reserve
* @par other
* void
* @par change log
* Alex created on 2023-05-31
*/
int main(void)
{
rf_data_typedef_t rf_data;
/* TX data packaging filling */
rf_data_config(rf_data.buff, sizeof(rf_data.buff));
rf_data.cnt = 0;
rf_data.temp = SEND_TIMERMS_CNT;
/* Clock initialization */
clock_init();
/* Serial port initialization */
app_uart_init();
/* rf 2.4g initialization configuration */
rf24g_init();
/* Set up ACKPAYLOD */
rf_ack_payload_config();
/* Set testing frequency points */
rf_set_channel(XINCX_2_4G_CHANNEL);
#if (XINCX_RF_TRANS_RATE == RATE_2M)
/* Set 2M mode register configuration */
/* Don't move this function interface */
rf_2M_config();
#endif //(XINCX_RF_TRANS_RATE == RATE_2M)
#ifdef DEBUG_LOG
/* Register information printing */
rf_dump_log();
#endif // DEBUG_LOG
#if XINCX_RF_MODE
/* ACK data packaging filling */
rf_data_config(ack_buff, sizeof(ack_buff));
/* Fill in TX FIFO */
rf_ackpayload_tx_fifo(ack_buff, sizeof(ack_buff));
/* Receive timeout setting :ms */
timer_init(RF_RX_TIMERx, RECV_TIMERMS_OUT);
/* RX enters receiver */
CE_CTL_HIGH;
#else
/* Launch data packaging filling */
rf_data_config(rf_data.buff, sizeof(rf_data.buff));
/* Set emission interval */
timer_init(RF_TX_TIMERx, SEND_TIMERMS_CNT);
#endif // XINCX_RF_MODE
for (;;) {
#if XINCX_RF_MODE
/* receive */
rf_rx_manage(&rf_data);
#else
/* sending */
rf_data.cnt = rf_tx_manage(&rf_data);
#endif // XINCX_RF_MODE
}
}