STM32F4 C++ 封装库 之 GPIO

       一直有一个想法就是用 C++ 去做 STM32 的开发，但是很少有这方面的资料。经过一段时间的思考，决定在官方的 ll 库的基础上做一层 C++ 的简单封装。因为官方的库基本实现了全系列的 MCU 都是相同的 API 接口，所以 C++ 封装后的库也有很好的移植性。原理性的东西就不讲理了，直接上代码。

stm32f4xx_xgpio.h 文件

1. /**
   
2.   ******************************************************************************
   
3.   * \file    stm32f4xx_xgpio.h
   
4.   * \author  XinLi
   
5.   * \version v1.0
   
6.   * \date    20-March-2018
   
7.   * \brief   Header file for general purpose I/O module.
   
8.   ******************************************************************************
   
9.   * \attention
   
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    
14.   * it under the terms of the GNU General Public License as published by
    
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    
22.   *
    
23.   * You should have received a copy of the GNU General Public License
    
24.   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
25.   *
    
26.   ******************************************************************************
    
27.   */
    
28. 
    
29. #ifndef STM32F4XX_XGPIO_H
    
30. #define STM32F4XX_XGPIO_H
    
31. 
    
32. #include <stdint.h>
    
33. #include "stm32f4xx_ll_gpio.h"
    
34. 
    
35. /*! General purpose I/O module. */
    
36. class XGpio
    
37. {
    
38. public:
    
39.   /*! Enumerate GPIO ports. */
    
40.   enum GpioPort
    
41.   {
    
42.     PortA = (uint32_t)GPIOA, /*!< GPIO port A. */
    
43.     PortB = (uint32_t)GPIOB, /*!< GPIO port B. */
    
44.     PortC = (uint32_t)GPIOC, /*!< GPIO port C. */
    
45.   #ifdef GPIOD
    
46.     PortD = (uint32_t)GPIOD, /*!< GPIO port D. */
    
47.   #endif // GPIOD
    
48.   #ifdef GPIOE
    
49.     PortE = (uint32_t)GPIOE, /*!< GPIO port E. */
    
50.   #endif // GPIOE
    
51.   #ifdef GPIOF
    
52.     PortF = (uint32_t)GPIOF, /*!< GPIO port F. */
    
53.   #endif // GPIOF
    
54.   #ifdef GPIOG
    
55.     PortG = (uint32_t)GPIOG, /*!< GPIO port G. */
    
56.   #endif // GPIOG
    
57.   #ifdef GPIOH
    
58.     PortH = (uint32_t)GPIOH, /*!< GPIO port H. */
    
59.   #endif // GPIOH
    
60.   #ifdef GPIOI
    
61.     PortI = (uint32_t)GPIOI, /*!< GPIO port I. */
    
62.   #endif // GPIOI
    
63.   #ifdef GPIOJ
    
64.     PortJ = (uint32_t)GPIOJ, /*!< GPIO port J. */
    
65.   #endif // GPIOJ
    
66.   #ifdef GPIOK
    
67.     PortK = (uint32_t)GPIOK, /*!< GPIO port K. */
    
68.   #endif // GPIOK
    
69.   };
    
70.   
    
71.   /*! Enumeration of GPIO pins. */
    
72.   enum GpioPin
    
73.   {
    
74.     Pin0  = LL_GPIO_PIN_0,  /*!< GPIO pin 0. */
    
75.     Pin1  = LL_GPIO_PIN_1,  /*!< GPIO pin 1. */
    
76.     Pin2  = LL_GPIO_PIN_2,  /*!< GPIO pin 2. */
    
77.     Pin3  = LL_GPIO_PIN_3,  /*!< GPIO pin 3. */
    
78.     Pin4  = LL_GPIO_PIN_4,  /*!< GPIO pin 4. */
    
79.     Pin5  = LL_GPIO_PIN_5,  /*!< GPIO pin 5. */
    
80.     Pin6  = LL_GPIO_PIN_6,  /*!< GPIO pin 6. */
    
81.     Pin7  = LL_GPIO_PIN_7,  /*!< GPIO pin 7. */
    
82.     Pin8  = LL_GPIO_PIN_8,  /*!< GPIO pin 8. */
    
83.     Pin9  = LL_GPIO_PIN_9,  /*!< GPIO pin 9. */
    
84.     Pin10 = LL_GPIO_PIN_10, /*!< GPIO pin 10. */
    
85.     Pin11 = LL_GPIO_PIN_11, /*!< GPIO pin 11. */
    
86.     Pin12 = LL_GPIO_PIN_12, /*!< GPIO pin 12. */
    
87.     Pin13 = LL_GPIO_PIN_13, /*!< GPIO pin 13. */
    
88.     Pin14 = LL_GPIO_PIN_14, /*!< GPIO pin 14. */
    
89.     Pin15 = LL_GPIO_PIN_15, /*!< GPIO pin 15. */
    
90.   };
    
91.   
    
92.   /*! Enumeration of GPIO modes. */
    
93.   enum GpioMode
    
94.   {
    
95.     ModeInput     = LL_GPIO_MODE_INPUT,     /*!< GPIO input mode. */
    
96.     ModeOutput    = LL_GPIO_MODE_OUTPUT,    /*!< GPIO output mode. */
    
97.     ModeAlternate = LL_GPIO_MODE_ALTERNATE, /*!< GPIO alternate function mode. */
    
98.     ModeAnalog    = LL_GPIO_MODE_ANALOG,    /*!< GPIO analog mode. */
    
99.   };
    
100.   
     
101.   /*! Enumeration of GPIO output types. */
     
102.   enum GpioOutput
     
103.   {
     
104.     OutputPushPull  = LL_GPIO_OUTPUT_PUSHPULL,  /*!< GPIO push-pull output. */
     
105.     OutputOpenDrain = LL_GPIO_OUTPUT_OPENDRAIN, /*!< GPIO open-drain output. */
     
106.   };
     
107.   
     
108.   /*! Enumeration of GPIO output speeds. */
     
109.   enum GpioSpeed
     
110.   {
     
111.     SpeedLow      = LL_GPIO_SPEED_FREQ_LOW,       /*!< GPIO low output speed. */
     
112.     SpeedMedium   = LL_GPIO_SPEED_FREQ_MEDIUM,    /*!< GPIO medium output speed. */
     
113.     SpeedHigh     = LL_GPIO_SPEED_FREQ_HIGH,      /*!< GPIO high output speed. */
     
114.     SpeedVeryHigh = LL_GPIO_SPEED_FREQ_VERY_HIGH, /*!< GPIO very high output speed. */
     
115.   };
     
116.   
     
117.   /*! Enumeration of GPIO pull-up/pull-down. */
     
118.   enum GpioPull
     
119.   {
     
120.     PullNo   = LL_GPIO_PULL_NO,   /*!< GPIO no pull. */
     
121.     PullUp   = LL_GPIO_PULL_UP,   /*!< GPIO pull-up. */
     
122.     PullDown = LL_GPIO_PULL_DOWN, /*!< GPIO pull-down. */
     
123.   };
     
124.   
     
125.   /*! Enumeration of GPIO alternate functions. */
     
126.   enum GpioAlternate
     
127.   {
     
128.     Alternate0  = LL_GPIO_AF_0,  /*!< GPIO alternate function 0. */
     
129.     Alternate1  = LL_GPIO_AF_1,  /*!< GPIO alternate function 1. */
     
130.     Alternate2  = LL_GPIO_AF_2,  /*!< GPIO alternate function 2. */
     
131.     Alternate3  = LL_GPIO_AF_3,  /*!< GPIO alternate function 3. */
     
132.     Alternate4  = LL_GPIO_AF_4,  /*!< GPIO alternate function 4. */
     
133.     Alternate5  = LL_GPIO_AF_5,  /*!< GPIO alternate function 5. */
     
134.     Alternate6  = LL_GPIO_AF_6,  /*!< GPIO alternate function 6. */
     
135.     Alternate7  = LL_GPIO_AF_7,  /*!< GPIO alternate function 7. */
     
136.     Alternate8  = LL_GPIO_AF_8,  /*!< GPIO alternate function 8. */
     
137.     Alternate9  = LL_GPIO_AF_9,  /*!< GPIO alternate function 9. */
     
138.     Alternate10 = LL_GPIO_AF_10, /*!< GPIO alternate function 10. */
     
139.     Alternate11 = LL_GPIO_AF_11, /*!< GPIO alternate function 11. */
     
140.     Alternate12 = LL_GPIO_AF_12, /*!< GPIO alternate function 12. */
     
141.     Alternate13 = LL_GPIO_AF_13, /*!< GPIO alternate function 13. */
     
142.     Alternate14 = LL_GPIO_AF_14, /*!< GPIO alternate function 14. */
     
143.     Alternate15 = LL_GPIO_AF_15, /*!< GPIO alternate function 15. */
     
144.   };
     
145.   
     
146.   /*! Enumeration of GPIO levels. */
     
147.   enum GpioLevel
     
148.   {
     
149.     LevelLow  = 0, /*!< GPIO low level. */
     
150.     LevelHigh = 1, /*!< GPIO high level. */
     
151.   };
     
152.   
     
153.   XGpio(GpioPort port, GpioPin pin, GpioMode mode = ModeInput);
     
154.   virtual ~XGpio();
     
155.   
     
156.   void setPort(GpioPort port);
     
157.   GpioPort getPort() const;
     
158.   
     
159.   void setPin(GpioPin pin);
     
160.   GpioPin getPin() const;
     
161.   
     
162.   void setMode(GpioMode mode);
     
163.   GpioMode getMode() const;
     
164.   
     
165.   void setOutput(GpioOutput output);
     
166.   GpioOutput getOutput() const;
     
167.   
     
168.   void setSpeed(GpioSpeed speed);
     
169.   GpioSpeed getSpeed() const;
     
170.   
     
171.   void setPull(GpioPull pull);
     
172.   GpioPull getPull() const;
     
173.   
     
174.   void setAlternate(GpioAlternate alternate);
     
175.   GpioAlternate getAlternate() const;
     
176.   
     
177.   void setLevel(GpioLevel level);
     
178.   GpioLevel getLevel();
     
179.   
     
180.   void toggle();
     
181.   
     
182.   bool open();
     
183.   void close();
     
184.   
     
185.   bool isOpen() const;
     
186.   
     
187. private:
     
188.   GpioPort      port;
     
189.   GpioPin       pin;
     
190.   GpioMode      mode;
     
191.   GpioOutput    output;
     
192.   GpioSpeed     speed;
     
193.   GpioPull      pull;
     
194.   GpioAlternate alternate;
     
195.   GpioLevel     level;
     
196.   bool          openFlag;
     
197.   
     
198.   XGpio(const XGpio &) = delete;
     
199.   XGpio & operator = (const XGpio &) = delete;
     
200. };
     
