27.1 初学者重要提示
- `0 Z: L: [( H0 |- ?  学习本章节前，务必优先学习了解TCM，SRAM等五块内存区的基础知识，比较重要。
  将RTX5系统的动态内存管理整理了出来，可以同时管理多个分区。如果其它RTOS中使用，记得做互斥保护或者加个调度锁均可。
  支持动态内存使用情况统计。
27.2 动态内存管理移植
& K8 n+ f. t: T/ F移植比较简单，仅需添加两个文件到工程即可。
4 Q! h/ ]* u8 r) n5 a, e
27.2.1 MDK版的移植
3 E" k) |1 d) M' `) j5 g# W2 x  第1步，添加如下两个文件到MDK中
注，以本章配套例子为例，这两个文件的路径\User\malloc。
- c# e# x, T  p
( D$ T* W* M1 I) ~+ i3 P

* `2 ~. v- A; x& U+ \5 t( w1 S
  第2步，添加路径。
7 z. D9 `( e) j. I5 x
3 X' M- i1 L( `

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

通过这简单的三步就完成了MDK的移植。

, r9 W" I9 J" L# i27.2.2 IAR版的移植
  第1步，添加如下两个文件到IAR中
注，以本章配套例子为例，这两个文件的路径\User\malloc。
0 V2 o# ], i9 \7 i4 m
, x' k. B& R% {6 H  o

2 o' i! N3 F+ Z" r1 c4 R1 U; a, b; H  第2步，添加路径。
: ?. i0 R- ?4 p

# M8 i: t* j  K& c* n( Q
/ o* B) I% S, t  第3步，添加头文件。
如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。

& {. J1 C& p1 q通过这简单的三步就完成了IAR的移植。
' C$ e  F1 R! }- V. C. X
, j/ ?0 W) V( p; Y27.3 动态内存的使用方法
下面分别以MDK和IAR为例进行说明：

27.3.1 MDK上的动态内存用法
3 o: M9 ^6 p. {; z  定义动态内存区
比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：

1. /* DTCM, 64KB */
   3 w# g) a4 M; _
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *DTCMUsed;
   0 o; T) R2 b- y* X9 b3 m! Z
4. /* 定义为64位变量，首地址是8字节对齐 */            
   + \, l  C* s* z6 |5 [! g3 h, X
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

如果要使用AXI SRAM作为动态内存空间，可以使用__attribute__((at( )))指定地址。
  j4 |1 I& g1 C5 `$ S% t

1. /* D1域, AXI SRAM, 512KB */
   0 b8 i8 i! Q2 \- k" I* K9 n5 ~
2. /* 用于获取当前使用的空间大小 */
   5 w% {$ _/ k7 E9 Q! o, z; w+ M
3. mem_head_t *AXISRAMUsed;  
   8 {4 o1 ?# r( ^0 x8 _
4. /* 定义为64位变量，首地址是8字节对齐 */
   
5. uint64_t AppMallocAXISRAM[512*1024/8]__attribute__((at(0x24000000)));

复制代码

  初始化动态内存区
调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：
* S4 N% |; ?& F% m* v* Q/ Q
: T2 [$ n) s- |5 XosRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

  申请动态内存
通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。
! i2 U6 k5 G! s2 k
第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。

第2个参数填写申请的字节大小，单位字节。
1 e# C4 S" `" h
. h) L4 g" ~% J1 S5 L7 x1 Z第3个参数固定填0即可。

返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！
2 b9 T6 i3 H6 i6 r. j% Q
举个例子：
! o, a$ s; {* K  K1 \
+ I& P8 u) i8 `3 S4 z% _

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   
2. 
   
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   / l( w( {" U) M3 P. h
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   . S2 v9 j* n% v, @5 }6 K# o. Q
7.                                                              DTCMUsed->size, DTCMUsed->used);
   
8. 
   ) c9 u8 w2 Z, u) e* L8 D7 a5 o! x) [( }9 z
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   + e3 o  p7 ?. B9 k: p9 c; m4 A* n
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    ! s- P: Z2 u" {! Z' ^
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    ) j# \4 h) {% n
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。

- I7 w* g) z8 `. L6 r4 }  释放动态内存
0 o+ Z2 r7 K0 q' [' S+ o通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。
1 T7 g* E2 Y9 [
1 K3 A, d2 \% Q1 t/ ]- h第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。
/ A3 u: @7 R) {' [8 K
3 b6 s+ Z0 E! z% I0 e第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。

返回值，返回1表示成功，返回0表示失败。
" L0 p7 S9 q4 q3 ]- @
2 }- B+ e, X" h/ x5 r; f, L举个例子：
. R" V9 Q8 Q( I+ o9 @5 g( |
% d! O' \( B9 e

1. /* 释放从DTCM申请的280字节空间 */
   
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   3 k! u4 a' L% B+ S! a  A1 L0 I
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   
5. 
   + w% q2 n, Y# S! E/ C
6. /* 释放从AXI SRAM申请的160字节空间 */
     l* }+ }) B6 G& ?" Y6 Z3 |
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used);

复制代码

27.3.2 IAR上的动态内存用法
$ S+ |& C0 z3 j8 G2 k0 s注：IAR使用这个动态内存管理，仅在定义时跟MDK略有不同，其它地方是一样的。
$ ~5 b1 ~2 K  x9 ]
  定义动态内存区
比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：

* C# u- G1 y- W  k

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

复制代码

; G1 w9 J' m& @3 b: e如果要使用AXI SRAM作为动态内存空间，可以使用__attribute__((at( )))指定地址。

: b$ C& v7 l4 Z- f

1. /* D1域, AXI SRAM, 512KB */
   
