STM32H750驱动SDRAM-W9825G6KH芯片

于 2024-09-06 17:13:16 发布
阅读量1.4k 收藏 26
点赞数 30
分类专栏： STM32系列 文章标签： stm32 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c2001102/article/details/141963049
版权

STM32H7X系列笔记

STM32H750X驱动SDRAM

本文介绍了W9825G6KH芯片一些参数的计算方法，可对照自己的开发板进行配置，计算方法都是一样的

查看SDRAM芯片型号，，野火系列开发板H750X核心板板载两片SDRAM芯片，目前使用的是W9825G6KH

查看STM32芯片型号，分别是V版还是Y版，为了方便，设置主频率为400MHz

  • V版：最高480MHz
  • Y版：最高400MHz

在这里插入图片描述
在这里插入图片描述

配置时钟，PLL2R2时钟设置为240MHz，为SDRAM芯片提供时钟。

  • 时钟选择为外部时钟

在这里插入图片描述

配置SDRAM 参数

在这里插入图片描述

参数配置如下：

  • Clock and chip enable：

查看核心板原理图

在这里插入图片描述

SDRAM芯片CKE引脚连接开发板PH7引脚，查看STM32参考手册

在这里插入图片描述

可以看到PH7对应的是FMC_SDCKE1。

  • Internal bank number：W9825G6KH是有4个BANK，13位地址线，具体看芯片数据手册。

  • Data：数据总线，W9825G6KH是16位，但是野火H750X核心板板载了两片，所以选择32bits

  • Byte enable：这个可以先不管，暂时用不上

配置SDRAM

在这里插入图片描述
参数配置如下

SDRAM control

  • Bank：默认即可

  • Number of column address bits：列地址位数：9位，查W9825G6KH手册

  • Number of row address bitsCAS latency：行地址位数：13位，查W9825G6KH手册

在这里插入图片描述

  • Write protection：关闭写保护

  • SDRAM common clock：SDRAM时钟是PLL2R时钟提供，在前面设置的240MHz，此选项选择2分频，所以SDRAM时钟频率为120MHz

  • SDRAM common burst read：冲突写，可选择打开

  • SDRAM common read pipe delay：1个时钟周期即可

SDRAM timing in memory clock cycles(时序寄存器配置)

在这里插入图片描述

  • Load mode register to active delay：

在这里插入图片描述
在这里插入图片描述

最小 2 个周期

这两个参数解释其实是一样的，TMRD 和 tRSC 两个意思是一样的，不同的芯片厂商，命名不一样，意思是一样的

  • Exit self-refresh delay：

在这里插入图片描述
在这里插入图片描述

最小 72 ns

计算-- TXSR：SDRAM的时钟周期通过单片机提供的240MHz分频得到120MHz

1/120000000 = 8.3333333 (ns)

W9825G6KH-6经过TRCD一个周期需要15ns

72/8.33333 = 8.64

向上取整得9

  • Self-refresh time：

在这里插入图片描述
在这里插入图片描述

最小 42 ns

计算同上

  • SDRAM common row cycle delay:

在这里插入图片描述
在这里插入图片描述

最小 60 ns

计算同上

  • Write recovery time:

在这里插入图片描述
在这里插入图片描述

这个参数最好是留着最后配置，因为有一些约束条件，例如：

在这里插入图片描述

先把其他参数配置好，然后选择这个配置的时候直接选择最小周期数就行了

在这里插入图片描述

  • SDRAM common row precharge delay:

在这里插入图片描述
在这里插入图片描述

最小 15ns

计算同上

  • Row to column delay:

在这里插入图片描述
在这里插入图片描述

计算-- TRCD：SDRAM的时钟周期通过单片机提供的240MHz分频得到120MHz

1/120000000 = 8.3333333 (ns)

W9825G6KH-6经过TRCD一个周期需要15ns

15/8.33333 = 1.8

向上取整得2

上面完整的表格如下图所示

在这里插入图片描述

具体选择要看W9825G6KH是哪个版本，核心版板载的是 -6 版本的，所以列就选择 -6 这一列去计算

配置好SDRAM基本信息后，需要查看cubemx默认设置的引脚和开发板的引脚是否一样

在这里插入图片描述
在这里插入图片描述

生成代码

fmc.c文件里面的SDRAM初始化，cubemx生成代码里面没有这个，需要加上

uint32_t tmpr = 0;
FMC_SDRAM_CommandTypeDef Command;

SDRAM_HandleTypeDef hsdram2;

// 第一步，给 SDRAM 提供时钟
Command.CommandMode = FMC_SDRAM_CMD_CLK_ENABLE;
Command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK2;
Command.AutoRefreshNumber = 1;
Command.ModeRegisterDefinition = 0;