201. 
     
202. #endif // STM32F4XX_XGPIO_H
     

复制代码

stm32f4xx_xgpio.cpp 文件

1. /**
   
2.   ******************************************************************************
   
3.   * \file    stm32f4xx_xgpio.cpp
   
4.   * \author  XinLi
   
5.   * \version v1.0
   
6.   * \date    20-March-2018
   
7.   * \brief   General purpose I/O module driver.
   
8.   ******************************************************************************
   
9.   * \attention
   
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    
14.   * it under the terms of the GNU General Public License as published by
    
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    
22.   *
    
23.   * You should have received a copy of the GNU General Public License
    
24.   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
25.   *
    
26.   ******************************************************************************
    
27.   */
    
28. 
    
29. #include "stm32f4xx_xgpio.h"
    
30. #include "stm32f4xx_ll_bus.h"
    
31. 
    
32. static __IO uint16_t openFlagPortA = 0;
    
33. static __IO uint16_t openFlagPortB = 0;
    
34. static __IO uint16_t openFlagPortC = 0;
    
35. #ifdef GPIOD
    
36. static __IO uint16_t openFlagPortD = 0;
    
37. #endif // GPIOD
    
38. #ifdef GPIOE
    
39. static __IO uint16_t openFlagPortE = 0;
    
40. #endif // GPIOE
    
41. #ifdef GPIOF
    
42. static __IO uint16_t openFlagPortF = 0;
    
43. #endif // GPIOF
    
44. #ifdef GPIOG
    
45. static __IO uint16_t openFlagPortG = 0;
    
46. #endif // GPIOG
    
47. #ifdef GPIOH
    
48. static __IO uint16_t openFlagPortH = 0;
    
49. #endif // GPIOH
    
50. #ifdef GPIOI
    
51. static __IO uint16_t openFlagPortI = 0;
    
52. #endif // GPIOI
    
