本文分析STM32单片机到底是如何软硬件结合的，分析单片机程序如何编译，运行。
- r& E4 f% m7 U  k+ E* `
软硬件结合
初学者，通常有一个困惑，就是为什么软件能控制硬件？就像当年的51，为什么只要写P1=0X55，就可以在IO口输出高低电平？要理清这个问题，先要认识一个概念：地址空间。
% Z" N" {, |) X( v5 u! w, d7 }. y
# L+ T2 ~/ P$ C) b4 p  H9 _寻址空间
1 W3 E' {: P, W- ?6 o  @% _什么是地址空间呢？所谓的地址空间，就是PC指针的寻址范围，因此也叫寻址空间。
# Y  v. K2 b/ b+ `) X5 i" F
大家应该都知道，我们的电脑有32位系统和64位系统之分，为什么呢？因为32位系统，PC指针就是一个32位的二进制数，也就是0xffffffff，范围只有4G寻址空间。现在内存越来越大，4G根本不够，所以需要扩展，为了能访问超出4G范围的内存，就有了64位系统。STM32是多少位的？是32位的，因此PC指针也是32位，寻址空间也就是4G。
  e! V. y0 e" x" V1 Y: F
我们来看看STM32的寻址空间是怎么样的。在数据手册《STM32F407_数据手册.pdf》中有一个图，这个图，就是STM32的寻址空间分配。所有的芯片，都会有这个图，名字基本上都是叫Memory map，用一个新芯片，就先看这个图。
8 L. _: Y7 _) k/ q  g
. R  |# n' b. n6 r

  q5 M$ V5 P1 @! g) M# ^9 o6 a

) N, ?; W' n$ D' G" D
$ A0 r+ z" ^; M8 b# Z最左边，8个block，每个block 512M，总共就是4G，也就是芯片的寻址空间。
) E- A8 Y5 s# v( C$ o* N
. m3 k: n: S6 X5 E& Dblock 0 里面有一段叫做FLASH，也就是内部FLASH，我们的程序就是下载到这个地方，起始地址是0X800 0000，大家注意，这个只有1M空间。现在STM32已经有2M flash的芯片了，超出1M的FLASH放在哪里呢？请自行查看对应的芯片手册。
  v8 s/ P# ?: p3 c3 X7 Z
3 在block 1 内，有两段SRAM，总共128K，这个空间，也就是我们前面说的内存，存放程序使用的变量。如果需要，也可以把程序放到SRAM中运行。407不是有196K吗？

; M" m  m+ a0 G+ I8 A. u其实407有196K内存，但是有64k并不是普通的SRAM，而是放在block 0 内的CCM。这两段区域不连续，而且，CCM只能内核使用，外设不能使用，例如DMA就不能用CCM内存，否则就死机。

block 2，是Peripherals，也就是外设空间。我们看右边，主要就是APB1/APB2、AHB1/AHB2，什么东西呢？回头再说。

- M* D" i# v1 g. D; G: p4 Cblock 3、block4、block5，是FSMC的空间，FSMC可以外扩SRAM，NAND FALSH，LCD等外设。
( p) S, _- Y$ N- @( b
! P0 b& k" E1 ?好的，我们分析了寻址空间，我们回过头看看，软件是如何控制硬件的。对于这个疑惑，也可以看此文：代码是如何控制硬件的？在IO口输出的例程中，我们配置IO口是调用库函数，我们看看库函数是怎么做的。
- v+ W' _2 k8 R' l2 ~
例如：

1. GPIO_SetBits(GPIOG, GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2| GPIO_Pin_3);

复制代码

这个函数其实就是对一个变量赋值，对GPIOx这个结构体的成员BSRRL赋值。

1. void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
   0 ^/ S0 b+ |* M0 X& B: P7 j; P
2. {
   # F$ F  F& M; e5 Y' M( t7 n# N
3. /* Check the parameters */
   + R" w8 v( K) d# K, n% Q
4. assert_param(IS_GPIO_ALL_PERIPH(GPIOx));
   
5. assert_param(IS_GPIO_PIN(GPIO_Pin));
   
6. 
   
7. 
   
8. GPIOx->BSRRL = GPIO_Pin;
   
9. }

复制代码

assert_param:这个是断言，用于判断输入参数是否符合要求GPIOx是一个输入参数，是一个GPIO_TypeDef结构体指针，所以，要用->获取其成员

  e7 t' N! S! z4 b& \( LGPIOx是我们传入的参数GPIOG，具体是啥？在stm32f4xx.h中有定义。

1. #define GPIOG               ((GPIO_TypeDef *) GPIOG_BASE)

复制代码

GPIOG_BASE同样在文件中有定义，如下：

1. /*!< Peripheral memory map */
   
2. #define APB1PERIPH_BASE       PERIPH_BASE
   - O7 L1 \  C4 e8 L9 K+ s
3. #define APB2PERIPH_BASE       (PERIPH_BASE + 0x00010000)
   
4. #define AHB1PERIPH_BASE       (PERIPH_BASE + 0x00020000)
   ! i- M6 p6 l3 v* U
5. #define AHB2PERIPH_BASE       (PERIPH_BASE + 0x10000000)

复制代码

再找找PERIPH_BASE的定义
* s. V7 L/ Q3 O) P- r: \" b5 j

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

