正点原子精英版的所有串口统一使用源程序

ID:909832 · 发表于 2023-4-5 23:18

#include "sys.h"
#include "usart.h"
#include "stdarg.h"
#include "main.h"
//////////////////////////////////////////////////////////////////////////////////
//如果使用ucos,则包括下面的头文件即可.
#if SYSTEM_SUPPORT_OS
#include "includes.h"                                     //ucos 使用
#endif
//////////////////////////////////////////////////////////////////////////////////
/*
五个串口使用
USART1  TX ---->PA9
RX----->PA10
USART2  TX ---->PA2
RX----->PA3
USART3  TX ---->PB10
RX----->PB11
UART4  TX ---->PC10
RX----->PC11
UART5  TX ---->PC12
RX----->PD2
*/
//////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////
//加入以下代码,支持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函数 //串口1使用printf函数
int fputc(int ch, FILE *f)
{
      while((USART2->SR&0X40)==0);//循环发送,直到发送完毕
USART2->DR = (u8) ch;
      return ch;
}

//int fgetc2(FILE *stream)//获取字符
//{
//
//}
#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_USART1_RX //如果使能了接收
//串口1中断服务程序
//注意,读取USARTx->SR能避免莫名其妙的错误
u8 USART1_RX_BUF[USART1_REC_LEN];    //接收缓冲,最大USART_REC_LEN个字节.
u8 USART2_RX_BUF[USART2_REC_LEN];
u8 USART3_RX_BUF[USART3_REC_LEN];
u8 UART4_RX_BUF[UART4_REC_LEN];
u8 UART5_RX_BUF[UART5_REC_LEN];
//接收状态
//bit15，       接收完成标志
//bit14，       接收到0x0d
//bit13~0，       接收到的有效字节数目
u16 USART1_RX_STA=0;    //接收状态标记
u16 USART2_RX_STA=0;
u16 USART3_RX_STA=0;
u16 UART4_RX_STA=0;
u16 UART5_RX_STA=0;
u8 Res;
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, ENABLE);       //使能USART1，GPIOA时钟

      //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_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

}

void USART1_IRQHandler(void)                      //串口1中断服务程序
{
      u8 Res;
#if SYSTEM_SUPPORT_OS                //如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
      OSIntEnter();
#endif
      if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
      {
            Res =USART_ReceiveData(USART1);       //读取接收到的数据
            if((USART1_RX_STA&0x8000)==0)//接收未完成
                     {
                              if(USART1_RX_STA&0x4000)//接收到了0x0d
                              {
                                    if(Res!=0x0a)USART1_RX_STA=0;//接收错误,重新开始
                                    else
                                    {
                                                      USART1_RX_STA|=0x8000;
                                    }       //接收完成了
                              }
                              else //还没收到0X0D
                              {
                                    if(Res==0x0d)USART1_RX_STA|=0x4000;
                                    else
                                    {
                                             USART1_RX_BUF[USART1_RX_STA&0X3FFF]=Res ;
                                             USART1_RX_STA++;
                                             if(USART1_RX_STA>(USART1_REC_LEN-1))USART1_RX_STA=0;//接收数据错误,重新开始接收
                                    }
                              }
                     }
}
#if SYSTEM_SUPPORT_OS       //如果SYSTEM_SUPPORT_OS为真，则需要支持OS.
      OSIntExit();
#endif
}
#endif

void usart2_init(u32 bound)
{
  //GPIO端口设置
  GPIO_InitTypeDef GPIO_InitStructure;
      USART_InitTypeDef USART_InitStructure;
      NVIC_InitTypeDef NVIC_InitStructure;

      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);       //使能USART2，GPIOB时钟
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);


      //USART2_TX GPIOA2
  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);//初始化GPIOA.2

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

  //Usart2 NVIC 配置
  NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1 ;//抢占优先级3
      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;             //子优先级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(USART2, &USART_InitStructure); //初始化串口2
  USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//开启串口接受中断
  USART_Cmd(USART2, ENABLE);                   //使能串口2

}

void USART2_IRQHandler(void)                      //串口2中断服务程序
{
      if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
            {
                     Res =USART_ReceiveData(USART2);       //读取接收到的数据
                     receive();
}
}

void usart3_init(u32 bound)
{
  //GPIO端口设置
  GPIO_InitTypeDef GPIO_InitStructure;
      USART_InitTypeDef USART_InitStructure;
      NVIC_InitTypeDef NVIC_InitStructure;

      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);       //使能USART3，GPIOB时钟
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);


      //USART3_TX GPIOB10
  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);//初始化GPIOB.10

  //USART3_RX       GPIOB11
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
  GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB.11

  //Usart3 NVIC 配置
  NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1 ;//抢占优先级3
      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;             //子优先级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); //初始化串口3
  USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);//开启串口接受中断
  USART_Cmd(USART3, ENABLE);                   //使能串口3

}

void USART3_IRQHandler(void)                      //串口3中断服务程序
{
      u8 Res;
      if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
            {
            Res =USART_ReceiveData(USART3);       //读取接收到的数据
            if((USART3_RX_STA&0x8000)==0)//接收未完成
            {
                     if(USART3_RX_STA&0x4000)//接收到了0x0d
                     {
                              if(Res!=0x0a)USART3_RX_STA=0;//接收错误,重新开始
                              else
                              {
                                             USART3_RX_STA|=0x8000;
                              }       //接收完成了
                     }
                     else //还没收到0X0D
                     {
                              if(Res==0x0d)USART3_RX_STA|=0x4000;
                              else
                                    {
                                             USART3_RX_BUF[USART3_RX_STA&0X3FFF]=Res ;
                                             USART3_RX_STA++;
                                             if(USART3_RX_STA>(USART3_REC_LEN-1))USART3_RX_STA=0;//接收数据错误,重新开始接收
                                    }
                     }
            }
}
}