HAL_SDRAM_SendCommand(&hsdram2, &Command, SDRAM_TIMEOUT);

// 第二步，延迟至少 200 us
HAL_Delay(1); // 延时 1 ms

// 第三步，对所有 Banks 预充电
Command.CommandMode = FMC_SDRAM_CMD_PALL;
Command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK2;
Command.AutoRefreshNumber = 1;
Command.ModeRegisterDefinition = 0;

HAL_SDRAM_SendCommand(&hsdram2, &Command, SDRAM_TIMEOUT);

// 第四步，插入 8 个自动刷新周期
Command.CommandMode = FMC_SDRAM_CMD_AUTOREFRESH_MODE;
Command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK2;
Command.AutoRefreshNumber = 8;
Command.ModeRegisterDefinition = 0;

HAL_SDRAM_SendCommand(&hsdram2, &Command, SDRAM_TIMEOUT);

// 第五步，编程 SDRAM 的加载模式寄存器
tmpr = (uint32_t)SDRAM_MODEREG_BURST_LENGTH_1 |
       SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL |
       SDRAM_MODEREG_CAS_LATENCY_3 |
       SDRAM_MODEREG_OPERATING_MODE_STANDARD |
       SDRAM_MODEREG_WRITEBURST_MODE_SINGLE;

/* 配置命令：设置SDRAM寄存器 */
Command.CommandMode = FMC_SDRAM_CMD_LOAD_MODE;
Command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK2;
Command.AutoRefreshNumber = 1;
Command.ModeRegisterDefinition = tmpr;

HAL_SDRAM_SendCommand(&hsdram2, &Command, SDRAM_TIMEOUT);

// 第六步，配置STM32FMC的 SDRAM 控制器的自动刷新周期
HAL_SDRAM_ProgramRefreshRate(&hsdram2, 918);

讲解一下第六步函数HAL_SDRAM_ProgramRefreshRate(&hsdram2, 918)的第二个参数计算：

官方例子:在这里插入图片描述

计算我们的开发板，先看W9825G6KH芯片手册。

在这里插入图片描述

rows = 2^13 = 8192rows

SDRAM refresh rate = 64ms / 8192rows = 7.81 us

Refresh rate = (7.81 * 120) - 20 = 937.2 - 20 = 917.2 = 918

main.c

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "memorymap.h"
#include "usart.h"
#include "gpio.h"
#include "fmc.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

#include "sdram_rw.h"
#include <stdlib.h>

/* USER CODE END Includes */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);

/**
 * @brief  The application entry point.
 * @retval int
 */
int main(void)
{
	/* MCU Configuration--------------------------------------------------------*/

	/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
	HAL_Init();

	/* Configure the system clock */
	SystemClock_Config();

	/* Initialize all configured peripherals */
	MX_GPIO_Init();
	MX_FMC_Init();
	MX_USART1_UART_Init();
	/* USER CODE BEGIN 2 */

	printf("\r\n Welcome to Cheney's SDRAM  !! \r\n");

	// 在SDRAM地址中写入一个数
	*(uint32_t *)(SDRAM_BANK2_ADDR + 0x0010) = 100;
	// 读取出来
	uint32_t tmp = *(uint32_t *)(SDRAM_BANK2_ADDR + 0x0010);
	// 打印--需配置usart串口
	printf("tmp : %d \r\n", tmp);

	/* USER CODE END 2 */

	/* Infinite loop */
	/* USER CODE BEGIN WHILE */
	while (1)
	{
		/* USER CODE END WHILE */

		/* USER CODE BEGIN 3 */
	}

	/* USER CODE END 3 */
}

/**
 * @brief System Clock Configuration
 * @retval None
 */
