27.1 初学者重要提示
+ p3 s9 Y# `$ ?: C  学习本章节前，务必优先学习了解TCM，SRAM等五块内存区的基础知识，比较重要。
4 N: N, m7 ]1 j' e4 w. R7 V  将RTX5系统的动态内存管理整理了出来，可以同时管理多个分区。如果其它RTOS中使用，记得做互斥保护或者加个调度锁均可。
  支持动态内存使用情况统计。
+ m4 o% i' E5 Z. I27.2 动态内存管理移植
" w3 h# R$ V. }0 L) k9 L5 S7 J/ [移植比较简单，仅需添加两个文件到工程即可。
  M/ n) o! G. J& k, ?0 y
& n9 J' o% z( t- S27.2.1 MDK版的移植
  第1步，添加如下两个文件到MDK中
注，以本章配套例子为例，这两个文件的路径\User\malloc。

+ o2 ?: B4 K1 M1 q( F

5 e% X, G8 I% E$ v* ]
  第2步，添加路径。
7 I* N: Z* C0 r. C
) |! c) b. c5 ?" U: x0 J6 J

- w  j( n! r7 o* a0 d. ]/ n# s
  第3步，添加头文件。
如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。

2 f( d: {, b3 x1 x/ z通过这简单的三步就完成了MDK的移植。
' p( Q' L0 F7 e- I+ a& y
27.2.2 IAR版的移植
5 A0 `/ ~% m; A; Z1 |  第1步，添加如下两个文件到IAR中
* ]; N9 [( [0 b0 X: _! E注，以本章配套例子为例，这两个文件的路径\User\malloc。
' v3 u& j7 W8 r, T+ Y# f1 E- l
# A" d" z2 O0 F) a( W

7 {% V! W. j8 ?* b- T3 O; u* ^  第2步，添加路径。

9 S; p% S" g" ^

  第3步，添加头文件。
! B2 j0 C- p& c( \: X, U; I/ c如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。
7 I/ A$ p' n2 }; v  y4 d/ a
) h* L* ]. b# z/ ^+ F2 q' R. s通过这简单的三步就完成了IAR的移植。

27.3 动态内存的使用方法
0 i) W; X0 p  _9 \: t7 C% W下面分别以MDK和IAR为例进行说明：

: w- k5 r. V2 r3 h3 Q27.3.1 MDK上的动态内存用法
# J- y6 b. _3 K5 u( k  定义动态内存区
比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：

1. /* DTCM, 64KB */
   
2. /* 用于获取当前使用的空间大小 */
   . r: G6 y) c& V" u' r
3. mem_head_t *DTCMUsed;
   6 F( t; Y& {) t8 N, B
4. /* 定义为64位变量，首地址是8字节对齐 */            
   ) x$ n6 ~% T/ \, `6 I
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

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

$ P1 h3 q* S" w  ?2 S$ O

1. /* D1域, AXI SRAM, 512KB */
   
2. /* 用于获取当前使用的空间大小 */
   " C( O* c' F1 l
3. mem_head_t *AXISRAMUsed;  
   
4. /* 定义为64位变量，首地址是8字节对齐 */
   
5. uint64_t AppMallocAXISRAM[512*1024/8]__attribute__((at(0x24000000)));

复制代码

" l; H8 f, d/ B+ [/ C  初始化动态内存区
调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：
, q" i6 X6 w7 a" G$ O! v
) g! i' f3 A5 I- t4 r: a5 L; FosRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

+ d$ {+ V+ t# U4 w3 M  @  申请动态内存
' X4 N4 o  \2 `& q8 p, \2 ^通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。
; B& `+ \, ^- t
3 s! i$ ]- g( e第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。

第2个参数填写申请的字节大小，单位字节。

第3个参数固定填0即可。
$ z" z$ t. v+ c# g0 i+ R
1 n( i- q& K8 Y2 P. L返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！
! X0 _" L/ p2 a3 L2 d
+ {1 w& {& y* r* ~7 q举个例子：
, M4 G  `. j4 h! B- w3 g
5 t/ M2 K- ~! P9 h) o

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   
2. 
   
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   ) v  \3 q$ Y) y- Z/ e; R
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   ) j+ |# \5 p* e6 [: u) ]
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   8 E/ W! w4 P& R2 ]1 a
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   
7.                                                              DTCMUsed->size, DTCMUsed->used);
   6 d$ G7 R& K. f4 T  N+ I