复制代码

到这里，我们可以看出，操作IO口G，其实就是操作0X40000000+0X1800这个地址上的一个结构体里面的成员。说白了，就是操作了这个地方的寄存器。实质跟我们操作普通变量一样，就像下面的两句代码，区别就是变量i是SRAM空间地址，0X40000000+0X1800是外设空间地址。
! D5 h+ k- a: I* U) \

1. u32 i;
   % q' r5 M/ u, e* D
2. i = 0x55aa55aa;

复制代码

( e1 Y) `/ B8 L: I- t% \这个外设空间地址的寄存器是IO口硬件的一部分。关于如下图STM32的GPIO文章推荐：STM32中GPIO工作原理详解。如下图，左边的输出数据寄存器，就是我们操作的寄存器（内存、变量），它的地址就是0X40000000+0X1800+0x14.
& r$ `$ N% u% U" }% k* G2 D

控制其他外设也类似，就是将数据写到外设寄存器上，跟操作内存一样，就可控制外设了。

. _0 I* b/ Y" x+ E+ Q寄存器，其实应该是内存的统称，外设寄存器应该叫做特殊寄存器。慢慢的，所有人都把外设的叫做寄存器，其他的统称内存或RAM。寄存器为什么能控制硬件外设呢？因为，初略的说，一个寄存器的一个BIT，就是一个开关，开就是1，关就是0。通过这个电子开关去控制电路，从而控制外设硬件。
/ g) y' Q: w* h5 v2 j# o
纯软件-包罗万象的小程序
$ @: ?8 t) Y% j我们已经完成了串口和IO口的控制，但是我们仅仅知道了怎么用，对其他一无所知。程序怎么跑的？关于程序是怎么在单片机运行的，也可以看此视频：动画演示单片机是如何跑程序的。代码到底放在那里？内存又是怎么保存的？下面，我们通过一个简单的程序，学习嵌入式软件的基本要素。

分析启动代码
函数从哪里开始运行？
4 {& g  ]0 k# K5 ^1 H每个芯片都有复位功能，复位后，芯片的PC指针（一个寄存器，指示程序运行位置，对于多级流水线的芯片，PC可能跟真正执行的指令位置不一致，这里暂且认为一致）会复位到固定值，一般是0x00000000，在STM32中，复位到0X08000004。因此复位后运行的第一条代码就是0X08000004。前面我们不是拷贝了一个启动代码文件到工程吗？startup_stm32f40_41xxx.s，这个汇编文件为什么叫启动代码？因为里面的汇编程序，就是复位之后执行的程序。在文件中，有一段数据表，称为中断向量，里面保存了各个中断的执行地址。复位，也是一个中断。
, o/ g1 O$ [" J- Y, H0 m0 n
8 T0 G- m) q- M, J5 r+ \芯片复位时，芯片从中断表中将Reset_Handler这个值（函数指针）加载到PC指针，芯片就会执行Reset_Handler函数了。（一个函数入口就是一个指针）

1. ; Vector Table Mapped to Address 0 at Reset
   
2.                 AREA    RESET, DATA, READONLY
   7 r# I: |- t& j1 U( O
3.                 EXPORT  __Vectors
   
4.                 EXPORT  __Vectors_End
   : H' G1 ?+ P' o
5.                 EXPORT  __Vectors_Size
   
6. 
   : J6 u, x) \4 ?- d
