27.1 初学者重要提示
. q3 s4 b5 d; w1 T& Z# ^  学习本章节前，务必优先学习了解TCM，SRAM等五块内存区的基础知识，比较重要。
  将RTX5系统的动态内存管理整理了出来，可以同时管理多个分区。如果其它RTOS中使用，记得做互斥保护或者加个调度锁均可。
5 P" ^. d1 m" q# G8 k2 F  支持动态内存使用情况统计。
$ I' V8 a+ r/ L! R' ~" d! `1 ]27.2 动态内存管理移植
移植比较简单，仅需添加两个文件到工程即可。
0 U5 T$ z2 ]/ j( E+ o+ {
27.2.1 MDK版的移植
! f9 {& E+ ?/ Z* k6 f  第1步，添加如下两个文件到MDK中
, H. W9 A6 c) `. ]; h0 G' r注，以本章配套例子为例，这两个文件的路径\User\malloc。

' i) z# }; C7 e1 ~

4 x- O. Y3 Q2 T5 M/ }$ S6 U  第2步，添加路径。

: M; w" g  O- y/ t" ?  [: h, o: n
* L0 R2 L( ?' I  第3步，添加头文件。
如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。
: @* y. T9 U4 g2 I; _2 ~" f
通过这简单的三步就完成了MDK的移植。

3 I: K* e3 B, e: t% b3 Y( L27.2.2 IAR版的移植
  第1步，添加如下两个文件到IAR中
注，以本章配套例子为例，这两个文件的路径\User\malloc。
7 B$ k' y5 W2 U2 e; ~
* K1 @) N5 a  Y% a, k' r% H

: h; F. ^# S" h
3 N, y/ Y; P6 x3 q( {' U; D' N, z  第2步，添加路径。
9 f8 l  j; g* g# T( T# a5 [

) D' X) N$ w+ L& ^
  第3步，添加头文件。
如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。
/ k- R' R, j7 x: e9 P' R
' p6 P8 H1 Q1 I/ C通过这简单的三步就完成了IAR的移植。

" s' j' K$ A5 u# D1 p27.3 动态内存的使用方法
- [: W2 P0 Y: b3 |下面分别以MDK和IAR为例进行说明：
; _8 T- E. I+ E- l/ }  z
. e- W: M8 B3 S6 K. L* V27.3.1 MDK上的动态内存用法
0 I: ~$ I: u: m( }% L$ }( b2 A  定义动态内存区
" U2 H; L3 T) e+ M# h$ t比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：

1. /* DTCM, 64KB */
   ' o+ m, f, F$ [  _0 Q2 r% j$ M
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *DTCMUsed;
   
4. /* 定义为64位变量，首地址是8字节对齐 */            
   ( f% h6 ?0 [: |( ]; U0 z2 x
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

, A4 T0 r# y. Y2 v, }如果要使用AXI SRAM作为动态内存空间，可以使用__attribute__((at( )))指定地址。

0 }% _2 f! x2 |$ W; `- S

1. /* D1域, AXI SRAM, 512KB */
   
2. /* 用于获取当前使用的空间大小 */
   ' W( s. `/ K; u3 |, i
3. mem_head_t *AXISRAMUsed;  
   
4. /* 定义为64位变量，首地址是8字节对齐 */
   ! o( v4 H/ _* U5 B, I9 a$ T* K
5. uint64_t AppMallocAXISRAM[512*1024/8]__attribute__((at(0x24000000)));

复制代码

  初始化动态内存区
调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：
6 h3 B/ ?2 G# M  ^1 k7 R
9 O. `" B+ ~6 E( z: j1 b! I  a9 josRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

1 k: i1 I8 B2 Q' A& _+ c1 _8 l  申请动态内存
通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。

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

第2个参数填写申请的字节大小，单位字节。
( p- Z  d- u& t) q: p+ s. @
& N5 K4 c% t; ]- q第3个参数固定填0即可。
4 ?7 F& q6 T2 K3 W
; X# e7 t& F( Y3 m. Y返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！

举个例子：
( W" J8 G& ?; V5 W$ U. s: j! h' a

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   
2. 
   
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   2 y  }2 {% e5 S/ B6 u# N% k1 \, [; s6 x
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   * D: D! x* x# V- @) E
7.                                                              DTCMUsed->size, DTCMUsed->used);
   6 `# ~9 Q! \! L" h
8. 
   4 ?2 J) x: U' i2 ^: B
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   # b6 C% F8 i- q+ c7 w4 U
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    $ y/ O1 z% C, `% h- v( R+ F
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    * a, x0 E; K" ^$ v1 v) Y
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    4 O% M* G% u" x" h9 y
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。
# B) R8 E6 b9 r- e' R
  释放动态内存
通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。
( a1 s! o0 S& H/ S  Z. \
: H& P( s8 \0 U第1个参数填写内存区首地址，比如释放的AppMallocDTCM，就填AppMallocDTCM即可。
; v% a; d6 `8 g  G2 u3 ~
, l, g, O5 ^  p5 ]2 \" G# D& V) b第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。
1 g& j. X6 `9 o- P9 p
返回值，返回1表示成功，返回0表示失败。
6 d" i/ e& P( Q: l& D: R( M
举个例子：

1. /* 释放从DTCM申请的280字节空间 */
   & h+ r5 o# o' E0 N" l- p  n
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   5 d4 k+ T0 z7 L1 X
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   
5. 
   ' w$ T( [% r- X; b
6. /* 释放从AXI SRAM申请的160字节空间 */
   
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   ! c( t4 r) z0 }* e8 q
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   - E) y2 u4 Q7 S1 |4 R
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used);

复制代码

! w9 G- r# B1 c1 Z) l& G# v27.3.2 IAR上的动态内存用法
: |: ]5 X6 K. R3 ?8 p注：IAR使用这个动态内存管理，仅在定义时跟MDK略有不同，其它地方是一样的。
1 y+ m7 E; ^$ @1 |4 C
  定义动态内存区
! X: a& v5 i1 Y4 f' R+ n: U7 U比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：

, T; x3 N! c9 H- v. S. i

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

复制代码

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

7 K; p# ?% [& ]3 s, v' P4 b

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

复制代码

: d5 I4 s) ~. ^  初始化动态内存区
2 z- k6 g( [! N' o1 I调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：

+ A5 D- B& |1 V

1. osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
   & S1 ~7 P) w: Q5 P
2. osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));

复制代码

  申请动态内存
通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。
" D3 N3 }- ~  I+ I
7 J2 P, g' W4 ?) _" J; K2 \: x第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。
% ^$ w7 G" l8 z* i! c
5 G* w1 G: e% P/ g' F5 G/ P# v第2个参数填写申请的字节大小，单位字节。
7 \+ D; n# B3 I- z: K5 t" Q/ R
第3个参数固定填0即可。

; S0 x( A& R0 u% u7 V返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！
& e4 A8 P" `7 s5 K
举个例子：

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   ) Z1 Q0 j/ i$ V! ~
2. 
   5 U' [1 K# M" ^( [
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   3 `3 E6 ^+ Y3 c2 m$ E" U! c
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   - f1 y8 K* A& P9 {' ?! h
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   
7.                                                              DTCMUsed->size, DTCMUsed->used);
   
8. 
   
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   1 I0 z* F% D, L0 S+ ~& a
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
      R5 ?. f$ U$ v+ B0 `, j
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    7 \- R5 y9 p/ c$ I5 F) C7 n
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

