27.1 初学者重要提示
  o+ A1 I- b3 M7 b  学习本章节前，务必优先学习了解TCM，SRAM等五块内存区的基础知识，比较重要。
( O- D( e& g: @( N, s7 c  将RTX5系统的动态内存管理整理了出来，可以同时管理多个分区。如果其它RTOS中使用，记得做互斥保护或者加个调度锁均可。
  支持动态内存使用情况统计。
5 t) C; N! [$ s( S27.2 动态内存管理移植
6 Z0 l/ M/ Z9 y: L, [移植比较简单，仅需添加两个文件到工程即可。

27.2.1 MDK版的移植
  第1步，添加如下两个文件到MDK中
1 ?/ h9 o5 j4 p" r注，以本章配套例子为例，这两个文件的路径\User\malloc。
! T, @/ k1 r) q2 y+ m2 A
# J  G0 X: u) @) ?

  第2步，添加路径。
. T8 }3 a. V* u6 A% h

  第3步，添加头文件。
" {0 J$ a9 Z/ w1 S: Y/ f9 E如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。

3 l: x  J$ K* D; t+ Z( z通过这简单的三步就完成了MDK的移植。

, h% `* M; w, |' s) Q6 }" @27.2.2 IAR版的移植
  第1步，添加如下两个文件到IAR中
& n( W) Y8 ^* G6 d注，以本章配套例子为例，这两个文件的路径\User\malloc。
: j" z9 ]+ ^. D: ?" p- o! ?7 F2 V# L

7 ?# n( o; E+ Y/ ~& A% ]
  第2步，添加路径。

3 T5 D" v/ E9 a4 U+ k0 Y  第3步，添加头文件。
4 q$ e" h* ]! W0 U2 c如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。
& U; o2 [, ~5 D. F3 _% A
通过这简单的三步就完成了IAR的移植。
7 ^+ X$ k, a& a  b4 Q/ I2 g
2 E8 _2 F* \3 J/ u8 R  E! Y27.3 动态内存的使用方法
下面分别以MDK和IAR为例进行说明：

; T% \7 z& H3 T6 z9 a; h6 I. N27.3.1 MDK上的动态内存用法
, u' |: Q% H& w2 m" D4 u5 I  定义动态内存区
比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：

1. /* DTCM, 64KB */
   $ q# O; k; U/ f  N& |- ^3 C
2. /* 用于获取当前使用的空间大小 */
   , E4 ?- O+ ?/ Q" M$ A9 G9 X- _
3. mem_head_t *DTCMUsed;
   
4. /* 定义为64位变量，首地址是8字节对齐 */            
   1 {" q: V6 [5 v' D+ z
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

7 @5 _* ^7 A* N如果要使用AXI SRAM作为动态内存空间，可以使用__attribute__((at( )))指定地址。

8 {' Z. y* A9 [, w/ h' x1 `5 F+ R9 h

1. /* D1域, AXI SRAM, 512KB */
   
2. /* 用于获取当前使用的空间大小 */
   $ L. m# v# q; E
3. mem_head_t *AXISRAMUsed;  
   ' K9 p3 K' m, e. s/ ^3 ~% @
4. /* 定义为64位变量，首地址是8字节对齐 */
   8 J8 X) T4 X# ?" Q
5. uint64_t AppMallocAXISRAM[512*1024/8]__attribute__((at(0x24000000)));

复制代码

  初始化动态内存区
调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：
6 K$ v# r8 x% |# A+ O
5 |* {" o+ X( m/ p, u5 H2 sosRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
( R" c6 E; T0 b; D3 }osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
, J: D7 G2 o5 D. ^* I$ _: U6 j
* Z( _4 ?9 }: f9 S! A- |0 N  申请动态内存
通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。

第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。

第2个参数填写申请的字节大小，单位字节。
! Q/ l# p. \: F* r; G: E3 T' j
4 L( j' x3 i9 B- o# p+ X第3个参数固定填0即可。

返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！
- Y4 j$ N5 ~( R
1 E+ J( ]1 e* q1 f. b举个例子：

4 h: R+ O4 ~6 m2 [; Y; H

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   
2. 
   + i8 k1 ?5 I  z1 e) E
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   9 ]  g9 r' Y7 y+ f" C4 ~% i
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   & U; I4 Q: r! P- b2 @; Z6 I) K
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   
7.                                                              DTCMUsed->size, DTCMUsed->used);
   $ [# f4 o! _1 E# b" |
8. 
   % A% [" J, K) \# B* b
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    2 G# G* V* x1 t
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

: q5 O# n' |8 d申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。

  释放动态内存
) }  ]: U5 E3 e3 L) D# l通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。
- Z; `, j; w( I6 P  A
第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。
( J2 B, ^$ V$ y/ H; V6 S% j! A
第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。
3 D) z7 T: Z! s6 X; j8 M8 [  c
返回值，返回1表示成功，返回0表示失败。
/ q2 T: {5 Q1 v+ v( Z
举个例子：
: H4 U0 p+ x: P/ U8 _7 _1 g- v& S

1. /* 释放从DTCM申请的280字节空间 */
   # h5 L8 x# \7 V& w5 v
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   4 Y' ~5 ~+ V  V$ g' Z3 c0 z' S+ z
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   8 M' a- U' Y1 N2 \" W8 L
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   % Z$ P) n" `2 ]6 e6 a1 K  R% ]
5. 
   / ^) D( g5 j6 ]1 i+ O% d
6. /* 释放从AXI SRAM申请的160字节空间 */
   ( l! I- ?$ v- n2 I! |% m
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   / K8 J! P8 z: @
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used);

复制代码

1 X. R/ W+ [+ C: @' p" R, w27.3.2 IAR上的动态内存用法
注：IAR使用这个动态内存管理，仅在定义时跟MDK略有不同，其它地方是一样的。

0 t+ w% D# M% p$ u8 w+ r  定义动态内存区
比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：
( c) E- m- ]! r! x
* R% {/ q- O% R. h5 D/ g1 F- S) V* _

1. /* DTCM, 64KB */
   
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *DTCMUsed;
   ! N+ ]! j; Z9 ?
