27.1 初学者重要提示
  学习本章节前，务必优先学习了解TCM，SRAM等五块内存区的基础知识，比较重要。
: d5 O' A5 Q% l, Y$ I6 t; {2 w  将RTX5系统的动态内存管理整理了出来，可以同时管理多个分区。如果其它RTOS中使用，记得做互斥保护或者加个调度锁均可。
( Y7 I" ?& Q; _9 M! ~  支持动态内存使用情况统计。
27.2 动态内存管理移植
移植比较简单，仅需添加两个文件到工程即可。
* ^: s/ |  Q9 f! T3 j% \
27.2.1 MDK版的移植
0 c' `1 c' |+ k5 n1 d4 o+ U  @  第1步，添加如下两个文件到MDK中
( F  s7 z2 N/ Y& @5 w9 g注，以本章配套例子为例，这两个文件的路径\User\malloc。

$ Y) O# F; I/ k, \. h
4 I# Z2 q5 z6 ?3 @2 B3 Y3 h  第2步，添加路径。

4 ~" }. l$ t# q  第3步，添加头文件。
如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。
! f6 j& j/ O, v7 \$ o* T1 k
通过这简单的三步就完成了MDK的移植。
& e* q# n5 _" p' T' }+ X9 ~' @
27.2.2 IAR版的移植
  第1步，添加如下两个文件到IAR中
注，以本章配套例子为例，这两个文件的路径\User\malloc。

+ Q; K% V5 h- L" |3 @4 X  P

  第2步，添加路径。
! H/ G! U) G1 g: L, `$ S- E: e* B
. h* _7 P/ M3 A6 f& s4 D

% D: e) J/ w6 F6 j
  第3步，添加头文件。
: z3 j/ w1 t( Z如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。

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

# D& N2 Z2 `- y) L0 c# `27.3 动态内存的使用方法
9 k$ V2 z$ U4 a3 {3 t' P' [: N下面分别以MDK和IAR为例进行说明：

; r8 `: Z% }5 w6 b: q27.3.1 MDK上的动态内存用法
) W7 ?$ }0 L% O! P  定义动态内存区
  G" q1 v! r' W' r, H比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：
' O5 j6 a2 q3 w
. x+ t& t( \% [, t; f. S7 |

1. /* DTCM, 64KB */
   
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *DTCMUsed;
   
4. /* 定义为64位变量，首地址是8字节对齐 */            
   - P( W% ~- u! X7 L  }+ @4 V# s; M
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

( U+ \' h* m6 y, K如果要使用AXI SRAM作为动态内存空间，可以使用__attribute__((at( )))指定地址。

* @' B4 S& L" ]8 L: M

1. /* D1域, AXI SRAM, 512KB */
   
2. /* 用于获取当前使用的空间大小 */
   ( S  T; r3 P4 G  Y  k2 u6 i& L0 i. k
3. mem_head_t *AXISRAMUsed;  
   
4. /* 定义为64位变量，首地址是8字节对齐 */
   . q4 Z* J6 d  l9 u0 M0 {# s( m
5. uint64_t AppMallocAXISRAM[512*1024/8]__attribute__((at(0x24000000)));

复制代码

2 L8 A0 v4 N: M# _8 n; B9 A0 c" U  初始化动态内存区
1 B; I( X& v7 I) A调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：
0 N! M! ~( l" S4 @8 E
osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
4 X" T6 k/ R8 hosRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

. M/ T$ o* ^/ t2 }  申请动态内存
/ T! X" Q! M9 L5 J- r通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。

. o2 [% m# U0 ^1 b0 o1 _第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。
2 i: Y% c" u) X8 C0 k3 X
第2个参数填写申请的字节大小，单位字节。
" a1 i* x3 E  ]% a7 z: d1 T# F
" l( J, d3 V3 W* }% R, J: R第3个参数固定填0即可。
2 K" \' ~8 w( D% j
& e: I1 F0 \0 I" G返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！

举个例子：

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   
2. 
   4 a6 ~8 D' r6 S8 o, O% x; W4 J% B
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   2 A! S2 d) l7 l) ]
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   - l' I7 H" K' Y# J8 k) p/ U
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   
7.                                                              DTCMUsed->size, DTCMUsed->used);
   , h1 G; w& S  T0 \! \- h, s: d, O
8. 
   
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    ' C! O+ z* A, y: L: o, j/ K4 c' j" R
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    6 R0 I/ o0 d* h# }. B* |+ o+ L" U
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

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

  释放动态内存
通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。
" y4 X: |( ]/ ?% H
6 D9 |/ D* C( @0 p& m第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。
$ l" o9 y1 \& R! R+ ^: G- P
( M, E6 O3 |7 n/ W/ j8 A第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。

返回值，返回1表示成功，返回0表示失败。
2 w, V. `' D3 f, q+ g2 \2 c) [
举个例子：
/ y1 I! b- i! _

1. /* 释放从DTCM申请的280字节空间 */
   & H4 ~9 I. [  v2 ^' U: |3 ], Z
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   " E. z5 i* \# j! \, |, e! {
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   + o# O* E; C& V& S
5. 
   4 x# g8 e5 l' y3 D" l- h9 O
6. /* 释放从AXI SRAM申请的160字节空间 */
   6 [, v  g, Z( c
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   : Y+ A! E& p5 j
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used);

复制代码

+ ?* s% X6 r* R  Z% H( s5 F, ~27.3.2 IAR上的动态内存用法
& u5 t  W0 m& F注：IAR使用这个动态内存管理，仅在定义时跟MDK略有不同，其它地方是一样的。

  定义动态内存区
) R9 c- l+ T$ g$ ~% G7 Y比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：

1. /* DTCM, 64KB */
   ' g0 L3 Y7 I& V$ J( o
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *DTCMUsed;
   - W# s, v- h( D- m+ c! @
4. /* 定义为64位变量，首地址是8字节对齐 */            
   . g1 b  Y; q& p- N) y
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

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

( K' R. R& A+ S  H6 F

1. /* D1域, AXI SRAM, 512KB */
   ; R; g8 G( y5 L
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *AXISRAMUsed;  
   ) N3 Z' _* r8 G' _# |8 O2 X
4. /* 指定下面数组的地址为0x24000000 */
   
5. #pragma location = 0x24000000
   
6. uint64_t AppMallocAXISRAM[512*1024/8];

复制代码

1 F4 |. B4 {  @: ?  初始化动态内存区
调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：
8 {; w) z$ w% a# r7 j9 l: P& ]

1. osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
   ) _$ g6 E8 D9 s& K6 ^( E
2. osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

复制代码

  申请动态内存
7 y3 h' l; y, {& \0 a通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。

第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。
: `( \8 l8 s; I7 _
  [# b' O; u' q, m# N% h第2个参数填写申请的字节大小，单位字节。

第3个参数固定填0即可。
; d$ P- U0 S" m- v8 b6 H# r! f+ ^
0 p0 R8 x3 o% f2 `# _9 m3 d返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！
) y6 g3 n% _/ {8 A; P/ u; N
举个例子：

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   0 ]$ I5 e& `2 [2 K$ Z
2. 
   
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   ( e/ x: u2 r/ D& k& `9 G7 g3 R; ^: X# D
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   ( V; B4 @8 h. ^( P' I% B
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   . z, t2 b4 ~4 `1 K3 U3 @
7.                                                              DTCMUsed->size, DTCMUsed->used);
   
8. 
   
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    3 E6 [7 @; J/ k" a) \7 g* M
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    # f6 n4 t+ M7 g8 Q/ x$ G6 t
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

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

; t& N6 f# B# g  释放动态内存
通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。

" T; L# r. Z, O8 X8 X8 ~第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。

第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。

返回值，返回1表示成功，返回0表示失败。
7 P0 y' x  W" F
& _" Q& {1 t: F" W# Q& D举个例子：

, L8 I6 {+ o" \( u

1. /* 释放从DTCM申请的280字节空间 */
   
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   % _8 B* {( u. f" S+ b! Y# \& F% r! v
5. 
   
6. /* 释放从AXI SRAM申请的160字节空间 */
   / n: Z) v7 U' J, Q
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   ( d3 j+ N6 B, t" h  E6 ~' q; T
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   4 S. N2 \1 K$ d, n1 A
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used)

复制代码

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

3 @3 X3 D: b/ [$ h% ~实验目的：
学习TCM，SRAM等五块内存的动态内存分配实现。

6 T/ n- H% n- Y7 W7 ?6 g
4 n; n3 o- h, e实验内容
启动自动重装软件定时器0，每100ms翻转一次LED2。
7 X: f" c$ b' V& M

$ z; r: B: {1 N/ }实验操作：
2 L8 }* D% a2 z& aK1键按下，从DTCM依次申请280字节，64字节和6111字节。
& t) |. i) J. U, BK1键松开，释放从DTCM申请的空间。
K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
K2键松开，释放从AXI SRAM申请的空间。
K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
3 {% m8 L9 k: G* G3 E# g) X" w# a$ {* bK3键松开，释放从D2域SRAM申请的空间。
摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
/ m. J% C# n( P摇杆OK键松开，释放从D3域SRAM申请的空间。

( {/ B- ?8 D. K3 e
+ `! Q7 z5 A8 ^  j1 F$ B9 \上电后串口打印的信息：
3 W# K; Y- I/ b- u& r
: Y- ^/ d% J; ^8 h9 T3 O, z$ q波特率 115200，数据位 8，奇偶校验位无，停止位 1

) C4 g0 E: w; Z! g3 n# f

/ ~  m6 ]4 U3 D$ t1 R- ?$ E% b$ j
程序设计：
1 A6 @6 ~  H9 ?
5 F' n# i* }% t8 ?  系统栈大小分配：
( A& q& [% L7 r4 d
! ^; o, ?( m# M8 x$ F+ b0 W

9 j$ }2 e) e" x. w7 P9 z' M8 _
. h  J% V, C. c1 l5 MRAM空间用的DTCM：

6 j6 D3 p, j3 a" S( E  @
  硬件外设初始化

" ^& U' |& U6 n! E4 w# E! d硬件外设的初始化是在 bsp.c 文件实现：
& H' ?, [- I" Y

1. /*
   
2. *********************************************************************************************************
   ) t0 u! N4 G5 _: M6 M
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   4 a! g* i& C8 R3 `4 |  o/ m
9. void bsp_Init(void)
   
10. {
    7 [; E7 d) @! e! H
11.     /* 配置MPU */
    ) \9 J- n" f7 v* w( A* _2 b
12.         MPU_Config();
    : {# P0 n- G; U$ L* U, k+ J$ j  q# T) Q/ n
13.         
    7 e1 ^/ B' e2 S2 V
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    
16. 
    
17.         /*
      c- ^8 g: ^( F/ r
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    6 a$ z  q' e* p, m* t
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    + \3 W. Z4 @, o* I( X, H8 I
21.          */
    
22.         HAL_Init();
    
23. 
    9 A/ k3 k5 l4 ^: |( k
24.         /*
    + T0 P1 j/ L  @. B  O
25.        配置系统时钟到400MHz
    1 Z# C2 Q3 Y. U% ]2 A+ C$ F# h0 `
26.        - 切换使用HSE。
    2 G; T+ m) X1 Q" U9 K# x' {7 G
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    
30. 
    
31.         /*
    0 g8 ~! i3 k& `2 J: v; _7 q2 G4 e, W/ ^
32.            Event Recorder：
    6 @5 C) f0 }. m0 ^
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    ) y9 U  G. d' F$ |: m" A; B1 i% g
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    5 p! y, W8 x) B# K/ Z
35.         */        
    2 B3 W# h! S3 G9 g
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    * t. _. h: \% i8 P
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    7 V4 P6 S6 ~# v7 q3 h' @
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

% z" F5 q, F5 J( ~% f1 ]  MPU配置和Cache配置：
数据Cache和指令Cache都开启。
, d4 E% h  C# P9 h: a- `
6 ^4 Y3 N& I' U9 wAXI SRAM的MPU属性：

( S: i* Z% |4 S, M* f. N0 nWrite back, Read allocate，Write allocate。
0 V. W4 N  {- ^7 l
FMC的扩展IO的MPU属性：

3 N* ~+ A) U5 \% T4 n. S必须Device或者Strongly Ordered。

D2 SRAM1，SRAM2和SRAM3的MPU属性：

Write through, read allocate，no write allocate。

D3 SRAM4的MPU属性：

Write through, read allocate，no write allocate。
5 r/ g5 U) W( I! U! S  p0 w

1. /*
     Z9 f! P0 e4 V7 d4 o" a9 p
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   6 w. ]1 ]* M! Q$ F
5. *        形    参: 无
   . r) r! ]1 o1 n! I% p& l% m. S
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   
10. {
    8 F7 q# U; C7 O# ^) ~: w# K! ]7 {) Z
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    9 U* I+ E" T* Q! s$ j
12. 
    + Y1 T0 _  n5 n5 z5 t2 i2 j
13.         /* 禁止 MPU */
    % {: ~$ w* ^7 ]' n! n8 `2 l% K1 a: h0 D
14.         HAL_MPU_Disable();
    4 s3 p' p/ L; I3 @2 L7 w- T
15. 
    ' ^' e) i. u* ~) d+ l) k( }
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    7 p5 v9 w# Z& n0 U
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
      j5 |9 Q* g& @3 O4 G
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    0 v/ ^4 A$ R1 P. R) j" n
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ' v! W8 n) T/ x4 [3 {! j  B+ i
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    1 |% o. r& s5 g1 B" N- V" R2 S
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    - o; s6 }; w5 c' _/ y5 j/ G
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    / }5 H2 h( @( L" l0 T6 i* m6 v' \6 u
30.         
    5 W1 z( y! S2 `) a, g
31.         
    0 P8 H8 f" ~% R+ V
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    4 `" r. B- O( n& i( h9 B7 a
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    / h* j. L; k" n  o$ e
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    # B0 W# A4 s# l9 w; g- s
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    , h2 w& w, x: W1 ^
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    $ P' q; Y( U, |0 R  {0 |( v' f8 w! g
46.         
    
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    . [* w/ }; A8 X: g( X/ W
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    * i5 l' _$ G9 b
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    " h6 R- g( U* l# f. n0 ]! ]. V: D
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;
    6 K2 |, `7 B! B; R5 J. r
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    1 T7 U+ e1 W- ~* r8 z. V
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    % f7 T( c3 s+ x  r8 {
59. 
    3 W' {% N% o5 ?6 r
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61.         
    
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    8 j* E  c# Q* v" O) x
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    8 w4 E; k3 W. U8 _6 w" L
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 }7 z% u: B% A% I6 p, `
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
74. 
    ) S6 Z- s7 Z; K+ l3 A3 Q: A% J
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
76. 
    
77. 
    
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    : }. F( x( A, r& Z5 @. d- L
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
      L. `9 ?  c, d6 ~( N
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    3 u0 Y# E9 f* q4 B; R
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    9 H' |& s% g9 U" W
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ! b) |2 y+ s2 K* p9 ?
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    5 K0 a4 V6 W6 B
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    ' o. ~. j( _3 Z- e, c
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
90. 
    
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
92.         
    ) C9 H8 i+ @2 `1 Y
93.         
    0 u3 j) g2 v- j
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    ( T" F& M$ [8 y4 @
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    & O# M  z9 X4 t) u- m- z" |
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    7 K* A& ^1 I7 h$ C, g# i) Z
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     3 Z+ ]6 d3 K1 g1 u" Y* @
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     . z9 _9 w  L  r
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     6 S4 p4 z4 S5 j& s# y5 I' n( D$ K- c
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     ( X* a8 g' C  ~: Z" h0 t
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     ! |$ z$ Q# o1 H% K8 {5 u
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     3 |( d  |9 i+ Q* V; c
108.         
     ) x! j6 v' B$ J2 h( P
109.         /*使能 MPU */
     
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     " t) H9 T5 O0 k1 l& O1 D% v
111. }
     
112. 
     
113. /*
     + N7 u  C" e0 g- @0 w( @& r
114. *********************************************************************************************************
     
115. *        函 数 名: CPU_CACHE_Enable
     
116. *        功能说明: 使能L1 Cache
     
117. *        形    参: 无
     
118. *        返 回 值: 无
     & j; B. Y; w( B; o6 O8 h$ [- k* O
119. *********************************************************************************************************
     
120. */
     
121. static void CPU_CACHE_Enable(void)
     
122. {
     & t4 B% F9 i- J) C& T0 K
123.         /* 使能 I-Cache */
     / S6 R8 M  X7 P! m% _: O& ]0 e# ~+ j6 N
124.         SCB_EnableICache();
     " M1 D, p# Z5 T
125. 
     
126.         /* 使能 D-Cache */
     
127.         SCB_EnableDCache();
     ( E9 Q- R& y( |. N
128. }

复制代码

  主功能：
5 q3 O" J  H7 K$ U- W% r
主程序实现如下操作：

  启动自动重装软件定时器0，每100ms翻转一次LED2。
  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
  K1键松开，释放从DTCM申请的空间。
/ h" K$ b/ M6 [4 a6 n' s  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
! p! _# X5 H3 K7 c/ }+ o" K  K2键松开，释放从AXI SRAM申请的空间。
  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
  K3键松开，释放从D2域SRAM申请的空间。
: V8 C+ U' G" c. D, p, s7 _2 j) ?  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
8 W- F0 H9 w* P) H& x7 Z0 U  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   * q  r. b; a! x
2. *********************************************************************************************************
   ) U/ n" W2 J9 m7 ^2 E
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   1 w$ q8 X7 Z, D& u/ Q* m. M# w
6. *        返 回 值: 错误代码(无需处理)
   , a2 M9 H# P/ t2 T. O" n6 J* s) X
7. *********************************************************************************************************
   
8. */
   8 ]6 j+ L' j/ I0 a$ I
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    9 f# L# j" k9 |& r
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    4 B8 H" T) F  {( L- F# I
13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
    
14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
    , e7 M7 v/ i! `+ t$ z, }3 S, q  z0 Y/ n
15. 
    8 I+ m" N) o4 Q6 j. M
16. 
    ! J7 D3 u9 _+ \; W% S. a8 R6 y
17.         bsp_Init();                /* 硬件初始化 */
    
18.         
    * A% \: z; S1 M  B* Q0 b
19.         /* 初始化动态内存空间 */
    
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    2 C) U9 |' V5 C9 Q# t5 d
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    / M4 L% W" S* }) Q$ d9 _
24.         
    
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
26.         PrintfHelp();        /* 打印操作提示 */
    
27. 
      C' `3 s% F1 |6 z! L2 ?
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
29.         
    
30. 
    / Z  b7 N" h" s
31.         /* 进入主程序循环体 */
    
32.         while (1)
    
33.         {
    . V& f4 i: C; p7 c* r3 u9 H
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    : g, o, x$ }, N7 a' j- g7 J& d
35. 
    
36.                 /* 判断定时器超时时间 */
    
37.                 if (bsp_CheckTimer(0))        
    . M. I, g4 N' C7 K
38.                 {
    1 T: Y7 X1 ^. h9 ?7 }! M
39.                         /* 每隔100ms 进来一次 */  
    
40.                         bsp_LedToggle(2);
    
41.                 }
    
