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

8 s) O1 ?9 n8 S, B3 G/ t27.2.1 MDK版的移植
8 k( d( L5 U2 k+ T, o9 P: r; H7 A: R  第1步，添加如下两个文件到MDK中
. b- M8 P5 |0 @' K注，以本章配套例子为例，这两个文件的路径\User\malloc。

8 f: ~" B8 D. i3 t

9 i1 v% [9 w# m& _: f  第2步，添加路径。
; X& ~! S& c- x, b; p

  w! i6 f2 }5 S7 X, a# g( m! g" r2 Q
" X. h1 a' p! u4 j8 n2 G  第3步，添加头文件。
如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。

6 M7 F0 l# _+ p通过这简单的三步就完成了MDK的移植。
. N  V) U: S" H5 y/ R' z; ?
2 x  R) ^" P3 e5 |; O/ f" p27.2.2 IAR版的移植
  第1步，添加如下两个文件到IAR中
9 Z3 r" c0 L* n4 c注，以本章配套例子为例，这两个文件的路径\User\malloc。
2 g: S1 |# g2 F

  第2步，添加路径。

& q0 _' Z% ?  N  i8 d
  第3步，添加头文件。
如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。
' V  h* H: o/ |* V) ?. P
通过这简单的三步就完成了IAR的移植。

9 w. s6 X1 l# J- _! |0 t& v' d27.3 动态内存的使用方法
% ]" [7 B9 Q' w, u# h/ X下面分别以MDK和IAR为例进行说明：

% X2 i1 }% w( _; O9 k: W27.3.1 MDK上的动态内存用法
0 c0 Y( L( n4 r  定义动态内存区
5 r  v9 a+ N8 f) R# Q0 x7 g比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：
2 K0 R8 {! }2 R9 Y- M
" C/ T( ?) X8 K, C' `% @( v) @0 ]

1. /* DTCM, 64KB */
   7 E# _$ v' z  ^5 \9 ^
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *DTCMUsed;
   ' O) z) m3 S. E* U6 G
4. /* 定义为64位变量，首地址是8字节对齐 */            
   
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

) D. _7 g# N  Y如果要使用AXI SRAM作为动态内存空间，可以使用__attribute__((at( )))指定地址。

! t! ~' Z. P  B! M- }

1. /* D1域, AXI SRAM, 512KB */
   9 f0 b  O, r5 H- Y- p
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *AXISRAMUsed;  
   
4. /* 定义为64位变量，首地址是8字节对齐 */
   6 D% Z: x5 |% @9 j% d3 w1 C, g
5. uint64_t AppMallocAXISRAM[512*1024/8]__attribute__((at(0x24000000)));

复制代码

  初始化动态内存区
& d% l9 u, u& ]8 X6 p: E调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：

) R8 E: A$ d4 U( ^& ^osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
  ?9 {2 D2 B! C. g$ MosRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

- k  f5 X' c. w$ s6 Y$ F  申请动态内存
通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。

第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。
2 v" m) ]# c6 o" U! |: c
- D# g/ o3 L  G) o  b. n4 J1 f& I第2个参数填写申请的字节大小，单位字节。

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

返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！

举个例子：
2 ]( f. ]/ m$ P1 v4 \. `9 T+ K
2 J2 a' k$ z" u# i' f3 M% i2 q

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   ! Y1 W4 ^" J& |/ t0 y. @: u
2. 
   
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   & M; W& @" c  l  v7 t* _2 _+ o
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   
7.                                                              DTCMUsed->size, DTCMUsed->used);
   9 o) I: K% v2 Q! i& t1 Q) I
8. 
   
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    / q' W8 ~8 Q' T( T) N' e0 S
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    . u0 v. Q0 D$ k/ M- V3 T
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

5 t% f$ M, y" N1 S. S9 B1 Y申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。

; m1 _) a8 U, a: U: i  释放动态内存
' k, j, d0 H+ I9 A  M+ t通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。

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

第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。
& L7 K/ W! w- h* g$ }9 e
% \$ F7 [4 m( k返回值，返回1表示成功，返回0表示失败。
  n( z6 ^4 B4 d
% ~6 M) m5 Y& @# d举个例子：
9 J) O7 v3 k: d+ Y' E2 \
) }! @+ O: @' Q" v, A) L/ A0 D( O

1. /* 释放从DTCM申请的280字节空间 */
   
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   4 w9 ~2 R+ [. l+ i
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   + R( h9 r/ K& a6 W/ V( A  ~
5. 
   * M" d) U6 X* F& O6 H# E
6. /* 释放从AXI SRAM申请的160字节空间 */
   
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   ' D+ ]! S9 }) g8 A
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used);

复制代码

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

5 \* N. m! n, a; [0 o8 V. h7 c  定义动态内存区
比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：
1 q& M% n9 |6 v( K
0 d, I! o; q5 j& m6 S; G7 w& H

1. /* DTCM, 64KB */
   
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *DTCMUsed;
   
4. /* 定义为64位变量，首地址是8字节对齐 */            
   ' k% [- z" J' ?( ]
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

1 O, r( t( m. h& H+ g9 @4 n6 ^如果要使用AXI SRAM作为动态内存空间，可以使用__attribute__((at( )))指定地址。

% @' R; Y" b, s

1. /* D1域, AXI SRAM, 512KB */
   6 D2 C( D3 \0 C5 g9 ^
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *AXISRAMUsed;  
   6 K, u4 x( I3 u* F! C% ^& ^
4. /* 指定下面数组的地址为0x24000000 */
     J" |1 S  j  y: ^
5. #pragma location = 0x24000000
   
6. uint64_t AppMallocAXISRAM[512*1024/8];

复制代码

4 `5 s7 u: d/ u! {  初始化动态内存区
# L! w" \. C* j, [, L8 k调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：

1. osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
   ' j6 I/ e5 q. J" Z/ V+ p( u: @% M- Y
2. osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

复制代码

  申请动态内存
8 Z$ f. O1 j: f" i) g通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。
' p  w& K0 n( K' c6 f3 Y
第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。

  D$ k: [1 g* }第2个参数填写申请的字节大小，单位字节。

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

; A. B. S  j# z# Q返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！

3 X2 |9 y8 ~3 j3 k1 W举个例子：

) X9 ~& ^8 u$ T2 J+ ?

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   
2. 
   2 o/ F+ O" e% k/ b9 v
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   + y2 Z+ ~7 G7 j( R
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   % L7 A8 T7 g6 q) m9 U$ {, L
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   " \* f' ~7 z' E! G) k
7.                                                              DTCMUsed->size, DTCMUsed->used);
   % F. Q6 ]  a; d
