27.1 初学者重要提示
! q9 b* `8 c2 H& _  学习本章节前，务必优先学习第25章，了解TCM，SRAM等五块内存区的基础知识，比较重要。
+ T5 E2 L; U& T  h9 q# v, V1 S5 U  将RTX5系统的动态内存管理整理了出来，可以同时管理多个分区。如果其它RTOS中使用，记得做互斥保护或者加个调度锁均可支持动态内存使用情况统计。
% b$ {. f1 u; i27.2 动态内存管理移植
移植比较简单，仅需添加两个文件到工程即可。
; m9 b/ f" {) H0 d
27.2.1 MDK版的移植
  第1步，添加如下两个文件到MDK中
注，以本章配套例子为例，这两个文件的路径\User\malloc。

9 W, j  Z, h8 l9 ]/ ~- N+ _+ V

9 Z' D' I1 O8 v% m4 c  第2步，添加路径。
1 X& L+ v; a) T: s

! |, B6 m5 X8 ~5 q  第3步，添加头文件。
如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。
+ [/ I4 P" v" o1 \9 l  f& [
6 s  ]8 |+ r8 t% x) E/ m; x. C* L
* |' c9 e) @+ f- Z
) z- Z8 a0 I, X2 s4 ~通过这简单的三步就完成了MDK的移植。

6 G& P& X. g6 A( O- F3 r9 A27.2.2 IAR版的移植
  第1步，添加如下两个文件到IAR中
' i' Z( y; l+ w- n5 n7 Z  k- M5 g注，以本章配套例子为例，这两个文件的路径\User\malloc。

! O4 Z. w+ C* G, V; W0 D+ U( w( O
/ g/ U3 x: l7 L1 U9 [  第2步，添加路径。
" @/ d# L; [8 E% h- @2 w6 B

$ c4 u3 y* z) Q4 E  第3步，添加头文件。
如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。

" r4 j6 J  O1 ?* o# x2 u  X& M
/ V) ?8 T! Y7 k  B: S) m+ i+ }通过这简单的三步就完成了IAR的移植。
& a2 S2 i. E5 Q% f
# Y0 T6 K  b4 ?; e4 b" N1 H27.3 动态内存的使用方法
' q0 z/ Y( @; p/ e0 v下面分别以MDK和IAR为例进行说明：
* T: n) a% }% [: j1 h, ]
27.3.1 MDK上的动态内存用法
  定义动态内存区
( }. W$ r7 c  m3 y$ q, Z比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：
% @+ S* e2 ?% X5 Q' N. E' r" ?. m) n

1. /* DTCM, 64KB */
   
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *DTCMUsed;
     G' I: _; r" m7 H9 V9 t9 z& j
4. /* 定义为64位变量，首地址是8字节对齐 */            
   
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

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

1. /* D1域, AXI SRAM, 512KB */
     B& b8 K* t5 b5 D( B
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *AXISRAMUsed;  
   : {4 \6 r; r( s7 m! V" [
4. /* 定义为64位变量，首地址是8字节对齐 */
   8 ?7 K/ Z1 i' s
5. uint64_t AppMallocAXISRAM[512*1024/8]__attribute__((at(0x24000000)));

复制代码

1 }- F9 A7 _1 X1 b( ~1 ^( Q- H  初始化动态内存区
5 w9 y0 |3 T" C- N9 J7 V2 O7 l4 h调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：
# t. D' f6 z0 v

1. osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
   
2. osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

复制代码

  申请动态内存
0 ?3 s' V3 X9 c通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。
+ p. s3 J- p+ \6 G9 D5 E' u, i: {, i
第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。
9 o3 u4 Y( C+ N, B* v! b
& l. Q3 u( s$ Q第2个参数填写申请的字节大小，单位字节。
! K" W( j* t8 a4 g0 |
* C2 ~: U6 U! Q2 |. M第3个参数固定填0即可。

返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！
. C- b& }" n1 v+ h/ N
" ?- B. {# w! P2 \' A6 l' Z举个例子：

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   
2. 
   1 S$ Z+ e. m) d9 n% D; Q
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   ) C' N) j. D5 Y
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   3 Z) V$ s, K. l* Q- d8 n0 h
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   6 e1 U3 K2 q9 ~" l
7.                                                              DTCMUsed->size, DTCMUsed->used);
   9 |% t6 q6 B) m' r( u
8. 
   8 P" S1 p% K: R2 T- v% w
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   % P1 d2 u  W2 X+ ]( H
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    / V/ z! @5 y/ \8 d# }
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    1 u! D# C, `8 t
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。
1 b. M* ^  }) z2 O) `) B
+ @8 H& N. |( V4 p3 W  释放动态内存
通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。

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

第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。
& T9 T0 q1 v3 l
, W; y& v! T4 y. e( V+ s" C返回值，返回1表示成功，返回0表示失败。

举个例子：
# V. r9 }/ V% E9 k5 N  t

1. /* 释放从DTCM申请的280字节空间 */
   $ P& H3 C/ _+ Q) J% m8 ]
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   $ T" z% t/ z6 h
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   ! `# }9 k! x$ O' V; t8 q/ [
5. 
   
6. /* 释放从AXI SRAM申请的160字节空间 */
   
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   # J3 U0 X4 F" J. m. X+ W# \" R  T
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   . y! s7 S: _5 P3 H4 h$ o
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used);

复制代码

