结构体和STM32的库函数

结构体基础知识 和 解析STM32的库函数

自定义结构体：

1. struct weapon{
   
2. char name[20];
   ( J  v' J* W5 h. T9 q7 C$ ]0 ?
3. int atk;
   3 H3 B$ W$ `$ E1 w3 n$ A; w
4. int price;
   + ^$ {) G: o( Y- @( b& x+ X/ y
5. };
   

复制代码

" j! s( L1 @6 B

它是"weapon"型（类似于我们熟知的int型，String型等），里面有一个char类型，两个int类型。

如何给这个结构体赋值以及访问里面的属性？

1. struct weapon weapon_1 = {"weapon_name",100,200};
   
2. printf("%s\n,%d\n",weapon_1.name,++weapon_1.price);
   

复制代码

结构体变量的初始化：

结构体变量的应用：

结构体中的成员，可以像普通变量那样单独使用，如下面例子中，结构体变量A中的成员num，可以用A.num的方式来使用。

结构体变量的成员引用：结构体变量名.成员名

当一个指针变量指向结构体时，我们就称它为结构体指针。C语言结构体指针的定义形式一般为：

struct 结构体名 *变量名;

下面是一个定义结构体指针的实例：

1. //结构体
   
2. struct stu{
   
3.     char *name;  //姓名
   
4.     int num;  //学号
   
5.     int age;  //年龄
   
6.     char group;  //所在小组
   
7.     float score;  //成绩
   / I1 V0 R2 p) u; ~) \
8. } stu1 = { "Tom", 12, 18, 'A', 136.5 };
   
9. //结构体指针
   ' W, {2 v0 D) V8 g
10. struct stu *pstu = &stu1;

复制代码

也可以在定义结构体的同时定义结构体指针：

1. struct stu{
   
2.     char *name;  //姓名
   2 X' {! y8 I" b* _( O
3.     int num;  //学号
   
4.     int age;  //年龄
   # Z% U# l4 Q5 H; @- d
5.     char group;  //所在小组
   ' l  a; O3 e( W+ V. f8 a
6.     float score;  //成绩
   + ?! X! v. @% K& H( z& N% n
7. } stu1 = { "Tom", 12, 18, 'A', 136.5 }, *pstu = &stu1;
   , ?; N1 l9 c( F

复制代码

注意，结构体变量名和数组名不同，数组名在表达式中会被转换为数组指针，而结构体变量名不会，无论在任何表达式中它表示的都是整个集合本身，要想取得结构体变量的地址，必须在前面加&，所以给 pstu 赋值只能写作：

1. struct stu *pstu = &stu1;

复制代码

  d1 P* h3 o: B6 o9 k8 l

而不能写作：

1. struct stu *pstu = stu1;

复制代码

还应该注意，结构体和结构体变量是两个不同的概念：结构体是一种数据类型，是一种创建变量的模板，

编译器不会为它分配内存空间，就像 int、float、char 这些关键字本身不占用内存一样；

结构体变量才包含实实在在的数据，才需要内存来存储。下面的写法是错误的，不可能去取一个结构体名的地址，也不能将它赋值给其他变量：

1. struct stu *pstu = &stu;
   
2. struct stu *pstu = stu;

复制代码

获取结构体成员

通过结构体指针可以获取结构体成员，一般形式为：

(*pointer).memberName

或者：

pointer->memberName

上面的两种写法是等效的，我们通常采用后面的写法，这样更加直观。

解析STM32的库函数

意法半导体在推出STM32微控制器之初，也同时提供了一套完整细致的固件开发包，里面包含了在STM32开发过程中所涉及到的所有底层操作。通过在程序开发中引入这样的固件开发包，可以使开发人员从复杂冗余的底层寄存器操作中解放出来，将精力专注应用程序的开发上，这便是ST推出这样一个开发包的初衷。

但这对于许多从51/AVR这类单片机的开发转到STM32平台的开发人员来说，势必有一个不适应的过程。因为程序开发不再是从寄存器层次起始，而要首先去熟悉STM32所提供的固件库。那是否一定要使用固件库呢？当然不是。但STM32微控制器的寄存器规模可不是常见的8位单片机可以比拟，若自己细细琢磨各个寄存器的意义，必然会消耗相当的时间，并且对于程序后续的维护，升级来说也会增加资源的消耗。对于当前“时间就是金钱”的行业竞争环境，无疑使用库函数进行STM32的产品开发是更好的选择。本文将通过一个简单的例子对STM32的库函数做一个简单的剖析。

以最常用的GPIO设备的初始化函数为例，如下程序段一：

这是一个在STM32的程序开发中经常使用到的GPIO初始化程序段，其功能是将GPIOA.4口初始化为推挽输出状态，并最大翻转速率为50MHz。下面逐一分解：

l  首先是1，该语句显然定义了一个GPIO_InitTypeDef类型的变量，名为GPIO_InitStructure，则找出GPIO_InitTypeDef的原型位于“stm32f10x_gpio.h”文件，原型如下：

1. typedef struct
   
2. {
   
3. u16 GPIO_Pin;
   
4. GPIOSpeed_TypeDef GPIO_Speed;
   $ V) M9 z- S- n! ]9 Y% z; ?
5. GPIOMode_TypeDef GPIO_Mode;
   . r5 a4 D; h5 `) N  \0 P
6. }GPIO_InitTypeDef;
   

