27.1 初学者重要提示
  学习本章节前，务必优先学习了解TCM，SRAM等五块内存区的基础知识，比较重要。
  将RTX5系统的动态内存管理整理了出来，可以同时管理多个分区。如果其它RTOS中使用，记得做互斥保护或者加个调度锁均可。
  支持动态内存使用情况统计。
+ c. C9 n, g0 {  z2 u. R27.2 动态内存管理移植
移植比较简单，仅需添加两个文件到工程即可。

27.2.1 MDK版的移植
! s8 Y8 q2 G' u* H+ N% }( M  第1步，添加如下两个文件到MDK中
3 i' u5 F4 D! m) H+ H: P' K3 B9 x, \注，以本章配套例子为例，这两个文件的路径\User\malloc。
2 H' U$ Y0 A# j% v9 ?; p
# i3 I) Q- D1 k

7 [4 |& K9 F) t: ~9 I- J- h  第2步，添加路径。
8 @9 k# }7 t8 U5 n3 l8 ?7 F. q

  第3步，添加头文件。
如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。
0 [4 c3 z2 l, c% V
通过这简单的三步就完成了MDK的移植。

# d0 e2 z' O" M' z& B3 u7 z5 L27.2.2 IAR版的移植
. c- L/ Z! _7 `- a1 F  第1步，添加如下两个文件到IAR中
( T4 P7 ^1 B8 ?- P# u: Y注，以本章配套例子为例，这两个文件的路径\User\malloc。

8 Q8 D$ U0 H' \9 P5 @  第2步，添加路径。
# j1 R+ T- |4 z, d

$ X' E$ O0 e- i* g4 Y2 t& ^; m
" Q; }* L6 w3 x( J  第3步，添加头文件。
+ ?8 d6 ]3 y/ h1 T& f1 Q+ u" y如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。
/ f4 K" l1 M7 o! ~0 G1 G; D
3 G. y3 X  ]3 n6 n  s4 t通过这简单的三步就完成了IAR的移植。
; ?4 E! p4 M1 |/ i2 I2 T2 X/ l# \) r9 O
27.3 动态内存的使用方法
$ a2 H' s7 G3 B( V- G下面分别以MDK和IAR为例进行说明：
9 D3 u) J3 V  f. ]0 @4 h) @4 c+ K$ x
27.3.1 MDK上的动态内存用法
  定义动态内存区
, R- V; ]4 g0 D% o2 g比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：
* f0 |) l, O) e$ F! L( [
) ]# n  u1 X& K. l# n% Y5 w( r

1. /* DTCM, 64KB */
   * W' `0 d2 h% A; }& G$ R0 U
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *DTCMUsed;
   4 j, s; O* H3 ]" a9 n  O1 K( s' R
4. /* 定义为64位变量，首地址是8字节对齐 */            
   
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

如果要使用AXI SRAM作为动态内存空间，可以使用__attribute__((at( )))指定地址。
- J2 T/ c- s9 e0 d) Q
. b; w/ F% V  E6 o2 |

1. /* D1域, AXI SRAM, 512KB */
   " p! {& ]4 I8 \; j6 W# R4 Y