53. #ifdef GPIOJ
    
54. static __IO uint16_t openFlagPortJ = 0;
    
55. #endif // GPIOJ
    
56. #ifdef GPIOK
    
57. static __IO uint16_t openFlagPortK = 0;
    
58. #endif // GPIOK
    
59. 
    
60. /*!
    
61.    \brief Open the general purpose I/O clock.
    
62.    \param port: GPIO port.
    
63. */
    
64. static void OpenGpioClock(XGpio::GpioPort port)
    
65. {
    
66.   if(port == XGpio::PortA)
    
67.   {
    
68.     LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOA);
    
69.   }
    
70.   else if(port == XGpio::PortB)
    
71.   {
    
72.     LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOB);
    
73.   }
    
74.   else if(port == XGpio::PortC)
    
75.   {
    
76.     LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOC);
    
77.   }
    
78. #ifdef GPIOD
    
79.   else if(port == XGpio::PortD)
    
80.   {
    
81.     LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOD);
    
82.   }
    
83. #endif // GPIOD
    
84. #ifdef GPIOE
    
85.   else if(port == XGpio::PortE)
    
86.   {
    
87.     LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOE);
    
88.   }
    
89. #endif // GPIOE
    
90. #ifdef GPIOF
    
91.   else if(port == XGpio::PortF)
    
92.   {
    
93.     LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOF);
    
94.   }
    
95. #endif // GPIOF
    
96. #ifdef GPIOG
    
97.   else if(port == XGpio::PortG)
    
98.   {
    
99.     LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOG);
    
100.   }
     
101. #endif // GPIOG
     
102. #ifdef GPIOH
     
103.   else if(port == XGpio::PortH)
     
104.   {
     
105.     LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOH);
     
106.   }
     
107. #endif // GPIOH
     
108. #ifdef GPIOI
     
109.   else if(port == XGpio::PortI)
     
110.   {
     
111.     LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOI);
     
112.   }
     
113. #endif // GPIOI
     
114. #ifdef GPIOJ
     
115.   else if(port == XGpio::PortJ)
     
116.   {
     
117.     LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOJ);
     
118.   }
     
119. #endif // GPIOJ
     
120. #ifdef GPIOK
     
121.   else if(port == XGpio::PortK)
     
122.   {
     
123.     LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_GPIOK);
     
124.   }
     
125. #endif // GPIOK
     
126. }
     
127. 
     
128. /*!
     
129.    \brief Close the general purpose I/O clock.
     
130.    \param port: GPIO port.
     
131. */
     
132. static void CloseGpioClock(XGpio::GpioPort port)
     
133. {
     
134.   if(port == XGpio::PortA)
     
135.   {
     
136.     LL_AHB1_GRP1_DisableClock(LL_AHB1_GRP1_PERIPH_GPIOA);
     
137.   }
     
138.   else if(port == XGpio::PortB)
     
139.   {
     
140.     LL_AHB1_GRP1_DisableClock(LL_AHB1_GRP1_PERIPH_GPIOB);
     
141.   }
     
142.   else if(port == XGpio::PortC)
     
143.   {
     
144.     LL_AHB1_GRP1_DisableClock(LL_AHB1_GRP1_PERIPH_GPIOC);
     
145.   }
     
146. #ifdef GPIOD
     
147.   else if(port == XGpio::PortD)
     
148.   {
     
149.     LL_AHB1_GRP1_DisableClock(LL_AHB1_GRP1_PERIPH_GPIOD);
     
150.   }
     
151. #endif // GPIOD
     
152. #ifdef GPIOE
     
153.   else if(port == XGpio::PortE)
     
154.   {
     
155.     LL_AHB1_GRP1_DisableClock(LL_AHB1_GRP1_PERIPH_GPIOE);
     
156.   }
     
157. #endif // GPIOE
     
158. #ifdef GPIOF
     
159.   else if(port == XGpio::PortF)
     
160.   {
     
161.     LL_AHB1_GRP1_DisableClock(LL_AHB1_GRP1_PERIPH_GPIOF);
     
162.   }
     
163. #endif // GPIOF
     
164. #ifdef GPIOG
     
165.   else if(port == XGpio::PortG)
     
166.   {
     
167.     LL_AHB1_GRP1_DisableClock(LL_AHB1_GRP1_PERIPH_GPIOG);
     
168.   }
     
169. #endif // GPIOG
     
170. #ifdef GPIOH
     
171.   else if(port == XGpio::PortH)
     
172.   {
     
173.     LL_AHB1_GRP1_DisableClock(LL_AHB1_GRP1_PERIPH_GPIOH);
     
174.   }
     
175. #endif // GPIOH
     
176. #ifdef GPIOI
     
177.   else if(port == XGpio::PortI)
     
178.   {
     
179.     LL_AHB1_GRP1_DisableClock(LL_AHB1_GRP1_PERIPH_GPIOI);
     
180.   }
     
181. #endif // GPIOI
     
182. #ifdef GPIOJ
     
183.   else if(port == XGpio::PortJ)
     
184.   {
     
185.     LL_AHB1_GRP1_DisableClock(LL_AHB1_GRP1_PERIPH_GPIOJ);
     
186.   }
     
187. #endif // GPIOJ
     
188. #ifdef GPIOK
     
189.   else if(port == XGpio::PortK)
     
190.   {
     
191.     LL_AHB1_GRP1_DisableClock(LL_AHB1_GRP1_PERIPH_GPIOK);
     
192.   }
     
193. #endif // GPIOK
     
194. }
     
195. 
     
196. /*!
     
197.    \brief Set the general purpose I/O pin flag.
     
198.    \param port: GPIO port.
     
199.    \param pin:  GPIO pin.
     
200. */
     
201. static void SetGpioPinFlag(XGpio::GpioPort port, XGpio::GpioPin pin)
     