复制代码

( }5 c3 o" u% A

由此可知GPIO_InitTypeDef是一个结构体类型同义字，其功能是定义一个结构体，该结构体有三个成员分别是u16类型的GPIO_Pin、GPIOSpeed_TypeDef类型的GPIO_Speed和GPIOMode_TypeDef 类型的GPIO_Mode。继续探查GPIOSpeed_TypeDef和GPIOMode_TypeDef类型，在“stm32f10x_gpio.h”文件中找到对GPIOSpeed_TypeDef的定义：

1. typedef enum
   
2. {
   : O; H/ z6 n( G
3. GPIO_Speed_10MHz = 1,
   
4. GPIO_Speed_2MHz,
   9 f9 j4 F. ^- e4 q
5. GPIO_Speed_50MHz
   
6. }GPIOSpeed_TypeDef;
   

复制代码

/ Q* O3 ]7 n. v! H4 r' p

则可知GPIOSpeed_TypeDef枚举类型同一只，其功能是定义一个枚举类型变量，该变量可表示GPIO_Speed_10MHz、GPIO_Speed_2MHz和GPIO_Speed_50MHz三个含义（其中GPIO_Speed_10MHz已经定义为1，读者必须知道GPIO_Speed_2MHz则依次被编译器赋予2，而GPIO_Speed_50MHz为3）。

同样也在“stm32f10x_gpio.h”文件中找到对GPIOMode_TypeDef的定义：

1. typedef enum
   
2. {
   + ]$ P5 B' O  ~$ O& b% T$ g. A. n3 R
3. GPIO_Mode_AIN = 0x0,
   
4. GPIO_Mode_IN_FLOATING = 0x04,
   
5. GPIO_Mode_IPD = 0x28,
   
6. GPIO_Mode_IPU = 0x48,
   % b& e' N, F5 K) d& Z% ^
7. GPIO_Mode_Out_OD = 0x14,
   
8. GPIO_Mode_Out_PP = 0x10,
   
9. GPIO_Mode_AF_OD = 0x1C,
   
10. GPIO_Mode_AF_PP = 0x18
    5 h7 l$ R- M- l; B# o; b  s
11. }GPIOMode_TypeDef;
      O$ X9 a$ X6 Q

复制代码

) e  A9 H! O* t3 P

1 d4 x. p- n1 c9 ~# @4 a( E: g

这同样是一个枚举类型同义字，其成员有GPIO_Mode_AIN、GPIO_Mode_AF_OD等（也可以轻易判断出这表示GPIO设备的工作模式）。

至此对程序段一的○1解析可以做一个总结：

