27.1 初学者重要提示
! Q( x. U5 h+ t# e1 `( K+ ]. |  学习本章节前，务必优先学习了解TCM，SRAM等五块内存区的基础知识，比较重要。
/ Z# x2 ?% _& ?. B  将RTX5系统的动态内存管理整理了出来，可以同时管理多个分区。如果其它RTOS中使用，记得做互斥保护或者加个调度锁均可。
$ }8 f7 U6 D' g% ?* S! _  支持动态内存使用情况统计。
27.2 动态内存管理移植
% H2 r# {3 V& E, i移植比较简单，仅需添加两个文件到工程即可。

1 x, @: L9 O7 m6 A6 S1 p& q% t. M27.2.1 MDK版的移植
' ~+ j7 `2 {& d7 n# k  第1步，添加如下两个文件到MDK中
注，以本章配套例子为例，这两个文件的路径\User\malloc。

8 {) k+ g% G) l( S1 g1 F! v% F+ W  第2步，添加路径。
! S- c( h5 n) i9 ~- s- p

! ^, `: p3 `* p7 [4 E5 v$ W  第3步，添加头文件。
3 O+ S* y& F( _如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。
' \1 W6 t5 b: _- O* {7 g
通过这简单的三步就完成了MDK的移植。

4 ^2 ~; r1 H! L7 Y) x27.2.2 IAR版的移植
  第1步，添加如下两个文件到IAR中
, N4 V1 q5 N6 I8 [注，以本章配套例子为例，这两个文件的路径\User\malloc。
; v5 o) w  |0 w3 Z1 u% R- ^- p
( T( g( `6 w* ?2 l

3 N8 }* T  V3 C6 k8 O, {* V/ H
1 s/ G* F/ b5 n, W0 A* y9 y9 d  第2步，添加路径。
; \& B% C) u" b2 B
+ J3 g* Q( H, R. w3 W% ?

  第3步，添加头文件。
: O0 e5 f+ ]1 h" r( q7 S- B如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。

通过这简单的三步就完成了IAR的移植。
. T9 Y) T  m! ]
5 b% \' {; J% S, p: a' |27.3 动态内存的使用方法
: {3 P# M! P8 x7 }4 y下面分别以MDK和IAR为例进行说明：
% [' B  P+ x, O' F
27.3.1 MDK上的动态内存用法
; b' F% Q5 r" O* W  定义动态内存区
- j0 W4 U6 S6 e* v9 D' Y7 v; R比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：
& o- S- f' k) C1 X0 L  J
2 z& K3 z6 z: G; `' G" d$ L$ m$ l7 O

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

复制代码

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

  w2 N( i8 Q% O

1. /* D1域, AXI SRAM, 512KB */
   
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *AXISRAMUsed;  
   ( u; L8 W& d8 n/ E8 A
4. /* 定义为64位变量，首地址是8字节对齐 */
   $ W& e4 `8 [6 x9 n1 b
5. uint64_t AppMallocAXISRAM[512*1024/8]__attribute__((at(0x24000000)));

复制代码

  初始化动态内存区
- h5 k, y8 m5 y7 _1 F# e8 e% Y% Y# m调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：

osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
4 N* j  M/ S5 L6 rosRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

9 g8 M8 q7 y2 A' ~  申请动态内存
通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。
$ q) M2 D/ W. f9 G4 [
" `) [2 l, K, A! u6 v第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。

& }' z$ U) b$ q% M* T8 j# Y第2个参数填写申请的字节大小，单位字节。

2 N* H2 O& P' m: F第3个参数固定填0即可。

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

举个例子：

  R. s% q, O% u  O, z- K

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   
2. 
   ( O4 T8 `+ z1 n& `  u+ ^  [
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   7 O: B' i" ^. b1 ~7 g* `* V
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   , r+ G, M# E2 E$ B  @& b, U7 ]' q  R
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   ! I. L6 H; S- J: d& ]2 v* ^0 H$ }2 E
7.                                                              DTCMUsed->size, DTCMUsed->used);
   & O+ S1 _# g* `, `; y
8. 
   2 _$ x' N! p- A- }
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   3 G& a7 r% g! {  C8 L( n
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    ! i  `( a& T5 B6 n6 T- d
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    : ~0 D' \( g1 `- ?0 _# m. r
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

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

$ N0 w6 ~: j4 Q2 g  释放动态内存
1 j( h( |3 l" c+ F/ f5 k通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。
: D' g" d- N6 P0 {5 S
第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。

第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。
% J. V# L* s4 s# r& D6 ^
返回值，返回1表示成功，返回0表示失败。
& L; R+ S# |( d! T" _* c1 S
举个例子：
; W0 v* i  M: C- M

1. /* 释放从DTCM申请的280字节空间 */
   3 i- F4 @: |* g6 W4 V# O
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   ( }, B: _4 ?# ~2 E
5. 
   ( s, J3 `" `- R$ \- p/ z: i" s
6. /* 释放从AXI SRAM申请的160字节空间 */
   " v# k9 n, n: _3 ^3 l2 H
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   / G- N2 ?/ x" ~1 S; @; A) ^6 N
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used);

复制代码

: l$ i6 [7 g! a: c4 A, [27.3.2 IAR上的动态内存用法
注：IAR使用这个动态内存管理，仅在定义时跟MDK略有不同，其它地方是一样的。
( d" ?3 O8 T9 U* R7 A7 f+ Y- p
  定义动态内存区
1 J3 Q8 h# G' [. ~比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：

1. /* DTCM, 64KB */
   2 `  S9 N! W) A) d0 B1 X
2. /* 用于获取当前使用的空间大小 */
   + I, p' ?4 P8 h7 S( I% W4 e
3. mem_head_t *DTCMUsed;
   7 Y$ W* C9 t2 p* [
4. /* 定义为64位变量，首地址是8字节对齐 */            
   ( F3 d! L: U' G. m
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

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

7 R9 J( g( n) N6 c+ C6 H( ^+ H* S' l

1. /* D1域, AXI SRAM, 512KB */
   + I- D2 d/ E# L& e1 N* S5 a
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *AXISRAMUsed;  
   ! T" V4 e) }& j# o; Z
4. /* 指定下面数组的地址为0x24000000 */
   3 k6 q! M2 M  x8 t. K8 d
5. #pragma location = 0x24000000
   
6. uint64_t AppMallocAXISRAM[512*1024/8];

复制代码

" M* X3 f3 _2 A. y  V  初始化动态内存区
调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：

3 I8 x) E" `, u

1. osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
   - ]- R) a5 `3 q) x  j# W
2. osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

复制代码

) V# S) _7 W; i! B  申请动态内存
, F( {7 C. e5 B( C  R通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。

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

! N: S) w  x  D2 G第2个参数填写申请的字节大小，单位字节。

: z" x1 @/ Z$ k6 d) U第3个参数固定填0即可。
/ {% U8 g) o  }9 |; D
返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！
: [% b4 ~6 M  H: L; Z; x
举个例子：

7 ^* @( p6 }2 z! O* ]6 m, ^4 t

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   7 _- ?, ]$ N2 v  e# @
2. 
   0 h/ S, {5 A1 H: [6 i: c" H8 }: e
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   ' L! l. M, B( p: V- N) V7 X
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   / g$ a1 |7 u: x& o- d
7.                                                              DTCMUsed->size, DTCMUsed->used);
   ' m% W. d. S3 [9 n
8. 
   
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

( S* |8 _1 }' D3 A2 [申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。

+ [' ]1 X& S% O$ \8 |: }  释放动态内存
通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。

第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。
0 G# l) ^: y& q) C, q6 U
第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。

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

举个例子：
( b. ]- E' D5 @/ z( L2 u# e

1. /* 释放从DTCM申请的280字节空间 */
   4 I& ]: k; s! a; A/ _7 h
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   ' ], X9 w! o4 b0 l0 m* |2 m) K
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   
5. 
   2 a+ n! x  J5 B% H) g. d" r. S
6. /* 释放从AXI SRAM申请的160字节空间 */
   - J, _; G2 B5 C& |! c6 h
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   # w* |' O  |9 b  \! g
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used)

复制代码

& ?3 A6 w: R# ^  g4 k" S27.4 实验例程说明（MDK）
! }, N0 V: L. v2 N" Z5 v配套例子：
9 O9 H; U0 j) m0 R1 p, l' y* K) OV7-006_TCM，SRAM等五块内存的动态内存分配实现
, m5 u/ X4 K2 Y* @4 Q' z0 {2 r. T
实验目的：
- G+ D6 j) T# s8 c- s学习TCM，SRAM等五块内存的动态内存分配实现。
+ F9 T/ y; K% P+ K
" z2 f$ z; [1 l) i
. e9 M; L- P& f9 b- e/ Q8 \4 f实验内容
1 d  r6 t3 M5 g0 @0 z' Z2 T启动自动重装软件定时器0，每100ms翻转一次LED2。

6 J: ~) D" ^: n
, t8 ?  e. W# a9 L2 }% c* ?实验操作：
K1键按下，从DTCM依次申请280字节，64字节和6111字节。
K1键松开，释放从DTCM申请的空间。
K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
$ F' F; [1 K& N$ I' P& F0 I7 ^K2键松开，释放从AXI SRAM申请的空间。
K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
K3键松开，释放从D2域SRAM申请的空间。
. y7 Q1 l- d, V- h+ f摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
摇杆OK键松开，释放从D3域SRAM申请的空间。
% ?5 J& {) N' p4 b3 M. h
+ _) L% U$ y1 ^
上电后串口打印的信息：
9 }1 Z+ P. u. t! D! Y7 i
波特率 115200，数据位 8，奇偶校验位无，停止位 1
# ~* g5 c/ x7 }
5 N& n$ `, ~8 M2 G

1 v# C5 ^! Y" T! ?! t
程序设计：
) F$ z9 o' i2 O" N8 G. n. T! u
; i1 U0 K! G* n% m3 w4 j7 y. m  Q7 Y  系统栈大小分配：

6 l+ n! J3 J. Q8 h9 {: m- a

RAM空间用的DTCM：
$ h5 y4 Y. Y9 H; N% B, H

  硬件外设初始化
5 Y+ P: `  Y. L  J7 _; b  {
硬件外设的初始化是在 bsp.c 文件实现：
% X  \% p, J1 p9 V$ C  G" i

1. /*
   
2. *********************************************************************************************************
   $ Q  T1 A4 g; b" g7 w! P4 C
3. *        函 数 名: bsp_Init
   : Y0 h7 B; d5 R9 U& ~7 w$ D' [
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
     ?1 e; E& g5 C
6. *        返 回 值: 无
   ' G2 v" C( }* L8 ?. A6 F
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   0 Z- j5 t$ X" E' s* K9 G
10. {
    2 v) ^0 P5 ]- d7 d0 l
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    & ]8 [. p. U2 B/ X
16. 
    
17.         /*
    1 Q$ I/ m5 z8 H: H, Y
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    , T. @  Y5 P/ p0 Y2 G
20.            - 设置NVIV优先级分组为4。
    / T* y( k9 g0 K
21.          */
    
22.         HAL_Init();
    ; Q) G$ I' z, t( m8 h
23. 
    
24.         /*
    9 J; I# p0 W; b& r6 j) O
25.        配置系统时钟到400MHz
    ( b+ q/ g) o) j+ Y$ n
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    1 Q. F/ N# j$ c% S
30. 
    
31.         /*
    - @' a9 }2 K4 Q( e
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    9 y8 W/ R7 Y( v0 S0 d
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    ! \1 G+ w  E) l# [4 ]- D! `
35.         */        
    : P+ ^' d- z* h  i: S/ ]5 U  r* F
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    $ m' ]4 S2 Z6 f. {9 _
38.         EventRecorderInitialize(EventRecordAll, 1U);
    5 a) g0 B+ [- ~- U; F9 p
39.         EventRecorderStart();
    
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
      {' D8 t# u1 |/ F9 B
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    % f8 s5 B/ p: B6 ]$ ?
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

, _" g3 v; T( [  MPU配置和Cache配置：
数据Cache和指令Cache都开启。

+ ]- a: s1 L1 ]% OAXI SRAM的MPU属性：
+ v1 M2 \5 Q6 C
0 |( n) X0 I. |1 g' ]0 w% c$ [Write back, Read allocate，Write allocate。

FMC的扩展IO的MPU属性：

0 u6 `  T% O# ]$ Q9 H必须Device或者Strongly Ordered。

* n5 m- u) {+ E' b4 v1 U4 h: Z/ {6 M' bD2 SRAM1，SRAM2和SRAM3的MPU属性：
5 i# @$ {- n8 ?2 Z
Write through, read allocate，no write allocate。

D3 SRAM4的MPU属性：
% t; n! h% ?+ f6 F8 \! g$ l3 Q
4 V, [# z; w8 ~5 pWrite through, read allocate，no write allocate。

) h- ]! B& ]* c

1. /*
   
2. *********************************************************************************************************
   / d# C8 ~% g2 ]% M
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   ) C( I) A  ^- a6 K
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   5 v2 ]+ n3 o* m& j2 t' R
9. static void MPU_Config( void )
   1 k- |1 d& H, Y  C7 G
10. {
    , A( b# m5 c* T/ e
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    $ Q9 c* t; O$ N# I
12. 
    ; F  `$ e* T+ k9 }$ z
13.         /* 禁止 MPU */
    % d9 N* C0 o6 `) z$ _
14.         HAL_MPU_Disable();
    
15. 
    6 o7 f0 I3 g: Q" N0 ?
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    : `$ c8 v! h, D1 ?( u
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    ' A9 u8 b$ w9 y5 O/ i4 l) A
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    4 J' h( k0 l9 j4 x$ s  r
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;
    * C% Y0 m* d1 e
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    0 q" M  Y  i( n6 e& z
28. 
    + H/ ~. b$ I3 c0 A8 x. e
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    3 L9 D7 i/ [$ u0 ^7 B% \" {
30.         
    ; ?8 u* D! X/ ?4 B5 K
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    ' ~4 u# a5 R* R0 d5 c, o5 _
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    . R& i) d% E4 f  M( u
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    ( A+ _* F/ E# Y! O) ~# ~
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ; n1 o$ f! e, |5 l. t: g1 Z3 f& K
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ! b" R! ~% A" r
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    " p9 A4 z, y9 ^3 M& q7 I2 [
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    1 v* Z' ^2 n% P
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    % e, y! o- _% t* V. i7 u+ j
44.         
    8 s( z( w' X; [- S# f$ `
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46.         
    
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    0 q. y7 b& d/ L& K3 a2 k
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    6 w$ d' G/ ~! s$ c0 y
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    3 X6 y; _5 G. d6 v0 E
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    2 S. c. T$ ?5 f4 G" z/ S
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61.         
    
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    " N; D- s; u$ P5 l
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    5 N/ W5 n- J1 W' p
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ) q/ b' J  D* H; y( Q6 O% `
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    - K& N7 T0 b9 V. R, A
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    : X# H9 G4 B6 G# w5 F7 S0 Y
74. 
    
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
76. 
    , S# ?. V& Z8 O4 F) h0 Q5 r/ |: Q
77. 
    $ X9 f5 @  O: U; ^2 _: z
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    & N1 Q1 W0 f/ _. C- j1 c
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    - }8 A  l) w$ P6 ^& [  w7 p
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    ; i: C" K$ f6 w/ x* Y& [
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    " Y2 ?% @" h1 `5 X- P6 l
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    $ J* h8 J' u1 a. t* x
90. 
    
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
92.         
    2 v' k: ^. e7 X: }
93.         
    
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    . l* [- J  l" c# w
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;
    $ f  N/ `5 Q* Q6 @* `  t& s
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    0 S0 O" z" _8 T
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     : l* T8 A' ]: Z$ c7 Y$ D; o
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     + J4 B$ P" y0 f: P
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     ! o7 P& u8 L8 n  J! A- N
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     0 a+ B! b( b4 l& L
108.         
     - Z. w! r( o1 E( M5 r
109.         /*使能 MPU */
     3 n& t! h2 z: s1 b! y/ r
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     & w8 t; h* M  }" Y$ w+ g
111. }
     
112. 
     
113. /*
     
114. *********************************************************************************************************
     
115. *        函 数 名: CPU_CACHE_Enable
     
116. *        功能说明: 使能L1 Cache
     3 W! ]7 K* p  k) ?( _( ]/ E2 x3 x
117. *        形    参: 无
     8 u( }4 h- H! Q2 P( u0 c
118. *        返 回 值: 无
     * r2 i) G( C1 X4 X
119. *********************************************************************************************************
     
120. */
     
121. static void CPU_CACHE_Enable(void)
     5 M3 s$ U; ~, f# T: @
122. {
     
123.         /* 使能 I-Cache */
     
124.         SCB_EnableICache();
     
125. 
     ( v# f) {' a4 w: e) F
126.         /* 使能 D-Cache */
     ; A1 O0 w' x4 J# Y
127.         SCB_EnableDCache();
     1 I/ n% M4 }' [- K
128. }

复制代码

6 ~7 V! V3 |, P  主功能：
/ l$ N" a$ N& \2 z8 s/ g
. m- I) `, L3 i1 K* D9 N2 }主程序实现如下操作：
; k9 z- n+ D. [7 s1 Z! l% [
  启动自动重装软件定时器0，每100ms翻转一次LED2。
  e4 Y* Z* O: t, N- w2 m; f  m  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
  K1键松开，释放从DTCM申请的空间。
  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
  K2键松开，释放从AXI SRAM申请的空间。
# g& O/ Y; m' P6 l1 ]  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
  K3键松开，释放从D2域SRAM申请的空间。
* L. U3 f7 w4 z8 l( I- y' N" q7 K; M  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   % N4 ?* D% ~1 w) g
2. *********************************************************************************************************
   
3. *        函 数 名: main
   - f: q, R0 @4 l) X" t; W! i; Q: k
4. *        功能说明: c程序入口
   - H0 G8 w5 M2 s1 p* p8 j( d5 {/ _
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   & _# W  M' N0 t3 W+ C) \( p) N# A
8. */
   
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    & r' B6 |& J7 ~' d  ]9 T+ ^
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    % M& `0 u) _9 m+ J
13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
    
14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
    $ _6 p. D  @& H$ h7 U$ y/ \( `7 n" f
15. 
    / k' X0 x2 c+ {0 o
16. 
    0 S* h; M# b! ]4 ^! a
17.         bsp_Init();                /* 硬件初始化 */
    
18.         
    ) W: h% t7 a. A, M% Q3 h, ?
19.         /* 初始化动态内存空间 */
    / \3 Q# q4 n9 M- X9 ]
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    ) F& u$ Z5 a- G9 |2 [% `# a, _7 C
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    ; w* W  L! K; r1 E! ~
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    
24.         
    
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    : [, x& u6 O. O
26.         PrintfHelp();        /* 打印操作提示 */
    9 f3 y4 H' d& K4 s
27. 
    : j+ X; F" Q8 }& Y4 Q% G( P
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    % E' ~+ B9 P0 P5 h7 f% M. O* r
29.         
    ; M( V5 i' r6 @- R: S) A" q
30. 
    % v& l6 Z' g( U' S! `" H+ R
31.         /* 进入主程序循环体 */
    - v# I5 w6 l4 `. b/ N% z4 f1 L" J
32.         while (1)
    ! J1 ^+ g/ X% G3 V2 L
33.         {
    9 b. q9 e# N0 A/ B* K8 f
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
35. 
    * h. {7 v" e5 F* w
36.                 /* 判断定时器超时时间 */
    ! ?6 T- w3 [. a  b
37.                 if (bsp_CheckTimer(0))        
    
38.                 {
    
39.                         /* 每隔100ms 进来一次 */  
    
40.                         bsp_LedToggle(2);
    
41.                 }
    
42. 
    ) @$ O  N6 L( G8 ^! G1 j  }6 E
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    * g& k' T) @+ |: g% m5 l$ C3 |
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
45.                 if (ucKeyCode != KEY_NONE)
    0 Z# @2 G5 m# M5 u
46.                 {
    ) j0 O- U: |# u6 V* A' C
47.                         switch (ucKeyCode)
    5 f( m$ ~; t* C& L8 g
48.                         {
    
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    2 g7 D: [6 z5 m% |7 r8 |
50.                                 case KEY_DOWN_K1:        
    
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    ! H- ?% H+ u, B7 ?
52.                                         printf("=========================================================\r\n");
    ! Q! [8 a" ~- K& ?
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    , L, B( c: L' G/ r- L
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    + M* J4 Y: i' o( t) _
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    * q: Q1 q7 I- I3 v$ X
57.                                 
    
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    3 l' _6 i5 y6 T+ x8 G3 q: \
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    5 {" L! E2 i4 n/ n- Y( l1 p& p
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    
63.                                 
    ; r; z+ R5 x% n" R; n
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    ( H8 M8 ]3 v+ M* [. z
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    + q0 {- N: P7 W; N4 c5 N
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    ' j: ~  Q8 l: [
69.                                         break;
    ) f% q/ G$ Z( y- J+ {
70.                                 
    
71.                                 /* 释放从DTCM申请的空间 */
    - O3 E) S+ _/ i3 R  x
72.                                 case KEY_UP_K1:        
    ( i) B' _* M" t5 N4 B9 K
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    9 k. u, z8 \* S# l) Q6 J* y8 h
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    
77. DTCMUsed->used);
    , y8 e9 O. T3 {
78.                                 
    ' u3 q% b7 l$ o0 @3 s* u$ B# I- P# a
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    6 ~# O# ^  c2 |7 @  J
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    2 N0 @& P0 h0 ?  R1 L8 S# Y1 H9 ~
83. DTCMUsed->used);
    / Y4 ?+ T- k4 n! c6 T
84.                                 
    8 s0 ~- g3 l8 K* U0 R* x0 L
85.                                         /* 释放从DTCM申请的6111字节空间 */
    
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    % m) m, \2 e& A; }! Q# |
89. DTCMUsed->used);
    " |$ J- s" Z! d' `4 z3 z' v) J! u. X
90.                                         break;
    
91.                                 
    
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    9 l8 h" U5 n- s' S+ c3 b5 U& v9 a
93.                                 case KEY_DOWN_K2:        
    
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    + M: j2 |3 \* F3 W9 c( 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);
    + z! h0 ~3 s1 M( u6 J7 q: b
100.                                 
     / P+ }4 w  O# [4 w5 y
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     3 R8 {4 Z1 G$ B6 a" j
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     ) V, Q$ ]3 S2 @, k1 \
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     6 b8 h* l' R5 N8 W/ |
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     
106.                                 
     
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     / o5 I) r) Q" u4 u
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     2 t1 X: L! p$ e; s# W
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     $ e4 {, m' ^* K/ }- H
112.                                         break;
     0 Z6 \8 ^* h; H! J% {8 k& f7 J
113.                                 
     ' s3 m/ B6 O) W) w0 r/ y2 U4 _
114.                                 /* 释放从AXI SRAM申请的空间 */
     
115.                                 case KEY_UP_K2:        
     
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     6 a& @# w6 G, [1 d
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     - W9 C+ V0 F+ p8 z( j: Z5 V1 r5 R
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     - ?2 H% W- j; L
120. AXISRAMUsed->used);
     
121.                                 
     
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     # L0 @3 _* J# T. T6 O! A
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     
126. AXISRAMUsed->used);
     
127.                                 
     
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     5 N0 k4 G8 J/ A' a
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     % _/ i$ j9 S1 s- |( N0 {  Z' V
132. AXISRAMUsed->used);
     
133.                                         break;
     2 f# M+ k4 n' T0 u0 v2 a1 r
134.                                 
     
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     3 i1 K6 ~6 g) [
136.                                 case KEY_DOWN_K3:        
     
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     9 k, }  b$ Z* T) d6 m
138.                                         printf("=========================================================\r\n");               
     % P. N3 o4 g8 A/ E) ^7 A
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     - ]" f2 |1 W$ b( F3 C( \0 F
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
143.                                 
     # K! W' t" @; L. v
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     7 g0 n2 f" K. G2 f8 v
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     % Y8 t4 u& v3 E9 J; n$ t
149.                                 
     * D* T+ {1 c* Z
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     $ i8 \0 B1 ?" m2 f* x
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
       r+ m! C  W# d, S( v
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     6 h9 {& P1 u. w) a+ B. D- ]# o0 I
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
155.                                         break;
     0 A  b: G/ V) F" v0 u
156.                                 
     
157.                                 /* 释放从D2域SRAM申请的空间 */
     7 r, [" G3 Y; e3 R2 g2 ~* v
158.                                 case KEY_UP_K3:        
     
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     " v7 X( l" D" s
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     % @9 {2 J) d" S$ g! D
163. SRAM1Used->used);
     
164.                                 
     ' v% w$ e2 P: e: _7 _8 g1 N- _
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     0 A$ Z9 b* J6 h0 `; u3 [
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     ) r1 g% w" `; g7 G, l
169. SRAM1Used->used);
     - j$ Q! Y' o3 e+ C( G* S8 @
170.                                 
     # u0 n. o+ U3 S+ x4 a
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     8 v: G& r0 Y9 M/ N7 `9 G+ ?
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     $ S% ~) a. D/ C! `  n
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     6 V' H$ `1 ^1 M. @) P0 B
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     ) i6 E" d; R. L' L- v9 q1 u" r5 N
175. SRAM1Used->used);
     7 ]. v& G+ W& Y( C" Y4 C6 z
176.                                         break;
     
177.                                 
     
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     
179.                                 case JOY_DOWN_OK:        
     , I8 B! P& a# C# v7 Q& |
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     * N2 v1 w7 l- N! ~4 Z. [+ X
181.                                         printf("=========================================================\r\n");               
     9 [; h" \5 X  w; I
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     : i6 _$ Z0 H# z  |5 K
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     0 V9 B$ f* T' S0 s' v4 W6 e7 {
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
186.                                 
     
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     3 I8 ^* y$ I& w! i% D8 H
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     ! G) j  S$ a: K) S* `
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     
192.                                 
     
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     6 j4 J1 ?+ B. x$ K# X
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     + M1 ]2 S; Q" }) Z8 h: H1 e
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     6 `2 x* ]8 K2 p* n" O. o- k& R
198.                                         break;
     % Q  l6 A. C" E# B* @9 f1 v1 B
199.                                 
     
200.                                 /* 释放从D3域SRAM申请的空间 */
     
201.                                 case JOY_UP_OK:        
     
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     
206. SRAM4Used->used);
     # Q- e, F& J# p
207.                                 
     
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     3 B6 r/ n/ B* U( Z
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     
212. SRAM4Used->used);
     ) n) o1 W8 Z; O! `
213.                                 
     0 `. F' Z) G& s- U2 u5 p
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     ) l' ~1 Q  u& h, R" Y
218. SRAM4Used->used);
     ) X# w8 f1 V4 |& U$ A% W& e
