STM32F767 SD卡读写DMA

已于 2022-12-01 21:51:42 修改
阅读量420 收藏 5
点赞数
分类专栏： STM32 文章标签： stm32 单片机 arm
于 2022-01-15 13:33:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smallerlang/article/details/122508988
版权 
/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

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

#include "delay.h"
#include "bsp_printf.h"
#include "bsp_key.h"
#include "string.h"
#include "bsp_sdram.h"
#include "bsp_malloc.h"
#include "bsp_sdmmc.h"
#include "ff.h"			/* Obtains integer types */
//#include "bsp_w25qxx.h"
//#include "bsp_ftl.h"
//#include "bsp_nand.h"

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

SD_HandleTypeDef hsd1;
DMA_HandleTypeDef hdma_sdmmc1_rx;
DMA_HandleTypeDef hdma_sdmmc1_tx;

UART_HandleTypeDef huart1;

SDRAM_HandleTypeDef hsdram1;

/* USER CODE BEGIN PV */

volatile uint8_t rx_done, tx_done;

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_FMC_Init(void);
static void MX_DMA_Init(void);
static void MX_SDMMC1_SD_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

static void Sdram_SendCommand(uint32_t CommandMode, uint32_t CommandTarget, uint32_t AutoRefreshNumber, uint32_t ModeRegisterDefinition)
{
	FMC_SDRAM_CommandTypeDef Command;
	
	Command.AutoRefreshNumber = AutoRefreshNumber;
	Command.CommandMode = CommandMode;
	Command.CommandTarget = CommandTarget;
	Command.ModeRegisterDefinition = ModeRegisterDefinition;
	
	HAL_SDRAM_SendCommand(&hsdram1, &Command, 0);
}

static void Sdram_Init_Sequence(void)
{
	uint32_t ModeRegisterDefinition;
	
	Sdram_SendCommand(FMC_SDRAM_CMD_CLK_ENABLE, FMC_SDRAM_CMD_TARGET_BANK1, 1, 0);//时钟配置使能
	
	delay_us(500);//至少延时200us
	
	Sdram_SendCommand(FMC_SDRAM_CMD_PALL, FMC_SDRAM_CMD_TARGET_BANK1, 1, 0);//对所有存储区预充电
	
	Sdram_SendCommand(FMC_SDRAM_CMD_AUTOREFRESH_MODE, FMC_SDRAM_CMD_TARGET_BANK1, 8, 0);//设置自刷新次数 
	
	//
	#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)

	ModeRegisterDefinition=(uint32_t)SDRAM_MODEREG_BURST_LENGTH_1          |	//设置突发长度:1(可以是1/2/4/8)
              SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL   |	//设置突发类型:连续(可以是连续/交错)
              SDRAM_MODEREG_CAS_LATENCY_3           |	//设置CAS值:3(可以是2/3)
              SDRAM_MODEREG_OPERATING_MODE_STANDARD |   //设置操作模式:0,标准模式
              SDRAM_MODEREG_WRITEBURST_MODE_SINGLE;     //设置突发写模式:1,单点访问

	Sdram_SendCommand(FMC_SDRAM_CMD_LOAD_MODE, FMC_SDRAM_CMD_TARGET_BANK1, 1, ModeRegisterDefinition);
	
	HAL_SDRAM_ProgramRefreshRate(&hsdram1, 823);
}

//通过串口打印SD卡相关信息
void show_sdcard_info(void)
{
	HAL_SD_CardCIDTypeDef cid;
	
	switch(hsd1.SdCard.CardVersion)
	{
		case CARD_V1_X:printf("Card Version:CARD_V1_X\r\n");break;
		case CARD_V2_X:printf("Card Version:CARD_V2_X\r\n");break;
		
	}	
	switch(hsd1.SdCard.CardType)
	{
		case CARD_SDSC:printf("Card Type:CARD_SDSC\r\n");break;
		case CARD_SDHC_SDXC:printf("Card Type:CARD_SDHC_SDXC\r\n");break;
		case CARD_SECURED:printf("Card Type:CARD_SECURED\r\n");break;
	}
	
	if(HAL_OK != HAL_SD_GetCardCID(&hsd1, &cid))
	{
		Error_Handler();
	}
	
  printf("Card ManufacturerID:%d\r\n",cid.ManufacturerID);	//制造商ID
 	printf("Card RCA:%d\r\n",hsd1.SdCard.RelCardAdd );								//卡相对地址
	printf("Card Capacity:%d MB\r\n",(uint32_t)(((uint64_t)hsd1.SdCard.BlockNbr*hsd1.SdCard.BlockSize)>>20));	//显示容量
 	printf("Card BlockSize:%d\r\n\r\n",hsd1.SdCard.BlockSize);			//显示块大小
	printf("Card LogBlockNbr:%d\r\n\r\n",hsd1.SdCard.LogBlockNbr);
	printf("Card LogBlockSize:%d\r\n\r\n",hsd1.SdCard.LogBlockSize);
}