42. 
    ; r9 s# w2 {8 m6 j/ X$ r4 Y- G
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    1 p, E$ f% W' t9 b% }) d
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
45.                 if (ucKeyCode != KEY_NONE)
    ! v( x) b7 p) W+ {' k& C
46.                 {
    " s8 [5 y  \4 D
47.                         switch (ucKeyCode)
    ' o6 |. {5 ?8 }6 Z
48.                         {
    
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    
50.                                 case KEY_DOWN_K1:        
    
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    ! s/ a7 g# Z( u2 M8 ?
52.                                         printf("=========================================================\r\n");
    
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    ) H$ r& n# K4 J8 r, d
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    : n( O5 E6 Z' r/ P( C
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    7 h! @, i$ A- g3 c7 d4 m. B; C
57.                                 
    
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    ! A* Y6 {0 G6 t' Y
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    ! a% p0 F3 h2 D' i3 Z
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    1 {, M  H8 K/ d" {+ A0 W$ a( G, b. ^
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    $ f0 a9 n5 \$ T. Q  o) ?
63.                                 
    
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    : A' Z9 T+ K/ z2 i# O0 H
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    4 h+ ~& p. I  g( r- d
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    5 F/ n; ^, \2 ~8 b" p; z
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    " P7 i# d* \* j4 G9 e" b# x" f
69.                                         break;
    
70.                                 
    & ]/ W" I9 {1 E: l
71.                                 /* 释放从DTCM申请的空间 */
    
72.                                 case KEY_UP_K1:        
    
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    4 h. ?& [: g8 u5 o4 N1 D% f1 L3 Q
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    # Q7 s; n0 [7 `5 t& n- y
77. DTCMUsed->used);
    - _3 N) m' B% `/ r  ^4 h
78.                                 
    
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    
83. DTCMUsed->used);
    % {8 b  a8 a/ E7 Z
84.                                 
    - B; ~( o  Q" x, x& |! Q2 X) w  E  Y
85.                                         /* 释放从DTCM申请的6111字节空间 */
    9 u4 B2 f: h3 U* X" X' G6 a
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    # Z+ @( m0 c" x9 M# \
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    
89. DTCMUsed->used);
    . _! a' j( W6 g! y3 V0 v! z
90.                                         break;
    : v& y0 s7 ^. U! ]  Q1 a  j
91.                                 
    
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    
93.                                 case KEY_DOWN_K2:        
    4 U/ X9 A4 w- a
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    
95.                                         printf("=========================================================\r\n");               
    % }, W7 ~* D1 w1 w/ ^0 y4 @; \
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    9 K, i, d7 M7 `8 T) i( O+ m0 c
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    6 `* O2 _# C# q; O9 S- c* `
100.                                 
     8 w5 Q1 W7 C8 a: c6 N
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     + n8 h8 ^# e% C6 i
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     
106.                                 
     
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     : C$ S) |6 y2 O- a# p  ?- o* s
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     ' Y6 ^, l7 n6 t2 I9 c$ h- h- M
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     6 l) r, w- `* s5 _% N
112.                                         break;
     
113.                                 
     * Z8 L9 V, {. M8 S% d
114.                                 /* 释放从AXI SRAM申请的空间 */
     
115.                                 case KEY_UP_K2:        
     
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     1 U% [" r5 N) |* G: J
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     : o1 d( r) [& a7 v8 {
120. AXISRAMUsed->used);
     
121.                                 
     
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     ) S6 g+ f; D/ R
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     
126. AXISRAMUsed->used);
     
127.                                 
     ' n: z& R4 [. a# P9 g0 ?- ^) ]
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     : A  u3 L, o( K: _( q7 o* V
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     , g% q9 ^& c% q: K* T/ I, S# Q# `
132. AXISRAMUsed->used);
     4 O6 \1 m! ^! c