! V* U* A. C: z' X4 z申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。
9 |2 w: q% s  c. C: H* p3 _
  释放动态内存
通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。

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

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

) E4 z* V" v" M) w9 O返回值，返回1表示成功，返回0表示失败。
- b" T* E8 r! }
举个例子：
# H# @4 N3 F2 X; M

1. /* 释放从DTCM申请的280字节空间 */
   
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   % `% a9 _( z7 w1 [7 W3 W
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   ! k+ G7 M4 s$ v6 K
5. 
   
6. /* 释放从AXI SRAM申请的160字节空间 */
   
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used)

复制代码

4 e6 |* v7 F' t' t8 {5 {27.4 实验例程说明（MDK）
/ h: C, R* f# |, h: i; F# x配套例子：
V7-006_TCM，SRAM等五块内存的动态内存分配实现
5 v! D8 x6 d, ^$ I# D5 R
实验目的：
$ d& {9 O/ y: i3 ?, i学习TCM，SRAM等五块内存的动态内存分配实现。
: B' X7 Y5 `0 K! T& x) \0 E* ~

实验内容
* ]1 ?1 r9 ?; V9 m启动自动重装软件定时器0，每100ms翻转一次LED2。


  P% {, l8 Z3 U- k& |实验操作：
' T7 v7 y* i2 e6 x3 \, D6 @5 KK1键按下，从DTCM依次申请280字节，64字节和6111字节。
* H3 _/ _  v- B# y2 T9 [% rK1键松开，释放从DTCM申请的空间。
K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
; O/ ], c; H9 Q% m+ hK2键松开，释放从AXI SRAM申请的空间。
5 ?" |  S4 [7 g9 @9 X/ y5 R8 P* ?K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
% b2 f& V* ^( W/ `* M* U4 r/ @K3键松开，释放从D2域SRAM申请的空间。
0 v( D( O2 {4 i; p摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
5 ?# n' e6 |. P5 Y. D0 E0 s" Y* [摇杆OK键松开，释放从D3域SRAM申请的空间。


上电后串口打印的信息：
7 B5 @, \) j- U& c/ p% [8 Y, k; X
3 F" `  N  a1 B波特率 115200，数据位 8，奇偶校验位无，停止位 1

1 l  R, i* |8 D+ a% y+ w+ l. t/ N; H

+ C/ i; V8 |# b# b9 B& p
程序设计：
9 p$ i2 Y  K( P& m* y, V
3 |/ J4 Z2 F5 k% Q" m; w  系统栈大小分配：

! y9 `5 i- W- [

* [# j- G. ~1 @
* R0 S- x. p) |) K1 G! XRAM空间用的DTCM：
" F7 L6 @' E4 d# e/ n
3 T  C* R0 |' W' e5 L

, W7 Y9 }( H# W2 Y
  硬件外设初始化
6 l' e" Z1 I& g
硬件外设的初始化是在 bsp.c 文件实现：

5 R, m& r* {, b" E4 W. F1 A

1. /*
   % X) X8 |! K0 d0 Y7 s# h
2. *********************************************************************************************************
   % ?7 }4 n4 w+ J
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   ! U8 o( c; B1 s. l0 j- |
8. */
   6 C' N+ \/ ~- q
9. void bsp_Init(void)
   
10. {
    & d3 ~% t2 X" x0 c: v$ U( O
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    ! j3 d+ I# H2 n# u
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    . e, C' b6 B2 @' H" C
16. 
    + r9 l( \' W5 @7 H" W0 O- Y
17.         /*
    7 q9 ]% B5 g7 w# x6 J+ c) F
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    3 o5 t7 v( m9 Z9 J6 x% o, ]
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    ! x, e& H+ C% M
20.            - 设置NVIV优先级分组为4。
    
21.          */
    ( _4 C' I- K7 p  l6 ?
22.         HAL_Init();
    
23. 
    , I  n) u5 d0 N) O7 w
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    ) t7 F+ t4 B) o' L* y4 h. L% m( x
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    
30. 
    + S* ?% U, P0 b/ @* o2 Z, e
31.         /*
    ! x" u/ U; X& X7 x
32.            Event Recorder：
    - T( m- ]2 I) o* I' B9 X
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    & c( e( `7 l9 C* [# H) e" v# r
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    # O# ^1 t* t5 h" w: U) S2 [
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    3 d! L, ~1 P, W$ s3 m2 K: O. s
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    % Y0 h  m& O: C' S3 w. p. m* e0 ^6 v5 u
41.         
    ) L9 }7 U, k. ^# O0 e/ T0 S
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    ! @9 I! m9 h% F. {7 p, h7 H
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    1 T0 s8 D: D7 q! R1 O; ?4 g- @
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    ) T. |# x/ O$ m4 n9 K% S# P7 P; M
47. }

复制代码

- a' E* g+ i( w) p( w. g7 n- F  MPU配置和Cache配置：
' ]' [4 t- o1 q6 ]数据Cache和指令Cache都开启。