8. 
   0 U) Z% W3 T# o) w% i+ c( L3 g5 g
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    6 q  t" _4 H; c* `4 e( J
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    . C  E0 O. C* Q5 J# D+ c# x
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

+ Z. }! C! r' o) {: ]" ^( j. W申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。

  释放动态内存
通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。
+ P2 ?1 e& X4 F2 E3 T8 H* Z1 y
第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。

+ c7 E8 |5 {) u' s- i第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。
0 T/ ?) R7 _) q( Q8 ]- O
返回值，返回1表示成功，返回0表示失败。
- @' s/ Z2 Z6 i1 _$ Z, D9 G- b7 L
9 p5 d8 S; `5 n( U: d9 p; ?3 \举个例子：
# L! {, K: X. g' G. X  \

1. /* 释放从DTCM申请的280字节空间 */
   
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   : b0 x4 k# m! o7 R* R
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   ( Y+ p) Y) r% E! s% p4 C
5. 
   ) w/ j7 ]0 ~% m( {' T  z: ^' v
6. /* 释放从AXI SRAM申请的160字节空间 */
   ( M4 z. p  e% R. ~: @) N
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used)

复制代码

27.4 实验例程说明（MDK）
* v8 H1 I& I1 l$ T配套例子：
V7-006_TCM，SRAM等五块内存的动态内存分配实现

) e( x& F8 n2 L8 g  K; q. `实验目的：
学习TCM，SRAM等五块内存的动态内存分配实现。
- M9 d" D7 z. x; C
; ~# }2 D5 T% `( m, Z5 S1 O3 Q
实验内容
0 \. o) w9 z& }- ^启动自动重装软件定时器0，每100ms翻转一次LED2。

1 b9 s/ K$ {2 \# k2 W/ J
0 W* v3 a7 w: F. O实验操作：
K1键按下，从DTCM依次申请280字节，64字节和6111字节。
K1键松开，释放从DTCM申请的空间。
K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
9 e& D7 {' k7 \K2键松开，释放从AXI SRAM申请的空间。
. l) m: \3 C6 Q7 f0 Q2 |8 N$ iK3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
. X6 Z# V4 l# ]5 wK3键松开，释放从D2域SRAM申请的空间。
3 @  b9 l" N8 B& r0 G4 p/ M" u摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
摇杆OK键松开，释放从D3域SRAM申请的空间。


上电后串口打印的信息：

  x4 \% X7 V" ]5 t# Y( o7 \波特率 115200，数据位 8，奇偶校验位无，停止位 1
, y+ R* r% F" C; B+ B$ i5 s

3 b3 H/ n- T! i/ o) K( p! `
2 K  |" ~! M# z+ D# m4 x5 k4 I程序设计：

  系统栈大小分配：

6 E, B5 a* E: f
$ L  `: C6 ?* L, F& SRAM空间用的DTCM：

" Q7 u4 G% G0 q! l
  硬件外设初始化

) q; O1 D1 Z* _" ^/ W硬件外设的初始化是在 bsp.c 文件实现：
% j* Z) ~. \4 W. s# h! {% P5 k

1. /*
   
2. *********************************************************************************************************
     F7 P* o8 x* p/ L/ R; d
3. *        函 数 名: bsp_Init
   " X0 z( ~" {7 l/ W- j4 ?
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   / Y4 C4 B: t3 L9 M
5. *        形    参：无
   9 a" E# A' c! h7 S
6. *        返 回 值: 无
   # b* H6 O+ H" c) y9 U1 I
7. *********************************************************************************************************
   + P: U4 C7 s# P, i" S
8. */
   
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    " W# R1 z9 r% Q' q& m
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    8 Z, I1 y# z9 `9 o
16. 
    5 W: o4 i' E0 ~" F9 W* O
17.         /*
    $ B( w2 j/ v" J1 ~4 ^% L% Z
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    % q! `3 Y) C. W: k& n, o0 p
20.            - 设置NVIV优先级分组为4。
    
21.          */
    . G9 ]5 ]! R; |9 L
22.         HAL_Init();
      N" z; d" J( V+ S$ F
23. 
    9 h) Y* k* w) O2 l& f6 `3 a8 P
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    + z# I8 j. p( h6 f. t* ?/ B* a( [
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    / V. c9 s9 D* u; P; W) A
29.         SystemClock_Config();
    ! U3 c. h4 m2 M0 t6 i
30. 
    
31.         /*
    ! N' I, [, s6 Q+ D0 Q
32.            Event Recorder：
    1 A6 v8 G! N' p2 o$ E/ _- V6 o( d6 ~
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    * I6 b. i2 _+ f* B$ u
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    $ H) i6 r9 U3 I' X  y1 C1 F; M
35.         */        
    1 m7 ~4 f" F4 |* T6 @- n, q6 M
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    7 C2 L# `/ \1 I
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    
41.         
    / g% w, u6 O6 A: d3 n; [
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    * ^. V( j" C0 P2 x+ N9 Q
44.         bsp_InitUart();        /* 初始化串口 */
    9 H: x% h0 m9 D# T* S, ?! P7 I
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    * |' o7 k( u" o* K1 _
46.         bsp_InitLed();            /* 初始化LED */        
    * |+ }1 R  _5 H2 Y
47. }

