wxsmart-test
/
remote_dido_unit
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

备份

This commit is contained in:
王绪洁 2025-02-11 10:25:25 +08:00
parent aa93ff2508
commit 9e44135a34
4 changed files with 140 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Core/Src/main.c
View File

@ -122,8 +122,8 @@ int main(void)
HAL_UARTEx_ReceiveToIdle_DMA(&huart3, ble2_uart3.rx_data_temp, ARRAY_LEN(ble2_uart3.rx_data_temp)); HAL_UARTEx_ReceiveToIdle_DMA(&huart3, ble2_uart3.rx_data_temp, ARRAY_LEN(ble2_uart3.rx_data_temp));
HAL_UARTEx_ReceiveToIdle_DMA(&huart5, hart1_uart5.rx_data_temp, ARRAY_LEN(hart1_uart5.rx_data_temp)); HAL_UARTEx_ReceiveToIdle_DMA(&huart5, hart1_uart5.rx_data_temp, ARRAY_LEN(hart1_uart5.rx_data_temp));
HAL_UARTEx_ReceiveToIdle_DMA(&huart2, hart2_uart2.rx_data_temp, ARRAY_LEN(hart2_uart2.rx_data_temp)); HAL_UARTEx_ReceiveToIdle_DMA(&huart2, hart2_uart2.rx_data_temp, ARRAY_LEN(hart2_uart2.rx_data_temp));
hart_ht1200m_reset(); // 夝佝HT1200M模块 hart_ht1200m_reset(); // 初始化HT1200M模块
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1); // 坯动PWM输出，用于驱动HT1200M模块 HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1); // PWM输出，用于驱动HT1200M模块
/* USER CODE END 2 */ /* USER CODE END 2 */
/* Call init function for freertos objects (in freertos.c) */ /* Call init function for freertos objects (in freertos.c) */
@ -139,7 +139,6 @@ int main(void)
/* USER CODE END WHILE */ /* USER CODE END WHILE */
/* USER CODE BEGIN 3 */ /* USER CODE BEGIN 3 */
// ad7124_get_analog(STOP_NC_ADC);
} }
/* USER CODE END 3 */ /* USER CODE END 3 */
} }

37
Core/Src/usart.c
View File