/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

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

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

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

  /* USER CODE BEGIN SysInit */
	
  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  MX_FMC_Init();
  MX_DMA_Init();
  MX_SDMMC1_SD_Init();
  /* USER CODE BEGIN 2 */
	
	#define DATA_SIZE 10000
	#define DATA_ADDR 380
	
	delay_init(216);
	delay_ms(5000);
	
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_RESET);
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET);
	
	Sdram_Init_Sequence(); 
	
	uint8_t key;	
	uint8_t *buf;
	uint32_t sd_size;
	uint32_t i;
	
	show_sdcard_info();	//打印SD卡相关信息
  while (1)
  {
		key=KEY_Scan(0);
		if(key==KEY0_PRES)//KEY0按下了
		{
			buf=mymalloc(SRAMIN,512);		//申请内存
			if(SD_ReadDisk(buf,0,1)==0)	//读取0扇区的内容
			{	
				printf("USART1 Sending Data...\r\n");
				printf("SECTOR 0 DATA:\r\n");
				for(sd_size=0;sd_size<512;sd_size++)printf("%x ",buf[sd_size]);//打印0扇区数据    	   
				printf("\r\nDATA ENDED\r\n");
				printf("USART1 Send Data Over!\r\n");
			}
			myfree(SRAMIN,buf);//释放内存	   
		} 
		else if(key==KEY1_PRES)
		{
			buf=mymalloc(SRAMIN,512);		//申请内存
			for(i=0; i<512; i++)
			{
				buf[i] += 6;
			}
			if(0 == SD_WriteDisk(buf,0,1))
			{
				printf("\r\nwrite success!\r\n");
			}	
			else
			{
				printf("\r\nwrite failed!\r\n");
			}
			myfree(SRAMIN,buf);//释放内存	 
		}
		delay_ms(10);
		
  }

	

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
		delay_ms(1000);
		printf("hello world!\r\n");
		
    /* 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};
  RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};

  /** Configure LSE Drive Capability
  */
  HAL_PWR_EnableBkUpAccess();
  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
  /** 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 = 25;
  RCC_OscInitStruct.PLL.PLLN = 432;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 9;
  RCC_OscInitStruct.PLL.PLLR = 2;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Activate the Over-Drive mode
  */
  if (HAL_PWREx_EnableOverDrive() != 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_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_7) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_USART1|RCC_PERIPHCLK_SDMMC1
                              |RCC_PERIPHCLK_CLK48;
  PeriphClkInitStruct.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK2;
  PeriphClkInitStruct.Clk48ClockSelection = RCC_CLK48SOURCE_PLL;
  PeriphClkInitStruct.Sdmmc1ClockSelection = RCC_SDMMC1CLKSOURCE_CLK48;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Enables the Clock Security System
  */
  HAL_RCC_EnableCSS();
}

/**
  * @brief SDMMC1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_SDMMC1_SD_Init(void)
{

  /* USER CODE BEGIN SDMMC1_Init 0 */

  /* USER CODE END SDMMC1_Init 0 */

  /* USER CODE BEGIN SDMMC1_Init 1 */

  /* USER CODE END SDMMC1_Init 1 */
  hsd1.Instance = SDMMC1;
  hsd1.Init.ClockEdge = SDMMC_CLOCK_EDGE_RISING;
  hsd1.Init.ClockBypass = SDMMC_CLOCK_BYPASS_DISABLE;
  hsd1.Init.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE;
  hsd1.Init.BusWide = SDMMC_BUS_WIDE_1B;
  hsd1.Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE;
  hsd1.Init.ClockDiv = 0;
  if (HAL_SD_Init(&hsd1) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_SD_ConfigWideBusOperation(&hsd1, SDMMC_BUS_WIDE_4B) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN SDMMC1_Init 2 */

  /* USER CODE END SDMMC1_Init 2 */

}

