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

#ifndef __BSP_MALLOC_H__

#define __BSP_MALLOC_H__



/* 包含头文件 ----------------------------------------------------------------*/

#include "stm32f1xx_hal.h"



/* 宏定义 --------------------------------------------------------------------*/

#ifndef NULL

#define NULL 0

#endif



//定义两个内存池

#define SRAMIN                         0                                         //内部内存池

#define SRAMEX                   1                                         //外部内存池 



#define SRAMBANK                        2                                   //定义支持的SRAM块数.        



//mem1内存参数设定.mem1完全处于内部SRAM里面.

#define MEM1_BLOCK_SIZE                             32                                                                       //内存块大小为32字节

#define MEM1_MAX_SIZE                               40*1024                                                                //最大管理内存 40K

#define MEM1_ALLOC_TABLE_SIZE    MEM1_MAX_SIZE/MEM1_BLOCK_SIZE          //内存表大小



//mem2内存参数设定.mem2的内存池处于外部SRAM里面

#define MEM2_BLOCK_SIZE                             32                                                                       //内存块大小为32字节

#define MEM2_MAX_SIZE                               928*1024                                                     //最大管理内存960K

#define MEM2_ALLOC_TABLE_SIZE           MEM2_MAX_SIZE/MEM2_BLOCK_SIZE    //内存表大小 



/* 类型定义 ------------------------------------------------------------------*/

//内存管理控制器

struct _m_mallco_dev

{

        void    ( * init ) ( uint8_t );                                 //初始化

        uint8_t ( * perused ) ( uint8_t );                 //内存使用率

        uint8_t   * membase [ SRAMBANK ];                   //内存池 管理SRAMBANK个区域的内存

        uint16_t  * memmap  [ SRAMBANK ];                    //内存管理状态表

        uint8_t     memrdy [ SRAMBANK ];                          //内存管理是否就绪

};        



/* 扩展变量 ------------------------------------------------------------------*/

extern struct _m_mallco_dev mallco_dev;         //在mallco.c里面定义



/* 函数声明 ------------------------------------------------------------------*/

void mymemset(void *s,uint8_t c,uint32_t count);            //设置内存

void mymemcpy(void *des,void *src,uint32_t n);        //复制内存     

void my_mem_init(uint8_t memx);                                                //内存管理初始化函数(外/内部调用)

uint32_t my_mem_malloc(uint8_t memx,uint32_t size);          //内存分配(内部调用)

uint8_t my_mem_free(uint8_t memx,uint32_t offset);                //内存释放(内部调用)

uint8_t my_mem_perused(uint8_t memx);                                          //获得内存使用率(外/内部调用) 



//用户调用函数

void myfree(uint8_t memx,void *ptr);                                     //内存释放(外部调用)

void *mymalloc(uint8_t memx,uint32_t size);                               //内存分配(外部调用)

void *myrealloc(uint8_t memx,void *ptr,uint32_t size); //重新分配内存(外部调用)



#endif /* __BSP_MALLOC_H__ */



/*************************************** 硬石嵌入式开发团队 *****END OF FILE****/

/**

  ******************************************************************************

  * 文件名程: bsp_malloc.c 

  * 作    者: 硬石嵌入式开发团队

  * 版    本: V1.0

  * 编写日期: 2015-10-04

  * 功    能: 动态内存分配管理实现

  ******************************************************************************

  * 说明：

  * 本例程配套硬石stm32开发板YS-F1Pro使用。

  * 

  * 淘宝：

  * 论坛：ing10bbs

  * 

  ******************************************************************************

  */

/* 包含头文件 ----------------------------------------------------------------*/

#include "malloc/bsp_malloc.h"

#include "exSRAM/bsp_exSRAM.h"



/* 私有宏定义 ----------------------------------------------------------------*/

/* 私有变量 ------------------------------------------------------------------*/

#if defined ( __CC_ARM )  // 使用Keil编译环境



//内存池(4字节对齐)