2. /* 用于获取当前使用的空间大小 */
   ) B( M2 @) ?3 `' \& I
3. mem_head_t *AXISRAMUsed;  
   
4. /* 指定下面数组的地址为0x24000000 */
   ; y; e- y' O+ v8 _0 M% V, D
5. #pragma location = 0x24000000
   
6. uint64_t AppMallocAXISRAM[512*1024/8];

复制代码

  初始化动态内存区
/ A1 w" X9 ^* y7 l& x" A) s调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：
) K1 T& p0 z. _

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

复制代码

  申请动态内存
5 o' a4 m* e' w' H" y  J% ?通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。

第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。
1 T# a9 h6 d8 T2 Q8 p
" n4 G/ b7 h2 l1 a2 Q: E第2个参数填写申请的字节大小，单位字节。

% j9 r8 H+ h3 K& ~9 d& p第3个参数固定填0即可。

4 T3 p) }" ~8 R返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！

$ h  `+ K$ l2 R  f4 \( }$ Z举个例子：

' N/ \4 C2 Y) y6 e' i$ B& @) M

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   + N+ }, [+ m4 C2 }" B" {8 d/ H5 K
2. 
   6 t7 Z  L) f4 o' x
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   + r# p% A) Z' i' j( x* N
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   ; g  w) S# g$ j
7.                                                              DTCMUsed->size, DTCMUsed->used);
   
8. 
   
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   . L. ?* m) ]% ]) u" V; j- g3 L) [  i
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    " J, s9 H) S% H2 |- X* }- V
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    / e6 |& w! [% t# p
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    ) H$ t' O( q* v6 a4 v" p
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

% o: t+ L& k  ?+ h申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。
) I6 R5 O3 y1 p, ~: O1 d: `
: `+ E: ]9 {0 z! H& g9 M& }. A  释放动态内存
通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。

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

第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。
+ K+ v: A( S& U( j
返回值，返回1表示成功，返回0表示失败。

9 R, @! T5 o  d" G; D; ^! }举个例子：
# m( i- o" V9 s% F8 t
8 y1 V4 P8 W0 M2 v) q% J0 M

1. /* 释放从DTCM申请的280字节空间 */
   
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   8 h2 t% A$ H7 Y/ i9 C' I
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   
5. 
   " y$ G4 O+ f& P1 P2 d' M0 B
6. /* 释放从AXI SRAM申请的160字节空间 */
   
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   2 h& h! }9 n! ~( V
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used)

复制代码

27.4 实验例程说明（MDK）
配套例子：
* A4 @1 v: s8 O. |V7-006_TCM，SRAM等五块内存的动态内存分配实现

  M# a: E- N/ x3 ]1 z实验目的：
学习TCM，SRAM等五块内存的动态内存分配实现。

% U( c! }4 R8 o6 q" N* ~
3 M# C" c/ a9 [) E实验内容
( t9 E7 p. [* S# P/ G' C) w* j3 u启动自动重装软件定时器0，每100ms翻转一次LED2。

5 e' |# }  s, G5 x3 p: [) t, o5 C1 ]
  x* e$ x* |9 d; ?& d+ g% \8 S% o实验操作：
8 A4 a/ t4 U+ ~; m! p3 WK1键按下，从DTCM依次申请280字节，64字节和6111字节。
! e' e9 u* @! s, i* l& xK1键松开，释放从DTCM申请的空间。
K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
K2键松开，释放从AXI SRAM申请的空间。
- e; ?# c7 {1 U  zK3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
, h# ~0 ?4 z: R, ]K3键松开，释放从D2域SRAM申请的空间。
) A; l  x" M9 W" h( T/ t$ T摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
摇杆OK键松开，释放从D3域SRAM申请的空间。

( e0 m' P) }& ]1 d$ g' P) F
1 O$ b) Q8 P0 F上电后串口打印的信息：
* J$ t3 x$ u1 `+ _
波特率 115200，数据位 8，奇偶校验位无，停止位 1

0 E5 Z7 v. }" s6 @7 I5 t
程序设计：
* H) E9 Y/ D& \6 t( X  P  K
) f( Q0 V/ ~2 j$ M! u6 B! F1 G; l  系统栈大小分配：
4 J4 K/ K! [$ i3 a, ~* q3 z

8 o3 h5 h6 e- TRAM空间用的DTCM：

9 P6 l, _) n7 _9 X5 b

. j9 b- u) [6 z, W2 w3 h" `  硬件外设初始化
; u# Q$ o3 ^# w3 M. U0 |# _
$ t3 o* A& D7 K( R+ r硬件外设的初始化是在 bsp.c 文件实现：

' I4 r# \/ i: ]

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   ; T2 O; c; P: S9 [+ c8 a0 n  z
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   1 p7 l5 f" _2 {8 k
6. *        返 回 值: 无
   6 }2 R0 K' K( [4 U& @* g
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
      l. d; M( r2 b, Z* u4 y" Y0 w# G# c
12.         MPU_Config();
      h' _, Q# Y2 R
13.         
    * a4 q) m# |9 z2 r% ~+ c
14.         /* 使能L1 Cache */
    ; g% u! _) e* m0 B. @
15.         CPU_CACHE_Enable();
    8 N* U8 i% F  m+ z) l3 T: p
16. 
    
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    0 ^8 Q3 A) Y1 |% A, k
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
      S) \/ u6 l5 \
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    * d$ z- f, o4 |! u4 T3 b: [! e
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    # ?$ f+ C( g; v0 d" {( _
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    + P  x& r% @5 B4 G3 E- D" \
29.         SystemClock_Config();
    
30. 
    
31.         /*
    
32.            Event Recorder：
    5 Z* i5 p; D5 J( r( P! V
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    / e/ X3 ^* z+ l
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    - l  n* `6 @) q6 c6 `2 U, G! K
35.         */        
    
36. #if Enable_EventRecorder == 1  
    : O. ^$ L, n3 ]5 P" I