/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 115200;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */

  /* USER CODE END USART1_Init 2 */

}

/**
  * Enable DMA controller clock
  */
static void MX_DMA_Init(void)
{

  /* DMA controller clock enable */
  __HAL_RCC_DMA2_CLK_ENABLE();

  /* DMA interrupt init */
  /* DMA2_Stream3_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA2_Stream3_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA2_Stream3_IRQn);
  /* DMA2_Stream6_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn);

}

/* FMC initialization function */
static 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 SDRAM1 memory initialization sequence
  */
  hsdram1.Instance = FMC_SDRAM_DEVICE;
  /* hsdram1.Init */
  hsdram1.Init.SDBank = FMC_SDRAM_BANK1;
  hsdram1.Init.ColumnBitsNumber = FMC_SDRAM_COLUMN_BITS_NUM_9;
  hsdram1.Init.RowBitsNumber = FMC_SDRAM_ROW_BITS_NUM_13;
  hsdram1.Init.MemoryDataWidth = FMC_SDRAM_MEM_BUS_WIDTH_16;
  hsdram1.Init.InternalBankNumber = FMC_SDRAM_INTERN_BANKS_NUM_4;
  hsdram1.Init.CASLatency = FMC_SDRAM_CAS_LATENCY_3;
  hsdram1.Init.WriteProtection = FMC_SDRAM_WRITE_PROTECTION_DISABLE;
  hsdram1.Init.SDClockPeriod = FMC_SDRAM_CLOCK_PERIOD_2;
  hsdram1.Init.ReadBurst = FMC_SDRAM_RBURST_ENABLE;
  hsdram1.Init.ReadPipeDelay = FMC_SDRAM_RPIPE_DELAY_0;
  /* SdramTiming */
  SdramTiming.LoadToActiveDelay = 2;
  SdramTiming.ExitSelfRefreshDelay = 8;
  SdramTiming.SelfRefreshTime = 4;
  SdramTiming.RowCycleDelay = 7;
  SdramTiming.WriteRecoveryTime = 3;
  SdramTiming.RPDelay = 2;
  SdramTiming.RCDDelay = 2;

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

  /* USER CODE BEGIN FMC_Init 2 */

  /* USER CODE END FMC_Init 2 */
}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOF_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOG_CLK_ENABLE();
  __HAL_RCC_GPIOE_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_5, GPIO_PIN_RESET);

  /*Configure GPIO pin : PC13 */
  GPIO_InitStruct.Pin = GPIO_PIN_13;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

  /*Configure GPIO pin : PF7 */
  GPIO_InitStruct.Pin = 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_AF9_QUADSPI;
  HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

  /*Configure GPIO pin : PA0 */
  GPIO_InitStruct.Pin = GPIO_PIN_0;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLDOWN;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pins : PH2 PH3 */
  GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);

  /*Configure GPIO pins : PB0 PB5 */
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_5;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pin : PB1 */
  GPIO_InitStruct.Pin = GPIO_PIN_1;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pin : PB2 */
  GPIO_InitStruct.Pin = GPIO_PIN_2;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF9_QUADSPI;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /*Configure GPIO pin : PB6 */
  GPIO_InitStruct.Pin = GPIO_PIN_6;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF10_QUADSPI;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

}

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

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/


/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    stm32f7xx_it.c
  * @brief   Interrupt Service Routines.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "stm32f7xx_it.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

#include "fifo.h"

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN TD */

/* USER CODE END TD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/* External variables --------------------------------------------------------*/
extern DMA_HandleTypeDef hdma_sdmmc1_rx;
extern DMA_HandleTypeDef hdma_sdmmc1_tx;
extern SD_HandleTypeDef hsd1;
/* USER CODE BEGIN EV */

/* USER CODE END EV */

/******************************************************************************/
/*           Cortex-M7 Processor Interruption and Exception Handlers          */
/******************************************************************************/
/**
  * @brief This function handles Non maskable interrupt.
  */