202. {
     
203.   if(port == XGpio::PortA)
     
204.   {
     
205.     openFlagPortA |= pin;
     
206.   }
     
207.   else if(port == XGpio::PortB)
     
208.   {
     
209.     openFlagPortB |= pin;
     
210.   }
     
211.   else if(port == XGpio::PortC)
     
212.   {
     
213.     openFlagPortC |= pin;
     
214.   }
     
215. #ifdef GPIOD
     
216.   else if(port == XGpio::PortD)
     
217.   {
     
218.     openFlagPortD |= pin;
     
219.   }
     
220. #endif // GPIOD
     
221. #ifdef GPIOE
     
222.   else if(port == XGpio::PortE)
     
223.   {
     
224.     openFlagPortE |= pin;
     
225.   }
     
226. #endif // GPIOE
     
227. #ifdef GPIOF
     
228.   else if(port == XGpio::PortF)
     
229.   {
     
230.     openFlagPortF |= pin;
     
231.   }
     
232. #endif // GPIOF
     
233. #ifdef GPIOG
     
234.   else if(port == XGpio::PortG)
     
235.   {
     
236.     openFlagPortG |= pin;
     
237.   }
     
238. #endif // GPIOG
     
239. #ifdef GPIOH
     
240.   else if(port == XGpio::PortH)
     
241.   {
     
242.     openFlagPortH |= pin;
     
243.   }
     
244. #endif // GPIOH
     
245. #ifdef GPIOI
     
246.   else if(port == XGpio::PortI)
     
247.   {
     
248.     openFlagPortI |= pin;
     
249.   }
     
250. #endif // GPIOI
     
251. #ifdef GPIOJ
     
252.   else if(port == XGpio::PortJ)
     
253.   {
     
254.     openFlagPortJ |= pin;
     
255.   }
     
256. #endif // GPIOJ
     
257. #ifdef GPIOK
     
258.   else if(port == XGpio::PortK)
     
259.   {
     
260.     openFlagPortK |= pin;
     
261.   }
     
262. #endif // GPIOK
     
263. }
     
264. 
     
265. /*!
     
266.    \brief Reset the general purpose I/O pin flag.
     
267.    \param port: GPIO port.
     
268.    \param pin:  GPIO pin.
     
269. */
     
270. static void ResetGpioPinFlag(XGpio::GpioPort port, XGpio::GpioPin pin)
     
271. {
     
272.   if(port == XGpio::PortA)
     
273.   {
     
274.     openFlagPortA &= ~pin;
     
275.   }
     
276.   else if(port == XGpio::PortB)
     
277.   {
     
278.     openFlagPortB &= ~pin;
     
279.   }
     
280.   else if(port == XGpio::PortC)
     
281.   {
     
282.     openFlagPortC &= ~pin;
     
283.   }
     
284. #ifdef GPIOD
     
285.   else if(port == XGpio::PortD)
     
286.   {
     
287.     openFlagPortD &= ~pin;
     
288.   }
     
289. #endif // GPIOD
     
290. #ifdef GPIOE
     
291.   else if(port == XGpio::PortE)
     
292.   {
     
293.     openFlagPortE &= ~pin;
     
294.   }
     
295. #endif // GPIOE
     
296. #ifdef GPIOF
     
297.   else if(port == XGpio::PortF)
     
298.   {
     
299.     openFlagPortF &= ~pin;
     
300.   }
     
301. #endif // GPIOF
     
302. #ifdef GPIOG
     
303.   else if(port == XGpio::PortG)
     
304.   {
     
305.     openFlagPortG &= ~pin;
     
306.   }
     
307. #endif // GPIOG
     
308. #ifdef GPIOH
     
309.   else if(port == XGpio::PortH)
     
310.   {
     
311.     openFlagPortH &= ~pin;
     
312.   }
     
313. #endif // GPIOH
     
314. #ifdef GPIOI
     
315.   else if(port == XGpio::PortI)
     
316.   {
     
317.     openFlagPortI &= ~pin;
     
318.   }
     
319. #endif // GPIOI
     
320. #ifdef GPIOJ
     
321.   else if(port == XGpio::PortJ)
     
322.   {
     
323.     openFlagPortJ &= ~pin;
     
324.   }
     
325. #endif // GPIOJ
     
326. #ifdef GPIOK
     
327.   else if(port == XGpio::PortK)
     
328.   {
     
329.     openFlagPortK &= ~pin;
     
330.   }
     
331. #endif // GPIOK
     
332. }
     
333. 
     
334. /*!
     
335.    \brief  Is a general purpose I/O pin flag set?
     
336.    \param  port:  GPIO port.
     
337.    \param  pin:   GPIO pin.
     
338.    \retval true:  General purpose I/O pin flag are set.
     
339.    \retval false: General purpose I/O pin flag is not set.
     
340. */
     
341. static bool IsSetGpioPinFlag(XGpio::GpioPort port, XGpio::GpioPin pin)
     
342. {
     
343.   if(port == XGpio::PortA)
     
344.   {
     
345.     return ((openFlagPortA & pin) == pin);
     
346.   }
     
347.   else if(port == XGpio::PortB)
     
348.   {
     
349.     return ((openFlagPortB & pin) == pin);
     
350.   }
     
351.   else if(port == XGpio::PortC)
     
352.   {
     
353.     return ((openFlagPortC & pin) == pin);
     
354.   }
     
355. #ifdef GPIOD
     
356.   else if(port == XGpio::PortD)
     
357.   {
     
358.     return ((openFlagPortD & pin) == pin);
     
359.   }
     
360. #endif // GPIOD
     
361. #ifdef GPIOE
     
362.   else if(port == XGpio::PortE)
     
363.   {
     
364.     return ((openFlagPortE & pin) == pin);
     
365.   }
     
366. #endif // GPIOE
     
367. #ifdef GPIOF
     
368.   else if(port == XGpio::PortF)
     
369.   {
     
370.     return ((openFlagPortF & pin) == pin);
     
371.   }
     
372. #endif // GPIOF
     
373. #ifdef GPIOG
     
374.   else if(port == XGpio::PortG)
     
375.   {
     
376.     return ((openFlagPortG & pin) == pin);
     
377.   }
     
378. #endif // GPIOG
     
379. #ifdef GPIOH
     
380.   else if(port == XGpio::PortH)
     
381.   {
     
382.     return ((openFlagPortH & pin) == pin);
     
383.   }
     
384. #endif // GPIOH
     
385. #ifdef GPIOI
     
386.   else if(port == XGpio::PortI)
     
387.   {
     
388.     return ((openFlagPortI & pin) == pin);
     
389.   }
     
390. #endif // GPIOI
     
391. #ifdef GPIOJ
     
392.   else if(port == XGpio::PortJ)
     
393.   {
     
394.     return ((openFlagPortJ & pin) == pin);
     
395.   }
     
396. #endif // GPIOJ
     
397. #ifdef GPIOK
     
398.   else if(port == XGpio::PortK)
     
399.   {
     
400.     return ((openFlagPortK & pin) == pin);
     
401.   }
     
402. #endif // GPIOK
     
403.   else
     
404.   {
     
405.     return true;
     
406.   }
     
407. }
     