2. /* 用于获取当前使用的空间大小 */
   ! Q4 K( `2 j" @& ^
3. mem_head_t *AXISRAMUsed;  
   
4. /* 定义为64位变量，首地址是8字节对齐 */
   3 b6 M* M6 Z3 _; U1 \4 R! ?+ j
5. uint64_t AppMallocAXISRAM[512*1024/8]__attribute__((at(0x24000000)));

复制代码

  初始化动态内存区
调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：

osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
' n0 W9 P8 V2 z! yosRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
* ^  ?+ e/ I& w1 y0 ^
  申请动态内存
通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。
: B  s5 R# {) m  w$ ^/ S3 O( l
第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。
8 x9 F! ?  D# J! s# J0 Z' \- Z6 J
$ p6 w3 T6 {& v+ T  _6 E0 A第2个参数填写申请的字节大小，单位字节。
% H- z9 Y, b" |1 ?! w
第3个参数固定填0即可。
" x$ d6 m% k& o- U- a: K
返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！

举个例子：
0 i; I' w9 |: e0 A0 }+ e3 Y" j

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   
2. 
   ! ^( F+ X! X& E; V5 B/ E
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   1 e& l" [; |& y1 A; o/ H
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   - o$ r7 Y. h$ n% l2 x' T) C" r# w
7.                                                              DTCMUsed->size, DTCMUsed->used);
   6 D% h0 W$ ~' v/ w
8. 
   5 D! `  J8 c5 ^. a0 r, r# r8 C' \/ O
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    6 n6 \# e2 i/ a4 j/ m, Y
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。
- M. @( e2 J; R) |
  释放动态内存
" R/ W# _- T7 P) c$ k通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。
" p9 Z  P; R6 L( |
5 F+ Z9 a7 c! O7 T! ], K' o- h第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。
1 H5 q! |; K$ ~8 R6 C# h! S
! A4 ^( {1 d! E% i  ?4 [第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。

( i+ O, R) J3 J5 \返回值，返回1表示成功，返回0表示失败。

% l: f; q  k; n: i举个例子：

( I5 E- P( h# ~+ v+ |

1. /* 释放从DTCM申请的280字节空间 */
   
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   ( V4 o4 ^$ `: x$ F. r
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   
5. 
   " @2 B( [8 l; u8 s9 u
6. /* 释放从AXI SRAM申请的160字节空间 */
   8 H& d! ?4 W* w+ L+ t( S$ [( f
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   ) T. c3 _8 G8 X7 c8 n/ m6 j
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   - I# p! D& u" d$ q0 V9 z! H$ m3 P
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used);

复制代码

27.3.2 IAR上的动态内存用法
注：IAR使用这个动态内存管理，仅在定义时跟MDK略有不同，其它地方是一样的。

  定义动态内存区
, p: |4 W' u- b1 `& j比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：
: ]/ V5 `0 H! {1 ^* A# W' ~

1. /* DTCM, 64KB */
   & C+ j: w; h; ?
2. /* 用于获取当前使用的空间大小 */
   $ P3 q1 n! u. y' p. G
3. mem_head_t *DTCMUsed;
   
4. /* 定义为64位变量，首地址是8字节对齐 */            
   ' w& l1 y7 z6 Q0 }& r# p" J9 v
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

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

1. /* D1域, AXI SRAM, 512KB */
   ( y5 ~1 w: k/ e$ Q
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *AXISRAMUsed;  
   8 r! u( r/ b3 h/ Y4 ]+ a/ \
4. /* 指定下面数组的地址为0x24000000 */
   
5. #pragma location = 0x24000000
   
6. uint64_t AppMallocAXISRAM[512*1024/8];

复制代码

0 x3 {0 T. `# X8 R2 |  初始化动态内存区
+ F" G8 t! |  N& [调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：

1. osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
   . ~, Q8 A. P. r
2. osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

复制代码

" |9 v+ H: M$ c+ r9 e  申请动态内存
1 Q/ g, D2 w2 w. z通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。

( c5 ^6 D- r: e# K第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。

0 n8 f- d# |' E$ Z# E: H! r6 ^5 f第2个参数填写申请的字节大小，单位字节。

第3个参数固定填0即可。

  \' J/ W# Z& e  {; T3 ~2 `+ U返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！
- N: W5 f  F- H4 `8 R
. b' x9 f) @" B0 e% O3 f; E4 g举个例子：

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   
2. 
   . s; c4 r: `0 J5 I% J
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   5 N1 @0 `- u* k
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   
7.                                                              DTCMUsed->size, DTCMUsed->used);
   * Z1 n6 B4 y1 m# [; Z
8. 
   1 r9 m  f: W1 Z" |1 |1 C; u' j# e' N
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    : x4 e8 \* M0 Z' y' a
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    1 b5 |" K+ F) Q6 n+ Y
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

  k+ r/ L4 i% ?' y2 M9 K* K申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。
6 C, j/ X- S  ?+ }  A
, K$ O/ d. K7 y" f$ V6 s8 l  释放动态内存
0 W& G" A& u- t# k- t1 G6 P. e通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。
, I' n' I) G1 n( t: A6 T/ U3 A
第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。

第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。

返回值，返回1表示成功，返回0表示失败。

举个例子：

1 V' j6 |. n( `% t4 K

1. /* 释放从DTCM申请的280字节空间 */
   5 K4 a% M  m. i$ D1 k! {$ V7 H
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   
5. 
   
6. /* 释放从AXI SRAM申请的160字节空间 */
   
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used)

复制代码

27.4 实验例程说明（MDK）
' K2 I2 [6 E5 J1 T3 [% y配套例子：
7 P& t" ?/ v. c8 S& zV7-006_TCM，SRAM等五块内存的动态内存分配实现
) f0 p, P3 b, G, `) s  Z
实验目的：
学习TCM，SRAM等五块内存的动态内存分配实现。
8 |3 O! C$ a8 N

实验内容
. I7 |9 F5 n7 `6 l4 r8 B! N启动自动重装软件定时器0，每100ms翻转一次LED2。


实验操作：
$ B: P7 n4 Y+ q, ]* X1 G2 n% H$ T9 PK1键按下，从DTCM依次申请280字节，64字节和6111字节。
K1键松开，释放从DTCM申请的空间。
7 g" T: V% |4 B8 Z+ k9 hK2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
K2键松开，释放从AXI SRAM申请的空间。
9 D% x: l/ g0 ^4 D9 hK3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
3 W4 l1 o& `8 N$ z5 GK3键松开，释放从D2域SRAM申请的空间。
摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
' |$ ?4 z( {4 Y* g  s, T摇杆OK键松开，释放从D3域SRAM申请的空间。
' o# E; u; v( `7 R- g4 z3 _

0 d6 R+ ~! f4 \3 q# X7 P2 F上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1
1 H8 Z4 {$ A& s& L

程序设计：

  系统栈大小分配：
! _$ n. ?& F7 B4 w' a

+ h, J" S+ ~7 x$ W& s
RAM空间用的DTCM：
/ _# _& ^% m0 `" F8 u
- v% Q! ~4 B$ k3 P3 m7 _

( `: Z1 d7 D2 k5 h  硬件外设初始化
2 l: X5 Q- Z& n6 ]
6 w4 a# @, P6 }! k9 o! u0 N硬件外设的初始化是在 bsp.c 文件实现：
+ E9 j( N" n2 E" A* {" M+ l
3 `; i6 [, k  o* ?  a, F# M

1. /*
   2 b- {1 C, h  a' C2 h' Y3 g; {4 J
2. *********************************************************************************************************
   : \7 g1 B0 ~8 Z
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   7 w+ j9 J  O. W2 V/ |, ~
6. *        返 回 值: 无
   + p2 m  c: y4 e% b$ e$ |8 _: H
7. *********************************************************************************************************
   8 ^, M+ _6 t3 R4 C7 J
8. */
   7 }7 Q, I% A" a, G
9. void bsp_Init(void)
   5 K# F6 J$ w0 `; }; \. H
10. {
    % ~$ y6 |3 `5 |: k
11.     /* 配置MPU */
    
12.         MPU_Config();
    5 t( P/ t3 O* ?; y/ m. V# a, D7 u
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    ; M. A8 B- B2 w+ W% Z
16. 
    2 `7 j" h) D2 r2 J1 M
17.         /*
    $ W& w  E* `1 I1 Q5 b0 n: W
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    - h+ w/ m0 |* o: W' v: \
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    , t# _6 R( M5 g4 b% n
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    
23. 
    ) w" |1 H: U1 J& c( ]9 {
24.         /*
    
25.        配置系统时钟到400MHz
    0 K  w, E: k& ^' r3 B5 @* B
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    3 M0 T3 `9 e& g  }" a/ b7 ?
29.         SystemClock_Config();
    
30. 
    
31.         /*
    7 w! _# R. [3 L, S3 H: V/ ~
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    # y- N" a1 [7 ]$ g) F9 r
35.         */        
    
36. #if Enable_EventRecorder == 1  
    # Q* z$ [3 Y' V0 ~1 s
37.         /* 初始化EventRecorder并开启 */
    ' H9 q& S6 j& \' c. V" Y# W
38.         EventRecorderInitialize(EventRecordAll, 1U);
    $ m* f4 Y% `6 o
39.         EventRecorderStart();
    " b$ D7 ]- R" W5 b6 ~% J- [
40. #endif
    
41.         
    " Q3 }* \/ B3 d7 s
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    2 M/ l" Q6 x$ x) L/ |
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    7 x8 Q2 V# Q' {
46.         bsp_InitLed();            /* 初始化LED */        
    / |  \$ ]) x+ K8 f  d2 Y* v
47. }

复制代码

1 j) z8 R; [2 c7 {/ o  MPU配置和Cache配置：
数据Cache和指令Cache都开启。
/ z5 g; V; z1 t5 Z/ v# _* t& J; P
1 N! ]5 z5 [) A( n7 XAXI SRAM的MPU属性：
6 [+ T, x- U9 k1 H/ {# {) H
, e; M0 R. ?7 \6 v0 y1 sWrite back, Read allocate，Write allocate。

FMC的扩展IO的MPU属性：

必须Device或者Strongly Ordered。
( h2 {: B* Z( Y$ R* W" R  D
D2 SRAM1，SRAM2和SRAM3的MPU属性：
$ l& j2 f7 v. S& G' [; J
7 ^' B, T! J/ ^. u0 B( ZWrite through, read allocate，no write allocate。
' Z* F1 c( Y0 r, b' [
8 ]- Y) q# L4 b% H) p/ f" A6 SD3 SRAM4的MPU属性：

Write through, read allocate，no write allocate。
5 A  D8 Y/ e* R) V( T
& ?+ w6 A# V& T- d

1. /*
   ' m/ B/ I* c! y; g3 s
2. *********************************************************************************************************
   4 n, m# t2 V6 V8 t; x0 f
3. *        函 数 名: MPU_Config
   3 r, B8 q, t% a5 c$ N2 N% _$ d
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    7 w4 \6 S' B0 c6 m+ J) l
14.         HAL_MPU_Disable();
    ( f6 _8 x1 U3 V" ?( T
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    , I$ i4 l# I8 a  ]1 L! V% h
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
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;
    4 U, j2 I3 P4 Z9 r0 P1 I( t
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    1 @- n6 q% G( N# ?& g' b: S5 o( I4 Y
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    % _0 t- U6 c  B# X% t4 |8 c. c. Z
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    * E- D  T; E1 L, z1 C. L
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    / l2 s) \( g* x8 T
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    : h- T2 Y9 N0 y6 O4 y- R
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    ! u  G) D9 _7 x# C: q$ b# Y
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    # u  }3 O) T9 l8 Q
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    2 h: E' s6 N+ _* `5 W
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    ( T+ v+ L$ k7 Z# ?% O/ [
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;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    9 e- f. X$ R- J2 O! F, T
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    2 o# i+ Q3 M0 V# D4 X' g
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    * ]7 d; ?3 E- W! w+ w2 V2 e: ^* l8 |
46.         
    
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    ; q8 z$ d$ \& |! o9 G8 s
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    $ P$ X6 h! S6 ]8 h  U" L( Z! |
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    0 O, D# v# L( \" k
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    & R7 @4 C9 n1 Z# G3 }* T
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    # k1 @+ l2 J7 l7 y) {: [
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ( Q+ T) D. j7 c8 a, D+ {; ~0 s3 e
59. 
    * {( q, R6 w' T) C- f3 n" j
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    3 m3 d( u/ E1 c) ^  N; E
61.         
    ) V! g9 |5 A( h
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    ! Y; C* r5 U6 B/ ~  z& {) A
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    0 @/ d# E: Y! n1 i. B2 h
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    4 Q/ i/ {9 E4 \' U
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    ( I. B% _% R* E+ X% L
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    + i5 j( L6 ~  t" i7 R- b
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    * X; ?0 H# `" I% D" m) v+ ~
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    4 U( z$ \. X( j4 }% ?; l. O/ q- y. ?
74. 
    
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ! ^& p) @  l* U+ \' ]
76. 
      }/ k( F( @7 I9 S6 q
77. 
    2 n8 W& G$ n1 H' g0 V$ q% H# v
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    2 k( z6 E, j1 M" {7 n& U7 U0 ?
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    # o7 h5 \5 S- o: O. s
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    7 t7 Y9 X0 o# z3 T" \! f. s; A+ r
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    . T  F! b1 z% K) k3 C. F
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    ( d4 b. c- }1 ?8 r
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ( e( O* J. b- K$ B
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    , v: y( a% r* X; C- [0 v
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. 
    
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    8 h5 J; ~0 Z, \* Z, L, ]+ x
92.         
    * u/ }  H$ i+ h/ e
93.         
    9 f2 @$ R  M, F- a0 L5 K/ R
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    1 w3 E! v# d, ^+ G
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    . N: s! F% C/ }4 r$ l6 g3 s( K
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    . V6 s' T' l2 U7 M3 M2 N' j: D- _' e0 p
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ( W+ P' `- Y8 r1 F: n) n; i
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
       p" |9 d1 p0 Z/ E. E7 p7 L2 ]
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     3 Y$ S: \) N2 d- T4 W! _- |, O
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     % z* x1 f2 G* C. M- F1 x2 T6 _
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     ' v0 @5 O5 c) T0 M0 P. @6 J
108.         
     
109.         /*使能 MPU */
     
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     
111. }
     2 |; O  \( L8 i& h& v* z
112. 
     
113. /*
     
114. *********************************************************************************************************
     
115. *        函 数 名: CPU_CACHE_Enable
       n8 O  }% ~7 D' m1 S5 b8 o  r0 j
116. *        功能说明: 使能L1 Cache
     
117. *        形    参: 无
     2 P" U  O; @2 {$ o& d1 [! w, y4 M7 H
118. *        返 回 值: 无
     
119. *********************************************************************************************************
     6 I4 T* v2 C! o4 S8 v% }9 o$ F- r
120. */
     
121. static void CPU_CACHE_Enable(void)
     6 w* L/ A" o! }: R4 S' S# {+ t
122. {
     
123.         /* 使能 I-Cache */
     1 a8 T" l9 t  e3 |
124.         SCB_EnableICache();
     
125. 
     
126.         /* 使能 D-Cache */
     - E, w( c- D6 b, e' X
127.         SCB_EnableDCache();
     
128. }

复制代码

# B' G8 t/ k: f0 D5 n  主功能：

* {: _( k$ z6 d, P0 f) O主程序实现如下操作：

- ~+ ]7 w# w, z7 _+ h  启动自动重装软件定时器0，每100ms翻转一次LED2。
/ D4 Z( F& l; M$ ?  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
  K1键松开，释放从DTCM申请的空间。
! a. o4 P$ ~. R9 \7 _$ t  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
# w7 w; s& D8 _' ]  K2键松开，释放从AXI SRAM申请的空间。
- d4 @7 i8 H' G$ [  C  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
5 G1 W  W% Z% Q" R0 B  K3键松开，释放从D2域SRAM申请的空间。
  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
: B6 S: {7 {# c+ a9 p8 n' V3 ]6 t  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   / F! I* ^5 |- |3 ^+ y
2. *********************************************************************************************************
   ( {% \7 h4 e7 ?- d7 D, Y/ s
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   4 s6 I  @- w7 f) ^
8. */
   
9. int main(void)
   
10. {
    6 M- ^  `5 u" ?. i1 n
11.         uint8_t ucKeyCode;                /* 按键代码 */
    7 B- B$ D7 o3 a& }7 P* s4 F
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    
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();                /* 硬件初始化 */
    1 M1 l# d; P/ P1 a8 n8 M' R
18.         
    ' y. B3 S2 \1 s* e# e5 n
19.         /* 初始化动态内存空间 */
    
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    - }2 h8 V+ G8 o) a
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    4 A( U, I0 a2 Z& C& A$ x* a" v5 w/ x- T
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    
24.         
    
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
26.         PrintfHelp();        /* 打印操作提示 */
    
27. 
    6 F! w( q" t6 A; ]1 x
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    / N" M3 \* b/ O! ^, A$ W
29.         
    ! Z% I3 H7 R6 [2 H+ w# q
30. 
    
31.         /* 进入主程序循环体 */
    . ]! c$ k3 _9 L
32.         while (1)
    & ~0 S5 c8 D3 ^+ p2 y- k1 X
33.         {
    
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
35. 
    
36.                 /* 判断定时器超时时间 */
    
37.                 if (bsp_CheckTimer(0))        
    ) X$ N( a# _* y0 `5 A
38.                 {
    
39.                         /* 每隔100ms 进来一次 */  
    
40.                         bsp_LedToggle(2);
    . W4 C/ a0 D8 J4 }
41.                 }
    
42. 
    
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
45.                 if (ucKeyCode != KEY_NONE)
    . I7 d! B/ h2 z. R, l
46.                 {
    
47.                         switch (ucKeyCode)
    
48.                         {
    
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    3 a* k/ H1 u+ D# l) C
50.                                 case KEY_DOWN_K1:        
    
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    ' t* }: A+ d. X
52.                                         printf("=========================================================\r\n");
    / e! ?* Q; j) s) w! H8 ?4 j8 z1 `; F
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    7 F$ `' }5 w6 H# V0 q' ~  `
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    9 g: D1 N. X! i
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
      \4 |2 o( I2 U0 G) @/ T. G9 a  ?
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
57.                                 
    
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    1 d4 A0 Z! R$ {
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    % U4 d1 x4 _- F1 I% y
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    2 o# {. ^- W. h3 {: X
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);
    & d1 D( l  W) m! f7 w; C. S, n0 u) \
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
      [" }6 b- w0 ^; I& t5 m8 L, n, c0 w
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
69.                                         break;
    + B6 U5 `3 E- o. @+ A8 K
70.                                 
    / y" l& b  I; {9 ~7 H# H/ h
71.                                 /* 释放从DTCM申请的空间 */
    . C/ X% l: z! f) }
72.                                 case KEY_UP_K1:        
    - b* L3 }0 d3 ~2 G# T0 i7 G
73.                                         /* 释放从DTCM申请的280字节空间 */
    ( M3 ~) s2 _/ F1 u! a6 B6 M, a
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    2 `& a/ I" D+ i* ?: n
77. DTCMUsed->used);
    2 q& s$ Y% y" G' a( W- @3 f! `
78.                                 
    
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    
83. DTCMUsed->used);
    , h' J4 n# b5 U! d# [
84.                                 
    0 |% \9 V5 d9 p$ k) q7 z
85.                                         /* 释放从DTCM申请的6111字节空间 */
    ; i9 V% u5 l" a
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    0 w* t9 n' c# w! J, T
89. DTCMUsed->used);
    " o  k$ @2 V: ^  D! l+ C
90.                                         break;
    
91.                                 
    
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    4 B; Y+ \' u+ ]& {( p, N% G" ^* W% L4 k
93.                                 case KEY_DOWN_K2:        
    * |0 h5 Y9 @1 t' v# U! D$ i+ B
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    
95.                                         printf("=========================================================\r\n");               
    + [% N2 u) c; W/ z" Q* m
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    ) E5 A5 {% L2 `  m# Q  z; }
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    + r# V6 L; {$ @$ R
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    , d  C: Y- c' P- ^
100.                                 
     " d; Z1 y. r$ d# I
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
       w1 |/ T! Q/ e) u/ v# t( E8 w
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     6 E, h! Z; B' v  L/ ]
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     & V5 N4 n1 m4 Q+ S; \
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     
106.                                 
     
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     * `. E, N. E! Z$ i
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     + L6 q3 d$ L- m0 s
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     
112.                                         break;
     & q2 @! j% z% i( C2 ~& \
113.                                 
     
114.                                 /* 释放从AXI SRAM申请的空间 */
     
115.                                 case KEY_UP_K2:        
     
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     3 S! H  t9 b) g- C
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     ' z% J5 Q0 L# m3 B6 S, Z
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     
120. AXISRAMUsed->used);
     
121.                                 
     
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     
126. AXISRAMUsed->used);
     
127.                                 
     
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     + j: @$ [7 i, w* [5 ^
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     
132. AXISRAMUsed->used);
     
133.                                         break;
     + _' d0 @' i& Y3 O& u# G5 v; ^
134.                                 
     7 z: O' ~) Y$ {$ y: ?
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     
136.                                 case KEY_DOWN_K3:        
     " h# w; S2 o" r" I& s2 G: _
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     - X/ M/ P2 O- K3 ?7 k  x) l" u4 D
138.                                         printf("=========================================================\r\n");               
     
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     : y. J) G. @2 y9 ?- N
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     / d8 W0 d* e; o" J! K3 |
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     0 Z, U8 B) B$ M6 {* n0 e( d
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     ! D0 q4 ]  d* @( O
143.                                 
     
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     # `' H- H3 N8 a9 h7 ]1 Q
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     6 v9 o* s( A! f% X& V
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     ; h7 b+ `; l! L" ~$ `+ J2 y% `7 F- f6 S
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     ! O' h% Y, x+ F4 ^
149.                                 
     9 b0 J6 \2 x, E
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
       o# ]) }* I+ s- Y/ M' }: J6 y
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     ' T3 q4 l! J; ^
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     4 \* w3 C7 Z9 S; z+ H4 I% z
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
155.                                         break;
     
156.                                 
     & x( C* E& w* I. Y
157.                                 /* 释放从D2域SRAM申请的空间 */
     
158.                                 case KEY_UP_K3:        
     7 f7 g6 `% q! f$ v7 v, O
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     " Z5 T" _4 E, L4 N
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     6 X" g0 s3 t" W( `
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     
163. SRAM1Used->used);
     
164.                                 
     $ }7 l; p# d% S) c% j
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     0 L  i6 l( v6 j5 _! r  `- i9 ], p
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     ; ]2 C) G) J: O$ ?
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     ' N. i/ W8 G0 ^% v3 G9 ^# \7 G% L
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     4 I$ C& n3 h7 [' O
169. SRAM1Used->used);
     $ ?; I1 a% c( Q- O$ E$ L( n
170.                                 
     
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     " l; y) \$ E+ v) `2 G- l
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     % l1 C/ \- ]5 I* H6 ^; B5 ^: B
175. SRAM1Used->used);
     
176.                                         break;
     
177.                                 
     : D5 x$ ]5 B( I/ m( B5 }
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     " L; f4 J( l5 C* R# c8 S6 C( A5 c
179.                                 case JOY_DOWN_OK:        
     6 [( {3 S. r% H* b( ~1 ?2 E* [
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     4 f% G7 s! ]1 k3 R
181.                                         printf("=========================================================\r\n");               
     ) a* L: s2 C1 D5 {8 V3 Q9 y
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     ! z& N$ K5 M% U2 R
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     " d0 w+ ^: p8 ?- q. X
186.                                 
     
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     . h5 T6 v/ R. l8 B1 R- x9 `
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     / ]9 y3 D$ z3 U
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     & r3 Z' M$ t( x/ M& Q2 M0 Z& d$ Z8 q
192.                                 
     , Y& ~9 U/ r! t, ~/ s. _) z% }
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     + z4 f* S5 H7 z7 @/ r
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     3 a, W; L$ ?- H! f% s
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     7 S3 @% N  B9 M. |2 A( G
198.                                         break;
     $ W5 L' d! w% \9 F7 e! l5 j
199.                                 
     7 \# w2 x/ S. m; L3 _
200.                                 /* 释放从D3域SRAM申请的空间 */
     
201.                                 case JOY_UP_OK:        
     - o$ E( E* \$ n4 n; H$ |0 n2 N
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     - O& M# ~+ Q% w/ G3 Z# K: [
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     
206. SRAM4Used->used);
     
207.                                 
     ' }& g0 N" r8 ]1 j0 V
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     1 R0 q! S& G/ e1 K5 [& {
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     " a( X& l! q: |/ j2 p- Y
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     6 }2 o) V# S3 S- t1 u, n7 |
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     
212. SRAM4Used->used);
     / j( X2 d" M1 i( ~8 }8 B
213.                                 
     ) _; n3 U* }  D( D+ J% m
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     ) J/ C0 R" q1 w) G; t5 j
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     
218. SRAM4Used->used);
     $ a+ w6 `5 S5 F# [1 G. Y
219.                                         break;
     6 \/ f$ b, }% K" I' L, Z
220.                         
     4 q- I. C. ~5 I+ l& k  x/ D
221.                                 default:
     ( v3 Q7 t7 B% f/ Y; R4 J. K
222.                                   /* 其它的键值不处理 */
     
223.                                   break;
     
224.                         }
     
225.                 }
     
226.         }
     
227. }

复制代码

27.5 实验例程说明（IAR）
配套例子：
! x# [& t; L' x: @V7-006_TCM，SRAM等五块内存的动态内存分配实现

3 Z4 K0 O- P- r2 L- C' Z7 _$ r实验目的：
学习TCM，SRAM等五块内存的动态内存分配实现。


实验内容：
3 D, F' H9 L% K" X2 @( |启动自动重装软件定时器0，每100ms翻转一次LED2。
+ W' b* j, o+ i4 J( \  t/ C  W
/ H, h( b- R* V% q1 x实验操作：
K1键按下，从DTCM依次申请280字节，64字节和6111字节。
K1键松开，释放从DTCM申请的空间。
2 W2 m9 f  }  O& s5 hK2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
K2键松开，释放从AXI SRAM申请的空间。
K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
& a# u, m: k% ]) Q5 ZK3键松开，释放从D2域SRAM申请的空间。
摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
# [1 E- |' T1 E2 ^8 t/ E摇杆OK键松开，释放从D3域SRAM申请的空间。
% C5 f. S( E  {' O! w0 ?- A
上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1

程序设计：
5 ~1 O/ d) B9 v6 _" b0 M
: u' K. ?6 b6 U* E( w( I2 h4 t  系统栈大小分配：

2 Z9 t' I' X# ]& ^' [

% R- [; H6 Q) S% I  RAM空间用的DTCM：

* L0 ?& @1 M! y5 I% I" k

  硬件外设初始化
$ v4 J9 s% a8 o* [1 A0 }/ Z
* L! h3 ?3 k* l9 z2 C硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   " c6 ~2 d4 A8 U( \1 C
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   5 w; R) [9 r# [8 F4 C
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   9 H( w$ P- S5 A, N/ z! I
8. */
   
9. void bsp_Init(void)
   % K( _5 p4 O/ B) F6 `
10. {
    , M6 ^5 f: w1 m+ f; g2 z6 S
11.     /* 配置MPU */
    . d: y# W" x$ c4 r3 s" A  |; i
12.         MPU_Config();
    & Z9 z& L( i7 H2 a
13.         
    ' k/ ]' X2 N% u2 T4 S0 O) E) U
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    ; i% W: D0 ]+ ?8 V8 l; A
16. 
    
17.         /*
    ) R$ k2 v3 u( Z- l/ u0 W
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    4 }* ]8 i: m5 p, @8 m
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    6 j5 T/ h1 z8 i! I# _' E
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    , }  x0 @6 s9 o& V' m* w4 L
26.        - 切换使用HSE。
    9 h* U( Q2 |3 r' ~$ i
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    ( C" h, @6 w: B9 X# U/ W, c
28.     */
    ( w% ]4 B" O0 k+ k# J8 o6 c1 G
29.         SystemClock_Config();
    
30. 
    
31.         /*
    5 x' r: v/ H( c) M- L
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    0 T  {/ Z0 }& w" X5 }7 N
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    / ?4 l3 R2 k, r; Y' R0 L/ i
35.         */        
    ; P  M5 Q, y6 k
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    9 k/ G$ F7 j) f  Y7 k5 G' i/ E
40. #endif
    
41.         
    7 F' U! i4 _7 E& F0 s" l, W2 z" k
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    / `. y3 b5 R% L& o- o+ h+ Q, u9 G$ r
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    + s& U2 r% h$ u/ s; ]
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    4 E2 g2 @: i# h* o# r. `' T
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

( V1 |! R1 C' C/ Q4 R8 P- @  MPU配置和Cache配置：
- L- O' d$ I4 k  o$ ?+ j) i) _6 S2 c
! y( r2 L9 c" q- G: d. u数据Cache和指令Cache都开启。
0 u) n& y. y4 j2 v3 i
AXI SRAM的MPU属性：

  ?3 E) j& z% t! V! e  t4 JWrite back, Read allocate，Write allocate。

FMC的扩展IO的MPU属性：
5 I! E- p0 b/ Q$ m4 w. K; m% V2 V2 L
! W6 |8 o! v: [6 m. F. N. `必须Device或者Strongly Ordered。
8 z7 O: V- ]0 P2 Z! m
D2 SRAM1，SRAM2和SRAM3的MPU属性：
+ z  f6 _: s0 h4 {# c1 A
, g: A+ [$ C' X* J/ J' {Write through, read allocate，no write allocate。
8 @# t  M1 C: D1 Q. A
  f; f; w/ P8 H( Q4 {0 _D3 SRAM4的MPU属性：

Write through, read allocate，no write allocate。
% |7 p* e  J% f8 h5 P/ p! s
9 i! d  {$ t* j9 ]% ~) [! @

1. /*
   : y4 j; h3 x( |
2. *********************************************************************************************************
   6 k5 v, j3 A0 G& T* H+ t0 ?4 G
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
     Y. p0 `. x' t- k4 _
5. *        形    参: 无
   1 ~9 U8 ?: i5 \0 L# z7 ?
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   ! a" a: I! M8 O% r8 S
9. static void MPU_Config( void )
   
10. {
    $ F4 _# s& g8 b
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    5 [' d  D' ^8 ^: x
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    ! b9 I) q# W7 c1 p" D* m
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    1 ^. E1 s' c! [  H1 S
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    7 N8 i& M# g, m* q# @% L- |
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    + I. b! f$ I* E$ P! l4 `
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    ) H( u( w; D! `  e: t( b
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    + P: Y* f) W$ ^  n4 F  q
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    $ u$ U, [1 V+ z8 ~7 Q9 }* y
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    7 ?- h3 o8 L; b' t- ?
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    $ p7 C: F) \% v0 Q' u; k0 u
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    * f! W6 x! k) B1 c; g1 v
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    4 a4 {2 @5 Q% }3 i8 `7 M
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    1 |) X' L4 K8 g# _. w
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    , b7 \  B8 [" \* g5 x
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ( C& U8 O7 z, E* ~& V( M/ S
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    + X! ~% q. o7 F5 d" R7 p: H3 K; N
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    9 H) A" }& V& ]( b
44.         
    8 {/ B4 c& k& n2 R! u
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ; k0 M8 V6 I! Y2 h& ^0 F1 {- a
46.         
    
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    7 d1 o' }' a6 L- j. x
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    - w  n+ U5 u: Q
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    - G0 x9 G. w+ d
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    7 N. b) v: ]# F5 {5 ^
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    ) Z; M8 w8 L+ C
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    , ~' Z6 }' F5 V0 G
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    . d# R/ E/ Q  }9 b
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    . {7 |3 K6 N/ F$ |. @
59. 
    % B* e( Y" c) q. h( `, n
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61.         
    + c, }" k/ g1 X/ O2 ?
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    " ~- @* y# b" g* i/ i7 V1 d) s
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
      [1 P# _# V3 T& t
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    " I: e3 [0 z6 A3 g! K  l! N
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    2 W7 ^; _4 e/ c9 I) B
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    . i5 O* ?( W/ t- M1 t" k
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    6 v/ s( q7 q0 N. C$ C* H! D! b& b" {7 G
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    7 ]5 j* h. s: [8 a3 ?
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    " J" ^: H) _3 D) P
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    9 {( K6 ], U2 U9 _! K) y7 _
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
74. 
    0 @0 l  F6 P. Q) c5 a1 S. h3 A+ Y
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ' T7 u) o0 ~/ m. U' g' g# f- X
76. 
    
77. 
    
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    # M# o) d& B+ l+ Q
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
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;
    ; H  b5 ^' |4 c" S* i; O
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    . }' p2 Q7 U& P1 A% t( n7 d% ^
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    9 [1 k! w% f7 M, M
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    / @" T) W) B: X! A* M. \
90. 
    5 V0 T4 r5 b2 b
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    7 v3 ~0 H$ _! y: W+ d" H: Q' P; [
92.         
    
93.         
    & |' g) P  N6 |. n8 d2 Y( I
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    8 V5 V! Z  o( ~
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    ! ~' f6 ~; {  ?& d9 I& g. }. S
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    - Y8 Z8 m% U7 B( o9 [, [6 ?- C
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     " B6 @. ^$ Z0 v/ \% o4 L
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     9 A5 n) a2 `& a& _+ o
106. 
     6 l1 @, {8 }' [2 W2 P6 G3 ]5 K
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     9 t4 j8 X4 x# D5 q( Y$ x1 F6 t
108.         
     2 ~* x7 h% E& ^$ Y) u# X( h
109.         /*使能 MPU */
     ' S. ^5 z) d9 C
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     ) n5 Y5 p4 c% e" }. O( c- L" h- v& `5 v
111. }
     
112. 
     
113. /*
     
114. *********************************************************************************************************
     " |( e6 a+ J; B  t6 c. Z/ t
115. *        函 数 名: CPU_CACHE_Enable
     
116. *        功能说明: 使能L1 Cache
     
117. *        形    参: 无
     1 _0 r7 D) `3 t  @
118. *        返 回 值: 无
     
119. *********************************************************************************************************
     & k+ [6 M7 b7 C% N, t
120. */
     
121. static void CPU_CACHE_Enable(void)
     * ^4 [. e, q+ O0 e' y
122. {
     
123.         /* 使能 I-Cache */
     2 B6 |' ^0 i: O  K* L
124.         SCB_EnableICache();
     - R1 D6 f( _% d: C. T8 I
125. 
     
126.         /* 使能 D-Cache */
     ; @' S' P; T3 ^% |  b0 ]
127.         SCB_EnableDCache();
     + S- m! h  j$ U. w( f9 a4 }4 z
128. }

复制代码

  主功能：
; K( I& K( u5 V" t. @
7 n+ i; y6 X. A/ z' ?3 ]0 U- U3 m0 b主程序实现如下操作：

) z6 o+ v3 y& p& r& d1 m, q  启动自动重装软件定时器0，每100ms翻转一次LED2。
  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
  K1键松开，释放从DTCM申请的空间。
& u* L0 x- d6 F2 V- [( N  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
  K2键松开，释放从AXI SRAM申请的空间。
6 l0 N: P" a, u3 j' @  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
: w4 K# w% A- T( p  K3键松开，释放从D2域SRAM申请的空间。
% n5 H+ u: h8 [* Q, f  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   1 v% _: I7 Z3 F  ?0 {- |
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   . [2 D7 ?- Q3 Q
8. */
   
9. int main(void)
   
10. {
    9 h! T9 N4 [  U+ E- K' B) B' m
11.         uint8_t ucKeyCode;                /* 按键代码 */
    
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    
13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
    
14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
      s4 o2 m! D2 w8 E% F
15. 
    
16. 
    ! A- ~$ V" h4 w, D8 v
17.         bsp_Init();                /* 硬件初始化 */
    ) m9 T* _" i: R3 L3 ]" ?% i
18.         
    
19.         /* 初始化动态内存空间 */
    6 j! u" W7 g9 K0 q, R8 K
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    0 _$ Y& @7 D4 d+ C: u' H* z% f
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    $ ]* s& Z; n5 X
24.         
    * C* T" @+ P# k3 D6 n
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    - Z3 O" [9 }1 z4 j9 b4 Q+ ?
26.         PrintfHelp();        /* 打印操作提示 */
    
27. 
    9 p" ]$ J; W% m# M
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    - P0 _$ I- _2 x$ ?6 U
29.         
    - S6 @* P4 A2 v8 s2 O" b
30. 
    
31.         /* 进入主程序循环体 */
    
32.         while (1)
    
33.         {
    / O( a' P( T! ^5 d9 w, k
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    ; S6 l4 `6 `; n1 j
35. 
    8 E% h+ }  N$ ~0 s5 ?8 k
36.                 /* 判断定时器超时时间 */
    % ^, @2 e9 |! @: E2 n
37.                 if (bsp_CheckTimer(0))        
    , s6 K) r. `7 D9 ^0 v) D
38.                 {
    
39.                         /* 每隔100ms 进来一次 */  
    
40.                         bsp_LedToggle(2);
    9 N; p- Y- F2 I& d. i: \2 ?
41.                 }
    
42. 
    
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    . _2 q' `2 ^5 r) `6 C
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
45.                 if (ucKeyCode != KEY_NONE)
    + i+ L6 e- C4 ~. E4 {% W
46.                 {
    
47.                         switch (ucKeyCode)
    
48.                         {
    
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    
50.                                 case KEY_DOWN_K1:        
    ) ~) k9 A+ O9 T: p+ e
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    7 ~/ e2 C* L: [2 \: ]! L) l5 m
52.                                         printf("=========================================================\r\n");
    
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    * `6 C( _/ K- g
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    ' @" K3 d5 V; E5 a: ]( G6 r
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
57.                                 
    & I0 h! E$ ?  r5 q$ p4 k  i9 V
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    5 |" b6 x' \8 }) ~: {5 c- g
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    ; v  j) r! s$ l1 }  c1 Q# p# M
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    ! g7 }" E8 W' n/ ?8 m; x
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    3 v3 K% }7 i% I* k% u# F
63.                                 
    # ]; g$ @+ _* }8 i( X* w* s- t
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    . R( y* N1 C4 m/ b; C' L
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    ' }$ v/ f& O, j3 `
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    : |. @. I9 ^& x
69.                                         break;
    
70.                                 
    4 ?( n- F% Y9 b
71.                                 /* 释放从DTCM申请的空间 */
    
72.                                 case KEY_UP_K1:        
    
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    0 W' i" N+ D: B9 `+ Z6 P8 x
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    ; b) @6 E! S( w, e( C
77. DTCMUsed->used);
    
78.                                 
    ( V  b7 z, f$ [! C7 s  w9 G. r# d
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    3 b2 R& R& ~# E- G/ R" C; y0 C
83. DTCMUsed->used);
    ! n1 F9 e' G4 m- v9 g8 ~
84.                                 
    7 ?' I- u( ]- |1 {" c3 _, w
85.                                         /* 释放从DTCM申请的6111字节空间 */
    
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    ' m: m9 ?% O$ \/ v. m5 M! D
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    
89. DTCMUsed->used);
      k! R. R9 ~$ u
90.                                         break;
    ! p9 P( U/ J5 u0 ]4 H4 E
91.                                 
    6 e/ ^4 i, O: t( i$ I' V$ g
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    7 U" e: T2 `( M8 ?9 u5 _
93.                                 case KEY_DOWN_K2:        
    4 F% }; K' J, L, t0 T3 H3 N
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    & h6 c1 h/ _* z
95.                                         printf("=========================================================\r\n");               
    ' n9 R, E* ]9 _1 P
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    * U4 f# ?! `6 o  X/ j$ d
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    8 h; P- C8 o. o7 K
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    
100.                                 
     : E, ~3 K9 C% |, j* N# M+ \9 m
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     $ e- b" x7 T' s+ Z  I! Y
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     ) A: ]. s7 j1 J2 Y
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     & _/ X" w7 ?+ b* y6 v( e8 D. f; W
106.                                 
     
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     ; o7 ~9 T& K7 `+ `. \
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     ! }: O- ?) b* w
112.                                         break;
     
113.                                 
     
114.                                 /* 释放从AXI SRAM申请的空间 */
     , P0 }# u  x6 f- |. A2 g* q
115.                                 case KEY_UP_K2:        
     
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     6 T- F% F+ U0 B7 q2 p
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     7 T" \3 G9 \% A. l$ V* r
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     * e7 B! J& e9 C3 r% @1 D2 `- f+ U$ L
120. AXISRAMUsed->used);
     ! `" V. U6 e- ^! |
121.                                 
     * S3 b5 A6 L/ g
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     / b$ E% I% G3 @1 _
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     1 f% k) I/ ]0 p# i( F+ ^
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     " U% Y- H9 ^4 |, [5 I7 k' l7 ?
126. AXISRAMUsed->used);
     & n+ t, T6 @0 }3 V
127.                                 
     
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     & g0 A7 n7 }! B; p. Z5 s
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     9 F0 _6 D; m! X- r5 x1 Q" }
132. AXISRAMUsed->used);
     - _7 t- i- a* G  }' }
133.                                         break;
     
134.                                 
     * B: W2 G+ U5 O
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     
136.                                 case KEY_DOWN_K3:        
     8 [0 ], n* G- N, L# K$ d+ S
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     2 f* E7 f# o3 S4 @" a, H
138.                                         printf("=========================================================\r\n");               
     , U! ]: ?% L" c6 [
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     # W( o. C- O# V( O+ K- [1 I7 l$ b
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
143.                                 
     
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     & }; l8 y/ o" @. k  X  q* |$ r& {
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     2 A% n1 _0 T/ n/ T* \) w0 c0 ?$ m  I
149.                                 
     : p: O$ v9 N; ]) E1 P7 Q
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     - ^2 f% ~  g) e# I1 G# @( H
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     , N2 Y% n# B: F+ M
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     / ?& a3 ^. c0 n' ^9 M2 I( ?6 a* }
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
155.                                         break;
     
