STM32CubeIDE 使用正点原子的内存管理MALLOC-可直接替换使用

最新推荐文章于 2024-09-30 11:07:20 发布
最新推荐文章于 2024-09-30 11:07:20 发布
阅读量416 收藏 7
点赞数 8
分类专栏： STM32F767功能实现 文章标签： stm32 嵌入式硬件 单片机 STM32CubeIDE 内存管理 MALLOC 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50808730/article/details/137039176
版权

STM32CubeIDE 使用正点原子的内存管理MALLOC

在正点原子开发板stm32F767igt6 平台。

一 keil原代码

1.1 malloc.h

#ifndef _MALLOC_H
#define _MALLOC_H
#include "sys.h"
//	 
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
//ALIENTEK STM32F7开发板
//内存管理 驱动代码	   
//正点原子@ALIENTEK
//技术论坛:www.openedv.com
//创建日期:2015/12/12
//版本：V1.0
//版权所有，盗版必究。
//Copyright(C) 广州市星翼电子科技有限公司 2014-2024
//All rights reserved									  
// 	 
#ifndef NULL
#define NULL 0
#endif

//定义三个内存池
#define SRAMIN	    0		//内部内存池
#define SRAMEX      1		//外部内存池(SDRAM)
#define SRAMDTCM    2		//DTCM内存池(此部分SRAM仅仅CPU可以访问!!!)

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

//mem1内存参数设定.mem1完全处于内部SRAM里面.
#define MEM1_BLOCK_SIZE			64  	  						//内存块大小为64字节
#define MEM1_MAX_SIZE			160*1024  						//最大管理内存 160K
#define MEM1_ALLOC_TABLE_SIZE	MEM1_MAX_SIZE/MEM1_BLOCK_SIZE 	//内存表大小

//mem2内存参数设定.mem2的内存池处于外部SDRAM里面
#define MEM2_BLOCK_SIZE			64  	  						//内存块大小为64字节
#define MEM2_MAX_SIZE			28912 *1024  					//最大管理内存28912K
#define MEM2_ALLOC_TABLE_SIZE	MEM2_MAX_SIZE/MEM2_BLOCK_SIZE 	//内存表大小
		 
//mem3内存参数设定.mem3处于CCM,用于管理DTCM(特别注意,这部分SRAM,仅CPU可以访问!!)
#define MEM3_BLOCK_SIZE			64  	  						//内存块大小为64字节
#define MEM3_MAX_SIZE			60 *1024  						//最大管理内存60K
#define MEM3_ALLOC_TABLE_SIZE	MEM3_MAX_SIZE/MEM3_BLOCK_SIZE 	//内存表大小


//内存管理控制器
struct _m_mallco_dev
{
	void (*init)(u8);					//初始化
	u16 (*perused)(u8);		  	    	//内存使用率
	u8 	*membase[SRAMBANK];				//内存池 管理SRAMBANK个区域的内存
	u32 *memmap[SRAMBANK]; 				//内存管理状态表
	u8  memrdy[SRAMBANK]; 				//内存管理是否就绪
};
extern struct _m_mallco_dev mallco_dev;	 //在mallco.c里面定义

void mymemset(void *s,u8 c,u32 count);	//设置内存
void mymemcpy(void *des,void *src,u32 n);//复制内存     
void my_mem_init(u8 memx);				//内存管理初始化函数(外/内部调用)
u32 my_mem_malloc(u8 memx,u32 size);	//内存分配(内部调用)
u8 my_mem_free(u8 memx,u32 offset);		//内存释放(内部调用)
u16 my_mem_perused(u8 memx) ;			//获得内存使用率(外/内部调用) 

//用户调用函数
void myfree(u8 memx,void *ptr);  			//内存释放(外部调用)
void *mymalloc(u8 memx,u32 size);			//内存分配(外部调用)
void *myrealloc(u8 memx,void *ptr,u32 size);//重新分配内存(外部调用)
#endif

1.2 malloc.C

#include "malloc.h"
//	 
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
//ALIENTEK STM32F7开发板
//内存管理 驱动代码	   
//正点原子@ALIENTEK
//技术论坛:www.openedv.com
//创建日期:2015/12/12
//版本：V1.0
//版权所有，盗版必究。
//Copyright(C) 广州市星翼电子科技有限公司 2014-2024
//All rights reserved									  
// 	 