133.                                         break;
     
134.                                 
     
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     
136.                                 case KEY_DOWN_K3:        
     ) n* g: t$ p6 D# i+ ]
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     7 M. R" X4 x1 E4 b/ W: t- 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);
     ; ]  u" ~0 Y; O! b# p  V$ I& h
143.                                 
     , ?7 f9 y  k1 j. M! H& e  H; ^
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     1 z; S! }1 z- v: {% h
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     $ j4 B, b( \0 e5 N
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     ) v" z5 Q# B9 Z2 P4 a+ A
149.                                 
     2 e+ ^- }' |5 {7 s5 ?* F
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     # Z9 L8 `7 i( t7 T/ b# ^
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     % c' d9 N' b' n+ r7 y0 C1 g- v8 y
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
155.                                         break;
     2 k1 F  \3 D4 K$ C7 G2 N) o# ]
156.                                 
     3 Q* g( |# f: g8 E9 `, M
157.                                 /* 释放从D2域SRAM申请的空间 */
     
158.                                 case KEY_UP_K3:        
     
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     2 G3 k% Z) H, C# c
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     1 t% Z; k, ?& q6 T4 G
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     ; h1 z) X( n2 h! K0 k
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     
163. SRAM1Used->used);
     
164.                                 
     3 D+ P/ g  c3 e# K
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     8 B* C# Z1 G' C: B* h* J
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     
169. SRAM1Used->used);
     
