stm32f1的串口之间是如何进行通信的

stm32f1串口通信（两串口之间互相通信以及USART_SendData函数的bug）

  简要功能

  串口识别另一串口的内容然后进行相应回应（以“521” “1314”为例）
  主要函数介绍

  （相关串口配置初始化网上代码很多，几乎也都差不多，我在这里也不介绍了，但是需要注意的是串口二的配置串口时钟和GPIOA的时钟不在一条总线上，两串口中断优先级也会有一定的影响。）
  

• 串口中断接受立即发送
  
  

*void USART1_IRQHandler(void)                        //串口1中断服务程序
{
        u8 Res;
        if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //mcu接受数据，接收中断
        {
                Res =USART_ReceiveData(USART1);        //读取通过串口1接收到的数据
                USART_SendData(USART2, Res);     //通过串口1接收到的数据,发送给串口2          
          }                 
}*    
串口二接收发送也是一样 。
需要注意的是 RXNE以及IDLE中断，在RXNE中断中接收串口数据，每次接收一个字节并存至缓存区，而IDLE是直到一帧数据存储完成IDLE置1，产生IDLE中断
*接收一个数据判断条件：
  if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
  *接收一帧数据判断条件：
  *if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET)
也就是说接收到的数据必须是0x0d 0x0a结尾
2.判断接收的内容是否为指定字符串
strstr函数
函数原型 ： strstr(str1,str2)
功能： 函数用于判断字符串str2是否是str1的子串。如果是，则该函数返回str2在str1中首次出现的地址；否则，返回NULL。
strchr函数
函数原型：char *strchr(const char *str, int c)
功能：在参数 str 所指向的字符串中搜索第一次出现字符 c（一个无符号字符）的位置
该函数返回在字符串 str 中第一次出现字符 c 的位置，如果未找到该字符则返回 NULL。
头文件： 两个函数均是 #include
例如判断接收到的CH中有没有“521”，如果有把字符串str2发送给串口一

            **if(strstr((char *)CH,"521"))
            for(t = 0; str2[t] != 0; t++)
            {
                USART_SendData(USART1,str2[t]);
                Delay(300);       //加延时的目的下面会有讲解
            }**


            简单的判断一般这样就可以实现了，检测相应的字符让开发板做出不一样回应是一样的
            例如               
     if(strstr((char *)req_payload, "redled"))                //搜索"redled"
     {
                    if(num == 1)                                                                //控制数据如果为1，代表开
                {
                        Led4_Set(LED_ON);
                }
                else if(num == 0)                                                        //控制数据如果为0，代表关
                {
                        Led4_Set(LED_OFF);
                }
        }


下面粘贴以下比较拙略的代码，想看的可以看一下


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


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


};


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


#if EN_USART1_RX    //如果使能了接收
//串口1中断服务程序
//注意,读取USARTx->SR能避免莫名其妙的错误
u8 USART_RX_BUF[USART_REC_LEN];   //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，        接收完成标志
//bit14，        接收到0x0d
//bit13~0，        接收到的有效字节数目
u16 USART_RX_STA=0,LEN = 0;       //接收状态标记
u8 CH[200];


void uart_init(u32 bound) {
    //GPIO端口设置
    /************************************************************************
            特定设备的中断优先级NVIC的属性包含在结构体NVIC_InitTypeDef中，
            其中字段
            NVIC_IRQChannel包含了设备的中断向量，保存在启动代码中；
            NVIC_IRQChannelPreemptionPriority为主优先级，NVIC_IRQChannelSubPriority为从优先级，
            取值的范围应根据位数划分的情况而定；
            最后NVIC_IRQChannelCmd字段是是否使能，
            一般定位ENABLE。最后通过NVIC_Init()来使能这一中断向量。
    *************************************************************************/
    GPIO_InitTypeDef GPIO_InitStructure;        //GPIO定义
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;


    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1，GPIOA时钟
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);  //使能串口二，IOA
    //USART1_TX   GPIOA.9
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;          //PA.9
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;          //复用推挽输出
    GPIO_Init(GPIOA, &GPIO_InitStructure);            //初始化GPIOA.9


    //USART1_RX          GPIOA.10初始化
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;            //PA10
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    GPIO_Init(GPIOA, &GPIO_InitStructure);               //初始化GPIOA.10


    //USART2_TX   GPIOA.2
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;          //PA.2
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;          //复用推挽输出
    GPIO_Init(GPIOA, &GPIO_InitStructure);            //初始化GPIOA.9


    //USART1_RX          GPIOA.3初始化
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;            //PA3
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    GPIO_Init(GPIOA, &GPIO_InitStructure);               //初始化GPIOA.10


    //Usart1 NVIC 配置
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;        //串口中断
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3   主优先级
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                  //子优先级3      从优先级
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                           //IRQ通道使能   通常为一
    NVIC_Init(&NVIC_InitStructure);                               //根据指定的参数初始化VIC寄存器


    //Usart2 NVIC 配置
    NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;        //串口中断
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0 ;//抢占优先级3   主优先级
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;                  //子优先级3      从优先级
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                           //IRQ通道使能   通常为一
    NVIC_Init(&NVIC_InitStructure);                               //根据指定的参数初始化VIC寄存器


    //USART 初始化设置
    /******************************************************************************


    通过结构体USART_InitTypeDef来确定。UART模式下的字段如下


    USART_BaudRate：波特率，视具体设备而定


    USART_WordLength：字长


    USART_StopBits：停止位


    USART_Parity：校验方式


    USART_HardwareFlowControl：硬件流控制


    USART_Mode：单/双工


    *******************************************************************************/
    USART_InitStructure.USART_BaudRate = bound;               //串口波特率
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    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);    //初始化串口1
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    USART_Cmd(USART1, ENABLE);                    //使能串口1


    USART_Init(USART2, &USART_InitStructure);    //初始化串口2
    USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//开启串口接受中断
    USART_Cmd(USART2, ENABLE);                    //使能串口


}