//内存池(32字节对齐)
__align(32) u8 mem1base[MEM1_MAX_SIZE];													//内部SRAM内存池
__align(32) u8 mem2base[MEM2_MAX_SIZE] __attribute__((at(0XC01F4000)));					//外部SDRAM内存池,前面2M给LTDC用了(1280*800*2)
__align(32) u8 mem3base[MEM3_MAX_SIZE] __attribute__((at(0X20000000)));					//内部DTCM内存池
//内存管理表
u32 mem1mapbase[MEM1_ALLOC_TABLE_SIZE];													//内部SRAM内存池MAP
u32 mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__((at(0XC01F4000+MEM2_MAX_SIZE)));	//外部SRAM内存池MAP
u32 mem3mapbase[MEM3_ALLOC_TABLE_SIZE] __attribute__((at(0X20000000+MEM3_MAX_SIZE)));	//内部DTCM内存池MAP
//内存管理参数	   
const u32 memtblsize[SRAMBANK]={MEM1_ALLOC_TABLE_SIZE,MEM2_ALLOC_TABLE_SIZE,MEM3_ALLOC_TABLE_SIZE};	//内存表大小
const u32 memblksize[SRAMBANK]={MEM1_BLOCK_SIZE,MEM2_BLOCK_SIZE,MEM3_BLOCK_SIZE};					//内存分块大小
const u32 memsize[SRAMBANK]={MEM1_MAX_SIZE,MEM2_MAX_SIZE,MEM3_MAX_SIZE};							//内存总大小

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