37.         /* 初始化EventRecorder并开启 */
    ; [' x1 G- P! P/ ~/ [. o
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    3 s* `# ~9 @% B0 }+ u
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    # w, }1 I4 V7 c1 K2 s7 B( R4 T
44.         bsp_InitUart();        /* 初始化串口 */
    ! Z2 f9 C* F: e8 G
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    $ |4 S# f- v4 V* e% X3 j
46.         bsp_InitLed();            /* 初始化LED */        
    % o' n& P, s9 P1 Z
47. }

复制代码

  MPU配置和Cache配置：
  w; X6 r, Y+ G) t* F5 I5 T数据Cache和指令Cache都开启。

AXI SRAM的MPU属性：
; Z7 D- X+ O. |3 q% ?" C4 {
Write back, Read allocate，Write allocate。
& c4 J; j6 }. F: I! D. E/ t
- e% [# b: Q* OFMC的扩展IO的MPU属性：
5 _% R( D9 D+ u  G* ]. p8 _
必须Device或者Strongly Ordered。

D2 SRAM1，SRAM2和SRAM3的MPU属性：

Write through, read allocate，no write allocate。

D3 SRAM4的MPU属性：

) m- d, V# Z% ?0 e+ ~/ [  R& \1 PWrite through, read allocate，no write allocate。

1. /*
   3 M+ u6 L$ w7 D4 T' d
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   : i' u( S# J2 @+ j9 X0 T3 R
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   ( L  x$ F  w9 u; L. J+ [$ |/ b
8. */
   ) @6 ~$ i7 V- p0 F
9. static void MPU_Config( void )
   0 n6 b! G4 W6 u4 E: K, w$ S
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    % l* z3 J' I8 U7 i1 B% e# T$ n% o
14.         HAL_MPU_Disable();
    $ _3 O- P' `6 C9 a3 i" T
15. 
    ' e$ l8 ]# W1 K, `/ A( f
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    + }( E. @  V" n4 u- G
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    / w7 m# i5 H5 _% E
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ' D1 n; k% E& J3 U
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    2 M) h7 i, E: r
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    9 w& l* r/ E) T! {/ m/ E4 _
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    5 `7 G) c) Y  ^
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    4 s& @5 B- F2 Q7 [0 |
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    - D4 j; T2 J$ u
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    4 ]" F, @' Q+ f# U* n
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
      [8 [. c5 e0 W* P, ^
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    4 d1 v7 Y' R$ c* E9 {1 \* J  t
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    . ~7 z4 ]8 x9 r8 ~0 n  M* \5 Z
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    5 ~9 z  v: S4 V2 G( s; c3 e- W2 S3 g
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    4 V; v' Y+ t: V; O6 t5 {( N
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    ) y7 ]% m7 S3 [9 ~' Y
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    & s/ V" U5 |/ o  T, a
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    4 b: `( Q0 k7 {
46.         
    
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    ' y/ z* i2 y6 \3 f' f
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    3 g# D# a# X  n; y- j5 L: w# V
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    * `) n) a# m/ L7 T
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    $ F5 \5 M8 K' U; A: d% A
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    7 [! r& R& K1 q2 F% m. C& l
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    4 J9 \- h7 O  L1 m$ i
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    ! f# a5 u, A* J+ X4 v
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    + W: W) `# K( A- K
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61.         
    ; y& }8 H# l+ @, h' ^  j
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    2 N+ ]+ b% F0 V3 T  m* W
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    * d" B( x  T% q/ }7 k
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    & X# r' \( k! L  d8 j" F( U$ T( I
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ; b. b: p' }( k$ W8 ^7 N
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    # m* @/ ~7 B0 h; r( V4 b6 L3 L$ u4 i
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    " C0 O; y" @8 \* T
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    " t1 p6 B- O; y% V$ l
74. 
    
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
76. 
    ; H, j# m% v. ?% v6 u
77. 
    
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
      `* B% e, _+ Q  A2 V
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    9 H7 ~& x9 E/ B$ _! J" ?1 D0 E" N4 a
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    4 e4 F$ U5 F: R3 \: N# `8 t
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
      J* h1 p& X4 y
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    / u* a- l5 P+ H; |* r. w1 x
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    6 c% ~% K8 Z6 [/ v
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;
    6 O2 M" f# x7 T4 h$ V
90. 
    
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
92.         
    
93.         
    - Z) o' O# r2 w% B6 Z) C
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    ) ]5 C" E" y8 D* ^4 A
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    ) p& z) I! x/ n/ O2 x! h4 N5 Z3 O/ H) m: T
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    - N4 u$ |$ d; O5 {) g8 N" H+ h
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     ; v: E* K6 w! e& S/ y
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     , I3 X/ U6 j  Q  c" _
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     . I0 ]( m8 L) p# m! c6 D3 U
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     
108.         
     
109.         /*使能 MPU */
     # v* i7 ~4 F9 y! f3 q. t6 L
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     ; Z: |! D# v0 ~8 ~1 @
111. }
     
112. 
     " {4 }) L2 \! ^8 q/ l
113. /*
     1 ?6 H2 \0 A% u' Q
114. *********************************************************************************************************
     
115. *        函 数 名: CPU_CACHE_Enable
     
116. *        功能说明: 使能L1 Cache
     
117. *        形    参: 无
     
118. *        返 回 值: 无
     
119. *********************************************************************************************************
     * H3 A3 Y- y- `2 l2 O5 y
120. */
     * ~% x  G- f6 ~: h, |* V$ n# o* E  ~
121. static void CPU_CACHE_Enable(void)
     
122. {
     
123.         /* 使能 I-Cache */
     . y* o6 r. P: }. q7 p
124.         SCB_EnableICache();
     $ u1 ^$ b  S$ i$ {+ n' _" I: U
125. 
     $ ]9 A5 k  A, o2 t: k
126.         /* 使能 D-Cache */
     
127.         SCB_EnableDCache();
     
128. }

复制代码

& o) l" L1 {4 \. h9 @8 H  主功能：

: c$ X1 d# Z. p- L! I- Q1 E/ @/ E% D* r" x主程序实现如下操作：
& p* q+ ]) I& k; M; S
  启动自动重装软件定时器0，每100ms翻转一次LED2。
, o. P# D# ?0 l! c  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
  K1键松开，释放从DTCM申请的空间。
+ n4 _4 c1 E1 T& K  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
% x% P2 q$ C9 y6 f  K2键松开，释放从AXI SRAM申请的空间。
  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