4. /* 定义为64位变量，首地址是8字节对齐 */            
   ! X+ x: U. F; G/ }0 ]6 `! U
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

如果要使用AXI SRAM作为动态内存空间，可以使用__attribute__((at( )))指定地址。

1. /* D1域, AXI SRAM, 512KB */
   
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *AXISRAMUsed;  
   % C7 F0 G7 }& V/ u
4. /* 指定下面数组的地址为0x24000000 */
   
5. #pragma location = 0x24000000
   
6. uint64_t AppMallocAXISRAM[512*1024/8];

复制代码

  初始化动态内存区
3 @( w0 g) I0 L  e/ A+ _' \调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：

0 `$ N, v' c) F7 M: k) R) q/ ^5 y

1. osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
   : j- g# U" h* @  Q
2. osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

复制代码

  申请动态内存
通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。
# y* r0 r( a" o9 m% t' r
+ S& a* J4 K% H1 }1 h2 y第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。

第2个参数填写申请的字节大小，单位字节。
4 v* m) H- i6 u- Y* w7 @/ y
第3个参数固定填0即可。

" P; b$ e9 u. E% X返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！
; ?8 i, @' l2 E$ A
) \" K; M# n) c7 h8 W, j0 j+ a举个例子：
. J4 I& y& G& q, z1 T
0 l3 R7 z9 T6 M* @" j

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   
2. 
   . j( }0 m" e! h8 P. R" y
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   % m1 C' V" o* e9 C$ e% b, K
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   : O% j* Q+ f- U+ v1 z* ~
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   / D& L0 o, {% J2 m+ @7 A: n
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   ! u; V; o8 H$ S6 w+ K) q/ @
7.                                                              DTCMUsed->size, DTCMUsed->used);
   
8. 
   - e( U" L! p0 ]7 M/ n9 l* b  |( s
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   ! ]( c" N+ B% K0 b7 }
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    ) M( a/ H, v2 f
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    # }: I$ m# k+ L# n7 G
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。
4 M7 ~- n$ B, ~) a
  释放动态内存
% C4 r, G0 @: b' L/ T% b通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。

第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。

3 f. Q6 y) N& J第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。

1 l9 W& G$ Y3 h# b返回值，返回1表示成功，返回0表示失败。
, f7 v& J4 Q3 f( P( W5 S4 R
举个例子：
) T! f7 x  A  }: @6 |+ C0 `

1. /* 释放从DTCM申请的280字节空间 */
   
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   , t3 s8 {0 b0 t- A# k' N2 u' k
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   
5. 
   & C; i7 \4 E& D( S+ b6 A6 Y: T
6. /* 释放从AXI SRAM申请的160字节空间 */
   
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   3 y$ K& p" z1 v1 w
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used)

复制代码

27.4 实验例程说明（MDK）
配套例子：
) C- j1 l  F* d# @, uV7-006_TCM，SRAM等五块内存的动态内存分配实现

) T8 z! R+ y% p) I- a6 q: P$ R实验目的：
9 d2 _8 g: E* e1 G& |学习TCM，SRAM等五块内存的动态内存分配实现。

2 o2 Q. D) H. u' o5 @. }- _% n
实验内容
5 K# l' `( g% n0 I$ `* Q启动自动重装软件定时器0，每100ms翻转一次LED2。
- i# I8 M4 l; ~& u9 a: L

实验操作：
K1键按下，从DTCM依次申请280字节，64字节和6111字节。
K1键松开，释放从DTCM申请的空间。
K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
! a6 Q, n5 l0 sK2键松开，释放从AXI SRAM申请的空间。
K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
9 ^) P# @/ d( R, LK3键松开，释放从D2域SRAM申请的空间。
6 @( _( Q; q& G, @& {) l  S: n9 f摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
9 v4 o; k7 U$ P0 r6 c摇杆OK键松开，释放从D3域SRAM申请的空间。

6 o' c" b6 q2 h, j) K
8 a0 Z' O1 K4 M4 P* k- y* v; A% Y2 |上电后串口打印的信息：
: l7 N. o1 H) X  n3 U+ n5 H/ J
0 a) y  S3 i( F" S1 z波特率 115200，数据位 8，奇偶校验位无，停止位 1

5 D7 p! q& `& v) [0 Q

* I+ T- R0 Q1 g/ H, N
7 @! n4 |- L; s; ]1 F程序设计：

  系统栈大小分配：
5 ?, a; n7 h$ x+ I6 N' `
* c# e, `3 w, ?3 Z+ M

RAM空间用的DTCM：

- b8 E2 J* |% ^4 ]

  硬件外设初始化
