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

基于STM32单片机软硬件结合经验分享

[复制链接]
攻城狮Melo 发布时间:2024-7-29 15:25
本文分析STM32单片机到底是如何软硬件结合的,分析单片机程序如何编译,运行。& A" t+ I1 [  d& S% W1 ~

/ W2 [) S9 W0 A4 b4 R. m  K软硬件结合
* b0 h; u; D/ v' a8 y) x" ?初学者,通常有一个困惑,就是为什么软件能控制硬件?就像当年的51,为什么只要写P1=0X55,就可以在IO口输出高低电平?要理清这个问题,先要认识一个概念:地址空间。
( D; Z7 g6 h" ], E

! F4 ~, }5 n, f' e9 A寻址空间
2 M. L# V4 v: c2 {; l什么是地址空间呢?所谓的地址空间,就是PC指针的寻址范围,因此也叫寻址空间。% Z6 W7 f" H; F# V
: ], C: I) W# h& D& x4 q2 L
大家应该都知道,我们的电脑有32位系统和64位系统之分,为什么呢?因为32位系统,PC指针就是一个32位的二进制数,也就是0xffffffff,范围只有4G寻址空间。现在内存越来越大,4G根本不够,所以需要扩展,为了能访问超出4G范围的内存,就有了64位系统。STM32是多少位的?是32位的,因此PC指针也是32位,寻址空间也就是4G。' E* O, o/ [- m+ D( o: q7 {4 L" }+ ^

& ?* R6 D  M; o' c# r& V2 p5 `我们来看看STM32的寻址空间是怎么样的。在数据手册《STM32F407_数据手册.pdf》中有一个图,这个图,就是STM32的寻址空间分配。所有的芯片,都会有这个图,名字基本上都是叫Memory map,用一个新芯片,就先看这个图。
8 k" i8 O) g2 n' M! W  u) D5 x5 }3 J: f( Y- X$ A" x
微信图片_20240729152315.png ' c( x6 G! U1 o: b6 m

+ k& R% ]* A3 ~
/ s2 V# L: @( A/ l2 c! C, X最左边,8个block,每个block 512M,总共就是4G,也就是芯片的寻址空间。
+ s, ]. F4 T5 j% q) v$ P& z
6 d  r% w  W- B$ ~  ?* A# K& Mblock 0 里面有一段叫做FLASH,也就是内部FLASH,我们的程序就是下载到这个地方,起始地址是0X800 0000,大家注意,这个只有1M空间。现在STM32已经有2M flash的芯片了,超出1M的FLASH放在哪里呢?请自行查看对应的芯片手册。% ?+ K! Z$ j  z/ m2 Y. r

+ W+ G* ^/ e8 l& ~1 ~% u4 ~! y3 在block 1 内,有两段SRAM,总共128K,这个空间,也就是我们前面说的内存,存放程序使用的变量。如果需要,也可以把程序放到SRAM中运行。407不是有196K吗?8 \  o9 v6 \3 X+ P

9 n& \$ o  Q* s7 [, K其实407有196K内存,但是有64k并不是普通的SRAM,而是放在block 0 内的CCM。这两段区域不连续,而且,CCM只能内核使用,外设不能使用,例如DMA就不能用CCM内存,否则就死机。/ d9 f: k) i6 I8 N2 ?2 z- k/ U

9 U$ X. Y% N1 w2 M" Jblock 2,是Peripherals,也就是外设空间。我们看右边,主要就是APB1/APB2、AHB1/AHB2,什么东西呢?回头再说。
# |, Q) }  y) }/ E8 g6 m3 e  F3 W7 T$ I" s, _1 E
block 3、block4、block5,是FSMC的空间,FSMC可以外扩SRAM,NAND FALSH,LCD等外设。
# x" d8 n& l* \# e6 g8 d/ D% [- i* S( a
好的,我们分析了寻址空间,我们回过头看看,软件是如何控制硬件的。对于这个疑惑,也可以看此文:代码是如何控制硬件的?在IO口输出的例程中,我们配置IO口是调用库函数,我们看看库函数是怎么做的。
1 x% u' c# O4 C7 e; O4 H4 a2 p" o4 D/ k# @7 I6 [, a! R6 d
例如:$ @. H4 c& t) X! m# C
  1. GPIO_SetBits(GPIOG, GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2| GPIO_Pin_3);
复制代码
; @' Z0 f) F2 m6 g0 O) Q# w
这个函数其实就是对一个变量赋值,对GPIOx这个结构体的成员BSRRL赋值。
/ }8 r/ E7 P. }  V/ R1 g  y
  1. void GPIO_SetBits(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)( L7 q. R# p. P& f) J
  2. {5 ^  A7 d4 h" f* C- a+ p
  3. /* Check the parameters */% u" \+ i& R+ J" J. M  P8 m
  4. assert_param(IS_GPIO_ALL_PERIPH(GPIOx));
    & B- t! v) o( f/ z, |+ [2 l) v
  5. assert_param(IS_GPIO_PIN(GPIO_Pin));
    8 F  l- D: P$ s) u9 |
  6. 0 R2 Y4 E, ]1 k; t

  7. $ p3 \. ^6 k3 m
  8. GPIOx->BSRRL = GPIO_Pin;
    0 }4 z; N. t2 z) Y2 t1 d2 C' ~
  9. }
复制代码
; ]" r! P# S) o# t; V
assert_param:这个是断言,用于判断输入参数是否符合要求GPIOx是一个输入参数,是一个GPIO_TypeDef结构体指针,所以,要用->获取其成员3 _$ Z8 `' Z& [: K. ^# `3 ]
9 y1 a! Q9 K. _7 E2 s3 k2 z! b, ~
GPIOx是我们传入的参数GPIOG,具体是啥?在stm32f4xx.h中有定义。
) ?+ X3 z  U4 }/ u4 I) F
  1. #define GPIOG               ((GPIO_TypeDef *) GPIOG_BASE)
