27.1 初学者重要提示
  学习本章节前，务必优先学习了解TCM，SRAM等五块内存区的基础知识，比较重要。
  将RTX5系统的动态内存管理整理了出来，可以同时管理多个分区。如果其它RTOS中使用，记得做互斥保护或者加个调度锁均可。
3 R& k, f. A8 K' B5 `  支持动态内存使用情况统计。
  y. {% x$ o$ a/ @0 y27.2 动态内存管理移植
移植比较简单，仅需添加两个文件到工程即可。

: m0 u2 X" h, `0 y' X/ S- \7 y. t27.2.1 MDK版的移植
& L2 N3 ~/ a4 K- C  第1步，添加如下两个文件到MDK中
注，以本章配套例子为例，这两个文件的路径\User\malloc。

! |: T, G4 Q  A  I$ Q

3 v# X  y) _  f  m4 A
4 m; `, |0 I( p: Y: [  第2步，添加路径。
1 P8 u- @9 V; ^/ I2 ^
5 N8 C8 z0 ~1 J/ i% K  D

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

/ Q* T6 I0 R, x  {1 W  A通过这简单的三步就完成了MDK的移植。
" T6 T4 [1 }5 o8 M- C. U8 I8 ?
0 M# R$ h( F, x1 D( B27.2.2 IAR版的移植
+ u8 O4 u, b7 v4 \0 S  第1步，添加如下两个文件到IAR中
. n% W' n' O4 O' A4 `2 F注，以本章配套例子为例，这两个文件的路径\User\malloc。
/ V3 e4 N( B1 c7 A# j$ ]' H: E9 _
6 F! o: [# N6 _

/ f/ `/ `* i; K% k3 x* R
3 _- J5 i; z0 l+ y& f( M4 y  第2步，添加路径。
+ |4 l% G7 g) c7 M  S* z3 p6 \' `0 u

6 d) S! |* J' D* F
0 y6 E- R, A7 z! }  第3步，添加头文件。
7 G! T6 k$ Y$ T9 @0 ?5 T6 o2 k如果哪个源文件要用到动态内存，包含rtx_lib.h即可，本章配套例子是直接将其放在了bsp.h文件里面，哪个源文件要用到动态内存，直接包含bsp.h头文件即可。

通过这简单的三步就完成了IAR的移植。
" L2 `" W# l8 d9 I5 _8 M2 u% R' c
27.3 动态内存的使用方法
/ |# L$ X! w- H/ U& Y" A下面分别以MDK和IAR为例进行说明：

27.3.1 MDK上的动态内存用法
# C9 c7 K0 U/ v4 v  定义动态内存区
比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：

1. /* DTCM, 64KB */
   
2. /* 用于获取当前使用的空间大小 */
   - g0 S( T% _: ?0 J2 h% K/ u
3. mem_head_t *DTCMUsed;
   + [: u6 g$ H* \4 K. s
4. /* 定义为64位变量，首地址是8字节对齐 */            
   0 z0 {- S3 q% A9 i1 O
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

1 B; _1 f. ?4 g  v如果要使用AXI SRAM作为动态内存空间，可以使用__attribute__((at( )))指定地址。

# d* j# f3 }) c2 B* r( [1 C

1. /* D1域, AXI SRAM, 512KB */
   
2. /* 用于获取当前使用的空间大小 */
   
3. mem_head_t *AXISRAMUsed;  
   
4. /* 定义为64位变量，首地址是8字节对齐 */
   $ t8 }6 k$ n6 ~4 f
5. uint64_t AppMallocAXISRAM[512*1024/8]__attribute__((at(0x24000000)));

复制代码

+ ]! o  C& p; |2 c3 h5 s$ l6 f  初始化动态内存区
$ E& H, v# S& T7 S3 q调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：

% {" Z/ T# H2 t. I/ P3 a7 hosRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
7 `; w0 U- N3 X8 F2 G
- v' ~. C0 _/ g* H+ ]/ ^; @2 o: }" E  申请动态内存
: s% L: ^2 T: v通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。
; @6 A$ t/ q: F. K3 A
5 W$ D/ P, q0 h5 p8 {第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。

第2个参数填写申请的字节大小，单位字节。
5 Q& x( h! A  L1 Y1 ~0 V
第3个参数固定填0即可。

+ ^- m( f: t% @返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！
+ y/ [% N, u+ ?, D, l+ ~
举个例子：

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   
2. 
   
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   # H$ \3 Q8 ~% w4 I; j5 G1 u# {
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   ! y/ C" |5 u8 d7 g; K4 I- |
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   * L- B/ e! |. `4 }: t* W* U
7.                                                              DTCMUsed->size, DTCMUsed->used);
   
8. 
   6 s, a. D( f- u. F
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    ( O8 u6 O8 ^' U" F$ B
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

& T0 u' Q; a: X$ t0 a申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。
( i& F5 W% Z. A7 E8 d
  释放动态内存
# a0 b! I2 {: v# d6 z+ f通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。

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

8 Q. E! r- [0 \3 h第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。

6 X5 A( x' w! l9 S& j2 q返回值，返回1表示成功，返回0表示失败。

举个例子：

0 B+ `5 I: u7 d+ D

1. /* 释放从DTCM申请的280字节空间 */
   
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   5 `, ^" Z, z0 b$ _( P7 A
5. 
   ; L% M% T3 w- Z0 O/ A2 ]
6. /* 释放从AXI SRAM申请的160字节空间 */
   : D! [6 a0 X/ k
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   1 V' U1 Q! B; ]/ G  b$ `7 l
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used);

复制代码

27.3.2 IAR上的动态内存用法
# b. P% u0 C8 _% \1 K9 H8 E5 c注：IAR使用这个动态内存管理，仅在定义时跟MDK略有不同，其它地方是一样的。

4 E; h$ H& M! y( s: X  定义动态内存区
7 s. s6 i2 h& p+ ]% S3 O9 P, s! s; }比如当前的主RAM用的DTCM，我们就可以直接定义一块大的数组作为动态内存空间：
+ a  n+ U9 t4 j$ P5 \: s; N

1. /* DTCM, 64KB */
   3 _. O4 z- O8 N# n/ O
2. /* 用于获取当前使用的空间大小 */
   * {' j: D) k& e  C7 a( E1 ]2 g
3. mem_head_t *DTCMUsed;
   
4. /* 定义为64位变量，首地址是8字节对齐 */            
   ) z2 P" e( j( u8 D
5. uint64_t AppMallocDTCM[64*1024/8];

复制代码

" n! s6 M) e+ j* X: y- C1 g, d3 a如果要使用AXI SRAM作为动态内存空间，可以使用__attribute__((at( )))指定地址。
8 b& i: W: g3 G& {8 z3 v% [, T/ i

1. /* D1域, AXI SRAM, 512KB */
   1 _: A$ i8 h1 q1 n5 l0 p) p
2. /* 用于获取当前使用的空间大小 */
   " O/ Z: n) s/ u9 v
3. mem_head_t *AXISRAMUsed;  
   . Q) V; w5 G# j! b5 H: A
4. /* 指定下面数组的地址为0x24000000 */
   
5. #pragma location = 0x24000000
   # R. W4 Q* C5 u8 p7 ]  Q
6. uint64_t AppMallocAXISRAM[512*1024/8];

复制代码

  初始化动态内存区
调用动态内存管理提供的函数osRtxMemoryInit即可做初始化：

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

复制代码

  申请动态内存
% g7 F% d2 n$ B+ b% W( a- p2 r通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。

& |3 p6 b& P$ |& y% _( E第1个参数填写内存区首地址，比如申请的AppMallocDTCM，就填AppMallocDTCM即可。

第2个参数填写申请的字节大小，单位字节。
4 K% W* u  d: {: M1 Z
2 d5 N, d- _) h第3个参数固定填0即可。
+ [  g! L0 `5 y- D! M
+ U$ v& v9 X# X. p8 b返回值是所申请缓冲区的首地址，如果没有空间可用，将返回NULL，这点要特别注意！

举个例子：

1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;
   
2. 
   " M3 o1 Q% E2 c. K( r- }5 e
3. /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
   " }3 P7 ]6 n' n
4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
   
5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   9 C- k4 Q$ B3 J. m8 |3 h& u- h
6. printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
   & i7 M& w: y/ [8 A
7.                                                              DTCMUsed->size, DTCMUsed->used);
   
8. 
   
9. /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
   
10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    - u$ \4 b& C; O3 Y( X
11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    # l6 f) @& |+ q4 Q. y5 {
12. printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);

复制代码

申请了空间后，就可以直接使用了。另外注意红色字体部分，通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。
$ o% g, }! x/ l' F5 V5 E
  释放动态内存
7 A% W# m+ _4 K+ Z9 D) ?通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。

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

- o# d, x- ~$ U5 i第2个参数填写申请内存时所获取的内存区首地址，这里用于释放。

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

& Q# `! f  x$ w5 ~举个例子：
7 M6 ^9 U1 Z# o) W+ @

1. /* 释放从DTCM申请的280字节空间 */
   , H8 }+ C/ J# w$ M. ^: z, ^
2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
   ' x0 y7 P4 {, B
3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
   * ~' g/ H3 `+ {
4. printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n", DTCMUsed->used);
   
5. 
   
6. /* 释放从AXI SRAM申请的160字节空间 */
   ; m$ V. h( G3 S1 |
7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
   
8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
   
9. printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n", AXISRAMUsed->used)

复制代码

27.4 实验例程说明（MDK）
配套例子：
. \1 k0 v# R, t5 O' H# QV7-006_TCM，SRAM等五块内存的动态内存分配实现

实验目的：
学习TCM，SRAM等五块内存的动态内存分配实现。


' @0 d2 ]& C, B# n5 ]0 Z实验内容
启动自动重装软件定时器0，每100ms翻转一次LED2。
. L" y9 v. N; X- ^. {9 g
6 x6 c9 H) b2 K5 ]
$ [5 B/ |$ g5 _) P3 F实验操作：
K1键按下，从DTCM依次申请280字节，64字节和6111字节。
K1键松开，释放从DTCM申请的空间。
$ o+ x0 ?7 _* w8 C1 H# _" p9 SK2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
K2键松开，释放从AXI SRAM申请的空间。
K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
K3键松开，释放从D2域SRAM申请的空间。
6 f* o8 O5 r3 G& v5 t摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
+ U( L8 p. S6 S: W0 [/ f* M6 \摇杆OK键松开，释放从D3域SRAM申请的空间。

7 c* @' D0 k8 `" {
上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1
+ n5 ~! k' x& C- I' E* \0 L! k. _& t' z

- j& [( n) g1 V  I! `  H' }, i
程序设计：

% l1 B8 P. f) L( R3 f7 T( Q  系统栈大小分配：

8 E+ t1 f3 Q( M" X9 a3 D- {

3 p) V0 ?( j, I- ]
" i, T- M6 f9 B, W# `RAM空间用的DTCM：
# e1 O2 R" B8 h& Y; L

5 p' }1 w# ]& c/ U, \' C2 }
0 Z9 ~7 Q4 D% u; P2 y: T5 e  硬件外设初始化

) m6 W) u4 t4 ~+ J9 l* E$ q  F; i$ b硬件外设的初始化是在 bsp.c 文件实现：
' a' S, J, }; J+ X9 O; W
9 e8 Y" b9 o( w6 i

1. /*
   6 @- W' Z: u! g- c2 w' V
2. *********************************************************************************************************
   , @7 ~$ c1 k' }- \. c
3. *        函 数 名: bsp_Init
   ; A: q2 H( z( |$ N) a
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   : T1 E) K8 ?. ?/ |
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   & U0 x- i2 @8 w8 q  O, H
8. */
   , y' ^% e9 j4 z9 ]! j
9. void bsp_Init(void)
   / g" Z# P: g. l
10. {
    0 Z4 b1 G$ e& l# b1 ~# L) L
11.     /* 配置MPU */
    
12.         MPU_Config();
    # ?9 Z, c3 B2 @
13.         
    
14.         /* 使能L1 Cache */
    3 g$ \! ^# P1 i$ t; g3 i7 H
15.         CPU_CACHE_Enable();
    - r. P! p6 `$ `. }- O
16. 
    3 k  t  n  \; _, Y0 V
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    + t1 [( T( ]1 Q" A$ I0 v# G
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    4 M& _1 z  D" E; g& ?
20.            - 设置NVIV优先级分组为4。
    0 O/ C. [4 H$ v, E
21.          */
    
22.         HAL_Init();
    8 u; E/ t6 {# J: [
23. 
    ! D8 {  W) V! \/ e
24.         /*
    4 M( S0 _! S7 k: H3 x7 e; c
25.        配置系统时钟到400MHz
    1 }6 ~5 k' J! _1 u5 u
26.        - 切换使用HSE。
    ' ~0 B; q. ^& ^& T4 O* [4 v3 Z
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    
30. 
    
31.         /*
    
32.            Event Recorder：
    % c- A2 Y8 O% ?; W$ A
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    0 c3 P) g4 I8 T! `' r9 j' K
35.         */        
    ! i1 o! C1 W: H  n6 F0 b9 \
36. #if Enable_EventRecorder == 1  
    5 _- e9 K. f8 b. o: u: U
37.         /* 初始化EventRecorder并开启 */
    3 \8 p" o, Y/ @$ \$ k
38.         EventRecorderInitialize(EventRecordAll, 1U);
    ; G; a/ }, P/ o1 l" H
39.         EventRecorderStart();
    
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    # V( J, G: X; H" ~( X8 o- r5 `3 I5 K& K
44.         bsp_InitUart();        /* 初始化串口 */
    & E; s% b- K! q, c. v$ C0 c; i
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

  MPU配置和Cache配置：
数据Cache和指令Cache都开启。
) R4 W2 a9 X7 P; D2 P" o* b
, K- U6 U8 P6 |. O, l! y! t% wAXI SRAM的MPU属性：

Write back, Read allocate，Write allocate。
5 e9 M. L' F6 z  ]- y6 ~+ J
3 e1 _( E1 V6 K, @' h6 i7 F6 oFMC的扩展IO的MPU属性：

必须Device或者Strongly Ordered。
- c8 h" d3 e4 ^+ d# e
D2 SRAM1，SRAM2和SRAM3的MPU属性：
2 E4 X: C) l9 o0 o* i7 G# i$ i. m
3 E& W# A, x4 k4 `+ B$ V$ ]. bWrite through, read allocate，no write allocate。
9 A4 X9 Y" J2 C, Q' r' w/ N
D3 SRAM4的MPU属性：
' I1 x5 U+ \+ ~: x; l, j  J4 I
1 O; f) @1 N7 n5 R3 ~+ v/ A: V5 H. dWrite through, read allocate，no write allocate。
* t' |: x# k1 e+ c7 e# c+ n
" `% p9 O6 o9 J" C

1. /*
   
2. *********************************************************************************************************
   / U, R- _# u" J7 N3 A% F' ]4 t- [
3. *        函 数 名: MPU_Config
   # J0 I- P6 W0 Q' `& ~2 q9 V* ?
4. *        功能说明: 配置MPU
   3 R" w" y* x- s0 t* e7 \( W- R" Q
5. *        形    参: 无
   1 u# z. i' J: V' C' P
6. *        返 回 值: 无
   3 l1 J( o3 Z, u2 r$ v
7. *********************************************************************************************************
   3 S2 X6 e8 h* t( \! A1 o% c* z
8. */
   ! O0 ~3 O! O8 o5 T' [/ D/ r. m3 d
9. static void MPU_Config( void )
   & q( X& `% `7 h9 a
10. {
    4 U4 G) C: Q5 Y+ p- p% O9 Q
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
      a9 V/ i6 U  m2 E
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    0 H  ]! J9 }* g3 ~$ v, Q
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    5 ?) S: e* j. S1 d1 n$ a* f% f' Y
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    5 p0 `% f: r' y3 d
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    $ P6 S3 e# B$ e( v# a6 ?
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    + f  ~3 C5 |6 q3 j0 ?6 z+ X
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ( |* U) B7 L* W7 i5 d7 L0 a
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    ! Q* s1 L. ^' x- ?
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    $ @  O' f7 A: r" W9 e
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;
    0 M+ X" u% j0 z8 @
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    3 G$ Y( G# X& X- K- l( h; K
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    * @1 r5 h, |" u
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    1 z% J1 U" E: t- U% F- ?
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    * C) h: ?6 [! Q: Y
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46.         
    5 i0 |9 F$ m2 m  S( d7 ^
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ; q  Q( D! Y+ c& p' Y. p  J( V9 N
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    # J* u; _9 H, }$ x
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ) l/ X$ H7 N, z' A" v- c& v- _8 ^
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    % S0 V) W1 B$ S5 I0 w+ v
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    3 N+ N5 f8 [1 W
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    / Z5 P+ s7 M% h* A; D
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    2 n/ R) w. S- j( K. l
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    $ o( E3 G/ Q5 u* O, |; Q
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    / z" ^; c5 a3 d2 E9 t7 ~' b- M
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    7 {/ Z: O. c# u4 |% ]
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    % U6 a/ H; ^4 E% |, _- a
61.         
    
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    7 I* W- @: Y$ b" I9 Y2 B
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    % I( }; \) [6 q/ O3 N
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    4 o' X% @( _# Y; Y3 l7 H
69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    
71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    ) q4 r8 v8 ?4 e- Z; \6 B. |' Y. Q
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
74. 
    
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
76. 
    - u1 m  w2 o: Y- b* U: T  ]; ^
77. 
    2 O& e. a' w! s
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    4 E0 ?7 v- A- `& Q
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    5 {6 Q8 _8 J+ Z5 J
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
      Z/ O- M/ F6 g8 y  x
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    " X* [3 Z2 e7 Q% P! e) m
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    , i4 j/ R$ W5 R$ e
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ! M3 N" R/ s( L8 M+ q
90. 
    % E. |: j2 }" q6 g. |
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
92.         
    
93.         
    4 W7 q1 V  x9 F7 m3 i% \
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    ! v# d8 m0 j( F8 K. T- |
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    + d# t: i0 C7 {
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    7 z* a: {4 s) X/ K
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    1 Y# H9 p% \* N+ C) k2 J& _: @2 O
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     4 c) P& Z7 \. A4 H+ A8 S% U
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
       U9 K+ E6 O, Q) n9 k) M
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     # @* o, \. k0 z2 d6 G$ p) f9 E
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     
108.         
     
109.         /*使能 MPU */
     
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     
111. }
     8 c, W* y1 T+ k* {7 w9 d  m# M! \
112. 
     
113. /*
     3 p9 \  y4 i! O7 j! |2 ~
114. *********************************************************************************************************
     " P6 \: Q9 E% {% y( R9 Z
115. *        函 数 名: CPU_CACHE_Enable
     
116. *        功能说明: 使能L1 Cache
     
117. *        形    参: 无
     . Z4 Z. O9 _, k) v) y9 {
118. *        返 回 值: 无
     + @9 x+ F8 @# Z0 U6 a6 d! |' @4 ?2 Y
119. *********************************************************************************************************
     - s9 k2 t8 W7 X9 C  i. h1 {! ~
120. */
       r) @, j% s7 b7 I/ D9 O
