【HAL库每天一例】第042例：FSMC-扩展SRAM内存管理

haohao663

【HAL库每天一例】系列例程从今天开始持续更新。。。。。
我们将坚持每天至少发布一个基于YS-F1Pro开发板的HAL库例程，
该系列例程将带领大家从零开始使用HAL库，后面会持续添加模块应用例程。
同样的，我们还程序发布基于HAL库的指导文档和视频教程，欢迎持续关注，并提出改进意见。
例程下载：
资料包括程序、相关说明资料以及软件使用截图
YSF1_HAL-042. FSMC-扩展SRAM内存管理.zip (4.88 MB, 下载次数: 24)

2016-6-16 08:44 上传

点击文件名下载附件

/**
  ******************************************************************************
  *                           硬石YS-F1Pro开发板例程功能说明
  *
  *  例程名称: YSF1_HAL-042. FSMC-扩展SRAM内存管理
  *   
  ******************************************************************************
  * 说明：
  * 本例程配套硬石stm32开发板YS-F1Pro使用。
  * 版权归硬石嵌入式开发团队所有，请勿商用。
  ******************************************************************************
  */

【1】例程简介
  FSMC：可变静态存储控制器，是STM32系列采用的一种新型的存储器扩展技术。
  RAM在单片机作用类似与电脑的内存。STM32F106ZET6内部有64KB大小的RAM，对应一般工程程序
是足够使用的，但如果需要运行类似STemWin支持的界面设计就显得有点捉襟见肘，我们可以外部扩
展SRAM。
  YS-F1Pro开发板板载1M字节的扩展SRAM，本例程增加动态内存管理驱动，这样提高内存的使用率。
  
【2】跳线帽情况
******* 为保证例程正常运行，必须插入以下跳线帽 **********
丝印编号     IO端口      目标功能引脚        出厂默认设置
  JP1        PA10        TXD(CH340G)          已接入
  JP2        PA9         RXD(CH340G)          已接入
  
【3】操作及现象
  使用开发板配套的MINI USB线连接到开发板标示“调试串口”字样的MIMI USB接口（需要安装驱动），
在电脑端打开串口调试助手工具，设置参数为115200 8-N-1。下载完程序之后，在串口调试助手窗口
可接收到信息。

/******************* (C) COPYRIGHT 2015-2020 硬石嵌入式开发团队 *****END OF FILE****/

bsp_malloc.h文件内容

1. #ifndef __BSP_MALLOC_H__
   
2. #define __BSP_MALLOC_H__
   
3. 
   
4. /* 包含头文件 ----------------------------------------------------------------*/
   
5. #include "stm32f1xx_hal.h"
   
6. 
   
7. /* 宏定义 --------------------------------------------------------------------*/
   
8. #ifndef NULL
   
9. #define NULL 0
   
10. #endif
    
11. 
    
12. //定义两个内存池
    
13. #define SRAMIN                         0                                         //内部内存池
    
14. #define SRAMEX                   1                                         //外部内存池
    
15. 
    
16. #define SRAMBANK                        2                                   //定义支持的SRAM块数.        
    
17. 
    
18. //mem1内存参数设定.mem1完全处于内部SRAM里面.
    
19. #define MEM1_BLOCK_SIZE                             32                                                                       //内存块大小为32字节
    
20. #define MEM1_MAX_SIZE                               40*1024                                                                //最大管理内存 40K
    
21. #define MEM1_ALLOC_TABLE_SIZE    MEM1_MAX_SIZE/MEM1_BLOCK_SIZE          //内存表大小
    
22. 
    
23. //mem2内存参数设定.mem2的内存池处于外部SRAM里面
    
24. #define MEM2_BLOCK_SIZE                             32                                                                       //内存块大小为32字节
    
25. #define MEM2_MAX_SIZE                               928*1024                                                     //最大管理内存960K
    
26. #define MEM2_ALLOC_TABLE_SIZE           MEM2_MAX_SIZE/MEM2_BLOCK_SIZE    //内存表大小
    
27. 
    
28. /* 类型定义 ------------------------------------------------------------------*/
    
29. //内存管理控制器
    
30. struct _m_mallco_dev
    
