【STM32】HAL库 STM32CubeMX教程十五---FMC-SDRAM(二)

Z小旋

已于 2022-03-29 21:43:56 修改

阅读量9.7k

点赞数 38

于 2022-03-29 21:42:42 首次发布

博客为博主原创，转载请评论说明并注明出处，谢谢

本文链接：https://blog.csdn.net/as480133937/article/details/123791568

版权

【STM32】专栏收录该内容

48 篇文章 5338 订阅

订阅专栏

前言：

本系列教程将HAL库与STM32CubeMX结合在一起讲解，使您可以更快速的学会各个模块的使用

上一讲我们说了CubeMX配置SDRAM的一些基本配置，还有FMC跟SDRAM的讲解，这一讲我们来说下SDRAM的初始化流程跟HAL库的SDRAM函数使用

【STM32】HAL库 STM32CubeMX教程十五—FMC-SDRAM(一)

所用工具：

1、芯片： STM32H743II

2、STM32CubeMx软件V6.4.0

3、IDE： MDK-Keil5软件

4、STM3H7xxHAL库

5、W9825G6KH

知识概括：

通过本篇博客您将学到：

SDRAM+FMC的基本原理

STM32CubeMX创建FMC-SDRAM例程

HAL库FMC函数库

SDRAM初始化

SDRAM的初始化，是由其内部的一个加载模式寄存控制的，该寄存器框图如下:

在这里插入图片描述

A0~A2: Burst Length，即突发长度（简称 BL） 也就是在同一行中相邻的存储单元连续传输多少数据
A3: Addressing Mode 突发访问的模式,Sequential（顺序）或 Interleave（间隔）我们读数据都是连续读，一般不需要跳着读，所以用顺序模式
A4~A6: CAS Latency，即列地址选通延迟（简称 CL）在发出读命令 (命令同时包含列地址) 后，需要等待几个时钟周期数据线 Data才会输出有效数据
A7~A8: SDRAM 的工作模式。当它被配置为“00”的时候表示工作在正常模式，其它值是测试模式或被保留的设定。实际使用时必须配置成正常模式。
A9: Write Mode，：设置写操作的模式，可以选择突发模式或者单次写入模式

SDRAM指令

我们把SDRAM的信号线和控制指令再写一下

在这里插入图片描述
我们列一些常用的控制指令

还有上一节的CubeMX配置：

然后我们再来下面那些参数的配置：

Load mode register to active delay ：tRSC 加载模式寄存器命令与行有效或刷新命令之间的延迟
Exit self-refresh delay：tXSR 退出自我刷新到行有效命令之间的延迟
Self-refresh time ： tRAS 自刷新周期
SDRAM common row cycle delay : tRC 刷新命令和激活命令之间的延迟
Write recovery time ： tWR 写命令和预充电命令之间的延迟
SDRAM common row precharge delay： tRP 义预充电命令与其它命令之间的延迟
Row to column delay tRCD 定义行有效命令与读/写命令之间的延迟

我们查看《W9825G6KH》数据手册，即可看到对应的参数：
在这里插入图片描述

在CubeMX中点击对应参数，下面会出来对应的介绍：
在这里插入图片描述
这些参数在手册里都有详细的说明，我们看MIN最小时间就好

以tXSR，举个例子我们SDRAM时钟为HCLK 2分频得到，为100MHZ 那么时钟周期就是 T=1/F =1/100MHz=10ns纳秒那么tXSR最少为72ns，也就是最小要延迟8个时钟周期所以我们设置为8

tRSC，最小为两个时钟周期tCK 所以我们设置为2

SDRAM初始化流程

SDRAM 上电后，必须进行初始化，才可以正常使用。

我们来看下SDRAM的初始化流程
在这里插入图片描述