408. 
     
409. /*!
     
410.    \brief  Is there a general purpose I/O pin set flag?
     
411.    \param  port:  GPIO port.
     
412.    \retval true:  There is a general purpose I/O pin set flag.
     
413.    \retval false: There is no general purpose I/O pin set flag.
     
414. */
     
415. static bool IsHaveSetGpioPinFlag(XGpio::GpioPort port)
     
416. {
     
417.   if(port == XGpio::PortA)
     
418.   {
     
419.     return (openFlagPortA != 0);
     
420.   }
     
421.   else if(port == XGpio::PortB)
     
422.   {
     
423.     return (openFlagPortB != 0);
     
424.   }
     
425.   else if(port == XGpio::PortC)
     
426.   {
     
427.     return (openFlagPortC != 0);
     
428.   }
     
429. #ifdef GPIOD
     
430.   else if(port == XGpio::PortD)
     
431.   {
     
432.     return (openFlagPortD != 0);
     
433.   }
     
434. #endif // GPIOD
     
435. #ifdef GPIOE
     
436.   else if(port == XGpio::PortE)
     
437.   {
     
438.     return (openFlagPortE != 0);
     
439.   }
     
440. #endif // GPIOE
     
441. #ifdef GPIOF
     
442.   else if(port == XGpio::PortF)
     
443.   {
     
444.     return (openFlagPortF != 0);
     
445.   }
     
446. #endif // GPIOF
     
447. #ifdef GPIOG
     
448.   else if(port == XGpio::PortG)
     
449.   {
     
450.     return (openFlagPortG != 0);
     
451.   }
     
452. #endif // GPIOG
     
453. #ifdef GPIOH
     
454.   else if(port == XGpio::PortH)
     
455.   {
     
456.     return (openFlagPortH != 0);
     
457.   }
     
458. #endif // GPIOH
     
459. #ifdef GPIOI
     
460.   else if(port == XGpio::PortI)
     
461.   {
     
462.     return (openFlagPortI != 0);
     
463.   }
     
464. #endif // GPIOI
     
465. #ifdef GPIOJ
     
466.   else if(port == XGpio::PortJ)
     
467.   {
     
468.     return (openFlagPortJ != 0);
     
469.   }
     
470. #endif // GPIOJ
     
471. #ifdef GPIOK
     
472.   else if(port == XGpio::PortK)
     
473.   {
     
474.     return (openFlagPortK != 0);
     
475.   }
     
476. #endif // GPIOK
     
477.   else
     
478.   {
     
479.     return true;
     
480.   }
     
481. }
     
482. 
     
483. /*!
     
484.    \brief General purpose I/O module constructor.
     
485.    \param port: GPIO port.
     
486.    \param pin:  GPIO pin.
     
487.    \param mode: GPIO mode.
     
488. */
     
489. XGpio::XGpio(GpioPort port, GpioPin pin, GpioMode mode)
     
490. {
     
491.   this->port      = port;
     
492.   this->pin       = pin;
     
493.   this->mode      = mode;
     
494.   this->output    = OutputPushPull;
     
495.   this->speed     = SpeedLow;
     
496.   this->pull      = PullNo;
     
497.   this->alternate = Alternate0;
     
498.   this->level     = LevelLow;
     
499.   this->openFlag  = false;
     
500. }
     
501. 
     
502. /*!
     
503.    \brief   General purpose I / O module destructor.
     
504.    \details Restore generic I/O to its default state(input mode, push-pull output,
     
505.             low output speed, no pull, alternate function 0, low level).
     
506. */
     
507. XGpio::~XGpio()
     
508. {
     
509.   close();
     
510. }
     
511. 
     
512. /*!
     
513.    \brief Set general purpose I/O port.
     
514.    \param port: GPIO port.
     
515. */
     
516. void XGpio::setPort(GpioPort port)
     
517. {
     
518.   if(openFlag != true)
     
519.   {
     
520.     this->port = port;
     
521.   }
     
522. }
     
523. 
     
524. /*!
     
525.    \brief  Get general purpose I/O port.
     
526.    \return GPIO port.
     
527. */
     
528. XGpio::GpioPort XGpio::getPort() const
     
529. {
     
530.   return port;
     
531. }
     
532. 
     
533. /*!
     
534.    \brief Set general purpose I/O pin.
     
535.    \param pin: GPIO pin.
     
536. */
     
537. void XGpio::setPin(GpioPin pin)
     
538. {
     
539.   if(openFlag != true)
     
540.   {
     
541.     this->pin = pin;
     
542.   }
     
543. }
     
544. 
     
545. /*!
     
546.    \brief  Get general purpose I/O pin.
     
547.    \return GPIO pin.
     
548. */
     
549. XGpio::GpioPin XGpio::getPin() const
     
550. {
     
551.   return pin;
     
552. }
     
553. 
     
554. /*!
     
555.    \brief Set general purpose I/O mode.
     
556.    \param mode: GPIO mode.
     
557. */
     
558. void XGpio::setMode(GpioMode mode)
     
559. {
     
560.   this->mode = mode;
     
561.   
     
562.   if(openFlag == true)
     
563.   {
     
564.     LL_GPIO_SetPinMode((GPIO_TypeDef *)port, pin, mode);
     
565.   }
     
566. }
     
567. 
     
568. /*!
     
569.    \brief  Get general purpose I/O mode.
     
570.    \return GPIO mode.
     
571. */
     
572. XGpio::GpioMode XGpio::getMode() const
     
573. {
     
574.   return mode;
     
575. }
     
576. 
     
577. /*!
     
578.    \brief Set general purpose I/O output type.
     
579.    \param output: GPIO output type.
     
580. */
     
581. void XGpio::setOutput(GpioOutput output)
     
582. {
     
583.   this->output = output;
     
584.   
     
585.   if(openFlag == true)
     
586.   {
     
587.     LL_GPIO_SetPinOutputType((GPIO_TypeDef *)port, pin, output);
     
588.   }
     
589. }
     
590. 
     
591. /*!
     
592.    \brief  Get general purpose I/O output type.
     
593.    \return GPIO output type.
     
594. */
     
595. XGpio::GpioOutput XGpio::getOutput() const
     
596. {
     
597.   return output;
     
598. }
     
