robofish/rm_balance
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

加ai

Browse Source
This commit is contained in:
Robofish 2025-10-07 20:10:56 +08:00
parent b5b1219f4a
commit b8698147d5
7 changed files with 87 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Core/Src/stm32f4xx_it.c
View File

@ -335,6 +335,7 @@ void USART1_IRQHandler(void)
/* USER CODE END USART1_IRQn 0 */ /* USER CODE END USART1_IRQn 0 */
HAL_UART_IRQHandler(&huart1); HAL_UART_IRQHandler(&huart1);
/* USER CODE BEGIN USART1_IRQn 1 */ /* USER CODE BEGIN USART1_IRQn 1 */
BSP_UART_IRQHandler(&huart1);
/* USER CODE END USART1_IRQn 1 */ /* USER CODE END USART1_IRQn 1 */
} }

4
User/bsp/bsp_config.yaml
View File

@ -129,4 +129,8 @@ uart:
devices: devices:
- instance: USART3 - instance: USART3
name: DR16 name: DR16
- instance: USART6
name: AI
- instance: USART1
name: REF
enabled: true enabled: true

8
User/bsp/uart.c
View File

@ -25,6 +25,10 @@ static void (*UART_Callback[BSP_UART_NUM][BSP_UART_CB_NUM])(void);
static BSP_UART_t UART_Get(UART_HandleTypeDef *huart) { static BSP_UART_t UART_Get(UART_HandleTypeDef *huart) {
if (huart->Instance == USART3) if (huart->Instance == USART3)
return BSP_UART_DR16; return BSP_UART_DR16;
else if (huart->Instance == USART6)
return BSP_UART_AI;
else if (huart->Instance == USART1)
return BSP_UART_REF;
else else
return BSP_UART_ERR; return BSP_UART_ERR;
} }
@ -115,6 +119,10 @@ UART_HandleTypeDef *BSP_UART_GetHandle(BSP_UART_t uart) {
switch (uart) { switch (uart) {
case BSP_UART_DR16: case BSP_UART_DR16:
return &huart3; return &huart3;
case BSP_UART_AI:
return &huart6;
case BSP_UART_REF:
return &huart1;
default: default:
return NULL; return NULL;
} }

2
User/bsp/uart.h
View File

@ -28,6 +28,8 @@ extern "C" {
/* UART实体枚举，与设备对应 */ /* UART实体枚举，与设备对应 */
typedef enum { typedef enum {
BSP_UART_DR16, BSP_UART_DR16,
BSP_UART_AI,
BSP_UART_REF,
BSP_UART_NUM, BSP_UART_NUM,
BSP_UART_ERR, BSP_UART_ERR,
} BSP_UART_t; } BSP_UART_t;

138
User/device/ai.c
View File

@ -1,91 +1,93 @@
// /* /*
// AI AI
// */ */
// /* Includes ----------------------------------------------------------------- */ /* Includes ----------------------------------------------------------------- */
// #include "ai.h" #include "ai.h"
// #include <string.h> #include <string.h>
// #include "bsp/time.h" #include "bsp/time.h"
// #include "bsp/uart.h" #include "bsp/uart.h"
// #include "component/crc16.h" #include "component/crc16.h"
// #include "component/crc8.h" #include "component/crc8.h"
// #include "component/user_math.h" #include "component/user_math.h"
// #include "component/filter.h" #include "component/filter.h"
// /* Private define ----------------------------------------------------------- */ /* Private define ----------------------------------------------------------- */
// #define AI_LEN_RX_BUFF (sizeof(Protocol_DownPackage_t)) #define AI_LEN_RX_BUFF (sizeof(AI_DownPackage_t))
// /* Private macro ------------------------------------------------------------ */ /* Private macro ------------------------------------------------------------ */
// /* Private typedef ---------------------------------------------------------- */ /* Private typedef ---------------------------------------------------------- */
// /* Private variables -------------------------------------------------------- */ /* Private variables -------------------------------------------------------- */
// static volatile uint32_t drop_message = 0;
// static uint8_t rxbuf[AI_LEN_RX_BUFF]; static uint8_t rxbuf[AI_LEN_RX_BUFF];
// static bool inited = false; static bool inited = false;
// static osThreadId_t thread_alert; static osThreadId_t thread_alert;
// /* Private function -------------------------------------------------------- */ static uint32_t drop_message = 0;
// static void Ai_RxCpltCallback(void) { /* Private function -------------------------------------------------------- */
// osThreadFlagsSet(thread_alert, SIGNAL_AI_RAW_REDY);
// }
// static void Ai_IdleLineCallback(void) { static void Ai_RxCpltCallback(void) {
// osThreadFlagsSet(thread_alert, SIGNAL_AI_RAW_REDY); osThreadFlagsSet(thread_alert, SIGNAL_AI_RAW_REDY);
// } }
// /* Exported functions ------------------------------------------------------- */ static void Ai_IdleLineCallback(void) {
// int8_t AI_Init(AI_t *ai) { osThreadFlagsSet(thread_alert, SIGNAL_AI_RAW_REDY);
// UNUSED(ai); }
// ASSERT(ai);
// if (inited) return DEVICE_ERR_INITED;
// VERIFY((thread_alert = osThreadGetId()) != NULL);
// BSP_UART_RegisterCallback(BSP_UART_AI, BSP_UART_RX_CPLT_CB, /* Exported functions ------------------------------------------------------- */
// Ai_RxCpltCallback); int8_t AI_Init(AI_t *ai) {
// BSP_UART_RegisterCallback(BSP_UART_AI, BSP_UART_IDLE_LINE_CB, UNUSED(ai);
// Ai_IdleLineCallback); if (inited) return DEVICE_ERR_INITED;
thread_alert = osThreadGetId();
BSP_UART_RegisterCallback(BSP_UART_AI, BSP_UART_RX_CPLT_CB,
Ai_RxCpltCallback);
BSP_UART_RegisterCallback(BSP_UART_AI, BSP_UART_IDLE_LINE_CB,
Ai_IdleLineCallback);
// inited = true; inited = true;
// return 0; return 0;
// } }
// int8_t AI_Restart(void) { int8_t AI_Restart(AI_t *ai) {
// __HAL_UART_DISABLE(BSP_UART_GetHandle(BSP_UART_AI)); UNUSED(ai);
// __HAL_UART_ENABLE(BSP_UART_GetHandle(BSP_UART_AI)); __HAL_UART_DISABLE(BSP_UART_GetHandle(BSP_UART_AI));
// return DEVICE_OK; __HAL_UART_ENABLE(BSP_UART_GetHandle(BSP_UART_AI));
// } return DEVICE_OK;
}
// int8_t AI_StartReceiving(AI_t *ai) { int8_t AI_StartReceiving(AI_t *ai) {
// UNUSED(ai); UNUSED(ai);
// if (HAL_UART_Receive_DMA(BSP_UART_GetHandle(BSP_UART_AI), rxbuf, if (HAL_UART_Receive_DMA(BSP_UART_GetHandle(BSP_UART_AI), rxbuf,
// AI_LEN_RX_BUFF) == HAL_OK) AI_LEN_RX_BUFF) == HAL_OK)
// return DEVICE_OK; return DEVICE_OK;
// return DEVICE_ERR; return DEVICE_ERR;
// } }
// bool AI_WaitDmaCplt(void) { bool AI_WaitDmaCplt(uint32_t timeout) {
// return (osThreadFlagsWait(SIGNAL_AI_RAW_REDY, osFlagsWaitAll, 0) == return (osThreadFlagsWait(SIGNAL_AI_RAW_REDY, osFlagsWaitAll, timeout) ==
// SIGNAL_AI_RAW_REDY); SIGNAL_AI_RAW_REDY);
// } }
// int8_t AI_ParseHost(AI_t *ai) { int8_t AI_ParseHost(AI_t *ai) {
// if (!CRC16_Verify((const uint8_t *)&(rxbuf), sizeof(ai->from_host))) if (!CRC16_Verify((const uint8_t *)&(rxbuf), sizeof(ai->from_host)))
// goto error; goto error;
// ai->ai_online = true; ai->header.online = true;
// memcpy(&(ai->from_host), rxbuf, sizeof(ai->from_host)); ai->header.last_online_time = BSP_TIME_Get();
// memset(rxbuf, 0, AI_LEN_RX_BUFF); memcpy(&(ai->from_host), rxbuf, sizeof(ai->from_host));
// return DEVICE_OK; memset(rxbuf, 0, AI_LEN_RX_BUFF);
return DEVICE_OK;
// error: error:
// drop_message++; drop_message++;
// return DEVICE_ERR; return DEVICE_ERR;
// } }
// void AI_PackCmd(AI_t *ai, CMD_Host_t *cmd_host) { // void AI_PackCmd(AI_t *ai, CMD_Host_t *cmd_host) {
// cmd_host->gimbal_delta.yaw = ai->from_host.data.gimbal.yaw; // cmd_host->gimbal_delta.yaw = ai->from_host.data.gimbal.yaw;

2
User/device/ai.h
View File

@ -58,7 +58,7 @@ typedef struct __packed {
/* 视觉 -> 电控 数据包 */ /* 视觉 -> 电控 数据包 */
typedef struct __packed { typedef struct __packed {
uint8_t id; /* 包ID */ uint8_t id; /* 包ID */
AI_Protucol_DownData_t package; /* 数据包 */ AI_Protocol_DownData_t package; /* 数据包 */
uint16_t crc16; /* CRC16校验 */ uint16_t crc16; /* CRC16校验 */
} AI_DownPackage_t; } AI_DownPackage_t;

2
User/device/device.h
View File

@ -30,7 +30,7 @@ extern "C" {
/* AUTO GENERATED SIGNALS END */ /* AUTO GENERATED SIGNALS END */
/* USER SIGNALS BEGIN */ /* USER SIGNALS BEGIN */
#define SIGNAL_AI_RAW_REDY (1u << 5)
/* USER SIGNALS END */ /* USER SIGNALS END */
/*设备层通用Header*/ /*设备层通用Header*/
typedef struct { typedef struct {