给 SDRAM 上电，并提供稳定的时钟，延时100-200us；
发送“空操作”(NOP) 预充电命令，给所有 Bank 预充电；
发送“预充电”(PRECHARGE) 命令，控制所有 Bank 进行预充电，并等待 tRC 时间，tRC 表
示预充电与其它命令之间的延迟；
发送至少 2 次 “自动刷新”(AUTO REFRESH) 命令，，每一个自刷新命令之间的间隔时间为 tRC
发送“加载模式寄存器”(LOAD MODE REGISTER) 命令，配置 SDRAM 的工作参数，并等
待 tRSC 时间， tRSC 表示加载模式寄存器命令与行有行或刷新命令之间的延迟；
初始化流程完毕，可以开始读写数据

tRC、tRFC、tRSC 这些参数在上一节已经介绍了

SDRAM读操作

在这里插入图片描述

发送“行有效”(ACTIVE) 命令，发送命令的同时包含行地址和 Bank 地址，然后等待 tRCD
时间，tRCD 表示行有效命令与读/写命令之间的延迟；
发送“读”(READ) 命令，在发送命令的同时发送列地址，完成对 SDRAM的寻址。

对于读操作还有一个 CL 延迟（CAS Latency），根据模式寄存器的 CL 定义，延迟 CL 个时钟周期后，SDRAM 的数据线 DQ才输出有效数据，所以需要等待给定的 CL 延迟（2 个或 3 个
CLK）后，再从 DQ 数据线上读取数据。

读/写命令都通过拉高 A10 地址线，控制自动预充电，执行“预充电”(auto precharge) 命令后，需要等待 tRP 时间，tRP 表示预充电与其它命令之间
的延迟；
图中的标号处的 tRAS，表示自刷新周期，即在前一个“行有效”与“预充电”命令之间的时
间；
发送第二次“行有效”(ACTIVE) 命令准备读写下一个数据，在图中的标号处的 tRC，表示
两个行有效命令或两个刷新命令之间的延迟。

SDRAM写操作

在这里插入图片描述

发送“行有效”(ACTIVE) 命令，发送命令的同时包含行地址和 Bank 地址，然后等待 tRCD
时间，tRCD 表示行有效命令与读/写命令之间的延迟；
发送“写”(WRITE) 命令，在发送命令的同时发送列地址，完成寻址的地址输入。写命令是没有 CL 延迟的，主机在发送写命令的同时就可以把要写入的数据用 DQ 输入到 SDRAM 中，这是读命令与写命令的时序最主要的区别。

图中的读/写命令都通过地址线 A10 控制自动预充电，而 SDRAM 接收到带预充电要求的读/写命令后，并不会立即预充电，而是等待 tWR 时间才开始，tWR 表示写命令与预充电之间的延迟；

读/写命令都通过拉高 A10 地址线，控制自动预充电，执行“预充电”(auto precharge) 命令后，需要等待 tRP 时间，tRP 表示预充电与其它命令之间的延迟；
图中的标号处的 tRAS，表示自刷新周期，即在前一个“行有效”与“预充电”命令之间的时
间；
发送第二次“行有效”(ACTIVE) 命令准备读写下一个数据，在图中的标号处的 tRC，表示
两个行有效命令或两个刷新命令之间的延迟。

关于上面的初始化操作和读写顺序请仔细阅读，在上一节我们已经建好了工程，那么现在就来看下FMC SDRAM的Hal库函数吧

首先我们来看下SDRAM的初始化
在这里插入图片描述

首先我们看下三个初始化函数：

 FMC_SDRAM_Init(FMC_SDRAM_TypeDef *Device,FMC_SDRAM_InitTypeDef *Init);

设置 SDRAM 的相关控制参数，比如地址线宽度、CAS 延迟、SDRAM 时钟等对应上图的上半部

 FMC_SDRAM_Timing_Init(FMC_SDRAM_TypeDef *Device,FMC_SDRAM_TimingTypeDef *Timing, uint32_t Bank);