31. {
    
32.         void    ( * init ) ( uint8_t );                                 //初始化
    
33.         uint8_t ( * perused ) ( uint8_t );                 //内存使用率
    
34.         uint8_t   * membase [ SRAMBANK ];                   //内存池 管理SRAMBANK个区域的内存
    
35.         uint16_t  * memmap  [ SRAMBANK ];                    //内存管理状态表
    
36.         uint8_t     memrdy [ SRAMBANK ];                          //内存管理是否就绪
    
37. };        
    
38. 
    
39. /* 扩展变量 ------------------------------------------------------------------*/
    
40. extern struct _m_mallco_dev mallco_dev;         //在mallco.c里面定义
    
41. 
    
42. /* 函数声明 ------------------------------------------------------------------*/
    
43. void mymemset(void *s,uint8_t c,uint32_t count);            //设置内存
    
44. void mymemcpy(void *des,void *src,uint32_t n);        //复制内存     
    
45. void my_mem_init(uint8_t memx);                                                //内存管理初始化函数(外/内部调用)
    
46. uint32_t my_mem_malloc(uint8_t memx,uint32_t size);          //内存分配(内部调用)
    
47. uint8_t my_mem_free(uint8_t memx,uint32_t offset);                //内存释放(内部调用)
    
48. uint8_t my_mem_perused(uint8_t memx);                                          //获得内存使用率(外/内部调用)
    
49. 
    
50. //用户调用函数
    
51. void myfree(uint8_t memx,void *ptr);                                     //内存释放(外部调用)
    
52. void *mymalloc(uint8_t memx,uint32_t size);                               //内存分配(外部调用)
    
53. void *myrealloc(uint8_t memx,void *ptr,uint32_t size); //重新分配内存(外部调用)
    
54. 
    
55. #endif /* __BSP_MALLOC_H__ */
    
56. 
    
57. /*************************************** 硬石嵌入式开发团队 *****END OF FILE****/
    
58. 
    

复制代码

bsp_malloc.c文件内容

1. /**
   
2.   ******************************************************************************
   
3.   * 文件名程: bsp_malloc.c
   
4.   * 作    者: 硬石嵌入式开发团队
   
5.   * 版    本: V1.0
   
6.   * 编写日期: 2015-10-04
   
7.   * 功    能: 动态内存分配管理实现
   
8.   ******************************************************************************
   
9.   * 说明：
   
10.   * 本例程配套硬石stm32开发板YS-F1Pro使用。
    
11.   *
    
12.   * 淘宝：
    
13.   * 论坛：http://www.ing10bbs.com
    
14.   *
    
15.   ******************************************************************************
    
16.   */
    
17. /* 包含头文件 ----------------------------------------------------------------*/
    
18. #include "malloc/bsp_malloc.h"
    
19. #include "exSRAM/bsp_exSRAM.h"
    
20. 
    
21. /* 私有宏定义 ----------------------------------------------------------------*/
    
22. /* 私有变量 ------------------------------------------------------------------*/
    
23. #if defined ( __CC_ARM )  // 使用Keil编译环境
    
24. 
    
25. //内存池(4字节对齐)
    
26. __align(4) uint8_t mem1base[MEM1_MAX_SIZE];                                                                                                        //内部SRAM内存池
    
27. __align(4) uint8_t mem2base[MEM2_MAX_SIZE] __attribute__((at(EXSRAM_BANK_ADDR)));                                        //外部SRAM内存池
    
28. 
    
29. //内存管理表
    
30. uint16_t mem1mapbase[MEM1_ALLOC_TABLE_SIZE];                                                                                                        //内部SRAM内存池MAP
    
31. uint16_t mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__((at(EXSRAM_BANK_ADDR+MEM2_MAX_SIZE)));        //外部SRAM内存池MAP
    
32. 
    
33. #elif defined ( __ICCARM__ ) // 使用IAR编译环境
    
34. 
    
35. //内存池(4字节对齐)
    
36. #pragma pack(4)
    
37. uint8_t mem1base[MEM1_MAX_SIZE];                                                                                                        //内部SRAM内存池
    
38. 
    
39. #pragma location=EXSRAM_BANK_ADDR
    
40. #pragma pack(4)
    
41. uint8_t mem2base[MEM2_MAX_SIZE];      //外部SRAM内存池
    
42. 
    
43. //内存管理表
    
44. uint16_t mem1mapbase[MEM1_ALLOC_TABLE_SIZE];        //内部SRAM内存池MAP
    
45. 
    
46. #pragma location=(EXSRAM_BANK_ADDR+MEM2_MAX_SIZE)
    
