ESP-01S串口发AT指令模块无返回OK

徐广辉

     大佬们，我用32F103C8T6连接ESP-01S编程，用串口2发送AT指令，串口1显示返回值，单独试过两个串口接收发送正常，用TTL转USB直接接模块，用安可信的串口助手发送AT指令可以正常收到回复，但是用单片机连接模块后串口2发送AT+RST正常接收返回的数据，但是其他的AT指令只收到回车换行，实在想不出哪里的问题，请大佬们教教我


#include "main.h"

/**
  * @brief  主函数
  * @param  无
  * @retval 无
  */
       
int main(void)
{       
        u8 len,t;
        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置系统中断优先级分组2
        delay_init();
        usart1_init();
        usart2_init();
        //usart2_SendString("\r\n串口2您发送的消息为:\r\n");
        usart_SendString("串口2您发送的消息为:\r\n");

        usart2_SendString("AT+RST\r\n");
        //printf("其他数据：%s",USART2_RX_BUF);
        //delay_ms(100);

       
while(1)
{
        if(USART2_RX_STA&0x8000)
                {                                          
                        len=USART2_RX_STA&0x3fff;//得到此次接收到的数据长度
                        //printf("数据为:%s\r\n",USART2_RX_BUF);
                        usart_SendString("\r\n接受到的消息为:\r\n");
                       
                        for(t=0;t<len;t++)
                        {
                                //usart_SendString("1111\r\n");
                                USART_SendData(USART1, USART2_RX_BUF[t]);         //向串口1发送数据
                                while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
                        }
                        USART2_RX_STA=0;
                       
                }
        }
               
}



串口的初始化函数

#include "main.h"

u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
u8 USART2_RX_BUF[USART2_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.

u16 USART_RX_STA=0;
u16 USART2_RX_STA=0;

void usart1_init(void)
{
        USART_InitTypeDef USART_InitStructure;
        GPIO_InitTypeDef GPIO_InitStructure;
        NVIC_InitTypeDef  NVIC_InitStructure;
       
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);

        GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_9;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                 //复用推挽输出
        GPIO_Init(GPIOA, &GPIO_InitStructure);

        GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_10;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  //浮空输入
        GPIO_Init(GPIOA, &GPIO_InitStructure);

        USART_InitStructure.USART_BaudRate = 115200;
        USART_InitStructure.USART_WordLength = USART_WordLength_8b;
        USART_InitStructure.USART_StopBits = USART_StopBits_1;
        USART_InitStructure.USART_Parity = USART_Parity_No;
        USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
        USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
        USART_Init(USART1,&USART_InitStructure);

        USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);  //开启接收中断
        USART_Cmd(USART1,ENABLE);        //串口1使能


        NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
        NVIC_Init(&NVIC_InitStructure);       
}

void usart2_init(void)
{
        USART_InitTypeDef USART_InitStructure;
        GPIO_InitTypeDef GPIO_InitStructure;
        NVIC_InitTypeDef  NVIC_InitStructure;
       
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

        GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_2;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                 //复用推挽输出
        GPIO_Init(GPIOA, &GPIO_InitStructure);

        GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_3;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  //浮空输入
        GPIO_Init(GPIOA, &GPIO_InitStructure);

        USART_InitStructure.USART_BaudRate = 115200;
        USART_InitStructure.USART_WordLength = USART_WordLength_8b;
        USART_InitStructure.USART_StopBits = USART_StopBits_1;
        USART_InitStructure.USART_Parity = USART_Parity_No;
        USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
        USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
        USART_Init(USART2,&USART_InitStructure);

        USART_ITConfig(USART2,USART_IT_RXNE,ENABLE);  //开启接收中断
        USART_Cmd(USART2,ENABLE);        //串口2使能


        NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
        NVIC_Init(&NVIC_InitStructure);       
}

int fputc(int ch, FILE *f)
{
   USART_SendData(USART1, (u8) ch);
   while(!(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == SET))
   {
   }
   return ch;
}
int fgetc(FILE *f)
{
   while(!(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == SET))
   {
   }  
   return (USART_ReceiveData(USART1));
}


//接收字符串
void USART1_IRQHandler(void)
{
        u8 Res;
        if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
                {
                Res =USART_ReceiveData(USART1);        //读取接收到的数据
               
                if((USART_RX_STA&0x8000)==0)//接收未完成
                        {
                        if(USART_RX_STA&0x4000)//接收到了0x0d
                                {
                                if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
                                else USART_RX_STA|=0x8000;        //接收完成了
                                }
                        else //还没收到0X0D
                                {       
                                if(Res==0x0d)USART_RX_STA|=0x4000;
                                else
                                        {
                                        USART_RX_BUF[USART_RX_STA&0X3FFF]=Res;
                                        USART_RX_STA++;
                                        if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收          
                                        }                 
                                }
                        }                    
    }
}


void USART2_IRQHandler(void)
{
        u8 Res;
        if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
                {
                Res =USART_ReceiveData(USART2);        //读取接收到的数据
               
                if((USART2_RX_STA&0x8000)==0)//接收未完成
                        {
                        if(USART2_RX_STA&0x4000)//接收到了0x0d
                                {
                                if(Res!=0x0a)USART2_RX_STA=0;//接收错误,重新开始
                                else USART2_RX_STA|=0x8000;        //接收完成了
                                }
                        else //还没收到0X0D
                                {       
                                if(Res==0x0d)USART2_RX_STA|=0x4000;
                                else
                                        {
                                        USART2_RX_BUF[USART2_RX_STA&0X3FFF]=Res;
                                        USART2_RX_STA++;
                                        if(USART2_RX_STA>(USART2_REC_LEN-1))USART2_RX_STA=0;//接收数据错误,重新开始接收          
                                        }                 
                                }
                        }                    
    }
}

//串口1发送字符串
void usart_SendString(char *str)
{       
        u8 index=0;
        do       
        {
                USART_SendData(USART1,str[index]);
                while(USART_GetFlagStatus(USART1,USART_FLAG_TXE)==RESET);
                index++;
        }while(str[index]!=0);
}

//串口2发送字符串
void usart2_SendString(char *str)
{       
        u8 index=0;
        do       
        {
                USART_SendData(USART2,str[index]);
                while(USART_GetFlagStatus(USART2,USART_FLAG_TXE)==RESET);
                index++;
        }while(str[index]!=0);
}

//发送len个字节.
//buf:发送区首地址
//len:发送的字节数(为了和本代码的接收匹配,这里建议不要超过64个字节)
void Usart2_Send_CMD(u8 *buf, u16 len)
{
        u16 t;
       
  for(t=0;t<len;t++)                //循环发送数据
        {                  
                while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);          
                USART_SendData(USART2,buf[t]);
        }         
        while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);               
}

//发送len个字节.
//buf:发送区首地址
//len:发送的字节数(为了和本代码的接收匹配,这里建议不要超过64个字节)
void Usart1_Send_Cmd(u8 *buf, u16 len)
{
        u16 t;
       
  for(t=0;t<len;t++)                //循环发送数据
        {                  
                while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);          
                USART_SendData(USART1,buf[t]);
        }         
        while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET);               
}

WZTENG

顶一顶

login_FAE

可以参考我们ESP8266的程序