SDRAM 时间相关参数，比如自刷新时间、恢复延迟、预充电延迟等，对应上图的下半部
‘
最后的初始化函数是：HAL_SDRAM_Init，把上面两个函数合到一起，我们来看下这两个结构体参数：

HAL_SDRAM_Init(SDRAM_HandleTypeDef *hsdram,FMC_SDRAM_TimingTypeDef *Timing);

参数:

*hsdram: 设置 SDRAM 的相关控制参数
*Timing ：SDRAM 时间相关参数

调用了两个结构体，对应我们CubeMx初始化的上下两个部分。

FMC_SDRAM_InitTypeDef结构体：

/* @brief FMC SDRAM 初始化结构体类型定义 */
typedef struct
{
uint32_t Bank; /* 选择 FMC 的 SDRAM 存储区域 */
uint32_t ColumnBitsNumber; /* 定义 SDRAM 的列地址宽度 */
uint32_t RowBitsNumber; /* 定义 SDRAM 的行地址宽度 */
uint32_t MemoryDataWidth; /* 定义 SDRAM 的数据宽度 */
uint32_t InternalBankNumber; /* 定义 SDRAM 内部的 Bank 数目 */
uint32_t CASLatency; /* 定义 CASLatency 的时钟个数 */
uint32_t WriteProtection; /* 定义是否使能写保护模式 */
uint32_t SDClockPeriod; /* 配置同步时钟 SDCLK 的参数 */
uint32_t ReadBurst; /* 是否使能突发读模式 */
uint32_t ReadPipeDelay; /* 定义在 CAS 个延迟后再等待多
少个 HCLK 时钟才读取数据 */
} FMC_SDRAM_InitTypeDef;

FMC_SDRAM_TimingTypeDef结构体：

/* @brief 控制 SDRAM 的时序参数，这些参数的单位都是“周期”
* 各个参数的值可设置为 1-16 个周期。 */
typedef struct
{
uint32_t LoadToActiveDelay; /*TMRD: 加载模式寄存器命令后的延迟 */
uint32_t ExitSelfRefreshDelay; /*TXSR: 自刷新命令后的延迟 */
uint32_t SelfRefreshTime; /*TRAS: 自刷新时间 */
uint32_t RowCycleDelay; /*TRC: 行循环延迟 */
uint32_t WriteRecoveryTime; /*TWR: 恢复延迟 */
uint32_t RPDelay; /*TRP: 行预充电延迟 */
uint32_t RCDDelay; /*TRCD: 行到列延迟 */
} FMC_SDRAM_TimingTypeDef

关于FMC IO口的一些初始化在

 HAL_FMC_MspInit();

函数里面，感兴趣的可自行查看，这里我们不做过多描述

在看完了初始化之后，我们来看下FMC关于SDRAM有哪些函数

注意，在HAL库里面有stm32h7xx_ll_fmc.c， stm32h7xx_hal_sdram.c，stm32h7xx_hal_dram.c等等文件，其中stm32h7xx_ll_fmc.c是关于FMC的一些函数及初始化，因为FMC支持很多存储器，所以有很多内容，我们这里用的是SDRAM，所以只看SDRAM的函数，也就是只看stm32h7xx_hal_sdram.c跟stm32h7xx_ll_fmc.c这两个文件

基本上SDRAM.C里的函数都是调用fmc.c中的

初始化函数：

首先是四个初始化函数，这几个函数在上面都介绍过了HAL_SDRAM_MspInit调用的是 HAL_FMC_MspInit(); 也就是硬件IO跟时钟初始化。

HAL_StatusTypeDef HAL_SDRAM_Init(SDRAM_HandleTypeDef *hsdram, FMC_SDRAM_TimingTypeDef *Timing);
HAL_StatusTypeDef HAL_SDRAM_DeInit(SDRAM_HandleTypeDef *hsdram);
void HAL_SDRAM_MspInit(SDRAM_HandleTypeDef *hsdram);
void HAL_SDRAM_MspDeInit(SDRAM_HandleTypeDef *hsdram);