170.                                 
     
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     , Y3 N4 l: b# B2 p1 ~* ?3 L( p
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     ( }5 V) O  m6 b' p8 a3 P- E
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     & l0 O4 _$ s9 a2 J7 p% z' x
175. SRAM1Used->used);
     5 |( K" i! v( H8 B: E6 ~: U' s/ @
176.                                         break;
     
177.                                 
     
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     ) h# H, V7 P8 \% C. T  z- k0 C
179.                                 case JOY_DOWN_OK:        
     / `4 P, g$ O; L+ J4 h
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     0 ^( L/ W0 k0 `$ z6 t/ G; {
181.                                         printf("=========================================================\r\n");               
     
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     2 P3 W! a) l9 Z4 W4 ]
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     6 m9 p) D4 B2 m9 N8 H
186.                                 
     
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     ; ~0 I1 Q1 w$ ]1 Z3 |! N% \; P
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     , m. e1 m0 t- o- V  M
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     
192.                                 
     
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     3 E. n8 o4 O- N+ C/ c' f" B
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
198.                                         break;
     
199.                                 
     
200.                                 /* 释放从D3域SRAM申请的空间 */
     
201.                                 case JOY_UP_OK:        
     / }0 [1 t) I' ~! V, M$ @) y
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     8 l. P. p6 P) E
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     
206. SRAM4Used->used);
     
