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

STM32单片机内存管理器代码

[复制链接]
STMCU小助手 发布时间:2022-9-18 22:18
    本代码适用于无操作系统的STM32单片机开发,功能强大。
    可申请到地址空间连续的不同大小的内存空间,且用户接口简单,使用方便。
    直接复制粘贴如下代码即可:
memory.h:
  1. #ifndef __MEMORY_H__
    9 X; m! l: j% N# f
  2. #define __MEMORY_H__, k6 f, I/ b& R3 b  @! L
  3. 7 |! e( N1 X" E: Y
  4. #include "stdio.h"! y5 J5 W! S7 U5 Z$ I4 [
  5. #include "string.h"
    ( j" y2 V' ~& t! L
  6. #include "includes.h"/ X5 ?& H) u& M5 I8 B6 L0 |- |, i0 E
  7. //用户使用
    9 H9 M1 T6 B4 ?1 j$ x$ ]
  8. typedef struct, L" W% ~$ b& M/ Y
  9. {
    ( j1 b; c9 }! G. }2 ]6 }" ^- f
  10.     void    *addr;//申请到的内存的起始地址
    & p1 k) y' t. f8 E5 b
  11.     uint32_t size;//申请到的内存的大小,按照块大小分配,大于等于申请大小0 `4 E! r% Q6 K2 v* Q" ~
  12.     uint16_t  tb; //申请表序号,申请内存时分配,释放内存时使用,用户不使用! t  j* {) X5 H' }7 p  @& q, m% r6 l
  13. }DMEM;
    * _# ~5 z5 `8 ~1 z+ }  a

  14. $ B3 @4 |# N0 O$ X3 `: X
  15. //若返回空,则申请失败0 E  f: Y$ N5 H6 E
  16. DMEM *DynMemGet(uint32_t size);" N, S- j+ K$ @4 i) q
  17. void DynMemPut(DMEM *pDmem);
    9 k3 w9 z1 F( K- s

  18. * F& M& U* L: f6 S& r0 B. X
  19. #endif //__MEMORY_H__
复制代码
' O& B( M: E1 a( M
memory.c:
  1. #include "memory.h"/ W6 {2 R( D4 p: E( Y/ w! Q  _+ M

  2. 4 B3 y5 Y% Y0 F: P
  3. #define DMEM_BLOCK_SIZE         256      //内存块大小为128字节* r) L' ~( G8 j2 r6 [- G9 X
  4. #define DMEM_BLOCK_NUM          20       //内存块个数为40个
    3 D! t5 x$ c/ Z' {6 ?5 I) [  S# @7 ?
  5. #define DMEM_TOTAL_SIZE         (DMEM_BLOCK_SIZE*DMEM_BLOCK_NUM)    //内存总大小& e: m, p8 O1 Z  L( X

  6. + U! D; G+ q  }% t+ _1 d
  7. typedef enum
    4 Y+ d6 ^* H: ~! |* u- [0 Z
  8. {' @5 b  x+ e: A( ^8 ]+ J) l- `
  9.     DMEM_FREE   = 0,6 N/ f1 x7 t% ~7 o6 q1 k5 R
  10.     DMEM_USED   = 1,2 Q7 ?1 k3 ^0 k- P1 H! h
  11. }DMEM_USED_ITEM;
    ; R* K. Q  S- N6 b% g2 ^
  12. $ t5 P6 Y; M" c# m+ Z5 w+ r% \4 x8 h
  13. typedef struct
    : W" l9 u5 @2 W5 R0 N. D# l
  14. {
    " ~( {- S' I+ N0 n) |8 j% [; P: @  ^
  15.     DMEM_USED_ITEM   used;       //使用状态9 o, h2 e. M$ e9 W* y
  16.     uint16_t         blk_s;      //起始块序号" G# @$ a4 u' w8 O+ n; n
  17.     uint16_t         blk_num;    //块个数0 q$ ^  ^8 u4 r
  18. }DMEM_APPLY;' H, U9 X) i7 A

  19. 1 Z; L5 t2 c/ K0 t; d% Z
  20. typedef struct
    5 P" M% A  w1 g
  21. {& T0 \3 }$ i* D
  22.     DMEM_USED_ITEM  tb_blk[DMEM_BLOCK_NUM];
    # A& |3 G; m: {7 p0 _9 [- ]% T
  23.     DMEM            tb_user[DMEM_BLOCK_NUM];        //用户申请内存信息
    0 j% |3 R! i: N. R# M4 V( t8 Q
  24.     DMEM_APPLY      tb_apply[DMEM_BLOCK_NUM];       //系统分配内存信息
    ) o9 |: c1 E3 E9 @) y
  25.     uint16_t        apply_num;      //内存申请表占用数目
    8 k+ h7 l$ w0 T- E
  26.     uint16_t        blk_num;        //内存块占用数目
    - ^* I% v' k' m3 f8 A
  27. }DMEM_STATE;4 |5 n* U2 i$ n2 w$ i% b

  28. 1 ]3 V% |4 ~5 n% o2 N
  29. static uint8_t DMEMORY[DMEM_TOTAL_SIZE];
      V& O: M& y/ Y  |3 j; J) O
  30. static DMEM_STATE DMEMS = {0};. X  R  ?7 {8 v, D+ u3 u1 t" I3 A# @

  31. . [# E9 L+ B# A6 w& ?9 u: q
  32. DMEM *DynMemGet(uint32_t size)
    . `3 N3 y3 u* f
  33. {; L& \: p7 s# L: v! ]
  34.     uint16_t loop = 0;$ S: v2 h1 V$ X% Q0 ?
  35.     uint16_t find = 0;
    5 l- o0 w1 d) S* y0 \& X1 B( n( o1 W
  36.     uint16_t blk_num_want = 0;
    7 `- u7 F- {2 h! ]  E- m  x
  37.     DMEM * user = NULL;. A1 }6 r) c4 i' @
  38.     DMEM_APPLY *apply = NULL;1 T, A, a8 g- p# r
  39.     3 P  n& h4 j2 {0 u7 S, S4 |
  40.     //申请内存大小不能为0
    : r1 P1 H, M1 [
  41.     if(size == 0)               {   return NULL;    }
    ( Z6 V) Y$ h& d+ a3 w+ d- X
  42.     //申请内存不可超过总内存大小
    / r# Y! x5 y( h9 h2 ^
  43.     if(size > DMEM_TOTAL_SIZE)  {   return NULL;    }
    ; Z; k& J7 j$ u5 B
  44.     //申请内存不可超过剩余内存大小
    $ R7 x6 I7 m" d- g! f: c' m: z' a* }
  45.     if(size > (DMEM_BLOCK_NUM - DMEMS.blk_num) * DMEM_BLOCK_SIZE)   {   return NULL;    }/ r, E! L7 Q0 m
  46.     //申请表必须有空余
    * I6 y- ~8 u: c7 a/ X8 K' n/ [
  47.     if(DMEMS.apply_num >= DMEM_BLOCK_NUM)   {   return NULL;    }
    # ]- S. I/ R. O2 W- a% p6 ~9 C
  48.     % t2 d# r' d, d  T# w5 l. C
  49.     //计算所需连续块的个数5 }2 G- _: ]* l9 J; h7 x
  50.     blk_num_want = (size + DMEM_BLOCK_SIZE - 1) / DMEM_BLOCK_SIZE;# t5 b/ s8 G& t) p
  51.    
    9 e, j$ E, p4 O. t! u+ M
  52.     //寻找申请表
    . `3 l3 V$ A% o
  53.     for(loop = 0; loop < DMEM_BLOCK_NUM; loop++)
    , M0 [9 F4 z4 I/ K' @# x0 E. B( ?
  54.     {3 W! J! {. c! W
  55.         if(DMEMS.tb_apply[loop].used == DMEM_FREE)
    - P3 c3 w! ?0 f" F- C
  56.         {
    + c" B/ v4 f6 L* g
  57.             apply = &DMEMS.tb_apply[loop];                  //申请表已找到
    ( M0 [3 b& k5 X9 j1 j/ f
  58.             user = &DMEMS.tb_user[loop];                    //用户表对应找到
    9 p, d; R" O1 R: k
  59.             user->tb = loop;                                //申请表编号记录5 e" I1 V( k$ X8 ]- S' V
  60.             user->size = blk_num_want * DMEM_BLOCK_SIZE;    //分配大小计算- ~4 d" W8 d' W) v+ C! J- {
  61.             break;
    & V& Q/ h" e" `2 \
  62.         }, K2 A' U3 w- o; z2 F1 t8 ~
  63.     }
    8 C( C( N) e( m+ U% _3 o3 D% j
  64.     / J$ i$ G- U+ O* H1 o1 A2 J# }9 L
  65.     //没有找到可用申请表,理论上是不会出现此现象的,申请表剩余已在上面校验2 B- c, l3 y& E4 d6 i; G, N( a. h
  66.     if(loop == DMEM_BLOCK_NUM)  {   return NULL;    }: R4 h; ^1 a7 {" m$ `1 F5 J0 k
  67.     2 j6 O$ x) }2 s0 H4 ~
  68.     //寻找连续内存块! q. b1 I. t9 B5 I( P- B3 p
  69.     for(loop = 0; loop < DMEM_BLOCK_NUM; loop++)5 G  Q/ h, s  q! {
  70.     {
    + y4 i! r; b% }% }# `. G& P
  71.         if(DMEMS.tb_blk[loop] == DMEM_FREE)7 N, Q" K2 H" }7 f7 j" y
  72.         {//找到第一个空闲内存块2 p" x) [' q: ?; Y0 h6 }& q
  73.             for(find = 1; (find < blk_num_want) && (loop + find < DMEM_BLOCK_NUM); find ++)
    ( g7 t: Q+ }  ?
  74.             {//找到下一个空闲内存块, C6 r) B) |6 C& A& Y% u
  75.                 if(DMEMS.tb_blk[loop + find] != DMEM_FREE)
    9 E# `: k  q6 F; l
  76.                 {//发现已使用内存块- p3 ~2 B: d, w1 Z6 H% ^
  77.                     break;+ J2 d3 l  {- T" S) m& `  m
  78.                 }3 F4 T, N2 q. |1 I
  79.             }$ E5 T6 U( k+ U# P
  80.             if(find >= blk_num_want)7 ^  V) T4 F4 H' e3 D
  81.             {//寻找到的空闲内存块数目已经够用
    7 u9 Q& {  [5 F* Q9 X
  82.                 user->addr = DMEMORY + loop * DMEM_BLOCK_SIZE;  //计算申请到的内存的地址, \' H* v& q4 ~8 g8 k- W4 c6 T
  83.                 apply->blk_s = loop;                            //记录申请到的内存块首序号# T% y" b; m  Q7 @3 N
  84.                 apply->blk_num = blk_num_want;                  //记录申请到的内存块数目: g( f* u: T- k. p3 m. ~2 [
  85.                 for(find = 0 ; find < apply->blk_num; find++)
    " k8 O! x! }) Y7 D9 X1 B
  86.                 {
      j# [9 S2 Z) w" V+ n/ v
  87.                     DMEMS.tb_blk[loop + find] = DMEM_USED;
    2 `$ d* P& j+ I/ H; Y( V5 }+ ]
  88.                 }3 f/ [1 q) W, k3 L) }
  89.                 apply->used = DMEM_USED;                        //标记申请表已使用' |5 K8 v4 z7 l+ D: @, a
  90.                 DMEMS.apply_num += 1;
    9 j5 u' S4 }9 g
  91.                 DMEMS.blk_num += blk_num_want;# c* E% r* @2 R8 P" o8 S5 W
  92.                
      C9 E) R7 I( v4 G' H$ c
  93.                 return user;
    $ X/ {0 U7 N0 b8 m/ i/ `, {9 \4 A1 T
  94.             }
    0 R" u$ o' l! M0 b& ^/ \- A" s) J, P
  95.             else! {* y% [$ E6 M
  96.             {//寻找到的空闲内存块不够用,从下一个开始找
    ) q* I1 K% R" y, k
  97.                 loop += find;
    * J6 e3 H, L, ^+ b
  98.             }; d$ |- j4 U: {+ S* `$ x: K* U
  99.         }8 u* @/ _% y/ @  s$ i4 o- m7 h( g
  100.     }) z; ?' t9 @, }' w( \
  101.     ! f/ {: A! \; m6 g; E' z' }% H
  102.     //搜索整个内存块,未找到大小适合的空间
    7 H3 d$ O9 i& Q2 {8 j
  103.     return NULL;
    1 S& R/ W" q1 c# e
  104. }
    : C7 A4 ?8 i& R, ]
  105. : V) e( r  `1 k( y# e4 _, h4 k" ^
  106. void DynMemPut(DMEM *user)+ f* l' \( o) p7 F2 C8 p
  107. {/ V- Q: I7 @* f& R, I7 f
  108.     uint16_t loop = 0;( A: ?1 u# C! y
  109.     //若参数为空,直接返回
    + ~+ w8 e# Y9 t* s4 g
  110.     if(NULL == user)    {   return; }! R4 b9 S4 ?' U" P
  111.     % C- G, E$ F# b) A5 c$ `1 y+ I& D
  112.     //释放内存空间+ e+ v5 S. n, \$ k
  113.     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++)
    8 F8 t) U0 @& b
  114.     {+ y( Y# ]/ t( Z4 \! B( Q
  115.         DMEMS.tb_blk[loop] = DMEM_FREE;
    ( r" w$ Q- N' a. P: Y
  116.         DMEMS.blk_num -= 1;7 ?% H  O  ]0 ]
  117.     }
    3 A6 o8 _6 J2 b$ \
  118.     //释放申请表, e0 Q, @) q* @8 a( s9 ~0 R$ m
  119.     DMEMS.tb_apply[user->tb].used = DMEM_FREE;
    2 A: F) Y% U* b( J% e
  120.     DMEMS.apply_num -= 1;
    8 }; H' J8 |2 k0 U% K. T$ e( Z2 O
  121. }
复制代码

! s: x' }! H* ~$ A' W  J$ r
赞 收藏 评论0 发布时间:2022-9-18 22:18

举报

0个回答

所属标签

相似技术帖

官网相关资源

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