STM32 内存管理

最新推荐文章于 2024-07-16 12:57:18 发布
最新推荐文章于 2024-07-16 12:57:18 发布
阅读量1.1k 收藏 9
点赞数 1
分类专栏： # stm32 文章标签： linux 运维 服务器 stm32
原文链接：https://blog.51cto.com/u_14114084/4586394
版权

动态内存管理

  • 根据需要分配內存和回收内存
    通常在一块较大且连续的内存空间上进行分配和回收
  • 动态内存管理解决的问题
    内存资源稀缺，通过内存复用增加任务的并发性
  • 动态内存管理的本质
    时间换空间，通过动态分配和回收“扩大”物理内存

动态内存管理的关键

  • 时间效率
    从发出内存申请到得内存的时间越短越好
  • 空间效率
    为了管理内存而占用的内存越少越好
  • 碎片化
    最大可分配内存占空闲内存总和的比例越大越好

动态内存管理的分类

  • 定长内存管理
    将内存分为大小相同的单元，每次申请一个单元的内存

  • 变长内存管理
    每次申请需要的内存（大小不固定，以字节为单位）

  • 定长内存管理的设计与实现
    将内存分为两部分：管理单元&分配单元
    管理单元与分配单元——对应

uint8_t mem2base[960*1024] __attribute__((at(0X68000000)));

表示在外部SRAM内存区域定义一个数组，这里使用的是FSMC的BANK1的NE3，对应的外部地址就是0X68000000。不明白的去看一看STM32的FSMC章节。
//内存池(32字节对齐)

__align(32) uint8_t mem1base[100*1024];										//内部SRAM内存池 100K
__align(32) uint8_t mem2base[960*1024] __attribute__((at(0X68000000)));		//外部SRAM内存池 960K
__align(32) uint8_t mem3base[60 *1024] __attribute__((at(0X10000000)));		//内部CCM内存池 60K

//内存管理表
uint16_t mem1mapbase[100*1024/32];											//内部SRAM内存池MAP
uint16_t mem2mapbase[960*1024/32] __attribute__((at(0X68000000+960*1024)));	//外部SRAM内存池MAP
uint16_t mem3mapbase[60 *1024/32] __attribute__((at(0X10000000+60*1024)));	//内部CCM内存池MAP

//内存管理参数	   
const uint32_t memtblsize[SRAMBANK]={100*1024/32,960*1024/32,60 *1024/32};	//内存表大小
const uint32_t memblksize[SRAMBANK]={32,32,32};					         //内存分块大小
const uint32_t memsize   [SRAMBANK]={100*1024,960*1024,60*1024};			//内存总大小

malloc.c

#include "malloc.h"	   


//内存管理就绪
#define  MEMRDY   1
#define  MEMBSY   0

//内存池(32字节对齐)   
__align(32) uint8_t mem1base[100*1024];										//内部SRAM内存池 100K
__align(32) uint8_t mem2base[960*1024] __attribute__((at(0X68000000)));		//外部SRAM内存池 960K
__align(32) uint8_t mem3base[60 *1024] __attribute__((at(0X10000000)));		//内部CCM内存池 60K

//内存管理表 32字节为单位
uint16_t mem1mapbase[100*1024/32];											//内部SRAM内存池MAP
uint16_t mem2mapbase[960*1024/32] __attribute__((at(0X68000000+960*1024)));	//外部SRAM内存池MAP
uint16_t mem3mapbase[60 *1024/32] __attribute__((at(0X10000000+60*1024)));	//内部CCM内存池MAP

//内存管理参数	   
const uint32_t memtblsize[SRAMBANK]={100*1024/32,960*1024/32,60 *1024/32};	//内存表大小
const uint32_t memblksize[SRAMBANK]={32,32,32};					            //内存分块大小
const uint32_t memsize   [SRAMBANK]={100*1024,960*1024,60*1024};			//内存总大小

