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

Stair56E UART project

Browse Source
This commit is contained in:
吴琪
2026-08-05 19:07:52 +08:00
parent 7ca1af130d
commit f5654b70cc
2500 changed files with 619007 additions and 282610 deletions
Download Patch File Download Diff File Expand all files Collapse all files
project/example/2.4g/RF24_TEST_CMD/app/shell/api/shell.h
+78
View File
@@ -0,0 +1,78 @@
/*!
* \file shell.h
*
* \brief The head file of shell.c
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __SHELL_H__
#define __SHELL_H__
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "xc6xxx_rf_2_4g.h"
//#include "dbg.h"
#include "shell_handler.h"
#include "shell_rf_handler.h"
#include "xc6xxx.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
#define XC_DATA_LEN 64U
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
typedef enum
{
XC_SHELL_CMD_RECV = 0,
XC_SHELL_CMD_PROC
} eXC_Shell_Proc_state;
typedef struct
{
char *cmd;
eXC_Cmd_State (*fn)(eCMD_Type opt, int srgc, char *srgv[]);
} XC_Cmd_Table_t;
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Exported Functions
-------------------------------------------------------------------------------------*/
void app_uart_init(void);
void xc_shell_init(void);
void xc_shell_test_case(void);
void shell_cmd_process(void);
#ifdef __cplusplus
}
#endif
#endif /* __SHELL_H__ */
project/example/2.4g/RF24_TEST_CMD/app/shell/api/shell_handler.h
+115
View File
@@ -0,0 +1,115 @@
/*!
* \file shell.h
*
* \brief The head file of shell_handler.c
*
* \copyright Revised BSD License, see section \ref LICENSE.
*
* \code
*
* _ __ _ ________ _
* | |/ /(_)___ / ____/ /_ (_)___
* | // / __ \/ / / __ \/ / __ \
* / |/ / / / / /___/ / / / / /_/ /
* /_/|_/_/_/ /_/\____/_/ /_/_/ .___/
* /_/
* (C) 2022-2025 XinChip
*
* \endcode
*
* \author ( XinChip ) Alex-J
*
* \author ( XinChip )
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __SHELL_HANDLER_H__
#define __SHELL_HANDLER_H__
/*-----------------------------------------------------------------------------------
INCLUDE HEADE FILES
------------------------------------------------------------------------------------*/
//#include "co_bt_defines.h"
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "xc6xxx.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
#define XC_CMD_SIZE 255U
#define SEND_DATA_LEN 512
// XC Command
#define XC_OK "OK"
#define XC_ERROR "+CME ERROR:"
#define XC_CMD_TEST "+TEST"
#define XC_CMD_REBOOT "+REBOOT"
#define XC_CMD_RF_ACK_INIT "+RF_ACK_INIT"
#define XC_CMD_RF_ADV_INIT "+RF_ADV_INIT"
#define XC_CMD_RF_SINGLE_INIT "+RF_SINGLE_INIT"
#define XC_CMD_RF_ACK_SEND_EVENT "+RF_ACK_SEND_EVENT"
#define XC_CMD_RF_ACK_RECV_EVENT "+RF_ACK_RECV_EVENT"
#define XC_CMD_RF_ADV_SEND_EVENT "+RF_ADV_SEND_EVENT"
#define XC_CMD_RF_ADV_RECV_EVENT "+RF_ADV_RECV_EVENT"
#define XC_CMD_RF_SET_CHANNEL "+RF_SET_CHANNEL"
#define XC_CMD_RF_SET_POWER "+RF_SET_POWER"
#define XC_CMD_RF_SET_RATE "+RF_SET_RATE"
#define XC_CMD_RF_SET_ADDR "+RF_SET_ADDR"
#define XC_CMD_RF_GET_REG_VALUE "+RF_GET_REG_VALUE"
#define XC_CMD_RF_SET_ANA_REG "+RF_SET_ANA_REG"
#define XC_CMD_RF_GET_ANA_REG "+RF_GET_ANA_REG"
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
typedef enum
{
RF_IDLE = 0,
RF_BLE_MODE,
RF_24G_MODE
} eRF_MODE_Status;
typedef enum
{
XC_CMD_ERROR = -1,
XC_CMD_SUCCESS = 0
} eXC_Cmd_State;
typedef enum
{
QUERY_CMD = 0x00,
SET_CMD
} eCMD_Type;
typedef struct
{
uint8_t byte0;
uint8_t byte1;
uint8_t byte2;
uint8_t byte3;
uint8_t byte4;
uint8_t byte5;
} BLE_Mac_Addr_t;
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
extern uint8_t XC_Cmd[XC_CMD_SIZE];
/*------------------------------------------------------------------------------------
Exported Functions
-------------------------------------------------------------------------------------*/
int ascii_strn2val(const char str[], char base, char n);
eXC_Cmd_State xc_reboot_handler(eCMD_Type opt, int srgc, char *srgv[]);
#ifdef __cplusplus
}
#endif
#endif /* __SHELL_HANDLER_H__ */
project/example/2.4g/RF24_TEST_CMD/app/shell/api/shell_rf_handler.h
+44
View File
@@ -0,0 +1,44 @@
#ifndef SHELL_RF_HANDLER_H__
#define SHELL_RF_HANDLER_H__
#include "shell_handler.h"
typedef enum
{
RF_STANY,
RF_ACK_SEND,
RF_ACK_RECV,
RF_ADV_SEND,
RF_ADV_RECV,
RF_SINGLE
} erf_status_t;
extern uint16_t temp_ch;
erf_status_t rf24g_get_status(void);
eXC_Cmd_State xc_rf_ack_init_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_adv_init_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_single_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_ack_send_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_ack_recv_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_ack_payload_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_adv_send_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_adv_recv_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_sleep_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_wakeup_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_set_channel_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_set_power_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_set_trans_rate_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_set_addr_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_get_reg_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_set_ana_reg_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_rf_get_ana_reg_handler(eCMD_Type opt, int srgc, char *srgv[]);
int data_power(int data,uint8_t power);
int hexToDec(uint8_t hex);
#endif //SHELL_RF_HANDLER_H__
project/example/2.4g/RF24_TEST_CMD/app/shell/src/shell.c
+218
View File
@@ -0,0 +1,218 @@
/*!
* \file shell.c
*
* \brief Target shell 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 "shell.h"
/*------------------------------------------------------------------------------------
Local Variables
-------------------------------------------------------------------------------------*/
static XC_Cmd_Table_t XC_CMD_Table[] = {
{XC_CMD_REBOOT, xc_reboot_handler},
{XC_CMD_RF_ACK_INIT, xc_rf_ack_init_handler},
{XC_CMD_RF_ADV_INIT, xc_rf_adv_init_handler},
{XC_CMD_RF_SINGLE_INIT, xc_rf_single_handler},
{XC_CMD_RF_ACK_SEND_EVENT, xc_rf_ack_send_handler},
{XC_CMD_RF_ACK_RECV_EVENT, xc_rf_ack_recv_handler},
{XC_CMD_RF_ADV_SEND_EVENT, xc_rf_adv_send_handler},
{XC_CMD_RF_ADV_RECV_EVENT, xc_rf_adv_recv_handler},
{XC_CMD_RF_SET_CHANNEL, xc_rf_set_channel_handler},
{XC_CMD_RF_SET_POWER, xc_rf_set_power_handler},
{XC_CMD_RF_SET_RATE, xc_rf_set_trans_rate_handler},
{XC_CMD_RF_SET_ADDR, xc_rf_set_addr_handler},
{XC_CMD_RF_GET_REG_VALUE, xc_rf_get_reg_handler},
{XC_CMD_RF_SET_ANA_REG, xc_rf_set_ana_reg_handler},
{XC_CMD_RF_GET_ANA_REG, xc_rf_get_ana_reg_handler},
};
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
#define XC_CMD_TABLE_SIZE (sizeof(XC_CMD_Table) / sizeof(XC_Cmd_Table_t))
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
eXC_Shell_Proc_state sh_sta = XC_SHELL_CMD_RECV;
uint8_t recv_buff[XC_CMD_SIZE] = {0};
//uint16_t recv_len = 0;
/*------------------------------------------------------------------------------------
Func Prototype
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
/**
****************************************************************************************
* @brief
*
* @param[in]
* @param[in]
*
* @return[out]
*
****************************************************************************************
*/
void xc_shell_init(void)
{
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);
xc_uart_enable_rx_it(UART0_IDX);
NVIC_EnableIRQ(UART0_IRQn);
}
/**
****************************************************************************************
* @brief
*
* @param[in]
* @param[in]
*
* @return[out]
*
****************************************************************************************
*/
eXC_Cmd_State xc_shell_proc(uint8_t *data, uint16_t data_len)
{
int srgc = 0;
int index = 0;
char *ptr = NULL;
char *srgv[XC_DATA_LEN];
eXC_Cmd_State ret = XC_CMD_ERROR;
uint8_t *rx_cmd = data + 2;
if (data_len <= 2 && data[data_len] == '\0') {
LOGI("error 1\r\n");
return ret;
}
// 注意这里 XC指令 只判定大写
if (data[0] != 'X' || data[1] != 'C') {
LOGI("error 2 \r\n");
goto xc_end;
}
for (index = 0; index < XC_CMD_TABLE_SIZE; index++) {
int cmd_len = strlen(XC_CMD_Table[index].cmd);
if (!strncmp((const char *)rx_cmd, XC_CMD_Table[index].cmd, cmd_len)) {
ptr = (char *)rx_cmd + cmd_len;
break;
}
}
if (index >= XC_CMD_TABLE_SIZE || !XC_CMD_Table[index].fn) {
LOGI("error 3 \r\n");
goto xc_end;
}
if (ptr[0] == '?') {
ret = XC_CMD_Table[index].fn(QUERY_CMD, srgc, srgv);
} else if (ptr[0] == '=') {
ptr += 1;
char *str = strtok((char *)ptr, " ");
while (str) {
srgv[srgc++] = str;
str = strtok((char *)NULL, " ");
}
ret = XC_CMD_Table[index].fn(SET_CMD, srgc, srgv);
} else {
LOGI("error 4 \r\n");
ret = XC_CMD_ERROR;
}
xc_end:
if (ret == XC_CMD_ERROR) {
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s %x\r\n", XC_ERROR, 1);
xc_uart_send_data(UART0_IDX, XC_Cmd, strlen((const char *)XC_Cmd));
} else {
xc_uart_send_data(UART0_IDX, XC_Cmd, strlen((const char *)XC_Cmd));
}
memset(XC_Cmd, 0, XC_CMD_SIZE);
return ret;
}
/**
****************************************************************************************
* @brief
*
* @param[in]
* @param[in]
*
* @return[out]
*
****************************************************************************************
*/
void shell_cmd_process(void)
{
/* main loop */
static uint16_t recv_len = 0;
switch (sh_sta) {
case XC_SHELL_CMD_RECV: {
// DEBUG(".");
recv_len += xc_uart_receive_data(UART0_IDX, recv_buff + recv_len);
if (recv_len) {
if ((recv_buff[recv_len - 2] == '\r') &&
(recv_buff[recv_len - 1] == '\n')) {
sh_sta = XC_SHELL_CMD_PROC;
//DEBUG("k");
} else {
//DEBUG("e");
}
}
} break;
case XC_SHELL_CMD_PROC: {
(void)xc_shell_proc(recv_buff, recv_len);
recv_len = 0;
sh_sta = XC_SHELL_CMD_RECV;
} break;
default:
break;
}
}
void xc_shell_test_case(void)
{
xc_shell_init();
while (1) {
shell_cmd_process();
}
}
project/example/2.4g/RF24_TEST_CMD/app/shell/src/shell_handler.c
+121
View File
@@ -0,0 +1,121 @@
/*!
* \file shell_handler.c
*
* \brief Target shell handler 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 "shell_handler.h"
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
uint8_t XC_Cmd[XC_CMD_SIZE] = {0};
static eRF_MODE_Status rf_mode_status = RF_IDLE;
static char ascii_char2val(const char c)
{
if (c >= '0' && c <= '9')
return c - '0';
if ((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))
return (c & 0x7) + 9;
return (char)(-1);
}
/*-------------------------------------------------------------------------
Function : ascii_strn2val ----add by chsheng,
chsheng@accelsemi.com Return: -1=error Description: str = "123" bas = 10 return
123 str = "123" bas = 16 return 0x123
-------------------------------------------------------------------------*/
int ascii_strn2val(const char str[], char base, char n)
{
int val = 0;
char v;
while (n != 0) {
v = ascii_char2val(*str);
#if 0
if (v == -1 || v >= base)
return -1;
#else
if (v == (char)(-1) || v >= base) {
if (val == 0) // to filter abormal beginning and ending
{
str++;
n--;
continue;
} else {
break;
}
}
#endif
val = val * base + v;
str++;
n--;
}
return val;
}
/**
****************************************************************************************
* @brief
*
* @param[in]
* @param[in]
*
* @return[out]
*
****************************************************************************************
*/
eXC_Cmd_State xc_test_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_ERROR;
switch (opt) {
case QUERY_CMD: {
ret = XC_CMD_SUCCESS;
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\n", XC_OK);
} break;
default:
break;
}
return ret;
}
eRF_MODE_Status get_ble_init_flag(void) { return rf_mode_status; }
eXC_Cmd_State xc_reboot_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_SUCCESS;
WDT_InitCfg_t wdt_cfg ;
wdt_cfg.WorkMode = WDT_WORK_MODE0;
wdt_cfg.ReloadValue = WDT_CLK_32M_RESET_MODE0_4096US;
xc_wdt_init( &wdt_cfg);
xc_wdt_start();
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\nOK\r\n", XC_CMD_REBOOT);
return ret;
}
project/example/2.4g/RF24_TEST_CMD/app/shell/src/shell_rf_handler.c
+544
View File
@@ -0,0 +1,544 @@
#include "shell_rf_handler.h"
#include "app_rf24g.h"
#include "xc6xxx_rf_single.h"
erf_status_t rf_status = RF_STANY;
static uint8_t rf_ack_addr[5] = {0};
uint32_t rf_ack_addr_l = 0;
uint32_t rf_ack_addr_h = 0;
uint8_t rf_ack_addr_width = 0;
uint16_t temp_ch = 0;
#define setbit(x,y) ((x) |= (1<<(y)))
#define clrbit(x,y) ((x) &= ~(1<<(y)))
void wbit(uint16_t reg_addr,int end,int start,uint32_t bit_str)
{
uint16_t reg_val = 0;
reg_val = *((volatile uint32_t *)(0x53021000UL + reg_addr * 4));
//LOGI("1-reg_val:0x%04x,bit_str:0x%04x\n",reg_val,bit_str);
uint16_t temp = 0;
for(int i=start;i<=end;i++)
{
if((bit_str>>(temp++))&0x1)
{
setbit(reg_val,i);
}
else
{
clrbit(reg_val,i);
}
}
//LOGI("2-reg_val:0x%04x\n",reg_val);
*((volatile uint32_t *)(0x53021000UL + reg_addr * 4)) = reg_val;
}
uint16_t rbit(uint16_t reg_addr)
{
return *((volatile uint32_t *)(0x53021000UL + reg_addr * 4));
}
/**
* @brief Rf 2.4g dump log
* @param void
*
* @retval void
*/
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("ana2_reg_l: 0x%08x\r\n", XC_BT_RF->ana2_reg_l);
LOGI("ana3_reg_l: 0x%08x\r\n", XC_BT_RF->ana3_reg_l);
LOGI("ana11_reg_l: 0x%08x\r\n", XC_BT_RF->ana11_reg_l);
LOGI("***********************************************\n");
LOGI("\r\n");
}
/**
* @brief Rf 2.4g get status
* @param void
*
* @retval erf_status_t - rf_status
*/
erf_status_t rf24g_get_status(void) { return rf_status; }
/**
* @brief Rf ack init handler
* @param eCMD_Type - opt
* @param int - srgc
* @param char * - srgv[]
* @retval erf_status_t - ret
*/
eXC_Cmd_State xc_rf_ack_init_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_SUCCESS;
uint8_t rf_mode = ascii_strn2val((const char *)srgv[0], 16, 2);
uint16_t rf_channel = ascii_strn2val((const char *)srgv[1], 10, 4);
LOGI("mode:%d---- channel:%04x", rf_mode, rf_channel);
rf24g_init();
set_rf_mode(rf_mode);
rf_set_channel(rf_channel);
rf_dump_log();
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\nOK\r\n", XC_CMD_RF_ACK_INIT);
rf_status = RF_STANY;
return ret;
}
/**
* @brief Rf adv init handler
* @param eCMD_Type - opt
* @param int - srgc
* @param char * - srgv[]
* @retval erf_status_t - ret
*/
eXC_Cmd_State xc_rf_adv_init_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_SUCCESS;
uint8_t rf_mode = ascii_strn2val((const char *)srgv[0], 16, 2);
uint16_t rf_channel = ascii_strn2val((const char *)srgv[1], 10, 4);
rf24g_adv_init();
set_rf_mode(rf_mode);
rf_set_channel(rf_channel);
rf_dump_log();
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\nOK\r\n", XC_CMD_RF_ADV_INIT);
rf_status = RF_STANY;
return ret;
}
/**
* @brief Rf single init handler
* @param eCMD_Type - opt
* @param int - srgc
* @param char * - srgv[]
* @retval erf_status_t - ret
*/
eXC_Cmd_State xc_rf_single_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_SUCCESS;
rf_single_init();
uint16_t rf_channel = ascii_strn2val((const char *)srgv[0], 10, 4);
/* */
uint16_t tx_proc_cfg = ascii_strn2val((const char *)srgv[1], 16, 2);
if (tx_proc_cfg == NULL) {
tx_proc_cfg = 0;
}
XC_RF_2_4G->TXPROC_CFG = tx_proc_cfg;
rf_set_channel(rf_channel);
rf_dump_log();
uint32_t channel = XC_RF_2_4G->RF_CH;
temp_ch = 0;
if (channel == rf_channel) {
temp_ch = rf_channel;
LOGI("OK:%d\r\n", channel);
} else {
LOGI("error:%d\r\n", channel);
}
rf_status = RF_SINGLE;
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\nOK\r\n", XC_CMD_RF_SINGLE_INIT);
return ret;
}
/**
* @brief Rf ack send handler
* @param eCMD_Type - opt
* @param int - srgc
* @param char * - srgv[]
* @retval erf_status_t - ret
*/
eXC_Cmd_State xc_rf_ack_send_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_SUCCESS;
static uint16_t rf_channel = 0;
rf_ack_addr_l = XC_RF_2_4G->TX_ADDR_L;
rf_ack_addr_h = XC_RF_2_4G->TX_ADDR_H;
rf_channel = ascii_strn2val((const char *)srgv[0], 10, 4);
rf_ack_addr_width = ascii_strn2val((const char *)srgv[1], 16, 2);
if (rf_ack_addr_width != 0) {
/* Address buffer */
for (uint8_t i = 0; i < rf_ack_addr_width; i++) {
rf_ack_addr[i] = ascii_strn2val((const char *)srgv[2 + i], 16, 2);
rf_ack_addr_l &= ~(0xff << (8 * i));
if (i == 5)
rf_ack_addr_h &= ~0xff;
}
for (uint8_t i = 0; i < rf_ack_addr_width; i++) {
rf_ack_addr_l |= rf_ack_addr[rf_ack_addr_width - i - 1] << (i * 8);
}
if (rf_ack_addr_width == 5)
rf_ack_addr_h = rf_ack_addr[0];
else
rf_ack_addr_h = XC_RF_2_4G->RX_ADDR_P0_H;
/* Set PTX address */
set_rf_txaddr(rf_ack_addr_l, rf_ack_addr_h);
/* Set PRX address */
set_rf_pipe0_rxaddr(rf_ack_addr_l, rf_ack_addr_h);
/* Set address width */
set_rf_tx_addr_width(rf_ack_addr_width);
memset(rf_ack_addr, 0, 5);
}
set_rf_mode(TX_MODE);
rf_set_channel(rf_channel);
uint32_t channel = XC_RF_2_4G->RF_CH;
if (channel == rf_channel) {
LOGI("OK:%02x\r\n", channel);
} else {
LOGI("error:%02x\r\n", channel);
}
tx_cnt = 0;
// rf_data.cnt = 0;
rf_dump_log();
rf_status = RF_ACK_SEND;
// timer_init(XC_RF_SEND_TIMER, SEND_TIMERMS_CNT);
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\nOK\r\n", XC_CMD_RF_ACK_SEND_EVENT);
return ret;
}
/**
* @brief Rf ack recv handler
* @param eCMD_Type - opt
* @param int - srgc
* @param char * - srgv[]
* @retval erf_status_t - ret
*/
eXC_Cmd_State xc_rf_ack_recv_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_SUCCESS;
rf_ack_addr_l = XC_RF_2_4G->TX_ADDR_L;
rf_ack_addr_h = XC_RF_2_4G->TX_ADDR_H;
static uint16_t rf_channel = 0;
rf_channel = ascii_strn2val((const char *)srgv[0], 10, 4);
rf_ack_addr_width = ascii_strn2val((const char *)srgv[1], 16, 2);
if (rf_ack_addr_width != 0) {
for (uint8_t i = 0; i < rf_ack_addr_width; i++) {
rf_ack_addr[i] = ascii_strn2val((const char *)srgv[2 + i], 16, 2);
rf_ack_addr_l &= ~(0xff << (8 * i));
if (i == 5)
rf_ack_addr_h &= ~0xff;
}
for (uint8_t i = 0; i < rf_ack_addr_width; i++) {
rf_ack_addr_l |= rf_ack_addr[rf_ack_addr_width - i - 1] << (i * 8);
}
if (rf_ack_addr_width == 5)
rf_ack_addr_h = rf_ack_addr[0];
else
rf_ack_addr_h = XC_RF_2_4G->RX_ADDR_P0_H;
/* Set PTX address */
set_rf_txaddr(rf_ack_addr_l, rf_ack_addr_h);
/* Set PRX address */
set_rf_pipe0_rxaddr(rf_ack_addr_l, rf_ack_addr_h);
/* Set address width */
set_rf_tx_addr_width(rf_ack_addr_width);
}
set_rf_mode(RX_MODE);
rf_set_channel(rf_channel);
rf_status = RF_ACK_RECV;
rx_cnt = 0;
CE_CTL_HIGH;
rf_dump_log();
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\nOK\r\n", XC_CMD_RF_ACK_RECV_EVENT);
return ret;
}
/**
* @brief Rf adv send handler
* @param eCMD_Type - opt
* @param int - srgc
* @param char * - srgv[]
* @retval erf_status_t - ret
*/
eXC_Cmd_State xc_rf_adv_send_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_SUCCESS;
uint16_t rf_channel = ascii_strn2val((const char *)srgv[0], 10, 4);
set_rf_mode(TX_MODE);
/* Set testing frequency points */
rf_set_channel(rf_channel);
rf_status = RF_ADV_SEND;
rf_dump_log();
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\nOK\r\n", XC_CMD_RF_ADV_SEND_EVENT);
return ret;
}
/**
* @brief Rf adv recv handler
* @param eCMD_Type - opt
* @param int - srgc
* @param char * - srgv[]
* @retval erf_status_t - ret
*/
eXC_Cmd_State xc_rf_adv_recv_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_SUCCESS;
uint16_t rf_channel = ascii_strn2val((const char *)srgv[0], 10, 4);
/* Set mode */
set_rf_mode(RX_MODE);
LOGI("************ADV Recv Start**************\r\n");
/* Set testing frequency points */
rf_set_channel(rf_channel);
rf_dump_log();
#if (XINCX_RF_ADV_NVIC_MODE == true)
/* Enable RF24G interrupt */
NVIC_EnableIRQ(RF24G_IRQn);
#endif
rf_status = RF_ADV_RECV;
XC_RF_2_4G->CMD_CFG = CMD_DONE | FLUSH_RX;
XC_RF_2_4G->CMD_CFG = CMD_DONE | FLUSH_TX;
XC_RF_2_4G->STATUS = MASK_ALL_INTER;
/* Entering the receiver */
CE_CTL_HIGH;
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\nOK\r\n", XC_CMD_RF_ADV_RECV_EVENT);
return ret;
}
/**
* @brief Rf set channel handler
* @param eCMD_Type - opt
* @param int - srgc
* @param char * - srgv[]
* @retval erf_status_t - ret
*/
eXC_Cmd_State xc_rf_set_channel_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_SUCCESS;
static uint16_t rf_channel = 0;
rf_channel = ascii_strn2val((const char *)srgv[0], 10, 4);
rf_set_channel(rf_channel);
uint32_t channel = XC_RF_2_4G->RF_CH;
if (channel == rf_channel) {
LOGI("OK:%02x\r\n", channel);
} else {
LOGI("error:%02x\r\n", channel);
}
LOGI("CHANNEL:%d\r\n", XC_RF_2_4G->RF_CH & 0x3ff);
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\nOK\r\n", XC_CMD_RF_SET_CHANNEL);
return ret;
}
/**
* @brief Rf set power handler
* @param eCMD_Type - opt
* @param int - srgc
* @param char * - srgv[]
* @retval erf_status_t - ret
*/
eXC_Cmd_State xc_rf_set_power_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_SUCCESS;
static uint8_t rf_power = 0;
rf_power = ascii_strn2val((const char *)srgv[0], 16, 2);
set_rf_power(rf_power);
uint8_t power = (XC_BT_RF->ana21_reg_l >> 6) & 0x3f;
if (power == rf_power) {
LOGI("OK:%02x\r\n", power);
ret = XC_CMD_SUCCESS;
} else {
LOGI("error:%02x\r\n", power);
ret = XC_CMD_ERROR;
}
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\nOK\r\n", XC_CMD_RF_SET_POWER);
return ret;
}
/**
* @brief Rf set trans rate handler
* @param eCMD_Type - opt
* @param int - srgc
* @param char * - srgv[]
* @retval erf_status_t - ret
*/
eXC_Cmd_State xc_rf_set_trans_rate_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_SUCCESS;
static uint8_t rf_trans_rate = 0;
rf_trans_rate = ascii_strn2val((const char *)srgv[0], 16, 2);
set_rf_DR(rf_trans_rate);
uint8_t rf_rate = XC_RF_2_4G->SETUP_RF;
if (rf_rate == rf_trans_rate) {
// if(rf_rate == DR_2M){
// rf_2M_config();
// }
LOGI("OK:%02x\r\n", rf_rate);
ret = XC_CMD_SUCCESS;
} else {
LOGI("error:%02x\r\n", rf_rate);
ret = XC_CMD_ERROR;
}
LOGI("SETUP:%04x\r\n", XC_RF_2_4G->SETUP_RF);
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\nOK\r\n", XC_CMD_RF_SET_RATE);
return ret;
}
/**
* @brief Rf set addr handler
* @param eCMD_Type - opt
* @param int - srgc
* @param char * - srgv[]
* @retval erf_status_t - ret
*/
eXC_Cmd_State xc_rf_set_addr_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_SUCCESS;
rf_ack_addr_width = ascii_strn2val((const char *)srgv[0], 16, 2);
rf_ack_addr_l = XC_RF_2_4G->TX_ADDR_L;
rf_ack_addr_h = XC_RF_2_4G->TX_ADDR_H;
for (uint8_t i = 0; i < rf_ack_addr_width; i++) {
rf_ack_addr[i] = ascii_strn2val((const char *)srgv[1 + i], 16, 2);
rf_ack_addr_l &= ~(0xff << (8 * i));
if (i == 5)
rf_ack_addr_h &= ~0xff;
}
if (rf_ack_addr_width == 0x5) {
for (uint8_t i = 0; i < 4; i++) {
rf_ack_addr_l |= rf_ack_addr[4 - i] << (i * 8);
}
rf_ack_addr_h = rf_ack_addr[0];
} else {
for (uint8_t i = 0; i < rf_ack_addr_width; i++) {
for (uint8_t i = 0; i < rf_ack_addr_width; i++) {
rf_ack_addr_l |= rf_ack_addr[rf_ack_addr_width - 1 - i] << (i * 8);
}
}
}
/* Set PTX address */
set_rf_txaddr(rf_ack_addr_l, rf_ack_addr_h);
/* Set PRX address */
set_rf_pipe0_rxaddr(rf_ack_addr_l, rf_ack_addr_h);
/* Set address width */
set_rf_tx_addr_width(rf_ack_addr_width);
LOGI("TX_ADDR: 0x%02x%08x\r\n", ((XC_RF_2_4G->TX_ADDR_H) & 0xFF), XC_RF_2_4G->TX_ADDR_L);
rf_ack_addr_l = 0;
rf_ack_addr_h = 0;
memset(rf_ack_addr, 0, sizeof(rf_ack_addr));
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\nOK\r\n", XC_CMD_RF_SET_ADDR);
return ret;
}
/**
* @brief Rf get reg handler
* @param eCMD_Type - opt
* @param int - srgc
* @param char * - srgv[]
* @retval erf_status_t - ret
*/
eXC_Cmd_State xc_rf_get_reg_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_SUCCESS;
uint8_t rf24g_reg_addr = 0;
rf24g_reg_addr = ascii_strn2val((const char *)srgv[0], 16, 2);
uint32_t reg_temp = XC_RF_2_4G_BASE + rf24g_reg_addr * 4;
LOGI("REG(%02x):%08x\r\n", reg_temp, *(uint32_t *)reg_temp);
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\nOK\r\n", XC_CMD_RF_GET_REG_VALUE);
return ret;
}
eXC_Cmd_State xc_rf_set_ana_reg_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_SUCCESS;
uint8_t rf_reg_value = ascii_strn2val((const char *)srgv[0], 10, 2);
uint8_t start_bit = ascii_strn2val((const char *)srgv[1], 10, 2);
uint8_t end_bit = ascii_strn2val((const char *)srgv[2], 10, 2);
uint8_t set_value_b = ascii_strn2val((const char *)srgv[3], 16, 2);
LOGI("W_REG(%02x)[%d:%d]:%d\r\n", ((volatile uint32_t *)(0x53021000UL + rf_reg_value * 4)), start_bit,end_bit, ascii_strn2val((const char *)srgv[3], 16, 2));
//printf("addr:%04x\n",*((volatile uint32_t *)(0x53021000UL + rf_reg_value * 4)));
wbit(rf_reg_value,start_bit,end_bit,set_value_b);
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\nOK\r\n", XC_CMD_RF_SET_ANA_REG);
//printf("addr:%04x\n",*((volatile uint32_t *)(0x53021000UL + rf_reg_value * 4)));
return ret;
}
eXC_Cmd_State xc_rf_get_ana_reg_handler(eCMD_Type opt, int srgc, char *srgv[])
{
eXC_Cmd_State ret = XC_CMD_SUCCESS;
uint8_t rf_reg_value = ascii_strn2val((const char *)srgv[0], 10, 2);
LOGI("addr:0x53021000UL+%x;value:0x%04x",rf_reg_value*4, rbit(rf_reg_value));
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s\r\nOK\r\n", XC_CMD_RF_GET_ANA_REG);
return ret;
}