复制代码
' d2 m% z. m* i! b
GPIOG_BASE同样在文件中有定义,如下:
4 R! @, J  [$ f
  1. /*!< Peripheral memory map */
    7 u7 Z+ H& G+ @
  2. #define APB1PERIPH_BASE       PERIPH_BASE
    " ?$ i$ h% m- V
  3. #define APB2PERIPH_BASE       (PERIPH_BASE + 0x00010000)# q- `% g  Q5 z: v8 F
  4. #define AHB1PERIPH_BASE       (PERIPH_BASE + 0x00020000)! e& q1 o& C3 t
  5. #define AHB2PERIPH_BASE       (PERIPH_BASE + 0x10000000)
复制代码

) T+ N4 }2 I6 ?2 i" X再找找PERIPH_BASE的定义
; T0 }: Z( U/ y' W& l  ^
  1. #define PERIPH_BASE           ((uint32_t)0x40000000)
复制代码
到这里,我们可以看出,操作IO口G,其实就是操作0X40000000+0X1800这个地址上的一个结构体里面的成员。说白了,就是操作了这个地方的寄存器。实质跟我们操作普通变量一样,就像下面的两句代码,区别就是变量i是SRAM空间地址,0X40000000+0X1800是外设空间地址。) P, Y* Q, a$ @4 [) ~5 n
  1. u32 i;
    8 I- p2 x$ C1 l6 t* H# t3 [
  2. i = 0x55aa55aa;
复制代码
$ `( J: }0 v9 b% V, [
这个外设空间地址的寄存器是IO口硬件的一部分。关于如下图STM32的GPIO文章推荐:STM32中GPIO工作原理详解。如下图,左边的输出数据寄存器,就是我们操作的寄存器(内存、变量),它的地址就是0X40000000+0X1800+0x14.$ h0 @$ c0 z3 L/ E! X

! S8 Y) y( s0 q4 p, T% j
微信图片_20240729152319.png

5 n6 Q+ e+ {3 T; ]
( u: E6 R  F- |7 |; n, K- @. ?4 q
控制其他外设也类似,就是将数据写到外设寄存器上,跟操作内存一样,就可控制外设了。, V% n4 F- k' `. J9 D: g& p6 I* l

: v3 Z! I5 y1 F3 G寄存器,其实应该是内存的统称,外设寄存器应该叫做特殊寄存器。慢慢的,所有人都把外设的叫做寄存器,其他的统称内存或RAM。寄存器为什么能控制硬件外设呢?因为,初略的说,一个寄存器的一个BIT,就是一个开关,开就是1,关就是0。通过这个电子开关去控制电路,从而控制外设硬件。
2 f+ |2 w- [  C6 M; }% _- A