8. 
   , w; @- a# l$ z
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   ! S1 y+ {8 I& \" N* [! K
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    % ?' x, W- Y& T& i+ C0 {
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    # X  p: z+ H3 J: s4 D7 q% ]8 R
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

- M% K6 l# t) p# P- b' S; Q* r申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。

  释放动态内存
: z( Z2 E2 p% j0 k通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。

1 M) z4 T) H( H; m7 {第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。

* G2 q( B2 i, h' j' `2 j+ Q; v: f第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。

; T. w2 H" U+ r; I4 @6 D: Y  x返回值，返回1表示成功，返回0表示失败。
! P; t: Z9 U* o8 c! P
举个例子：

1. /* 释放从DTCM申请的280字节空间 */
   + D5 a1 r+ p# ?- L/ ^5 J" c
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   
5. 
   
6. /* 释放从AXI SRAM申请的160字节空间 */
   & u( q1 l, O9 A* m8 N
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   3 d' r: E. C* A8 k/ X
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used);

复制代码

27.3.2 IAR上的动态内存用法
5 S# @- ~& F! [* v, X% b注：IAR使用这个动态内存管理，仅在定义时跟MDK略有不同，其它地方是一样的。
/ P/ ^' Z/ x7 p
  定义动态内存区
比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：

1. /* DTCM, 64KB */
   ( ?" ]& w/ c) \* P& [! b, s( _) s
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *DTCMUsed;
   , X" l& j* h# z5 {
4. /* 定义为64位变量，首地址是8字节对齐 */            
   
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

如果要使用AXI SRAM作为动态内存空间，可以使用__attribute__((at( )))指定地址。
; C- ?8 T) `1 _# n4 u. s

1. /* D1域, AXI SRAM, 512KB */
   
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *AXISRAMUsed;  
   ) A$ r( Y# a3 D$ |
4. /* 指定下面数组的地址为0x24000000 */
   
5. #pragma location = 0x24000000
   
6. uint64_t AppMallocAXISRAM[512*1024/8];

复制代码

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

% }' R3 c1 s+ [, h7 s

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

复制代码

  申请动态内存
通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。

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

第2个参数填写申请的字节大小，单位字节。
- e. [. ^2 v. M' x% ]  g( D$ V5 L
第3个参数固定填0即可。

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

0 |9 J3 p) |6 p5 O9 x4 d举个例子：
- m& ~/ }8 p9 }8 D

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   . w/ W( ]& p7 {, j+ t
2. 
   
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   2 l7 B) J4 ?) D2 h3 S; W, `
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   5 p! g% G  a2 R  R
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   
7.                                                              DTCMUsed->size, DTCMUsed->used);
   , I7 Y6 Z1 U6 f4 w1 z, R
8. 
   7 y7 p  Z+ h) }1 F
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   5 g' A/ `, m. R
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    9 y" [6 P: e. @
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    + z# U( `5 E+ i" w; E* ]
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

; i' C9 k/ O+ a4 i$ v2 @申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。
" ]# b, c! w8 L
2 ?6 U1 I+ a3 w  c  释放动态内存
通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。
$ F, Q) x* h( M$ `& V; k  F- Q- @9 v* W
9 c( e: a7 B# G* i, E第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。
; a$ w) I! w1 c+ d
4 a/ ]! d  }: W/ \( Q第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。
; ?0 Z- G# {  {( K
- P) u8 z$ b. l3 Y. L! G- ?3 J4 j返回值，返回1表示成功，返回0表示失败。
8 V+ M! m8 t6 v. t/ N
1 N0 `- C' n% m  T举个例子：

$ |- ~; Y) i9 M7 l! E9 v

1. /* 释放从DTCM申请的280字节空间 */
   2 S) G; D& R1 D% @
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   ' |; d4 R3 c; y" A$ I+ s
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   , h1 l/ Z- i+ A' p! n% i5 J" F) [0 ?
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   
5. 
   
6. /* 释放从AXI SRAM申请的160字节空间 */
   " E* l- `2 G- u7 x, A, a
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   " X! K+ L# E1 ~0 Y# S5 n
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used)

复制代码

5 G% u; w1 r+ O* Z27.4 实验例程说明（MDK）
配套例子：
V7-006_TCM，SRAM等五块内存的动态内存分配实现

实验目的：
学习TCM，SRAM等五块内存的动态内存分配实现。
% u/ l8 W% s. Z

实验内容
$ {/ F" C& S% L0 {& c启动自动重装软件定时器0，每100ms翻转一次LED2。

$ s6 P2 O" y4 B
实验操作：
8 l! @- }- G" j  a1 V( n8 F0 }2 HK1键按下，从DTCM依次申请280字节，64字节和6111字节。
K1键松开，释放从DTCM申请的空间。
, L; b" Y- ^0 MK2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
K2键松开，释放从AXI SRAM申请的空间。
K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
K3键松开，释放从D2域SRAM申请的空间。
# J* y- k( f( }; [+ D# ]摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
+ h$ ~+ i/ f" U3 d摇杆OK键松开，释放从D3域SRAM申请的空间。
* i6 Q+ W& Q5 U, F& A# C/ X

3 ~9 U, x; V' s/ a! \" g5 t' R上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1
: L% C9 e0 k# v. ^! [

程序设计：

  系统栈大小分配：
& ?% x" ?# X& r: Y# X3 W
+ \9 m, g" W' |" v

- ]- D2 c3 W# Z% V
RAM空间用的DTCM：

  硬件外设初始化
) v0 c- T  n) i* p
硬件外设的初始化是在 bsp.c 文件实现：
1 r; q" G/ _% ?  z9 k
# k4 Q& y, q; O- r  [/ c1 ~

1. /*
   " E' T+ F. @) m6 K; x+ G
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   + n: J% m# u* ^+ ~  Z# x
5. *        形    参：无
   
6. *        返 回 值: 无
   " q0 h6 Y2 s& m7 D  K# e1 m; C
7. *********************************************************************************************************
   
8. */
   # h8 H+ ]; _+ G9 b) E
9. void bsp_Init(void)
   
10. {
    & t4 @, q. K* p( A6 j& K* s/ B' I) e" W3 ]7 s
11.     /* 配置MPU */
    " h8 o) Z# ~2 z  |' @1 f
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    
16. 
    + v0 ]' i4 B6 k3 y$ N/ p
17.         /*
    , f/ u8 r) |+ e9 ?( s2 g9 V
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
      ~( b0 m: d2 a- p+ q
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    4 H4 i! L) G  R% W- s. D: p9 g
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    ! B9 l8 V$ @5 U: H8 n( U
26.        - 切换使用HSE。
    % \" n: R5 [; K$ ~0 C# \* l2 j
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    " O% t7 E/ s; j" }; V1 s# }5 }
28.     */
    8 |1 B# N2 J0 `
29.         SystemClock_Config();
    
30. 
    
31.         /*
    ! Y! u; s0 a" D
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    6 Y% Y; d# Z' `2 @+ H- O- d
39.         EventRecorderStart();
    
40. #endif
    ' r# j5 j8 ?0 k! n: }
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    2 l7 ?5 g& v" x) S, l
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    " ~. }" L7 L1 c5 B" x" m
44.         bsp_InitUart();        /* 初始化串口 */
    * K4 ]3 L% n$ d/ D1 i& D8 Z& h, }
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    - e, v2 G7 G' u8 j/ W; [/ G
47. }