219.                                         break;
     " A- [" }7 x) I+ N5 [7 F7 f3 B
220.                         
     
221.                                 default:
     
222.                                   /* 其它的键值不处理 */
     
223.                                   break;
     
224.                         }
     
225.                 }
     
226.         }
     5 b/ O" D8 @1 O/ d  V# r) j
227. }

复制代码

27.5 实验例程说明（IAR）
) _  |6 q. |2 t! `# U配套例子：
V7-006_TCM，SRAM等五块内存的动态内存分配实现
- t5 z8 r% q  @# C
5 d- N( I- a: X0 P实验目的：
学习TCM，SRAM等五块内存的动态内存分配实现。


( o$ u4 S$ K5 {9 t9 o/ ~实验内容：
启动自动重装软件定时器0，每100ms翻转一次LED2。

  c7 L2 v$ l0 Q! R* V3 I实验操作：
  t# h4 l: ~9 ?5 e! GK1键按下，从DTCM依次申请280字节，64字节和6111字节。
  m! l- v0 g. o+ X% f( l) P; ]% ~' PK1键松开，释放从DTCM申请的空间。
# ~3 ^0 a3 C3 C( jK2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
, ?, C- \. v  m* xK2键松开，释放从AXI SRAM申请的空间。
K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
K3键松开，释放从D2域SRAM申请的空间。
' \' a5 M( k1 B# d2 N5 `* A摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
' y* d- [2 }( @8 G摇杆OK键松开，释放从D3域SRAM申请的空间。
5 m0 n( T7 p, K, R; |6 m" s+ N/ y
5 l  g. a$ w' H6 N7 X" M5 r" w上电后串口打印的信息：

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

% `, q! ], `$ m$ w3 k8 ?

7 C  U5 n/ P' i
程序设计：
9 _; n) K: d3 J$ i8 s
# o: H! C+ o$ W; [  系统栈大小分配：
2 m1 J# x% }0 D  s( X: z% c