121. static void CPU_CACHE_Enable(void)
     
122. {
     : x  F3 V$ G" G) u. P& K. e
123.         /* 使能 I-Cache */
     2 S) b7 a1 p: }  ?6 C( o$ A0 c3 F# R
124.         SCB_EnableICache();
     
125. 
     
126.         /* 使能 D-Cache */
     / ^  C; p) m% [/ a0 N
127.         SCB_EnableDCache();
     
128. }

复制代码

  主功能：

主程序实现如下操作：

  启动自动重装软件定时器0，每100ms翻转一次LED2。
3 v$ v1 x& g% ]4 D$ ~  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
7 h! b% [. [/ V" T! ?  K1键松开，释放从DTCM申请的空间。
6 L4 ^6 q0 A0 a9 X. F& k  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
6 c5 V6 z" `' B1 |  K2键松开，释放从AXI SRAM申请的空间。
- B, L8 U9 h0 V2 A8 p# y# I8 F  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
1 r1 s! B) f: u+ G$ B6 A- y; f# W  K3键松开，释放从D2域SRAM申请的空间。
  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
  摇杆OK键松开，释放从D3域SRAM申请的空间。
; g4 v* L) W$ o8 [7 y9 M. U- ^

1. /*
   ; z, b1 W6 f! F1 Q% g
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   " f0 F" I; k! g$ {. A  R, C& f
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   * H2 ^, p, h: b$ D
8. */
   
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    
13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
    6 f8 v9 n0 P  c- ]1 N2 y