% d4 h& T7 [: a1 E% @4 ?AXI SRAM的MPU属性：

Write back, Read allocate，Write allocate。
& M1 z6 ?0 R1 I6 F0 r* y
FMC的扩展IO的MPU属性：

必须Device或者Strongly Ordered。

D2 SRAM1，SRAM2和SRAM3的MPU属性：
1 h5 k$ f$ N5 t8 E5 @' X5 }% ?
$ ]. a! e0 q3 gWrite through, read allocate，no write allocate。
: {* [( Q3 r2 c6 I- t
6 K! b( s: k$ {D3 SRAM4的MPU属性：
. ^4 G/ D! [) B2 x' c% X7 z
Write through, read allocate，no write allocate。

+ v' Q7 ?+ ?. z; E4 ^

1. /*
   8 O# S4 j4 Y2 p/ {
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
     o4 u* h6 H9 Z( m  B! T
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   - s# }$ ]( [( S; y5 j3 i
10. {
    1 `/ l7 A, W4 n5 e! w4 O/ D6 Z
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    / ~, T" M  \3 p2 k/ k. r( D
12. 
    4 o$ j/ k2 Q4 v8 a; u5 @- j
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    9 k) b# N) w3 S
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    7 p; V" G: b( N: X
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    % y8 o! b( n& o7 w$ n4 k( A# V( }
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ( H6 o2 h/ |. ?: e- @+ M
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    * t$ f8 J0 g' U2 _$ g: j) a& H! X
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    % ]) s% F+ C1 e+ y5 R9 k- p
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    0 H* h# F# j6 |9 G" E2 ^
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    % u0 N7 J7 Z9 I4 H7 ?- N6 m* G4 l" ?
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    * L$ D- F/ r' b" }( _
28. 
    ! ?6 F" v3 h  V3 [/ B. U
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    $ g) G' O/ n. G
30.         
    
31.         
    ( m' `, T  d: f3 ?4 C8 g
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    , n$ m0 K2 s) y
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    . R* O, l! e, Y$ j5 t' \% ~
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    , \% \# B! v& j  l* {4 p
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
      d" j9 c1 b( r' L
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    ! b. `, L$ V: o' ~8 n
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    & A7 I- b# _  T) a9 `6 g+ U; l
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    : m5 {2 g: h# D( f; k$ y
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    / t9 I! v0 ?1 s4 h8 T* p" X, {
46.         
    
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    $ d1 V( h1 F" p$ P/ S; w  Q! z
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    ; c! w$ Q8 ^8 e# D1 R
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    0 q  x; _$ O0 J) n: I: t! t0 b. J
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    2 K5 Y; w- k- }; K/ c
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ! D- C% t* l/ W/ \$ U
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    % H. B) o) B+ h8 A) T
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    / H" }) u) k0 q/ l' {. A) s" z
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    , O6 }4 k# p+ J  M+ B
61.         
    * {  c9 S8 U% q& s4 M
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    " J# O  x  W# ?$ e+ ]6 _' O
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    7 T  E2 r& a3 S2 ?+ {
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    ; u& N. J  @  A, w! J
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    + s! b& @5 j: S
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
74. 
    1 _5 R0 B/ l( S# D, h3 h3 d" @. V
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    - r% w- E6 K& @3 I! x7 E
76. 
    
77. 
    ! C* Q8 p  I: @- m: {
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    % k% q5 o. M4 B  k: M- ]
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    4 c. V7 A- v2 Q, M
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    / `& m" H8 s% l- y8 ~, k: R
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    0 H. I+ H: T6 D6 f( k6 N! h& J3 h
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    0 n0 x1 O7 C, }0 a
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    0 w( v$ W  v- W9 R
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    4 i$ [% d& `9 g' v+ N  k  I# d
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
90. 
    & D" K: D" H+ R$ g; K+ x- ]: l
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
92.         
    
93.         
    3 p$ t( v& V9 ^  A2 m) N: K* B2 u) t
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    ' h- w3 T  G; {) O
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    # }# t( i2 F% m# r
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    : h5 v$ x: b' ^8 J4 e6 b
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    & W. ], H: r, G4 a, A) _% B
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    $ F; V& S( A0 J: v2 r/ R6 y8 V" O) j
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     2 w7 p8 Y+ p% |1 b! @
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     8 k$ n4 g5 q- V  c" k% z
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     7 O) F5 o/ S% W4 n# }
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
       q( j( X0 Y8 N3 ^& N! N; f
108.         
     + |2 f6 S$ m! |
109.         /*使能 MPU */
       w2 I% G7 B( E4 E) L4 e# j- i' i6 c; u
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     
111. }
     
112. 
     6 h; O7 D% @. R9 V8 \
113. /*
     
114. *********************************************************************************************************
     % l' ]6 m5 U8 ~# g9 n+ X9 J) ~& |
115. *        函 数 名: CPU_CACHE_Enable
     ; l! N! I6 a; G7 u& V7 P9 b; ^8 o
116. *        功能说明: 使能L1 Cache
     
117. *        形    参: 无
     
118. *        返 回 值: 无
     
119. *********************************************************************************************************
     4 O3 j: z6 P- }  ]" V7 m# G
120. */
     
121. static void CPU_CACHE_Enable(void)
     " ?5 P) k9 W' p' f& L. T+ K6 l
122. {
     . f! Y  |7 s4 l% s# e
123.         /* 使能 I-Cache */
     ; Q% H0 W0 ]; V
124.         SCB_EnableICache();
     4 m# c2 ]; j- s! W* Q; j8 G
125. 
     # Q+ a0 S, @0 z% w
126.         /* 使能 D-Cache */
     
127.         SCB_EnableDCache();
     
128. }

复制代码

  z% H. [& H% k/ P2 \, O$ \1 _  主功能：
6 ^; H& k7 u2 w  N
* ^5 m* N3 i: `1 w5 J$ b; ~主程序实现如下操作：

  启动自动重装软件定时器0，每100ms翻转一次LED2。
  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
: e1 t! K% r, [  K1键松开，释放从DTCM申请的空间。
  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
  K2键松开，释放从AXI SRAM申请的空间。
: E1 E5 T( N2 S; l: ]4 |8 P/ H! |  o  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
/ v  V2 i: f0 F9 l9 F$ C  K3键松开，释放从D2域SRAM申请的空间。
  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
/ @" i1 |# Q8 l: ^7 S4 V  摇杆OK键松开，释放从D3域SRAM申请的空间。
+ _* f' o) \( n/ j5 d. n/ ]

1. /*
   
2. *********************************************************************************************************
   # o: u) V: w9 j! L8 A
3. *        函 数 名: main
   3 m! F9 ~5 K2 u4 t. n
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   * {  X1 ~1 ^' ]& [0 C
6. *        返 回 值: 错误代码(无需处理)
   - ~8 G* n6 T; k' }
7. *********************************************************************************************************
   
8. */
   1 n8 l3 c$ S$ r- h7 @
9. int main(void)
   
10. {
    * C: W; {; ?! j6 q: n2 G* v4 B. f
11.         uint8_t ucKeyCode;                /* 按键代码 */
    6 E* `# C  O: V: p
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    
13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
    
14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
    
15. 
    
16. 
    
17.         bsp_Init();                /* 硬件初始化 */
    + E2 s9 c  @& c3 a( Q2 X
18.         
      l5 U5 Y" ^+ ]4 i
19.         /* 初始化动态内存空间 */
    0 w; H* H8 J; e6 u0 o
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    8 J) R) W; Z9 w2 h- D, v
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    
24.         
    ( i1 \% _7 q9 S3 k' B/ P
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
26.         PrintfHelp();        /* 打印操作提示 */
    3 `6 X* i/ |+ d* {+ p: q8 R% ^
27. 
    
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    0 V) R" L% e/ w( {
29.         
    
30. 
    
31.         /* 进入主程序循环体 */
    8 o: J* c7 b" g4 ~: X
32.         while (1)
    
33.         {
    $ m( C) [; ^, g6 w
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    8 B1 ~( Y, U! h
35. 
    3 w! W: \: O+ Y4 e8 C! q) p
36.                 /* 判断定时器超时时间 */
    7 k- y" D" K' {  g" g% I+ j
37.                 if (bsp_CheckTimer(0))        
    
38.                 {
    1 R1 L* W7 @2 B6 r: T' Q! X  \
39.                         /* 每隔100ms 进来一次 */  
    
40.                         bsp_LedToggle(2);
    
41.                 }
    ( L+ ?6 g6 v* B0 \' ~
42. 
    6 Y2 n, I6 k! {  X( W' |
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    3 J- V+ Z4 h8 R8 J/ n
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    # P9 T9 j, D" r3 L: R
45.                 if (ucKeyCode != KEY_NONE)
    
46.                 {
    1 h) }$ j; @$ Y1 B4 k. X, V! d+ Q
47.                         switch (ucKeyCode)
    + j4 O2 Q9 T  c  C* M5 K
48.                         {
    
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    4 {0 P% D& ]5 d6 }6 p4 d
50.                                 case KEY_DOWN_K1:        
    
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    , I% J/ r" h9 m
52.                                         printf("=========================================================\r\n");
    ' \) F4 ~& U6 M. a, \
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    2 c; H6 a' A8 |3 \$ F4 ~- j) e
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
57.                                 
    
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    : p4 d! i& ?5 o
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    ' n& P" j" ^, V% A) L
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    ' L7 ?7 Q9 L7 y5 F# N! a
63.                                 
    
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    1 y$ u6 P9 W% ~" H3 R" h  [
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    + o9 v5 f9 B  e6 Y+ S
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    $ \0 }1 b/ X( i3 \! ?
69.                                         break;
    , O; S$ Y  ]' |; h
70.                                 
    
71.                                 /* 释放从DTCM申请的空间 */
    
72.                                 case KEY_UP_K1:        
    
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    9 A) g, D; R- v5 M0 S6 W
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    ' U9 j2 l: P) E/ r
77. DTCMUsed->used);
    
78.                                 
    
79.                                         /* 释放从DTCM申请的64字节空间 */
    0 U: W4 Q% c/ F$ T- R
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    2 D% z! a9 U+ [( Y/ B
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    & K; V0 Y) g0 X# Z+ j
83. DTCMUsed->used);
    0 ], L/ @- D3 a4 F; ~
84.                                 
      V7 B0 o2 A3 g; t* ~
85.                                         /* 释放从DTCM申请的6111字节空间 */
    0 L) D$ r, \9 J6 v- y) q
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    $ k' _- Y+ v; U4 e6 `' \; P2 E, G
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    - O8 j9 N2 {% j+ b8 a/ l# h( [3 q
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    
89. DTCMUsed->used);
    
90.                                         break;
    
91.                                 
    
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    - N8 @( m; X2 C: e& F
93.                                 case KEY_DOWN_K2:        
    - ^" o  x5 E/ M/ c" o/ |" J2 S
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    
95.                                         printf("=========================================================\r\n");               
    
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    : _2 l0 o' Y" u% Z8 X4 K6 K" ]
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    3 y: O+ |( y8 o3 G) M6 t$ h
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    
100.                                 
     
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     ; H; ?  {7 b1 e# n2 p
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     & ?/ Y' r, X+ m: I! X. |; K
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     5 E7 \2 [4 K! b# a: T9 ^, N
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     " X, \0 r4 j+ A2 q! G/ w: Z
106.                                 
     
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     5 c9 i. U% }! o6 t: B- D  i+ A
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     & i& s2 f0 U* O! w6 g& A+ M
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     7 ]: [3 [+ v( h( h
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     
112.                                         break;
     ! ?! _' k: y, L/ e
113.                                 
     
114.                                 /* 释放从AXI SRAM申请的空间 */
       J! [$ w- C, M+ u
115.                                 case KEY_UP_K2:        
     # S- s, V! U: K8 n
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     ; e, J2 ^( `3 B: c- h' S+ Z
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     : u, p% G" K; B5 ]& Q  l8 G; I
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     / ?# ?1 @+ _- H1 z
120. AXISRAMUsed->used);
     0 C1 P5 l. d( l: e% E  g9 \4 Y' i2 ^
121.                                 
     
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     + s. K3 ~( M+ T$ p2 D5 {) |
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     ; p# a& o, B, M# J6 {4 T4 e
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     $ k- b/ E. s: ?
126. AXISRAMUsed->used);
     
127.                                 
     9 z) |- H$ \4 Q% x
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     " [& E- `4 V2 l2 e. N3 m
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     
132. AXISRAMUsed->used);
     $ F* H4 {- @: k# i- F0 Q: E, F
133.                                         break;
     
134.                                 
     9 n8 _) _1 T5 }
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     , `7 Y/ j& ~1 \/ R& K- i
136.                                 case KEY_DOWN_K3:        
     5 n3 ^  p+ d* F2 W1 H0 p  B, I
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     8 \6 ?2 l, {) X. e8 _# G7 R. }
138.                                         printf("=========================================================\r\n");               
     
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     , D6 z0 x. Z4 }/ Y; \* d, B
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     % B5 b; i* W. r) C; ]7 ?
143.                                 
     
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     1 N5 t0 O  u  s. B, s
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     6 A0 y- s. ^! v; |8 }2 M
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     4 ]; e7 v7 @! c5 \. l
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     : G2 U& Z: J! X
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     
149.                                 
     
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     ) N9 [; x0 H# N  A  i# t
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     - F3 F+ R! D% r+ k3 I0 y
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     ' c% t4 U7 k! M* ?5 d6 @4 P
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
155.                                         break;
     % U/ v1 T% ], i3 P) L$ R
156.                                 
     ! o4 m# _# w5 z$ C' P
157.                                 /* 释放从D2域SRAM申请的空间 */
     
158.                                 case KEY_UP_K3:        
     3 ~/ }2 a) {9 K8 K4 `5 {+ `8 `
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     2 X$ D( f& s6 Z$ S6 @. ~
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     1 y8 V, O# ^  p7 U
163. SRAM1Used->used);
     
164.                                 
     - j7 I/ Y# k- |9 B4 ]/ q9 o
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     % S- }' Y7 \7 |& h! _
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     3 E7 ?* Z& n. z0 k2 R
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     & g0 u/ f$ g0 b! K* c$ [2 r
169. SRAM1Used->used);
     
170.                                 
     2 f1 {5 f9 N1 u3 B
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     8 R+ ^2 [( L" R+ G8 m8 ^9 _. U  {
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     
175. SRAM1Used->used);
     
176.                                         break;
     ( e% i, ~0 L1 j% j: \! s
177.                                 
     3 Y1 a+ Z6 m! q. x/ W: F. y  a
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     * @2 }. _5 o+ i1 d
179.                                 case JOY_DOWN_OK:        
     " r: u) q7 ?) N
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     5 m! O: A( F9 g/ c( s
181.                                         printf("=========================================================\r\n");               
     3 a0 D, Z( \/ Y9 I0 ?& |2 M
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     $ P* k8 q0 p, q
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ! ~8 i9 f/ H& s( q0 ?1 U4 K
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     $ y+ X  L2 ?% s3 a% _
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
186.                                 
     
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     0 P+ n5 ^8 w. e" E3 v& G8 F: z& ~
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     $ R/ u( w0 }# O4 S. t- G6 c
192.                                 
     
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     ( c4 _/ {$ ?1 a' Z
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     6 ^! s! H: f1 O3 |- B
198.                                         break;
     ; H( U$ p  d% C4 X8 c+ D$ N
199.                                 
     9 x! h8 h% }2 S
200.                                 /* 释放从D3域SRAM申请的空间 */
     
201.                                 case JOY_UP_OK:        
     / q2 p, V2 ~# G
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     2 w1 Z! p1 Q* x6 n2 i
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     
206. SRAM4Used->used);
     
207.                                 
     ; j6 n; ^3 g* B- R" a
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     & ~9 ^8 j6 ~# K) x, Z. b5 Z
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     4 R! Q' R* c9 K% o
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
       _4 x6 y+ u8 N0 m: }- }
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     
212. SRAM4Used->used);
     
213.                                 
     
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     - @% X- x% H3 v' a5 u7 s5 R
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     
218. SRAM4Used->used);
     ( y! C' C( J& c/ P
219.                                         break;
     0 J- W! T0 |% X2 S: H) b% {) X
220.                         
     - r) t+ C2 U% w: v% O
221.                                 default:
     3 E" i. O6 b4 G* h1 U6 m
222.                                   /* 其它的键值不处理 */
     ! n6 [5 u1 i. Q: K. L* t9 D, ]
223.                                   break;
     9 h0 b+ Y! S( h$ P; _: q
224.                         }
     
225.                 }
     ! S7 G) K" I5 `5 A* g
226.         }
     
227. }

复制代码

. s. Q" k  d5 r7 i5 E/ J27.5 实验例程说明（IAR）
配套例子：
9 ]  t3 ~& I; [- `2 N& M. i8 |V7-006_TCM，SRAM等五块内存的动态内存分配实现

# s# q9 s/ v/ U( l6 a实验目的：
学习TCM，SRAM等五块内存的动态内存分配实现。


实验内容：
启动自动重装软件定时器0，每100ms翻转一次LED2。

6 _; ~' ?; H/ Q  V7 `' l# z  m实验操作：
$ n& Z1 _  O+ z3 PK1键按下，从DTCM依次申请280字节，64字节和6111字节。
, Q, ]6 o$ n: s) j8 d# c6 cK1键松开，释放从DTCM申请的空间。
* x8 x! ?6 W7 ^+ b! N# l6 ZK2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
+ [% ~5 n) |! Z7 @1 OK2键松开，释放从AXI SRAM申请的空间。
K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
K3键松开，释放从D2域SRAM申请的空间。
. p/ `; r9 e  h$ t摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
. g* y  A/ c' ]1 h% @: z' ?3 p# b! N" b摇杆OK键松开，释放从D3域SRAM申请的空间。

上电后串口打印的信息：

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

2 V( |! W0 c* T2 A4 l7 H# \

3 }2 ?; D9 N4 x' U
5 k7 [3 f& a" O2 T8 u程序设计：
, [0 C) S# g+ S& {  K& P) e
% \5 s# [9 X5 k- p) T$ ^. R  Q; O  系统栈大小分配：

9 y- I% U' Q4 l6 f  V% B  RAM空间用的DTCM：
5 T2 g: z# o3 A# W  E: m
2 d% j9 L. G6 b( T  a' W! m3 _

. c% a) g# A$ A& g* L  硬件外设初始化

# v, S" \# Q- H4 c/ Z硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   
2. *********************************************************************************************************
   9 l4 j7 c" z6 e6 X! i
3. *        函 数 名: bsp_Init
   * b9 I  w: _5 [" H: ~1 @
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   ( v  O6 i; i, k& m- `
5. *        形    参：无
   
6. *        返 回 值: 无
   5 U% c8 _0 r5 g2 t) t( h6 k% {/ Z
7. *********************************************************************************************************
   2 q3 D0 z6 p( {! c5 d9 q0 M) {0 m
8. */
   & x/ @/ P' b. R1 t
9. void bsp_Init(void)
   % j8 f7 a3 \! |" o7 @9 ^6 j$ m
10. {
    ' y2 y, B" h- N* E
11.     /* 配置MPU */
    7 @* ?+ K  ^- j9 P* K1 B
12.         MPU_Config();
      z/ J* b. Z" q. J+ K& G; V/ E7 p4 y
13.         
    9 Y) }7 C' n( _
14.         /* 使能L1 Cache */
    % ]  o+ {& o6 P" `2 Y
15.         CPU_CACHE_Enable();
    
16. 
    
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    1 w  c- C7 c# _9 Q5 s  b
23. 
    
24.         /*
    , k/ e' ?. f# |. n2 B  T
25.        配置系统时钟到400MHz
    ! L: u( H% s6 B* k: e/ A. \
26.        - 切换使用HSE。
    . m' i2 v$ a/ L2 h3 u$ {- g, d, s" d
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    5 N8 N- g* P! p- J. t; c" h
29.         SystemClock_Config();
    ( `+ w- K- e5 `8 ^
30. 
    6 a4 \# F9 T! B
31.         /*
    
32.            Event Recorder：
    2 d0 l5 m, c3 `
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    ; t! T9 D$ O2 k2 M% Q. D+ j5 o9 R
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    ! p6 Y: ?( I0 A7 \" g4 G* h
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    * o* U& V; g, p9 }  ?8 t
39.         EventRecorderStart();
    " ~  W& }8 X! C  m) R
40. #endif
    ) T* `4 Z) K1 I; G0 p$ S7 @+ T
41.         
    * J+ ^0 Z8 W+ T  @5 I& J
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    2 C) W) j+ C9 ~4 [/ y+ t
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

2 v" R1 c+ {' |! Z2 Y  MPU配置和Cache配置：

数据Cache和指令Cache都开启。

9 h5 ^5 Q4 n0 L( }4 z  J/ O4 MAXI SRAM的MPU属性：

Write back, Read allocate，Write allocate。

FMC的扩展IO的MPU属性：
; E1 ~; {7 C) _" D6 T$ n
7 S+ `# {: `% l8 B+ g  A必须Device或者Strongly Ordered。

D2 SRAM1，SRAM2和SRAM3的MPU属性：
' y/ Y$ v  N( g+ l2 w4 d! g
Write through, read allocate，no write allocate。

* \; t  L7 P& W. R- G" YD3 SRAM4的MPU属性：

$ w8 M% Q) u# LWrite through, read allocate，no write allocate。
$ d  g& g. S5 G/ j9 J% @+ t" V

1. /*
   
2. *********************************************************************************************************
   7 o0 P1 h* Z' |3 b
3. *        函 数 名: MPU_Config
   ; W/ \* ^- y8 ]1 g  }
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   7 M% Z  k! D: x) k- o  Q- t! Q
7. *********************************************************************************************************
   
8. */
   1 Z: N3 ]4 ^2 `& W1 A8 ^
9. static void MPU_Config( void )
   - O: B; d8 O1 n: w+ [7 ~5 J* Z
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
      P* q$ D( @% H/ e
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    " m4 T" Z5 {' ]1 z4 P% @# }' t; U
15. 
    . d1 M" t) T- G/ F0 h
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    # `. D4 C, r4 R2 }& D. P3 y; ^
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    ( i+ V. x, @7 }  Q) d  [, }
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    5 S" a# X3 `5 }
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    % F! @6 H+ ?8 G% ~( n8 R  \
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ( E+ b5 C- p5 R+ W# h1 e
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    , D& k, i, b1 s
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    0 z0 w( P/ s! r( d% F9 }
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    , v  o4 F, F2 X+ N* r( y4 C
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    . X$ n" X) A' i0 o( M/ c
30.         
    
31.         
    * l* F- u$ x% b2 o4 q* P
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ; ^& Y9 Y6 a/ h
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    - V) _# u& l8 `) T- {  F
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    ; {/ S5 K: J  ?6 d( G+ X/ h$ A7 B8 ]
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    + |/ H9 L$ ?  z' _2 }$ U# A
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    % D2 r2 t4 ~/ o& k% L$ j/ O6 g
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    . a6 f& [1 |  d4 J
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    1 X2 }2 K" X; J9 ?7 N  }1 g
44.         
    4 ^# `7 h' u: q, j# e+ q5 o: A; G. G1 U
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    2 }0 q( r( u! X* b3 Q
46.         
    : V3 F% c! h$ x" A
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    ( V2 h% m* J' r7 z* O5 X
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ( v7 |/ [, f3 s' }* {# Y: W
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    0 t4 q$ I" X; s5 C0 R
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    9 b) B2 `: T, w  h
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    & t! S) {/ d4 |( a
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ; G7 J  A1 t0 L' h
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61.         
    5 k/ t  E1 ]* ^$ h3 o2 G( x9 t" C% V
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
      G- v  P/ L+ @) x* |' I
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    * w5 m* O' M0 u) c- w5 T' T
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    + r9 Q0 \, F% T/ E$ a* J
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;
    
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    , l9 Q. J8 O6 G) R
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    " H8 G+ s: @* J$ E
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
74. 
    $ y; i! g& w& q# N: c7 O
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
76. 
    
77. 
    
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    " |$ m5 @5 Q% d
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    ! d8 b9 G/ P; E4 d
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    $ ?, e0 S5 |7 C3 D* v/ Z5 D
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    : D6 s6 w* h6 O+ A4 y0 q0 }$ i/ P
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    + \0 Y  E& M1 P  r0 i' e8 G
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    2 ]# f* e3 Y; {8 J. A" C: S
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    & ^9 [0 I* c5 P
90. 
    . E! y) B) Y+ U0 a
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    - w' p+ U  w" G6 i; z
92.         
    
93.         
    
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    & q9 j; C5 g! A8 ^' _5 X
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    8 G) s. U; y) c: H4 b  Y  Z
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    * z0 f6 T, ~! w9 I
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    , w5 o- r4 ~2 Y7 E; B) A6 I% o
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
       O3 g) G! i# X1 ?5 D
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     - F; u% r( y/ P5 `: a; {
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     % Y2 b- T" e6 S, x- K
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     
108.         
     / T8 {8 o# i, N. }& G
109.         /*使能 MPU */
     
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
       z+ Q: P& C; `0 b9 R
111. }
     
112. 
     : I: X. Y% F2 p* H
113. /*
     
114. *********************************************************************************************************
     4 o( m9 \/ x/ S: k- j8 U( }
115. *        函 数 名: CPU_CACHE_Enable
     
116. *        功能说明: 使能L1 Cache
     . g4 s! D- `/ _; m
117. *        形    参: 无
     
118. *        返 回 值: 无
     
119. *********************************************************************************************************
     
120. */
     ; q6 i: @6 e! S. I% w- `
121. static void CPU_CACHE_Enable(void)
     
122. {
     9 U, j& T9 [5 {5 d8 V- T. _
123.         /* 使能 I-Cache */
     6 }9 r: f0 @- e/ s2 Z
124.         SCB_EnableICache();
     
125. 
     * w" ^1 T" _" y+ E
126.         /* 使能 D-Cache */
     4 l, y8 n0 c1 f' D# N, r
127.         SCB_EnableDCache();
     0 u) o# Y4 ]4 b2 U2 u: d
128. }

复制代码

  主功能：
" q3 g( s9 M6 T1 M! t. O# c% H' Q
主程序实现如下操作：
2 k% B: c3 B" X; m/ w5 k( X4 T$ |/ @) B
% f1 w9 B  H7 b3 M1 p1 {8 y  启动自动重装软件定时器0，每100ms翻转一次LED2。
4 v; o6 n! B( n$ L7 u" C  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
0 i5 ^" x) m4 s- v$ k% f, J% {  K1键松开，释放从DTCM申请的空间。
- ^) f. o0 D8 Z6 `- i  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
  K2键松开，释放从AXI SRAM申请的空间。
  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
  K3键松开，释放从D2域SRAM申请的空间。
: J+ B0 l/ D, K  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
! y( y& I9 N* C, H6 J  摇杆OK键松开，释放从D3域SRAM申请的空间。
! n$ t4 }) ]2 o$ |  [. J! g& Y

1. /*
   
2. *********************************************************************************************************
   - X- b9 G& |" }3 b
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   3 @/ u% n4 {6 t2 o! f9 M: |* |& |7 d
5. *        形    参: 无
   , n. b# W3 n5 x. @6 ?3 S
6. *        返 回 值: 错误代码(无需处理)
   4 _5 H4 s5 A. b
7. *********************************************************************************************************
   
8. */
   7 h5 T  J( D4 l8 b
9. int main(void)
   8 s6 ^7 G, i- U3 l0 ?& h
10. {
    ) l" |& x: N. }2 T
11.         uint8_t ucKeyCode;                /* 按键代码 */
    9 {- C  o( W, t* w, R
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    & y7 j8 M7 O8 e2 ?8 n
13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
    ; j1 b! Z0 Z& S4 }9 a
14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
    
15. 
    
16. 
    
17.         bsp_Init();                /* 硬件初始化 */
    6 ~. G# j( o  e+ o8 d- @8 `7 r
18.         
    
19.         /* 初始化动态内存空间 */
    
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    + Y5 q) A  d4 Q$ L% v0 G- ~+ {
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    
24.         
    $ ]* ~7 J/ g1 F! }+ c. D1 U
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    7 [7 ?8 A! x" L: d. p6 u+ `
26.         PrintfHelp();        /* 打印操作提示 */
    
27. 
    " r5 \/ d% f/ U4 j
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    ' z. x4 E2 D5 H& f& d! V
29.         
    
30. 
    3 G3 Z. m3 Z. \, m
31.         /* 进入主程序循环体 */
    
32.         while (1)
    
33.         {
    
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    ' }' e1 y4 K2 d) P! ], G
35. 
    
36.                 /* 判断定时器超时时间 */
    ) v  ?! }" S4 R1 P9 S0 T
37.                 if (bsp_CheckTimer(0))        
    
38.                 {
    
39.                         /* 每隔100ms 进来一次 */  
    3 W. j0 J( \$ c7 S' ~
40.                         bsp_LedToggle(2);
    
41.                 }
    
42. 
    0 f1 J9 D! L2 I
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
45.                 if (ucKeyCode != KEY_NONE)
    
46.                 {
    7 K$ s0 e: y# P4 S: Y: |; L
47.                         switch (ucKeyCode)
    
48.                         {
    9 S# u! }/ z  q4 i4 h+ a. p/ f$ y
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    - f. x$ {2 w: M
50.                                 case KEY_DOWN_K1:        
    
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    8 m  K2 O! a* n% K$ q; l9 t. O& w
52.                                         printf("=========================================================\r\n");
    ' j. P; a+ t, S8 S# C. Q
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
57.                                 
    
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",
    # n; q8 z+ F5 o1 K1 m
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    
63.                                 
    ( a/ ^! b* `* o& O- Z" d1 u
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
      b; ~$ v6 G! N, M
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    4 d0 m, M* t- L( j5 ?" T4 T
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
69.                                         break;
    
70.                                 
    + S# {7 g" Z; M- b8 F
71.                                 /* 释放从DTCM申请的空间 */
    4 B9 ?( n1 u6 ~( B1 [. n9 Q
72.                                 case KEY_UP_K1:        
    
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    - @. S( J' q) \- s3 W2 @" i& U3 R
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    
77. DTCMUsed->used);
    
78.                                 
    
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    " A# b# @7 I/ p; s  w
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    
83. DTCMUsed->used);
    
84.                                 
    
85.                                         /* 释放从DTCM申请的6111字节空间 */
    1 F2 s8 j- d, J% J  l
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    ; v$ A/ V+ z- C
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    4 v' }4 o# N- L: C, p) n
89. DTCMUsed->used);
    
90.                                         break;
    " Z$ W3 p" Z/ ]$ s6 S8 c: F1 U
91.                                 
    
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    3 G) Q9 Q+ E& Q+ _2 Y
93.                                 case KEY_DOWN_K2:        
    
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    
95.                                         printf("=========================================================\r\n");               
    # B* t. {( w  p* V
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    - y* `/ ]4 U0 W% E' j
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    : L$ P+ U8 ~9 n" j6 [
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    + w4 T; Y  K7 @/ D; N1 P( q3 h
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    # h' i  w) e% e4 z7 L  e
100.                                 
     
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     ( y# @# ~! U! p2 D3 B2 _7 Q
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     ! r$ V8 x) A& m6 v1 h7 H
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     * M  m( S, a5 |( y
106.                                 
     
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     # @0 t) H- M2 O, @: v
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     * |# h$ ?6 I( X& _+ q5 w
112.                                         break;
     
113.                                 
     
114.                                 /* 释放从AXI SRAM申请的空间 */
     ) z+ X+ u  M  c! c7 w
115.                                 case KEY_UP_K2:        
     
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     ; m& l, e. L) T8 s' s2 U
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     0 t$ @6 z. D- _" |/ {+ g  N: Z9 [
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     ; d+ U' r- h" i9 v) z/ V
120. AXISRAMUsed->used);
     
121.                                 
     
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     4 h" r$ O* F7 Y  L# a; Y
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     , ^9 f0 l) P* S) z" X' P2 T& c
126. AXISRAMUsed->used);
     & |! |' o$ E4 {
127.                                 
     7 y1 X, u% H4 _& ^% S
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     ; x* {9 H, X9 |" W
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     ) h. _5 o  W; `+ D' W% D% l% t
132. AXISRAMUsed->used);
     
133.                                         break;
     ( D7 P9 N- h, z2 ~- o
134.                                 
     3 ]+ q- M) e9 p  \$ l" D
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     
136.                                 case KEY_DOWN_K3:        
     
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     
138.                                         printf("=========================================================\r\n");               
     
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     , L3 \, {! K5 @+ G% ]$ [
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     0 S4 ]/ \2 r( }" C/ c5 g7 J
143.                                 
     
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     3 N- n/ c7 x, t9 Y: e- z1 F3 M
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     ; }' k+ m3 q$ L* Q7 U5 d
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     - u6 s0 K7 M& F1 I
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     
149.                                 
     . e% R6 A- g% _1 c: i3 ?3 c$ O
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     0 |2 O) b* V, R+ q7 k
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     % K8 [6 B8 E  x) K5 e+ Y6 @$ A
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
155.                                         break;
     # s: G3 I3 O7 x
156.                                 
     
157.                                 /* 释放从D2域SRAM申请的空间 */
     
158.                                 case KEY_UP_K3:        
     
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     , U; J1 t* N! R& t' f
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     7 q/ F0 T7 t# C/ c7 l. F0 J2 P2 o2 a
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     + j2 ^& i$ z1 t0 ~* n3 D
163. SRAM1Used->used);
     : n7 n) Z5 W# R; E6 R: ?
164.                                 
     ( V0 o) P2 z/ F/ N& A5 Q& d
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     . l0 q2 r0 W# G0 I7 D5 t5 N
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     " D; [1 T% R+ [9 D4 o
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     
169. SRAM1Used->used);
     
170.                                 
     
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     " d( b! y! }8 L: C( g
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     5 G- W5 U# E9 z
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     * ~  U" m/ ]7 _5 e- u  }/ d  [
175. SRAM1Used->used);
     
176.                                         break;
     ! r7 N4 b3 j$ ?- V# q  `
177.                                 
     1 i( r6 Y+ Y* X, i* d  D
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     $ V( C* N! R/ \
179.                                 case JOY_DOWN_OK:        
     * P/ C3 g1 p; x* M/ P  P. [
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     
181.                                         printf("=========================================================\r\n");               
     / F, Q& }- Z) N1 k% y: m
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     8 p8 q2 z3 k* B+ X7 q% p6 F3 {9 M
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     3 l; L* c) n0 X# a
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     6 q/ |: C$ y6 g, d& p' P3 r8 i/ S
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
186.                                 
     
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     ) V% f3 C- l+ ~2 k3 ^9 M+ l* W& j
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     7 \4 V1 @& _; u, M
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     
192.                                 
     3 }  s' \  Y+ W* k2 X9 {. \
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     9 o4 b# P6 u' q) E3 T6 a
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     6 @' F! w' E" |: y/ M' `/ s1 d
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
198.                                         break;
     
199.                                 
     
200.                                 /* 释放从D3域SRAM申请的空间 */
     : j1 y, q% |, C: L8 B& p
201.                                 case JOY_UP_OK:        
     
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     : a; N3 R* ~* l1 X4 \9 b) r% Q- K! h
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     
206. SRAM4Used->used);
     
207.                                 
     " i# u; T: J/ f3 C" E
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     / ]6 k9 S- j% C" z. {
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     
212. SRAM4Used->used);
     
213.                                 
     . ~" f4 d% N  S3 B
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     # a0 H1 P. P- ~- p$ I, s% {
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     
218. SRAM4Used->used);
     
219.                                         break;
       f& r9 s  u) C% F  x2 o# E# C- s
220.                         
     
221.                                 default:
     
222.                                   /* 其它的键值不处理 */
     
223.                                   break;
     5 M# S( e$ K; L! z; ^
224.                         }
     & e' m, I5 C" {1 R' x( A6 |7 q
225.                 }
     
226.         }
     
227. }

复制代码

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