//void uart4_init(u32 bound)
//{
//  //GPIO端口设置
//  GPIO_InitTypeDef GPIO_InitStructure;
//       USART_InitTypeDef USART_InitStructure;
//       NVIC_InitTypeDef NVIC_InitStructure;
//
//       RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);       //使能UART4，GPIOC时钟
//  RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE);
//
//
//       //USART4_TX GPIOC10
//  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);//初始化GPIOC10
//
//  //USART4_RX       GPIOC11
//  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
//  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
//  GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化GPIOC.11

//  //Usart4 NVIC 配置
//  NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;
//       NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1 ;//抢占优先级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(UART4, &USART_InitStructure); //初始化串口3
//  USART_ITConfig(UART4, USART_IT_RXNE, ENABLE);//开启串口接受中断
//  USART_Cmd(UART4, ENABLE);                   //使能串口3

//}

void UART4_IRQHandler(void)                      //串口4中断服务程序
{
      u8 Res;
      if(USART_GetITStatus(UART4, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
            {
            Res =USART_ReceiveData(UART4);       //读取接收到的数据
            if((UART4_RX_STA&0x8000)==0)//接收未完成
                     {
                     if(UART4_RX_STA&0x4000)//接收到了0x0d
                     {
                              if(Res!=0x0a)UART4_RX_STA=0;//接收错误,重新开始
                              else
                              {
                                             UART4_RX_STA|=0x8000;
                              }       //接收完成了
                     }
                     else //还没收到0X0D
                     {
                              if(Res==0x0d)UART4_RX_STA|=0x4000;
                              else
                                    {
                                             UART4_RX_BUF[UART4_RX_STA&0X3FFF]=Res ;
                                             UART4_RX_STA++;
                                             if(UART4_RX_STA>(UART4_REC_LEN-1))UART4_RX_STA=0;//接收数据错误,重新开始接收
                                    }
                     }
            }
}
}

//void uart5_init(u32 bound)
//{
//  //GPIO端口设置
//  GPIO_InitTypeDef GPIO_InitStructure;
//       USART_InitTypeDef USART_InitStructure;
//       NVIC_InitTypeDef NVIC_InitStructure;
//
//       RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);       //使能UART5，GPIOC时钟
//       RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD, ENABLE);
//  RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART5, ENABLE);
//
//
//       //USART5_TX GPIOC12
//  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
//  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
//  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;       //复用推挽输出
//  GPIO_Init(GPIOC, &GPIO_InitStructure);//初始化GPIOC10
//
//  //USART5_RX       GPIOD2
//  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
//  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
//  GPIO_Init(GPIOD, &GPIO_InitStructure);//初始化GPIOC.11

//  //Usart5 NVIC 配置
//  NVIC_InitStructure.NVIC_IRQChannel = UART5_IRQn;
//       NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2 ;//抢占优先级3
//       NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;             //子优先级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(UART5, &USART_InitStructure); //初始化串口3
//  USART_ITConfig(UART5, USART_IT_RXNE, ENABLE);//开启串口接受中断
//  USART_Cmd(UART5, ENABLE);                   //使能串口3

//}

void UART5_IRQHandler(void)                      //串口4中断服务程序
{
      u8 Res;
      if(USART_GetITStatus(UART5, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
            {
            Res =USART_ReceiveData(UART5);       //读取接收到的数据
            if((UART5_RX_STA&0x8000)==0)//接收未完成
                     {
                     if(UART5_RX_STA&0x4000)//接收到了0x0d
                     {
                              if(Res!=0x0a)UART5_RX_STA=0;//接收错误,重新开始
                              else
                              {
                                             UART5_RX_STA|=0x8000;
                              }       //接收完成了
                     }
                     else //还没收到0X0D
                     {
                              if(Res==0x0d)UART5_RX_STA|=0x4000;
                              else
                                    {
                                             UART5_RX_BUF[UART5_RX_STA&0X3FFF]=Res ;
                                             UART5_RX_STA++;
                                             if(UART5_RX_STA>(UART5_REC_LEN-1))UART5_RX_STA=0;//接收数据错误,重新开始接收
                                    }
                     }
            }
}
}
//串口格式化打印函数
void UsartPrintf(USART_TypeDef *USARTx, char *fmt,...)
{

      unsigned char UsartPrintfBuf[296];
      va_list ap;
      unsigned char *pStr = UsartPrintfBuf;

      va_start(ap, fmt);
      vsprintf((char *)UsartPrintfBuf, fmt, ap);                                                       //格式化
      va_end(ap);

      while(*pStr != 0)
      {
            USART_SendData(USARTx, *pStr++);
            while(USART_GetFlagStatus(USARTx, USART_FLAG_TC) == RESET);
      }
}

帐号		自动登录	找回密码
密码			立即注册

正点原子精英版的所有串口统一使用 源程序

评分

正点原子精英版的所有串口统一使用源程序