复制代码

+ i' ~. S  ~  d0 r0 e  MPU配置和Cache配置：
; O- o& I- C) x数据Cache和指令Cache都开启。
# i, J1 v" K2 F1 E: |- {1 D  w
) T& A( X* y' s' }) l6 hAXI SRAM的MPU属性：
4 \( D; T3 m' h5 K* ?" N; x1 z) m
Write back, Read allocate，Write allocate。

8 p1 ], F, A8 x+ ~$ u4 M6 `0 ^FMC的扩展IO的MPU属性：
" ~, E, u; T  N' n$ n) @
必须Device或者Strongly Ordered。

D2 SRAM1，SRAM2和SRAM3的MPU属性：
! I( z; Y8 G- O
- A* w8 w2 g, d  Q$ M" x+ JWrite through, read allocate，no write allocate。
2 y% F$ y# d6 Y- h" \, ?8 \% e' s
7 o7 x. ]% Z# _1 H1 XD3 SRAM4的MPU属性：

Write through, read allocate，no write allocate。
3 k  ]$ k% x9 m( h

1. /*
   
2. *********************************************************************************************************
   2 N. u! n6 Y7 E" w) }! p0 _
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   5 S' E- v$ X* t. w" d
5. *        形    参: 无
   
6. *        返 回 值: 无
   8 }3 u. a/ {( I; P' \( k
7. *********************************************************************************************************
   0 o0 [/ U( a7 x8 u* r& G
8. */
   9 a) E# h- ]( r0 o8 I
9. static void MPU_Config( void )
   % G- [# M$ f* o( W, a- q/ g6 N
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    ( m' F! G, h/ j1 @, y9 l( X
14.         HAL_MPU_Disable();
    & e8 L$ {& ~. R9 k! ^* R: w2 k
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    4 ~$ E: @8 l) u0 v
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    $ e: Z$ f& w4 n" ~
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    : ?) K  Z9 L5 ^8 ~  Y! `4 T
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    8 M, g( h1 Y, P
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
      W8 y5 M# X; T% Y  |; V0 U  r! z
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ( z. Y# Y3 I- ^1 ~0 Z2 S% E; L
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    5 p: G! x2 ]1 e4 f% S$ `
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    5 W, m3 M% S: j  p+ }9 A
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    1 i. V! \6 `! z) T( ]
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    9 M8 Y; e: {2 X7 \! A5 x
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    & h0 z+ L; Y, V3 W6 f% ]# e' o
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    5 y# G& t3 ^) P$ {/ E
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    $ ^; i" n3 _  B; c) x( C1 F
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    # K/ X, e: b! |7 Y9 _9 E
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;
    0 a' d9 D9 P( S  B; K; D. |' e
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    - h# N( O& d* W1 @9 C7 [8 P
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    9 x5 {" e- t0 e
46.         
    6 W! \, G8 K, q- V) h
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    ! S( Q0 V, P! W' N; Q  R0 A
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    , i3 f# N7 T5 n; d
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    8 r: c) s! @" e
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    3 @, \8 y7 b  T; w
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    1 I/ i: M  ]1 r: o3 @( ^2 V
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    . J  x6 l1 p% \4 \* r  |
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    & H+ M+ q+ Y  r' [' e
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    % K1 i" g) @( }. h
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    5 ]9 N& l2 G' X1 ^
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61.         
    4 x' s) U4 P0 i8 c" n3 }! m
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    % C1 g9 B' `* B1 I: i( E2 @
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    8 a# B+ `3 _3 W4 N2 b5 o
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    - L# b6 U5 y2 H4 @1 {
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    4 o+ ?; D/ T# u1 l" |
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    8 _0 Q+ X& w% s+ t& `% j
74. 
    5 r0 C& b! l) m1 K$ _3 b% a
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
      q% Y$ W& h* N$ e
76. 
    
77. 
    
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    " j( S7 T9 G0 D/ g
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    4 N1 o; u" O! Y
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    ( H$ ]* m4 b1 w' ~9 T5 m: R
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    * v8 M, O5 b* O8 R1 z& y
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    7 \% v: o! Y3 w: c: P0 X
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
90. 
    4 l& L+ I4 t7 F, N$ |
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    & p9 S' w9 P/ |/ D1 _
92.         
    
93.         
    + C& R0 \" ~1 g) {. W3 u2 S6 \6 M1 Q
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    & }/ r) A6 W1 @  y9 g2 C* I. \* v
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ' c; I1 ^2 d' U9 Z; O
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    ) B& D; i) d& U2 u) {" X
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    * i& v# W2 |1 u, S
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    9 [/ o5 V1 A# m) ~4 i0 h9 B
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     $ M. u0 }* E; x% \4 Z
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     7 c' e: E1 b- _8 o: G! o
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     % @7 c/ x: B* q9 U
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     
108.         
     1 ^& K3 w* X, C# p' ~
109.         /*使能 MPU */
     
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     
111. }
     " ?3 s  P% a& o; x" B( U" n6 S
112. 
     5 g- Z8 S% I0 T5 @4 E; z9 X
113. /*
     + ?( n$ m) F# ]" ~" {( B' q
114. *********************************************************************************************************
     
115. *        函 数 名: CPU_CACHE_Enable
     
116. *        功能说明: 使能L1 Cache
       V2 b* R+ l. k6 d7 M
117. *        形    参: 无
     
118. *        返 回 值: 无
     + P; T! [, @5 J& v
119. *********************************************************************************************************
     ( ^  e! {# ^( m8 H, a9 P6 C8 I
120. */
     # O4 ]. A( R5 k
121. static void CPU_CACHE_Enable(void)
     
122. {
     ( l2 R$ i& B8 t. _- G9 g9 X
123.         /* 使能 I-Cache */
     
124.         SCB_EnableICache();
     8 `! u" ]( N7 z. n7 e