599. 
     
600. /*!
     
601.    \brief Set general purpose I/O output speed.
     
602.    \param speed: GPIO output speed.
     
603. */
     
604. void XGpio::setSpeed(GpioSpeed speed)
     
605. {
     
606.   this->speed = speed;
     
607.   
     
608.   if(openFlag == true)
     
609.   {
     
610.     LL_GPIO_SetPinSpeed((GPIO_TypeDef *)port, pin, speed);
     
611.   }
     
612. }
     
613. 
     
614. /*!
     
615.    \brief  Get general purpose I/O output speed.
     
616.    \return GPIO output speed.
     
617. */
     
618. XGpio::GpioSpeed XGpio::getSpeed() const
     
619. {
     
620.   return speed;
     
621. }
     
622. 
     
623. /*!
     
624.    \brief Set general purpose I/O pull-up/pull-down.
     
625.    \param pull: GPIO pull-up/pull-down.
     
626. */
     
627. void XGpio::setPull(GpioPull pull)
     
628. {
     
629.   this->pull = pull;
     
630.   
     
631.   if(openFlag == true)
     
632.   {
     
633.     LL_GPIO_SetPinPull((GPIO_TypeDef *)port, pin, pull);
     
634.   }
     
635. }
     
636. 
     
637. /*!
     
638.    \brief  Get general purpose I/O pull-up/pull-down.
     
639.    \return GPIO pull-up/pull-down.
     
640. */
     
641. XGpio::GpioPull XGpio::getPull() const
     
642. {
     
643.   return pull;
     
644. }
     
645. 
     
646. /*!
     
647.    \brief Set general purpose I/O alternate function.
     
648.    \param alternate: GPIO alternate function.
     
649. */
     
650. void XGpio::setAlternate(GpioAlternate alternate)
     
651. {
     
652.   this->alternate = alternate;
     
653.   
     
654.   if(openFlag == true)
     
655.   {
     
656.     if(pin < Pin8)
     
657.     {
     
658.       LL_GPIO_SetAFPin_0_7((GPIO_TypeDef *)port, pin, alternate);
     
659.     }
     
660.     else
     
661.     {
     
662.       LL_GPIO_SetAFPin_8_15((GPIO_TypeDef *)port, pin, alternate);
     
663.     }
     
664.   }
     
665. }
     
666. 
     
667. /*!
     
668.    \brief  Get general purpose I/O alternate function.
     
669.    \return GPIO alternate function.
     
670. */
     
671. XGpio::GpioAlternate XGpio::getAlternate() const
     
672. {
     
673.   return alternate;
     
674. }
     
675. 
     
676. /*!
     
677.    \brief Set general purpose I/O level status.
     
678.    \param level: GPIO level status.
     
679. */
     
680. void XGpio::setLevel(GpioLevel level)
     
681. {
     
682.   this->level = level;
     
683.   
     
684.   if(openFlag == true)
     
685.   {
     
686.     if(level != LevelLow)
     
687.     {
     
688.       LL_GPIO_SetOutputPin((GPIO_TypeDef *)port, pin);
     
689.     }
     
690.     else
     
691.     {
     
692.       LL_GPIO_ResetOutputPin((GPIO_TypeDef *)port, pin);
     
693.     }
     
694.   }
     
695. }
     
696. 
     
697. /*!
     
698.    \brief  Get general purpose I/O level status.
     
699.    \return GPIO level status.
     
700. */
     
701. XGpio::GpioLevel XGpio::getLevel()
     
702. {
     
703.   if(openFlag == true)
     
704.   {
     
705.     level = (GpioLevel)LL_GPIO_IsInputPinSet((GPIO_TypeDef *)port, pin);
     
706.   }
     
707.   
     
708.   return level;
     
709. }
     
710. 
     
711. /*!
     
712.    \brief Toggle general purpose I/O level status.
     
713. */
     
714. void XGpio::toggle()
     
715. {
     
716.   level = level != LevelLow ? LevelLow : LevelHigh;
     
717.   
     
718.   if(openFlag == true)
     
719.   {
     
720.     LL_GPIO_TogglePin((GPIO_TypeDef *)port, pin);
     
721.   }
     
722. }
     
723. 
     
724. /*!
     
725.    \brief Open general purpose I/O pin.
     
726. */
     
727. bool XGpio::open()
     
728. {
     
729.   if(IsSetGpioPinFlag(port, pin) != true)
     
730.   {
     
731.     if(IsHaveSetGpioPinFlag(port) != true)
     
732.     {
     
733.       OpenGpioClock(port);
     
734.     }
     
735.    
     
736.     SetGpioPinFlag(port, pin);
     
737.    
     
738.     LL_GPIO_SetPinMode((GPIO_TypeDef *)port, pin, mode);
     
739.     LL_GPIO_SetPinOutputType((GPIO_TypeDef *)port, pin, output);
     
740.     LL_GPIO_SetPinSpeed((GPIO_TypeDef *)port, pin, speed);
     
741.     LL_GPIO_SetPinPull((GPIO_TypeDef *)port, pin, pull);
     
742.    
     
743.     if(pin < Pin8)
     
744.     {
     
745.       LL_GPIO_SetAFPin_0_7((GPIO_TypeDef *)port, pin, alternate);
     
746.     }
     
747.     else
     
748.     {
     
749.       LL_GPIO_SetAFPin_8_15((GPIO_TypeDef *)port, pin, alternate);
     
750.     }
     
751.    
     
752.     if(level != LevelLow)
     
753.     {
     
754.       LL_GPIO_SetOutputPin((GPIO_TypeDef *)port, pin);
     
755.     }
     
756.     else
     
757.     {
     
758.       LL_GPIO_ResetOutputPin((GPIO_TypeDef *)port, pin);
     
759.     }
     
760.    
     
761.     openFlag = true;
     
762.    
     
763.     return true;
     
764.   }
     
765.   else
     
766.   {
     
767.     return false;
     
768.   }
     
769. }
     
770. 
     
771. /*!
     
772.    \brief   Close general purpose I/O pin.
     
773.    \details Restore generic I/O to its default state(input mode, push-pull output,
     
774.             low output speed, no pull, alternate function 0, low level).
     
775. */
     
776. void XGpio::close()
     