/ Q2 {$ J8 M$ N& J! d* c# M! A  K3键松开，释放从D2域SRAM申请的空间。
7 I1 F; R* t; r' e( a7 E  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
! w8 U+ P$ n. ^  M  摇杆OK键松开，释放从D3域SRAM申请的空间。
  ~3 C0 X( Q: h; L

1. /*
   
2. *********************************************************************************************************
   7 {: E3 w' M4 W" U% a; p6 d& g
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   $ c, t: p% `3 x
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   ) }3 o4 V; @- O' \
8. */
   . z5 L" K" o, ]+ C7 S$ d
9. int main(void)
   8 E- X6 x) \2 }7 I- J6 E2 y
10. {
    9 A. J% ]. q9 t1 Z5 _7 U
11.         uint8_t ucKeyCode;                /* 按键代码 */
    5 K0 z, r  f$ m4 w# K' X
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.         
    
19.         /* 初始化动态内存空间 */
    
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    7 R3 h2 O' X6 o3 \4 }- i
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    ' t- x- X# @: `: k+ B
24.         
    
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
26.         PrintfHelp();        /* 打印操作提示 */
    
27. 
    - j) Y6 v4 {: |6 K
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
29.         
    
30. 
    
31.         /* 进入主程序循环体 */
    
32.         while (1)
    
33.         {
    
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
35. 
    1 z( c# j) g8 b( @! I" {/ ^, ^% B7 C
36.                 /* 判断定时器超时时间 */
    
37.                 if (bsp_CheckTimer(0))        
    1 }9 ?3 a3 `2 R& X" x$ a- w
38.                 {
    
39.                         /* 每隔100ms 进来一次 */  
    
40.                         bsp_LedToggle(2);
    
41.                 }
    ; @0 ?( o; m! V9 D( x! H
42. 
    8 P3 |: u$ W# e9 Z% `: G
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
45.                 if (ucKeyCode != KEY_NONE)
    
46.                 {
    0 }/ U! M4 w8 [9 F$ w
47.                         switch (ucKeyCode)
    $ ^4 S- L5 D# i+ H; h, Z
48.                         {
    . P# q& ~+ Z+ P
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    - m' D+ F1 b, v( o
50.                                 case KEY_DOWN_K1:        
    
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    
52.                                         printf("=========================================================\r\n");
    5 p+ ]% r2 Q" h6 k8 E) O
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    . R& \6 w5 M: H8 a: i
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    ( ^  n) P! x7 @; O3 T. @" j
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
57.                                 
    : o4 c  r9 F9 l, Y$ C: }2 L
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    6 Y6 ?  a' h% _; V& ^% d& L
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    + y; v0 x" r! |  F; B: A; I' p
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    
63.                                 
    : u# \% u2 L  E: `8 B$ d( p
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    & n  S7 o) m* {( p1 X2 q
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    / Q! Q6 w  `5 I- z& h
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    5 b3 T) g6 n: I" A+ N( A
69.                                         break;
    7 @- d& T( j. o* F. _- c
70.                                 
    
71.                                 /* 释放从DTCM申请的空间 */
    
72.                                 case KEY_UP_K1:        
    
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    4 K7 [+ y) H8 P1 {7 C8 j
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    : g4 }' i# o& I8 x9 v) N' c4 j6 F
77. DTCMUsed->used);
    & t" x! d3 S% a8 @
78.                                 
    * H/ [, B. `: F$ j; K' Z
79.                                         /* 释放从DTCM申请的64字节空间 */
    . X1 v4 T! ^/ i0 A' T
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    + l4 D5 M5 B, m9 I. m3 T/ m
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    8 j! `& M0 Q9 n" @! Q
83. DTCMUsed->used);
    8 T2 ?' ?2 u% s9 |5 C
84.                                 
    / `6 \, H# \2 S% u
85.                                         /* 释放从DTCM申请的6111字节空间 */
    " k! _5 l6 J, y7 a( m
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    # j! D8 F& O! t0 k' x
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    
89. DTCMUsed->used);
    
90.                                         break;
    , p2 X$ ?  Z  L6 q. {* o) j$ g, @
91.                                 
    
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    , V2 q# q7 `6 j0 _2 p) J) K
93.                                 case KEY_DOWN_K2:        
    
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    
95.                                         printf("=========================================================\r\n");               
    
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    9 A5 A  [2 L2 S( z+ f/ g* f
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    : S% O4 U( V6 K5 Q
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    
100.                                 
     ) b0 v7 ~0 H8 `# M4 T! m
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     9 ~, U+ F) z* M8 y' u& @
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     & b  r& r, O/ O$ V. u* H% P% Q, b$ b
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     5 [) @1 D. d1 u( i1 c! v
106.                                 
     7 f+ U1 U* x. t* u9 ]+ C: n
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     ! Y* T1 E* b$ v# v5 X# s4 Y2 D
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     / D5 a# k# e0 e! O' T  ]' A5 m
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     " k" o9 }# c1 Q( M- [% \; z/ d. P  `
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     * q2 B2 \: W+ i1 h
112.                                         break;
     9 ~" Q2 R. }$ l: Y2 w4 l. H
113.                                 
     
114.                                 /* 释放从AXI SRAM申请的空间 */
     7 U, Y# w' Y# S0 n
115.                                 case KEY_UP_K2:        
     
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     . h$ o2 E1 d( w% I# c: d* f# `
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     . L* C5 N; C7 q- G+ M! V2 a& s
120. AXISRAMUsed->used);
     " I( o- f. o9 z( g
121.                                 
     
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     : w. A. B3 z" ^+ E* `& \9 W$ g
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     8 F1 S. _$ R, |4 `. w( F" b+ e. R
126. AXISRAMUsed->used);
     
127.                                 
     
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     ' N4 R+ r9 x- r7 i& y
132. AXISRAMUsed->used);
     9 @+ u+ t4 S( D  p2 ^8 v' _% m7 R1 N
133.                                         break;
     
134.                                 
     9 ^" A$ P6 C8 C$ g' q& P
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     
136.                                 case KEY_DOWN_K3:        
     
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     , W2 g( \/ H; `$ ~
138.                                         printf("=========================================================\r\n");               
     
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.                                 
     ) B+ Y* d5 f; R$ C4 X9 w! B  y. p
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     . }3 ]1 \! k( n- s0 M: @5 G
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     6 x" E- r+ P& l7 Z* M
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     + D9 B( A, u. w" h( I) \1 _
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     
149.                                 
     2 Q8 ?. d4 ?  y
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     - b4 t7 C2 F  ?2 W& S
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     9 \# I) i* B5 e' ~/ {
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
155.                                         break;
     , _! i& ?$ I. ^! |; J3 Z
156.                                 
     $ k& h" Y7 n0 [0 I, v7 Y& ~
157.                                 /* 释放从D2域SRAM申请的空间 */
     
158.                                 case KEY_UP_K3:        
     9 ~% v; C1 G4 j
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     0 {& X0 q( H  h. n
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     - v( j- Z$ S4 \* t
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     4 f8 ?& k* g6 N! r0 D' B2 S
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     $ T( L& I. w) [6 j
163. SRAM1Used->used);
     7 ~* Z; e8 n2 Q9 p
164.                                 
     7 d7 g( y! g2 [+ N
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     6 R4 V' F7 v+ a/ @1 ~' w
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     0 V; Q4 }, P: C6 E, K3 g
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     
169. SRAM1Used->used);
     ( C  M; }, e  s+ e. c
170.                                 
     + O+ k, _% ?2 E7 ^% p5 N- c7 {3 }7 ]
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     ) H$ N" t) o0 t& |1 ?, [/ h) S
175. SRAM1Used->used);
     7 l* g/ ]. t5 M1 [0 E4 q
176.                                         break;
     
177.                                 
     
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     
179.                                 case JOY_DOWN_OK:        
     8 {; j* _& [: i2 V% {+ R6 \! o$ U
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     ) Z3 K7 O  }0 I0 |7 O
181.                                         printf("=========================================================\r\n");               
     ( F/ R0 \( m$ B) B3 Y/ W
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     ' _. e4 C* }* ]
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ! B8 ]0 L7 ]; V2 X. `
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     : H: |+ L: `( t8 O/ Y; L+ `  Q0 ]- Y' E8 R
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
186.                                 
     8 k4 `$ n; q8 G) B" a3 \5 W* I" o7 o
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     3 m0 w2 e' a5 m( a
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     7 X1 U+ y8 q) u
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     # S& h2 F* t( m/ c/ V
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     4 T! r# f& E  {1 t' P& G7 z1 D: q" X- a
192.                                 
       Q, g2 k/ X0 U1 D1 [
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     2 N1 m) H5 a. r4 o4 k9 q
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     + k/ X1 P' c+ Q+ |8 O; O
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     ( d$ n9 l+ Q8 B
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     5 [" l: R* z2 F4 O, d
198.                                         break;
     . ^2 t9 N! {4 P8 F1 H  @
199.                                 
     ) J: p+ s0 b8 J! i0 r" h
200.                                 /* 释放从D3域SRAM申请的空间 */
     / w. Z" o& U6 `1 S
201.                                 case JOY_UP_OK:        
     / ~( j- t3 w+ c8 k3 q# s
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     - w2 d- T  F+ }
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     
206. SRAM4Used->used);
     
207.                                 
     
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     # q- ]1 f- y7 _# O
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     5 a3 p8 y8 D) M) ]$ w% w* y
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     
212. SRAM4Used->used);
       W- Q2 E0 Z% E3 A
