使用 C++ 语言给 STM32 编写一个 Usart 类

我使用的STM32芯片：STM32F103ZET6

我们使用的STM32库版本：V3.5.0

注意：

  • 想学习本套 STM32 C++编程 的专栏是有点门槛的。你需要有一点点 STM32 基础 和 一点点 C++ 语言基础。

  • 完整的STM32 C++ Usart类 的下载地址可以在本篇博客的最下面找到。

Usart.cpp

  1. #include "Usart.h"
  2. #include "Gpio.h"
  4. using namespace stm32f10x;
  5. //2015-9-1 00:47:46 Usart2， Uart4,5 没有测试
  7. //_______初始化部分______________
  8. Usart::Usart(USART_TypeDef* USARTx, uint32_t USART_BaudRate, uint32_t NVIC_PriorityGroup,
  9.          uint8_t  NVIC_IRQChannelPreemptionPriority, uint8_t  NVIC_IRQChannelSubPriority)
  10.     :usartx(USARTx),baudRate(USART_BaudRate),nvicPriorityGroup(NVIC_PriorityGroup),
  11.         preemptionPriority(NVIC_IRQChannelPreemptionPriority), subPriority(NVIC_IRQChannelSubPriority){
  12.     initialize();
  13. }
  15. void Usart::initialize(){
  16.     Gpio txd,rxd;
  17.     switch((uint32_t)usartx){
  18.         case (uint32_t)USART1:  txd = Gpio(PA,9,GM_AFPP); rxd=Gpio(PA,10,GM_IN_FLOATING);   break;
  19.         case (uint32_t)USART2:  txd = Gpio(PA,2,GM_AFPP); rxd=Gpio(PA,3,GM_IN_FLOATING);    break;
  20.         case (uint32_t)USART3:  txd = Gpio(PB,10,GM_AFPP); rxd=Gpio(PB,11,GM_IN_FLOATING);  break;
  21.         case (uint32_t)UART4:   txd = Gpio(PC,10,GM_AFPP); rxd=Gpio(PC,11,GM_IN_FLOATING);  break;
  22.         case (uint32_t)UART5:   txd = Gpio(PC,12,GM_AFPP); rxd=Gpio(PD,2,GM_IN_FLOATING);   break;
  23.     }
  25.     //打开USARTx时钟
  26.     if((uint32_t)usartx < APB2PERIPH_BASE){
  27.         uint32_t RCC_APB1Periph = (uint32_t)(1<< ( ((uint32_t)usartx-APB1PERIPH_BASE)>>10));
  28.         RCC_APB1PeriphClockCmd(RCC_APB1Periph, ENABLE);
  29.     }
  30.     else{
  31.         uint32_t RCC_APB2Periph = (uint32_t)(1<< ( ((uint32_t)usartx-APB2PERIPH_BASE)>>10));
  32.         RCC_APB2PeriphClockCmd(RCC_APB2Periph, ENABLE);
  33.     }
  35.     USART_InitTypeDef USART_InitStructure;
  36.     //配置USARTx
  37.     USART_InitStructure.USART_BaudRate = baudRate;       //波特率可以通过地面站配置
  38.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;  //8位数据
  39.     USART_InitStructure.USART_StopBits = USART_StopBits_1;   //在帧结尾传输1个停止位
  40.     USART_InitStructure.USART_Parity = USART_Parity_No;    //禁用奇偶校验
  41.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None; //硬件流控制失能
  42.     USART_InitStructure.USART_Mode = USART_Mode_Tx | USART_Mode_Rx;  //发送、接收使能
  43.     USART_Init(usartx, &USART_InitStructure);
  45.     NVIC_InitTypeDef NVIC_InitStructure;
  46.     NVIC_PriorityGroupConfig(nvicPriorityGroup);
  47.     switch((uint32_t)usartx){
  48.         case (uint32_t)USART1:  NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;   break;
  49.         case (uint32_t)USART2:  NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;   break;
  50.         case (uint32_t)USART3:  NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;   break;
  51.         case (uint32_t)UART4:   NVIC_InitStructure.NVIC_IRQChannel = UART4_IRQn;    break;
  52.         case (uint32_t)UART5:   NVIC_InitStructure.NVIC_IRQChannel = UART5_IRQn;    break;
  53.     }
  54.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = preemptionPriority;
  55.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = subPriority;
  56.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  57.     NVIC_Init(&NVIC_InitStructure); 
  59.     //使能接收中断
  60.     USART_ITConfig(usartx, USART_IT_RXNE, ENABLE);
  61.     //使能USARTx
  62.     USART_Cmd(usartx, ENABLE); 
  64. }
  65. //_________初始化部分end___________________
  67. //_________发送数据部分______________________
  68. //////////发送字符串
  69. void Usart::print(const char* pfmt, ...){
  70.     double vargflt = 0;
  71.     int  vargint = 0;
  72.     char* vargpch = NULL;
  73.     char vargch = 0;
  74.     va_list vp;
  75.     va_start(vp, pfmt);
  76.     while(*pfmt){
  77.         if(*pfmt == '%'){
  78.             switch(*(++pfmt)){
  80.                 case 'c':
  81.                     vargch = va_arg(vp, int);
  82.                     /*    va_arg(ap, type), if type is narrow type (char, short, float) an error is given in strict ANSI
  83.                     mode, or a warning otherwise.In non-strict ANSI mode, 'type' is allowed to be any expression. */
  84.                     print((char)vargch);
  85.                     break;
  86.                 case 'd':
  87.                 case 'i':
  88.                     vargint = va_arg(vp, int);
  89.                     printdec(vargint);
  90.                     break;
  91.                 case 'f':
  92.                     vargflt = va_arg(vp, double);
  93.                     /*    va_arg(ap, type), if type is narrow type (char, short, float) an error is given in strict ANSI
  94.                     mode, or a warning otherwise.In non-strict ANSI mode, 'type' is allowed to be any expression. */
  95.                     print(vargflt);
  96.                     break;
  97.                 case 's':
  98.                     vargpch = va_arg(vp, char*);
  99.                     print(vargpch);
  100.                     break;
  101.                 case 'b':
  102.                 case 'B':
  103.                     vargint = va_arg(vp, int);
  104.                     printbin(vargint);
  105.                     break;
  106.                 case 'x':
  107.                 case 'X':
  108.                     vargint = va_arg(vp, int);
  109.                     printhex(vargint);
  110.                     break;
  111.                 case '%':
  112.                     print('%');
  113.                     break;
  114.                 case 'o':
  115.                 case 'O':
  116.                     vargint = va_arg(vp, int);
  117.                     printoct(vargint);
  118.                     break;
  119.                 default:
  120.                     break;
  121.             }
  122.             pfmt++;
  123.         }
  124.         else{
  125.             print(*pfmt++);
  126.         }
  127.     }
  128.     va_end(vp);
  129. }
  130. //2015年9月3日11:41:40 支持 打印 0 和 负数
  131. void Usart::printdec(int dec){
  132.     static uint8_t dp = 0;
  133.     static int _dec;
  134.     if(dec<=0 && dp == 0){
  135.         if(dec == 0){
  136.             print('0');
  137.             return ;
  138.         }else{
  139.             print('-');
  140.             dec = -dec;
  141.         }
  142.     }
  143.     if(dp ==0 ){
  144.         dp = 1;
  145.         _dec = dec;
  146.     }
  147.     if(dec==0){
  148.         return; }
  149.     printdec(dec/10);
  150.     print( (char)(dec%10 + '0'));
  151.     if(_dec == dec)
  152.         dp = 0;
  153. }
  155. void Usart::printflt(double flt){
  156.     int tmpint = 0;
  158.     tmpint = (int)flt;
  159.     printdec(tmpint);
  160.     print('.');
  161.     flt = flt - tmpint;
  162.     flt = flt<0?-flt:flt;
  163.     tmpint = (int)(flt * 1000000);
  164.     printdec(tmpint);
  165. }
  167. void Usart::printbin(int bin){
  168.     if(bin == 0){
  169.         //printstr("0b");
  170.         return; }
  171.     printbin(bin/2);
  172.     print( (char)(bin%2 + '0'));
  173. }
  175. void Usart::printhex(int hex){
  176.     if(hex==0){
  177.         //printstr("0x");
  178.         return; }
  179.     printhex(hex/16);
  180.     if(hex%16 < 10)
  181.         print((char)(hex%16 + '0'));
  182.     else
  183.         print((char)(hex%16 - 10 + 'a' ));
  184. }
  186. void Usart::printoct(int oct){
  187.     if(oct==0){
  188.         //printstr("8JinZhi");
  189.         return;
  190.     }
  191.     printoct(oct/8);
  192.     print((char)(oct%8 + '0'));
  193. }
  195. //________2015-8-31 02:57:51
  196. void Usart::print(char ch){
  197.     USART_SendData(usartx, ch);    /*发送单个数据 */
  198.     while(USART_GetFlagStatus(usartx, USART_FLAG_TXE)==RESET);/* 检测指定的USART标志位 即RESET=1时 发送完成*/
  199. }
  201. void Usart::print(const unsigned char *str){
  202.     while(*str){
  203.         USART_SendData(usartx, *str);    /*发送单个数据 */
  204.         while(USART_GetFlagStatus(usartx, USART_FLAG_TXE)==RESET);/* 检测指定的USART标志位 即RESET=1时 发送完成*/
  205.         str++;
  206.     }
  207. }
  209. void Usart::print(int val, Format format){
  210.     switch((uint8_t)format){
  211.         case (uint8_t)DEC:
  212.             printdec(val);
  213.             break;
  214.         case (uint8_t)HEX:
  215.             printhex(val);
  216.             break;
  217.         case (uint8_t)BIN:
  218.             printbin(val);
  219.             break;
  220.         case (uint8_t)OCT:
  221.             printoct(val);
  222.             break;
  223.         default:
  224.             break;
  225.     }
  226. }
  228. int Usart::pow(int a, int n){
  229.     int sum = 1;
  230.     while(n--){
  231.         sum = sum*a;
  232.     }
  233.     return sum;
  234. }
  235. void Usart::print(double flt, uint8_t  para){
  236.     int tmpint = 0;
  237.     tmpint = (int)flt;
  238.     printdec(tmpint);
  239.     print('.');
  240.     flt = flt - tmpint;
  241.     flt = flt<0?-flt:flt;
  242.     tmpint = (int)(flt * pow(10, para));
  243.     printdec(tmpint);
  245. }
  247. void Usart::println(const char* pfmt, ...){
  248.     double vargflt = 0;
  249.     int  vargint = 0;
  250.     char* vargpch = NULL;
  251.     char vargch = 0;
  252.     va_list vp;
  253.     va_start(vp, pfmt);
  254.     while(*pfmt){
  255.         if(*pfmt == '%'){
  256.             switch(*(++pfmt)){
  258.                 case 'c':
  259.                     vargch = va_arg(vp, int);
  260.                     /*    va_arg(ap, type), if type is narrow type (char, short, float) an error is given in strict ANSI
  261.                     mode, or a warning otherwise.In non-strict ANSI mode, 'type' is allowed to be any expression. */
  262.                     print((char)vargch);
  263.                     break;
  264.                 case 'd':
  265.                 case 'i':
  266.                     vargint = va_arg(vp, int);
  267.                     printdec(vargint);
  268.                     break;
  269.                 case 'f':
  270.                     vargflt = va_arg(vp, double);
  271.                     /*    va_arg(ap, type), if type is narrow type (char, short, float) an error is given in strict ANSI
  272.                     mode, or a warning otherwise.In non-strict ANSI mode, 'type' is allowed to be any expression. */
  273.                     print(vargflt);
  274.                     break;
  275.                 case 's':
  276.                     vargpch = va_arg(vp, char*);
  277.                     print(vargpch);
  278.                     break;
  279.                 case 'b':
  280.                 case 'B':
  281.                     vargint = va_arg(vp, int);
  282.                     printbin(vargint);
  283.                     break;
  284.                 case 'x':
  285.                 case 'X':
  286.                     vargint = va_arg(vp, int);
  287.                     printhex(vargint);
  288.                     break;
  289.                 case '%':
  290.                     print('%');
  291.                     break;
  292.                 case 'o':
  293.                 case 'O':
  294.                     vargint = va_arg(vp, int);
  295.                     printoct(vargint);
  296.                     break;
  297.                 default:
  298.                     break;
  299.             }
  300.             pfmt++;
  301.         }
  302.         else{
  303.             print(*pfmt++);
  304.         }
  305.     }
  306.     va_end(vp);
  307.     print("\n");
  308. }
  310. void Usart::println(double flt, uint8_t  para){
  311.     print(flt, para);
  312.     print("\n");
  313. }
  315. void Usart::println(int val, Format format){
  316.     print(val, format);
  317.     print("\n");
  318. }
  320. //////发送数据
  321. void Usart::write(u8 val){
  322.     print((char)val);
  323. }
  324. //请注意 int8_t,vs8 原型都是 int(32位的)  并不是char(8位的)
  325. void Usart::write(char val){
  326.     print((char)val);
  327. }
  329. void Usart::write(u16 val){
  330.     print((char)BYTE1(val));
  331.     print((char)BYTE0(val));
  332. }
  334. void Usart::write(vs16 val){
  335.     print((char)BYTE1(val));
  336.     print((char)BYTE0(val));
  337. }
  339. void Usart::write(u32 val){
  340.     print((char)BYTE3(val));
  341.     print((char)BYTE2(val));
  342.     print((char)BYTE1(val));
  343.     print((char)BYTE0(val));
  344. }
  346. void Usart::write(vs32 val){
  347.     print((char)BYTE3(val));
  348.     print((char)BYTE2(val));
  349.     print((char)BYTE1(val));
  350.     print((char)BYTE0(val));
  351. }
  352. //_________发送部分end______________________
  354. unsigned char Usart::read(){
  355.     unsigned char ch;
  356.     if(USART_GetITStatus(usartx, USART_IT_RXNE) != RESET){
  357.         ch = USART_ReceiveData(usartx);
  358.         print("%c",ch);
  359.     }
  360.     return ch;
  361. }