复制代码

  MPU配置和Cache配置：
数据Cache和指令Cache都开启。
: p5 _/ y* |! i1 g/ Q* Z) k
AXI SRAM的MPU属性：

Write back, Read allocate，Write allocate。
; ?! w/ }3 @" f% m* C; Q: U
FMC的扩展IO的MPU属性：
3 w! C) c# s  ^* P
必须Device或者Strongly Ordered。

/ Z4 y) \. H/ W" PD2 SRAM1，SRAM2和SRAM3的MPU属性：
9 v* G$ r- L& e: g; F
Write through, read allocate，no write allocate。
4 W4 g; ~, M! H7 {: l
D3 SRAM4的MPU属性：

# j& o9 U  B& B6 b: CWrite through, read allocate，no write allocate。

9 x7 P" i1 \; a& K, z

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   # x8 L  J% [1 G& P. P# k. P
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   ; d9 X* r3 n3 \( B; j; _
7. *********************************************************************************************************
   8 \4 l$ m/ G8 Q5 s- `
8. */
   
9. static void MPU_Config( void )
   ! s+ L% A7 ?5 \3 g: k7 C7 M
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    ' W5 f# R/ q. t; c; ]; D
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    . f/ w4 m3 {4 K7 c' T9 _# t& C
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    / p/ w% n! c7 i9 U2 X
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
      n1 W6 a! s; K: i  L
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    $ J0 T4 N4 l: `1 R2 S! U
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
      s2 j/ P) a4 E, d
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    7 X" b5 o$ M: \5 r7 q7 e% U
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    $ j& y* U7 i( G6 }  a0 `
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    % K2 C5 O+ E$ [: d, {0 f% _
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    1 Y# ^* h% K' @9 L0 R
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    4 f/ C& E& Q- a/ o3 b6 ?+ S
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    % @/ N5 o: B* [. o+ U8 ?% G8 h
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    * D, W8 i8 e# F8 E3 l& B* u
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    7 ]3 j) ?4 W$ o- g& z9 P4 b
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    : M& V" C3 e' H, _5 z2 L, u
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    & H  J. `3 \5 c7 c( b1 z; o; \
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46.         
    
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    4 b' z  W* Q% s+ L; w4 q! I7 j
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    # d, J: Z  i0 T0 D, i
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
      G0 O; P0 ?$ G' u- h0 G
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    # w: U- `. a& G. l
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    - d0 |7 S6 i+ ~) v
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ( ~" o# V% R/ ]# W5 `
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    % H7 C; x- v3 Q8 R& d
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    ( h) q5 C  P4 S
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    8 E8 ?& r) r, j) G- B9 O/ X
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    7 @' a$ H, f& o8 N4 L
59. 
    $ }6 Z9 p3 r: U6 ^
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ) z* o7 Q+ g, _( `2 v
61.         
    
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    2 n! O3 j- m. t, V, k
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    2 X) @. m* x' O+ D  B5 V5 o/ H, w% j
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    3 ~6 t7 \0 i( @( I( c
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    9 Y% l' R+ H' J# ?0 x; Y
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    # k5 c0 b! g8 z2 U" v) W! ~
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    : y1 }% b3 I; X3 A* g) S3 `
74. 
    
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
76. 
    % X( ?* g: w; ?5 _$ A0 w6 {4 E+ K
77. 
    % v9 A7 y' l9 k3 r! E* _+ d
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    - E) {5 P, u5 C$ s- {1 w1 L
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    ! m* Y* q, @: l7 Q/ U
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    ) C- q; m) P4 E$ o! k4 `' N
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    * y" D: }: L1 z; n$ Y9 b* a2 `
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    4 I* _* `8 e% O' q% e# t" F
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    # u% N, G# `9 ]' i4 A0 G
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    4 e3 ?1 N& {6 k$ q
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
90. 
    8 Y6 ~" X5 E% i4 e
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
92.         
    # X/ p0 _2 C* E" g
93.         
    / g+ S1 s/ t4 i2 A0 N7 \
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    & ?# B6 ]5 f3 R
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    ! [# S' B8 m1 a: S2 Y
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    , ^+ \; P9 B& m8 I. q9 M) I# R* {
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ! ?* z# N4 N5 Z. Y& h& {
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    0 s  R$ ^  U- _
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     
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;
     
106. 
     $ m0 P  s3 u% Q7 f$ b' A* Z+ e
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     
108.         
     " r" \4 z7 V7 q# G! f
109.         /*使能 MPU */
     1 n4 d/ O/ ^; ~( P( B+ o7 m) @: k$ F# F
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     ; N4 g, f# R. j+ i4 s
111. }
     
112. 
     
113. /*
     2 r; m8 }+ l  \9 g2 A% \! X% M0 g# O
114. *********************************************************************************************************
     
115. *        函 数 名: CPU_CACHE_Enable
     
116. *        功能说明: 使能L1 Cache
     % ]  G$ l8 f% e& R  T4 v3 {0 M& K
117. *        形    参: 无
     7 X% N! W  m' _2 J5 ]
118. *        返 回 值: 无
     
119. *********************************************************************************************************
     / |$ c; J& G. \4 x) _
120. */
     
121. static void CPU_CACHE_Enable(void)
       k& [$ E& A# L9 j+ L
122. {
     4 M2 q7 C/ T' R& f
123.         /* 使能 I-Cache */
     
124.         SCB_EnableICache();
     + P: g8 W7 N& L5 t6 d9 R
125. 
     2 }7 J% v. ]  t3 K- S7 }
126.         /* 使能 D-Cache */
     
127.         SCB_EnableDCache();
     $ r: I5 B7 W' v" N) Z" Z4 {
128. }

复制代码

  主功能：