该行定义一个结构体类型的变量GPIO_InitStructure，并且该结构体有3个成员，分别为GPIO_Pin、GPIO_Speed和GPIO_Mode，并且GPIO_Pin表示GPIO设备引脚GPIO_Speed表示GPIO设备速率和GPIO_Mode表示GPIO设备工作模式。

接下来是2，此句是一个赋值语句，把GPIO_Pin_4赋给GPIO_InitStructure结构体中的成员GPIO_Pin，可以在“stm32f10x_gpio.h”文件中找到对GPIO_Pin_4做的宏定义：

#define GPIO_Pin_4 ((u16)0x0010)

因此○2的本质是将16位数0x0010赋给GPIO_InitStructure结构体中的成员GPIO_Pin。

3语句和2相似将GPIO_Speed_50MHz赋给GPIO_InitStructure结构体中的成员GPIO_Speed，但注意到此处GPIO_Speed_50MHz只是一个枚举变量，并非具体的某个值。

4语句亦和2语句类似，把GPIO_Mode_Out_PP赋给GPIO_InitStructure结构体中的成员GPIO_Mode，从上文可知GPIO_Mode_Out_PP的值为0x10。

5是一个函数调用，即调用GPIO_Init函数，并提供给该函数2个参数，分别为GPIOA和&GPIO_InitStructure，其中&GPIO_InitStructure表示结构体变量GPIO_InitStructure的地址，而GPIOA则在“stm32f10x_map.h”文件中找到定义：

1. #ifdef _GPIOA
   6 E  V9 Y3 w, i: ]9 M8 a
2. #define GPIOA ((GPIO_TypeDef *) GPIOA_BASE)
   
3. #endif
   

复制代码

* U2 f/ A: ~' E- o# v. F

6 W7 m( ~% r6 W: j" _; P& q

此三行代码是一个预编译结构，首先判断是否定义了宏_GPIOA。可以在“stm32f10x_conf.h”中发现对_GPIOA的定义为：

1. <font size="2">#define _GPIOA</font>

复制代码

这表示编译器会将代码中出现的GPIOA全部替换为((GPIO_TypeDef *) GPIOA_BASE)。从该句的C语言语法可以判断出((GPIO_TypeDef *) GPIOA_BASE)的功能为将GPIOA_BASE强制类型转换为指向GPIO_TypeDef类型的结构体变量。如此则需要找出GPIOA_BASE的含义，依次在“stm32f10x_map.h”文件中找到：

1. #define GPIOA_BASE (APB2PERIPH_BASE + 0x0800)

复制代码

和：

1. #define APB2PERIPH_BASE (PERIPH_BASE + 0x10000)

复制代码

还有：

1. #define PERIPH_BASE ((u32)0x40000000)

复制代码

明显GPIOA_BASE表示一个地址，通过将以上3个宏展开可以得到：

GPIOA_BASE = 0x40000000 + 0x10000 + 0x0800

此处的关键便在于0x40000000、0x10000和0x0800这三个数值的来历。

读者应该通过宏名猜到了，这就是STM32微控制器的GPIOA的设备地址。通过查阅STM32微控制器开发手册可以得知，STM32的外设起始基地址为0x40000000，而APB2总线设备起始地址相对于外设基地址的偏移量为0x10000，GPIOA设备相对于APB2总线设备起始地址偏移量为0x0800。

对○5句代码进行一个总结：调用GPIO_Init函数，并将STM32微控制器的GPIOA设备地址和所定义的结构体变量GPIO_InitStructure的地址传入。

以上是对GPIOA初始化库函数的剖析，现继续转移到函数内部分析，GPIO_Init函数原型如程序段二：

1. void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct)
   
2. {
   
3. u32 currentmode = 0x00, currentpin = 0x00, pinpos = 0x00, pos = 0x00;
   " b. ]8 T* Q. t. Q3 `# c7 A. D
4. u32 tmpreg = 0x00, pinmask = 0x00;
   ) T5 d: I7 X' V; V9 E, F6 [+ q