void USART2_IRQHandler(void) // 串口2中断服务函数
{
    u8 res;


    if(USART_GetITStatus(USART2,USART_IT_RXNE)) // 中断标志
    {
        res = USART_ReceiveData(USART2);
                CH[LEN] = res;
                LEN++;
          USART_SendData(USART2, res);       
    }
}


void USART1_IRQHandler(void)                        //串口1中断服务程序
{
    u8 ch;
    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)//接收到数据产生接收中断(接收到的数据必须是0x0d 0x0a结尾)
    {
        ch = USART_ReceiveData(USART1);        //接受数据
        if((USART_RX_STA&0x8000) == 0)         //正在接受数据
        {
            USART_RX_BUF[USART_RX_STA] = ch;
            USART_RX_STA++;
            if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;       //接收数据错误,重新开始接收
            if(ch == 0x0a)  
                        {
                                USART_RX_STA|=0x8000;          //接收到换行  接受完成
                               
                        }                               
        }
    }
}
main.c
1
#include "stm32f10x.h"
#include "sys.h"
#include "usart.h"
#include
#include


void Delay(u32 count)
{
    u32 i=0;
    for(; i }
int main(void)
{
    u16 t = 0,len = 0;
    char *str1 = "521";
    char *str2 = "1314";
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
    uart_init(115200);              //串口初始化为115200
    while(1)
    {
        if(LEN>=3)      //串口2检测   满足条件发送相应字符串
        {
            if(strstr((char *)CH,"521"))
                for(t = 0; str2[t] != 0; t++)
                {
                    USART_SendData(USART1,str2[t]);
                    Delay(300);
                }
            USART_SendData(USART1,13);
            Delay(300);
            USART_SendData(USART1,10);
            Delay(300);
            while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);
            LEN = 0;
        }
        if((USART_RX_STA&0x8000) != 0)        //串口接受数据完成
        {
            len  = USART_RX_STA&0x3fff;  //得到此次接收到的数据长度
            if(strstr((char *)USART_RX_BUF,str1))
                for(t = 0; str2[t] != 0; t++)
                {


                    USART_SendData(USART2,str2[t]);
                    Delay(300);
                }
            USART_SendData(USART2,13);
            Delay(300);
            USART_SendData(USART2,10);
            Delay(300);
            while(USART_GetFlagStatus(USART2,USART_FLAG_TC)!=SET);


            for(t=0; t < len; t++)
            {


                USART_SendData(USART1, USART_RX_BUF[t]);//向串口1发送数据
                while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET);//等待发送结束
            }
            USART_RX_STA=0;  //清空接受数据标志
        }
    }
}


   USART_SendData 函数注意事项
细心的会发现每次用USART_SendData函数发送完后都会加一段延时
这是因为函数体内部没有一个判断一个字符是否发送完毕的语句，数据直接放入发送缓冲区，当连续发送数据时，导致发送缓冲区的数据溢出老的数据还未及时发送出去，新的数据又把发送缓冲区的老数据覆盖了。
解决办法：
  

• 修改USART_SendData函数加上
  while(USART_GetFlagStatus(USARTx, USART_FLAG_TXE) == RESET)；判断条件
  2.加延时（具体时间和波特率有关）