0 `3 \, {* s: g2 W+ u0 x7 G5 E- ?  RAM空间用的DTCM：
8 w4 c' P6 @; S. F5 N" v/ p1 X2 d- D- m
; M$ C* A+ b* S, ~2 e) u  \: F( l+ I

  硬件外设初始化
8 O- Q- p5 J0 y% R2 o- y8 H
硬件外设的初始化是在 bsp.c 文件实现：
5 S  z8 f/ w  L# j/ B
1 }5 l) q8 l' \( |+ i, k" \

1. /*
   * L, t# q  `$ ~9 o9 P
2. *********************************************************************************************************
   $ q8 |/ [# c, A3 D" `
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   8 `+ t, i* t! r' `& d
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   2 U3 S: v7 t' a! m* i
8. */
   
9. void bsp_Init(void)
   
10. {
      g. S1 g" E/ ^
11.     /* 配置MPU */
    . p. v( {2 X* v, Q1 M- j
12.         MPU_Config();
    - B4 f+ j' A2 a2 Z, F% F) Q
13.         
    4 d  S- V9 V( Q- J! R
14.         /* 使能L1 Cache */
    : ]6 M* ~1 N* z* W1 d- n
15.         CPU_CACHE_Enable();
    
16. 
    ' }. n# b& k4 _( f& C
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    ( A. E& B$ T- w) M; t
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    1 r( P: |) [. Q9 P1 r: E. `5 c3 A: }
23. 
    
24.         /*
    + ?) e/ ?& q5 _- y% y& b
25.        配置系统时钟到400MHz
    , M, `% h; H0 n
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    3 v( r7 D5 a9 ~9 ^" S, h
28.     */
    # T7 n; N5 ~, R9 l
29.         SystemClock_Config();
    1 D; h0 n, D0 @4 D  H- L
30. 
    
31.         /*
      Y; E9 o# p% c, L, h7 n2 G
32.            Event Recorder：
    2 X8 v" c: i1 `
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    + h0 N4 X  ~( v9 ^. V2 ?
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    9 v. l1 }2 _# L9 _2 C1 e7 y
36. #if Enable_EventRecorder == 1  
    + L  |, H# j6 \6 N
37.         /* 初始化EventRecorder并开启 */
      K5 t) ?8 E4 U9 B) d. B9 L% B
38.         EventRecorderInitialize(EventRecordAll, 1U);
    ) i6 d& R( R$ r4 }" Z
39.         EventRecorderStart();
    
40. #endif
    0 T1 r/ \0 }  n2 ~& g
41.         
    9 n5 q9 O$ e0 H7 d( D, N$ X2 t
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    + G5 r. L( K$ ]% }$ P
46.         bsp_InitLed();            /* 初始化LED */        
    5 E9 W) q3 R7 @; r+ \+ Z
47. }

