你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

【经验分享】STM32是如何软硬件结合,编译后怎么样一步步运行起来的

[复制链接]
STMCU小助手 发布时间:2022-5-27 21:34
不知道大家有没有疑惑,为什么软件能控制硬件?本文分析STM32单片机到底是如何软硬件结合的,分析单片机程序如何编译,运行。
7 v) s, \- o+ }4 ^软硬件结合$ c+ A2 h8 d4 F9 D8 ~/ S; }
) d, O+ Z! ?2 @. t+ R1 a

7 N. [1 E" N5 X& w( u6 I0 E初学者,通常有一个困惑,就是为什么软件能控制硬件?就像当年的51,为什么只要写P1=0X55,就可以在IO口输出高低电平?要理清这个问题,先要认识一个概念:地址空间。
4 t' }- Y2 B4 w# P
+ E) d- U$ u% D% K2 G( s: H) z
2 ~7 C+ k& r. y; V' |
寻址空间
3 J: G5 v8 w1 T8 U. _# _4 r& B" U- _; d& H" Q0 u
什么是地址空间呢?所谓的地址空间,就是PC指针的寻址范围,因此也叫寻址空间。
大家应该都知道,我们的电脑有32位系统和64位系统之分,为什么呢?因为32位系统,PC指针就是一个32位的二进制数,也就是0xffffffff,范围只有4G寻址空间。现在内存越来越大,4G根本不够,所以需要扩展,为了能访问超出4G范围的内存,就有了64位系统。STM32是多少位的?是32位的,因此PC指针也是32位,寻址空间也就是4G。
我们来看看STM32的寻址空间是怎么样的。在数据手册《STM32F407_数据手册.pdf》中有一个图,这个图,就是STM32的寻址空间分配。所有的芯片,都会有这个图,名字基本上都是叫Memory map,用一个新芯片,就先看这个图。
4 p) K7 h% R7 g- g# y% [
: \2 z' o/ N  C( {# r
/ E) U+ {) L( `
640 (25).png " j# U& k& U4 K# i( ~' i! G  e
  t! p7 u, E7 a, M! c- O& t
  • 最左边,8个block,每个block 512M,总共就是4G,也就是芯片的寻址空间。
  • block 0 里面有一段叫做FLASH,也就是内部FLASH,我们的程序就是下载到这个地方,起始地址是0X800 0000,大家注意,这个只有1M空间。现在STM32已经有2M flash的芯片了,超出1M的FLASH放在哪里呢?请自行查看对应的芯片手册。
  • 3 在block 1 内,有两段SRAM,总共128K,这个空间,也就是我们前面说的内存,存放程序使用的变量。如果需要,也可以把程序放到SRAM中运行。407不是有196K吗?
  • 其实407有196K内存,但是有64k并不是普通的SRAM,而是放在block 0 内的CCM。这两段区域不连续,而且,CCM只能内核使用,外设不能使用,例如DMA就不能用CCM内存,否则就死机。
  • block 2,是Peripherals,也就是外设空间。我们看右边,主要就是APB1/APB2、AHB1/AHB2,什么东西呢?回头再说。
  • block 3、block4、block5,是FSMC的空间,FSMC可以外扩SRAM,NAND FALSH,LCD等外设。

    6 Q! F( w  ?- {. I6 s; i

    2 T- i# p5 ^/ t7 q& Q0 c- G
好的,我们分析了寻址空间,我们回过头看看,软件是如何控制硬件的。在IO口输出的例程中,我们配置IO口是调用库函数,我们看看库函数是怎么做的。2 P: O5 g  L1 ~# N

9 E6 W9 ?5 R) y4 I; H2 _/ X7 e5 i例如:( k& ?3 P& L/ i9 U& B3 ?) ~/ R
  1. GPIO_SetBits(GPIOG, GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2| GPIO_Pin_3);
复制代码
  j. b# D0 Y* E& o; f2 r
这个函数其实就是对一个变量赋值,对GPIOx这个结构体的成员BSRRL赋值。
  1. void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
    " _( g4 d& Y. C) |/ M4 |* F
  2. {. B$ `; k+ G0 C7 {
  3. /* Check the parameters */
    4 Q' Z3 V% q8 ?5 I+ v0 {
  4. assert_param(IS_GPIO_ALL_PERIPH(GPIOx));. F* L! c% ]' K( a
  5. assert_param(IS_GPIO_PIN(GPIO_Pin));0 t7 M. |- z1 I5 ]; ^- d2 \
  6. . M9 [2 c& \: ?+ E, f
  7. GPIOx->BSRRL = GPIO_Pin;
    6 A$ z  @; `2 O$ O6 ?
  8. }
复制代码
4 Y+ p! q1 l3 T" \# J. e" i
assert_param:这个是断言,用于判断输入参数是否符合要求GPIOx是一个输入参数,是一个GPIO_TypeDef结构体指针,所以,要用->获取其成员

7 F3 i. g: X/ Y9 Z1 E; \
GPIOx是我们传入的参数GPIOG,具体是啥?在stm32f4xx.h中有定义9 K) {4 B2 S, }0 e) Y
  1. #define GPIOG               ((GPIO_TypeDef *) GPIOG_BASE)
复制代码
# b$ Y" ?3 Q5 N$ K
GPIOG_BASE同样在文件中有定义,如下:
2 F# K  w4 n  I+ w+ o. J5 K
  1. #define GPIOG_BASE           (AHB1PERIPH_BASE + 0x1800)
复制代码

4 ]. O2 a/ ]% QAHB1PERIPH_BASE,AHB1地址,有点眉目了吧?在进一步看看
  1. /*!< Peripheral memory map */& _2 r( \; {5 N
  2. #define APB1PERIPH_BASE       PERIPH_BASE
    ! `8 m; |  i. a5 `" S4 p! t# f% H
  3. #define APB2PERIPH_BASE       (PERIPH_BASE + 0x00010000): r0 Z7 I' q$ V$ ?* |
  4. #define AHB1PERIPH_BASE       (PERIPH_BASE + 0x00020000)
    & l) Y6 ?7 j% K$ M. a
  5. #define AHB2PERIPH_BASE       (PERIPH_BASE + 0x10000000)
复制代码

( k5 C  ]1 r0 q# u& B9 w
  ~0 R' h  H0 ~% i
再找找PERIPH_BASE的定义
  1. #define PERIPH_BASE           ((uint32_t)0x40000000)   
复制代码

1 G: r: L/ u' K7 h: x( Q+ ]8 v7 n. h1 y, Y+ K% V  I/ c. ^

) g# |+ M0 B. A; W$ p4 w到这里,我们可以看出,操作IO口G,其实就是操作0X40000000+0X1800这个地址上的一个结构体里面的成员。说白了,就是操作了这个地方的寄存器。实质跟我们操作普通变量一样,就像下面的两句代码,区别就是变量i是SRAM空间地址,0X40000000+0X1800是外设空间地址。: M7 H0 M& h+ E5 C: d' v# q
  1. u32 i;3 f3 o5 l/ s1 W4 i. y
  2. i = 0x55aa55aa;
复制代码

0 V) S  l1 c5 S0 c* E4 |$ e/ F4 H8 g" y: t; y5 p  _

, F0 C& l7 P' m3 ?8 A这个外设空间地址的寄存器是IO口硬件的一部分。如下图,左边的输出数据寄存器,就是我们操作的寄存器(内存、变量),它的地址就是0X40000000+0X1800+0x14.
5 k, B# y# y6 h8 P7 W9 q8 L
3 J+ [% P" w) c
( K: Z1 h9 f( }- T" W9 @$ T
640 (24).png   j# p6 \) s1 B- @

# k5 F5 x8 B* z) H, M# e控制其他外设也类似,就是将数据写到外设寄存器上,跟操作内存一样,就可控制外设了。
寄存器,其实应该是内存的统称,外设寄存器应该叫做特殊寄存器。慢慢的,所有人都把外设的叫做寄存器,其他的统称内存或RAM。寄存器为什么能控制硬件外设呢?因为,初略的说,一个寄存器的一个BIT,就是一个开关,开就是1,关就是0。通过这个电子开关去控制电路,从而控制外设硬件。

6 `8 X9 X$ m  S; H1 b8 L
纯软件-包罗万象的小程序& ~# H2 v9 \/ b& w
/ d  W4 A/ T) A0 w' d

