你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

用C++写单片机程序STM32F103+自建固件库+FreeRTOS gcc编译器  

[复制链接]
freemancn 发布时间:2019-8-17 18:13
用C++写单片机程序 STM32F103 + 自建固件库 + FreeRTOS 用gcc编译器和newlib(1篇)
/ S$ W1 Q! V8 L$ s
  H" j. h) e" k3 s! M9 ]2 f
& g5 K# {' s+ g8 `1 J5 ^& X
       作为论坛的新人,先自我介绍一下。本人有10年的Win平台开发经验,从VS6.0一直用到VS2019,主要使用C#构建程序。在安徽某大学任教C语言程序设计7年,C语言自然是滚花烂熟。由于工作需要或者说是个人爱好,转战单片机。刚开始学习也是51+Keil用C语言开发,既然是学习实现的功能并不复杂,编写的代码量也不大,但还是体会到什么是一夜回到解放前。Keil的代码自动完成功能太弱鸡,如果做正式的项目效率会非常低。当时也只是想想而已,因为知道自己并不会去做实际的项目。之后当然就是学习STM32了,选择STM32主要是看中了中文资料多,学习人数多学习氛围好。STM32十足让我惊叹,比51复杂N倍的体系架构,超多的片上外设,还有如此低廉的价格。深入学习后发现还是Keil+C语言,至少市面上99%的学习都是基于这一框架的。非常的失望,非常的不适应。因为之前用C#开发Win应用,肯定是面向对象的开发思路,因为.NET Framework(相当于STM32的固件库)就是OO(面相对象)设计的,这么多年用下来,也深深的体会到OO的优势。不光是程序设计思路,还有就是IDE(集成开发环境)对开发者的重要性。我独自开发的Win应用最大的有10万行代码,我可以很轻松的构建,还能很轻松的完成代码维护,这里的代码维护指的是修订BUG,优化功能,增加功能,版本迭代等等。
