目录
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这么大。
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时的时序：
- 先使能片选引脚指明设备，然后开始发送地址；
- 一段时间后使能OE引脚，再经过tDOE时间后开始采集数据；
- 数据是内存芯片通过16个IO引脚传回STM32的，在整个读取的过程地址线要保持不变tRC时间（即每根地址线上的高低电平要保持住）；
- 三个时间比较重要：tRC，tAA，tODE。
STM32写入数据到SRAM的时序如下：
读写时序的流程很类似，过程如下：
(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存储控制器来管理，因此我们暂时先学习这部分即可。
然后接着是FSMC NOR存储控制器的信号线，CLK即HCLK，FSMC这个外设挂载在HCLK时钟线下（默认72MHz，用于内核与FSMC的时钟同步，也可用于输出时钟信号），接着是地址总线共有26个，但是这次的SRAM只用到19个，数据线和SRAM一样都是16个，NE是个很有趣的东西，它决定了FSMC可以控制多个存储器，下文再接着介绍，先继续往下看，NOE和NWE分别为读/写使能，NL和NWAIT没有用到，暂时不理；最后的NBL则是掩码信号引脚，对应的是SRAM的LB#和UB#
上面讲到的FSMC引脚与SRAM的引脚相匹配总结如下，发现其高度统一：
接着将上面的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信号线会输出控制信号。
例如，当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外设的读写时序：
以读时序为例，该图表示一个存储器操作周期由地址建立周期(ADDSET)、数据建立周期(DATAST)以及2个HCLK周期组成。在地址建立周期中，地址线发出要访问的地址，数据掩码信号线指示出要读取地址的高、低字节部分，片选信号使能存储器芯片；地址建立周期结束后读使能信号线发出读使能信号，接着存储器通过数据信号线把目标数据传输给FSMC，FSMC把它交给内核。
写时序类似，区别是它的一个存储器操作周期仅由地址建立周期(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;
}
}
}
运行结果如下：
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页。
从上图可以看出，分块式内存管理由内存池和内存管理表两部分组成。内存池被等分为 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;
}
}
}
运行结果为：
这里提醒大家，如果对一个指针进行多次内存申请，而之前的申请又没释放，那么将造成“内存泄露”，这是内存管理所不希望发生的，久而久之，可能导致无内存可用的情况！所以，在使用的时候，请大家一定记得，申请的内存在用完以后，一定要释放。