使用芯片STM32F101 ，usart3  RS485半双工，同样的硬件板子，串口会收到发送出的数据帧，即数据为 发送帧+对方回复帧，有时又收到正确数据，即对方回复帧。一直想不通，请论坛里的大佬们解答。
以下为一、初始化代码：Uart_Initial(USART3,4800,0);

1. void Uart_Initial(USART_TypeDef* USARTx,u32 BRate,u16 WorkMode)
   
2. {               
   
3.         u16 WordLength;
   
4.         u16 StopBits;
   
5.   u16 Parity;
   
6.   u16 FlowControl;
   
7. 
   
8.         GPIO_InitTypeDef GPIO_InitStructure;
   
9.         USART_InitTypeDef USART_InitStructure;
   
10.   USART_ClockInitTypeDef USART_ClockInitStructure;        
    
11.         
    
12.         if(USARTx==USART3)
    
13.         {
    
14.                 /* Configure USART3 Tx (PB.10) as alternate function push-pull */
    
15.                 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    
16.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    
17.                 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
18.                 GPIO_Init(GPIOB, &GPIO_InitStructure);
    
19.                
    
20.                 /* Configure USART3 Rx (PB.11) as input floating */
    
21.                 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
    
22.                 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
23.                 GPIO_Init(GPIOB, &GPIO_InitStructure);
    
24.         }        
    
25. //0x1010
    
26.   WordLength = WorkMode & 0xf000;        
    
27.         StopBits = WorkMode & 0x0f00;
    
28.         StopBits <<= 4;
    
29.         Parity = WorkMode & 0x00f0;
    
30.         Parity <<= 4;
    
31.         FlowControl = WorkMode & 0x000f;
    
32.         FlowControl <<= 8;
    
33. 
    
34.         USART_InitStructure.USART_BaudRate = BRate;
    
35.         USART_InitStructure.USART_WordLength = WordLength;
    
36.         USART_InitStructure.USART_StopBits = StopBits;
    
37.         if(Parity==0)
    
38.         {                USART_InitStructure.USART_Parity = USART_Parity_No;
    
39.         }
    
40.         else
    
41.         {
    
42.          USART_InitStructure.USART_Parity = USART_Parity_Even;//Parity;
    
43.         }
    
44.         USART_InitStructure.USART_HardwareFlowControl = FlowControl;
    
45.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
46.         USART_ClockInitStructure.USART_Clock = USART_Clock_Disable;
    
47.         USART_ClockInitStructure.USART_CPOL = USART_CPOL_Low;
    
48.         USART_ClockInitStructure.USART_CPHA = USART_CPHA_2Edge;
    
49.         USART_ClockInitStructure.USART_LastBit = USART_LastBit_Disable;
    
50.         /* Configure the USARTx */
    
51.         USART_Init(USARTx, &USART_InitStructure);
    
52.         USART_ClockInit(USARTx, &USART_ClockInitStructure);
    
53. 
    
54.         /* Enable USARTx RX INT*/
    
55.         USART_ITConfig(USARTx,USART_IT_RXNE,ENABLE);
    
56.         //USART_ITConfig(USARTx,USART_IT_TXE,ENABLE);
    
57.         FeedDog();
    
58.         /* Enable USARTx */
    
59.         USART_Cmd(USARTx, ENABLE);        
    
60. }

复制代码

二、中断优先级设置

1. void NVIC_Configuration(void)
   
2. {
   
3.     NVIC_InitTypeDef NVIC_InitStructure;
   
4. 
   
5.   /* Configure the NVIC Preemption Priority Bits */  
   
6.    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
   
7.   
   
8.    /* Enable the USART1 Interrupt */
   
9.    NVIC_InitStructure.NVIC_IRQChannel =USART1_IRQn;
   
10.          NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    
11.    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
    
12.    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
13.    NVIC_Init(&NVIC_InitStructure);
    
14.    /* Configure the NVIC Preemption Priority Bits */  
    
15.    //NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    
16. 
    
17.    /* Enable the USART2 Interrupt */
    
18.    NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
    
19.          NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    
20.    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;
    
21.    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
22.    NVIC_Init(&NVIC_InitStructure);
    
23. 
    
24.    /* Enable the USART3 Interrupt */
    
25.    NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
    
26.          NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority =1;
    
27.    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    
28.    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
29.    NVIC_Init(&NVIC_InitStructure);
    
30. 
    
31.       /* Enable the USART3 Interrupt */
    
32.    NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;
    
33.          NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    
34.    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
    
35.    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
36.    NVIC_Init(&NVIC_InitStructure);
    
37. 
    
38.             /* Enable the TIM2 Interrupt */
    
39.            NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
    
40.           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
    
41.            NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    
42.            NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
43.            NVIC_Init(&NVIC_InitStructure);
    
44.                
    
45.           /* Enable the TIM3 Interrupt */
    
46.           NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;
    
47.           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
    
48.            NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    
49.            NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
50.            NVIC_Init(&NVIC_InitStructure);
    
51. 
    
52.     /* Enable the TIM4 Interrupt */
    
53.            NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;
    
54.           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;//1
    
55.            NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    
56.            NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
57.            NVIC_Init(&NVIC_InitStructure);        
    
58. }