213.                                 
     / J9 ]4 i+ Z  D8 }
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     1 A) \. a* Z0 p. t7 S
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     
218. SRAM4Used->used);
     $ a  N- s$ z5 ?2 \2 q
219.                                         break;
     
220.                         
     7 a; x- E% _. P) h, p% u& a- Q: R
221.                                 default:
     0 E2 n5 ?6 _* w, F% V0 Q
222.                                   /* 其它的键值不处理 */
     
223.                                   break;
     ) l: {4 U6 b9 }& n1 s
224.                         }
     
225.                 }
     6 }9 {' M) B6 F
226.         }
     5 a9 ?: A  s* Y& r
227. }

复制代码

27.5 实验例程说明（IAR）
配套例子：
" b& c* |8 i) w3 I; L& oV7-006_TCM，SRAM等五块内存的动态内存分配实现
  g  K* D1 e3 p9 `( l$ z% O
' J2 \/ {- R6 \实验目的：
# L0 r  s- j% f, A学习TCM，SRAM等五块内存的动态内存分配实现。

7 W: A( I7 i5 S8 ]# _. a, Z
实验内容：
3 R, T3 C; g5 V5 a" t4 M4 N2 K+ E启动自动重装软件定时器0，每100ms翻转一次LED2。
4 K* g8 l* E! O+ G, q
实验操作：
K1键按下，从DTCM依次申请280字节，64字节和6111字节。
7 J, K) Z2 E4 E% kK1键松开，释放从DTCM申请的空间。
- G- H# E" y2 C9 uK2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
7 [/ y: Q7 V6 c/ i1 s3 g) |- IK2键松开，释放从AXI SRAM申请的空间。
K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
7 S, m, I3 Q  K2 I- @$ AK3键松开，释放从D2域SRAM申请的空间。
4 X# y9 y# C, Q+ T1 `摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
0 q2 w% e, ]2 e$ g3 H摇杆OK键松开，释放从D3域SRAM申请的空间。

上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1
: v1 ^; i. i- y5 p- G
! W# R# d6 [: P& U- e2 f1 X1 D. ^

程序设计：
6 o, v% Z3 E1 k4 M* D
  系统栈大小分配：
& m0 S9 r9 u6 ~+ Y" Q) O0 V
: C% R! V8 ^, _, e

! s4 s) P" ?$ `- y, ~  Z; y
  RAM空间用的DTCM：