777. {
     
778.   if(openFlag == true)
     
779.   {
     
780.     LL_GPIO_SetPinMode((GPIO_TypeDef *)port, pin, ModeInput);
     
781.     LL_GPIO_SetPinOutputType((GPIO_TypeDef *)port, pin, OutputPushPull);
     
782.     LL_GPIO_SetPinSpeed((GPIO_TypeDef *)port, pin, SpeedLow);
     
783.     LL_GPIO_SetPinPull((GPIO_TypeDef *)port, pin, PullNo);
     
784.    
     
785.     if(pin < Pin8)
     
786.     {
     
787.       LL_GPIO_SetAFPin_0_7((GPIO_TypeDef *)port, pin, Alternate0);
     
788.     }
     
789.     else
     
790.     {
     
791.       LL_GPIO_SetAFPin_8_15((GPIO_TypeDef *)port, pin, Alternate0);
     
792.     }
     
793.    
     
794.     LL_GPIO_ResetOutputPin((GPIO_TypeDef *)port, pin);
     
795.    
     
796.     ResetGpioPinFlag(port, pin);
     
797.    
     
798.     if(IsHaveSetGpioPinFlag(port) != true)
     
799.     {
     
800.       CloseGpioClock(port);
     
801.     }
     
802.    
     
803.     openFlag = false;
     
804.   }
     
805. }
     
806. 
     
807. /*!
     
808.    \brief  Is the general purpose I/O pin open?
     
809.    \retval true:  General purpose I/O pin open.
     
810.    \retval false: General purpose I/O pin not open.
     
811. */
     
812. bool XGpio::isOpen() const
     
813. {
     
814.   return openFlag;
     
815. }
     

复制代码

例程

1. /**
   
2.   ******************************************************************************
   
3.   * @file    main.cpp
   
4.   * @author  XinLi
   
5.   * @version v1.0
   
6.   * @date    20-March-2018
   
7.   * @brief   Main program body.
   
8.   ******************************************************************************
   
9.   * @attention
   
10.   *
    
11.   * <h2><center>Copyright © 2018 XinLi</center></h2>
    
12.   *
    
13.   * This program is free software: you can redistribute it and/or modify
    
14.   * it under the terms of the GNU General Public License as published by
    
15.   * the Free Software Foundation, either version 3 of the License, or
    
16.   * (at your option) any later version.
    
17.   *
    
18.   * This program is distributed in the hope that it will be useful,
    
19.   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
20.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
21.   * GNU General Public License for more details.
    
22.   *
    
23.   * You should have received a copy of the GNU General Public License
    
24.   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
25.   *
    
26.   ******************************************************************************
    
27.   */
    
28. 
    
29. /* Header includes -----------------------------------------------------------*/
    
30. #include "main.h"
    
31. #include "stm32f4xx_xgpio.h"
    
32. 
    
33. /* Macro definitions ---------------------------------------------------------*/
    
34. /* Type definitions ----------------------------------------------------------*/
    
35. /* Variable declarations -----------------------------------------------------*/
    
36. /* Variable definitions ------------------------------------------------------*/
    
37. /* Function declarations -----------------------------------------------------*/
    
38. static void SystemClock_Config(void);
    
39. 
    
40. /* Function definitions ------------------------------------------------------*/
    
41. 
    
42. /**
    
43.   * @brief  Main program.
    
44.   * @param  None.
    
45.   * @return None.
    
46.   */
    
47. int main(void)
    
48. {
    
49.   /* STM32F4xx HAL library initialization:
    
50.        - Configure the Flash prefetch, instruction and Data caches
    
51.        - Configure the Systick to generate an interrupt each 1 msec
    
52.        - Set NVIC Group Priority to 4
    
53.        - Global MSP (MCU Support Package) initialization
    
54.      */
    
55.   HAL_Init();
    
56.   
    
57.   /* Configure the system clock to 168 MHz */
    
58.   SystemClock_Config();
    
59.   
    
60.   XGpio led0(XGpio::PortF, XGpio::Pin9,  XGpio::ModeOutput);
    
61.   XGpio led1(XGpio::PortF, XGpio::Pin10, XGpio::ModeOutput);
    
62.   
    
63.   led0.open();
    
64.   led1.open();
    
65.   
    
66.   for(;;)
    
67.   {
    
68.     HAL_Delay(250);
    
69.     led0.toggle();
    
70.     HAL_Delay(250);
    
71.     led1.toggle();
    
72.   }
    
73. }
    
74. 
    
75. /**
    
76.   * @brief  System Clock Configuration
    
77.   *         The system Clock is configured as follow :
    
78.   *            System Clock source            = PLL (HSE)
    
79.   *            SYSCLK(Hz)                     = 168000000
    
80.   *            HCLK(Hz)                       = 168000000
    
81.   *            AHB Prescaler                  = 1
    
82.   *            APB1 Prescaler                 = 4
    
83.   *            APB2 Prescaler                 = 2
    
84.   *            HSE Frequency(Hz)              = 8000000
    
85.   *            PLL_M                          = 8
    
86.   *            PLL_N                          = 336
    
87.   *            PLL_P                          = 2
    
88.   *            PLL_Q                          = 7
    
89.   *            VDD(V)                         = 3.3
    
90.   *            Main regulator output voltage  = Scale1 mode
    
91.   *            Flash Latency(WS)              = 5
    
92.   * @param  None
    
93.   * @retval None
    
94.   */
    
95. static void SystemClock_Config(void)
    
96. {
    
97.   RCC_ClkInitTypeDef RCC_ClkInitStruct;
    
98.   RCC_OscInitTypeDef RCC_OscInitStruct;
    
99. 
    
100.   /* Enable Power Control clock */
     
101.   __HAL_RCC_PWR_CLK_ENABLE();
     
102. 
     
103.   /* The voltage scaling allows optimizing the power consumption when the device is
     
104.      clocked below the maximum system frequency, to update the voltage scaling value
     
105.      regarding system frequency refer to product datasheet.  */
     
106.   __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
     
107. 
     
108.   /* Enable HSE Oscillator and activate PLL with HSE as source */
     
109.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
     
110.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
     
111.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
     
112.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
     
113.   RCC_OscInitStruct.PLL.PLLM = 8;
     
114.   RCC_OscInitStruct.PLL.PLLN = 336;
     
115.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
     
116.   RCC_OscInitStruct.PLL.PLLQ = 7;
     
117.   HAL_RCC_OscConfig(&RCC_OscInitStruct);
     
118.   
     
119.   /* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2
     
120.      clocks dividers */
     
121.   RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
     
122.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
     
123.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
     
124.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;  
     
125.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;  
     
126.   HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);
     
