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

Usart.h

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

main.cpp

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

搞定


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

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

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



小结:

下一讲,我们来使用 C++ 语言,创建一个 STM32Adc 类。

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 ...