STM32F4中的内存管理的实现

已于 2022-03-15 11:31:00 修改
阅读量1k 收藏 7
点赞数 2
分类专栏： 嵌入式基础-STM32 文章标签： 单片机 stm32 c语言 嵌入式
于 2022-02-28 09:45:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhj1021/article/details/123126056
版权

更多交流欢迎关注作者抖音号：81849645041

目的

        了解内部内存，外部内存，实现对内存的动态管理。

原理

内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源。内存管理的实现方法有很多种，他们其实最终都是要实现 2 个函数：malloc 和 free；malloc 函数用于内存申请，free 函数用于内存释放。

一种比较简单的办法来实现：分块式内存管理。

        从上图可以看出，分块式内存管理由内存池和内存管理表两部分组成。内存池被等分为 n块，对应的内存管理表，大小也为 n，内存管理表的每一个项对应内存池的一块内存。内存管理表的项值代表的意义为：当该项值为 0 的时候，代表对应的内存块未被占用，当该项值非零的时候，代表该项对应的内存块已经被占用，其数值则代表被连续占用的内存块数。比如某项值为 10，那么说明包括本项对应的内存块在内，总共分配了 10 个内存块给外部的某个指针。

        内寸分配方向如图所示，是从顶底的分配方向。即首先从最末端开始找空内存。当内存管理刚初始化的时候，内存表全部清零，表示没有任何内存块被占用。

        分配原理

        当指针 p 调用 malloc 申请内存的时候，先判断 p 要分配的内存块数（m），然后从第 n 项开始，向下查找，直到找到 m 块连续的空内存块（即对应内存管理表项为 0），然后将这 m 个内存管理表项的值都设置为 m（标记被占用），最后，把最后的这个空内存块的地址返回指针 p，完成一次分配。注意，如果当内存不够的时候（找到最后也没找到连续的 m 块空闲内存），则返回 NULL 给 p，表示分配失败。

        释放原理

        当 p 申请的内存用完，需要释放的时候，调用 free 函数实现。free 函数先判断 p 指向的内存地址所对应的内存块，然后找到对应的内存管理表项目，得到 p 所占用的内存块数目 m（内存管理表项目的值就是所分配内存块的数目），将这 m 个内存管理表项目的值都清零，标记释放，完成一次内存释放。

准备

        MDK5 开发环境。

        STM32F4xx HAL库。

        STM32F407 开发板。

        STM32F4xx 参考手册。

        STM32F4xx 数据手册。

        STM32F407 开发板电路原理图。

步骤

  • 创建头文件bsp_mallco.h并定义引脚和相关读写函数。
#ifndef __BSP_SRAM_H
#ifndef __BSP_MALLOC_H
#define __BSP_MALLOC_H

#include "stm32f4xx.h"

#ifndef NULL
#define NULL 0
#endif

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

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

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

//mem2内存参数设定.mem2的内存池处于外部SRAM里面
#define MEM2_BLOCK_SIZE			32  	  						//内存块大小为32字节
#define MEM2_MAX_SIZE			960 *1024  						//最大管理内存960K
#define MEM2_ALLOC_TABLE_SIZE	MEM2_MAX_SIZE/MEM2_BLOCK_SIZE 	//内存表大小
		 
//mem3内存参数设定.mem3处于CCM,用于管理CCM(特别注意,这部分SRAM,仅CPU可以访问!!)
#define MEM3_BLOCK_SIZE			32  	  						//内存块大小为32字节
#define MEM3_MAX_SIZE			60 *1024  						//最大管理内存60K
#define MEM3_ALLOC_TABLE_SIZE	MEM3_MAX_SIZE/MEM3_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_mallco.c并实现读写操作函数
#include "bsp_mallco.h"

/***内存池(32字节对齐)***/
// 内部SRAM内存池
__align(32) uint8_t mem1base[MEM1_MAX_SIZE];
// 外部SRAM内存池
__align(32) uint8_t mem2base[MEM2_MAX_SIZE] __attribute__((at(0x68000000)));
// 内部CCM内存池
__align(32) uint8_t mem3base[MEM3_MAX_SIZE] __attribute__((at(0x10000000)));