void NMI_Handler(void)
{
  /* USER CODE BEGIN NonMaskableInt_IRQn 0 */

  /* USER CODE END NonMaskableInt_IRQn 0 */
  HAL_RCC_NMI_IRQHandler();
  /* USER CODE BEGIN NonMaskableInt_IRQn 1 */
  while (1)
  {
  }
  /* USER CODE END NonMaskableInt_IRQn 1 */
}

/**
  * @brief This function handles Hard fault interrupt.
  */
void HardFault_Handler(void)
{
  /* USER CODE BEGIN HardFault_IRQn 0 */

  /* USER CODE END HardFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_HardFault_IRQn 0 */
    /* USER CODE END W1_HardFault_IRQn 0 */
  }
}

/**
  * @brief This function handles Memory management fault.
  */
void MemManage_Handler(void)
{
  /* USER CODE BEGIN MemoryManagement_IRQn 0 */

  /* USER CODE END MemoryManagement_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_MemoryManagement_IRQn 0 */
    /* USER CODE END W1_MemoryManagement_IRQn 0 */
  }
}

/**
  * @brief This function handles Pre-fetch fault, memory access fault.
  */
void BusFault_Handler(void)
{
  /* USER CODE BEGIN BusFault_IRQn 0 */

  /* USER CODE END BusFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_BusFault_IRQn 0 */
    /* USER CODE END W1_BusFault_IRQn 0 */
  }
}

/**
  * @brief This function handles Undefined instruction or illegal state.
  */
void UsageFault_Handler(void)
{
  /* USER CODE BEGIN UsageFault_IRQn 0 */

  /* USER CODE END UsageFault_IRQn 0 */
  while (1)
  {
    /* USER CODE BEGIN W1_UsageFault_IRQn 0 */
    /* USER CODE END W1_UsageFault_IRQn 0 */
  }
}

/**
  * @brief This function handles System service call via SWI instruction.
  */
void SVC_Handler(void)
{
  /* USER CODE BEGIN SVCall_IRQn 0 */

  /* USER CODE END SVCall_IRQn 0 */
  /* USER CODE BEGIN SVCall_IRQn 1 */

  /* USER CODE END SVCall_IRQn 1 */
}

/**
  * @brief This function handles Debug monitor.
  */
void DebugMon_Handler(void)
{
  /* USER CODE BEGIN DebugMonitor_IRQn 0 */

  /* USER CODE END DebugMonitor_IRQn 0 */
  /* USER CODE BEGIN DebugMonitor_IRQn 1 */

  /* USER CODE END DebugMonitor_IRQn 1 */
}

/**
  * @brief This function handles Pendable request for system service.
  */
void PendSV_Handler(void)
{
  /* USER CODE BEGIN PendSV_IRQn 0 */

  /* USER CODE END PendSV_IRQn 0 */
  /* USER CODE BEGIN PendSV_IRQn 1 */

  /* USER CODE END PendSV_IRQn 1 */
}

/**
  * @brief This function handles System tick timer.
  */
void SysTick_Handler(void)
{
  /* USER CODE BEGIN SysTick_IRQn 0 */

  /* USER CODE END SysTick_IRQn 0 */
  HAL_IncTick();
  /* USER CODE BEGIN SysTick_IRQn 1 */

  /* USER CODE END SysTick_IRQn 1 */
}

/******************************************************************************/
/* STM32F7xx Peripheral Interrupt Handlers                                    */
/* Add here the Interrupt Handlers for the used peripherals.                  */
/* For the available peripheral interrupt handler names,                      */
/* please refer to the startup file (startup_stm32f7xx.s).                    */
/******************************************************************************/

/**
  * @brief This function handles SDMMC1 global interrupt.
  */
void SDMMC1_IRQHandler(void)
{
  /* USER CODE BEGIN SDMMC1_IRQn 0 */

  /* USER CODE END SDMMC1_IRQn 0 */
  HAL_SD_IRQHandler(&hsd1);
  /* USER CODE BEGIN SDMMC1_IRQn 1 */

  /* USER CODE END SDMMC1_IRQn 1 */
}

/**
  * @brief This function handles DMA2 stream3 global interrupt.
  */