14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
    
15. 
    
16. 
    * J9 L- V6 M- E4 E6 ^
17.         bsp_Init();                /* 硬件初始化 */
    ( k3 x) b- x) A) M: A- W2 \' P
18.         
    
19.         /* 初始化动态内存空间 */
    ' n0 h  \- [' h0 q( T; T! }* M; V
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
      s" i2 e( I0 o$ C0 ^- g; r
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    2 M+ m! b  W- Y6 ~6 T
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    - ~$ [2 O% G$ ~3 ?9 z
24.         
    % p3 T' g- Y* z0 R0 x
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
26.         PrintfHelp();        /* 打印操作提示 */
    
27. 
    ' \/ T; e, w" k0 m! A: Q  ?$ H$ T
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    * c! K- X$ L' t, u" a4 {
29.         
    ; G; p  _; H0 ]6 \; {
30. 
    2 f) |/ r# m/ ]
31.         /* 进入主程序循环体 */
    7 [8 m+ q+ c* l! o+ J- _, l$ J5 @8 S9 u
32.         while (1)
    . w) N5 f( h, r2 R; @
33.         {
    9 n" w/ J. E( X, b% L9 P
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    3 ]! r0 P5 r1 g4 i8 Y
35. 
    
36.                 /* 判断定时器超时时间 */
    , b. z. j6 h# G: C+ t, \% B
37.                 if (bsp_CheckTimer(0))        
    & i9 X4 `" a1 Y" \5 S" \
38.                 {
    ( q# R. w$ R) g8 ~0 b& q/ F5 S, h5 z5 l
39.                         /* 每隔100ms 进来一次 */  
    
40.                         bsp_LedToggle(2);
    # {5 ~" D: P2 v4 n& K: F
41.                 }
    9 o3 f2 _( u. S
42. 
    
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
45.                 if (ucKeyCode != KEY_NONE)
    
46.                 {
    
47.                         switch (ucKeyCode)
    / d, `; U# e* x: w8 w
48.                         {
    
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    
50.                                 case KEY_DOWN_K1:        
    
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    
52.                                         printf("=========================================================\r\n");
    
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    2 M3 r8 T! ]- c8 P9 ?8 x
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    7 G* V2 w/ m4 f8 m; o2 X: J8 d
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    : `# o/ C* g* T9 S
57.                                 
    
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    ' l3 M6 e5 \3 x4 ^0 b/ H8 z4 x
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    ( h, w" q6 Y: ?' o
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    6 g, K8 K, r2 D9 ]3 i; W
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
      ~/ f" e) R( c4 X& t
63.                                 
    
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    7 Q% U/ B( G1 i+ b: G  Z0 Y
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    4 o5 ~, h& H* o: f) h
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    / _  F: P  O, P' W
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    * T  K5 `+ L7 G4 K0 o
69.                                         break;
    
70.                                 
    
71.                                 /* 释放从DTCM申请的空间 */
    
72.                                 case KEY_UP_K1:        
    3 b& `- `) v3 m& ]# ~% X6 J4 S+ y- I