207.                                 
     5 o7 \3 v4 a/ S; m; K9 i; N& F( W
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     * ]( {; T, j4 c5 A
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     8 w0 {% l3 t6 Z
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     0 O0 H% f2 L0 x+ J' F
212. SRAM4Used->used);
     
213.                                 
     5 w2 {1 k* w* t
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     4 C* `7 P' v2 R
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     * q1 _4 C6 N- Q" O+ @) J! s
218. SRAM4Used->used);
     
219.                                         break;
     8 H* Z1 v" e! r0 N: ^+ j- z, O
220.                         
     
221.                                 default:
     0 T5 P. c' x% {
222.                                   /* 其它的键值不处理 */
     . q: q2 }0 Z8 k+ H+ ^
223.                                   break;
     
224.                         }
     ) F2 N' S: X' d; k  w; W, ]8 C+ h
225.                 }
     
226.         }
     
227. }

复制代码

5 w! T  f3 V, P% e8 ^5 e1 m27.5 实验例程说明（IAR）
" |) i' J) ~! G  g配套例子：
V7-006_TCM，SRAM等五块内存的动态内存分配实现
* G) T1 [7 @+ H% l2 u) Q* c
实验目的：
7 D! a) ~6 O/ ?1 O5 h学习TCM，SRAM等五块内存的动态内存分配实现。


实验内容：
1 S3 H* e: ~. K启动自动重装软件定时器0，每100ms翻转一次LED2。
* [; O/ e# o" m' K6 ^! X
( F: m- W+ e: ~5 k, C: C实验操作：
K1键按下，从DTCM依次申请280字节，64字节和6111字节。
K1键松开，释放从DTCM申请的空间。
) t+ i# o9 a9 ^$ ~8 k. }K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
& R& i* A; J* h# S3 X- pK2键松开，释放从AXI SRAM申请的空间。
  k. A' a+ W5 z  h! q3 eK3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
K3键松开，释放从D2域SRAM申请的空间。
. O, S5 R& H2 K  z" i! S摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
' i+ K" C0 A' w  i7 v. o% s. D# ~摇杆OK键松开，释放从D3域SRAM申请的空间。
2 X! `4 n: k) X. N) D1 g
4 }+ d' R' F; r$ N上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1
+ U' E: ~/ b+ H3 a# D" O

; w" ~7 U+ Q  @" d" |% d; u5 C) z
程序设计：
* u# [% X; r2 {* J  R8 i
  系统栈大小分配：

  RAM空间用的DTCM：
