27.1 初学者重要提示
! l- P( {4 o+ K/ r! i0 f" `! j& t- V  学习本章节前，务必优先学习了解TCM，SRAM等五块内存区的基础知识，比较重要。
  将RTX5系统的动态内存管理整理了出来，可以同时管理多个分区。如果其它RTOS中使用，记得做互斥保护或者加个调度锁均可。
2 F" n& C6 y  r3 B" l  支持动态内存使用情况统计。
/ u: w2 K6 y( P0 q% {' J27.2 动态内存管理移植
+ A% ^( _, C& l) k+ V  M移植比较简单，仅需添加两个文件到工程即可。
' z  N" p' e; d+ {: K7 t& ?$ Q! \
27.2.1 MDK版的移植
5 K# r9 M" B2 ~/ x0 n5 m% r  第1步，添加如下两个文件到MDK中
. a6 h. T# a$ k注，以本章配套例子为例，这两个文件的路径\User\malloc。
$ W3 O; g2 }! I  B5 A

  第2步，添加路径。
  s$ R% F: |! Y

  第3步，添加头文件。
5 t- C' H; t0 P% c如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。
' ]6 e. p0 p! G
+ S5 a8 z2 X$ l/ \, N通过这简单的三步就完成了MDK的移植。
8 T5 ^: ^, [% ^. d( ?* j
27.2.2 IAR版的移植
  第1步，添加如下两个文件到IAR中
! r$ w: j8 r( y4 r7 |1 f& x3 o注，以本章配套例子为例，这两个文件的路径\User\malloc。
7 U! z2 l) _; M0 @( I

1 K; T) `& ^1 Q& V9 p  {
  第2步，添加路径。

* E( k7 a, c  e* l( c. D
4 W2 R+ R3 s' F1 X  第3步，添加头文件。
2 `% ?7 m1 s) S2 O1 m* d: o如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。
. K9 |% m% l/ i# y) K
9 l  g* e7 f2 b& l通过这简单的三步就完成了IAR的移植。
5 V, X3 W( `5 Q8 n. o: ^0 g+ U
6 _- D, ?9 @& Z% E: M% r27.3 动态内存的使用方法
' j8 z, L: f0 J/ y+ f下面分别以MDK和IAR为例进行说明：

27.3.1 MDK上的动态内存用法
; ?1 s$ T9 N7 \& u! @5 R3 d% M" Q  定义动态内存区
比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：
3 S! ~& U1 {. W1 }  D

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

复制代码

" v  `4 V6 [2 Y. H如果要使用AXI SRAM作为动态内存空间，可以使用__attribute__((at( )))指定地址。
- j+ |$ C6 u* P, m0 _5 E3 g
! a! \# }6 D5 Y+ a8 o. J

1. /* D1域, AXI SRAM, 512KB */
   
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *AXISRAMUsed;  
   - e" f) f( x& b& I; J+ n
4. /* 定义为64位变量，首地址是8字节对齐 */
   ; T! ^/ P$ _4 m0 P; o& t2 I
5. uint64_t AppMallocAXISRAM[512*1024/8]__attribute__((at(0x24000000)));

复制代码

& ~) U+ D! E3 g( `4 L* s( ~  初始化动态内存区
调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：

osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

  申请动态内存
. p# _# _) L, \* x# I通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。

2 ^2 t% y* S$ R# x  u' V! S4 m第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。

% \! s4 \1 r$ k第2个参数填写申请的字节大小，单位字节。
9 R- w& G& I5 O5 I
第3个参数固定填0即可。

2 C6 `, j* U- M6 c& m( _返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！
' t0 O1 Z3 a. J- c! ^
8 a# u9 F6 k) k6 {举个例子：

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   
2. 
   7 @0 M/ v9 j" y
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   / w4 Z9 ]' `: U0 ]; Z2 ]! Z, |% Z
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   
7.                                                              DTCMUsed->size, DTCMUsed->used);
   ) t6 h; f$ E! t: x
8. 
   
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   # Y8 a1 m! {9 Y6 n) G! ^4 [# x( w! Z
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);

复制代码

5 E: Z1 Z1 ^! _4 A7 T- ]1 |3 P申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。
3 n- y: N9 v. @, k
. ~5 Q. M- z, C, I+ O$ K, j  释放动态内存
9 L9 X+ l% g' T2 _, _' ]通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。

/ g* V8 q. q: E/ O2 r4 v3 Y第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。
# G  |* }3 p6 g
第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。
  s. q( j4 j' M, b8 P
5 j* p, ?4 q- I( q2 m返回值，返回1表示成功，返回0表示失败。

" W: g& \/ H. {1 L举个例子：
. v4 t8 B. Z# u; M8 Q$ c6 {

1. /* 释放从DTCM申请的280字节空间 */
   0 X/ @2 J/ j! L- O3 \! Y
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   
5. 
   
6. /* 释放从AXI SRAM申请的160字节空间 */
   " X8 W& @6 a7 k" a" _! E
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   3 T6 M( V& }. `% w# w# c# b
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     B/ G7 G- f1 U/ d% E, c& p
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used);

复制代码

$ U4 g: V+ M0 g% s6 _* H2 ^27.3.2 IAR上的动态内存用法
注：IAR使用这个动态内存管理，仅在定义时跟MDK略有不同，其它地方是一样的。

  定义动态内存区
. U+ F( u8 G/ V' T比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：
3 V# d) n- x$ F2 ]+ ~9 Z% y

1. /* DTCM, 64KB */
   
2. /* 用于获取当前使用的空间大小 */
   " D( E1 ~) }0 E9 y* _2 C
3. mem_head_t *DTCMUsed;
   
4. /* 定义为64位变量，首地址是8字节对齐 */            
   
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

9 d5 B* h* _9 L0 \. d8 ^如果要使用AXI SRAM作为动态内存空间，可以使用__attribute__((at( )))指定地址。

1. /* D1域, AXI SRAM, 512KB */
   3 d- O6 ]9 J6 \% u0 T
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *AXISRAMUsed;  
   / `( E* p  r9 ~
4. /* 指定下面数组的地址为0x24000000 */
   & [( X. t! u. K& E3 Z4 g9 b; f
5. #pragma location = 0x24000000
   7 y# p  O, R) v
6. uint64_t AppMallocAXISRAM[512*1024/8];

复制代码

  初始化动态内存区
调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：
4 p( V+ Q  O  h

1. osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
   $ E( q% H( O" R2 K2 i  R
2. osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

复制代码

+ e; R$ u/ M+ \6 ?7 ~6 U" {  申请动态内存
2 ?% {9 G' e$ n通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。

第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。
: z' S, w' m- c5 I! h( O* \9 r$ s
第2个参数填写申请的字节大小，单位字节。
8 B8 P* ^+ d; z2 O! s$ I
第3个参数固定填0即可。

返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！
- M: J' H! ]5 [0 q
: C; S# C, m6 A举个例子：
" Y# n: {( I/ a; ~& t

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   + H; z) d" b1 \* o1 n( n9 x% S
2. 
   
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   3 t' H  `* y/ e( m3 A9 H5 m( q
7.                                                              DTCMUsed->size, DTCMUsed->used);
   ; N% M4 c5 [# g, O3 a
8. 
   
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   3 X+ e" M/ C1 b
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    + m1 @: p) }( Y  d) p. v9 X
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    . }0 X5 H7 ~) X! K: x7 A' }
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

9 V1 ]& {. Y4 ~! W0 r申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。

8 W# w  X: g; X  O. d* ]  释放动态内存
6 I  `! E* V/ X1 T# {  }通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。
) M# u, s- W- k' p, f8 P% O
" U- t8 {4 T- w$ _  o: [第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。
9 {" W9 c- P% R4 P5 p* U
第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。

: [; B8 U; h0 |返回值，返回1表示成功，返回0表示失败。

6 h* a& o% D: T; j' F" ]举个例子：

2 R" {# F) O4 `/ T# o+ I7 K# o) t

1. /* 释放从DTCM申请的280字节空间 */
   
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   / C, U2 ~& }6 i, Y4 P) g
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   
5. 
   , K: \! ?& p) i
6. /* 释放从AXI SRAM申请的160字节空间 */
   
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   7 D9 u5 f- ^- b) u- m5 L0 G7 X
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used)

复制代码

8 \1 h, U+ w! @$ R, Y27.4 实验例程说明（MDK）
& }0 G2 H0 N  ]* w% f, U# U配套例子：
V7-006_TCM，SRAM等五块内存的动态内存分配实现