73.                                         /* 释放从DTCM申请的280字节空间 */
    $ U, G2 s& v8 X. f0 U! S2 {: e. {
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    0 I8 [. n8 n1 Y& c% t$ `
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    
77. DTCMUsed->used);
    
78.                                 
    
79.                                         /* 释放从DTCM申请的64字节空间 */
    
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    * A6 ~; t1 T  K- ^+ I* x$ n; q% t2 ^9 a
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    3 c+ Q' C6 q. A
83. DTCMUsed->used);
    
84.                                 
    
85.                                         /* 释放从DTCM申请的6111字节空间 */
    
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    $ ]6 @! h7 K2 a
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    . T% s) [6 ?7 c  o( Y
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    
89. DTCMUsed->used);
    . k1 ]8 r% V4 H* j, R8 U* r, G* V
90.                                         break;
    
91.                                 
    
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    * p5 L1 T/ X# Z7 ^( a0 L$ {# P
93.                                 case KEY_DOWN_K2:        
    
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    
95.                                         printf("=========================================================\r\n");               
    
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    ! y, n! D% T* J& d
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    ) {& @# O" u* A6 e; L' t
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    / g; K/ G* c' P1 i& E
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    
100.                                 
     ; u, \& g/ u: I0 V6 Z0 w) M
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     
106.                                 
     
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     , ~; Q1 g! J& g( a: o. w
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     3 E# t4 P5 P( N8 C
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     - ~8 {' ~& _) \4 Q* @
112.                                         break;
     
113.                                 
     
114.                                 /* 释放从AXI SRAM申请的空间 */
     ' r4 W5 C3 b1 Q" R0 c
115.                                 case KEY_UP_K2:        
     
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     ! w( r, k6 l" [' q' F
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     $ e4 o, B' L9 B' Z; d% V
120. AXISRAMUsed->used);
     9 e  V$ W3 @5 e, q+ ^( s6 D& D3 a& R) E
121.                                 
     
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
     ; e- M% `% [) }1 E
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     & x3 e5 y! [1 \
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     3 f" L& c* s" A5 O! h/ z
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     
126. AXISRAMUsed->used);
     
127.                                 
     # _3 O6 {" Y6 f7 M3 }& k; q7 P
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     * _$ T) a# s5 o2 l
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     
132. AXISRAMUsed->used);
     
133.                                         break;
     
134.                                 
     ! X! r0 U" z; }' h; ~: L: E* R
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     
136.                                 case KEY_DOWN_K3:        
     4 p' x; P+ n6 t0 g' A) b3 f7 R3 d3 s
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     $ M6 f1 E  _3 e+ D1 ^, X* n! Q# Q/ r
138.                                         printf("=========================================================\r\n");               
     1 E7 a3 H8 C* C4 B& d6 G
139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
     . p# X) [9 Y2 m. W2 |
140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     $ g- P7 |# w3 @# j0 y. _8 ~1 Y
141.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0200字节，当前共使用大小 = %d字节\r\n",
     7 f, [) {; T" h
142.                                                                                 SRAM1Used->size, SRAM1Used->used);
     2 X6 z# Q' \! v  t
143.                                 
     6 ~8 J: r; T0 F8 I
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     ! s4 i$ p/ U7 F
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     . f  C4 a0 `- x2 L+ e
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     0 v0 z, G7 j$ a2 C
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     % S# [: r& Z7 {: [' |1 r6 A4 `3 v
149.                                 
     ! T4 w8 {& L7 e8 f; q
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     / q! Y" U9 h5 L; j' x5 o
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     & ~; K7 x$ c' l5 S8 ], z
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     : q7 H& t7 N9 @5 [: t/ u5 ^
155.                                         break;
     
156.                                 
     
157.                                 /* 释放从D2域SRAM申请的空间 */
     
158.                                 case KEY_UP_K3:        
     7 B9 ?' B, D4 w! W: p
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     ( E9 z, X- R7 k( F" d. n5 }% e; r' A# C
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     0 l& M' n: c& y& R
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     7 ]7 O! o2 R: G. U2 X
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     
163. SRAM1Used->used);
     . M: c" w# W. Q: _& T3 f# w
164.                                 
     # y6 ^( T( o6 X4 b( ]. K
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     3 p8 L/ W4 @% F9 a
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     5 I: C9 G+ y% H, [. P1 l
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     
169. SRAM1Used->used);
     
170.                                 
     9 E5 r$ N4 y- g: e7 L6 ^. Q
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     + D0 a, o: i0 Z: {4 a) x; v* S& x
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     % I8 d, ]& v" W7 A
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     
175. SRAM1Used->used);
     
