stm32f030RB串口接收数据问题

lft900223

stm32f030RB串口接收数据问题 [复制链接]

开发环境：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 );       
    
15. 
    
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);        
    
23. 
    
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. }
    
41. 
    
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 );       
    
55. 
    
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);        
    
63. 
    
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. }
    
81. 
    
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. }
     
119. 
     
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. }
    
27. 
    
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. }
    
54. 
    
55. void HAL_UART_MspInit(UART_HandleTypeDef* huart)
    
56. {
    
57. 
    
58.   GPIO_InitTypeDef GPIO_InitStruct;
    
59.   if(huart->Instance==USART1)
    
60.   {
    
61.   /* USER CODE BEGIN USART1_MspInit 0 */
    
62. 
    
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);
    
77. 
    
78.   /* USER CODE BEGIN USART1_MspInit 1 */
    
79. 
    
80.   /* USER CODE END USART1_MspInit 1 */
    
81.   }
    
82.   else if(huart->Instance==USART2)
    
83.   {
    
84.   /* USER CODE BEGIN USART2_MspInit 0 */
    
85. 
    
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);
    
100. 
     
101.   /* USER CODE BEGIN USART2_MspInit 1 */
     
102. 
     
103.   /* USER CODE END USART2_MspInit 1 */
     
104.   }
     
105. 
     
106. }
     
107. 
     
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. }

复制代码

lft900223

心塞

strong161

头疼，看不懂……你还不如上传工程呢！