void SystemClock_Config(void)
{
	RCC_OscInitTypeDef RCC_OscInitStruct = {0};
	RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

	/** Supply configuration update enable
	 */
	HAL_PWREx_ConfigSupply(PWR_LDO_SUPPLY);

	/** Configure the main internal regulator output voltage
	 */
	__HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

	while (!__HAL_PWR_GET_FLAG(PWR_FLAG_VOSRDY))
	{
	}

	/** Initializes the RCC Oscillators according to the specified parameters
	 * in the RCC_OscInitTypeDef structure.
	 */
	RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
	RCC_OscInitStruct.HSEState = RCC_HSE_ON;
	RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
	RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
	RCC_OscInitStruct.PLL.PLLM = 2;
	RCC_OscInitStruct.PLL.PLLN = 64;
	RCC_OscInitStruct.PLL.PLLP = 2;
	RCC_OscInitStruct.PLL.PLLQ = 4;
	RCC_OscInitStruct.PLL.PLLR = 2;
	RCC_OscInitStruct.PLL.PLLRGE = RCC_PLL1VCIRANGE_3;
	RCC_OscInitStruct.PLL.PLLVCOSEL = RCC_PLL1VCOWIDE;
	RCC_OscInitStruct.PLL.PLLFRACN = 0;
	if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
	{
		Error_Handler();
	}

	/** Initializes the CPU, AHB and APB buses clocks
	 */
	RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2 | RCC_CLOCKTYPE_D3PCLK1 | RCC_CLOCKTYPE_D1PCLK1;
	RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
	RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1;
	RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV2;
	RCC_ClkInitStruct.APB3CLKDivider = RCC_APB3_DIV2;
	RCC_ClkInitStruct.APB1CLKDivider = RCC_APB1_DIV2;
	RCC_ClkInitStruct.APB2CLKDivider = RCC_APB2_DIV2;
	RCC_ClkInitStruct.APB4CLKDivider = RCC_APB4_DIV2;

	if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
	{
		Error_Handler();
	}
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
 * @brief  This function is executed in case of error occurrence.
 * @retval None
 */
void Error_Handler(void)
{
	/* USER CODE BEGIN Error_Handler_Debug */
	/* User can add his own implementation to report the HAL error return state */
	__disable_irq();
	while (1)
	{
	}
	/* USER CODE END Error_Handler_Debug */
}

#ifdef USE_FULL_ASSERT
/**
 * @brief  Reports the name of the source file and the source line number
 *         where the assert_param error has occurred.
 * @param  file: pointer to the source file name
 * @param  line: assert_param error line source number
 * @retval None
 */
void assert_failed(uint8_t *file, uint32_t line)
{
	/* USER CODE BEGIN 6 */
	/* User can add his own implementation to report the file name and line number,
	   ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
	/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

fmc.c


/* Includes ------------------------------------------------------------------*/
#include "fmc.h"

/* USER CODE BEGIN 0 */

FMC_SDRAM_CommandTypeDef Command;

/* USER CODE END 0 */

SDRAM_HandleTypeDef hsdram2;

/* FMC initialization function */
void MX_FMC_Init(void)
{
  /* USER CODE BEGIN FMC_Init 0 */

  /* USER CODE END FMC_Init 0 */

  FMC_SDRAM_TimingTypeDef SdramTiming = {0};

  /* USER CODE BEGIN FMC_Init 1 */

  /* USER CODE END FMC_Init 1 */

  /** Perform the SDRAM2 memory initialization sequence
  */
  hsdram2.Instance = FMC_SDRAM_DEVICE;
  /* hsdram2.Init */
  hsdram2.Init.SDBank = FMC_SDRAM_BANK2;
  hsdram2.Init.ColumnBitsNumber = FMC_SDRAM_COLUMN_BITS_NUM_9;
  hsdram2.Init.RowBitsNumber = FMC_SDRAM_ROW_BITS_NUM_13;
  hsdram2.Init.MemoryDataWidth = FMC_SDRAM_MEM_BUS_WIDTH_32;
  hsdram2.Init.InternalBankNumber = FMC_SDRAM_INTERN_BANKS_NUM_4;
  hsdram2.Init.CASLatency = FMC_SDRAM_CAS_LATENCY_3;
  hsdram2.Init.WriteProtection = FMC_SDRAM_WRITE_PROTECTION_DISABLE;
  hsdram2.Init.SDClockPeriod = FMC_SDRAM_CLOCK_PERIOD_2;
  hsdram2.Init.ReadBurst = FMC_SDRAM_RBURST_ENABLE;
  hsdram2.Init.ReadPipeDelay = FMC_SDRAM_RPIPE_DELAY_1;
  /* SdramTiming */
  SdramTiming.LoadToActiveDelay = 2;
  SdramTiming.ExitSelfRefreshDelay = 9;
  SdramTiming.SelfRefreshTime = 6;
  SdramTiming.RowCycleDelay = 8;
  SdramTiming.WriteRecoveryTime = 4;
  SdramTiming.RPDelay = 2;
  SdramTiming.RCDDelay = 2;

  if (HAL_SDRAM_Init(&hsdram2, &SdramTiming) != HAL_OK)
  {
    Error_Handler( );
  }

  /* USER CODE BEGIN FMC_Init 2 */

	uint32_t tmpr = 0;

	// 第一步，给 SDRAM 提供时钟
	Command.CommandMode = FMC_SDRAM_CMD_CLK_ENABLE;
	Command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK2;
	Command.AutoRefreshNumber = 1;
	Command.ModeRegisterDefinition = 0;

	HAL_SDRAM_SendCommand(&hsdram2, &Command, SDRAM_TIMEOUT);

	// 第二步，延迟至少 200 us
	HAL_Delay(1); // 延时 1 ms

	// 第三步，对所有 Banks 预充电
	Command.CommandMode = FMC_SDRAM_CMD_PALL;
	Command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK2;
	Command.AutoRefreshNumber = 1;
	Command.ModeRegisterDefinition = 0;

	HAL_SDRAM_SendCommand(&hsdram2, &Command, SDRAM_TIMEOUT);

	// 第四步，插入 8 个自动刷新周期
	Command.CommandMode = FMC_SDRAM_CMD_AUTOREFRESH_MODE;
	Command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK2;
	Command.AutoRefreshNumber = 8;
	Command.ModeRegisterDefinition = 0;

	HAL_SDRAM_SendCommand(&hsdram2, &Command, SDRAM_TIMEOUT);

	// 第五步，编程 SDRAM 的加载模式寄存器
	tmpr = (uint32_t)SDRAM_MODEREG_BURST_LENGTH_1 |
		   SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL |
		   SDRAM_MODEREG_CAS_LATENCY_3 |
		   SDRAM_MODEREG_OPERATING_MODE_STANDARD |
		   SDRAM_MODEREG_WRITEBURST_MODE_SINGLE;

	/* 配置命令：设置SDRAM寄存器 */
	Command.CommandMode = FMC_SDRAM_CMD_LOAD_MODE;
	Command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK2;
	Command.AutoRefreshNumber = 1;
	Command.ModeRegisterDefinition = tmpr;

	HAL_SDRAM_SendCommand(&hsdram2, &Command, SDRAM_TIMEOUT);

	// 第六步，配置STM32FMC的 SDRAM 控制器的自动刷新周期
	HAL_SDRAM_ProgramRefreshRate(&hsdram2, 918);

  /* USER CODE END FMC_Init 2 */
}

static uint32_t FMC_Initialized = 0;

static void HAL_FMC_MspInit(void){
  /* USER CODE BEGIN FMC_MspInit 0 */

  /* USER CODE END FMC_MspInit 0 */
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if (FMC_Initialized) {
    return;
  }
  FMC_Initialized = 1;
  RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};

  /** Initializes the peripherals clock
  */
    PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_FMC;
    PeriphClkInitStruct.PLL2.PLL2M = 10;
    PeriphClkInitStruct.PLL2.PLL2N = 192;
    PeriphClkInitStruct.PLL2.PLL2P = 2;
    PeriphClkInitStruct.PLL2.PLL2Q = 10;
    PeriphClkInitStruct.PLL2.PLL2R = 2;
    PeriphClkInitStruct.PLL2.PLL2RGE = RCC_PLL2VCIRANGE_1;
    PeriphClkInitStruct.PLL2.PLL2VCOSEL = RCC_PLL2VCOWIDE;
    PeriphClkInitStruct.FmcClockSelection = RCC_FMCCLKSOURCE_PLL2;
    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
    {
      Error_Handler();
    }

  /* Peripheral clock enable */
  __HAL_RCC_FMC_CLK_ENABLE();

  /** FMC GPIO Configuration
  PI6   ------> FMC_D28
  PI5   ------> FMC_NBL3
  PI4   ------> FMC_NBL2
  PI1   ------> FMC_D25
  PI0   ------> FMC_D24
  PI7   ------> FMC_D29
  PE1   ------> FMC_NBL1
  PI2   ------> FMC_D26
  PH15   ------> FMC_D23
  PH14   ------> FMC_D22
  PE0   ------> FMC_NBL0
  PI3   ------> FMC_D27
  PG15   ------> FMC_SDNCAS
  PD0   ------> FMC_D2
  PH13   ------> FMC_D21
  PI9   ------> FMC_D30
  PD1   ------> FMC_D3
  PI10   ------> FMC_D31
  PG8   ------> FMC_SDCLK
  PF2   ------> FMC_A2
  PF1   ------> FMC_A1
  PF0   ------> FMC_A0
  PG5   ------> FMC_BA1
  PF3   ------> FMC_A3
  PG4   ------> FMC_BA0
  PG2   ------> FMC_A12
  PF5   ------> FMC_A5
  PF4   ------> FMC_A4
  PC0   ------> FMC_SDNWE
  PE10   ------> FMC_D7
  PF13   ------> FMC_A7
  PF14   ------> FMC_A8
  PE9   ------> FMC_D6
  PE11   ------> FMC_D8
  PH10   ------> FMC_D18
  PH11   ------> FMC_D19
  PD15   ------> FMC_D1
  PD14   ------> FMC_D0
  PF12   ------> FMC_A6
  PF15   ------> FMC_A9
  PE12   ------> FMC_D9
  PE15   ------> FMC_D12
  PH9   ------> FMC_D17
  PH12   ------> FMC_D20
  PF11   ------> FMC_SDNRAS
  PG0   ------> FMC_A10
  PE8   ------> FMC_D5
  PE13   ------> FMC_D10
  PH6   ------> FMC_SDNE1
  PH8   ------> FMC_D16
  PD10   ------> FMC_D15
  PD9   ------> FMC_D14
  PG1   ------> FMC_A11
  PE7   ------> FMC_D4
  PE14   ------> FMC_D11
  PH7   ------> FMC_SDCKE1
  PD8   ------> FMC_D13
  */
  /* GPIO_InitStruct */
  GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_5|GPIO_PIN_4|GPIO_PIN_1
                          |GPIO_PIN_0|GPIO_PIN_7|GPIO_PIN_2|GPIO_PIN_3
                          |GPIO_PIN_9|GPIO_PIN_10;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF12_FMC;

  HAL_GPIO_Init(GPIOI, &GPIO_InitStruct);

  /* GPIO_InitStruct */
  GPIO_InitStruct.Pin = GPIO_PIN_1|GPIO_PIN_0|GPIO_PIN_10|GPIO_PIN_9
                          |GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_15|GPIO_PIN_8
                          |GPIO_PIN_13|GPIO_PIN_7|GPIO_PIN_14;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF12_FMC;

  HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

  /* GPIO_InitStruct */
  GPIO_InitStruct.Pin = GPIO_PIN_15|GPIO_PIN_14|GPIO_PIN_13|GPIO_PIN_10
                          |GPIO_PIN_11|GPIO_PIN_9|GPIO_PIN_12|GPIO_PIN_6
                          |GPIO_PIN_8|GPIO_PIN_7;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF12_FMC;

  HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);

  /* GPIO_InitStruct */
  GPIO_InitStruct.Pin = GPIO_PIN_15|GPIO_PIN_8|GPIO_PIN_5|GPIO_PIN_4
                          |GPIO_PIN_2|GPIO_PIN_0|GPIO_PIN_1;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF12_FMC;

  HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);

  /* GPIO_InitStruct */
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_15|GPIO_PIN_14
                          |GPIO_PIN_10|GPIO_PIN_9|GPIO_PIN_8;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF12_FMC;

  HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);

  /* GPIO_InitStruct */
  GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_1|GPIO_PIN_0|GPIO_PIN_3
                          |GPIO_PIN_5|GPIO_PIN_4|GPIO_PIN_13|GPIO_PIN_14
                          |GPIO_PIN_12|GPIO_PIN_15|GPIO_PIN_11;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF12_FMC;

  HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

  /* GPIO_InitStruct */
  GPIO_InitStruct.Pin = GPIO_PIN_0;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF12_FMC;

  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /* USER CODE BEGIN FMC_MspInit 1 */

  /* USER CODE END FMC_MspInit 1 */
}