Usart.h

  1. #ifndef     __USART_H_
  2. #define __USART_H_
  4. #include "stm32f10x.h"
  5. #include <stdio.h>
  6. #include <stdarg.h>
  8. namespace stm32f10x
  9. {
  11. enum Format
  12. {//2,   10 , 8,   16 进制
  13. BIN=1, DEC, OCT, HEX,
  14. };
  16. #define BYTE0(dwTemp)       (*(char *)(&dwTemp))
  17. #define BYTE1(dwTemp)       (*((char *)(&dwTemp) + 1))
  18. #define BYTE2(dwTemp)       (*((char *)(&dwTemp) + 2))
  19. #define BYTE3(dwTemp)       (*((char *)(&dwTemp) + 3))
  21. class Usart{
  22.     public:
  23.     //初始化部分
  24.         Usart(USART_TypeDef* USARTx = USART1,
  25.                 uint32_t USART_BaudRate = 115200,
  26.                 uint32_t NVIC_PriorityGroup = NVIC_PriorityGroup_0,
  27.                 uint8_t  NVIC_IRQChannelPreemptionPriority = 0,
  28.                 uint8_t  NVIC_IRQChannelSubPriority = 1
  29.                 );
  30.         void initialize();
  31.     //发送字符串部分
  32.         void print(const char* ch, ...);
  33.         void print(int val, Format format= DEC);
  34.         void print(double flt, uint8_t  para = 2);
  35.         void println(const char* ch = "", ...);
  36.         void println(int val, Format format= DEC);
  37.         void println(double flt, uint8_t  para = 2);
  38.     //发送数据部分
  39.         void write(u8 val);    //unsigned char, uint8_t
  40.         void write(char val);  //char         //请注意 int8_t,vs8 原型都是 int(32位的)  并不是char(8位的)
  41.         void write(u16 val);   //uint16_t
  42.         void write(vs16 val);  //int16_t
  43.         void write(u32 val);   //unsigned int, uint32_t
  44.         void write(vs32 val);  //int, int32, int8_t, vs8
  45.     //接收数据部分
  46.         unsigned char read();
  47.     private:
  48.         USART_TypeDef* usartx;
  49.         uint32_t       baudRate;
  50.         uint32_t       nvicPriorityGroup;
  51.         uint8_t    preemptionPriority;
  52.         uint8_t        subPriority;
  54.         void print(char ch);
  55.         void print(const unsigned char *str);
  56.         void printdec(int dec);
  57.         void printflt(double flt);
  58.         void printbin(int bin);
  59.         void printhex(int hex);
  60.         void printoct(int oct);
  61.         int pow(int a, int n);
  63. };
  65. }
  67. #endif

