精华内容
下载资源
问答
  • USART

    千次阅读 2017-11-07 15:24:15
    USART初始化结构体typedef struct{ uint32_t USART_BaudRate;//波特率 uint32_t USART_WordLength;//字长 uint32_t USART_StopBits;//停止位 uint32_t USART_Parity;//校验位 uint32_t USART_Mode;//USART模式 ...

    USART初始化结构体

    typedef struct{
        uint32_t USART_BaudRate;//波特率
        uint32_t USART_WordLength;//字长
        uint32_t USART_StopBits;//停止位
        uint32_t USART_Parity;//校验位
        uint32_t USART_Mode;//USART模式
        uint32_t USART_HardwareFlowControl;//硬件流控制
    }USART_InitTypeDef

    1) USART_BaudRate:波特率设置。一般设置为 2400、 9600、 19200、 115200。标准库函数会根据设定值计算得到 USARTDIV值, 从而设置 USART_BRR 寄存器值。

    2) USART_WordLength:数据帧字长,可选 8位或 9位。它设定 USART_CR1寄存器的 M 位的值。如果没有使能奇偶校验控制,一般使用 8 数据位;如果使能了奇偶
    校验则一般设置为 9 数据位。

    3) USART_StopBits:停止位设置,可选 0.5 个、 1 个、 1.5 个和 2 个停止位,它设定USART_CR2 寄存器的 STOP[1:0]位的值,一般我们选择 1 个停止位。

    4) USART_Parity : 奇 偶 校 验 控 制 选 择 , 可 选 USART_Parity_No( 无 校 验 ) 、USART_Parity_Even( 偶 校 验 ) 以 及 USART_Parity_Odd( 奇 校 验 ) , 它 设 定
    USART_CR1 寄存器的 PCE 位和 PS 位的值。

    5) USART_Mode: USART模式选择,有 USART_Mode_Rx,USART_Mode_Tx,允许使用逻辑或运算选择两个,它设定 USART_CR1 寄存器的 RE 位和 TE 位。

    6) USART_HardwareFlowControl:硬件流控制选择,只有在硬件流控制模式才有效,可选有⑴使能 RTS、 ⑵使能 CTS、 ⑶同时使能 RTS 和 CTS、 ⑷不使能硬件流。当使用同步模式时需要配置 SCLK 引脚输出脉冲的属性, 标准库使用一个时钟初始化结构体 USART_ClockInitTypeDef 来设置, 该结构体内容也只有在同步模式才需要设置。

    USART时钟初始化结构体
    typedef struct{
    uint16_t USART_Clock;//时钟使能控制
    uint16_t USART_CPOL;//时钟极性
    uint16_t USART_CPHA;//时钟相位
    uint16_t USART_LastBit;//最尾为时钟脉冲
    }USART_ClockInitTypeDef;

    展开全文
  • USART通讯介绍

    2020-06-12 22:51:48
    USART

    1.USART介绍

    USART是串口通讯,常用于设备之间的通讯,电平标准有两种,TTL和RS232:使用两条通讯线:RX和TX
    在这里插入图片描述

    2.STM32支持通讯引脚

    在这里插入图片描述

    3.硬件电路

    在这里插入图片描述

    4.软件设计

    4.1. USART1的GPIO口配置
    PA9发送信号配置成复用推挽输出
    PA10接收信号配置成浮空输入
    使能信号随便找个GPIO口,配置成推挽输出

    void RS1_GPIO_Config(void)
    {
        GPIO_InitTypeDef GPIO_InitStructure;
    
        //¿ªÆôRS485  GPIO¶Ë¿ÚʱÖÓ
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, 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);
    
        GPIO_InitStructure.GPIO_Pin = RS1_GPIO_RE_PIN;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;//ÍÆÍìÊä³ö
        GPIO_Init(GPIOA, &GPIO_InitStructure);
    }
    
    

    4.2 USART1的初始化配置
    打开USART1口时钟
    波特率设置:可选为400、9600、19200、115200,波特率越高,输出速度越快
    数据位:8位或9位(使用奇偶校验数据位是9位,不适用则为8位)
    停止位:可选0.5,1,1.5, 2
    奇偶检验:可选无校验,奇校验,偶校验,无校验
    模式:发送和接收
    硬件流控制:有四种:
    USART_HardwareFlowControl_None
    硬件流控制失能
    USART_HardwareFlowControl_RTS
    发送请求RTS使能
    USART_HardwareFlowControl_CTS
    清除发送CTS使能
    USART_HardwareFlowControl_RTS_CTS
    RTS和CTS使能

    void RS1_USART_Config(void)
    {
        USART_InitTypeDef USART_InitStruct;
    
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); //¿ªÆô´®¿Ú1 ÍâÉèʱÖÓ
      
        USART_InitStruct.USART_BaudRate = 19200;
        USART_InitStruct.USART_WordLength = USART_WordLength_8b;
        USART_InitStruct.USART_StopBits = USART_StopBits_1;
        USART_InitStruct.USART_Parity = USART_Parity_No ;
        USART_InitStruct.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
        USART_InitStruct.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
        USART_Init(USART1, &USART_InitStruct);
    }
    

    3.USART1的NVIC中断配置
    中断通道使用哪个USART就配置哪个

    static void NVIC_Config(void)
    {
        NVIC_InitTypeDef NVIC_InitStructure;
    
        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
    
        NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;		//ÉèÖÃÖжÏͨµÀ
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;	//ÉèÖÃÇÀÕ¼ÓÅÏȼ¶
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;			//ÉèÖôÎÓÅÏȼ¶
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
        NVIC_Init(&NVIC_InitStructure);
    }
    
    

    4.USART1发送一个字节数据
    打开发送使能接口
    调用 USART_SendData(pUSARTx, ch);发送一个字节数据
    等待发送数据寄存器为空
    关闭发送使能接口

    void RS1_SendByte(USART_TypeDef* pUSARTx, uint16_t ch)
    {
        Delay(10000);
        RS1_TX_EN();
    	 // Delay(10000);
    
        USART_SendData(pUSARTx, ch);
        while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
    
        Delay(10000);
        RS1_RX_EN();
    }
    

    5.发送半字
    打开发送使能接口
    发送高8位数据
    等待发送寄存器为空
    发送低8位数据
    等待发送寄存器为空
    关闭发送使能接口

    void RS1_SendHalfWord(USART_TypeDef* pUSARTx, uint16_t data)
    {
        uint8_t temp_h,temp_l;
    
        Delay(10000);
        RS1_TX_EN();
    
        temp_h = data>>8;
        temp_l = data&0xff ;
    
        USART_SendData(pUSARTx, temp_h);
        while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
    
        USART_SendData(pUSARTx, temp_l);
        while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
    
        Delay(10000);
        RS1_RX_EN();
    }
    
    

    6.发送数组

    打开发送使能接口
    逐个发送字节
    等待发送寄存器为空
    关闭发送使能接口

    void RS1_SendArray(USART_TypeDef* pUSARTx, uint8_t *array,uint16_t num)
    {
        uint8_t i;
    
        Delay(10000);
        RS1_TX_EN();
    
        for(i=0 ; i<num; i++)
        {
            RS1_SendByte(pUSARTx, *array++);
        }
        while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TC) == RESET);
    
        Delay(10000);
        RS1_RX_EN();
    }
    
    

    7.发送字符
    打开发送使能接口
    逐个发送字节
    等待发送寄存器为空
    关闭发送使能接口

    void RS1_SendChar(USART_TypeDef* pUSARTx, char *str)
    {
        unsigned int k=0;
    
        Delay(10000);
        RS1_TX_EN();
    
        do
        {
            RS1_SendByte( pUSARTx, *(str + k) );
            k++;
        } while(*(str + k)!='\0');
    
        while(USART_GetFlagStatus(pUSARTx,USART_FLAG_TC)==RESET);
    
        Delay(10000);
        RS1_RX_EN();
    }
    

    8.重定向C库函数peintf到串口

    int fputc(int ch, FILE *f)
    {
    		/* ·¢ËÍÒ»¸ö×Ö½ÚÊý¾Ýµ½´®¿Ú */
    		USART_SendData(DEBUG_USARTx, (uint8_t) ch);
    		
    		/* µÈ´ý·¢ËÍÍê±Ï */
    		while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);		
    	
    		return (ch);
    }
    
    

    9.重定向c库函数scanf到串口

    int fgetc(FILE *f)
    {
    		/* µÈ´ý´®¿ÚÊäÈëÊý¾Ý */
    		while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_RXNE) == RESET);
    
    		return (int)USART_ReceiveData(DEBUG_USARTx);
    }
    
    

    10.调用中断服务函数
    使用哪个usart中断就调用哪个
    当产生中断时就调用接收数据和发送数据函数

    void    USART1_IRQHandler(void)
    {
      uint8_t ucTemp;
    	if(USART_GetITStatus(DEBUG_USARTx,USART_IT_RXNE)!=RESET)
    	{		
    		ucTemp = USART_ReceiveData(DEBUG_USARTx);
        USART_SendData(DEBUG_USARTx,ucTemp);    
    	}	 
    }
    
    展开全文
  • change USART

    2020-12-26 06:41:03
    <div><p>Is it possible to use a different USART on the Arduino mega? <p>I tried to change the USART in cpu_map.h from: #define SERIAL_RX USART0_RX_vect #define SERIAL_UDRE USART0_UDRE_vect <p>to ...
  • STM32串口通信配置分别为USART1+USART2+USART3+UART4

    千次阅读 多人点赞 2020-07-15 21:45:52
    STM32串口通信配置分别为USART1+USART2+USART3+UART4 文章目录STM32串口通信配置分别为USART1+USART2+USART3+UART4一、串口一的配置二、串口二的配置三、串口三的配置四、串口四的配置 在stm32中UART和USART是不...

    STM32串口通信配置分别为USART1+USART2+USART3+UART4

     在stm32中UART和USART是不相同的
    
    USART是通用同步/异步串行接收/发送器
    UART是通用异步收发传输器
    
    简单区分同步和异步就是看通信时需不需要对外提供时钟输出,我们平时用的串口通信基本都是 UART。
    
    USART支持同步模式,因此USART 需要同步时钟信号USART_CK(如STM32 单片机),通常情况同步信号很少使用,因此一般的单片机  UART和USART使用方  式是一样的,都使用异步模式。
    
    UART需要固定的波特率,就是说两位数据的间隔要相等。 UART总线是异步串口,一般由波特率产生器(产生的波特率等于传输波特率的16)、UART接收器、 UART发送器组成,硬件上有两根线,一根用于发送,一根用于接收。 显然,如果用通用IO口模拟UART总线,则需一个输入口,一个输出口。
    
    UART是一个并行输入成为串行输出的芯片,通常集成在主板上,多数是16550AFN芯片。因为计算机内部采用并行数据,不能直接把数据发到Modem,必须经过UART整理才能进行异步传输,其过程为:CPU先把准备写入串行设备的数据放到UART的寄存器(临时内存块)中,再通过FIFO(First Input First Output,先入先出队列)传送到串行设备,若是没有FIFO,信息将变得杂乱无章,不可能传送到Modem。
    
    作为接口的一部分,UART还提供以下功能:将由计算机内部传送过来的并行数据转换为输出的串行数据流。将计算机外部来的串行数据转换为字节,供计算机内部使用并行数据的器件使用。在输出的串行数据流中加入奇偶校验位,并对从外部接收的数据流进行奇偶校验。在输出数据流中加入启停标记,并从接收数据流中删除启停标记。处理由键盘或鼠标发出的中断信号(键盘和鼠标也是串行设备)。可以处理计算机与外部串行设备的同步管理问题。
    
    USART收发模块一般分为三大部分:时钟发生器、数据发送器和接收器。控制寄存器为所有的模块共享。时钟发生器由同步逻辑电路(在同步从模式下由外部时钟输入驱动)和波特率发生器组成。发送时钟引脚XCK仅用于同步发送模式下,发送器部分由一个单独的写入缓冲器(发送UDR)、一个串行移位寄存器、校验位发生器和用于处理不同浈结构的控制逻辑电路构成。使用写入缓冲器,实现了连续发送多浈数据无延时的通信。接收器是USART模块最复杂的部分,最主要的是时钟和数据接收单元。数据接收单元用作异步数据的接收。除了接收单元,接收器还包括校验位校验器、控制逻辑、移位寄存器和两级接收缓冲器(接收UDR)。接收器支持与发送器相同的帧结构,同时支持桢错误、数据溢出和校验错误的检测。USART是一个全双工通用同步/异步串行收发模块,该接口是一个高度灵活的串行通信设备。
    
    

    一、串口一的配置

    //(初始化+中断配置+中断接收函数)
    /*===============================================================================
    Copyright:
    Version: v2.0
    Author:
    Date: 2020/11/3
    Description:
        配置独立看门狗初始化函数,在主函数中运行IWDG_ReloadCounter进行喂狗主函数必须在4s内进行一次喂狗不然系统会复位;
        函数功能是将接收固定长度的字符串,并将接收后的字符串通过串口发送出去
    revise Description:
    ===============================================================================*/
    #include "stm32f10x_usart.h"
    #include "stm32f10x.h"
    #include "stm32f10x_iwdg.h"
    
    u8 USART1_RX_BUF[21];
    u8 USART1_RX_CNT=0;
    
    void IWDG_Configuration(void);
    
    void Usart1_Init(u32 bound)
    {
        //GPIO端口设置
        GPIO_InitTypeDef GPIO_InitStructure;
        USART_InitTypeDef USART_InitStructure;
        NVIC_InitTypeDef NVIC_InitStructure;
    
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC, ENABLE);//使能USART1,GPIOA,C时钟
    
        //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
    
        //Usart1 NVIC 配置
        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);    //设置NVIC中断分组2:2位抢占优先级,2位响应优先级   0-3;
    
        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寄存器
    
       //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(USART1, &USART_InitStructure); //初始化串口1
        USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
        USART_Cmd(USART1, ENABLE);                    //使能串口1
    }
    /**
    * USART1发送len个字节.
    * buf:发送区首地址
    * len:发送的字节数(为了和本代码的接收匹配,这里建议不要超过64个字节)
    **/
    void USART1_Send_Data(u8 *buf,u16 len)
    {
        u16 t;
        GPIO_SetBits(GPIOC,GPIO_Pin_9);
    //  RS485_TX_EN=1;            //设置为发送模式
        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);
        GPIO_ResetBits(GPIOC,GPIO_Pin_9);
    //    RS485_TX_EN=0;                //设置为接收模式
    }
    void main(void)
    {
        Usart1_Init(9600);//串口1波特率设置为9600
        IWDG_Configuration();
        while(1)
        {
            IWDG_ReloadCounter();//4s内必须喂狗不然复位
            if(USART1_RX_CNT==21)//数据接收完成
            {
                USART1_RX_CNT=0;//指针复位
                //将接收到的数据发送出去
                USART1_Send_Data(USART1_RX_BUF,21);//通过串口1将接收到的固定长度字符发送出去
            }
        }
    
    }
    /**
    * 接收指定长度的字符串
    * 比如接收固定大小为21个字节的字符串
    **/
    void USART1_IRQHandler(void)                    //串口1中断服务程序
    {
        u8 Res;
        if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
            {
                Res =USART_ReceiveData(USART1);    //读取接收到的数据
                if(USART1_RX_CNT<21)//对于接收指定长度的字符串
                {
                    USART1_RX_BUF[USART1_RX_CNT]=Res;        //记录接收到的值
                    USART1_RX_CNT++;                                        //接收数据增加1
                }
         }
             //溢出-如果发生溢出需要先读SR,再读DR寄存器则可清除不断入中断的问题
        if(USART_GetFlagStatus(USART1,USART_FLAG_ORE) == SET)
        {
            USART_ReceiveData(USART1);
            USART_ClearFlag(USART1,USART_FLAG_ORE);
        }
         USART_ClearFlag(UART1,USART_IT_RXNE); //一定要清除接收中断
    }
    /*===============================================================================
    Copyright:
    Version:
    Author:
    Date: 2020-07-15
    Description:配置独立看门狗初始化函数,在主函数中运行IWDG_ReloadCounter进行喂狗
        主函数必须在4s内进行一次喂狗不然系统会复位
    revise Description:
    ===============================================================================*/
    void IWDG_Configuration(void)
    {
         /* 写入0x5555,用于允许狗狗寄存器写入功能 */
        IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);
         /* 狗狗时钟分频,40K/256=156HZ(6.4ms)*/
        IWDG_SetPrescaler(IWDG_Prescaler_256);    /* 喂狗时间 5s/6.4MS=781 .注意不能大于0xfff*/
        IWDG_SetReload(781);//781(5s时间)
        IWDG_SetReload(3125);//781(20s时间)
        IWDG_Enable();//启用定时器
        IWDG_ReloadCounter();
    }
    

    二、串口二的配置

    //始化+中断配置+中断接收函数)
    /*===============================================================================
    Copyright:
    Version:
    Author:
    Date: 2020-07-15
    Description
        函数功能是将接收固定长度的字符串,并将接收后的字符串通过串口发送出去
    revise Description:
    ===============================================================================*/
    #include "stm32f10x_usart.h"
    #include "stm32f10x.h"
    #include "stm32f10x_iwdg.h"
    
    
    u8 USART2_RX_BUF[250];
    u8 USART2_RX_CNT=0;
    u16 USART2_RX_STA=0;       //接收状态标记
    
    void Usart2_Init(u32 bound)
    {
        GPIO_InitTypeDef GPIO_InitStructure;
        USART_InitTypeDef USART_InitStructure;
        NVIC_InitTypeDef NVIC_InitStructure;
        //|RCC_APB2Periph_AFIO
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);//使能GPIOA时钟
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);//使能USART2时钟
    
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;    //PA2
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽
        GPIO_Init(GPIOA, &GPIO_InitStructure);
    
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;//PA3
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入
        GPIO_Init(GPIOA, &GPIO_InitStructure);
    
        RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2,ENABLE);//复位串口2
        RCC_APB1PeriphResetCmd(RCC_APB1Periph_USART2,DISABLE);//停止复位
    
        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);    //设置NVIC中断分组2:2位抢占优先级,2位响应优先级   0-3;
        NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn; //使能串口2中断
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3; //先占优先级2级
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //从优先级2级
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //使能外部中断通道
        NVIC_Init(&NVIC_InitStructure); //根据NVIC_InitStruct中指定的参数初始化外设NVIC寄存器
    
        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(USART2, &USART_InitStructure); ; //初始化串口
        USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//开启中断
        USART_Cmd(USART2, ENABLE);                    //使能串口
    
    }
    /**
    * USART2发送len个字节.
    * buf:发送区首地址
    * len:发送的字节数(为了和本代码的接收匹配,这里建议不要超过64个字节)
    **/
    void USART2_Send_Data(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);
    }
    /**
    * 这也是一个接收函数,可以用,也可以用下面main函数的方法调用
    * USART2查询接收到的数据
    * buf:接收缓存首地址
    * len:读到的数据长度
    **/
    void USART2_Receive_Data(u8 *buf)
    {
        u8 rxlen=USART2_RX_CNT;
        u8 i=0;
        delay_ms(10);        //等待10ms,连续超过10ms没有接收到一个数据,则认为接收结束
        while(rxlen!=USART2_RX_CNT)
        {
            rxlen=USART2_RX_CNT;
            delay_ms(10);
        }
            for(i=0;i<(USART2_RX_CNT);i++)
            {
                buf[i] = USART2_RX_BUF[i];
                USART2_RX_BUF[i] = 0;
            }
            USART2_RX_CNT=0;        //清零
    
    }
    
    void main(void)
    {
        Usart2_Init(9600);//串口2特率设置为9600
        while(1)
        {
            if(USART2_RX_STA)//数据接收完成
            {
                USART2_RX_STA=0;
                //将接收到的数据发送出去
                USART2_Send_Data(USART2_RX_BUF,USART2_RX_CNT);//通过串口1将接收到的固定长度字符发送出去
                USART2_RX_CNT=0;//指针复位
            }
        }
    }
    
    
    void USART2_IRQHandler(void)
    {
        u8 res;
         if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET) //接收到数据
        {
            res =USART_ReceiveData(USART2);     //读取接收到的数据
            if(USART2_RX_STA==0)
            {
                USART2_RX_BUF[USART2_RX_CNT] = res;        //记录接收到的值
                //当数据结尾收到0xA0和0xA1代表数据接收完成,是一串完整的数据
                if(USART2_RX_BUF[USART2_RX_CNT-1]==0xA0&&USART2_RX_BUF[USART2_RX_CNT]==0xA1)
                    USART2_RX_STA=1;//表示接收数据结束
                USART2_RX_CNT++;                        //接收数据增加1
            }
            }
        }
        //溢出-如果发生溢出需要先读SR,再读DR寄存器则可清除不断入中断的问题
        if(USART_GetFlagStatus(USART2,USART_FLAG_ORE) == SET)
        {
            USART_ReceiveData(USART2);
            USART_ClearFlag(USART2,USART_FLAG_ORE);
        }
         USART_ClearFlag(UART2,USART_IT_RXNE); //一定要清除接收中断
    }
    

    三、串口三的配置

    //(初始化+中断配置+中断接收函数)
    /*===============================================================================
    Copyright:
    Version:
    Author:
    Date: 2020-07-15
    Description:
        函数功能是将接收固定长度的字符串,并将接收后的字符串通过串口发送出去
        通过滴答定时器方式获取数据
    revise Description:
    ===============================================================================*/
    #include "stm32f10x_usart.h"
    #include "stm32f10x.h"
    
    #define USART3_TIMEOUT_Setting 800  //(ms)
    
    u8 USART3_RX_BUF[250];
    u16 USART3_RX_CNT=0;
    u16 USART3_RX_TIMEOUT=0;       //接收状态标记
    
    void Timer1CountInitial(void);
    
    void USART3_Init(u32 baud)
    {
        USART_InitTypeDef USART_InitStructure;
        NVIC_InitTypeDef NVIC_InitStructure;
        GPIO_InitTypeDef GPIO_InitStructure;    //声明一个结构体变量,用来初始化GPIO
        //使能串口的RCC时钟
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB , ENABLE); //使能UART3所在GPIOB的时钟
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
    
        //串口使用的GPIO口配置
        // Configure USART3 Rx (PB.11) as input floating
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
        GPIO_Init(GPIOB, &GPIO_InitStructure);
    
        // Configure USART3 Tx (PB.10) as alternate function push-pull
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
        GPIO_Init(GPIOB, &GPIO_InitStructure);
    
        //配置串口
        USART_InitStructure.USART_BaudRate = baud;
        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;
    
    
        // Configure USART3
        USART_Init(USART3, &USART_InitStructure);//配置串口3
        // Enable USART3 Receive interrupts 使能串口接收中断
        USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
        // Enable the USART3
        USART_Cmd(USART3, ENABLE);//使能串口3
    
        //串口中断配置
        //Configure the NVIC Preemption Priority Bits
        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
        // Enable the USART3 Interrupt
        NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;        //子优先级3
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
        NVIC_Init(&NVIC_InitStructure);
    
    }
    
    void USART3_Sned_Char(u8 temp)
    {
        USART_SendData(USART3,(u8)temp);
        while(USART_GetFlagStatus(USART3,USART_FLAG_TXE)==RESET);
    
    }
    
    void USART3_Sned_Char_Buff(u8 buf[],u32 len)
    {
        u32 i;
        for(i=0;i<len;i++)
        USART3_Sned_Char(buf[i]);
    
    }
    
    void main(void)
    {
        Timer1CountInitial();
        Usart3_Init(9600);//串口3波特率设置为9600
        while(1)
        {
            if(USART3_RX_TIMEOUT==USART3_TIMEOUT_Setting)
            {
                USART3_RX_TIMEOUT=0;
                USART3_Sned_Char_Buff(USART3_RX_BUF,USART3_RX_CNT);//将接收到的数据发送出去
                USART3_RX_CNT=0;
            }
    
        }
    }
    void USART3_IRQHandler(void)                    //串口3中断服务程序
    {
        u8 Res;
        if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
        {
            USART3_RX_TIMEOUT=0;
            USART3_RX_BUF[USART3_RX_CNT++] = USART_ReceiveData(USART3);    //读取接收到的数据
        }
        //溢出-如果发生溢出需要先读SR,再读DR寄存器则可清除不断入中断的问题
        if(USART_GetFlagStatus(USART3,USART_FLAG_ORE) == SET)
        {
            USART_ReceiveData(USART3);
            USART_ClearFlag(USART3,USART_FLAG_ORE);
        }
        USART_ClearITPendingBit(USART3, USART_IT_RXNE);
    
    }
    
    //放到主函数的初始化中初始化
    void Timer1CountInitial(void)
    {
        //定时=36000/72000x2=0.001s=1ms;
            TIM_TimeBaseInitTypeDef    TIM_TimeBaseStructure;
            ///
            RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1, ENABLE);
    
            TIM_TimeBaseStructure.TIM_Period = 100-1;//自动重装值(此时改为10ms)
            TIM_TimeBaseStructure.TIM_Prescaler = 7200-1;//时钟预分频
            TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;//向上计数
            TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;        //时钟分频1
            TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
            TIM_TimeBaseInit(TIM1,&TIM_TimeBaseStructure);
    
            TIM_ClearFlag(TIM1,TIM_FLAG_Update);
            TIM_ITConfig(TIM1,TIM_IT_Update,ENABLE);
            TIM_Cmd(TIM1, ENABLE);
    }
    void TIM1_UP_IRQHandler(void)
    {
        //TIM_TimeBaseStructure.TIM_Period = 100-1;//自动重装值(此时改为10ms)
        if (TIM_GetITStatus(TIM1, TIM_IT_Update) != RESET)
        {
            if(USART3_RX_TIMEOUT<USART3_TIMEOUT_Setting)
                    USART3_RX_TIMEOUT++;
        }
        TIM_ClearITPendingBit(TIM1,TIM_IT_Update);
    }
    

    四、串口四的配置

    //(初始化+中断配置+中断接收函数)
    /*===============================================================================
    Date: 2020-07-15
    Description:
        函数功能是将接收固定长度的字符串,并将接收后的字符串通过串口发送出去
        通过滴答定时器方式获取数据
    revise Description:
    ===============================================================================*/
    #include "stm32f10x_usart.h"
    #include "stm32f10x.h"
    
    #define USART4_TIMEOUT_Setting 800  //(ms)
    
    u8 USART4_RX_BUF[250];
    u16 USART4_RX_CNT=0;
    u16 USART2_RX_STA=0;       //接收状态标记
    
    void Systick_delay_init(u8 SYSCLK);
    u8 virtual_delay(u32 num,u8 unit);
    
    //通用异步收发器UART4
    void UART4_Init(u32 bound)
    {
        USART_InitTypeDef USART_InitStructure;
        GPIO_InitTypeDef GPIO_InitStructure;
    
        //used for USART3 full remap
        //GPIO_PinRemapConfig(GPIO_FullRemap_USART3, ENABLE);
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_AFIO, ENABLE);
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE);//for UART4
    
        //Configure RS485_TX_EN PIN
        GPIO_InitStructure.GPIO_Pin = RS485_TX_EN_PIN;                 //PC9端口配置
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;          //推挽输出
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(RS485_TX_EN_PORT, &GPIO_InitStructure);
    
        RS485_TX_EN=0;            //设置485默认为接收模式
    
        /* Configure USART Tx as alternate function push-pull */
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
        GPIO_Init(GPIOC, &GPIO_InitStructure);
    
        /* Configure USART Rx as input floating */
        GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_11;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
        GPIO_Init(GPIOC, &GPIO_InitStructure);
    
    
        USART_InitStructure.USART_BaudRate = bound;
        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(UART4, &USART_InitStructure);
        //USART_Init(USART3, &USART_InitStructure);
        /* Enable the USART */
        USART_Cmd(UART4, ENABLE);
        USART_ITConfig(UART4, USART_IT_RXNE, ENABLE);//开启串口接受中断
        USART_ClearFlag(UART4,USART_FLAG_TC);
    }
    //USART1查询接收到的数据
    //buf:接收缓存首地址
    //len:读到的数据长度
    void UART4_Receive_Data(u8 *buf)
    {
        u8 rxlen=21;
        u8 i=0;
        delay_ms(10);        //等待10ms,连续超过10ms没有接收到一个数据,则认为接收结束
    
        RS485_RX_FLAG = 0;
        if((UART4_RX_BUF[0]==0x01)&&(UART4_RX_BUF[1]==0x03))
        {
            for(i=0;i<rxlen;i++)
            {
                buf[i]=UART4_RX_BUF[i];
                UART4_RX_BUF[i] = 0;
            }
            RS485_RX_FLAG = 1;
        }
            UART4_RX_CNT=0;        //清零
    }
    
    
    //USART1发送len个字节.
    //buf:发送区首地址
    //len:发送的字节数(为了和本代码的接收匹配,这里建议不要超过64个字节)
    void UART4_Send_Data(u8 *buf,u16 len)
    {
        u16 t;
        RS485_TX_EN=1;            //设置为发送模式
        for(t=0;t<len;t++)        //循环发送数据
        {
            while(USART_GetFlagStatus(UART4,USART_FLAG_TC)==RESET); //循环发送,直到发送完毕
            USART_SendData(UART4,buf[t]);
        }
        while(USART_GetFlagStatus(UART4, USART_FLAG_TC) == RESET);
        RS485_TX_EN=0;                //设置为接收模式
    }
    
    void main(void)
    {
        Systick_delay_init(72);
        Usart4_Init(9600);//串口4波特率设置为9600
        while(1)
        {
            if(USART2_RX_STA)
            {
                if(virtual_delay(USART4_TIMEOUT_Setting,MS))//超过800ms空闲则可以读取数据
                {
                    UART4_Send_Data(UART4_RX_BUF,UART4_RX_CNT);
                    USART2_RX_STA=0;
                    UART4_RX_CNT=0;
                }
    
            }
    
        }
    }
    void UART4_IRQHandler(void)                    //UART4 Receive Interrupt
    {
        u8 Res;
    
        if(USART_GetITStatus(UART4, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
        {
            Res =USART_ReceiveData(UART4);//(USART1->DR);    //读取接收到的数据
            UART4_RX_BUF[UART4_RX_CNT&0XFF]=Res;        //回传的数据存入数组,0X3F限制为64个数值
                UART4_RX_CNT++;
            USART2_RX_STA=1;
        }
    
        if( USART_GetITStatus(UART4, USART_IT_TC) == SET )
        {
            USART_ClearFlag(UART4, USART_FLAG_TC);
        }
        //溢出-如果发生溢出需要先读SR,再读DR寄存器则可清除不断入中断的问题
        if(USART_GetFlagStatus(UART4,USART_FLAG_ORE) == SET)
        {
            USART_ReceiveData(UART4);
            USART_ClearFlag(UART4,USART_FLAG_ORE);
        }
    //    USART_ITConfig(UART4, USART_IT_RXNE, DISABLE);//临时关闭接收中断
        USART_ClearFlag(UART4,USART_IT_RXNE); //一定要清除接收中断
    
    }
    
    //初始化延迟函数
    //SYSTICK的时钟固定为HCLK时钟的1/8
    //SYSCLK:系统时钟
    void Systick_delay_init(u8 SYSCLK)
    {
        SysTick->CTRL&=0xfffffffb;//bit2清空,选择外部时钟  HCLK/8
    //    SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);    //选择外部时钟  HCLK/8
        fac_us=SYSCLK/8;
        fac_ms=(u16)fac_us*1000;
    }
    /*===============================================================================
    Author:peter pan
    Date:
    Description: 查询式分时或叫做轮询式(近似延时)。本函数是用于执行高效率场合的查询延时,但是一个for or while 循环中只能用一次。
    revise Description:
    @ num :    //分时查询的周期计数值
    @ unit :    //分时查询的周期单位
        @@ParaValue :
            MS    //周期单位为MS毫秒级
            US    //周期单位为US微秒级
    @ virtual_delay_status :    //静态变量
        @@ParaValue :
            SET    //SYSTICK正在占用中,请勿用
            RESET  //SYSTICK空闲,可以使用
    @ReValue :
        with zero mean Time non-arrive ,one representative Time arrived ,you can do task;
    ##example             if(virtual_delay(1000,MS)) LedFlash();    //1000ms LED闪烁一下
    ===============================================================================*/
    u8 virtual_delay(u32 num,u8 unit)
    {
        u32 temp;
        if(virtual_delay_status==RESET)    //  SYSTICK空闲,可以使用
          {
              if(unit==MS)
              {
                    SysTick->LOAD=(u32)num*Delay_SYSCLK*125;//时间加载(SysTick->LOAD为24bit)
                    SysTick->VAL =0x00;           //清空计数器
                    SysTick->CTRL=0x01 ;          //开始倒数
              }else if(unit==US)
              {
                    SysTick->LOAD=num*Delay_SYSCLK/8; //时间加载
                    SysTick->VAL=0x00;        //清空计数器
                    SysTick->CTRL=0x01 ;      //开始倒数
              }
              virtual_delay_status=SET;
              return 0;
            }
        else
            {        //virtual_delay_status==SET SYSTICK被占用
    
                temp=SysTick->CTRL;
                if(!(temp&0x01&&!(temp&(1<<16))))//等待时间到达
                {
                    SysTick->CTRL=0x00;       //关闭计数器
                    SysTick->VAL =0X00;       //清空计数器
                    virtual_delay_status=RESET;
                    return 1;
                }else return 0;
            }
    }
    
    展开全文
  • USART总结

    2020-02-27 20:21:21
    (以下总结经验为STM32F103ZET6系列)(以下总结经验为STM32F103ZET6系列)(以下总结经验为STM32F103ZET6系列) USART 串口分两种,第一种是 USART ,第二种为 UART 。...(此处以USART2USART2USART2为例)存在五个...

    STM32F103ZET6(以下总结经验为STM32F103ZET6系列)

    USART 串口分两种,第一种是 USART ,第二种为 UART 。第一种被称作同步异步收发器,而第二种被称为异步收发器,在查询STM32芯片外设手册时,可以观察到的,USART存在五个外设口

    (此处以USART2USART2为例)存在五个外设口

    USART2_CTS USART2_RTS

    USART2_TX USART2_RX USART2_CK

    在这里插入图片描述
    以上原图片出处

    五个外设口分别为 允许发送 请求发送 发送数据 接收数据 串口时钟

    (此处以UART4UART4为例)存在两个外设口

    UART4_TX UART4_RX

    两个外设口分别为 发送数据 接收数据

    此上是为芯片上的不一样,由此可以引出同步和异步的关系

    同步和异步的区别就是发送数据端和接收数据端两端的内部时钟是否一样,若为一样的,则为同步,若不一样则为异步。

    所以可以和明显的发现USART比UART更让人注意的外设口则是USART2_CK,直接表明了其存在同步发送数据的功能,初学阶段还经常只能停留在异步数据发送的阶段,在此也只讲述异步发送

    void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct);

    该函数就是USART/UART初始化的函数,如果只用他的话就是异步通信

    void USART_ClockInit(USART_TypeDef* USARTx, USART_ClockInitTypeDef* USART_ClockInitStruct);

    该函数就是USART时钟初始化的函数,外加上他的的话就是同步通信初始化

    #define USART_HardwareFlowControl_None ((uint16_t)0x0000)
    #define USART_HardwareFlowControl_RTS ((uint16_t)0x0100)
    #define USART_HardwareFlowControl_CTS ((uint16_t)0x0200)
    #define USART_HardwareFlowControl_RTS_CTS ((uint16_t)0x0300)

    此四行是官方库函数的库定义,USART_HardwareFlowControl_None 是我们视频理看到的:无数据硬件流控制。

    此函数就是影响USART2_CTS USART2_RTS的控制。

    (以上是自己探索的关于串口的信息,以后领悟更加深了,会重新编辑文章)

    接下来是自己写函数最重要的标志位的使用

    1、USART_FLAG_RXNE 串口信号接收完成

    2、USART_FLAG_TXE 数据预发送准备

    3、USART_FLAG_TC数据发送完成

    主要采取此三个标志位会让数据传输的更加准确,不会导致数据缺胳膊少腿的,2与3在发送数据时只需要一个标志位即可,这里有个很生动的比喻来形容USART_FLAG_TXE的功能,我们将手枪打子弹位数据传输,USART_FLAG_TC表示我的子弹打完了,USART_FLAG_TXE表示我子弹还没打完还有子弹时上膛着的

    串口通信还有一个标志位USART_FLAG_ORE需要注意,如果接受数据出现缺陷,可能就要查看这个位是否置一,若置一的话表示,接收数据出现了数据过多导致数据溢出错误,需要检查程序的接收端是否能行之有效,

    此下为转载:

    if(USART_GetFlagStatus(USART2, USART_FLAG_ORE) != RESET)
    {
    USART_ClearFlag(USART2, USART_FLAG_ORE); //清除溢出中断
    }

    if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
    {
    USART_ClearITPendingBit(USART2, USART_IT_RXNE);
    //rebuf[num++] = USART_ReceiveData(USART2); 读取串口数据
    }

    在此使用USART_ClearITPendingBit(USART1, USART_IT_ORE);清除ORE位是没有任何作用的。

    原文章:ORE处理详解

    以上为转载。

    void DataRecevice1b(USART_TypeDef* USARTx)
    {
    for(RxCounter=0;RxCounter<5;RxCounter++)
    {
    DataRe[RxCounter]=USART_ReceiveData(USARTx);
    while(USART_GetFlagStatus(USARTx,USART_FLAG_RXNE)==RESET);
    }
    }

    void DataSend(USART_TypeDef* USARTx,u8* Message)
    {
    while(* Message!=’\0’)
    {
    Send1Byte(USARTx,*Message++);
    delay_ms(2);
    }
    }

    TXRXstat Send1Byte(USART_TypeDef* USARTx,u8 dat)
    {
    vu32 cnt=0;
    USART_SendData(USARTx,dat);
    while(USART_GetFlagStatus(USARTx,USART_FLAG_TXE)!=RESET)
    {
    cnt++;
    if(cnt>100000)
    {
    return ERR;
    }
    }
    return OK;
    }

    void DataClearAll(u8 len)
    {
    u8 i;
    for(i=0;i<len;i++)
    {
    DataRe[i]=0;
    }
    }

    此处贴了四个我自己写的函数,很简单自己也可以理清楚,就不多言了

    翔予有个秃头梦
    展开全文
  • USART HMI

    2020-12-29 17:34:09
    USART HMI即串口人机接口,其将底层功能封装在HMI设备中,通过串口与MCU 进行通信交互,MCU只需通过串口与HMI设备发送/接收指令,HMI设备即可作出相应响应。 2. HMI设备端 以陶晶驰USART HMI串口屏为例。 2.1 USART...
  • USART库函数

    千次阅读 2018-08-06 20:40:27
    1.void USART_DeInit(USART_TypeDef* USARTx) 功能:将USART寄存器重置为默认值 注释:主要是调用了RCC_APBxPeriphResetCmd函数对寄存器进行复位 例如:USART_DeInit(USART1);   2.void USART_Init(USART_...
  • USART列子

    2018-12-05 20:55:00
    #include "stm32f10x.h" void USART_INit(void) { GPIO_InitTypeDef GPIO_Initstructe;... USART_InitTypeDef USART_Initstructe; NVIC_InitTypeDef NVIC_Initstructe; ...
  • 串口usart

    2018-09-10 15:44:12
    #ifndef _H_IL_USART1_201611251016_H_ #define _H_IL_USART1_201611251016_H_ #include "il_system_configure.h" #include &lt;stdbool.h&gt; #include &lt;stdint.h&gt; typedef ...
  • USART DMA.rar

    2019-09-29 16:23:52
    USART1和USART2发送接收数据均采用DMA,实测可用,DMA可防止由于频繁被打断而出现错误。
  • 试验原因 将程序中所有必须成功的地方都下了断言, 在断言函数中下了断点. ...void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct) { uint32_t tmpreg = 0x00, apbclock = ...
  • STM32f103系列 USART2 USART3 串口2和串口3通信

    万次阅读 多人点赞 2018-04-29 15:22:11
    最近在做一个工程要用到多个串口同时通讯的,就参考了正点原子的串口通讯例程,发现例程是USART1 串口1的,后面我想改成USART2 串口2的,上网找了资料,要不是不靠谱,要不就是要积分下载。所以后面自己写了一个可用...
  • STM32用USART发送字符串,以USART_FLAG_TXE和USART_FLAG_TC怎么用一:STM32用USART发送字符串void UART_Send_Message(u8 *Data) { while(*Data!='\0') { USART_SendData(USART1, *Data); while(USART_...
  • USART interrupt issue

    2020-11-30 07:06:22
    <p>The problem: it is impossible to use USART RX interrupt with MFRC522 library, because (like Arduino IDE say) it is already in use in this library. Try code below and you will get an error. I`ve...
  • USART_ClearITPendingBith和 USART_ClearFlag的区别

    千次阅读 多人点赞 2018-07-02 09:00:38
    stm32 v3.5 库函数里面,对于串口USART有这样两个函数: USART_ClearFlag()和USART_ClearITPendingBit() 查库函数定义,说一个是清除标志,一个是清除中断预处理位。然后我看了stm32f10x_usart.c文件,发现两个...
  • USART概述

    2017-12-26 13:31:53
    一、USART简介  一般使用MAX232芯片在STM32和DB9接头之间进行电平转换,将STM32的PA10(USART1-TX)连接到DB9(公头)的第三引脚。  串口的发送数据和接收数据都是在USART_DR中实现的,为一个双寄存器,包含了...
  • USART_StructInit(&USART_InitStructure);//装填默认值 USART_Init(USART1, &USART_InitStructure);//根据USART_InitStruct中指定的参数初始化外设USARTx寄存器 USART_Cmd(USART1, ENABLE); //启用
  • USART_GetITStatus和USART_GetFlagStatus的区别 USART_GetITStatus()和USART_GetFlagStatus()的区别  都是访问串口的SR状态寄存器,唯一不同是,USART_GetITStatus()会判断中断是否开启,如果没开启,也会返回...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,745
精华内容 3,098
关键字:

usart