5. 
   , [. H: d$ r- X/ p. s2 j5 S- r5 ?
6. assert_param(IS_GPIO_ALL_PERIPH(GPIOx));
   
7. assert_param(IS_GPIO_MODE(GPIO_InitStruct->GPIO_Mode));
   
8. assert_param(IS_GPIO_PIN(GPIO_InitStruct->GPIO_Pin));
   8 a+ T; z' ?1 D# i0 O
9. 
   8 J  X; c+ {8 h6 t1 z7 d' h
10. currentmode = ((u32)GPIO_InitStruct->GPIO_Mode) & ((u32)0x0F);
    ! i3 [6 w% n; T/ e% U
11. 
    
12. if ((((u32)GPIO_InitStruct->GPIO_Mode) & ((u32)0x10)) != 0x00)
    1 q9 h, H1 z4 ?5 z  B
13. {
    4 T: E; q5 d8 Z# w
14. assert_param(IS_GPIO_SPEED(GPIO_InitStruct->GPIO_Speed));
    ) f* N6 V0 m9 g1 {2 }
15. currentmode |= (u32)GPIO_InitStruct->GPIO_Speed;
    
16. }
    $ B! b3 w, E3 B3 @
17. 
    2 B+ i) \6 d5 [  D4 o7 f
18. if (((u32)GPIO_InitStruct->GPIO_Pin & ((u32)0x00FF)) != 0x00)
    ( l. ^+ k4 V2 X1 F6 R
19. {
    
20. 
    ! F; r/ B3 ^3 K& e
21. tmpreg = GPIOx->CRL;
    # Q' [/ L/ i" F6 v5 P, f
22. for (pinpos = 0x00; pinpos < 0x08; pinpos++)
    
23. {
    
24. 
    
25. pos = ((u32)0x01) << pinpos;
    
26. currentpin = (GPIO_InitStruct->GPIO_Pin) & pos;
    
27. if (currentpin == pos)
    " q6 z" n* _# C. y. R* r
28. {
    ! A+ @* a. o& b5 E( I! X1 w" y
29. 
    , T' j% Q8 k) N0 i% d
30. pos = pinpos << 2;
    $ I6 Z  N$ B6 `+ M
31. pinmask = ((u32)0x0F) << pos;
    
32. 
    & U1 ~+ m- k8 w% l
33. tmpreg &= ~pinmask;
    
34. 
    , v4 V# ]# }6 H8 a% M3 x9 \
35. tmpreg |= (currentmode << pos);
    % J+ }+ W0 L9 m: l4 N7 K- x) Z
36. 
    ; X# }+ ?, n( J- d) K
37. if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPD)
    % m4 u: n6 |5 ?2 f3 y9 {' \$ ~$ z
38. {
    
39. GPIOx->BRR = (((u32)0x01) << pinpos);
    
40. }
    * g7 T7 F" ?- S0 K3 q) U6 I& l
41. else
    
42. {
    * B: `  U( L0 c6 b# B& S8 d! O
43. if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPU)
    
44. {
    % ~0 ?& }9 V, w# s/ a# S2 K$ d0 X
45. GPIOx->BSRR = (((u32)0x01) << pinpos);
    
46. }
      z/ d- V: {$ m
47. }
    5 M" o0 n' y- `3 f# f2 W7 q# |
48. }
    
49. }
    
50. 
    
51. GPIOx->CRL = tmpreg;
    4 {$ P* Q3 z( n
52. }
    
53. 
    6 u. k) t4 d4 D- j0 d, H9 N- K. v
54. if (GPIO_InitStruct->GPIO_Pin > 0x00FF)
    
55. {
    
56. tmpreg = GPIOx->CRH;
    
57. for (pinpos = 0x00; pinpos < 0x08; pinpos++)
    " ~7 x! W8 ^* \3 U1 }
58. {
    2 q3 P; H  Y3 N, e
59. pos = (((u32)0x01) << (pinpos + 0x08));
    
60. currentpin = ((GPIO_InitStruct->GPIO_Pin) & pos);
    7 `* T) U- [0 W9 @* }3 l
61. if (currentpin == pos)
    
62. {
    
63. pos = pinpos << 2;
    
64. pinmask = ((u32)0x0F) << pos;
    
65. tmpreg &= ~pinmask;
    $ P) U8 o' ~0 k6 ^3 s8 I
66. tmpreg |= (currentmode << pos);
    
67. if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPD)
    0 W$ I2 I3 e$ Z4 }# n
68. {
    
69. GPIOx->BRR = (((u32)0x01) << (pinpos + 0x08));
    ; \- L9 u7 l! c7 V* @# n- b
70. }
    ) b/ i+ `; y* l
71. if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPU)
    
72. {
    
73. GPIOx->BSRR = (((u32)0x01) << (pinpos + 0x08));
    
74. }
    # A5 ^3 Y7 _& g* T5 H) J3 i
75. }
    . k2 U+ z- O- @9 o5 l
76. }
    
77. GPIOx->CRH = tmpreg;
    / d, \" _! z) `3 h0 ?/ |" \
78. }
    
79. }
    

复制代码

+ r9 V( v/ ~5 i# H3 O

* p( b8 P8 D9 q& e3 R& r

这段程序的流程是：首先检查由结构体变量GPIO_InitStructure所传入的参数是否正确，然后对GPIO寄存器进行“保存——修改——写入”的操作，完成对GPIO设备的设置工作。显然，结构体变量GPIO_InitStructure所传入参数的目的是设置对应GPIO设备的寄存器。而STM32的参考手册对关于GPIO设备的设置寄存器的描述如下图1和表1（仅列出低八位引脚寄存器描述，高八位引脚类同）：

  c4 N' p3 u5 }: c( O5 v, K

该寄存器为32位，其中分为8份，每份4位，对应低八位引脚的设置。每一个引脚的设置字分为两部分，分别为CNF和MODE，各占两位空间。当MODE的设置字为0时，表示将对应引脚配置为输入模式，反之设置为输出模式，并有最大翻转速率限制。而当引脚配置为输出模式时，CNF配置字则决定引脚以哪种输出方式工作（通用推挽输出、通用开漏输出等）。

7 L& E# d7 [: o

通过对程序的阅读和分析不难发现，本文最初程序段中GPIO_InitStructure所传入参数的对寄存器的作用如下：

1、GPIO_Pin_4被宏替换为0x0010，对应图1可看出为用于选择配置GPIOx_CRL的[19:16]位，分别为CNF4[1:0]、MODE4[1:0]。

2、GPIO_Speed_50MHz为枚举类型，包含值0x03，被用于将GPIOx_CRL位中的MODE4[1:0]配置为b11（此处b意指二进制）。

3、GPIO_Mode亦为枚举类型，包含值0x10，被用于将GPIOx_CRL位中的MODE4[1:0]配置为b00。事实上GPIO_Mode的值直接影响寄存器的只有低四位，而高四位的作用可以从程序段二中看出，是用于判断此参数是否用于GPIO引脚输出模式的配置。

至此应不难知道STM32的固件库最后是怎样影响最底层的寄存器的。总结起来就是：固件库首先将各个设备所有寄存器的配置字进行预先定义，然后封装在结构或枚举变量中，待用户调用对应的固件库函数时，会根据用户传入的参数从这些封装好的结构或枚举变量中取出对应的配置字，最后写入寄存器中，完成对底层寄存器的配置。

( @( @9 ]* p; t! Q: N2 ]

可以看到，STM32的固件库函数对于程序开发人员来说是十分便利的存在，只需要填写言简意赅的参数就可以在完全不关心底层寄存器的前提下完成相关寄存器的配置，具有相当不错的通用性和易用性，也采取了一定措施保证库函数的安全性（主要引入了参数检查函数assert_param）。但同时也应该知道，通用性、易用性和安全性的代价是加大了代码量，同时增加了一些逻辑判断代码造成了一定的时间消耗，在对时间要求比较苛刻的应用场合需要评估使用固件库函数对程序运行时间所带来的影响。读者在使用STM32的固件库函数进行程序开发时，应该意识到这些问题。

文章出处： 正解岛

8 z' D- Z& l! P: x$ B8 w# ~