125. 
     
126.         /* 使能 D-Cache */
     
127.         SCB_EnableDCache();
     
128. }

复制代码

- s8 H, a, f8 r7 f, b8 C& m6 F  主功能：

主程序实现如下操作：

& M8 B. @! b0 z& n: Z& H* B9 `  启动自动重装软件定时器0，每100ms翻转一次LED2。
  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
# R* ~  U2 t" F9 y! M  K1键松开，释放从DTCM申请的空间。
8 ^5 Z1 {' ]/ ~3 A- R2 V" k' Q  C  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
+ E7 b8 n7 j( C$ W. U! F  K2键松开，释放从AXI SRAM申请的空间。
9 U8 N% z1 v2 ^; o9 K+ |  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
  K3键松开，释放从D2域SRAM申请的空间。
  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   ) G; V" ?2 V& s4 x3 f9 U4 j% W' F
2. *********************************************************************************************************
   
3. *        函 数 名: main
   . U: d) R! c4 u, d4 \$ p, i) [2 n7 v
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   2 s: |9 ]1 \) f6 }# ?
7. *********************************************************************************************************
   1 l% M  l: k# H, B9 j
8. */
   , S% Z; b5 A3 X" [
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    , \* X% d9 u. K& z/ o
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    
13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
    
14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
    
15. 
    
16. 
    
17.         bsp_Init();                /* 硬件初始化 */
    
18.         
    / u* L( F" j. ^, o  k' @
19.         /* 初始化动态内存空间 */
    
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    5 X4 m7 X( i; ]' g" ~
24.         
    3 o% z, F% I1 V# ]
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
26.         PrintfHelp();        /* 打印操作提示 */
    
27. 
    $ h- }- r' |2 p
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
29.         
    
30. 
    1 k6 U7 N& f( i  E6 [0 E8 o0 i/ y. p
31.         /* 进入主程序循环体 */
    
32.         while (1)
    5 L: i; x! l% E) j; R
33.         {
    
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    5 A: ]( A/ U# X$ d7 k
35. 
    
36.                 /* 判断定时器超时时间 */
    . Z; S* _" b) L. d7 N* i4 |, u4 Z8 o) K
37.                 if (bsp_CheckTimer(0))        
    , ]) d# ^" w( R  x
38.                 {
    
39.                         /* 每隔100ms 进来一次 */  
    / R1 k8 v$ O" N/ x3 R
40.                         bsp_LedToggle(2);
    
41.                 }
    8 V; d% B; k  t8 W' \. g) V& h
42. 
    
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    ) u# L6 u& L8 B
45.                 if (ucKeyCode != KEY_NONE)
    , d0 Q  \! O2 p  H1 L
46.                 {
    & T" H+ z5 h1 x  R  i/ h8 d
47.                         switch (ucKeyCode)
    
48.                         {
    0 U6 L/ k4 h/ }
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    . V+ m6 |! u5 B- L( K
50.                                 case KEY_DOWN_K1:        
    
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    
52.                                         printf("=========================================================\r\n");
    4 ^/ _$ v9 k+ E5 Z' b* ]- G
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    $ w6 Z3 D# |4 U9 P$ a# x& f; v
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    $ p" m9 d- d$ X& a5 o
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    / V/ ^/ |/ F; ?- m6 l% R
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    ) ~5 X; n- o8 A, d
57.                                 
    ; T& M; w! [5 f# t6 T
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    * n9 \2 q# s! a5 v5 ^' A
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    - Q* q5 R7 s: C1 K
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    ! S; r8 [) ?7 ^/ E. B1 z9 [$ S
63.                                 
    
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    % [, `2 n+ J" |3 H
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    8 Z6 C: ~/ j# k4 ?
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    2 Q9 Q$ H9 X/ x2 U7 z* ]
69.                                         break;
    
70.                                 
    
71.                                 /* 释放从DTCM申请的空间 */
    1 U: U4 k) N& f4 d% {$ g( r2 e
72.                                 case KEY_UP_K1:        
    
73.                                         /* 释放从DTCM申请的280字节空间 */
    / p' |, e4 R% x- L# H, ]. ?
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    + f6 V9 W5 W5 [+ m
77. DTCMUsed->used);
    # r  l, @2 \" k8 w. G
78.                                 
    
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    
83. DTCMUsed->used);
    # m7 Y9 B! R- k: h" j) ]* Z$ I
84.                                 
    
85.                                         /* 释放从DTCM申请的6111字节空间 */
    
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    : ]8 j6 [' y  }. }
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    + S" j2 Q5 k; u
89. DTCMUsed->used);
    - x4 f' |4 O9 {* Z/ M- t) ?7 B