$ |: u) L% s3 l9 Y7 [' M
4 g5 O' {$ [/ a, `- j% [7 r( X主程序实现如下操作：

, X" V+ y; D. g  启动自动重装软件定时器0，每100ms翻转一次LED2。
  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
+ R" M- ]( s% n  K1键松开，释放从DTCM申请的空间。
$ c% m8 N+ T7 J. o  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
* G$ f/ g: c5 j3 V  K2键松开，释放从AXI SRAM申请的空间。
  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
  K3键松开，释放从D2域SRAM申请的空间。
  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   , b# ^$ I& O: @) X) e
2. *********************************************************************************************************
   $ m, p! u1 I/ I) y* A( Q1 E& E+ j. Z
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   3 J- f' B. r. r; v, {$ c7 [
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   ( O6 S+ H, |) f3 H1 U* n3 Y) k
8. */
   
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    0 y2 ~- H5 G/ ?2 Z$ \0 g
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    8 D3 p# J+ M& D7 [
13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
    9 [  Y1 F5 @$ F9 v
14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
    * B  }5 V; O3 Y1 n- I: r% J
15. 
    9 Y8 J1 I, e4 Q- Y8 c. W
16. 
    & m) N3 P, t& F1 y% M( U4 m
17.         bsp_Init();                /* 硬件初始化 */
    2 y- Z; G! u6 X+ i! ^7 z5 D
18.         
    
19.         /* 初始化动态内存空间 */
    + x/ @. [- a8 D* z% {
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    2 C& n, {" B1 X2 Y2 J3 P8 ?, S
24.         
    
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    2 n1 F1 J% A3 K. [
26.         PrintfHelp();        /* 打印操作提示 */
    / I( {+ P) t8 `  s' a3 x, t
27. 
    
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
29.         
    ) H0 g0 r* g& g* U2 c% D4 \2 y* s9 A
30. 
    
31.         /* 进入主程序循环体 */
    
32.         while (1)
    . j6 M) K( R1 K. u
33.         {
    . o0 K2 U+ G' \! p
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    6 z- }( p% C0 z$ h, {) j# L
35. 
    # h! u, P+ w* h! r
36.                 /* 判断定时器超时时间 */
    - ^% S) a3 J$ N) \
37.                 if (bsp_CheckTimer(0))        
    # ~2 Q! Z7 T$ i+ g9 `" U1 `8 M
38.                 {
    0 K$ C" s4 S# l) j5 _8 K
39.                         /* 每隔100ms 进来一次 */  
    8 M% {' x4 F% y- s" v
40.                         bsp_LedToggle(2);
    4 g) @5 C& ^6 L, `  _6 {
41.                 }
    
42. 
    , W- e2 a6 A4 E( `, I6 R
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
45.                 if (ucKeyCode != KEY_NONE)
    
46.                 {
    - y, a; G4 u' }5 c8 ~
47.                         switch (ucKeyCode)
    % r; B. E8 v# o4 X6 k) K  m
48.                         {
    3 |: |% v& e; M0 H$ T
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    " b1 Y' r% h2 I, e% G) v
50.                                 case KEY_DOWN_K1:        
    
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    1 V: r9 ]! b+ P
52.                                         printf("=========================================================\r\n");
    
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    " W: D+ ]8 B4 R$ t
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
      F" z" n3 T% F
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    6 n9 y8 g- i+ w' j; k9 q
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    + S  t0 z, x; ?! g
57.                                 
    
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    + C( H$ b7 Z9 n4 k1 I
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    ( j  y! p0 E% h: e6 G* P
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    ( A- L5 c* d1 y0 w" f: w+ r
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    / B* d5 ]2 L. |, B" F1 @# r5 R
63.                                 
    $ H+ j9 N/ {# [) I1 L
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    6 i& T9 h; W: K
69.                                         break;
    5 M. n$ b: G* A+ U
70.                                 
    / \8 S/ f1 `& F7 B. h* g8 v& B
71.                                 /* 释放从DTCM申请的空间 */
    $ Q2 G! ]9 E+ i) H; g  |9 n; z
72.                                 case KEY_UP_K1:        
    ) Z( B- F7 U. ]; q4 J3 l2 V
73.                                         /* 释放从DTCM申请的280字节空间 */
    5 ^. w, Z% S( G, K9 X+ D
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    * i& x7 q" G$ T/ a  K4 D% @, n% @
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    & t$ d- @0 R% {4 z" W1 H
77. DTCMUsed->used);
      _$ s7 \2 M& i: N6 p: V, F( H
78.                                 
    
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    , G! k$ v: E- G  h! ?
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    8 \/ m( g: M0 u+ a
83. DTCMUsed->used);
    - N) V  m0 j  Y& Z$ `( a) j% S
84.                                 
    
85.                                         /* 释放从DTCM申请的6111字节空间 */
    
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    0 a) t# I  D2 v
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    ! H! D* A: M$ D' {  A9 C
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    
89. DTCMUsed->used);
    4 R/ c. L% _1 `- P4 U1 e
90.                                         break;
    
91.                                 
    , v8 Q9 H* P1 D& O, \  v  F
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    6 R) v4 f3 j0 K( l$ D$ [& _  ]
93.                                 case KEY_DOWN_K2:        
    $ W, `' [# Q# B+ l- P4 Q! p
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    
95.                                         printf("=========================================================\r\n");               
    7 w1 Z! ~! A1 v$ m
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    9 {2 c  s8 E+ D' X- b7 P5 Z
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    9 i# ]( g1 p. R# P8 A6 p) K
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    + I+ @+ F; O4 k& k! H4 V% o
100.                                 
     
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     1 m9 O5 z4 _9 A8 c8 ~$ O0 a
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     6 K2 H" U6 ]5 y5 Q0 ?* K' g
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     : I/ E, Y, D4 K. U. |" S. F
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     0 q2 n0 o# \& d4 F) E& m# g& m. P& ~
106.                                 
     
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     : |4 q/ f) L6 d4 y! n
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     ! r) U% U# [8 H# G5 a9 G9 y' }
112.                                         break;
     
113.                                 
     & Q1 v/ @$ [/ B0 {" o
114.                                 /* 释放从AXI SRAM申请的空间 */
     * o! I3 N  L3 {' k
115.                                 case KEY_UP_K2:        
     9 z. n! S6 X" q  H& p% k
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     ; J/ l) ~$ [6 ?9 Y5 }: P
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     8 Q, [& r: P8 |- ]+ ^# O. y; j9 E
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     4 m2 D5 k5 B2 i! Q" I# G1 ?' M! V
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     : U% G4 f2 U- a) i4 }! G
120. AXISRAMUsed->used);
     1 w) \) Z/ m+ j
121.                                 
     8 F  G  O9 h* B* A; f) s# n- O2 z
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     $ t/ B8 E3 d0 {% H# f
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     1 J; A+ u; s  i7 D, w
126. AXISRAMUsed->used);
     
127.                                 
     , h: N# @$ N; \, {4 M4 S
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
       u, P* J  @6 ^$ ?$ a( G& [" _" m
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     
132. AXISRAMUsed->used);
     
133.                                         break;
     
134.                                 
     + H$ O5 o  o+ T/ W$ z+ `
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     
136.                                 case KEY_DOWN_K3:        
     ) p* T- w9 E& H) }4 e& X
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     % w% b7 \, j$ @5 g4 t) q* q
138.                                         printf("=========================================================\r\n");               
     
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     : ^; ]: j$ Y) `. P9 ^% g
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);
     : F! Q$ J+ p1 Q9 H' ?6 N
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     + _* Z. P. E1 e8 @! ~- M
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     $ c! Z8 x( E6 l
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     
149.                                 
     " J# R6 ?) s0 t4 D  {$ m
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",
     
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     1 m5 o# C+ }) y- z) K: S
155.                                         break;
     ) v% j- Z9 z( t0 W3 G
156.                                 
     3 l* E" H  \" |/ D+ O, f
157.                                 /* 释放从D2域SRAM申请的空间 */
     
158.                                 case KEY_UP_K3:        
     
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     + K: j+ k/ f7 M. A, }6 }- W3 n
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     ( ^. r7 `. M/ {) N
163. SRAM1Used->used);
     
164.                                 
     3 Z- {7 ^9 h" c. T4 a8 w
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     + `8 u8 e) u$ G5 x
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     / w7 O! g8 S& [' K5 E, X# t, j4 z2 Y
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     3 I% ~" g# ^* T# ^+ S
169. SRAM1Used->used);
     $ h4 |2 x* @" O
170.                                 
     
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     5 f+ b+ O2 `3 F$ {9 S& i$ D, Q
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     2 ?# G1 X. o- L
175. SRAM1Used->used);
     
176.                                         break;
     
177.                                 
     - v# L3 g1 w, B' Z$ A6 t- q$ m# l
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     
179.                                 case JOY_DOWN_OK:        
     
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     / f! |: z" C. x; `, F6 V: k
181.                                         printf("=========================================================\r\n");               
     
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     9 T6 L# a# q1 z* u0 n
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ; e7 W, [4 n! ~/ a
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     ; g+ [- q7 e1 W5 c
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     1 C+ B9 |( N9 A5 w8 I/ w+ U
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.                                 
     ' A7 U, j9 e- N+ u# v
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     + ~( c4 s; S$ U, Q; o
198.                                         break;
     ) j8 ~) a7 t/ ~6 g. _. x. ^
199.                                 
     " P1 t8 K1 a' I' x+ g8 ~
200.                                 /* 释放从D3域SRAM申请的空间 */
     # q* P9 v7 P" V* f
201.                                 case JOY_UP_OK:        
     
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ' n) D9 x* y& F* C- j( s6 I
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     
206. SRAM4Used->used);
     
207.                                 
     8 S, I& L; E3 f" S
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     5 f+ \9 T5 Y4 ]3 c2 u8 _2 K$ d. S
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     , I" D4 I  b1 Y3 s1 O+ W% n
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     
212. SRAM4Used->used);
     
213.                                 
     
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     1 C2 F% K" V' p& N% X; h" F  |
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     
218. SRAM4Used->used);
     
219.                                         break;
     ( b  ^5 K8 B0 u  n: _" T. k
220.                         
     
221.                                 default:
     
222.                                   /* 其它的键值不处理 */
     ' L1 W1 C- t- o
223.                                   break;
     
224.                         }
     8 b5 n. M" o3 d! i7 A
225.                 }
       i, n' M- Q: z