" A8 d5 H" @! A& ~; f. t* N- ]
8 C5 [& K( m+ O8 j5 b

# x$ \0 h% W& B7 V) s+ J       STM32F103的主频已有72MHz,复杂的系统架构,超多的片上外设。想要喂饱这个MCU或者说是发挥出它强大的功能,肯定是需要大量代码的。当代码数量达到一定规模,自然要面对代码结构的问题。用Keil+C可以做,完成需要的功能肯定没有问题,而且现在绝大多数人都在这么做。但是C语言是面相过程的语言,对代码结构毫无帮助,毫无益处,因为无计可施。达到一定规模后,代码逻辑估计只有设计者很清楚,别人要想看懂是一件很耗费时间的事情。导致这一结果的原因是有大量的宏,更可怕的是宏嵌套、使用全局变量,这个变量会被多少函数共享,在什么时候会被改变分析起来很头疼、大量的函数,这些函数在语言层面是相互独立的,但逻辑上可能是有联系的,在语言级并没有这种逻辑关系的表达。就像官方的HAL库,我读起来想死的心都有。不是我读不懂而是读懂这些我付出的时间代价太大,要在OO思路下,这个要轻松N倍。时间就是金钱,效率就是生命。官方的HAL库其实就是想实现一个硬件抽象层,让开发者对于不同型号的MCU有一个统一的应用层开发界面,提高代码的移植性,缩短开发周期。想法是好的,做法是失败的,因为HAL库还是再用C语言编写,硬是用C语言套OO思路,代码恶心到极致。这也就是STD库还是有人在用的原因。如果使用真OO就可以把逻辑上有关联的函数组织到一起,将一些全局变量限定在部分函数中共享,其实这就OO中的封装,是语言层面提供的支持。还有要吐槽的地方就是IDE,VS的代码自动完成功能真的很好用,只要你按下任何按键都会出现提示列表,按下空格自动填充你还没有输入的内容,还有参数列表的提示。带来的好处就是,我不需要记住所有函数的名称和参数列表,我只要有一个模糊的映像,输入代码的时候IDE协助我完成。让我专注于逻辑思路,代码只是完成逻辑思路的工具而已。对语言再熟悉,对函数再熟悉,没有一个好的逻辑思路仍然写不出优秀的应用。不光是代码自动完成,还有代码着色,代码折叠,代码重构等等IDE功能,对于开发真的是不可或缺。Keil可能也有这方面的支持,但和其它一些IDE相比真的太弱了。再次重申一遍,时间就是金钱,效率就是生命。Keil+C可以吐槽的地方还有很多很多,我可以给你说一整天,我并不想开吐槽大会,只是想告诉大家其实可以有更好的选择。
% z7 E6 @0 I/ Q  ~6 D8 c/ W0 G" N8 N7 \" G& L$ i9 z7 P+ G5 G

- e2 g- I: V- c, b6 g* l/ y6 j      说一下代码效率问题,这可能是大家非常关注的地方。绝大多数人会认为C++的时间效率不如C,但是你要知道C++是C的超集,使用C++开发并不是什么地方都必须C++,你任然可以写C函数,任然可以写嵌入汇编代码。C++的效率损失主要是函数调用,C语言中会将参数压栈,而C++对象函数除了压栈参数以外还要压栈一个this指针,多一个32位的变量而已。表面上看是多了一个参数,但事实上呢?C语言函数可能需要4个参数,而对象函数的这个this指针却能代表这4个参数,因为C++通过这个this指针去访问私有变量,而这些私有变量恰恰是C函数的那4个参数。以上的说明可能过于抽象,你现在未必需要知道细节,你只要明白一点,效率的损失不是绝对的,有时却是一种效率的提升。再高级一点的效率损失来自于多态。在C99里面已有函数参数的多态支持,即使相同函数名但参数不同,调用时根据给定参数自动选择对应的函数。这种多态在C++里面也是存在的,但这种多态是在编译时完成的,对运行效率毫无影响。而虚函数多态的效率损失才是重点,当使用基类指针指向一个子类并调用虚函数,实际运行的时候会确定实际对象的类型去调用不同版本的虚函数,这需要在运行时查找虚函数表来完成,多了一个查找的过程,在内存中多了一份虚函数表。但是这种特性有助于实现一个优秀的代码结构或设计思路,用纯C可能实现不了或者实现了效率也未必比C++来的高效,而代码的逻辑和结构肯定没有C++的优雅,构建的速度也没有C++来的快。对于虚函数的采用是选择性的,没有什么项目在任何位置都需要虚函数。而一些普通的代码,例如:int a, b; a = 10; b = a + 200; if、for......不管是用C还是C++生成的汇编代码都是一致的。第二是空间效率,上面也分析了时间效率,所以空间效率可能有所损失,但也不是绝对的。当你用到一些特性的时候,执行的代码量必然增加,所以固件的体积肯定会有所增加。C++还有个STL库,里面实现了很多基础类,这些基础类可以直接使用或者进行再封装。当你使用这个库时,固件体积会极速增加。对于一些Flash只有64K或更小的MCU,可能有点紧张。但对于更大容量的Flash完全就不是问题了。使用这个库的好处就是,更少的BUG,更快的构建速度。这也是选择性的,你可以根据实际情况自由选择。而C语言中的常用库,例如printf、abs、floor等在C++中也是可以用的,且不会因为你是C++这些库函数就发生变化。总结起来就是可能会带来一些效率的损失,这些损失大部分是选择性的,当你选择牺牲性能的同时会得到C语言无法实现的功能,得到优雅的代码,得到清晰的逻辑,得到快速的构建。对于当今的MCU性能的损失往往都是可以接受的,你能不能喂饱单片机反而是个问题。当你在C++中需要极致性能的时候,你任然可以像C语言一样,该干嘛干嘛。+ j3 U! V; x5 K

% I* f+ L  _- n/ M" l9 G
- q  K3 i: o  M7 O7 y7 `) W
       互联网上可以找到的资料实在是少之又少,断断续续搞了2年,现在已经完整构建了整个环境,打算写一个连载。这是第一篇,主要是阐述这种开发环境的优势。后面将陆续给大家分享开发环境的搭建,为什么要自建固件库,如何自建固件库,FreeRTOS如何与C++联合使用,newlib中如何实现printf重定向到串口,以及在实践过程中遇到的各种零碎的问题。随着芯片科技的不断进步,MCU性能的进一步加强,我相信这种环境将是未来的主流。也希望一些技术大牛不要再保守秘密了,把真正的技术都分享出来,彻底提升MCU编程。目前我已在用这个环境做实际的项目了,下面给一张开发环境的截图。能回复的回复一下啊,让我有写完整篇的动力。& C$ |' i  w. P; l0 ~( B8 D! t% c; f4 N
IED.jpg . f$ J  j6 q# ^2 P, f2 b1 l( L' A

' s: g5 |1 T" V8 l+ E, p" ]
2 N* p( R7 r" d, e
赞 收藏 5 评论31 发布时间:2019-8-17 18:13

举报

31个回答
freemancn 回答时间:2020-11-19 21:43:03
mylovemcu 发表于 2020-11-13 14:08: X; B5 P2 ~' `# W: ~" @  P
老师去哪了  怎么不更新了  搞一个库上来学习一下" l2 y" r2 O5 l7 I/ G& b8 o
想看看你的顶层库怎么写的  我现在也在用C++  底层库太费 ...
- t  h+ u/ h% ?! X( k  b6 R
分享一个
8 a6 Z& O# _, E& w7 s* n5 j" Z
4 v# o0 [8 s' s- n4 W( s#ifndef RCC_HPP_. ^3 G/ J0 R. k7 y8 b$ m- G4 r
#define RCC_HPP_
+ s* X8 z1 h) I) ^9 ^
3 N4 U0 d" M1 s/ A1 B- s/ v0 K#include "STM32F103.h"" W5 C5 O0 u0 X* m' O9 Y$ ^
/ Q& d( q2 o. T/ b2 z
namespace MCU. ^1 ?/ h2 \3 ^
{8 K( q  C! g. t+ g0 O! G) J
        namespace STM32F103
% X, R% h* O, n+ A        {; z* Y9 X. W0 e/ u5 E+ F/ G# `; o
                struct RegisterRCC
- V$ P4 a" E+ X4 H5 P. r5 a                {, n( ?, i4 w& e$ n* @) y" x6 o6 J* F
                        volatile union2 r8 n3 R+ [# G% }8 E, w: U5 G4 T! @
                        {
6 v  ~9 n. K. m8 L; c                                volatile uint32_t Value;& n0 q; ], a0 E1 b; G5 {
                        . Q: Y  u2 A! h0 _3 s
                                volatile struct6 U" L, {) e# L& c* [( a
                                {% c* f- g! t, B- z
                                        volatile uint32_t HSION : 1;; I' Q! h  x7 u! e* l0 ~: }7 M
                                        volatile const uint32_t HSIRDY : 1;
0 g7 A6 [0 s4 P1 R5 A$ G  ?& ^                                        volatile uint32_t RESERVED1 : 1;
% y* e6 z& A0 }4 H                                        volatile uint32_t HSITRIM : 5;+ J. f7 r' T: @
                                        volatile const uint32_t HSICAL : 8;
* |. q* v; K" ?4 f  }" H. ~                                        volatile uint32_t HSEON : 1;2 \5 `, S; Z5 B7 [% u
                                        volatile const uint32_t HSERDY : 1;0 _* j2 f2 G9 O$ G+ M1 P. I, Q; D3 v" _
                                        volatile uint32_t HSEBYP : 1;
& x) h( S. L. w2 b                                        volatile uint32_t CSSON : 1;" e; s6 {+ ?/ o4 b1 i( I7 ]9 e
                                        volatile uint32_t RESERVDE2 : 4;) Y8 y. }9 x  k  w) K, H  s
                                        volatile uint32_t PLLON : 1;$ V  o( R/ a$ w0 _
                                        volatile const uint32_t PLLRDY : 1;
2 m2 Y; b0 x4 T2 o' I5 x$ P                                        volatile uint32_t RESERVDE3 : 6;) t' @% G; A9 k- I
                                }Bit;% j7 z* `0 c) G
                        }CR;
8 D. |6 _! F0 W
8 u' K+ ?" ^. F# O  n$ x1 g, t! h) \                        volatile union9 B+ D9 O% G7 i+ Q( r( s
                        {( ?# s, S6 q4 i; Q* C: I9 |+ f
                                volatile uint32_t Value;- [8 @7 b3 u- \; F( T
                        
, ]" f, B2 d. \* k! ^                                volatile struct
6 E$ Y" K+ c( V* y: h# s2 L5 b                                {
% Y( v% A$ ~, l0 O' L                                        volatile uint32_t SW : 2;5 `4 d, ~  G  `6 S, V* @
                                        volatile const uint32_t SWS : 2;
+ R8 ^: J# u+ x6 c                                        volatile uint32_t HPRE : 4;% B3 j. F7 `/ i8 D; o: Q
                                        volatile uint32_t PPRE1 : 3;4 V, {* s* e  C+ t
                                        volatile uint32_t PPRE2 : 3;
4 L' I7 h1 W1 |7 n1 z  X! L                                        volatile uint32_t ADCPRE : 2;
- J4 w& c- n8 K4 ~                                        volatile uint32_t PLLSRC : 1;& u% L7 @7 n! x" y5 v& G! `9 D
                                        volatile uint32_t PLLXTPRE : 1;
7 D6 q  x" E7 G4 s2 o                                        volatile uint32_t PLLMUL : 4;7 H- ?1 V6 }9 \' T/ V
                                        volatile uint32_t USBPRE : 1;* u* q" J$ a1 t) n& ]
                                        volatile uint32_t RESERVED1 : 1;+ ^' T' m& M' u5 S/ y
                                        volatile uint32_t MCO : 3;4 r6 b) N( H5 m8 I% j
                                        volatile uint32_t RESERVED2 : 5;
  U/ Q0 P/ }, ]! Q1 t: ~: ^                                }Bit;+ S* Z6 b( L0 [( A$ y0 c1 o  g
                        }CFGR;/ P" q& t4 Z5 X& X" x8 A
               
+ y2 Y9 n( ?# B/ I4 w4 O: [) E( H                        volatile union6 K/ Z1 q) B- E& v% L+ f1 }1 T3 ^
                        {, w# S, u( u- z
                                volatile uint32_t Value;
: N3 J! `* |3 P( F8 c                        5 G1 `- Q0 C5 b* v, ~0 E) \
                                volatile struct0 o: |$ @. |/ p+ d
                                {! \( g3 x5 Q' M
                                        volatile const uint32_t LSIRDYF : 1;) C4 c2 F8 \7 D# y3 l  C4 C+ J7 t
                                        volatile const uint32_t LSERDYF : 1;
1 |! J7 v1 N, _0 Z  ?                                        volatile const uint32_t HSIRDYF : 1;
% M; m: g) T. p* i                                        volatile const uint32_t HSERDYF : 1;
7 z- D1 N; K9 e$ i( w' l                                        volatile const uint32_t PLLRDYF : 1;
/ q  ]! Z& |$ p; c/ Z9 c  z- n                                        volatile const uint32_t PLL2RDYF : 1;5 j% X- ?! c' B; N
                                        volatile const uint32_t PLL3RDYF : 1;6 a1 }6 X5 o/ M4 ]
                                        volatile const uint32_t CSSF : 1;9 h6 U* T/ T( g  G- R- [
                                        volatile uint32_t LSIRDYIE : 1;0 }6 r, y" @/ L- N5 n! V2 L
                                        volatile uint32_t LSERDYIE : 1;4 t, ?% _% d; G. n& }2 w- e  x
                                        volatile uint32_t HSIRDYIE : 1;9 y: W% N8 G& h9 h! |
                                        volatile uint32_t HSERDYIE : 1;
: [. w, ^$ `/ b) {( O/ S  @                                        volatile uint32_t PLLRDYIE : 1;
' \1 E- M/ z/ @$ L  O" l                                        volatile const uint32_t PLL2RDYE : 1;
' o2 j; e8 _) b                                        volatile const uint32_t PLL3RDYE : 1;
7 a3 _0 F6 _3 _                                        volatile uint32_t RESERVED1 : 1;
, E& h. v4 A' F2 g- M! I$ x                                        volatile uint32_t LSIRDYC : 1;
+ T' d; U3 v3 ]  I& Q/ b& h1 l                                        volatile uint32_t LSERDYC : 1;1 P6 K/ [  x% G8 F3 f# y
                                        volatile uint32_t HISRDYC : 1;3 V6 j- M6 K/ G; e5 G& E, q
                                        volatile uint32_t HSERDYC : 1;2 I# d- a" L2 r8 I
                                        volatile uint32_t PLLRDYC : 1;4 Z, ^: v9 m6 A  E2 V; P
                                        volatile uint32_t PLL2RDYC : 1;; K( Q9 c; C8 ~6 F* Y/ `
                                        volatile uint32_t PLL3RDYC : 1;  W& u7 b8 I! X3 a- @. H, j
                                        volatile uint32_t CSSC : 1;
4 X2 F9 a( x/ ~8 ~: ^. J6 p                                        volatile uint32_t RESERVED2 : 8;
( m, e0 Z/ A# w                                }Bit;- f& f2 I* t4 r+ _4 G0 i( _
                        }CIR;
9 J1 j; K9 F$ b, p  t/ _! A               
3 P- F, c! h: M8 o) u                        volatile union
4 {' p2 y5 y& H/ |& Y4 ^/ o! h                        {& r* a. K. W4 A- Q8 B- h0 T
                                volatile uint32_t Value;0 J+ y- K" |+ H2 p' S
                        & l3 T& L2 p# g- [5 U" n
                                volatile struct+ T& F2 g5 N1 W1 ?* q4 z7 n
                                {+ }0 f7 i6 P8 `7 R
                                        volatile uint16_t AFIORST : 1;  @. N8 u8 I9 W) l* {0 P; B7 h& h
                                        volatile uint16_t RESERVED1 : 1;( O6 v! j# r+ C: k5 C, f
                                        volatile uint16_t IOPARST : 1;
1 p( {8 k& u# u                                        volatile uint16_t IOPBRST : 1;
3 X2 G6 z% ^! O+ X" q5 X5 V9 U" X1 ]                                        volatile uint16_t IOPCRST : 1;1 w( j: T8 g: y* d( d
                                        volatile uint16_t IOPDRST : 1;
' B1 S2 s& ]0 ~; n, O                                        volatile uint16_t IOPERST : 1;# j$ ^' z2 q, m
                                        volatile uint16_t IOPFRST : 1;* r! A8 D- X1 b5 r6 V: c9 p
                                        volatile uint16_t IOPGRST : 1;! Z8 n) L1 c; r, ?' ^% T! |1 c5 k
                                        volatile uint16_t ADC1RST : 1;
2 L* o2 E% F) k  b' t                                        volatile uint16_t ADC2RST : 1;
4 T) Q) M4 j2 @2 {) z8 n$ h5 o                                        volatile uint16_t TIM1RST : 1;, `3 Z4 n4 D$ n9 C" V
                                        volatile uint16_t SPI1RST : 1;
# I% u# Z- c( U5 e) Q2 k                                        volatile uint16_t TIM8RST : 1;
; D( V$ |: J9 V5 O& A% b, T% Q                                        volatile uint16_t USART1RST : 1;
: k  J( N$ D& u                                        volatile uint16_t ADC3RST : 1;
4 \% G* \2 [" \                                        volatile uint16_t RESERVED2 : 16;: Y" t, U) J; t4 i1 U4 S! w
                                }Bit;8 k- ~* C' ^" H' a) w' ]
                        }APB2RSTR;5 S4 @- b+ s+ ]. n; j8 S/ c
                ( ?8 {/ m2 I8 A
                        volatile union
( C% S. L9 Q: J" e4 c                        {
2 |( ~. J: v7 @% o% {+ _                                volatile uint32_t Value;0 A8 v1 m$ _) A/ b# T4 h0 F$ g
                        & _% i6 P% p2 H
                                volatile struct9 x7 V. Y! d3 T
                                {" {- q+ t" ~9 k% R# N
                                        volatile uint32_t TIM2RST : 1;! z2 ~6 K/ X3 T
                                        volatile uint32_t TIM3RST : 1;
' n( p9 d0 g( ^. m, z2 ]8 h5 S/ P                                        volatile uint32_t TIM4RST : 1;$ f1 ~  X3 Q+ }5 c
                                        volatile uint32_t TIM5RST : 1;
; \5 {0 T2 o9 {( v$ |. x6 p. u                                        volatile uint32_t TIM6RST : 1;/ K9 @& V4 m' }/ B; S9 m
                                        volatile uint32_t TIM7RST : 1;
; n" j& Z0 }5 |; e# ]                                        volatile uint32_t RESERVED1 : 2;
/ z. @  \3 r; x; K5 |, D7 R8 O, T# k                                        volatile uint32_t RESERVED2 : 3;
! ?6 l" Y9 O' g* c6 J5 p" v* F                                        volatile uint32_t WWDGRST : 1;
3 J7 w+ P. H* b  m" N: J7 Y                                        volatile uint32_t RESERVED3 : 2;. h) q7 f" V, M- G3 {; V  y
                                        volatile uint32_t SPI2RST : 1;' O  e7 S3 K3 X5 k- Z. J( w
                                        volatile uint32_t SPI3RST : 1;
1 M* y2 |4 L1 W/ A, X+ e. r                                        volatile uint32_t RESERVED4 : 1;1 C1 [# ^" \- W5 |
                                        volatile uint32_t USART2RST : 1;0 {( l; X7 ~# Q8 z* f. a2 @0 S, |
                                        volatile uint32_t USART3RST : 1;
" ^! [% f! ?$ V+ S# y$ Z8 g, r                                        volatile uint32_t USART4RST : 1;) p2 F7 h* ?4 g  h
                                        volatile uint32_t USART5RST : 1;
9 g5 e5 u4 w$ M* }0 L                                        volatile uint32_t I2C1RST : 1;+ ]4 a: e2 G' Q% H
                                        volatile uint32_t I2C2RST : 1;9 Y* P% k  q. F# g
                                        volatile uint32_t USBRST : 1;
) x/ D% y" r6 w# X2 S                                        volatile uint32_t RESERVED5 : 1;% s$ L8 I4 ]6 d! J/ |
                                        volatile uint32_t CANRST : 1;/ o  h* K) E8 b- H4 o
                                        volatile uint32_t RESERVED6 : 1;' m' H9 ~2 ?* V5 p) n5 Q
                                        volatile uint32_t BKPRST : 1;
+ m6 H8 z) \7 x8 j                                        volatile uint32_t PWRRST : 1;
/ n: T' Z) S( t. B                                        volatile uint32_t DACRST : 1;
4 M" W( c, D; _# n5 w                                        volatile uint32_t RESERVED7 : 2;
  J( L, D( C# j+ E& T/ k- [( c! K                                }Bit;7 ?5 U' z7 Z; a( o
                        }APB1RSTR;
- X+ ^8 w' ], p4 Q( B# E               
) s3 l0 I; \3 v3 L5 ?                        volatile union3 R  o# Z/ ~% K8 I. c
                        {
2 j# |0 W1 k2 [. c4 d2 C                                volatile uint32_t Value;0 M7 J# U- n' }
                        5 @1 z$ f3 ?5 L  I+ _
                                volatile struct
" W( `4 ^8 O8 q! p# w                                {
2 A: L9 m, q- _- v7 U/ z                                        volatile uint16_t DMA1EN : 1;. s3 o5 U% L" e) N& e, p1 e
                                        volatile uint16_t DMA2EN : 1;0 @7 N7 G1 q2 ?
                                        volatile uint16_t SRAMEN : 1;
+ j* V* ~; o4 P( A: l1 ?                                        volatile uint16_t RESERVED1 : 1;' M$ c/ o' t* r7 [# b9 J8 `
                                        volatile uint16_t FLITFEN : 1;
% _9 U1 B" z! a& M. z                                        volatile uint16_t RESERVED2 : 1;9 `9 ?1 G1 C3 P# l" h
                                        volatile uint16_t CRCEN : 1;
. t! Z5 b) Y- p, f7 u                                        volatile uint16_t RESERVED3 : 1;, g2 B: B. W) b' T( p
                                        volatile uint16_t FSMCEN : 1;# D% v+ r( P8 o, l
                                        volatile uint16_t RESERVED4 : 1;
% `4 w% L- {! C2 Z5 L- `& r                                        volatile uint16_t SDIOEN : 1;
# F( ]% C5 D, M; o/ z) f  f                                        volatile uint16_t RESERVED5 : 5;
: \# Z5 @/ ^8 f8 m# m                                        volatile uint16_t RESERVED6 : 16;
# Z! x6 g% j1 S9 O6 Y                                }Bit;
& b; b! z, v9 L6 t7 n4 C# O9 r                        }AHBENR;! {, F. d3 u( E$ l! }, y
               
9 |  H  K0 S* B) A                        volatile union
1 K8 E* q  Y4 I  c7 E8 Y                        {0 C6 k8 B' l: |8 Z) j! V
                                volatile uint32_t Value;7 m' f% j( Y+ B, x  O
                        
& P- V, n0 D2 p6 {                                volatile struct: e% q! M# e$ _5 E9 U
                                {
+ f# f! F/ J/ {: q5 r8 G$ R, |                                        volatile uint16_t AFIOEN : 1;
& e/ s! W% x# G9 E0 J( [                                        volatile uint16_t RESERVED1 : 1;6 y$ w& z6 h1 I% _+ }- f5 ~; x/ f. H! f
                                        volatile uint16_t IOPAEN : 1;
  f- M: p1 b/ r1 R; m+ ]                                        volatile uint16_t IOPBEN : 1;
7 `! x+ t+ [) u4 E. o                                        volatile uint16_t IOPCEN : 1;
3 r" h/ d% [, Q7 v0 x' s4 @                                        volatile uint16_t IOPDEN : 1;( `9 [$ x+ Z8 `% [! H8 @' X
                                        volatile uint16_t IOPEEN : 1;
8 i) L  P& d6 z( g                                        volatile uint16_t IOPFEN : 1;
  I, |- G8 p8 x, Z) u4 A                                        volatile uint16_t IOPGEN : 1;
! W2 K& q# Z3 V( \  f# ^8 j5 z                                        volatile uint16_t ADC1EN : 1;! U, L9 [) n: {8 X; u
                                        volatile uint16_t ADC2EN : 1;
) I' a4 l3 L! O; q                                        volatile uint16_t TIM1EN : 1;. N! \+ p1 f! ?6 D8 K
                                        volatile uint16_t SPI1EN : 1;
5 S* H' x. s* s5 h& o8 Z# Q                                        volatile uint16_t TIM8EN : 1;0 o* ?" d, x) i3 K& @
                                        volatile uint16_t USART1EN : 1;* ^. e. D# {( ~- A
                                        volatile uint16_t ADC3EN : 1;* w  F" b" w9 T' D% Y; _
                                        volatile uint16_t RESERVED2 : 16;, v+ F+ Z5 m3 a# Q2 J
                                }Bit;, x/ M7 L8 ]* n& j9 X
                        }APB2ENR;/ O8 z9 J4 |' n
                # X6 T2 a3 R4 \( f1 ]8 n
                        volatile union
! T8 h" u& j( P- {7 ^- i4 H                        {$ n# g, G6 G" Y( x$ `1 Z( s3 f
                                volatile uint32_t Value;
+ l/ a3 o4 f  l                        
# m5 D% ^% o, q" E                                volatile struct  E, R" c; n% V0 Z1 I4 ^) z
                                {
6 @3 G# S% }) {9 h. b+ h; v, ]                                        volatile uint32_t TIM2EN : 1;1 a7 |6 m$ i1 G% c. S9 u9 f
                                        volatile uint32_t TIM3EN : 1;- o" {( Y4 ]+ \3 }
                                        volatile uint32_t TIM4EN : 1;
4 ?% k# i5 o3 z7 ?$ B- w                                        volatile uint32_t TIM5EN : 1;
& z. P, [: G$ G* ?# h                                        volatile uint32_t TIM6EN : 1;; X% H4 O" V0 y& k" v
                                        volatile uint32_t TIM7EN : 1;$ L/ B* X% x4 l
                                        volatile uint32_t RESERVED1 : 2;
+ k! a, d  ]) l9 R+ o0 Z                                        volatile uint32_t RESERVED2 : 3;
& c4 {: d9 x! G2 }                                        volatile uint32_t WWDGEN : 1;" h4 Z! k6 ~* t) r& S7 X9 P. V6 ~
                                        volatile uint32_t RESERVED3 : 2;; M' U) D" ~$ q
                                        volatile uint32_t SPI2EN : 1;7 D) d6 i; _- S9 [& B5 X
                                        volatile uint32_t SPI3EN : 1;- L4 S8 ?! D# t; B  f, {1 b% Z1 K' G
                                        volatile uint32_t RESERVED4 : 1;
: S1 o- }7 P9 K7 W% X! G$ K) u                                        volatile uint32_t USART2EN : 1;. s+ D6 b* r3 f& }5 n9 d3 P
                                        volatile uint32_t USART3EN : 1;6 Z/ a7 B  H0 r* Q* \
                                        volatile uint32_t USART4EN : 1;
  I' Q0 X! Z+ p: M$ `/ W                                        volatile uint32_t USART5EN : 1;
  ]& e* @1 M' I) I                                        volatile uint32_t I2C1EN : 1;
2 `- E, `: s' H6 r                                        volatile uint32_t I2C2EN : 1;3 P6 |" d/ u- ]/ Y- }+ h  |
                                        volatile uint32_t USBEN : 1;
+ \5 }# U2 o3 c* U7 p9 t                                        volatile uint32_t RESERVED5 : 1;# H& z* u  a$ y
                                        volatile uint32_t CANEN : 1;
3 y+ o$ o$ a+ o; k" x% }                                        volatile uint32_t RESERVED6 : 1;
( _/ S4 N7 k7 i! w9 H                                        volatile uint32_t BKPEN : 1;3 W5 O$ L! v5 h6 p$ ^
                                        volatile uint32_t PWREN : 1;/ w" T# \& ]: l% x
                                        volatile uint32_t DACEN : 1;% E) R" u8 k9 D1 @
                                        volatile uint32_t RESERVED7 : 2;
* W( F7 P( Y0 x  S                                }Bit;
! l* L, e9 k, K6 X0 B/ Y, }                        }APB1ENR;  W! ?( b. V( z
                & J' P# N% G2 c- b- G
                        volatile union5 G* B# z* C  z+ J+ G- w; c9 ~
                        {! C' {$ r, q- s) f# k4 e
                                volatile uint32_t Value;
- j( O3 R+ n; N6 V( g                        
5 ]& n" e# k1 l) n                                volatile struct
3 j1 @6 x" {% N( w                                {
0 d) R3 S4 \9 d. s/ D                                        volatile uint32_t LSEON : 1;
; }$ d- b1 U3 d0 b9 M* q                                        volatile const uint32_t LSERDY : 1;/ I7 L; k% s8 `# r( N0 W
                                        volatile uint32_t LSEBYP : 1;! _+ Q* G9 J8 C( H4 Y
                                        volatile uint32_t RESERVED1 : 5;
/ r3 c7 @9 g. H- g! s# Y! x                                        volatile uint32_t RTCSEL : 2;6 G' d' t% h! O
                                        volatile uint32_t RESERVED2 : 5;: v) ?% r# |4 e: [
                                        volatile uint32_t RTCEN : 1;* B! U- Q/ b) h1 L: C9 W
                                        volatile uint32_t BDRST : 1;
3 d: A1 A) q9 T/ |0 H( t- W# _: ^                                        volatile uint32_t RESERVED3 : 7;
8 H: T" @9 |, X! Q0 b  J, K                                        volatile uint32_t RESERVED4 : 8;
2 z2 V& M4 m! l6 |  B                                }Bit;# U' ^4 `9 b) A5 d6 E+ \
                        }BDCR;' N' Z6 o0 p7 k! \5 W7 q' D- l
                , g( r8 D/ o8 b$ H9 R) j
                        volatile union
. n4 E' S3 P: ?                        {  i" k- ]2 l- L- f
                                volatile uint32_t Value;
5 t) K# f5 ?2 y1 _) F                        " X3 F2 V& k: `' l' s* w2 G; P
                                volatile struct
! r4 J% T4 M3 C; A; ?# }  l                                {$ u  F3 `% {. f1 P( `6 x' l
                                        volatile uint32_t LSION : 1;
1 m# G6 p3 {/ j# R0 z9 s% I/ ^" \                                        volatile const uint32_t LSIRDY : 1;7 S2 }, J, I8 M' s, I* \- O
                                        volatile uint32_t RESERVED1 : 6;
( f  d8 a* `' W5 Q                                        volatile uint32_t RESERVED2 : 8;# m6 O8 r5 F% M  X1 v1 h! h
                                        volatile uint32_t RESERVED3 : 8;) D( p2 P1 l6 b# |' T' G9 T
                                        volatile uint32_t RMVF : 1;
9 q+ C7 ?! N  u" C                                        volatile uint32_t RESERVED4 : 1;4 f: p# d! J% D1 t4 F
                                        volatile uint32_t PINRSTF : 1;" L# c7 j* M! t5 F% O" `' A5 Z
                                        volatile uint32_t PORRSTF : 1;8 T) W( S% B9 M  L( K
                                        volatile uint32_t SFTRSTF : 1;0 Z8 @5 y! |  F8 W
                                        volatile uint32_t IWDGRSTF : 1;
* c  }  ]: ?2 _3 ]                                        volatile uint32_t WWDGRSTF : 1;
: V. Z! |: T! s$ K3 a! [' w                                        volatile uint32_t LPWRRSTF : 1;; G; [! k4 J' C; X& L! d5 w0 ?) N* a$ D
                                }Bit;3 o8 r5 X5 b7 L4 S1 w
                        }CSR;
. ?9 p! U, [3 [0 a7 N. Z! W2 U                };3 x! K. O  ~* s. F/ Y3 n! r* c
        
8 R+ U6 M4 z6 K, c3 t                enum RCC_PLL_MUL) H9 X( e' P4 p' B' n4 b
                {
2 }5 P) A# v1 L+ R                        RCC_PLL_MUL2  = 0b0000,; t7 S1 t* I* u% B
                        RCC_PLL_MUL3  = 0b0001,
& \: M* o, `- {) a% T9 U8 p                        RCC_PLL_MUL4  = 0b0010,, m& Q! P- Q: _
                        RCC_PLL_MUL5  = 0b0011,
# X. n$ g; A4 \$ M& o- t9 f" }                        RCC_PLL_MUL6  = 0b0100,
/ W2 O0 d1 H0 ~" n                        RCC_PLL_MUL7  = 0b0101,- r9 g$ E" _: I- o/ E' K- K
                        RCC_PLL_MUL8  = 0b0110,
& C- }/ }5 _- L( r- o2 B                        RCC_PLL_MUL9  = 0b0111,
9 U  R7 ?; C/ g1 f; K! p                        RCC_PLL_MUL10 = 0b1000,
. {- a1 c: s. C) a5 w5 x                        RCC_PLL_MUL11 = 0b1001,
! s# [. h+ n/ h5 G$ F( ]                        RCC_PLL_MUL12 = 0b1010,2 f* R3 [1 w' o
                        RCC_PLL_MUL13 = 0b1011,3 e% {) F. L# A: t- U4 F
                        RCC_PLL_MUL14 = 0b1100,
' S- N& k: D3 x. D1 }                        RCC_PLL_MUL15 = 0b1101,
# H" g" G' v" k2 J0 X                        RCC_PLL_MUL16 = 0b1110,
/ d. Q6 @$ K1 U) O* P, I                };! o7 y5 F$ m/ \4 i% t
               
2 b9 L. Q0 a6 F7 G3 X                enum RCC_PLL_XTPRE5 e, P7 v6 Q  {) b+ F+ a9 r6 A6 c* M
                {
# E& W5 C) l3 A& p& I                        RCC_PLL_XTPRE_DIV1 = 0b0,
3 C9 V: z' Z0 U  X                        RCC_PLL_XTPRE_DIV2 = 0b1,5 l: m: d6 R% A! b  Z! G
                };
1 j& ~$ m0 S* S: n. Z2 Q7 e               
+ ^5 J% W% o- p: @0 H' d! l                enum RCC_PLL_SRC, e3 k) P4 i' U, W# x
                {# {+ z* _8 A% J
                        RCC_PLL_SRC_HSI_DIV2 = 0b0,  N+ X& `& H  i2 c2 v
                        RCC_PLL_SRC_HSE      = 0b1,
0 ^0 d& J! }0 ?: A                };8 W2 X1 s4 a0 R$ _
                # K1 ~1 ~* E  P" @  n3 W
                enum RCC_HPRE
/ ?9 {# k& Q8 }6 s: A                {
2 Z  o2 [8 N3 m6 R; Y1 }& M; z+ m                        RCC_HPRE_DIV1   = 0b0000,
- x: B0 l9 a7 z# _& ]4 I                        RCC_HPRE_DIV2   = 0b1000,
( s2 d% V7 J8 z% i2 K/ V                        RCC_HPRE_DIV4   = 0b1001,
& W( _2 T: k: Z. u: m8 n& F! o                        RCC_HPRE_DIV8   = 0b1010,
4 Z9 T. a; l) B; C4 T                        RCC_HPRE_DIV16  = 0b1011,* h9 N3 w# r1 v' V, h) s5 P7 g1 P
                        RCC_HPRE_DIV64  = 0b1100,
7 V  N: U% X4 D% p6 b- ^$ N) U                        RCC_HPRE_DIV128 = 0b1101,3 g# S0 f6 ]4 e
                        RCC_HPRE_DIV256 = 0b1110,
5 P" p/ ]5 M6 z& R% r$ V                        RCC_HPRE_DIV512 = 0b1111,3 I7 }# b- x4 _  J4 E5 C
                };
- k- h% M; B2 k( a  u               
. r3 K% j6 {5 ^$ p6 m' U+ k                enum RCC_PPRE5 r" O# Y& @8 R4 ?
                {/ R0 g/ z# e) L' w1 {2 \  a7 w
                        RCC_PPRE_DIV1  = 0b000,
- F, ]! f# H4 H                        RCC_PPRE_DIV2  = 0b100,
+ [3 O) j: W4 H; s% X- f8 T" Z8 q                        RCC_PPRE_DIV4  = 0b101,
& z& X2 A6 I. Y                        RCC_PPRE_DIV8  = 0b110,
0 u# b: O5 g2 |# D6 U6 a) |                        RCC_PPRE_DIV16 = 0b111,( h8 ?: }0 Y; x, Y7 o, U- p" Q3 @8 c
                };
$ a# O: o4 [! E  o                ' E" X) \+ c5 `0 f' K  p  o
                enum RCC_SW5 w! A% z0 X$ f! ]7 l, q
                {
6 O" Q$ t% y1 \2 [% o. I                        RCC_SW_HSI = 0b00,$ p2 X3 s4 i5 N) Y& q1 C- ^  s/ k9 u/ R
                        RCC_SW_HSE = 0b01,
7 p1 _0 D; X" E# f                        RCC_SW_PLL = 0b10,
0 n0 X$ Z$ X2 A8 A# i                };& g' a/ N1 g4 c; Y0 v* s
               
+ R  X# J! M7 s8 y+ |; I                class CRCC1 J% b# y: Z7 r. G1 S8 @  R9 M+ d. z
                {7 ~$ D3 e* O& v5 V- S
                public:& D2 Q/ B8 ^  G4 H* S
                        //保存外部晶体频率 在EnableHSE方法中初始化 用于计算系统频率
* ]- _& y+ J; ?! T                        static uint32_t HSE;7 P$ O8 p" i- {- B8 k4 T
                        5 M, V# }0 ?. [" q+ i. w( d% f
                        volatile struct RegisterRCC *pRegister = (volatile struct RegisterRCC *)(RCC_BASE);
0 }" X2 ]8 L- h) \/ B. }, C2 j/ b                        
7 `. J% S1 O7 O5 ?: S" F                        //开启外部高速时钟并等待时钟就绪,如果时钟不能就绪则一直等待+ y# H' p: h7 S
                        //HSE:晶体频率 单位:Hz( ^. U, [  y/ ?3 i
                        void EnableHSE(uint32_t HSE)+ \0 g2 G- p' q- u% w2 N) {
                        {
6 B7 h# |8 x- ^& |6 E                                CRCC::HSE = HSE;" m3 S3 B( p. T8 `; U1 q  u' m7 T
                                $ C. n! p- M& ~' k7 z/ s! d
                                this->pRegister->CR.Bit.HSEON = 1;6 I) ?7 I1 C+ [# `+ E, p* M. E
                                while(!this->pRegister->CR.Bit.HSERDY);0 }7 ~& l" h9 Q
                        }- D4 |& m3 H) _& p3 j7 F: Q7 @' X8 Q
                        - Y; C5 |9 T2 l
                        //设置PLL参数,必须在PLL关闭的状态下
  D( }# n, ?" c+ q4 ]& f" h                        void SetPLL(RCC_PLL_MUL MUL, RCC_PLL_XTPRE XTPRE, RCC_PLL_SRC SRC)
9 U6 A# ~( M* Q) s, ~/ c                        {" m9 I9 i( {( H9 z5 N
                                this->pRegister->CFGR.Bit.PLLMUL = MUL;0 T& X; M2 j. j1 u
                                this->pRegister->CFGR.Bit.PLLXTPRE = XTPRE;
, {: M( z( s% d5 ?2 A2 Q, y                                this->pRegister->CFGR.Bit.PLLSRC = SRC;
: V: [5 A' M; N- A: h                        }+ W! t! k- u& \7 h
                        4 a: O0 G1 c6 h& r3 V: s
                        //开启PLL时钟并等待时钟就绪,如果时钟不能就绪则一直等待) D% D$ c8 F! J, K0 C
                        void EnablePLL(void)& H" d0 }+ ]. s8 a  R
                        {2 w6 L) `1 Q: {. L9 O3 c; I
                                this->pRegister->CR.Bit.PLLON = 1;
0 }4 Q; ~8 e! s- V/ N7 {                                while(!this->pRegister->CR.Bit.PLLRDY);
) {, Q* o1 {" `" m                        }
4 j6 W2 z/ }- G                        / @2 t1 o3 T& M0 M9 E! X- x
                        //切换系统时钟源并等待切换就绪,如果切换不能就绪则一直等待5 R* R! Y2 l- y) ~( c
                        void SetSysClkSource(RCC_SW SW)
: l3 |% L+ i  L+ A                        {
7 h) \, b) U( d9 g8 V/ w                                this->pRegister->CFGR.Bit.SW = SW;
% b: z6 x8 x& Y8 T- @0 l4 z9 C                                while(this->pRegister->CFGR.Bit.SWS != SW);- s; t* |! l# c, q3 l2 x; S0 q0 j
                        }
, l* P% J$ ~' K! @                        ; T$ o8 B' |2 A
                        //获取系统时钟频率 单位:Hz
; n- j! F! t9 Y& F" ~                        uint32_t GetSYSCLK(void)
+ Y% l+ Z, D  I% ]                        {
9 ?- ~5 F! `2 L" e                                if(this->pRegister->CFGR.Bit.SWS == RCC_SW_HSI)
2 M& {$ G1 y# `  q+ P, o' p                                {9 @$ p2 g$ f1 [! z+ x
                                        //系统时钟为HSI
1 w4 A# G) ^" H7 ?                                        return 8000000;+ J" n1 J5 ~& B: J
                                }
9 h4 j  s7 P+ ^8 ~                                else if(this->pRegister->CFGR.Bit.SWS == RCC_SW_HSE)
, G0 S) F7 P+ K2 W6 k8 C9 f3 |                                {
1 v1 W) Z5 Y; R6 x  W6 ?0 {- G                                        //系统时钟为HSE  E& v6 _+ m3 N/ P) f7 N
                                        return CRCC::HSE;7 e. K) y" [% s, _/ G. S
                                }( R1 N: S$ o4 i' }; ~
                                else if(this->pRegister->CFGR.Bit.SWS == RCC_SW_PLL)
& g: f5 Q, L( ?5 Y% L( h! G                                {
7 t2 X# L' Z! C4 p  }- X9 B$ @7 ~! n                                        //系统时钟为PLL' l; b4 D4 O- I1 o9 A& _: X1 W
                                        uint32_t SRC, XTPRE, MUL;
$ P8 t/ h/ z5 F) o) ?. @+ G                                        ) f; ]4 [' g; e" e" n; g2 O; l7 ]3 s
                                        if(this->pRegister->CFGR.Bit.PLLSRC == RCC_PLL_SRC_HSI_DIV2)
6 ]+ x: v# e; ~& D0 D' G                                        {
; S" z  }. q9 o5 k* f5 G( o4 \3 e                                                //PPL输入时钟源为HSI/2" {* N! Y% B4 S9 s7 S; }6 A: [* i
                                                SRC = 8000000;
' G. N) F9 V5 l' ?                                                XTPRE = 2;
9 D% ]! i3 w& v+ `) E                                        }4 H  u3 |# h! u8 F6 d
                                        else2 f* H+ r: B: [% K3 T! U4 f
                                        {
3 \5 `+ x4 h1 G9 g% ^                                                //PLL输入时钟源为HSE: @& P4 @. b. d0 E
                                                SRC = CRCC::HSE;
0 p( i$ @7 b5 a% o1 _0 w( g                                                
. \- D1 ^2 R  i9 t4 l/ h7 ]' l$ S                                                if(this->pRegister->CFGR.Bit.PLLXTPRE == RCC_PLL_XTPRE_DIV1)
+ j3 F+ `$ Y4 Q0 t                                                {
# p; j' l- t# V, c( g                                                        //PLL输入时钟源为HSE/2
6 B; d' ]' V% R* [+ e1 }                                                        XTPRE = 1;
0 w3 Z' F- k- ~( n- f1 Q                                                }
, s1 ~( R' X" \. ?                                                else
! U) F) c- k9 C$ s, W                                                {' ^) R; h* z1 B' O  t
                                                        //PLL输入时钟源为HSE/27 ]* b: r8 Z0 ^
                                                        XTPRE = 2;
5 k1 T8 t  U$ t                                                }0 O& k0 L+ l( P4 N1 r
                                        }
( K+ V- a7 U' W0 w# L% ?0 t& a                                        ! C# X, {( F3 f6 ]: ?9 Q
                                        switch((uint32_t)this->pRegister->CFGR.Bit.PLLMUL)1 J" b4 m8 h) B/ X) s3 B" e
                                        {8 B$ ~7 Q, e# v2 Z
                                                case RCC_PLL_MUL2: MUL = 2; break;
, l$ u- c* s! O% f+ P2 b6 e( K                                                case RCC_PLL_MUL3: MUL = 3; break;
% d% w! `( R( Y! l' P& _" Y                                                case RCC_PLL_MUL4: MUL = 4; break;8 K4 B4 Q. V( k2 d" ]& A3 i) Q5 j
                                                case RCC_PLL_MUL5: MUL = 5; break;
0 [" [$ T- c) i$ C5 [/ Z                                                case RCC_PLL_MUL6: MUL = 6; break;: X# i$ K7 D" w# a
                                                case RCC_PLL_MUL7: MUL = 7; break;
+ Y* o# B5 J8 ]                                                case RCC_PLL_MUL8: MUL = 8; break;) @2 m; \; B" s$ \& F3 M
                                                case RCC_PLL_MUL9: MUL = 9; break;
) j% b* |& i, }5 o& x) b) B                                                case RCC_PLL_MUL10: MUL = 10; break;
8 |3 i" P" P" k                                                case RCC_PLL_MUL11: MUL = 11; break;
$ e* _4 ~  l/ r# p                                                case RCC_PLL_MUL12: MUL = 12; break;; c8 m/ |1 M4 S* A6 s% p/ p/ ]
                                                case RCC_PLL_MUL13: MUL = 13; break;8 e3 T' _/ l) \) p
                                                case RCC_PLL_MUL14: MUL = 14; break;
  z7 S: z. T7 \, B: A0 J                                                case RCC_PLL_MUL15: MUL = 15; break;& N9 F( P# [, E- w1 z7 a
                                                case RCC_PLL_MUL16: MUL = 16; break;) V- }2 {) N; f5 f, [
                                                default: MUL = 16; break;
( C% n; d. v1 i9 E! ?% O; {                                        }
0 r. m! D( ~1 c4 {0 U" Y2 k5 G                                        9 d* |9 d8 w* T2 [9 `# S# a
                                        return SRC / XTPRE * MUL;
) v% e. `6 B9 z! u# r; d                                }
* e( K2 U& k: o4 ?$ e- X# V                                else6 A1 X' {6 }  S: Y; p
                                        return 8000000;
0 r# i# a( i5 E- u0 n2 g1 \                        }; m- ^& o5 L* _4 g
                        8 _2 K5 h+ g* s5 m
                        //获取AHB总线频率 单位:Hz
* H$ \# B/ H( G2 S; T                        uint32_t GetHCLK(void)6 E& h2 X. S6 v4 t( t' \
                        {
; i1 m6 V' h6 X6 h4 X# d                                uint32_t Prescaler;
, W7 ~% J# E1 j* X                                
: u2 O( i/ e' V: n6 [3 X                                switch((uint32_t)this->pRegister->CFGR.Bit.HPRE)
' {6 u0 S9 L" K                                {. a0 Y* |! }- k$ _/ Y, r# D
                                        case RCC_HPRE_DIV1: Prescaler = 1; break;4 C( P) _( t0 I
                                        case RCC_HPRE_DIV2: Prescaler = 2; break;
3 z! I2 O& J/ w8 d) p2 [! g                                        case RCC_HPRE_DIV4: Prescaler = 4; break;
, T4 A9 v$ X* }2 M6 {5 @, j& w$ I                                        case RCC_HPRE_DIV8: Prescaler = 8; break;
% j, t! L0 _; w9 P                                        case RCC_HPRE_DIV16: Prescaler = 16; break;
7 g! b6 _7 z6 M5 ~                                        case RCC_HPRE_DIV64: Prescaler = 64; break;
2 N  S  h4 W' d  h- m                                        case RCC_HPRE_DIV128: Prescaler = 128; break;# @* B3 |; ~$ [! m
                                        case RCC_HPRE_DIV256: Prescaler = 256; break;
( }% V, O3 N# `7 s. [3 M  ~0 f+ \                                        case RCC_HPRE_DIV512: Prescaler = 512; break;" j( O; v4 N: |% E/ g
                                        default: Prescaler = 1; break;
$ ]" c6 ~8 T7 n( |4 f                                }
- P. Z7 ~9 m' {, d# B6 Y. X                                $ O0 H& D. P1 R. C# m/ B7 l/ ~
                                return this->GetSYSCLK() / Prescaler;' H/ m0 D8 ^9 r
                        }5 R8 d7 m( G# E+ Z5 b, U, ~2 \, J, r
                        6 V) c1 \$ j5 G  l4 Q
                        //获取APB1总线频率 单位:Hz
$ o& X2 D! O4 U& A1 H                        uint32_t GetPCLK1(void)
1 x/ n' g% D: g& v' d/ k0 u7 A4 o8 k+ U                        {
8 v. q8 y: f# m6 W# U" i                                uint32_t Prescaler;- u1 s+ F& l# R/ h4 w; u7 j
                                
- ~* f- d7 ]  P                                switch((uint32_t)this->pRegister->CFGR.Bit.PPRE1)
/ P" J( R3 y* a) m6 l                                {2 m1 y* e" C4 q" b7 N
                                        case RCC_PPRE_DIV1:        Prescaler = 1; break;
2 D! w9 d& @7 I# ~3 b                                        case RCC_PPRE_DIV2:        Prescaler = 2; break;* }' v9 g9 n/ o( }
                                        case RCC_PPRE_DIV4: Prescaler = 4; break;
3 G) }7 U6 R  m) p3 m& I& z9 ]                                        case RCC_PPRE_DIV8: Prescaler = 8; break;
% y- e$ I4 I1 V) I6 k( @* d# z                                        case RCC_PPRE_DIV16: Prescaler = 16; break;
( K8 }* u- {- s# f                                        default: Prescaler = 1; break;
& K9 t3 Z& V# M  _* {! y  c                                }+ _; f' O  H( e- ~" {
                                / c, ?* b( M! z, K- ~6 @
                                return this->GetHCLK() / Prescaler;
/ b: r' ^" _- r# D                        }  g1 X- |$ Y' ]1 ?
                        
/ t# u: Q& P6 Y7 B                        //获取APB2总线频率 单位:Hz  N. g" [$ \, w
                        uint32_t GetPCLK2(void)' ~$ ^) A( W, j  H# H
                        {. c4 V' y- |* W! U% t# G/ A7 A# h
                                uint32_t Prescaler;% e+ d( ^/ V$ J8 I/ v& e* Q
                                # ~9 r: Y) ?; C$ q) k5 d+ W* [$ V
                                switch((uint32_t)this->pRegister->CFGR.Bit.PPRE2)
' p* ?! z& }9 w2 v+ e                                {
9 u( q6 S) w/ F; d5 y& p) G; p                                        case RCC_PPRE_DIV1: Prescaler = 1; break;1 V) ?. n+ K$ a/ }, J0 K5 @6 K1 a
                                        case RCC_PPRE_DIV2: Prescaler = 2; break;3 h7 X; l# f! r, R, f
                                        case RCC_PPRE_DIV4: Prescaler = 4; break;5 w% f+ B, W9 A' x( G  a- q" ^
                                        case RCC_PPRE_DIV8: Prescaler = 8; break;
0 \4 q, |: p+ J% y* ^4 `* r1 Y; K                                        case RCC_PPRE_DIV16: Prescaler = 16; break;+ {7 I& G* v' O* ?; t
                                        default: Prescaler = 1; break;
- v; U0 E) U$ ?5 f                                }6 ^! Y' V! V6 A: ^1 q# X
                                & H7 U" A8 s, _
                                return this->GetHCLK() / Prescaler;) v: r) _5 S! d7 J( @) ^
                        }
/ K( j3 |1 v" R4 [5 n9 r                };
% x$ b+ D5 D5 g: |( U               
2 f) G: y$ c3 \0 |                uint32_t CRCC::HSE = 0;  O/ e( J: N7 E$ t
        }  v# j; p$ |/ Y( b
}
' Q$ c! C" m! W; K9 n
; J3 T( k& T5 Y% C% P8 |#endif // !RCC_HPP_
7 Y. y4 p5 F% ~* a1 g% V8 a  m0 t2 g- U' c0 v
这是对RCC的封装,其实对寄存器的封装只是C++写单片机的小问题.还有几个问题要解决.; z0 o, {8 S# H& z
第一:如何把中断连接到任何对象的方法,这个问题本质就是如何利用指针调用对象方法,实现后可以更好的发挥面向对象的多态思路,实现一些高灵活度的编程.我用模板类实现了一个类似C#中的委托对象,然后利用这个对象还可以实现类似C#中的事件,完成消息的多播.当然这是需要付出代价的,这个模板类要用到虚函数表,经过实测这个消耗是可以接受的,多1us左右吧.这个模板类的实现具体可以用Bing国际版搜索FastDelegate.
& F. `( d. w) h2 ^2 H7 r第二:如何new和delete,这个必须通过OS实现.我使用FreeRTOS,然后全局重载new和delete运算符到pvPortMalloc和pvPortFree.不过能定义声明的对象尽量定义声明,不要频繁new和delete因为FreeRTOS的内存管理还是很弱鸡的.实现的目的只是为了提高程序的灵活度.让一些代码可以更快地适配一些硬件.我通常都是只new不delete# b* z7 k( G5 G0 k8 t
, O! V9 Q6 V8 _0 U. M! [, b  ?/ `
为了更好更快地更换MCU,应该定义一个HAL层,里面全是虚基类,抽象类似但又不同的硬件.然后顶层基于HAL开发,底层继承HAL的虚基类并做具体实现.不过虚基类又牵涉虚函数表,会有性能损失.在对性能要求高的地方还是针对不同的硬件进行直接控制./ F# X2 C$ r- k6 a% O
3 m( D. {( K( \4 Y! Y  r
为了更好的进行C++编程,我用gcc编译器.使用这个编译器时一定要注意,编译优化可能导致运行结果不正确,我通常是用O2或Os,一些特殊的函数还需要标记为O0.开发环境是Visual Studio 2019(个人版 免费) + VisualGDB(我买了正版).VisualGDB V5.5R2这个版本真是超级好用,自动完成,代码着色,代码格式化都是杠杠的.这个环境中在线仿真是ST-Link 2 + OpenOCD,可以设置端点,可以实时读取寄存器值,等等.) v- r5 |, _# E

) Q- Y' v5 s, j6 u总之,C++配上这个开发环境生产力大大提高,代码的可复用性也大大提高.另外,我的项目已经投产了.
4 }/ d; t$ v4 F+ Y9 p6 @& w- X; f, k! t

$ |2 J- k9 D6 R, V& `2 M6 r; x) @  \
freemancn 回答时间:2019-9-18 21:55:48
redstone8415 发表于 2019-9-15 11:03: i; W5 V; U# A+ S4 W
做嵌入式的基本上都是从电子硬件转入的! window编程能力非常有限!计算机基础也不扎实,& u5 ?1 J0 x7 _) Y8 L# L
C#,C++面向对象 ...
' F- Y7 U& ]9 W# @% R5 j$ C
) @2 a% C9 e' V
我不是去开发一个IDE,而是用了别人很少用的IDE并且完全实现了我的想法。现在正在用这个IDE以及C++在做一个USB键盘(实际的产品)的项目。其实主要的动机来源于对USB的开发,真的是太复杂了不用C++很难解耦和重用。现在USB键盘已经接近尾声了,等我忙完我会继续写贴教大家怎么搭建开发环境,分享一些在C++过程中的心得。提前透露一下,我的键盘的USB枚举过程比海盗船K70快很多,K70是266ms完成,我键盘是176ms完成。海盗船单次获取设备描述耗时88us,我的键盘是61us,那些国产方案的键盘更是要230us左右。我购买一台USB协议分析仪测量的。虽然这个过程快一点对用户并没有什么卵用,但是说明使用C++程序效率并不会降低。
redstone8415 回答时间:2019-9-15 11:03:00
做嵌入式的基本上都是从电子硬件转入的! window编程能力非常有限!计算机基础也不扎实,
3 z* Z6 Y2 U, L5 u0 hC#,C++面向对象被以前的那些所谓嵌入式大佬批得体无完肤!让他们得以在嵌入式上守住一片天地。/ L. L# S5 W1 I- u* r3 g6 K
而C#,和C++也缺少实际的应用实例(嵌入式),而真正的即懂C#,C++又懂嵌入式的人,几乎没有!
+ k/ Y) J8 f6 p" B7 K! k9 g老师望你在嵌入式C#,C++上开辟一片天地。* j- ?. y) O8 ^, A  y
还有!老师要实现你的愿景!可能需要一个团队,一个人可能难以完成!也可以把它做成一个项目,才可能有持续下去的源源动力。0 W% D, w& G, t) j$ Q) K  P
个人认为: 关键在于有足够多的实际应用(嵌入式的各个功能)实例服众。( ]  l  X% R9 q5 E( P# w+ V. v
奏奏奏 回答时间:2019-8-17 19:21:03
哦,支持一下这位老师。
Kevin_G 回答时间:2019-8-17 21:18:13
支持这位老师,期待革命性的变革。现在MCU性能越来越强大,使用C语言及Keil越来越吃力。$ V8 U! E& w( b
不知道ST自己的IDE(STM32CubeIDE)也是使用GCC编译器,不知道对楼主改用C++开发是否有用。
STMWoodData 回答时间:2019-8-18 13:19:44
提示: 作者被禁止或删除 内容自动屏蔽
pythonworld 回答时间:2019-8-18 18:08:31
楼主可以了解一下mbed,是用c++的。
294479435@qq.co 回答时间:2019-8-19 15:08:51
楼主分析的KEIL+C确实是经典,我也想试试C++,期待楼主后期大作
啊泽 回答时间:2019-8-19 20:08:15
支持大佬,干翻官方库
zbxiaowu 回答时间:2019-8-20 17:18:15
支持大佬
generalcircuits 回答时间:2019-8-22 11:20:07
支持老师,VS确实比keil好用
sq0101 回答时间:2019-8-22 11:41:16
楼主,mbed和vs code了解下吧,又会给你打开新的大门
haocheng996 回答时间:2019-8-22 13:59:17
支持一下
lornis 回答时间:2019-8-22 15:35:18
想法非常非常的好,支持你这样做。当面对大的项目的时候,这样做就会从容很多。
jingwang 回答时间:2019-8-23 09:15:19
支持
tanic 回答时间:2019-8-23 09:41:01
感觉C和C++混合编程,官方底层SDK还是没必要修改的。$ L7 l$ H( v% \" E' `  L
然后单片机项目主要是UI花费时间重复代码多,应用逻辑的话其实还好。- F- x: C( X8 m* L5 Z
我整过一个2W行的单片机项目,2/3的代码量花在UI上了,
123下一页

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版