STM32F103 USART2做RS485通信只能发送，不能接收是什么原因呢？

shengxiaozhu

   PA1是485的控制脚



#include "sys.h"
#include "usart.h"        



int USART_PRINTF_FLAG = 2;//默认串口2

//////////////////////////////////////////////////////////////////
//加入以下代码,支持printf函数,而不需要选择use MicroLIB         
#if  1
#pragma import(__use_no_semihosting)            
//标准库需要的支持函数                 
struct __FILE
{
        int handle;

};

FILE __stdout;      
//定义_sys_exit()以避免使用半主机模式   
void _sys_exit(int x)
{
        x = x;
}
//重定义fputc函数
int fputc(int ch, FILE *f)
{      
        
         if(USART_PRINTF_FLAG==2)
         {
            while((USART2->SR&0X40)==0);//循环发送,直到发送完毕   
      USART2->DR = (u8) ch;
         }  else  if(USART_PRINTF_FLAG==1)
         {
            while((USART1->SR&0X40)==0);//循环发送,直到发送完毕   
      USART1->DR = (u8) ch;
         }
         
        return ch;
}
#endif


//串口1中断服务程序
//注意,读取USARTx->SR能避免莫名其妙的错误           
u8 USART1_RX_BUF[USART1_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
u8 USART1_TX_BUF[USART1_REC_LEN];     //发送缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，        接收完成标志
//bit14，        接收到0x0d
//bit13~0，        接收到的有效字节数目
u16 USART1_RX_STA=0;       //接收状态标记         

u8 aRxBuffer1[RXBUFFERSIZE];//HAL库使用的串口接收缓冲
UART_HandleTypeDef UART1_Handler; //UART句柄




//串口2中断服务程序
//注意,读取USARTx->SR能避免莫名其妙的错误           
u8 USART2_RX_BUF[USART2_REC_LEN];      //接收缓冲,最大USART2_REC_LEN个字节.
u8 USART2_TX_BUF[USART2_REC_LEN];      //发送缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，        接收完成标志
//bit14，        接收到0x0d
//bit13~0，        接收到的有效字节数目
u16 USART2_RX_STA=0;       //接收状态标记         

u8 aRxBuffer2[RXBUFFERSIZE];//HAL库使用的串口接收缓冲
UART_HandleTypeDef UART2_Handler; //UART句柄




//初始化IO 串口1
//bound:波特率
void uart_init1(u32 bound)
{        
        //UART 初始化设置
        UART1_Handler.Instance=USART1;                                            //USART1
        UART1_Handler.Init.BaudRate=bound;                                    //波特率
        UART1_Handler.Init.WordLength=UART_WORDLENGTH_8B;   //字长为8位数据格式
        UART1_Handler.Init.StopBits=UART_STOPBITS_1;            //一个停止位
        UART1_Handler.Init.Parity=UART_PARITY_NONE;                    //无奇偶校验位
        UART1_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE;   //无硬件流控
        UART1_Handler.Init.Mode=UART_MODE_TX_RX;                    //收发模式
        HAL_UART_Init(&UART1_Handler);                                            //HAL_UART_Init()会使能UART1
        
        HAL_UART_Receive_IT(&UART1_Handler, (u8 *)aRxBuffer1, RXBUFFERSIZE);//该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量

}


//初始化IO 串口2
//bound:波特率
void uart_init2(u32 bound)
{        
        //UART 初始化设置
        UART2_Handler.Instance=USART2;                                            //USART1
        UART2_Handler.Init.BaudRate=bound;                                    //波特率
        UART2_Handler.Init.WordLength=UART_WORDLENGTH_8B;   //字长为8位数据格式
        UART2_Handler.Init.StopBits=UART_STOPBITS_1;            //一个停止位
        UART2_Handler.Init.Parity=UART_PARITY_NONE;                    //无奇偶校验位
        UART2_Handler.Init.HwFlowCtl=UART_HWCONTROL_NONE;   //无硬件流控
        UART2_Handler.Init.Mode=UART_MODE_TX_RX;                    //收发模式
        HAL_UART_Init(&UART2_Handler);                                            //HAL_UART_Init()会使能UART1
        
        HAL_UART_Receive_IT(&UART2_Handler, (u8 *)aRxBuffer2, RXBUFFERSIZE);//该函数会开启接收中断：标志位UART_IT_RXNE，并且设置接收缓冲以及接收缓冲接收最大数据量

}

//UART底层初始化，时钟使能，引脚配置，中断配置
//此函数会被HAL_UART_Init()调用
//huart:串口句柄

void HAL_UART_MspInit(UART_HandleTypeDef *huart)
{
        
         if(huart->Instance==USART1)//如果是串口1，进行串口1 MSP初始化
        {
                 GPIO_InitTypeDef GPIO_Initure;
               
                __HAL_RCC_GPIOA_CLK_ENABLE();                          //使能GPIOA时钟
                __HAL_RCC_USART1_CLK_ENABLE();                        //使能USART2时钟
                __HAL_RCC_AFIO_CLK_ENABLE();
               
               
                GPIO_Initure.Pin=GPIO_PIN_9;                        //PA9
                GPIO_Initure.Mode=GPIO_MODE_AF_PP;                //复用推挽输出
                GPIO_Initure.Pull=GPIO_PULLUP;                        //上拉
                GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//高速
                HAL_GPIO_Init(GPIOA,&GPIO_Initure);                   //初始化PA9

                GPIO_Initure.Pin=GPIO_PIN_10;                        //PA10
                GPIO_Initure.Mode=GPIO_MODE_AF_INPUT;        //模式要设置为复用输入模式！        
                HAL_GPIO_Init(GPIOA,&GPIO_Initure);                   //初始化PA10
               

                HAL_NVIC_EnableIRQ(USART1_IRQn);                                //使能USART1中断通道
                HAL_NVIC_SetPriority(USART1_IRQn,3,3);                        //抢占优先级3，子优先级3
        
        }
        
        
        
        if(huart->Instance==USART2)//如果是串口2，进行串口2 MSP初始化
        {
                //GPIO端口设置
                GPIO_InitTypeDef GPIO_Initure;
               
                __HAL_RCC_GPIOA_CLK_ENABLE();                          //使能GPIOA时钟
                __HAL_RCC_USART2_CLK_ENABLE();                        //使能USART2时钟
                __HAL_RCC_AFIO_CLK_ENABLE();
           
               
                GPIO_Initure.Pin=GPIO_PIN_2;                        //PA2
                GPIO_Initure.Mode=GPIO_MODE_AF_PP;                //复用推挽输出
                GPIO_Initure.Pull=GPIO_PULLUP;                        //上拉
                GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//高速
                HAL_GPIO_Init(GPIOA,&GPIO_Initure);                   //初始化PA9
                          
               
                GPIO_Initure.Pin=GPIO_PIN_3;                        //PA3
                GPIO_Initure.Mode=GPIO_MODE_AF_INPUT;        //模式要设置为复用输入模式！        
                GPIO_Initure.Pull=GPIO_PULLUP;                        //上拉
                GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//高速
                HAL_GPIO_Init(GPIOA,&GPIO_Initure);                   //初始化PA10
               
               
                //485控制脚  0：收，1：发
                 GPIO_Initure.Pin=GPIO_PIN_1;                        //PA1
                GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP;                //复用推挽输出
                GPIO_Initure.Pull=GPIO_PULLUP;                        //-----不需要上拉（因为电路图里有外部上拉电阻）
                GPIO_Initure.Speed=GPIO_SPEED_FREQ_HIGH;//高速
                HAL_GPIO_Init(GPIOA,&GPIO_Initure);                   //初始化PA1               
                USART2_485_RX_ON();       //PA1  写0
               
                                    
                HAL_NVIC_EnableIRQ(USART2_IRQn);                                //使能USART2中断通道
                HAL_NVIC_SetPriority(USART2_IRQn,3,3);                        //抢占优先级3，子优先级3
                                
        }
        
        
}

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
        
        if(huart->Instance==USART1)//如果是串口1
        {
                if((USART1_RX_STA&0x8000)==0)//接收未完成
                {
                        if(USART1_RX_STA&0x4000)//接收到了0x0d
                        {
                                if(aRxBuffer1[0]!=0x0a)USART1_RX_STA=0;//接收错误,重新开始
                                else USART1_RX_STA|=0x8000;        //接收完成了
                        }
                        else //还没收到0X0D
                        {        
                                if(aRxBuffer1[0]==0x0d)USART1_RX_STA|=0x4000;
                                else
                                {
                                        USART1_RX_BUF[USART1_RX_STA&0X3FFF]=aRxBuffer1[0] ;
                                        USART1_RX_STA++;
                                        if(USART1_RX_STA>(USART1_REC_LEN-1))USART1_RX_STA=0;//接收数据错误,重新开始接收         
                                }                 
                        }
                }

        }
        
        
        
        if(huart->Instance==USART2)//如果是串口2
        {   
                if((USART2_RX_STA&0x8000)==0)//接收未完成
                {      
                        if(USART2_RX_STA&0x4000)//接收到了0x0d
                        {   
                                if(aRxBuffer2[0]!=0x0a)USART2_RX_STA=0;//接收错误,重新开始
                                else USART2_RX_STA|=0x8000;        //接收完成了
                        }
                        else //还没收到0X0D
                        {        
               
                                if(aRxBuffer2[0]==0x0d)USART2_RX_STA|=0x4000;
                                else
                                {     
                                        USART2_RX_BUF[USART2_RX_STA&0X3FFF]=aRxBuffer2[0] ;
                                        USART2_RX_STA++;
                                        if(USART2_RX_STA>(USART2_REC_LEN-1))USART2_RX_STA=0;//接收数据错误,重新开始接收         
                                }                 
                        }
                }

        }
}