( D$ y( w4 `7 o1 _9 Y

  硬件外设初始化

: f; D, _& U' K8 ]- v/ H  t+ z硬件外设的初始化是在 bsp.c 文件实现：
( `7 D1 `7 B. m
4 N' S7 H; w5 v: b

1. /*
   2 ^8 D( \* u7 A# k' F0 w8 y2 ^
2. *********************************************************************************************************
     n1 T) t, q, A
3. *        函 数 名: bsp_Init
   % T  b6 k$ c6 L. m3 M1 M9 V. q
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   % K$ Y, A& I/ {9 w
5. *        形    参：无
   0 X- X# v9 b+ u3 y
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   * k9 H4 E; L% j' l# y# I* O
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    6 y/ z8 Z  u! @( O8 u3 L: O3 T
15.         CPU_CACHE_Enable();
    # I+ _+ Y& \2 \. B1 ^
16. 
    0 f+ V4 [9 u4 g7 j4 ^9 ?
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    4 `! q3 j# Q. `, {6 n6 @: {1 j
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    
23. 
    7 c2 |7 Z$ J( L, q0 f6 W) O" o
24.         /*
    7 \, P* N- ]/ h* n( {- R1 K
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    2 [7 Y0 a9 S0 R4 o( o, K0 A
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    ' r3 C3 k1 G3 N7 ]! K6 E
29.         SystemClock_Config();
    * ~4 K, b. S. i9 j1 y0 M+ b/ R8 |
30. 
    
31.         /*
    * y4 x) H. p) `( [
32.            Event Recorder：
    . s7 }) @: k! O' h
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    ( z; c0 X* v( E, o0 I
38.         EventRecorderInitialize(EventRecordAll, 1U);
    # O9 B3 F  |. z& n; X8 {
39.         EventRecorderStart();
    
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    $ x. S% j/ Z# S# j6 ^: S
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    $ r4 Z; p+ i: L2 M5 ?
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    $ y) l0 H, S2 C  H
47. }

复制代码

  MPU配置和Cache配置：
. Y( D8 W, G/ `# V& B
) ]+ y4 D% Q6 E. T数据Cache和指令Cache都开启。

7 }, m, b7 L  S# m5 I# HAXI SRAM的MPU属性：
, ]0 {. @, T7 f
9 K# Z) J% }4 t! i9 C4 K3 ~( {Write back, Read allocate，Write allocate。

! D- r5 F6 V% n  {+ ?1 {FMC的扩展IO的MPU属性：
$ S# @* c0 p9 K
* f/ m6 M, f1 u& F$ k必须Device或者Strongly Ordered。

/ x8 Z; J3 M# m+ D7 Z0 n' N- i3 MD2 SRAM1，SRAM2和SRAM3的MPU属性：
& q5 x- O$ S0 O6 i. T
Write through, read allocate，no write allocate。
+ f3 N6 N7 C+ @; c; A1 H0 [9 h
D3 SRAM4的MPU属性：

3 B; O  B7 i% d/ h$ u- j6 c4 jWrite through, read allocate，no write allocate。

1. /*
   ) ~9 s( x, r% K
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   : D0 {# S7 ~8 t  c
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   4 J# I' P; Q. e* ~* u
8. */
   ' V& Q( ^# D8 C9 ?
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    ; N5 b, i2 ?5 i4 J, \! N& |
12. 
    ' [0 a7 {: u( M, R8 w1 r
13.         /* 禁止 MPU */
    ( ^  `" L1 q  B1 d  g
14.         HAL_MPU_Disable();
    9 {) U7 O$ x6 c( H% x- u, T
15. 
    2 z  W4 Z, A( U. p3 P; B1 ]
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    5 z8 {$ u  b. e: j
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    . L  J3 V( y% {! T8 j, h) @
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ' l$ M% t" l/ a
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    / y0 w+ l4 G: g8 p: ~+ W3 s" Y
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    2 v+ o( [6 O# _$ v% F$ K) u. z6 t
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    5 @- e! e) B* V. D' O! W' v
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    8 s$ Q8 ^4 r; X& u) [
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    0 C4 C# t+ n1 X; @5 _* |1 i
31.         
    ) K1 J( n( V, `
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    . Q. O( b1 v' Q4 d
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    2 u7 ]3 ]* l* y+ z0 n2 N& ^* L0 F
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;
    ) S: ]5 ^3 z& A. S3 c( M
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    3 I6 C; @1 r, y, Z% w: N
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;
    ) K' T- t( D9 w# N  e, ^6 @
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46.         
    
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    6 v, C2 U' D$ x5 S( y3 R
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    8 K$ W; ]7 g' u+ K; O9 R+ M) ]
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    : }. I8 A, o0 Z2 j0 b
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    5 S/ J8 T. i2 w1 [( g8 A! u
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    : ^3 D9 y* q( u. _( `6 g
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    % K& S9 J; z/ K. h) [
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    7 g" o" c4 @. n
61.         
    
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    4 q0 l! S3 O- z/ l' j7 Z7 U
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;
    " ~0 j9 X. a: G% d# `& w* F
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    9 J" p$ R' @# J8 V% \
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    % D- q2 E9 }0 t; v: S$ W
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
74. 
    
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    0 O! N; j3 B7 D" j% T
76. 
    & l1 J  W) ]$ l. \% O
77. 
    ( i" T$ I. G- a7 ^1 h6 T. }: O
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    : W6 k/ W8 J3 ?, j
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    $ G* k* A( j+ U2 E% U
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    7 W# F! C0 M- L
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    ( B8 m+ x/ W6 t/ R% c
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    6 u/ i. `/ u+ ]- ]+ y3 U# {4 h, y
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    - G% z' Y4 C0 ?$ L  |. h
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    ! j9 b8 M& F) X
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
90. 
    7 t1 ^% u% B+ }* p% W% S& s; J
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ) l0 s, n, D9 i! a  R8 t3 w; Y1 v
92.         
    4 y7 E0 `+ N$ t% W' N" _! i! A( x
93.         
    
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    9 p& i( I- w) ~% {2 B- g! h3 ]8 F
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    - i: d, ^% W) A$ W  h/ s' a
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ; g. I' I! t* |; q# k+ v4 O
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     8 k0 T7 J$ _% _! x( u
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     8 j0 [/ O6 v& I5 E
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     % G4 Q" Z/ z- d8 O* @3 L9 g# q, c
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     8 ~. n1 P* o1 [+ h! E$ Q: c
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     0 z" q* \3 G* L: h
108.         
     5 d4 P( v$ e; v
109.         /*使能 MPU */
     6 T8 A) Z8 C4 G3 i9 H0 S
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     0 O, R* o7 a# U2 j
111. }
     
112. 
     
113. /*
     
114. *********************************************************************************************************
     
115. *        函 数 名: CPU_CACHE_Enable
     
116. *        功能说明: 使能L1 Cache
     , f8 k# x0 I! v" |, J8 S( L5 N1 K$ T
117. *        形    参: 无
     0 u3 K7 Y" C, o- N/ `% b6 K; i$ n, R
118. *        返 回 值: 无
     
119. *********************************************************************************************************
     8 S( J8 X0 q! D- C
120. */
     - [7 S% ^1 ]+ z1 f. U6 D  ?; x
121. static void CPU_CACHE_Enable(void)
     
122. {
     
123.         /* 使能 I-Cache */
     
124.         SCB_EnableICache();
     
125. 
     + |% E& N. Z" x' r- I0 _
126.         /* 使能 D-Cache */
     
127.         SCB_EnableDCache();
     . _: m% s6 V; u& _7 e
128. }

复制代码

0 B' E) m) a' D' R/ U' {% v! P/ d  主功能：
5 [$ w) r3 P! `
主程序实现如下操作：

  启动自动重装软件定时器0，每100ms翻转一次LED2。
$ G% ^3 p8 W+ U; t$ n5 B+ q  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
  K1键松开，释放从DTCM申请的空间。
  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
  K2键松开，释放从AXI SRAM申请的空间。
( C; J8 ~# U- J; k( T, k6 w3 `  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
! }1 `1 x3 f/ a- Y  |  K3键松开，释放从D2域SRAM申请的空间。
' _' e: k; D$ E7 m  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
) m3 \) x2 \( a  摇杆OK键松开，释放从D3域SRAM申请的空间。
$ |% U& ]9 m6 f# k: }

1. /*
   
2. *********************************************************************************************************
   , k: |* I* N9 e/ p8 ^# P
3. *        函 数 名: main
   : M  Y. r& D2 v; ?* u4 Q
4. *        功能说明: c程序入口
   : J# F) k' u* ^" X/ a
5. *        形    参: 无
   - x" w' L: h3 _( t4 U# m# R1 u. U
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   : Y" ]. }. \4 h1 N0 x+ e3 [* v2 O
8. */
   9 u4 z2 A7 k. ^% h  g
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    5 A% M% K/ ~2 H! o* W& L+ a& r
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    " t+ q$ V; f( i; T' I# J/ y
13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
    - b6 q$ [2 r5 e/ _
14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
    
15. 
    + l% N+ k( R, ~' O! r
16. 
    
17.         bsp_Init();                /* 硬件初始化 */
    0 p0 _! y' b( J  D4 y% P, ?
18.         
    
19.         /* 初始化动态内存空间 */
    
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    3 f7 g! o0 Y8 F% s
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    # R4 B9 x# h: Y. m9 k
24.         
    1 h: C! X+ Y* c* q8 M, V9 M, ~/ o
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
26.         PrintfHelp();        /* 打印操作提示 */
    , x; }2 t! e' |2 J6 t
27. 
    
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
29.         
    3 g+ v/ H% C: O6 P: H9 H, D
30. 
    : S- Z1 m5 ^7 T4 e) v+ g  h. A
31.         /* 进入主程序循环体 */
    : J3 x0 `8 U8 i! o3 i
32.         while (1)
    
33.         {
    + N2 m( Q" w2 a1 M  ]& I
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    ; N: I6 }- t  O" N
35. 
    7 @" g  ^0 P# i* d' a
36.                 /* 判断定时器超时时间 */
    
37.                 if (bsp_CheckTimer(0))        
    
38.                 {
    
39.                         /* 每隔100ms 进来一次 */  
    
40.                         bsp_LedToggle(2);
    
41.                 }
    0 {/ o1 A* c; P+ o1 h
42. 
    
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
45.                 if (ucKeyCode != KEY_NONE)
    * x  s3 [. ]0 S+ u
46.                 {
    
47.                         switch (ucKeyCode)
    6 r6 f2 r% Y( |% r) v
48.                         {
    ) O! ?8 t7 P; h7 s* p
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    - e/ B; B; b, c2 |
50.                                 case KEY_DOWN_K1:        
    + R( ^8 S+ V! K, @: [
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    
52.                                         printf("=========================================================\r\n");
    , y1 f9 v. H2 r" l) K
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    7 O" u7 B2 Z8 ~: `7 P, }" L
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    7 Y! N+ h( z( W: `: k+ D9 `4 e
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    : y0 c& m# y/ M2 E; E* X
57.                                 
    
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    . B4 g8 l; _- J
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    " }; c+ P1 P% }# ^# g. ~* @
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    " {# E% k0 M/ o
63.                                 
    
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
69.                                         break;
    8 r# |. v& a# c7 ^6 H) l" i
70.                                 
    
71.                                 /* 释放从DTCM申请的空间 */
    + U2 r9 Y, `) w; @
72.                                 case KEY_UP_K1:        
    # z- Y3 G1 P. C
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    8 p, C! p0 n: R; @0 H0 d' W$ i
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    , K7 p- U$ g" B
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    ) H1 Y) k) v) M' _2 `- R/ m
77. DTCMUsed->used);
    2 d2 J( T3 r! r% t. o! X# R) |
78.                                 
    9 b# [3 y0 b. f' n
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    $ F" T7 F9 Q7 h' t5 ~6 _
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    6 F0 ?* k$ }, e- }( X
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    
83. DTCMUsed->used);
    . f5 v9 Q8 d& o7 q" y3 Y
84.                                 
    
85.                                         /* 释放从DTCM申请的6111字节空间 */
    $ V5 z0 u) B2 C8 x7 \+ _; Y
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    2 y  y. k8 h% p% h# `/ Q" f
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    
89. DTCMUsed->used);
    " R- [- K* b2 r/ Q* Q
90.                                         break;
    # Y: W# a" F8 q; ]/ B+ c
91.                                 
    
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    
93.                                 case KEY_DOWN_K2:        
    
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    " `( z* w2 R4 h- H" `, X
95.                                         printf("=========================================================\r\n");               
    
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    
100.                                 
     5 ]8 C. {0 [0 J+ C
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     / h) c* ^1 A4 K6 v2 W1 ~
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     8 v4 u) x# i5 k
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     + ]+ }+ P9 C! I' v; ~
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     ) _- o6 n- s/ B2 G6 U
106.                                 
     
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     % A6 S% R5 X$ L# q% ^
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     ' W! N7 T0 H1 N/ H  z% I
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     
112.                                         break;
     
113.                                 
     + B4 q/ `0 a5 |
114.                                 /* 释放从AXI SRAM申请的空间 */
     
115.                                 case KEY_UP_K2:        
     3 y$ j, l* Z! Q) R  w  @
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     - ]" S4 Z# b# j! ?
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     1 Z7 J/ |! M( r& a5 D% t
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     , x: s# z! t; g1 [$ M9 ?) e
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     % `8 o. p' R9 D7 W+ |
120. AXISRAMUsed->used);
     
121.                                 
     ; q" A1 f1 g# [" v& c% \* |
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     7 {7 ~( `; c7 @" s/ _8 ~
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     ' X7 v! E$ @  Y+ U: I$ c+ q
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     
126. AXISRAMUsed->used);
     2 i  i/ G8 b3 s- w
127.                                 
     
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     ; f- u; K$ t: l2 D7 l) O: l
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     ) S( t0 ^* k. Q7 J" u
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     ( t+ u% J' d6 S7 r. \
132. AXISRAMUsed->used);
     
133.                                         break;
     
134.                                 
     
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     ; V+ H0 s6 E9 ]: @: T
136.                                 case KEY_DOWN_K3:        
     $ f" r3 h8 ]/ l; b2 {) R2 I, o
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     3 Y  ?! k/ e2 t" l& P
138.                                         printf("=========================================================\r\n");               
     # X: d! P& `) x$ U4 c+ |
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     2 x) q2 s# w3 Y# Q2 w# ]' [. e
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
143.                                 
     
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     . V3 R1 k$ V" f6 X1 t% [7 A/ f1 M- `2 H
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     5 C! d# Z$ h) K; }! j
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     9 A: H4 k& b9 d! R9 K% r
149.                                 
     
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     - S; j# v2 ]8 M0 h5 S! ^! c6 C
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     " G% Z* h4 Q' h3 l2 J- K' X, F" S) |- s+ b
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     7 q+ Z0 s# x) T" f% v2 N
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     + h( K2 P) T9 M. u3 e1 \; D
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
155.                                         break;
     
156.                                 
     
157.                                 /* 释放从D2域SRAM申请的空间 */
     : O0 ~8 c( |- C4 }8 F
158.                                 case KEY_UP_K3:        
     ; r, x; M8 j- F1 t+ o, ~. P+ ~3 |
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     / z# \5 e" {5 s" ?( R
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     9 ~6 N5 i6 [7 r! U
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     ! Z7 v1 w  @/ a9 H. k- y
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     + s: E2 i' s3 P9 |0 k) G6 h
163. SRAM1Used->used);
     $ z. Z8 c0 M3 {/ Z; g) K- E
164.                                 
     
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     $ y& T" @$ h, @: B$ f9 Q# S
169. SRAM1Used->used);
     
170.                                 
     
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     & Q* J8 X. h: M5 ?$ J  }& K  \- ^
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     
175. SRAM1Used->used);
     
176.                                         break;
     2 J  t( W* D9 ?4 ]5 T) e