void HAL_SDRAM_MspInit(SDRAM_HandleTypeDef* sdramHandle){
  /* USER CODE BEGIN SDRAM_MspInit 0 */

  /* USER CODE END SDRAM_MspInit 0 */
  HAL_FMC_MspInit();
  /* USER CODE BEGIN SDRAM_MspInit 1 */

  /* USER CODE END SDRAM_MspInit 1 */
}

static uint32_t FMC_DeInitialized = 0;

static void HAL_FMC_MspDeInit(void){
  /* USER CODE BEGIN FMC_MspDeInit 0 */

  /* USER CODE END FMC_MspDeInit 0 */
  if (FMC_DeInitialized) {
    return;
  }
  FMC_DeInitialized = 1;
  /* Peripheral clock enable */
  __HAL_RCC_FMC_CLK_DISABLE();

  /** FMC GPIO Configuration
  PI6   ------> FMC_D28
  PI5   ------> FMC_NBL3
  PI4   ------> FMC_NBL2
  PI1   ------> FMC_D25
  PI0   ------> FMC_D24
  PI7   ------> FMC_D29
  PE1   ------> FMC_NBL1
  PI2   ------> FMC_D26
  PH15   ------> FMC_D23
  PH14   ------> FMC_D22
  PE0   ------> FMC_NBL0
  PI3   ------> FMC_D27
  PG15   ------> FMC_SDNCAS
  PD0   ------> FMC_D2
  PH13   ------> FMC_D21
  PI9   ------> FMC_D30
  PD1   ------> FMC_D3
  PI10   ------> FMC_D31
  PG8   ------> FMC_SDCLK
  PF2   ------> FMC_A2
  PF1   ------> FMC_A1
  PF0   ------> FMC_A0
  PG5   ------> FMC_BA1
  PF3   ------> FMC_A3
  PG4   ------> FMC_BA0
  PG2   ------> FMC_A12
  PF5   ------> FMC_A5
  PF4   ------> FMC_A4
  PC0   ------> FMC_SDNWE
  PE10   ------> FMC_D7
  PF13   ------> FMC_A7
  PF14   ------> FMC_A8
  PE9   ------> FMC_D6
  PE11   ------> FMC_D8
  PH10   ------> FMC_D18
  PH11   ------> FMC_D19
  PD15   ------> FMC_D1
  PD14   ------> FMC_D0
  PF12   ------> FMC_A6
  PF15   ------> FMC_A9
  PE12   ------> FMC_D9
  PE15   ------> FMC_D12
  PH9   ------> FMC_D17
  PH12   ------> FMC_D20
  PF11   ------> FMC_SDNRAS
  PG0   ------> FMC_A10
  PE8   ------> FMC_D5
  PE13   ------> FMC_D10
  PH6   ------> FMC_SDNE1
  PH8   ------> FMC_D16
  PD10   ------> FMC_D15
  PD9   ------> FMC_D14
  PG1   ------> FMC_A11
  PE7   ------> FMC_D4
  PE14   ------> FMC_D11
  PH7   ------> FMC_SDCKE1
  PD8   ------> FMC_D13
  */

  HAL_GPIO_DeInit(GPIOI, GPIO_PIN_6|GPIO_PIN_5|GPIO_PIN_4|GPIO_PIN_1
                          |GPIO_PIN_0|GPIO_PIN_7|GPIO_PIN_2|GPIO_PIN_3
                          |GPIO_PIN_9|GPIO_PIN_10);

  HAL_GPIO_DeInit(GPIOE, GPIO_PIN_1|GPIO_PIN_0|GPIO_PIN_10|GPIO_PIN_9
                          |GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_15|GPIO_PIN_8
                          |GPIO_PIN_13|GPIO_PIN_7|GPIO_PIN_14);

  HAL_GPIO_DeInit(GPIOH, GPIO_PIN_15|GPIO_PIN_14|GPIO_PIN_13|GPIO_PIN_10
                          |GPIO_PIN_11|GPIO_PIN_9|GPIO_PIN_12|GPIO_PIN_6
                          |GPIO_PIN_8|GPIO_PIN_7);

  HAL_GPIO_DeInit(GPIOG, GPIO_PIN_15|GPIO_PIN_8|GPIO_PIN_5|GPIO_PIN_4
                          |GPIO_PIN_2|GPIO_PIN_0|GPIO_PIN_1);

  HAL_GPIO_DeInit(GPIOD, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_15|GPIO_PIN_14
                          |GPIO_PIN_10|GPIO_PIN_9|GPIO_PIN_8);

  HAL_GPIO_DeInit(GPIOF, GPIO_PIN_2|GPIO_PIN_1|GPIO_PIN_0|GPIO_PIN_3
                          |GPIO_PIN_5|GPIO_PIN_4|GPIO_PIN_13|GPIO_PIN_14
                          |GPIO_PIN_12|GPIO_PIN_15|GPIO_PIN_11);

  HAL_GPIO_DeInit(GPIOC, GPIO_PIN_0);

  /* USER CODE BEGIN FMC_MspDeInit 1 */

  /* USER CODE END FMC_MspDeInit 1 */
}