176.                                         break;
     
177.                                 
     
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     
179.                                 case JOY_DOWN_OK:        
     
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     1 S0 D0 \$ A7 X  L3 i$ m
181.                                         printf("=========================================================\r\n");               
     - I- Q( D7 O6 I' \. L( V
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     / _" k  w7 o# l& n, M( e
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     3 F. D2 F$ ^; u1 j0 T
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
186.                                 
     
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     1 @! [! W% P  P/ P# U( M
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     ! s+ {( v# Z6 |$ c$ l
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     , H; d2 \+ P. S' x' A5 M
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     
192.                                 
     # S: z+ f' J+ n! v1 q. l- L
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     . N9 F/ {1 S5 e/ Y
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     / B& x8 }1 X  F* _- \
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     0 C9 t6 j0 k4 M7 E
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     
198.                                         break;
     * x+ y) \5 V/ D/ f) W: a& ~
199.                                 
     
200.                                 /* 释放从D3域SRAM申请的空间 */
     
201.                                 case JOY_UP_OK:        
     
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     
206. SRAM4Used->used);
     
207.                                 
     * ]! X  C+ D; `* T) |: h
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     5 T/ G3 e0 Y% h6 x* Z& l
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     
212. SRAM4Used->used);
     
213.                                 
     
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
       U7 f* V! P$ t6 K6 h+ N; L: b# U/ `
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     
218. SRAM4Used->used);
     
219.                                         break;
     2 i0 r! F( Z0 \& b( S8 Z9 y1 l
220.                         
     - ^, i0 z4 U, l% S! C8 x4 ~+ D
221.                                 default:
     
222.                                   /* 其它的键值不处理 */
     0 L6 w, c$ i% ?6 t& M, w
223.                                   break;
     8 x! G+ [4 i7 v7 d: w
224.                         }
     7 |3 O  a& g# \$ \8 v! v/ j
225.                 }
     
226.         }
     
227. }

复制代码

27.5 实验例程说明（IAR）
! }# e2 V4 _6 p6 z: }' K配套例子：
V7-006_TCM，SRAM等五块内存的动态内存分配实现

* I  f+ ?! G  K0 _, _% m6 \1 E% W实验目的：
; E! D4 T: ^& E学习TCM，SRAM等五块内存的动态内存分配实现。


实验内容：
启动自动重装软件定时器0，每100ms翻转一次LED2。
" l( H# w+ _3 r9 K2 v
实验操作：
K1键按下，从DTCM依次申请280字节，64字节和6111字节。
9 ]* i" ?/ H; M6 @& SK1键松开，释放从DTCM申请的空间。
7 Y/ F. T6 O: B. M9 kK2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
K2键松开，释放从AXI SRAM申请的空间。
1 D5 W3 d  k$ s& H3 z6 b% T7 L% RK3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
* N$ D) k. B9 g# S+ cK3键松开，释放从D2域SRAM申请的空间。
2 o5 b- z- g" }! N* H$ Z6 a. @摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
摇杆OK键松开，释放从D3域SRAM申请的空间。
0 o, C) Z+ Y. L* B' l3 L
上电后串口打印的信息：
9 h+ D4 o! L. o, M7 E" l/ G5 ]
波特率 115200，数据位 8，奇偶校验位无，停止位 1

1 O' C: B" S8 A8 r' C5 S) C1 _8 I程序设计：

& d- X! Y8 z- ]) U' b9 o  系统栈大小分配：

" w5 ?( F+ r0 J5 L  c

0 i% H- ]4 V1 C1 Y9 m) ~4 Z2 E% ^
  RAM空间用的DTCM：
6 ?. b# p+ Y' P7 E5 }6 m4 C- W
" G1 g: |* ^' p

8 U6 R8 T0 u7 K$ T! ~2 J, K3 g
$ [0 Q- r5 r' t  硬件外设初始化

$ X: T5 p* g0 C( }硬件外设的初始化是在 bsp.c 文件实现：
" z2 h( h: O  o' v# t) h
- k9 g1 C5 j2 l) M: V2 T& s* i

1. /*
   
2. *********************************************************************************************************
   $ H% H/ g$ J" {+ ^7 {# a4 C3 I; c6 R
3. *        函 数 名: bsp_Init
   3 C. z8 u; n4 T1 v) y
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   + V3 r& M8 h: }1 `5 T9 r+ h: ~! z
8. */
   7 m- h) F) F' D, @: j2 [1 Y
9. void bsp_Init(void)
   & c( n4 q6 Z+ I
10. {
    
11.     /* 配置MPU */
    8 M/ }. z% t" R* [' }
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    
16. 
    
17.         /*
    / [% v4 J) }: ~0 R
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    5 {* o0 j7 K5 L4 S, l- y
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    
21.          */
    ; |3 S/ E7 t7 y5 f( s
22.         HAL_Init();
    / Z0 t3 V2 ~( ^- ~6 a
23. 
    8 t1 n5 }7 V/ _0 c! o6 L4 p# w5 l+ N
24.         /*
    4 E1 Z7 x' Y# z0 P
25.        配置系统时钟到400MHz
    ; [4 d2 E+ M: z, o5 H2 Y
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    ! b* a" s7 L  q( k
28.     */
    : I1 O" U/ h  d& A" ?
29.         SystemClock_Config();
    - {* G) h# w' M2 x, L
30. 
    
31.         /*
    , T  V$ J( n0 t( t
32.            Event Recorder：
    3 K( g$ X: t, Q( X/ y$ Z4 l/ x- w
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    % X2 O0 h/ _' ^8 s$ @* `3 ^
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    " _" d0 R: L9 n1 n  `8 L' O" x- {
40. #endif
    
41.         
    4 Y' L# D3 @- l
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    ) r+ C; Q6 c! d& g
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    - k) G; Q: Z+ B/ o4 j2 W7 h
44.         bsp_InitUart();        /* 初始化串口 */
    . i& M0 b" E7 `9 F
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    * p! A; [" ^& B( S2 d
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

6 i- z+ U8 W7 j$ u$ ?  MPU配置和Cache配置：
% v9 U7 }- Y0 q% q4 Q( g6 U1 r$ U
) z& g% f& F% k* e9 s2 G# L数据Cache和指令Cache都开启。
4 C5 @8 U" c* W7 Y8 _2 @/ I
AXI SRAM的MPU属性：

& z4 [" ~& Y( C- f6 ZWrite back, Read allocate，Write allocate。
% U) ^  G, a) u* Z/ `
FMC的扩展IO的MPU属性：

  D0 m- L( P& y% v必须Device或者Strongly Ordered。

D2 SRAM1，SRAM2和SRAM3的MPU属性：
# n" v* R4 r" A0 I8 I
3 ]( Z; M5 N. s5 B/ vWrite through, read allocate，no write allocate。

D3 SRAM4的MPU属性：
, }: L& b4 T4 r4 w( B0 w1 r/ I
Write through, read allocate，no write allocate。

7 I$ T' i# l  y" D

1. /*
   / ~+ H. F" B7 k2 `' f
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   $ l9 i; Z" p6 N0 z: w& p
4. *        功能说明: 配置MPU
   8 o+ e6 k; I/ }( T
5. *        形    参: 无
   . H. y7 h" ~6 v. Y
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   2 i2 f& Z; j3 C7 J( \$ S% ]" X# |
8. */
   
9. static void MPU_Config( void )
   - |+ d  R- w+ @" I. e. |" W( ^9 h4 q
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    % E: K6 k  n, v. l9 h
12. 
    8 ]  u7 \) Y  p' ?7 G
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    7 p# `1 z3 G# K2 ~5 k( Z( K5 L
15. 
    . J) H3 A9 T9 X8 x
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
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;
    0 E+ m$ F6 _* X
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    3 v( y5 H" C1 H, U8 S" D; ?
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    # _' L' n# S! |9 p# Z
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    9 Z5 |1 t) ]8 k' y" U$ d
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    0 o" C2 e: H9 S0 g$ @
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    3 D- j1 g" i1 P$ u( _
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    7 G, ^: F" `& z5 C7 G
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    7 G+ j/ |  U9 e& ?
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ! I6 b* |, C  `. C& |% X. k3 b
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    % R+ ~! o0 W0 Y/ z. b
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    . s& e$ a" B( n- a
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    0 Q1 Y# w' C4 S* n, R  h+ t
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ' F# F" ]) h5 H7 d
46.         
    
47.         /* 配置SRAM1的属性为Write through, read allocate，no write allocate */
    
48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    9 }1 d" Y" h4 u$ Q0 b0 B2 K  a0 `
50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    
51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ' C8 m. o1 s* [! }; K+ e- ~9 Z
52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    9 `% g, R7 b; {6 g, @* s
53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    
56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    ; n/ D: z' _+ P) `2 S9 b9 V6 @  N# I
57.     MPU_InitStruct.SubRegionDisable = 0x00;
    