//内存管理控制器
MALLOC_EDV_T  g_mallcoDev = 
{
	my_mem_init,					    	      //内存初始化
	my_mem_perused,						      //内存使用率
	mem1base, mem2base, mem3base,			     //内存池
	mem1mapbase, mem2mapbase, mem3mapbase,  //内存管理状态表
	MEMBSY, MEMBSY, MEMBSY,	    	           //内存管理未就绪
};


/************************************************************************
** 函数名称: mymemcpy									
** 函数功能: 复制内存
** 入口参数: void *des:目的地址
**           void *src:原地址
**           uint32_t n:  需要复制的内存长度(以字节为单位) 
** 出口参数: 												
************************************************************************/
void mymemcpy(void *des,void *src,uint32_t n)  
{  
	uint8_t *xdes=des;
	uint8_t *xsrc=src; 
	while(n--)
		*xdes++=*xsrc++;  
} 


/************************************************************************
** 函数名称: mymemset									
** 函数功能: 设置内存
** 入口参数: void *s:内存首地址
**           uint8_t c:要设置的值
**           uint32_t count:  需要设置的内存长度(以字节为单位) 
** 出口参数: 												
************************************************************************/
void mymemset(void *s,uint8_t c,uint32_t count)  
{  
	uint8_t *xs = s;  
	while(count--)
		*xs++=c;  
}	   


/************************************************************************
** 函数名称: my_mem_init									
** 函数功能: 内存管理初始化  
** 入口参数: uint8_t memx:所属内存块 
** 出口参数: 												
************************************************************************/
void my_mem_init(uint8_t memx)  
{  
	//清除内存状态表-每一个内存块对应状态表中的一项
	//因为内存管理状态表示16位的，所以需要乘以2
	mymemset( g_mallcoDev.memmap[memx], 0, memtblsize[memx]*2); 
	//把所管理的内存池全部清理
	mymemset(g_mallcoDev.membase[memx], 0, memsize[memx]); 
	//表明对应的内存管理已经就绪
	g_mallcoDev.memrdy[memx] = MEMRDY;
}  

/************************************************************************
** 函数名称: my_mem_perused									
** 函数功能: 计算内存使用率
** 入口参数: uint8_t 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++)  
	{  
		  //如果表项值不为0就表示对应内存块被使用了
			if(g_mallcoDev.memmap[memx][i])
				used++; 
	} 
	
	//计算百分比
	return (used*100)/(memtblsize[memx]);  
}

/************************************************************************
** 函数名称: my_mem_malloc									
** 函数功能: 内存分配(内部调用)
** 入口参数: uint8_t memx:所属内存块 
**           uint32_t 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(g_mallcoDev.memrdy[memx] == MEMBSY)
		g_mallcoDev.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(g_mallcoDev.memmap[memx][offset] == 0)
		{
			//连续空内存块数增加
			cmemb++;
		}
		else 
		{
			//连续内存块清零--只要找到一个被使用的就表示不连续了，要重新开始找
			cmemb=0;								
		}
		
		//找到了连续nmemb个空内存块
		if(cmemb == nmemb)							
		{
			//标注内存块非空--并且是连续nmemb个非空块
			for(i=0;i<nmemb;i++)  					
			{  
				g_mallcoDev.memmap[memx][offset+i] = nmemb;  
			}  
			//返回偏移地址 
			return (offset*memblksize[memx]); 
		}
	}  
	//未找到符合分配条件的内存块 
	return 0xFFFFFFFF; 
}  

/************************************************************************
** 函数名称: my_mem_free									
** 函数功能: 释放内存(内部调用) 
** 入口参数: uint8_t memx:所属内存块
**           uint32_t offset:内存地址偏移
** 出口参数: 0-释放成功;1-释放失败										
************************************************************************/
uint8_t my_mem_free(uint8_t memx,uint32_t offset)  
{  
	int i; 

  //未初始化,先执行初始化	
	if(g_mallcoDev.memrdy[memx] == MEMBSY)
	{
		g_mallcoDev.init(memx);    
    return 1;//未初始化  
   }  
	
	//偏移在内存池内. 
	if(offset < memsize[memx])
	{  
		int index = offset/memblksize[memx];			//偏移所在内存块号码  
		int nmemb = g_mallcoDev.memmap[memx][index];	//内存块数量
		
		for(i=0;i<nmemb;i++)  						//内存块清零
		{  
			g_mallcoDev.memmap[memx][index+i] = 0;  
		}  
		return 0;  
	}
	else 
		return 2;//偏移超区了.  
}  