+ O* @$ K; D$ \2 U( {( x
5 \7 R% V4 @; P+ g# C$ e

& p0 M! l0 Y+ D- H$ p6 u
  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
! \( ]$ R; h; `
* J, j2 M4 v1 t

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   ; U0 m5 \4 q1 f- s" {$ x% B& h3 w* T
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   ; a& e8 n7 T4 k
5. *        形    参：无
   6 x4 o0 k: w, X. ?- v
6. *        返 回 值: 无
   ' k% M+ E$ ]7 p" m. {* N
7. *********************************************************************************************************
   1 w+ M; P9 t; P) U% j
8. */
   
9. void bsp_Init(void)
   ' Z3 V/ H' G! q* S% B  p; z+ p+ `
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
      B1 M8 j3 d0 F
13.         
    7 p) H. x6 R- x
14.         /* 使能L1 Cache */
    ! K1 `) Q/ \) U; n
15.         CPU_CACHE_Enable();
    4 b7 {, N; X5 r0 s3 R
16. 
    $ w- [4 X- @. k* a6 Q) i
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    
23. 
    
24.         /*
    ) _: s2 j+ J+ o, C; n1 m8 P$ n% [
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    6 `+ w4 C/ H$ @: f2 x
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    3 Y% z5 a& M6 A- ?2 |$ P7 i3 _
29.         SystemClock_Config();
    . N/ Z1 C0 Q" N* Q
30. 
    
31.         /*
    9 @5 H* `# Z2 `$ L5 H" O. G
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    / S! U4 d  t6 T7 h" e
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    : C) H  q+ d/ {- s4 r
37.         /* 初始化EventRecorder并开启 */
    3 D( q) a4 u3 W, K% v2 C; r- n
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    
41.         
    8 c* _2 l# o' N! D7 m0 F% L. p
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    + |* j( A+ N/ I0 r2 k
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    ' G% t3 r5 w" }4 G$ R. g# T7 R9 d
46.         bsp_InitLed();            /* 初始化LED */        
    + V3 w; Y; M& m  `4 m1 r+ y4 u
47. }

复制代码

* R9 E& \1 \9 \1 k6 s6 t, I  MPU配置和Cache配置：
3 Z9 M2 N, b; z" G- n6 X
1 j, U+ p% h4 z& `3 i8 A& t数据Cache和指令Cache都开启。

" l2 C. ?) o+ T6 S* {4 ^2 a7 oAXI SRAM的MPU属性：

Write back, Read allocate，Write allocate。
! V6 L6 q9 N! H1 l' O  K
# s7 f- g- T2 P( w3 \: D0 U/ `& ]FMC的扩展IO的MPU属性：
' ]! X. g3 U) G7 y
必须Device或者Strongly Ordered。
$ d3 y- _' @+ L- ?6 \# {9 G& o
D2 SRAM1，SRAM2和SRAM3的MPU属性：

! Q: V4 ~; M! u) l& Z( EWrite through, read allocate，no write allocate。

D3 SRAM4的MPU属性：
$ V% R" l9 K- \
+ V( }# R4 g: K2 ~% o7 Z* _Write through, read allocate，no write allocate。
* q% a5 n0 }# m1 d1 [
3 r( q5 I" K5 [2 {' C2 w+ ^

1. /*
   8 f9 }7 M, r2 K+ @) E8 ^' h
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   ) b. q/ `3 t6 n# T; R- y& C
4. *        功能说明: 配置MPU
   7 E) z3 u& V$ H* A! p9 D
5. *        形    参: 无
   # U5 |+ N( a) L, X: Z4 \8 F# }3 {
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   $ w) f0 G+ U" r
8. */
   & ]' a  q0 x8 B" r/ O* T
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    ' l4 \- m% p  v8 }3 m
13.         /* 禁止 MPU */
    ! l. }. d1 P# m% s$ a4 R
14.         HAL_MPU_Disable();
    
15. 
    * B! s# o( A) e: w! O
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    7 K# W  u2 ]+ A9 _( J8 K# L6 M; Q
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    2 O: d' o# Q0 @) p! b
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    + c* R( F1 y* k. m# h7 u3 g
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    ; ~* o( {  r! S9 q6 L" Z% n) [* h# X+ d
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    ; {3 }7 S. G, ?# H8 R# A* M
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    % U- ?+ \. P& t6 X; o8 V
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    $ E' C" `4 L: n# u; p7 n
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    " z/ \4 l, o) m3 r4 L' z
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    / a9 c4 `. b6 Y) Y
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    % s/ W4 Y. b5 o8 N  }/ X) r) t
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    9 s) g- U+ t3 [6 Z
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46.         
    
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ) X& t5 t& |; R+ `
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    7 l, q; k+ o. f3 J
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    / ]) C1 @4 S* J9 M
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    2 Q/ d' B9 W  r  {+ B1 C. W8 C0 s; ~
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    # W& J" M$ ?  |/ J+ }% G- h
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    3 w: T" S; M$ O8 X, H/ S: f
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    : x6 z2 h+ X9 q: v4 f
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;
    ) b/ L0 ^, C% `2 T$ b/ Z3 j
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    0 c5 \$ ]. M) _7 f, `" R
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    7 Z3 B  b. d+ r. d2 r
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    9 l0 O! F8 j  h3 R; h% N* @, s9 f
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    ! {7 F# p0 w, l6 ]/ w: R& P+ c1 g
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
74. 
    
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
76. 
    
77. 
    
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    3 X1 b; `8 u/ M
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;
    % |/ m6 `  x/ y7 B0 b2 n# D! L
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
      J3 \4 e4 f: Y8 f, K4 D9 j
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    * X/ i8 F2 i0 o& C) D1 Y
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    ( n" ~/ @- k6 Q
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
90. 
    
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    4 y9 Z7 s% Q4 a0 ~
92.         
    5 g8 `/ _/ b. T$ m
93.         
    ' T# [, d& j$ E2 Y8 v0 H4 q3 y+ b
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    6 |7 M' r4 U5 p. X' S/ x" L
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     ( @+ x. r+ g# r7 N( m2 N: U0 d
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     ! V; z0 N4 J$ M- g8 w) p
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     8 G* `- f2 \" `8 U
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     
106. 
     4 D% {, w# I1 |% T1 x' k$ n7 B' k
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     ) p# r- i! y8 r
108.         
     
109.         /*使能 MPU */
     
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     
111. }
     3 d/ K7 O. W) z; j% O