90.                                         break;
    ; }  e( X$ @' t) e( U6 A
91.                                 
    " f$ k4 ~' F6 N; e
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    
93.                                 case KEY_DOWN_K2:        
    
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    9 e; \. G+ I1 e6 e
95.                                         printf("=========================================================\r\n");               
    
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    " X' I+ b: E/ L+ H# D: O7 b
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    8 B0 }) A/ y, _1 E
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    ! G6 f" c! x: ^
100.                                 
     % ~8 @, _( g, z8 C) L9 I7 E
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     , {) `& |: c7 e7 w, E. C7 v8 c+ a
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     
106.                                 
     
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     ( _/ {" h/ K4 E6 \9 D/ m
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     ; W/ G2 o5 d- L& V* j
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     * F3 n7 ?' C$ k
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
       X& c1 P$ q& z( S: s. }
112.                                         break;
     
113.                                 
     
114.                                 /* 释放从AXI SRAM申请的空间 */
     : S; _- ]( U+ V; ~% _3 m) C* F
115.                                 case KEY_UP_K2:        
     ( f4 O: z. ]: ?& o* P* k7 L# p% i8 f) \
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     & T# }3 M& z" s
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     
120. AXISRAMUsed->used);
     
121.                                 
     
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     # m  c* Q# f* Z' b8 q7 b7 E
126. AXISRAMUsed->used);
     5 q, r4 k" Z, E- c, ?
127.                                 
     $ n. p0 x" X  e3 N# j
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     9 B/ w3 k7 d5 d+ e: e) y% ^2 b% j1 O
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     * ~5 m/ |3 s. V, m( J9 ^
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     
132. AXISRAMUsed->used);
     
133.                                         break;
     
134.                                 
     . |( G3 M' h% Z3 Y/ C
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     
136.                                 case KEY_DOWN_K3:        
     & N; t7 x9 s$ f# X7 e) m1 ]4 q/ ?+ s
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     % b) O' j; u! Z4 J6 t$ H
138.                                         printf("=========================================================\r\n");               
     9 B. j8 N8 v4 N% C
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     6 d+ F5 U0 v( \! H. [2 I" t/ K
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
143.                                 
     , O0 M9 J& w1 X) R3 _! h
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     ; u+ X: b! g5 \
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     
149.                                 
     
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     * |( `. M3 v1 f! h% A
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     ) E/ r7 s% Q. L8 B1 ?
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     + n# e2 p3 O* K4 s; L/ C  r4 v
155.                                         break;
     
156.                                 
     2 u# ?" E8 d  H7 R
157.                                 /* 释放从D2域SRAM申请的空间 */
     . y, z' O% A# |6 y: q2 Q; U
158.                                 case KEY_UP_K3:        
     
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     / w) b: P, L5 ]' ^
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     
163. SRAM1Used->used);
     . V2 R: B0 ]/ p! `; t6 ?
164.                                 
     $ S0 N  I& `8 K
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     
169. SRAM1Used->used);
     4 u- H7 w4 c5 e1 c
170.                                 
     $ g, w! o% N0 J; l* ?  {) `7 B. W& v
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     . n" q" `( [" M) P0 X+ S
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     3 T! p$ y& B0 x+ j
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     8 x% \2 Y1 u. B' s) a
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     ) I2 ^! c+ L, a  x
175. SRAM1Used->used);
     . W: ]; S$ }5 G) l  `5 a- {3 y
176.                                         break;
     # I1 j) i6 M0 g! P+ v
177.                                 
     0 P' F. D' i. m- D, x( ^
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     + v( G+ a0 e" m4 r' I: k
179.                                 case JOY_DOWN_OK:        
     
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     
181.                                         printf("=========================================================\r\n");               
     0 T5 p7 L* [$ k4 H5 f
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     7 k- k8 [3 f( \2 Q( }3 e4 v
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     - @! W' k  K& P- F: R4 j- k
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     ' R  J- C) a% b. \
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     . Y. G, L- S$ `( _( O) a2 e
186.                                 
     
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     . m0 ]( J# \0 R: Y& J. q
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
       G+ k( e3 Z7 @; Z: T7 `$ j( ~
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     9 [/ p) C* E& D1 I9 K. ~3 h  a) v6 `
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     
192.                                 
     
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     5 _: z- U7 C) u3 g
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     ; w$ }6 y: E" O1 J1 x0 L
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
198.                                         break;
     ! o5 S4 f5 q* W4 C* [- M
199.                                 
     , `$ {; h9 g8 D  {8 e+ \/ D7 r
200.                                 /* 释放从D3域SRAM申请的空间 */
     
201.                                 case JOY_UP_OK:        
     ' ]" ^" s5 |0 Y
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ! C' U+ X/ d' a2 n7 U- N
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     * T; L0 J2 ^$ R8 d
206. SRAM4Used->used);
     
207.                                 
     * H. t# S6 q7 u6 l3 F: @
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     6 t$ M8 j$ |6 z4 n' p: ^* @7 |. Y
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     
212. SRAM4Used->used);
     . _! Y4 Q) r4 O' o' z& Z6 H' j
213.                                 
     $ M7 q' M4 W7 W" I/ D; V4 i8 D' U
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     , i1 ~+ Q& j, E1 D9 y5 S
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     
218. SRAM4Used->used);
     
219.                                         break;
     / k: W( D/ T  q4 S
220.                         
     
221.                                 default:
     
222.                                   /* 其它的键值不处理 */
     5 F$ ~4 I) X) H( k( g# g
223.                                   break;
     
224.                         }
     
225.                 }
     
226.         }
     ! W: L0 p' P5 C  [  h
227. }

复制代码

27.5 实验例程说明（IAR）
* a3 K( L! B! F/ x配套例子：
" S% i$ m; b1 |V7-006_TCM，SRAM等五块内存的动态内存分配实现
  r9 o2 `3 }3 x, p/ i& {! j7 q% S9 X
实验目的：
学习TCM，SRAM等五块内存的动态内存分配实现。
4 z/ ~2 R/ \' Z! O. N. V
* C% R4 o% c7 G" [5 T3 J7 c
+ y: B8 q8 F4 b7 ]# Q& \$ k1 W, M) j实验内容：
启动自动重装软件定时器0，每100ms翻转一次LED2。