void DMA2_Stream3_IRQHandler(void)
{
  /* USER CODE BEGIN DMA2_Stream3_IRQn 0 */

  /* USER CODE END DMA2_Stream3_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_sdmmc1_rx);
  /* USER CODE BEGIN DMA2_Stream3_IRQn 1 */

  /* USER CODE END DMA2_Stream3_IRQn 1 */
}

/**
  * @brief This function handles DMA2 stream6 global interrupt.
  */
void DMA2_Stream6_IRQHandler(void)
{
  /* USER CODE BEGIN DMA2_Stream6_IRQn 0 */

  /* USER CODE END DMA2_Stream6_IRQn 0 */
  HAL_DMA_IRQHandler(&hdma_sdmmc1_tx);
  /* USER CODE BEGIN DMA2_Stream6_IRQn 1 */

  /* USER CODE END DMA2_Stream6_IRQn 1 */
}

/* USER CODE BEGIN 1 */

/**
  * @brief Rx Transfer completed callbacks
  * @param hsd: Pointer SD handle
  * @retval None
  */
void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd)
{
	HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_1);
	rx_done = 1;
}

/**
  * @brief Tx Transfer completed callbacks
  * @param hsd: Pointer to SD handle
  * @retval None
  */
void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd)
{
	HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_1);
	tx_done = 1;
}

/**
  * @brief SD error callbacks
  * @param hsd: Pointer SD handle
  * @retval None
  */
void HAL_SD_ErrorCallback(SD_HandleTypeDef *hsd)
{
	HAL_GPIO_TogglePin(GPIOB, GPIO_PIN_0);
}


/* USER CODE END 1 */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/


#include "bsp_sdmmc.h"
#include <string.h>
#include "delay.h"

//SD_ReadDisk/SD_WriteDisk函数专用buf,当这两个函数的数据缓存区地址不是4字节对齐的时候,
//需要用到该数组,确保数据缓存区地址是4字节对齐的.
__align(4) uint8_t SDIO_DATA_BUFFER[512]; 


//读SD卡
//buf:读数据缓存区
//sector:扇区地址
//cnt:扇区个数	
//返回值:错误状态;0,正常;其他,错误代码;
uint8_t SD_ReadDisk(uint8_t* buf,uint32_t sector,uint8_t cnt)
{
	uint8_t sta=HAL_OK;
	uint8_t n;

	if((uint32_t)buf%4!=0)
	{
		for(n=0;n<cnt;n++)
		{
			rx_done = 0;
			sta=HAL_SD_ReadBlocks_DMA(&hsd1, SDIO_DATA_BUFFER, sector+n, 1);//单个sector的读操作
			while(!rx_done);
			memcpy(buf,SDIO_DATA_BUFFER,BLOCKSIZE);
			buf+=512;
		}
	}else
	{
		rx_done = 0;
		sta=HAL_SD_ReadBlocks_DMA(&hsd1, buf, sector, cnt);//多个sector的读操作
		while(!rx_done);
	}
	
	while(1)
	{
		if(4 == HAL_SD_GetCardState(&hsd1))
		{
			break;
		}
		delay_us(100);
	}

	return sta;
}  

//写SD卡
//buf:写数据缓存区
//sector:扇区地址
//cnt:扇区个数	
//返回值:错误状态;0,正常;其他,错误代码;	
uint8_t SD_WriteDisk(uint8_t *buf,uint32_t sector,uint8_t cnt)
{   
	uint8_t sta=HAL_OK;
	uint8_t n;

	if((uint32_t)buf%4!=0)
	{
		for(n=0;n<cnt;n++)
		{
			memcpy(SDIO_DATA_BUFFER,buf,BLOCKSIZE);
			tx_done = 0;
			sta=HAL_SD_WriteBlocks_DMA(&hsd1, SDIO_DATA_BUFFER, sector+n, 1);//单个sector的写操作
			while(!tx_done);
			buf+=BLOCKSIZE;
		}
	}else
	{
		tx_done = 0;
		sta=HAL_SD_WriteBlocks_DMA(&hsd1, buf, sector, cnt);//多个sector的写操作
		while(!tx_done);
	}
	
	while(1)
	{
		if(4 == HAL_SD_GetCardState(&hsd1))
		{
			break;
		}
		delay_us(100);
	}

	return sta;
} 