226.         }
     
227. }

复制代码

% \) m, |: T! e7 g2 P" Y4 s* w; p4 Y27.5 实验例程说明（IAR）
配套例子：
; d4 P' A+ v" ^7 Z, {& ]+ _V7-006_TCM，SRAM等五块内存的动态内存分配实现
: x9 j4 ~/ s1 O
3 v7 u2 u% ~, U) g4 N% z" b! H实验目的：
学习TCM，SRAM等五块内存的动态内存分配实现。


实验内容：
  N4 b7 d  u4 W* ^启动自动重装软件定时器0，每100ms翻转一次LED2。

实验操作：
K1键按下，从DTCM依次申请280字节，64字节和6111字节。
K1键松开，释放从DTCM申请的空间。
$ ?5 e- C1 b+ o( _' p, h& LK2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
, Q" |6 q2 Q; T! n) h9 @7 m# \K2键松开，释放从AXI SRAM申请的空间。
( J; M% L2 {. `4 m$ ~; `" tK3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
K3键松开，释放从D2域SRAM申请的空间。
摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
" ?; U/ u( a8 `6 t4 w+ K1 y$ n, x摇杆OK键松开，释放从D3域SRAM申请的空间。

上电后串口打印的信息：

8 f2 l- T' E* s# v1 D波特率 115200，数据位 8，奇偶校验位无，停止位 1

: a+ A5 `" P& S+ Q+ D

" s: I8 v- q' p' U' H1 D0 G) f程序设计：

  系统栈大小分配：

2 a+ S0 V3 R0 \3 a9 E3 a  RAM空间用的DTCM：

0 ^2 s" K# ^. [8 a( n! {4 T) S

  w( h0 P; N, i  硬件外设初始化

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

1. /*
   9 |8 l; ^3 N( @7 g
2. *********************************************************************************************************
   8 ?7 C" W" c% w0 x0 N* o* |; \
3. *        函 数 名: bsp_Init
   ! V& U" C  }  B9 j2 [8 W' D
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   ! t! r+ V: w4 h1 c
5. *        形    参：无
   
6. *        返 回 值: 无
   # P- y' g1 G7 }0 S. G
7. *********************************************************************************************************
   1 }; h. @* R7 M" k& V
8. */
   & q- Y9 J( f7 b6 p! g
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    % [* E. ^( b  Y1 c# A$ Y
12.         MPU_Config();
    
13.         
    - [$ p: F" z2 g6 T6 M
14.         /* 使能L1 Cache */
    9 M) {5 o& R( w$ }0 E
15.         CPU_CACHE_Enable();
    
16. 
    ; u- ]9 }' R/ h9 d, y2 l+ h
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    
23. 
    
24.         /*
    9 J# S0 g! O7 ?& e
25.        配置系统时钟到400MHz
    7 }! ~* P3 x8 l
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    # L  i$ k" _" D" H
29.         SystemClock_Config();
    4 f, V! t  j+ Q) T* k1 W2 \' E
30. 
    
31.         /*
    $ v- u! r- j+ u/ M& A9 I9 O
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    # J- s: d  r: s
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    ( c- I# B: u+ c
40. #endif
    
41.         
    , Z; V8 o& B( R9 h; n# z
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    7 r% p# N' S, r
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    $ l2 p& H4 p6 |2 J; N* {
44.         bsp_InitUart();        /* 初始化串口 */
    ( c* ?2 {1 J8 L- E0 \
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    1 `1 s) r4 M  O7 }- n: ]$ s
47. }