156.                                 
     
157.                                 /* 释放从D2域SRAM申请的空间 */
     % @, J6 B4 v9 V4 ~6 N$ P- v
158.                                 case KEY_UP_K3:        
     
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     3 e  Z; `- {. H. W
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     0 n* V6 R' c$ F& D1 J: S5 E
163. SRAM1Used->used);
     2 v/ G; a, q2 e& L4 g. ~
164.                                 
     : ^2 J4 j) G  r( N8 u0 J
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     2 A! r! L+ K; H6 L2 w; Q
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     
169. SRAM1Used->used);
     
170.                                 
     6 Q. ^1 m3 M& g: k
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     0 P/ {  z* Y' M  m& J- G5 N1 ]
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     4 h$ S2 n, `) W# R+ ?) ~, B
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     
175. SRAM1Used->used);
     , a% Q2 A6 @, V7 r2 g4 F
176.                                         break;
     
177.                                 
     5 |  F# f4 M: B/ J  L2 N9 L
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     
179.                                 case JOY_DOWN_OK:        
     7 z) K& T: b; E8 f: Q8 K
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
       ]+ t  m% E! |9 U2 s
181.                                         printf("=========================================================\r\n");               
     & O4 M$ m; p& l5 s2 ~+ f
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ' K+ L# U+ X, r2 _+ t8 h
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     0 S+ o+ M9 i0 n$ W8 R, S' m
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
186.                                 
     
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     
192.                                 
     + ?, N* L- a* H' R) h
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     # B/ R1 R- c6 i
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     0 r0 J" r; N! m# y! R% {
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
198.                                         break;
     8 G& ~7 M  Z/ m6 H