27.3.2 IAR上的动态内存用法
2 |& {0 `7 |. T  g+ K注：IAR使用这个动态内存管理，仅在定义时跟MDK略有不同，其它地方是一样的。

  定义动态内存区
比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：

1. /* DTCM, 64KB */
     y1 N  ?& D2 Y
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *DTCMUsed;
   
4. /* 定义为64位变量，首地址是8字节对齐 */            
   ' x% M) }5 Z: a* W
5. uint64_t AppMallocDTCM[64*1024/8];
   5 L8 p& o7 V$ O/ W# \2 |0 _0 C
6. 如果要使用AXI SRAM作为动态内存空间，可以使用__attribute__((at( )))指定地址。
   
7. 
   ) O# d2 L1 {  q. f; n
8. /* D1域, AXI SRAM, 512KB */
   ( c9 A: `0 O9 O" O" `  I
9. /* 用于获取当前使用的空间大小 */
   7 a% Z  j2 w4 Z8 N" Z
10. mem_head_t *AXISRAMUsed;  
    
11. /* 指定下面数组的地址为0x24000000 */
    9 `- p5 c( r4 a$ N& B' \) A
12. #pragma location = 0x24000000
    
13. uint64_t AppMallocAXISRAM[512*1024/8];

复制代码

  初始化动态内存区
0 l4 G6 ~! k" V9 r调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：
  D" A) h2 q! O& g
5 _7 N6 t# A. Z4 a  x5 }

1. osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
   
2. osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

复制代码

  申请动态内存
+ K3 L; c, u+ h通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。

第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。
. ?& d" C# \5 n# _3 E: D5 u
) b) L! @8 `7 b4 w1 q第2个参数填写申请的字节大小，单位字节。
6 S$ D! j; D3 J: O
第3个参数固定填0即可。

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

举个例子：
2 w* i0 ^2 X1 K$ J3 ]7 _1 g

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   
2. 
   
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   3 }6 u# l2 e- o1 U2 u
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   + g3 H7 j8 X( g& m
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   ! _3 u9 Z5 r) o
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   2 q: R. i; o; t2 C# C
7.                                                              DTCMUsed->size, DTCMUsed->used);
   
8. 
   4 |  _' C4 p2 z# {' z
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

* l5 s* z" I, H7 L6 e* \8 r申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。
5 c/ i7 P5 z  N) r% D8 Z
+ t, F$ \: K  v, v  释放动态内存
% T7 Y8 n, o. V# S7 {通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。
: c, O% H3 z9 X( ^/ U. J* u
  d3 k( F7 \- D. u+ m第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。
0 h, ]& R2 _* @! c  f% }
& r( u8 X# P) x8 V( [第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。

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

举个例子：
3 m1 B, p' L1 E0 n
3 w  s, {6 L' A* f. P8 D/ n

1. /* 释放从DTCM申请的280字节空间 */
     K1 @0 Z+ W* D) x( Y
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   * P6 D3 O9 r/ E* U
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   - C$ w  U* X. d# e
5. 
   # z) z. ]9 A1 ~+ B# Q- W4 n1 ]
6. /* 释放从AXI SRAM申请的160字节空间 */
   
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used)

复制代码

/ i* s  F: T9 j27.4 实验例程说明（MDK）
配套例子：

. E! r# y2 m: U$ JV7-006_TCM，SRAM等五块内存的动态内存分配实现
1 r5 Y/ R# Z  X- S) g3 u
实验目的：
! j. ^: ]9 V6 b2 z; G  n
& D1 O. L; I3 p1 L; p学习TCM，SRAM等五块内存的动态内存分配实现。
. a' }8 B- _+ C$ J/ h实验内容：
6 A) \# Y  Y0 U6 N% B5 z
启动自动重装软件定时器0，每100ms翻转一次LED2。
实验操作：
" v4 h& ]4 C2 c7 _" V# X2 c. K
% j% N5 Q5 V4 f2 P1 {/ BK1键按下，从DTCM依次申请280字节，64字节和6111字节。
. j' S0 l( |3 JK1键松开，释放从DTCM申请的空间。
K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
- N2 p- \. X5 F/ W. bK2键松开，释放从AXI SRAM申请的空间。
, `6 V: c  A# K6 C% ^. \. ?K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
K3键松开，释放从D2域SRAM申请的空间。
摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
摇杆OK键松开，释放从D3域SRAM申请的空间。
上电后串口打印的信息：
* P- ]( Z2 r: n0 y/ N6 e
: |1 N# K8 n: |4 E) n" ~# s0 t波特率 115200，数据位 8，奇偶校验位无，停止位 1

$ |" R/ ?. I5 h2 \0 }- j! u2 V6 f: i
, e" _2 K/ D7 w程序设计：

: K+ s; H; |4 w5 A9 R( U  系统栈大小分配：

( B. ~* o9 a6 Z5 E( p4 z

RAM空间用的DTCM：

& U) [# @/ v  N" b4 G9 u# j

( n  u) A# V6 c+ s/ U  硬件外设初始化
" i* `" U5 [  C' U. q( K: P
) ?, Z* w( V' e# [! a3 R* b硬件外设的初始化是在 bsp.c 文件实现：

7 {4 d1 a$ l9 l- y) L- l

1. /*
   ; f5 Y! v( k. b& p+ @
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   1 H$ j2 w; x( O* x- g$ v9 {
7. *********************************************************************************************************
   
8. */
   2 `$ ^; K, R" Q: \" P2 ?
9. void bsp_Init(void)
   % g% v: M/ j; J& W+ Q5 l
10. {
    
11.     /* 配置MPU */
    / l5 y6 f0 N2 g9 K
12.         MPU_Config();
    " M" P0 |, A" ?3 j
13.         
    
14.         /* 使能L1 Cache */
    2 L& h; g% J! i- A7 i0 v% f; m2 {- M
15.         CPU_CACHE_Enable();
    6 O" J: a% n8 m5 x& s
16. 
    $ B' e, J1 _; y. W5 i  X
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    & H' z" ^7 @; i. n
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    0 y9 h3 A0 J& U: j
23. 
    - S3 W/ _) C) u
24.         /*
    
25.        配置系统时钟到400MHz
    ( c* v' V! [8 N5 N: A/ g
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    8 u) J( _  B4 G. M" C
28.     */
    1 \) n% f! l. h- [! O
29.         SystemClock_Config();
    1 \7 a' a7 C( u( U& f8 V
30. 
    ' H- Z3 b* }2 q7 k
31.         /*
    : Z. e" `: C0 Z
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    0 Z# N0 X' X1 y& |6 M1 h* Y7 r
35.         */        
    5 h4 x7 o) O! l* x1 l, l, Q
36. #if Enable_EventRecorder == 1  
    $ M" N6 {- q  k7 w
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    9 g! k$ E: u* N" [
39.         EventRecorderStart();
    ! ]9 m1 x* [( `( P# c+ I0 p5 H
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    1 E2 U' t% B) [! B6 q( A' |
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    ! T/ P3 Y, A$ e" u0 q2 A
44.         bsp_InitUart();        /* 初始化串口 */
    1 L6 f1 c6 Y0 j7 A5 @4 d/ @
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

  MPU配置和Cache配置：
数据Cache和指令Cache都开启。

AXI SRAM的MPU属性：
5 t: X0 R6 P7 b; L3 T
Write back, Read allocate，Write allocate。
8 r  Y' X% s+ r. g
  l: I* ?" L% tFMC的扩展IO的MPU属性：
2 [7 I% w2 K# z3 @8 s
必须Device或者Strongly Ordered。
0 l% Q# k; M' Y4 R5 T' R9 f9 [
/ f' E, A8 h3 a# a7 ^0 d$ t1 sD2 SRAM1，SRAM2和SRAM3的MPU属性：

Write through, read allocate，no write allocate。

: o: {2 }8 t# h# O; G( o) C2 n$ `D3 SRAM4的MPU属性：

Write through, read allocate，no write allocate。
; q9 S6 F; D! }7 W. {

1. /*
   / o2 W* M) B+ m) M  S, h! s+ [
2. *********************************************************************************************************
   # H& b" ?8 G3 Q  j" u  i! l
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   ; q( @6 q* C& s, y5 N
5. *        形    参: 无
   - g! b7 `. g3 ^3 d4 s
6. *        返 回 值: 无
   6 q2 y) K1 e5 P6 `
7. *********************************************************************************************************
   5 [+ v' {9 X3 N. ^5 T, X
8. */
   
9. static void MPU_Config( void )
   + f. s+ U- _/ Y0 K% G  v- O
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    - q! H5 g! g2 N% {: q  Z1 V' ]
14.         HAL_MPU_Disable();
    
15. 
    8 x. ^) S- ^5 j$ `
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    7 f) `1 l/ a" h0 c5 p. g5 G
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    6 V" n: J" h& x- @; A/ E$ |4 G& R
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    : _# K% m1 j' `0 R; l, s6 n. |( o
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    % E! @" V' L5 ~% \/ N4 N8 u
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    $ m9 H4 w  W( b% ^6 \: \- t6 {
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    & _7 Y# T2 ?4 x2 S! V$ X
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    7 c. \5 T0 ?2 c
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    % p8 }6 M8 d" f9 g
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    # q. J" l" G; l1 `, Z6 y" P6 k! p; F
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    / x) t+ T3 z' U6 `( Q% J5 U1 Y/ Q
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    : \0 c4 I, j; T5 ^
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    2 [: r! v+ C  P
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    & ^. q& e/ D$ k% |% o
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ' R& v( M" K/ s+ F, ~  J. r( m
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    4 X+ o, v5 ?* l+ _7 p
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    / g" |/ {# h. h, K9 g  s
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    + G& A; N: x2 z8 u7 m5 v3 T
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    5 M) R8 B- b- A2 P+ m
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    & P/ G: c" n, S& @# O9 E" K; H3 z1 Y" ]# Q: r
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    1 }1 l1 w9 {3 ^  Y9 T; m
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    , K6 o& C$ d. p: M5 l
46.         
    / p% K: o' c. Z! z7 E
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    0 U! N& a* ^% k$ a2 u* P$ [
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    6 S$ {6 c6 M' N( N5 }4 Y* C
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    ) V4 u, V/ p$ l
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;
    % k7 \8 M8 A- c, |- {# [
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    # T- _, c- m' I7 Z5 l6 w' R9 J
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    $ b8 @! Q4 r0 R3 ^: K* {( b" N  e3 i
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    5 c5 r8 A, I! R) u% x6 [. k" ^
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    : p& g2 t: E6 [" F+ [- A4 d
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61.         
    
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    ) P8 o3 Q  {' B" l7 O# J& @; j. I) M, U1 y
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    + z$ N7 u( i' Y8 Q: b9 p  q
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    * |5 x7 P, f& L/ f" i
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    3 N# C4 ^0 P1 R9 F/ u+ H4 ]
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    1 w9 B, G& R9 e! A8 g. c
74. 
    
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    # e. e9 }. `! T, z
76. 
    # v$ r' `1 M8 T2 b% E
77. 
    3 b0 r- _& q. E: [2 R  J+ h* H( R
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    4 i# ^" Q3 l8 C& X0 T2 p
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    & O  E" W4 M7 {: i5 a" B/ @; H
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;
    - R3 }; r4 }' ^' M  }6 r
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;
    4 y  a: y$ ]5 E7 H
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    , k& k/ ?7 d( q1 R' D
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
90. 
    
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
92.         
    
93.         
    
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ; m8 W- x# z. Q% X3 [& u" r
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;
    + ?+ U, G) }9 F% Z3 u) j
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     . |. J& U0 n- P/ C+ f8 @
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     : i6 t7 H  a9 |+ j  G
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     & ?! r* M& u( x) X
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     $ R. {. U* q; |: B' s9 y; g
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     # I  E& i, C" X. `+ x! Y; @
108.         
     
109.         /*使能 MPU */
     
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     
111. }
     5 r! }4 ^2 ~- W) v0 |& k
112. 
     
113. /*
     % _2 b- {2 x% R; B7 F4 [/ i0 L
114. *********************************************************************************************************
     
115. *        函 数 名: CPU_CACHE_Enable
     / Y4 G! E( ]9 O3 F: e
116. *        功能说明: 使能L1 Cache
     
117. *        形    参: 无
     2 `* \( L! y6 G* t9 @) F+ R% h0 f
118. *        返 回 值: 无
     : @, r# i7 g3 I/ z5 \
119. *********************************************************************************************************
     ( w$ @( S  z% _( y. k
120. */
     % L% z& K- r6 p4 A! \. Q5 S8 e+ |
121. static void CPU_CACHE_Enable(void)
     
122. {
     
123.         /* 使能 I-Cache */
     6 C6 j3 G( Z) I. j1 Y' A2 e
124.         SCB_EnableICache();
     : \1 R2 S- E& h; z- A
125. 
     : I) \- h6 K" ?3 S
126.         /* 使能 D-Cache */
     ! |3 ~) d9 W( F1 a0 U9 M
127.         SCB_EnableDCache();
     4 C7 h1 l# L3 Y( n" O
128. }

复制代码

  主功能：

) B7 M+ c$ Q- y6 g4 j主程序实现如下操作：
& V* B) L1 }( L, e- w
: j$ G9 E. l- W7 O' A) A) q/ H# a  启动自动重装软件定时器0，每100ms翻转一次LED2。
  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
5 `1 a1 Q* Y$ i, m+ u3 o  K1键松开，释放从DTCM申请的空间。
! B2 R$ N9 n. n' p9 A  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
+ @: N5 @; ]" M/ k/ a- E& q0 K& o8 ]  K2键松开，释放从AXI SRAM申请的空间。
  P% C) j" d+ I8 u  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
  K3键松开，释放从D2域SRAM申请的空间。
  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
  E4 Z' _7 g1 o! [, t5 w  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   
2. *********************************************************************************************************
   * @& f+ D. x4 v/ X% L3 U
3. *        函 数 名: main
   5 t; ^5 f: s" q& `+ |
4. *        功能说明: c程序入口
   # b9 b2 B  O4 N  N; v& O9 d
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   / }$ ^/ w% a5 N5 y" H0 D
7. *********************************************************************************************************
   7 `0 f" d; |# K% y- ^
8. */
   # {6 \+ M% ]. [  a+ u: ]
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    & y' L) u' P) a: q/ Q
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;
    ) E' ?8 z9 X" q: M
15. 
    ) u) `! e! P% W- `( Q
16. 
    
17.         bsp_Init();                /* 硬件初始化 */
    . `3 ?& A! @& Z- q5 R
18.         
    ( v6 j4 G. D1 K- O
19.         /* 初始化动态内存空间 */
    
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    , ?8 ^; s, B* ?9 R
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    
24.         
    6 X; n, x6 W/ U+ [! u
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    1 l7 ]3 Q7 z+ w3 D" t
26.         PrintfHelp();        /* 打印操作提示 */
    4 k; c8 b8 \0 t: x; a; H, B" ~2 k
27. 
    5 z2 v  W/ e  }" b7 ?* E
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    / z5 Z8 |  R! S& [# Q: s5 Q5 B  V& Q* ~7 }
29.         
    
30. 
    
31.         /* 进入主程序循环体 */
    . T2 p& n' y% q" ?' l
32.         while (1)
    : S: R) l* X1 k: z8 n
33.         {
    
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
35. 
    + R8 e  A  j" C0 V3 p
36.                 /* 判断定时器超时时间 */
    ; P1 L1 Z1 V* V; S( `+ J4 {
37.                 if (bsp_CheckTimer(0))        
    4 i& |+ B( ?% W, h8 E; m  Y
38.                 {
    
39.                         /* 每隔100ms 进来一次 */  
    
40.                         bsp_LedToggle(2);
    9 }! P0 V* t  M& \" c- f3 Z1 G: j; W
41.                 }
    
42. 
    8 S) {) T1 Y! @  g6 \4 s: ?& j
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
45.                 if (ucKeyCode != KEY_NONE)
    
46.                 {
    
47.                         switch (ucKeyCode)
    $ B& \& }5 [& V* \3 F: h
48.                         {
    5 g1 S! y5 G+ k4 O! W0 O. M0 d
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    
50.                                 case KEY_DOWN_K1:        
    5 q: _- k& Z1 K. `) V/ ~
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    
52.                                         printf("=========================================================\r\n");
    
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    - B1 b0 i* {2 p
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    1 e6 U: T9 \2 E* K" Q- W3 u
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
57.                                 
    
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    ( W( s# l* W8 e" H. A; `8 x
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    + n/ |! e8 ^- k  |$ z" `# q
63.                                 
    0 M5 v* Q8 C7 ^) z: |3 a% D: I
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    . b; p8 p! J& ^* c( g  B# D; O% |
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
69.                                         break;
    
70.                                 
    
71.                                 /* 释放从DTCM申请的空间 */
    4 k5 y3 ^- u5 o6 y5 q5 D/ B5 z
72.                                 case KEY_UP_K1:        
    
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    & d( a" N7 h2 f$ n% P' c- l
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    
77. DTCMUsed->used);
    
78.                                 
    
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    % h1 M. e; w0 ]) n, f* s
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    # n# l0 v6 \0 s0 b8 `* v0 ?
83. DTCMUsed->used);
    
84.                                 
    0 J; J' p# e% J+ Z
85.                                         /* 释放从DTCM申请的6111字节空间 */
    
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    2 H- g4 v2 \5 E; j, S# ?
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    * [( @% X7 D8 Q, W$ V# Y8 w
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    
89. DTCMUsed->used);
    
90.                                         break;
    9 N  E7 u( s5 ?- c+ t5 u* M
91.                                 
    
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    # u* g7 H' s( m# V9 y8 H
93.                                 case KEY_DOWN_K2:        
    
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    ) g) `) l& q/ _. s8 k: d! S
95.                                         printf("=========================================================\r\n");               
    
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    5 B# Y" m$ k, J2 D) G5 E& t
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    3 L' l  m) j1 ~. ]: k  r" x) Q
100.                                 
     
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     3 m. W' h5 K$ _- f$ C
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
       r8 b$ U7 `# a/ t; R
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     + L) ^3 {/ @/ w! ~, u
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",
     / Z9 a+ r/ P5 h7 x4 x! S# E
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     
112.                                         break;
     
113.                                 
     
114.                                 /* 释放从AXI SRAM申请的空间 */
     & ^5 W& f. S8 ]8 O
115.                                 case KEY_UP_K2:        
     
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     ; ]4 V% \- g" g
120. AXISRAMUsed->used);
     