实验目的：
0 f7 l* y+ p& g学习TCM，SRAM等五块内存的动态内存分配实现。
4 I& p& b+ c6 H2 M  F7 h. W

5 U' q0 d6 H9 \% J. e实验内容
6 V4 d# Q- r6 \. f6 K: {3 _启动自动重装软件定时器0，每100ms翻转一次LED2。
6 F6 D( q: ~6 N" ^# k4 q5 B( z- G

" Y, r. n* m: f" {" J3 Q实验操作：
K1键按下，从DTCM依次申请280字节，64字节和6111字节。
K1键松开，释放从DTCM申请的空间。
: E* u4 o  Z! nK2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
K2键松开，释放从AXI SRAM申请的空间。
' U+ r; v+ D. }% F* @! e8 I: UK3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
6 B: o( m. k# D: G" ZK3键松开，释放从D2域SRAM申请的空间。
! N( S8 N  }# u; o( j摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
摇杆OK键松开，释放从D3域SRAM申请的空间。
, H: U5 ~3 \& f% d) ~1 F
7 D+ I2 ]9 [: ?% m8 z' y0 g
6 [: U3 R  ?8 ^0 n上电后串口打印的信息：

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

' u9 V0 T! a- |2 i# i

) k* l7 I: L' L3 R3 d
程序设计：

, b2 w4 k9 g0 a& W; l  l7 h0 y  系统栈大小分配：
) {( |( _( T1 w/ `: L, F

RAM空间用的DTCM：

& d  w6 L5 X# B/ Y0 k0 b

; ]7 R) ^5 y& j7 y. t( v  硬件外设初始化

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

1. /*
   0 `9 d' V" Q: T7 y
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   : e  y# p5 C9 s$ t7 a& V
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   5 `. x( g1 X0 A
5. *        形    参：无
   8 {5 ^: T1 r- D
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   + D) D9 v# J" R. w2 k
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    6 p( v5 R; u  X" C
12.         MPU_Config();
    
13.         
    $ T& W  j( h: |& f
14.         /* 使能L1 Cache */
    3 A) D/ Y% e8 a
15.         CPU_CACHE_Enable();
    ; d, e( B9 O5 Q# y2 m
16. 
    4 a+ o. Y; V5 Z  k( _
17.         /*
    - b+ j. n2 U* G* M3 E+ r
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    ( t" i, f: C4 g1 \! q
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    & H; w/ t  G. ?2 U: J% o
21.          */
    $ x4 `+ l6 P- d1 r" B: b7 z4 ^! O: p2 }
22.         HAL_Init();
    ' O' S( x) \! L
23. 
      g9 ?( t( y" \% {2 U
24.         /*
    5 u4 j; B7 M7 z  s3 N6 _3 j; v
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    " h3 l! b9 z% p9 [) V' I
28.     */
    
29.         SystemClock_Config();
    
30. 
    
31.         /*
    / Y% E& w1 k% g+ S( X/ E
32.            Event Recorder：
    8 @% F/ B9 x1 o, N4 O  u, \
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    4 d+ E( s  \- q1 @& u2 K8 G- {
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    " p) B8 O0 P; `  v2 d
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    1 _- K. b1 ?- n7 z  b5 g8 K
40. #endif
    6 h% v* O* a8 _$ e! w
41.         
    : e. H9 b% Y3 J3 F- E7 @
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    6 S# V6 W& r6 v
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    $ [& p1 B. q' o; h9 T6 M7 f& W
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

$ b3 B" h6 x  `; @3 j# @/ q  MPU配置和Cache配置：
+ [9 v" h; ^3 S3 @1 u" m( W8 J数据Cache和指令Cache都开启。

. r& o, D/ D5 f) P% a: MAXI SRAM的MPU属性：
- e2 J+ e* `0 X6 ^" k+ p
, p3 B, p) N) Z4 H7 _4 DWrite back, Read allocate，Write allocate。
( Z. S/ T1 _$ q9 I
FMC的扩展IO的MPU属性：

; c) |2 S: Y6 _& q5 G必须Device或者Strongly Ordered。

: ]$ A- q1 X2 B+ `7 |8 [( {D2 SRAM1，SRAM2和SRAM3的MPU属性：

Write through, read allocate，no write allocate。

D3 SRAM4的MPU属性：
/ Z& d7 X4 N! ?/ |" D; r" n8 e
+ d* s; z. v3 m* E  WWrite through, read allocate，no write allocate。
& `* f& D: f% Y6 |. s* O' r

1. /*
   ) e/ ?  [, w8 y' R- ^  e$ b/ I
2. *********************************************************************************************************
   & D( Q- H/ m! J; P9 F1 n
3. *        函 数 名: MPU_Config
   " R: f  o4 Q- [- V# _
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   ! C+ [  s; V) s8 ?- Y2 a
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    . j( [4 o# [7 k) j
12. 
    0 ~2 m* |! Z8 S7 ?* K" [3 Y6 W
13.         /* 禁止 MPU */
    2 ^/ I7 ^8 N! a
14.         HAL_MPU_Disable();
    
15. 
    7 i9 _$ ]+ n0 B2 ]8 }0 A
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    ) |7 q! k' n5 Z$ E" f
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ) W# |, n& M3 O2 [: |; b6 U
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    3 F9 P! a4 l1 G& o- L4 }
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    - M/ U. r; v- C
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    , H0 t& d- v* ]: P+ s
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    2 f2 X: z2 B) x% M5 V  Y
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    7 x# ~% }# M! g# d- A1 M  f1 x$ J
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    8 D' |$ W, D  E8 o. ?% Q) {$ ]
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;
    1 l0 l9 B+ H1 w( B% g$ A5 p) Z: A/ x
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;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    , ?/ H4 Z& g& G$ Z: c: e
44.         
    + }( o' P, t; L# O5 C% ?) g5 a% j; t
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46.         
    
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    " F* M: B$ `" F  d& W, l
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    % g) \! w. n5 k6 b
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
      ?5 R: v6 k  L9 O9 Q/ U  S
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    , ^& k1 K  [: [2 u- ^
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    5 D" a3 q9 d4 s$ D' e3 B% F+ f
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    2 Z8 }# g. z1 ?
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    3 V4 g1 w8 u0 w( D) n0 @  B' z
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    - I- W5 p* E2 R! b) v
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61.         
    ' g0 L/ W" B. W" u
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    5 H# E. ?! w$ [; y0 `
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;
    + p) {8 G6 R, q0 ^- u; t+ a
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    % W2 t; e/ R$ L# ~  }0 N0 @
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;
    
74. 
    0 g9 a6 c% N, S' p% s. {2 |9 }$ A3 m3 }& x
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
76. 
    
77. 
    
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    " l  G* a7 X- I- n! a$ t
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    , ^. l+ N1 d( y+ i9 q6 X
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    7 v2 h- u  \; x% M7 t* _; Q! T
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    9 x) l/ O" k0 ]+ Z- K
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    1 ?, b- e5 \3 B. R: w' R& `5 _$ [
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    * R4 _5 \: Q3 @" L$ v
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    % [; P4 n: n9 x- q
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    ; Q4 c: J' q$ g$ I0 S
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
90. 
    3 I8 m7 u- ?' G  ~
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
92.         
    + y3 B# `8 w- w( P
93.         
    
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    5 W1 s  T2 x/ Y2 z
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;
    ( K5 `7 x/ H8 N% q
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     " Q5 x3 e# `) F7 h2 J
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     
106. 
     ) H2 @1 K( f9 B6 C* a2 }- {9 Y
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     
108.         
     
109.         /*使能 MPU */
     
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     . k/ f% p0 {6 |. b" b7 M4 p
111. }
     
112. 
     4 p  X* [$ m* j3 G/ C
113. /*
     ! S. z( r7 L% i
114. *********************************************************************************************************
     
115. *        函 数 名: CPU_CACHE_Enable
     ' T9 h5 G+ J$ A! b# W
116. *        功能说明: 使能L1 Cache
     
117. *        形    参: 无
     
118. *        返 回 值: 无
     3 ]6 C( \4 M0 ]) k3 @6 K1 y
119. *********************************************************************************************************
     
120. */
     
121. static void CPU_CACHE_Enable(void)
     ! W. k! }. K* q  `
122. {
     . y0 R4 G  d3 h
123.         /* 使能 I-Cache */
     , s& n) a; W9 ?: ~* X  u
124.         SCB_EnableICache();
     
125. 
     
126.         /* 使能 D-Cache */
     ! n0 F# _4 X8 x8 @
127.         SCB_EnableDCache();
     + A# ?2 o& j7 F* ]# _9 I/ i6 i4 p
128. }

复制代码

) W! ]8 F4 G" [: D4 ]  主功能：
* m2 _+ L- Z* J0 }5 }. g  c/ O" e
  M4 R7 ~0 ]- J/ Q主程序实现如下操作：

) a4 z) Q9 M- w! W6 y! {9 e  启动自动重装软件定时器0，每100ms翻转一次LED2。
  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
  K1键松开，释放从DTCM申请的空间。
  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
  K2键松开，释放从AXI SRAM申请的空间。
  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
# m9 w$ q) D& O" p: K3 [& c1 M  K3键松开，释放从D2域SRAM申请的空间。
- }! l' F- l  }- K  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
1 z& a: h! y+ @7 M1 a- q6 l# \  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   " @6 r, C: {" Z% M6 K9 x5 M
2. *********************************************************************************************************
   
3. *        函 数 名: main
   - X& t, Z6 J$ Y+ q  v
4. *        功能说明: c程序入口
   6 R2 D, Z9 y+ w
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   , W' u. f) R( E7 J) O7 R
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    * i2 w: j: S" _/ N
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    9 f$ `3 O" d" g& f
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();                /* 硬件初始化 */
    7 u/ q0 I8 t3 ]! A% G- R. Y8 W
18.         
    
19.         /* 初始化动态内存空间 */
    ( X2 B7 _% P$ ]
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    
24.         
    2 {' Z$ F; ~- H
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
26.         PrintfHelp();        /* 打印操作提示 */
    ) r8 O) v; o& E9 {; [& r* W
27. 
    $ b2 A8 h* E& c9 Y% y3 R8 M
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    0 A; ^' M( C$ k& g( {  k
29.         
    + f! T* P8 U* H% W' \+ @
30. 
    1 b. ^6 h, A$ [' W  f3 ^! E
31.         /* 进入主程序循环体 */
    
32.         while (1)
    " P4 n& S, t; X2 Q/ t8 G( c
33.         {
    
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    3 a" C% d: k0 \) k* U5 R0 V
35. 
    
36.                 /* 判断定时器超时时间 */
    
37.                 if (bsp_CheckTimer(0))        
    : O9 F: G% U+ T9 h
38.                 {
    
39.                         /* 每隔100ms 进来一次 */  
    
40.                         bsp_LedToggle(2);
    4 m7 D5 r$ ^2 t- W* [" g
41.                 }
    7 s2 R0 X2 c4 t( _
42. 
    
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    4 |, M+ ]9 P% p1 U
45.                 if (ucKeyCode != KEY_NONE)
    
46.                 {
    
47.                         switch (ucKeyCode)
    
48.                         {
    
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    $ C& b* p" N- K% v5 l! k% q1 |% T
50.                                 case KEY_DOWN_K1:        
    7 S8 j5 O1 X; \6 Q
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    
52.                                         printf("=========================================================\r\n");
    
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    ) R% c5 ~( Q  `; U7 a, ~) b
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    & f- T% g6 F7 |: ]- V2 v) ]
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
57.                                 
    
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    ) t/ e7 Z  g  Q# c
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    $ b  |1 K$ N% J5 U5 j
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    
63.                                 
    8 o0 M  D* G4 Y# K$ r
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    8 _! D& z8 L# P5 ]
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    ! ?% M& ]  |/ Q6 p, ^" P; r8 Z
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
69.                                         break;
    # n& n0 ]! l! L9 o9 e
70.                                 
    
71.                                 /* 释放从DTCM申请的空间 */
    
72.                                 case KEY_UP_K1:        
      G) d) J. k1 f
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    ! j, `% H- g3 g3 \) s* B. O- Z! b
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    
77. DTCMUsed->used);
    
78.                                 
    
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    - g5 r! j0 d0 M$ X1 X# ?; A  F
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    + B8 x/ o" N9 b$ {
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    6 Y, V& F+ P$ }) y% B+ ?! Q, c
83. DTCMUsed->used);
    9 s3 Z1 c) s( c, _
84.                                 
    
85.                                         /* 释放从DTCM申请的6111字节空间 */
    & C. z/ D- D% U2 f- A/ I
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    
89. DTCMUsed->used);
    
90.                                         break;
    
91.                                 
    
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    ) ~( ^; W3 b' R, r. C# v7 r
93.                                 case KEY_DOWN_K2:        
    
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    
95.                                         printf("=========================================================\r\n");               
    * x4 ~) \4 z1 o" A5 P
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    2 n+ T" B1 G. p8 F! t" E
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
      N' z5 ?. V* I, M% ~) ^2 Z
