打印
[STM32F1]

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

[复制链接]
1253|1
手机看帖
扫描二维码
随时随地手机跟帖
跳转到指定楼层
楼主
亼亽|  楼主 | 2016-6-16 08:35 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
【HAL库每天一例】系列例程从今天开始持续更新。。。。。
我们将**每天至少发布一个基于YS-F1Pro开发板的HAL库例程,
该系列例程将带领大家从零开始使用HAL库,后面会持续添加模块应用例程。
同样的,我们还程序发布基于HAL库的指导文档和视频教程,欢迎持续关注,并提出改进意见。
例程下载:
资料包括程序、相关说明资料以及软件使用截图
等级不够,不给发连接(去掉下面链接空格)
百度云:pan. baidu. com/s/1jIvrqlC
(硬石YS-F1Pro开发板HAL库例程持续更新\1. 软件设计之基本裸机例程(HAL库版本)\YSF1_HAL-042. FSMC-扩展SRAM内存管理


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

【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文件内容
#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文件内容
/**
  ******************************************************************************
  * 文件名程: 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****/




沙发
mmuuss586| | 2016-6-16 10:16 | 只看该作者
谢谢分享

使用特权

评论回复
发新帖 我要提问
您需要登录后才可以回帖 登录 | 注册

本版积分规则

122

主题

216

帖子

48

粉丝