/***内存管理表***/
// 内部SRAM内存池MAP
uint16_t mem1mapbase[MEM1_ALLOC_TABLE_SIZE];		
// 外部SRAM内存池MAP
uint16_t mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__((at(0X68000000+MEM2_MAX_SIZE)));	
// 内部CCM内存池MAP
uint16_t mem3mapbase[MEM3_ALLOC_TABLE_SIZE] __attribute__((at(0X10000000+MEM3_MAX_SIZE)));	


/***内存管理参数***/
// 内存表大小 总字节/分块大小(32字节)
const uint32_t memtblsize[SRAMBANK]={MEM1_ALLOC_TABLE_SIZE, MEM2_ALLOC_TABLE_SIZE, MEM3_ALLOC_TABLE_SIZE};	
// 内存分块大小 32字节
const uint32_t memblksize[SRAMBANK]={MEM1_BLOCK_SIZE, MEM2_BLOCK_SIZE, MEM3_BLOCK_SIZE};					
// 内存总大小 总字节
const uint32_t 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} //内存管理未就绪
};

/**
*  函数名:mymemset
*  描述:写内存
*  输入:*s:内存首地址 
*				c :要设置的值 
*				count:需要设置的内存大小(字节为单位)
*  输出:void
*/
void mymemset(void *s, uint8_t c, uint32_t count)	//写内存
{
	uint8_t *xs = s;
	while(count--)
	{ 
		*xs++ = c;
	}
}

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

/**
*  函数名:my_mem_init
*  描述:内存管理初始化函数(外/内部调用)
*  输入:memx 所属内存块
*  输出:void
*/
void my_mem_init(uint8_t memx)
{
	// 内存状态表数据清零 
	mymemset(mallco_dev.memmap[memx], 0, memtblsize[memx]*2);
	// 内存池所有数据清零
	mymemset(mallco_dev.membase[memx], 0, memsize[memx]);
	// 内存管理初始化OK
	mallco_dev.memrdy[memx] = 1;
}

/**
*  函数名:my_mem_malloc
*  描述:内存分配(内部调用)
*  输入: 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; // 未找到符合分配条件的内存块
}

/**
*  函数名:my_mem_free
*  描述:内存释放(内部调用)
*  输入: memx:所属内存块 offset:内存地址偏移
*  输出: 0,释放成功;1,释放失败;
*/
uint8_t my_mem_free(uint8_t memx, uint32_t offset)
{
	uint32_t i;
	if(!mallco_dev.memrdy[memx]) // 未初始化,先执行初始化
	{ 
		mallco_dev.init(memx);
		return 1;
	}
	if(offset < memsize[memx]) // 偏移在内存池内. 
	{ 
		uint32_t index = offset/memblksize[memx]; // 偏移所在内存块号码
		uint32_t nmemb = mallco_dev.memmap[memx][index]; // 内存块数量
		for(i=0;i<nmemb;i++) // 内存块清零
	  { 
			mallco_dev.memmap[memx][index+i]=0;
		}
		return 0;
	}
	else{
		return 2; //偏移超区了
	}
}

/**
*  函数名:my_mem_perused
*  描述:获得内存使用率(外/内部调用)
*  输入:memx:所属内存块
*  输出:使用率(0~100)
*/
uint8_t my_mem_perused(uint8_t memx)
{
	uint32_t used = 0,i;
	for(i=0;i<memtblsize[memx];i++)
	{
		if(mallco_dev.memmap[memx][i])
		{
			used++;
		}
	}
	
	return (used*100)/memblksize[memx];
}