: |# {4 z6 ^. Z8 F' `) r! x: L我们已经完成了串口和IO口的控制,但是我们仅仅知道了怎么用,对其他一无所知。程序怎么跑的?代码到底放在那里?内存又是怎么保存的?下面,我们通过一个简单的程序,学习嵌入式软件的基本要素。; Q! e5 _. k  \0 L
! b% j! _: F" I4 M; G7 F
5 k4 l) g! Q& s% @& I: M# ^/ m( W
分析启动代码
  • 函数从哪里开始运行?

    ( m0 X( t$ g, d0 H" b7 Y
每个芯片都有复位功能,复位后,芯片的PC指针(一个寄存器,指示程序运行位置,对于多级流水线的芯片,PC可能跟真正执行的指令位置不一致,这里暂且认为一致)会复位到固定值,一般是0x00000000,在STM32中,复位到0X08000004。因此复位后运行的第一条代码就是0X08000004。前面我们不是拷贝了一个启动代码文件到工程吗?startup_stm32f40_41xxx.s,这个汇编文件为什么叫启动代码?因为里面的汇编程序,就是复位之后执行的程序。在文件中,有一段数据表,称为中断向量,里面保存了各个中断的执行地址。复位,也是一个中断。
( C7 m. s& T" q芯片复位时,芯片从中断表中将Reset_Handler这个值(函数指针)加载到PC指针,芯片就会执行Reset_Handler函数了。(一个函数入口就是一个指针)& ]" Q" T: ]1 q  G
  1. ; Vector Table Mapped to Address 0 at Reset
    + g3 x* _( ~. j5 Q* [5 _
  2.                 AREA    RESET, DATA, READONLY
    & o; I1 L/ Z( V8 ^+ G( N
  3.                 EXPORT  __Vectors
    ) `; I: B9 Y! I! k8 s$ x4 \
  4.                 EXPORT  __Vectors_End/ N4 g& G/ @$ ^8 M/ n) o, B& e0 }
  5.                 EXPORT  __Vectors_Size
    3 Z6 J& c& a. u! y% V) `. j# s
  6. . U: A" m6 O: X# ]: f3 h% k' R( ]' ?
  7. __Vectors       DCD     __initial_sp               ; Top of Stack
    ( }$ P1 n- E. _$ A6 q  e1 x5 ]2 [
  8.                 DCD     Reset_Handler              ; Reset Handler
    ( X& \/ H" e' _1 a! h2 J5 E, y
  9.                 DCD     NMI_Handler                ; NMI Handler( _* h% K! b7 p- D( _4 d3 w
  10.                 DCD     HardFault_Handler          ; Hard Fault Handler
    # Q5 q) c# h- L7 n# {- H
  11.                 DCD     MemManage_Handler          ; MPU Fault Handler
    4 B8 J# [* v. f6 P! J" O( \6 E5 z9 k
  12.                 DCD     BusFault_Handler           ; Bus Fault Handler( j" X2 v6 _# N# o
  13.                 DCD     UsageFault_Handler         ; Usage Fault Handler
复制代码

% q3 S) ]! a% L8 d$ k" g( u0 i) r) M( _' g
& W. ?1 b. V/ n; l1 v1 Q# r+ `
Reset_Handler函数,先执行SystemInit函数,这个函数在标准库内,主要是初始芯片时钟。然后跳到__main执行,__main函数是什么函数?
# \# g8 v# P+ I  U% K
6 J0 s" w( `4 G4 ~2 Q* B: D8 k: Y
1 X, s" P0 }' p2 r- X
是我们在main.c中定义的main函数吗?后面我们再说这个问题。
" L) z9 m7 U# I& p0 I$ i! e/ K+ [! x) T- p* T- s

* \0 f9 s3 H0 B `K9@]PZ]{27KB)L05F~Z(QV.png
, U+ p9 `: a4 j8 X* F" u
, o7 y7 F; m$ \" H9 Q( ^芯片是怎么知道开始就执行启动代码的呢?或者说,我们如何把这个启动代码放到复位的位置?这就牵涉到一个一般情况下不关注的文件wujique.sct,这个文件在wujique\prj\Objects目录下,通常把这个文件叫做分散加载文件,编译工具在链接时,根据这个文件放置各个代码段和变量。' W' t: x8 C: R; t& ]' n& N

! _( H7 p( ~5 S$ F/ C
4 w& f& g' D3 f& T+ d! p7 C
在MDK软件Options菜单Linker下有关于这个菜单的设置。
$ W( l1 M+ w1 m4 ~7 P" ?/ b- v+ v) [5 `' X) r3 e9 G

' a. B: r7 j3 Y! x, B1 i! m3 c 640 (23).png 4 F7 J! N; i- G+ c+ r
, M3 W- n. L( d
把Use Memory Layout from Target Dialog前面的勾去掉,之前不可设置的框都可以设置了。点击Edit进行编辑。- d1 a/ l9 R1 H" C3 _/ Y9 i

8 N* X- V8 ^: ^) c  q

# Y: u% p$ D; l) N$ N 640 (22).png
" a" S; W3 ?  k) c* ^1 x9 D& j! r: J8 S$ d* C3 o
在代码编辑框出现了分散加载文件内容,当前文件只有基本的内容。
其实这个文件功能很强大,通过修改这个文件可以配置程序的很多功能,例如:1 指定FLASH跟RAM的大小于起始位置,当我们把程序分成BOOT、CORE、APP,甚至进行驱动分离的时候,就可以用上了。2 指定函数与变量的位置,例如把函数加载到RAM中运行。

+ a3 ~, F5 M5 D* t. A7 d
640 (21).png
2 g# E6 @1 Y1 Q0 _0 N+ v% G! ?5 x. Y' G

4 {$ r6 f+ \( X6 @7 E. s( @从这个基本的分散加载文件我们可以看出:
  • 第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。
  • 第8行 *(InRoot$$Sections)什么鬼?GOOGLE啊!回头再说。
  • 第9行 .ANY (+RO)意思就是其他的所有RO,顺序往后放。就是说,其他代码,跟着启动代码后面。
  • 第11行 RW_IRAM1 0x20000000 0x00020000定义了RAM大小。
  • 第12行 .ANY (+RW +ZI)所有的RW ZI,全部放到RAM里面。RW,ZI,也就是变量,这一行指定了变量保存到什么地址。
      ?+ O% q! X: v7 J
    # T! n: z/ P+ ~* j1 C. l9 H
    ( }# x) p# [1 K* C5 i" z
分析用户代码
: @! m, E" i/ B8 G9 Z8 V: X  ]* B, V% l1 x! o
7 F. w5 t4 Z8 J7 s: s6 Z
到此,基本启动过程已经分析完。下一步开始分析用户代码,就从main函数开始。1 程序跳转到main函数后:RCC_GetClocksFreq获取RCC时钟频率;SysTick_Config配置SysTick,在这里打开了SysTick中断,10毫秒一次。Delay(5);延时50毫秒。6 @; G4 W; X5 i3 {
  1. int main(void)
    - b& B+ A7 x7 I" U0 b6 u
  2. {
    0 g) I: U$ k( ]" A- W
  3.   GPIO_InitTypeDef GPIO_InitStructure;
    0 r( k& j7 `7 j
  4. 8 Q: C% a4 h8 g
  5. /*!< At this stage the microcontroller clock setting is already configured,
    " D: t2 u3 d3 C/ s
  6.        this is done through SystemInit() function which is called from startup
      U8 r3 v' P5 y1 @) |  b0 I5 s/ \
  7.        files before to branch to application main.
    9 ~' Z' |* l9 z2 _9 ~; ?* H9 i& t* @3 E
  8.        To reconfigure the default setting of SystemInit() function,1 O/ Q% n! t5 p! x7 J& M
  9.        refer to system_stm32f4xx.c file */
    2 K5 H, G! y; F) d+ P
  10. ; r6 I) d5 [& P5 V: W3 D6 S- t
  11.   /* SysTick end of count event each 10ms */) f- M! ]" L, _
  12.   RCC_GetClocksFreq(&RCC_Clocks);
    5 n$ H" ]) y+ K1 s$ R$ X
  13.   SysTick_Config(RCC_Clocks.HCLK_Frequency / 100);
    + ?* j7 N2 z( v2 \% v

  14. ! l% t. B" ]; t4 t4 }, J
  15.   /* Add your application code here */4 g; Y. Z8 g, w, x
  16.   /* Insert 50 ms delay */
    4 r+ X, X7 h2 n" J3 g& ]
  17.   Delay(5);
复制代码
5 A$ f2 r# [: U9 [" X

0 Z/ Y" r8 I( i

, x3 O2 e* q7 Z: i( m+ Y2 初始化IO就不说了,进入while(1),也就是一个死循环,嵌入式程序,都是一个死循环,否则就跑飞了。
) i+ o+ N$ s* l( Q" ~
  1. /*初始化LED IO口*// ^/ D- A7 g$ V3 M% G/ k
  2. RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE);3 B+ K$ d4 L& a  m( o
  3. & b" ~1 k! J- C
  4. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2| GPIO_Pin_3;! h' p! e& c/ E1 Z6 y
  5. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;9 ~& ~1 l) t+ Q) B! A: j) A

  6. : I4 B/ n6 J' |" f9 S7 {3 X, a
  7. GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    8 f4 y4 f' }1 V( P" Y
  8. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;! S+ D; r2 b0 z4 x7 T* `& A
  9. GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    ) ]. z6 ^2 d  y! I
  10. GPIO_Init(GPIOG, &GPIO_InitStructure);    + `9 `7 N! V2 \
  11. 4 i' t9 R+ M3 R. J& L* O4 }8 [
  12. /* Infinite loop */
    ' Z& b3 F) M7 a! s- @, n
  13. mcu_uart_open(3);" e7 n. _; R, A; T  E/ x1 s. J
  14. while (1)
    2 n9 [0 Q1 e9 i# s: p
  15. {
    - ]4 H% Q" m# h6 h7 o
  16.   GPIO_ResetBits(GPIOG, GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);( R$ @5 H" a4 }+ j9 ?
  17.   Delay(100);: e: N9 j! p# P9 x; a
  18.   GPIO_SetBits(GPIOG, GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);: i0 A3 @( n1 w( u
  19.   Delay(100);
    / ]- E; Y% I. z( E
  20.   mcu_uart_test();
    ' u3 B& t0 B  k
  21. : q1 ]; V5 H6 N+ |6 }  B; X
  22.   TestFun(TestTmp2);
    ) |- z+ e# a6 q* P
  23. }
复制代码
* K9 E3 i  b! z" }3 F
5 Q% f# f( g1 `/ B# p# O

2 D+ q( U2 x" {! I+ [5 N3 在while(1)中调用TestFun函数,这个函数使用两个全局变量,两个局部变量。
0 K* A0 u0 j) t2 B: l
  1. /* Private functions ---------------------------------------------------------*/' ?3 N& b" {  e2 n. `0 f: Q
  2. u32 TestTmp1 = 5;//全局变量,初始化为5
    - N3 s3 c8 x% t- l( {
  3. u32 TestTmp2;//全局变量,未初始化
    & _: Y3 w* W: d# o& R

  4. 6 S8 S# X5 X6 i+ \% a
  5. const u32 TestTmp3[10] = {6,7,8,9,10,11,12,13,12,13};1 _/ Q, L+ l( d" r
  6. 4 w& V% h. U- E& D* y
  7. u8 TestFun(u32 x)//函数,带一个参数,并返回一个u8值
    8 f2 D5 X& s, T: R- \! h* R
  8. {2 J6 V& y. I* V/ |' n& J
  9. u8 test_tmp1 = 4;//局部变量,初始化
    ( ^2 E, Q) o8 @  t
  10. u8 test_tmp2;//局部变量,未初始化
      Q& p; h: Q7 W: F5 x  K+ r" @

  11. : A# m! H9 w. s2 \/ Q* {: @
  12. static u8 test_tmp3 = 0;//静态局部变量
    7 F+ \( L9 `. Y4 Q3 x+ y7 L1 F

  13. 8 U/ a2 N8 Q5 c9 v8 L2 X
  14. test_tmp3++;( _/ _+ V; K3 B: M* |9 [

  15. 6 N8 a5 A' U, q. S& Q, I$ l
  16. test_tmp2 = x;0 H( ?) E# P. E) C

  17. 7 O* M! Z' W. S
  18. if(test_tmp2> TestTmp1)" F5 `  t( d6 Z( r+ v
  19.   test_tmp1 = 10;1 w! |/ Y) a! g7 q  `
  20. else2 C/ l8 i( ^% }  L3 b
  21.   test_tmp1 = 5;
    - D3 t( G$ {5 X6 l0 ^

  22. ) y: l* Z! j# p$ P5 i
  23. TestTmp2 +=TestTmp3[test_tmp1];
    4 \' y8 G( L1 {; T# g- f8 ^

  24. 0 b7 R# {/ j8 ]+ |& V
  25. return test_tmp1;" Q: h, l2 ^6 h* _! A
  26. }
复制代码

4 `! Z. ?! d( \9 g0 C  P7 x: J8 I; A# ^  ]; ?

( S7 U: x6 P, r8 R7 a0 ]! p7 l然后程序就一直在main函数的while循环里面执行。中断呢?对,还有中断。中断中断,就是中断正常的程序执行流程。我们查看Delay函数,uwTimingDelay不等于0就死等?谁会将uwTimingDelay改为0?
# X. I1 a2 M: }4 p3 I
  1. ; Y6 f# g. d$ n4 S
  2. /**) `) J# |. j4 ]. l
  3.   * @brief  Inserts a delay time.) N8 f1 H9 L9 a
  4.   * @param  nTime: specifies the delay time length, in milliseconds.
    2 `/ ~' R$ p& I
  5.   * @retval None: o* t0 N& N; m' `/ @- n
  6.   */  I$ a  _2 }9 L  L6 E
  7. void Delay(__IO uint32_t nTime)( ]3 r' T. o, H2 t
  8. {
    ( x0 _8 i, I" ]1 J* V0 f
  9.   uwTimingDelay = nTime;
    $ U) c! a8 B$ s% U' c4 M

  10. / Y/ U1 G+ s* t+ J% S9 Y
  11.   while(uwTimingDelay != 0);0 U: M& x9 P( p8 V& N; W7 ~
  12. }
复制代码
1 ~1 W4 L7 l7 m; a2 C+ i

+ K3 {- M+ P! t9 t( B. [搜索uwTimingDelay变量,函数TimingDelay_Decrement会将变量一直减到0。' ^3 ]2 m' Z& x6 y
  1. /**. C7 ?  G9 U0 p
  2.   * @brief  Decrements the TimingDelay variable.' E, c; c5 T2 k% d4 p: ?4 \
  3.   * @param  None
    ( ]; I1 v( v6 T, X: t7 J
  4.   * @retval None( g; V7 l. X% p7 t& a( @
  5.   */
    . S. Z2 i# u: j# E4 \( k
  6. void TimingDelay_Decrement(void)
    4 T% C6 {+ |+ R% L" C/ j
  7. {% X# T' G5 ^: q6 i
  8.   if (uwTimingDelay != 0x00)
    1 Y) e9 ]0 i. F2 ?1 U
  9.   {
    9 `# V. |9 h7 @& A* Q
  10.     uwTimingDelay--;* r+ d5 M1 X: B! [; p! [) ^
  11.   }& G' @# k' d+ l5 o1 I! Q7 w
  12. }
复制代码
4 O) Z8 q0 b  p
8 i0 E6 @" r: U* k) s* y

& `  ?/ P3 Z# p这个函数在哪里执行?经查找,在SysTick_Handler函数中运行。谁用这个函数?" {* A. o$ G& x6 v2 t2 [% [
  1. /**
    ) h" W" B8 X# J7 j. V3 W" y* p
  2.   * @brief  This function handles SysTick Handler.
    + e) E8 i" B; E
  3.   * @param  None
    8 _- m% \: p( \' L
  4.   * @retval None! V( t% w; k( m& E9 X9 D' q
  5.   */
    + u8 l7 W! g* t$ h0 M4 a; E
  6. void SysTick_Handler(void)4 N7 o7 E+ C: A. |; \7 s
  7. {& ~2 q2 z: `) P3 \1 R
  8.   TimingDelay_Decrement();' P/ Q6 G; _* K
  9. }
复制代码

- U0 f# ?7 R4 B5 L  J0 u+ h6 e) P% _" `. i/ Z

! m# ~( ]0 v+ i: L& `' m经查找,在中断向量表中有这个函数,也即是说这个函数指针保存在中断向量表内。当发生中断时,就会执行这个函数。当然,在进出中断会有保存和恢复现场的操作。这个主要涉及到汇编,暂时不进行分析了。有兴趣自己研究研究。通常,现在我们开发程序不用关心上下文切换了。
  l+ C* u4 k5 d8 }0 ?6 t. ^
  1. __Vectors       DCD     __initial_sp               ; Top of Stack
    & G" y( N' X; B& B) A7 n# ~5 R
  2.                 DCD     Reset_Handler              ; Reset Handler: f4 `+ u# P4 S# H' S6 z1 H, T
  3.                 DCD     NMI_Handler                ; NMI Handler% K- z3 j1 b. b: a
  4.                 DCD     HardFault_Handler          ; Hard Fault Handler
    7 h9 S( A$ p3 ?5 N; G9 K
  5.                 DCD     MemManage_Handler          ; MPU Fault Handler, ]8 e  H7 }" T& y* P
  6.                 DCD     BusFault_Handler           ; Bus Fault Handler" r: p9 O0 z7 }& `6 _
  7.                 DCD     UsageFault_Handler         ; Usage Fault Handler
    ' G4 A+ E& L6 A
  8.                 DCD     0                          ; Reserved
    0 Y! |' A' x) i# F5 R3 a
  9.                 DCD     0                          ; Reserved9 y" q! ^! U. l* ]7 n$ g7 {5 |
  10.                 DCD     0                          ; Reserved
    ) S; G3 t8 [0 K
  11.                 DCD     0                          ; Reserved
    8 q/ t# G$ r7 C- |8 j# a& j" Q/ U
  12.                 DCD     SVC_Handler                ; SVCall Handler- n8 V( e; @4 @" Y5 B- l
  13.                 DCD     DebugMon_Handler           ; Debug Monitor Handler( Y2 `; Y+ ?1 e& E
  14.                 DCD     0                          ; Reserved7 s3 l5 x) n( U6 y
  15.                 DCD     PendSV_Handler             ; PendSV Handler7 `8 j6 [% M" O. I/ `6 n
  16.                 DCD     SysTick_Handler            ; SysTick Handler
复制代码

5 s8 M; j4 W1 ~8 Q8 H
# V) \2 o! q' Q# |& Z' y8 h" x. w# _3 S

6 l* e1 L% r% f3 m余下问题
$ e  B3 k! b  s* D9 D5 R. i
/ T2 I1 k  d, h; D6 q+ }
3 }' z6 S/ M5 C+ q
1 __main函数是什么函数?是我们在main.c中定义的main函数吗?2 分散加载文件中*(InRoot$$Sections)是什么?3 ZI段,也就是初始化为0的数据段,什么时候初始化?谁初始化?# N5 |; i5 }9 n" q2 T& p, F8 U

/ ^5 g; V# e5 ~2 A' [8 C4 S

  X9 o9 |1 |+ |- f" L为什么这几个问题前面留着不说?因为这是同一个问题。顺藤摸瓜!
( |* G* F2 h& E% Q% x7 a( I3 c
8 g, y- z0 ?, x" T& n, n* B
% S. Q3 A* i3 F$ n+ A: _, y$ Y4 {: E
通过MAP文件了解代码构成
6 I1 @; i5 e6 d6 w3 J: ~6 W3 L! H7 I1 g
2 p; U  ?9 Y5 j6 U% S$ Y  L
编译结果5 J; C% Z. k$ j9 u/ B0 I7 w  Z
程序编译后,在下方的Build Output窗口会输出信息:
: r$ `5 m. {' l6 q( G& h+ g  ~
  1. *** Using Compiler 'V5.06 update 5 (build 528)', folder: 'C:\Keil_v5\ARM\ARMCC\Bin') I0 P3 z3 {. V/ T- m
  2. Build target 'wujique'
    , D! O. b/ J0 i3 ?. ^5 F
  3. compiling stm32f4xx_it.c...
    6 l/ U9 }+ l+ s
  4. ..., Z1 B4 d8 W4 [" ]  }: i8 J
  5. assembling startup_stm32f40_41xxx.s..., |6 a( U8 z2 F+ V& i  f
  6. compiling misc.c...4 }& j/ y9 A! i8 t& t9 L
  7. ...6 o6 [  s3 T# p  S& O
  8. compiling mcu_uart.c.../ I$ q. r! C/ Z* N
  9. linking.../ ^% w/ `0 z; v; {5 l% G
  10. Program Size: Code=9038 RO-data=990 RW-data=40 ZI-data=6000  - }  k& O* M; O! g4 K7 h5 T
  11. FromELF: creating hex file...1 E4 R4 {: b' |
  12. ".\Objects\wujique.axf" - 0 Error(s), 0 Warning(s).2 n# B6 M( T2 Y" \# J
  13. Build Time Elapsed:  00:00:32
复制代码

7 m. r/ X* p& ^! i. J) w6 x2 o5 h$ D+ N, x% X
& |# P7 E: q, Q1 C! s7 X
  • 编译目标是wujique
  • C文件compiling,汇编文件assembling,这个过程叫编译
  • 编译结束后,就进行link,链接。
  • 最后得到一个编译结果,9038字节code,RO 990,RW 40,ZI 6000。CODE,是代码,很好理解,那RO、RW、ZI都是什么?
  • FromELF,创建hex文件,FromELF是一个好工具,需要自己添加到option中才能用1 H; v% {1 m. ?7 \# o

    4 ~! e! I" [  o0 f  G
map文件配置) n3 d% ]' I) }$ `& ]! n9 }! V

- \9 G6 ~% a: y2 H

, H+ j8 n$ S1 p/ X0 d, r6 q更多编译具体信息在map文件中,在MDK Options中我们可以看到,所有信息都放在\Listings\wujique.map; P, I2 x9 F+ b, y4 w9 P

% r% f% q1 d: L9 L4 s
默认很多编译信息可能没钩,钩上所有信息会增加编译时间。

& R: x3 P' k( k- B+ ]7 v1 D9 C8 \
640 (20).png 6 M9 W  N+ d/ z3 q7 v

/ [" m$ [8 H. p5 m9 \+ _- ]map文件
9 g: I2 y2 J/ L& n! E8 u打开map文件,好乱?习惯就好。我们抓重点就行了。; e  X: q5 Q' s) D9 t# u2 J% O
% |' T: C3 z# y8 Z1 u
1 P, e& r1 `- u7 f
640 (19).png
* \% E* v% Z: L" w' x- T. G. m( ~
$ }5 E/ O* C2 {3 m# t3 S$ E
  • map 总信息

    4 D! N$ _- `2 J; C/ Z
从最后看起,看到没?最后的这一段map内容,说明了整个程序的基本概况。4 T8 z; ?- S, g8 ]  I6 X
有多少RO?RO到底是什么?' s1 Q! j7 C) M4 Z7 P% o6 a, I
有多少RW?RW又是什么?, X9 E: p9 x( U' h7 L0 R
ROM为什么不包括ZI Data?
1 b+ g0 {4 i5 q3 t4 N为什么包含RW Data?
. e" L$ G# x) ~- S5 `8 b" o" f" v4 c1 O  h! |2 r* r

8 A3 p7 B. b+ U6 u) o! l 640 (18).png . `6 C' [3 y. w/ \1 G
# B" K9 }* X+ c! x2 m  `1 Z- J
  • Image component sizes
    : y! F- f$ V+ F

    . e2 C% J/ w! t9 x" P
往上,看看Image component sizes,这个就比刚刚的总体统计更细了。这部分内容,说明了每个源文件的概况首先,是我们自己的源码,这个程序我们的代码不多,只有main.o,wujique_log.o,和其他一些STM32的库文件。
0 k1 g9 O$ S) x4 J8 z
6 ]8 p- b& H% M9 ~. @$ W8 K' G. w
( z  F/ b9 _+ `, z+ u% z1 v. |
640 (17).png
9 E- m% v) r6 A, p3 C第2部分是库里面的文件,看到没?里面有一个main.o。main函数是不是我们写的main函数?明显不是,我们的main函数是放在main.o文件。这么小的一个工程,用了这么多库,你以前关注过吗?估计没有,除非你曾经将一个原本在1M flash上的程序压缩到能在512K上运行。
$ o3 j' Z- w) P. x( h1 E# }- Z' ]) _
9 @- C9 A4 i: X
0 Y0 s, N" @1 t% x
640 (16).png : ~1 G$ r& o6 n$ {6 T
( d" p5 i" |8 @$ j
第3部分也是库,暂时没去分析这两个是什么东西。2 c5 A, v4 k! R5 @9 ?4 g

+ r  Z$ Y. X/ c3 l
/ W' p, ?1 {6 Y7 D$ ?% w
640 (15).png 7 P/ x. o! [0 }7 \4 p
; I6 ]& ]6 m. Z. y# A
库文件是什么?库文件就是别人已经别写好的代码库。在代码中,我们经常会包含一些头文件,例如:
#include <stdarg.h>' E/ f  x' A  }, D! w
#include <stdlib.h>
3 ]1 U# n# Z# b3 G#include <string.h>  
这些就是库的头文件。这些头文件保存在MDK开发工具的安装目录下。我们经常用的库函数有:memcpy、memcmp、strcmp等。只要代码中包含了这些函数,就会链接库文件。
' T6 u% B; K2 u# I
  • 文件map

    ' |$ p5 v" Z* h. B
再往上,就是文件MAP了,也就时每个文件中的代码段(函数)跟变量在ROM跟RAM中的位置。首先是ROM在0x08000000确实放的是startup_stm32f40_41xxx.o中的RESET
: @( }$ X. N- A( H% y  B2 [, a6 Q6 u7 y  ~. f0 i9 `% s$ e" g! n
库文件是什么?

6 ~4 u! c6 H* ]5 Y% k
库文件就是别人已经别写好的代码库。在代码中,我们经常会包含一些头文件,例如:0 c0 {1 v6 C  n) M" |
  1. #include <stdarg.h>' H  p- w2 K! Z; w. X0 Y# t' w
  2. #include <stdlib.h>5 A/ O: J# p9 G: v9 b7 R
  3. #include <string.h>
复制代码

) P: V+ F, ]; `9 P$ @. k0 a8 @% l, l5 u3 B! q8 w$ @, v) K( V

& ^" q4 Y) `1 E" r9 o0 C! I& L# v 这些就是库的头文件。这些头文件保存在MDK开发工具的安装目录下。
+ i) i; ~% x; R8 m% C  O+ x我们经常用的库函数有:memcpy、memcmp、strcmp等。只要代码中包含了这些函数,就会链接库文件。
$ U4 x( f9 a9 V/ m) B5 \+ T2 r$ A. m. O6 g& F& b( b* C
  • 文件map7 ]2 P" m: k5 b* }! {; n9 X, W
    9 n/ W0 W6 P7 v% @6 w+ l
再往上,就是文件MAP了,也就时每个文件中的代码段(函数)跟变量在ROM跟RAM中的位置。首先是ROM在0x08000000确实放的是startup_stm32f40_41xxx.o中的RESET) r3 E1 T5 x4 w) ?* _: g$ U  }

* E' P' T0 q2 P4 E; s+ |
/ g2 E7 j0 w$ r* k% k
640 (14).png
. y, q1 _: e1 d% \+ H: p每个文件有有多行,例如串口,4个函数。# Q* ~" A% q4 p4 u4 l
: d! C& Z6 q- Q$ L2 H' x  M; b

5 q/ A) ]( t/ L# y 640 (13).png
& c2 p* k" ]( \- Q) x9 B. {0 I9 l# z1 X* E# J+ T% l/ _5 v' Y3 ]
5 S& D* p2 I7 O: F  b3 a
然后是RAM的,main.o中的变量,放在0x20000000,总共有0x0000000c,类型是Data、RW。串口有两种变量,data和bss,什么是bss?这两个名称,是section name,也就是段的意思。看前面type和Attr,RW Data,放在.data段;RW Zero放在.bss段,RW Zero,其实就是ZI。到底哪些变量是RW,哪些是ZI?
: b. z. l% b: p( T8 L5 q6 ~8 r
" D+ W  x. l9 w) @5 ^
  j+ l. A+ G+ a/ n% e% m" q
640 (12).png 0 j1 {4 q- k  [+ K; R' f  d

  T6 o7 \$ N7 ~! z% O8 P
  • Image Symbol Table

    - E( u4 A2 z, i; K3 T$ U, x
再往上就是Image Symbol Table,就更进一步到每个函数或者变量的信息了; Q6 F9 x# m9 c3 Z8 j" E

. K9 I! Z, b* Y* s0 T9 K% x* f

: T! c5 O  n5 v9 @3 V 640 (11).png # k% A: Y; i% M% M- e. ?7 M

+ p# I( c6 g* O4 t  d

1 [4 Z9 R  d6 V! _5 x  N例如,全局变量TestTmp1,是Data,4字节,分配的位置是0x20000004。
+ J- E  ]* y. d! {2 N3 _, r$ O
8 s7 c3 f0 {+ c, R- J" i/ ~

( u0 l& G7 C, H- f$ j# H 640 (10).png   s, U# m& k+ c
/ v+ J( m4 l  L
3 j5 I) D2 T. A6 j7 b% c& L6 g
TestTmp3数组放在哪里?放在0X080024E0这个地方,这可是代码区额。因为我们用const修饰了这个全局变量数组,告诉编译器,这个数组是不可以改变的,编译器就将这个数组保存到代码中了。程序中我们经常会使用一些大数组数据,例如字符点阵,通常有几K几十K大,不可能也没必要放到RAM区,整个程序运行过程这些数据都不改变,因此通过const修饰,将其存放到代码区。" y; U  y" I8 n, U% Z

" R3 j" O8 H2 X: E
const的用处比较多,可以修饰变量,也可以修饰函数。更多用法自行学习

( m* ?' z: w; B0 W  e8 I
640 (9).png
/ Z" n2 y8 Y- j0 }
- t; w( s7 i! y' {9 s; p; X8 F9 f5 y5 z
2 F; @1 R0 y* e5 v% R9 f
那局部变量存放在哪里呢?我们找到了test_tmp3,
) Q6 r1 P$ f9 q- Y7 p# d, r: m1 U; ?. V" P. d

6 I" A  E7 o6 l1 q0 a 640 (8).png 7 |; G. V% U) G* Q: Z

9 ~! z0 ~: E1 [/ V
  n: U5 K, Y, G
没找到test_tmp1/test_tmp2,为什么呢?在定义时,test_tmp3增加了static定义,意思就是静态局部变量,功能上,相当于全局变量,定义在函数内,限制了这个全局变量只能在这个函数内使用。哪test_tmp1、test_tmp2放在哪里呢? 局部变量,在编译链接时,并没有分配空间,只有在运行时,才从栈分配空间。
& W; _& C7 H& F$ @7 M
  1. u8 TestFun(u32 x)//函数,带一个参数,并返回一个u8值
    ! D5 J" d# ?' x4 d! a) X4 e. q( Z- e
  2. {) p) Q$ B/ f( s6 m" }* a9 @
  3. u8 test_tmp1 = 4;//局部变量,初始化
    7 O, i9 J+ S& X: r, k! S
  4. u8 test_tmp2;//局部变量,未初始化
    " b, G# y; i% F3 ]& f5 ^
  5. * j" ~& P- t5 K
  6. static u8 test_tmp3 = 0;//静态局部变量
复制代码
6 D5 K" c: Q# e( l4 G

5 y/ ], q6 c0 s1 @, I

+ Z% }! @8 F4 A+ A( @上一部分,我们留了一个问题,哪些变量是RW,哪些是ZI?我们看看串口变量的情况,UartBuf3放在bss段,其他变量放在.data段。为什么数组就放在bss?bss是英文Block Started by Symbol的简称。
/ ^$ m! U$ r$ c* y2 v0 l& k7 g, X. `

) G: j" m2 o: M8 g" u  v 640 (7).png
7 }& P9 H& @4 Y% b1 U! }) c, s" |; n  q2 C0 e7 t
! g  ?2 a8 F+ M
到这里,我们可解释下面几个概念了:- `. Q8 `8 r" `. Z
Code就是代码,函数。
RO Data,就是只读变量,例如用const修饰的数组。
RW Data,就是读写变量,例如全局变量跟static修饰的局部变量。
ZI Data,就是系统自动初始化为0的读写变量,大部分是数组,放在bss段。
RO Size等于代码加只读变量。
RW Size等于读写变量(包括自动初始化为0的),这个也就是RAM的大小。
ROM Size,也就是我们编译之后的目标文件大小,也就是FLASH的大小。但是?为什么会包含RW Data呢?因为所有全局变量都需要一个初始化的值(就算没有真正初始化,系统也会分配一个初始化空间),例如我们定义一个变量u8 i = 8;这样的全局变量,8,这个值,就需要保存在FALSH区。
$ |' j* `5 i" u0 |) W, Y) n0 B
640 (6).png - E2 h1 I7 a4 _- G4 ?0 n% v* A8 o

: v( Y5 Y+ k9 I( S我们看看函数的情况,前面我们不是有一个问题吗?__main和main是一个函数吗?查找main后发现,main是main,放在0x08000579! w) x8 s6 h% k6 s! j

) v' ~$ m% h$ u4 c( s
2 G( b" M* G  p0 @( O! Q) l0 D( q2 D
640 (5).png
; _* r3 g% X3 x( X
5 u* N. k, U% Z) j7 y( ?/ G: gmain是main,放在0x08000189! S+ p  w, E" m8 r% k) w
: @$ `2 f9 U, ^3 _+ O
# L! A9 e, K7 ^. D* q: h
640 (4).png / A: o& u5 s5 J0 m% a
. z, H2 T* t$ u* E* B

( A5 l3 g7 z" z5 |__main到main之间发生了什么?还记得分散加载文件中的这句吗?
, V( C' x, `0 w
  1. *(InRoot$Sections)
复制代码
4 ?) @9 p& [' ~/ c  n  E: ~
__main就在这个段内。下图是__main的地址,在0x08000189。__Vectors就是中断向量,放在最开始。) X& ]4 a& e/ x$ A0 f7 |
5 w7 ~* [5 o" i: {6 V9 T' C
( w7 ~* X& h3 V( R) m7 e: m1 U1 i
640 (3).png
# x4 i5 G3 ^2 F/ z, C( _. o6 ?# J  C2 M- e' C- z; M. Z4 s
2 o6 \2 z# z3 Y  z6 X+ N- V
在分散加载文件中,紧跟RESET的就是*(InRoot$$Sections)。* m  @2 I0 j$ W. d' K' ?4 a

  d5 [- g7 C% e5 m+ D2 x

4 I1 w8 n4 V  {. ^$ }4 u 640 (2).png ! Z4 G. O0 v# v, u7 V  D+ K

7 j0 A3 N; H0 j) S/ ~" q

. M- V7 f/ \- r# w6 D8 o而且,RESET段正好大小0x00000188。
- w% j1 l6 h3 L0 k8 b; q
( f4 J0 H! Y. D( n1 Q6 H5 v' @
) s( K4 [' x0 l: j8 S
640 (1).png
. `0 E( J% C; w% O) X* A
! e+ Q7 Z: e! Y  l- o" w! |, v& P! a
- {5 }% Z. Y9 H( P2 u# e
巧合?
7 D* o1 N( i% `1 x# @2 N% K% @8 y% c/ ]8 a

- G7 U0 f2 X  r" l2 O) d 640.png
) B  R! O* R# p- s( j0 R  B  J9 E; x3 l5 h! V$ W

; c- `! N0 }$ ]3 H5 Z这一段代码都完成什么功能呢?主要完成ZI代码的初始化,也就是将一部分RAM初始化为0。其他环境初始化……最后到这里,一个程序,是怎么组成的,程序是如何运行的,基本有一个总体印象了。
% G1 [1 t4 J7 V. L/ e, F
0 N) E) \8 }& G7 {
- b  p; K! U  Q1 {6 Q
& |. _; r5 t8 ]  E; d! v& m, ]9 R5 L- V  Y: z' B6 Z3 J3 w1 n  x
4 u2 i$ v1 M$ _. u/ \+ K9 g
3 {# z' Y! K/ }1 ?# L# s
赞 收藏 评论0 发布时间:2022-5-27 21:34

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版