|
用C++写单片机程序 STM32F103 + 自建固件库 + FreeRTOS 用gcc编译器和newlib(1篇) & 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,优化功能,增加功能,版本迭代等等。 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可以吐槽的地方还有很多很多,我可以给你说一整天,我并不想开吐槽大会,只是想告诉大家其实可以有更好的选择。 / W0 G" N8 N7 \" G& L$ i9 z7 P+ G5 G 说一下代码效率问题,这可能是大家非常关注的地方。绝大多数人会认为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 - 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
|
DMA 原理从 0 到 1:为什么它能解放 CPU?一文讲透 DMA 的工作流程
【福利三:雨露均沾·逢7狂欢】之五:STM32系统时钟PLL故障排除1例
【福利三:雨露均沾·逢7狂欢】之三:AI帮我查BUG
福利三:雨露均沾·逢7狂欢】之二:STM32F407VG串口通信乱码故障的排除
基于STM32F103的I2C主从机通信
OpenBLT移植到STM32F103战舰开发板上适用于所有STM32F103系列的Bootloader
TFT LCD 与 FSMC 的硬件连接大容量 STM32F10xxx FSMC 接口
单片机:初学者该了解的STM32F103基础知识
2025软件工具兔哥知道
STM32之继电器模块
微信公众号
手机版
分享一个
#ifndef RCC_HPP_. ^3 G/ J0 R. k7 y8 b$ m- G4 r
#define RCC_HPP_
#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
{; z* Y9 X. W0 e/ u5 E+ F/ G# `; o
struct RegisterRCC
{, n( ?, i4 w& e$ n* @) y" x6 o6 J* F
volatile union2 r8 n3 R+ [# G% }8 E, w: U5 G4 T! @
{
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;
volatile uint32_t RESERVED1 : 1;
volatile uint32_t HSITRIM : 5;+ J. f7 r' T: @
volatile const uint32_t HSICAL : 8;
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;
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;
volatile uint32_t RESERVDE3 : 6;) t' @% G; A9 k- I
}Bit;% j7 z* `0 c) G
}CR;
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
volatile struct
{
volatile uint32_t SW : 2;5 `4 d, ~ G `6 S, V* @
volatile const uint32_t SWS : 2;
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;
volatile uint32_t ADCPRE : 2;
volatile uint32_t PLLSRC : 1;& u% L7 @7 n! x" y5 v& G! `9 D
volatile uint32_t PLLXTPRE : 1;
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;
}Bit;+ S* Z6 b( L0 [( A$ y0 c1 o g
}CFGR;/ P" q& t4 Z5 X& X" x8 A
volatile union6 K/ Z1 q) B- E& v% L+ f1 }1 T3 ^
{, w# S, u( u- z
volatile uint32_t Value;
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;
volatile const uint32_t HSIRDYF : 1;
volatile const uint32_t HSERDYF : 1;
volatile const uint32_t PLLRDYF : 1;
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;
volatile uint32_t PLLRDYIE : 1;
volatile const uint32_t PLL2RDYE : 1;
volatile const uint32_t PLL3RDYE : 1;
volatile uint32_t RESERVED1 : 1;
volatile uint32_t LSIRDYC : 1;
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;
volatile uint32_t RESERVED2 : 8;
}Bit;- f& f2 I* t4 r+ _4 G0 i( _
}CIR;
volatile union
{& 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;
volatile uint16_t IOPBRST : 1;
volatile uint16_t IOPCRST : 1;1 w( j: T8 g: y* d( d
volatile uint16_t IOPDRST : 1;
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;
volatile uint16_t ADC2RST : 1;
volatile uint16_t TIM1RST : 1;, `3 Z4 n4 D$ n9 C" V
volatile uint16_t SPI1RST : 1;
volatile uint16_t TIM8RST : 1;
volatile uint16_t USART1RST : 1;
volatile uint16_t ADC3RST : 1;
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
{
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;
volatile uint32_t TIM4RST : 1;$ f1 ~ X3 Q+ }5 c
volatile uint32_t TIM5RST : 1;
volatile uint32_t TIM6RST : 1;/ K9 @& V4 m' }/ B; S9 m
volatile uint32_t TIM7RST : 1;
volatile uint32_t RESERVED1 : 2;
volatile uint32_t RESERVED2 : 3;
volatile uint32_t WWDGRST : 1;
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;
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;
volatile uint32_t USART4RST : 1;) p2 F7 h* ?4 g h
volatile uint32_t USART5RST : 1;
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;
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;
volatile uint32_t PWRRST : 1;
volatile uint32_t DACRST : 1;
volatile uint32_t RESERVED7 : 2;
}Bit;7 ?5 U' z7 Z; a( o
}APB1RSTR;
volatile union3 R o# Z/ ~% K8 I. c
{
volatile uint32_t Value;0 M7 J# U- n' }
5 @1 z$ f3 ?5 L I+ _
volatile struct
{
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;
volatile uint16_t RESERVED1 : 1;' M$ c/ o' t* r7 [# b9 J8 `
volatile uint16_t FLITFEN : 1;
volatile uint16_t RESERVED2 : 1;9 `9 ?1 G1 C3 P# l" h
volatile uint16_t CRCEN : 1;
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;
volatile uint16_t SDIOEN : 1;
volatile uint16_t RESERVED5 : 5;
volatile uint16_t RESERVED6 : 16;
}Bit;
}AHBENR;! {, F. d3 u( E$ l! }, y
volatile union
{0 C6 k8 B' l: |8 Z) j! V
volatile uint32_t Value;7 m' f% j( Y+ B, x O
volatile struct: e% q! M# e$ _5 E9 U
{
volatile uint16_t AFIOEN : 1;
volatile uint16_t RESERVED1 : 1;6 y$ w& z6 h1 I% _+ }- f5 ~; x/ f. H! f
volatile uint16_t IOPAEN : 1;
volatile uint16_t IOPBEN : 1;
volatile uint16_t IOPCEN : 1;
volatile uint16_t IOPDEN : 1;( `9 [$ x+ Z8 `% [! H8 @' X
volatile uint16_t IOPEEN : 1;
volatile uint16_t IOPFEN : 1;
volatile uint16_t IOPGEN : 1;
volatile uint16_t ADC1EN : 1;! U, L9 [) n: {8 X; u
volatile uint16_t ADC2EN : 1;
volatile uint16_t TIM1EN : 1;. N! \+ p1 f! ?6 D8 K
volatile uint16_t SPI1EN : 1;
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
{$ n# g, G6 G" Y( x$ `1 Z( s3 f
volatile uint32_t Value;
volatile struct E, R" c; n% V0 Z1 I4 ^) z
{
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;
volatile uint32_t TIM5EN : 1;
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;
volatile uint32_t RESERVED2 : 3;
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;
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;
volatile uint32_t USART5EN : 1;
volatile uint32_t I2C1EN : 1;
volatile uint32_t I2C2EN : 1;3 P6 |" d/ u- ]/ Y- }+ h |
volatile uint32_t USBEN : 1;
volatile uint32_t RESERVED5 : 1;# H& z* u a$ y
volatile uint32_t CANEN : 1;
volatile uint32_t RESERVED6 : 1;
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;
}Bit;
}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;
volatile struct
{
volatile uint32_t LSEON : 1;
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;
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;
volatile uint32_t RESERVED3 : 7;
volatile uint32_t RESERVED4 : 8;
}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
{ i" k- ]2 l- L- f
volatile uint32_t Value;
" X3 F2 V& k: `' l' s* w2 G; P
volatile struct
{$ u F3 `% {. f1 P( `6 x' l
volatile uint32_t LSION : 1;
volatile const uint32_t LSIRDY : 1;7 S2 }, J, I8 M' s, I* \- O
volatile uint32_t RESERVED1 : 6;
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;
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;
volatile uint32_t WWDGRSTF : 1;
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;
};3 x! K. O ~* s. F/ Y3 n! r* c
enum RCC_PLL_MUL) H9 X( e' P4 p' B' n4 b
{
RCC_PLL_MUL2 = 0b0000,; t7 S1 t* I* u% B
RCC_PLL_MUL3 = 0b0001,
RCC_PLL_MUL4 = 0b0010,, m& Q! P- Q: _
RCC_PLL_MUL5 = 0b0011,
RCC_PLL_MUL6 = 0b0100,
RCC_PLL_MUL7 = 0b0101,- r9 g$ E" _: I- o/ E' K- K
RCC_PLL_MUL8 = 0b0110,
RCC_PLL_MUL9 = 0b0111,
RCC_PLL_MUL10 = 0b1000,
RCC_PLL_MUL11 = 0b1001,
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,
RCC_PLL_MUL15 = 0b1101,
RCC_PLL_MUL16 = 0b1110,
};! o7 y5 F$ m/ \4 i% t
enum RCC_PLL_XTPRE5 e, P7 v6 Q {) b+ F+ a9 r6 A6 c* M
{
RCC_PLL_XTPRE_DIV1 = 0b0,
RCC_PLL_XTPRE_DIV2 = 0b1,5 l: m: d6 R% A! b Z! G
};
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,
};8 W2 X1 s4 a0 R$ _
# K1 ~1 ~* E P" @ n3 W
enum RCC_HPRE
{
RCC_HPRE_DIV1 = 0b0000,
RCC_HPRE_DIV2 = 0b1000,
RCC_HPRE_DIV4 = 0b1001,
RCC_HPRE_DIV8 = 0b1010,
RCC_HPRE_DIV16 = 0b1011,* h9 N3 w# r1 v' V, h) s5 P7 g1 P
RCC_HPRE_DIV64 = 0b1100,
RCC_HPRE_DIV128 = 0b1101,3 g# S0 f6 ]4 e
RCC_HPRE_DIV256 = 0b1110,
RCC_HPRE_DIV512 = 0b1111,3 I7 }# b- x4 _ J4 E5 C
};
enum RCC_PPRE5 r" O# Y& @8 R4 ?
{/ R0 g/ z# e) L' w1 {2 \ a7 w
RCC_PPRE_DIV1 = 0b000,
RCC_PPRE_DIV2 = 0b100,
RCC_PPRE_DIV4 = 0b101,
RCC_PPRE_DIV8 = 0b110,
RCC_PPRE_DIV16 = 0b111,( h8 ?: }0 Y; x, Y7 o, U- p" Q3 @8 c
};
' E" X) \+ c5 `0 f' K p o
enum RCC_SW5 w! A% z0 X$ f! ]7 l, q
{
RCC_SW_HSI = 0b00,$ p2 X3 s4 i5 N) Y& q1 C- ^ s/ k9 u/ R
RCC_SW_HSE = 0b01,
RCC_SW_PLL = 0b10,
};& g' a/ N1 g4 c; Y0 v* s
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方法中初始化 用于计算系统频率
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);
//开启外部高速时钟并等待时钟就绪,如果时钟不能就绪则一直等待+ y# H' p: h7 S
//HSE:晶体频率 单位:Hz( ^. U, [ y/ ?3 i
void EnableHSE(uint32_t HSE)+ \0 g2 G- p' q- u% w2 N) {
{
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关闭的状态下
void SetPLL(RCC_PLL_MUL MUL, RCC_PLL_XTPRE XTPRE, RCC_PLL_SRC SRC)
{" 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;
this->pRegister->CFGR.Bit.PLLSRC = SRC;
}+ 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;
while(!this->pRegister->CR.Bit.PLLRDY);
}
/ @2 t1 o3 T& M0 M9 E! X- x
//切换系统时钟源并等待切换就绪,如果切换不能就绪则一直等待5 R* R! Y2 l- y) ~( c
void SetSysClkSource(RCC_SW SW)
{
this->pRegister->CFGR.Bit.SW = SW;
while(this->pRegister->CFGR.Bit.SWS != SW);- s; t* |! l# c, q3 l2 x; S0 q0 j
}
; T$ o8 B' |2 A
//获取系统时钟频率 单位:Hz
uint32_t GetSYSCLK(void)
{
if(this->pRegister->CFGR.Bit.SWS == RCC_SW_HSI)
{9 @$ p2 g$ f1 [! z+ x
//系统时钟为HSI
return 8000000;+ J" n1 J5 ~& B: J
}
else if(this->pRegister->CFGR.Bit.SWS == RCC_SW_HSE)
{
//系统时钟为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)
{
//系统时钟为PLL' l; b4 D4 O- I1 o9 A& _: X1 W
uint32_t SRC, XTPRE, MUL;
) f; ]4 [' g; e" e" n; g2 O; l7 ]3 s
if(this->pRegister->CFGR.Bit.PLLSRC == RCC_PLL_SRC_HSI_DIV2)
{
//PPL输入时钟源为HSI/2" {* N! Y% B4 S9 s7 S; }6 A: [* i
SRC = 8000000;
XTPRE = 2;
}4 H u3 |# h! u8 F6 d
else2 f* H+ r: B: [% K3 T! U4 f
{
//PLL输入时钟源为HSE: @& P4 @. b. d0 E
SRC = CRCC::HSE;
if(this->pRegister->CFGR.Bit.PLLXTPRE == RCC_PLL_XTPRE_DIV1)
{
//PLL输入时钟源为HSE/2
XTPRE = 1;
}
else
{' ^) R; h* z1 B' O t
//PLL输入时钟源为HSE/27 ]* b: r8 Z0 ^
XTPRE = 2;
}0 O& k0 L+ l( P4 N1 r
}
! 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;
case RCC_PLL_MUL3: MUL = 3; break;
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;
case RCC_PLL_MUL6: MUL = 6; break;: X# i$ K7 D" w# a
case RCC_PLL_MUL7: MUL = 7; break;
case RCC_PLL_MUL8: MUL = 8; break;) @2 m; \; B" s$ \& F3 M
case RCC_PLL_MUL9: MUL = 9; break;
case RCC_PLL_MUL10: MUL = 10; break;
case RCC_PLL_MUL11: MUL = 11; break;
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;
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;
}
9 d* |9 d8 w* T2 [9 `# S# a
return SRC / XTPRE * MUL;
}
else6 A1 X' {6 } S: Y; p
return 8000000;
}; m- ^& o5 L* _4 g
8 _2 K5 h+ g* s5 m
//获取AHB总线频率 单位:Hz
uint32_t GetHCLK(void)6 E& h2 X. S6 v4 t( t' \
{
uint32_t Prescaler;
switch((uint32_t)this->pRegister->CFGR.Bit.HPRE)
{. 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;
case RCC_HPRE_DIV4: Prescaler = 4; break;
case RCC_HPRE_DIV8: Prescaler = 8; break;
case RCC_HPRE_DIV16: Prescaler = 16; break;
case RCC_HPRE_DIV64: Prescaler = 64; break;
case RCC_HPRE_DIV128: Prescaler = 128; break;# @* B3 |; ~$ [! m
case RCC_HPRE_DIV256: Prescaler = 256; break;
case RCC_HPRE_DIV512: Prescaler = 512; break;" j( O; v4 N: |% E/ g
default: Prescaler = 1; break;
}
$ 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
uint32_t GetPCLK1(void)
{
uint32_t Prescaler;- u1 s+ F& l# R/ h4 w; u7 j
switch((uint32_t)this->pRegister->CFGR.Bit.PPRE1)
{2 m1 y* e" C4 q" b7 N
case RCC_PPRE_DIV1: Prescaler = 1; break;
case RCC_PPRE_DIV2: Prescaler = 2; break;* }' v9 g9 n/ o( }
case RCC_PPRE_DIV4: Prescaler = 4; break;
case RCC_PPRE_DIV8: Prescaler = 8; break;
case RCC_PPRE_DIV16: Prescaler = 16; break;
default: Prescaler = 1; break;
}+ _; f' O H( e- ~" {
/ c, ?* b( M! z, K- ~6 @
return this->GetHCLK() / Prescaler;
} g1 X- |$ Y' ]1 ?
//获取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)
{
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;
case RCC_PPRE_DIV16: Prescaler = 16; break;+ {7 I& G* v' O* ?; t
default: Prescaler = 1; break;
}6 ^! Y' V! V6 A: ^1 q# X
& H7 U" A8 s, _
return this->GetHCLK() / Prescaler;) v: r) _5 S! d7 J( @) ^
}
};
uint32_t CRCC::HSE = 0; O/ e( J: N7 E$ t
} v# j; p$ |/ Y( b
}
#endif // !RCC_HPP_
1 g% V8 a m0 t2 g- U' c0 v
这是对RCC的封装,其实对寄存器的封装只是C++写单片机的小问题.还有几个问题要解决.; z0 o, {8 S# H& z
第一:如何把中断连接到任何对象的方法,这个问题本质就是如何利用指针调用对象方法,实现后可以更好的发挥面向对象的多态思路,实现一些高灵活度的编程.我用模板类实现了一个类似C#中的委托对象,然后利用这个对象还可以实现类似C#中的事件,完成消息的多播.当然这是需要付出代价的,这个模板类要用到虚函数表,经过实测这个消耗是可以接受的,多1us左右吧.这个模板类的实现具体可以用Bing国际版搜索FastDelegate.
第二:如何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
总之,C++配上这个开发环境生产力大大提高,代码的可复用性也大大提高.另外,我的项目已经投产了.
6 @& w- X; f, k! t
2 M6 r; x) @ \
我不是去开发一个IDE,而是用了别人很少用的IDE并且完全实现了我的想法。现在正在用这个IDE以及C++在做一个USB键盘(实际的产品)的项目。其实主要的动机来源于对USB的开发,真的是太复杂了不用C++很难解耦和重用。现在USB键盘已经接近尾声了,等我忙完我会继续写贴教大家怎么搭建开发环境,分享一些在C++过程中的心得。提前透露一下,我的键盘的USB枚举过程比海盗船K70快很多,K70是266ms完成,我键盘是176ms完成。海盗船单次获取设备描述耗时88us,我的键盘是61us,那些国产方案的键盘更是要230us左右。我购买一台USB协议分析仪测量的。虽然这个过程快一点对用户并没有什么卵用,但是说明使用C++程序效率并不会降低。
C#,C++面向对象被以前的那些所谓嵌入式大佬批得体无完肤!让他们得以在嵌入式上守住一片天地。/ L. L# S5 W1 I- u* r3 g6 K
而C#,和C++也缺少实际的应用实例(嵌入式),而真正的即懂C#,C++又懂嵌入式的人,几乎没有!
老师望你在嵌入式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
不知道ST自己的IDE(STM32CubeIDE)也是使用GCC编译器,不知道对楼主改用C++开发是否有用。
然后单片机项目主要是UI花费时间重复代码多,应用逻辑的话其实还好。- F- x: C( X8 m* L5 Z
我整过一个2W行的单片机项目,2/3的代码量花在UI上了,