wxsmart-test
/
positioner_testing_project
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(&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));
hart_ht1200m_reset(); // 夝佝HT1200M模块
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1); // 坯动PWM输出，用于驱动HT1200M模块
hart_ht1200m_reset(); // 初始化HT1200M模块
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1); // PWM输出，用于驱动HT1200M模块
/* USER CODE END 2 */
/* Call init function for freertos objects (in freertos.c) */
@ -139,7 +139,6 @@ int main(void)
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
// ad7124_get_analog(STOP_NC_ADC);
}
/* USER CODE END 3 */
}

99
Core/Src/usart.c
View File

@ -66,7 +66,6 @@ void MX_UART4_Init(void)
/* USER CODE BEGIN UART4_Init 2 */
//__HAL_UART_ENABLE_IT(&huart4, UART_IT_IDLE); // 使能IDLE中断
/* USER CODE END UART4_Init 2 */
}
/* UART5 init function */
void MX_UART5_Init(void)
@ -92,10 +91,9 @@ void MX_UART5_Init(void)
Error_Handler();
}
/* USER CODE BEGIN UART5_Init 2 */
__HAL_UART_ENABLE_IT(&huart5, UART_IT_RXNE); // 接收中断
__HAL_UART_ENABLE_IT(&huart5, UART_IT_IDLE); // 空闲中断
// __HAL_UART_ENABLE_IT(&huart5, UART_IT_RXNE); // 接收中断
// __HAL_UART_ENABLE_IT(&huart5, UART_IT_IDLE); // 空闲中断
/* USER CODE END UART5_Init 2 */
}
/* USART2 init function */
@ -122,10 +120,9 @@ void MX_USART2_UART_Init(void)
Error_Handler();
}
/* USER CODE BEGIN USART2_Init 2 */
__HAL_UART_ENABLE_IT(&huart2, UART_IT_RXNE); // 接收中断
__HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE); // 使能IDLE中断
// __HAL_UART_ENABLE_IT(&huart2, UART_IT_RXNE); // 接收中断
// __HAL_UART_ENABLE_IT(&huart2, UART_IT_IDLE); // 使能IDLE中断
/* USER CODE END USART2_Init 2 */
}
/* USART3 init function */
@ -154,7 +151,6 @@ void MX_USART3_UART_Init(void)
/* USER CODE BEGIN USART3_Init 2 */
/* USER CODE END USART3_Init 2 */
}
/* USART6 init function */
@ -183,14 +179,13 @@ void MX_USART6_UART_Init(void)
/* USER CODE BEGIN USART6_Init 2 */
/* USER CODE END USART6_Init 2 */
}
void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
void HAL_UART_MspInit(UART_HandleTypeDef *uartHandle)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
if(uartHandle->Instance==UART4)
if (uartHandle->Instance == UART4)
{
/* USER CODE BEGIN UART4_MspInit 0 */
@ -203,7 +198,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
PC10 ------> UART4_TX
PC11 ------> UART4_RX
*/
GPIO_InitStruct.Pin = LCD_TX_Pin|LCD_RX_Pin;
GPIO_InitStruct.Pin = LCD_TX_Pin | LCD_RX_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
@ -227,7 +222,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler();
}
__HAL_LINKDMA(uartHandle,hdmarx,hdma_uart4_rx);
__HAL_LINKDMA(uartHandle, hdmarx, hdma_uart4_rx);
/* UART4_TX Init */
hdma_uart4_tx.Instance = DMA1_Stream4;
@ -245,7 +240,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler();
}
__HAL_LINKDMA(uartHandle,hdmatx,hdma_uart4_tx);
__HAL_LINKDMA(uartHandle, hdmatx, hdma_uart4_tx);
/* UART4 interrupt Init */
HAL_NVIC_SetPriority(UART4_IRQn, 5, 0);
@ -254,7 +249,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
/* USER CODE END UART4_MspInit 1 */
}
else if(uartHandle->Instance==UART5)
else if (uartHandle->Instance == UART5)
{
/* USER CODE BEGIN UART5_MspInit 0 */
@ -299,7 +294,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler();
}
__HAL_LINKDMA(uartHandle,hdmatx,hdma_uart5_tx);
__HAL_LINKDMA(uartHandle, hdmatx, hdma_uart5_tx);
/* UART5_RX Init */
hdma_uart5_rx.Instance = DMA1_Stream0;
@ -317,7 +312,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler();
}
__HAL_LINKDMA(uartHandle,hdmarx,hdma_uart5_rx);
__HAL_LINKDMA(uartHandle, hdmarx, hdma_uart5_rx);
/* UART5 interrupt Init */
HAL_NVIC_SetPriority(UART5_IRQn, 5, 0);
@ -326,7 +321,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
/* USER CODE END UART5_MspInit 1 */
}
else if(uartHandle->Instance==USART2)
else if (uartHandle->Instance == USART2)
{
/* USER CODE BEGIN USART2_MspInit 0 */
@ -339,7 +334,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
PD5 ------> USART2_TX
PD6 ------> USART2_RX
*/
GPIO_InitStruct.Pin = HART2_TX_Pin|HART2_RX_Pin;
GPIO_InitStruct.Pin = HART2_TX_Pin | HART2_RX_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
@ -363,7 +358,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler();
}
__HAL_LINKDMA(uartHandle,hdmarx,hdma_usart2_rx);
__HAL_LINKDMA(uartHandle, hdmarx, hdma_usart2_rx);
/* USART2_TX Init */
hdma_usart2_tx.Instance = DMA1_Stream6;
@ -381,7 +376,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler();
}
__HAL_LINKDMA(uartHandle,hdmatx,hdma_usart2_tx);
__HAL_LINKDMA(uartHandle, hdmatx, hdma_usart2_tx);
/* USART2 interrupt Init */
HAL_NVIC_SetPriority(USART2_IRQn, 5, 0);
@ -390,7 +385,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
/* USER CODE END USART2_MspInit 1 */
}
else if(uartHandle->Instance==USART3)
else if (uartHandle->Instance == USART3)
{
/* USER CODE BEGIN USART3_MspInit 0 */
@ -403,7 +398,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
PD8 ------> USART3_TX
PD9 ------> USART3_RX
*/
GPIO_InitStruct.Pin = BLE2_TX_Pin|BLE2_RX_Pin;
GPIO_InitStruct.Pin = BLE2_TX_Pin | BLE2_RX_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
@ -427,7 +422,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler();
}
__HAL_LINKDMA(uartHandle,hdmarx,hdma_usart3_rx);
__HAL_LINKDMA(uartHandle, hdmarx, hdma_usart3_rx);
/* USART3_TX Init */
hdma_usart3_tx.Instance = DMA1_Stream3;
@ -445,7 +440,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler();
}
__HAL_LINKDMA(uartHandle,hdmatx,hdma_usart3_tx);
__HAL_LINKDMA(uartHandle, hdmatx, hdma_usart3_tx);
/* USART3 interrupt Init */
HAL_NVIC_SetPriority(USART3_IRQn, 5, 0);
@ -454,7 +449,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
/* USER CODE END USART3_MspInit 1 */
}
else if(uartHandle->Instance==USART6)
else if (uartHandle->Instance == USART6)
{
/* USER CODE BEGIN USART6_MspInit 0 */
@ -467,7 +462,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
PC6 ------> USART6_TX
PC7 ------> USART6_RX
*/
GPIO_InitStruct.Pin = BLE1_TX_Pin|BLE1_RX_Pin;
GPIO_InitStruct.Pin = BLE1_TX_Pin | BLE1_RX_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
@ -491,7 +486,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler();
}
__HAL_LINKDMA(uartHandle,hdmarx,hdma_usart6_rx);
__HAL_LINKDMA(uartHandle, hdmarx, hdma_usart6_rx);
/* USART6_TX Init */
hdma_usart6_tx.Instance = DMA2_Stream6;
@ -509,7 +504,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler();
}
__HAL_LINKDMA(uartHandle,hdmatx,hdma_usart6_tx);
__HAL_LINKDMA(uartHandle, hdmatx, hdma_usart6_tx);
/* USART6 interrupt Init */
HAL_NVIC_SetPriority(USART6_IRQn, 5, 0);
@ -520,10 +515,10 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
}
}
void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
void HAL_UART_MspDeInit(UART_HandleTypeDef *uartHandle)
{
if(uartHandle->Instance==UART4)
if (uartHandle->Instance == UART4)
{
/* USER CODE BEGIN UART4_MspDeInit 0 */
@ -535,7 +530,7 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
PC10 ------> UART4_TX
PC11 ------> UART4_RX
*/
HAL_GPIO_DeInit(GPIOC, LCD_TX_Pin|LCD_RX_Pin);
HAL_GPIO_DeInit(GPIOC, LCD_TX_Pin | LCD_RX_Pin);
/* UART4 DMA DeInit */
HAL_DMA_DeInit(uartHandle->hdmarx);
@ -547,7 +542,7 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
/* USER CODE END UART4_MspDeInit 1 */
}
else if(uartHandle->Instance==UART5)
else if (uartHandle->Instance == UART5)
{
/* USER CODE BEGIN UART5_MspDeInit 0 */
@ -573,7 +568,7 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
/* USER CODE END UART5_MspDeInit 1 */
}
else if(uartHandle->Instance==USART2)
else if (uartHandle->Instance == USART2)
{
/* USER CODE BEGIN USART2_MspDeInit 0 */
@ -585,7 +580,7 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
PD5 ------> USART2_TX
PD6 ------> USART2_RX
*/
HAL_GPIO_DeInit(GPIOD, HART2_TX_Pin|HART2_RX_Pin);
HAL_GPIO_DeInit(GPIOD, HART2_TX_Pin | HART2_RX_Pin);
/* USART2 DMA DeInit */
HAL_DMA_DeInit(uartHandle->hdmarx);
@ -597,7 +592,7 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
/* USER CODE END USART2_MspDeInit 1 */
}
else if(uartHandle->Instance==USART3)
else if (uartHandle->Instance == USART3)
{
/* USER CODE BEGIN USART3_MspDeInit 0 */
@ -609,7 +604,7 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
PD8 ------> USART3_TX
PD9 ------> USART3_RX
*/
HAL_GPIO_DeInit(GPIOD, BLE2_TX_Pin|BLE2_RX_Pin);
HAL_GPIO_DeInit(GPIOD, BLE2_TX_Pin | BLE2_RX_Pin);
/* USART3 DMA DeInit */
HAL_DMA_DeInit(uartHandle->hdmarx);
@ -621,7 +616,7 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
/* USER CODE END USART3_MspDeInit 1 */
}
else if(uartHandle->Instance==USART6)
else if (uartHandle->Instance == USART6)
{
/* USER CODE BEGIN USART6_MspDeInit 0 */
@ -633,7 +628,7 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
PC6 ------> USART6_TX
PC7 ------> USART6_RX
*/
HAL_GPIO_DeInit(GPIOC, BLE1_TX_Pin|BLE1_RX_Pin);
HAL_GPIO_DeInit(GPIOC, BLE1_TX_Pin | BLE1_RX_Pin);
/* USART6 DMA DeInit */
HAL_DMA_DeInit(uartHandle->hdmarx);
@ -648,17 +643,23 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
}
/* USER CODE BEGIN 1 */
/*
*********************************************************************************************************
* å‡? æ•? å<EFBFBD>?: dma_usart_send
* 功能说明: 串å<EFBFBD>£å<EFBFBD>‘é?<EFBFBD>功能函æ•?
* å½? å<EFBFBD>?: buf，len
* � � �: �
*********************************************************************************************************
*/
void dma_usart_send(UART_HandleTypeDef *huart, uint8_t *buf, uint8_t len) // 串å<C2B2>£å<C2A3>‘é?<3F>å°<C3A5>è£?
/**
* @brief 使用DMA方式通过串口发送数据
*
* 该函数使用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)
{
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();
}

2
MDK-ARM/TEST2.uvoptx
View File

@ -308,7 +308,7 @@
<Group>
<GroupName>Application/User/Core</GroupName>
<tvExp>0</tvExp>
<tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel>
<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_ble1;
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)
{ // 对应接收数据连接的控制块 接收到的数据
{ // 对应接收数据连接的控制块 接收到的数据
if (p != NULL)
{
/* 更新窗口*/
/* 更新窗口*/
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 *));
#if 0
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;
dma_usart_send(&huart5, hart1_uart5.tx_data, p->tot_len);
// 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
memset(p->payload, 0, p->tot_len);
pbuf_free(p);
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
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)
{ // 对应接收数据连接的控制块 接收到的数据
{ // 对应接收数据连接的控制块 接收到的数据
if (p != NULL)
{
/* 更新窗口*/
/* 更新窗口*/
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 *));
#if 1
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);
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
memset(p->payload, 0, p->tot_len);
pbuf_free(p);
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
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)
{ // 对应接收数据连接的控制块 接收到的数据
{ // 对应接收数据连接的控制块 接收到的数据
if (p != NULL)
{
/* 更新窗口*/
/* 更新窗口*/
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(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);
pbuf_free(p);
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
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)
{ // 对应接收数据连接的控制块 接收到的数据
{ // 对应接收数据连接的控制块 接收到的数据
if (p != NULL)
{
/* 更新窗口*/
/* 更新窗口*/
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(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);
pbuf_free(p);
}
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
else if (err == ERR_OK) // 检测到对方主动关闭连接时，也会调用recv函数，此时p为空
{
return tcp_close(tpcb);
}
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;
}
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;
}
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;
}
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;
}
@ -180,53 +157,53 @@ void tcp_echo_init(void)
struct tcp_pcb *server_ble1 = NULL;
struct tcp_pcb *server_ble2 = NULL;
/* 创建一个TCP控制块 */
/* 创建一个TCP控制块 */
server_hart1 = tcp_new();
/* 绑定TCP控制块 */
/* 绑定TCP控制块 */
tcp_bind(server_hart1, IP_ADDR_ANY, TCP_PORT_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();
/* 绑定TCP控制块 */
/* 绑定TCP控制块 */
tcp_bind(server_hart2, IP_ADDR_ANY, TCP_PORT_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();
/* 绑定TCP控制块 */
/* 绑定TCP控制块 */
tcp_bind(server_ble1, IP_ADDR_ANY, TCP_PORT_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();
/* 绑定TCP控制块 */
/* 绑定TCP控制块 */
tcp_bind(server_ble2, IP_ADDR_ANY, TCP_PORT_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)