121.                                 
     - e3 u" @; m+ O. N
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     ' U; t. B! u# h- z  I+ |  |0 d2 m4 g9 W
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     " O: U8 }( p7 ^' m6 n7 d2 ^: j
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     
126. AXISRAMUsed->used);
     
127.                                 
     
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     3 j  R# D' c! z1 ^4 Y+ t
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     ; q& u  }( `% \; F  n( [
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     
132. AXISRAMUsed->used);
     $ V; C' w/ E8 |  J0 _* C
133.                                         break;
     
134.                                 
     
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     - w' O- C" T, a4 e
136.                                 case KEY_DOWN_K3:        
     $ a4 M) s' ]- B" W& K+ @
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     8 |# k% p6 v# z0 R
138.                                         printf("=========================================================\r\n");               
     # v& m/ f0 ]- {- m- h1 a5 M
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     # B3 W9 ^' `/ T, T9 k! h$ u
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
143.                                 
     , v( B+ |6 T4 L& _- B# G/ E# ^
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     $ K5 L6 |/ J: x; |3 \# }, b0 T, o
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     & y. R+ c$ l3 `) m! g
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     " p* I, Y. r/ U6 G& K. ^# ]
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     1 }$ e. n1 W# c) o7 Y7 F
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     2 e. P; W. E1 P6 H
149.                                 
     
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     1 @4 H1 f  s' x* V
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     / R. u# N$ y, r2 _8 e5 o9 \
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     ; X+ z' K' ]5 k
155.                                         break;
     2 b% u/ D8 w" @* C% r% g' Y
156.                                 
     
157.                                 /* 释放从D2域SRAM申请的空间 */
     
158.                                 case KEY_UP_K3:        
     
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     1 H$ h- z) s' K$ g2 ]; L
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     ' g0 @. l+ Y, A4 t) Q
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     
163. SRAM1Used->used);
     % F& X, N2 d2 Q: ^; X& C
164.                                 
     
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     # P. j) I: h1 |" x3 k8 u
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     / }8 u3 F1 c8 B* _/ E
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     : |7 ]3 J+ J8 u( X. o6 F7 K7 z! ?7 R+ D
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     . y% G" k$ V" n: i8 M
169. SRAM1Used->used);
     
170.                                 
     
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     
175. SRAM1Used->used);
     
176.                                         break;
     
177.                                 
     1 _" w1 P' Q; V) N
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     7 j# }& ]. g; p/ j* `
179.                                 case JOY_DOWN_OK:        
     
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     
181.                                         printf("=========================================================\r\n");               
     
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
       ]& N9 G5 D% T6 J3 n0 z# B
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     + d) f5 D1 ?* @2 G
186.                                 
     
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     # w9 p" d, |( B( L- j1 R
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     9 d3 T1 G* p* e' H
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     $ {% i6 ?1 L6 o. ]7 g
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     
192.                                 
     + Y" l4 N1 ^# B. f
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     " G# D* O# e# K$ N' O
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     9 I( ~5 O: K' \8 S
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     * f' h9 A* }* Y3 m1 |
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
198.                                         break;
     
199.                                 
     
200.                                 /* 释放从D3域SRAM申请的空间 */
     
201.                                 case JOY_UP_OK:        
     ! u6 C+ ?4 S! @6 G1 @
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
       \# D  ^9 d! L9 `4 l
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     5 T- y* M2 i# Q( O8 T" v; [$ F3 Q& i
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     
206. SRAM4Used->used);
     6 F' a; Z# Y" y4 l/ G7 z" g
