你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

【经验分享】STM32H7的TCM,SRAM等五块内存的动态内存分配实现

[复制链接]
STMCU小助手 发布时间:2021-12-23 15:00
27.1 初学者重要提示( o  Y$ o" k4 g; _3 z8 N  X" s- w* n" j
  学习本章节前,务必优先学习了解TCM,SRAM等五块内存区的基础知识,比较重要。
- _+ {# ]. L" ^& `- c: f# D/ M( ~  将RTX5系统的动态内存管理整理了出来,可以同时管理多个分区。如果其它RTOS中使用,记得做互斥保护或者加个调度锁均可。
7 \) B; d6 V( M6 x  支持动态内存使用情况统计。
" i5 M0 Y- }$ T! G* P' K27.2 动态内存管理移植. Y- U% W6 L6 m5 P8 g1 ~
移植比较简单,仅需添加两个文件到工程即可。
$ c9 ]: @) k1 n( n% Z$ U, s% X
5 T( A5 }. D# k& p4 n& Y27.2.1 MDK版的移植0 u7 H" {, M/ W/ s
  第1步,添加如下两个文件到MDK中9 y( c' `( `; i
注,以本章配套例子为例,这两个文件的路径\User\malloc。; L/ K( q, @" a8 b
. `' {: d  L# I2 o; a2 ~7 `. _# t8 Z$ u$ G
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png
' x; L; r2 e4 M. T9 T
5 l6 ~; k# }2 {( b2 t* q
  第2步,添加路径。- I" t: g& X0 h. D0 x7 P( z

  W9 G* ~0 h2 o6 k6 E9 g7 `
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png

8 w. Z" \" Y7 p* B6 @
4 a# t" Y4 _4 M  k  第3步,添加头文件。6 V9 J  L' @6 z! {. S% G9 @
如果哪个源文件要用到动态内存,包含rtx_lib.h即可,本章配套例子是直接将其放在了bsp.h文件里面,哪个源文件要用到动态内存,直接包含bsp.h头文件即可。
( L; ?- Q5 v  o7 b- P) W! H
' ~1 v8 v0 n% Q通过这简单的三步就完成了MDK的移植。* N, P4 X( i& F6 ]9 S0 }( T: X# E

, F$ L5 q  i; W' I6 G27.2.2 IAR版的移植
, {) Q6 n+ r( G- U0 b  第1步,添加如下两个文件到IAR中0 x; Z1 [0 x/ |3 m; @
注,以本章配套例子为例,这两个文件的路径\User\malloc。+ m, \# [+ s) ^% F1 K+ b, W

0 A! @/ x0 m3 i. Z& `- s8 O
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png
9 g' x3 p* @6 ~1 \% R

* b8 e, v" p2 I  第2步,添加路径。$ w- q( v6 B2 n& q3 [
' G- ~" y2 F! ?  K( _: W
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png
+ d$ q$ N& r' B8 Y& n, N& |

. m; I7 Q( N. e7 w  第3步,添加头文件。
# C! i/ s, W- H. g0 \( L如果哪个源文件要用到动态内存,包含rtx_lib.h即可,本章配套例子是直接将其放在了bsp.h文件里面,哪个源文件要用到动态内存,直接包含bsp.h头文件即可。$ v" |4 b2 [4 A8 v  A5 C
! M2 R& V9 D5 g' o. v/ x
通过这简单的三步就完成了IAR的移植。
8 H+ S/ G/ y0 S. h, P
2 a) ?- D/ U9 ?$ {27.3 动态内存的使用方法0 }" t1 o  e" h5 P9 U: ]1 k; |9 |; Q
下面分别以MDK和IAR为例进行说明:
; F$ T  B7 ?% c5 Q2 d  V3 r7 c+ Z3 i  ?* o/ \- M) u
27.3.1 MDK上的动态内存用法( O: t# E: C- l4 d% @
  定义动态内存区0 T( F+ s/ q  T
比如当前的主RAM用的DTCM,我们就可以直接定义一块大的数组作为动态内存空间:
$ f" }' z" r3 k: h  w! x( \( K/ l7 f% w$ d& \5 z
  1. /* DTCM, 64KB */
    0 G$ j/ n0 R: M/ a  M+ w
  2. /* 用于获取当前使用的空间大小 */8 x1 N: }. o& u
  3. mem_head_t *DTCMUsed; 0 n  W( ?  l* n  q9 _  V
  4. /* 定义为64位变量,首地址是8字节对齐 */             ' `" e7 E$ b3 V6 p7 g
  5. uint64_t AppMallocDTCM[64*1024/8];
复制代码
# N$ `1 F5 n0 l
如果要使用AXI SRAM作为动态内存空间,可以使用__attribute__((at( )))指定地址。
- _! U. d# Y# ^! t9 C
" ?) g3 m! @& n: ~. ^1 W/ h7 d
  1. /* D1域, AXI SRAM, 512KB */
    6 k0 q$ V5 I8 `' z2 k
  2. /* 用于获取当前使用的空间大小 */2 H: a0 a5 v& B& N
  3. mem_head_t *AXISRAMUsed;  
    " {4 Y! r5 A( N$ Y& o, U  c
  4. /* 定义为64位变量,首地址是8字节对齐 */ 0 P6 ~' G, E- f( H! C
  5. uint64_t AppMallocAXISRAM[512*1024/8]__attribute__((at(0x24000000)));
复制代码

: g4 }7 u+ g4 E% p  初始化动态内存区
2 m  e$ O) g7 m: o( \调用动态内存管理提供的函数osRtxMemoryInit即可做初始化:
) S! v0 Z7 _" m- w# G3 P+ Y
+ C. Y  H, V# bosRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
$ a0 W* ~) h  y1 ~6 }2 n2 IosRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
6 R% j; b: X) a1 a9 Y7 `5 a; U2 U  A( b- V% m; c# t4 f, j
  申请动态内存
' d. s  B9 B/ V! Y通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。. S& L. s- N; ]7 Y, h

/ A& Y1 t9 R3 v! ^8 A第1个参数填写内存区首地址,比如申请的AppMallocDTCM,就填AppMallocDTCM即可。
' H+ j6 i# j, D& t
% c6 f! @6 u$ n' `3 c第2个参数填写申请的字节大小,单位字节。5 r# E, e  T# E* H

, \) k6 t7 I9 X0 W" f. P+ Q第3个参数固定填0即可。
$ n8 A. l( r' ?
4 V' k# w; [& k6 i6 u- l返回值是所申请缓冲区的首地址,如果没有空间可用,将返回NULL,这点要特别注意!
% N. q4 j2 T6 V. @. L
9 E9 Z0 m0 F- U0 o+ t举个例子:9 d1 I9 f! m$ |) D2 [6 D8 h  n

# f; l% x) n; f" t
  1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;0 J2 q3 B" ?+ L$ E* f
  2. / ~# T/ l! g. |$ H
  3. /* 从DTCM申请280字节空间,使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        
      h! a, F. m  z  x  t: n4 j
  4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    3 X. H' |5 @4 Y3 L
  5. DTCMUsed = MemHeadPtr(AppMallocDTCM);
    ( Y$ V% k  L7 g3 |" d& B
  6. printf("DTCM总大小 = %d字节,申请大小 = 0280字节,当前共使用大小 = %d字节\r\n",
    7 Z/ D1 Q' M" {
  7.                                                              DTCMUsed->size, DTCMUsed->used);
    5 c' h+ b6 R: W( S7 Q5 D

  8. * [* j  H* D1 s" S$ R3 M8 s
  9. /* 从AXI SRAM 申请160字节空间,使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
    4 ~' a( X' G$ |
  10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    % r" c9 R$ e; t( m% Q& W' I
  11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    , J: D5 L1 Y( k
  12. printf("AXI SRAM总大小 = %d字节,申请大小 = 0162字节,当前共使用大小 = %d字节\r\n", ; p2 W8 X+ a2 z2 y% C6 M
  13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);
复制代码

0 A# {# o1 ^% M- G1 q* X申请了空间后,就可以直接使用了。另外注意红色字体部分,通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。& a% [7 x0 N) j( N. k
) u, \# p( @# ~; m
  释放动态内存
& G4 r) L( L: B0 J' B* R7 O通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。, I# a4 m4 a! P0 S. V$ ?& R

7 \4 l' ^: C: l% {1 \, L+ q第1个参数填写内存区首地址,比如释放的AppMallocDTCM,就填AppMallocDTCM即可。; a. q% l' n$ ?/ E; y! i% l9 I

- w7 V% o' ^: U0 f! h: u9 C% R第2个参数填写申请内存时所获取的内存区首地址,这里用于释放。
; I6 t1 r8 i- g7 L! n( p( x( P7 G* e$ u' s, B. Q$ n% L
返回值,返回1表示成功,返回0表示失败。8 g( A  o8 M1 w# O! k# j2 F* z4 K

& E* B9 ]2 a0 @  E2 G举个例子:
$ b, m4 B3 Z5 @( o" k$ D5 }6 C) K
( ~7 a$ g; ]$ |! `4 v
  1. /* 释放从DTCM申请的280字节空间 */0 J4 a2 R, i0 E# r4 G; K. M: r+ l
  2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    ) J# X2 l* S, t4 s
  3. DTCMUsed = MemHeadPtr(AppMallocDTCM);& b9 h' K% k, F5 G: w
  4. printf("释放DTCM动态内存区申请的0280字节,当前共使用大小 = %d字节\r\n", DTCMUsed->used);$ Q+ `' E) @; o) ~( {6 e

  5. & |9 k9 T  R* n# J+ R1 C
  6. /* 释放从AXI SRAM申请的160字节空间 */
    9 I6 Q0 K% G7 x. W7 r$ ~# \$ a
  7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);' _/ h6 p( @. v/ z1 `& N
  8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);0 N9 P6 _9 z! o/ I( ~$ L  E6 }& {) y
  9. printf("释放AXI SRAM动态内存区申请的0160字节,当前共使用大小 = %d字节\r\n", AXISRAMUsed->used);
复制代码

" W% C& R$ l/ k/ C% ~! m$ X27.3.2 IAR上的动态内存用法4 N% y/ {1 O! x  T
注:IAR使用这个动态内存管理,仅在定义时跟MDK略有不同,其它地方是一样的。
( j5 _) L$ G7 W; S, R* k" R, q/ v, z1 M* u. X
  定义动态内存区
+ W) R8 ]& U# T8 ~0 X5 ^比如当前的主RAM用的DTCM,我们就可以直接定义一块大的数组作为动态内存空间:
! P3 A$ N0 U* R3 B$ v
1 [  B/ ?( e& I$ @; R! U" o
  1. /* DTCM, 64KB */1 ~1 C0 B5 L6 ]+ R" t$ U* t
  2. /* 用于获取当前使用的空间大小 */
    / P+ [, l  ~  l' l/ X
  3. mem_head_t *DTCMUsed; . M$ v- b/ N7 ?9 f, ^
  4. /* 定义为64位变量,首地址是8字节对齐 */            
    ) z& s: N! p% t' I  ?
  5. uint64_t AppMallocDTCM[64*1024/8];
复制代码

" j1 o3 U+ z* [4 q# T如果要使用AXI SRAM作为动态内存空间,可以使用__attribute__((at( )))指定地址。# A& v# ~$ E; r) T, D* K. a) i8 g+ I
. ?- J: [" r; V8 v/ W! \2 |0 d
  1. /* D1域, AXI SRAM, 512KB */
    6 R- l  N& y2 ]% Q+ {+ z5 D# l1 E
  2. /* 用于获取当前使用的空间大小 */
    4 c% L3 c# j$ r' w: j* @9 M
  3. mem_head_t *AXISRAMUsed;  
    # K6 j* i) F7 H( {; c; U- P
  4. /* 指定下面数组的地址为0x24000000 */
    3 n: B! v9 M* z- r, a& X' z# z9 P
  5. #pragma location = 0x24000000
    / l4 o7 g$ Z' T' z
  6. uint64_t AppMallocAXISRAM[512*1024/8];
复制代码
9 k. i9 ]# q' m, t8 Z
  初始化动态内存区+ S4 V5 b1 U, k/ v
调用动态内存管理提供的函数osRtxMemoryInit即可做初始化:
- |+ u% k0 b1 ?6 `6 I# K: E/ E, c( k# B2 `5 l
  1. osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));4 L3 s' Q' S; G! M
  2. osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
复制代码

2 _) a* {( V- H$ m' R' `9 Q  申请动态内存
1 ]0 \( C! ]8 x) Y/ h通过函数void *osRtxMemoryAlloc (void *mem, uint32_t size, uint32_t type)做动态内存申请。, k+ d& E# O% t& K( ]
- t. }7 j( a7 p7 Z2 Z. R
第1个参数填写内存区首地址,比如申请的AppMallocDTCM,就填AppMallocDTCM即可。
  S3 g& `/ W% J; i% R9 F4 _. w$ g
  m* R" j( M) E第2个参数填写申请的字节大小,单位字节。
8 O+ Y1 C) p6 N. V1 f" B
& U) `2 p4 e  \6 J第3个参数固定填0即可。% {! \6 P# r& \! _& Y
+ C6 f4 ?4 v7 r0 x# u- c. z
返回值是所申请缓冲区的首地址,如果没有空间可用,将返回NULL,这点要特别注意!
) Z1 Q/ I! D0 V7 v4 s8 m' n1 p3 D
" ]% X- u7 U( L( |) F4 M举个例子:
! h3 O; j2 V. Z+ t) a, r3 |3 @
  r6 u3 A. Y6 D
  1. uint32_t *DTCM_Addres0, *AXISRAM_Addres0;2 }+ T# f' s" g7 |2 L, R

  2. ) p# a# P# h" W. c
  3. /* 从DTCM申请280字节空间,使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */        5 P  I  X( T( I' a3 z
  4. DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);* k: E$ x3 _3 Q5 J
  5. DTCMUsed = MemHeadPtr(AppMallocDTCM);" C; }# Z. _% G( I) ~; p0 a
  6. printf("DTCM总大小 = %d字节,申请大小 = 0280字节,当前共使用大小 = %d字节\r\n",
    $ E5 S# r' W5 M/ z3 F8 {# }$ O+ Y
  7.                                                              DTCMUsed->size, DTCMUsed->used);. B, G) D/ N! J( l) J# D

  8. . D' r/ u4 e1 s$ {' ?  N
  9. /* 从AXI SRAM 申请160字节空间,使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */        
    + `$ F& Z1 r% _* G
  10. AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);4 C9 H6 T! ]4 {& v3 X" C
  11. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    ( Z2 r# P; h" g3 V( ^6 q, z. T
  12. printf("AXI SRAM总大小 = %d字节,申请大小 = 0162字节,当前共使用大小 = %d字节\r\n", % c3 R: ~- B% l) P% V
  13.                                                             AXISRAMUsed->size, AXISRAMUsed->used);
复制代码

9 {: ^6 S6 u6 x* X4 x4 e申请了空间后,就可以直接使用了。另外注意红色字体部分,通过DTCMUsed->used和AXISRAMUsed->used可以获取当前使用的空间大小。# O* A% c- X  `; F9 R

0 }2 q+ {, t. ?7 C/ X; }  释放动态内存
2 [' B1 e/ O; m) L) ]通过函数uint32_t osRtxMemoryFree (void *mem, void *block)做动态内存释放。) M' }6 a! J5 v$ l8 a# ?5 ]
8 ~3 ^, u- _$ p6 D8 o, \1 K  c4 k
第1个参数填写内存区首地址,比如释放的AppMallocDTCM,就填AppMallocDTCM即可。% ~- O& Y; M8 ]3 \9 l9 k
3 p4 E5 g2 J4 R; z' f
第2个参数填写申请内存时所获取的内存区首地址,这里用于释放。
6 a9 z6 F5 x( O+ ^# L% H
( c& j5 |6 \2 E+ O: @4 e返回值,返回1表示成功,返回0表示失败。" W' O/ \$ Z6 O( a; N1 D. Q8 I# C/ v9 P/ r
  q, z9 i( [  A, f: t
举个例子:
  G8 D; j6 d. _2 e" p  Z0 R; N
' I7 {& m( W$ Y
  1. /* 释放从DTCM申请的280字节空间 */
    : Z$ o4 n  S$ H4 w
  2. osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);0 z8 ]8 s0 M1 Z/ F
  3. DTCMUsed = MemHeadPtr(AppMallocDTCM);
    " x* q4 h6 o" U% B
  4. printf("释放DTCM动态内存区申请的0280字节,当前共使用大小 = %d字节\r\n", DTCMUsed->used);
    8 N$ D) n3 a! a) B6 X: ^0 i$ X1 t
  5. + W9 J- R8 R' V2 c
  6. /* 释放从AXI SRAM申请的160字节空间 */
    . U+ q  a: l7 y
  7. osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);9 q, c* ]0 E7 d; y+ }& Z2 g
  8. AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);1 Y( m# M) M0 k& `, w; Y
  9. printf("释放AXI SRAM动态内存区申请的0160字节,当前共使用大小 = %d字节\r\n", AXISRAMUsed->used)
复制代码

* w. e$ t, v5 X. w* {) h+ b27.4 实验例程说明(MDK)7 L  R* X4 R% R
配套例子:: Z3 Y6 `" v9 Z
V7-006_TCM,SRAM等五块内存的动态内存分配实现
$ N/ o  U3 h* F- I6 y# C: c# g) T, J$ G& t" R* ^6 A, _1 I7 L5 o
实验目的:9 ]  L; T& ^: S
学习TCM,SRAM等五块内存的动态内存分配实现。% Q. ]5 V$ ^3 D- N: Q% ^

7 Z: O/ w5 u- e% c% B
1 j- D4 T' v5 d: U3 ?实验内容
' t' ^. [, p; I; x* `启动自动重装软件定时器0,每100ms翻转一次LED2。
0 d# P6 Z2 i8 `# Q; l5 q
6 ?  S" k6 f3 z7 E
0 F' M+ L  a' X' {7 y* ^+ K# k实验操作:& K9 l9 t* X8 G! K/ M6 X
K1键按下,从DTCM依次申请280字节,64字节和6111字节。
& q/ y+ N8 d3 v9 M% bK1键松开,释放从DTCM申请的空间。6 W- h" L# m+ c9 g& c
K2键按下,从AXI SRAM依次申请160字节,32字节和2333字节。
0 `6 `9 H, d. s( w) \2 N' `K2键松开,释放从AXI SRAM申请的空间。# f& r' k' H7 M# E% B3 V" \
K3键按下,从D2域SRAM依次申请200字节,96字节和4111字节。' B, ~0 d6 Q! K1 f6 g
K3键松开,释放从D2域SRAM申请的空间。
" L* i; L$ Y$ b/ G4 f2 I& G摇杆OK键按下,从D3域SRAM依次申请300字节,128字节和5111字节。! N( u6 l6 m, H% a3 m6 _  t! Z, G: m
摇杆OK键松开,释放从D3域SRAM申请的空间。
- \* N: _" H  V9 \  V/ i( J, a2 V" [5 i8 ]+ P5 @
1 ?0 v. ]7 S# [
上电后串口打印的信息:
& ^. m! x1 ?) q7 d- `
6 P1 J$ r8 H. M  V8 B( D( z! U波特率 115200,数据位 8,奇偶校验位无,停止位 1; P9 B- R$ ]  b

  H5 r3 O" T, J. M8 `/ B% x9 i
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png
) h- i( {  m5 u2 Y- b# t2 J' _

9 P. r) k' T% ~6 Y# t/ M# [- J程序设计:
/ u* m: ?+ J5 \9 s) s; G; S' M' z: L$ {, h
  系统栈大小分配:7 I3 x- G$ O- S0 E3 r
% p; ^% |# w# _$ c
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png

2 m7 p9 G: M# ]: e$ o( q8 ?$ {' j9 o3 X. Q; D1 ?- Q) @! X
RAM空间用的DTCM:
3 \' ^: f7 t0 I, Q; N0 X4 X4 d' l
8 F2 {' d# r5 `0 \
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png

7 i1 [4 I4 D8 {1 N9 n
* }+ U  l7 @! f1 z' v  s  硬件外设初始化: [' j& c9 b2 S5 {# ]

: K; U) p! N' x6 x硬件外设的初始化是在 bsp.c 文件实现:2 I" j2 u2 k2 A8 m% j

+ \; X* K5 t, s: L$ L* `
  1. /*9 O7 T  m0 E/ D, C! J! L+ {: {
  2. *********************************************************************************************************
    # v5 v. S% }, `1 K
  3. *        函 数 名: bsp_Init
    ; D  [) M: C) R$ L  s
  4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次3 q; k! z" K# ~, w8 B& a
  5. *        形    参:无
    & a" b2 w1 j7 |- T2 F
  6. *        返 回 值: 无7 D3 e+ \9 D6 T6 U: i) g* L
  7. *********************************************************************************************************- _$ a1 l& R$ j7 p( |
  8. */
    ; C: R1 k8 v( i3 i8 H  u- \
  9. void bsp_Init(void)
    + Z+ C3 _" A' z0 m# v2 U
  10. {( ]' a3 l$ V8 r1 p' z
  11.     /* 配置MPU */
    7 G/ h& A/ ]6 y6 J4 {  k) G& f
  12.         MPU_Config();
    ' x" v( z  L% {# z" x4 Q
  13.         , z9 O6 f; ^" V
  14.         /* 使能L1 Cache */
    3 Z. ?0 _! v5 J0 {; O9 T
  15.         CPU_CACHE_Enable();
    : q9 n/ I  s1 s; q( t/ m# R* w
  16. 9 G0 D9 W7 n" N3 t6 I+ G
  17.         /*
    ( B0 n! Q2 N, b: J1 `+ G; z
  18.        STM32H7xx HAL 库初始化,此时系统用的还是H7自带的64MHz,HSI时钟:
    0 q# L$ M) f5 C9 F# {. W) h( I; N3 k
  19.            - 调用函数HAL_InitTick,初始化滴答时钟中断1ms。& g% @0 K# ]( x$ s. n8 k2 R
  20.            - 设置NVIV优先级分组为4。$ S% ~4 e$ f0 Z+ w: C
  21.          */
    . u9 b: D% X2 m; N
  22.         HAL_Init();- W8 v& x  U9 ^/ U, a$ o+ }/ w( Q
  23. . h( |5 D0 X' z5 M
  24.         /*
    7 Y* B0 ^4 H! w$ L' j
  25.        配置系统时钟到400MHz- I+ C; ]# C- Z+ b' S( d0 A& ~
  26.        - 切换使用HSE。/ a/ e1 h9 h3 ]3 B
  27.        - 此函数会更新全局变量SystemCoreClock,并重新配置HAL_InitTick。
    ( F" S. S: @2 B, ?
  28.     */( C  t0 B/ Z' h1 V
  29.         SystemClock_Config();& H) e/ q0 N( |0 S4 n1 j7 J

  30. 6 X2 X6 t0 |8 l0 t8 m
  31.         /* 2 d; w4 [; P( _  P6 a; w) ~6 \2 R% B
  32.            Event Recorder:
    : Y9 K5 B6 \! M! }5 L( E
  33.            - 可用于代码执行时间测量,MDK5.25及其以上版本才支持,IAR不支持。9 h% O, J& X' I4 P% ]/ C
  34.            - 默认不开启,如果要使能此选项,务必看V7开发板用户手册第xx章' \% D% f1 w3 D# y" \. Q/ d' G
  35.         */        
    ) \( t, s: D% L) C8 a/ m) p; w
  36. #if Enable_EventRecorder == 1  : g9 i& L) X" F' z+ O0 Z0 N) R4 h
  37.         /* 初始化EventRecorder并开启 */. m8 L# p& o( R$ P' E# H# R
  38.         EventRecorderInitialize(EventRecordAll, 1U);
    " |+ c: o" V1 v: }, |
  39.         EventRecorderStart();: y# B( {% Z; k
  40. #endif
    5 Z0 R0 j# ^: U; @$ m
  41.         $ S& L5 n( C! @3 V. O, r
  42.         bsp_InitKey();            /* 按键初始化,要放在滴答定时器之前,因为按钮检测是通过滴答定时器扫描 */) S" Z' N$ y" L( \: s7 @3 s
  43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    - r0 h1 ^& r- X0 Q* {4 |; U' P
  44.         bsp_InitUart();        /* 初始化串口 */" X* P! @) T# w# m
  45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    " A( c. k5 \0 d
  46.         bsp_InitLed();            /* 初始化LED */        
    % g! v3 X. X0 I" t
  47. }
复制代码
, f  O  l" O$ M) \+ z5 F
  MPU配置和Cache配置:
) F8 P0 r; o2 Q: g9 g- r数据Cache和指令Cache都开启。
) D9 q7 Q; \% {7 i
: f4 g$ z0 S0 V/ d* {2 h- SAXI SRAM的MPU属性:
2 t. Z3 R! f3 H1 h. J3 H% b1 D* }
6 `6 m! i& h' e/ \4 SWrite back, Read allocate,Write allocate。3 h0 A- E3 n1 K1 e" j  R+ j5 b- U* {) G
% L% E6 R! L: o' g, F# G6 `
FMC的扩展IO的MPU属性:
' `, L9 ~2 c, p. I
* o) b8 R6 l1 l( ]6 {5 x0 ?必须Device或者Strongly Ordered。/ ?/ L0 F8 V. H- w1 M+ }( I
/ M& k$ R$ J! J$ j$ ], M
D2 SRAM1,SRAM2和SRAM3的MPU属性:; h- g" O, b" x  @# g

- M; @0 o! O6 @2 z0 Y: RWrite through, read allocate,no write allocate。
" w- C0 u/ ^) ^3 e, {3 V% Z, M) @3 _2 R# r& @4 B
D3 SRAM4的MPU属性:9 @& K6 n0 i/ o/ A/ B  S  {6 |5 {, X' ~

' E. Y/ g/ _7 C/ N2 EWrite through, read allocate,no write allocate。
) r2 @) D9 l0 l6 T* C4 F( ?# p6 t" G5 s1 O
  1. /*
    ' @  F8 @. o3 M$ b' W
  2. *********************************************************************************************************2 ?+ U9 }& k. t2 l: t" Y
  3. *        函 数 名: MPU_Config
    / U( @' ?, m& p
  4. *        功能说明: 配置MPU/ O. N8 J2 \' [! c9 ?! |: K5 ^- v
  5. *        形    参: 无" B6 F+ U( ^/ ~$ n
  6. *        返 回 值: 无
    9 {' j& \7 [; x6 S! `  `
  7. *********************************************************************************************************! g( O' {; Q" W7 |/ J
  8. */
    5 Z7 u! v0 q" X! Z% h$ f
  9. static void MPU_Config( void )  ~5 u# j* {, ]# k
  10. {
    4 J+ }2 L% Q: H
  11.         MPU_Region_InitTypeDef MPU_InitStruct;
    % V! H; ^) J$ i0 d# l

  12. & ~( h4 v) c. X$ N+ n- |* Z
  13.         /* 禁止 MPU */) w7 C+ g  m( P1 y! U
  14.         HAL_MPU_Disable();: d3 V& R) D! `% f8 U) A

  15. $ J+ [$ x0 a& \- Y4 `' n' f, J. k
  16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate,Write allocate */
    + v! ^9 z3 ]* E, R
  17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;9 ?: ^) ]# E* |) {" l2 j& \
  18.         MPU_InitStruct.BaseAddress      = 0x24000000;) n0 J7 P" H% W: e) Z
  19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;2 ^( S) p4 t0 ^/ C
  20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;/ x) P% q9 z; H9 N
  21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;, n( \# C! q6 `' h" A
  22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;0 m, h$ Y& i% d: X0 P+ a- u4 Q4 [8 z
  23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;' |7 D. R4 l5 s3 u: F
  24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;/ v$ `# T4 g  ~" M
  25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;7 F, `# ]. I8 e+ R, E
  26.         MPU_InitStruct.SubRegionDisable = 0x00;4 Q  L& ^" y6 n+ _, Q- k
  27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;2 n' H/ C9 Z9 K. S

  28. + I! G' l7 A+ q& c2 S  P
  29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    # A) Y, A0 L8 F; ]; d6 A+ w( {5 ]
  30.         
    : N. V0 s8 C. ]" y5 h# S4 Z
  31.         
    7 I# z9 Z  W* B, Y4 t; p
  32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    . ~2 f8 I. Q4 h  m, {
  33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;  t0 J4 c) v- z# S
  34.         MPU_InitStruct.BaseAddress      = 0x60000000;9 F& V7 A/ j5 Q  c
  35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        / G2 H" F& b1 M, r6 e
  36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;" s1 A" @/ Z+ D  l* R0 E
  37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    9 H0 Q9 F2 T, T1 Y
  38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
      f: U5 O) X- g' i3 t
  39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;4 m5 `" i3 p% b9 k
  40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    0 ~$ h. ]4 j0 M
  41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    . t8 n* ~8 N5 m. f
  42.         MPU_InitStruct.SubRegionDisable = 0x00;' A  I% T2 J. r6 c- @- W1 |; _1 {  a) X
  43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    + o+ w3 I/ \, _, k% Q8 G& b! C# v
  44.         1 l2 R$ _$ B. f; j0 s
  45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);9 N7 z+ F: s4 o" X0 d
  46.         
    4 f4 }5 ]( `  j
  47.         /* 配置SRAM1的属性为Write through, read allocate,no write allocate */* S3 s$ O& B( r2 H( J
  48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    : V5 w# V  P& I  }8 B
  49.     MPU_InitStruct.BaseAddress      = 0x30000000;; q% X3 s, v% k; d  O. a. X
  50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        5 h7 ]% Z7 b7 L, Q' O6 c& A
  51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    1 G* G! x0 B4 D& z
  52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;& u: G. {8 g0 d. o: d/ H
  53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    7 g; l( J  N9 u+ f. |
  54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    / f' S) E3 j' m; t; o
  55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    : g/ h- `1 K6 Y# c
  56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
      ^( R' t- ~6 q) }4 X2 K" E& P7 Q
  57.     MPU_InitStruct.SubRegionDisable = 0x00;
    1 J) H- O! S/ s8 B! k& Y
  58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    # T& ~! M: i3 J

  59. ( l4 F1 F3 C0 ^! |& P
  60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);! ]1 q) q. E) Q$ T
  61.         , j% |; F/ \$ G7 H8 j, Z
  62.         /* 配置SRAM2的属性为Write through, read allocate,no write allocate */
    - `/ C; L4 d& b8 ^$ f
  63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    # _, H1 r' b) R& z/ C/ ?; d5 |! S
  64.     MPU_InitStruct.BaseAddress      = 0x30020000;
    ) {  I1 Q- V! k
  65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        
    9 D1 {8 C$ ~5 \6 n: b" @# v$ \" _
  66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;8 {/ x9 _- a+ P
  67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;8 w' l$ n1 l% y
  68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;7 D6 Y5 @% c! Y* ^  E. S* h; E
  69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ) V2 ?: Z+ n" u9 F
  70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;
    2 F+ [6 K  ^; E6 j7 U4 T& W( r
  71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    % h+ {; s; c$ c  l2 g# @+ p7 ^" B
  72.     MPU_InitStruct.SubRegionDisable = 0x00;3 C: N  `, n* J2 k' |" k+ i$ e
  73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    3 I* ~7 {6 V' ~/ U  A  C" L) S" T
  74. 9 Q3 [# X5 |9 S1 b
  75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    0 C* i- h! O9 n  S4 z8 h; ]
  76. ) V, M5 h' _0 E3 I
  77. , Z0 q. H3 ?9 R5 r& l# D# ?- |
  78.     /* 配置SRAM3的属性为Write through, read allocate,no write allocate */
    % v" |; M5 P) {: @! P" F
  79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;7 m3 w8 Q( V; \3 L" ]& T
  80.     MPU_InitStruct.BaseAddress      = 0x30040000;" S' F- C$ L% p) p+ A% g9 l: i+ [
  81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    + k$ e! u+ ]8 T2 l; z
  82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;) F( g- y/ d2 p/ N0 o& i" d7 S
  83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    1 @9 K/ }0 o+ v9 \
  84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;+ f0 E) d% Z$ m
  85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;+ z; f5 B  Z7 q) ^% w
  86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;: M# k' R: p! f: r, V% ?) }
  87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    & j. |7 X1 B4 }. y  I  g
  88.     MPU_InitStruct.SubRegionDisable = 0x00;6 S/ d; |+ m9 u; i. s
  89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;* ]* u+ D9 T$ Q0 B1 f; H/ `% {
  90. 0 V" q& Q( o7 S4 I  j$ \8 {6 U3 z
  91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    6 l1 R$ R/ F" M) ]- p* s
  92.         
    0 H' T" ]! ~, B8 X
  93.         
    2 o  Y) g, P1 b. d. g  V4 I( {) H% v5 d
  94.         /* 配置SRAM4的属性为Write through, read allocate,no write allocate */
    : c# ~% Z3 S9 H; Q
  95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;, l0 x8 T! `" `' q$ b, \0 p3 |5 s
  96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    " u! t8 j- X3 |  u8 N' V" i, U
  97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        1 z9 d% a$ h( u' y
  98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;6 J3 O' r7 S! D/ |) U9 {6 S
  99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;) D. w  M9 q3 B. ~
  100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    . |& b% A, d0 Q7 e
  101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    " Q  Q$ R9 e, z$ @
  102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;2 G1 Y! V. H1 r: L  _  ?9 n, l5 T
  103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;- j& }- C  b* h+ e4 t% e: v
  104.     MPU_InitStruct.SubRegionDisable = 0x00;
    0 ~& H/ M* o1 s! o# s  H7 E; P
  105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;' H1 h) Z, Y- n# m

  106. - i) H# J, i- Q1 T7 l/ Q9 i6 F0 K2 {/ V
  107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);; d! G. q7 g3 N
  108.         # k7 e+ E9 y! r# h7 k
  109.         /*使能 MPU */5 c) z$ y9 e7 |! R6 E% R0 l
  110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);8 x1 E5 \7 U1 q7 a4 L( M
  111. }  R' {8 b  i4 H
  112. 5 Q. ^0 i% J; `- R5 f
  113. /*
    * }, Z# t- B( y/ s
  114. *********************************************************************************************************$ i5 j7 P# P/ U- ?( V
  115. *        函 数 名: CPU_CACHE_Enable$ k6 n/ x, G% O1 L* K& Q( {7 B
  116. *        功能说明: 使能L1 Cache; R, o/ S4 V- n( q7 ^0 m1 \! Z0 P
  117. *        形    参: 无, Q  d  ~" Q) ]: p8 m
  118. *        返 回 值: 无, P3 B) [# B& N' Y0 S* w! R
  119. *********************************************************************************************************
    ; j0 x  l8 r" e: b
  120. */( i4 G0 m- @( O" c. _0 |. C
  121. static void CPU_CACHE_Enable(void)2 ]  d/ y+ L/ D5 x- ]) F
  122. {
    % y4 X/ }- ]- s* n+ E  k' D+ g
  123.         /* 使能 I-Cache */
    5 q' @0 r3 Y0 Y3 M8 \0 M2 f' w5 D
  124.         SCB_EnableICache();
    : ~3 ?) J. K% [

  125. 0 h1 m; h* L( Y3 u
  126.         /* 使能 D-Cache */
    ; a4 i/ M" g' H5 E. i/ S/ R
  127.         SCB_EnableDCache();! [" E9 ]' |2 \/ |% b
  128. }
复制代码

  [0 P' U$ {# m% M7 `  主功能:
* S) {1 j2 e+ b2 S3 d( E  S- W/ a. M* D8 o+ P) W6 N
主程序实现如下操作:
5 E. ~3 F: U' }- j% G( m' T+ m) z
3 |' N7 G2 l$ W) @) H4 W  启动自动重装软件定时器0,每100ms翻转一次LED2。% i5 I+ V) E! [) i! c3 @7 z
  K1键按下,从DTCM依次申请280字节,64字节和6111字节。
; C# ~) _( Y0 r! ~  j4 L: p1 s9 Z2 _" r! d  K1键松开,释放从DTCM申请的空间。  w) s" H' O  T5 n+ W, X
  K2键按下,从AXI SRAM依次申请160字节,32字节和2333字节。
# m! J, G2 E& D- ?; W  K2键松开,释放从AXI SRAM申请的空间。: G* _5 K% W& k8 {: w; V
  K3键按下,从D2域SRAM依次申请200字节,96字节和4111字节。8 J1 q! ]# N: t4 A/ i; U
  K3键松开,释放从D2域SRAM申请的空间。
5 M6 U8 d/ D+ S6 T9 Z: M  摇杆OK键按下,从D3域SRAM依次申请300字节,128字节和5111字节。
0 o. E, `- D( a3 f  摇杆OK键松开,释放从D3域SRAM申请的空间。
" w0 l# S- I+ n. ]7 W9 m& p
  1. /*8 [+ K/ s/ _0 R' J' c0 x8 U) l: C
  2. *********************************************************************************************************
    + @5 k( {  P& D' m% _
  3. *        函 数 名: main
    # E2 f; C6 t3 Y3 f/ {$ O/ `
  4. *        功能说明: c程序入口
    ( d4 K/ D. i$ e2 B$ G" ?8 U
  5. *        形    参: 无4 L5 v, e! \: h( p5 }6 G
  6. *        返 回 值: 错误代码(无需处理)
    0 Y8 `* T! x1 i$ P( B
  7. *********************************************************************************************************& g3 [5 G4 |6 q) [; L
  8. */
    - e! l- u9 R# o5 [  b! G; T
  9. int main(void)0 b( u6 Z7 S/ t% ]
  10. {
    ' X  Y$ I" y+ k) w1 H$ |' ~7 d9 {
  11.         uint8_t ucKeyCode;                /* 按键代码 */
    " [5 r( |+ ^. i) b* ^
  12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;  m  L: G" j( ~9 u2 J3 v' ?
  13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;5 b) c' C1 Y6 z4 q
  14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;# ~$ z+ u/ a; n4 d: ?
  15. . I( s1 b% \, j" u/ d: {
  16. # T" N  _8 s' ~) K
  17.         bsp_Init();                /* 硬件初始化 */& B# s8 A& U: v$ q2 ~
  18.         
    ' N8 H; z8 q4 S( O8 r
  19.         /* 初始化动态内存空间 */
    / h1 Z/ F5 \' m5 K& a. x( b) g( `! E
  20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));
    . A3 p" k3 b7 Y5 i/ W
  21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    / q3 [4 S8 h* {8 d( Z* X
  22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));; ?. W9 }6 i5 h& Y0 z: U! H
  23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));! l1 q9 @- }+ ~4 H
  24.         $ I5 m# D2 B; u9 c
  25.         PrintfLogo();        /* 打印例程名称和版本等信息 */1 R3 O" K1 d4 A6 Y* J% i
  26.         PrintfHelp();        /* 打印操作提示 */$ l; _; O, A, h2 e& z# I0 n

  27. : \3 |4 y8 }3 a( W, J0 c6 ]2 o* B
  28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */
    ) E/ {5 A; \6 E: t2 d, g
  29.         & ]: N: n; b% @5 j6 k. \  v, p7 R

  30. % ]3 D- `+ D" e- l+ x7 o
  31.         /* 进入主程序循环体 */
    ' A! l- M: l( z8 [: O1 R
  32.         while (1)
      z7 i$ q- x: H! o
  33.         {+ |, s/ u( f" S7 G
  34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    $ H6 ^, f# a' H, Y( @4 k$ e$ m

  35. / I+ Y1 v4 t1 U, n! L
  36.                 /* 判断定时器超时时间 */  W' w" a8 V( }
  37.                 if (bsp_CheckTimer(0))        $ z6 V; f  e1 X9 r4 k( \
  38.                 {
    + O9 Y0 P: U9 ?* ^
  39.                         /* 每隔100ms 进来一次 */  , r3 p  C# S3 G) v2 c; o  d/ ^
  40.                         bsp_LedToggle(2);" v: S8 M% [1 P+ ]: g, |6 c# @4 J& ?
  41.                 }: A; ~* j  p! z8 r, B! X( p/ ~4 Y

  42. / M; \; d, X4 ?% J
  43.                 /* 按键滤波和检测由后台systick中断服务程序实现,我们只需要调用bsp_GetKey读取键值即可。 */: F: E5 o$ a: i0 G( W8 b( L: H0 s" s
  44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */0 ~' j5 o/ Q- o2 n
  45.                 if (ucKeyCode != KEY_NONE)
    . G) @: O" N6 T$ O! m+ p! W
  46.                 {" b3 _" \' t$ M6 U. l1 Q4 N
  47.                         switch (ucKeyCode)
    5 W  j/ j. ~' a$ [( s  T2 l; u
  48.                         {# j2 x3 T! n# ?& p
  49.                 /* 从DTCM依次申请280字节,64字节和6111字节 */
    / d. b) u0 J  L+ ]) C  L  b+ h; K
  50.                                 case KEY_DOWN_K1:        
    / S, T: k: a# }( V
  51.                     /* 从DTCM申请280字节空间,使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */, O: z- {! a6 n; @7 I) Y
  52.                                         printf("=========================================================\r\n");
    ' W: E! n  w: W4 P( R7 x
  53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);) |" P; `* T) ~( D# N& F* u4 j3 D
  54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);5 f# J6 Y! _5 P& z- p3 n! F
  55.                                         printf("DTCM总大小 = %d字节,申请大小 = 0280字节,当前共使用大小 = %d字节\r\n",
    & B' ~8 y: H  T' r1 G4 y2 _
  56.                                                                                 DTCMUsed->size, DTCMUsed->used);; a: R5 [5 l- E1 e2 J* t
  57.                                 / i8 \& R5 o4 }* M
  58.                         /* 从DTCM申请64字节空间,使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        : g0 ~0 [$ _/ ^1 n! F+ o
  59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);
    : B% f: b3 |6 m" j  I$ n7 k
  60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
      k: O/ X! K" g
  61.                                         printf("DTCM总大小 = %d字节,申请大小 = 0064字节,当前共使用大小 = %d字节\r\n", # |! R0 Z4 p5 j2 k
  62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    - E. E' h, a# \3 F% U9 X' Q
  63.                                 
    $ H4 b* I; ]. `0 Q8 }" C
  64.                     /* 从DTCM申请6111字节空间,使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */; A8 `, }8 y. p5 r
  65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);' F* m2 b) }; s/ H' g3 J
  66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    + m( Y: P# y: [8 |
  67.                                         printf("DTCM总大小 = %d字节,申请大小 = 6111字节,当前共使用大小 = %d字节\r\n", " X  S8 ?. ]3 d( I6 [
  68.                                                                                 DTCMUsed->size, DTCMUsed->used);# J0 d$ R( D9 s/ {/ W# U! {
  69.                                         break;: a: c+ J$ _3 X  H" `: w
  70.                                 & F. p- s8 w1 s" O$ W
  71.                                 /* 释放从DTCM申请的空间 */& Q9 R) {+ e6 o' z, C: @; u( {
  72.                                 case KEY_UP_K1:        $ O% V( j  m9 ^4 j% F0 ]& M
  73.                                         /* 释放从DTCM申请的280字节空间 */8 r1 U( x: d) R7 A9 a
  74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);
    ! [9 m! {6 A/ |& X/ {* V
  75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);3 f2 R4 m% w$ ~; P
  76.                                         printf("释放DTCM动态内存区申请的0280字节,当前共使用大小 = %d字节\r\n", * ?0 ~7 d/ w* Q/ }& ?
  77. DTCMUsed->used);
    : p- P9 A. ]6 n, d) l3 @/ U% d# g
  78.                                 + R$ q9 |! {* N6 T; @" k
  79.                                         /* 释放从DTCM申请的64字节空间 */
    9 w+ h; P' s& I2 q3 H5 E) o: s
  80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);, a  \; ^8 C) a( @2 q5 \1 L5 m- `" J
  81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    3 n( y& o: @. y7 B. A1 @
  82.                                         printf("释放DTCM动态内存区申请的0064字节,当前共使用大小 = %d字节\r\n",; M7 j: r5 V8 ?2 ^5 |2 D; S! y
  83. DTCMUsed->used);
    ' h0 J* Z9 u6 r+ l
  84.                                 * }! y# ~  q9 w; H
  85.                                         /* 释放从DTCM申请的6111字节空间 */3 l$ p$ g- J1 E1 o$ S
  86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);* p2 ~% g$ \+ R# W& B
  87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);, D6 l' P7 P! C' i
  88.                                         printf("释放DTCM动态内存区申请的6111字节,当前共使用大小 = %d字节\r\n",) {. {  a- s  X% ]; _+ V' P
  89. DTCMUsed->used);
    ! H1 |" E+ ?1 u: L4 ~
  90.                                         break;9 h$ q! T8 [5 S! t: s' c
  91.                                 
    . M2 O7 M5 R* P6 M
  92.                                 /* 从AXI SRAM依次申请160字节,32字节和2333字节 */
    ' b. x3 u# Q; ^2 ?6 h4 S( Z' T& v
  93.                                 case KEY_DOWN_K2:        & w8 b1 K7 f4 ^' C* ^
  94.             /* 从AXI SRAM 申请160字节空间,使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */# t3 z7 i2 S! F' q5 Q/ [9 L6 m
  95.                                         printf("=========================================================\r\n");                5 a! y# F& h; W  D0 I
  96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);
    ! y' e9 E! O* q
  97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    4 c5 A0 X# a6 Z9 T2 n0 R
  98.                                         printf("AXI SRAM总大小 = %d字节,申请大小 = 0162字节,当前共使用大小 = %d字节\r\n",
    ) z0 F4 P- [5 U
  99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);, M! z  I# P9 Y1 Z& D% b
  100.                                 0 v6 L: c! k! l  I2 ~, ~
  101.                         /* 从AXI SRAM 申请32字节空间,使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */) B/ {; D  H  ^! T- n$ T% T3 F
  102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);4 r/ |! R3 v+ W/ ]& G' E, Q
  103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    * G5 b% m0 n2 M# @' T& j/ T
  104.                                         printf("AXI SRAM总大小 = %d字节,申请大小 = 0032字节,当前共使用大小 = %d字节\r\n",
    3 T& Q" C- O# l1 w
  105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
    8 X( a+ W# \8 k3 S, v
  106.                                 
    5 K8 I% {" Q& E3 s7 Z; l
  107. /* 从AXI SRAM 申请2333字节空间,使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        
    6 j/ A* u. a/ D# M- H
  108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
    9 v3 U) W5 P$ G
  109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);8 E2 \+ R: y# z# h' A# [) S# y# F1 i3 G
  110.                                         printf("AXI SRAM总大小 = %d字节,申请大小 = 2333字节,当前共使用大小 = %d字节\r\n", / N/ i* ]6 c+ s  b) R: Q
  111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);2 L( y1 \9 q% _
  112.                                         break;
    5 \7 O. g7 s$ r3 ]. u. A4 ]' ?; w% D
  113.                                 ! s( H7 H; ]/ W& w6 ]6 r9 q4 o
  114.                                 /* 释放从AXI SRAM申请的空间 */
    8 B6 o+ Z7 ~$ Q& b1 t; E  C' _
  115.                                 case KEY_UP_K2:        8 ^) T% V, O, o& s/ y6 R
  116.                                         /* 释放从AXI SRAM申请的160字节空间 */& d! A* V" G# N
  117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);
    $ A2 }: [$ m  I% m/ t8 {
  118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    ( ?4 |4 B- z1 u" F* }' c
  119.                                         printf("释放AXI SRAM动态内存区申请的0160字节,当前共使用大小 = %d字节\r\n",6 W8 S& f+ \- W! ]4 p/ ~3 {
  120. AXISRAMUsed->used);; \% g9 H0 s. k, W: [# W& \0 }
  121.                                 2 o: }8 a3 W9 ]8 {# D8 m
  122.                                         /* 释放从AXI SRAM申请的32字节空间 */
      A/ }& J6 D0 k4 d; y- ^' o
  123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);- n! f- r: i1 m/ c, f* n
  124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);, o6 f. A6 z1 j2 j! N7 N& k% ?
  125.                                         printf("释放AXI SRAM动态内存区申请的0032字节,当前共使用大小 = %d字节\r\n",* K0 @0 a4 C/ u. v1 d( }: a
  126. AXISRAMUsed->used);" L6 l4 S4 F) h) v, t: K  W% l
  127.                                 5 U" D9 |: `, X) @" Q) ]+ ^
  128.                                         /* 释放从AXI SRAM申请的2333字节空间 */
    0 y2 U4 C) O& h5 ^/ W, O7 x- D7 Z7 r
  129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);( M- t* _0 _2 o+ \) w: F
  130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    . x5 W$ g2 C: q2 p; T. L' s; ?
  131.                                         printf("释放AXI SRAM动态内存区申请的2333字节,当前共使用大小 = %d字节\r\n",
    + R( C7 v# `( ]! `( N$ _! V7 F
  132. AXISRAMUsed->used);3 U0 [" O9 A! t/ Z, G
  133.                                         break;
    1 T8 Z1 l2 J0 h
  134.                                 
    8 [. @2 t7 C* G( M7 L: N8 B7 C/ r
  135.                                 /* 从D2域SRAM依次申请200字节,96字节和4111字节 */
    5 y& l3 ]) P5 x; f  C8 F6 Q- T
  136.                                 case KEY_DOWN_K3:        
    # Y* r9 r1 o* _; d2 t  r
  137.         /* 从D2域的SRAM申请200字节空间,使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */; W; i+ \3 B* v& W; D  i
  138.                                         printf("=========================================================\r\n");                + V+ e8 [8 t3 I8 e. A
  139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);: {, j+ r# A3 w( T% v
  140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
    * H% B& c) u/ r7 ^$ Q. r
  141.                                         printf("D2域SRAM总大小 = %d字节,申请大小 = 0200字节,当前共使用大小 = %d字节\r\n",
    6 [5 J( F: l6 b* V2 H! Q
  142.                                                                                 SRAM1Used->size, SRAM1Used->used);; |. h4 X3 M' ~+ j
  143.                                 7 D! u8 T3 F. T/ z
  144.          /* 从D2域的SRAM申请96字节空间,使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
    0 e- r8 s7 C8 n2 T! Z: s% z7 o, H- T
  145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);  P1 N! F* R. Y( {; s9 x  v* g: n
  146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);- t  e$ \! p. k
  147.                                         printf("D2域SRAM总大小 = %d字节,申请大小 = 0096字节,当前共使用大小 = %d字节\r\n",
    6 i5 S; B4 a* p- {- z, M, @
  148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
    " E4 y  @# E4 v# }( E9 ^/ Z6 U
  149.                                 2 G0 P9 ?( M2 [/ \0 F& g
  150.          /* 从D2域的SRAM申请4111字节空间,使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */2 r. C) |8 C$ H9 c
  151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);) b& {7 j  n  L  [, [# f1 ]- u: n7 y; i
  152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
    * }5 @/ E4 ~7 N: x9 I& ~9 R" s9 ~- z
  153.                                         printf("D2域SRAM总大小 = %d字节,申请大小 = 4111字节,当前共使用大小 = %d字节\r\n", % I8 k# ~3 Y. O* V4 D5 I% P
  154.                                                                                 SRAM1Used->size, SRAM1Used->used);; h, @. w+ H" Z2 Q2 ?
  155.                                         break;& I" Y) @! m- {3 a5 r. ~7 H6 u
  156.                                 
    . ^- o: {6 i  C( L% P
  157.                                 /* 释放从D2域SRAM申请的空间 */
    ; n# S( A! F4 @
  158.                                 case KEY_UP_K3:        ! @5 `/ _; S. b8 B- V1 w
  159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
    8 {. F- b% D' s2 _6 \; G5 t+ Q
  160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);
    % U# B5 a, `5 k/ G; {; K5 j# r! v% v
  161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);9 u- v- M  S8 Y0 y. g
  162.                                         printf("释放D2域SRAM动态内存区申请的0200字节,当前共使用大小 = %d字节\r\n",- H7 u. M4 Y# N* s- W2 T
  163. SRAM1Used->used);1 x$ a, [3 p* a* r' M- ]/ U
  164.                                 
    % ^, n8 c8 S3 a3 o! e4 x
  165.                                         /* 释放从D2域的SRAM申请的96字节空间 */5 X, L5 @  {9 }6 g0 b
  166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);6 z' }5 K) [( q  E9 L# X
  167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
      t! ^2 T* u( p7 R2 Z. `
  168.                                         printf("释放D2域SRAM动态内存区申请的0096字节,当前共使用大小 = %d字节\r\n",! y( ]1 n4 }7 [$ W2 A0 f
  169. SRAM1Used->used);8 R* g  P2 d7 c3 h) l0 I* O7 G+ y
  170.                                 ) A  J, g! z* V% [- ]( V. K" @
  171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */( V6 _+ o9 u& A# o1 g5 t2 `! G
  172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);
    7 s  E4 l$ y/ t
  173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);: \( H* h! ^) A# o; L' b+ g' v0 Y) Q
  174.                                         printf("释放D2域SRAM动态内存区申请的4111字节,当前共使用大小 = %d字节\r\n",
    % q: E' ~+ _. _. ?
  175. SRAM1Used->used);
    - b0 U" V- y8 ]: A
  176.                                         break;  W0 e( Q3 C, f/ j5 I
  177.                                 
    " M) Z5 T; P+ L- W! C/ ~
  178.                                 /* 从D3域SRAM依次申请300字节,128字节和5111字节 */% P, v2 _" ]" Q" @; W
  179.                                 case JOY_DOWN_OK:        * E. Z2 r  J; N! H2 J1 w6 F
  180.             /* 从D3域的SRAM申请300字节空间,使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */
    # I+ L* Z) V) j1 [
  181.                                         printf("=========================================================\r\n");               
    ' d+ t$ p* F4 L" F
  182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);, F2 e' H; h* o0 {; V3 X! u
  183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);- _. i: G5 O* S4 h: y$ y4 U; {5 g
  184.                                         printf("D3域SRAM总大小 = %d字节,申请大小 = 0300字节,当前共使用大小 = %d字节\r\n",
    ! C) Z" i6 g8 L7 b8 e  T
  185.                                                                                 SRAM4Used->size, SRAM4Used->used);& z' a9 W) t1 g8 A" d
  186.                                 
    + B6 |, [1 ?4 \7 R$ ], c8 a
  187.                 /* 从D3域的SRAM申请96字节空间,使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */8 D' `5 U% n/ j! N
  188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);. e* {) [: @! w+ M  t; Y
  189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);9 |! ?7 N/ j4 ?8 h
  190.                                         printf("D3域SRAM总大小 = %d字节,申请大小 = 0128字节,当前共使用大小 = %d字节\r\n",   d# Y  M( y5 I  {; t" d/ H
  191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
      R  n# U/ m8 R5 N- y8 I
  192.                                 
    ( \' p' n/ [7 E9 ?( t6 L2 b8 a
  193.         /* 从D3域的SRAM申请5111字节空间,使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */! E, n2 O  h1 \! |
  194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
    : T2 O) n; f' h( J( i5 i: R
  195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
    # A# @; b* J" A
  196.                                         printf("D3域SRAM总大小 = %d字节,申请大小 = 5111字节,当前共使用大小 = %d字节\r\n", + C7 f1 L. d  Q5 k( C4 w* d
  197.                                                                                 SRAM4Used->size, SRAM4Used->used);
    : W+ n5 f! T. E6 ~: p; q
  198.                                         break;
    ! u+ i" H2 I1 O4 v
  199.                                 6 B6 B* |& [+ u% k8 k5 ~, ?
  200.                                 /* 释放从D3域SRAM申请的空间 */  ]4 {6 y; {- ^7 [- e
  201.                                 case JOY_UP_OK:        . W7 t+ O+ |& z1 v1 M' C
  202.                                         /* 释放从D3域的SRAM申请的300字节空间 */
    4 x# G, V1 A, m, o# a7 }: r
  203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);: g2 W" N8 I4 k. f3 m
  204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
    % J1 X8 I3 w" `5 F: }4 Y4 O0 f
  205.                                         printf("释放D3域SRAM动态内存区申请的0300字节,当前共使用大小 = %d字节\r\n", % w4 `, ?6 y, ]4 N1 O
  206. SRAM4Used->used);
    ; G* @' I2 x4 k& p- q
  207.                                 
    ( K. a8 p$ T9 S1 S2 h
  208.                                         /* 释放从D3域的SRAM申请的128字节空间 */( W) {; ~, I7 P& F' @% H
  209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);& T+ W$ j6 q7 m/ j3 u4 f
  210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
    ' Z4 i8 K& k( f, V6 l5 T
  211.                                         printf("释放D3域SRAM动态内存区申请的0128字节,当前共使用大小 = %d字节\r\n",; y" }) s* m! i/ q4 `$ X
  212. SRAM4Used->used);( e/ h8 S# ?' N" ^9 r
  213.                                 1 c# q4 m, X* V
  214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */. ?* y( c# v- `
  215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);$ l- C7 e% q0 Y9 m
  216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
    9 w! I* f6 h9 o; v. o
  217.                                         printf("释放D3域SRAM动态内存区申请的5111字节,当前共使用大小 = %d字节\r\n"," a! Z" r- z; D+ s) l3 G
  218. SRAM4Used->used);3 O& y/ J6 B6 y& S) a$ N
  219.                                         break;- ^- H1 G% ]: |# I
  220.                         
    - R! |2 p7 v0 F; S: [9 ~
  221.                                 default:/ K1 ^8 p* L6 ^/ w) p) I0 |
  222.                                   /* 其它的键值不处理 */+ }9 w$ E- z/ e% _4 Z2 S
  223.                                   break;) k& J& J: v; M# w+ H  B( Z+ W
  224.                         }/ P# u  k; e8 z1 t
  225.                 }
    & T5 {( P! p! L) `2 X% l5 n
  226.         }( N9 [& {( Y& X# o. @" n
  227. }
复制代码
8 h( R3 K9 j" c
27.5 实验例程说明(IAR)
: u# E1 }* ]3 w配套例子:, M4 ^. x- B, \! u: a  x/ e
V7-006_TCM,SRAM等五块内存的动态内存分配实现! j: _$ @1 Q3 N6 J! Z
5 q3 {& M; @. V% g7 K' ?7 [' F
实验目的:' B& U0 U- i3 `4 [
学习TCM,SRAM等五块内存的动态内存分配实现。) e9 l9 }5 V6 a/ k' k) [
( {2 I0 T; }+ }* X3 |0 G

. l: R7 N+ M+ I9 m. i. d# ^实验内容:
7 h& {; d( T3 ]启动自动重装软件定时器0,每100ms翻转一次LED2。9 d1 M( X& a: O0 {+ g2 n5 k
5 A, |2 u" N+ s$ B' ], O
实验操作:
; N& b* T4 s% l" ], C' VK1键按下,从DTCM依次申请280字节,64字节和6111字节。) y6 A* U& E! `0 d
K1键松开,释放从DTCM申请的空间。) g4 s& G3 O; Y4 p) ?
K2键按下,从AXI SRAM依次申请160字节,32字节和2333字节。
5 n) B& U8 X; G7 TK2键松开,释放从AXI SRAM申请的空间。0 V# J. V& Z4 r* r. ^
K3键按下,从D2域SRAM依次申请200字节,96字节和4111字节。5 T) O; Y" ?. V5 T3 \+ a, B" m
K3键松开,释放从D2域SRAM申请的空间。
2 ], C5 e6 B) C" E. F摇杆OK键按下,从D3域SRAM依次申请300字节,128字节和5111字节。* P: P) O( h4 o0 C
摇杆OK键松开,释放从D3域SRAM申请的空间。1 Y" Y0 ]7 f1 c* ]% G  j  X" E" U