//用户调用函数
/**
*  函数名:myfree
*  描述:内存释放(外部调用)
*  输入:memx:所属内存块
*  输出:ptr:内存首地址
*/
void myfree(uint8_t memx, void *ptr)
{
	uint32_t offset;
	if(ptr == NULL)
	{
		return;
	}
	offset = (uint32_t)ptr - (uint32_t)mallco_dev.membase[memx];
	my_mem_free(memx, offset);
}

/**
*  函数名:mymalloc
*  描述:内存分配(外部调用)
*  输入: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);
	}
}

/**
*  函数名:myrealloc
*  描述:重新分配内存(外部调用)
*  输入: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);
	}
}
  • main.c中切换不同的内存，读写指定地址数据。
#include "bsp_clock.h"
#include "bsp_uart.h"
#include "bsp_key.h"
#include "bsp_sram.h" 
#include "bsp_led.h"
#include "bsp_mallco.h"
#include <string.h>

int main(void)
{
	uint8_t i=0;	   
	uint8_t *p=0;
	uint8_t sramx=0;					//默认为内部sram
	uint8_t tx[] = "SRAMEX Malloc Test";
	uint32_t n = sizeof(tx);
	uint8_t rx[n];
	
	CLOCLK_Init(); // 初始化系统时钟
	UART_Init(); // 串口初始化
	KEY_Init(); // 按键初始化
	LED_Init(); // LED初始化
	SRAM_Init(); // SRAM初始化
	
	my_mem_init(SRAMIN); //初始化内部内存池
	my_mem_init(SRAMEX); //初始化外部内存池
	my_mem_init(SRAMCCM);//初始化CCM内存池
	
	while(1)
	{
		uint8_t key = KEY_Scan(0);
		 if(key == 1) // KEY0按下
		 { 
			 p = mymalloc(sramx,2048); // 申请2K字节
			  
			 if(p!=NULL && sramx == 0) // 内部内存池
			 { 
				strcpy((char*)p,"SRAMIN Malloc Test"); // 向内部内存池写入一些内容
				HAL_Delay(100);
			  printf("%s \n",p); 
			 }
			 else if(p!=NULL && sramx == 2) // CCM内存池
			 { 
				strcpy((char*)p,"SRAMCCM Malloc Test"); // 向CCM内存池写入一些内容
				HAL_Delay(100);
			  printf("%s \n",p);  
			 }
			 else if(p!=NULL && sramx == 1) // 外部内存池
			 { 
				SRAM_WriteBuff(p,tx,n); // 向CCM内存池写入一些内容
				HAL_Delay(100);
				SRAM_ReadnBuff(p,rx,n);
				printf("%s \n",rx);
			 }
			 
			 myfree(sramx,p);
			  p=0;
			 i++;
		 }
		 
		 if(key == 2)
		 { // KEY1按下 切换SRAM
			sramx++;
			 if(sramx>2)
			 {
				 sramx=0;
			 }
			 
			 if(sramx == 0) printf("SRAMIN \n");
			 if(sramx == 1) printf("SRAMEX \n");
			 if(sramx == 2) printf("SRAMCCM \n"); 	
		 }
		 
		 HAL_Delay(50);
	}
}

现象

        把编译好的程序下载到开发板。Key1切换内存，key0在对应内存中写入数据后在读出数据打印出来。

奚海蛟
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
STM32F4xx中文参考手册
04-21
STM32F4xx家族包括STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx和STM32F43xxx等不同型号，它们在内存大小、封装和外设配置上有所差异，以满足不同层次的需求。 STM32F4xx微控制器的主要特点包括： 1. 集成了高...
STM32F4——内存管理
任长江
10-18 6398
一、简介：     对于内存的管理主要是用来管理MCU在运行过程中内存资源的分配和使用问题，主要解决的问题是如何高效和快速的分配，并在适当时候回收内存资源，内存管理的方法也有很多种，但是最终都是在解决两个函数：malloc（内存申请）和free（内存释放）。     二、分块式内存管理原理     存储方式：在这里介绍有关分块式内存管理的原理，对于分块式内存管理由内存池和内存管理表两部分组成
STM32——内存管理实验
weixin_62584795的博客
10-09 1660
STM32——内存管理实验
malloc.c正点原子编写内存管理的学习笔记
liliang87129的博客
07-06 2106
malloc.c正点原子编写内存管理的学习笔记
STM32CubeMX实战教程（九）——外部SRAM+内存管理
weixin_43892323的博客
08-19 7757
内存管理作为STM32及其他单片机非常重要的知识，可以说是单片机学习中必须要学到的，它不是像其他知识一样基于外设展开，而是基于自身内部的内存或是外部内存出发的；是学习较高级复杂的外设或功能如：USB，emWin，以及操作系统的基础，因为这是当单片机功能越来越复杂时绕不开的问题。
为什么要进行内存管理
最新发布
weixin_54046648的博客
08-24 222
在单道系统阶段，一个系统在一个时间段只执行一个程序，内存的分配及其简单，即仅分配给当前到运行的进程。引入多道程序后，进程之间共享的不仅仅是处理机，还有主处理器。然而，共享主存会形成一些特殊的挑战、若不对内存进行管理，则容易导致内存数据的混乱，以至于影响进程的并发执行。因此，为了更好地支持多道程序并发执行。
STM32F4_内存管理(Malloc、Free)
light_2025的博客
08-02 2867
当指针p调用malloc函数动态申请内存的时候，先去判断指针p要分配的内存块数m，然后从末端开始查找，直到找到m块连续的空内存块，然后把这m块空的内存块的内存管理项设置为m，表示对应块的内存被占用，最后将这m块对应的内存块地址返回给指针p，完成一次分配。KEY2用于释放内存。我们在使用一块内存的时候，通常都不会恰到好处的使用完定义的内存，可能我们定义的内存不够我们使用，也可能我们定义的内存会多，这样会造成内存浪费；内存池被等分为n块，对应的内存管理表大小也为n，内存管理表的每一项对应内存池的一块内存。
STM32F4系列中文参考手册
08-06
1. **概述**：这部分会介绍STM32F4系列的基本特性，如处理器内核、工作频率、内存大小、外设接口等。它还可能涉及STM32F4家族的不同型号及其差异，帮助用户选择合适的型号。 2. **处理器架构**：手册会深入解析...
STM32F4xx固件库
06-26
13. **内存管理**：STM32F4固件库中的内存管理函数，如DMA（直接存储器访问）和内存分配/释放，能够高效地处理数据传输和内存分配问题。 14. **错误处理和日志记录**：固件库包含错误处理机制，如HAL_StatusTypeDef...
STM32F4中文用户手册.rar
06-15
手册首先会介绍STM32F4系列的概述，包括处理器核心、存储器配置、时钟系统、电源管理等基本信息。Cortex-M4内核支持浮点运算单元（FPU），能够处理复杂的数学运算，提升了嵌入式系统的计算能力。手册中会解释这些...
STM32F4XX系列KEIL安装包
09-13
总的来说，STM32F4XX系列KEIL安装包为STM32F4系列微控制器的开发提供了便利，结合Keil uVision IDE和STM32F4xx_DFP，使得开发者可以高效、准确地实现对STM32F4芯片的软件开发和硬件功能的充分利用。
STM32F4_外部SRAM
light_2025的博客
08-02 2275
因为数据宽度是16位的，所以一行可以存放2个字节，每次写入一个字节，那么就需要分别写入这16位的高8位和低8位，那么就需要借助I/O0-I/O7、I/O8-I/O15数据线分别写入这16位的高字节和低字节）因为SRAM读取数据是异步通讯，也就是没有时钟总线，也可以说是双方没有规定好时间，那么我将要读取的地址发送以后，就需要给出一定的反应时间（因为没有时钟，不是同步通信），也就是图中程序区域的。对于一般的应用来说，192K字节已经够用了，但是对于那些对内存要求比较高的，192K字节是远远不够用的；
（44）STM32——内存管理实验
weixin_66578482的博客
10-05 1651
本节我们要来学习的是内存管理实验，主要用来解决的问题其实和C语言中数组遇到的问题类似，就是我们不知道到底需要多少内存，为了避免数组越界，我们只能定义一个很大的数组，但是在单片机这种“寸土寸金”的地方就很不现实了，所以我们必须引入C语言中的内存管理函数malloc和free了。
STM32F407内存管理
wg582981826的专栏
08-15 752
CCM共64KB，是直接挂在D-bus上的，除了CPU（即Cortex-M核）之外，谁都无法访问。此外，由于CCM不属于BusMatrix的一部分，所有也就不能被其他组件访问，例如DMA控制器。对于CCM，CPU能以最大的系统时钟和最小的等待时间从CCM中读取数据或者代码。官方文档说明了使用CCM的一些优势：比如将频繁读取的数据放到CCM，将中断函数放到CCM，这都能加快程序的执行速度。
初始化内存池报超出空间错误
ture_mydream的博客
01-07 468
加入my_mem_init(SRAMIN);编译后报错 错误：.\Objects\f4xx_demo_pro.axf: Error: L6406E: No space in execution regions with .ANY selector matching heap_4.o(.bss). 解决办法将内存池的那些宏改小些： 将 #define MEM1_MAX_SIZE 100*1024 改为 #define MEM1_MAX_SI...
STM32F4内的FLASH和RAM
不断debug，优化中……
10-01 5008
STM32F4内的FLASH和RAM(CCM) 单片机的flash和RAM，可以简单理解为电脑的硬盘和内存条。 FLASH 什么是FLASH？FLASH的作用？ 掉电不丢失数据，能够存储数据的存储器，所以用于存储单片机的程序，单片机重启上电，根据起始地址，flash上的程序。 这里FLSH有分为NANDFLASH和NORFLASH，这两者的主要区别就是，访问存储的单位空间大小不同，一个是块（一般是512字节），一个是字节，程序是以字节单位访问执行代码，所以用户可以直接运行装载在NOR FLASH里面的代码，
STM32F4_常用存储器简介
light_2025的博客
05-29 1432
又称为闪存，它是可重复擦写的存储器。它的容量一般比EEPROM大得多，且在擦除时，一般以多个字节为单位。所谓随机存储，指的是当存储器中的消息被读写或写入时，所需要的时间与这段信息所在的位置无关。像我们平时买手机时，128G、256G，512G、1T内存，这些这不是我们手机真正存储的内存，实际上这些是。，内核是用来进行数据的运算和处理的。是 “Read Only Memory” 的缩写，意为。有关存储器大家了解即可，方便后续的学习。根据ARM的存储机制，又分为。根据存储单元的电流不同，
STM32F4，Flash，ROM，RAM，IAP升级，ISP下载
weixin_40267061的博客
04-15 1053
ISP技术的优势是不需要编程器就可以进行单片机的实验和开发，单片机芯片可以直接焊接到电路板上，调试结束即成成品，免去了调试时由于频繁地插入取出芯片对芯片和电路板带来的不便。(3)全局区与静态区（data）：存储全局变量和静态变量，其中初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。bss指的是没有初始化，或者初始化为0的全局或静态变量。全局与静态变量的初始值，是需要保存下来，其基本可以分为三大类，一种是等于0的，一种是不等于0，还有一种是没有初始值的。
STM32F4XX LWIP+freeRTOS移植(二)
u014453443的博客
08-06 6966
有疑问请加扣扣技术交流群：460189483 源码下载地址：https://download.csdn.net/download/u014453443/10698059 前面几个文件改好了之后，下面进入实战环节，从ucos_ii系统+lwip移植为freeRTOS+LWIP！ 第一步：从原子例程中找一个现成的freeRTOS系统工程，这里我们选的FreeRTOS实验20-1 FreeRTOS...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

奚海蛟

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

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

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

打赏作者

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

抵扣说明：

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

余额充值