3 x4 z4 p" i. t
9 r- u; t8 F! z! h, {! V8 A硬件外设的初始化是在 bsp.c 文件实现：

3 Q, V( P( e$ X( ^, M# X# P

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   4 C9 F8 Y3 d( [. k0 y
8. */
   
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    & A* o1 @8 ?7 o( f( @
13.         
    & T" e7 b4 K% h) b% h* Y' [  X
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    9 Z( l! f1 C! w
16. 
    
17.         /*
    ( C2 [+ D2 b8 Y
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    / t- w$ ?# |3 K: u* M
21.          */
    " m# B9 p4 C4 g" X$ E
22.         HAL_Init();
    6 B9 d9 J; J3 w( \6 Y6 K4 Q
23. 
    
24.         /*
    9 s6 {$ a, o  o* Z$ y+ [
25.        配置系统时钟到400MHz
      J( q( R" Z* x1 {5 S0 C) m* k
26.        - 切换使用HSE。
    6 T. a6 b$ w; Q4 m% N
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    ! |- J& M$ O, z3 d. A& l
28.     */
    
29.         SystemClock_Config();
    
30. 
    
31.         /*
    6 t* q# [( t6 b9 Z! g. X
32.            Event Recorder：
    2 W; d3 G2 b; [2 M* K
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
      g% F2 V) C5 {: W! m( I5 L; i
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    6 n( M- M. @. C) j/ e; ]% ]/ |! [) a
36. #if Enable_EventRecorder == 1  
    0 t/ B- n3 `" Z* T! B0 b
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    5 b! {6 j/ G6 J. u0 A. @& y8 S
39.         EventRecorderStart();
    ; |" ]6 J( f7 R5 Z2 N
40. #endif
    , Y; C* e5 i* l) l4 q3 z0 I# K
41.         
    7 Y( O* m1 [& H, J; o& u' F  B! H+ g
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    6 s$ u8 _  o! ~6 N9 ?
44.         bsp_InitUart();        /* 初始化串口 */
    1 N5 V6 [& D  c/ n
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    * w( U" I, M4 b7 Q- e
46.         bsp_InitLed();            /* 初始化LED */        
    3 r! k* G. W6 ~( {% K7 y
47. }

复制代码

  MPU配置和Cache配置：
5 e8 {: m# i* S3 I. x数据Cache和指令Cache都开启。
, _: G) G' u5 l- t8 y
2 Z5 T6 i3 F  r/ @AXI SRAM的MPU属性：
) B0 v0 y, w8 o
Write back, Read allocate，Write allocate。

FMC的扩展IO的MPU属性：

6 |% f$ b. _! T) W( r: x7 x& G必须Device或者Strongly Ordered。
* X2 u) G! F6 b% l) H
D2 SRAM1，SRAM2和SRAM3的MPU属性：
; \7 W  Z5 {8 b4 A6 u
Write through, read allocate，no write allocate。
, W2 m' g8 c% J$ G7 B
D3 SRAM4的MPU属性：

Write through, read allocate，no write allocate。
* e6 r7 J* ?" ]/ C# Q& p2 ~% }: D- \

1. /*
   * p/ F- S0 s  S4 I  y
2. *********************************************************************************************************
   3 Z: z7 E: |/ w) R# a! c6 r
3. *        函 数 名: MPU_Config
   2 t; u% W: V  R1 K) C
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   1 e1 d  G8 o( z* Q
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   1 s0 U4 O& {  O8 k8 n; K1 X$ v
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    & y: X; q. I3 s! \+ l
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    : ~" j/ \2 F& D' D- ?& Y9 I
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    8 _- Q" d% A. h' T. _7 j  }
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    * ?* y. @- y" y1 R; N% O
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    4 b- S6 F2 I( P6 q# i
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    3 b( t8 h8 ~( D1 e" A: g+ ?
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    ( d6 }/ t$ K2 m
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    * n# K9 |' I& v1 |0 B, E! D
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    0 Y& q6 c; h8 a  h  J
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    ! A' Q' h- L& b1 o' T
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    1 y; D/ u* L- Z/ s9 Q! P8 C! m5 j1 ^( I
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    ; V; R. Q. w! U. [0 [7 m5 S
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    3 \" u8 E0 T1 m. g3 }, ~
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    9 w1 a. J; Z, r  M5 W8 T1 B5 ?7 c
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    + Q7 W- A7 j6 O4 b+ l  Q
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    7 \7 a' D4 @5 l6 J/ F( K
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    2 g5 f1 {0 Q8 I( Y) Q; s' m) Y
44.         
    ( u6 F/ f. m. v$ q8 Q& r. C+ Y
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    6 ~' d' E+ ]) S& Z$ ~% `( [/ H
46.         
    2 s$ P# ^# t& o4 I+ ]% Y
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    1 U7 o9 v8 q% }. i# T
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    0 s. i# d) X% `6 G8 r! V9 Q2 C
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    $ E' H: Z/ N2 [, O
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    " I2 V' Y  m: c( w. {. T$ g
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    & E9 D- C; |" e
61.         
    ! C% \$ L, l" _
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    , @3 f  @# N1 E- ]# o
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    3 p$ H, |$ O8 |% L9 S/ Q$ S
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    3 _# f. `) r2 g# d: E
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    3 N# C5 o$ k7 b  |- E+ w
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    " o0 ]4 v/ U8 U4 ]& o# U
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
      |: g$ V) K" f7 T( q% L
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    % Z7 W6 r3 O9 z* o4 w
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    + x) {4 x1 z+ Q6 u* A; {! \
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
74. 
    . N. m/ ^( k# D* E. G% v: i
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    1 J: \5 Q. x* F
76. 
    $ n1 t* {, H0 Q, m
77. 
    
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    1 E" a4 J) a7 B8 i) @7 p4 D" t
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    + Y: z) ^7 i7 g4 x, Z8 P9 y6 T3 [
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    9 M  @  \# n6 _9 g$ H
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    6 M* C+ O5 S; ^4 i7 l9 W  t% L0 K! ?
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ( c2 _" v" w3 f
90. 
    
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ' e# a" S  }6 o
92.         
    : P$ o6 N) {; J5 f" i  m
93.         
    " z) Z. h0 t4 ?+ I
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    ) X% N2 O$ @+ d
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    + ]% \6 U3 i8 X9 {
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    $ @# V( o: Y2 Y/ V) X
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     # ~$ a* x: B: j
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
       V/ H& L9 r* m, o
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     ' }/ ?+ r4 a7 ~" U
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     # P$ f) @& g' u. \" Z6 q5 J3 K6 ^
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     9 P% h3 ^5 `7 q& x: V1 ~8 ]9 }
106. 
     0 O* N- z: C9 o  l
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     ( }5 J! r& W7 w! t3 R
108.         
     
109.         /*使能 MPU */
     / k% @, P5 Y0 f) u5 G
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     : Q  @" h7 ]2 Z5 t- D
111. }
     
112. 
     & m2 e6 r# q6 c$ X% X2 |
113. /*
     
114. *********************************************************************************************************
     $ w: B2 b" E( U
115. *        函 数 名: CPU_CACHE_Enable
     
116. *        功能说明: 使能L1 Cache
     ) ]! i# e4 ~0 A# G; K9 ?, Y
117. *        形    参: 无
     
118. *        返 回 值: 无
     3 Y) z( f- E( E8 E
119. *********************************************************************************************************
     
120. */
     
121. static void CPU_CACHE_Enable(void)
     0 B' ?0 d$ X+ ^( ?# p2 x  L! |( o
122. {
     & p5 [) J) j- O4 j( s+ a: [7 h
123.         /* 使能 I-Cache */
       j6 j4 }: B- w4 F$ U) w
124.         SCB_EnableICache();
     + K0 H0 ?! V  k) _' z
125. 
     
126.         /* 使能 D-Cache */
     7 d' q8 N- a; k- |" E/ ^
127.         SCB_EnableDCache();
     
128. }

复制代码

  主功能：

/ C0 w% u7 x2 \! A' X主程序实现如下操作：
0 d9 z  X! c$ y& [& Q1 @4 H* Y8 E
  启动自动重装软件定时器0，每100ms翻转一次LED2。
$ Q) g; w3 B' h2 h$ Z5 X  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
  K1键松开，释放从DTCM申请的空间。
3 R" X/ O: B/ d4 Z# H  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
/ z$ w3 g/ e  u& a  K2键松开，释放从AXI SRAM申请的空间。
3 F2 G5 T4 x/ T7 m8 y) g  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
. K( @5 ^. ~0 _/ K2 g' T  F  K3键松开，释放从D2域SRAM申请的空间。
  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   
2. *********************************************************************************************************
     [0 b, }- U8 L
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   + z- r# O4 d& r  K3 Z
8. */
   
9. int main(void)
   ( x. l3 P9 o; x/ _0 J: r
10. {
    # R, W$ t$ i4 C; n  }
11.         uint8_t ucKeyCode;                /* 按键代码 */
    + A. G& L, G# u- F- h' e
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    
13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
    " j2 A( g( _: l- \
14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
    
15. 
    
16. 
    
17.         bsp_Init();                /* 硬件初始化 */
    
18.         
    1 J+ m" [3 Q6 H% J1 ~. R! f
19.         /* 初始化动态内存空间 */
    - a* P! S! L9 v3 W# k. ^7 [; p$ v
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    6 o) f* @, T5 c% Z7 L1 ~% i# i8 P
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    ( w5 T9 X  \8 l0 W9 L8 c
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    5 x0 y3 r$ F% M6 a2 h
24.         
    
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    . `1 i; Y7 `# _' F7 Q
26.         PrintfHelp();        /* 打印操作提示 */
    
27. 
    " P7 u4 ^9 I  s
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
29.         
    
30. 
    ; \5 `' t, s6 ^5 w" h( K$ I5 ?
31.         /* 进入主程序循环体 */
    5 v) s# ^2 k* ]2 R8 r0 n+ p
32.         while (1)
    0 E2 J* Y" n" s  r/ X" @
33.         {
    4 L, t( N6 p) f- Y0 v* \
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
35. 
    
36.                 /* 判断定时器超时时间 */
    
37.                 if (bsp_CheckTimer(0))        
    2 q/ ^$ K0 Y: b7 [. O0 q9 A
38.                 {
    
39.                         /* 每隔100ms 进来一次 */  
    ( K  W1 S. A$ C- X3 P
40.                         bsp_LedToggle(2);
    / T6 g/ c, {" y  Z3 y5 N+ _
41.                 }
    7 A' X5 A3 q6 ]& l& e
42. 
    
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    ; B. I, }1 M* N
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    " J7 c# ?+ d( h$ K: _
45.                 if (ucKeyCode != KEY_NONE)
    
46.                 {
    : Q& C7 @% q. _3 k+ A  U' m
47.                         switch (ucKeyCode)
      z# d. |3 C; S
48.                         {
    
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    
50.                                 case KEY_DOWN_K1:        
    
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    ) _. I8 k% q: g0 u7 |. V9 p: w4 L! d$ }
52.                                         printf("=========================================================\r\n");
    
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    8 W/ {6 U% a4 C; Q
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    3 ?- K& h$ H. v9 X  M, \/ H
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
57.                                 
    
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    4 F9 ^8 ~7 h+ Q
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    % `  d! |4 ^" G7 R
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    9 E2 y8 p4 J6 E
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    
63.                                 
    
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    & j: Y: V6 [/ y" p2 H
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    # j& d% d3 e1 O  U) J% s1 D
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    - W, q$ Y5 x, Z. k; P- Q
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
69.                                         break;
    
70.                                 
    
71.                                 /* 释放从DTCM申请的空间 */
    ' Q4 U( |" U2 Z; A2 O, G5 p6 \
72.                                 case KEY_UP_K1:        
    
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    2 W5 h* m- g4 J
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
      |" _  h; V; ~0 U8 _4 s3 }
77. DTCMUsed->used);
    
78.                                 
    ! s0 ]) X' n+ M; r0 V9 \/ Z8 ?- V+ x
79.                                         /* 释放从DTCM申请的64字节空间 */
    9 l& @8 Z2 i- ^. i6 j" y) q! A
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    , w/ p: A8 f4 l& k9 J
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    
83. DTCMUsed->used);
    ) D  u) _# q' l0 I0 X  F1 P
84.                                 
    
85.                                         /* 释放从DTCM申请的6111字节空间 */
    ' K$ A: {; y: O* B* @$ a: X
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    
89. DTCMUsed->used);
    % ~1 h. G7 U3 V
90.                                         break;
    5 S! v- z$ y2 U! }# f2 c
91.                                 
    1 C( {5 Y) m% s9 M$ K: |4 J* h' i2 |7 F$ i
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    
93.                                 case KEY_DOWN_K2:        
    : ^3 ^, ]6 H( x. N8 Z: X" |, K% j
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    " Z# K6 w# ?& F% U1 h
95.                                         printf("=========================================================\r\n");               
    
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    & A5 Z6 Z( @" z3 G
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    5 c( i; N3 d. _& t/ ]1 c
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    , F% g* f% t( Z9 ^
100.                                 
     
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
       g7 J- [1 w! x$ G; O: |3 Q
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     . y  [0 Z1 l6 G6 k! z5 v" S1 H
106.                                 
     8 h! d6 P# C1 [' I
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     ! z: w( F5 ~. D3 A6 g3 v. s& ~; K
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     7 s: G' N3 j3 c
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     2 n0 ]! q: m% c' O/ Y6 k
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     
112.                                         break;
     
113.                                 
     3 y  F0 G( s2 f# |
114.                                 /* 释放从AXI SRAM申请的空间 */
     
115.                                 case KEY_UP_K2:        
     ! `' F3 m' K8 T
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     ; Y  P7 D* v$ {/ N  W. n
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     6 s# X1 d$ o) J0 `( L
120. AXISRAMUsed->used);
     . A5 P! V4 D" K7 Y5 J
121.                                 
     " s, P* N: Y& j# Q# A' I
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     " _$ Q- r% W: w# ?8 Z
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     1 T8 R9 L, n, v7 `1 B3 _1 W
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     
126. AXISRAMUsed->used);
     ! n- C, c% P/ J2 J8 i
127.                                 
     
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     8 Q- q0 K1 H5 ?; u7 M, g7 l
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     : |: c1 L% K; _" t
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     , {8 V% ^2 M5 w) a3 y0 E
132. AXISRAMUsed->used);
     ) y2 D4 Y4 T- l) C. Q
133.                                         break;
     
134.                                 
     
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     + O* o( V3 F  D/ k* L. L
136.                                 case KEY_DOWN_K3:        
     
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     # S- I& l" j4 u, c, O0 R1 N5 `- ^
138.                                         printf("=========================================================\r\n");               
     , Y/ `- m- q) T/ w6 V4 H
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     , L5 ]% A# J& x7 ~8 P
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     6 h$ M5 s. @7 U2 a$ u8 t. z' k3 h
143.                                 
     
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     6 s4 P3 N. |$ H/ }1 x' }8 q7 d9 ?2 R* k
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     1 S# F% E3 _) ]1 v
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     $ f+ A+ d* y; O$ o. V% n
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     & n  u5 o3 n  K* I& b; x; m
149.                                 
     + W; j) `! }" J( M( v4 j
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     & ^" p* H: P% q5 G1 b
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     1 C4 u  E, F% Q1 k
155.                                         break;
       {& S6 r% ^$ N& }
156.                                 
     $ l8 G# s" v. ?3 Z8 T
157.                                 /* 释放从D2域SRAM申请的空间 */
     7 U, u- x. ]  v2 O" W
158.                                 case KEY_UP_K3:        
     2 ^3 ~' R0 Z- Y2 y( l
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     
163. SRAM1Used->used);
     8 O9 d7 D2 X; M; h7 l# b
164.                                 
     
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     6 Z( F/ r% |0 v1 t! p
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     6 V5 K2 O7 m. `. q. }# F  e5 ?  a
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     
169. SRAM1Used->used);
     
170.                                 
     
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     4 K( }  Z# u( M7 ]& a2 S+ w' d
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     * J0 h2 _7 k4 B
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     - ?$ v) t# L" j$ B" G! N1 I4 \
175. SRAM1Used->used);
     * q- B: E0 Q3 t
176.                                         break;
     
177.                                 
     7 C! n! \1 P+ ?# }: p
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     
179.                                 case JOY_DOWN_OK:        
     
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     , i  V3 Y0 X0 L  W/ x
181.                                         printf("=========================================================\r\n");               
     
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ) z% |: p! o4 N6 R, n- ?
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     6 a. D8 `% B8 q# Z0 A8 _9 O" ^
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     - U- @6 P- b: }6 M7 c
186.                                 
     
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     2 S" B& ?5 k8 P
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     8 m. J8 I' U, X; u
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     * c3 f) c4 P  f! M3 r; {
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     + }8 p: |* j" \! k/ K4 T
192.                                 
     : w6 h) o5 ^2 u* t' M  ]
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     8 W2 w0 w, t% |( k) i2 e
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     . A8 ^6 \) n: |  ]! V: b  @, v
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     0 E9 _! U9 l1 Z: ?) Y
198.                                         break;
     ' h: |2 |$ h) T+ Y- N