207.                                 
     & V) H4 N1 c0 ^& O
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     4 L# n8 |) d$ Y* I
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     1 @5 _5 h+ p$ [+ l
212. SRAM4Used->used);
     , X/ {3 x" P. [
213.                                 
     " I, f% |, Q) U- s; M8 L( n
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     + Q0 @0 Z% j1 K, S0 W* C) v3 @! ?+ q
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     # X7 A# w) W& D6 w0 q
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     
218. SRAM4Used->used);
     
219.                                         break;
     
220.                         
     
221.                                 default:
     
222.                                   /* 其它的键值不处理 */
     
223.                                   break;
     
224.                         }
     1 e& d9 z/ ^2 ^' N
225.                 }
     9 x3 ^; B) B3 y; i' [
226.         }
     
227. }

复制代码

27.5 实验例程说明（IAR）
0 o1 q: M) \! t" V8 ~4 ]& M4 P( D) Z6 w配套例子：

% A3 T  z# X" ]# u8 nV7-006_TCM，SRAM等五块内存的动态内存分配实现
) {6 @" C/ n  k4 s
实验目的：

学习TCM，SRAM等五块内存的动态内存分配实现。
6 S0 j' h" x- Q+ I* O1 X( D实验内容：
9 i$ N8 D4 `& J* l$ A8 Y- L
5 _; b5 Z( {8 ~/ m启动自动重装软件定时器0，每100ms翻转一次LED2。
. I/ `2 ^' E* C% u! ~: z! ~9 o实验操作：

K1键按下，从DTCM依次申请280字节，64字节和6111字节。
& x: z/ k; O# MK1键松开，释放从DTCM申请的空间。
K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
2 Y2 O" e  b5 T5 S- w+ }, bK2键松开，释放从AXI SRAM申请的空间。
5 o/ a+ M3 r, [5 i* KK3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
K3键松开，释放从D2域SRAM申请的空间。
摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
+ I$ V6 B* z! g3 Z, V% u摇杆OK键松开，释放从D3域SRAM申请的空间。
上电后串口打印的信息：

4 q9 H$ b0 N- C* p: v1 |波特率 115200，数据位 8，奇偶校验位无，停止位 1
0 X$ g! Z! c/ A9 _& ?% N8 i2 n
) w5 c9 Y1 [% O) v2 E9 y

' I/ Z7 h: {: z( H) O
程序设计：

  系统栈大小分配：

  RAM空间用的DTCM：

& `# W5 a0 [* `5 N3 b! m
  硬件外设初始化
; ^  p9 w, m8 W- y
; g( X+ D) Q7 o; h- |硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   5 n2 _) Q- ]9 l4 k" j) Z4 X
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   # Q5 I5 Z( E# ?) L
5. *        形    参：无
   5 H& @# j/ N/ Y$ J' z
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   9 V9 \5 N  ?/ [. B" @7 q
8. */
   
9. void bsp_Init(void)
   2 V/ l2 U7 a- B) j5 t. x! u
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    / n2 ], g- |6 @& @
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    
16. 
    
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    ! \& u5 i" b% L/ B2 U: T
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    ! s# ]  p: V4 @3 p
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    ) x* G0 `+ L* p+ H" W: Y
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    6 _# V; Y  b  R+ f  g
30. 
    - F, x0 r6 {! j2 F
31.         /*
    
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    ) R- i7 O" y8 V5 }; W
35.         */        
    6 ~6 k+ o2 f& o$ ~6 O7 }
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    : s0 ]3 e% Q- n2 N  I5 Q6 {( o/ H/ j& W
40. #endif
    
41.         
    7 e# t! v* |- W3 `4 o) C
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    3 d3 }) k3 l7 [/ [  o
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    / t1 x2 m& u( r3 ^) m5 b3 w0 Z
46.         bsp_InitLed();            /* 初始化LED */        
    4 f+ C* A2 ?" t5 E& B) m; e6 j% s
47. }

复制代码

3 _9 p5 y* x5 |0 m9 N7 P  MPU配置和Cache配置：
) w) p( t5 a& ?3 U
- q6 i! R/ s: R: W' ?数据Cache和指令Cache都开启。

AXI SRAM的MPU属性：
. G: E, v) r; p8 V
Write back, Read allocate，Write allocate。
4 P. z* e( V7 I) K: R
FMC的扩展IO的MPU属性：
3 |/ ]0 P* \1 ]% M3 r
必须Device或者Strongly Ordered。

