stm32f103c8t6串口接收中断回调函数及其主函数

uint8_t buf=0;

//定义最大接收字节数 200，可根据需求调整
#define UART1_REC_LEN 200

// 接收缓冲, 串口接收到的数据放在这个数组里，最大UART1_REC_LEN个字节
uint8_t UART1_RX_Buffer[UART1_REC_LEN];

//  接收状态
//  bit15，      接收完成标志
//  bit14，      接收到0x0d
//  bit13~0，    接收到的有效字节数目
uint16_t UART1_RX_STA=0;

// 接收完成回调函数，收到一个数据后，在这里处理
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    // 判断中断是由哪个串口触发的
    if(huart->Instance == USART1)
    {
        // 判断接收是否完成（UART1_RX_STA bit15 位是否为1）
        if((UART1_RX_STA & 0x8000) == 0)
        {
            // 如果已经收到了 0x0d （回车），
            if(UART1_RX_STA & 0x4000)
            {
                // 则接着判断是否收到 0x0a （换行）
                if(buf == 0x0a)
                    // 如果 0x0a 和 0x0d 都收到，则将 bit15 位置为1
                    UART1_RX_STA |= 0x8000;
                else
                    // 否则认为接收错误，重新开始
                    UART1_RX_STA = 0;
            }
            else    // 如果没有收到了 0x0d （回车）
            {
                //则先判断收到的这个字符是否是 0x0d （回车）
                if(buf == 0x0d)
                {
                    // 是的话则将 bit14 位置为1
                    UART1_RX_STA |= 0x4000;
                }
                else
                {
                    // 否则将接收到的数据保存在缓存数组里
                    UART1_RX_Buffer[UART1_RX_STA & 0X3FFF] = buf;
                    UART1_RX_STA++;
                    
                    // 如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
                    if(UART1_RX_STA > UART1_REC_LEN - 1)
                        UART1_RX_STA = 0;
                }
            }
        }
        // 重新开启中断
        HAL_UART_Receive_IT(&huart1, &buf, 1);
    }
}

int fputc(int ch, FILE *f)
{      
    unsigned char temp[1]={ch};
    HAL_UART_Transmit(&huart1,temp,1,0xffff);  
    return ch;
}

int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */
    // 开启接收中断
    HAL_UART_Receive_IT(&huart1, &buf, 1);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
        //判断判断串口是否接收完成，数据位会影响其数据接收（0x8000不能写成0x800）
        if(UART1_RX_STA & 0x8000)
        {
            printf("收到数据：");
            // 将收到的数据发送到串口
            HAL_UART_Transmit(&huart1, UART1_RX_Buffer, UART1_RX_STA & 0x3fff, 0xffff);
            // 等待发送完成
            while(huart1.gState != HAL_UART_STATE_READY);
            printf("\r\n");
            // 重新开始下一次接收
            UART1_RX_STA = 0;
        }
        printf("hello liangxu\r\n");
        HAL_Delay(1000);

  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}
 

主函数加入的是开启中断while中加入的是将接收数据发送