复制代码

  MPU配置和Cache配置：
6 ^, ~' Z. k: v
6 [8 P5 ?. Y9 L2 s5 x5 V数据Cache和指令Cache都开启。
4 W% X; e: v4 Q" b/ S' H) M% f' `
  G$ u. G- F, W# n) `) lAXI SRAM的MPU属性：

Write back, Read allocate，Write allocate。

FMC的扩展IO的MPU属性：
8 x6 b4 Y) X. T- ]
( B0 x2 S* u% s& i' I必须Device或者Strongly Ordered。
2 o) u; q! E* {; C
8 O0 x2 ^$ d; ]! }$ y3 f+ e3 B$ `( CD2 SRAM1，SRAM2和SRAM3的MPU属性：

Write through, read allocate，no write allocate。
2 o) A6 L7 k& E2 H2 k2 y& N
7 E4 m3 s/ {" I! e* j. jD3 SRAM4的MPU属性：
% n  @5 }6 E2 B
Write through, read allocate，no write allocate。
8 Z- r3 @/ C" ^4 W9 C1 i% Z

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   ' ]- y' ~: Q! X& j% H
4. *        功能说明: 配置MPU
   & Z. U/ v- r& {, i% t: Z( }( ]
5. *        形    参: 无
   8 _* b: |. y; i  ]! N
6. *        返 回 值: 无
   1 |4 X3 C0 `/ K0 Y2 E5 J