100.                                 
     
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     % P. A8 c+ p, ~1 T, V8 w' ~
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     & p4 W) c; G' ]8 _9 x
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     - I7 K' \& }9 Q
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     
106.                                 
     " T& ^0 N- z/ u/ I2 }9 Q$ F+ r' w2 Q+ g
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     ( u$ d  S* A9 J/ G
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     , }: D3 h- y& x
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     5 e) R6 K' ^. t6 C/ Q' M, [( R
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     $ i# t* w( W. d% A% W
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     
112.                                         break;
       P" v1 W* r& `4 F( I, c4 G5 F2 G
113.                                 
     " k% y; S% [" G: F$ B
114.                                 /* 释放从AXI SRAM申请的空间 */
     . h9 |& ^8 s5 d* u& `
115.                                 case KEY_UP_K2:        
       N5 T8 z* u( Q0 n5 T2 j$ _
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     7 m7 a7 g1 D$ D1 w8 J1 P, W, a
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     . e0 i( j6 Q* w& p
120. AXISRAMUsed->used);
     7 A3 F( @/ U7 n& |, x
121.                                 
       N1 W6 W$ I* C- C3 S9 ~% B
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     $ Q$ Z) g  _6 a; ^% w: v" f
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     
126. AXISRAMUsed->used);
     
127.                                 
     : X, m$ Z( j; q3 x$ e3 |
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     0 L$ s0 k- g7 q: ~
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     7 L5 |( T2 t& s( n" f
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     
132. AXISRAMUsed->used);
     
133.                                         break;
     
134.                                 
     
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     
136.                                 case KEY_DOWN_K3:        
     * s% n+ E1 w8 Z( |* y6 e  a( V
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     
138.                                         printf("=========================================================\r\n");               
     & j& K- w# f1 |) Q3 w
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
143.                                 
     
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     ; A5 D, ]# k. W4 Y
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     5 Z) s8 |% @8 O' K% U0 ~) r8 B# v4 k
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     1 S8 w3 @, c! c% b* H) j" k
149.                                 
     
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     & s$ L' n% D. a
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     1 @0 U! ^4 n' G
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     # W& Y! u1 a  [, ^& g( j
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     * K+ M1 d6 ?) i
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     ( W& {6 b+ M! s$ k& @
155.                                         break;
     
156.                                 
     5 H/ Y3 V* m+ D+ {
157.                                 /* 释放从D2域SRAM申请的空间 */
     
158.                                 case KEY_UP_K3:        
     9 I/ P/ \% ]7 w8 B% Y, M
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     
163. SRAM1Used->used);
     ' A! ?* e1 m2 M; c) y1 \. ?
164.                                 
     - h1 ?' y3 @' I( ~! O( i1 B6 m
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     $ @- n7 F/ }. e. A1 \
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     + W7 x* U  {' Z
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     
169. SRAM1Used->used);
     
170.                                 
     8 S' q5 `2 W$ h
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     # o2 ~' O- K- n6 ^+ K( p0 u
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     
175. SRAM1Used->used);
     
176.                                         break;
     ) @% w6 W9 t* B# S& y- b
