前言
/ _$ _1 o7 ~( Y4 X最近老是遇到使用 KEIL 时需要将部分或者全部程序放到 RAM 中运行的问题。故此花了不少时间搜索资料和几番尝试，现将其总结在本篇文章中，也是为大家以后的工作节省时间罢。本文中会介绍通过 STM32F411Nucleo 的一个例子来介绍几种让程序在 RAM 中运行的方法。在该例子中，通过调用 ToggleLED 函数来翻转 LED2 亮灭。接下来，我们将通过多种方法将这段代码放在 RAM 中运行。

: T, d. {1 C# e$ Q6 [ToggleLED 函数从 Flash 中执行的情况
我们先来看看 ToggleLED 函数从 Flash 中执行的情况。下面是 ToggleLED 函数和它的调用情况。在 main 函数的 while（1）里调用 ToggleLED。
, X3 a/ v  I  z3 o3 v5 n

1. void ToggleLED(void)
   - G, j: w1 q0 n# Z: n' x4 J& X
2. {
   " ?5 T6 \. g$ w
3. HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
   
4. 
   ) K, n5 d  U  R' g3 z$ ], y" V- E2 S
5. /* Insert a 100ms delay */
   
6. HAL_Delay(100);
   % [4 L& d7 R) ?) e* o. ]
7. }

复制代码

1. int main(void)
   