58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
59. 
    
60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
61.         
    
62.         /* 配置SRAM2的属性为Write through, read allocate，no write allocate */
    
63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    7 y* h) w! Q  Z
65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    
66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ( ~* Y" e& u' M# Y1 m: {
67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    - W2 i( s5 b  t" a4 _3 p8 `
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;
    
72.     MPU_InitStruct.SubRegionDisable = 0x00;
    
73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
74. 
    
75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
76. 
    
77. 
    ) @' s$ A. M1 ^8 ]7 s4 p2 t+ D
78.     /* 配置SRAM3的属性为Write through, read allocate，no write allocate */
    ( F7 B  O- B3 D* h" [; F) C: q
79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    1 C- j# n/ \3 D& j2 }
80.     MPU_InitStruct.BaseAddress      = 0x30040000;
    1 T: H; i) ?% ^# D8 v: b
81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    
82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ; S4 U" o4 r( g  ]2 |! G
83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    
84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    * n6 j% ]7 G) K8 X, n# @  ~1 S1 i
86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    
87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
88.     MPU_InitStruct.SubRegionDisable = 0x00;
    
89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    & m, j7 Z" Q/ P3 H: a9 E
90. 
    ) d7 w1 \1 V: F- M/ W+ n5 f
91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ! I: J' A( S  R3 @
92.         
    ! A3 w- U" ]" z
93.         
    ; ~/ e  @% [5 W6 q
94.         /* 配置SRAM4的属性为Write through, read allocate，no write allocate */
    
95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ' U4 g9 [1 L) A6 T: m/ ]: T
96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    $ U, c+ I- x, I8 E) N3 I
97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    5 B% X0 y4 w4 Y6 U) B6 X2 P
98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    , W. ~5 a' i0 A% x" Z/ S# C
99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    . J3 y5 Y$ i' Y+ C5 ]; i, G) _1 P
100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
     5 ~  o( Z3 n0 O5 Z
101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
     5 p& s! O/ Z/ a' @- S. P9 u" Z
102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
     
103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
     
104.     MPU_InitStruct.SubRegionDisable = 0x00;
     + F, `' |2 a9 a1 E. X
105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
     
106. 
     
107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
     9 c' N. s9 p: k; g
108.         
     
109.         /*使能 MPU */
     
110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
     
111. }
       Q2 J  L  F3 @  A; Y3 N
112. 
     $ ?4 M* Q1 j6 ~+ x* p
113. /*
     
114. *********************************************************************************************************
     
115. *        函 数 名: CPU_CACHE_Enable
     
116. *        功能说明: 使能L1 Cache
     & z% w: g: `5 C$ n- e% d
117. *        形    参: 无
     
118. *        返 回 值: 无
     # P' o' D4 n* ]+ o
119. *********************************************************************************************************
     
120. */
     
121. static void CPU_CACHE_Enable(void)
     
122. {
     
123.         /* 使能 I-Cache */
     
124.         SCB_EnableICache();
     6 T: |1 d7 a  g* l* b
125. 
     9 K$ S$ }' {. v2 p* U0 p1 k$ f& y9 k
126.         /* 使能 D-Cache */
     
127.         SCB_EnableDCache();
     
128. }

复制代码

  主功能：

主程序实现如下操作：
( N# F' D6 z; W8 Z- Y
  启动自动重装软件定时器0，每100ms翻转一次LED2。
7 ?3 R* Z& _+ u% A  K1键按下，从DTCM依次申请280字节，64字节和6111字节。
9 Z8 O; C, g2 E, {3 F  K1键松开，释放从DTCM申请的空间。
3 o% x. d/ P. @) B" `+ r  K2键按下，从AXI SRAM依次申请160字节，32字节和2333字节。
: z: T; c: N) Z! z- N" h  K2键松开，释放从AXI SRAM申请的空间。
  K3键按下，从D2域SRAM依次申请200字节，96字节和4111字节。
  K3键松开，释放从D2域SRAM申请的空间。
  摇杆OK键按下，从D3域SRAM依次申请300字节，128字节和5111字节。
  摇杆OK键松开，释放从D3域SRAM申请的空间。
! i7 g. ~. a+ M7 d6 B$ y& w" D4 N

1. /*
   
2. *********************************************************************************************************
   9 K, y: j# q- B' G% i- W. ]# Z
3. *        函 数 名: main
   , A, T% t/ @+ K
4. *        功能说明: c程序入口
   " w- K/ V- f# I- {8 F% a# |9 a
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    - U7 f; K  o" k1 n+ s1 Y
12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    
13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;
    ) H4 p) s; g8 J+ U+ J
14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
    
15. 
    " E5 l- ?& T' m- ?+ C# W
16. 
    
17.         bsp_Init();                /* 硬件初始化 */
      U3 D8 z, L1 a7 U* G
18.         
    & `4 Z% i  D& [, H: E$ ]# L$ C- K
19.         /* 初始化动态内存空间 */
    
20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    1 C" e; |" F* ^8 j! A1 {
21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    9 Y0 c6 ~  d5 P9 ~  k* q
22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));
    " b8 }: w% x$ m; ^& q2 w
23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
    ! ~2 I- `, r$ e2 P1 U