177.                                 
     
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     
179.                                 case JOY_DOWN_OK:        
     
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     
181.                                         printf("=========================================================\r\n");               
     2 I( V2 ?% J8 j0 E0 q, p1 ]
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
       @/ @5 r& f, u& ]/ V2 O/ p
186.                                 
     
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     $ I' {' V5 n0 ~$ c& v' e4 I
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     3 n0 M2 s: B: E: G0 a4 X) F8 ?
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     + _. j9 i' n: ^. ^
192.                                 
     & `! e. b/ E' [" P7 I2 R; o
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     0 H* x6 D! S8 i2 a" [
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     / L( T. f3 ~% j% I
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     9 o' T/ V5 p. o' p% S9 G
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     , E' ~2 D2 \0 g; X
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
198.                                         break;
     6 J; b) Q% e9 C* R
199.                                 
     ' O! n$ K6 \7 Z8 K6 A" b! P- D9 n
200.                                 /* 释放从D3域SRAM申请的空间 */
     
201.                                 case JOY_UP_OK:        
     
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     : e5 L$ d9 b2 E( B3 t
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     , w( x9 [  J8 b( _5 e4 Z5 ^' @
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     3 t- m2 l9 U: g( a2 e4 s; U
206. SRAM4Used->used);
     $ [0 J+ c" ]; t' E
207.                                 
     
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     5 a! [6 u- b8 o' A
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     % Q7 c$ Y0 Q+ m7 j4 x; _
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     
212. SRAM4Used->used);
     
213.                                 
     
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     0 S  O9 k, h0 ]) t
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     
218. SRAM4Used->used);
     
219.                                         break;
     7 s+ m$ ~% X. {3 k  w; x
220.                         
     - v+ w. X* y# F8 n
221.                                 default:
     : m- O# d. m1 E" g1 }3 j- l7 ^
222.                                   /* 其它的键值不处理 */
     ) V6 Z% d5 g7 d$ u8 ^5 f
223.                                   break;
     
224.                         }
     
225.                 }
     
226.         }
     
227. }

复制代码

27.5 实验例程说明（IAR）
配套例子：
V7-006_TCM，SRAM等五块内存的动态内存分配实现

实验目的：
学习TCM，SRAM等五块内存的动态内存分配实现。
/ x. B: g' U0 m* Z8 A! E
5 G2 }" }- V# M' }0 g0 l+ M2 `
实验内容：
启动自动重装软件定时器0，每100ms翻转一次LED2。