main.cpp

  1. /* Includes ------------------------------------------------------------------*/
  2. #include "stm32f10x.h"
  3. #include "Usart.h"
  5. using namespace stm32f10x;
  6. /* Private functions ---------------------------------------------------------*/
  7. Usart Serial(USART1, 115200);
  8. //  Usart Serial;
  10. /**
  11.   * @brief  Main program.
  12.   * @param  None
  13.   * @retval None
  14.   */
  16. int main(void)
  17. {
  18. //  uint8_t val8 = 0x33;
  19. //  uint32_t val32 = 0x21122112;
  20.     while(1){
  21.         Serial.println("1.%f",-123.4545);
  22.         Serial.println("2.%o",123);
  23.         Serial.println("3.print: %c", 'c');
  24.         Serial.println("4.print: %s", "string test");
  25.         Serial.println("5.print: %b, %d", 0x12345ff, 4343);
  26.         Serial.println("%d", -4343);
  27.         Serial.println("6.print: %x", 0xa1d);
  28. //      Serial.println("7.print: %%");
  29. //      Serial.println(1234, BIN);
  30. //      Serial.println(12.3434, 4);
  31. //      Serial.write(val8);
  32. //      Serial.write(val32);
  33. //      Serial.println();
  34.     }
  36. }

搞定