//复制内存
//*des:目的地址
//*src:源地址
//n:需要复制的内存长度(字节为单位)
void mymemcpy(void *des,void *src,u32 n)  
{  
    u8 *xdes=des;
	u8 *xsrc=src; 
    while(n--)*xdes++=*xsrc++;  
}  
//设置内存
//*s:内存首地址
//c :要设置的值
//count:需要设置的内存大小(字节为单位)
void mymemset(void *s,u8 c,u32 count)  
{  
    u8 *xs = s;  
    while(count--)*xs++=c;  
}	
//内存管理初始化  
//memx:所属内存块
void my_mem_init(u8 memx)  
{  
    mymemset(mallco_dev.memmap[memx],0,memtblsize[memx]*4);	//内存状态表数据清零  
 	mallco_dev.memrdy[memx]=1;								//内存管理初始化OK  
}  
//获取内存使用率
//memx:所属内存块
//返回值:使用率(扩大了10倍,0~1000,代表0.0%~100.0%)
u16 my_mem_perused(u8 memx)  
{  
    u32 used=0;  
    u32 i;  
    for(i=0;i<memtblsize[memx];i++)  
    {  
        if(mallco_dev.memmap[memx][i])used++; 
    } 
    return (used*1000)/(memtblsize[memx]);  
}  
//内存分配(内部调用)
//memx:所属内存块
//size:要分配的内存大小(字节)
//返回值:0XFFFFFFFF,代表错误;其他,内存偏移地址 
u32 my_mem_malloc(u8 memx,u32 size)  
{  
    signed long offset=0;  
    u32 nmemb;	//需要的内存块数  
	u32 cmemb=0;//连续空内存块数
    u32 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,释放失败;  
u8 my_mem_free(u8 memx,u32 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(u8 memx,void *ptr)  
{  
	u32 offset;   
	if(ptr==NULL)return;//地址为0.  
 	offset=(u32)ptr-(u32)mallco_dev.membase[memx];     
    my_mem_free(memx,offset);	//释放内存      
}  
//分配内存(外部调用)
//memx:所属内存块
//size:内存大小(字节)
//返回值:分配到的内存首地址.
void *mymalloc(u8 memx,u32 size)  
{  
    u32 offset;   
	offset=my_mem_malloc(memx,size);  	   	 	   
    if(offset==0XFFFFFFFF)return NULL;  
    else return (void*)((u32)mallco_dev.membase[memx]+offset);  
}  
//重新分配内存(外部调用)
//memx:所属内存块
//*ptr:旧内存首地址
//size:要分配的内存大小(字节)
//返回值:新分配到的内存首地址.
void *myrealloc(u8 memx,void *ptr,u32 size)  
{  
    u32 offset;    
    offset=my_mem_malloc(memx,size);   	
    if(offset==0XFFFFFFFF)return NULL;     
    else  
    {  									   
	    mymemcpy((void*)((u32)mallco_dev.membase[memx]+offset),ptr,size);	//拷贝旧内存内容到新内存   
        myfree(memx,ptr);  											  		//释放旧内存
        return (void*)((u32)mallco_dev.membase[memx]+offset);  				//返回新内存首地址
    }  
}

二 STM32CubeIDE 修改好的代码

2.1 malloc.h

#ifndef _MYMALLOC_H
#define _MYMALLOC_H
#include "stm32f7xx_hal.h"
//	 
//������ֻ��ѧϰʹ�ã�δ��������ɣ��������������κ���;
//ALIENTEK STM32F7������
//�ڴ���� ��������	   
//����ԭ��@ALIENTEK
//������̳:www.openedv.com
//��������:2015/12/12
//�汾��V1.0
//��Ȩ���У�����ؾ���
//Copyright(C) ������������ӿƼ����޹�˾ 2014-2024
//All rights reserved									  
// 	 
#ifndef NULL
#define NULL 0
#endif

//���������ڴ��
#define SRAMIN	    0		//�ڲ��ڴ��
#define SRAMEX      1		//�ⲿ�ڴ��(SDRAM)
#define SRAMDTCM    2		//DTCM�ڴ��(�˲���SRAM����CPU���Է���!!!)

#define SRAMBANK 	3	    //����֧�ֵ�SRAM����.	

//mem1�ڴ�����趨.mem1��ȫ�����ڲ�SRAM����.
#define MEM1_BLOCK_SIZE			64  	  						//�ڴ���СΪ64�ֽ�
#define MEM1_MAX_SIZE			160*1024  						//�������ڴ� 160K
#define MEM1_ALLOC_TABLE_SIZE	MEM1_MAX_SIZE/MEM1_BLOCK_SIZE 	//�ڴ���С

//mem2�ڴ�����趨.mem2���ڴ�ش����ⲿSDRAM����
#define MEM2_BLOCK_SIZE			1 	  						//�ڴ���СΪ64�ֽ�
#define MEM2_MAX_SIZE			1*1024  					//�������ڴ�28912K
#define MEM2_ALLOC_TABLE_SIZE	MEM2_MAX_SIZE/MEM2_BLOCK_SIZE 	//�ڴ���С
		 
//mem3�ڴ�����趨.mem3����CCM,���ڹ���DTCM(�ر�ע��,�ⲿ��SRAM,��CPU���Է���!!)
#define MEM3_BLOCK_SIZE			64  	  						//�ڴ���СΪ64�ֽ�
#define MEM3_MAX_SIZE			60 *1024  						//�������ڴ�60K
#define MEM3_ALLOC_TABLE_SIZE	MEM3_MAX_SIZE/MEM3_BLOCK_SIZE 	//�ڴ���С


//�ڴ���������
struct _m_mallco_dev
{
	void (*init)(u8);					//��ʼ��
	u16 (*perused)(u8);		  	    	//�ڴ�ʹ����
	u8 	*membase[SRAMBANK];				//�ڴ�� ����SRAMBANK��������ڴ�
	u32 *memmap[SRAMBANK]; 				//�ڴ����״̬��
	u8  memrdy[SRAMBANK]; 				//�ڴ�����Ƿ����
};
extern struct _m_mallco_dev mallco_dev;	 //��mallco.c���涨��

void mymemset(void *s,u8 c,u32 count);	//�����ڴ�
void my_mem_init(u8 memx);				//�ڴ�����ʼ������(��/�ڲ�����)
u32 my_mem_malloc(u8 memx,u32 size);	//�ڴ����(�ڲ�����)
u8 my_mem_free(u8 memx,u32 offset);		//�ڴ��ͷ�(�ڲ�����)
u16 my_mem_perused(u8 memx) ;			//����ڴ�ʹ����(��/�ڲ�����) 

//�û����ú���
void myfree(u8 memx,void *ptr);  			//�ڴ��ͷ�(�ⲿ����)
void *mymalloc(u8 memx,u32 size);			//�ڴ����(�ⲿ����)
void *myrealloc(u8 memx,void *ptr,u32 size);//���·����ڴ�(�ⲿ����)
#endif

2.2 malloc.C

#include "malloc.h"
//	 
//������ֻ��ѧϰʹ�ã�δ��������ɣ��������������κ���;
//ALIENTEK STM32F7������
//�ڴ���� ��������	   
//����ԭ��@ALIENTEK
//������̳:www.openedv.com
//��������:2015/12/12
//�汾��V1.0
//��Ȩ���У�����ؾ���
//Copyright(C) ������������ӿƼ����޹�˾ 2014-2024
//All rights reserved									  
// 	 

//�ڴ��(32�ֽڶ���)
__attribute__ ((aligned (32)))   u8 mem1base[MEM1_MAX_SIZE];
__attribute__ ((aligned (32)))   u8 mem2base[MEM2_MAX_SIZE] __attribute__((at(0XC01F4000)));					//�ⲿSDRAM�ڴ��,ǰ��2M��LTDC����(1280*800*2)
__attribute__ ((aligned (32)))   u8 mem3base[MEM3_MAX_SIZE] __attribute__((at(0X20000000)));


//�ڴ�����
__attribute__ ((aligned (32))) u32 mem1mapbase[MEM1_ALLOC_TABLE_SIZE];													//�ڲ�SRAM�ڴ��MAP
//u32 mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__((section (0XC01F4000+MEM2_MAX_SIZE)));	//�ⲿSRAM�ڴ��MAP
//u32 mem3mapbase[MEM3_ALLOC_TABLE_SIZE] __attribute__((section (0X20000000+MEM3_MAX_SIZE)));	//�ڲ�DTCM�ڴ��MAP
__attribute__ ((aligned (32))) u32 mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__ ((at(0XC01F4000+MEM2_MAX_SIZE)));	//�ⲿSRAM�ڴ��MAP
__attribute__ ((aligned (32))) u32 mem3mapbase[MEM3_ALLOC_TABLE_SIZE] __attribute__ ((at(0X20000000+MEM3_MAX_SIZE)));

//�ڴ�������	   
const u32 memtblsize[SRAMBANK]={MEM1_ALLOC_TABLE_SIZE,MEM2_ALLOC_TABLE_SIZE,MEM3_ALLOC_TABLE_SIZE};	//�ڴ���С
const u32 memblksize[SRAMBANK]={MEM1_BLOCK_SIZE,MEM2_BLOCK_SIZE,MEM3_BLOCK_SIZE};					//�ڴ�ֿ��С
const u32 memsize[SRAMBANK]={MEM1_MAX_SIZE,MEM2_MAX_SIZE,MEM3_MAX_SIZE};							//�ڴ��ܴ�С

//�ڴ���������
struct _m_mallco_dev mallco_dev=
{
	my_mem_init,						//�ڴ��ʼ��
	my_mem_perused,						//�ڴ�ʹ����
	mem1base,mem2base,mem3base,			//�ڴ��
	mem1mapbase,mem2mapbase,mem3mapbase,//�ڴ����״̬��
	0,0,0,  		 					//�ڴ����δ����
};

//�����ڴ�
//*des:Ŀ�ĵ�ַ
//*src:Դ��ַ
//n:��Ҫ���Ƶ��ڴ泤��(�ֽ�Ϊ��λ)
void mymemcpy(void *des,void *src,u32 n)  
{  
    u8 *xdes=des;
	u8 *xsrc=src; 
    while(n--)*xdes++=*xsrc++;  
}  
//�����ڴ�
//*s:�ڴ��׵�ַ
//c :Ҫ���õ�ֵ
//count:��Ҫ���õ��ڴ��С(�ֽ�Ϊ��λ)
void mymemset(void *s,u8 c,u32 count)  
{  
    u8 *xs = s;  
    while(count--)*xs++=c;  
}	
//�ڴ�����ʼ��  
//memx:�����ڴ��
void my_mem_init(u8 memx)  
{  
    mymemset(mallco_dev.memmap[memx],0,memtblsize[memx]*4);	//�ڴ�״̬����������  
 	mallco_dev.memrdy[memx]=1;								//�ڴ�����ʼ��OK  
}  
//��ȡ�ڴ�ʹ����
//memx:�����ڴ��
//����ֵ:ʹ����(������10��,0~1000,����0.0%~100.0%)
u16 my_mem_perused(u8 memx)  
{  
    u32 used=0;  
    u32 i;  
    for(i=0;i<memtblsize[memx];i++)  
    {  
        if(mallco_dev.memmap[memx][i])used++; 
    } 
    return (used*1000)/(memtblsize[memx]);  
}  
//�ڴ����(�ڲ�����)
//memx:�����ڴ��
//size:Ҫ������ڴ��С(�ֽ�)
//����ֵ:0XFFFFFFFF,�������;����,�ڴ�ƫ�Ƶ�ַ 
u32 my_mem_malloc(u8 memx,u32 size)  
{  
    signed long offset=0;  
    u32 nmemb;	//��Ҫ���ڴ����  
	u32 cmemb=0;//�������ڴ����
    u32 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,�ͷ�ʧ��;  
u8 my_mem_free(u8 memx,u32 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(u8 memx,void *ptr)  
{  
	u32 offset;   
	if(ptr==NULL)return;//��ַΪ0.  
 	offset=(u32)ptr-(u32)mallco_dev.membase[memx];     
    my_mem_free(memx,offset);	//�ͷ��ڴ�      
}  
//�����ڴ�(�ⲿ����)
//memx:�����ڴ��
//size:�ڴ��С(�ֽ�)
//����ֵ:���䵽���ڴ��׵�ַ.
void *mymalloc(u8 memx,u32 size)  
{  
    u32 offset;   
	offset=my_mem_malloc(memx,size);  	   	 	   
    if(offset==0XFFFFFFFF)return NULL;  
    else return (void*)((u32)mallco_dev.membase[memx]+offset);  
}  
//���·����ڴ�(�ⲿ����)
//memx:�����ڴ��
//*ptr:���ڴ��׵�ַ
//size:Ҫ������ڴ��С(�ֽ�)
//����ֵ:�·��䵽���ڴ��׵�ַ.
void *myrealloc(u8 memx,void *ptr,u32 size)  
{  
    u32 offset;    
    offset=my_mem_malloc(memx,size);   	
    if(offset==0XFFFFFFFF)return NULL;     
    else  
    {  									   
	    mymemcpy((void*)((u32)mallco_dev.membase[memx]+offset),ptr,size);	//�������ڴ����ݵ����ڴ�   
        myfree(memx,ptr);  											  		//�ͷž��ڴ�
        return (void*)((u32)mallco_dev.membase[memx]+offset);  				//�������ڴ��׵�ַ
    }  
}
常驻客栈
关注
专栏目录
正点原子的内存管理_STM32-内存管理
weixin_29146477的博客
12-24 1671
#ifndef __MALLOC_H#define __MALLOC_H#include"stm32f10x.h"////////////////////////////////////////////////////////////////////////////////////本程序只供学习使用，未经作者许可，不得用于其它任何用途//ALIENTEK战舰STM32开发板V3//内存管理 驱动代...
正点原子的内存管理_正点原子【STM32-F407探索者】第四十二章 内存管理实验
weixin_42118770的博客
12-24 1765
1)资料下载:点击资料即可下载2)对正点原子Linux感兴趣的同学可以加群讨论：9354467413)关注正点原子公众号，获取最新资料更新上一章，我们学会了使用 STM32F4 驱动外部 SRAM，以扩展 STM32F4 的内存，加上 STM32F4 本身自带的 192K 字节内存，我们可供使用的内存还是比较多的。如果我们所用的内 存都像上一节的 testsram 那样，定义一个数组来使用，显然不...
STM32F103单片机HAL库例程-内存malloc管理实验.rar
03-20
1、嵌入式物联网单片机项目开发实战。例程经过精心编写，简单好用。 2、代码使用KEIL HAL库开发，当前在STM32F103运行，如果是STM32F103其他型号芯片，依然适用，请自行更改KEIL芯片型号以及FLASH容量即可。 3、软件下载时，请注意keil选择项是jlink还是stlink。 4、技术v：349014857; 5、如果接入其他传感器，请查看发布的其他资料。 6、单片机与模块的接线，在代码当中均有定义，请自行对照。 7、若硬件差异，请根据自身情况适当调整代码，程序仅供参考。 8、代码有注释说明，请耐心阅读。
STM32cubeIDE使用CCMRAM
chejianhp的博客
12-24 2572
STM32cubeIDE使用CCMRAM 找到如下文件并打开 在最末尾插入如下代码 .ccmram : { . = ALIGN(4); __MALLOC_SYMBOLS = .; *(.ccmram) *(.ccmramm*) . = ALIGN(4); __EMALLOC_SYMBOLS = .; } ...
STM32CubeIDE教程-查看FLASH与RAM细节
热门推荐
wallace89的博客
05-12 1万+
文章目录一、前言二、STM32CubeIDE - Build Analyzer2.1、打开Build Analyzer2.2、查看Build Analyzer2.3、Build Analyzer的搜索功能 一、前言 实际工作中，经常会遇到编写一些flash的程序。就会想起STM32的内存架构，比如芯片的FLASH大小，RAM大小，STM32的FLASH到底存着什么，STM32的RAM到底存着什么？ 关于数据类型，变量和堆栈的基础知识，可以学习《安富莱_STM32-V7开发板_用户手册，含BSP驱动包设计（V
【正点原子MP157连载】第八章 STM32CubeIDE工程模板分析-摘自【正点原子】STM32MP1 M4裸机CubeIDE开发指南
weixin_55796564的博客
02-24 1811
第八章 STM32CubeIDE工程模板分析
[STM32CubeIDE]创建HAL库项目
不忘理解过程的艰辛
07-17 1662
利用STM32CubeIDE创建HAL库项目相对容易 *随着CubeIDE的版本更新使用ST-Link、J-Link以外的调试器越来越复杂 *系统时钟问题可以用MCO功能排查，不起振不一定是晶振的原因。
STM32CubeIDE的FreeRTOS参数配置说明
VIFIN的博客
07-10 2440
FreeRtos参数配置说明
STM32CUBEIDE——malloc
Warm's Blogs
11-04 2364
需要将STM32CUBEIDE reduced C 改为 Standard C
STM32 使用malloc函数内存分配失败的问题
qq_58619066的博客
08-03 1341
第一次初始化结构体指针时，括号内的长度只给了结构体的长度，导致后面写入的参数出现错误。初始堆栈大小分别为，0x200；修改后为0x400，和0x400；出现内存分配失败的情况，即指针的首地址为空，导致后续数据写入出现问题。
stm32f103c8+mem-malloc代码
04-13
单片机内存管理模块mem_malloc，这个mem_malloc的使用不会产生内存碎片，可以高效利用单片机ram空间。 使用单片机内存时容易导致内存碎片，且一般单片机的内存都比较小，而且没有MMU，malloc 与free的使用容易造成...
STM32CUBE_LCD_SRAM_MALLOCC_SDIO_FATFS_SPI_FLASH.rar
02-19
基于STM32CUBE移植正点原子的例程，花了我2个礼拜集成在一个工程里。包括用CUBE驱动LCD屏，用SPI写FLASH，MALLOC文件的移植，SDIO驱动TF卡，FATFS管理SD卡或外部SRAM。移植过程及其艰辛，踩过无数坑，终于调试成功。...
STM32CubeMX学习笔记（35）——FreeRTOS实时操作系统使用（内存管理）
Leung的博客
01-06 4500
一、FreeRTOS简介 FreeRTOS 是一个可裁剪、可剥夺型的多任务内核，而且没有任务数限制。FreeRTOS 提供了实时操作系统所需的所有功能，包括资源管理、同步、任务通信等。 FreeRTOS 是用 C 和汇编来写的，其中绝大部分都是用 C 语言编写的，只有极少数的与处理器密切相关的部分代码才是用汇编写的，FreeRTOS 结构简洁，可读性很强！最主要的是非常适合初次接触嵌入式实时操作系统学生、嵌入式系统开发人员和爱好者学习。 最新版本 V9.0.0（2016年），尽管现在 FreeRTOS 的
STM32
2301_80339607的博客
09-27 1075
四个主动单元：DCode(数据总线)、DMA1、DMA2、系统总线四个被动单元：SRAM、Flash、FSMC（存储控制器）、AHB到APB的桥。
STM32移植RT-Thread实现DAC功能
weixin_44176501的博客
09-29 769
我的RT-Thread中，没有DAC的宏定义，因此我就在末尾直接添加了一个：#define BSP_USING_DAC1RT-Thread中存在着部分外设没有驱动程序需要我们自己去移植，或者使用HAL库的编程思想去实现。
【从零开始实现stm32无刷电机FOC】【实践】【7.1/7 硬件设计】
欢迎你来
09-29 1286
为了承载和验证本文的FOC代码工程，本节设计了一个简易的三相无刷电机，主控采用非常常用的stm32f103c8t6单片机，电机编码器采用MT6701，电机采用22xx系列云台电机，驱动电路采用集成驱动芯片DRV8313，电流传感器采用INA199A1在线采样。该使用无工具快拆装设计，到手即可直接快速手拧安装拆卸。
STM32的DMA技术介绍
u012698191的博客
09-30 1114
DMA（Direct Memory Access，直接内存访问） 是一种允许外设直接与系统内存进行数据传输，而无需经过CPU的技术。在STM32微控制器中，DMA技术极大地提高了数据传输效率，降低了CPU的负担，从而提升系统整体性能。
STM32 OLED
最新发布
ganhui13000的博客
09-30 769
STM32 OLED的移植和使用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

常驻客栈

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值