wxsmart-test
/
signal_generator
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 */
} }

179
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,18 +179,17 @@ 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)
{ {
GPIO_InitTypeDef GPIO_InitStruct = {0}; GPIO_InitTypeDef GPIO_InitStruct = {0};
if(uartHandle->Instance==UART4) if (uartHandle->Instance == UART4)
{ {
/* USER CODE BEGIN UART4_MspInit 0 */ /* USER CODE BEGIN UART4_MspInit 0 */
/* USER CODE END UART4_MspInit 0 */ /* USER CODE END UART4_MspInit 0 */
/* UART4 clock enable */ /* UART4 clock enable */
__HAL_RCC_UART4_CLK_ENABLE(); __HAL_RCC_UART4_CLK_ENABLE();
@ -203,7 +198,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
PC10 ------> UART4_TX PC10 ------> UART4_TX
PC11 ------> UART4_RX 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.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
@ -227,7 +222,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler(); Error_Handler();
} }
__HAL_LINKDMA(uartHandle,hdmarx,hdma_uart4_rx); __HAL_LINKDMA(uartHandle, hdmarx, hdma_uart4_rx);
/* UART4_TX Init */ /* UART4_TX Init */
hdma_uart4_tx.Instance = DMA1_Stream4; hdma_uart4_tx.Instance = DMA1_Stream4;
@ -245,20 +240,20 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler(); Error_Handler();
} }
__HAL_LINKDMA(uartHandle,hdmatx,hdma_uart4_tx); __HAL_LINKDMA(uartHandle, hdmatx, hdma_uart4_tx);
/* UART4 interrupt Init */ /* UART4 interrupt Init */
HAL_NVIC_SetPriority(UART4_IRQn, 5, 0); HAL_NVIC_SetPriority(UART4_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(UART4_IRQn); HAL_NVIC_EnableIRQ(UART4_IRQn);
/* USER CODE BEGIN UART4_MspInit 1 */ /* USER CODE BEGIN UART4_MspInit 1 */
/* USER CODE END UART4_MspInit 1 */ /* USER CODE END UART4_MspInit 1 */
} }
else if(uartHandle->Instance==UART5) else if (uartHandle->Instance == UART5)
{ {
/* USER CODE BEGIN UART5_MspInit 0 */ /* USER CODE BEGIN UART5_MspInit 0 */
/* USER CODE END UART5_MspInit 0 */ /* USER CODE END UART5_MspInit 0 */
/* UART5 clock enable */ /* UART5 clock enable */
__HAL_RCC_UART5_CLK_ENABLE(); __HAL_RCC_UART5_CLK_ENABLE();
@ -299,7 +294,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler(); Error_Handler();
} }
__HAL_LINKDMA(uartHandle,hdmatx,hdma_uart5_tx); __HAL_LINKDMA(uartHandle, hdmatx, hdma_uart5_tx);
/* UART5_RX Init */ /* UART5_RX Init */
hdma_uart5_rx.Instance = DMA1_Stream0; hdma_uart5_rx.Instance = DMA1_Stream0;
@ -317,20 +312,20 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler(); Error_Handler();
} }
__HAL_LINKDMA(uartHandle,hdmarx,hdma_uart5_rx); __HAL_LINKDMA(uartHandle, hdmarx, hdma_uart5_rx);
/* UART5 interrupt Init */ /* UART5 interrupt Init */
HAL_NVIC_SetPriority(UART5_IRQn, 5, 0); HAL_NVIC_SetPriority(UART5_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(UART5_IRQn); HAL_NVIC_EnableIRQ(UART5_IRQn);
/* USER CODE BEGIN UART5_MspInit 1 */ /* USER CODE BEGIN UART5_MspInit 1 */
/* USER CODE END UART5_MspInit 1 */ /* USER CODE END UART5_MspInit 1 */
} }
else if(uartHandle->Instance==USART2) else if (uartHandle->Instance == USART2)
{ {
/* USER CODE BEGIN USART2_MspInit 0 */ /* USER CODE BEGIN USART2_MspInit 0 */
/* USER CODE END USART2_MspInit 0 */ /* USER CODE END USART2_MspInit 0 */
/* USART2 clock enable */ /* USART2 clock enable */
__HAL_RCC_USART2_CLK_ENABLE(); __HAL_RCC_USART2_CLK_ENABLE();
@ -339,7 +334,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
PD5 ------> USART2_TX PD5 ------> USART2_TX
PD6 ------> USART2_RX 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.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
@ -363,7 +358,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler(); Error_Handler();
} }
__HAL_LINKDMA(uartHandle,hdmarx,hdma_usart2_rx); __HAL_LINKDMA(uartHandle, hdmarx, hdma_usart2_rx);
/* USART2_TX Init */ /* USART2_TX Init */
hdma_usart2_tx.Instance = DMA1_Stream6; hdma_usart2_tx.Instance = DMA1_Stream6;
@ -381,20 +376,20 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler(); Error_Handler();
} }
__HAL_LINKDMA(uartHandle,hdmatx,hdma_usart2_tx); __HAL_LINKDMA(uartHandle, hdmatx, hdma_usart2_tx);
/* USART2 interrupt Init */ /* USART2 interrupt Init */
HAL_NVIC_SetPriority(USART2_IRQn, 5, 0); HAL_NVIC_SetPriority(USART2_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(USART2_IRQn); HAL_NVIC_EnableIRQ(USART2_IRQn);
/* USER CODE BEGIN USART2_MspInit 1 */ /* USER CODE BEGIN USART2_MspInit 1 */
/* USER CODE END USART2_MspInit 1 */ /* USER CODE END USART2_MspInit 1 */
} }
else if(uartHandle->Instance==USART3) else if (uartHandle->Instance == USART3)
{ {
/* USER CODE BEGIN USART3_MspInit 0 */ /* USER CODE BEGIN USART3_MspInit 0 */
/* USER CODE END USART3_MspInit 0 */ /* USER CODE END USART3_MspInit 0 */
/* USART3 clock enable */ /* USART3 clock enable */
__HAL_RCC_USART3_CLK_ENABLE(); __HAL_RCC_USART3_CLK_ENABLE();
@ -403,7 +398,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
PD8 ------> USART3_TX PD8 ------> USART3_TX
PD9 ------> USART3_RX 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.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
@ -427,7 +422,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler(); Error_Handler();
} }
__HAL_LINKDMA(uartHandle,hdmarx,hdma_usart3_rx); __HAL_LINKDMA(uartHandle, hdmarx, hdma_usart3_rx);
/* USART3_TX Init */ /* USART3_TX Init */
hdma_usart3_tx.Instance = DMA1_Stream3; hdma_usart3_tx.Instance = DMA1_Stream3;
@ -445,20 +440,20 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler(); Error_Handler();
} }
__HAL_LINKDMA(uartHandle,hdmatx,hdma_usart3_tx); __HAL_LINKDMA(uartHandle, hdmatx, hdma_usart3_tx);
/* USART3 interrupt Init */ /* USART3 interrupt Init */
HAL_NVIC_SetPriority(USART3_IRQn, 5, 0); HAL_NVIC_SetPriority(USART3_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(USART3_IRQn); HAL_NVIC_EnableIRQ(USART3_IRQn);
/* USER CODE BEGIN USART3_MspInit 1 */ /* USER CODE BEGIN USART3_MspInit 1 */
/* USER CODE END USART3_MspInit 1 */ /* USER CODE END USART3_MspInit 1 */
} }
else if(uartHandle->Instance==USART6) else if (uartHandle->Instance == USART6)
{ {
/* USER CODE BEGIN USART6_MspInit 0 */ /* USER CODE BEGIN USART6_MspInit 0 */
/* USER CODE END USART6_MspInit 0 */ /* USER CODE END USART6_MspInit 0 */
/* USART6 clock enable */ /* USART6 clock enable */
__HAL_RCC_USART6_CLK_ENABLE(); __HAL_RCC_USART6_CLK_ENABLE();
@ -467,7 +462,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
PC6 ------> USART6_TX PC6 ------> USART6_TX
PC7 ------> USART6_RX 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.Mode = GPIO_MODE_AF_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
@ -491,7 +486,7 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler(); Error_Handler();
} }
__HAL_LINKDMA(uartHandle,hdmarx,hdma_usart6_rx); __HAL_LINKDMA(uartHandle, hdmarx, hdma_usart6_rx);
/* USART6_TX Init */ /* USART6_TX Init */
hdma_usart6_tx.Instance = DMA2_Stream6; hdma_usart6_tx.Instance = DMA2_Stream6;
@ -509,25 +504,25 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
Error_Handler(); Error_Handler();
} }
__HAL_LINKDMA(uartHandle,hdmatx,hdma_usart6_tx); __HAL_LINKDMA(uartHandle, hdmatx, hdma_usart6_tx);
/* USART6 interrupt Init */ /* USART6 interrupt Init */
HAL_NVIC_SetPriority(USART6_IRQn, 5, 0); HAL_NVIC_SetPriority(USART6_IRQn, 5, 0);
HAL_NVIC_EnableIRQ(USART6_IRQn); HAL_NVIC_EnableIRQ(USART6_IRQn);
/* USER CODE BEGIN USART6_MspInit 1 */ /* USER CODE BEGIN USART6_MspInit 1 */
/* USER CODE END USART6_MspInit 1 */ /* USER CODE END USART6_MspInit 1 */
} }
} }
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 */ /* USER CODE BEGIN UART4_MspDeInit 0 */
/* USER CODE END UART4_MspDeInit 0 */ /* USER CODE END UART4_MspDeInit 0 */
/* Peripheral clock disable */ /* Peripheral clock disable */
__HAL_RCC_UART4_CLK_DISABLE(); __HAL_RCC_UART4_CLK_DISABLE();
@ -535,7 +530,7 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
PC10 ------> UART4_TX PC10 ------> UART4_TX
PC11 ------> UART4_RX 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 */ /* UART4 DMA DeInit */
HAL_DMA_DeInit(uartHandle->hdmarx); HAL_DMA_DeInit(uartHandle->hdmarx);
@ -543,15 +538,15 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
/* UART4 interrupt Deinit */ /* UART4 interrupt Deinit */
HAL_NVIC_DisableIRQ(UART4_IRQn); HAL_NVIC_DisableIRQ(UART4_IRQn);
/* USER CODE BEGIN UART4_MspDeInit 1 */ /* USER CODE BEGIN UART4_MspDeInit 1 */
/* USER CODE END UART4_MspDeInit 1 */ /* USER CODE END UART4_MspDeInit 1 */
} }
else if(uartHandle->Instance==UART5) else if (uartHandle->Instance == UART5)
{ {
/* USER CODE BEGIN UART5_MspDeInit 0 */ /* USER CODE BEGIN UART5_MspDeInit 0 */
/* USER CODE END UART5_MspDeInit 0 */ /* USER CODE END UART5_MspDeInit 0 */
/* Peripheral clock disable */ /* Peripheral clock disable */
__HAL_RCC_UART5_CLK_DISABLE(); __HAL_RCC_UART5_CLK_DISABLE();
@ -569,15 +564,15 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
/* UART5 interrupt Deinit */ /* UART5 interrupt Deinit */
HAL_NVIC_DisableIRQ(UART5_IRQn); HAL_NVIC_DisableIRQ(UART5_IRQn);
/* USER CODE BEGIN UART5_MspDeInit 1 */ /* USER CODE BEGIN UART5_MspDeInit 1 */
/* USER CODE END UART5_MspDeInit 1 */ /* USER CODE END UART5_MspDeInit 1 */
} }
else if(uartHandle->Instance==USART2) else if (uartHandle->Instance == USART2)
{ {
/* USER CODE BEGIN USART2_MspDeInit 0 */ /* USER CODE BEGIN USART2_MspDeInit 0 */
/* USER CODE END USART2_MspDeInit 0 */ /* USER CODE END USART2_MspDeInit 0 */
/* Peripheral clock disable */ /* Peripheral clock disable */
__HAL_RCC_USART2_CLK_DISABLE(); __HAL_RCC_USART2_CLK_DISABLE();
@ -585,7 +580,7 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
PD5 ------> USART2_TX PD5 ------> USART2_TX
PD6 ------> USART2_RX 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 */ /* USART2 DMA DeInit */
HAL_DMA_DeInit(uartHandle->hdmarx); HAL_DMA_DeInit(uartHandle->hdmarx);
@ -593,15 +588,15 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
/* USART2 interrupt Deinit */ /* USART2 interrupt Deinit */
HAL_NVIC_DisableIRQ(USART2_IRQn); HAL_NVIC_DisableIRQ(USART2_IRQn);
/* USER CODE BEGIN USART2_MspDeInit 1 */ /* USER CODE BEGIN USART2_MspDeInit 1 */
/* USER CODE END USART2_MspDeInit 1 */ /* USER CODE END USART2_MspDeInit 1 */
} }
else if(uartHandle->Instance==USART3) else if (uartHandle->Instance == USART3)
{ {
/* USER CODE BEGIN USART3_MspDeInit 0 */ /* USER CODE BEGIN USART3_MspDeInit 0 */
/* USER CODE END USART3_MspDeInit 0 */ /* USER CODE END USART3_MspDeInit 0 */
/* Peripheral clock disable */ /* Peripheral clock disable */
__HAL_RCC_USART3_CLK_DISABLE(); __HAL_RCC_USART3_CLK_DISABLE();
@ -609,7 +604,7 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
PD8 ------> USART3_TX PD8 ------> USART3_TX
PD9 ------> USART3_RX 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 */ /* USART3 DMA DeInit */
HAL_DMA_DeInit(uartHandle->hdmarx); HAL_DMA_DeInit(uartHandle->hdmarx);
@ -617,15 +612,15 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
/* USART3 interrupt Deinit */ /* USART3 interrupt Deinit */
HAL_NVIC_DisableIRQ(USART3_IRQn); HAL_NVIC_DisableIRQ(USART3_IRQn);
/* USER CODE BEGIN USART3_MspDeInit 1 */ /* USER CODE BEGIN USART3_MspDeInit 1 */
/* USER CODE END USART3_MspDeInit 1 */ /* USER CODE END USART3_MspDeInit 1 */
} }
else if(uartHandle->Instance==USART6) else if (uartHandle->Instance == USART6)
{ {
/* USER CODE BEGIN USART6_MspDeInit 0 */ /* USER CODE BEGIN USART6_MspDeInit 0 */
/* USER CODE END USART6_MspDeInit 0 */ /* USER CODE END USART6_MspDeInit 0 */
/* Peripheral clock disable */ /* Peripheral clock disable */
__HAL_RCC_USART6_CLK_DISABLE(); __HAL_RCC_USART6_CLK_DISABLE();
@ -633,7 +628,7 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
PC6 ------> USART6_TX PC6 ------> USART6_TX
PC7 ------> USART6_RX 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 */ /* USART6 DMA DeInit */
HAL_DMA_DeInit(uartHandle->hdmarx); HAL_DMA_DeInit(uartHandle->hdmarx);
@ -641,24 +636,30 @@ void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
/* USART6 interrupt Deinit */ /* USART6 interrupt Deinit */
HAL_NVIC_DisableIRQ(USART6_IRQn); HAL_NVIC_DisableIRQ(USART6_IRQn);
/* USER CODE BEGIN USART6_MspDeInit 1 */ /* USER CODE BEGIN USART6_MspDeInit 1 */
/* USER CODE END USART6_MspDeInit 1 */ /* USER CODE END USART6_MspDeInit 1 */
} }
} }
/* 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 指向需要发送的数据缓冲区的指针
void dma_usart_send(UART_HandleTypeDef *huart, uint8_t *buf, uint8_t len) // 串å<C2B2>£å<C2A3>‘é?<3F>å°<C3A5>è£? * @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(); 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)