void HAL_SDRAM_MspDeInit(SDRAM_HandleTypeDef* sdramHandle){
  /* USER CODE BEGIN SDRAM_MspDeInit 0 */

  /* USER CODE END SDRAM_MspDeInit 0 */
  HAL_FMC_MspDeInit();
  /* USER CODE BEGIN SDRAM_MspDeInit 1 */

  /* USER CODE END SDRAM_MspDeInit 1 */
}

fmc.h


/* USER CODE END Header */
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __FMC_H
#define __FMC_H
#ifdef __cplusplus
 extern "C" {
#endif

/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* USER CODE BEGIN Includes */

#include <stdio.h>

/* USER CODE END Includes */

extern SDRAM_HandleTypeDef hsdram2;

/* USER CODE BEGIN Private defines */

#define SDRAM_SIZE_64M 0x4000000 // 64M字节,两片W9825G6KH-6,32MB@16bit组成64M@32bit
#define SDRAM_SIZE_32M 0x2000000 // 32M字节,

/**
 * @brief  FMC SDRAM 数据基地址
 */
#define SDRAM_BANK1_ADDR ((uint32_t)0xC0000000)		// BANK1 起始地址
#define SDRAM_BANK2_ADDR ((uint32_t)0xD0000000)		// BANK2 起始地址

/**
 * @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)

#define SDRAM_TIMEOUT ((uint32_t)0xFFFF)

/*信息输出*/
#define SDRAM_DEBUG_ON         1

#define SDRAM_INFO(fmt,arg...)           printf("<<-SDRAM-INFO->> "fmt"\n",##arg)
#define SDRAM_ERROR(fmt,arg...)          printf("<<-SDRAM-ERROR->> "fmt"\n",##arg)
#define SDRAM_DEBUG(fmt,arg...)          do{\
										if(SDRAM_DEBUG_ON)\
										printf("<<-SDRAM-DEBUG->> [%d]"fmt"\n",__LINE__, ##arg);\
										}while(0)


/* USER CODE END Private defines */

void MX_FMC_Init(void);
void HAL_SDRAM_MspInit(SDRAM_HandleTypeDef* hsdram);
void HAL_SDRAM_MspDeInit(SDRAM_HandleTypeDef* hsdram);

/* USER CODE BEGIN Prototypes */

uint8_t SDRAM_Test(void);


/* USER CODE END Prototypes */

#ifdef __cplusplus
}
#endif
#endif /*__FMC_H */

