stm32f030RB串口接收数据问题

2019-03-23 17:45发布

站内问答 / STM32/STM8
13695 2 1567
开发环境：IAR for ARM 7.80.2
问题描述：1、使用CMSIS库，开了串口1和串口2，除波特率不同，其他都一样。串口2工作正常，串口1接收数据出错。
2.使用HAL库，串口1和串口2都正常。
排除了硬件的故障，所以问题肯定还是出在软件上面。但是比较两者不同，貌似又没有什么不同。调了好几天，实在没头绪。
代码如下：
CMSIS下：
  1. /**
  2.   * [url=home.php?mod=space&uid=159083]@brief[/url]  uart1 init
  3.   * @param  none
  4.   * @retval None
  5.   */
  6. void USART1_Init(void)
  7. {
  8.   NVIC_InitTypeDef NVIC_InitStructure;
  9.   GPIO_InitTypeDef GPIOInitType;
  10.   USART_InitTypeDef USART_InitStructure;
  11.   //RCC_USARTCLKConfig(RCC_USART1CLK_PCLK);
  12.   
  13.   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
  14.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE );       

  16.   USART_InitStructure.USART_BaudRate = 9600;
  17.   USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  18.   USART_InitStructure.USART_StopBits = USART_StopBits_1;
  19.   USART_InitStructure.USART_Parity   = USART_Parity_No;
  20.   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  21.   USART_InitStructure.USART_Mode          = USART_Mode_Rx | USART_Mode_Tx;
  22.   USART_Init(USART1, &USART_InitStructure);        

  24.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
  25.   USART_Cmd(USART1, ENABLE);
  26.   
  27.   GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_1);
  28.   GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_1);
  29.   GPIOInitType.GPIO_Pin   = GPIO_Pin_9 | GPIO_Pin_10;
  30.   GPIOInitType.GPIO_Speed = GPIO_Speed_50MHz;
  31.   GPIOInitType.GPIO_Mode  = GPIO_Mode_AF;
  32.   GPIOInitType.GPIO_OType = GPIO_OType_PP;
  33.   GPIOInitType.GPIO_PuPd = GPIO_PuPd_UP ;
  34.   GPIO_Init(GPIOA, &GPIOInitType);  
  35.   
  36.   NVIC_InitStructure.NVIC_IRQChannelPriority = 0;
  37.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
  38.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  39.   NVIC_Init(&NVIC_InitStructure);
  40. }

  42. /**
  43.   * @brief  uart2 init
  44.   * @param  none
  45.   * @retval None
  46.   */
  47. void USART2_Init(void)
  48. {
  49.   NVIC_InitTypeDef NVIC_InitStructure;
  50.   GPIO_InitTypeDef GPIOInitType;
  51.   USART_InitTypeDef USART_InitStructure;
  52.   
  53.   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
  54.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE );       

  56.   USART_InitStructure.USART_BaudRate = 115200;
  57.   USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  58.   USART_InitStructure.USART_StopBits = USART_StopBits_1;
  59.   USART_InitStructure.USART_Parity   = USART_Parity_No;
  60.   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  61.   USART_InitStructure.USART_Mode          = USART_Mode_Rx | USART_Mode_Tx;
  62.   USART_Init(USART2, &USART_InitStructure);        

  64.   USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);
  65.   USART_Cmd(USART2, ENABLE);
  66.   
  67.   GPIO_PinAFConfig(GPIOA,GPIO_PinSource2,GPIO_AF_1);
  68.   GPIO_PinAFConfig(GPIOA,GPIO_PinSource3,GPIO_AF_1);
  69.   GPIOInitType.GPIO_Pin   = GPIO_Pin_2 | GPIO_Pin_3;
  70.   GPIOInitType.GPIO_Speed = GPIO_Speed_50MHz;
  71.   GPIOInitType.GPIO_Mode  = GPIO_Mode_AF;
  72.   GPIOInitType.GPIO_OType = GPIO_OType_PP;
  73.   GPIOInitType.GPIO_PuPd = GPIO_PuPd_UP ;
  74.   GPIO_Init(GPIOA, &GPIOInitType);
  75.   
  76.   NVIC_InitStructure.NVIC_IRQChannelPriority = 1;
  77.   NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;  
  78.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  79.   NVIC_Init(&NVIC_InitStructure);
  80. }

  82. /**
  83.   * @brief  uart1 interrupt
  84.   * @param  None
  85.   * @retval None
  86.   */
  87. void USART1_IRQHandler(void)
  88. {
  89.   U8 dat = 0;
  90.   if (USART_GetFlagStatus(USART1, USART_FLAG_ORE) != RESET)
  91.   {
  92.     USART_ClearITPendingBit(USART1,USART_IT_ORE);      
  93.     dat = USART_ReceiveData(USART1);  
  94.     if(!QueueIsFull(&BoardRxQueue)) //队列不满
  95.     {
  96.       PushInQueue_Q(&BoardRxQueue, dat);   
  97.       TIM6->CNT = 0;  //定时器计数设为0      
  98.       if(g_devWorkStatus.bRecvDataUart1 == 0)//打开定时器。如果定时器产生了中断，则说明一帧数据接收完毕了
  99.         TIM6_Set(1);
  100.     }
  101.     else
  102.       g_devWorkStatus.bRecvDataUart1 = 1;
  103.   }
  104.   if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
  105.   {
  106.     dat = USART_ReceiveData(USART1);
  107.     if(!QueueIsFull(&BoardRxQueue)) //队列不满
  108.     {
  109.       PushInQueue_Q(&BoardRxQueue, dat);   
  110.       TIM6->CNT = 0;  //定时器计数设为0      
  111.       if(g_devWorkStatus.bRecvDataUart1 == 0)//打开定时器。如果定时器产生了中断，则说明一帧数据接收完毕了
  112.         TIM6_Set(1);
  113.     }
  114.     else
  115.       g_devWorkStatus.bRecvDataUart1 = 1;
  116.     USART_ClearITPendingBit(USART1, USART_IT_RXNE);
  117.   }
  118. }

  120. /**
  121.   * @brief  uart2 interrupt
  122.   * @param  None
  123.   * @retval None
  124.   */
  125. void USART2_IRQHandler(void)
  126. {
  127.   U8 dat = 0;
  128.   if (USART_GetFlagStatus(USART2, USART_FLAG_ORE) != RESET)
  129.   {
  130.     USART_ClearITPendingBit(USART2,USART_IT_ORE);      
  131.     dat = USART_ReceiveData(USART2);  
  132.     if(!QueueIsFull(&MG2618RxQueue)) //队列不满
  133.     {
  134.       PushInQueue_Q(&MG2618RxQueue, dat);   
  135.       TIM7->CNT = 0;  //定时器计数设为0      
  136.       if(g_devWorkStatus.bRecvDataUart2 == 0)//打开定时器。如果定时器产生了中断，则说明一帧数据接收完毕了
  137.         TIM7_Set(1);
  138.     }
  139.     else
  140.       g_devWorkStatus.bRecvDataUart2 = 1;
  141.   }
  142.   
  143.   if (USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
  144.   {
  145.     dat = USART_ReceiveData(USART2);
  146.     if(!QueueIsFull(&MG2618RxQueue)) //队列不满
  147.     {
  148.       PushInQueue_Q(&MG2618RxQueue, dat);   
  149.       TIM7->CNT = 0;  //定时器计数设为0      
  150.       if(g_devWorkStatus.bRecvDataUart2 == 0)//打开定时器。如果定时器产生了中断，则说明一帧数据接收完毕了
  151.         TIM7_Set(1);
  152.     }
  153.     else
  154.       g_devWorkStatus.bRecvDataUart2 = 1;
  155.     USART_ClearITPendingBit(USART2, USART_IT_RXNE);
  156.   }
  157. }
复制代码
HAL库下的代码：
  1. /* USART1 init function */
  2. static void MX_USART1_UART_Init(void)
  3. {
  4.   
  5.   huart1.Instance = USART1;
  6.   huart1.Init.BaudRate = 9600;
  7.   huart1.Init.WordLength = UART_WORDLENGTH_8B;
  8.   huart1.Init.StopBits = UART_STOPBITS_1;
  9.   huart1.Init.Parity = UART_PARITY_NONE;
  10.   huart1.Init.Mode = UART_MODE_TX_RX;
  11.   huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  12.   huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  13.   huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  14.   huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  15.   if (HAL_UART_Init(&huart1) != HAL_OK)
  16.   {
  17.     Error_Handler();
  18.   }
  19.   __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);
  20.   //  if(HAL_UART_Receive_IT(&huart1,aRxBuffer,1)!=HAL_OK)
  21.   //  {
  22.   //    Error_Handler();
  23.   //  }
  24.   NVIC_SetPriority(USART1_IRQn, 1);
  25.   HAL_NVIC_EnableIRQ(USART1_IRQn);     
  26. }

  28. /* USART2 init function */
  29. static void MX_USART2_UART_Init(void)
  30. {
  31.   
  32.   huart2.Instance = USART2;
  33.   huart2.Init.BaudRate = 115200;
  34.   huart2.Init.WordLength = UART_WORDLENGTH_8B;
  35.   huart2.Init.StopBits = UART_STOPBITS_1;
  36.   huart2.Init.Parity = UART_PARITY_NONE;
  37.   huart2.Init.Mode = UART_MODE_TX_RX;
  38.   huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  39.   huart2.Init.OverSampling = UART_OVERSAMPLING_16;
  40.   huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  41.   huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  42.   if (HAL_UART_Init(&huart2) != HAL_OK)
  43.   {
  44.     Error_Handler();
  45.   }
  46.   __HAL_UART_ENABLE_IT(&huart2, UART_IT_RXNE);
  47.   //  if(HAL_UART_Receive_IT(&huart2,aRxBuffer,1)!=HAL_OK)
  48.   //  {
  49.   //    Error_Handler();
  50.   //  }
  51.   NVIC_SetPriority(USART2_IRQn, 0);
  52.   HAL_NVIC_EnableIRQ(USART2_IRQn);
  53. }

  55. void HAL_UART_MspInit(UART_HandleTypeDef* huart)
  56. {

  58.   GPIO_InitTypeDef GPIO_InitStruct;
  59.   if(huart->Instance==USART1)
  60.   {
  61.   /* USER CODE BEGIN USART1_MspInit 0 */

  63.   /* USER CODE END USART1_MspInit 0 */
  64.     /* Peripheral clock enable */
  65.     __HAL_RCC_USART1_CLK_ENABLE();
  66.   
  67.     /**USART1 GPIO Configuration   
  68.     PA9     ------> USART1_TX
  69.     PA10     ------> USART1_RX
  70.     */
  71.     GPIO_InitStruct.Pin = GPIO_PIN_9|GPIO_PIN_10;
  72.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  73.     GPIO_InitStruct.Pull = GPIO_PULLUP;
  74.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  75.     GPIO_InitStruct.Alternate = GPIO_AF1_USART1;
  76.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  78.   /* USER CODE BEGIN USART1_MspInit 1 */

  80.   /* USER CODE END USART1_MspInit 1 */
  81.   }
  82.   else if(huart->Instance==USART2)
  83.   {
  84.   /* USER CODE BEGIN USART2_MspInit 0 */

  86.   /* USER CODE END USART2_MspInit 0 */
  87.     /* Peripheral clock enable */
  88.     __HAL_RCC_USART2_CLK_ENABLE();
  89.   
  90.     /**USART2 GPIO Configuration   
  91.     PA2     ------> USART2_TX
  92.     PA3     ------> USART2_RX
  93.     */
  94.     GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;
  95.     GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  96.     GPIO_InitStruct.Pull = GPIO_PULLUP;
  97.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  98.     GPIO_InitStruct.Alternate = GPIO_AF1_USART2;
  99.     HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  101.   /* USER CODE BEGIN USART2_MspInit 1 */

  103.   /* USER CODE END USART2_MspInit 1 */
  104.   }

  106. }

  108. void USART1_IRQHandler(void)
  109. {
  110.    if((USART1->ISR & 0x20)==0x20)
  111.    {
  112.      RingBufWriteOne(&mowerRingBuffObj,USART1->RDR);
  113.    }
  114. //   else
  115. //   {
  116. //      
  117. //   }
  118.   //HAL_UART_IRQHandler(&huart1);
  119. }
  120. extern UART_HandleTypeDef huart2;
  121. extern tRingBufObject GprsRingBuffObj;
  122. void USART2_IRQHandler(void)
  123. {
  124.    //uint8_t ret=0;
  125.   if((USART2->ISR & 0x20)==0x20)
  126.   {
  127.    RingBufWriteOne(&GprsRingBuffObj,USART2->RDR);
  128.   }
  129. //  else
  130. //  {
  131. //      
  132. //  }
  133.    //ret=RingBufReadOne(&GprsRingBuffObj);
  134.    //HAL_UART_Transmit(&huart2,&ret,1,20);
  135.   //HAL_UART_IRQHandler(&huart2);
  136. }
复制代码
此帖出自小平头技术问答
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
2条回答
strong161
2019-03-24 02:28
 精彩回答 2  元偷偷看……0人看过

一周热门 更多>

相关问题