( I& G2 s- ~4 \" @D2 SRAM1，SRAM2和SRAM3的MPU属性：
' X  ?# w. R" r& W. n/ C* O4 n7 Q
$ i( a* D5 a. v1 {Write through, read allocate，no write allocate。

D3 SRAM4的MPU属性：
( l( G8 e$ P* q; ?' x$ T
Write through, read allocate，no write allocate。
( U! \4 A8 y3 ^1 o3 Q

1. /*
   
2. *********************************************************************************************************
   / P: R3 V0 [; J; _/ t" o/ q
3. *        函 数 名: MPU_Config
   9 ?- _* g( o& H( L9 O) N" X
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   % r0 }9 g" S' I* n# s# D
8. */
   
9. static void MPU_Config( void )
   1 V( Z7 Q, {. l; r* \! D  i, p
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    , t& y% u5 Q- ?& z
13.         /* 禁止 MPU */
    0 X" H: G# l5 k+ g  @
14.         HAL_MPU_Disable();
    " s1 Y2 N& W% s7 Q0 \3 ]1 L9 o5 t# b0 m
15. 
    : ]- e( `% v8 W( }
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ) E2 L3 c" n  D, m
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    6 R! Y/ g; c$ u9 Z0 Q' S
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    6 C/ ?: a% |3 }; s
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ; P" ^- P4 m! H4 ?: @/ Y
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    " r3 b7 j" X3 i3 O: c4 M' B
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    / P1 ~( q# [7 U$ }
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    0 S. Y$ _! X1 h6 N! J. S
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    + N! \  ~# f1 h# g  w# U! M; V
28. 
    , K0 h: E9 i! q+ {7 G" O! ?
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ( e- K% x9 b; M5 D8 @
30.         
    " T6 {3 M: v4 H
31.         
    5 @0 i; b7 Q3 R) L( c- v: y! I7 j. f
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    2 O* F7 w0 ~0 w' w. J6 W
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    / b. s; v; Z9 E
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    1 c2 Q, E9 \6 `6 `* w8 i
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;
    7 x$ a& q. Z/ j8 {  G
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    : |0 h8 f* Q+ m' y, [0 d
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ' d# W" ?+ U5 w
46.         
    $ ^" u! {6 |5 r0 O
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    4 E. h  D' G0 u& P- R, Y  l9 c3 k
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    4 q  B7 a) g4 ?5 g* d) D  g1 s- K5 ?
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    ( I. B$ ^  `  Z0 B! T
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    6 W% G9 r4 j2 x! r& a
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ) l8 M7 w2 C0 `' q) A' h
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    ; z9 ?: a5 Q4 c6 [# P
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    9 u) @; z" R2 j9 t$ o
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61.         
    
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    . S7 w5 g, C; i- z0 J2 m- s( u
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    ' K+ u) z' U. |  Q% m
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    7 H0 w% l4 v$ G% W- R1 ?8 i- q  t
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    # y5 K8 i  J- b) p9 T/ E' d: T
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;
    
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    : ]: E) B2 V, f6 P  ~; X
74. 
    ' `6 b: v8 O9 K: k: r1 M
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ' u! _' I. L9 J0 L6 e7 C, ~9 ~
76. 
    
77. 
    
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    , N* w" q% X5 N2 o! @6 L, e
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    ' y7 s: C2 e1 Q2 Y1 M2 d( V6 ]
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ! o+ \* g4 u8 J; v, d
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    7 z' Y  u/ T+ Q# x  t, u* k
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    7 m8 c! q: A) Q
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
      j/ p: V+ {* l! Q6 }/ F
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
90. 
    
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    0 s2 L+ ^  s# ?' _) i% p" h
92.         
    , Y1 n2 M0 y* r
93.         
    
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    5 [; n1 A! e3 x% m9 Q- D
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    ; p, Y: X* d% J3 @
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    % V( r7 x2 Y8 y! F2 e7 K: ^
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     % a1 F! @3 f+ z8 x
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     : I- b& ]3 F4 V7 _
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     7 J- _4 c' B# `* ]% m
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     ) c$ e- S7 g9 F" k
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     & s2 y* e  K% n
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     
108.         
     " ]% W5 C# W3 x! l& Q! V  o! b
109.         /*使能 MPU */
     0 A1 D4 ]8 V0 l2 V6 G# |6 |
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     ; s8 @) ~; A* A) f( a' n
111. }
     
112. 
     ! P5 U& A/ o; z7 ~+ }0 x
113. /*
     % p  E8 j) \* D( a
114. *********************************************************************************************************
     
115. *        函 数 名: CPU_CACHE_Enable
     5 F# r, o% z2 c
116. *        功能说明: 使能L1 Cache
     + g# b! q* I( A; N
117. *        形    参: 无
     , p  ~, q3 j6 |
118. *        返 回 值: 无
     
119. *********************************************************************************************************
     
120. */
     
121. static void CPU_CACHE_Enable(void)
     
122. {
     0 i  ?9 }8 n. w0 k' e% S
123.         /* 使能 I-Cache */
     / C& z, D/ b9 T: [; z
124.         SCB_EnableICache();
     
125. 
     & t; V1 d) p: \
126.         /* 使能 D-Cache */
     
127.         SCB_EnableDCache();
     7 v& X- J! m) X# s
128. }