199.                                 
     $ A% f( A( u$ F; R
200.                                 /* 释放从D3域SRAM申请的空间 */
     7 t: `# y' S* t2 O
201.                                 case JOY_UP_OK:        
     
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     " U6 i* ~0 V2 }1 g) f% a2 j. U* a7 A
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     4 B) P. F9 @5 V
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     / _* U6 c6 P/ g* X
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     % f. g8 F+ d% G4 {: v9 y* q
206. SRAM4Used->used);
     
207.                                 
     * P1 J/ g  s: x% ^4 `7 T
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     - m2 a" r& R" g: G' t
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     
212. SRAM4Used->used);
     + K; w% O: @, {+ b
213.                                 
     2 g/ t* [& V9 D$ ?% K0 j8 z
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     0 p, R$ q) x4 |8 ^4 A7 M
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     % N8 p2 S1 }0 {( f9 R
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     
218. SRAM4Used->used);
     $ J1 X4 Y6 ^# _8 Z* U" x2 L
219.                                         break;
     
220.                         
     ) l7 b/ s# i3 l
221.                                 default:
     8 f0 Q9 [4 u# `1 m+ ^8 b7 I% n
222.                                   /* 其它的键值不处理 */
     
223.                                   break;
     + R/ [' D9 C0 F$ {, b- b- W
224.                         }
     
225.                 }
     
226.         }
     
227. }

复制代码

/ z; |0 t/ n" o27.6 总结
本章节就为大家讲解这么多，还是比较有项目实用价值的，特别是MP3编解码，JPEG编解码，视频播放器，矢量字体等需要动态内存的场合。
# w" g" S+ z( D
8 S& }& J1 [5 {$ F7 ]8 a
% t0 \2 k5 x( U+ ]7 l& V
; J9 |" K/ P2 p; @2 V  C- g