/************************************************************************
** 函数名称: myfree									
** 函数功能: 释放内存(外部调用) 
** 入口参数: uint8_t memx:所属内存块
**           void *ptr:内存地址偏移
** 出口参数: 无									
************************************************************************/
void myfree(uint8_t memx,void *ptr)  
{  
	uint32_t offset; 
	
  //地址为0. 
	if(ptr==NULL)
		return; 
	
	//计算指针在相应内存块中的偏移量
 	offset = (uint32_t)ptr-(uint32_t)g_mallcoDev.membase[memx]; 

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

/************************************************************************
** 函数名称: mymalloc									
** 函数功能: 内存分配(内部调用)
** 入口参数: uint8_t memx:所属内存块 
**           uint32_t 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)g_mallcoDev.membase[memx]+offset);  
}  

/************************************************************************
** 函数名称: myrealloc									
** 函数功能: 重新分配内存(外部调用)
** 入口参数: uint8_t memx:所属内存块 
**           void *ptr:旧内存首地址
**           uint32_t 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)g_mallcoDev.membase[memx]+offset),ptr,size);	 
		
		//释放旧内存
		myfree(memx,ptr);  			
		
		//返回新内存首地址		
		return (void*)((uint32_t)g_mallcoDev.membase[memx]+offset);  				
	}  
}

malloc.h

#ifndef __MALLOC_H
#define __MALLOC_H

#include "main.h"

#ifndef NULL
    #define NULL 0
#endif

//定义三个内存池
#define SRAMIN	 0		//内部内存池
#define SRAMEX   1		//外部内存池
#define SRAMCCM  2		//CCM内存池(此部分SRAM仅仅CPU可以访问!!!)
#define SRAMBANK 	3	//定义支持的SRAM块数.	

//内存管理控制器
typedef struct
{
    void      (*init)(uint8_t);					      //初始化
    uint8_t   (*perused)(uint8_t);		  	    //内存使用率
    uint8_t    *membase[SRAMBANK];				//内存池 管理SRAMBANK个区域的内存
    uint16_t  *memmap[SRAMBANK]; 				//内存管理状态表
    uint8_t   memrdy[SRAMBANK]; 			   	//内存管理是否就绪
}MALLOC_EDV_T;

extern MALLOC_EDV_T  g_mallcoDev;	 //在mallco.c里面定义
/************************************************************************
** 函数名称: mymemcpy
** 函数功能: 复制内存
** 入口参数: void *des:目的地址
**           void *src:原地址
**           uint32_t n:  需要复制的内存长度(以字节为单位)
** 出口参数:
************************************************************************/
void mymemcpy(void *des, void *src, uint32_t n);

/************************************************************************
** 函数名称: mymemset
** 函数功能: 设置内存
** 入口参数: void *s:内存首地址
**           uint8_t c:要设置的值
**           uint32_t count:  需要设置的内存长度(以字节为单位)
** 出口参数:
************************************************************************/
void mymemset(void *s, uint8_t c, uint32_t count);

/************************************************************************
** 函数名称: my_mem_init
** 函数功能: 内存管理初始化
** 入口参数: uint8_t memx:所属内存块
** 出口参数:
************************************************************************/
void my_mem_init(uint8_t memx);

/************************************************************************
** 函数名称: my_mem_perused
** 函数功能: 计算内存使用率
** 入口参数: uint8_t memx:所属内存块
** 出口参数: 使用率(0~100)
************************************************************************/
uint8_t my_mem_perused(uint8_t memx);

/************************************************************************
** 函数名称: my_mem_malloc
** 函数功能: 内存分配(内部调用)
** 入口参数: uint8_t memx:所属内存块
**           uint32_t size:要分配的内存大小(字节)
** 出口参数: 0xFFFFFFFF-分配错误 其他-内存偏移地址
************************************************************************/
uint32_t my_mem_malloc(uint8_t memx, uint32_t size);

/************************************************************************
** 函数名称: my_mem_free
** 函数功能: 释放内存(内部调用)
** 入口参数: uint8_t memx:所属内存块
**           uint32_t offset:内存地址偏移
** 出口参数: 0-释放成功;1-释放失败
************************************************************************/
uint8_t my_mem_free(uint8_t memx, uint32_t offset);

/************************************************************************
** 函数名称: myfree
** 函数功能: 释放内存(外部调用)
** 入口参数: uint8_t memx:所属内存块
**           void *ptr:内存地址偏移
** 出口参数: 无
************************************************************************/
void myfree(uint8_t memx, void *ptr);

/************************************************************************
** 函数名称: mymalloc
** 函数功能: 内存分配(内部调用)
** 入口参数: uint8_t memx:所属内存块
**           uint32_t size:要分配的内存大小(字节)
** 出口参数: 分配到的内存首地址.
************************************************************************/
void *mymalloc(uint8_t memx, uint32_t size);

/************************************************************************
** 函数名称: myrealloc
** 函数功能: 重新分配内存(外部调用)
** 入口参数: uint8_t memx:所属内存块
**           void *ptr:旧内存首地址
**           uint32_t size:要分配的内存大小(字节)
** 出口参数: 新分配到的内存首地址.
************************************************************************/
void *myrealloc(uint8_t memx, void *ptr, uint32_t size);

#endif

用法：

#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "key.h"
#include "lcd.h"
#include "usmart.h"
#include "sram.h"
#include "malloc.h" 


int main(void)
{
	u8 key;		 
 	u8 i=0;	    
	u8 *p=0;
	
  HAL_Init();                   	//初始化HAL库    
  Stm32_Clock_Init(336,8,2,7);  	//设置时钟,168Mhz
	delay_init(168);               	//初始化延时函数

	KEY_Init();						//初始化KEY
	SRAM_Init();					//初始化外部SRAM 
	my_mem_init(SRAMEX);			//初始化外部内存池	
 	while(1)
	{	
		key=KEY_Scan(0);//不支持连按	
		switch(key)
		{
			case 0://没有按键按下	
				break;
			case KEY0_PRES:	//KEY0按下
				p=mymalloc(SRAMEX,10240);//申请10K字节
				break;
			case KEY1_PRES:	//KEY1按下	   
				if(p!=NULL)
				{
					sprintf((char*)p,"%d",i);//更新显示内容 	 
					LCD_ShowString(30,270,200,16,16,p);			 //显示P的内容
				}
				break;
			case KEY2_PRES:	//KEY2按下	  
				myfree(SRAMEX,p);//释放内存
				p=0;			//指向空地址
				break;
		}
}
路过的小熊~
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STM32内存管理
stm32_newlearner的博客
03-15 7468
内存管理详解 1、介绍 内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源。 内存管理的实现方法有很多种，他们其实最终都是要实现 2 个函数： malloc 和 free； malloc 函数用于内存申请， free 函数用于内存释放。 介绍一种简单的实现方法，分块式内存管理： 原理： malloc分析 首先确定...
stm32-内存管理
Musing的博客
07-05 1473
直接上代码：malloc.h:#ifndef __MALLOC_H #define __MALLOC_H #ifndef NULL #define NULL 0 #endif //定义三个内存池，分别是ARM自带的SDRAM，外置的SDRAM，以及仅供CPU访问的CCM空间 #define SRAMIN 0 //内部内存池 #define SRAMEX 1 //外部内存池(SDRAM...
mymalloc:2 malloc实现的简单功能，专为Linux和gcc提供，具有原子自旋锁
05-17
mymalloc mymalloc-2个malloc实现的简单功能，专为Linux和gcc提供，具有原子自旋锁 进一步的说明可以在我的博客文章找到 执照 麻省理工学院
C语言学习笔记
a201754646的博客
07-20 2264
那么当编译的时候就会生成a.o文件，但并不会去找b这个变量在哪里，而是把它用symbol标记起来，同时b.c文件也会编译，b.c文件中有定义了变量b，当两个文件都编译后就会链接起来，就能找到b变量了。在bin或者HEX文件里面有代码段和数据段，有值的全局变量就是保存在数据段里的，当烧录到Falsh里面时也是分为代码段和数据段，当程序运行时就会把Flash里面的数据段原封不动的拷贝到RAM中。为了区分两种意思，应该进行括号分割，当表示返回值是int*类型时，（int*）add(inta,intb);.....
深入理解STM32内存管理
热门推荐
zhuguanlin121的博客
08-19 1万+
在讨论STM32的内存之前，先来看看STM32的存储器系统，我们知道，STM32大都属于Cortex-M系列的处理器，可以对32的存储器进行寻址，因此存储器的寻址空间能够达到4G，这就意味着指定和数据共用相同的地址空间，也就是将程序存储器、数据存储器、寄存器和输入输出端口被组织在同一个4GB的线性地址空间内。数据字节以小端格式存放在存储器中。一个字里的最低地址字节被认为是该字的最低有效字节，而最高地址字节是最高有效字节。
STM32——内存管理实验
weixin_62584795的博客
10-09 1660
STM32——内存管理实验
STM32内存管理方法
DreamTrue520的博客
01-08 2641
warning: 'at' attribute directive ignored [-Wattributes]的解决 内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源。在我们学习C语言的时候，有学习到malloc和free，一般情况下，C程序使用malloc()在堆上分配内存，free()释放内存。malloc工作原理malloc函数分配的内存是在堆（heap）上的。
STM32 内存管理源码
09-06
STM32 内存管理分析源码实验。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。...
stm32内存管理方法总结资料下载
07-07
一、内存管理简介 内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源。内存管理的实现方法有很多种，他们其实最终都是要...
STM32 内存管理.zip
12-06
STM32F103ZET6项目，稍微修改可以在STM32F103C8T6芯片中运行
mymalloc
03-16
Creating my own MyMalloc & MyFree functions:- “ mylinkedlist.c”文件包含链表的实现。 在这里，mylinkedlist文件包含在节点中插入元素，在节点中删除第一个元素并在节点中显示元素。 “ mymalloc.h”文件包含malloc和free函数的实现，这些函数包含在mylinkedlist文件中，这有助于内存分配和删除。 这里的mymalloc文件包含MyMalloc和MyFree函数。 Mymalloc函数的功能与C语言中的malloc函数相同，而在MyFree函数中，链表中的第一个元素被删除然后打印。 运行代码的命令：-gcc malloc.h gcc myimplementation.c -o myexe ./myexe
实验38 内存管理实验.rar_STM32 内存管理_STM32内存管理
09-21
在STM32的开发过程中，内存管理是一项至关重要的任务，它涉及到程序的存储、分配和释放，确保程序运行的效率和稳定性。在这个实验中，我们将深入探讨STM32的内存管理机制。 首先，STM32的内存分为两种主要类型：...
神舟3号STM32内存管理实验
03-16
本实验将深入探讨STM32的内存管理，这在进行高效且优化的代码编写中至关重要。 内存管理是嵌入式系统编程中的关键部分，尤其是在资源有限的微控制器环境中。STM32的内存分为Flash和RAM两部分，其中Flash用于存储...
STM32内存管理笔记
qq_52139746的博客
08-16 358
SRAMIN芯片内部存储池，SRAMEX芯片外部存储池内存管理（STM32的内存管理相关（内存架构，内存管理，map文件分析） - 知乎）Mymalloc(SRAMIN,4096)//申请4个字节内存(FIL*)mymalloc(SRAMIN,sizeof(FIL))//也可以直接按照FIL内存大小，分配内存//申请了内存就必须释放掉内存C程序使用malloc()在堆上分配内存，free()释放内存。memset 一般使用“0”初始化内存单元，而且通常是给数组或结构体进行初始化。
malloc 的工作原理
hjjdebug的专栏
04-09 4147
该函数演示了malloc 的工作原理： 1. malloc 在一块平坦的内存区管理内存（可以称之为堆) 2. malloc 由管理块和数据块构成 3. malloc 首先以链表的方式搜索已管理的内存，没有找到，再从大池里扩展一块进入valid_address 管理区
STM32的内存管理相关（内存架构，内存管理，map文件分析）
qq_27568125的博客
10-16 705
RAM有两大类，一种称为静态RAM(Static RAM/SRAM)，SRAM速度非常快，是目前读写最快的存储设备了，但是它也非常昂贵，所以只在要求很苛刻的地方使用，譬如CPU的一级缓冲，二级缓冲。存储器映射 是用 地址来表示 对象，因为Cortex-M3是32位的单片机，因此其PC指针可以指向2^32=4G的地址空间，也就是图中的 0x00000000到0xFFFFFFFF的区间，也就是将程序存储器、数据存储器、寄存器和输入输出端口被组织在同一个4GB的线性地址空间内，数据字节以小端格式存放在存储器中。
一文搞懂linux的库打桩
Leon的博客
03-19 2246
Linux下的链接器支持一个强大的库打桩（library interpositioning），允许你拦截对系统标准库中某个目标函数的调用，取而代之执行自己的包装函数。它可以给我们带来两个好处，一是通过添加某些语句，可以追踪自己的程序对某些库函数的调用情况；二是可以在你自己的程序中，对某些库函数偷天换日，替换成一个完全不同的实现。 打桩可以发生在编译，链接和运行的任意一个阶段，相应的代码编写和编译也...
LINUX:懒汉单例模式线程池
最新发布
W2155的博客
07-16 450
创建一个线程，就是要这个线程去完成某种任务的。池化技术就是，提前创建一批线程，有任务这一批线程就会执行。而不是有任务的时候在去创建线程。池化技术有着更高的效率，因为线程都是提前创建好的，直接执行任务。
stm32内存管理代码
09-07
当涉及到STM32的内存管理时，我们通常需要关注以下几个方面： 1. 堆栈管理：STM32的堆栈大小可以在链接脚本(.ld文件)中配置。默认情况下，堆栈大小为512字节。可以通过修改.ld文件中的堆栈大小来适应应用程序的需求。 2. 动态内存分配：STM32通常使用C库提供的malloc()和free()函数进行动态内存分配和释放。这些函数依赖于堆的实现，需要在链接脚本中定义堆的起始地址和大小。你可以在你的项目中使用相应的库函数或者自行实现动态内存管理。 3. 静态内存分配：静态内存分配是指在编译时为变量和数据结构分配固定的内存空间。在STM32中，可以使用关键字static来定义静态变量和数组。静态内存分配不需要运行时的内存管理操作，但是需要精确地估计所需的内存大小。 4. 内存访问权限：STM32中的内存访问权限由特定寄存器进行配置。例如，对于外设寄存器的访问，通常需要通过RCC_APB2ENR或者RCC_APB1ENR寄存器使能相应外设的时钟。这样才能正确地访问外设提供的寄存器和内存区域。 需要注意的是，对于特定的STM32型号和开发环境，具体的内存管理实现可能会有所不同。因此，你需要参考相关的芯片手册和开发环境的文档来了解具体的内存管理代码实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值