复制代码

  主功能：
0 ?% c9 ]# |9 a. u8 Q& R: o
4 I4 u8 y: B" b, |主程序实现如下操作：

0 _' g+ E8 b1 c6 M  启动自动重装软件定时器0，每100ms翻转一次LED2。
  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
  K1键松开，释放从DTCM申请的空间。
  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
  K2键松开，释放从AXI SRAM申请的空间。
/ e1 x, }, u0 o; K3 m# l' k+ ^  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
' }* o5 A4 x% O4 r  U7 w  K3键松开，释放从D2域SRAM申请的空间。
# Z& w- d9 `/ d4 {% I4 j# @" q  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   / m6 [8 f* M6 x: V
5. *        形    参: 无
   4 ]1 i% P6 P! O+ E2 O  L
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   7 f; [# A7 z" N  H* v2 k
8. */
   + D( u: F1 G# j  Z
9. int main(void)
   ; e+ m5 c$ W6 `
10. {
    7 |' G( u+ e" [. T1 w
11.         uint8_t ucKeyCode;                /* 按键代码 */
    - h/ P  M- }* i' S( z3 k" ~
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;
    8 ~! Z5 h* z  d. r2 Q1 k0 h0 s
15. 
    * [' E1 U8 X$ y, S
16. 
    
17.         bsp_Init();                /* 硬件初始化 */
    
18.         
    , L" z$ r* S* j) G- n
19.         /* 初始化动态内存空间 */
    + U1 F# {: L5 c- R  E: V: s
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    , I  ?2 q+ P* {; T! y1 X: h+ |0 w8 h
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    5 o! _9 q, ]5 q1 {. n
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    ( }, _7 d1 L+ `9 q2 B
24.         
    
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
26.         PrintfHelp();        /* 打印操作提示 */
    
27. 
    9 d& _' H& c2 Y% W
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
29.         
    9 S: Z0 u9 o" _6 I
30. 
    
31.         /* 进入主程序循环体 */
    
32.         while (1)
    8 E7 h' ~: N# i2 R9 v: I7 O4 L
33.         {
    
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    5 ^9 d7 }+ o, _! }
35. 
    
36.                 /* 判断定时器超时时间 */
    
37.                 if (bsp_CheckTimer(0))        
    " k# j  W. [, I$ z
38.                 {
    
39.                         /* 每隔100ms 进来一次 */  
    ; Q2 Q$ R: ~, l% }
40.                         bsp_LedToggle(2);
    
41.                 }
    