24.         
    
25.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
26.         PrintfHelp();        /* 打印操作提示 */
    ! T! x6 b: C! f) @' ~# ]9 h) Q
27. 
    
28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    / r4 t0 l6 ?3 o* t6 ^+ A
29.         
    " d% I8 u! L1 E& u/ K
30. 
    + N3 K3 Q! f. {6 O% \* F, W
31.         /* 进入主程序循环体 */
    4 e0 G3 q, U) l4 `4 C
32.         while (1)
    : [1 x' R. A; ]# c
33.         {
    % T2 I; f0 l& Q# g4 H: ]
34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    8 ^) v3 w) I- }+ l" [/ N3 Z
35. 
    9 k4 J: F+ E  D! O; S$ U# l
36.                 /* 判断定时器超时时间 */
    4 \* u, X5 |/ V
37.                 if (bsp_CheckTimer(0))        
    3 R3 Q; w9 [' c: l- o2 t& P
38.                 {
    9 e, U  s2 d( \7 ^/ Q
39.                         /* 每隔100ms 进来一次 */  
    * o5 S( X- U% `' b- K
40.                         bsp_LedToggle(2);
    2 J5 }/ B  S8 k; a" U3 e2 b) J: N8 s
41.                 }
    
42. 
      y6 H9 O2 f$ S( _3 t
43.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    * [: c& G- U) a8 L% _% Z
44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
45.                 if (ucKeyCode != KEY_NONE)
    
46.                 {
    
47.                         switch (ucKeyCode)
    ' u) Q* Z$ Q6 T7 n* y; G
48.                         {
    
49.                 /* 从DTCM依次申请280字节，64字节和6111字节 */
    $ ]) z7 K  Y) C% @
50.                                 case KEY_DOWN_K1:        
    , p0 I7 }; ]" |% Y# `% T% S( S
51.                     /* 从DTCM申请280字节空间，使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    9 m; `8 _* X7 c9 D
52.                                         printf("=========================================================\r\n");
    
53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    : a! T& S9 n# i+ J( [
54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    / F: C$ E/ [& j5 N" B/ _: y, @
55.                                         printf("DTCM总大小 = %d字节，申请大小 = 0280字节，当前共使用大小 = %d字节\r\n",
    8 K7 a" Z+ S9 j
56.                                                                                 DTCMUsed->size, DTCMUsed->used);
      ]- j5 {6 f- O" {
57.                                 
    " Z' b" {. m0 J1 a/ z
58.                         /* 从DTCM申请64字节空间，使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        
    
59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    
60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
      U9 v( Q% w, X# a
61.                                         printf("DTCM总大小 = %d字节，申请大小 = 0064字节，当前共使用大小 = %d字节\r\n",
    5 J! G5 G" k! o2 v
62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    
63.                                 
    * H: `: T( a/ f7 N  c! ?
64.                     /* 从DTCM申请6111字节空间，使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    
65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    
66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
67.                                         printf("DTCM总大小 = %d字节，申请大小 = 6111字节，当前共使用大小 = %d字节\r\n",
    ' W& j  D2 o. \! O- f
68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    
69.                                         break;
    # U1 ]( V% p, h  g! m
70.                                 
    
71.                                 /* 释放从DTCM申请的空间 */
    
72.                                 case KEY_UP_K1:        
    * J! p' d& e' R1 V
73.                                         /* 释放从DTCM申请的280字节空间 */
    
74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    8 h' \9 f  w, b
75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    
76.                                         printf("释放DTCM动态内存区申请的0280字节，当前共使用大小 = %d字节\r\n",
    
77. DTCMUsed->used);
    . \2 B, r+ M  H/ ?& ^- }( c9 Y
78.                                 
    ; ~4 `! W5 r; f1 ?9 _' e
79.                                         /* 释放从DTCM申请的64字节空间 */
    . n. N. f9 p2 c" {8 N" R6 ?
80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);
    3 K* \6 w( X3 }- ~
81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    7 M  B' x& t1 l' Q
82.                                         printf("释放DTCM动态内存区申请的0064字节，当前共使用大小 = %d字节\r\n",
    : d& D6 X) C1 ~) ^" K4 S
83. DTCMUsed->used);
    ' b2 t2 a) X0 z# b
84.                                 
    
85.                                         /* 释放从DTCM申请的6111字节空间 */
    8 P: T% S, p: D  M9 d, y: d7 m$ l
86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);
    4 S, {" D% s# n: j- x" V* X
87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
      [0 ?) C7 h6 \& Q
88.                                         printf("释放DTCM动态内存区申请的6111字节，当前共使用大小 = %d字节\r\n",
    4 C0 [1 r' t& r1 ?1 y
89. DTCMUsed->used);
    $ T3 f) s; N4 c* T$ Q1 ]
90.                                         break;
      x: }" ~  g! j) x
91.                                 
    . C4 C- }+ u* [7 |9 J
92.                                 /* 从AXI SRAM依次申请160字节，32字节和2333字节 */
    & `. I; I3 l  Q6 O) m- T8 |
93.                                 case KEY_DOWN_K2:        
    
94.             /* 从AXI SRAM 申请160字节空间，使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    
95.                                         printf("=========================================================\r\n");               
    
96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    - G( @4 g5 G6 f' _
97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    ( ^4 u& X( @) Q( P' I
98.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0162字节，当前共使用大小 = %d字节\r\n",
    
99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
      `1 ]& p0 r0 }/ H
100.                                 
     7 U, g# b% w& i7 a' v1 S
101.                         /* 从AXI SRAM 申请32字节空间，使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
     3 d3 ~% k# r  r/ @- f
102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
     9 w9 [  s* F( R; `, Q) @* y4 H8 B
103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
104.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 0032字节，当前共使用大小 = %d字节\r\n",
     
105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
     
106.                                 
     $ y  r$ P6 O6 q. _% ~. I$ j# N
107. /* 从AXI SRAM 申请2333字节空间，使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
     
108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
     $ x0 K' a- u6 n# u. S! s5 n
109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
110.                                         printf("AXI SRAM总大小 = %d字节，申请大小 = 2333字节，当前共使用大小 = %d字节\r\n",
     9 z' b7 J8 _  X+ e' f
111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
     . a7 }8 \+ R# t' }7 P( J- D' {- _
112.                                         break;
     
113.                                 
     , T2 R- n$ v$ Z  [
114.                                 /* 释放从AXI SRAM申请的空间 */
     . [2 p3 r* j9 _* @" S! X
115.                                 case KEY_UP_K2:        
     
116.                                         /* 释放从AXI SRAM申请的160字节空间 */
     
117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
     - o2 N9 o: Q+ @" Z' g4 q8 W
118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     - T. X+ C& D& T# @0 u6 U& p
119.                                         printf("释放AXI SRAM动态内存区申请的0160字节，当前共使用大小 = %d字节\r\n",
     
120. AXISRAMUsed->used);
     
121.                                 
     
122.                                         /* 释放从AXI SRAM申请的32字节空间 */
       M! ?) s: V# ]# O