实验操作：
K1键按下，从DTCM依次申请280字节，64字节和6111字节。
7 b5 A6 S3 a* G9 w( uK1键松开，释放从DTCM申请的空间。
K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
K2键松开，释放从AXI SRAM申请的空间。
0 Z- E. ^  n6 L/ XK3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
K3键松开，释放从D2域SRAM申请的空间。
6 w$ T4 B1 X3 s! e摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
$ O7 H) H% y" [9 v/ E5 {摇杆OK键松开，释放从D3域SRAM申请的空间。
! Q( ]* R+ O  j2 d/ R! Q
上电后串口打印的信息：
9 A! |2 `0 }4 Y9 j( D% q; d$ U
波特率 115200，数据位 8，奇偶校验位无，停止位 1
- g, q2 |1 M5 a( p

% [' v( D  Z$ Q6 d
# K) [! x4 I  W+ o程序设计：

  系统栈大小分配：

7 w6 l7 D& Z8 E, q1 k5 J( u: P  RAM空间用的DTCM：
, ~: N& c/ I- Q
" U3 f5 p2 w' _; K

  硬件外设初始化

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

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   6 P+ o/ ~1 f5 r/ C4 F1 k
8. */
   
9. void bsp_Init(void)
   & A! v( `* U, _1 x5 V' B
10. {
    4 X$ u3 h, d' q9 N6 g1 f  U
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    % e* a. m! h) f" i7 u& ]4 c, j
15.         CPU_CACHE_Enable();
    
16. 
    
17.         /*
    4 J6 c+ {, S' p! c. w0 y
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    2 B( A. _6 n/ _
20.            - 设置NVIV优先级分组为4。
    
21.          */
    : J) w$ k! j0 t9 h
22.         HAL_Init();
    $ \: [/ u. c4 r3 ~
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    0 H* Z$ g% u+ A8 g8 Z7 P
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    . r6 G; x: `8 _7 {3 |- d
30. 
    
31.         /*
    0 _2 c% ~) }6 U( i! l2 G
32.            Event Recorder：
    " v7 w$ d  h& a& F! h: N% J
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    + v! X0 D* x- V  f
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    3 }% S/ C( q6 l5 P! A9 e
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    : t/ T  Y: o; R' f8 n' U5 e! c" @
41.         
    5 `7 v+ P: Y; d) v
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    " l5 r2 q/ S1 o- @) U2 [* u. d
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    + d/ o! z8 R! `- u4 u: K4 Y
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    : p- G: X+ Q* Q" K. U
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

& |- {" c& X2 d+ B) i  MPU配置和Cache配置：
5 i" a2 X, g7 N0 y3 ^
! x# Q  ~5 e0 W7 v- o数据Cache和指令Cache都开启。

AXI SRAM的MPU属性：

3 w% @; q" t% IWrite back, Read allocate，Write allocate。
& F  h+ ?9 c; s3 _) I% {
FMC的扩展IO的MPU属性：
) `0 c2 f6 L3 H; T
必须Device或者Strongly Ordered。

D2 SRAM1，SRAM2和SRAM3的MPU属性：

6 p' O: H5 M7 v" lWrite through, read allocate，no write allocate。

1 @7 H; @6 `5 E/ `) ZD3 SRAM4的MPU属性：
8 d, c: q# f- a5 K
9 \1 v0 f, C+ M8 ]+ N. @3 U) ZWrite through, read allocate，no write allocate。

1. /*
   9 f) F# K  l7 G, v( Y4 {
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   2 T) J+ x& J$ ]5 {
5. *        形    参: 无
   % n% c% U- [' B1 E- R8 t/ y4 E
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   9 r2 b* E5 O( k8 @4 E% Q
9. static void MPU_Config( void )
   $ O$ b; x  ?+ g: T  f, r, I7 G
10. {
    - Y0 }' N8 W/ f' J2 O; P
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    7 K/ `; U! S3 E
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    : X4 B$ n9 u5 [* K5 Z
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    ! ?1 S( f; Z2 u1 \# G5 G$ p! V: c
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    0 n2 X. T- n5 R! ]  @& T& z9 @
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    9 V2 n0 e) }8 B% R8 L2 q
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ! Y" F1 ?- Y+ }& U. T) H. {6 m
30.         
    7 b2 R: Z2 [  Z) B8 v1 b) _8 j$ @6 E, E9 a
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    % ~" f/ ^; m3 d9 a
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    / E8 i+ b. S0 V5 R  {9 p5 s
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    $ G6 o# W: K5 T' f- f6 Z
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
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;
    . Z! H6 O) [% o2 x  t
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    4 b* x# Z3 l" h6 t& Q
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    ! W9 G4 o( A' h) K
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    . g, G- T( Q' ~/ c3 ~0 o/ |
44.         
    7 h- m" W! R9 K3 D0 |, I  q' n
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46.         
    
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    : D  w5 Q! s- R; c% T+ e
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    2 y6 w9 N/ @1 `9 l" C" g% C
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    " ^: L2 `* T  c) s# n% {) N5 o( @
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    : l) Y  `/ D5 F( d
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
      u8 r7 W# Q4 }: z
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    . p# x0 p; P3 D$ ~4 ]
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    : p' i3 F7 |# S
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    4 t% d! H) O- \% q- c0 h3 H
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    $ I/ [$ c/ {2 i, e
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61.         
    
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    2 o' `' |" K; s# c9 A
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    # C8 C5 Y6 G- j3 p$ B4 S
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;
    
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    ; b/ D- g9 C! L
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    - u2 A0 {% S5 A3 h7 [6 U: P* l
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    7 G9 e( ]% ?: ?. V$ F) P. V
74. 
    , l0 Y1 W" d- X- {. I4 u
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    6 ^; O# K+ q6 T1 l* v6 b' M
76. 
    
77. 
    # r% i( _' N- d7 `) l, D
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    8 h4 S; I, m2 l9 }; p! K
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    $ l  }0 w' @5 \9 l" ^, ~
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    1 @+ k7 R. G1 b+ g5 V# ]
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    $ S1 Q$ _% Y: G9 I. p9 A* A: D( u
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
90. 
    3 e+ x& g) B1 b1 G5 Q3 u
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
92.         
    ; ]8 O" a/ k. K6 `
93.         
    
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    % n1 m- r" B2 j7 R$ b6 i
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
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;
     
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     / ~& l3 ]+ k# F( n* P
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     & O! n0 L. e6 H
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     
108.         
     
109.         /*使能 MPU */
     6 U  S$ g$ f* k. i) {
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     
111. }
     0 i! I+ g, k3 H5 y; N: @