47. uint16_t mem2mapbase[MEM2_ALLOC_TABLE_SIZE];        //外部SRAM内存池MAP
    
48. 
    
49. #endif
    
50. 
    
51. //内存管理参数           
    
52. const uint32_t memtblsize[SRAMBANK]={MEM1_ALLOC_TABLE_SIZE,MEM2_ALLOC_TABLE_SIZE};                        //内存表大小
    
53. const uint32_t memblksize[SRAMBANK]={MEM1_BLOCK_SIZE,MEM2_BLOCK_SIZE};                                                      //内存分块大小
    
54. const uint32_t memsize[SRAMBANK]={MEM1_MAX_SIZE,MEM2_MAX_SIZE};                                                                          //内存总大小
    
55. 
    
56. /* 私有类型定义 --------------------------------------------------------------*/
    
57. //内存管理控制器
    
58. struct _m_mallco_dev mallco_dev=
    
59. {
    
60.         my_mem_init,                                             //内存初始化
    
61.         my_mem_perused,                                           //内存使用率
    
62.         mem1base,mem2base,                                 //内存池
    
63.         mem1mapbase,mem2mapbase,               //内存管理状态表
    
64.         0,0,                                                                  //内存管理未就绪
    
65. };
    
66. 
    
67. /* 扩展变量 ------------------------------------------------------------------*/
    
68. /* 私有函数原形 --------------------------------------------------------------*/
    
69. /* 函数体 --------------------------------------------------------------------*/
    
70. 
    
71. //复制内存
    
72. //*des:目的地址
    
73. //*src:源地址
    
74. //n:需要复制的内存长度(字节为单位)
    
75. void mymemcpy(void *des,void *src,uint32_t n)  
    
76. {  
    
77.         uint8_t *xdes=des;
    
78.         uint8_t *xsrc=src;         
    
79.         while(n--)*xdes++=*xsrc++;  
    
80. }  
    
81. 
    
82. //设置内存
    
83. //*s:内存首地址
    
84. //c :要设置的值
    
85. //count:需要设置的内存大小(字节为单位)
    
86. void mymemset(void *s,uint8_t c,uint32_t count)  
    
87. {  
    
88.         uint8_t *xs = s;  
    
89.         while(count--)*xs++=c;  
    
90. }           
    
91. 
    
92. //内存管理初始化  
    
93. //memx:所属内存块
    
94. void my_mem_init(uint8_t memx)  
    
95. {  
    
96.         mymemset(mallco_dev.memmap[memx], 0,memtblsize[memx]*2);//内存状态表数据清零  
    
97.         mymemset(mallco_dev.membase[memx], 0,memsize[memx]);        //内存池所有数据清零  
    
98.         mallco_dev.memrdy[memx]=1;                                                                //内存管理初始化OK  
    
99. }  
    
100. 
     
101. //获取内存使用率
     
102. //memx:所属内存块
     
103. //返回值:使用率(0~100)
     
104. uint8_t my_mem_perused(uint8_t memx)  
     
105. {  
     
106.         uint32_t used=0;  
     
107.         uint32_t i;  
     
108.         
     
109.         for(i=0;i<memtblsize[memx];i++)  
     
110.         {  
     
111.                 if(mallco_dev.memmap[memx][i])used++;
     
112.         }
     
113.         return (used*100)/(memtblsize[memx]);  
     
114. }  
     
115. 
     
116. 
     
117. //内存分配(内部调用)
     
118. //memx:所属内存块
     
119. //size:要分配的内存大小(字节)
     
120. //返回值:0XFFFFFFFF,代表错误;其他,内存偏移地址
     
121. uint32_t my_mem_malloc(uint8_t memx,uint32_t size)  
     