你可以到这里下载我已经做好的 STM32 C++ Usart类：

百度云 链接：http://pan.baidu.com/s/1bpbZ2MV 密码：esam

也可以在CSDN里面下载：http://download.csdn.net/detail/github_35160620/9623335

小结：

下一讲，我们来使用 C++ 语言，创建一个 STM32 的 Adc 类。

STM32 C++编程 003 USART(串口)类的更多相关文章

  1. STM32（6）——USART串口的使用

    1. 串口的基本概念 在STM32的参考手册中,串口被描述成通用同步异步收发器(USART),它提供了一种灵活的方法与使用工业标准NRZ异步串行数据格式的外部设备之间进行全双工数据交换.USART利用 ...

  2. STM32 C++编程 004 Adc (数模转换)类

    使用 C++ 语言给 STM32 编写一个 Adc 类 我使用的STM32芯片:STM32F103ZET6 我们使用的STM32库版本:V3.5.0 注意: 想学习本套 STM32 C++编程 的专栏 ...

  3. STM32 C++编程 005 I2c(Soft)类

    使用 C++ 语言给 STM32 编写一个 I2c(Soft)类 我使用的STM32芯片:STM32F103ZET6 我们使用的STM32库版本:V3.5.0 注意: 想学习本套 STM32 C++编 ...

  4. STM32之旅4——USART

    STM32之旅4--USART 串口也是用的比较多的,在STM32CubeMX中生成代码后,需要添加一些代码才可以用. drv_usart.h: #ifndef __DRV_USART_H #defi ...

  5. STM32 C++编程 002 GPIO类

    使用 C++ 语言给 STM32 编写一个 Gpio 类 我使用的STM32芯片:STM32F103ZET6 我们使用的STM32库版本:V3.5.0 注意: 想学习本套 STM32 C++编程 的专 ...

  6. 单片机stm32 USART串口实际应用解析

    stm32作为现在嵌入式物联网单片机行业中经常要用多的技术,相信大家都有所接触,今天这篇就给大家详细的分析下有关于stm32的出口,还不是很清楚的朋友要注意看看了哦,在最后还会为大家分享有些关于stm ...

  7. stm32 usart 串口

    比特率是每秒钟传输二进制代码的位数,单位是:位/秒(bps).如每秒钟传送240个字符, 而每个字符格式包含10位(1个起始位.1个停止位.8个数据位),这时的比特率为: 10位 × 240个/秒 = ...

  8. 第20章 USART—串口通讯—零死角玩转STM32-F429系列

    第20章      USART—串口通讯 全套200集视频教程和1000页PDF教程请到秉火论坛下载:www.firebbs.cn 野火视频教程优酷观看网址:http://i.youku.com/fi ...

  9. 【STM32H7教程】第29章 STM32H7的USART串口基础知识和HAL库API

    完整教程下载地址:http://www.armbbs.cn/forum.php?mod=viewthread&tid=86980 第29章       STM32H7的USART串口基础知识和 ...

