[STM32]利用串口实现F1 F4双机通信问题

stm32双机通信 F4 F1串口通信

star_vi

4668人浏览 · 2023-01-14 12:22:35

star_vi · 2023-01-14 12:22:35 发布

一、串口通信电平介绍

TTL电平通信

TTL电平通信时，直接将单片机A的TXD端接单片机B的RXD端，单片机A的RXD端接单片机B的TXD端。需要强调的是，两个单片机系统必须要共地！！！即把它们的系统电源地线要连接在一起，这是常犯错误的地方。

数据在传输时必须要有一个回路，单片机A的高电平相对于系统A有一个固定电压值,单片机B的高电平相对于系统B有一一个固定电压值，但若两个系统不共地，单片机A的高电平相对于系统B的地来说就不知道是什么电压值了，同样单片机B的高电平相对系统A的地来说也不知道是什么电压值了，只有共地线的情况下，它们的高低电平才可统一地被系统识别。

图1.1 接线方式

二、常见问题总结

两个单片机间一定要共地

两单片机通信波特率完全一致，否则接受不到正确的信息

如果没通信成功，用USB转TTL连接电脑上位机和单片机串口，分别测试发送端与接收端代码是否正常，检查哪端出现问题

三、代码实现

功能描述：

(条件选择型：根据发的值不同，进不同判断条件)

这是我在以前项目中截取的代码，重新改了一下。原来项目里发送端发数据放在主函数里，直接用printf发。(这里我把它拿出来放在usart里封装成了一个函数，在主函数调用)

主要功能：通过一个单片机的按键控制另一个单片机点亮相应的灯。这里接了6个LED、6个按键。

发送端代码(F4)

usart.c


#include "sys.h"
#include "usart.h"
#include "key.h"
u8 key=0;
//如果使用ucos,则包括下面的头文件即可.
#if SYSTEM_SUPPORT_OS
#include "includes.h"                    //ucos 使用      
#endif

//
//加入以下代码,支持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)
{     
    while((USART1->SR&0X40)==0);//循环发送,直到发送完毕   
    USART1->DR = (u8) ch;      
    return ch;
}
#endif
 
//串口1中断服务程序
//注意,读取USARTx->SR能避免莫名其妙的错误       
u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，    接收完成标志
//bit14，    接收到0x0d
//bit13~0，    接收到的有效字节数目
u16 USART_RX_STA=0;       //接收状态标记    

//初始化IO 串口1 
//bound:波特率
//收发都有 
void uart_init(u32 bound)
    {
   //GPIO端口设置
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;
    
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE); //使能GPIOA时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);//使能USART1时钟
 
    //串口1对应引脚复用映射
    GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_USART1); //GPIOA9复用为USART1
    GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_USART1); //GPIOA10复用为USART1
    
    //USART1端口配置
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9 | GPIO_Pin_10; //GPIOA9与GPIOA10
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//复用功能
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;    //速度50MHz
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //推挽复用输出
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; //上拉
    GPIO_Init(GPIOA,&GPIO_InitStructure); //初始化PA9，PA10

   //USART1 初始化设置
    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 

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

    
}
//按下不同按键对应发送不同数值 这里我使用printf发字符型数据
void send_data()
{
    key=key_scan();//按键扫描 在key.c里
    if(key==KEY1_PRES)        {printf("%c\n",'1');}
    if(key==KEY2_PRES)        {printf("%c\n",'2');}    
    if(key==KEY3_PRES)        {printf("%c\n",'3');}    
    if(key==KEY4_PRES)        {printf("%c\n",'4');}    
    if(key==KEY5_PRES)        {printf("%c\n",'5');}    
    if(key==KEY6_PRES)        {printf("%c\n",'6');}   
}

usart.h


#ifndef __USART_H
#define __USART_H
#include "stdio.h"    
#include "stm32f4xx_conf.h"

#define USART_REC_LEN              200      
#define EN_USART1_RX             1        
          
extern u8  USART_RX_BUF[USART_REC_LEN];  
extern u16 USART_RX_STA;                 
void uart_init(u32 bound);
#endif

补key


#include "key.h"
#include "delay.h" 
void KEY_Init(void)
{
    
    GPIO_InitTypeDef  GPIO_InitStructure;
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE);//Ê¹ÄÜGPIOA,GPIOEÊ±ÖÓ
 
  GPIO_InitStructure.GPIO_Pin =GPIO_Pin_2|GPIO_Pin_4| GPIO_Pin_6|GPIO_Pin_8; //KEY0 KEY1 
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100M
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_Init(GPIOG, &GPIO_InitStructure);
    
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7|GPIO_Pin_9; 
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;//100M
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_Init(GPIOC, &GPIO_InitStructure);
} 

u8 key_scan()
{
    if(KEY1==0)
    {
        delay_ms(10);
        if(KEY1==0)return 1;
    }
    else if(KEY2==0)
    {
        delay_ms(10);
        if(KEY2==0)return 2;
    }
    else if(KEY3==0)
    {
        delay_ms(10);
        if(KEY3==0)return 3;
    }
    else if(KEY4==0)
    {
        delay_ms(10);
        if(KEY4==0)return 4;
    }
    else if(KEY5==0)
    {
        delay_ms(10);
        if(KEY5==0)return 5;
    }
    else if(KEY6==0)
    {
        delay_ms(10);
        if(KEY6==0)return 6;
    }
    else return 0;
}



#ifndef __KEY_H
#define __KEY_H     
#include "sys.h" 

