目录
1 概述
STM32控制器芯片内部有一定大小的SRAM及FLASH作为内存和程序存储空间,代码存放在FLASH里,而代码运行过程的一些变量及缓存会放在SRAM里(可以把SRAM理解成电脑的内存条,内存条实质是由多个内存颗粒(即SDRAM芯片)组成的通用标准模块),当程序较大、比如跑算法或者跑 GUI 等,内存和程序空间不足时,就需要在STM32芯片的外部扩展存储器了。STM32F103ZE系列芯片可以扩展外部SRAM用作内存。
1.1 自带的IS62WV51216芯片
STM32F103ZET6 自带了 64K 字节的 SRAM(在芯片里),战舰 STM32 开发板板载了一颗 1M 字节容量的外部 SRAM 芯片:IS62WV51216,它是一颗 16 位宽 512K(16 * 512K,即 1M 字节;ps:16=2个字节)容量的 CMOS 静态内存芯片。“16”表示16位数据总线,即表示每个地址上的数据是16位(2个字节)。PS:1M字节 = 1024 * 1024字节 = 512K * 2字节 = (512 * 1024)字节 * 2字节。
1.2 FSMC概述
FSMC是Flexible StaticMemory Controller的缩写,就是灵活的静态存储控制器。它可以用于驱动包括SRAM、NOR FLASH(如W25Q128)以及NAND FLSAH类型的存储器。其他我们不用管,我们只要知道,stm32雇佣FSMC这个管家来管理我们的IS62WV51216。
介绍之前,先描述一下用FSMC来管理IS62WV51216后的美好样子:已知C代码在定义变量时,编译器最终会将变量名替换成内存的实际地址,以后每次访问该变量,就相当于直接访问了该地址里的数据,还有比如指针的解引用。这个也一样,配置好FSMC一些相关的参数后(相当于让外部SRAM与它进行绑定),然后我们就可以直接使用外部SRAM上的内存了,以前的变量对应的是芯片内部内存的地址,而现在则对应的是外部SRAM里的地址,并且和对内部内存地址操作的方式都一样,有两种方式:
- 使用指针对SRAM进行读写:定义一个指针直接指向SRAM里的地址即可
#define SRAM_BASE_ADDR (0x68000000)
uint8_t *p;
p = (uint8_t *)(SRAM_BASE_ADDR+0x40);
*p = 0xAB; //写入数据到外部SRAM,同样也可读出
- 使用绝对地址的方式访问SRAM:直接访问到SRAM里的实际地址
#define SRAM_BASE_ADDR (0x68000000)
//使用__attribute__定义变量时,需要定义为全局变量(MDK提供的)
//指定一个变量的地址
uint8_t testValue __attribute__ ((at (SRAM_BASE_ADDR+0x40))) ;
testValue = 0xAB; //写入数据到外部SRAM,同样也可读出
看到这里惊呆了,居然还能这样子方便,即只要你知道这个外部SRAM里的内存地址了,你就可以很方便去访问了。这里应该有个疑问,使用内部内存的地址和这个外部的内存的地址会不会有冲突?不会。下面是cotex-m3内核的地址映射和FSMC相关的地址映射:可以知道芯片自带的片上SRAM的地址在0x20000000到0x3FFFFFFF,而划分给FSMC管理的地址从0x60000000到0x9FFFFFFF,即供外部SRAM拓展的最大空间有1G这么大。
![](https://img-blog.csdnimg.cn/20200806132411170.png)
code区访问片上SRAM的数据和访问外部SRAM的数据一摸一样,只要有了内存地址,并且你的内存芯片已经做好了准备(比如初始化FSMC),那么就可以直接读写了。
2 IS62WV51216芯片介绍
先介绍IS62WV51216芯片的相关知识:
![]() |
![]() |
图中 A0 ~ 18 为地址线,总共 19 根地址线(即 2^19bit=512K,1K=1024bit);IO0 ~ 15 为数据线,总共 16 根数据线(分高低两部分)。CS2 和 CS1 都是片选信号,不过 CS2 是高电平有效 CS1 是低电平有效;OE是输出使能信号(读信号,如果要读取该芯片,则需要使能该引脚);WE 为写使能信号(写入数据时,则使能该引脚);UB 和 LB 分别是高字节控制和低字节控制信号(数据掩码信号);
实际的内存大小为1024 * 1204个字节,但是19根地址线只能访问到512K(512*1024字节)的范围,那怎么办呢?注意IS62WV51216里的”16“代表的是16bit,也就是只要给一个地址,其实就能够访问到16bit的数据(即2字节,比如输入地址0,实际可以访问到第0和第1个字节),因此19根地址线实际可寻址的范围是1024个字节这么大。只不过有时候如果我只想读写一个字节的时候怎么做呢?那就用到了上一段的UB 和 LB数据掩码信号。
比如,我要往第0字节写入数据,而不影响第1字节里原有的数据,则我需要将UB线拉高,LB线拉低(低位字节有效),数据通过16根数据线传过来,IS62WV51216就知道自己只要接收 IO0 ~ 7的数据,自动屏蔽忽略了IO8 ~ 15的数据。
2.1 SRAM通信时序
外部SRAM(IS62WV51216)的读写时序介绍,采用的是异步方式:
下面是STM32读取SRAM时的时序:
![](https://img-blog.csdnimg.cn/20200806141003528.png)
- 先使能片选引脚指明设备,然后开始发送地址;
- 一段时间后使能OE引脚,再经过tDOE时间后开始采集数据;
- 数据是内存芯片通过16个IO引脚传回STM32的,在整个读取的过程地址线要保持不变tRC时间(即每根地址线上的高低电平要保持住);
- 三个时间比较重要:tRC,tAA,tODE。
![](https://img-blog.csdnimg.cn/20200806142056339.png)
STM32写入数据到SRAM的时序如下:
![](https://img-blog.csdnimg.cn/20200806142425373.png)
读写时序的流程很类似,过程如下:
(1) 主机使用地址信号线发出要访问的存储器目标地址;
(2) 控制片选信号CS1#及CS2#使能存储器芯片;
(3) 若是要进行读操作,则控制读使能信号OE#表示要读数据,若进行写操作则控制写使能信号WE#表示要写数据;
(4) 使用掩码信号LB#与UB#指示要访问目标地址的高、低字节部分;
(5) 若是读取过程,存储器会通过数据线向主机输出目标数据,若是写入过程,主要使用数据线向存储器传输目标数据。
3 FSMC的介绍
关于FSMC的介绍,如前面提到的,FSMC是Flexible StaticMemory Controller的缩写,就是灵活的静态存储控制器。它是STM32集成的一个外设,顾名思义它只能控制静态存储器,类似于SDRAM这样的动态内存它无法控制,可以把它看成是一个衔接CPU与外部存储的桥梁,它的功能呢就是你往相应的地址里写数据时候,你不需用软件来模拟外部存储芯片的读写时序,而只需配置好FSMC相关的时序寄存器,配置好相关寄存器之后,你只管往相应存储块中的地址里写数据就可以了。
下面是FSMC的控制框图,本文讲到的IS62WV51216这个外部SRAM归属于NOR存储控制器来管理,因此我们暂时先学习这部分即可。
![](https://img-blog.csdnimg.cn/20200806171050504.png)
然后接着是FSMC NOR存储控制器的信号线,CLK即HCLK,FSMC这个外设挂载在HCLK时钟线下(默认72MHz,用于内核与FSMC的时钟同步,也可用于输出时钟信号),接着是地址总线共有26个,但是这次的SRAM只用到19个,数据线和SRAM一样都是16个,NE是个很有趣的东西,它决定了FSMC可以控制多个存储器,下文再接着介绍,先继续往下看,NOE和NWE分别为读/写使能,NL和NWAIT没有用到,暂时不理;最后的NBL则是掩码信号引脚,对应的是SRAM的LB#和UB#
![](https://img-blog.csdnimg.cn/20200806171543838.png)
上面讲到的FSMC引脚与SRAM的引脚相匹配总结如下,发现其高度统一:
![](https://img-blog.csdnimg.cn/20200806172411203.png)
接着将上面的FSMC_NE[1:4],是用于控制SRAM芯片的控制信号线,STM32具有FSMC_NE1/2/3/4号引脚,不同的引脚对应STM32内部不同的地址区域。啥不同的地址区域呢?
![]() |
![]() |
cotex-m3将4GB的地址空间中的0x60000000到0x9FFFFFFF共1GB的空间分给外部内存,这1GB的空间供用户自由使用,然后强势的FSMC就接管了这1GB的空间。FSMC把整个External RAM存储区域分成了4个Bank区域,并分配了地址范围及适用的存储器类型,如NOR及SRAM存储器只能使用Bank1的地址(0x60000000到0x6FFFFFFF)。
Bank内部的256MB空间又被分成4个小块,每块64M,各自有相应的控制引脚用于连接片选信号,如FSMC_NE[4:1]信号线可用于选择BANK1内部的4小块地址区域,当STM32访问0x68000000-0x6BFFFFFF地址空间时,会访问到Bank1的第3小块区域,相应的FSMC_NE3信号线会输出控制信号。
![](https://img-blog.csdnimg.cn/20200806173836354.png)
例如,当STM32访问0x68000000-0x6BFFFFFF地址空间时,FSMC_NE3引脚会自动设置为低电平,由于它连接到SRAM的CE#引脚,所以SRAM的片选被使能,而访问0x60000000-0x63FFFFFF地址时,FSMC_NE1会输出低电平。当使用不同的FSMC_NE引脚连接外部存储器时,STM32访问SRAM的地址不一样,从而达到控制多块SRAM芯片的目的。
3.1 FSMC时序
另外,FSMC外设支持输出多种不同的时序以便于控制不同的存储器,它具有ABCD四种模式,以模式A为例,当内核发出访问某个指向外部存储器地址时,FSMC外设会根据配置控制信号线产生时序(由硬件产生时序)访问存储器,下图是访问外部SRAM时FSMC外设的读写时序:
![](https://img-blog.csdnimg.cn/20200806174734181.png)
以读时序为例,该图表示一个存储器操作周期由地址建立周期(ADDSET)、数据建立周期(DATAST)以及2个HCLK周期组成。在地址建立周期中,地址线发出要访问的地址,数据掩码信号线指示出要读取地址的高、低字节部分,片选信号使能存储器芯片;地址建立周期结束后读使能信号线发出读使能信号,接着存储器通过数据信号线把目标数据传输给FSMC,FSMC把它交给内核。
![](https://img-blog.csdnimg.cn/20200806175051601.png)
写时序类似,区别是它的一个存储器操作周期仅由地址建立周期(ADDSET)和数据建立周期(DATAST)组成,且在数据建立周期期间写使能信号线发出写信号,接着FSMC把数据通过数据线传输到存储器中。
3.2 FSMC相关的配置结构体
IS62WV51216为异步类型的SRAM存储器
时序结构体: FSMC_NORSRAMTimingInitTypeDef,定义SRAM读写时序中的各项时间参数,与FSMC_BRT及FSMC_BWTR寄存器配置对应。
//HCLK的时钟频率为72MHz,即一个HCLK周期为1/72微秒
typedef struct{
uint32_t FSMC_AddressSetupTime;/*ADDSET 地址建立时间,0-0xF个HCLK周期*/
uint32_t FSMC_AddressHoldTime ;/*ADDHLD 地址保持时间,0-0xF个HCLK周期*/
uint32_t FSMC_DataSetupTime;/*DATAST 地址建立时间,0-0xF 个HCLK周期*/
uint32_t FSMC_BusTurnAroundDuration; /*BUSTURN 总线转换周期, 0-0xE个HCLK周期,在NOR FLASH */
uint32_t FSMC_CLKDivision; /*CLKDIV 时钟分频因子, 1-0xF,若控制异步存储器,本参数无效*/
uint32_t FSMC_DataLatency; /*数据延迟/保持时间,若控制异步存储器,本参数无效*/
uint32_t FSMC_AccessMode;/*设置访问模式,可选FSMC_AccessMode_A/B/C/D模式。一般来说控制SRAM时使用A模式。
*/
} FSMC_NORSRAMTimingInitTypeDef;
//对于本示例中只用到以下三个参数:
//FSMC_AddressSetupTime、FSMC_DataSetupTime、FSMC_AccessMode
初始化结构体: FSMC_NORSRAMInitTypeDef,对应到FSMC_BCR中的寄存器位。
typedef struct{
uint32_t FSMC_Bank;/*设置要控制的Bank区域(1~4)*/
uint32_t FSMC_DataAddressMux; /*设置地址总线与数据总线是否复用,nor flash使用*/
uint32_t FSMC_MemoryType;/*设置存储器的类型,本示例SRAM*/
uint32_t FSMC_MemoryDatawidth;/*设置存储器的数据宽度,可选8/16*/
uint32_t FSMC_BurstAccessMode; /*设置是否支持突发访问模式(访问地址自增加),只支持同步类型的存储器*/
uint32_t FSMC_AsynchronousWait;/*设置是否使能在同步传输时的等待信号,*/
uint32_t FSMC_WaitsignalPolarity; /* 设置等待信号的极性*/
uint32_t FSMC_WrapMode;/*设置是否支持对齐的突发模式*/
uint32_t FSMC_WaitsignalActive; /* 配置等待信号在等待前有效还是等待期间有效*/
uint32_t FSMC_Writeoperation;/*设置是否写使能(保护存储器,禁止写使能的话FSMC只能从存储器中读取数据,不能写入)*/
uint32_t FSMC_Waitsignal;/*设置是否使能等待状态插入*/
uint32_t FSMC_ExtendedMode ;/*设置是否使能扩展模式*/
uint32_t FSMC_WriteBurst;/*设置是否使能写突发操作*/
/* 当不使用扩展模式时,本参数用于配置读写时序,否则用于配置读时序*/
FSMC_NORSRAMTimingInitTypeDef* FSMC_ReadwriteTimingStruct;
/*当使用扩展模式时,本参数用于配置写时序*/
FSMC_NORSRAMTimingInitTypeDef* FSMC_WriteTimingStruct;
} FSMC_NORSRAMInitTypeDef;
/*
在非扩展模式下,对存储器读写的时序都只使用FSMC_BCR寄存器中的配置,即下面的
FSMC_ReadWriteTimingStruct结构体成员;在扩展模式下,对存储器的读写时序可以分开配置,
读时序使用FSMC_BCR寄存器,写时序使用FSMC_BWTR寄存器的配置,即下面的FSMC_WriteTimingStruct结构体。
*/
//对于SRAM,只要关注这几个:
//FSMC_Bank、FSMC_DataAddressMux、FSMC_MemoryType、FSMC_MemoryDatawidth
//FSMC_Writeoperation、FSMC_ExtendedMode
//FSMC_ReadwriteTimingStruct、FSMC_WriteTimingStruct
4 扩展外部SRAM硬件部分
SRAM与FSMC的硬件连接图如下,用到的引脚很多很多,,我就不一一列出来了,反正有DEFG引脚,直接在代码里看吧。
![]() |
![]() |
5 扩展外部SRAM代码部分
使用 FSMC 的 BANK1 区域 3 来控制 IS62WV51216
sram.c
#include "sram.h"
#include "usart.h"
/*
A[0:18]接FMSC_A[0:18]
D[0:15]接FSMC_D[0:15]
UB接FSMC_NBL1 引脚PE1
LB接FSMC_NBL0 引脚PE0
OE接FSMC_NOE 引脚PD4
WE接FSMC_NWE 引脚PD5
CS接FSMC_NE3 引脚PG10
*/
#define Bank1_SRAM3_ADDR ((u32)(0x68000000))
//初始化外部SRAM
void FSMC_SRAM_Init(void)
{
FSMC_NORSRAMInitTypeDef FSMC_NORSRAMInitStructure;
FSMC_NORSRAMTimingInitTypeDef readWriteTiming;
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD|RCC_APB2Periph_GPIOE|RCC_APB2Periph_GPIOF|RCC_APB2Periph_GPIOG,ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC,ENABLE);//开启外设时钟
//所有引脚都配置成复用推挽输出、50MHz
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
// /*写法一:将所用到的引脚的地址相或,得到最终的地址,这样做可以简化代码*/
// /*---------------------------------------------------------------*/
// GPIO_InitStructure.GPIO_Pin = 0xFF33; //PORTD
// GPIO_Init(GPIOD, &GPIO_InitStructure);
// /*---------------------------------------------------------------*/
// GPIO_InitStructure.GPIO_Pin = 0xFF83; //PORTE
// GPIO_Init(GPIOE, &GPIO_InitStructure);
// /*---------------------------------------------------------------*/
// GPIO_InitStructure.GPIO_Pin = 0xF03F; //PORTF
// GPIO_Init(GPIOF, &GPIO_InitStructure);
// /*---------------------------------------------------------------*/
// GPIO_InitStructure.GPIO_Pin = 0x043F; //PORTG
// GPIO_Init(GPIOG, &GPIO_InitStructure);
// /*---------------------------------------------------------------*/
/*写法二:常规写法*/
/*---------------------------------------------------------------*/
/*A地址信号线 针对引脚配置*/
//A0 ~ 9 分别对应 PF0 ~ PF5 和 PF12 ~ PF15
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5 \
|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;
GPIO_Init(GPIOF, &GPIO_InitStructure);
//A10 ~ 15 分别对应 PG0 ~ PG5
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5;
GPIO_Init(GPIOG, &GPIO_InitStructure);
//A16 ~ 18 分别对应 PD11 ~ PD13
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13;
GPIO_Init(GPIOD, &GPIO_InitStructure);
/*---------------------------------------------------------------*/
/*DQ数据信号线 针对引脚配置*/
//D0 ~ 15对应的引脚分别为 D14 D15 D0 D1 E7 E8 E9 E10 E11 E12 E13 E14 E15 D8 D9 D10
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14|GPIO_Pin_15|GPIO_Pin_0|GPIO_Pin_1 \
|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10;
GPIO_Init(GPIOD, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10 \
|GPIO_Pin_11|GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;
GPIO_Init(GPIOE, &GPIO_InitStructure);
/*---------------------------------------------------------------*/
/*控制信号线*/
//UB LB OE WE CS 分别对应 PE0 PE1 PD4 PD5 PG10
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1;
GPIO_Init(GPIOE, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4|GPIO_Pin_5;
GPIO_Init(GPIOD, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_Init(GPIOG, &GPIO_InitStructure);
/*
读时序的要求
//1. ADDSET+1+DATAST+1 +2 >55ns
//2. DATAST+1 > 25ns
//3. ADDSET+1 > 0ns
写时序的要求
//1. ADDSET+1+DATAST+1 >55ns
//2. DATAST+1 > 40ns
//3. ADDSET+1 > 0ns
//理论上ADDSET=0 DATAST=1也可以了,但是实际不行,故分别设置成0,2
*/
readWriteTiming.FSMC_AccessMode = FSMC_AccessMode_A; //模式A
readWriteTiming.FSMC_AddressSetupTime = 0x00; //地址建立时间(ADDSET)为1个HCLK 1/72M=13.8 ns,理论值
readWriteTiming.FSMC_DataSetupTime = 0x02; //数据保持时间(DATAST)为3个HCLK 3/72M=54.9ns(DATAST设为2,在寄存器会加1,因此为3)
//SRAM模式A未用到以下的参数,全都设为0
readWriteTiming.FSMC_AddressHoldTime = 0x00; //地址保持时间(ADDHLD)
readWriteTiming.FSMC_BusTurnAroundDuration = 0x00;
readWriteTiming.FSMC_CLKDivision = 0x00;
readWriteTiming.FSMC_DataLatency = 0x00;
/*初始化参数*/
FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM3;// 这里我们使用NE3 ,也就对应BTCR[4],[5]
FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable; // 非扩展模式,读写使用相同的时序
FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b;//存储器数据宽度为16bit
FSMC_NORSRAMInitStructure.FSMC_MemoryType =FSMC_MemoryType_SRAM;// FSMC_MemoryType_SRAM; //SRAM
FSMC_NORSRAMInitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable; //存储器写使能
//初始化结构体SRAM下用不到,配置为disable
FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable;
FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode =FSMC_BurstAccessMode_Disable;// FSMC_BurstAccessMode_Disable;
FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low;
FSMC_NORSRAMInitStructure.FSMC_AsynchronousWait=FSMC_AsynchronousWait_Disable;
FSMC_NORSRAMInitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable;
FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState;
FSMC_NORSRAMInitStructure.FSMC_WaitSignal = FSMC_WaitSignal_Disable;
FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable;
//读写时序结构体
FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &readWriteTiming;
FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &readWriteTiming; //读写同样时序
FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure); //初始化FSMC配置
FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM3, ENABLE); // 使能BANK3
}
main.c
:SRAM掉电不保存数据,因为要先按key0写入数据,然后key1访问0字节地址的数据时才有意义(值应该为0)
#include "led.h"
#include "delay.h"
#include "key.h"
#include "sys.h"
#include "usart.h"
#include "sram.h"
//两种方式访问SRAM
//1.使用指针对SRAM进行读写
//2.使用绝对地址的方式访问SRAM
//使用__attribute__定义变量时,需要定义为全局变量
u32 testValue __attribute__((at(SRAM_BASE_ADDR+0x40)));//该变量存的数值放在外部SRAM中
//外部内存测试(最大支持1M字节内存测试)
void fsmc_sram_test(void)
{
u32 i=0;
u8 temp=0;
u8 sval=0; //在地址0读到的数据
printf("正在测试外部SRAM内存...\r\n");
//每隔4K字节,写入一个数据,总共写入256个数据,刚好是1M字节
for(i=0;i<1024*1024;i+=4096) //1M字节 = 1024*1024字节 = 512K * 2字节 = (512*1024)字节 * 2字节 = 256 * 4 K
{
//第一次将数值0写入到“0”地址(1字节),第二次将1写入“4094”地址(1字节),...(总共有1024*1024个地址)
*(uint8_t*)(SRAM_BASE_ADDR+i) = temp;//一个字节为单位进行写入
temp++;
}
//依次读出之前写入的数据,进行校验
for(i=0;i<1024*1024;i+=4096)
{
temp = *(uint8_t*)(SRAM_BASE_ADDR+i);//一个字节为单位进行读出
if(i==0) sval=temp;
else if(temp<=sval) break;//后面读出的数据一定要比第一次读到的数据大.
}
printf("经测试读出的外部SRAM内存大小为:%dK\r\n\r\n",(u16)(temp-sval+1)*4); //最终temp=255,sval=0
}
int main(void)
{
//指针方式测试
uint8_t *p8 = (uint8_t *)SRAM_BASE_ADDR; //SRAM的"0"地址,只访问一个字节
uint16_t *p16; //访问第0和第1个字节
uint8_t testTemp_1;
uint16_t testTemp_2;
//float *pf = (float *)(SRAM_BASE_ADDR+20);
u8 key;
u8 i=0;
delay_init(); //延时函数初始化
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2:2位抢占优先级,2位响应优先级
uart_init(115200); //串口初始化为115200
LED_Init(); //初始化与LED连接的硬件接口
KEY_Init(); //初始化按键
FSMC_SRAM_Init(); //初始化外部SRAM
printf("key0:测试SRAM容量\tkey1:指针方式访问SRAM\tkey2:绝对地址方式访问SRAM\r\n\r\n");
while(1)
{
key=KEY_Scan(0);//不支持连按
if(key==KEY0_PRES)fsmc_sram_test();//测试SRAM容量
else if(key==KEY1_PRES){
printf("(8bit时) 读取到外部SRAM 0x%p 地址的内容为: %d\r\n",p8,*p8);
p16 = (uint16_t *)(SRAM_BASE_ADDR);//同时对两个字节操作
*p16 = 0xabcd; //将第0和第1字节的内容写为0x1234
testTemp_2 = *(uint16_t*)(SRAM_BASE_ADDR); //读出“0”地址和“1”地址里的数据
printf("(16bit时)读取到外部SRAM 0x%p 地址的内容为: 0x%x\r\n\r\n",p16,testTemp_2);
}
else if(key==KEY2_PRES){
testValue = 10;
printf("将 %d 的值写入到外部SRAM 0x%p 地址\r\n",testValue,&testValue);
testTemp_1 = *(uint8_t*)(SRAM_BASE_ADDR+0x40);
printf("从外部SRAM 0x%p 地址读取到的数值为 %d\r\n\r\n",&testValue,testTemp_1);
}
else delay_ms(10);
i++;
if(i==20)//DS0闪烁
{
i=0;
LED0=!LED0;
}
}
}
运行结果如下:
![](https://img-blog.csdnimg.cn/20200806213048402.png)
6 内存管理内、外部SRAM
运用内存管理技术,实现对内存的动态管理。比如定义一个u32 testsram[250000]的数组放在外部SRAM中,U32表示一个数占4个字节(B),这个数组一共包涵250000个数,也就是说这个数组的大小为4250000=110^7=100 0000=100万B=1000KB=1MB,这个数组比我们实际用的SRAM较小,1M=1024KB,小了24KB。在实际运用中当有多个这样的数组需求,则需要用到动态内存管理。
内存管理,是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效、快速的分配,并且在适当的时候释放和回收内存资源。内存管理的实现方法有很多种,他们其实最终都是要实现 2 个函数:malloc 和 free;malloc 函数用于内存申请,free 函数用于内存释放。
针对于单片机 RAM 如此紧缺的设备来讲,使用 C 标准库中的内存管理函数是不恰当的,存在着许多弊端,主要有以下几点:
- 他们的实现可能非常大,占据了相当大的一块代码空间
- 这两个函数会使得链接器配置得复杂
- 如果允许堆空间的生长方向覆盖其他变量的内存,他们会成为 debug 的灾难
这里用正点原子教程的分块式内存管理方法,在其中文参考手册的572页。
![](https://img-blog.csdnimg.cn/20200808142925883.png)
从上图可以看出,分块式内存管理由内存池和内存管理表两部分组成。内存池被等分为 n块,对应的内存管理表,大小也为 n,内存管理表的每一个项对应内存池的一块内存。
内存管理表的项值代表的意义为:当该项值为 0 的时候,代表对应的内存块未被占用,当该项值非零的时候,代表该项对应的内存块已经被占用,其数值则代表被连续占用的内存块数。比如某项值为 10,那么说明包括本项对应的内存块在内,总共分配了 10 个内存块给外部的某个指针。
内寸分配方向如图所示,是从顶到底的分配方向。即首先从最末端开始找空内存。当内存管理刚初始化的时候,内存表全部清零,表示没有任何内存块被占用。
6.1 分配原理
当指针p调用malloc申请内存的时候,先判断p要分配的内存块数(m),然后从第n项开始向下查找,直到找到m块连续的空内存块(即对应内存管理表项为0),然后将这m个内存管理表项的值都设置为m(标记被占用),最后把最后的这个空内存块的地址返回指针p,完成一次分配。注意,如果当内存不够的时候(找到最后也没找到连续的m块空闲内存),则返回NULL给p,表示分配失败。(首先确定要开辟的内存大小n,从表的最后向前找n个空单元,找到后将其对应的内存地址返回,那么[p,p+n]就是空闲的n个单元。)
6.2 释放原理
当指针p申请的内存用完,需要释放的时候,调用free函数实现。free函数先判断p指向的内存地址所对应的内存块,然后找到对应的内存管理表项目,得到p所占用的内存块数目m(内存管理表项目的值就是所分配内存块的数目),将这m个内存管理表项目的值都清零,标记释放,完成一次内存释放。
6.3 代码部分
malloc.h
#ifndef __MALLOC_H
#define __MALLOC_H
#include "stm32f10x.h"
#ifndef NULL
#define NULL 0
#endif
//定义两个内存池
#define SRAMIN 0 //内部内存池
#define SRAMEX 1 //外部内存池
#define SRAMBANK 2 //定义支持的SRAM块数
//内存管理控制器
struct _m_mallco_dev
{
void (*init)(u8); //初始化
u8 (*perused)(u8); //内存使用率
u8 *membase[SRAMBANK]; //内存池 管理SRAMBANK个区域的内存
u16 *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); //内存释放(内部调用)
u8 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
malloc.c
#include "malloc.h"
//mem1内存参数设定.mem1完全处于内部SRAM里面.
#define MEM1_BLOCK_SIZE 32 //内存块大小为32字节
#define MEM1_MAX_SIZE 40*1024 //最大管理内存 40K //STM32内部SRAM为64K
#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 //内存表大小
//因为内存块的大小是 32 字节,而且我们从这里也可以看到我们所定义的内存池本质
//就是一个全局变量的数组,这个数组在编译时,就被分配了一个固定大小的内存
//内存池(32字节对齐)
__align(32) u8 mem1base[MEM1_MAX_SIZE]; //内部SRAM内存池,数组个数40K,类型U8
__align(32) u8 mem2base[MEM2_MAX_SIZE] __attribute__((at(0X68000000))); //外部SRAM内存池
//内存管理表
u16 mem1mapbase[MEM1_ALLOC_TABLE_SIZE]; //内部SRAM内存池MAP
u16 mem2mapbase[MEM2_ALLOC_TABLE_SIZE] __attribute__((at(0X68000000+MEM2_MAX_SIZE))); //外部SRAM内存池MAP
//内存管理参数
const u32 memtblsize[SRAMBANK]={MEM1_ALLOC_TABLE_SIZE,MEM2_ALLOC_TABLE_SIZE}; //内存表大小
const u32 memblksize[SRAMBANK]={MEM1_BLOCK_SIZE,MEM2_BLOCK_SIZE}; //内存分块大小
const u32 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,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]*2);//内存状态表数据清零
mymemset(mallco_dev.membase[memx], 0,memsize[memx]); //内存池所有数据清零
mallco_dev.memrdy[memx]=1; //内存管理初始化OK
}
//获取内存使用率
//memx:所属内存块
//返回值:使用率(0~100)
u8 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*100)/(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); //返回新内存首地址
}
}
main.c
#include "led.h"
#include "delay.h"
#include "key.h"
#include "sys.h"
#include "usart.h"
#include "sram.h"
#include "malloc.h"
#include "string.h"
int main(void)
{
u8 key;
u8 i=0;
u8 *p[10]={0};
u8 sramx=0; //默认为内部sram
char* nowSram[2] = {"内部SRAM","外部SRAM"};
int num=0;
delay_init(); //延时函数初始化
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2:2位抢占优先级,2位响应优先级
uart_init(115200); //串口初始化为115200
LED_Init(); //初始化与LED连接的硬件接口
KEY_Init(); //初始化按键
FSMC_SRAM_Init(); //初始化外部SRAM
my_mem_init(SRAMIN); //初始化内部内存池
my_mem_init(SRAMEX); //初始化外部内存池
printf("》》 %s 使用率:%d%%\r\n",nowSram[sramx],my_mem_perused(sramx));
printf("key0:动态申请内存\tkey1:写入新数据\tkey2:释放内存\tkey_up:切换内/外部SRAM\r\n\r\n");
while(1)
{
key=KEY_Scan(0); //不支持连按
switch(key)
{
case 0: //没有按键按下
break;
case KEY0_PRES: //KEY0按下
if(p[num]) num++;
if(num>10)
{
num = 10;
printf("%s: 申请失败!已满!\r\n\r\n",nowSram[sramx]);
break;
}
p[num] = mymalloc(sramx,2048);//申请2K字节
// int sprintf(char *string, char *format [,argument,...]);
//把格式化的数据写入某个字符串中,即发送格式化输出到 string 所指向的字符串
if(p[num]!=NULL)
{
sprintf((char*)p[num],"Memory Malloc Test: %s",nowSram[sramx]);//向p写入一些内容
printf("%s: 申请内存成功!\r\n内容:%s\r\n地址:0x%p\r\n",nowSram[sramx],(char*)p[num],p[num]);
printf("》》 %s 使用率:%d%%\r\n\r\n",nowSram[sramx],my_mem_perused(sramx));
}
else printf("%s: 申请失败!地址错误!\r\n\r\n",nowSram[sramx]);
break;
case KEY1_PRES: //KEY1按下
if(p[num]!=NULL)
{
sprintf((char*)p[num],"Write Test New: Memory Malloc Test: %s",nowSram[sramx]);//更新显示内容
printf("%s: 已更新数据!\r\n内容:%s\r\n地址:0x%p\r\n\r\n",nowSram[sramx],(char*)p[num],p[num]);
printf("》》 %s 使用率:%d%%\r\n\r\n",nowSram[sramx],my_mem_perused(sramx));
}
break;
case KEY2_PRES: //KEY2按下
printf("%s: 释放内存成功!\r\n地址:0x%p\r\n\r\n",nowSram[sramx],p[num]);
myfree(sramx,p[num]);//释放内存
p[num]=0; //指向空地址
printf("》》 %s 使用率:%d%%\r\n\r\n",nowSram[sramx],my_mem_perused(sramx));
num--;
if(num<0) num=0;
break;
case WKUP_PRES: //KEY UP按下
if(p[num])
{
printf("切换失败!请先释放 %s 的内存!\r\n\r\n",nowSram[sramx]);
break;
}
sramx =! sramx; //切换当前malloc/free操作对象
printf("切换成功!现在为:%s\r\n\r\n",nowSram[sramx]);
printf("》》 %s 使用率:%d%%\r\n\r\n",nowSram[sramx],my_mem_perused(sramx));
break;
}
delay_ms(10);
i++;
if((i%20)==0)//DS0闪烁.
{
LED0=!LED0;
}
}
}
运行结果为:
![](https://img-blog.csdnimg.cn/20200808163723124.png)
这里提醒大家,如果对一个指针进行多次内存申请,而之前的申请又没释放,那么将造成“内存泄露”,这是内存管理所不希望发生的,久而久之,可能导致无内存可用的情况!所以,在使用的时候,请大家一定记得,申请的内存在用完以后,一定要释放。