__align(4) uint8_t mem1base[MEM1_MAX_SIZE];                                                                                                        //内部SRAM内存池

__align(4) uint8_t mem2base[MEM2_MAX_SIZE] __attribute__((at(EXSRAM_BANK_ADDR)));                                        //外部SRAM内存池



//内存管理表

uint16_t mem1mapbase[MEM1_ALLOC_TABLE_SIZE];                                                                                                        //内部SRAM内存池MAP

uint16_t mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__((at(EXSRAM_BANK_ADDR+MEM2_MAX_SIZE)));        //外部SRAM内存池MAP



#elif defined ( __ICCARM__ ) // 使用IAR编译环境



//内存池(4字节对齐)

#pragma pack(4) 

uint8_t mem1base[MEM1_MAX_SIZE];                                                                                                        //内部SRAM内存池



#pragma location=EXSRAM_BANK_ADDR

#pragma pack(4)

uint8_t mem2base[MEM2_MAX_SIZE];      //外部SRAM内存池



//内存管理表

uint16_t mem1mapbase[MEM1_ALLOC_TABLE_SIZE];        //内部SRAM内存池MAP



#pragma location=(EXSRAM_BANK_ADDR+MEM2_MAX_SIZE)

uint16_t mem2mapbase[MEM2_ALLOC_TABLE_SIZE];        //外部SRAM内存池MAP



#endif



//内存管理参数           

const uint32_t memtblsize[SRAMBANK]={MEM1_ALLOC_TABLE_SIZE,MEM2_ALLOC_TABLE_SIZE};                        //内存表大小

const uint32_t memblksize[SRAMBANK]={MEM1_BLOCK_SIZE,MEM2_BLOCK_SIZE};                                                      //内存分块大小

const uint32_t memsize[SRAMBANK]={MEM1_MAX_SIZE,MEM2_MAX_SIZE};                                                                          //内存总大小



/* 私有类型定义 --------------------------------------------------------------*/

//内存管理控制器

struct _m_mallco_dev mallco_dev=

{

        my_mem_init,                                             //内存初始化

        my_mem_perused,                                           //内存使用率

        mem1base,mem2base,                                 //内存池

        mem1mapbase,mem2mapbase,               //内存管理状态表

        0,0,                                                                  //内存管理未就绪

};



/* 扩展变量 ------------------------------------------------------------------*/

/* 私有函数原形 --------------------------------------------------------------*/

/* 函数体 --------------------------------------------------------------------*/



//复制内存

//*des:目的地址

//*src:源地址

//n:需要复制的内存长度(字节为单位)

void mymemcpy(void *des,void *src,uint32_t n)  

{  

        uint8_t *xdes=des;

        uint8_t *xsrc=src;         

        while(n--)*xdes++=*xsrc++;  

}  



//设置内存

//*s:内存首地址

//c :要设置的值

//count:需要设置的内存大小(字节为单位)

void mymemset(void *s,uint8_t c,uint32_t count)  

{  

        uint8_t *xs = s;  

        while(count--)*xs++=c;  

}           



//内存管理初始化  

//memx:所属内存块

void my_mem_init(uint8_t memx)  

{  

        mymemset(mallco_dev.memmap[memx], 0,memtblsize[memx]*2);//内存状态表数据清零  

        mymemset(mallco_dev.membase[memx], 0,memsize[memx]);        //内存池所有数据清零  

        mallco_dev.memrdy[memx]=1;                                                                //内存管理初始化OK  

}  



//获取内存使用率

//memx:所属内存块

//返回值:使用率(0~100)

uint8_t my_mem_perused(uint8_t memx)  

{  

        uint32_t used=0;  

        uint32_t i;  

        

        for(i=0;i<memtblsize[memx];i++)  

        {  

                if(mallco_dev.memmap[memx][i])used++; 

        } 

        return (used*100)/(memtblsize[memx]);  

}  





//内存分配(内部调用)

//memx:所属内存块

//size:要分配的内存大小(字节)