6 e* ~7 ?) ^/ }& ~/ V上电后串口打印的信息:
! M" P6 A+ D7 @- b& ^7 J
" |: k6 ^0 {7 Y波特率 115200,数据位 8,奇偶校验位无,停止位 14 `9 o0 \0 @- F7 O- x  R5 G+ v. w
) s1 u6 v. }, [/ v% s- O- ~
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png

/ J/ ~8 P( b3 y! d6 U
4 m  u: i5 N4 P: W) g- i9 w$ z+ B程序设计:
* Y7 j3 H% }/ N6 O6 u5 N# d( q: d
. V3 d+ Y4 P- o( j  系统栈大小分配:' [+ P9 _. }  b" A" b& P
8 \1 e$ l' `. F4 y: }: \
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png

. [6 u- v1 I# I, b- o
3 r9 a! ?8 W0 F: u" c% [- S  RAM空间用的DTCM:
5 j/ V% P% I- w% c
" L9 V& O4 U6 J8 q2 M& R
aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDcvMTM3OTEwNy0yMDE5.png

! E% `% z- w! G1 z7 V4 _# l+ @7 x* X# Q8 h8 @5 X
  硬件外设初始化

# l) p/ t# l- O9 ]/ D/ ?/ ~
6 J( b! ~) B+ H4 q6 I硬件外设的初始化是在 bsp.c 文件实现:
( E0 L# v4 N" F3 W# C! k% ]4 u, i& W0 s# ]/ H
  1. /*
      A, `9 c4 W# s0 _, T2 C: [
  2. *********************************************************************************************************) `1 M$ P6 ~5 {
  3. *        函 数 名: bsp_Init
    6 ?" @* r. ]; f* J8 |8 C' u3 p9 `
  4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
    - R! f9 N7 e+ \* m
  5. *        形    参:无
    ! Y' J, v, ?  b) O5 d  L
  6. *        返 回 值: 无7 G' E$ k4 H' Y
  7. *********************************************************************************************************
    7 S% }& ?7 P; m% S) r2 y" B$ k. @
  8. */! z/ c/ `  `% ^6 H8 W0 q6 C
  9. void bsp_Init(void)) v% l  D% D$ `0 p& P0 p
  10. {
    - b$ O' W+ Y* F4 S# q
  11.     /* 配置MPU */
    , F( G9 f9 f4 [6 ~. [7 B7 B$ F
  12.         MPU_Config();; v) U+ y$ X* ~' a; A1 D
  13.         
    & j' n6 s2 D$ s+ F
  14.         /* 使能L1 Cache */
    5 {5 [7 k% R- h" o+ W
  15.         CPU_CACHE_Enable();
    ' `# }. Y$ J# i+ N: g7 r" u' e

  16. 5 `0 q+ f7 {" c$ n$ K# d
  17.         /* . r0 t% i' r0 O! q' u3 v0 a$ W
  18.        STM32H7xx HAL 库初始化,此时系统用的还是H7自带的64MHz,HSI时钟:9 c- v) i) ^" k1 O* f
  19.            - 调用函数HAL_InitTick,初始化滴答时钟中断1ms。7 {' k! `, U3 u/ Q  |
  20.            - 设置NVIV优先级分组为4。4 f1 h( {+ H2 I$ k
  21.          */
    3 @0 s( J! h/ ^4 e5 [
  22.         HAL_Init();
    % c' T1 e" d. m! r% P( b2 t# C1 x- n
  23. % F- y) M1 X! x9 n  j) E3 ?
  24.         /*
    , J' A7 @  ~, J: g) N. t
  25.        配置系统时钟到400MHz
    . X. R; w; \) b! S# ]
  26.        - 切换使用HSE。
    & D" u' D9 K0 {0 N
  27.        - 此函数会更新全局变量SystemCoreClock,并重新配置HAL_InitTick。
    $ h  }+ `+ l( \
  28.     */4 Z1 \3 D) ?1 e1 d
  29.         SystemClock_Config();! m- E/ G7 W& ^3 r

  30. # U$ E' g3 ~& e; M! ~( Z) G- A+ R
  31.         /*
    / S8 `) Z2 G+ ^1 V* S
  32.            Event Recorder:
    ' N+ v: P+ H, O8 ^* J
  33.            - 可用于代码执行时间测量,MDK5.25及其以上版本才支持,IAR不支持。
    / s. u( m. O% g
  34.            - 默认不开启,如果要使能此选项,务必看V7开发板用户手册第xx章
    ( t$ _9 F6 _( Y6 o( O. J& Z; [0 J
  35.         */        / |. h- ?$ j. d' |% p" o, f
  36. #if Enable_EventRecorder == 1  ' X* D9 j# h& `
  37.         /* 初始化EventRecorder并开启 */
    - R& K0 S( [, {* ~' c9 v4 I" M0 `4 w: H  B
  38.         EventRecorderInitialize(EventRecordAll, 1U);2 f; n3 K5 i0 Q# k' d" q& M6 s
  39.         EventRecorderStart();# D* S/ s2 T6 _4 L. Z
  40. #endif( L, s; _/ k- p
  41.         5 c; \) S5 b( C  ]# E5 h
  42.         bsp_InitKey();            /* 按键初始化,要放在滴答定时器之前,因为按钮检测是通过滴答定时器扫描 */
    % r& D% h& L' l/ O( {: H, h: w
  43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    # [$ l6 o# u' a
  44.         bsp_InitUart();        /* 初始化串口 */
    * z) x) {- t& o# T" x4 N* F5 B" D& e
  45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    0 ?' Z/ e# r# r! b! A0 _
  46.         bsp_InitLed();            /* 初始化LED */        
    ' u/ Y& @! j5 C' C* F8 U
  47. }
复制代码
4 @) d7 ~' @* L0 [
  MPU配置和Cache配置:

, Y4 f- x& G0 ?7 m4 l0 r. a5 A+ u  A. p3 K
数据Cache和指令Cache都开启。
! Y; @2 t" V0 g" g
) i& m/ E" Z: W* W; EAXI SRAM的MPU属性:3 s/ o# v, L  ?+ x2 h
+ x0 k4 r5 t. x" v9 @, O1 N6 \6 s
Write back, Read allocate,Write allocate。% N! X. m" `+ k- z; D# Q+ b
# e" F1 o1 i, |1 f2 Z4 k$ w' E
FMC的扩展IO的MPU属性:4 G5 U; Q! F' B' Q5 h9 M1 S% |

- {& N5 h! ]" ^4 L( b8 b. X必须Device或者Strongly Ordered。
$ Y1 l5 t2 T/ ]" p
( t7 \- f; P1 dD2 SRAM1,SRAM2和SRAM3的MPU属性:
* L, Q2 P' d3 N& o$ L; S. w
2 l: t4 J) m% ?! OWrite through, read allocate,no write allocate。
7 L6 U. E# R6 v/ M6 T5 |6 }) P, U2 H0 I) i+ w
D3 SRAM4的MPU属性:
9 u  _* i: \( |/ a( _& Q: o) d2 q
) T) V5 b8 L/ l3 q' o9 x& J4 {Write through, read allocate,no write allocate。/ S3 E5 ^* f* @1 w$ B4 b# g
4 @* u, ]; c8 E  M! U
  1. /** v- }2 Y9 [0 N6 K* s; l' B: ^
  2. *********************************************************************************************************) h* g4 P4 F+ G5 G  n
  3. *        函 数 名: MPU_Config0 u/ M; ?7 a. M. d/ I& z8 i7 A
  4. *        功能说明: 配置MPU* V% f2 k6 Q2 M" V
  5. *        形    参: 无
    0 `* H+ h* [3 w+ s$ I4 |; e
  6. *        返 回 值: 无* J+ g: D0 P4 l2 s1 P9 N; I
  7. *********************************************************************************************************' G  X; X# n+ w8 N3 x" ~4 J
  8. */
      s& ]- C; U! d* J/ N" z
  9. static void MPU_Config( void )$ b) R- {' M2 f. ^0 {. {- L
  10. {
    7 Y" m' K8 p% G2 _% ]
  11.         MPU_Region_InitTypeDef MPU_InitStruct;
    ' b' [) S" Q, U' j  r
  12. ! Y1 z, }, g" [' ~+ Y0 P
  13.         /* 禁止 MPU */( |3 r, S2 l2 a2 A6 p% y
  14.         HAL_MPU_Disable();
    6 z) C+ @* r0 e: O
  15. 7 Y. M  N  i# J' D; B- O
  16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate,Write allocate */1 a1 n. `: Y$ H2 L% k& Y
  17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    # Y$ M! [! r2 {% e" b/ N
  18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    9 I1 i; m9 Q" U. N  R
  19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;5 Z& X1 l& b' ]8 ]
  20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;4 X; U6 a7 d& B: ~: l  g
  21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;6 s% g8 Z! b' w5 ]1 l! Y3 T
  22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    - K) ?8 n' L& r7 ^* ?- P! F
  23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;# e; ~4 \6 I9 a- X) A& ~* w8 o
  24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;) A0 h  ]8 m) M/ `( o
  25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;) M/ M, c1 g5 L# i, L6 F7 ^) {
  26.         MPU_InitStruct.SubRegionDisable = 0x00;8 |5 ~: P& M& A* V" l
  27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    7 h0 A7 r) Z- {2 K2 q4 v

  28. ( h$ J% D8 s5 T  c* B1 j2 V( C  Q, P
  29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);  \8 o: D8 [7 R: F4 o
  30.         % e/ N, D9 y$ n9 o' U8 R" ?8 f( ^; A
  31.         
    - s& N: Y, a6 r; R
  32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */$ ^: X, h: s7 \; [( u0 |1 Z
  33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    % O( @# x* T, \7 ~9 G* k; J1 F! c
  34.         MPU_InitStruct.BaseAddress      = 0x60000000;8 ~4 p9 J% k4 \. O
  35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        0 j- x5 e  w* u  S/ ~6 A. z
  36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    - \$ c8 O- o3 t; \3 r$ v
  37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;5 H5 L, x; A& ^/ T5 @, F
  38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;
    " t0 x- x' s1 l' G
  39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ' t5 K. A& ^6 p. E
  40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;+ C% L0 I" H9 l- V4 z* i  N& }4 v
  41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    - {7 p. E. _3 w
  42.         MPU_InitStruct.SubRegionDisable = 0x00;& [7 C4 u' G) d( k* y7 i$ v* a
  43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;3 K' o- v) k9 f
  44.         9 f- E' w, ?, T% `! \, E
  45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);! k7 K' g; [; U- I! u  @
  46.         
    ) \1 E' q7 A; }, L$ Z8 A1 P) c( r! V
  47.         /* 配置SRAM1的属性为Write through, read allocate,no write allocate */' d9 S$ q/ p+ e6 b5 S+ X
  48.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;( q1 \* ~; i' P6 l4 {
  49.     MPU_InitStruct.BaseAddress      = 0x30000000;
    ( a* r; n  n7 Z
  50.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        8 l7 F- u8 ~$ B3 ?1 y
  51.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;$ Z: }2 w, S& q" K! Z; {
  52.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    8 y* P1 w& b$ C- ^) Q
  53.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;3 @5 S, ^' F! V0 {+ V& `
  54.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;$ Q& C7 n. S! V% j) `% E
  55.     MPU_InitStruct.Number           = MPU_REGION_NUMBER2;
    ( {" Y  u, a* I) `9 y* S( R0 L
  56.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;8 C8 ^3 m- ]2 H# l, c, e4 `3 ]( N! `( S
  57.     MPU_InitStruct.SubRegionDisable = 0x00;" h3 Y, @! g! Q: M& U, e1 r
  58.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ; _. {2 S% l3 d; h
  59. + K0 f3 u2 t5 X3 M
  60.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    & u: y, f0 l# P
  61.         8 ]; v$ y4 }: i0 s
  62.         /* 配置SRAM2的属性为Write through, read allocate,no write allocate */, i/ L; i# T- b: y& m  {  Z- z- ~
  63.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    3 e! Z5 Q! c0 P) p2 a
  64.     MPU_InitStruct.BaseAddress      = 0x30020000;5 v( R: X+ U. Q. B6 a* A8 P% h
  65.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_128KB;        2 d9 O& w* G# r, s0 d; C# |7 p
  66.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    : M. p) y. Z3 S& e" h
  67.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;4 U" Z  A8 a9 ?; P, }3 m
  68.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;! k  c. e' Y; f( \* f
  69.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;; T) i+ c! Z  c, w9 [, ~, o  X
  70.     MPU_InitStruct.Number           = MPU_REGION_NUMBER3;, X7 B6 @: _/ d( N7 O8 L
  71.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    & o6 o7 x5 _3 B6 |0 ~  ^
  72.     MPU_InitStruct.SubRegionDisable = 0x00;' I: S8 l1 k) b: {, u
  73.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    9 ]" P+ b- }5 z& T, v8 O  c1 s; Q' q# ]! L

  74. 2 a2 {) D% T+ T' X
  75.     HAL_MPU_ConfigRegion(&MPU_InitStruct);) W8 d% C2 d0 o
  76. 2 M4 h( L2 B+ y0 Q- ?6 Y3 o* ^  p

  77. 2 N6 R# k" M7 a
  78.     /* 配置SRAM3的属性为Write through, read allocate,no write allocate */
    + k/ j; l; B6 D. e0 C& c
  79.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ' {0 q6 A4 u% Y1 x
  80.     MPU_InitStruct.BaseAddress      = 0x30040000;) W  n7 Z, ^6 l
  81.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_32KB;        
    5 I6 b! o9 j! x" V# V
  82.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;' M) j, q; f/ }, y% J
  83.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;9 `  Z( ^4 ?) d& R- X
  84.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;/ W6 a7 }/ `+ W; L  A' Y8 N1 {
  85.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;/ `( F6 f; ?% O; ?1 B: k. y. s
  86.     MPU_InitStruct.Number           = MPU_REGION_NUMBER4;
    5 Z& @- U9 ]  p
  87.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;7 l1 ]) D2 i3 H! d& v& i
  88.     MPU_InitStruct.SubRegionDisable = 0x00;" `1 P: ~8 [& V) b% O4 t
  89.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;. O+ t* M2 i. Q) J

  90. 7 p1 {+ Z/ U- j; r2 {4 @: O
  91.     HAL_MPU_ConfigRegion(&MPU_InitStruct);9 [( A$ W/ b% m  ~0 J0 T
  92.         
    7 _; y8 G, ?8 r
  93.         ; P& {8 z3 @8 T
  94.         /* 配置SRAM4的属性为Write through, read allocate,no write allocate */7 P8 a+ z! d, b" Z, W
  95.     MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    , e4 B8 Z6 U7 J2 G# j
  96.     MPU_InitStruct.BaseAddress      = 0x38000000;
    9 f1 F, v6 W7 o, l, ~& h) U% e5 ~
  97.     MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        ( ?; ~8 _% }! @9 j* i
  98.     MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;- I5 u- k0 h6 B! Q: ^1 q" q
  99.     MPU_InitStruct.IsBufferable     = MPU_ACCESS_NOT_BUFFERABLE;
    5 n4 m, J5 ^4 d9 _
  100.     MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;/ @1 \+ {' c5 o# a  T
  101.     MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
      e) y$ A. j# M+ l) Y' m8 i( G
  102.     MPU_InitStruct.Number           = MPU_REGION_NUMBER5;
    ! U' e! F. ]: k
  103.     MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    ) Z3 R  ^- P' Q7 j% n# \/ k
  104.     MPU_InitStruct.SubRegionDisable = 0x00;
    ; r' i& A( k# k3 G8 v
  105.     MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    8 m! a! |' K6 A, }9 G- h

  106. 3 q: S- i$ s4 F$ e0 V; l
  107.     HAL_MPU_ConfigRegion(&MPU_InitStruct);
    & t2 [& N) n# \. O  H  x
  108.         
    + K/ M" K! }) F& k. v
  109.         /*使能 MPU */
    & U. \# y( E+ ~/ ~" Q% O
  110.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    + J2 o/ |: o$ V9 r. D6 a
  111. }
    6 `3 `% b) Z/ o& e( P
  112. % D0 b3 W+ `/ |$ M5 D5 i
  113. /*
    2 y& g& y/ C9 c4 `& F( d
  114. *********************************************************************************************************1 _# B0 A8 g- ~" P
  115. *        函 数 名: CPU_CACHE_Enable
    7 L  m8 \; g6 F  Q
  116. *        功能说明: 使能L1 Cache+ g7 W, w4 o' z- S* K
  117. *        形    参: 无* w( m3 S8 [8 u+ c; o/ c# V- \
  118. *        返 回 值: 无
    : F& {1 \4 L7 i0 c3 _" p$ A; }
  119. *********************************************************************************************************3 J2 z, L# B  W* R/ Z; X
  120. */* v9 f9 l3 J! k3 Q2 c" g
  121. static void CPU_CACHE_Enable(void)! v- E! a7 K1 o# |1 d
  122. {
    5 _$ ^- F/ d7 W$ ~
  123.         /* 使能 I-Cache */
    / ?- x. u$ B. u
  124.         SCB_EnableICache();
    , e# q# G" a: r) [$ [. O" q
  125. . x& `3 c5 T% W4 z5 y! t
  126.         /* 使能 D-Cache */
    + A" U. }" R2 H: d
  127.         SCB_EnableDCache();
    , n) ~; {3 t5 y
  128. }
复制代码

& [$ r" ~3 Y1 @/ w  主功能:
6 B/ Z$ ~& Y( I' R! x
5 s( @1 z4 }% H2 K9 h* X* v主程序实现如下操作:) V- u3 L$ d% q  Q  m* C
5 z8 g0 R" ~9 c
  启动自动重装软件定时器0,每100ms翻转一次LED2。
' h4 x$ E4 o/ S* F2 ?7 P1 `( [  K1键按下,从DTCM依次申请280字节,64字节和6111字节。
' r( j" P/ E0 E& W1 [3 _; h  K1键松开,释放从DTCM申请的空间。( m" J" g5 U. e7 O: j& y/ A, ]
  K2键按下,从AXI SRAM依次申请160字节,32字节和2333字节。7 w6 B8 T2 M- a1 t( B) [
  K2键松开,释放从AXI SRAM申请的空间。
. r- U4 y* x% |1 f  K3键按下,从D2域SRAM依次申请200字节,96字节和4111字节。
, X3 ^: X  |6 X  a! k; G4 G  p  K3键松开,释放从D2域SRAM申请的空间。4 n# E4 T1 ]/ Z7 H1 a, }
  摇杆OK键按下,从D3域SRAM依次申请300字节,128字节和5111字节。3 p  m& h/ F2 t1 a2 \+ ^" X. D+ c
  摇杆OK键松开,释放从D3域SRAM申请的空间。
$ {' ~$ b& j6 W' x5 Q7 f( a
  1. /*0 J& P! w4 Z9 {
  2. *********************************************************************************************************
    . i; y8 p; j  b
  3. *        函 数 名: main
    # ^* w* D; {- O4 v1 \
  4. *        功能说明: c程序入口7 l' x, E* _: f. G/ V
  5. *        形    参: 无
    : j. f  g- z" E) b" b
  6. *        返 回 值: 错误代码(无需处理)
    9 {) G8 L. L( L# v' r5 V1 M
  7. *********************************************************************************************************
    $ ^8 o, a6 a4 H( [! u
  8. */
    ( {" g/ Y" j9 k( i
  9. int main(void)
    * i9 Y1 I0 c% }+ P! t$ T
  10. {% Q8 S' ^. S. U% r( `$ \! {, T& ?
  11.         uint8_t ucKeyCode;                /* 按键代码 */
    " Z0 U$ @0 h4 b( D# W
  12.         uint32_t *DTCM_Addres0, *AXISRAM_Addres0, *SRAM1_Addres0, *SRAM4_Addres0;
    + V2 I0 v1 l% x  t
  13.         uint16_t *DTCM_Addres1, *AXISRAM_Addres1, *SRAM1_Addres1, *SRAM4_Addres1;5 P' L  a3 V# {% q
  14.         uint8_t  *DTCM_Addres2, *AXISRAM_Addres2, *SRAM1_Addres2, *SRAM4_Addres2;
    " l2 t+ m# S0 p0 w4 N
  15. 3 l# C: v& _. ]! R# `! x

  16. " l/ r( ]. a: ]6 m& e" S: o
  17.         bsp_Init();                /* 硬件初始化 */! h! D+ I; k' _8 b. t) K) T
  18.         
    ' |4 K; D& A8 B* a1 b1 Z( X  |. V' g8 Q
  19.         /* 初始化动态内存空间 */
    : T5 h& v4 u/ h. {4 C
  20.         osRtxMemoryInit(AppMallocDTCM,    sizeof(AppMallocDTCM));1 I8 f, O( Q1 G! Q$ R/ A/ [7 B, U  y
  21.         osRtxMemoryInit(AppMallocAXISRAM, sizeof(AppMallocAXISRAM));
    $ G# Y. N7 m& W  Z6 z
  22.         osRtxMemoryInit(AppMallocSRAM1,   sizeof(AppMallocSRAM1));9 g- F6 s3 z0 y) Z, F$ T7 @. X7 h
  23.         osRtxMemoryInit(AppMallocSRAM4,   sizeof(AppMallocSRAM4));
      y  Q7 D# ~4 U6 J! s. c
  24.         
    4 O7 K/ T' `: W7 \
  25.         PrintfLogo();        /* 打印例程名称和版本等信息 */" A) v0 O# U. x$ |, R+ B
  26.         PrintfHelp();        /* 打印操作提示 */" c: ~; ~6 C) x. X; S" }

  27. % A/ E2 s, h- L9 Y/ I
  28.         bsp_StartAutoTimer(0, 100);        /* 启动1个100ms的自动重装的定时器 */: A/ p9 \2 y$ U  a1 y
  29.         
    , C: S" P/ K' e6 _4 H1 p$ R* B
  30. 1 j7 e' j; f* W1 q: f
  31.         /* 进入主程序循环体 */6 \  k) S3 f) f$ Q9 i% N, A
  32.         while (1)
      n) G  J6 T8 H6 H$ l9 D
  33.         {
    * Z1 Z) ?( [6 ~% y8 B
  34.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */# O# X+ L' ^5 g- B
  35. 2 c0 u! W* a8 t1 Z* A! R2 t
  36.                 /* 判断定时器超时时间 */
      ~7 Q  a/ _1 U/ ^3 R7 O
  37.                 if (bsp_CheckTimer(0))        
    8 `% ]; E: N  F% @6 w( }& }
  38.                 {
    ! V1 i1 {) U( O: ~$ N  l4 E
  39.                         /* 每隔100ms 进来一次 */  * }. d- l6 {+ H& S
  40.                         bsp_LedToggle(2);
    ( R+ B+ v6 p: [- O
  41.                 }9 x! t- u8 @! |# ^2 G0 D
  42. & C8 D! D3 X) L2 G
  43.                 /* 按键滤波和检测由后台systick中断服务程序实现,我们只需要调用bsp_GetKey读取键值即可。 */: I; ]+ _3 I9 k- b5 v
  44.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */( Z; P! x8 F  Q1 E* Z& o  J2 W7 w
  45.                 if (ucKeyCode != KEY_NONE)
      |0 J, N1 a9 \% J2 P0 {
  46.                 {# k. a9 a8 \7 _, Y' l- }+ F
  47.                         switch (ucKeyCode)
    + b3 c  d: E7 Y# U: H: f( M
  48.                         {. T6 {6 X: O" Q5 @+ E
  49.                 /* 从DTCM依次申请280字节,64字节和6111字节 */
    # y$ K* U8 S1 e
  50.                                 case KEY_DOWN_K1:        
      x" p) q+ d6 y: o. K
  51.                     /* 从DTCM申请280字节空间,使用指针变量DTCM_Addres0操作这些空间时不要超过280字节大小 */
    " S3 V1 ^9 g- h$ ~0 Q! T) s
  52.                                         printf("=========================================================\r\n");
    3 Y5 P# d2 W: u0 O! s
  53.                                         DTCM_Addres0 = osRtxMemoryAlloc(AppMallocDTCM, 280, 0);
    3 I1 W. Y6 _; C& ~7 F2 C
  54.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);/ C% g+ p  a4 L3 B8 f
  55.                                         printf("DTCM总大小 = %d字节,申请大小 = 0280字节,当前共使用大小 = %d字节\r\n", 8 m: Y! r. B0 W, |
  56.                                                                                 DTCMUsed->size, DTCMUsed->used);
    7 u& L& _% @  k7 a2 j& ~1 J
  57.                                 : V/ ^4 ~' v+ |  \: T+ Z
  58.                         /* 从DTCM申请64字节空间,使用指针变量DTCM_Addres1操作这些空间时不要超过64字节大小 */        ; u# _+ f$ P& X; l+ W
  59.                                         DTCM_Addres1 = osRtxMemoryAlloc(AppMallocDTCM, 64, 0);4 c3 Q; Y* c( {3 b% B& ^# P9 y  T
  60.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);9 |' P2 v8 e" T  ]5 g) P
  61.                                         printf("DTCM总大小 = %d字节,申请大小 = 0064字节,当前共使用大小 = %d字节\r\n", 5 C) N2 q: D& i
  62.                                                                                                            DTCMUsed->size, DTCMUsed->used);
    $ o" P) o. ]& x* H7 ~; R( J
  63.                                 2 _$ i3 r7 S) e( g
  64.                     /* 从DTCM申请6111字节空间,使用指针变量DTCM_Addres2操作这些空间时不要超过6111字节大小 */
    : @, N) N' y- X# M3 f9 F0 k
  65.                                         DTCM_Addres2 = osRtxMemoryAlloc(AppMallocDTCM, 6111, 0);
    3 n5 R1 A2 \$ t3 L  c# G0 A4 A' L( ]
  66.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    3 v# ^1 m# V; I- v
  67.                                         printf("DTCM总大小 = %d字节,申请大小 = 6111字节,当前共使用大小 = %d字节\r\n", * d; o; r9 z" j+ Q/ S% i! N7 S
  68.                                                                                 DTCMUsed->size, DTCMUsed->used);
    + s0 `7 v/ }7 X% ~0 ]2 j4 G
  69.                                         break;
    1 \+ V, o% J" z: g! ]
  70.                                 7 p8 R8 ]  \2 l+ k8 I
  71.                                 /* 释放从DTCM申请的空间 */" @2 ?6 X0 L0 L' @
  72.                                 case KEY_UP_K1:          x/ @4 ~8 w/ O. L3 `9 H
  73.                                         /* 释放从DTCM申请的280字节空间 */
    ; Y& G. B8 v% P1 \1 ?) G* m
  74.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres0);$ p* V8 ~; A5 s0 [. N
  75.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);1 ^1 Y" Y5 m% ~( x0 U/ N1 [) V
  76.                                         printf("释放DTCM动态内存区申请的0280字节,当前共使用大小 = %d字节\r\n",
    8 `$ o/ ]! Y5 t
  77. DTCMUsed->used);8 N/ \7 f' X+ D. R8 a; i/ U) L  f
  78.                                   T* B+ X8 A  m0 u, I. Y
  79.                                         /* 释放从DTCM申请的64字节空间 */6 [6 j; {; K& q/ y
  80.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres1);- Q7 {% q& G. T5 F0 H6 U
  81.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    : m2 O" \. J0 z$ j! f
  82.                                         printf("释放DTCM动态内存区申请的0064字节,当前共使用大小 = %d字节\r\n",! `3 l% L1 o" _$ a2 ]- Q, o7 u5 |
  83. DTCMUsed->used);
    3 S9 W# x; |/ {/ C% l4 O: |% Q1 d
  84.                                 . w5 u) }8 U4 e3 g* j
  85.                                         /* 释放从DTCM申请的6111字节空间 */
    4 n1 y* J( R" J4 q6 Q
  86.                                         osRtxMemoryFree(AppMallocDTCM, DTCM_Addres2);2 }6 V# m6 D# h' M9 D6 P& ]/ ~, z) c
  87.                                         DTCMUsed = MemHeadPtr(AppMallocDTCM);
    % I% |  l3 t) c3 W/ ]3 n- t
  88.                                         printf("释放DTCM动态内存区申请的6111字节,当前共使用大小 = %d字节\r\n"," M8 @0 z: p! {- o% W
  89. DTCMUsed->used);' ]5 h1 Q0 a2 @0 A0 S
  90.                                         break;
    * p* v* ^# H- o8 C1 y
  91.                                 
    9 t: x2 Q. Q. p% w* }
  92.                                 /* 从AXI SRAM依次申请160字节,32字节和2333字节 */6 g: j. [, f' u& L
  93.                                 case KEY_DOWN_K2:        
    / I! I1 z& q( A" l% u! U* y+ F; C
  94.             /* 从AXI SRAM 申请160字节空间,使用指针变量AXISRAM_Addres0操作这些空间时不要超过160字节大小 */
    2 p: T6 [3 i3 i5 N  ~9 o4 p. j
  95.                                         printf("=========================================================\r\n");                ' x9 Q% G+ q4 ?" j
  96.                                         AXISRAM_Addres0 = osRtxMemoryAlloc(AppMallocAXISRAM, 160, 0);; f7 _" A# K( a! z9 d8 T% V# e. I0 I
  97.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);/ f* E* _; m7 ^3 }. Q0 L
  98.                                         printf("AXI SRAM总大小 = %d字节,申请大小 = 0162字节,当前共使用大小 = %d字节\r\n", 6 U3 h4 ~+ w9 ]4 k$ O
  99.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    4 e$ ?" T3 l7 K9 I+ G% U
  100.                                 2 v. N* O, A  `- r
  101.                         /* 从AXI SRAM 申请32字节空间,使用指针变量AXISRAM_Addres1操作这些空间时不要超过32字节大小 */
    + i7 b( S1 V- d# d9 O# h% |. e" ^
  102.                                         AXISRAM_Addres1 = osRtxMemoryAlloc(AppMallocAXISRAM, 32, 0);
    $ m3 E/ W. D2 j: F) q
  103.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    % r' G5 u# U# k5 C
  104.                                         printf("AXI SRAM总大小 = %d字节,申请大小 = 0032字节,当前共使用大小 = %d字节\r\n", ; \4 R6 z1 w% V$ I# }  @
  105.                                                                                                       AXISRAMUsed->size, AXISRAMUsed->used);
    , J+ \# _3 d8 D3 E0 o
  106.                                 * T, S: D  L6 \" o  U+ I$ V3 v) p$ i
  107. /* 从AXI SRAM 申请2333字节空间,使用指针变量AXISRAM_Addres2操作这些空间时不要超过2333字节大小 */        4 f- k; |5 e0 j5 f5 x
  108.                                         AXISRAM_Addres2 = osRtxMemoryAlloc(AppMallocAXISRAM, 2333, 0);
    ! s# U% ?9 C4 {% N) O
  109.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);: Y* {4 Y1 u" X1 L
  110.                                         printf("AXI SRAM总大小 = %d字节,申请大小 = 2333字节,当前共使用大小 = %d字节\r\n", 5 r! v% v0 o* O4 b0 X+ q3 C
  111.                                                                                 AXISRAMUsed->size, AXISRAMUsed->used);
    1 c0 l, |  v) ]# b
  112.                                         break;6 {8 C0 d2 C2 x$ |: Z# o2 {
  113.                                 ) p4 x+ M9 I) @, K
  114.                                 /* 释放从AXI SRAM申请的空间 */
    8 X2 c: _( M. |) H
  115.                                 case KEY_UP_K2:        & X( |. e0 l' G# U' B
  116.                                         /* 释放从AXI SRAM申请的160字节空间 */
    0 F7 s, B) T6 D. Z# H5 `
  117.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres0);& g9 Y' T) w+ {5 F7 A
  118.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    3 @$ l/ h3 C) g7 }* L8 m
  119.                                         printf("释放AXI SRAM动态内存区申请的0160字节,当前共使用大小 = %d字节\r\n",# y# e3 j* W8 `- _( E
  120. AXISRAMUsed->used);% z. K" q3 a( o9 Z6 V: r
  121.                                 
    3 Q1 g/ |1 g# S7 J& p) j! U
  122.                                         /* 释放从AXI SRAM申请的32字节空间 */6 ?$ ?! _) T6 W
  123.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres1);
    . M& c- h$ b1 V; K  R9 G5 b
  124.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    ' I& J- W5 n! ^7 g9 b$ ^
  125.                                         printf("释放AXI SRAM动态内存区申请的0032字节,当前共使用大小 = %d字节\r\n",! y/ K7 Z( Y* N) i
  126. AXISRAMUsed->used);; B; L) p( O% k  G8 s, ?) g
  127.                                 6 g& J. W0 J/ F9 d0 I& E, Z8 W* }1 E
  128.                                         /* 释放从AXI SRAM申请的2333字节空间 */' \5 e. c* x, X% C- e1 Q& j
  129.                                         osRtxMemoryFree(AppMallocAXISRAM, AXISRAM_Addres2);
    0 h9 ~- y' c3 X- m) m6 |
  130.                                         AXISRAMUsed = MemHeadPtr(AppMallocAXISRAM);
    , {5 E- b5 }7 W9 u- E7 T
  131.                                         printf("释放AXI SRAM动态内存区申请的2333字节,当前共使用大小 = %d字节\r\n",
    4 f( Z  u7 o, N5 C- S) w- \
  132. AXISRAMUsed->used);
    7 W# |, B, j7 m; G
  133.                                         break;
    2 t7 p* ~- x% v& N/ \* `
  134.                                 
    & Y2 S; d6 S! N/ k4 g# M
  135.                                 /* 从D2域SRAM依次申请200字节,96字节和4111字节 */
    5 F4 m6 y8 y! x: t
  136.                                 case KEY_DOWN_K3:        & E5 E$ ~# b- k2 }6 s0 R) _
  137.         /* 从D2域的SRAM申请200字节空间,使用指针变量SRAM1_Addres0操作这些空间时不要超过200字节大小 */
    * u4 `5 R3 D3 d
  138.                                         printf("=========================================================\r\n");               
    2 p1 w( X* ?' U. q# l2 x2 @1 S
  139.                                         SRAM1_Addres0 = osRtxMemoryAlloc(AppMallocSRAM1, 200, 0);
      S: A9 @2 _9 D& M" P  z6 t& _
  140.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
    $ r# U9 f+ K; v  B9 a
  141.                                         printf("D2域SRAM总大小 = %d字节,申请大小 = 0200字节,当前共使用大小 = %d字节\r\n", 8 }( X3 d2 T* O& c
  142.                                                                                 SRAM1Used->size, SRAM1Used->used);4 E: v6 ?3 `! U, l- J
  143.                                 
    , A  N( s5 i8 ]  J6 F1 L
  144.          /* 从D2域的SRAM申请96字节空间,使用指针变量SRAM1_Addres1操作这些空间时不要超过96字节大小 */        
    5 ]8 m! M7 w1 ^& B" @
  145.                                         SRAM1_Addres1 = osRtxMemoryAlloc(AppMallocSRAM1, 96, 0);
    : l! _4 |; K- P- \! U
  146.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);$ L6 f# S3 D2 z! J# X
  147.                                         printf("D2域SRAM总大小 = %d字节,申请大小 = 0096字节,当前共使用大小 = %d字节\r\n",
    ) [+ s( O1 r6 ?: Q3 d: k  O
  148.                                                                                                            SRAM1Used->size, SRAM1Used->used);
    2 D3 [2 J1 h! l$ {6 Q5 W2 D
  149.                                 
    / _4 B4 H; n' n" h- t! m
  150.          /* 从D2域的SRAM申请4111字节空间,使用指针变量SRAM1_Addres2操作这些空间时不要超过4111字节大小 */+ W! ], ], e1 L. Z3 B- `
  151.                                         SRAM1_Addres2 = osRtxMemoryAlloc(AppMallocSRAM1, 4111, 0);; T: @9 ?8 E/ X; F$ \
  152.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
    9 E" V9 N) I8 V$ ~# V: I! K5 B7 c
  153.                                         printf("D2域SRAM总大小 = %d字节,申请大小 = 4111字节,当前共使用大小 = %d字节\r\n", $ T1 z  R. u, C- w2 z3 D% S
  154.                                                                                 SRAM1Used->size, SRAM1Used->used);1 Y8 A. X$ `% A/ c* E' N# w
  155.                                         break;
    7 y+ j2 l3 p" g4 w3 a/ Y
  156.                                 8 W7 ]6 k0 o. }' d
  157.                                 /* 释放从D2域SRAM申请的空间 */5 O. ~6 N" |' ~2 T' r
  158.                                 case KEY_UP_K3:        
    " x& F- i/ G; Z' G( b7 l/ u
  159.                                         /* 释放从D2域的SRAM申请的200字节空间 */
    ! t" v! a. B) l7 Y  [% [3 D3 V
  160.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres0);5 D" u1 e7 D- e# l% G, o  c/ c
  161.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);2 R6 D5 D2 w  ^
  162.                                         printf("释放D2域SRAM动态内存区申请的0200字节,当前共使用大小 = %d字节\r\n",
    ; t# a" \; `* E: \/ }
  163. SRAM1Used->used);
    6 w  S9 ?2 H/ b: Q; j9 {5 N# d3 S2 ~
  164.                                 ; F! T2 x( N' R5 Q. N
  165.                                         /* 释放从D2域的SRAM申请的96字节空间 */
    6 D( ^# s- L% ~3 h# ]1 |( @; a' U, q
  166.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres1);
    6 C4 |8 d$ p" j8 ?! s1 V
  167.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
    9 y- k  e4 H( @/ k, d! z
  168.                                         printf("释放D2域SRAM动态内存区申请的0096字节,当前共使用大小 = %d字节\r\n",
    ( V9 u# B' b6 W/ w
  169. SRAM1Used->used);
    & x& d8 n5 G! F7 N7 J
  170.                                 
    ) @; G8 M6 W. j/ j0 n' \7 F; E
  171.                                         /* 释放从D2域的SRAM申请的4111字节空间 */+ u1 n4 S+ n3 A7 A7 w* l5 \
  172.                                         osRtxMemoryFree(AppMallocSRAM1, SRAM1_Addres2);# g$ T; Z1 \, U3 f2 J
  173.                                         SRAM1Used = MemHeadPtr(AppMallocSRAM1);
    % }) t- z4 S+ A  G5 w$ B
  174.                                         printf("释放D2域SRAM动态内存区申请的4111字节,当前共使用大小 = %d字节\r\n",
    : o7 W6 N6 o" @/ h4 K, Z: f1 n
  175. SRAM1Used->used);" u! k! \" o/ h
  176.                                         break;; v0 I. j  ?0 j6 D; b- d7 k
  177.                                 
    5 k) D/ W4 T+ U6 J- g
  178.                                 /* 从D3域SRAM依次申请300字节,128字节和5111字节 */
    ; a3 U. y* {( @( e# P. G4 D
  179.                                 case JOY_DOWN_OK:        8 [4 P/ S0 W0 i4 V: i# h
  180.             /* 从D3域的SRAM申请300字节空间,使用指针变量SRAM4_Addres0操作这些空间时不要超过300字节大小 */' Z% E3 F0 T3 g. r- [: X! M
  181.                                         printf("=========================================================\r\n");               
    - D% L1 D; q6 f9 X, F
  182.                                         SRAM4_Addres0 = osRtxMemoryAlloc(AppMallocSRAM4, 300, 0);
    5 m3 c( ?! n4 ^( A8 t1 K" s2 }7 M
  183.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);- E7 w; O& z! `
  184.                                         printf("D3域SRAM总大小 = %d字节,申请大小 = 0300字节,当前共使用大小 = %d字节\r\n", $ q" j1 q  M' J7 `4 R* b* J1 X  T
  185.                                                                                 SRAM4Used->size, SRAM4Used->used);" ~' M" ]9 p' A
  186.                                 / ?2 K  `# b! J  i7 N
  187.                 /* 从D3域的SRAM申请96字节空间,使用指针变量SRAM4_Addres1操作这些空间时不要超过96字节大小 */7 P7 Z, E1 T" d# P; m+ {- @& y5 K& h
  188.                                         SRAM4_Addres1 = osRtxMemoryAlloc(AppMallocSRAM4, 128, 0);
    9 x# s/ w0 m: p7 H
  189.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);9 X+ V- k- O" G$ U. Y" j
  190.                                         printf("D3域SRAM总大小 = %d字节,申请大小 = 0128字节,当前共使用大小 = %d字节\r\n",
    & _: ?) o! Q7 @3 A) t! V: l
  191.                                                                                                            SRAM4Used->size, SRAM4Used->used);
    2 s7 F5 v" W/ n, j/ O
  192.                                 1 ^  B+ v* ~+ p4 B  ]* ]1 |" E7 g
  193.         /* 从D3域的SRAM申请5111字节空间,使用指针变量SRAM4_Addres2操作这些空间时不要超过5111字节大小 */! G9 N" S% U! ]" S
  194.                                         SRAM4_Addres2 = osRtxMemoryAlloc(AppMallocSRAM4, 5111, 0);
    6 h( D3 Y4 b1 _; T/ J$ d1 v  V. Z
  195.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
    / X  ~/ F- i) R* y- c; j9 X
  196.                                         printf("D3域SRAM总大小 = %d字节,申请大小 = 5111字节,当前共使用大小 = %d字节\r\n",
    ; `/ s  h4 G* Z
  197.                                                                                 SRAM4Used->size, SRAM4Used->used);  Y, R  c3 [3 {
  198.                                         break;
    ( M' {$ f3 w9 d1 w7 j1 \; E
  199.                                 
    8 {9 q. R7 S( i4 w) w
  200.                                 /* 释放从D3域SRAM申请的空间 */
    2 b# O; p- @" r9 l+ p# y! H
  201.                                 case JOY_UP_OK:        ! E, y- k) E2 d* F7 Q0 h! A! W
  202.                                         /* 释放从D3域的SRAM申请的300字节空间 */+ x9 H0 V% }! Q) X0 U) h3 y
  203.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres0);
    ; V- n. e7 {- e0 O! }# p" _
  204.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
    8 y! E* W# s+ {) g7 E! v
  205.                                         printf("释放D3域SRAM动态内存区申请的0300字节,当前共使用大小 = %d字节\r\n", ' v$ X  v4 Z* T5 c- f5 h. V; u
  206. SRAM4Used->used);
      s0 b6 D9 |9 u  ^( \: l1 [+ C
  207.                                 : I" d) w, R& h+ P, Z, m$ Z
  208.                                         /* 释放从D3域的SRAM申请的128字节空间 */
    7 T6 ^. f& J1 I8 N7 N
  209.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres1);
    + r3 J% Q3 P. @5 t- u4 h- s
  210.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);5 G+ S  x7 j) B  \3 K4 B6 R' I) n
  211.                                         printf("释放D3域SRAM动态内存区申请的0128字节,当前共使用大小 = %d字节\r\n",& T  I4 M! F. k& H9 S
  212. SRAM4Used->used);
    # h- A  Y$ }, _- v* y- p, u% U$ ?+ h
  213.                                 
    , m4 H; Y/ s) `" f7 n
  214.                                         /* 释放从D3域的SRAM申请的5111字节空间 */
    5 G& x2 d) {9 D3 K) X- x' g8 x
  215.                                         osRtxMemoryFree(AppMallocSRAM4, SRAM4_Addres2);' y6 @% t: A" Y. `% Z
  216.                                         SRAM4Used = MemHeadPtr(AppMallocSRAM4);
    4 |/ r4 }- l- X( S
  217.                                         printf("释放D3域SRAM动态内存区申请的5111字节,当前共使用大小 = %d字节\r\n",2 Y( O9 l6 x" ?) F: [
  218. SRAM4Used->used);# K) Y& a$ H7 H( ~& U. w
  219.                                         break;0 T. ~: `! M$ y7 ~2 J4 w
  220.                         % m! ?" N* |- {# P
  221.                                 default:
    7 D- F# q8 m7 y# H( T
  222.                                   /* 其它的键值不处理 */
    * X6 X1 b* ^* |9 x0 c
  223.                                   break;
    9 m( v( Q2 T! V& u) P  r) P
  224.                         }
    + j  m; U+ O+ c) W# Y' E3 z
  225.                 }" v' ^$ t' J+ p! |  I8 Y
  226.         }! `1 Q% f* L3 N+ n4 s% {6 w
  227. }
复制代码
  S1 ?4 q4 M" W: A+ |
27.6 总结
: P" a9 u0 G0 m: J" h7 N本章节就为大家讲解这么多,还是比较有项目实用价值的,特别是MP3编解码,JPEG编解码,视频播放器,矢量字体等需要动态内存的场合。4 o+ q6 i+ M  W+ i) q) N8 S
2 Y3 I; @" K8 x& P" X: l

9 x: r# u# A  b3 w  m: x3 r# }0 y$ G: S& P2 Y# y" S
赞 收藏 评论0 发布时间:2021-12-23 15:00

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版