123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
     " X3 \7 U5 S4 R- L
124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     
125.                                         printf("释放AXI SRAM动态内存区申请的0032字节，当前共使用大小 = %d字节\r\n",
     0 W+ z! G& F5 `! d1 \  }
126. AXISRAMUsed->used);
     
127.                                 
     $ }: N0 [/ Q6 [
128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
     
129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
     
130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
     ! ?# [" K! A  e0 N
131.                                         printf("释放AXI SRAM动态内存区申请的2333字节，当前共使用大小 = %d字节\r\n",
     
132. AXISRAMUsed->used);
     8 H$ e& v7 r8 ^# d" o: n* R
133.                                         break;
     7 k' C# h& p9 N2 {0 j2 `4 [7 N* e
134.                                 
     5 h$ @8 C% F" C4 [0 ~" N* A! }
135.                                 /* 从D2域SRAM依次申请200字节，96字节和4111字节 */
     
136.                                 case KEY_DOWN_K3:        
     
137.         /* 从D2域的SRAM申请200字节空间，使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
     ! c3 O3 n2 ^7 i! V7 \+ a& M4 C
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);
     . q5 n5 b1 a% t* c; H( p
143.                                 
     
144.          /* 从D2域的SRAM申请96字节空间，使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
     7 Z8 u2 X' O5 ]7 Y2 J, @* q
145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
     
146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
147.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 0096字节，当前共使用大小 = %d字节\r\n",
     
148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
     
149.                                 
     8 {# @, Y# ]) V
150.          /* 从D2域的SRAM申请4111字节空间，使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */
     
151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);
     - q6 i3 e* C# T2 J% m
152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     $ M" p2 O5 g9 E, t# o
153.                                         printf("D2域SRAM总大小 = %d字节，申请大小 = 4111字节，当前共使用大小 = %d字节\r\n",
     
154.                                                                                 SRAM1Used->size, SRAM1Used->used);
     
155.                                         break;
     
156.                                 
     
157.                                 /* 释放从D2域SRAM申请的空间 */
     
158.                                 case KEY_UP_K3:        
     . `8 X. i$ w+ E9 k0 e3 `5 E9 D
159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
     
160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
     
161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     
162.                                         printf("释放D2域SRAM动态内存区申请的0200字节，当前共使用大小 = %d字节\r\n",
     . g1 c7 E( z" R+ ^( J- ?5 h
163. SRAM1Used->used);
     
164.                                 
     0 w3 ?. T8 p' n. S
165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
     
166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
     & `0 Y  T; B1 c: @& k: W
167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     " l2 h. C: w; m4 ?7 l* ?' z, i9 r  A
168.                                         printf("释放D2域SRAM动态内存区申请的0096字节，当前共使用大小 = %d字节\r\n",
     
169. SRAM1Used->used);
     9 f/ a5 i: T& h  `# k2 M- d7 d9 p' N2 r
170.                                 
     2 ^% Y+ Y* W2 F0 m+ ~& a+ C
171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */
     
172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
     
173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
     & h: Q. O) K7 q, P
174.                                         printf("释放D2域SRAM动态内存区申请的4111字节，当前共使用大小 = %d字节\r\n",
     ! Z, b9 J' h  S# q, |# T1 d# ]
175. SRAM1Used->used);
     " _& E3 E5 p% C1 L5 Q
176.                                         break;
     5 B- C8 W7 g) t% w' H
177.                                 
     + j. {0 k$ v) }, X
178.                                 /* 从D3域SRAM依次申请300字节，128字节和5111字节 */
     # n% K5 V# D8 j, U# @2 Y+ B+ d0 Q
179.                                 case JOY_DOWN_OK:        
     
180.             /* 从D3域的SRAM申请300字节空间，使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
     & i' ]" g4 P7 q  Q- e9 ~
181.                                         printf("=========================================================\r\n");               
     - R* h1 R, M! `- ?9 Z9 r8 V
182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
     
183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
184.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0300字节，当前共使用大小 = %d字节\r\n",
     
185.                                                                                 SRAM4Used->size, SRAM4Used->used);
     & h: |; ?, c" @; ~/ m1 a! [
186.                                 
     
187.                 /* 从D3域的SRAM申请96字节空间，使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */
     
188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
     & u. o* u/ h5 \) b5 ]; K: c
189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
190.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 0128字节，当前共使用大小 = %d字节\r\n",
     6 E5 _; D" Y9 H* s/ M0 u& Y
191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
     
192.                                 
     
193.         /* 从D3域的SRAM申请5111字节空间，使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */
     7 O7 {( B  @6 {* `+ B) G! [
194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
     3 t& c& z& }! E% J/ E6 w
195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
196.                                         printf("D3域SRAM总大小 = %d字节，申请大小 = 5111字节，当前共使用大小 = %d字节\r\n",
     
197.                                                                                 SRAM4Used->size, SRAM4Used->used);
     % O8 h/ e, l2 c) Z1 O
198.                                         break;
     
199.                                 
     
200.                                 /* 释放从D3域SRAM申请的空间 */
     
201.                                 case JOY_UP_OK:        
     
202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
     " E3 m! w3 X6 N! [
203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
     
204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
205.                                         printf("释放D3域SRAM动态内存区申请的0300字节，当前共使用大小 = %d字节\r\n",
     5 j- E& U* r% G4 Y' @% r  k
206. SRAM4Used->used);
     . L1 d1 B: M3 ~3 L( P* H/ e
207.                                 
     
208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
     4 t  C* o* I! M' q& V
209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
     
210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     6 T  d- `. T0 z6 E+ a! ^) n% W* X! ]
211.                                         printf("释放D3域SRAM动态内存区申请的0128字节，当前共使用大小 = %d字节\r\n",
     9 T: W8 I* z* x. I5 I
212. SRAM4Used->used);
     ; n: f3 x/ j  m/ y: ~, v( X# o. \+ L
213.                                 
     
214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
     
215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);
     
216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
     
217.                                         printf("释放D3域SRAM动态内存区申请的5111字节，当前共使用大小 = %d字节\r\n",
     0 R/ \5 {4 Q+ ~! J) x8 S; G
218. SRAM4Used->used);
     1 f- Z$ c5 H4 p5 N* b7 H
219.                                         break;
     ' u: T& O, s1 k& Q; X' I& f
220.                         
     
221.                                 default:
     * d' X2 h0 z# ~( {
222.                                   /* 其它的键值不处理 */
     
223.                                   break;
     3 c' x# H( U; W; l3 J  q
224.                         }
     
225.                 }
     
226.         }
     8 E. V* Q+ H, V1 |/ F! g* X
227. }

复制代码

27.6 总结
本章节就为大家讲解这么多，还是比较有项目实用价值的，特别是MP3编解码，JPEG编解码，视频播放器，矢量字体等需要动态内存的场合。
% e+ x" Y" h1 ?8 u" J4 w* a: y: g6 P

% W) `3 [1 M; k0 W% H