//串口1中断服务程序
void USART1_IRQHandler(void)                        
{
        u32 timeout=0;

        
        HAL_UART_IRQHandler(&UART1_Handler);        //调用HAL库中断处理公用函数
        
        timeout=0;
    while (HAL_UART_GetState(&UART1_Handler) != HAL_UART_STATE_READY)//等待就绪
        {
         timeout++;////超时处理
     if(timeout>HAL_MAX_DELAY) break;               
        
        }

        timeout=0;
        
        while(HAL_UART_Receive_IT(&UART1_Handler, (u8 *)aRxBuffer1, RXBUFFERSIZE) != HAL_OK)//一次处理完成之后，重新开启中断并设置RxXferCount为1
        {
         timeout++; //超时处理
         if(timeout>HAL_MAX_DELAY) break;        
        }

}


//串口2中断服务程序
void USART2_IRQHandler(void)                        
{
        u32 timeout=0;

        
        
        HAL_UART_IRQHandler(&UART2_Handler);        //调用HAL库中断处理公用函数
        
        timeout=0;
    while (HAL_UART_GetState(&UART2_Handler) != HAL_UART_STATE_READY)//等待就绪
        {
         timeout++;////超时处理
     if(timeout>HAL_MAX_DELAY) break;               
        
        }

        timeout=0;
        while(HAL_UART_Receive_IT(&UART2_Handler, (u8 *)aRxBuffer2, RXBUFFERSIZE) != HAL_OK)//一次处理完成之后，重新开启中断并设置RxXferCount为1
        {
         timeout++; //超时处理
         if(timeout>HAL_MAX_DELAY) break;        
        }
         

}