复制代码

  MPU配置和Cache配置：
1 l6 M1 P1 v7 q& y* ^- n
8 V* E$ y6 x' _) a/ D  M' T数据Cache和指令Cache都开启。

: P. Z" D, ^6 yAXI SRAM的MPU属性：
+ H. S) Y6 l' [+ W
2 H0 J, r# M9 Y" z; nWrite back, Read allocate，Write allocate。
& K) g1 b) q8 J' s. q. V, W
! n! g9 h0 u& X* `, M. ]( _6 jFMC的扩展IO的MPU属性：

必须Device或者Strongly Ordered。
9 q) P) A* ~, I* ^' D3 U, _- B
D2 SRAM1，SRAM2和SRAM3的MPU属性：

Write through, read allocate，no write allocate。

& x6 E7 L( P2 X/ O; R: JD3 SRAM4的MPU属性：

Write through, read allocate，no write allocate。
) z' b8 ]4 {5 O9 S; L

1. /*
   : W& ~9 M: t, E1 ]. A
2. *********************************************************************************************************
   # I2 E( y3 \3 P9 {# d( X; j) s
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   0 o5 _$ ]' F2 y- G
5. *        形    参: 无
   
6. *        返 回 值: 无
   + v3 X$ D; |$ q" |4 |
7. *********************************************************************************************************
   $ o2 l/ n( k. S3 R3 ]
8. */
   ' I+ z; P" y$ r& b9 _7 P# [+ a: X
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    5 M9 l. }8 y, Z- |4 n; p! W
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    , \- R4 z4 p: x8 ^
15. 
    7 I. I* O. u+ ^% V
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
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;
    5 I7 S$ Q( V5 O! u
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
      H* X! x: ~( `% F
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    , s4 F8 g1 I0 x) G( v) K8 o
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    4 L$ X/ t* q  N6 [
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    2 ^% k0 T8 A, k  `8 B) u
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    5 t5 c! Z( S$ P1 g/ _4 ]
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;
    ' V( t' r1 }% y; r4 N" p
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    " G, x- M3 I6 l) N
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    , Y: v1 Z* |! R) \" A( K" V
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    1 D; e. K- z6 O+ v( [
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46.         
    
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    . t' W% b% C+ f, x; P
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    / M4 D( r7 B: N5 B! L
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    4 G% J6 Q+ g  ?" U- p& Q
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
      P2 A$ G1 _. d0 [$ Q4 e& L5 x8 c% M
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
      L6 L/ e, |& h! ]5 o) r3 x& z
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61.         
    
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    : V0 H1 \- B- Y8 F" A& M& j
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    0 a8 ^7 a; ~) R# m# K
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    4 E; u! \: m  _9 w0 z
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    % Y' U* |# F2 p8 }! J
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;
    
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    # O+ R0 W6 v- E+ G1 J0 a
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
74. 
    
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ' r$ z7 g4 a) N/ M$ J; W" k2 j" F
76. 
    + T. z/ `0 k: P% J* T- p; E
77. 
    
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    4 F+ o' a, J  ?$ ~- L+ H
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
      Q3 I; C/ u+ K4 K
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
      A8 N9 Z5 n0 V" A( Q; E$ I) g
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;
    7 `; B  P1 ~" U, ]
90. 
    
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    & s" V( O4 O; H$ V
92.         
    7 g+ |5 T% U6 f2 i  H! z
93.         
    
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    ! L3 I) P* {. n' Q2 q
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ' h5 s* M6 G9 V; i
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;
    
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     9 z9 T! [) ?, S. B' ?5 z0 F
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     " _( r. e9 o9 _, N2 |4 b, n" D  I
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     : m, R1 ~9 _9 K4 E; q
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     : O( E+ I2 X. D3 J+ d( F4 J7 T
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     
108.         
     ( }/ n: T3 j' h7 Z# u1 \' T
109.         /*使能 MPU */
     2 Z$ ~, Q" [# _7 x
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     8 C1 g2 w6 m9 F0 a; d' {
111. }
     
112. 
     
113. /*
     
114. *********************************************************************************************************
     % g$ O6 t7 W( U0 n
115. *        函 数 名: CPU_CACHE_Enable
     
116. *        功能说明: 使能L1 Cache
     
117. *        形    参: 无
     : i4 b4 w4 r. E
118. *        返 回 值: 无
     ! a' @5 n; i" M
119. *********************************************************************************************************
     $ E# n& c( x  S' z' m9 G" k% Z
120. */
     : P% G  \. P2 D! P( u
121. static void CPU_CACHE_Enable(void)
     
122. {
     
123.         /* 使能 I-Cache */
     
124.         SCB_EnableICache();
     
125. 
     ! c- n, T( X4 u, W6 p7 X7 N7 \
126.         /* 使能 D-Cache */
     3 Y; N3 M9 `1 g* t" \
127.         SCB_EnableDCache();
       s6 B8 R3 g, `* }: F9 |% Y
128. }

复制代码

- O' ^% U# O( j# D  主功能：
" F  e1 z7 P! B  ^/ Z2 d9 J) o' \
' O; p; J% ?5 J3 l  |' _9 J主程序实现如下操作：
( ]* C- {/ g8 ]: L- s
/ B( q: A" V7 t: l" O  启动自动重装软件定时器0，每100ms翻转一次LED2。
7 v' P7 V3 `, d) A  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
  K1键松开，释放从DTCM申请的空间。
  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
  K2键松开，释放从AXI SRAM申请的空间。
  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
  K3键松开，释放从D2域SRAM申请的空间。