199.                                 
     6 u# o2 b3 l. W! o0 H5 `' [
200.                                 /* 释放从D3域SRAM申请的空间 */
     
201.                                 case JOY_UP_OK:        
     
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     6 w+ q) w$ j* R- d2 d% B$ y
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     
206. SRAM4Used->used);
     
207.                                 
       y1 ~% h% p  j# D$ A
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     5 b0 u, q; X# e* q9 p
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
       M. X( j7 D7 }$ ?
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     ! x" v+ x: \0 {. G
212. SRAM4Used->used);
     
213.                                 
     
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     9 a7 d# {" f8 R. v; ^
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     
218. SRAM4Used->used);
     
219.                                         break;
     1 t; r0 L' U, d! T4 V, l9 U8 @! E
220.                         
     4 s9 q5 B6 q2 H( t- G; I) t- E  j6 U! X
221.                                 default:
     
222.                                   /* 其它的键值不处理 */
     # i, I& U5 k# Q/ a% v. ^
223.                                   break;
     1 V7 \% l7 p  t$ ], r
224.                         }
     , e7 x( }9 L3 H" k, T; z
225.                 }
     
226.         }
     % {3 f- Y! k2 L$ z# R/ M
227. }

复制代码

27.5 实验例程说明（IAR）
7 L! [+ |8 `/ d& E  t配套例子：
& s$ w9 W0 A9 e; s% b- gV7-006_TCM，SRAM等五块内存的动态内存分配实现

+ H8 t% p/ K2 u* |# @+ d实验目的：
6 W$ s9 T* _! a1 l) h( q) o学习TCM，SRAM等五块内存的动态内存分配实现。


实验内容：
启动自动重装软件定时器0，每100ms翻转一次LED2。

实验操作：
K1键按下，从DTCM依次申请280字节，64字节和6111字节。
" E% R( h. p  y1 a% m7 dK1键松开，释放从DTCM申请的空间。
& O* _+ o. ^2 ~K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
, Y0 D& Z2 O/ U& b1 A- RK2键松开，释放从AXI SRAM申请的空间。
K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
K3键松开，释放从D2域SRAM申请的空间。
摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
摇杆OK键松开，释放从D3域SRAM申请的空间。
5 S5 J1 \4 \) t# z
" s) G. i8 |6 P$ v- R* a! k上电后串口打印的信息：
* d  E% }/ v4 y5 N  I5 Y
6 R  R: m! P2 y! ]: L& p波特率 115200，数据位 8，奇偶校验位无，停止位 1
: h( U- ~+ }% `% o3 Q

程序设计：

  系统栈大小分配：
$ i- B" B2 V: ^5 m$ A) T4 Q! ]4 O7 X, ~

- z- R9 G- ]8 ?* K' b  RAM空间用的DTCM：