/ i! c4 @/ `" y8 Z2 K实验操作：
K1键按下，从DTCM依次申请280字节，64字节和6111字节。
3 f0 R; a+ l4 h# ?6 Y' SK1键松开，释放从DTCM申请的空间。
K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
K2键松开，释放从AXI SRAM申请的空间。
7 f0 c; J8 l* Z0 K* IK3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
4 O/ S7 I/ U5 PK3键松开，释放从D2域SRAM申请的空间。
摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
8 s. p/ T4 W' i& v摇杆OK键松开，释放从D3域SRAM申请的空间。

上电后串口打印的信息：
3 d/ A1 [- Q- b2 ]% z, f/ a
波特率 115200，数据位 8，奇偶校验位无，停止位 1
3 P3 r. R8 d* R. L* H+ @
+ ~$ ~* F# }+ ^

' I. v8 ^8 L& J2 J: s, i9 ?
程序设计：
& v3 M- G  a: r% I/ v
% ]2 |: d- ^3 q: a( ^  系统栈大小分配：
7 V% T9 c2 F; x, |% {
4 `% U- e) t* e* ~/ L5 q

8 Q/ `! |/ B) W2 N: e( w9 d
  RAM空间用的DTCM：

  硬件外设初始化

7 Z. g1 T: I, L硬件外设的初始化是在 bsp.c 文件实现：

: _' D$ G: B. c3 N1 P8 m6 U

1. /*
   # |  K8 W1 L" c# \' E
2. *********************************************************************************************************
   ( U' n8 Z1 u* _) h9 R8 R# d7 @
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   0 {& v, V& m% q$ [& V  r. g
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   # y% a' R! B  t8 e: |
8. */
   
9. void bsp_Init(void)
   8 p" J! G0 B- \; U1 T
10. {
    
11.     /* 配置MPU */
    ; Y3 z' T8 v( A* e; J
12.         MPU_Config();
    ( V6 f5 i  b& R" O8 ?& `9 {
13.         
    4 g8 S( F8 f2 T- p+ Z
14.         /* 使能L1 Cache */
    & b( s. \1 W$ p) d- v, s
15.         CPU_CACHE_Enable();
    
16. 
    
17.         /*
    0 S: P9 c6 e% |0 A; b+ d
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    8 }% k; X/ T  }: S
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    # @7 C8 [1 w/ i3 C( f8 B
20.            - 设置NVIV优先级分组为4。
    - ~0 b* t) u$ @! l4 O& i: {4 V7 ^1 d
21.          */
    
22.         HAL_Init();
    3 l8 g/ k$ d2 Z4 l9 K' N
23. 
    7 H, ?# E5 r8 L- m% t( A2 @
24.         /*
    6 t* N; N  j3 C; l# c
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    2 V  f6 ~5 I# T! J4 s6 M$ v
29.         SystemClock_Config();
    . [7 l0 v, R7 s! h& z& U; j9 j
30. 
    , ]" J, _) t: L4 m; Y4 n$ N
31.         /*
    . b2 |8 f0 Q8 E% ]( a2 J
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    4 E. R, S2 _* v5 U- O) b( w# V
39.         EventRecorderStart();
    9 y; E% w" `3 P
40. #endif
    
41.         
    ! A' b4 ~( P% _
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    2 v$ U# n8 w' y* s0 x" g
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    + m/ L$ t' b: d9 B
44.         bsp_InitUart();        /* 初始化串口 */
    / ]* m9 H3 L  z+ l
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    ) i* b3 s" D) f, a! u; s% [
47. }

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。