112. 
     
113. /*
       f, d  h8 l0 K( t
114. *********************************************************************************************************
     
115. *        函 数 名: CPU_CACHE_Enable
     
116. *        功能说明: 使能L1 Cache
     
117. *        形    参: 无
     
118. *        返 回 值: 无
     1 q" z1 A' l  k9 _
119. *********************************************************************************************************
     8 L: X* O7 o: b4 R( t
120. */
     
121. static void CPU_CACHE_Enable(void)
     
122. {
     
123.         /* 使能 I-Cache */
     8 {" K2 |# }  M# r) f
124.         SCB_EnableICache();
     " j! D: p1 l; K: N9 m: |3 U6 |
125. 
     1 q" L7 c$ L' U8 a, I3 ?
126.         /* 使能 D-Cache */
     
127.         SCB_EnableDCache();
     
128. }

复制代码

  主功能：

主程序实现如下操作：
( H! [1 `/ v) a- c+ G# Z
  启动自动重装软件定时器0，每100ms翻转一次LED2。
  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
; U5 o2 h1 _% X: b( z  x  T. Y  K1键松开，释放从DTCM申请的空间。
9 J# w8 `& h+ X0 o. z, o0 ~  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
  K2键松开，释放从AXI SRAM申请的空间。
9 n* z9 M; e( k& p  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
* N: x! i. n  u/ c3 ^, H  f  K3键松开，释放从D2域SRAM申请的空间。
" @7 `: f9 ^7 U8 k5 j( K( h9 |, Z2 p  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
  摇杆OK键松开，释放从D3域SRAM申请的空间。

1. /*
   ; u3 y3 P, }- |6 |
2. *********************************************************************************************************
   
3. *        函 数 名: main
   ; H3 W: @  S, g* S
4. *        功能说明: c程序入口
   * [- i( \. M! V$ F. @5 ~
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   3 x' u4 d* Q6 p/ ?7 P: ?
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    ( x/ _- H4 v4 x. x. m- Y6 d) S
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    " G. _" q9 W+ O0 J6 d
13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
    
14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
    - _* y& g# B* x; K. {
15. 
    4 X' K- j1 V8 ^1 k
16. 
    
17.         bsp_Init();                /* 硬件初始化 */
    . a) Y% g7 b% f* x" _3 ]& u; C
18.         
      f# b5 t8 |7 Q: Z- _/ j* X8 G
19.         /* 初始化动态内存空间 */
    " ]. T8 N& f( q' A8 q
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    6 y1 X+ H$ k7 w
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    , q: M" ~) g5 }* U0 _3 e
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    * E( x/ w8 a7 g3 d$ f" ~
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    
24.         
    + c3 ^5 `) ]9 o2 f0 h; r
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
26.         PrintfHelp();        /* 打印操作提示 */
    
27. 
    2 s" G+ U! f" c* f- @3 e; I+ b  S
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    
29.         
    
30. 
    
31.         /* 进入主程序循环体 */
    1 Q/ l# T% z; D% _/ W: m% x
32.         while (1)
    
33.         {
    
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
35. 
    
36.                 /* 判断定时器超时时间 */
    1 i5 x+ Y% g7 y6 F. W1 J% c7 m
37.                 if (bsp_CheckTimer(0))        
    
38.                 {
    
39.                         /* 每隔100ms 进来一次 */  
    0 D* ?: b0 U" y" y
40.                         bsp_LedToggle(2);
    5 u( a: |* S0 x8 f
41.                 }
    1 w) i9 e$ x  m& R" X
42. 
    
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    3 V# T; o0 i* ]" X0 O& q- n' o1 y
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
45.                 if (ucKeyCode != KEY_NONE)
    
46.                 {
    $ B0 w( R* U: u5 [& g0 m* m, L% s
47.                         switch (ucKeyCode)
    # e" }9 s9 r; o% O# I& I
48.                         {
    
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    
50.                                 case KEY_DOWN_K1:        
    : U, l6 B- [  z# b+ f4 U
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    ; g, m7 t. V, z1 ^1 I( W, G$ M
52.                                         printf("=========================================================\r\n");
    5 v9 S" z$ D! r, t* O2 ^& L8 a
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    : Y) O0 t% ~: H8 {/ H+ W# Q
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
57.                                 
    3 C- E3 i" {2 Q; C2 I
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    
63.                                 
    
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    " R) Q; g! f  j$ R
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    6 L9 z. W' F6 U
69.                                         break;
    
70.                                 
    
71.                                 /* 释放从DTCM申请的空间 */
    / A/ e9 g, w1 o; |: S5 x4 j
72.                                 case KEY_UP_K1:        
    ) K3 c. g! j) B7 b" F' f! Q
73.                                         /* 释放从DTCM申请的280字节空间 */
    5 ^0 i  S1 G6 u6 a5 B) l2 ?
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    % F: K: ~: J* E6 E
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    ! L. T+ a8 \: ?; L# Q1 Q
77. DTCMUsed->used);
    
78.                                 
    
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    2 P7 i' e4 `% f
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    
83. DTCMUsed->used);
    
84.                                 
    : f$ i# D1 f" |" g+ a- f
85.                                         /* 释放从DTCM申请的6111字节空间 */
    
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    # @. c% D/ |2 W% k! B3 _; c1 q
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    
89. DTCMUsed->used);
    
90.                                         break;
    
91.                                 
    
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    
93.                                 case KEY_DOWN_K2:        
    6 N$ L/ z9 ?8 n+ }# Q
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    
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.                                 
     , P! ]  ^4 t0 E8 m' Z
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     ; c1 V1 A, c9 u$ S2 T) C- s/ U
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     8 i: G9 B9 m; ?) Z; \9 Q
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     ) k: e/ ]2 |. |2 [4 s9 a+ o
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     9 ]% w( B$ z( o( G# m! Y8 V
106.                                 
     
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     9 W5 O" A# Z7 K. [+ Z
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     ; C4 @5 W! B, b" B
112.                                         break;
     3 M1 ~) Q* W3 ]
113.                                 
     . X. j, O& ^* @9 a) K+ Q