: W( A- V& e7 |+ \纯软件-包罗万象的小程序
) E5 b. T% J% T4 V我们已经完成了串口和IO口的控制,但是我们仅仅知道了怎么用,对其他一无所知。程序怎么跑的?关于程序是怎么在单片机运行的,也可以看此视频:动画演示单片机是如何跑程序的。代码到底放在那里?内存又是怎么保存的?下面,我们通过一个简单的程序,学习嵌入式软件的基本要素。
- s( K( ~( m0 ^( q- b
6 {8 @7 i9 P2 ?, u; W/ c分析启动代码/ K6 P$ j" R: s" l0 `
函数从哪里开始运行?: Y  {! r. P! ^. F5 Z
每个芯片都有复位功能,复位后,芯片的PC指针(一个寄存器,指示程序运行位置,对于多级流水线的芯片,PC可能跟真正执行的指令位置不一致,这里暂且认为一致)会复位到固定值,一般是0x00000000,在STM32中,复位到0X08000004。因此复位后运行的第一条代码就是0X08000004。前面我们不是拷贝了一个启动代码文件到工程吗?startup_stm32f40_41xxx.s,这个汇编文件为什么叫启动代码?因为里面的汇编程序,就是复位之后执行的程序。在文件中,有一段数据表,称为中断向量,里面保存了各个中断的执行地址。复位,也是一个中断。# f) }5 b2 a4 e7 ^  G$ @

* B8 p/ o8 k3 G" b& I3 n/ b芯片复位时,芯片从中断表中将Reset_Handler这个值(函数指针)加载到PC指针,芯片就会执行Reset_Handler函数了。(一个函数入口就是一个指针)
  1. ; Vector Table Mapped to Address 0 at Reset
    . z+ I9 e/ C+ Y! l2 j: Q0 ]" W
  2.                 AREA    RESET, DATA, READONLY
    - g* `& `4 k$ o5 |3 B( K7 p
  3.                 EXPORT  __Vectors! g4 J  `/ |- s0 @! P. K
  4.                 EXPORT  __Vectors_End
    9 s1 ?$ ?/ F) Y
  5.                 EXPORT  __Vectors_Size; |: V  f7 T9 n

  6. 6 V9 q0 I+ g8 K+ q
  7. __Vectors       DCD     __initial_sp               ; Top of Stack9 H  U2 J: ^1 F6 T! b" p6 Z
  8.                 DCD     Reset_Handler              ; Reset Handler; S; \) ]( N; ~* W* ?
  9.                 DCD     NMI_Handler                ; NMI Handler5 Y, v0 M% l* ?* D* f8 S+ o' M
  10.                 DCD     HardFault_Handler          ; Hard Fault Handler
    & f2 }: x9 K, d0 |9 Q$ y' o
  11.                 DCD     MemManage_Handler          ; MPU Fault Handler% [3 M* U/ t5 N4 f: V) ^) n
  12.                 DCD     BusFault_Handler           ; Bus Fault Handler
    ( f2 x- _7 U7 e' Y: N- |" Y( i
  13.                 DCD     UsageFault_Handler         ; Usage Fault Handler
复制代码
8 F1 C& A+ ?' a# M+ X" q
Reset_Handler函数,先执行SystemInit函数,这个函数在标准库内,主要是初始芯片时钟。然后跳到__main执行,__main函数是什么函数?/ K# H, c) i2 R) e1 l: Y+ Q  ]
0 n1 S( @. `. s) f
是我们在main.c中定义的main函数吗?后面我们再说这个问题。6 k( d5 n% s, l7 {0 f
6 U* y. Z7 b& r& Z# a* p6 U
微信图片_20240729152323.png
% A3 _* b5 m7 C

- q. Z3 T* L0 g$ q6 Y* W* g" S0 E芯片是怎么知道开始就执行启动代码的呢?或者说,我们如何把这个启动代码放到复位的位置?这就牵涉到一个一般情况下不关注的文件wujique.sct,这个文件在wujique\prj\Objects目录下,通常把这个文件叫做分散加载文件,编译工具在链接时,根据这个文件放置各个代码段和变量。8 b1 S$ V( C- U

+ ]6 @3 R1 O. L$ |. L% ~( x在MDK软件Options菜单Linker下有关于这个菜单的设置。
0 M( N! W% G+ ?& Q# g, c' O5 a8 j3 U5 @* a; L2 _9 z* s
微信图片_20240729152326.png
7 _, h7 _6 g- {! h3 f

: i! p9 I. Q! W* Q# `% f2 c+ r& \, [- }1 a$ o
! P$ ?! X) H% E4 U- D1 L
把Use Memory Layout from Target Dialog前面的勾去掉,之前不可设置的框都可以设置了。点击Edit进行编辑。6 t6 @6 F& O6 W  A7 k- I
! o. E! P2 a8 v
2.png

9 }9 u& S# U% s3 j( c1 F5 o" R; C$ E
4 s+ C+ B# {" S$ j5 v: |% v
' o  a; T8 w) {
在代码编辑框出现了分散加载文件内容,当前文件只有基本的内容。
: J0 t* z& q; e" |1 ^# A, m. F5 u: ~3 _" q( s
其实这个文件功能很强大,通过修改这个文件可以配置程序的很多功能,例如:1 指定FLASH跟RAM的大小于起始位置,当我们把程序分成BOOT、CORE、APP,甚至进行驱动分离的时候,就可以用上了。2 指定函数与变量的位置,例如把函数加载到RAM中运行。5 Y+ y* _/ C" |3 Q
  T, H2 j" J) e0 J
3.png

+ Y2 M8 n: n6 I8 E2 L
5 k# T( x& ?" I1 i& N' G2 Z4 G% U
从这个基本的分散加载文件我们可以看出:
2 A" ^% O/ ~6 m) R+ \( F0 Q
: `. ~0 O+ R0 W1 m; k  g/ K& u第6行 ER_IROM1 0x08000000 0x00080000定义了ER_IROM1,也就是我们说的内部FLASH,从0x08000000开始,大小0x00080000。0 u0 j$ E& ~& p9 ?7 i6 w+ i5 C
1 [8 E+ a/ F7 M, M# B) k1 D. E" l
第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。
; Q2 U% K- p& m, C" A

( C, [/ l0 c( z  H1 Q, r+ S第8行 *(InRoot$$Sections)什么鬼?GOOGLE啊!回头再说。) N* b. e% [+ F+ E4 ^- A) Z# f" D; O

; e9 R9 X* _- R$ G9 j; ?; U第9行 .ANY (+RO)意思就是其他的所有RO,顺序往后放。就是说,其他代码,跟着启动代码后面。
2 k# r: X6 g/ `- T- N/ q5 c" C1 G
% X. ]( N: H2 r# c1 s1 F$ X
第11行 RW_IRAM1 0x20000000 0x00020000定义了RAM大小。7 [  C4 D+ J! c

+ L% k, F3 g- l- ?  z) p第12行 .ANY (+RW +ZI)所有的RW ZI,全部放到RAM里面。RW,ZI,也就是变量,这一行指定了变量保存到什么地址。* J) T3 H( Q# G- x% a

7 g$ l( y* ]% w+ [分析用户代码
" A0 p& y: O( @: H到此,基本启动过程已经分析完。下一步开始分析用户代码,就从main函数开始。' K" B6 P; R, }* B. Z" g9 J
# N( N% w; P- V' v* P4 D
1 程序跳转到main函数后:RCC_GetClocksFreq获取RCC时钟频率;SysTick_Config配置SysTick,在这里打开了SysTick中断,10毫秒一次。Delay(5);延时50毫秒。
  1. int main(void)  |. A+ {  h0 R7 h
  2. {! n3 f  ^+ D0 l3 W( o
  3.   GPIO_InitTypeDef GPIO_InitStructure;& R7 d7 F! I7 ^- L* b) h" i) Y
  4. . R: Q& t% t& W0 C
  5. /*!< At this stage the microcontroller clock setting is already configured,
    * u9 I) L! l, i, M3 q# Q5 H. }
  6.        this is done through SystemInit() function which is called from startup
    1 p2 T$ f* l' D6 ~6 K
  7.        files before to branch to application main.
    $ ?  X$ N" F) E
  8.        To reconfigure the default setting of SystemInit() function,8 L) ]  F8 k( v# C/ i
  9.        refer to system_stm32f4xx.c file */) C5 y4 R: _9 @" v3 B
  10. " \% p$ A( y/ U+ Z" d- i
  11.   /* SysTick end of count event each 10ms */3 n9 o% i. M7 [! w& H( K
  12.   RCC_GetClocksFreq(&RCC_Clocks);) s& u/ J' X2 u
  13.   SysTick_Config(RCC_Clocks.HCLK_Frequency / 100);+ {3 k7 }9 z& ]. H$ P( i/ W. J- `
  14. , A1 ^9 g2 L; Z7 H% @5 [' e& t
  15.   /* Add your application code here */' [. s% Y7 P& z! n
  16.   /* Insert 50 ms delay */7 [$ |/ Q9 o1 a/ F, @) K* V
  17.   Delay(5);
复制代码
" o0 G( @+ N1 Z8 D( Y
2 初始化IO就不说了,进入while(1),也就是一个死循环,嵌入式程序,都是一个死循环,否则就跑飞了。
  1. /*初始化LED IO口*/& {8 Z. t% K9 L& j
  2. RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOG, ENABLE);% t& C" L2 z4 i1 R1 z' w3 h. y8 w
  3. , |, e5 e; o& E( A* K' l, n6 ^
  4. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2| GPIO_Pin_3;! `, H3 H4 U2 u; q
  5. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    6 L+ [* f( v4 s6 ?7 q+ P. C" L
  6. 5 r# m- P& k0 R, x6 z6 g9 g9 D
  7. GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    + o- ?: I3 i8 D3 X
  8. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;& D7 y0 q% S. O4 F9 c5 A1 N
  9. GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    ) o" J% }! z3 L. o4 }
  10. GPIO_Init(GPIOG, &GPIO_InitStructure);   
      n, \9 ]% q9 G+ k' V. J( G
  11. * d! w& G8 b) t* E7 ^; v
  12. /* Infinite loop */
    ( U4 |2 {: \  n0 C% ]* B2 Y6 F
  13. mcu_uart_open(3);
    % S* W+ B# |* A8 a3 K/ _
  14. while (1)
      {1 @; I4 M# Y3 k. I) w9 F
  15. {* \8 k' d5 w6 T, K9 r
  16.   GPIO_ResetBits(GPIOG, GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);
    # D" u9 Z7 m1 p: M% u5 ~
  17.   Delay(100);
    ( G, n$ Q- Q! x# V+ K# E- r; c
  18.   GPIO_SetBits(GPIOG, GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3);* k0 i! K3 v6 G8 s- X0 Q) R3 F
  19.   Delay(100);
    9 @8 I1 ?% Y/ q9 Q2 a
  20.   mcu_uart_test();7 _2 c. u% i9 Y& w6 Z  g" b
  21. ( `* X! n. _5 v* D- ^0 J
  22.   TestFun(TestTmp2);
    / n" f( ^. g. V  N7 |; v
  23. }
复制代码

. o7 C2 N+ Y. ^; i% u- ?3 在while(1)中调用TestFun函数,这个函数使用两个全局变量,两个局部变量。
  1. /* Private functions ---------------------------------------------------------*/8 ^2 l0 @4 K9 T/ i3 }. l
  2. u32 TestTmp1 = 5;//全局变量,初始化为51 n/ ^# \; x! h) _
  3. u32 TestTmp2;//全局变量,未初始化
    ' [1 p8 o: Z& x4 F9 I# e; H& x

  4. - x- D( E( r* b! o) M2 D
  5. const u32 TestTmp3[10] = {6,7,8,9,10,11,12,13,12,13};
    5 o3 C4 n0 k" I6 p% w6 C' O0 p  o
  6. % `( u5 `* A, R. f5 K, F# U
  7. u8 TestFun(u32 x)//函数,带一个参数,并返回一个u8值. {8 ^, S0 p" A6 f
  8. {
    0 L+ z9 P9 s' ?& ^  t1 J3 K
  9. u8 test_tmp1 = 4;//局部变量,初始化" S: u8 G! H2 U; f6 w, P5 g
  10. u8 test_tmp2;//局部变量,未初始化
    ' D! w  f( \  j! ]' w: G* T

  11. , J+ q3 h( C! C$ i( @
  12. static u8 test_tmp3 = 0;//静态局部变量" A. F0 u' \* [9 U% T1 J+ `2 X2 {

  13. * u0 k; W9 ?1 z5 O: }+ R6 H1 u1 v
  14. test_tmp3++;- k. k1 b9 e8 R1 d' i. p3 _
  15. % K! K: r8 B  |/ _$ d6 T5 g
  16. test_tmp2 = x;
    6 F4 j) J; y7 q* ^8 r

  17. $ {. ~2 _6 j" @! G# r: Z) X
  18. if(test_tmp2> TestTmp1)
    ( T' k( b8 n; g7 Z/ f
  19.   test_tmp1 = 10;5 k- ~# G6 l4 g  f5 ?
  20. else7 Y$ a3 C- `0 S  s. V6 _
  21.   test_tmp1 = 5;
    6 L) c& B: X  t; H

  22. ! _6 j. s' m4 x
  23. TestTmp2 +=TestTmp3[test_tmp1];
    ' K3 U6 z2 l5 J8 x: m; ^
  24. 6 m1 o$ Z4 H3 G
  25. return test_tmp1;
    7 ]& R7 Q& p( Q7 _( k  B
  26. }
复制代码
' U3 k7 z! i7 `! W* d4 c: C/ C% N
然后程序就一直在main函数的while循环里面执行。中断呢?对,还有中断。中断中断,就是中断正常的程序执行流程。相关文章:STM32中断系统。我们查看Delay函数,uwTimingDelay不等于0就死等?谁会将uwTimingDelay改为0?
  1. /**' h; g7 _9 ^; s2 W( v% J6 S: L0 w! y
  2.   * @brief  Inserts a delay time.
    $ i) R/ q8 a5 {8 @* d$ W" n
  3.   * @param  nTime: specifies the delay time length, in milliseconds.
    ; X$ f6 p: U" b& }* Q) o$ c3 G( h
  4.   * @retval None& I$ r8 I# e) ~. \# g5 h' ~
  5.   */
    ; v. }& o* J: y7 l& P
  6. void Delay(__IO uint32_t nTime)
    & m  W4 _. n* T1 s
  7. {9 [4 q0 |/ _- t2 G% J! q
  8.   uwTimingDelay = nTime;
    ) f0 S/ g3 E  ?* o! h# S
  9. 6 U  g0 _( O0 c7 O5 D
  10.   while(uwTimingDelay != 0);
    7 V- N% r2 i5 z7 N& _) k( p
  11. }
复制代码

) T) f2 z# y  l5 g' N搜索uwTimingDelay变量,函数TimingDelay_Decrement会将变量一直减到0。
/ C9 S+ C5 C# z6 {9 @! p
  1. /**
    ) o  S/ g8 q) n6 Y' I7 d# V
  2.   * @brief  Decrements the TimingDelay variable.
    + d" l1 k2 S2 r0 y% Z9 H
  3.   * @param  None& ~, a  j9 H4 i. x- ^6 }4 r
  4.   * @retval None# t! x+ }- v: K6 r& p
  5.   */5 `$ ^9 J& ~6 T( r
  6. void TimingDelay_Decrement(void)
    2 K  g; `" D7 U" q' r% z" W6 Y
  7. {
    # n! a) ~: g$ \& z
  8.   if (uwTimingDelay != 0x00)
    . @) t4 ^$ w! B9 d8 z. G
  9.   {
    ! a3 N( D+ k8 b  u+ i  S
  10.     uwTimingDelay--;
    1 E' ~- Z9 l% {7 e& P
  11.   }+ i% J& h* D, ]
  12. }
复制代码
8 v% ^1 k: a" T# e
这个函数在哪里执行?经查找,在SysTick_Handler函数中运行。谁用这个函数?
  1. /**7 R1 Q9 d: t1 K
  2.   * @brief  This function handles SysTick Handler.# S' i1 m. _0 j/ f. {
  3.   * @param  None% x7 p% z9 K0 n$ P1 m5 o
  4.   * @retval None
    : i) B& d! l  I6 `
  5.   */
    1 ?+ D: o0 S  \3 n& n
  6. void SysTick_Handler(void)
    ( u( L  Z" {9 `" o
  7. {$ q! f1 x! p$ @& F4 a3 ~, t
  8.   TimingDelay_Decrement();
    + d4 k1 o# q, Y9 X! X0 R; S; B
  9. }
复制代码
+ z1 j8 Q" E( n5 K/ }7 h% c; g
经查找,在中断向量表中有这个函数,也即是说这个函数指针保存在中断向量表内。当发生中断时,就会执行这个函数。当然,在进出中断会有保存和恢复现场的操作。这个主要涉及到汇编,暂时不进行分析了。有兴趣自己研究研究。通常,现在我们开发程序不用关心上下文切换了。
  1. __Vectors       DCD     __initial_sp               ; Top of Stack3 Q1 p. `' M4 O9 L1 g; _! \
  2.                 DCD     Reset_Handler              ; Reset Handler
    + g+ P* p1 r6 y! c5 ~5 `% w$ d" m( h
  3.                 DCD     NMI_Handler                ; NMI Handler
    " @0 p' e4 u, |# j& W% K
  4.                 DCD     HardFault_Handler          ; Hard Fault Handler2 m) b# I. `5 g9 H4 Y$ b2 O3 }3 Q3 a0 ]
  5.                 DCD     MemManage_Handler          ; MPU Fault Handler
    7 f+ i5 Y! d  Y% T, U+ Y
  6.                 DCD     BusFault_Handler           ; Bus Fault Handler
    ) y4 l+ Y2 D! G
  7.                 DCD     UsageFault_Handler         ; Usage Fault Handler
    - c% O! W2 r3 T' q: l
  8.                 DCD     0                          ; Reserved# T' B& g" [: n+ @- Y/ K9 u* ]
  9.                 DCD     0                          ; Reserved" |3 S6 |3 W- H# T: f7 E
  10.                 DCD     0                          ; Reserved  Q3 H2 M+ _0 S" G& b
  11.                 DCD     0                          ; Reserved
    , u' b: \) x& N3 q8 S% c  @
  12.                 DCD     SVC_Handler                ; SVCall Handler) U8 Q& F! Y) {" \+ }
  13.                 DCD     DebugMon_Handler           ; Debug Monitor Handler
    ! P# Z& p" c# r5 D' Z
  14.                 DCD     0                          ; Reserved; R1 L+ @# q$ O, k1 g2 D& ~
  15.                 DCD     PendSV_Handler             ; PendSV Handler
    & ~: J( W9 h  Q5 C6 h
  16.                 DCD     SysTick_Handler            ; SysTick Handler
复制代码

3 c# B9 {: S3 I' I( `$ x5 N余下问题
) B. l" A) }; h- q" z' Y: [1 __main函数是什么函数?是我们在main.c中定义的main函数吗?2 分散加载文件中*(InRoot$$Sections)是什么?3 ZI段,也就是初始化为0的数据段,什么时候初始化?谁初始化?
  R. C* z$ ]  R8 ~9 t% ]; L

, ]# v0 l: t! M% a! _2 k为什么这几个问题前面留着不说?因为这是同一个问题。顺藤摸瓜!$ c- A2 w0 @% G  |, L
& @  g! S9 r- S0 i3 g7 Q

1 K' x, s. J0 G+ v, j+ V6 ]' L通过MAP文件了解代码构成) D. X( _* a  P6 S0 n2 `7 y  R
编译结果

$ g! P6 D# i) Z5 Y0 j# B, V程序编译后,在下方的Build Output窗口会输出信息:
  1. *** Using Compiler 'V5.06 update 5 (build 528)', folder: 'C:\Keil_v5\ARM\ARMCC\Bin'4 D" Q5 Z3 l" b1 r: C3 z$ x
  2. Build target 'wujique'
    & j* e! p* Q, q7 P. o: U# y( s" ~
  3. compiling stm32f4xx_it.c..., U7 @8 g( a* k# L4 ]- b9 ]
  4. ...
    3 z: A6 \* D5 b* y
  5. assembling startup_stm32f40_41xxx.s..., Z+ l' ^0 E; R, L5 j
  6. compiling misc.c...4 s. N( i1 R! p2 ^
  7. ...  u0 X3 ^  q. ?. e) [
  8. compiling mcu_uart.c...
    , R; n4 q/ P9 F9 M) ]% q
  9. linking...
    7 }: U3 F/ H3 w; k
  10. Program Size: Code=9038 RO-data=990 RW-data=40 ZI-data=6000  % q' d$ m+ \" |9 x
  11. FromELF: creating hex file...
    9 e7 N2 L, \3 y! M7 H. f8 {) H
  12. ".\Objects\wujique.axf" - 0 Error(s), 0 Warning(s).
    + c  B' n5 C1 b3 _# D0 t! q
  13. Build Time Elapsed:  00:00:32
复制代码

* U' j, a% ]( A7 d. x4 X9 x% V编译目标是wujique
. w8 y5 u) p& K5 g$ N3 @8 P4 }5 `C文件compiling,汇编文件assembling,这个过程叫编译, e/ y& H4 ?$ D% G! t. s
编译结束后,就进行link,链接。  u8 x! H% s+ c9 A
最后得到一个编译结果,9038字节code,RO 990,RW 40,ZI 6000。CODE,是代码,很好理解,那RO、RW、ZI都是什么?0 N% C& u! r6 z/ E1 ~
FromELF,创建hex文件,FromELF是一个好工具,需要自己添加到option中才能用) D2 V: X' n* q8 I' |9 g

% |5 c7 j1 m% z! I  F5 {) z4 c+ W
map文件配置
5 V3 @1 h, @9 f6 z更多编译具体信息在map文件中,在MDK Options中我们可以看到,所有信息都放在\Listings\wujique.map
; ~6 @  J: v* S/ }  h. E* d
, n$ h' `- U% F5 g! @% v默认很多编译信息可能没钩,钩上所有信息会增加编译时间。; }$ ?6 Q1 x7 J+ C% X4 E, _" X