7. __Vectors       DCD     __initial_sp               ; Top of Stack
   
8.                 DCD     Reset_Handler              ; Reset Handler
   
9.                 DCD     NMI_Handler                ; NMI Handler
   " F7 m# z; d; M7 v5 D  Z# r, A
10.                 DCD     HardFault_Handler          ; Hard Fault Handler
    
11.                 DCD     MemManage_Handler          ; MPU Fault Handler
    
12.                 DCD     BusFault_Handler           ; Bus Fault Handler
    $ {: S7 S) G1 G, m, I
13.                 DCD     UsageFault_Handler         ; Usage Fault Handler

复制代码

Reset_Handler函数，先执行SystemInit函数，这个函数在标准库内，主要是初始芯片时钟。然后跳到__main执行，__main函数是什么函数？
* _  u& @) c: K+ Y8 Z
- V& L  P+ \7 q/ l* _是我们在main.c中定义的main函数吗？后面我们再说这个问题。
. I; q2 W! i, N$ l2 d6 H# F& Q

1 B) q1 E$ t7 _* R/ K- J
: m/ I/ X, n( q芯片是怎么知道开始就执行启动代码的呢？或者说，我们如何把这个启动代码放到复位的位置？这就牵涉到一个一般情况下不关注的文件wujique.sct，这个文件在wujique\prj\Objects目录下，通常把这个文件叫做分散加载文件，编译工具在链接时，根据这个文件放置各个代码段和变量。

5 |" z& W/ ?& G* I; n" _7 q: N% d7 B在MDK软件Options菜单Linker下有关于这个菜单的设置。

) W" X9 W+ t3 }; ?/ D

2 I6 L: w/ w7 V/ {" m' O; z

把Use Memory Layout from Target Dialog前面的勾去掉，之前不可设置的框都可以设置了。点击Edit进行编辑。

6 _6 ?# w+ W3 M3 O$ {$ N( Z

在代码编辑框出现了分散加载文件内容，当前文件只有基本的内容。
1 ?# v' C/ K3 r6 j! x4 S6 p2 M
其实这个文件功能很强大，通过修改这个文件可以配置程序的很多功能，例如：1 指定FLASH跟RAM的大小于起始位置，当我们把程序分成BOOT、CORE、APP，甚至进行驱动分离的时候，就可以用上了。2 指定函数与变量的位置，例如把函数加载到RAM中运行。
! ~! ~- W$ ?5 ]# ~: k3 u/ Z
* p) U. T, k4 |- T6 U

从这个基本的分散加载文件我们可以看出：
, g1 I8 I% J7 m3 R
第6行 ER_IROM1 0x08000000 0x00080000定义了ER_IROM1，也就是我们说的内部FLASH，从0x08000000开始，大小0x00080000。

第7行.o (RESET, +First)从0x08000000开始，先放置一个.o文件， 并且用(RESET, +First)指定RESET块优先放置，RESET块是什么？请查看启动代码，中断向量就是一个AREA，名字叫RESET，属于READONLY。这样编译后，RESET块将放在0x08000000位置，也就是说，中断向量就放在这个地方。DCD是分配空间，4字节，第一个就是__initial_sp，第二个就是Reset_Handler函数指针。也就是说，最后编译后的程序，将Reset_Handler这个函数的指针（地址），放在0x800000+4的地方。所以芯片在复位的时候，就能找到复位函数Reset_Handler。

: X* f* g" @+ _; g第8行 *(InRoot$$Sections)什么鬼？GOOGLE啊！回头再说。