: J+ e6 \! ^- \4 J' _$ |  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   " E2 e) U  g2 n
2. *********************************************************************************************************
   
3. *        函 数 名: main
   $ w1 n* ]: w7 V2 Q+ P& S' X
4. *        功能说明: c程序入口
   * U5 Q0 e4 O& Z8 P4 D8 c( o# ?5 \' s8 X
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   + S* [0 L; q% v& v; H7 D; e
7. *********************************************************************************************************
   
8. */
   9 T4 ~9 Z/ G7 Y7 K) v
9. int main(void)
   ( f5 K8 u, I# a+ G1 Q0 u# ^
10. {
    # p* L$ |/ t. U) H* t
11.         uint8_t ucKeyCode;                /* 按键代码 */
    ! A' `! A  Y8 q1 m& 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. 
    : M* M5 G0 ]7 G% p1 S4 u2 T5 Y
17.         bsp_Init();                /* 硬件初始化 */
    
18.         
    & D( Q' o8 A$ m+ H( k
19.         /* 初始化动态内存空间 */
    
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    
24.         
    ' z# i: y8 T# l! K
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    3 ^6 q* O# \3 A
26.         PrintfHelp();        /* 打印操作提示 */
    ' O4 E7 p$ B/ G2 E8 u
27. 
    
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    " C7 v$ V9 X# c! B0 Y: `$ T9 ~  I: Y4 I
29.         
    3 Z; ]9 ]2 C- w; X- W+ v8 R; K/ K
30. 
    
31.         /* 进入主程序循环体 */
    
32.         while (1)
    $ h* V6 v* }2 y
33.         {
    9 h0 r" g* i  U5 ~" ^6 M
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    : `! A6 a8 a9 S3 h% S2 ^
35. 
    
36.                 /* 判断定时器超时时间 */
    
37.                 if (bsp_CheckTimer(0))        
    / S/ Y' T4 P. _; u% |% d1 D  U' r
38.                 {
    
39.                         /* 每隔100ms 进来一次 */  
    
40.                         bsp_LedToggle(2);
    
41.                 }
    
42. 
    / P$ J9 P" L( w' K
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    & j2 x' ]+ I6 k) p9 w8 e4 f
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    ! O+ ]! X  o8 k* G
45.                 if (ucKeyCode != KEY_NONE)
    
46.                 {
    ; |0 R+ ?" h# a+ t* M2 x6 M" r
47.                         switch (ucKeyCode)
    6 D6 c$ @4 @; W" n2 V" L9 c0 O
48.                         {
    
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    
50.                                 case KEY_DOWN_K1:        
    * Q; p/ T9 K* B
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    7 w  o3 ~9 `, y8 m0 o5 T* P( Y& G$ t
52.                                         printf("=========================================================\r\n");
    
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    1 f1 `& c) F! k- \  Q: o3 r2 e
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
57.                                 
    $ X3 p: b+ r6 W5 E# e
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    7 z! c( H4 h( n2 T/ W
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    ) F* F) k% D6 _6 r' l% A/ z6 J
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    1 E. [! v0 n9 o. K2 v$ H9 T$ q
63.                                 
    
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    5 v9 P/ d5 v- ?' X
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    " `9 w# @+ ?. E/ q& L* m
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    : z7 z% A% ?# R- E' q$ I  J
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    # e; \/ E7 M/ u: d4 }$ K$ ]
69.                                         break;
    1 N! u. m9 S5 r3 k1 z2 E8 M
70.                                 
    & a. A0 C" j! F7 M
71.                                 /* 释放从DTCM申请的空间 */
    
72.                                 case KEY_UP_K1:        
    
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    . h) |4 [# I* g. J0 r9 j1 t
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    # D- |' c! L, f0 V- X
77. DTCMUsed->used);
    
78.                                 
    ' Q: {9 U% ?, b' }
79.                                         /* 释放从DTCM申请的64字节空间 */
    & C) k* T0 E; D# \! C
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    ! |1 |# f0 a+ @( d; n8 J$ H
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    + v+ D( C! N5 l% U& P$ ~" v
83. DTCMUsed->used);
    
84.                                 
    
85.                                         /* 释放从DTCM申请的6111字节空间 */
    
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    3 y0 Q4 e0 x4 [5 k1 D. t' l
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    ; Z6 ?9 \( c4 k
89. DTCMUsed->used);
    ) w7 G; x1 Y2 M2 T, x* _4 _2 f  a
90.                                         break;
    