. ~. D/ P4 S* S" [) s( JAXI SRAM的MPU属性：
% f! g7 ~: b9 h+ K  X3 ?$ G
Write back, Read allocate，Write allocate。

FMC的扩展IO的MPU属性：

, J5 C) b) _6 j必须Device或者Strongly Ordered。

D2 SRAM1，SRAM2和SRAM3的MPU属性：

( }1 H2 s5 u( @" w5 lWrite through, read allocate，no write allocate。
% z0 t# d& a% ~( O: y7 o3 V! X
3 p3 p( @" ?6 t: U. DD3 SRAM4的MPU属性：
6 s0 x* i1 J2 i& m8 `
8 H1 B2 O; p$ M2 U5 U% [- YWrite through, read allocate，no write allocate。

! G+ w. B' V4 Y  ]2 U) ~/ A" L( u

1. /*
   
2. *********************************************************************************************************
   , \/ k! w. e: {5 _3 C' }4 G. K
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   1 c+ F5 I$ u, F9 ^0 ?: I0 L
9. static void MPU_Config( void )
   * o% L" m1 ?* q1 L
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    & |8 s, f8 U- s; B) I; b/ J0 S
12. 
    
13.         /* 禁止 MPU */
    7 x. U# D* k% Z; f
14.         HAL_MPU_Disable();
    ( Y6 P' [4 i( h( u
15. 
    6 C+ I, k9 t1 S/ M
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    . A7 w/ f6 E- N
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    8 ?+ T: n0 F% c" d
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    - H% G3 V/ H$ ^
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    $ R+ B' R1 I3 x$ y% g9 |7 ?0 q
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    8 `# A( `+ I5 E
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    / q3 r- t5 u6 K  E3 T/ W7 x* f
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    " [! P# H0 v. |- X0 s5 V5 _9 @
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    ) P. O+ J$ [" R* K
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
      U+ T7 M: o2 L
30.         
    
31.         
    + Y* m+ U/ R: Y& q, W
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    6 f! J  a: k5 m! R; k  h
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    : H$ J* |# a/ ]
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    ) |& O1 h( r5 r. w3 J
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    7 C8 \( J6 h% A% z7 f: H( x9 D
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
      ~' _, p% N/ J  M5 Q
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    2 h+ s& m/ e/ R+ X
44.         
    6 o; i. E$ h1 R6 W: q3 A3 ]8 j
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    5 P5 M: r7 E( s1 E
46.         
    9 `4 x" Y  r) z; ]% ?# G
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    . i2 y( D2 v0 c1 \0 E  F
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    3 U7 \6 n  ]( c1 F
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    . K1 d  r# _; `7 Y- W' `6 k  b: _
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ! w; ~  t9 @3 u$ X4 \* Y
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    2 c- T+ ~9 h. k. `! I% y! E' i
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    9 b; `$ ^4 j9 R& F8 u
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    " N& ?: h0 t2 U
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    5 \$ B0 ]+ k" O; q5 y' T5 R3 y7 _" `! r
61.         
    : R/ @' l% K4 ~3 j9 }2 U
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    7 w7 O1 ~; W/ {+ q' x  }& E. k
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;
    4 R& U3 G; e$ S7 J6 S4 g4 x  }3 ~  ^
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    % V! _. Q3 ~- @# X& }2 [
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
74. 
    
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
76. 
    
77. 
    
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    + [! x: X) W$ ^4 `4 a$ _
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    % ?/ ~0 p# D. ]5 F: a7 X
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    0 e5 I4 ]7 [+ e1 D& Y; _# Y  A0 _* A2 D
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    3 @) w0 y8 q5 P% B( ]3 Z" D
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    + S; m( x5 s- S: r$ _
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    / g) x( k8 ~6 ]% ~0 g
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    2 a7 P5 \4 U! e- ]+ G0 c+ D
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    3 g1 z0 m' O2 e/ Y, @
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
90. 
    ' J9 S- R3 t  s9 N5 d! P
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    # {: I( M5 T5 |% w; O7 L+ V* t
92.         
    
93.         
    
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    & @, d' J1 {( n2 h9 Z
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;
     ; E8 z5 O: ~: }: A! u
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     7 @$ ]" M+ C0 n/ @
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     
106. 
     % C: O/ X) h, \+ O" @' U5 S3 H
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     % |- J' Z) V! T3 S8 B" e
108.         
     6 E3 q0 ~: ?; p1 S; t& I