复制代码

三、中断处理

1. void USART3_IRQHandler(void)
   
2. {  
   
3.   static u8 TxCounter3;
   
4.         u8 TempChar;
   
5.         uint32_t tempint;
   
6. 
   
7.         static u8 aaai;
   
8.         //RUN_LED_1
   
9.      if (USART_GetFlagStatus(USART3, USART_FLAG_PE) != RESET)
   
10.     {
    
11.         USART_ReceiveData(USART3);
    
12.       USART_ClearFlag(USART3, USART_FLAG_PE);
    
13.     }
    
14.       
    
15.     if (USART_GetFlagStatus(USART3, USART_FLAG_ORE) != RESET)
    
16.     {
    
17.         USART_ReceiveData(USART3);
    
18.       USART_ClearFlag(USART3, USART_FLAG_ORE);
    
19.     }
    
20.      
    
21.      if (USART_GetFlagStatus(USART3, USART_FLAG_FE) != RESET)
    
22.     {
    
23.         USART_ReceiveData(USART3);
    
24.        USART_ClearFlag(USART3, USART_FLAG_FE);
    
25.     }
    
26.           if (USART_GetFlagStatus(USART3, USART_FLAG_LBD) != RESET)
    
27.     {
    
28.        USART_ClearFlag(USART3, USART_FLAG_LBD);
    
29.     }
    
30.         if(USART_GetFlagStatus(USART3,USART_IT_RXNE)==SET)
    
31.         {  
    
32.                   USART_ClearFlag(USART3, USART_FLAG_RXNE);//USART3->SR &= ~USART_FLAG_RXNE;
    
33.       USART_ClearITPendingBit(USART3, USART_IT_RXNE);               
    
34.                         tempint = USART_ReceiveData(USART3);
    
35.                    TempChar = (u8)(tempint&0x00ff);        
    
36.                    *usart_user_3.p_buff = TempChar;
    
37. 
    
38.                   usart_user_3.p_buff++;
    
39.                    usart_user_3.rcv_num++;        
    
40.                
    
41.                    if(usart_user_3.rcv_num >= (BUF_SPACE-1))
    
42.                    {
    
43.                            usart_user_3.p_buff = usart_user_3.buff;
    
44.                           usart_user_3.rcv_num = 0;
    
45.                    }            
    
46.                    usart_user_3.rcv_overtime_add = 0;
    
47.         }
    
48. 
    
49.         
    
50.         if(USART_GetITStatus(USART3, USART_IT_TXE) != RESET)
    
51.                 {   
    
52.                         /* Write one byte to the transmit data register */
    
53.                         USART_SendData(USART3, usart_user_3.send_buff[TxCounter3++]);
    
54. 
    
55.                         if(TxCounter3 == usart_user_3.send_num )
    
56.                         {                                USART_ITConfig(USART3, USART_IT_TXE, DISABLE);
    
57.                                 TxCounter3 = 0;
    
58.                         }
    
59.                 }
    
60. }

复制代码

四、数据处理
中断10ms定时器程序中，定时到80ms，延迟接收结束，处理数据。处理数据不做展开。

问题1.我仿真时就看80ms后的收数据buffer现在200字节，足够大，但是会看到数据前部分就是我发送的数据后面就是接收到的数据。程序得到数据：
发：C2 03 08 33 00 0E 27 52
收：C2 03 08 33 00 0E 27 52 C2 03 1C 00 0C 00 00 00 20 00 00 00 5A 00 8F 00 E8 00 01 00 00 01 61 00 00 00 65 00 52 00 7E 1A A2
正确帧数据应该是
发：C2 03 08 33 00 0E 27 52
收：C2 03 1C 00 0C 00 00 00 20 00 00 00 5A 00 8F 00 E8 00 01 00 00 01 61 00 00 00 65 00 52 00 7E 1A A2
曾以为是硬件问题，但用串口工具收数据，就是看到正确帧数据。说明硬件链路上数据确实正确。
2.是另外一个问题，串口没有开通LIN功能，但是USART_FLAG_ORE会置位，不明白。。。我只能通过清除位来使得串口正常工作，想知道USART_FLAG_ORE置位的原因。

应该是你的 RS485-RE 一直 Enable, 才会收到你的发数据.

我设备上串口数据跑了20多个小时 是正常的（即没有接收到发送数据），后来突然报接收数据错误，我仿真看到 收到数据前面加了发送数据帧。无法确定是硬件原因还是软件原因？如果是由RS485线路上阻抗匹配问题引起（数据线只有几米）不知道怎么确定这个原因？

soh4th 发表于 2020-8-27 14:13
应该是你的 RS485-RE 一直 Enable, 才会收到你的发数据.

RE是在除了发送之外一直是Enable的。

是的，re除了发送数据之外，一直是使能的