STM32F10X串口通信配置（USART1+USART2+USART3+UART4）

最新推荐文章于 2024-07-13 01:57:03 发布
最新推荐文章于 2024-07-13 01:57:03 发布
阅读量2.7k 收藏 10
点赞数 2
分类专栏： STM32 文章标签： stm32
原文链接：https://www.cnblogs.com/pertor/p/9488446.html
版权

转载自:https://www.cnblogs.com/pertor/p/9488446.html

一、串口一的配置（初始化+中断配置+中断接收函数）
/*===============================================================================
Copyright:
Version:
Author:
Date: 2017/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: 2017/11/3
    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: 2017/11/3
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);//串口1波特率设置为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: 2017/11/3
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);//串口1波特率设置为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);
}

四、串口四的配置（初始化+中断配置+中断接收函数）

注意串口四的中断优先级没有贴出来，和前面的三个一样的配置，为了不占用过多的篇幅就不贴中断优先级配置了
/===============================================================================
Copyright:
Version:
Author:
Date: 2017/11/3
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);//串口1波特率设置为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_us1000;
}
/===============================================================================
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_statusRESET) // SYSTICK空闲，可以使用
{
if(unitMS)
{
SysTick->LOAD=(u32)numDelay_SYSCLK125;//时间加载(SysTick->LOAD为24bit)
SysTick->VAL =0x00; //清空计数器
SysTick->CTRL=0x01 ; //开始倒数
}else if(unitUS)
{
SysTick->LOAD=num*Delay_SYSCLK/8; //时间加载
SysTick->VAL=0x00; //清空计数器
SysTick->CTRL=0x01 ; //开始倒数
}
virtual_delay_status=SET;
return 0;
}
else
{ //virtual_delay_statusSET 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;
    }

}

yekui009
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
stm32串口c语言程序,STM32串口通信-代码实现
weixin_35304361的博客
05-21 2210
代码实现功能实现:与上位机进行通信宏定义需要的GPIO//头文件中的引脚 宏定义// 串口1-USART1#ifndef _USART_H#define _USART_H#include "stm32f10x.h"#include "stdio.h"// 串口1-USART1#define USART1_TX USART1#define USART1_TX...
STM32L151C8-USART1+USART3 -20190813-1347.zip
08-15
STM32L151C8-USART1+USART3 在原有LED例程的基础上，添加了USART1和USART3的支持。 并在开发板上调试通过。
STM32F10xx串口通信
RedValkyrie的博客
06-09 2058
一、通信方式相关 1.1 并行通信 1.2 串行通信 串行通信的通信方式： 常见的串行通信接口： STM32的串口通信接口 USART：通用异步收发器 UART：通用同步异步收发器 STM32F10x大容量系列芯片，包含3个USART（支持异步也支持同步）和2个UART（只支持异步） 二、UART 异步通信方式引脚连接方法： RXD：数据输入引脚，数据接收 TXD：数据输出引脚，数据发送。 PC机里CPU也是含有发送引脚和接收引脚的，他们通过主板引出已经被转化为RS232电平，然后通过
关于STM32的USART串口通信——异步全双工（1）
最新发布
xueyin55的博客
07-13 1006
STM32F10X芯片，包含3个USART（USART1、USART2、USART3）和2个UART（UART4、UART5）。其中USART是通用同步/异步收发器，而UART是通用异步收发器。在以下运用中，只介绍USART作为异步全双工串口通信使用，即UART模式，在此以USART1具体。
关于STM32F10x串口UART相关代码笔记
hus5487的博客
01-23 3490
一、更新时间 2022.1.22 二、相关器件 stm32f103c8t6最小系统板，CH340。 三、硬件连接 四、现象与事件 五、具体操作：
STM32F10x 学习笔记之USART实现串口通讯
* . Benirus的专栏
12-27 2891
这次讲讲利用串口收发中断来进行串口通讯。STM32 上为每个串口分配了一个中断。也就是说无论是发送完成还是收到数据或是数据溢出都产生同一个中断。程序需在中断处理函数中读取状态寄存器(USART_SR)来判断当前的是什么中断。下面的中断映像图给出了这些中断源是如何汇合成最终的中断信号的。图中也给出了如何控制每一个单独的中断源是否起作用。 另外，Cortex-M3 内核中还有个N
STM32 F10x USART串口通信详解
weixin_31914685的博客
07-02 647
STM32 F10x USART串口通信详解 在工程模板下另外创建如下文件： uart.c uart.h 文件：uart.c #include "uart.h" ////////////////////////////////////////////////////////////////// //加入以下代码,支持printf函数,而不需要选择use MicroLIB #if 1 #pragma import(__use_no_semihosting) //标准库需
Stm32设置串口300波特率 2400 4800 9600计算方法
FLYMCU的博客
02-15 868
比如我们要设置300波特率， reg_value = 72000000/ (16 * 300) = 15000,虽然能计算出来，但注意，USART_BRR的前四位存放的是小数部分，后12位存放的是整数部分，所以整数部分最大位4095，根本达不到15000，因此只能改变APB1的时钟频率。在APB1为72MHz的时钟频率下，是设置不了300波特率的，原因在于 Tx/Rx baud = fck / （16 * reg_value) ，reg_value是写进USART_BRR寄存器里。
1STM32F10X_串口USART1_串口_uart_STM32F103_
10-03
在这个项目中，我们专注于使用STM32F103单片机实现串行通信接口（UART），特别是使用USART1进行数据传输。 串口，全称Universal Asynchronous Receiver/Transmitter，是一种通用异步收发传输器，用于在设备之间进行...
STM32F10X-USART.rar_USART__examples_stm32f10x_stm32f10x uart_stm
09-19
STM32F10X-USART.rar 是一个与STM32F10X微控制器相关的压缩包，包含了一些关于UART（通用异步收发传输器）应用的示例代码。STM32F10X系列是基于ARM Cortex-M3内核的微控制器，广泛应用于嵌入式系统设计中，因其高...
USART1.zip_STM32 串口通信_keil4 stm32_stm32 usart1 MDK_stm32f10x_cl
09-21
综上所述，这个压缩包文件包含了一个使用Keil4和STM32F10X的USART1串口通信项目，开发者可以通过学习和实践来掌握STM32串口通信的基本原理和编程技巧。通过深入理解这些知识点，可以进一步提升嵌入式系统的开发能力...
stm32F103串口程序的配置及简单的使用（串口1，串口2，串口3）USART1,USART2,USART3.zip
07-20
stm32F103串口程序的配置及简单的使用（串口1，串口2，串口3）USART1,USART2,USART3 通过按键发送一串十六进制指令 串口二收到数据并将收到数据存入数组中 串口二收到的数据以0x3A开头，0x23结束。 串口1用作串口测试。本程序可用做zigbee的串口通信
STM32L452UART+USART+DMATX+RXIT.rar
10-18
总的来说，"STM32L452UART+USART+DMATX+RXIT.rar"中的内容将帮助开发者理解如何在STM32L452上使用LL库配置和操作USART，实现DMA传输和中断接收，这对于需要高效、低功耗串行通信的项目尤其有价值。通过深入学习这些...
STM32F1的UART4串口配置
热门推荐
骨头和狗的博客
10-24 4万+
注意是UART4，不是USART4   在stm32中UART和USART是不相同的   USART是通用同步/异步串行接收/发送器   UART是通用异步收发传输器   简单区分同步和异步就是看通信时需不需要对外提供时钟输出，我们平时用的串口通信基本都是 UART。   USART支持同步模式，因此USART 需要同步时钟信号USART_CK（如STM3
STM32：串口基本配置代码
Mr_zhang1911116的博客
01-24 1549
STM32串口1（PA9 & PA10）的基本代码配置如下： void USART1_Configuration(void)//串口1的配置函数 { GPIO_InitTypedef GPIO_InitStructure; USART_InitTypedef USART_InitStructure; NVIC_InitTypedef NVIC_InitStructure; //使能时钟频率 RCC_APB2PeriphClockCmd(RCC_APB2Peri
STM32F1XX的串口配置代码详解
Thousand_drive的博客
09-14 1232
STM32的串口通信是最常用的通信方式，串口通信（Serial Communications）的概念非常简单，串口按位（bit）发送和接收字节。尽管比按字节（byte）的并行通信慢，但是串口可以在使用一根线发送数据的同时用另一根线接收数据。它很简单并且能够实现远距离通信。下面根据stm32f1的中文手册和stm32f1固件库来配置一个串口。stm32f1的中文手册和stm32f1固件库链接：https://pan.baidu.com/s/1dMGIH9Cq-UBruGPraDPQvg。
STM32F207 USART2 波特率设置9600以下，4800、2400发送报文乱码---原因串口空闲时间操作16ms，就强制将串口设置成接收模式，目的是为了防止串口发送失败导致死锁
二进制模----细微行动改变影响世界
08-20 1317
STM32F207 USART2 波特率设置9600以下，4800、2400发送报文乱码 juelianhuayao 2020-06-11 22:07:34 792 收藏 1 文章标签： stm32 USART2 串口乱码 版权 最近有一个老项目有新的需求，需要对串口进行一下改造，波特率从原来的9600改到了2400，结果奇葩的事情发生了，之前一直好好的串口，发送出来的报文竟然变成了乱码，代码也就修改了一下波特率，其他的什么都没有修改。百思不得其解，网上查阅资料说是时钟频率的问题，降低一点就解...
标准库STM32F1_USART2_DMA接收发送数据源码分享直接复制能用
weixin_41226265的博客
10-24 392
现有一个小需求，使用STM32F1系列单片机做串口2的收发数据的功能，通过PC上的串口调试助手给单片机发一串数据，单片机收到数据后再给PC的串口调试助手发回去。STM32使用USART2，对应单片机的PA1控制方向，PA2发送，PA3接收。本次使用的是串口DMA方式接收数据，和DMA方式发送数据。
stm32,波特率设置为9600，却只能用4800进行通信
ting_junhui的博客
08-02 4566
用stm32f10x系列，以USART为通信协议写一个串口与串口通信的实例
03-25
以下是使用STM32F10x系列微控制器，使用USART串口通信协议实现串口与串口通信的示例代码： ```c #include "stm32f10x.h" USART_InitTypeDef USART_InitStructure; void USART1_Init(void){ GPIO_InitTypeDef ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值