2. {
   1 D+ `1 e3 b7 z+ h9 w
3. ……
   * R. s5 L: {- d
4. 
   & a' @2 m% P+ g& z0 ^- ]
5. /*##-3- Toggle PA05 IO in an infinite loop #################################*/
   - e; d+ g, P+ C
6. while (1)
   2 F5 W4 i$ i) _4 E* i0 W  @, l
7. {
   
8. ToggleLED();
   
9. }
   
10. }

复制代码

& T+ k" H+ h1 o1 _  D- nLinker 的配置为，见下图：
Flash 起始地址：0x08000000
RAM 起始地址：0x20000000
: Q# b4 a( F% j5 M* l. B; `
3 P; H* S# x$ O9 k7 P' w# Z; k
0 w  k  K6 ?( N. }2 |6 G1 [9 D
3 L" ^1 a3 v7 J" h+ c3 F2 p7 C6 X: R编译后从 map 文件可以看到，ToggleLED 以及其中调用到的 HAL_GPIO_TogglePin 和 HAL_Delay 函数的地址都在 FLASH中。
& u" x0 @% D1 ?8 ~) U- x- }) n
6 f3 Z2 u( N6 p% |6 `$ ?' _* s+ l" h

1 F% F' ^; K1 N+ S6 u2 v; W! z将翻转 LED 的程序放到 SRAM 中执行
8 D7 s% G- f- {6 Y- u! Z2 v. J! z5 [6 b方法一：通过#pragma arm section code = “RAMCODE ”和#pragma arm section。参考 Example1 代码。
/ v+ J; d) @: c( Y) [/ g这种方式，可以同时将多个函数放到指定的 section。具体方法如下：
- Z$ q# G% _& c, W1. 修改.sct 文件，自定义一个叫做 RAMCODE 的 section，放在 RW_IRAM1 执行区域，地址范围 0x20000000~0x20020000。
1 O9 M" K8 t8 L( |4 V

1.    LR_IROM1 0x08000000 0x00080000 { ; load region size_region
   
2.    ER_IROM1 0x08000000 0x00080000 { ; load address = execution address
   2 k8 C' s  e: k! x/ t! s1 }' O
3.    *.o (RESET, +First)
   
4.    *(InRoot$Sections)
   
5.    .ANY (+RO)
   . I9 z5 X4 J& Z
6.    }
   
7.    RW_IRAM1 0x20000000 0x00020000 { ; RW data
   
8.    *.o(RAMCODE)
   6 w8 z& ]$ z2 g  O2 N8 H
9.    .ANY (+RW +ZI)
   
10.    }
    
11.    }

复制代码

$ _% w2 o9 J$ z4 t; `2. 在工程中使用前面修改的.sct 文件
: F5 A: j1 m: \( n6 Z  F
% c: D  B1 g. `& J2 `- r

   3.以#pragma arm section code = “RAMCODE” 开头，以#pragma arm section 结尾。将所有需要放到 RAMCODE section 的函数包括进来。编译时，编译器会自动将这些函数放到 RAMCODE 所在 0x20000000 开始的区域。
6 c: q- Z- B/ {- T1 r5 q( v

1. #pragma arm section code = "RAMCODE"
   
2. void ToggleLED(void)
   
3. {
   
4. HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
   4 [, R3 N: f! s/ [& _' |4 Y/ R
5. 
   # n. s* {, B* |% Z
6. /* Insert a 100ms delay */
   1 L* I' E0 p# ^- @# l, ~  c; F
7. HAL_Delay(100);
   : a: f; D/ g) A% g: n$ k, n
8. }
     e  X# v  L& j" ]5 B. |
9. void HAL_GPIO_TogglePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
   6 |0 G6 p* r2 M1 o; j# f* g
10. {
    9 \8 ~$ s+ ]; o7 }% [! W
11. /* Check the parameters */
    4 D0 Y, {/ M/ p8 |
12. assert_param(IS_GPIO_PIN(GPIO_Pin));
    ( s+ q" d7 [8 W
13. GPIOx->ODR ^= GPIO_Pin;
    
14. }
    ! {) Z2 k& x$ \. W  }1 h; N- ]/ V
15. uint32_t HAL_GetTick(void)
    
16. {
    
17. return tick;
    : M% w" y' e  O6 v
18. }
    % P( ?0 `& `' Z, a7 ^$ M% a9 v
19. void HAL_Delay(__IO uint32_t Delay)
    2 L  O$ I! d2 ]# S' w
20. {
    
21. uint32_t tickstart = 0;
    
22. tickstart = HAL_GetTick();
    
23. while((HAL_GetTick() - tickstart) < Delay)
    
24. {
    
25. }
    
26. }
    
27. #pragma arm section

复制代码

( Q9 l0 w  d: k8 A" I5 E4.从 map 文件里，可以看到这四个函数都已经被放到了 SRAM 中。



方法二：通过__attribute__((section(“name ”)))
在 KEIL 中可以通过__attribute__((at(address)))的方式将变量放到指定的位置。
通过__attribute__((section(“name ”)))的方式将变量或者函数放到指定的位置。
下面我们来看看如何通过这种方式将程序放到 SRAM 中执行。可以参考 Example2 的代码。
& ?8 \+ S3 b# W& @2 p6 v1.同样，我们需要修改.sct 文件，自定义一个叫做 RAMCODE 的 section，并在工程选项的 linker 页面中，选择定义好的.sct文件。（见方法一中的第 1，2 步）

1. LR_IROM1 0x08000000 0x00080000 { ; load region size_region
   / U, {8 E" s9 l) F1 h
2. ER_IROM1 0x08000000 0x00080000 { ; load address = execution address
   1 K8 F& R1 F+ W5 G2 P
3. *.o (RESET, +First)
   $ c* q; E) g5 w. t/ x
4. *(InRoot$Sections)
   
5. .ANY (+RO)
   ( V7 S2 L1 z  n8 b8 }: y
6. }
   
7. RW_IRAM1 0x20000000 0x00020000 { ; RW data
   
8. *.o(RAMCODE)
   ) ?, o* f7 A- B. Q3 f
9. .ANY (+RW +ZI)
   
10. }
    & ^. e7 N& |) Y. u3 Q7 b% ?
11. }

复制代码

  y3 t# a, L4 J2.在需要放到 RAM 中的函数前，用__attribute__((section("RAMCODE")))声明该函数放在 RAMCODE section 中。注意，该函数中调用到的所有函数也要放到 RAMCODE section 中。
4 h6 O) ^. Z6 H& U' q

1. __attribute__((section("RAMCODE")))
   . U0 v$ Z0 V( w0 t* m: S
2. void ToggleLED(void)
   6 f3 ]) [1 W, x  U, E3 w
3. {
   , m' K6 E: \5 v! Y% {/ M5 m$ _& v! v
4. HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
     y( V. W$ |' c: j2 X7 M
5. 
   
6. /* Insert a 100ms delay */
   2 N/ P+ }1 O; h: E0 h# r- s
7. HAL_Delay(100);
   
8. }

复制代码

1. __attribute__((section("RAMCODE")))
   
2. void HAL_GPIO_TogglePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
   
3. {
   
4. /* Check the parameters */
   
5. assert_param(IS_GPIO_PIN(GPIO_Pin));
   1 u4 N- r! n* m4 [! L2 `
6. GPIOx->ODR ^= GPIO_Pin;
   
7. }
   
8. __attribute__((section("RAMCODE")))
   1 r9 ~  d* Y" H8 s. ]
9. __weak uint32_t HAL_GetTick(void)
   ; d7 i& \) M: e. S4 M( K' t
10. {
    
11. return uwTick;
    $ P. S9 R, j! ]4 U+ g* [
12. }
    
13. __attribute__((section("RAMCODE")))
    
14. __weak void HAL_Delay(__IO uint32_t Delay)
    
15. {
      Q3 j3 ^9 d+ @# B
16. uint32_t tickstart = 0;
    
17. tickstart = HAL_GetTick();
    $ G  i' D; e2 |& k: N' t) i- j
18. while((HAL_GetTick() - tickstart) < Delay)
    
19. {
    
20. }
    9 M' f7 b1 l$ S8 n/ s- f/ V
21. }

复制代码

3.从编译后的 map 文件可以看出，ToggleLED 以及它调用到的所有函数都被到了 RAM 中。
8 O, e( B4 }5 t: k

% [. `1 Q3 U! ?) U/ X8 S, ^! l( c方法二可以覆盖方法一，也就是说如果你同时用方法一和方法二对同一个函数的执行区域做了说明。最终起作用的是方法二。我们可以通过 Example3 来说明
+ D9 c  b* S8 I" h# G/ ~. ]( N$ o1.修改.sct 文件。将 SRAM 分为两个执行区 RW_IRAM1 和 RW_IRAM2。Section RAMCODE1，RAMCODE2 分别位于
0x20000000 开始，和 0x20010000 开始的两个 64KB 的区域。

1. LR_IROM1 0x08000000 0x00080000 { ; load region size_region
   
2. ER_IROM1 0x08000000 0x00080000 { ; load address = execution address
   
3. *.o (RESET, +First)
   ' ?% `/ ~, U% k+ t' {8 L+ o, w
4. *(InRoot$Sections)
   
5. .ANY (+RO)
   
6. }
   0 x/ V* Z+ p# Z1 C
7. RW_IRAM1 0x20000000 0x00010000 { ; RW data
   1 y( D, u* r6 j# `1 g- Y, R$ b
8. *.o(RAMCODE1)
   
9. .ANY (+RW +ZI)
   
10. }
    
11. RW_IRAM2 0x20010000 0x00010000 {
    
12. *.o(RAMCODE2)
    
13. }
    * [- \2 ?1 f3 e: u7 I% D- f0 a
14. }

复制代码

2.在代码中, HAL_GetTick 被放在了#pragma 的作用域内被声明放在 RAMCODE1 section，同时又用__attribute__( ( section( "RAMCODE2" ) ) ) 将其放在 RAMCODE2 的 section 内。

1. #pragma arm section code = "RAMCODE1"
     X- j# j; {# e; Y6 B* W5 l
2. void ToggleLED(void)
   
3. {
   9 N# @& y: g" h( {& i* g
4. HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
   # U) b) C: H. }
5. 
   
6. /* Insert a 100ms delay */
   
7. HAL_Delay(100);
   , j6 y0 y! s. K, ]
8. }
   
9. void HAL_GPIO_TogglePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
   + q/ u' _2 s8 w+ f& X
10. {
    + b! R/ c% p8 F& G# c
11. /* Check the parameters */
    
12. assert_param(IS_GPIO_PIN(GPIO_Pin));
    
13. GPIOx->ODR ^= GPIO_Pin;
    ' F$ \; O. a9 j
14. }
    
15. __attribute__( ( section ( "RAMCODE2" ) ) )
    4 n' X9 a( b) ~; h
16. uint32_t HAL_GetTick(void)
    , P, b9 ]( M+ ^1 D, P# t) b: Z
17. {
    : H3 Q( L: @  n$ o! u9 X
18. return tick;
    
19. }
    
20. void HAL_Delay(__IO uint32_t Delay)
    ' v$ b5 g. @# E( G9 T* I" X! ?3 P
21. {
    - ?# r1 [! {6 G$ V/ {7 Q) {
22. uint32_t tickstart = 0;
    
23. tickstart = HAL_GetTick();
    
24. while((HAL_GetTick() - tickstart) < Delay)
    
25. {
    ' S7 E' n* d/ `2 B3 C
26. }
    8 e" i. H7 u; {
27. }
    
28. #pragma arm section

复制代码

3.编译完成后，我们再看看 map 文件中 HAL_GetTick 到底被放到了哪个 section。
. y, x) }# L( C& `/ _, f

! d+ N/ C3 m+ e: `2 p0 P
从 map 里可以看到，最终 HAL_GetTick 被放在了 RAMCODE2 section 中。

- E' J& {% L5 I" Q* `: x4 H将整个程序放到 SRAM 中执行
4 {% Z$ S# F& C" v! d) p前面我们介绍了将一个或多个程序放到指定地址执行的方法。如果需要放到指定地址的程序比较多，我们还可以将这些需要放到指定地址的程序集中放到一个或几个 C 文件中，然后在.sct 文件中将这些 C 文件生成的目标文件放到指定地址。
在这里，我们将尝试将整个程序放到 SRAM 中执行。复位后程序从 FLASH 启动，之后将从 SRAM 执行所有的程序。下面是具体的步骤。可以参考 Example4 的代码。
1.将中断向量表和中断处理程序放到 SRAM 中
; c( R: S" S- d. i* w0 p( Q 新建一个 startup_stm32f411xe_ram.s 文件，放到 0x20000000 开始的位置（在.sct 文件中修改）。注意这里是新建，而不是直接将原来的文件放到 SRAM 中，为什么呢？大家可以思考一下。在 startup_stm32f411xe_ram.s 里定义新的 SECTION，叫做 RESET_ram（还有其他的修改，请对照参考代码）。在后面的.sct 中将把 RESET_ram 这个 section 放到 SRAM 开始的位置上（见第 3 步）。
: p: u0 C6 m0 P: P6 m; l

1. ; Vector Table Mapped to Address 0 at Reset
   
2. AREA RESET_ram, DATA, READONLY
   
3. EXPORT __Vectors_ram
   
4. EXPORT __Vectors_End_ram
   2 I" G" u5 x. U) V& a
5. EXPORT __Vectors_Size_ram
   
6. __Vectors_ram DCD 0 ; Top of Stack
   - Z/ [/ ]8 S$ I3 z' D
7. DCD 0 ; Reset Handler
   
8. DCD NMI_Handler ; NMI Handler
   , Q8 n2 [4 r7 ~
9. ……

复制代码

7 z- V  B" [! e; W2.在 SystemInit 中将中断向量表的偏移地址设置为 0x20000000。使能 VECT_TAB_SRAM。

1. #ifdef VECT_TAB_SRAM
   
2. SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal SRAM */
   4 {5 P, ]: q$ n1 K" s5 ^' h( K
3. #else
   
4. SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal FLASH
   
5. */
   
6. #endif

复制代码

3.修改.sct 文件，将运行时需要的所有目标文件都放到 SRAM 执行区中。这里中断向量表有同样的两份，一份在 0x08000000开始的位置，一份在 0x20000000 开始的位置。

1. LR_IROM1 0x08000000 0x00080000 { ; load region size_region
   
2. ER_IROM1 0x08000000 0x00080000 { ; load address = execution address
   
3. *.o (RESET, +First)
   ! B1 A0 S$ a2 e& `  ^
4. *(InRoot$Sections)
   
5. .ANY (+RO)
   
6. }
   
7. RW_IRAM1 0x20000000 0x00020000 { ; RW data
   4 s* T. Q" c4 ~' K' ^2 `) j
8. *.o (RESET_ram, +First)
   
9. startup_stm32f411xe_ram.o(+RO)
   - r  @* |/ ?2 n* A
10. main.o(+RO +RW)
    
11. stm32f4xx_it.o(+RO +RW)
    + t% l+ a) [3 q
12. stm32f4xx_hal.o(+RO +RW)
    7 y: {& K6 c- x7 E) J) A
13. stm32f4xx_hal_gpio.o(+RO +RW)
    
14. stm32f4xx_hal_rcc.o(+RO +RW)
    
15. stm32f4xx_hal_cortex.o(+RO +RW)
    
16. .ANY (+RW +ZI)
    / N8 n9 M2 L$ Q8 Q$ z" [
17. }
    
18. }

复制代码

4. 编译完成后，从 map 文件或者跟踪调试的结果都可以看到。系统复位以后，从 main 函数开始，所有的程序都在 RAM 中运行了。
另外，如果你的程序中有用到 ARM 底层的库，可以在.sct 文件中加入*armlib*(+RO)来将所有用到的库文件放到 SRAM 中。


8 F+ O1 W4 t2 c
% H- Z8 }1 K( p


2 ]2 d4 N3 T8 H1 M1 g* E' y! x: d5 h
' T* k4 d0 B$ ^* F



  C; W" W. ]/ {0 L# L; `7 W
4 G4 i* U* n4 r( G3 r/ K& }
( a# m& j! I- Z0 M) v! u+ a