177.                                 
     + D" l7 F- c. ]0 t2 Y6 T
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     
179.                                 case JOY_DOWN_OK:        
     # }) c7 p7 t$ p9 {: Z2 ]0 E5 O
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     
181.                                         printf("=========================================================\r\n");               
     
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     2 Q8 D# K% |: T( ~6 r7 Z, B! e
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     ) x2 |5 U- k- \4 r
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     6 d' w  V  x& k8 Z4 J8 U7 J) ^+ H/ g
186.                                 
     . ?% D+ ?9 b4 o
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     7 A! o: D8 b$ g9 Y+ t  C
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ) Z( D$ M# q0 x& k
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     1 K- J  W, R# a' Y+ a' T
192.                                 
     
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     4 V  k+ Q6 b+ b
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ( u9 w& A7 S) \
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     ; e' `% s5 b/ T4 B
198.                                         break;
     
199.                                 
     
200.                                 /* 释放从D3域SRAM申请的空间 */
     ) V, y9 I6 u, n/ W5 y
201.                                 case JOY_UP_OK:        
     
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     1 N2 }$ t1 m" h: w
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     
206. SRAM4Used->used);
     8 S- m1 w5 E/ G2 w5 i" A
207.                                 
     
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     
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);
     . R3 C& B: i  S
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ; x, y' G; D0 Q) p& \$ k9 m' k/ \
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     0 b- w: V( Y* U  a
218. SRAM4Used->used);
     
219.                                         break;
     ' ~- x0 j; M( j1 o8 y0 E8 j
220.                         
     4 ^8 V; O$ B3 u, J  {! b" D8 J% P2 R% f
221.                                 default:
     
222.                                   /* 其它的键值不处理 */
     
223.                                   break;
     
224.                         }
     
225.                 }
     
226.         }
     - ?( T0 e$ n/ e
227. }

复制代码

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

0 s) R- ]% ^, f- S
+ H0 K! D! |, T( \1 I/ o