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
component/ble/modules/shell/api/shell.h
+72
View File
@@ -0,0 +1,72 @@
/*!
* \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 <stdio.h>
#include <string.h>
#include <stdint.h>
#include "xc6xxx.h"
#include "shell_handler.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 xc_shell_test_case(void);
#ifdef __cplusplus
}
#endif
#endif /* __SHELL_H__ */
component/ble/modules/shell/api/shell_handler.h
+93
View File
@@ -0,0 +1,93 @@
/*!
* \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 <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include "xc6xxx.h"
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
#define XC_CMD_SIZE 255U
// XC Command
#define XC_OK "OK"
#define XC_ERROR "+CME ERROR:"
#define XC_CMD_TEST "+TEST"
#define XC_CMD_BLE_MAC "+BMACADDR"
/*------------------------------------------------------------------------------------
TypeDef
-------------------------------------------------------------------------------------*/
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
-------------------------------------------------------------------------------------*/
eXC_Cmd_State xc_test_handler(eCMD_Type opt, int srgc, char *srgv[]);
eXC_Cmd_State xc_ble_mac_addr_handler(eCMD_Type opt, int srgc, char *srgv[]);
#ifdef __cplusplus
}
#endif
#endif /* __SHELL_HANDLER_H__ */
component/ble/modules/shell/src/shell.c
+199
View File
@@ -0,0 +1,199 @@
/*!
* \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_TEST, xc_test_handler },
{ XC_CMD_BLE_MAC, xc_ble_mac_addr_handler },
};
/*------------------------------------------------------------------------------------
Macros
-------------------------------------------------------------------------------------*/
#define XC_CMD_TABLE_SIZE (sizeof(XC_CMD_Table) / sizeof(XC_Cmd_Table_t))
/*------------------------------------------------------------------------------------
Global Variables
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Func Prototype
-------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
/**
****************************************************************************************
* @brief
*
* @param[in]
* @param[in]
*
* @return[out]
*
****************************************************************************************
*/
void xc_shell_init(void)
{
UART_InitTypeDef UART_InitStruct={0};
UART_InitStruct.Parity = UART_PARITY_DISABLE;
UART_InitStruct.StopBits = UART_STOP_1_BITS;
UART_InitStruct.WordLength = UART_UARTx_TCR_CLS_8BITS;
UART_InitStruct.BaudRate = UART_BAUDRATE_115200;
UART_InitStruct.HardwareFlowControl = UART_UARTx_MCR_AFCE_DISABLE;
UART_Init(XC_UART0, &UART_InitStruct);
UART_Enable_RxIT(XC_UART0);
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;
int16_t rx_cmd_idx = data_len - 2;
if(data_len <=2 && data[data_len] == '\0') {
return ret;
}
if(rx_cmd_idx <= 0 || rx_cmd[rx_cmd_idx] != '\0') {
return ret;
}
// 注意这里 XC指令 只判定大写
if(data[0] != 'X' || data[1] != 'C') {
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) {
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 {
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);
UART_SendData(XC_UART0, XC_Cmd, strlen((const char *)XC_Cmd));
} else {
UART_SendData(XC_UART0, XC_Cmd, strlen((const char *)XC_Cmd));
}
memset(XC_Cmd, 0, XC_CMD_SIZE);
return ret;
}
/**
****************************************************************************************
* @brief
*
* @param[in]
* @param[in]
*
* @return[out]
*
****************************************************************************************
*/
void xc_shell_test_case(void)
{
eXC_Shell_Proc_state sh_sta = XC_SHELL_CMD_RECV;
uint8_t recv_buff[XC_CMD_SIZE] = { 0 };
uint16_t recv_len = 0;
xc_shell_init( );
while(1) {
/* main loop */
switch(sh_sta) {
case XC_SHELL_CMD_RECV: {
recv_len += UART_ReceiveData(XC_UART0, 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;
}
}
break;
case XC_SHELL_CMD_PROC: {
// UART_SendData(XC_UART0, recv_buff, recv_len);
(void)xc_shell_proc(recv_buff, recv_len);
recv_len = 0;
sh_sta = XC_SHELL_CMD_RECV;
}
break;
default:
break;
}
}
}
component/ble/modules/shell/src/shell_handler.c
+114
View File
@@ -0,0 +1,114 @@
/*!
* \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 };
BLE_Mac_Addr_t Mac_Addr;
/*------------------------------------------------------------------------------------
Functions
-------------------------------------------------------------------------------------*/
/**
****************************************************************************************
* @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;
}
/**
****************************************************************************************
* @brief
*
* @param[in]
* @param[in]
*
* @return[out]
*
****************************************************************************************
*/
eXC_Cmd_State xc_ble_mac_addr_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: %02x:%02x:%02x:%02x:%02x:%02x\r\nOK\r\n",
XC_CMD_BLE_MAC, Mac_Addr.byte0, Mac_Addr.byte1, Mac_Addr.byte2,
Mac_Addr.byte3, Mac_Addr.byte4, Mac_Addr.byte5);
}
break;
case SET_CMD: {
if(srgc < 1) break;
Mac_Addr.byte0 = atoi(srgv[0]);
Mac_Addr.byte1 = atoi(srgv[1]);
Mac_Addr.byte2 = atoi(srgv[2]);
Mac_Addr.byte3 = atoi(srgv[3]);
Mac_Addr.byte4 = atoi(srgv[4]);
Mac_Addr.byte5 = atoi(srgv[5]);
ret = XC_CMD_SUCCESS;
snprintf((char *)XC_Cmd, XC_CMD_SIZE, "\r\n%s: %02x:%02x:%02x:%02x:%02x:%02x\r\nOK\r\n",
XC_CMD_BLE_MAC, Mac_Addr.byte0, Mac_Addr.byte1, Mac_Addr.byte2,
Mac_Addr.byte3, Mac_Addr.byte4, Mac_Addr.byte5);
}
break;
default:
break;
}
return ret;
}