结语

本文没有介绍串口配置，可见其他博主进行配置
芯片手册可找我获取

Cheney,
关注
专栏目录
基于STM32H750的开发板：ARM开发评估、学习和应用
ZzVerilog的博客
09-13 1069
开发板提供了丰富的外设和接口，包括GPIO、UART、SPI、I2C等，使得开发者可以轻松地与其他设备进行通信和控制。本文将介绍STM32H750开发板的特性和用途，并提供一些示例源代码，以帮助读者更好地了解和使用该开发板。外设和接口：开发板支持多种外设和接口，包括通用输入/输出引脚（GPIO）、串行通信接口（UART、SPI、I2C）、模拟输入/输出（ADC、DAC）、定时器等。该微控制器采用ARM Cortex-M7内核，运行频率高达480MHz，具有丰富的外设和接口，适用于广泛的应用领域。
STM32H750.zip
06-04
STM32FH50系列引脚功能定义，需要的下载，跟743系列有区别的，不通用
stm32cubemx读写SDRAM-W9825G6KH
热门推荐
我的blog屋
11-01 1万+
转自：https://blog.csdn.net/mculover666/article/details/108221735 本篇详细的记录了如何使用STM32CubeMX配置 STM32F767IGT6 的硬件FMC外设与 SDRAM 通信（W9825G6KH）。 1. 准备工作 硬件准备 开发板 首先需要准备一个开发板，这里我准备的是STM32F767IGT6的核心板。 SDRAM 核心板板载一片SDRAM，型号为 W9825G6KH，大小为 32 MB。 软件准备 需要准备一份
20.1CubeMx配置FMC控制SDRAM【W9825G6KH-6】
qq_36561846的博客
10-13 2259
CubeMx配置FMC控制SDRAM【W9825G6KH-6】
STM32H750 SDRAM W9825G6KH-6
smallerlang的博客
11-27 3677
SDRAM
SDRAM W9825G6KH
AIoT技术栈的博客
03-16 4822
STM32F429IGT6 自带了 256K 字节的 SRAM，对一般应用来说，已经足够了，不过在一些 对内存要求高的场合， STM32F429 自带的这些内存就不够用了。比如使用 LTDC 驱动 RGB 屏、 跑算法或者跑 GUI 等，就可能不太够用，STM32F429 开发板板载了一颗 32M 字节 容量的 SDRAM 芯片： W9825G6KH，满足大内存使用的需求。 ...
WINBOND/华邦 W9825G6KH-6I SDRAM,256Mb(32MB,16Mbx16),3.3v 动态随机存取存储器
hongyuanniki的博客
03-28 1092
W9825G6KH-6I SDRAM,256Mb(32MB,16Mbx16),3.3v 动态随机存取存储器
STM32H750启动和内存优化（分散加载修改）
最新发布
weixin_38426553的博客
06-09 1604
前些日子有个朋友一直给我推荐这款芯片，说它的性价比，说它多么多么好。于是乎，这两天试了试，嚯，真香！我们先看看基本配置这里简单总结下，cortex-m7内核，128k片内flash ，1M RAM，淘宝价格十几块，瞬间感觉1052没那么香了（价格二十多）。关键这个价格几乎跟imxrt1011差不多了，而1011只有128K RAM，无片内flash，导致做不了很复杂的项目。除此之外h750还能拓展出32bit sdram这点相比1052的16bit性能也进一步加强。
STM32H750驱动SDRAM W9825G6KH读写【支持STM32H7系列单片机_寄存器库驱动】.zip
02-14
在本项目中，我们关注的是如何为STM32H750驱动SDRAM，特别是W9825G6KH型号的SDRAM芯片，以便实现高效的数据存储和处理。 SDRAM（Synchronous Dynamic Random Access Memory），同步动态随机访问内存，是一种高速...
STM32H750实现SDRAM W9825G6KH读写【支持STM32H7系列单片机_HAL库驱动】.zip
02-14
总之，这个项目提供了一个STM32H750与W9825G6KH SDRAM交互的实例，对于学习STM32H7系列的高级用法，特别是外部存储扩展和HAL库的应用，具有很高的参考价值。开发者可以通过研究和理解这些代码，进一步提升自己在...
STM32H750移植rt-thread操作系统完整工程.zip
05-17
在本项目中，我们关注的是如何将rt-thread操作系统移植到STM32H750芯片上，并在正点原子STM32H750开发板上成功运行。 rt-thread是一款开源、实时、嵌入式操作系统，由国内开发者社区开发和维护。它提供了一个轻量级...
stm32h750vbt6电赛自制版PCB文件
09-26
2019年电赛D题自用信号处理单片机，主控芯片为stm32h750vbt6，四路adc以SMA头引出，也可作为两路差分的adc使用，并可以复用为两路dac，带正点原子的TTF屏幕接口，矩阵键盘，预留三路串口（其中一路以usb加ch340g引出），以及12个空引脚。 赠送自用的全套库文件。
STM32H750VBT6.SchLib
05-30
STM32H750VBT6原理图库ALTIUM DESIGNER软件的，分开多个SUB部分，管脚复用功能有标注。
STM32H750VB_ltdcV3.rar
03-01
STM32H750VBT6驱动800*600分辨率的屏，采用L8像素格式 。 ， 。 / 。
stm32h750 IAP_Demo
10-21
STM32H750 iap固件升级工程Demo，设计思路详见我的博客《STM32H750 iap固件升级》，建议看懂了再下载。博客链接：https://blog.csdn.net/qq_43536512/article/details/108809726
STM32H750单片机SDRAM W9825G6KH读写驱动程序开发
资源摘要信息:"STM32H750实现SDRAM W9825G6KH读写【支持STM32H7系列单片机_HAL库驱动】.zip" 知识点一：STM32H750单片机介绍 STM32H750是ST公司（意法半导体）生产的一款高性能ARM Cortex-M7内核的单片机，具备丰富...
STM32H750开发指南-寄存器版本_V1.01.pdf
05-29
STM32H750是意法半导体（STMicroelectronics）推出的一款高性能微控制器，属于STM32H7系列，该系列基于ARM Cortex-M7内核，具备高速运算能力和丰富的外设接口。这款芯片适用于需要高计算能力和低功耗的嵌入式应用，...
STM32H750 480MHZ频率 RAM分配处理 KEIL工程
devicenet的博客
08-19 9881
各位看官都知道 STM32H750超值系列提供128 KB的Flash存储器，具有以下结构的1 MB SRAM：192 KB的TCM RAM（包括64 KB的ITCM RAM和128 KB的DTCM RAM，用于时间关键型程序和数据），高达512 KB的用户SRAM，以及备份域中4 KB的SRAM，其实对于大多数工业控制实际情况，这种配置足可以了，一个实时操作系统+实际控制程序超过128KB的代码都算比较大的系统了，RAM也有128KB的DTCM空间，都足可以了，可以非常舒服的利用480MHZ的主频了，当然
stm32h750开发指南-寄存器版本
07-02
STM32H750开发指南-寄存器版本在STM32H750微控制器的开发中起着重要的作用。该开发指南提供了使用寄存器级编程进行硬件驱动和应用程序开发的相关信息和指令。 寄存器是微控制器内部的特殊存储区域，用于控制和配置硬件功能。STM32H750开发指南-寄存器版本详细描述了每个寄存器的功能和使用方法，帮助开发者了解和掌握STM32H750微控制器的内部结构和工作原理。 该开发指南首先介绍了STM32H750微控制器的基本知识，如内核架构、存储器和外设等。然后，它详细讲解了各种寄存器的功能和用法，包括GPIO、USART、SPI、I2C、ADC和定时器等。开发者可以根据自己的需求选择适当的寄存器进行配置和编程。 此外，开发指南还提供了大量的例程和示例代码，以帮助开发者更好地理解和应用寄存器级编程。开发者可以通过参考这些示例代码，更好地了解和掌握如何编写高效的硬件驱动和应用程序。 总之，STM32H750开发指南-寄存器版本是一本非常有价值的参考书，对于想要深入了解和应用STM32H750微控制器的开发者来说是一本必备之物。通过学习和掌握寄存器级编程，开发者可以更好地利用STM32H750微控制器的强大功能，实现各种应用需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值