109.         /*使能 MPU */
     9 a1 X- c. t6 P8 B: b' v, C
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     
111. }
     ' D8 f/ ?; b! k" e
112. 
     
113. /*
     
114. *********************************************************************************************************
     
115. *        函 数 名: CPU_CACHE_Enable
     ) L) O# A5 c9 B: ^- B/ Y8 f
116. *        功能说明: 使能L1 Cache
     $ q1 _$ n. {9 P3 w  S5 V
117. *        形    参: 无
     " Y* w) i- [7 U+ v; U
118. *        返 回 值: 无
     
119. *********************************************************************************************************
     
120. */
     
121. static void CPU_CACHE_Enable(void)
     % v( r% S( N1 P4 _
122. {
     % `9 l# v: y4 j* c0 t
123.         /* 使能 I-Cache */
     % L& ?* _0 d' }" M+ x* Y
124.         SCB_EnableICache();
     
125. 
     ) T* e1 c: c7 |. x
126.         /* 使能 D-Cache */
     
127.         SCB_EnableDCache();
     
128. }

复制代码

6 S: P( M0 d. @0 c  主功能：
- K+ g7 g0 y, T: k( n
) W1 Y* t9 b7 C! w# z主程序实现如下操作：
8 m  C* d1 f, p8 V0 D' p6 I: ?
  启动自动重装软件定时器0，每100ms翻转一次LED2。
3 ?) s$ @( x' h2 D5 w) j  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
  K1键松开，释放从DTCM申请的空间。
  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
  K2键松开，释放从AXI SRAM申请的空间。
. z; [1 F9 j% k0 O0 }  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
5 _. q  k5 z6 {+ x. ~' G4 P: N  K3键松开，释放从D2域SRAM申请的空间。
: B0 p6 V' N# k  i2 H  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
8 ~, E4 b. n: _5 ~9 Y  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   
2. *********************************************************************************************************
   ; c; F5 `* S0 R, E
3. *        函 数 名: main
   . t5 G- H+ a9 P, R
4. *        功能说明: c程序入口
   # S5 H% M7 L: N  U. H! O/ U. ]
5. *        形    参: 无
   0 u) G9 N5 q4 W0 }: Y' c
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   5 g/ Q9 ]$ `3 d
9. int main(void)
   
10. {
    ) b* M( ~* B6 h9 m# d5 p7 _
11.         uint8_t ucKeyCode;                /* 按键代码 */
    
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    / J8 @2 ~' Y5 J7 E, o; X
13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
    
14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
    ' z, H* K8 \5 T$ c( M8 j. U
15. 
    
16. 
    
17.         bsp_Init();                /* 硬件初始化 */
    
18.         
    # R& h/ v: Y" _& K8 N
19.         /* 初始化动态内存空间 */
    
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    
24.         
    
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
26.         PrintfHelp();        /* 打印操作提示 */
    - u, {" |, i2 x, d
27. 
    
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    ( i  |1 m- l0 Y$ W# L, B5 s
29.         
    
30. 
    1 }6 q' M9 z, k: O' j/ |! ?
31.         /* 进入主程序循环体 */
    
32.         while (1)
    
33.         {
    
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
35. 
    
36.                 /* 判断定时器超时时间 */
    : A. Q+ P8 {, t5 K5 m
37.                 if (bsp_CheckTimer(0))        
    0 P3 H6 |8 U' o* i! o( N2 Q
38.                 {
    ! r, ^4 Y( a0 K' a3 w! c- Y
39.                         /* 每隔100ms 进来一次 */  
    
40.                         bsp_LedToggle(2);
    
41.                 }
    7 G( A( Y+ n' x2 K( U/ d
42. 
    
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    1 Q/ J( b) T7 B6 G0 `: u
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    + }; G! W3 D5 {' k3 j( x& N" R) K
45.                 if (ucKeyCode != KEY_NONE)
    
46.                 {
    " O5 p: R1 b1 b) g  Q
47.                         switch (ucKeyCode)
    9 c$ ?: ?% W) W& g* r
48.                         {
    
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    & a* `$ {6 N* x) N% \3 A
50.                                 case KEY_DOWN_K1:        
    ' N8 m- a% s- [2 }+ c
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    ) d" k; F' o0 j. p. N- m# s
52.                                         printf("=========================================================\r\n");
    - b- i) I3 b8 s/ |  X
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    , C$ ^2 K: Z( [  t- v7 F$ X5 [
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    % ^. ?1 V6 v. E- e+ Y
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    - R( H+ G' B$ V( t, Q+ C2 U2 K3 L
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
57.                                 
    7 {4 V' v- P* X0 c5 T0 ]& p
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    2 {# g) a) J* S5 [; {7 M. u
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    & v9 H# G! U" [
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    1 Q  C- ]; W4 r0 ^; G
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    
63.                                 
    3 i. w( P$ o% o  O. @
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    : U5 ^! N! `4 ?) M/ W
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    - {! m: P7 T' q9 d/ Z
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
69.                                         break;
    
70.                                 
    
71.                                 /* 释放从DTCM申请的空间 */
    3 d6 A3 d8 D2 j7 G0 K. w  v  t
72.                                 case KEY_UP_K1:        
    ! n4 A* F6 ~1 J2 W$ U
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    + @  J/ d$ L! e
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    
77. DTCMUsed->used);
    
78.                                 
    % S$ o9 d1 d. T  ?; f9 l* N
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    7 e. m( N, }) B; K$ n# J2 c! `; F
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    $ i, X# @/ Y# R* K  g0 G, F6 v
83. DTCMUsed->used);
    ! X, I" l2 |1 F# K