127. 
     
128.   /* STM32F405x/407x/415x/417x Revision Z devices: prefetch is supported  */
     
129.   if (HAL_GetREVID() == 0x1001)
     
130.   {
     
131.     /* Enable the Flash prefetch */
     
132.     __HAL_FLASH_PREFETCH_BUFFER_ENABLE();
     
133.   }
     
134. }
     

复制代码

归档链接

STM32F4 C++ 封装库 之 EXTI

有点意思。。。局部封装挺不错的。。。

技术角度上,非常认可,赞...产品角度上,何苦呢?

mbed 做了这些工作

butterflyspring 发表于 2018-4-2 10:10
技术角度上,非常认可,赞...产品角度上,何苦呢?

用 C 语言想要写出容易维护的程序，远远没有 C++ 语言实现的要简单，更何况刚入行没有多久的新人去开发那，C++ 语言只要稍微学习一下类和虚函数，用到开发中还是比较容易的，然后后续的程序维护也简单了些。

hawk123345 发表于 2018-4-2 13:56
mbed 做了这些工作

是这样的，但是 mbed 的程序，当应用层的对象销毁时，底层的硬件，并没有跟着去恢复上电的初始状态，驱动部分并没有用 C++ 去实现，只是封装了 C++ 接口。不过 mbed 经过这么多年的发展已经到了 v5.8 生态系统也比较完善，也有一定的生产力了，看来是时候把它用在工作当中了

赞一个

感谢分享，请汇总到4月技术原创
https://www.stmcu.org.cn/module/forum/thread-615497-1-1.html

感谢分享，大赞。

我一直是用c++开发的
这是我的类
PORT:ORT(){};
PORT:ORT(GPIO_TypeDef* gpio,u8 pin,GPIOMode_TypeDef mode,GPIOOType_TypeDef type,GPIOPuPd_TypeDef pupd,GPIOSpeed_TypeDef speed){
if (gpio==GPIOA) PortNo=0;
if (gpio==GPIOB) PortNo=1;
if (gpio==GPIOC) PortNo=2;
if (gpio==GPIOD) PortNo=3;
if (gpio==GPIOE) PortNo=4;
if (gpio==GPIOF) PortNo=5;

GPIO=gpio;
Pin=1<<pin;
PinNo=pin*2;
  
  RCC->AHB1ENR |= 1<<ortNo;
  
  setType(type);
  setMode(mode);
  setPUPD(pupd);
  setSpeed(speed);

}

void PORT:ow() {
  ///GPIO->BSRRH =Pin;
  GPIO->ODR &=~(1<<(PinNo/2));
}
void PORT::High() {
  //GPIO->BSRRL =Pin;
  GPIO->ODR |=1<<(PinNo/2);
}
void PORT::setType(GPIOOType_TypeDef type) {
    //GPIO->OTYPER  &= ~(GPIO_OTYPER_OT_0 << (uint16_t)(PinNo/2)) ;
    //GPIO->OTYPER |= (uint16_t)(type<< (uint16_t)(PinNo/2));

  GPIO->OTYPER &=~(1<<(PinNo/2));
  GPIO->OTYPER |=type<<(PinNo/2);
}
void PORT::setSpeed(GPIOSpeed_TypeDef speed) {
    //GPIO->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR0 << PinNo);
  GPIO->OSPEEDR &=~(3<<inNo);
    GPIO->OSPEEDR |= (speed << PinNo);
}
void PORT::setPUPD(GPIOPuPd_TypeDef pupd) {
  //GPIO->UPDR &= ~(GPIO_PUPDR_PUPDR0 << PinNo);
  GPIO->UPDR &=~(3<<inNo);
    GPIO->UPDR |= (pupd << PinNo);
}
void PORT::setMode(GPIOMode_TypeDef mode) {
  //GPIO->MODER  &= ~(GPIO_MODER_MODER0 << PinNo);
  GPIO->MODER &= ~(3<<inNo);
    GPIO->MODER |= (mode << PinNo);
}
u8 PORT::Read() {
  return GPIO_ReadInputDataBit(GPIO,Pin);
  //return (GPIO->IDR & Pin);
}

还封装了 LED灯、LED单采、LED全彩、ILI9341,SSD1315,LD3320,SD卡 开关、串口、IIC、SPI、DTU、WIFI、外部flash，内部flash，LAN(w5500)和一部分传感器（温湿，pm25,负氧离子，SO2.....)
支持 f103c8t6和f407vet6。
usart,iic,spi 实现软硬2种方式。

LED LED_Running(GPIOD,10);

使用 ：LED_Running.Turn(true);点亮, LED_Running.Turn(false);点黑

SWITCH wifiSwitch(GPIOE,9);

使用：if (wifiSwitch.isOn) 是否开，if (wifiSwitch.isOff) 是否关，类里已经处理重复触发。

USART usart_wifi(USART1,new PORT(GPIOA,9),new PORT(GPIOA,10),0,115200);

使用：usart_wifi.sendData(buf,8);

SPI spi_flash(SPI1);或者SPI spi_sort(new PORT(GPIOA,9,....)软件模拟spi
使用： spi_flash.sendData(buf,8);

IIC iic_Pm25(new PORT(GPIOC,9),new PORT(GPIOA,8));
WIFI wifi(&usart_wifi);
DTU dtu(&usart_dtu);
LAN lan(&spi_lan,new PORT(GPIOE,0),new PORT(GPIOB,8),new PORT(GPIOB,9),&LED_Lan);

使用 SOCKET tcp=lan.InitTCP();sock.connect();
SOCKET udp=lan.InitUDP();sock.bind();
udp.sendData(buf,len);
内部自增加socket，

EFLASH eflash(&spi_flash,new PORT(GPIOA,4));
VAR var(&eflash); 变量管理，如果用内部存储，就定义个 MEMORY flash(&spi....)然后 VAR var(&flash)
使用 var.setInt(key,value) var.getInt(key)

TEMPHUMI TempHumi(&usart5);
ION Ion(&usart5); 温湿度和负氧离子，使用的是同一个485的 usart5口
PM25 Pm25(&iic_Pm25); pm25用的iic的，如果是串口的，就用 PM25 Pm25(&usart5);

使用 Pm25.setType(厂家设备型号), 里面会处理，发送什么数据，接收应该检测什么数据。

感谢分享