//while(1)
//{
//	if(4 == HAL_SD_GetCardState(&hsd1))
//	{
//		break;
//	}
//	delay_us(100);
//}

总结：
1、
在这里插入图片描述

2、
在这里插入图片描述
3、
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

4、SDMMC1 global interrupt需要使能，否则DMA写SD卡会有问题
5、使用DMA读写SD卡，可以不使能ICACHE、DCACHE，CACHE问题后面再看
6、读写SD卡过程中不能关闭全局中断，因为无法进入中断，程序会卡在读写函数的while()循环中
7、
读写后需要加入一段代码判断SD卡是否就绪
while(1)
{
if(4 == HAL_SD_GetCardState(&hsd1))
{
break;
}
delay_us(100);
}

smallerlang
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在STM32中使用DMA进行SD卡读写操作的实现方法
weixin_66608063的博客
02-16 736
在实际应用中，需要根据具体的需求选择合适的SPI工作模式、数据大小和时钟频率，并根据SD卡规格和性能要求进行适当的优化配置。首先，需要初始化SD卡和SPI外设，包括配置SPI的工作模式、数据大小、时钟极性和相位等参数，并初始化SD卡的相关参数。接下来，需要配置DMA传输通道，并设置DMA的传输方向、数据大小、通道、外设地址、内存地址等参数。一旦SPI、SD卡和DMA都已经配置完成，可以开始启动DMA传输来进行SD卡的读写操作。在使用DMA进行SD卡读写操作时，需要将SD卡的数据流控制与DMA通道关联。
STM32 对 SD 卡操作的例程包含读、写、擦除、初始化
知寒
06-07 2862
STM32 控制 SD卡 的读、写、擦除函数示例！
【STM32+HAL】SDIO+DMA模式读写SD卡
最新发布
缺积分下载资源的可以私信我或在评论区留言邮箱号
04-29 835
一、准备工作 有关CUBEMX的初始化配置，参见我的另一篇blog：【STM32+HAL】CUBEMX初始化配置 二、所用工具 1、芯片： STM32F407VET6 2、IDE： MDK-Keil软件 3、库文件：STM32F4xxHAL库 三、实现功能 实现用DMA读写SD卡内容
使用vscode + gcc进行 STM32 单片机开发（三）DMA读写SD卡，移植FATFS文件系统
jiladahe1997的博客
12-27 1256
STM32L4新版HAL库SDIO（DMA）、FatFs使用教程（三）
zl199203的博客
10-29 8776
使用FatFs文件系统 添加FatFs文件系统，使用DMA读写方式驱动。 1、打开配置文件，在FatFs勾选SD Card 2、在configuration选项卡中打开“FATFS”选项，按下图配置，以支持中文和长目录。生成代码并打开工程。   打开菜单栏project -&gt; settings，如图红框部分，调大堆栈，heap = 0x400, Stack = 0x100...
STM32CubeIDE SD卡 使用DMA问题
yegw420的博客
11-15 1637
STM32CubeIDE　配置　SD模块并使用DMA 如下图， 比较简单 只用了dma２-channel4, 重写两个　__weak　函数： BSP_SD_WriteBlocks　和　BSP_SD_ReadBlocks （自动生成的代码sd_diskio.c　中使用的是这两个函数,） uint8_t BSP_SD_ReadBlocks(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks, uint32_t Timeout) { uint8_
STM32CubeMX系列09——SDIO（SD卡读写、SD卡移植FATFS文件系统）
32Haozi
11-16 5909
CubeMX配置了如何读写SD卡，并移植了FATFS文件系统
STM32CubeMX配置SD+DMA+Fatfs（正点原子F767开发板）
05-27
在这个项目中，我们重点讨论如何使用STM32CubeMX配置STM32F767微控制器，集成SD卡、DMA（直接存储器访问）以及Fatfs文件系统，以便在正点原子F767开发板上实现SD卡的读写功能。 1. **STM32CubeMX的使用** 首先，...
STM32H750实现SD卡读写【支持STM32H7系列单片机_寄存器库驱动】.zip
02-14
总之，STM32H750实现SD卡读写的过程涉及到了硬件接口的配置、寄存器操作以及SD卡协议的遵循。通过寄存器库驱动，开发者可以直接控制硬件资源，实现高效且灵活的SD卡读写操作。这个项目提供的代码可以直接在STM32H7...
STM32的DMA方式实现SD卡存储
10-17
在这个项目中，我们将关注如何利用STM32F103的DMA（直接内存访问）功能来实现串口数据的高效采集，并通过FATFS文件系统将这些数据存储到SD卡上。以下是关于这个主题的详细解释： 首先，DMA是一种在没有CPU干预的...
STM32F103读取SD卡中的数据
07-12
本话题将深入探讨如何使用STM32F103读取SD卡中的数据，这对于开发存储和读取大量数据的应用至关重要。 首先，要实现STM32F103与SD卡的通信，需要利用到SD卡的SPI协议。SPI（Serial Peripheral Interface）是一种...
STM32读写SD卡中的FAT文件_FATFS读写txt_stm32SD_stm32SD卡_
10-03
在STM32项目中，经常需要进行外部存储设备如SD卡的读写操作，以便存储数据或者运行程序。本节将详细介绍如何使用STM32通过FAT文件系统读写SD卡中的TXT文件。 1. **FATFS文件系统** FAT文件系统（File Allocation ...
【【SOC简单设计流程之SD卡读写DMA环路实验】】
weixin_50965981的博客
10-19 394
SOC简单设计流程之SD卡读写DMA环路实验
linux申请dma内存,linux内存管理之DMA
weixin_35881820的博客
04-30 2323
说起DMA我们并不陌生，但是实际编程中去用的人不多吧，最多就是网卡驱动里的环形buffer，再有就是设备的dma，下面我们就分析分析.DMA用来在设备内存和内存之间直接数据交互。而无需cpu干预内核为了方便驱动的开发，已经提供了几个dma 函数接口。dma跟硬件架构相关，所以linux关于硬件部分已经给屏蔽了，有兴趣的可以深入跟踪学习.按照linux内核对dma层的架构设计，各平台dma缓冲区映射...
STM32L4使用HAL库SDMMC+DMA读写SD卡的问题
zhang062061的专栏
03-12 2862
之前介绍过使用STM32F4系列的单片机SDIO接口读写SD卡及文件系统的教程，可参考《STM32CubeMX之SDIO+FatFS读写SD卡》。最近使用L4系列的，SDMMC接口+DMA...
STM32对SD卡的读、写、擦除操作（SDIO模式）（DMA）
知寒
06-06 9390
STM32的 SDIO 控制 SD 卡的读、写、擦除操作
STM32-DMA直接存储器存储(存储器到存储器的DMA传输)
cyaya6的博客
11-13 5156
STM32中DMA直接存储器存储(存储器到存储器的DMA传输)
STM32CubeMX配置SD卡+DMA+Fatfs文件系统
dxc8865de2的博客
08-10 7983
STM32CubeMX配置SD卡+DMA+Fatfs文件系统 一、设备及软件 1、keil 2、STM32CubeMX 3、正点原子STM32F407探索者开发板 二、配置步骤 1、配置RCC外部晶振和SYS为SW模式（看之前配置方式） 2、配置USART1（调试使用） 3、时钟树配置，SDIO模块输入时钟为48MHZ 4,、SDIO配置 SDIO时钟SDIO_CK = 48MHz/(CLKDIV+2)。即12MHZ 打开SDIO中断 添加DMA 5、配置Fatfs文件系统 支持中文及长文件
STM32F7---＞SDRAM
qq_42069216的博客
08-06 1523
文章目录SDRAMSDRAM信号线存储单元存储结构数据传输控制命令空操作命令激活命令读写命令预充电命令刷新命令设置模式寄存器命令初始化写操作读操作FMC接口驱动SDRAM附录交代声明 SDRAM SDRAM英文名是 Synchronous Dynamic Random Access Memory ，即同步动态随机存储器，相较于 SRAM(静态存储器) SDRAM 具有：容量大和价格便宜的特点。 STM32F767 支持 SDRAM ，我们可以外挂 SDRAM ，从而大大降低外扩内存的成本，如下SDRAM
stm32f4 spi dma 读写sd卡
06-28
### 回答1： 在STM32F4系列中，使用SPI和DMA读写SD卡是相对较简单的操作。 首先，我们需要配置SPI和DMA。对于SPI，我们需要设置SPI的工作模式、数据大小、极性和相位等参数。我们还需要配置DMA来传输数据。DMA可以在SPI和SD卡之间进行数据传输，提高速度和效率。 然后，我们需要初始化SD卡。这包括发送一系列的命令和参数来配置SD卡，使其能够与MCU进行通信。这些命令可以通过SPI进行传输，并且可以使用DMA进行数据传输。 接下来，我们可以使用SPI和DMA来读写SD卡。通过发送读写命令和地址来指定要读写的数据块。通过SPI和DMA进行数据传输，以读取或写入数据。 同时要注意，对于读取数据，我们需要等待SD卡的响应，并确保数据正确接收到MCU。对于写入数据，我们也需要等待SD卡的响应，并检查是否成功写入。 最后，在使用完SD卡后，我们需要进行关闭和释放相关资源的操作。这包括关闭SPI和DMA的功能，并确保SD卡处于适当的状态。 综上所述，通过配置SPI和DMA，初始化SD卡并使用SPI和DMA进行数据传输，我们可以在STM32F4上实现SD卡的读写操作。这种方法能够提高效率和速度，并简化了操作过程。 ### 回答2： STM32F4 SPI+DMA方式读写SD卡的操作步骤如下： 1. 初始化SPI和DMA：首先需要初始化SPI和DMA模块，设置SPI相关参数，如数据位数、时钟分频等。同时，配置DMA的通道和相关参数，以便实现SPI数据的直接传输。 2. 初始化SD卡：根据SD卡规范，使用SPI发送命令和参数来初始化SD卡。初始化过程中，需要发送CMD0命令以及CMD8命令等，以及在响应中获取SD卡的OCR、CSD等信息。 3. 读写SD卡：使用SPI+DMA方式进行SD卡的读写操作。对于读操作，先发送CMD17命令来指定要读取的块地址，然后启动DMA传输，将从SD卡读取的数据保存到目标内存中。对于写操作，先发送CMD24命令来指定要写入的块地址，然后启动DMA传输，将数据从源内存传输到SD卡。 4. 数据检验与校验：在读写操作完成后，需要进行数据的检验与校验。对于读操作，可以使用CRC校验码进行数据的完整性验证；对于写操作，可以使用CRC校验码来确保写入的数据正确。 5. 错误处理与重试：在读写操作中，可能会遇到SPI和DMA传输错误、SD卡响应错误等情况。在这种情况下，可以根据具体的错误类型进行相应的处理和重试操作，例如重新初始化SPI和DMA，重新发送命令等。 总结：通过SPI+DMA方式进行SD卡的读写操作，可以提高数据传输的效率和速度，并且能够充分利用STM32F4的硬件资源。在实际操作过程中，需要注意配置SPI和DMA的相关参数，正确发送SD卡的命令和参数，以及处理可能出现的错误情况。 ### 回答3： STM32F4系列微控制器支持SPI（串行外设接口）和DMA（直接内存访问）功能，可以实现对SD卡的读写操作。 首先，配置SPI硬件资源。选择一个可用的SPI外设和对应的引脚，并配置SPI的时钟频率、数据位、极性、相位等参数。 其次，配置DMA传输。选择一个可用的DMA通道，并设置传输方向、数据宽度、传输数量等参数，以使得DMA能够自动地在SPI和内存之间传输数据。 然后，初始化SD卡。通过发送SD卡命令和接收响应来识别和初始化SD卡，包括设置SPI的工作模式、速度、起始块地址等。 接下来，进行数据传输操作。如果要读取SD卡上的数据，首先发送读数据命令和相应的地址；然后通过DMA启动数据传输，将SD卡中的数据读取到指定的内存地址；最后等待DMA传输完成，并检查传输数据的正确性。 如果要写入数据到SD卡，首先发送写数据命令和相应的地址；然后通过DMA启动数据传输，将指定内存地址的数据写入到SD卡中；最后等待DMA传输完成，并检查写入数据的正确性。 最后，进行数据处理和错误处理。对于读取操作，可以对传输的数据进行解析和处理，以满足应用的需求。对于写入操作，可以检查写入数据是否正确，并处理写入数据过程中可能出现的错误，如超时、电压不稳定等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值