SDRAM中断函数

void HAL_SDRAM_IRQHandler(SDRAM_HandleTypeDef *hsdram);

SDRAM自刷新错误回调函数：

void HAL_SDRAM_RefreshErrorCallback(SDRAM_HandleTypeDef *hsdram);

SDRAM DMA函数：

void HAL_SDRAM_DMA_XferCpltCallback(MDMA_HandleTypeDef *hmdma);
void HAL_SDRAM_DMA_XferErrorCallback(MDMA_HandleTypeDef *hmdma);

这些函数我们基本用不到，有个了解即可

SDRAM控制函数

HAL_StatusTypeDef HAL_SDRAM_WriteProtection_Enable(SDRAM_HandleTypeDef *hsdram);

参数:

*hsdram: 选择是那个sdram，比如&hsdram1，&hsdram2

功能：SDRAM写保护使能，使能写保护之后就不能往SDRAM中写数据了，只能读数据

 HAL_SDRAM_WriteProtection_Disable(SDRAM_HandleTypeDef *hsdram);

参数:

*hsdram: 选择是那个sdram，比如&hsdram1，&hsdram2

功能：SDRAM写保护关闭，关闭写保护

HAL_SDRAM_SendCommand(SDRAM_HandleTypeDef *hsdram, FMC_SDRAM_CommandTypeDef *Command,
 uint32_t Timeout);

参数:

*hsdram: 选择是那个sdram，比如&hsdram1，&hsdram2
*Command SDRAM命令的结构体函数，下面对这个结构体做了介绍
Timeout ：超时时间，就是执行函数最长的时间，超过该时间自动退出函数

FMC_SDRAM_CommandTypeDef 结构体，SDRAM命令设置，参数如下

typedef struct
{
 uint32_t CommandMode; //命令类型 
 uint32_t CommandTarget; //目标 SDRAM 存储区域 
 uint32_t AutoRefreshNumber; //自刷新次数
 uint32_t ModeRegisterDefinition; // SDRAM 模式寄存器的内容
}FMC_SDRAM_CommandTypeDef

CommandMode 用来设置命令类型，可用命令类型如下：

/** @defgroup FMC_SDRAM_Command_Mode FMC SDRAM Command Mode
  * @{
  */
#define FMC_SDRAM_CMD_NORMAL_MODE               (0x00000000U)
#define FMC_SDRAM_CMD_CLK_ENABLE                (0x00000001U)
#define FMC_SDRAM_CMD_PALL                      (0x00000002U)
#define FMC_SDRAM_CMD_AUTOREFRESH_MODE          (0x00000003U)
#define FMC_SDRAM_CMD_LOAD_MODE                 (0x00000004U)
#define FMC_SDRAM_CMD_SELFREFRESH_MODE          (0x00000005U)
#define FMC_SDRAM_CMD_POWERDOWN_MODE            (0x00000006U)

在这里插入图片描述

CommandTarget 设置目标 SDRAM 存储区域，因为FMC可以外挂 2 个SDRAM ，发送命令的时候，需要指定命令发送给哪个存储器

/** @defgroup FMC_SDRAM_Command_Target FMC SDRAM Command Target
  * @{
  */
#define FMC_SDRAM_CMD_TARGET_BANK2              FMC_SDCMR_CTB2
#define FMC_SDRAM_CMD_TARGET_BANK1              FMC_SDCMR_CTB1
#define FMC_SDRAM_CMD_TARGET_BANK1_2            (0x00000018U)

AutoRefreshNumber 自刷新次数，我们知道SDRAM每次初始化的时候都需要多次自刷新，

需要CommandMode 被配置为 FMC_SDRAM_CMD_AUTOREFRESH_MODE 自刷新命令时才有效

可输入参数值为 1-16