112. 
     
113. /*
     , Z2 k1 w9 s  W1 d/ b/ y; `. K
114. *********************************************************************************************************
     
115. *        函 数 名: CPU_CACHE_Enable
     / N2 L  w! C: z0 d6 B! Q
116. *        功能说明: 使能L1 Cache
     0 R, b/ j  Y- T* G! g0 s
117. *        形    参: 无
     ' y* }( ^) g: d) |# E
118. *        返 回 值: 无
     1 p" ^" z- X* Y7 _5 h
119. *********************************************************************************************************
     
120. */
     
121. static void CPU_CACHE_Enable(void)
     
122. {
     0 T+ }: }- W/ ]1 ?2 F- X
123.         /* 使能 I-Cache */
     
124.         SCB_EnableICache();
     
125. 
     / q; D( j+ o4 C
126.         /* 使能 D-Cache */
     
127.         SCB_EnableDCache();
     3 c0 ]% p! P+ M9 `; E/ l' y
128. }

复制代码

  主功能：

8 O& J. R# g! K- l) Q5 I主程序实现如下操作：

  启动自动重装软件定时器0，每100ms翻转一次LED2。
# Y) q+ g" H+ x1 b2 a, P% l  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申请的空间。
1 R( q" X+ h& X/ w  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   * I- h$ y+ M) w( F5 z0 i: g3 k
9. int main(void)
   / K% L) H2 C8 j5 I
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    4 S  C; B+ ]5 f2 l0 G# _
13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
    / P: G8 R  o5 X
14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
    
15. 
    
16. 
    - B' |2 L: g# |& A
17.         bsp_Init();                /* 硬件初始化 */
    ( b' c9 |2 E) X% T
18.         
    0 k5 `( e7 \  J* o" Z
19.         /* 初始化动态内存空间 */
    - ?: `7 K2 U( r6 ]  i% O* K0 }
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    : S0 o6 r: c  z5 t
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    
24.         
    , g0 S2 v& ]( \/ g$ Q0 t8 O
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
26.         PrintfHelp();        /* 打印操作提示 */
    3 n/ c/ F  E1 f6 ]4 u/ f$ z
27. 
    
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    , f+ |$ d# K5 H4 d& M
29.         
    3 y/ ^0 W6 ~$ y; [
30. 
    3 v1 L) K, z& |4 l/ _) u/ x; G9 k
31.         /* 进入主程序循环体 */
    
32.         while (1)
    0 D  s  G) t/ Y# S9 n& U
33.         {
    . R$ u# {1 P5 O1 l: ]3 V0 A
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
35. 
    
36.                 /* 判断定时器超时时间 */
    % \" f; v" w5 [( A6 L' L, E
37.                 if (bsp_CheckTimer(0))        
    
38.                 {
    2 i5 Q6 |# `2 }4 Q$ a7 C( n
39.                         /* 每隔100ms 进来一次 */  
    
40.                         bsp_LedToggle(2);
    
41.                 }
    
42. 
    - r& z+ R; i& l& U1 o" Q5 Y
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    3 p0 o' [: u4 R& e; L: ]# w
45.                 if (ucKeyCode != KEY_NONE)
    
46.                 {
    ; C- s9 K+ c! }  C
47.                         switch (ucKeyCode)
    
48.                         {
    
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    
50.                                 case KEY_DOWN_K1:        
    
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    2 W! p" U' j( U8 _+ S
52.                                         printf("=========================================================\r\n");
    
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    9 \! k3 g6 A$ a2 o# I
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
57.                                 
    
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    . h+ p( {2 z$ @9 ^, U7 ?
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    9 H8 T* q9 z8 U: ]7 ]
63.                                 
    
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    ; l+ |3 O8 J$ r/ J' b
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    6 U0 R) k, z# y/ V
69.                                         break;
    
70.                                 
    & p7 t# Z2 n, M4 N" ^7 @2 |8 m
71.                                 /* 释放从DTCM申请的空间 */
    . `* M( |/ i4 c
72.                                 case KEY_UP_K1:        
    1 j3 K# G  H' s
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    
77. DTCMUsed->used);
    * W" e6 Q7 o# q' |4 R3 `
78.                                 
    
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    ) F7 E/ {3 Y( F* ]! K- A' Z$ _
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    0 {' o: }$ z2 Z$ r/ f1 Z9 U! F
83. DTCMUsed->used);
    % H( w6 j/ S. O% G" O" q
84.                                 
    % r2 Z* Z! }% I! K3 L. W
85.                                         /* 释放从DTCM申请的6111字节空间 */
    
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    ( }+ m) F4 p2 V
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    
89. DTCMUsed->used);
    
90.                                         break;
    