+ Z5 N# y/ T4 i7 n: p) q& G
4.png
! M$ A! I* @  c9 `! b

! E* p& x3 |& C8 Bmap文件

/ G. Q; M) ?+ \* h+ q2 `! t打开map文件,好乱?习惯就好。我们抓重点就行了。
% H+ D% V8 T$ C6 B* u9 U  c1 s; _7 R- `) l9 R/ o
5.png 7 J' O3 [9 V: N  j* I

  F1 M; q; T5 Y! o$ ?( f( m: R$ g+ Amap 总信息9 k: }' I+ o: {2 ^' [$ P: r* r
( {( ]7 u% m& _9 X% P+ x/ k3 P$ ]
从最后看起,看到没?最后的这一段map内容,说明了整个程序的基本概况。6 d# c& D6 A4 \5 e/ Y$ s2 M) f
% x1 E8 Z$ t% _7 Y# }* ~) t5 J9 q/ M
有多少RO?RO到底是什么?
& Z8 j! ^3 {* J; J: ^+ x1 L
! a. [0 n2 l6 ?: U* I# A有多少RW?RW又是什么?4 z2 S1 Z; ~# Z6 I
7 M6 G" a. u! y0 B. `
ROM为什么不包括ZI Data?为什么包含RW Data?: C. n. A$ e' H& z$ g
4 @  {1 c, ^- X# W' \! L9 I! A" t1 H& _
6.png 7 E+ u' K! _. }! o, z
Image component sizes
" o" H; g" [% g: j  w' v) J+ f& p' j: E. a! a% z( [* n2 Z5 n( h
往上,看看Image component sizes,这个就比刚刚的总体统计更细了。  ^  M4 j- [! r( j2 J( L
* X; D0 `) r5 [8 N  e, q
这部分内容,说明了每个源文件的概况% O. l9 l2 Y. X3 p8 D0 R
# z/ R3 a: ^8 B
首先,是我们自己的源码,这个程序我们的代码不多,只有main.o,wujique_log.o,和其他一些STM32的库文件。6 k( i. I  u5 W$ r7 p4 s; n
/ d3 H3 [5 W& N; r, F! S& j
7.png
4 X! U& M3 c8 \7 ?: f3 V

  `7 i% u2 b4 f+ k1 _: Y第2部分是库里面的文件,看到没?里面有一个main.o。main函数是不是我们写的main函数?明显不是,我们的main函数是放在main.o文件。这么小的一个工程,用了这么多库,你以前关注过吗?估计没有,除非你曾经将一个原本在1M flash上的程序压缩到能在512K上运行。
+ N& G; m+ H$ K: m' c1 c7 O& t" Y. v9 w( ^- t9 \
8.png

; N8 \4 k8 y" o. G1 W; T" A
6 o4 y5 S5 a$ o6 A, ^3 I
第3部分也是库,暂时没去分析这两个是什么东西。
4 L1 ~* I4 V/ Q
7 Z3 g' ]" n4 o
9.png

6 N6 N+ u' }' p+ @9 x
, r: M$ C8 R9 S: r3 X/ Y
库文件是什么?库文件就是别人已经别写好的代码库。在代码中,我们经常会包含一些头文件,例如:
2 X+ r  d% q/ w) a! }#include <stdarg.h>
9 |4 r8 s; ^1 H: x6 L3 R9 \* i#include <stdlib.h>! s! W" @0 i% ^, T: R) N
#include <string.h>  . B" ^1 f! W- p# Q

: N9 [+ `3 [% e! w
这些就是库的头文件。这些头文件保存在MDK开发工具的安装目录下。我们经常用的库函数有:memcpy、memcmp、strcmp等。只要代码中包含了这些函数,就会链接库文件。
7 ^% `+ r( m% M. T4 r
1 D0 u4 C9 V4 V7 J* K

* w7 l. c) g4 P$ p文件map
2 p: p9 O# u" N. e  S4 O0 S. E- p再往上,就是文件MAP了,也就时每个文件中的代码段(函数)跟变量在ROM跟RAM中的位置。首先是ROM在0x08000000确实放的是startup_stm32f40_41xxx.o中的RESET
% N* ?& Q) V& s8 `& O1 m1 [2 C% j* Z2 K$ w6 p& i
库文件是什么?( z3 P6 [/ y; U; W( D8 A
库文件就是别人已经别写好的代码库。# H6 X* k5 I$ F2 Z, ?, e5 |
% J, z8 |% I5 E0 u% _1 n" ?' Y
在代码中,我们经常会包含一些头文件,例如:
! n5 G9 \! ~( e. B& M. d' Y5 Z7 ?
  1. #include <stdarg.h>
    / j4 V6 w. I+ N$ C) _* J; N. I2 G
  2. #include <stdlib.h>
    $ N- ?- I3 U$ T8 @1 Y9 S* H
  3. #include <string.h>
复制代码

* Z$ B5 U6 v/ i) a8 E; P这些就是库的头文件。相关文章:C语言中的头文件。这些头文件保存在MDK开发工具的安装目录下。' x, w6 H/ Z# d" J! a, ?" a, k
2 L! V  f* ^8 C- N& D
我们经常用的库函数有:memcpy、memcmp、strcmp等。. I, a. _6 `! J; ~) B# v8 e
* t) }- q; B6 c" h' B, \
只要代码中包含了这些函数,就会链接库文件。9 e# a. N0 I  Z" _, E( g

: }. t2 E% o8 t1 z文件map( G  P: P, Q9 v/ w5 j& y' S) g
再往上,就是文件MAP了,也就时每个文件中的代码段(函数)跟变量在ROM跟RAM中的位置。首先是ROM在0x08000000确实放的是startup_stm32f40_41xxx.o中的RESET; M  q0 G3 `1 C

' h5 s0 k: \3 c8 Q8 P
10.png

1 X( A  m! I2 M& E0 H

' b0 `$ l9 ~. S1 ^每个文件有有多行,例如串口,4个函数。& z: v$ g- m/ k+ D
5 l) o1 v7 L4 c8 {/ Z* z7 q
11.png

# J* t' K4 E4 q" f, z0 s

4 C% C- J) L$ _+ \% z然后是RAM的,main.o中的变量,放在0x20000000,总共有0x0000000c,类型是Data、RW。串口有两种变量,data和bss,什么是bss?这两个名称,是section name,也就是段的意思。看前面type和Attr,
- R- r; {' A8 r" h, O9 `" s# Y# C* P& e
RW Data,放在.data段;RW Zero放在.bss段,RW Zero,其实就是ZI。到底哪些变量是RW,哪些是ZI?
: N' z4 o3 ]' ?# E2 M& [
6 Q; V5 Q, M/ L7 L& J
12.png

. s! I! c( U5 s) V* L

  ?# E9 V0 s* H4 w! o; Y6 ?2 l# a! {Image Symbol Table* Q& R+ @$ l# S1 G( Z' Y

  l# d9 c# H* y( d( U: l" B再往上就是Image Symbol Table,就更进一步到每个函数或者变量的信息了) J" J( Z1 F) V- o9 m
# ]; J. G' s7 \' h" V
13.png

9 R, |, ~" {9 C0 l* Q. C, r# @
4 f8 J# g6 W' `6 C8 I例如,全局变量TestTmp1,是Data,4字节,分配的位置是0x20000004。  P& e2 Z) [; }7 }

- H: I& y! B( t( g1 j
15.png
" i5 _7 E0 E" F$ W; N8 s: W
. T; _6 A8 C# U* i
TestTmp3数组放在哪里?放在0X080024E0这个地方,这可是代码区额。因为我们用const修饰了这个全局变量数组,告诉编译器,这个数组是不可以改变的,编译器就将这个数组保存到代码中了。程序中我们经常会使用一些大数组数据,例如字符点阵,通常有几K几十K大,不可能也没必要放到RAM区,整个程序运行过程这些数据都不改变,因此通过const修饰,将其存放到代码区。
6 A. h5 {+ W- v9 w+ C9 ?* {- v+ l! w
const的用处比较多,可以修饰变量,也可以修饰函数。更多用法自行学习
/ W0 M7 D5 U- T# V
% R4 s* a# g: C6 g( J% _% e. z
16.png
/ a+ N6 q  N) Y, p3 Y
# s: G0 j& b% y" K" [& p& `$ C
那局部变量存放在哪里呢?我们找到了test_tmp3,/ ?) O+ Q7 Y  a# z1 }

1 O+ M, u7 ^' H! m5 f% V
17.png

) u+ b4 |/ Z% K; {! p3 D/ |2 @" Y

4 V7 ?9 h& {. F5 _6 n: v没找到test_tmp1/test_tmp2,为什么呢?在定义时,test_tmp3增加了static定义,意思就是静态局部变量,功能上,相当于全局变量,定义在函数内,限制了这个全局变量只能在这个函数内使用。哪test_tmp1、test_tmp2放在哪里呢? 局部变量,在编译链接时,并没有分配空间,只有在运行时,才从栈分配空间。
  1. <blockquote>u8 TestFun(u32 x)//函数,带一个参数,并返回一个u8值
复制代码

( N. n! E* v6 o% t: W# p上一部分,我们留了一个问题,哪些变量是RW,哪些是ZI?我们看看串口变量的情况,UartBuf3放在bss段,其他变量放在.data段。为什么数组就放在bss?bss是英文Block Started by Symbol的简称。! c: z" V4 I: i8 ]* C' e; Z5 B
: g0 H1 j( _# {
18.png
5 |6 n+ [$ B4 T; R$ q( i- d

# |, S9 N) t4 @到这里,我们可解释下面几个概念了:/ `/ \+ ?3 O8 n& X. C* U
Code就是代码,函数。
6 H0 d+ c1 \: ], Q! I: ]RO Data,就是只读变量,例如用const修饰的数组。
3 y) f) z1 s3 b6 qRW Data,就是读写变量,例如全局变量跟static修饰的局部变量。2 k) a1 k1 W: x8 K2 Y7 _2 g. W
ZI Data,就是系统自动初始化为0的读写变量,大部分是数组,放在bss段。; [0 h# j) L9 g0 _
RO Size等于代码加只读变量。
- ?9 d- V- l% _: j8 Z4 RRW Size等于读写变量(包括自动初始化为0的),这个也就是RAM的大小。
+ t7 ?* |  Z2 B0 [; ^/ p1 q$ wROM Size,也就是我们编译之后的目标文件大小,也就是FLASH的大小。但是?为什么会包含RW Data呢?因为所有全局变量都需要一个初始化的值(就算没有真正初始化,系统也会分配一个初始化空间),例如我们定义一个变量u8 i = 8;这样的全局变量,8,这个值,就需要保存在FALSH区。
% q0 K; ]& i! E9 O3 R
, @8 N5 B% @9 s0 O
19.png

; l! W6 H& u8 E+ x8 w2 [; M& y
' s! m- Q, Y5 U2 O# M4 j+ O" V# J9 V
我们看看函数的情况,前面我们不是有一个问题吗?__main和main是一个函数吗?查找main后发现,main是main,放在0x080005798 [/ M7 S5 X( X$ ]
. Y* Y8 B* M& {3 e1 @0 e
20.png

: S& [& u$ o" ]9 c
! f2 r$ a# q  q
main是main,放在0x08000189
+ ]; z/ M2 B, Z. Q+ W* G6 h; i
  S; x) T# D, h6 A- k5 I6 N
21.png
/ f/ |1 p; B9 [% l+ }

1 O. g+ N( L$ V% `" G: w7 T: f__main到main之间发生了什么?还记得分散加载文件中的这句吗?
/ [* e7 B* R2 H  {*(InRoot$$Sections)9 u& s2 y: ?7 U0 f- ^  o" Q
6 H- r  _( w% x/ M. s9 m! K
__main就在这个段内。下图是__main的地址,在0x08000189。__Vectors就是中断向量,放在最开始。
, O0 s; m' H, o% s: y. v0 J/ ~* ^1 v% L/ q# Y2 N
22.png

+ f1 X6 W1 M% H# L' o4 ^2 O/ Z6 _% a1 c0 e1 R* q
在分散加载文件中,紧跟RESET的就是*(InRoot$$Sections)。
' w7 F) O& _6 N$ Y. C
5 F5 S: b+ J7 x2 u. l
23.png

9 y% r) b7 O# L0 H4 ?* z
5 Y, S4 d' ~  d: s: Y8 n( q
而且,RESET段正好大小0x00000188。! c  }7 b& ]0 v2 J# X% p  A
! R5 H( \: {. x9 {2 }/ D
24.png
, M0 m* e9 n) Z$ _1 n
. i' W4 P" K9 K, \+ [
巧合?可以参考PPT文档《ARM嵌入式软件开发.ppt》。7 H% R5 I" R7 w; Q) c

: i8 t' p! A, I/ n- q0 P7 i6 s
25.png

1 M$ E: A% V, {
/ x$ X3 W- |( K9 g9 \9 h& X
这一段代码都完成什么功能呢?主要完成ZI代码的初始化,也就是将一部分RAM初始化为0。其他环境初始化……. g; D6 {: L2 _# q
4 Z) |; ?; d* W
5 Q5 P+ I; }3 f
最后
! M3 f$ y6 P$ G+ I  P到这里,一个程序,是怎么组成的,程序是如何运行的,基本有一个总体印象了。
  z* h6 h7 `+ w" ]2 U4 N4 i$ t0 X0 V' T/ T  `0 U

) m* u5 Z5 Q. n) @) `: ^1 \; Q转载自: [color=var(--weui-LINK)][url=]STM32嵌入式开发[/url]
. R3 a  `" h5 U如有侵权请联系删除
) [  d- B+ h+ }; ]
$ q- Z6 R( Z, I( P* M* @

+ z! o: ]# k/ n( ~# h
赞 收藏 评论0 发布时间:2024-7-29 15:25

举报

0个回答

所属标签

相似技术帖

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