ModeRegisterDefinition 用来设置 SDRAM 模式寄存器，这个成员值长度为 13 位，各个位一一对应 SDRAM 的模式寄存器

我们自己添加以下下面的宏定义就好

/**
* @brief FMC SDRAM 模式配置的寄存器相关定义
*/
//突发长度设置
#define SDRAM_MODEREG_BURST_LENGTH_1 ((uint16_t)0x0000)
#define SDRAM_MODEREG_BURST_LENGTH_2 ((uint16_t)0x0001)
#define SDRAM_MODEREG_BURST_LENGTH_4 ((uint16_t)0x0002)
#define SDRAM_MODEREG_BURST_LENGTH_8 ((uint16_t)0x0004)
// 连续还是间隔模式
#define SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL ((uint16_t)0x0000)
#define SDRAM_MODEREG_BURST_TYPE_INTERLEAVED ((uint16_t)0x0008)
// CL等待几个时钟周期
#define SDRAM_MODEREG_CAS_LATENCY_2 ((uint16_t)0x0020)
#define SDRAM_MODEREG_CAS_LATENCY_3 ((uint16_t)0x0030)
//正常模式
#define SDRAM_MODEREG_OPERATING_MODE_STANDARD ((uint16_t)0x0000)
//设置写操作的模式，可以选择突发模式或者单次写入模式*
#define SDRAM_MODEREG_WRITEBURST_MODE_PROGRAMMED ((uint16_t)0x0000)
#define SDRAM_MODEREG_WRITEBURST_MODE_SINGLE ((uint16_t)0x0200)

这些宏是根据“SDRAM 的模式寄存器”的位定义的，例如突发长度、突发模式、CL 长度、SDRAM
工作模式以及突发写模式

功能：设置SDRAM刷新频率

 HAL_SDRAM_ProgramRefreshRate(SDRAM_HandleTypeDef *hsdram, uint32_t RefreshRate);

参数:

*hsdram: 选择是那个sdram，比如&hsdram1，&hsdram2
*RefreshRate：自动刷新周期

SDRAM的自动刷新，在上一节我们也提到了

“自动刷新”，SDRAM 内部有一个行地址生成器（也称刷新计数器）用来自动地依次生成
行地址，每收到一次命令刷新一行。在刷新过程中，所有 Bank 都停止工作，而每次刷新所占用
的时间为 N 个时钟周期 (视 SDRAM 型号而定，通常为 N=9)，刷新结束之后才可进入正常的工
作状态，也就是说在这 N 个时钟期间内，所有工作指令只能等待而无法执行。一次次地按行刷
新，刷新完所有行后，将再次对第一行重新进行刷新操作，刷新所有行一遍所需要的时间，
称为 SDRAM 的刷新周期，通常为 64ms。

这个函数会向刷新定时寄存器 FMC_SDRTR 写入计数值，这个计数值每个 SDCLK周期自动减 1，减至 0 时 FMC 会自动向 SDRAM 发出自动刷新命令，控制 SDRAM 刷新，SDRAM每次收到刷新命令后，刷新一行，对同一行进行刷新操作的时间间隔称为 SDRAM 的刷新周期。

计算公式为：

刷新速率=（COUNT+1）*SDRAM 频率时钟

刷新速率=(SDRAM 刷新周期/行数)

(COUNT+1)=刷新速率/SDRAM 频率时钟

但是实际的COUNT计数值需要减少20个SDRAM时钟周期，最终公式如下：

COUNT = (SDRAM 刷新周期/行数)/SDRAM 时钟频率 – 20

以 W9825G6KH 为例讲解计算过程，W9825G6KH 的SDRAM刷新周期为 64ms，行数为 8192行，则每行的刷新速率为：

刷新速率=64ms/8192=7.813us

即每隔 7.813us 需要收到一次自动刷新命令

而 SDRAM 时钟频率=200Mhz/2=100Mhz（10ns）

