每次写代码的时候，写外设的初始化都要去复制已经写好的或者是官方的例程，再根据自己的需求来修改，重复性的工作太多，就想到用C++来封装下STM32的库函数，顺便学习下C++，感受下面向对象的强大。
    硬件平台：STM32F4-Discovery
. \/ [" x% `8 A    开发平台：MDK5.14(本来是用VS2013 +VisualGDB的，想到坛友基本都是用MDK的，又改成MDK)
' ~/ X8 i( H( X2 e8 z" t# z% r: O* e   先看Main

1. #include "system.h"
   3 R4 N* B7 v6 r: a  x
2. 
   ; P9 G* N( R$ v2 g( Z5 }3 A
3. System *stm32f407;//系统接口指针
   ' o' Z" q5 W0 W: n3 r% `
4. 
   
5. void btnhandle(void *arg)  //按键回调处理函数
   
6. {
   
7.          delay->delay_ms(20);
   2 I9 @  |. }- G: {; w$ |' P4 U* C7 }9 f
8.         if (stm32f407->btn->ReadData() == true)
   ' b9 i* P# w( v
9.                 stm32f407->led2->Toggle();
   
10. }
    
11. 
    
12. void tim6handle(void *arg)  //定时器中断处理函数
    
13. {
    
14.         stm32f407->led2->Toggle();
    # s# m3 Y2 s( u
15. }
      p7 e* ]( |1 _( V
16. 
    
17. int main()
    
18. {
    . _' Z7 Q$ E; W5 z9 [( L# `4 [
19.         stm32f407 = new System;//构建系统接口类
    
20.         stm32f407->tim2->startIT((void*)tim6handle, NULL);//调用TIM类的中断启动函数，只要传入中断回调函数实现自己的功能，并不需要知道中断是要怎么处理的
    
21.         uint8_t recvdata[100];
    9 S: o! J! r/ x9 J2 U
22.   for (;;)
    
23.   {
    
24.           stm32f407->led1->Toggle();//在system中初始化，就可以直接调用类函数
    * \) I* u3 J" B: L1 f4 p
25.           if (true == stm32f407->Debug->IsGetRecv)//串口自动接收标志
    ) h- `8 \  ]* I! ?6 p
26.           {
    " x4 N, x2 j( O/ a5 t4 b7 R& e
27.                   stm32f407->Debug->RecvData(recvdata);//串口接收函数，传入Buffer，得到接收的数据
    
28.                   stm32f407->Debug->SendData(recvdata, stm32f407->Debug->RecvDataLen, 100);
    4 ^7 b$ O( c0 p$ n2 q. v
29.           }
    
30.           delay->delay_ms(500);
    
31.   }
    1 d9 p& e+ N' h6 v" K+ U; T. M
32. }
    

复制代码

  [8 ]5 {  \) @# n8 E    再看System类的初始化
. T. l! P( G. x

1. void System::init()
   
2. {
   ) R' G+ |5 A) j
3.         HAL_Init();
   
4.         SystemClock_Config();
   
5. //外设初始化
   
6.   delay = new timerdelay;                //系统延时初始
   # e, W9 p+ r7 f5 }  q2 H9 @
7.         Debug = new Usart(USART3, 115200, Usart::USART_IT, 200); //Debug 串口输出初始化，只要传入用的串口号，跟波特率，传输的模式，还有接收Buffer的大小，就可以完成初始化
   
8.         led1 = new LED(GPIOD, GPIO_PIN_14, true, LED::highlevel);//LED类，继承OutputPort类，只要传入LED对应的GPIO，跟Pin，还有LED电平控制，就可以完成初始化
   
9.         led2 = new LED(GPIOD, GPIO_PIN_12, false, LED::highlevel);
     L: i5 Q' p6 v/ w( J9 S' h
10.         btn = new InputPort(GPIOA, GPIO_PIN_0, GPIO_MODE_IT_RISING, (void*)btnhandle, NULL); //输入类，传入GPIO，PIN，中断触发模式，回调指针，回调参数，完成初始化
    $ F8 S* J8 N0 [3 m
11.         tim2 = new Timer_base(TIM2, 16800, 10000);
    " @& ]! W5 y& Q8 r) K
12.         BoardInfo();
    
13. }

复制代码

6 y, I4 K. J% a1 N9 V0 n( w
1 F& B4 i4 t" q& @/ n
OutputPort类：

1. class OutputPort
   # m9 _/ N  r7 v( C; l0 u
2. {
   - {/ z+ v& I# C2 _% s
3. public:
   6 _( t' Y! F% x+ f
4.         OutputPort(GPIO_TypeDef* mPORT, uint16_t mGPIO_PIN, bool initialState);//OutputPort类构建函数，简单传入三个参数
   ! l6 [& f  U( M$ y2 J9 n# ]
5.         OutputPort(GPIO_TypeDef* mPORT, uint16_t mGPIO_PIN, uint32_t GPIO_Speed, uint32_t GPIO_PuPd, bool initialState);//构建函数重载，可以传入更多的参数
   3 V! {$ g8 [" l- Q' Y3 s5 N4 h; O
6.         ~OutputPort();
   
7.         void H(void);//类函数，构建的类都是调用同函数就可以实现，减少代码的重复
   
8.         void L(void);
   
9.         inline void  RegH(){PORT->BSRR |= GPIO_PIN;        }//内联函数，直接代码替换成寄存器操作，提高执行效率
   
10.         inline void  RegL(){ PORT->BSRR |= GPIO_PIN << 16; }
    
11.         GPIO_TypeDef* PORT;
    & Z, |2 r8 P/ e0 k
12.         uint16_t GPIO_PIN;
    
13. private:
    
14. protected:
    * V+ _% T  d/ o+ W
15. 
    
16. };
    
17. 
    4 S+ c. s! b' [6 L: Y: Y8 O: Y
18. LED类：
    9 \* @- E4 y" ^3 s# o8 G
19. class LED :public OutputPort
    0 l& Y: `# E' N8 F. L
20. {
    
21. public:
    
22.         LED(GPIO_TypeDef* mPORT, uint16_t mGPIO_PIN, bool initialState, uint8_t mCtlVolLev) : OutputPort(mPORT, mGPIO_PIN, initialState), CtlVolLev(mCtlVolLev){};//继承OutputPort类，并增加新的参数
    + k! w4 t6 C2 k. X
23.          ~LED();
    
24.          void ON();
    
25.          void OFF();
      I' S0 O  V) k" E' C. {
26.          void Toggle();
    : o: Y8 j5 m) ]- e% O
27.          enum{ lowlevel, highlevel };
    
28. private:
    , v  [2 {( y. D# b8 ?0 ~  _. j
29. protected:
    ! x4 S1 w  Q3 r( A9 ?
30.         uint8_t CtlVolLev;    //LED 1为高电平  0为低电平
    ; c3 q% j9 N/ [5 n1 F7 Y# ]
31. };

复制代码

6 f7 y8 o5 R# Z! ~  UART类：

1. extern uint8_t UART_Recv_Timeout[5];//Time Tick
   ) ]. }" b  n& ?6 c3 ?
2. 
   
3. class Usart
   
4. {
   
5. public:
   ; W0 s2 }7 E) @2 g0 a+ L
6.         enum tranmode
   6 F( h0 ^4 o9 W7 a* {; s
7.         {
   2 Z% v* R) W7 {3 h! Y5 n
8.                 USART_Normal, //普通发送
   
9.                 USART_IT,    //中断发送接收，接收自动判断超时完成接收
   
10.                 USART_DMA    //DMA发送接收，UART闲时中断自动接收DMA接收完成
    
11.         };//类构建时传入，类函数根据输入的类别发送接收
    
12.         Usart(USART_TypeDef *USARTx, uint32_t BaudRate, tranmode mmode,uint16_t mRecvBuffSize);
    
13.         void SendData(uint8_t data);
    
14.         void SendData(uint8_t *pData, uint16_t Size, uint32_t Timeout);
    
15.         uint16_t RecvData(uint8_t *pData);
    
16.         uint16_t RecvDataLen; //接收到数据长度
    
17.         UART_HandleTypeDef UartHandle;
    , l# c- {7 S& o3 v2 N4 I
18.         uint8_t IsGetRecv;   //接收标志
    ! o0 A7 s  w( P3 v( K% g
19.         uint8_t isSendOk ;  //发送完成标志
    ! J, P  f3 I3 [8 X9 S, |/ h) g
20.         tranmode mode;
    0 k7 C# n' j/ `; I  d- T# W: A7 z& W
21.         void Printf(const char* fmt, ...);
    ' ~6 A6 _2 o) t! h
22.         ~Usart();
    
23. 
    
24. private:
    ! Y: H( Z8 C% W; ^- Q! o8 N& m7 |
25.         uint16_t RecvBuffSize;
    # I% n2 x3 K4 i. L( d4 B
26.         uint8_t *RecvBuff;
    
27.         uint8_t SendBuff[100];
    % }0 K+ }9 ~% ?3 N- G8 B
28.         void USART_DMA_Config(UART_HandleTypeDef *UartHandle);
    7 D3 n( q: @, J6 O
29. };
    0 i/ x/ S% O9 n( v
30. 
    9 a& J7 a5 s, ]7 W) C) f* x
31. void Do_UART_Recv(uint8_t i);//接收超时处理函数

复制代码

     C++面向对象最大的好处是，只要定义一个类，相同的外设只要传入参数构建类，就可以调用类函数来实现功能，不需要为每个外设再重新写代码。而且封装好了类，只需要知道传入什么参数，可以调用什么接口来实现自己的功能就可以了，不需要再去了解类里面是怎么来实现的。目前就封装了GPIO，UART，TIM Base，SPI等几个外设，可以给大家体验下面向对象的强大，提供一些封装函数的思路，更具体的代码可以下载附件的工程。
STM32F4_Cpp.zip (3.72 MB, 下载次数: 104)

2016-4-21 20:29 上传

点击文件名下载附件
" N% w! Y# Z% s' G' u. w

不错 不过现实的单片机c++应用 怕也只是止步于此了.

最近也有这个想法，但是还没实施，先学习了...

楼主可以参考Mbed的实现

如果使用模板，生成的代码效率，比用C写的还高。

先学习下  谢谢分享

高手，现在只能观望了。以后有机会再应用吧

不错，我们好多的项目，已经这么做了，效果不错，就是类和类之间传值有点麻烦，其他的都OK，写的程序，都按照“流”执行，思路清晰。
1 B; s) ~4 b$ N未来的趋势就是单片机会越来越多的支持高级语言的开发，比如C#，ST官网也针对F4有例程，基于.NET MICRO FRAMEWORK的，最近一直研究，有兴趣，可以一起搞。

auto_ele 发表于 2016-4-28 11:13
; v4 Z2 L* E% A9 }不错，我们好多的项目，已经这么做了，效果不错，就是类和类之间传值有点麻烦，其他的都OK，写的程序，都按 ...

.NET MICRO FRAMEWORK我去年就有研究，写过一些文章，只能是玩玩，实际上没太多的胜任

蓝凌风 发表于 2016-4-29 09:03
.NET MICRO FRAMEWORK我去年就有研究，写过一些文章，只能是玩玩，实际上没太多的胜任 ...

3 c: Q3 y7 i  ^- [9 }6 l较LINUX之类的系统，它把硬件层和应用层完全分开，只要写好CLR就可以。

学习了, 帮顶

学习学习学习学习