122. {  
     
123.         signed long offset=0;  
     
124.         uint32_t nmemb;        //需要的内存块数  
     
125.         uint32_t cmemb=0;//连续空内存块数
     
126.         uint32_t i;  
     
127.         
     
128.         if(!mallco_dev.memrdy[memx])mallco_dev.init(memx);//未初始化,先执行初始化
     
129.         
     
130.         if(size==0)
     
131.                 return 0XFFFFFFFF;//不需要分配
     
132.         
     
133.         nmemb=size/memblksize[memx];          //获取需要分配的连续内存块数
     
134.         
     
135.         if(size%memblksize[memx])nmemb++;
     
136.         
     
137.         for(offset=memtblsize[memx]-1;offset>=0;offset--)//搜索整个内存控制区  
     
138.         {     
     
139.                 if(!mallco_dev.memmap[memx][offset])cmemb++;//连续空内存块数增加
     
140.                 else cmemb=0;                                                                //连续内存块清零
     
141.                
     
142.                 if(cmemb==nmemb)                                                        //找到了连续nmemb个空内存块
     
143.                 {
     
144.                         for(i=0;i<nmemb;i++)                                          //标注内存块非空
     
145.                         {  
     
146.                                         mallco_dev.memmap[memx][offset+i]=nmemb;  
     
147.                         }  
     
148.                         return (offset*memblksize[memx]);//返回偏移地址  
     
149.                 }
     
150.         }  
     
151.         return 0XFFFFFFFF;//未找到符合分配条件的内存块  
     
152. }  
     
153. 
     
154. 
     
155. //释放内存(内部调用)
     
156. //memx:所属内存块
     
157. //offset:内存地址偏移
     
158. //返回值:0,释放成功;1,释放失败;  
     
159. uint8_t my_mem_free(uint8_t memx,uint32_t offset)  
     
160. {  
     
161.         int i;  
     
162.   
     
163.         if(!mallco_dev.memrdy[memx])//未初始化,先执行初始化
     
164.         {
     
165.         mallco_dev.init(memx);   
     
166.                         return 1;//未初始化  
     
167.         }  
     
168. 
     
169.         if(offset<memsize[memx])//偏移在内存池内.
     
170.         {  
     
171.                         int index=offset/memblksize[memx];                        //偏移所在内存块号码  
     
172.                         int nmemb=mallco_dev.memmap[memx][index];        //内存块数量
     
173.                         for(i=0;i<nmemb;i++)                                                  //内存块清零
     
174.                         {  
     
175.                                         mallco_dev.memmap[memx][index+i]=0;  
     
176.                         }  
     
177.                         return 0;  
     
178.         }
     
179.         else
     
180.                 return 2;//偏移超区了.  
     
181. }  
     
182. 
     
183. 
     
184. //释放内存(外部调用)
     
185. //memx:所属内存块
     
186. //ptr:内存首地址
     
187. void myfree(uint8_t memx,void *ptr)  
     
188. {  
     
189.         uint32_t offset;   
     
190.         
     
191.         if(ptr==NULL)return;//地址为0.  
     
192.         offset=(uint32_t)ptr-(uint32_t)mallco_dev.membase[memx];     
     
193.         my_mem_free(memx,offset);        //释放内存     
     
194. }  
     
195. 
     
196. //分配内存(外部调用)
     
197. //memx:所属内存块
     
198. //size:内存大小(字节)
     
199. //返回值:分配到的内存首地址.
     
200. void *mymalloc(uint8_t memx,uint32_t size)  
     
201. {  
     
202.         uint32_t offset;   
     
203. 
     
204.         offset=my_mem_malloc(memx,size);                     
     
205.         
     
206.         if(offset==0XFFFFFFFF)return NULL;  
     
207.         else return (void*)((uint32_t)mallco_dev.membase[memx]+offset);  
     
208. }  
     
209. 
     
210. //重新分配内存(外部调用)
     
211. //memx:所属内存块
     
212. //*ptr:旧内存首地址
     
213. //size:要分配的内存大小(字节)
     
214. //返回值:新分配到的内存首地址.
     
215. void *myrealloc(uint8_t memx,void *ptr,uint32_t size)  
     
216. {  
     
217.         uint32_t offset;   
     
218.         
     
219.         offset=my_mem_malloc(memx,size);           
     
220.         if(offset==0XFFFFFFFF)return NULL;     
     
221.         else  
     
222.         {                                                                             
     
223.                 mymemcpy((void*)((uint32_t)mallco_dev.membase[memx]+offset),ptr,size);        //拷贝旧内存内容到新内存   
     
224.                 myfree(memx,ptr);                                                                                                            //释放旧内存
     
225.                 return (void*)((uint32_t)mallco_dev.membase[memx]+offset);                                  //返回新内存首地址
     
226.         }  
     
227. }
     
228. 
     
229. /***************************************硬石嵌入式开发团队 *****END OF FILE****/
     

复制代码

Ian-392967

谢谢分享！