COUNT 的值为：

COUNT=(7.81us/10ns)-20≈761

这里正点原子跟野火给的公式都是错的，看他们的📕的时候请务必注意，两家不知道谁炒谁，错的一模一样

 HAL_SDRAM_GetModeStatus(SDRAM_HandleTypeDef *hsdram);

功能：获取SDRAM的状态返回SET表示SDRAM空闲，RESET表示SDRAM忙
参数:

*hsdram: 选择是那个sdram，比如&hsdram1，&hsdram2

函数说完了，下面我们就是要写代码了，那么具体的流程

完成SDRAM FMC初始化 (CubeMX已经配置好)
完成SDRAM芯片初始化
SDRAM读函数
SDRAM写函数

我们首先来看第二步：

先定义三个宏定义：

static FMC_SDRAM_CommandTypeDef Command;   //定义SDRAM命令结构体
#define sdramHandle hsdram1  
#define SDRAM_TIMEOUT                    ((uint32_t)0xFFFF)  //定义超时时间

然后再fmc.h中添加加载模式寄存器的宏定义命令：

/**
  * @brief  FMC SDRAM 模式配置的寄存器相关定义
  */
#define SDRAM_MODEREG_BURST_LENGTH_1             ((uint16_t)0x0000)
#define SDRAM_MODEREG_BURST_LENGTH_2             ((uint16_t)0x0001)
#define SDRAM_MODEREG_BURST_LENGTH_4             ((uint16_t)0x0002)
#define SDRAM_MODEREG_BURST_LENGTH_8             ((uint16_t)0x0004)
#define SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL      ((uint16_t)0x0000)
#define SDRAM_MODEREG_BURST_TYPE_INTERLEAVED     ((uint16_t)0x0008)
#define SDRAM_MODEREG_CAS_LATENCY_2              ((uint16_t)0x0020)
#define SDRAM_MODEREG_CAS_LATENCY_3              ((uint16_t)0x0030)
#define SDRAM_MODEREG_OPERATING_MODE_STANDARD    ((uint16_t)0x0000)
#define SDRAM_MODEREG_WRITEBURST_MODE_PROGRAMMED ((uint16_t)0x0000) 
#define SDRAM_MODEREG_WRITEBURST_MODE_SINGLE     ((uint16_t)0x0200)

然后添加SDRAM的初始化函数：

/*
 ******************************************************************************************************
 * 函 数 名: SDRAM 初始化序列
 * 功能说明: 完成 SDRAM 序列初始化
 * 形 参: hsdram: SDRAM 句柄
 * Command: 命令结构体指针
 * 返 回 值: None
 ******************************************************************************************************
 *//**
  * @brief  对SDRAM芯片进行初始化配置
  * @param  None. 
  * @retval None.
  */