7. *********************************************************************************************************
   
8. */
   $ M9 r7 R$ X5 ^$ {
9. static void MPU_Config( void )
   & R7 s" I  g. ^, A9 d+ N  {
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    4 k, Y% F* G; L% x
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    0 A6 c2 e4 a% z6 \1 t5 e4 _8 h8 z8 {
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    ( s* _+ L8 }- }, ~2 m
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    3 f% e, `4 J# t
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    # V+ I& v; ]0 h  o' V/ X/ N5 A4 Z
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    # x1 S* k" C2 D7 |1 `' r% Y9 a
30.         
    - q8 \6 k7 f' O% C; `; |
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    # Y4 N/ k, T6 A: T4 w6 i, V: W! w
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ; |) v0 W; Z( M9 N: d# `$ [; F% O8 E# S
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    9 q; G+ A6 c; \, T% l! j
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ( q; G( J( I" a! R! ?2 u
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    2 W/ c8 B  r; A: U
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    : y4 F' j+ ]$ x) C- K  ^. i
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    % _, O# C7 R) b6 B. l  \5 K
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46.         
    
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    8 f. w( {  j2 |. S1 f; }
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    ( @+ N2 f4 N0 a; r
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    7 Y- ]: D: Q9 ]! Z
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    8 V  s% y9 M& \0 H& {! q
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    # A  I: a: H* w- b. p3 D2 L
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ( H7 V5 e( j. ~# a
61.         
    
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    4 S4 p* H+ i% s
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ( k. V) y5 S+ _, @" H
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    6 H1 X  o. r2 \/ A3 T( w
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    : r* K# E( L  ?$ D& T4 Q
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    , o7 M7 W. h0 C( s
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    0 m& y4 x9 r2 N
74. 
    2 k: U* a/ }' }& d" M' {: T+ |7 `
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    2 }- d7 o$ Y( x1 x) z& \
76. 
    ' u! ^" R# B0 I/ o0 v
77. 
    
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    * V9 F* L/ Y* d7 H: _
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    3 @, q8 b# q  K4 [. I: I% s/ A+ E
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    0 ]' m  J- W6 a' \' q3 G0 |
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    : o$ k8 ]  c+ p3 s' t: g
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    : d* y& j0 s( l3 c; U  [2 M
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    7 r" M7 w) O" @9 b$ }* u
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    & j5 e# _  C% ?9 u2 k) }
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    ) T1 l8 ?* ~0 s
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
90. 
    5 w1 j, Y4 e; K; I- M( L
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
92.         
    
93.         
    + E& Q: K0 {# L* O2 D
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    5 {6 N( Y: ?) }  w0 y
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    7 e: S: C% V8 T$ Y5 b) f# _7 B$ B
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    & }# I) j7 J2 i, w+ |" U
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     # C$ M& K  ~" f# J  Y' I4 U
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     . J# M* Q& N; R* C6 |
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     ; I' R0 n* c. B5 z
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     % e& K' w: c. t: g( y# i
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     
108.         
     
109.         /*使能 MPU */
     
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     
111. }
     
112. 
     3 K/ J5 K5 M: [/ b
113. /*
     2 d0 r) q. N" r$ ~2 x' F
114. *********************************************************************************************************
     
115. *        函 数 名: CPU_CACHE_Enable
     1 d0 A; Z- p: k9 Z0 I: F
116. *        功能说明: 使能L1 Cache
     1 I7 }- t$ g+ o; e- j/ }' ]* j
117. *        形    参: 无
     
118. *        返 回 值: 无
     3 J; H) ^% K! q. ^
119. *********************************************************************************************************
     / l+ Y' C/ H  }
120. */
     
121. static void CPU_CACHE_Enable(void)
     
122. {
     
123.         /* 使能 I-Cache */
     
124.         SCB_EnableICache();
     
125. 
     
126.         /* 使能 D-Cache */
     # S$ n( m* Z2 r! u; @
127.         SCB_EnableDCache();
     % F4 N$ w. N+ L: r+ g( _
128. }

复制代码

  主功能：
7 b; n% T- P: i0 Z! ]8 T. f9 X
主程序实现如下操作：
- G# ~# a5 R% K7 @8 n9 g
  启动自动重装软件定时器0，每100ms翻转一次LED2。
# R0 e5 b% D3 m6 A; {$ G! a  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
4 l$ r4 q5 N8 I9 U$ l  K1键松开，释放从DTCM申请的空间。
  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
( H: Z) n4 ~; ]9 L, u* X5 O* Q  K2键松开，释放从AXI SRAM申请的空间。
  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
  K3键松开，释放从D2域SRAM申请的空间。
8 ?; B2 d3 J! S  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
/ J: h; D( H( l; ]+ s! n# `, P/ n  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   6 x4 }% M: R. @; k# H5 _- {
8. */
   2 k6 a$ H7 O5 E9 C: J
9. int main(void)
   $ B$ p/ `) t3 y( q: Y
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
      W$ [0 [% x% R
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;
    7 C+ [, p! E: v" M) s9 W
15. 
    
16. 
    
17.         bsp_Init();                /* 硬件初始化 */
    
18.         
      f4 @$ L. Y$ M$ m' x  U
19.         /* 初始化动态内存空间 */
    - G2 K* S. S# k7 C4 u
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    . Z8 s; u$ ~) J
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    & k+ c* r6 |& l* j
24.         
    
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    * O9 J1 p0 w1 W/ p  d8 d
26.         PrintfHelp();        /* 打印操作提示 */
    
27. 
    3 S! r3 g% P( s
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    ; A. \# H2 D0 T
29.         
    - v0 r2 L3 O( @6 _' o
30. 
    
31.         /* 进入主程序循环体 */
    
32.         while (1)
    - {6 H& ]- j' R7 h, c# w
33.         {
    
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    7 W' ^. {  a* I5 H! c0 P+ e& p4 O* ]
35. 
    
36.                 /* 判断定时器超时时间 */
    # ?7 q# A( w5 O5 F
37.                 if (bsp_CheckTimer(0))        
    
38.                 {
    " f- E- B4 t) {5 z) N& k, v% b
39.                         /* 每隔100ms 进来一次 */  
    
40.                         bsp_LedToggle(2);
    # }( @1 U2 a2 ^4 ?6 ~3 r$ Q
41.                 }
    
42. 
    
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    4 W* A8 u$ r0 Q9 d
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    9 I" N0 x! j2 n4 ^* n  v
45.                 if (ucKeyCode != KEY_NONE)
    
46.                 {
    
47.                         switch (ucKeyCode)
    $ X0 a0 R! W8 k9 k$ t5 P2 a
48.                         {
    & d# P6 s. ^5 ?% [1 c! w4 }( ?
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    - s) c0 W* K2 [$ b& z
50.                                 case KEY_DOWN_K1:        
    
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    
52.                                         printf("=========================================================\r\n");
    
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    - y+ ?+ S7 h" R4 q% g6 E# i
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    ( `7 M. U9 F$ L1 d& c
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
57.                                 
    
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    , q- ~5 H6 [( L% Z
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    0 v( c- Y/ `, ]) H, k
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    6 R* D& \1 H" k" J, X; h# Q' ^
63.                                 
    
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    + N+ t$ F( s/ r9 e
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    7 U) X5 B$ a* X6 E4 T& |+ w
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    * X- p% `) r: c8 a
69.                                         break;
    2 \0 _% A) U8 L1 v/ ]- c# o. P
70.                                 
    8 o2 ~# t$ R1 R- D7 Q/ _6 J
71.                                 /* 释放从DTCM申请的空间 */
    2 V4 s5 ~3 g+ M9 P
72.                                 case KEY_UP_K1:        
    6 s7 q( L* l* x5 A) u
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    6 E9 R  c$ [* k* Z5 z% K2 h  R1 d7 T
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    . E" u* T7 ]3 t- o9 x, L+ O
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    6 @4 y2 I2 l6 u7 m, B
77. DTCMUsed->used);
    * f( o$ G! v0 s% n% d( ?* Q
78.                                 
    8 t4 d2 Z! C1 J9 b6 {6 n
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    1 W& d% p& d: [# l/ T; f7 g2 o3 h
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    1 Q0 y, E# D0 t
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    # `$ A+ i8 y6 Z* t. m' Q
83. DTCMUsed->used);
    1 N& J' K! I2 u3 }! h$ x/ L
84.                                 
    , P" C& p/ t# J9 q
85.                                         /* 释放从DTCM申请的6111字节空间 */
    
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    
89. DTCMUsed->used);
    8 h4 t7 c/ G5 ]7 u6 a" i3 B
90.                                         break;
    # Z: Q0 }& g/ H% {
91.                                 
    
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    ' b; s: h1 I" G
93.                                 case KEY_DOWN_K2:        
    " J% _. F4 T" k0 }
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    . M5 a3 k0 q7 l# m
95.                                         printf("=========================================================\r\n");               
    
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    9 q+ a- \9 B. m+ K- K/ r6 ]! }
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    " y( ]" X" `8 z3 `4 H, F8 `
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    7 p" \8 o/ n8 S6 k) P# u) Q9 d
100.                                 
     
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     8 |& _9 A& M& W3 ^0 t6 C* T, m% @
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     . i( X" O& V  p: K$ c
106.                                 
     % ^0 F6 n- U3 S3 s
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     ( z% X' R, g( H' G, O. K5 z6 U' p0 l
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     : d- X& T% n' T$ A2 _+ z
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     # X" i  a) G2 G8 \4 S( e1 J8 N
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     9 w' B9 L+ w* q* N, a& m
112.                                         break;
     ) u4 K; N2 m7 K+ C. E! ]1 E" j% j
113.                                 
     
114.                                 /* 释放从AXI SRAM申请的空间 */
     
115.                                 case KEY_UP_K2:        
     ! \9 [2 n  O" l5 S. R- w
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     , s0 m; m$ d4 O; y: _, z( Z- Y5 y
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     % {4 _) ]" P7 h
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     6 f2 q! m- c) W  M" j: g0 _: |% V
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     : j2 N& z5 A, g" U& F9 I
120. AXISRAMUsed->used);
     0 l+ k8 j4 G+ ~/ p/ ]. l
121.                                 
     1 R5 m6 {& N" K
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     ; s+ ?' r* C, a) Q8 M
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     
126. AXISRAMUsed->used);
     ! _. C- W; D5 }+ w8 `( w8 w+ R
127.                                 
     
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     1 e4 q. k, z6 x5 N/ i
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
       e6 B2 p' m6 x3 _0 w( M. {% i" k
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     
132. AXISRAMUsed->used);
     
133.                                         break;
     
134.                                 
     % P( K& w! L* `; r
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     
136.                                 case KEY_DOWN_K3:        
     9 B7 v3 {4 c: {( \8 {* l2 P. R
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     - p. T" H( X2 S# z! t& ?
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.                                 
     
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     ; V8 w2 {% H* [1 F
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     * Y" x$ d" ^9 f1 z$ \* A
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     - C0 o- d. m6 L" ^; f3 x
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     ) x$ v% H& j+ p$ Q# y" _
149.                                 
     
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
       q* E: U* }" j; d( H
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     9 Q" P# N' c$ \8 h
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
155.                                         break;
     # N( s5 c" t7 t0 r1 z
156.                                 
     
157.                                 /* 释放从D2域SRAM申请的空间 */
     
158.                                 case KEY_UP_K3:        
     - n7 Y, \; l/ c
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     % [: P1 ?5 @( I4 B2 u
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     & `6 i2 R; p" \4 o8 J
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     ( p9 k6 [/ p1 O5 n  \1 k) V+ z
163. SRAM1Used->used);
     
164.                                 
     
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     " `0 T& d# y. d, B: i- E
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     0 Y  d9 \4 ^# u
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     ) A4 l7 U$ L# e+ V5 o
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     ! g" m+ d8 g6 j. p8 F& k) ]0 z
169. SRAM1Used->used);
     * X$ n+ \, D9 j" E: f" |
170.                                 
     
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     5 `& O/ i5 ?/ E& P7 }
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     ; N4 d4 w  P7 s; E! p% V* [3 b
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     
175. SRAM1Used->used);
     
176.                                         break;
     
177.                                 
     
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     
179.                                 case JOY_DOWN_OK:        
     ; F( \* N, {3 T" h: L& ^
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     7 l& T' C8 _' W; X! u4 c
181.                                         printf("=========================================================\r\n");               
     $ w" m5 ]- o0 K
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ! E5 ~! S) t* w% k& M, t
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     3 O5 Z  }* E; l8 `! D
186.                                 
     ' j; O5 J0 z+ Z( \* E! N
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     / r3 Y7 D" n3 _
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     " v9 ^6 d; _! z( I; _3 Q3 y
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     , f( Q3 X* s/ P+ l5 _: u
192.                                 
     9 h& o% M) y9 e2 o4 H' Z
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     7 V5 e: w9 u- |. y
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     4 G: A+ p( o6 `9 Q2 w
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     ' h5 D6 k  |7 i/ J; u: Y* q
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
198.                                         break;
     ' N+ w$ |8 _8 V( @/ m5 n: e( J
199.                                 
     
200.                                 /* 释放从D3域SRAM申请的空间 */
     6 i- q- p0 J5 x1 k% A! P
201.                                 case JOY_UP_OK:        
     
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     % |  n6 z# e0 c0 N/ x- o8 S
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     9 x  w6 F: B( e! z7 R) `
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     $ M, h( ^5 B0 F
206. SRAM4Used->used);
     
207.                                 
     
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     6 |7 F1 S* P1 W: u' Y2 p. f
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ; y" u  _- _8 r) h' i
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     
212. SRAM4Used->used);
     
213.                                 
     
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     8 o3 F9 K" o4 o
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     
218. SRAM4Used->used);
     
219.                                         break;
     ' c6 M8 q& _4 K. N3 J( `- M
220.                         
     
221.                                 default:
     
222.                                   /* 其它的键值不处理 */
     
223.                                   break;
     5 O3 K+ s3 u8 _" \
224.                         }
     
225.                 }
     , q- o  a6 b# ~
226.         }
     
227. }

复制代码

5 |0 \. j$ ^& G% D" R27.6 总结
  t& X* f  h* ]/ e本章节就为大家讲解这么多，还是比较有项目实用价值的，特别是MP3编解码，JPEG编解码，视频播放器，矢量字体等需要动态内存的场合。

$ D4 g, q) @4 s
& @0 c8 F) o, b  B( o1 I0 X
& |' F3 o" T6 t/ X