42. 
    
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    7 q2 B! t+ O" o6 _* z
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
45.                 if (ucKeyCode != KEY_NONE)
    
46.                 {
    
47.                         switch (ucKeyCode)
    
48.                         {
    
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    ' }: i) h* ~( H+ \: K& t1 D
50.                                 case KEY_DOWN_K1:        
      y! p7 m# @6 e5 ^3 x. S2 |4 V
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    ' g5 H) [  M* E
52.                                         printf("=========================================================\r\n");
    
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    / k" f8 ~# ^0 E7 ^  K! k
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    8 O* X( E* K$ E
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    * O; L3 c: ?: P4 W; ~6 }* u- m
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    : Z  m# e( |6 y2 I7 k3 F6 s
57.                                 
    
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    , F# J( f9 m/ `* j. q8 m' r
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    0 ~% D; |9 `5 {. o
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    
63.                                 
    
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    : `6 x' Y% Z" z+ ?, o
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
      M* I. V7 e, }, i
69.                                         break;
    
70.                                 
    ' q# [+ X0 [1 v3 `( y$ @
71.                                 /* 释放从DTCM申请的空间 */
    7 S5 I: `/ d! j" x- y" E4 m5 j
72.                                 case KEY_UP_K1:        
    
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    : A5 X' T, Q2 |  M/ l6 l
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    * q! }' E; K& i0 V# s$ [
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    ( V" T  p. r* \  g
77. DTCMUsed->used);
    ! L1 v# r% M. j# T& Z( [6 x
78.                                 
    / g$ w8 o/ }- r8 ~: j, k# K) H
79.                                         /* 释放从DTCM申请的64字节空间 */
    / Q6 C5 J5 C. U3 \& I4 H, V! T6 f
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    
83. DTCMUsed->used);
    7 n: |3 V1 c4 H) ~& v0 {% K
84.                                 
    
85.                                         /* 释放从DTCM申请的6111字节空间 */
    7 E& M  m6 ^2 A0 A9 x
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    1 {- C$ R  _8 e+ A7 d2 t
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    : V6 A0 j) Z; Z! b' F" \$ \
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    7 s9 b9 {: t& o
89. DTCMUsed->used);
    8 g) O1 Q& V! p7 w3 D8 d' v
90.                                         break;
    
91.                                 
    / A9 E8 [* _' R1 [
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    
93.                                 case KEY_DOWN_K2:        
    
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    & D. L6 Z* I+ z+ M) ?: U
95.                                         printf("=========================================================\r\n");               
    
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    $ j) {0 ^) L/ Y0 ]) T
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    
100.                                 
     
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     & f9 J# D1 w4 ?0 p1 Z
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     
106.                                 
     
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     # p& z) v! o3 u( c8 k
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     0 u& F9 n9 w6 f4 e9 ]' K* c0 ?2 F' r
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     1 a; R) H0 l' c5 j
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     
112.                                         break;
     2 z1 W) n. @' Y- d
113.                                 
     
114.                                 /* 释放从AXI SRAM申请的空间 */
     # B8 N* [/ r5 J1 b) t+ K
115.                                 case KEY_UP_K2:        
     
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     3 t0 w) g, ]. s6 V  r
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     * i6 N( O! G; T) v
120. AXISRAMUsed->used);
     ( F% g' l& N$ z1 F' _7 m
121.                                 
     
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     % D4 P. q2 \. l. G- [& L
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     / i6 ?) U: p4 R1 ]; l- W
126. AXISRAMUsed->used);
     9 S. }# S0 G# ~. e7 P
127.                                 
     
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     # P6 A& G; w  c: a: X
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     ) M) y. t; o. D4 }: A& d# f
132. AXISRAMUsed->used);
     1 ^/ J. U( \2 H1 ?8 Z" d
133.                                         break;
     
134.                                 
     
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     
136.                                 case KEY_DOWN_K3:        
     $ j1 p: M/ A# A% _
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     $ n% Q% D9 x6 b& Y) w
138.                                         printf("=========================================================\r\n");               
     
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     : i# S0 E  U* J4 s3 [
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     0 `8 S' X  ]. }/ F+ O
143.                                 
     5 \3 f6 V; L1 Q
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     # y; @, C, F& n+ f
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     $ r" G6 j- r) F% S2 o; @9 W3 x( w% d
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     
149.                                 
     
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     7 o/ q$ k% s7 s# k- M4 ~
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);
     ) ^$ E# c- y0 d3 Y