static void SDRAM_InitSequence(void)
{
	uint32_t tmpr = 0;

	/* Step 1 ----------------------------------------------------------------*/
	/* 配置命令：开启提供给SDRAM的时钟 */
	Command.CommandMode = FMC_SDRAM_CMD_CLK_ENABLE; //时钟配置使能
	Command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;     //目标SDRAM存储区域
	Command.AutoRefreshNumber = 1;
	Command.ModeRegisterDefinition = 0;
	/* 发送配置命令 */
	HAL_SDRAM_SendCommand(&sdramHandle, &Command, SDRAM_TIMEOUT);

	/* Step 2: 延时100us */ 
	
	HAL_Delay(1);
	
	/* Step 3 ----------------------------------------------------------------*/
	/* 配置命令：对所有的bank预充电 */ 
	Command.CommandMode = FMC_SDRAM_CMD_PALL;    //预充电命令
	Command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;    //目标SDRAM存储区域
	Command.AutoRefreshNumber = 1;
	Command.ModeRegisterDefinition = 0;
	/* 发送配置命令 */
	HAL_SDRAM_SendCommand(&sdramHandle, &Command, SDRAM_TIMEOUT);   

	/* Step 4 ----------------------------------------------------------------*/
	/* 配置命令：自动刷新 */   
	Command.CommandMode = FMC_SDRAM_CMD_AUTOREFRESH_MODE;  //自动刷新命令
	Command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;
	Command.AutoRefreshNumber = 4;  //设置自刷新次数 
	Command.ModeRegisterDefinition = 0;  
	/* 发送配置命令 */
	HAL_SDRAM_SendCommand(&sdramHandle, &Command, SDRAM_TIMEOUT);

	/* Step 5 ----------------------------------------------------------------*/
	/* 设置sdram寄存器配置 */
	tmpr = (uint32_t)SDRAM_MODEREG_BURST_LENGTH_1          |  //设置突发长度:1(可以是1/2/4/8)
				   SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL   |  //设置突发类型:连续(可以是连续/间隔)
				   SDRAM_MODEREG_CAS_LATENCY_2           |   //设置CAS值:3(可以是2/3)
				   SDRAM_MODEREG_OPERATING_MODE_STANDARD |   //设置操作模式:0,标准模式
				   SDRAM_MODEREG_WRITEBURST_MODE_SINGLE;    //设置突发写模式:1,单点访问

	/* 配置命令：设置SDRAM寄存器 */
	Command.CommandMode = FMC_SDRAM_CMD_LOAD_MODE;  //加载模式寄存器命令
	Command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;
	Command.AutoRefreshNumber = 1;
	Command.ModeRegisterDefinition = tmpr;
	/* 发送配置命令 */
	HAL_SDRAM_SendCommand(&sdramHandle, &Command, SDRAM_TIMEOUT);

	/* Step 6 ----------------------------------------------------------------*/

	/* 设置自刷新速率 */
	
	    //刷新频率计数器(以SDCLK频率计数),计算方法:
	//COUNT=SDRAM刷新周期/行数-20=SDRAM刷新周期(us)*SDCLK频率(Mhz)/行数
    //我们使用的SDRAM刷新周期为64ms,SDCLK=200/2=100Mhz,行数为8192(2^13).
	//所以,COUNT=64*1000*100/8192-20=761
	HAL_SDRAM_ProgramRefreshRate(&sdramHandle, 761); 
}

然后在fmc.h中添加SDRAM的基地址：

/**
  * @brief  FMC SDRAM 数据基地址
  */   
#define SDRAM_BANK_ADDR     ((uint32_t)0xC0000000)

然后我们使能下串口：

就直接配置为异步模式，然后IO口复用成PA9跟PA10
在这里插入图片描述
在USART.C里面添加

#include<stdio.h>


//#pragma import(__use_no_semihosting)             
//标准库需要的支持函数                 
struct __FILE 
{ 
	int handle; 
}; 

FILE __stdout;       
//定义_sys_exit()以避免使用半主机模式    
void _sys_exit(int x) 
{ 
	x = x; 
} 
//重定义fputc函数 
int fputc(int ch, FILE *f)
{ 	
	while((USART1->ISR&0X40)==0);//循环发送,直到发送完毕   
	USART1->TDR=(uint8_t)ch;      
	return ch;
}

可以在FMC.C中添加SDRAM读写函数：

SDRAM写函数：


/**
  * @brief  向sdram写入数据 ，在指定地址(WriteAddr+Bank5_SDRAM_ADDR)开始,连续写入n个字节
  * @param  pBuffer: 指向数据的指针 
  * @param  WriteAddr: 要写入的SDRAM内部地址
  * @param  n:要写入的字节数
  * @retval None.
  */

