|
现在非常多的的MCU性能都还不错,同时用户也会去扩展一些外部RAM,这样如果高效便捷的管理这些内存是一个重要话题。 今天给大家分享一份源码:基于无操作系统的STM32单片机开发,功能强大,可申请到地址空间连续的不同大小的内存空间,且用户接口简单,使用方便。 2 E/ U T+ P, w, C8 ]% p- ]3 {
源码说明 源码包含memory.h 和 memory.c 两个文件(嵌入式C/C++代码的“标配”),其源码中包含重要的注释。 头文件memory.h :包含结构体等定义,函数API申明等; 源文件memory.c :是实现内存管理相关API函数的原型。! | A$ ~4 y" Z: u6 a9 H: y
头文件memory.h 头文件是相关的定义和申请:: P% F0 q7 o6 {& s/ Y$ j, g- |1 ^& h
- #ifndef __MEMORY_H__
+ ] _& [: J2 @2 ~* e1 z5 U3 M - #define __MEMORY_H__ l8 y) p3 W* S& @+ M7 y# q7 T0 j5 ?
- ; F0 q2 j2 ^ F5 ]( r
- #include "stdio.h"; _) d5 E% ?- o- f- ~- m* A
- #include "string.h"
0 L5 s+ u% @+ k* w - #include "includes.h"
- u( I9 P2 y8 J ?# H0 n7 W8 Z - //用户使用
1 T3 R0 z/ o! r6 \; ] - typedef struct: ]3 k* z. S1 ?. C4 d6 a
- {
; c7 i& ~5 w, ?" X. A1 @ - void *addr; //申请到的内存的起始地址
4 ~( Q+ e! a( \" q - uint32_t size; //申请到的内存的大小,按照块大小分配,大于等于申请大小" h, d; B! p9 Q: T. t
- uint16_t tb; //申请表序号,申请内存时分配,释放内存时使用,用户不使用! B8 D% v# E8 w2 e2 j- q- X6 @! {
- }DMEM;
3 e2 q2 Z# s" |4 k - //若返回空,则申请失败
& d+ @; B/ w6 M2 o! x7 q - DMEM *DynMemGet(uint32_t size);# v9 M, D; c1 x5 d2 F" \
# g2 d: q7 f6 j/ {- void DynMemPut(DMEM *pDmem);2 }. `8 | x5 z$ g$ S
( W0 k) i3 i/ d, O; B K2 l- O8 R0 B- #endif //__MEMORY_H__
复制代码
$ F- [3 J7 p4 J8 b% @5 H; f. t8 j3 h! B/ D/ @+ }* z. Q/ n
这里的代码比较简单,也是常规的写法,重点是要理解结构体成员的含义。 ; g' r/ d- m1 t: o1 T; `$ v6 ~
源文件memory.c 源文件主要就是实现内存管理的函数,源码比较多,这里才分为三部分。4 X) u0 n' c" q' u% M+ {- F' J
1、相关的定义
& ?4 [0 g: S1 J' J N3 ^- #include "memory.h"
4 x) u6 Z- p7 Y C. T$ k - % x L/ G$ V- E( c! W) v
- #define DMEM_BLOCK_SIZE 256 //内存块大小为128字节8 Q% m: G% m0 y6 K
- #define DMEM_BLOCK_NUM 20 //内存块个数为40个; J+ H8 ^ Y) W/ m" d
- #define DMEM_TOTAL_SIZE (DMEM_BLOCK_SIZE*DMEM_BLOCK_NUM) //内存总大小# {: B& P) T( F2 E: {. W
- W% j8 H- l$ w- static uint8_t DMEMORY[DMEM_TOTAL_SIZE];- [' I8 ^. D" t% l- g& d" W3 s. e8 }' _ E
- static DMEM_STATE DMEMS = {0};
0 R, E; ], F0 N- y; q$ P - u _% p3 R$ X; [+ A
- typedef enum
1 r/ a8 W5 ]0 u% C8 Z. X - {/ o" J. k: b P, e p! c
- DMEM_FREE = 0,( n, P6 m6 d9 j! l: e* x* o
- DMEM_USED = 1,( o0 I+ w9 u+ s; J( g5 Y$ B8 N
- }DMEM_USED_ITEM;% [) v9 P. i# r
- 0 W/ U! _) t3 ]
- typedef struct* J0 G8 H/ c2 Y4 |: g' _
- {) N+ e x( z" R5 m0 ], f' y
- DMEM_USED_ITEM used; //使用状态
; N- k' \) ~% F7 ^ - uint16_t blk_s; //起始块序号
6 p. A9 ]0 _7 \: v" { - uint16_t blk_num; //块个数0 Z z& R* u0 y( _% Z2 ^
- }DMEM_APPLY;
" }8 O, g9 `* s9 v' C; w
6 z& g: k# _5 P; M/ D- typedef struct
; D* o6 C% o" r - {
8 l: |: @" `$ C3 q; E2 y - DMEM_USED_ITEM tb_blk[DMEM_BLOCK_NUM];1 ?1 l1 s: \' X1 N% G4 V+ w/ P
- DMEM tb_user[DMEM_BLOCK_NUM]; //用户申请内存信息
, o) i% E/ R! e/ W$ T$ B - DMEM_APPLY tb_apply[DMEM_BLOCK_NUM]; //系统分配内存信息
7 W# @( P1 C# i$ {4 l3 h( Z - uint16_t apply_num; //内存申请表占用数目6 P y. N; q5 z1 m6 {
- uint16_t blk_num; //内存块占用数目
* E( k& w) P- L& R# H* A$ p - }DMEM_STATE;
复制代码
9 y' F: q% m! i8 ^8 N# h: m# J6 f, o2 c$ @% f. d! k5 M' H( ~
2、内存分配函数DynMemGet
& @9 a9 X. J$ F( \( U- DMEM *DynMemGet(uint32_t size) I* g' E& N3 B" V7 v- t- f
- {
$ S V8 P4 t) s& z% y - uint16_t loop = 0;2 u9 V0 F4 y7 V2 n5 C% ~" e% D8 o
- uint16_t find = 0;
5 i W9 j* ` O - uint16_t blk_num_want = 0;
7 R9 z, \2 F! T: ] X - DMEM * user = NULL;' i8 o7 P3 V/ u8 s- q
- DMEM_APPLY *apply = NULL;
/ d' T: T9 a7 z6 ]8 @ - * U* v" |( ?8 Q- r
- //申请内存大小不能为0+ t: J3 P. T2 a" M
- if(size == 0) { return NULL; }
( \* i! f' ~- T7 z8 r u3 W - //申请内存不可超过总内存大小
. u1 [* v, f3 v8 H - if(size > DMEM_TOTAL_SIZE) { return NULL; }
) O* |! s+ s8 B/ ?# a; e8 C - //申请内存不可超过剩余内存大小* ]& f- t) c8 F& b% p
- if(size > (DMEM_BLOCK_NUM - DMEMS.blk_num) * DMEM_BLOCK_SIZE) { return NULL; }
M4 V4 S/ [1 T - //申请表必须有空余
' ]2 P% y; s& R. U - if(DMEMS.apply_num >= DMEM_BLOCK_NUM) { return NULL; }. s3 \; _3 j2 K; l1 z* O
$ @* {7 l. n, @1 ^3 w+ A- //计算所需连续块的个数) r) c. v8 v$ l4 J
- blk_num_want = (size + DMEM_BLOCK_SIZE - 1) / DMEM_BLOCK_SIZE;
* K/ p0 i6 ~( {, v$ `* `7 A, I3 ]- X
+ ~: W3 U" l3 m7 Q: ]" J% ]- //寻找申请表
& U3 I8 A3 n4 q - for(loop = 0; loop < DMEM_BLOCK_NUM; loop++)+ ]: W# M0 g; \
- {( t& y1 c; W: o) V
- if(DMEMS.tb_apply[loop].used == DMEM_FREE)# O2 `$ @5 Q( Q! Q
- {
6 K1 E* I" {) s) N - apply = &DMEMS.tb_apply[loop]; //申请表已找到: _" M0 X$ u& Z9 L1 r* L0 S
- user = &DMEMS.tb_user[loop]; //用户表对应找到7 \# h( f7 o' U! r/ P& k/ X' N
- user->tb = loop; //申请表编号记录+ v$ t6 U) N. s* P! h% }
- user->size = blk_num_want * DMEM_BLOCK_SIZE; //分配大小计算
4 c% N/ l" k3 D" P f - break;1 g% ~7 A' c' h4 Q" ~$ M" V' L
- }0 w/ r! O. _ c& y8 _
- }
7 g4 ~" n9 O: q' r8 x# J9 o - 1 i' u, P+ h0 h* C) K, s- C
- //没有找到可用申请表,理论上是不会出现此现象的,申请表剩余已在上面校验/ w. G4 C4 \. g8 l- R. N0 `: g
- if(loop == DMEM_BLOCK_NUM) { return NULL; }0 E1 {: A' w% J- Y
% w0 v6 b; A; w: v& b4 ]! ~; `" y- //寻找连续内存块* j8 `, [* q" d/ u1 y: @
- for(loop = 0; loop < DMEM_BLOCK_NUM; loop++)
1 o- H; H1 X9 t" R { - {
, E8 b% j9 T) k9 D* _ - if(DMEMS.tb_blk[loop] == DMEM_FREE)
H5 m; f: w1 W6 i/ R4 B - {//找到第一个空闲内存块9 Q- Y7 i' i9 s% w3 R9 |# M
- for(find = 1; (find < blk_num_want) && (loop + find < DMEM_BLOCK_NUM); find ++)
+ W* r& d. g+ Y1 ]3 n; F - {//找到下一个空闲内存块! w! o2 p' L* A% ^8 y
- if(DMEMS.tb_blk[loop + find] != DMEM_FREE)
2 F& M* X# i4 Y& D/ D+ h5 r - {//发现已使用内存块& f. s ?9 A( D& }% I7 B& Q
- break;
2 B/ ~7 Y% ]% h1 T - }
6 u; w/ m% a' d - }
$ R1 j7 a5 z. h! t- \; c" h - if(find >= blk_num_want)7 X; N& g+ h$ J7 F
- {//寻找到的空闲内存块数目已经够用1 d/ Y. B b/ @$ K
- user->addr = DMEMORY + loop * DMEM_BLOCK_SIZE; //计算申请到的内存的地址1 K2 e0 U4 [: c" U. _2 i+ N. [
- apply->blk_s = loop; //记录申请到的内存块首序号# p+ i/ Q; k! G2 V) w! R- T
- apply->blk_num = blk_num_want; //记录申请到的内存块数目: V/ F( t* N8 E, Y
- for(find = 0 ; find < apply->blk_num; find++)
* L0 Q1 }3 Y' H* R9 J% G; q - {3 t) _ P' P1 [9 P
- DMEMS.tb_blk[loop + find] = DMEM_USED;1 f' d! X3 t& G- `. F
- }
5 Q* D H: R" }/ w" J - apply->used = DMEM_USED; //标记申请表已使用9 T, \) i5 H$ z( g
- DMEMS.apply_num += 1;! Q o) O) ^. U5 t+ r$ y
- DMEMS.blk_num += blk_num_want;
1 y3 G: c- _9 |7 x% v0 @
! A( [+ e, b7 R) j1 E% O% J- return user;1 A( W- y8 p$ L6 Z V! x7 ~
- } y' O3 Q- ^* P. F1 _
- else
( P9 x: d3 {& ?& D$ C+ b - {//寻找到的空闲内存块不够用,从下一个开始找7 x8 g5 c. P1 N- z- N
- loop += find;7 b# s. u4 k: e6 O. D
- }. v- B }6 c# ]8 ?% l# C
- }
% _! S8 M# `$ ~ - }
, J! j& p, }& ?& s& L2 O4 D+ H, [ - 2 B( R: Q0 d4 z6 P
- //搜索整个内存块,未找到大小适合的空间
1 z8 K* G: Y" b t+ \ - return NULL;+ |4 p" k1 ^+ d% x+ f- x9 J
- }
复制代码
l& n0 i' C/ R* {# m6 e) d: \- O: a, j7 O( k2 `& b
3、内存释放函数DynMemPut
) K* v/ {% }2 L- void DynMemPut(DMEM *user)) A+ h, h9 s( s
- {/ {! ~' u2 P, c
- uint16_t loop = 0;
" V" i# s6 }1 N4 ~. q. F8 ]1 _ - //若参数为空,直接返回
: Y9 S2 i) B: ?+ x - if(NULL == user) { return; }
; m& Q7 V4 B# x2 l( S6 R
" D5 k' F9 Z% R. R! B; f* G- //释放内存空间7 _' i% r6 m! P) O' a
- for(loop = DMEMS.tb_apply[user->tb].blk_s; loop < DMEMS.tb_apply[user->tb].blk_s + DMEMS.tb_apply[user->tb].blk_num; loop++)
9 C8 I2 U! g$ A1 _8 i - {
; t# ?) ] ~- c6 w/ k - DMEMS.tb_blk[loop] = DMEM_FREE;! D+ O7 e5 l! B/ _
- DMEMS.blk_num -= 1;7 c N5 F/ i4 b5 O
- }
: y8 J; L/ X% B/ [2 N - //释放申请表9 q; Z2 {$ @! c8 h4 C
- DMEMS.tb_apply[user->tb].used = DMEM_FREE;$ X8 y" d4 M8 E6 ^
- DMEMS.apply_num -= 1;% y. _0 f! L. F' |
- }
复制代码
1 P* \. F: B) R
5 L* r$ J) h0 z2 d: i. P- v2 u! n
; L. E e* h6 L, r; o( T W4 }7 r! w# d
代码中包含注释,注释描述的比较清楚,也比较容易理解。. E4 O9 n! Q6 X5 O# m
' G3 w5 m M; d4 i |