+ g1 D# e) N  v" y& P
  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   
2. *********************************************************************************************************
   ) K, ]6 `; N: w) l- U
3. *        函 数 名: bsp_Init
   , k( v8 l  P+ F- s$ `
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   ' R$ I7 X7 ^9 p
6. *        返 回 值: 无
   / p4 V  X6 ~1 N( O
7. *********************************************************************************************************
   # r4 y- n" L2 v# s/ y7 ]2 @( G
8. */
   / T; r3 {9 ~$ J
9. void bsp_Init(void)
   
10. {
    1 _9 z% w1 S5 ~+ u
11.     /* 配置MPU */
    
12.         MPU_Config();
    * q" c! Q( P+ V$ R; l
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    
16. 
    : O4 k1 N  V6 V6 b' c5 S. @
17.         /*
    ( v; x0 a  r; {# g
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    
21.          */
    % H0 u% q" z& e( }' @5 \
22.         HAL_Init();
    - A1 I3 d( t  ]) d
23. 
    # m, V# p) B% l) ?
24.         /*
    
25.        配置系统时钟到400MHz
    9 {: B" q: I( l4 {4 G
26.        - 切换使用HSE。
    3 k3 g8 t$ m& b8 }  `2 H7 @
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    - {5 [" _/ d8 @2 b6 x7 R
28.     */
    2 s! k- |7 c: }/ Z0 A7 S' `
29.         SystemClock_Config();
    # f0 |% K# O9 ^" ]) n
30. 
    6 j8 x3 B+ {% N) C# g. W
31.         /*
    
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    ( C& c; ]. L1 L. K
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    ! Y/ \( O7 X7 |# v7 A" K) v
35.         */        
    0 A, Q+ _9 n# f' o, B* W
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
      C7 j. I! x1 A1 ^$ B! C5 Z
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    
41.         
    : v9 m) [- x' V  f
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    * P4 c+ w! Q' {
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    ! N' Z; B- C' {% J: v
44.         bsp_InitUart();        /* 初始化串口 */
    ( v* r( L3 Q0 ]7 ~8 d. i5 x1 X
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    : v( I( w* |6 T# j# W; \, G# d
46.         bsp_InitLed();            /* 初始化LED */        
    + e( h. z$ q9 j$ ^
47. }

复制代码

0 H2 ~( [) F6 j1 \& R/ R2 J  MPU配置和Cache配置：
: j% x6 i9 e# i$ `3 C
9 K0 b1 {1 D; y, r/ |' T数据Cache和指令Cache都开启。

9 a1 G; b) u7 ?AXI SRAM的MPU属性：
. A  t! I' X2 e0 v, s+ j) }
9 ]: h  F! L& p8 m" F& m+ lWrite back, Read allocate，Write allocate。
2 V3 W( \2 r! q1 i" n( R. g$ W! C  D
FMC的扩展IO的MPU属性：
$ ]- {1 h( B4 Q
6 z+ z6 E- i; m必须Device或者Strongly Ordered。
% S( p& Y* q7 V; g' g9 l# z' R
2 x2 u: P' B7 m' b' iD2 SRAM1，SRAM2和SRAM3的MPU属性：
2 E& u  j- w, ^0 _  t. x8 {, q- n
Write through, read allocate，no write allocate。

/ |/ i, G. y0 xD3 SRAM4的MPU属性：
3 O* d+ M- q, f1 e2 |" J7 b! x4 Z
Write through, read allocate，no write allocate。
3 K1 R$ ^' w, y

1. /*
   
2. *********************************************************************************************************
   0 y* [+ {) W' V
3. *        函 数 名: MPU_Config
   4 a4 M0 V+ T/ @  C& U# t3 e
4. *        功能说明: 配置MPU
   - j2 O0 V" T/ V9 n7 f
5. *        形    参: 无
   ) w! \+ G# v# g) H0 D
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   9 t) r, T% e: Y% M
8. */
   
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    , b5 |% B, i# l" c
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    6 e. }0 R! y/ h& P* P
15. 
    * v: C3 b4 p! d3 n8 j
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    ; h) z, b" v# ^7 `; Y
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ' J+ Z/ g  L& W8 t. Y9 G
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ! T: {0 f2 m: a4 a- {, W
30.         
    
31.         
    + }8 c& [: U& s8 y. n
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    5 t- t/ W" N; H  J0 {
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    7 ]2 m" K$ m5 _% I* h3 f
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    $ \' M6 j5 s) m, ^1 k. q
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    2 ^# w) W( E) L. P/ f7 n
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    . u% P) c2 W; L3 }
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ; N5 ~, T  `2 U3 F6 w4 K
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    - G8 z; w9 h9 U+ f
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    - J2 i$ G% S: v1 @* [9 u$ G; K3 d
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    4 F0 B4 }* T* M. X& K: |
46.         
    
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    . n& u- W/ R$ k+ u
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    0 b+ _  T  F, T0 G
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ! v5 C4 |# N2 O& Z' Y  d  H
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    5 t* H8 u! Q& q& B
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    9 K/ L& r4 ]1 l" Z$ O. o
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    ; [# y4 W( q/ v" S
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ) z9 Z  }  h. e/ E0 h
61.         
    
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    9 A0 @+ K- k0 w) |
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    & Y; W% J5 {$ q' J# Z
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    - }  z: j; h9 u2 F1 E- j  l
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    % b  u. r! S( w8 V! h
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
      t* e4 W9 S& G3 @+ h# z$ @" H
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
      P* a! @$ u' D" B* f  p
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    9 o- u/ F9 }8 ^  c
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    + M# {3 J% r- j5 ^6 B: P9 D
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    - v6 _# V- x% k& `1 l
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    5 \' W1 R4 Q7 I. h8 X
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ' E- h$ a( l7 @6 U' X7 Y6 Y
74. 
    " F/ U. Q2 K0 _6 A' b! c: d( h2 j
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
76. 
    
77. 
    
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    " h) }5 L! i! g7 y8 X$ g
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    / s: C6 H- W" o7 W8 I
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
90. 
    + Y/ t* }  e  J( Z9 v9 C; t) z: G" C+ t; V2 F
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    , Y5 I1 |3 n& a  ?* j% }! B
92.         
    
93.         
    
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    3 K0 r$ ?% W& h6 B
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    0 \/ i% y+ `' G. l
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
      z- G% C7 q6 m" e6 Z
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     ; X  p' I9 B6 J& [5 F' x
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     . t: o- y, {; O* i5 d
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     + p  o! {. E, G, D9 B
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     
108.         
     
109.         /*使能 MPU */
     
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     
111. }
     % m' i; z- S3 z7 R+ ]3 T5 P6 M  l: z
112. 
     9 _! n' {, k, y* R+ y
113. /*
     
114. *********************************************************************************************************
     4 r5 m. ]: }) g( n1 k) U, e
115. *        函 数 名: CPU_CACHE_Enable
     
116. *        功能说明: 使能L1 Cache
     
117. *        形    参: 无
     $ `, I# s$ _/ a& Q. B" e
118. *        返 回 值: 无
     
119. *********************************************************************************************************
     
120. */
     
121. static void CPU_CACHE_Enable(void)
     
122. {
     2 {4 J( S3 R! U/ Z3 l
123.         /* 使能 I-Cache */
     
124.         SCB_EnableICache();
     ! Q: s  }# N, r# t- k3 S
125. 
     
126.         /* 使能 D-Cache */
     * X! Z+ \# P' `' R0 f* {/ X
127.         SCB_EnableDCache();
     # O; C; V1 b) |
128. }

复制代码

  主功能：
4 F5 Y% z: [7 }; k8 @# A% H
0 ]9 f: S6 z5 ?% {  K/ F主程序实现如下操作：

  启动自动重装软件定时器0，每100ms翻转一次LED2。
  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
6 \' G8 ~! H+ F0 k- s5 I  K1键松开，释放从DTCM申请的空间。
  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
  K2键松开，释放从AXI SRAM申请的空间。
5 S: Z  h! y) M8 U2 A  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
/ j2 R( B+ N& q3 _. K) G1 h  K3键松开，释放从D2域SRAM申请的空间。
  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
9 o# ]$ V8 v& e7 H/ N  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   5 E4 h# l6 [* M+ [
2. *********************************************************************************************************
   
3. *        函 数 名: main
   4 ?* V$ K/ s1 j+ y( l
4. *        功能说明: c程序入口
   1 l3 p# {! @. Y, B7 Q& a" R8 [
5. *        形    参: 无
   7 g$ H, E6 J+ l6 e# S* V  S
6. *        返 回 值: 错误代码(无需处理)
     j5 A6 s& z: O& w
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   7 l- o4 b9 X% E  ?" m5 i0 D/ R" |
10. {
    5 j: y% S3 q+ E9 e+ {7 f
11.         uint8_t ucKeyCode;                /* 按键代码 */
    * y6 D3 z' r% P  c' I% i% S& w+ `
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    + z- R% ~% z; u# o/ {
13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
    
14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
    
15. 
    
16. 
    
17.         bsp_Init();                /* 硬件初始化 */
    9 p* Z: I+ ?) Q/ |& [
18.         
    
19.         /* 初始化动态内存空间 */
    7 N& Z  ?, a/ E' h( _
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    * a. o- M7 B' y9 r3 K
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    ' j3 W% m) \8 [3 @7 h. U( {
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    
24.         
    , n) l! J* {0 R
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    ' U& @8 G' H. R( O4 D
26.         PrintfHelp();        /* 打印操作提示 */
    
27. 
    
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    - K( s$ n% u6 ~
29.         
    5 c8 Q( N- e  g# \- h
30. 
    : ~2 \/ V9 P9 {, Q7 o
31.         /* 进入主程序循环体 */
    
32.         while (1)
    0 a7 a, U- v/ U' P3 G! p
33.         {
    
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
35. 
    / f$ b8 u1 Z, s6 u
36.                 /* 判断定时器超时时间 */
    . T, s' S! ?! d1 n+ v
37.                 if (bsp_CheckTimer(0))        
    ( O( b. m+ j4 e4 p: U
38.                 {
    
39.                         /* 每隔100ms 进来一次 */  
    
40.                         bsp_LedToggle(2);
    1 `$ K4 l4 [" S2 M% M1 J
41.                 }
    3 @, N9 F* Q5 a1 ^; d( e
42. 
    
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
45.                 if (ucKeyCode != KEY_NONE)
    6 X: a5 I( K2 H9 ?: s) ~
46.                 {
    % k5 X( `$ I) y3 ^+ ~
47.                         switch (ucKeyCode)
    7 m9 U' A0 d( L& z
48.                         {
    $ w$ [% Y5 A. h% z: F8 g+ R) Q  A
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    
50.                                 case KEY_DOWN_K1:        
    2 m  ]# r4 {! F; a
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    
52.                                         printf("=========================================================\r\n");
    
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    * s' ^4 J2 T7 q  D' j! T1 T9 X
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
      \4 l( O9 Q) ?  m
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    6 @9 _$ D: j; Y# [1 {' Y" J
57.                                 
    + L  [$ @. x, p( l  T
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    : Z$ D3 m* P7 P8 M5 X& i% Z
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    
63.                                 
    
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    ! d( r, h  r: u
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    $ x1 L7 ]. O; x( C0 k2 \; V
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    $ U6 R) j) L% h# \$ x# b
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    ( O1 e  A. n  Z: ^2 P& j
69.                                         break;
      E- F3 n1 Z4 p
70.                                 
    8 ?# ^3 b+ t" e" R8 G( W
71.                                 /* 释放从DTCM申请的空间 */
    ' W7 T* M+ D' o. O6 }5 y
72.                                 case KEY_UP_K1:        
    
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    1 w* m, }1 H* ^4 k, \1 _
77. DTCMUsed->used);
    ; h4 E9 O' v' y" E- ~
78.                                 
    7 ?7 @. i( t9 I  c
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    + h3 ^! c' b& d* Q0 e# {
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    - |/ o& l& t- a1 _) {
83. DTCMUsed->used);
    * ]5 s1 W/ ^5 c6 P) P6 q
84.                                 
    " X' u) L  j: J! M
85.                                         /* 释放从DTCM申请的6111字节空间 */
    " H6 t( K# |2 v$ R. @
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    
89. DTCMUsed->used);
    
90.                                         break;
    
91.                                 
    9 v$ n- S7 L# \5 b
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    
93.                                 case KEY_DOWN_K2:        
    
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    
95.                                         printf("=========================================================\r\n");               
    ' [  f: t5 G7 }
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    " S* n3 z# ?3 h. ~, E
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    % ^0 Y+ w! a4 d& R2 Y
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    , ^/ H, a6 E- ^$ @! l1 O
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    ; s2 E' ^2 t: \/ N
100.                                 
     
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     + a0 R" x3 i+ x
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     7 x; l1 |1 u7 i: \4 F! }
106.                                 
     5 s5 f0 q+ J1 {
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     2 }' I/ J3 [% n9 @
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     " ?* m0 r' r! I& E5 H9 K9 }: V
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     + J: W) u9 C" P- ~* i; h
112.                                         break;
     9 j+ l! s2 g' p! j
113.                                 
     4 K+ L" d# Q, Z
114.                                 /* 释放从AXI SRAM申请的空间 */
     * b* v; N- n" c1 N* |: M* x, Q( y
115.                                 case KEY_UP_K2:        
     5 o" V4 k% W: q9 W( t8 ~
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     3 A# G) l" b' E  \7 V( G0 |
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     # H) f& `7 L# J8 L" u- N  q2 A7 f
120. AXISRAMUsed->used);
     
121.                                 
     . s9 q% @6 k" Q3 A1 A- A
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     & {: \8 f! q6 Z" d/ S1 J
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     
126. AXISRAMUsed->used);
     
127.                                 
     4 D9 G7 {7 o) Y6 H2 h# w% e
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     ; c4 Y3 S$ d. U; G7 e
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     9 |" y2 j# A/ s. C. R6 q
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     $ I7 \3 P  N( Y! m
132. AXISRAMUsed->used);
     9 Q4 J3 }( a$ ^0 Q4 a
133.                                         break;
     1 f% r' Y  ^7 l; ?, o
134.                                 
     
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     ! G1 [$ u6 i# Z& w" g& \9 q
136.                                 case KEY_DOWN_K3:        
     
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     / s8 b' x  Y8 N7 N2 E
138.                                         printf("=========================================================\r\n");               
     " Y5 a! M8 x# F2 \* ?
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     % m" V9 X& A$ a  e
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     % w% b% Y$ K! g" I% A
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     7 c& u) M, r7 f
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
143.                                 
     5 B/ o3 F0 e: j/ P6 M4 O! }, g
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     ! t+ {, q+ F3 w  E
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     ) G2 O9 J0 B- n8 t8 [5 ~( A# c4 D
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     ; p8 Z' T9 T9 M* w
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     " r/ w) [8 M7 ?2 o: U
149.                                 
     
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     7 p/ w; m  x; k& u, f- q# ^
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     1 d3 S: y5 I6 H! B! _
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
155.                                         break;
     
156.                                 
     * i- _! f, w; I
157.                                 /* 释放从D2域SRAM申请的空间 */
       k! K. f# ^, x1 d
158.                                 case KEY_UP_K3:        
     4 R' R  b! u+ K" D
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
       f% [! h$ ^; O. P( ^% x. m
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     3 O' r( S- Y5 v0 k/ ~
163. SRAM1Used->used);
     % S% e2 K9 V/ L  \5 |- Q; m
164.                                 
     # [" P- m& d. c; @- ?' V% k
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     & A3 C( H0 X7 L8 f& }. P0 k; c
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     & Y8 ~7 Y5 ]; J; N' r
169. SRAM1Used->used);
     : e9 @# u& Z' r1 O. C6 H4 z! `4 d+ [. P
170.                                 
     " M' ^) h4 g4 ^/ A; ~9 _
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     + M9 Z) i% \2 Y2 v# X3 `9 ?3 a
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     
175. SRAM1Used->used);
     4 B" ]5 ~  ]5 B. [
176.                                         break;
     
177.                                 
     % z: s' G- ?( h: b1 z6 F) m* F
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     - `1 f- r$ W% e' _
179.                                 case JOY_DOWN_OK:        
     $ F) R+ ^7 `! R$ s! W) b4 E
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
       E: o) n: q  e- l7 ?( b/ x; k& N
181.                                         printf("=========================================================\r\n");               
     
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     : W& X! w7 [7 ^' V: C; b8 s
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     * @! _  Q2 X9 L  s
186.                                 
     " V6 b4 \! O- A' Y
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     $ r9 @; e* ]3 B* Y
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     
192.                                 
     % A& A1 y) E+ C& S) ^
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     3 ^1 v( c" C, A+ P2 @
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     - j3 S- ?+ P% @% s
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     ) ^6 R5 H& b: ~" s: f% P' i( p/ z
198.                                         break;
     
199.                                 
     
200.                                 /* 释放从D3域SRAM申请的空间 */
     
201.                                 case JOY_UP_OK:        
     % E8 T5 S# m" {; D9 r
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     0 H$ Y) _8 N. s( `: H2 }' j
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     6 f' }# h5 Z$ R1 ]9 o. X5 U1 R% D
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     
206. SRAM4Used->used);
     * u0 y9 G3 t" U5 U9 R) M' q
207.                                 
     9 y7 f# X" T2 C4 d8 Y
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     : t; P& T: O' O/ \* E* m& S4 l' f
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     6 p8 {% Y- x" J( s) J, _
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ; N6 g) @9 K9 F8 j) t9 e. p8 p
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     / @/ b+ b$ ~' k( s- U# Z4 G" A
212. SRAM4Used->used);
     3 `% f. `4 f, N+ z( I2 V6 T
213.                                 
     
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     / l9 v% y7 n6 K* _. E
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     , i. [6 ?! a0 N
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     ; X# k1 W3 ^+ o" u
218. SRAM4Used->used);
     ; R- S! K7 M6 j3 F1 ]1 E
219.                                         break;
     # ^) W% N7 |; h1 f5 l5 C
220.                         
     
221.                                 default:
     - F6 o1 P* ^" Z
222.                                   /* 其它的键值不处理 */
     
223.                                   break;
     : r0 }5 y7 Y6 ^
224.                         }
     
225.                 }
     * v: @, u! q: X# W* g
226.         }
     
227. }

复制代码

27.6 总结
/ s3 r( C) w0 d2 u9 G( G本章节就为大家讲解这么多，还是比较有项目实用价值的，特别是MP3编解码，JPEG编解码，视频播放器，矢量字体等需要动态内存的场合。

- A  @- F3 C' ]6 n/ u6 n; q( q/ o