5 G. i0 h( |: q3 i" e' ^2 K* G第9行 .ANY (+RO)意思就是其他的所有RO，顺序往后放。就是说，其他代码，跟着启动代码后面。
+ s7 S" ~+ r4 Y  x0 o
" ^, V* o, z5 z$ C+ J' s* E( u2 |3 M8 h第11行 RW_IRAM1 0x20000000 0x00020000定义了RAM大小。
" b& s, l# T; q9 y% M* {
" n6 |  T# I! g8 P/ J# w第12行 .ANY (+RW +ZI)所有的RW ZI，全部放到RAM里面。RW,ZI，也就是变量，这一行指定了变量保存到什么地址。
5 D  Y4 D* P2 r4 y; B
分析用户代码
% K4 {+ a' ?1 j0 j到此，基本启动过程已经分析完。下一步开始分析用户代码，就从main函数开始。

1 程序跳转到main函数后:RCC_GetClocksFreq获取RCC时钟频率；SysTick_Config配置SysTick，在这里打开了SysTick中断，10毫秒一次。Delay(5);延时50毫秒。

1. int main(void)
   
2. {
   
3.   GPIO_InitTypeDef GPIO_InitStructure;
   ; |" T) m# ?  h6 S) z6 i+ S
4. 
   
5. /*!< At this stage the microcontroller clock setting is already configured,
   " \. z! z& `8 n' p! x# E3 \5 l
6.        this is done through SystemInit() function which is called from startup
   9 o, x; |; s1 R' Y. R; d; e, B
7.        files before to branch to application main.
   
8.        To reconfigure the default setting of SystemInit() function,
   ( W" t+ u$ d' ?; o9 g4 G" R
9.        refer to system_stm32f4xx.c file */
   
10. 
    
11.   /* SysTick end of count event each 10ms */
    5 i0 H$ b7 g8 ~  @7 ?8 n
12.   RCC_GetClocksFreq(&RCC_Clocks);
    
13.   SysTick_Config(RCC_Clocks.HCLK_Frequency / 100);
    ) O6 C, a! `4 U; o: z& N4 N
14. 
    7 e/ k9 A4 R: ^2 j+ K
15.   /* Add your application code here */
    / m4 h4 n) [! L
16.   /* Insert 50 ms delay */
    8 B' D: E/ L7 i) L- b
17.   Delay(5);

复制代码

2 初始化IO就不说了，进入while(1)，也就是一个死循环，嵌入式程序，都是一个死循环，否则就跑飞了。

1. /*初始化LED IO口*/
   : N6 x* D0 o$ ?: c& {' G( ]
2. RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE);
   7 o: J5 c# ^  x, H& v5 q. V. ]
3. 
   ; g: _8 }: j  q
4. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2| GPIO_Pin_3;
   , P5 `- n- i& d3 o
5. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
   
6. 
   
7. GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
   5 f5 m% [7 F6 f6 _  h
8. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
   ( q, z, S$ @4 z- L/ x
9. GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
   
10. GPIO_Init(GPIOG, &GPIO_InitStructure);   
    5 x( Q. m8 K4 R3 X* i0 a. Y6 N
11. 
    . Q& w4 l( y  Z; P
12. /* Infinite loop */
    
13. mcu_uart_open(3);
    + R0 {  [- D3 j, }: k/ d
14. while (1)
    2 D1 m5 @6 a3 B: z- k  a. n
15. {
    
16.   GPIO_ResetBits(GPIOG, GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);
    
17.   Delay(100);
    
18.   GPIO_SetBits(GPIOG, GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);
    3 l: |0 S1 G! F( p: R
19.   Delay(100);
    
20.   mcu_uart_test();
    0 t3 h. G3 O* M' r$ G* n7 D
21. 
    # M) N  ~# B- ^$ Z4 p
22.   TestFun(TestTmp2);
    
23. }

复制代码

3 在while(1)中调用TestFun函数，这个函数使用两个全局变量，两个局部变量。

1. /* Private functions ---------------------------------------------------------*/
   
2. u32 TestTmp1 = 5;//全局变量，初始化为5
   5 \! E% d* P# X; u9 A
3. u32 TestTmp2;//全局变量，未初始化
   ) P2 z" l; P  {& @/ c( V1 `
4. 
   
5. const u32 TestTmp3[10] = {6,7,8,9,10,11,12,13,12,13};
   0 Y4 t- _4 I$ J' o6 c, x1 `9 i) ]
6. 
     f1 e5 }' Z1 P. A- y
7. u8 TestFun(u32 x)//函数，带一个参数，并返回一个u8值
   , N2 x- ?2 U" `4 i# f
8. {
   ( I  N6 Y7 K2 K( m
9. u8 test_tmp1 = 4;//局部变量，初始化
   : R" q& p# |0 d1 b: Q& w5 c) R: w* \
10. u8 test_tmp2;//局部变量，未初始化
      A0 A6 [" ]3 F; f; g
11. 
    
12. static u8 test_tmp3 = 0;//静态局部变量
    
13. 
    ( F- ?5 \1 `1 K) q: E
14. test_tmp3++;
    
15. 
    * i3 C5 K3 o+ z5 l( G4 _7 Q" y) R
16. test_tmp2 = x;
    
17. 
    . R% B1 p1 d$ z: N* u
18. if(test_tmp2> TestTmp1)
    ! ]# D# m4 A5 i, @' o; W
19.   test_tmp1 = 10;
    ) t3 x) O1 @  U2 g
20. else
    2 [5 e1 k. U8 T5 p: H0 Z
21.   test_tmp1 = 5;
    ; X8 Q: U3 M+ y/ e1 c
22. 
    9 q# x# |# v6 T
23. TestTmp2 +=TestTmp3[test_tmp1];
    
24. 
    " k- e3 d: g/ ^1 K# A
25. return test_tmp1;
    
26. }

复制代码

然后程序就一直在main函数的while循环里面执行。中断呢？对，还有中断。中断中断，就是中断正常的程序执行流程。相关文章：STM32中断系统。我们查看Delay函数，uwTimingDelay不等于0就死等？谁会将uwTimingDelay改为0？

1. /**
   
2.   * @brief  Inserts a delay time.
   ( E3 ~3 C2 @' \# H
3.   * @param  nTime: specifies the delay time length, in milliseconds.
   ) {5 E5 d6 r8 O4 q1 D% S
4.   * @retval None
   
5.   */
   # C" n( W0 K  u
6. void Delay(__IO uint32_t nTime)
   5 j1 y+ k. P, m4 C5 [6 u$ p
7. {
   8 W/ |! {$ O7 C3 I' y
8.   uwTimingDelay = nTime;
   3 c: \" W0 R3 ^: F
9. 
   " n9 \+ H+ \# w' G; m% D% l9 ]6 [% N
10.   while(uwTimingDelay != 0);
    
11. }

复制代码

搜索uwTimingDelay变量，函数TimingDelay_Decrement会将变量一直减到0。

1. /**
   - o) x" G0 ?& [- j9 J# X
2.   * @brief  Decrements the TimingDelay variable.
   5 p- _& z% z# M. S- n; V
3.   * @param  None
     l& d6 z* {  r5 l0 ^1 v
4.   * @retval None
   
5.   */
   # s2 [  |2 q) s) Y* ?
6. void TimingDelay_Decrement(void)
   
7. {
   % j  ?! t9 s  h; _; E! u
8.   if (uwTimingDelay != 0x00)
   ! I0 k& X: W0 f
9.   {
   , A/ i1 C  B. y1 b
10.     uwTimingDelay--;
    : T( ]  |' n* W
11.   }
    2 a2 q' o7 W" f' K9 M
12. }

复制代码

这个函数在哪里执行？经查找，在SysTick_Handler函数中运行。谁用这个函数？

1. /**
   ; t, y3 m* Q! N: _3 r  X. i& U* ~( H9 k
2.   * @brief  This function handles SysTick Handler.
   " H! [2 R0 q* c5 y7 A6 H! Y
3.   * @param  None
   % j9 D+ r3 @8 Y) ?3 g
4.   * @retval None
   ) _- t! ~) F/ `, h) {
5.   */
   3 A/ W& ?$ D: s8 Z7 s7 \. ]
6. void SysTick_Handler(void)
   
7. {
   
8.   TimingDelay_Decrement();
   7 }+ K, ~  j0 N. M
9. }

复制代码

& A$ b6 Y3 `' {5 w经查找，在中断向量表中有这个函数，也即是说这个函数指针保存在中断向量表内。当发生中断时，就会执行这个函数。当然，在进出中断会有保存和恢复现场的操作。这个主要涉及到汇编，暂时不进行分析了。有兴趣自己研究研究。通常，现在我们开发程序不用关心上下文切换了。

1. __Vectors       DCD     __initial_sp               ; Top of Stack
   7 ]! ^0 y# c. h5 N; F+ c$ Z" i( {
2.                 DCD     Reset_Handler              ; Reset Handler
   
3.                 DCD     NMI_Handler                ; NMI Handler
   9 b# d7 r& e  \8 d* o& _! W
4.                 DCD     HardFault_Handler          ; Hard Fault Handler
   
5.                 DCD     MemManage_Handler          ; MPU Fault Handler
   
6.                 DCD     BusFault_Handler           ; Bus Fault Handler
   
7.                 DCD     UsageFault_Handler         ; Usage Fault Handler
   ' |7 R; \/ r" a: w. I2 H
8.                 DCD     0                          ; Reserved
   
9.                 DCD     0                          ; Reserved
   
10.                 DCD     0                          ; Reserved
    
11.                 DCD     0                          ; Reserved
    
12.                 DCD     SVC_Handler                ; SVCall Handler
    ' H% y8 p9 S, I# B* g- h! q
13.                 DCD     DebugMon_Handler           ; Debug Monitor Handler
    " S7 j' k4 P, J
14.                 DCD     0                          ; Reserved
    
15.                 DCD     PendSV_Handler             ; PendSV Handler
    
16.                 DCD     SysTick_Handler            ; SysTick Handler

复制代码

余下问题
1 __main函数是什么函数？是我们在main.c中定义的main函数吗？2 分散加载文件中*(InRoot$$Sections)是什么？3 ZI段，也就是初始化为0的数据段，什么时候初始化？谁初始化？
& f% O* Y4 Z# G3 A* f+ o# s
为什么这几个问题前面留着不说？因为这是同一个问题。顺藤摸瓜！
2 f8 K+ c% D6 Q, ?2 I- l3 w
# ]& ~, U% N7 X
9 J* k  a. @  G. n: x通过MAP文件了解代码构成
编译结果
) t. N/ a2 w2 j: _程序编译后，在下方的Build Output窗口会输出信息：

1. *** Using Compiler 'V5.06 update 5 (build 528)', folder: 'C:\Keil_v5\ARM\ARMCC\Bin'
   
2. Build target 'wujique'
   . C8 j# n" s4 a/ k
3. compiling stm32f4xx_it.c...
   
4. ...
   2 G8 n! l: @- H# V3 m
5. assembling startup_stm32f40_41xxx.s...
   7 I1 C! r4 X2 [& I
6. compiling misc.c...
   ' I- f( E# g' K
7. ...
   
8. compiling mcu_uart.c...
   
9. linking...
   9 I% f3 ~; [1 P, H% E9 n
10. Program Size: Code=9038 RO-data=990 RW-data=40 ZI-data=6000  
    
11. FromELF: creating hex file...
    
12. ".\Objects\wujique.axf" - 0 Error(s), 0 Warning(s).
    
13. Build Time Elapsed:  00:00:32

复制代码

编译目标是wujique
C文件compiling，汇编文件assembling，这个过程叫编译
编译结束后，就进行link，链接。
; T1 o% a; ~3 ~) C$ K7 a' b最后得到一个编译结果，9038字节code，RO 990，RW 40，ZI 6000。CODE，是代码，很好理解，那RO、RW、ZI都是什么？
FromELF，创建hex文件，FromELF是一个好工具，需要自己添加到option中才能用
+ T5 o. F6 T( J- m- }( f
map文件配置
更多编译具体信息在map文件中，在MDK Options中我们可以看到，所有信息都放在\Listings\wujique.map
: U! a4 V3 _1 u9 N* P# K
5 g" L9 P; g3 o7 @; Y默认很多编译信息可能没钩，钩上所有信息会增加编译时间。
# u& c6 k; M. R. |) R: I
/ q" e: r, K- r9 _" O2 ^
; E+ z) W7 c* l! R! z
map文件
打开map文件，好乱？习惯就好。我们抓重点就行了。
8 L8 n5 V7 ^; `, E6 ]
9 k7 q( x8 U6 z. z( f. d8 y! \
4 K6 v3 S/ @9 |( w
( m1 i1 M# V5 B% ~9 [: s, n! Mmap 总信息

从最后看起，看到没？最后的这一段map内容，说明了整个程序的基本概况。

有多少RO？RO到底是什么？

有多少RW?RW又是什么？

ROM为什么不包括ZI Data？为什么包含RW Data？
( A% ^2 _6 t' j3 g# ^1 Q) s/ Q3 M

Image component sizes

# d* z1 M# I# z1 _往上，看看Image component sizes，这个就比刚刚的总体统计更细了。

这部分内容，说明了每个源文件的概况
" G& g3 O' ?; O0 Z+ p0 {
: O2 L" a& z7 g8 }6 b4 h$ x首先，是我们自己的源码，这个程序我们的代码不多，只有main.o，wujique_log.o，和其他一些STM32的库文件。

& Y6 L& g4 I4 D7 _, j/ @第2部分是库里面的文件，看到没？里面有一个main.o。main函数是不是我们写的main函数？明显不是，我们的main函数是放在main.o文件。这么小的一个工程，用了这么多库，你以前关注过吗？估计没有，除非你曾经将一个原本在1M flash上的程序压缩到能在512K上运行。
8 |& |5 y. r4 f% K' v/ ^6 G) T3 @

/ s/ X3 }2 u! O7 q, ]
第3部分也是库，暂时没去分析这两个是什么东西。

. L3 V& f: e+ j

1 B' C2 p8 R" |/ H% \
库文件是什么？库文件就是别人已经别写好的代码库。在代码中，我们经常会包含一些头文件，例如：
#include <stdarg.h>
#include <stdlib.h>
$ V8 z$ ~4 z- s* q#include <string.h>  
% `; R5 C# L  `) I: g5 s
9 ?; X4 a; {1 G7 p' H7 N这些就是库的头文件。这些头文件保存在MDK开发工具的安装目录下。我们经常用的库函数有：memcpy、memcmp、strcmp等。只要代码中包含了这些函数，就会链接库文件。
8 {' Y* G5 u  T: ^4 C6 u  b
; e! I7 Q8 q' V2 |: P& b3 |
文件map
再往上，就是文件MAP了，也就时每个文件中的代码段（函数）跟变量在ROM跟RAM中的位置。首先是ROM在0x08000000确实放的是startup_stm32f40_41xxx.o中的RESET
: |$ l5 V8 g6 B& U" w8 O0 J
库文件是什么？
! ]4 s0 p# `8 a库文件就是别人已经别写好的代码库。

在代码中，我们经常会包含一些头文件，例如：
' }' F6 w  O0 P& y, U

1. #include <stdarg.h>
   . k  C' j  e# S7 i+ P' X- O% i
2. #include <stdlib.h>
   
3. #include <string.h>

复制代码

. c( q: @, p" Y" ~. V* [8 b这些就是库的头文件。相关文章：C语言中的头文件。这些头文件保存在MDK开发工具的安装目录下。

# q) ~2 |% K0 k我们经常用的库函数有：memcpy、memcmp、strcmp等。
+ n8 _, g4 q3 @* a
只要代码中包含了这些函数，就会链接库文件。
0 O0 o8 ~/ q0 l, a5 X; H- p* O
文件map
再往上，就是文件MAP了，也就时每个文件中的代码段（函数）跟变量在ROM跟RAM中的位置。首先是ROM在0x08000000确实放的是startup_stm32f40_41xxx.o中的RESET
3 m! Y% \0 A4 [% k3 ^3 G
9 F- V# B3 Q: C/ d+ y

( W4 p7 _9 F7 o7 ~1 h6 m- X4 v7 ?每个文件有有多行，例如串口，4个函数。
# u+ m2 }' S* A! y
! _. Y7 [: Z" P! o, b

" p/ Q- k) H' x# n0 t0 e- h
( K6 p! a" Q3 n% E( g% n然后是RAM的，main.o中的变量，放在0x20000000，总共有0x0000000c，类型是Data、RW。串口有两种变量，data和bss，什么是bss？这两个名称，是section name，也就是段的意思。看前面type和Attr，

0 _' z" }! u+ VRW Data，放在.data段；RW Zero放在.bss段，RW Zero，其实就是ZI。到底哪些变量是RW，哪些是ZI？
1 g4 C, y4 F* m% B, ~! x+ m8 t7 b2 T5 J

Image Symbol Table
6 h7 N! U( |+ A$ n
再往上就是Image Symbol Table，就更进一步到每个函数或者变量的信息了

# `5 D2 f% J  y% h2 S0 \

5 z* n0 B+ U( h+ }6 h; y4 o5 d! D例如，全局变量TestTmp1，是Data，4字节，分配的位置是0x20000004。

7 l8 X9 P6 c( H" i

7 o4 Q9 {  \2 j+ a* G! N
1 g8 R. j) R3 j9 _+ v* F$ h# OTestTmp3数组放在哪里？放在0X080024E0这个地方，这可是代码区额。因为我们用const修饰了这个全局变量数组，告诉编译器，这个数组是不可以改变的，编译器就将这个数组保存到代码中了。程序中我们经常会使用一些大数组数据，例如字符点阵，通常有几K几十K大，不可能也没必要放到RAM区，整个程序运行过程这些数据都不改变，因此通过const修饰，将其存放到代码区。

  f; p9 f( N) J" ?: ?const的用处比较多，可以修饰变量，也可以修饰函数。更多用法自行学习
/ T( d$ j# q3 ^( Z& L

那局部变量存放在哪里呢？我们找到了test_tmp3，
$ S% S, w5 l9 h: p) x+ L6 j
8 L" l$ V: q% ]# i8 V0 X' ]

没找到test_tmp1/test_tmp2，为什么呢？在定义时，test_tmp3增加了static定义，意思就是静态局部变量，功能上，相当于全局变量，定义在函数内，限制了这个全局变量只能在这个函数内使用。哪test_tmp1、test_tmp2放在哪里呢？ 局部变量，在编译链接时，并没有分配空间，只有在运行时，才从栈分配空间。

1. <blockquote>u8 TestFun(u32 x)//函数，带一个参数，并返回一个u8值

复制代码

0 X2 ?$ x( i6 s- z# Z" Z- m* Y上一部分，我们留了一个问题，哪些变量是RW，哪些是ZI？我们看看串口变量的情况，UartBuf3放在bss段，其他变量放在.data段。为什么数组就放在bss？bss是英文Block Started by Symbol的简称。

到这里，我们可解释下面几个概念了：
) p, f. a  K: {7 ~1 A: o2 ZCode就是代码，函数。
RO Data，就是只读变量，例如用const修饰的数组。
RW Data，就是读写变量，例如全局变量跟static修饰的局部变量。
! D' a3 n3 L+ h9 P6 lZI Data，就是系统自动初始化为0的读写变量，大部分是数组，放在bss段。
RO Size等于代码加只读变量。
4 q) F' T2 L6 r$ uRW Size等于读写变量（包括自动初始化为0的），这个也就是RAM的大小。
ROM Size，也就是我们编译之后的目标文件大小，也就是FLASH的大小。但是？为什么会包含RW Data呢？因为所有全局变量都需要一个初始化的值（就算没有真正初始化，系统也会分配一个初始化空间），例如我们定义一个变量u8 i = 8;这样的全局变量，8，这个值，就需要保存在FALSH区。

4 P6 l  C3 P7 I9 q  B

我们看看函数的情况，前面我们不是有一个问题吗？__main和main是一个函数吗？查找main后发现，main是main，放在0x08000579
0 ^6 }8 y$ Y/ F5 ~8 Z8 j# f

* y% `; O/ W4 g8 P, e# I
main是main，放在0x08000189

" T* S2 @1 s# S6 K5 |9 {

1 P( F1 k' F- I8 k' S7 }$ s
! q5 Q" n2 n/ e- c4 I__main到main之间发生了什么？还记得分散加载文件中的这句吗？
( \" ]7 r( v' }2 b*(InRoot$$Sections)
8 R, ]4 o6 {" _- L9 h
__main就在这个段内。下图是__main的地址，在0x08000189。__Vectors就是中断向量，放在最开始。

在分散加载文件中，紧跟RESET的就是*(InRoot$$Sections)。
; @5 v0 G$ R- A2 B# B% R

而且，RESET段正好大小0x00000188。

; J: T# e  C, m

0 s/ v& G4 s2 F% P% g+ _( Z* g+ |
/ {  c5 a. k; J$ ?巧合？可以参考PPT文档《ARM嵌入式软件开发.ppt》。
9 r" h# P5 m5 c  m3 l: t  X1 I

5 r, K) V2 M( P5 u8 j1 `
; I2 k$ o. ^% G/ \这一段代码都完成什么功能呢？主要完成ZI代码的初始化，也就是将一部分RAM初始化为0。其他环境初始化……
, g$ c* v: r, ~

最后
到这里，一个程序，是怎么组成的，程序是如何运行的，基本有一个总体印象了。
9 o: m% a9 E4 V( w6 F
! `+ V6 f) ]) z8 `3 E0 k, u
0 m- O/ Y# ?/ k9 a6 b转载自： [color=var(--weui-LINK)][url=]STM32嵌入式开发[/url]
( b6 @3 @* z! R- n- c3 O如有侵权请联系删除
0 o7 N% r5 @# S  N6 f
  L. u4 u* \: A: J; E  e: T- l
1 V/ r) }% d6 `+ k4 z