91.                                 
    
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    $ J( P7 [0 N. j! H+ F. m6 D
93.                                 case KEY_DOWN_K2:        
    1 U  `+ o$ {& E) e2 C- N' g
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    
95.                                         printf("=========================================================\r\n");               
    ! e" U1 [" x9 m$ G4 ]; \
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    / ^- r2 w' B; i. W% _4 D5 s3 C
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    . N% q% B& L" r" r  }: o
100.                                 
     & _7 j( u( s* w' j
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     $ u& }" e. w- |) r6 ?/ c. J
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     1 `3 z+ ^3 U$ a- ~" X: W/ K
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     , ?+ V2 ?! H; T$ i. f: w
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     
106.                                 
     4 m: X! h/ \+ s2 q) M9 ]
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     / l% S& D4 O& |, T
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     % N2 G2 `9 @% f7 Y$ e4 r
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     
112.                                         break;
     
113.                                 
     
114.                                 /* 释放从AXI SRAM申请的空间 */
     
115.                                 case KEY_UP_K2:        
     
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     4 Z& P. v9 v4 I8 F+ o
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     
120. AXISRAMUsed->used);
     9 N/ P2 H/ [! u% I( k
121.                                 
     
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     # I; F) W3 }, K2 B7 {  Y7 o- U* ~  [% ?
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     , w9 \( ]/ {4 ]4 }9 b" W' o
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     
126. AXISRAMUsed->used);
     + B! j+ H2 }, ~- J- `  T5 x4 i% q
127.                                 
     1 v* {% ], O- _
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     1 M3 J( B/ v' F  s" [9 w
132. AXISRAMUsed->used);
     - [/ R% w7 j  J1 Q: ?
133.                                         break;
     
134.                                 
     9 B. g9 X! R# e% t$ R' h
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     9 R" c6 p* E* i
136.                                 case KEY_DOWN_K3:        
     7 ]/ h$ X, s# V. ]2 C9 A5 M' ^; ]
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     
138.                                         printf("=========================================================\r\n");               
     : A6 T# B7 C/ K+ J3 q
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     6 d8 @% o, M9 |% @& }( @
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     . c& x: x  d5 V0 L& \
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     * F( }9 O/ \  ?( K# {
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
143.                                 
     ( X, t6 _7 T& k/ y) w+ I
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     8 G+ k3 i& u# e* K+ L- w
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     3 P9 ~* s* O, O/ K, Z' S
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     / y4 k+ o5 c- m* v8 M% y. x
149.                                 
     7 [* `, N; {# w7 S7 V/ C
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     3 C, J" Y4 Z' z7 ^: l- K" }  G6 ?7 M
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     ) @3 V# y2 M: D- A# n0 A* T3 d! M$ U
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     - x6 t- p1 v! `% C  L
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     / O0 i2 N6 I, m7 `5 M- k2 w
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     : w1 k- \% H* m5 p$ G4 n
155.                                         break;
     
156.                                 
     3 ~, z* ~, x. U, s+ F# S
157.                                 /* 释放从D2域SRAM申请的空间 */
     
158.                                 case KEY_UP_K3:        
     
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     0 C) ?1 d( |3 h& F
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     ) T0 c# y& f$ j0 f! B' m
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     7 h; o' U& `( t6 Q$ O$ J, u- N" P
163. SRAM1Used->used);
     
164.                                 
     
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     * a7 c9 v. ~5 O7 P9 {
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     
169. SRAM1Used->used);
     
170.                                 
     
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     ; a8 _5 P* n- y5 g" k: @
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     ! T4 m$ U  a. @  x8 Y
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     2 A) G& P6 Q, V3 W9 w
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     
175. SRAM1Used->used);
     % `7 Y/ q7 b0 h- f' x( ~
176.                                         break;
     
177.                                 
     ' f* m$ ^" t# S- \( r% `
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     " d2 c( d# w% V/ f, c6 c( Z: \
179.                                 case JOY_DOWN_OK:        
     5 c$ Z# z$ V7 _8 J# |/ L
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     0 E# U6 ~# I: Z, C. Z4 z
181.                                         printf("=========================================================\r\n");               
     ! e2 Q% D" a3 ^
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     . h0 P% `; ~+ k3 A1 L" l
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     3 ~4 O- ?% a  V
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
186.                                 
     
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     - O9 }" \- S9 C9 A
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     9 D; b( Z5 a" C8 e
192.                                 
     # e0 T3 Z" p. S, [' n) @
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     3 L2 H  \% _. |
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     ( @4 z! y/ e3 `" P
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
198.                                         break;
     " o1 e: l+ j5 x  U' [  x: G
199.                                 
     
200.                                 /* 释放从D3域SRAM申请的空间 */
     & A% M+ U% X2 {3 }
201.                                 case JOY_UP_OK:        
     
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     ! N4 C0 m; F: h6 i/ `1 c  x
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     0 L( G( {0 U3 _0 p
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     
206. SRAM4Used->used);
     
207.                                 
     
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     ! C! B+ N/ C. j- s1 Z" n2 R& i
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     
212. SRAM4Used->used);
     
213.                                 
     " r. v$ V/ L" w5 ?
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     ' d5 G0 B' @9 j
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     0 T& ]8 N2 Q( o4 {
218. SRAM4Used->used);
     
219.                                         break;
     / M5 w9 p( x' F3 x$ w% l
220.                         
     
221.                                 default:
     
222.                                   /* 其它的键值不处理 */
     % W% W4 g2 K: s6 {7 N' [: F
223.                                   break;
     8 o9 y2 Z- c% T" U1 ?1 m$ r
224.                         }
     . N& r1 r$ L6 g  [" H/ l
225.                 }
     # p" [) \8 Z8 d, X/ H1 C
226.         }
     
227. }

复制代码

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

  X" ?5 G% }. \- H