@ -66,7 +66,6 @@ void MX_UART4_Init(void)
/* USER CODE BEGIN UART4_Init 2 */ /* USER CODE BEGIN UART4_Init 2 */
//__HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE); // 使能IDLE中断 //__HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE); // 使能IDLE中断
/* USER CODE END UART4_Init 2 */ /* USER CODE END UART4_Init 2 */
} }
/* UART5 init function */ /* UART5 init function */
void MX_UART5_Init(void) void MX_UART5_Init(void)
@ -92,10 +91,9 @@ void MX_UART5_Init(void)
Error_Handler(); Error_Handler();
} }
/* USER CODE BEGIN UART5_Init 2 */ /* USER CODE BEGIN UART5_Init 2 */
__HAL_UART_ENABLE_IT(&huart5, UART_IT_RXNE); // 接收中断 // __HAL_UART_ENABLE_IT(&huart5, UART_IT_RXNE); // 接收中断
__HAL_UART_ENABLE_IT(&huart5, UART_IT_IDLE); // 空闲中断 // __HAL_UART_ENABLE_IT(&huart5, UART_IT_IDLE); // 空闲中断
/* USER CODE END UART5_Init 2 */ /* USER CODE END UART5_Init 2 */
} }
/* USART2 init function */ /* USART2 init function */
@ -122,10 +120,9 @@ void MX_USART2_UART_Init(void)
Error_Handler(); Error_Handler();
} }
/* USER CODE BEGIN USART2_Init 2 */ /* USER CODE BEGIN USART2_Init 2 */
__HAL_UART_ENABLE_IT(&huart2, UART_IT_RXNE); // 接收中断 // __HAL_UART_ENABLE_IT(&huart2, UART_IT_RXNE); // 接收中断
__HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE); // 使能IDLE中断 // __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE); // 使能IDLE中断
/* USER CODE END USART2_Init 2 */ /* USER CODE END USART2_Init 2 */
} }
/* USART3 init function */ /* USART3 init function */
@ -154,7 +151,6 @@ void MX_USART3_UART_Init(void)
/* USER CODE BEGIN USART3_Init 2 */ /* USER CODE BEGIN USART3_Init 2 */
/* USER CODE END USART3_Init 2 */ /* USER CODE END USART3_Init 2 */
} }
/* USART6 init function */ /* USART6 init function */
@ -183,7 +179,6 @@ void MX_USART6_UART_Init(void)
/* USER CODE BEGIN USART6_Init 2 */ /* USER CODE BEGIN USART6_Init 2 */
/* USER CODE END USART6_Init 2 */ /* USER CODE END USART6_Init 2 */
} }
void HAL_UART_MspInit(UART_HandleTypeDef *uartHandle) void HAL_UART_MspInit(UART_HandleTypeDef *uartHandle)
@ -648,17 +643,23 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
} }
/* USER CODE BEGIN 1 */ /* USER CODE BEGIN 1 */
/*
********************************************************************************************************* /**
* å‡? æ•? å<EFBFBD>?: dma_usart_send * @brief 使用DMA方式通过串口发送数据
* 功能说明: 串å<EFBFBD>£å<EFBFBD>‘é?<EFBFBD>功能函æ•? *
* å½? å<EFBFBD>?: buf，len * 该函数使用DMA方式通过指定的串口发送指定长度的数据。
* � � �: � *
********************************************************************************************************* * @param huart UART_HandleTypeDef结构体指针，指向需要使用的串口句柄
* @param buf 指向需要发送的数据缓冲区的指针
* @param len 需要发送的数据长度
*
* @return 无返回值
*
* @note 如果发送过程中出现错误，会调用Error_Handler函数处理错误
*/ */
void dma_usart_send(UART_HandleTypeDef *huart, uint8_t *buf, uint8_t len) // 串å<C2B2>£å<C2A3>‘é?<3F>å°<C3A5>è£? void dma_usart_send(UART_HandleTypeDef *huart, uint8_t *buf, uint8_t len)
{ {
if (HAL_UART_Transmit_DMA(huart, buf, len) != HAL_OK) // 判断是å<C2AF>¦å<C2A6>‘é?<3F>正常，如果出现异常则进入异常中断函æ•? if (HAL_UART_Transmit_DMA(huart, buf, len) != HAL_OK) // 判断是否发送正常，如果出现异常则进入异常中断函数
{ {
Error_Handler(); Error_Handler();
} }

2
MDK-ARM/TEST2.uvoptx
View File

@ -308,7 +308,7 @@
<Group> <Group>
<GroupName>Application/User/Core</GroupName> <GroupName>Application/User/Core</GroupName>
<tvExp>0</tvExp> <tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg> <tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel> <cbSel>0</cbSel>
<RteFlg>0</RteFlg> <RteFlg>0</RteFlg>

117
User/application/src/tcpserverc.c
View File

@ -19,14 +19,14 @@ extern uint8_t tcp_echo_flags_hart1;
extern uint8_t tcp_echo_flags_hart2; extern uint8_t tcp_echo_flags_hart2;
extern uint8_t tcp_echo_flags_ble1; extern uint8_t tcp_echo_flags_ble1;
extern uint8_t tcp_echo_flags_ble2; extern uint8_t tcp_echo_flags_ble2;
/*接收回调函数*/ /*接收回调函数*/
static err_t tcpecho_recv_hart1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) static err_t tcpecho_recv_hart1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块 接收到的数据 { // 对应接收数据连接的控制块 接收到的数据
if (p != NULL) if (p != NULL)
{ {
/* 更新窗口*/ /* 更新窗口*/
tcp_echo_flags_hart1 = 1; tcp_echo_flags_hart1 = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度 tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
memcpy(&server_pcb_hart1, &tpcb, sizeof(struct tcp_pcb *)); memcpy(&server_pcb_hart1, &tpcb, sizeof(struct tcp_pcb *));
#if 0 #if 0
memcpy(hart2_uart2.tx_data, (int *)p->payload, p->tot_len); memcpy(hart2_uart2.tx_data, (int *)p->payload, p->tot_len);
@ -39,23 +39,11 @@ static err_t tcpecho_recv_hart1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
HART1_RTS_SEND; HART1_RTS_SEND;
dma_usart_send(&huart5, hart1_uart5.tx_data, p->tot_len); dma_usart_send(&huart5, hart1_uart5.tx_data, p->tot_len);
// HART1_RTS_RECEIVE; // HART1_RTS_RECEIVE;
#endif
#if 0
memcpy(ble1_uart6.tx_data, (int *)p->payload, p->tot_len);
dma_usart_send(&huart6, ble1_uart6.tx_data, p->tot_len);
#endif
#if 0
memcpy(ble2_uart3.tx_data, (int *)p->payload, p->tot_len);
dma_usart_send(&huart3, ble2_uart3.tx_data, p->tot_len);
#endif
#if 0
memcpy(lcd_uart4.tx_data, (int *)p->payload, p->tot_len);
dma_usart_send(&huart4, lcd_uart4.tx_data, p->tot_len);
#endif #endif
memset(p->payload, 0, p->tot_len); memset(p->payload, 0, p->tot_len);
pbuf_free(p); pbuf_free(p);
} }
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空 else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{ {
return tcp_close(tpcb); return tcp_close(tpcb);
} }
@ -63,12 +51,12 @@ static err_t tcpecho_recv_hart1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
} }
static err_t tcpecho_recv_hart2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) static err_t tcpecho_recv_hart2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块 接收到的数据 { // 对应接收数据连接的控制块 接收到的数据
if (p != NULL) if (p != NULL)
{ {
/* 更新窗口*/ /* 更新窗口*/
tcp_echo_flags_hart2 = 1; tcp_echo_flags_hart2 = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度 tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
memcpy(&server_pcb_hart2, &tpcb, sizeof(struct tcp_pcb *)); memcpy(&server_pcb_hart2, &tpcb, sizeof(struct tcp_pcb *));
#if 1 #if 1
memcpy(hart2_uart2.tx_data, (int *)p->payload, p->tot_len); memcpy(hart2_uart2.tx_data, (int *)p->payload, p->tot_len);
@ -81,22 +69,11 @@ static err_t tcpecho_recv_hart2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
HAL_UART_Transmit(&huart5, hart1_uart5.tx_data, p->tot_len, 100); HAL_UART_Transmit(&huart5, hart1_uart5.tx_data, p->tot_len, 100);
HART1_RTS_RECEIVE; HART1_RTS_RECEIVE;
#endif #endif
#if 0
memcpy(ble1_uart6.tx_data, (int *)p->payload, p->tot_len);
dma_usart_send(&huart6, ble1_uart6.tx_data, p->tot_len);
#endif
#if 0
memcpy(ble2_uart3.tx_data, (int *)p->payload, p->tot_len);
dma_usart_send(&huart3, ble2_uart3.tx_data, p->tot_len);
#endif
#if 0
memcpy(lcd_uart4.tx_data, (int *)p->payload, p->tot_len);
dma_usart_send(&huart4, lcd_uart4.tx_data, p->tot_len);
#endif
memset(p->payload, 0, p->tot_len); memset(p->payload, 0, p->tot_len);
pbuf_free(p); pbuf_free(p);
} }
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空 else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{ {
return tcp_close(tpcb); return tcp_close(tpcb);
} }
@ -104,12 +81,12 @@ static err_t tcpecho_recv_hart2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
} }
static err_t tcpecho_recv_ble1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) static err_t tcpecho_recv_ble1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块 接收到的数据 { // 对应接收数据连接的控制块 接收到的数据
if (p != NULL) if (p != NULL)
{ {
/* 更新窗口*/ /* 更新窗口*/
tcp_echo_flags_ble1 = 1; tcp_echo_flags_ble1 = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度 tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
memcpy(&server_pcb_ble1, &tpcb, sizeof(struct tcp_pcb *)); memcpy(&server_pcb_ble1, &tpcb, sizeof(struct tcp_pcb *));
memcpy(ble1_uart6.tx_data, (int *)p->payload, p->tot_len); memcpy(ble1_uart6.tx_data, (int *)p->payload, p->tot_len);
@ -118,7 +95,7 @@ static err_t tcpecho_recv_ble1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
memset(p->payload, 0, p->tot_len); memset(p->payload, 0, p->tot_len);
pbuf_free(p); pbuf_free(p);
} }
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空 else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{ {
return tcp_close(tpcb); return tcp_close(tpcb);
} }
@ -126,12 +103,12 @@ static err_t tcpecho_recv_ble1(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
} }
static err_t tcpecho_recv_ble2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) static err_t tcpecho_recv_ble2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
{ // 对应接收数据连接的控制块 接收到的数据 { // 对应接收数据连接的控制块 接收到的数据
if (p != NULL) if (p != NULL)
{ {
/* 更新窗口*/ /* 更新窗口*/
tcp_echo_flags_ble2 = 1; tcp_echo_flags_ble2 = 1;
tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度 tcp_recved(tpcb, p->tot_len); // 读取数据的控制块 得到所有数据的长度
memcpy(&server_pcb_ble2, &tpcb, sizeof(struct tcp_pcb *)); memcpy(&server_pcb_ble2, &tpcb, sizeof(struct tcp_pcb *));
memcpy(ble2_uart3.tx_data, (int *)p->payload, p->tot_len); memcpy(ble2_uart3.tx_data, (int *)p->payload, p->tot_len);
@ -140,36 +117,36 @@ static err_t tcpecho_recv_ble2(void *arg, struct tcp_pcb *tpcb, struct pbuf *p,
memset(p->payload, 0, p->tot_len); memset(p->payload, 0, p->tot_len);
pbuf_free(p); pbuf_free(p);
} }
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空 else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{ {
return tcp_close(tpcb); return tcp_close(tpcb);
} }
return ERR_OK; return ERR_OK;
} }
static err_t tcpecho_accept_hart1(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的 static err_t tcpecho_accept_hart1(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
// 形参的数量和类型必须一致 // 形参的数量和类型必须一致
{ {
tcp_recv(newpcb, tcpecho_recv_hart1); // 当收到数据时，回调用户自己写的tcpecho_recv tcp_recv(newpcb, tcpecho_recv_hart1); // 当收到数据时，回调用户自己写的tcpecho_recv
return ERR_OK; return ERR_OK;
} }
static err_t tcpecho_accept_hart2(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的 static err_t tcpecho_accept_hart2(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{ {
tcp_recv(newpcb, tcpecho_recv_hart2); // 当收到数据时，回调用户自己写的tcpecho_recv tcp_recv(newpcb, tcpecho_recv_hart2); // 当收到数据时，回调用户自己写的tcpecho_recv
return ERR_OK; return ERR_OK;
} }
static err_t tcpecho_accept_ble1(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的 static err_t tcpecho_accept_ble1(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{ {
tcp_recv(newpcb, tcpecho_recv_ble1); // 当收到数据时，回调用户自己写的tcpecho_recv tcp_recv(newpcb, tcpecho_recv_ble1); // 当收到数据时，回调用户自己写的tcpecho_recv
return ERR_OK; return ERR_OK;
} }
static err_t tcpecho_accept_ble2(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的 static err_t tcpecho_accept_ble2(void *arg, struct tcp_pcb *newpcb, err_t err) // 由于这个函数是*tcp_accept_fn类型的
{ {
tcp_recv(newpcb, tcpecho_recv_ble2); // 当收到数据时，回调用户自己写的tcpecho_recv tcp_recv(newpcb, tcpecho_recv_ble2); // 当收到数据时，回调用户自己写的tcpecho_recv
return ERR_OK; return ERR_OK;
} }
@ -180,53 +157,53 @@ void tcp_echo_init(void)
struct tcp_pcb *server_ble1 = NULL; struct tcp_pcb *server_ble1 = NULL;
struct tcp_pcb *server_ble2 = NULL; struct tcp_pcb *server_ble2 = NULL;
/* 创建一个TCP控制块 */ /* 创建一个TCP控制块 */
server_hart1 = tcp_new(); server_hart1 = tcp_new();
/* 绑定TCP控制块 */ /* 绑定TCP控制块 */
tcp_bind(server_hart1, IP_ADDR_ANY, TCP_PORT_HART1); tcp_bind(server_hart1, IP_ADDR_ANY, TCP_PORT_HART1);
/* 进入监听状态 */ /* 进入监听状态 */
server_hart1 = tcp_listen(server_hart1); server_hart1 = tcp_listen(server_hart1);
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */ /* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
tcp_accept(server_hart1, tcpecho_accept_hart1); // 侦听到连接后，回调用户编写的tcpecho_accept tcp_accept(server_hart1, tcpecho_accept_hart1); // 侦听到连接后，回调用户编写的tcpecho_accept
/* 创建一个TCP控制块 */ /* 创建一个TCP控制块 */
server_hart2 = tcp_new(); server_hart2 = tcp_new();
/* 绑定TCP控制块 */ /* 绑定TCP控制块 */
tcp_bind(server_hart2, IP_ADDR_ANY, TCP_PORT_HART2); tcp_bind(server_hart2, IP_ADDR_ANY, TCP_PORT_HART2);
/* 进入监听状态 */ /* 进入监听状态 */
server_hart2 = tcp_listen(server_hart2); server_hart2 = tcp_listen(server_hart2);
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */ /* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
tcp_accept(server_hart2, tcpecho_accept_hart2); // 侦听到连接后，回调用户编写的tcpecho_accept tcp_accept(server_hart2, tcpecho_accept_hart2); // 侦听到连接后，回调用户编写的tcpecho_accept
/* 创建一个TCP控制块 */ /* 创建一个TCP控制块 */
server_ble1 = tcp_new(); server_ble1 = tcp_new();
/* 绑定TCP控制块 */ /* 绑定TCP控制块 */
tcp_bind(server_ble1, IP_ADDR_ANY, TCP_PORT_BLE1); tcp_bind(server_ble1, IP_ADDR_ANY, TCP_PORT_BLE1);
/* 进入监听状态 */ /* 进入监听状态 */
server_ble1 = tcp_listen(server_ble1); server_ble1 = tcp_listen(server_ble1);
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */ /* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
tcp_accept(server_ble1, tcpecho_accept_ble1); // 侦听到连接后，回调用户编写的tcpecho_accept tcp_accept(server_ble1, tcpecho_accept_ble1); // 侦听到连接后，回调用户编写的tcpecho_accept
/* 创建一个TCP控制块 */ /* 创建一个TCP控制块 */
server_ble2 = tcp_new(); server_ble2 = tcp_new();
/* 绑定TCP控制块 */ /* 绑定TCP控制块 */
tcp_bind(server_ble2, IP_ADDR_ANY, TCP_PORT_BLE2); tcp_bind(server_ble2, IP_ADDR_ANY, TCP_PORT_BLE2);
/* 进入监听状态 */ /* 进入监听状态 */
server_ble2 = tcp_listen(server_ble2); server_ble2 = tcp_listen(server_ble2);
/* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */ /* 处理连接 注册函数，侦听到连接时被注册的函数被回调 */
tcp_accept(server_ble2, tcpecho_accept_ble2); // 侦听到连接后，回调用户编写的tcpecho_accept tcp_accept(server_ble2, tcpecho_accept_ble2); // 侦听到连接后，回调用户编写的tcpecho_accept
} }
void user_send_data_hart1(uint8_t *data, uint16_t len) void user_send_data_hart1(uint8_t *data, uint16_t len)