91.                                 
    
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    
93.                                 case KEY_DOWN_K2:        
    
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    * {* H( E4 M5 l' ]' w( u
95.                                         printf("=========================================================\r\n");               
    
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    ( w, Q( Q  B: K0 u1 s7 X( A
100.                                 
     2 t& _( y; I# {" j7 J
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     , [3 t. c! d1 ^9 D0 \$ j4 s4 S
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     % m# }* ^# V* t7 u+ S1 _
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     7 V2 h1 B1 F4 n
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);
     9 u, R: y: |( R
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     6 O: M; W5 r# W  ?
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     * ^7 O) q& a( S4 f- G
112.                                         break;
     
113.                                 
     3 z$ k: U+ t/ p2 T
114.                                 /* 释放从AXI SRAM申请的空间 */
     
115.                                 case KEY_UP_K2:        
     ) X, p1 N  ?$ v/ |  Q$ b
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     % F  P( ~1 w; F3 U0 e4 x% _4 Q
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     ' l. Y$ n5 w- k' C
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     4 {- Q2 z% B- z% A% w4 J
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     
120. AXISRAMUsed->used);
     * S% H$ _8 B) [2 `8 {2 Q! G
121.                                 
     
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     3 P. h! s  `4 I3 {! s; f
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     ) x, h0 K( N  z1 |" s& f7 c' M
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     , d; C3 r  W' }
126. AXISRAMUsed->used);
     , T. @; t2 {5 M4 q  {
127.                                 
     ; E; S" i7 I: a& m
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     
132. AXISRAMUsed->used);
     5 F% p! J) u5 U
133.                                         break;
     - _0 L6 ^$ V; @2 |4 N$ f) }: J+ [
134.                                 
     
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     
136.                                 case KEY_DOWN_K3:        
     ' ~0 q1 x3 z! m: n8 n
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     9 C$ y+ \( T& Z) l
138.                                         printf("=========================================================\r\n");               
     5 b8 o& o, z+ U5 ^0 `+ i- W% U
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     & L8 X" U8 m& F! ~( [) H9 C
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     6 y  d4 ]) o: `9 a0 p
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     : t6 \! x! n( Y
143.                                 
     0 p) F' m$ K4 y) t0 y6 {
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     $ D+ Y( y5 [1 x1 a0 C
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
       N, v1 S6 Y# ~) y( @0 S1 c
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     
149.                                 
     
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",
     
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     - K! |: f1 x) ?5 }! [: f. W) [9 R
155.                                         break;
     ; p* v0 N- M8 ^5 n: @7 i1 E
156.                                 
     
157.                                 /* 释放从D2域SRAM申请的空间 */
     , E5 K9 c  V' H, j# k. {
158.                                 case KEY_UP_K3:        
     * O# G0 k7 Q+ C; n- H, N/ x, k3 F
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     ! Y6 k" O4 P! Y% i8 |* {3 f$ p! }
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     9 h( C$ r4 t% R, }: s4 a5 z
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     3 p- m) b' c2 R$ _9 y  @7 Q: D1 u
163. SRAM1Used->used);
     + ]$ B& P3 d$ H2 b' S- l& e5 l
164.                                 
     3 A' R: b) k- H' L# v. G
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     / A4 ]6 d' e0 p' e+ B
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     
169. SRAM1Used->used);
     % {; V0 J1 C: i- s
170.                                 
     ) k9 S! I$ T4 G8 N  m; G8 c# t
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     0 H2 w. E! q. o$ ~. z$ I, ~
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     8 b* y' C8 A/ x. Y* n
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     
175. SRAM1Used->used);
     ; @$ c7 Y, b& D# {4 o$ _
176.                                         break;
     ; J, O& u' F- s/ C
177.                                 
     
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     
179.                                 case JOY_DOWN_OK:        
     
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     
181.                                         printf("=========================================================\r\n");               
     ' ?2 n2 U5 D. m, U5 T
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     ( s' T- d8 s3 O3 _0 \3 }9 P
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
186.                                 
     * A6 R- X& o# N' }9 j
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     8 S! H; ^# Q) f4 q9 [! [
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     
192.                                 
     ) l; J% \5 s4 ?$ I
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     4 Y0 a: L/ W: z2 _  y
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     0 `3 B3 M) u( ]6 ~
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     : ?& Z: Z* Y, `
198.                                         break;
     
199.                                 
     
200.                                 /* 释放从D3域SRAM申请的空间 */
     - I; i7 ?% w" K% t, e$ V
201.                                 case JOY_UP_OK:        
     
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     
206. SRAM4Used->used);
     ! n# [) g/ ~( V5 g+ n( ~" g. b% W
207.                                 
     " N+ q* {+ g2 E) U) Y
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     " Y9 w" G/ W0 j: D
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     ; D. k3 L' ?0 z. a( p% s
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ; h( c; b# D  u- G# |' y. N
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     6 E2 ^  a, b' E4 v1 e) Z  l
212. SRAM4Used->used);
     
213.                                 
     ) v' `' X! [% j+ v
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     5 F9 L, D: |6 B7 }/ {/ f
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     1 u, z) M. B* m! O- N) F* X
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     
218. SRAM4Used->used);
     4 G/ T+ ~; y% v) R  l
219.                                         break;
     
220.                         
     
221.                                 default:
     ! j% j* A/ Q& ?
222.                                   /* 其它的键值不处理 */
     3 \( T$ F& b) e: z4 ^/ F6 C
223.                                   break;
     
224.                         }
     0 _6 b( A/ Z( K: S
225.                 }
     6 i& g. g9 ]# x% ^( T& r
226.         }
     / Z5 A- U4 f: A# L1 {1 B! w7 ?
227. }

复制代码

0 {. F4 p' O: {6 f. y/ I. [27.6 总结
本章节就为大家讲解这么多，还是比较有项目实用价值的，特别是MP3编解码，JPEG编解码，视频播放器，矢量字体等需要动态内存的场合。
5 C2 v2 b3 m7 T" |+ p2 G
; h) i( E  Q6 J( V1 f4 U