155.                                         break;
     
156.                                 
     " m$ Z1 J' M8 c. b# W1 k
157.                                 /* 释放从D2域SRAM申请的空间 */
     
158.                                 case KEY_UP_K3:        
     
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     ) [+ D6 Q6 ?  L) g' h
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     , |9 Q0 P2 s8 e! ^
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     
163. SRAM1Used->used);
     
164.                                 
     ) u- E4 Q9 E( I! F4 i, K2 k/ p) B/ d
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     / C. q+ B# L1 N  f
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     
169. SRAM1Used->used);
     ! Q8 c+ l! t; s
170.                                 
     
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     - Y" ?8 O$ r/ N$ F2 N' H
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     
175. SRAM1Used->used);
     ( l2 l4 _" i' W' `/ a0 J5 h
176.                                         break;
     
177.                                 
     ; C% }% {$ `& W% i3 x  {8 c6 @4 o5 w" A; u
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     
179.                                 case JOY_DOWN_OK:        
     
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     8 n, A' c" k1 q) K
181.                                         printf("=========================================================\r\n");               
     
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     8 j/ {& b+ l- j* V6 F9 B) u
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     - T# J1 e8 K; [' `0 e! Y' j  j
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);
     ) ^) g9 @3 z7 T3 C
192.                                 
     
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     3 V3 K1 ?' h4 j
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     - m! m1 d) t2 [+ ]4 _6 ?9 D
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
198.                                         break;
     
199.                                 
     
200.                                 /* 释放从D3域SRAM申请的空间 */
     
201.                                 case JOY_UP_OK:        
     ( G: u* y% ~8 H: @" v, _$ d
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     / o/ R& Q) [* j
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     % \  E% t" C* ~! B) X) j6 j* v
206. SRAM4Used->used);
     4 @0 X& O( O9 s& ?) _/ f
207.                                 
     
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     % |$ _4 C- P' Y- ~( J
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     7 O4 f) f1 d- O. d  h- M
212. SRAM4Used->used);
     
213.                                 
     
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     , K2 C) Z: ]% D. K" q4 l' G8 Z; o7 y1 \
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     0 O, q9 ]/ W. e3 u
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     
218. SRAM4Used->used);
     & w! R; [( _: Z1 A
219.                                         break;
     ( x* N0 E/ [7 x1 W0 a/ s2 Z0 z' }9 N
220.                         
     " K0 F3 |5 n2 V9 i4 E
221.                                 default:
     
222.                                   /* 其它的键值不处理 */
     
223.                                   break;
     9 z4 E) M5 U% p
224.                         }
     ( X1 ^1 s& ?  _
225.                 }
     
226.         }
     
227. }

复制代码

! y7 \) ^# ~# _27.6 总结
6 ^8 L  l1 Z' `  r9 J# _( q  F) ]0 \本章节就为大家讲解这么多，还是比较有项目实用价值的，特别是MP3编解码，JPEG编解码，视频播放器，矢量字体等需要动态内存的场合。

' N5 u; a. {, X, U) x% w