114.                                 /* 释放从AXI SRAM申请的空间 */
     
115.                                 case KEY_UP_K2:        
     / ?6 d3 t# p; t* k0 Z+ Y
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
       w3 j7 S: U6 I# |6 N# O* x5 s
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     . S8 ~& k' `& _; e
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     , w& }# e% ^' `' q" j+ h
120. AXISRAMUsed->used);
     
121.                                 
     ; a$ A  ?; |8 i* J4 s3 ^
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     + U7 g, v5 n2 [9 K& y4 c, w
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     # K$ D; R: w% V9 q2 ^
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
       W; v( C/ o" l& g* U/ \5 C7 s
126. AXISRAMUsed->used);
     
127.                                 
     1 g, v6 h$ A% y5 J6 g; x. {- f
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     2 z1 |8 [8 T5 C9 n% J
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     - `1 i4 b% m- O
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     
132. AXISRAMUsed->used);
     
133.                                         break;
     
134.                                 
     - K& I/ j3 k& X
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     
136.                                 case KEY_DOWN_K3:        
     - N( c  r) K0 f3 s: ?  ?* v
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     $ O- G: r' w' F4 M2 X( h/ i! l
138.                                         printf("=========================================================\r\n");               
     
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     & q0 o, s- D) }5 H1 ~
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     $ a, E( A4 T8 V" t6 N# t; X  i
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     8 I+ `' d2 [2 I, j
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
143.                                 
     7 o/ h! F: s6 u! I9 Q) a. R1 W
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     6 h/ Z* s3 |# H0 N  @
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     
149.                                 
     ' n/ ?: j' y9 h3 g. H" h
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     9 x- Q2 Z, y: o6 c; x1 |5 G9 F
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     $ g: D0 _# u% {) K% Z& R
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     ) ^- T$ J4 S* Y1 u, g* k. R
155.                                         break;
     
156.                                 
     
157.                                 /* 释放从D2域SRAM申请的空间 */
     : W3 x+ @  h" i: l
158.                                 case KEY_UP_K3:        
     
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     . o3 `3 g( a; p  G' l
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     / G0 F/ r& V/ N1 W; W& e) q
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     - o; L# p5 ~  H5 b" [8 T% r
163. SRAM1Used->used);
     
164.                                 
     8 \8 w+ H2 N0 p
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     5 D) D0 m) K! z6 s4 |( F/ V# P
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     % p# m7 U+ V& B. F, }7 D
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     ! M* k" i! W' f3 \0 A1 X
169. SRAM1Used->used);
     6 N9 S; |5 n2 l2 j3 I9 t
170.                                 
     
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     8 p. g6 u6 _1 e" g. F
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     ' e9 g; q. n6 L( J" U% @2 E6 r1 E
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     & h7 w2 k1 w: n# U8 L8 R% ^
175. SRAM1Used->used);
     ) s  L; v- {7 E8 T/ W/ |
176.                                         break;
     
177.                                 
     
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     
179.                                 case JOY_DOWN_OK:        
     
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     * X  X, ^/ G$ `6 k
181.                                         printf("=========================================================\r\n");               
       v9 g! Z6 j& c0 }& \! {
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     . O7 Q( X: g* \0 j9 \# W5 P
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     9 e8 N4 t- r( S: [3 O) C2 J6 @' b
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
186.                                 
     ; ~. n. L0 K) i; K. r2 C
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     - L9 W+ Q( v9 z) G4 x
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     
192.                                 
     
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     / u! _: ]' o! Y3 S7 W
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     / A  c7 r% i/ S. c3 e( K7 K5 S0 ~
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     ; a" ^) p! f  R. ]# o- [
198.                                         break;
     
199.                                 
     7 [$ x& h% ~; r7 @* M
200.                                 /* 释放从D3域SRAM申请的空间 */
     
201.                                 case JOY_UP_OK:        
     7 C6 U% T/ M: f( j( w. r5 N
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     $ C. F4 G/ C. Z3 t+ Y( a2 b
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ' Y- O# W6 j! ^  p! l& U3 @
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
       u9 Y2 g7 A. e/ Y/ _9 G
206. SRAM4Used->used);
     9 L: B  Q) \  g/ `2 v# g
207.                                 
       Z# _9 s+ c* O( B
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     ( j/ i" y5 K0 `: n9 P) y
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     $ X0 U$ {- [$ D7 e; f3 E
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     
212. SRAM4Used->used);
     
213.                                 
     8 o. D$ V% Q0 D/ |' o# C7 W
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     " E, t1 i- ?) ^' F; t4 O* S2 {
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     . Q( u, G7 f  d2 E% N& u/ z  z
218. SRAM4Used->used);
     
219.                                         break;
     3 I6 r: o6 x" B
220.                         
     
221.                                 default:
     
222.                                   /* 其它的键值不处理 */
     6 ^% C/ B0 ]) v% \+ n
223.                                   break;
     ! F3 U) J; d  H
224.                         }
     ; H! D# U9 V  j3 l; f9 {
225.                 }
       N6 ^  C5 E- h/ w
226.         }
     . p' V/ G" _3 O# E8 Q7 W5 _! A
227. }

复制代码

! ?3 V* A% X+ }) ]. s/ c27.6 总结
; z/ Y; ^  M2 g4 i本章节就为大家讲解这么多，还是比较有项目实用价值的，特别是MP3编解码，JPEG编解码，视频播放器，矢量字体等需要动态内存的场合。