//返回值:0XFFFFFFFF,代表错误;其他,内存偏移地址 

uint32_t my_mem_malloc(uint8_t memx,uint32_t size)  

{  

        signed long offset=0;  

        uint32_t nmemb;        //需要的内存块数  

        uint32_t cmemb=0;//连续空内存块数

        uint32_t i;  

        

        if(!mallco_dev.memrdy[memx])mallco_dev.init(memx);//未初始化,先执行初始化 

        

        if(size==0)

                return 0XFFFFFFFF;//不需要分配

        

        nmemb=size/memblksize[memx];          //获取需要分配的连续内存块数

        

        if(size%memblksize[memx])nmemb++; 

        

        for(offset=memtblsize[memx]-1;offset>=0;offset--)//搜索整个内存控制区  

        {     

                if(!mallco_dev.memmap[memx][offset])cmemb++;//连续空内存块数增加

                else cmemb=0;                                                                //连续内存块清零

                

                if(cmemb==nmemb)                                                        //找到了连续nmemb个空内存块

                {

                        for(i=0;i<nmemb;i++)                                          //标注内存块非空 

                        {  

                                        mallco_dev.memmap[memx][offset+i]=nmemb;  

                        }  

                        return (offset*memblksize[memx]);//返回偏移地址  

                }

        }  

        return 0XFFFFFFFF;//未找到符合分配条件的内存块  

}  





//释放内存(内部调用) 

//memx:所属内存块

//offset:内存地址偏移

//返回值:0,释放成功;1,释放失败;  

uint8_t my_mem_free(uint8_t memx,uint32_t offset)  

{  

        int i;  

  

        if(!mallco_dev.memrdy[memx])//未初始化,先执行初始化

        {

        mallco_dev.init(memx);    

                        return 1;//未初始化  

        }  



        if(offset<memsize[memx])//偏移在内存池内. 

        {  

                        int index=offset/memblksize[memx];                        //偏移所在内存块号码  

                        int nmemb=mallco_dev.memmap[memx][index];        //内存块数量

                        for(i=0;i<nmemb;i++)                                                  //内存块清零

                        {  

                                        mallco_dev.memmap[memx][index+i]=0;  

                        }  

                        return 0;  

        }

        else 

                return 2;//偏移超区了.  

}  





//释放内存(外部调用) 

//memx:所属内存块

//ptr:内存首地址 

void myfree(uint8_t memx,void *ptr)  

{  

        uint32_t offset;   

        

        if(ptr==NULL)return;//地址为0.  

        offset=(uint32_t)ptr-(uint32_t)mallco_dev.membase[memx];     

        my_mem_free(memx,offset);        //释放内存     

}  



//分配内存(外部调用)

//memx:所属内存块

//size:内存大小(字节)

//返回值:分配到的内存首地址.

void *mymalloc(uint8_t memx,uint32_t size)  

{  

        uint32_t offset;   



        offset=my_mem_malloc(memx,size);                      

        

        if(offset==0XFFFFFFFF)return NULL;  

        else return (void*)((uint32_t)mallco_dev.membase[memx]+offset);  

}  



//重新分配内存(外部调用)

//memx:所属内存块

//*ptr:旧内存首地址

//size:要分配的内存大小(字节)

//返回值:新分配到的内存首地址.

void *myrealloc(uint8_t memx,void *ptr,uint32_t size)  

{  

        uint32_t offset;    

        

        offset=my_mem_malloc(memx,size);           

        if(offset==0XFFFFFFFF)return NULL;     

        else  

        {                                                                             

                mymemcpy((void*)((uint32_t)mallco_dev.membase[memx]+offset),ptr,size);        //拷贝旧内存内容到新内存   

                myfree(memx,ptr);                                                                                                            //释放旧内存

                return (void*)((uint32_t)mallco_dev.membase[memx]+offset);                                  //返回新内存首地址

        }  

}



/***************************************硬石嵌入式开发团队 *****END OF FILE****/