随机推荐

  1. 17 python 内置函数

    内置函数:Python的内部自带的函数 作用域相关: 基于字典的形式获取局部变量和全局变量 globals()——获取全局变量的ha1 locals()——获取执行本方法所在命名空间内的局部变量的字典 ...

  2. js改变select的选中项不触发select的change事件

    // test var selectEl = document.querySelector('select') var buttonEl = document.querySelector('butto ...

  3. [转]Angular移除不必要的$watch之性能优化

    双向绑定是Angular的核心概念之一,它给我们带来了思维方式的转变:不再是DOM驱动,而是以Model为核心,在View中写上声明式标签.然后,Angular就会在后台默默的同步View的变化到Mo ...

  4. C# 保护进程不被结束(源代码）防任务管理器结束进程

    C# 保护进程不被结束(源代码)防任务管理器结束进程 Posted on 2013-03-25 16:03 快乐家++ 阅读(3173) 评论(3) 编辑 收藏 闲来无事,英语又学的太痛苦.看到我妈妈 ...

  5. error: cast from ‘char*’ to ‘int’ loses precision

    程序: char* addrCom; addrCom= ......//赋值 == (int)addrCom) //导致编译出错 { ...... } 编译时出现错误: error: cast fro ...

  6. JDK7和JDK8新特性

    参考:http://www.cnblogs.com/langtianya/p/3757993.html JDK 1.7 新特性 1,switch中可以使用字串了 String s = "te ...

  7. springboot springcloud eureka

    参考: https://www.cnblogs.com/skyblog/p/5133752.htmlhttp://blog.csdn.net/u012734441/article/details/78 ...

  8. DBUtils使用BeanListHandler及BeanHandler时返回null

    一.使用Bean相关方法时返回null 问题描述: 使用DBUtils查询数据,如果使用ArrayListHandler等都能够返回正确值,但使用BeanListHandler 和 BeanHandl ...

  9. 问题：C#Chart控件自动添加Series；结果：图形组件Chart动态添加Series

    Chart1.DataSource = dtb; string[] strcolor = new string[20]; strcolor[0] = "220, 224, 64, 10&qu ...

  10. java.lang.ClassCastException: org.apache.catalina.connector.RequestFacade cannot be cast to org.springframework.web.multipart.MultipartHttpServletRequest

    转自:https://blog.csdn.net/iteye_17476/article/details/82651580 java.lang.ClassCastException: org.apac ...