void FMC_SDRAM_WriteBuffer(uint8_t *pBuffer,uint32_t WriteAddr,uint32_t n)
{

  /* 检查SDRAM标志，等待至SDRAM空闲 */  
  while ( HAL_SDRAM_GetState(&hsdram1) != RESET)
  {
  }
	for(;n!=0;n--)
	{
		*(__IO uint8_t*)(SDRAM_BANK_ADDR+WriteAddr)=*pBuffer;
		WriteAddr++;
		pBuffer++;
	}
}

SDRAM读函数：

/**
  * @brief  从sdram读数据 ，在指定地址((WriteAddr+Bank5_SDRAM_ADDR))开始,连续读出n个字节.
  * @param  pBuffer: 指向数据的指针 
  * @param  ReadAddr: 要读出的起始地址
  * @param  n:要读出的字节数
  * @retval None.
  */
void FMC_SDRAM_ReadBuffer(uint8_t *pBuffer,uint32_t ReadAddr,uint32_t n)
{

  /* 检查SDRAM标志，等待至SDRAM空闲 */  
  while ( HAL_SDRAM_GetState(&hsdram1) != RESET)
  {
  }
	for(;n!=0;n--)
	{
		*pBuffer++=*(__IO uint8_t*)(SDRAM_BANK_ADDR+ReadAddr);
		ReadAddr++;
	}
}

例程测试

在main.c中主函数外添加宏定义：

uint16_t testsram[250000] __attribute__((at(0XC0000000)));//测试用数组

添加SDRAM测试函数：


//SDRAM内存测试	    
void fsmc_sdram_test()
{  
	__IO uint32_t i=0;  	  
	__IO uint32_t temp=0;	   
	__IO uint32_t sval=0;	//在地址0读到的数据	  				   
  
	//每隔16K字节,写入一个数据,总共写入2048个数据,刚好是32M字节
	for(i=0;i<32*1024*1024;i+=16*1024)
	{
		*(__IO uint32_t*)(SDRAM_BANK_ADDR+i)=temp; 
		temp++;
	}
	//依次读出之前写入的数据,进行校验		  
 	for(i=0;i<32*1024*1024;i+=16*1024) 
	{	
  		temp=*(__IO uint32_t*)(SDRAM_BANK_ADDR+i);
		if(i==0)sval=temp;
 		else if(temp<=sval)break;//后面读出的数据一定要比第一次读到的数据大.	   		   
		printf("SDRAM Capacity:%dKB\r\n",(uint16_t)(temp-sval+1)*16);//打印SDRAM容量
 	}					 
}

在main主函数里添加：

  	uint32_t ts=0; 
    for(ts=0;ts<250000;ts++)
	{
		testsram[ts]=ts;//预存测试数据	 
  	}
    HAL_Delay(2000);
	fsmc_sdram_test();
	HAL_Delay(2000);
	
		for(ts=0;ts<250000;ts++)
	{
		printf("testsram[%d]:%d\r\n",ts,testsram[ts]);  //打印SDRAM数据
	}


	while(1)
	{

	}

打开串口，然后查看测试数据：
在这里插入图片描述
下载地址：
链接：https://pan.baidu.com/s/1A8pY0Oz7Bba15CfPPD8fMQ
提取：zzzz

请添加图片描述

Z小旋

关注

38
点赞
踩
97

收藏

觉得还不错? 一键收藏
打赏
8
评论
【STM32】HAL库 STM32CubeMX教程十五---FMC-SDRAM(二)

前言：本系列教程将HAL库与STM32CubeMX结合在一起讲解，使您可以更快速的学会各个模块的使用上一讲我们说了CubeMX配置SDRAM的一些基本配置，还有FMC跟SDRAM的讲解，这一讲我们来说下SDRAM的初始化流程跟HAL库的SDRAM函数使用所用工具：1、芯片： STM32H743II2、STM32CubeMx软件V6.4.03、IDE： MDK-Keil5软件4、STM3H7xxHAL库5、W9825G6KH知识概括：通过本篇博客您将学到：SDRAM+FMC的基本
复制链接

扫一扫