#define KEY1         GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_9)    //PE3 
#define KEY2         GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_7)    //PE3 
#define KEY3         GPIO_ReadInputDataBit(GPIOG,GPIO_Pin_8)    //PE3 
#define KEY4         GPIO_ReadInputDataBit(GPIOG,GPIO_Pin_6)    //PE3 
#define KEY5         GPIO_ReadInputDataBit(GPIOG,GPIO_Pin_2)    //PE3 
#define KEY6         GPIO_ReadInputDataBit(GPIOG,GPIO_Pin_4)    //PE3 

#define KEY1_PRES    1
#define KEY2_PRES    2
#define KEY3_PRES    3
#define KEY4_PRES    4
#define KEY5_PRES    5
#define KEY6_PRES    6

void KEY_Init(void);    
u8 key_scan();
#endif

接收端代码(F1)

usart.c

如果发送字符串：可以用if选择语句和strcmp()选择条件，如：


#include "sys.h"
#include "usart.h"      
//      
//如果使用ucos,则包括下面的头文件即可.
#if SYSTEM_SUPPORT_OS
#include "includes.h"                    //ucos 使用      
#endif

//
//加入以下代码,支持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)
{      
    while((USART1->SR&0X40)==0);//循环发送,直到发送完毕   
    USART1->DR = (u8) ch;      
    return ch;
}
#endif 

/*使用microLib的方法*/
 /* 
int fputc(int ch, FILE *f)
{
    USART_SendData(USART1, (uint8_t) ch);

    while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET) {}    
   
    return ch;
}
int GetKey (void)  { 

    while (!(USART1->SR & USART_FLAG_RXNE));

    return ((int)(USART1->DR & 0x1FF));
}
*/
 
#if EN_USART3_RX   //如果使能了接收
//串口1中断服务程序
//注意,读取USARTx->SR能避免莫名其妙的错误       
u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，    接收完成标志
//bit14，    接收到0x0d
//bit13~0，    接收到的有效字节数目
u16 USART_RX_STA=0;       //接收状态标记      
  
void uart3_init(u32 bound)
{
    //GPIO端口设置
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);    //使能USART1，GPIOA时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);    //使能USART1，GPIOA时钟

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

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

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

    //USART 初始化设置

    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(USART3, &USART_InitStructure); //初始化串口1
  USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);//开启串口接受中断
  USART_Cmd(USART3, ENABLE);                    //使能串口1 

}

void USART3_IRQHandler(void)                    //串口1中断服务程序
{
    u8 Res;
    if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
    {
        Res =USART_ReceiveData(USART3);    //读取接收到的数据
            switch(Res)
        {
            case '1':LED1=0;break;
            case '2':LED2=0;break;
            case '3':LED3=0;break;
            case '4':LED4=0;break;
            case '5':LED5=0;break;
            case '6':LED6=0;break;
         }                
     } 
USART_RX_STA=0;
} 
#endif

usart.h


#ifndef __USART_H
#define __USART_H
#include "stdio.h"    
#include "sys.h" 
#include "led.h"
#include "carconfig.h"
#define USART_REC_LEN              200      //定义最大接收字节数 200
#define EN_USART3_RX             1        //使能（1）/禁止（0）串口1接收
          
extern u8  USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符 
extern u16 USART_RX_STA;                 //接收状态标记    
//如果想串口中断接收，请不要注释以下宏定义
void uart3_init(u32 bound);

#endif

(读取数值型：我们常会用到单片机从传感器或其它模块获取数据，通过串口发生送到另一单片机上)

发送端：

功能描述：发送算出的Frequency数据(整型变量)

思路：获取到的数据为整数或浮点数，我们把它转成字符串，调用sprintf()函数，如：


sprintf(str,"%d",Frequency);//Frequency为int类型的变量

sprintf指的是字符串格式化命令，主要功能是把格式化的数据写入某个字符串中，即发送格式化数据输出到 string 所指向的字符串。
//把整数123 打印成一个字符串保存在s 中。
　　sprintf(s, "%d", 123); //产生"123"
　　可以指定宽度，不足的左边补空格：
　　sprintf(s, "%8d%8d", 123, 4567); //产生：" 123 4567"
　　

然后利用Usart_SendString( USART_TypeDef * pUSARTx, char *str)发送字符串即可。


 sprintf(str,"%d",Frequency/2);
 Usart_SendString(USART1, strcat(str,"\r\n"));//字符串连同\r\n一起发送

接收端

功能描述：接收数据，显示到屏幕上(LCD/OLED)

思路：收到的数据存在接收缓冲USART_RX_BUF[USART_REC_LEN]中，通过遍历数组，可对每一位字符操作。 len=USART_RX_STA&0x3fff可以得到此次接收到的数据长度，作为循环判断条件。

如何把字符数据解析为我们要的Frequency整数,供后续对其值操作？

遍历，每次进行x=x*10+USART_RX_BUF[t]-48 操作即可恢复整数。(字符型数字以ASCII码形式和整数差了48) 注意：x初始值为0.

后续程序若有需要对x操作即可。

如果仅仅想显示数据是否正确，可以直接用LCD_ShowString(u16 x,u16 y,u16 width,u16 height,u8 size,u8 *p)打出来，USART_RX_BUF作为*p.


     int fre_rec=0;
   
     if(USART_RX_STA&0x8000)   //接收完成
        {                       
           len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
            for(t=0;t<len;t++)
            {
                fre_rec=10*fre_rec+USART_RX_BUF[t]-48;
            }
                   
            USART_RX_STA=0;//清除接收标志位
            LCD_ShowString(55,5,200,16,16,USART_RX_BUF);
        }