84.                                 
    8 X2 E- q* n, L2 x' y2 s
85.                                         /* 释放从DTCM申请的6111字节空间 */
    
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    * b# y; y! Q& l' i7 Y& r" I/ Q
89. DTCMUsed->used);
    . c3 h2 B- K, B: Q2 G* f
90.                                         break;
    
91.                                 
    
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    
93.                                 case KEY_DOWN_K2:        
    
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    
95.                                         printf("=========================================================\r\n");               
    8 x0 e( c3 T+ ]' }' Y
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    + K, N$ ~) i2 B: Y7 q
100.                                 
     
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     2 l% I& R# e! o: y) p( ^& u
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     ) K( a6 e: O; Q) l/ i6 Y; `
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     
106.                                 
     1 ~6 }: i: ]( ]
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     9 g+ p/ T  U' G+ W& Y: B: E
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     
112.                                         break;
     
113.                                 
     & ^: {( L2 O$ z1 |) B$ ^6 j( X  E% d
114.                                 /* 释放从AXI SRAM申请的空间 */
     
115.                                 case KEY_UP_K2:        
     6 M  |: ?6 o# e4 a5 `9 n, n( x& z# m# @+ S
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     ( J3 d6 M/ ~" O3 b
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     " J& L3 u4 D6 c% S) \2 ~
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     
120. AXISRAMUsed->used);
     
121.                                 
     
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     - w% d! b0 |, M# s3 C+ w
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     , C. n9 K& k# ]- K" n
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     , h1 I# E3 p6 ?8 W" r+ m
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     + e3 b( Z7 q# V$ }
126. AXISRAMUsed->used);
     
127.                                 
     ! B2 }; K2 u# C
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     : Q% T, _& M: j+ D* H/ ]
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     
132. AXISRAMUsed->used);
     
133.                                         break;
     8 F  B/ |) Z+ h3 H
134.                                 
     3 v, R6 e, R4 A# ^  U
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     - M9 T( D( s9 v- w- z8 z" E% d4 e
136.                                 case KEY_DOWN_K3:        
     
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     
138.                                         printf("=========================================================\r\n");               
     
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     ' x1 \2 W0 J+ j
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     " E; H+ Q8 _, V7 B
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
143.                                 
     
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
       V8 ~. X5 {$ ^+ D1 l- y
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     2 q$ B8 b. k( T4 C$ V8 r! L" d
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     % v7 @- y8 ?/ E. b& r
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     ' Q! X1 _+ W! Y# x! X" s
149.                                 
     
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     4 _1 s, u* n* E# L' w
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
155.                                         break;
     8 k; ^8 I# H( A1 p' z7 D9 n6 B
156.                                 
     : D2 e5 c' r( X, m. g
157.                                 /* 释放从D2域SRAM申请的空间 */
     8 r+ ~  N9 R/ n
158.                                 case KEY_UP_K3:        
     0 w0 v( `/ Y4 O& @/ ^
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     2 E1 t( B* V0 ]0 l# _' B2 R
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     
163. SRAM1Used->used);
     
164.                                 
     + c$ ]) n+ }# Z5 A  y
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     - C/ y- n, w! O* }2 p- u% J$ U2 P
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     ' z# X% ?& J/ r) l- b
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     7 L& T/ p/ r" \8 M$ U
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     
169. SRAM1Used->used);
     
170.                                 
     
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     % N% @0 j8 J' E7 u4 B* L
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     0 H( h  v! x; Z! u6 V/ x6 ^7 j
175. SRAM1Used->used);
     
176.                                         break;
     
177.                                 
     
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     7 u3 \4 D  C& f% o3 k
179.                                 case JOY_DOWN_OK:        
     ' ?1 Q! {( l. S+ f, W
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     4 F2 ]- z1 i1 J- d: d. M
181.                                         printf("=========================================================\r\n");               
     
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     6 r  j/ c' d6 B' _
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     7 {- x4 p$ o' l' g; e
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
186.                                 
       s9 l4 _1 P$ v
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     " f0 y" i$ p# J
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
       O& p1 i4 {; ^2 ?4 D( j
192.                                 
     
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     9 B0 Z0 U3 o& |, ]: D% K  l  p
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     7 x& c* _/ P" }# ]* [/ x3 c' o; V
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
198.                                         break;
     # R. ^' ~6 Q+ R& i$ ^7 k
199.                                 
     ) S) G: a1 y/ V: S6 s/ W
200.                                 /* 释放从D3域SRAM申请的空间 */
     
201.                                 case JOY_UP_OK:        
     9 T- R: {  t5 a; k. e' l# }2 O
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     ; A: z# }* W" X) y
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     
206. SRAM4Used->used);
     " ^" _5 W* H: I, p$ P, Z5 r3 n0 o6 C
207.                                 
     8 ?1 r1 M, ^& @6 y! C1 ?
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     7 a8 l% G+ L2 ?$ k1 v7 S: t
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     # f3 n2 Q5 \* X, ]- O
212. SRAM4Used->used);
     ! I5 A" v; \$ K" h% n1 z' \; U
213.                                 
     
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     ' e; _: o1 g" }7 N( s* P+ o3 w
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     
218. SRAM4Used->used);
     
219.                                         break;
     0 H/ Y5 b. o/ X5 x
220.                         
     
221.                                 default:
     
222.                                   /* 其它的键值不处理 */
     5 C5 U- B0 g" w# |9 R% m( F
223.                                   break;
     - W) H( s4 j# V! e$ C7 X
224.                         }
     
225.                 }
     
226.         }
     
227. }

复制代码

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

( S2 Y) y) x2 t7 a0 W1 r* e* U" Z
2 z7 y- F' D! G; [4 O
  U6 ~5 O7 H* W2 a" c6 P