int main(void)
{
                           
    HAL_Init();                            //初始化HAL库   
    Stm32_Clock_Init(RCC_PLL_MUL6); //设置时钟,72M
    delay_init(72);                 //初始化延时函数
    uart_init1(115200);                                                  //初始化串口1   115200
    uart_init2(115200);                                                        //初始化串口2   115200



             u8 len;        
        u16 times=0;  

                while(1)
        {   
     if(USART2_RX_STA&0x8000)
                {                                          
                        len=USART2_RX_STA&0x3fff;//得到此次接收到的数据长度        
                        HAL_UART_Transmit(&UART2_Handler,(uint8_t*)USART2_RX_BUF,len,1000);        //发送接收到的数据
                        while(__HAL_UART_GET_FLAG(&UART2_Handler,UART_FLAG_TC)!=RESET);                //等待发送结束        
                        USART2_RX_STA=0;
                }else
                {
                        times++;        
                        delay_ms(10);   
                }
                  
                        
        }

}




   这个是什么原因呢？

xia_yangchun

这电路设计的，有点意思，你用的是RS485，是半双工，收发需要通过PA1来控制的，低电平时接收模式，高电平时发送模式，你这PA1直接就拉高了，好像没看到对PA1的控制，需要改为发送前把PA1拉高，发送完吧PA1拉低，你这硬件电路也有意思，人家都是把PA1下拉电阻到地，即默认时接收模式，需要发送的时候才拉高，你这电路设计的默认时上拉电阻，默认时发送模式，要知道RS485更多的时候处于监听接收模式。