你的浏览器版本过低，可能导致网站不能正常访问！
为了你能正常使用网站功能，请使用这些浏览器。

st-img
chrome st-img
firefox st-img
safari st-img
ie8及以上

【经验分享】STM32H7的SDMMC总线基础知识和HAL库API

[复制链接]
STMCU小助手 发布时间：2021-11-6 23:38
87.1 初学者重要提示
  对于SDMMC控制SD卡或者eMMC，掌握本章的知识点就够用了，更深入的认识可以看STM32H7的参考手册。
  注意，操作SD卡是采用的函数HAL_SD_XXXX，而操作eMMC是采用的函数HAL_MMC_XXXX，也就是说他们采用的函数前缀是不同的。
  SDMMC驱动eMMC支持1线，4线和8线模式，其中8线模式的最高速度可达208MB/S，实际速度受IO最大速度限制。
  SDMMC驱动SD卡支持1线和4线模式。
  STM32H7的SDMMC也支持eMMC：
  
87.2 SDMMC总线基础知识
87.2.1 SDMMC总线的硬件框图
认识一个外设，最好的方式就是看它的框图，方便我们快速的了解SDMMC的基本功能，然后再看手册了解细节。

6eea62abe623396815a50adc87205b83.png


通过这个框图，我们可以得到如下信息：

sdmmc_ker_ck输入
SDMMC内核时钟。

  sdmmc_hclk输入
AHB时钟。

  sdmmc_it输出
SDMMC全局中断。

  sdmmc_dataend_trg输出
MDMA的SDMMC数据接收触发信号。

  SDMMC_CMD
SD/SDIO/MMC卡双向/响应信号。

  SDMMC_D[7:0]
SD/SDIO/MMC卡双向数据线。

  SDMMC_CKIN
来自SD/SDIO/MMC卡的外部驱动器的时钟反馈（用于SDR12，SDR25，SDR50和DDR50）。

  SDMMC_CK
SD/SDIO/MMC卡的时钟。

  SDMMC_CDIR
SDMMC_CMD信号的SD/SDIO/MMC卡I/O方向指示。

  SDMMC_D123DIR
SDMMC_D[3:1]数据线的SD/SDIO/MMC卡I/O方向指示。

  SDMMC_D0DIR
SDMMC_D0数据线的SD/SDIO/MMC卡I/O方向指示。

STM32H7有两个SDMMC控制器，SDMMC1和SDMMC2，这两个控制器支持的功能是一样的。

87.2.2 SDMMC时钟
SDMMC控制器的时钟来源：

676ec31792fcb80bee640ed979d48084.png


SDMMC1和SDMMC2时钟源是一样的：

79b1c69986d1ee5bc090bf1676f396fd.png


87.2.3 SDMMC1和SDMMC2支持的RAM空间区别
注：大家应用时要特别注意这个问题。

使用STM32H7的SDIO1仅支持AXI SRAM，而SDIO2是AXI，SRAM1,SRAM2和SRAM3都支持的

6a5491d2f4a8740d838af58d034b7597.png


87.2.4 SDMMC支持的速度
驱动SD卡支持的最大总线速度：

b70ce31107b38ea820dbc28c3caec38e.png


驱动eMMC支持的最大总线速度：

843bf7a054944ba7d5d137ca84e1d4ed.png


关于这两个数据表，注意以下几点：

  驱动SD卡最大支持4bit，驱动eMMC最大支持8bit。
  针对信号电压1.8V或者1.2V，STM32H7需要外接专门的PHY芯片才可以驱动。
  最大IO翻转限制说的是SDR50，SDR104这种高速通信。平时用的DS，HS这种，无压力，刷满速不成问题。
87.2.5 SDMMC支持UHS-I模式
STM32H7的SDIO外接支持UHS-I 模式 (SDR12, SDR25, SDR50, SDR104和DDR50)需要1.8的电平转换器。STM32H7参考手册给了一个型号ST6G3244ME：

2b8e4430b8a60dc5a1b342d7c7f75f52.png


85f975745619c9afc64f8889289dad58.png


87.2.6 SDMMC自带的DMA控制器IDMA
STM32H7的SDMMC自带了专用的DMA控制器IDMA，支持突发，也支持双缓冲。为什么要自带DMA控制器？ 主要原因是STM32H7的通用DMA1和DMA2已经无法满足SDMMC高速通信速度。在本教程的第62章专门为大家测试过。通过让SDMMC自带控制器，这个问题就迎刃而解。

87.3 SDMMC总线的HAL库用法
87.3.1 SDMMC总线结构体SD_TypeDef
SDMMC总线相关的寄存器是通过HAL库中的结构体SD_TypeDef定义，在stm32h743xx.h中可以找到这个类型定义：

  1. #define SD_TypeDef          SDMMC_TypeDef
  2. typedef struct
  3. {
  4.   __IO uint32_t POWER;          /*!< SDMMC power control register,             Address offset: 0x00  */
  5.   __IO uint32_t CLKCR;          /*!< SDMMC clock control register,             Address offset: 0x04  */
  6.   __IO uint32_t ARG;            /*!< SDMMC argument register,                  Address offset: 0x08  */
  7.   __IO uint32_t CMD;            /*!< SDMMC command register,                   Address offset: 0x0C  */
  8.   __I uint32_t  RESPCMD;        /*!< SDMMC command response register,          Address offset: 0x10  */
  9.   __I uint32_t  RESP1;          /*!< SDMMC response 1 register,                Address offset: 0x14  */
  10.   __I uint32_t  RESP2;          /*!< SDMMC response 2 register,                Address offset: 0x18  */
  11.   __I uint32_t  RESP3;          /*!< SDMMC response 3 register,                Address offset: 0x1C  */
  12.   __I uint32_t  RESP4;          /*!< SDMMC response 4 register,                Address offset: 0x20  */
  13.   __IO uint32_t DTIMER;         /*!< SDMMC data timer register,                Address offset: 0x24  */
  14.   __IO uint32_t DLEN;           /*!< SDMMC data length register,               Address offset: 0x28  */
  15.   __IO uint32_t DCTRL;          /*!< SDMMC data control register,              Address offset: 0x2C  */
  16.   __I uint32_t  DCOUNT;         /*!< SDMMC data counter register,              Address offset: 0x30  */
  17.   __I uint32_t  STA;            /*!< SDMMC status register,                    Address offset: 0x34  */
  18.   __IO uint32_t ICR;            /*!< SDMMC interrupt clear register,           Address offset: 0x38  */
  19.   __IO uint32_t MASK;           /*!< SDMMC mask register,                      Address offset: 0x3C  */
  20.   __IO uint32_t ACKTIME;        /*!< SDMMC Acknowledgement timer register,     Address offset: 0x40  */
  21.   uint32_t      RESERVED0[3];   /*!< Reserved, 0x44 - 0x4C - 0x4C                                    */
  22.   __IO uint32_t IDMACTRL;       /*!< SDMMC DMA control register,               Address offset: 0x50  */
  23.   __IO uint32_t IDMABSIZE;      /*!< SDMMC DMA buffer size register,           Address offset: 0x54  */
  24.   __IO uint32_t IDMABASE0;      /*!< SDMMC DMA buffer 0 base address register, Address offset: 0x58  */
  25.   __IO uint32_t IDMABASE1;      /*!< SDMMC DMA buffer 1 base address register, Address offset: 0x5C  */
  26.   uint32_t      RESERVED1[8];   /*!< Reserved, 0x60-0x7C                                             */
  27.   __IO uint32_t FIFO;           /*!< SDMMC data FIFO register,                 Address offset: 0x80  */
  28.   uint32_t      RESERVED2[222]; /*!< Reserved, 0x84-0x3F8                                            */
  29.   __IO uint32_t IPVR;           /*!< SDMMC data FIFO register,                 Address offset: 0x3FC */
  30. } SDMMC_TypeDef;
复制代码

这个结构体的成员名称和排列次序和CPU的寄存器是一 一对应的。

__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：

  1. #define     __O     volatile             /*!< Defines 'write only' permissions */
  2. #define     __IO    volatile             /*!< Defines 'read / write' permissions */
复制代码

下面我们看下SDMMC的定义，在stm32h743xx.h文件。

  1. #define PERIPH_BASE           (0x40000000UL)
  2. #define D1_AHB1PERIPH_BASE    (PERIPH_BASE + 0x12000000UL)
  3. #define D2_AHB2PERIPH_BASE    (PERIPH_BASE + 0x08020000UL)

  5. #define SDMMC1_BASE           (D1_AHB1PERIPH_BASE + 0x7000UL)
  6. #define SDMMC2_BASE           (D2_AHB2PERIPH_BASE + 0x2400UL)

  8. #define SDMMC1              ((SDMMC_TypeDef *) SDMMC1_BASE)
  9. #define SDMMC2              ((SDMMC_TypeDef *) SDMMC2_BASE) <----- 展开这个宏，(SDMMC_TypeDef *)0x48022400
复制代码

我们访问SDMMC1的CMD寄存器可以采用这种形式：SDMMC1->CMD = 0。

87.3.2 SDMMC总线初始化结构体SD_InitTypeDef
下面是SDMMC总线的初始化结构体：

  1. #define SD_InitTypeDef      SDMMC_InitTypeDef
  2. typedef struct
  3. {
  4.   uint32_t ClockEdge;            
  5.   uint32_t ClockPowerSave;      
  6.   uint32_t BusWide;            
  7.   uint32_t HardwareFlowControl;  
  8.   uint32_t ClockDiv;            
  9. #if (USE_SD_TRANSCEIVER != 0U)
  10.   uint32_t TranceiverPresent;   
  11. #endif
  12. }SDMMC_InitTypeDef;
复制代码

下面将结构体成员逐一做个说明：

  ClockEdge
用于设置SDMMC的数据或者命令变化的时钟沿。
  1. #define SDMMC_CLOCK_EDGE_RISING               ((uint32_t)0x00000000U)
  2. #define SDMMC_CLOCK_EDGE_FALLING              SDMMC_CLKCR_NEGEDGE
复制代码

  ClockPowerSave
用于设置空闲状态，是否输出时钟。
  1. #define SDMMC_CLOCK_POWER_SAVE_DISABLE         ((uint32_t)0x00000000U)
  2. #define SDMMC_CLOCK_POWER_SAVE_ENABLE          SDMMC_CLKCR_PWRSAV
复制代码

  BusWide
用于设置SDMMC总线位宽。
  1. #define SDMMC_BUS_WIDE_1B                      ((uint32_t)0x00000000U)
  2. #define SDMMC_BUS_WIDE_4B                      SDMMC_CLKCR_WIDBUS_0
  3. #define SDMMC_BUS_WIDE_8B                      SDMMC_CLKCR_WIDBUS_1
复制代码

  HardwareFlowControl
用于设置时候使能硬件流控制。
  1. #define SDMMC_HARDWARE_FLOW_CONTROL_DISABLE    ((uint32_t)0x00000000U)
  2. #define SDMMC_HARDWARE_FLOW_CONTROL_ENABLE     SDMMC_CLKCR_HWFC_EN
复制代码

  ClockDiv
用于设置SDMMC时钟分频，参数范围0到1023。

  TranceiverPresent
用于设置是否带1.8V收发器。
  1. #define SDMMC_TRANSCEIVER_UNKNOWN             ((uint32_t)0x00000000U)
  2. #define SDMMC_TRANSCEIVER_NOT_PRESENT         ((uint32_t)0x00000001U)
  3. #define SDMMC_TRANSCEIVER_PRESENT             ((uint32_t)0x00000002U)
复制代码

87.3.3 SDMMC接SD卡信息结构体HAL_SD_CardInfoTypeDef
下面是SDMMC总线的卡信息结构体：
  1. typedef struct
  2. {
  3.   uint32_t CardType;                     /*!< Specifies the card Type                         */
  4.   uint32_t CardVersion;                  /*!< Specifies the card version                      */
  5.   uint32_t Class;                        /*!< Specifies the class of the card class           */
  6.   uint32_t RelCardAdd;                   /*!< Specifies the Relative Card Address             */
  7.   uint32_t BlockNbr;                     /*!< Specifies the Card Capacity in blocks           */
  8.   uint32_t BlockSize;                    /*!< Specifies one block size in bytes               */
  9.   uint32_t LogBlockNbr;                  /*!< Specifies the Card logical Capacity in blocks   */
  10.   uint32_t LogBlockSize;                 /*!< Specifies logical block size in bytes           */
  11.   uint32_t CardSpeed;                    /*!< Specifies the card Speed                        */
  12. }HAL_SD_CardInfoTypeDef;
复制代码

下面将结构体成员逐一做个说明：

CardType
卡类型。
  1. /*!< SD Standard Capacity <2Go                        */
  2. #define CARD_SDSC                  ((uint32_t)0x00000000U)
  3. /*!< SD High Capacity <32Go, SD Extended Capacity <2To  */
  4. #define CARD_SDHC_SDXC             ((uint32_t)0x00000001U)  
  5. #define CARD_SECURED               ((uint32_t)0x00000003U)
复制代码

  CardVersion
卡版本。
  1. #define CARD_V1_X                  ((uint32_t)0x00000000U)
  2. #define CARD_V2_X                  ((uint32_t)0x00000001U)
复制代码

  Class
卡类型。

  RelCardAdd
卡相对地址。

  BlockNbr
整个卡的块数。

  BlockSize
每个块的字节数。

  LogBlockNbr
整个卡的逻辑块数。

  LogBlockSize
逻辑块大小
  1. #define SPI_FIRSTBIT_MSB                              (0x00000000UL)
  2. #define SPI_FIRSTBIT_LSB                              SPI_CFG2_LSBFRST
复制代码

CardSpeed
用于设置是否使能SPI总线的TI模式。
  1. /*!< Normal Speed Card <12.5Mo/s , Spec Version 1.01    */
  2. #define CARD_NORMAL_SPEED        ((uint32_t)0x00000000U)  

  4. /*!< High Speed Card <25Mo/s , Spec version 2.00        */
  5. #define CARD_HIGH_SPEED          ((uint32_t)0x00000100U)

  7. /*!< UHS-I SD Card <50Mo/s for SDR50, DDR5 Cards
  8.      and <104Mo/s for SDR104, Spec version 3.01        */
  9. #define CARD_ULTRA_HIGH_SPEED    ((uint32_t)0x00000200U)  
复制代码

87.3.4 SDMMC总线句柄结构体SD_HandleTypeDef
下面是SDMMC句柄结构体：

  1. #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
  2. typedef struct __SD_HandleTypeDef
  3. #else
  4. typedef struct
  5. #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
  6. {
  7.   SD_TypeDef                   *Instance;        /*!< SD registers base address           */
  8.   SD_InitTypeDef               Init;             /*!< SD required parameters              */
  9.   HAL_LockTypeDef              Lock;             /*!< SD locking object                   */
  10.   uint8_t                      *pTxBuffPtr;      /*!< Pointer to SD Tx transfer Buffer    */
  11.   uint32_t                     TxXferSize;       /*!< SD Tx Transfer size                 */
  12.   uint8_t                      *pRxBuffPtr;      /*!< Pointer to SD Rx transfer Buffer    */
  13.   uint32_t                     RxXferSize;       /*!< SD Rx Transfer size                 */
  14.   __IO uint32_t                Context;          /*!< SD transfer context                 */
  15.   __IO HAL_SD_StateTypeDef     State;            /*!< SD card State                       */
  16.   __IO uint32_t                ErrorCode;        /*!< SD Card Error codes                 */
  17.   HAL_SD_CardInfoTypeDef       SdCard;           /*!< SD Card information                 */
  18.   uint32_t                     CSD[4];           /*!< SD card specific data table         */
  19.   uint32_t                     CID[4];           /*!< SD card identification number table */

  21. #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
  22.   void (* TxCpltCallback)                 (struct __SD_HandleTypeDef *hsd);
  23.   void (* RxCpltCallback)                 (struct __SD_HandleTypeDef *hsd);
  24.   void (* ErrorCallback)                  (struct __SD_HandleTypeDef *hsd);
  25.   void (* AbortCpltCallback)              (struct __SD_HandleTypeDef *hsd);
  26.   void (* Read_DMADblBuf0CpltCallback)    (struct __SD_HandleTypeDef *hsd);
  27.   void (* Read_DMADblBuf1CpltCallback)    (struct __SD_HandleTypeDef *hsd);
  28.   void (* Write_DMADblBuf0CpltCallback)   (struct __SD_HandleTypeDef *hsd);
  29.   void (* Write_DMADblBuf1CpltCallback)   (struct __SD_HandleTypeDef *hsd);
  30. #if (USE_SD_TRANSCEIVER != 0U)
  31.   void (* DriveTransceiver_1_8V_Callback) (FlagStatus status);
  32. #endif /* USE_SD_TRANSCEIVER */

  34.   void (* MspInitCallback)                (struct __SD_HandleTypeDef *hsd);
  35.   void (* MspDeInitCallback)              (struct __SD_HandleTypeDef *hsd);
  36. #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
  37. }SD_HandleTypeDef;
复制代码

注意事项：

条件编译USE_HAL_SD_REGISTER_CALLBACKS用来设置使用自定义回调还是使用默认回调，此定义一般放在stm32h7xx_hal_conf.h文件里面设置：

  #define   USE_HAL_SD_REGISTER_CALLBACKS   1

通过函数HAL_SD_RegisterCallback注册回调，取消注册使用函数HAL_SD_UnRegisterCallback。

这里重点介绍下面几个参数，其它参数主要是HAL库内部使用和自定义回调函数。

  SD_TypeDef   *Instance
这个参数是寄存器的例化，方便操作寄存器。

  SD_InitTypeDef  Init
这个参数在本章节3.2小节已经进行了详细说明。

87.4 SDMMC总线源文件stm32h7xx_hal_sd.c
此文件涉及到的函数较多，这里把几个常用的函数做个说明：

  HAL_SD_Init
  HAL_SD_DeInit
  HAL_SD_ReadBlocks
  HAL_SD_WriteBlocks
  HAL_SD_ReadBlocks_DMA
  HAL_SD_WriteBlocks_DMA
  HAL_SD_Erase
87.4.1 函数HAL_SD_Init
函数原型：

  1. HAL_StatusTypeDef HAL_SD_Init(SD_HandleTypeDef *hsd)
  2. {
  3.   HAL_SD_CardStatusTypeDef CardStatus;
  4.   uint32_t speedgrade, unitsize;
  5.   uint32_t tickstart;

  7.   /* 检查句柄是否有效 */
  8.   if(hsd == NULL)
  9.   {
  10.     return HAL_ERROR;
  11.   }

  13.   /* 检查参数 */
  14.   assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));
  15.   assert_param(IS_SDMMC_CLOCK_EDGE(hsd->Init.ClockEdge));
  16.   assert_param(IS_SDMMC_CLOCK_POWER_SAVE(hsd->Init.ClockPowerSave));
  17.   assert_param(IS_SDMMC_BUS_WIDE(hsd->Init.BusWide));
  18.   assert_param(IS_SDMMC_HARDWARE_FLOW_CONTROL(hsd->Init.HardwareFlowControl));
  19.   assert_param(IS_SDMMC_CLKDIV(hsd->Init.ClockDiv));

  21.   if(hsd->State == HAL_SD_STATE_RESET)
  22.   {
  23.     /* 开锁 */
  24.     hsd->Lock = HAL_UNLOCKED;

  26. #if (USE_SD_TRANSCEIVER != 0U)
  27.     /* 兼容 */
  28.     if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_UNKNOWN)
  29.     {
  30.       hsd->Init.TranceiverPresent = SDMMC_TRANSCEIVER_PRESENT;
  31.     }
  32. #endif
  33. #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
  34.     /* 复位回调 */
  35.     hsd->TxCpltCallback    = HAL_SD_TxCpltCallback;
  36.     hsd->RxCpltCallback    = HAL_SD_RxCpltCallback;
  37.     hsd->ErrorCallback     = HAL_SD_ErrorCallback;
  38.     hsd->AbortCpltCallback = HAL_SD_AbortCallback;
  39.     hsd->Read_DMADblBuf0CpltCallback = HAL_SDEx_Read_DMADoubleBuf0CpltCallback;
  40.     hsd->Read_DMADblBuf1CpltCallback = HAL_SDEx_Read_DMADoubleBuf1CpltCallback;
  41.     hsd->Write_DMADblBuf0CpltCallback = HAL_SDEx_Write_DMADoubleBuf0CpltCallback;
  42.     hsd->Write_DMADblBuf1CpltCallback = HAL_SDEx_Write_DMADoubleBuf1CpltCallback;
  43. #if (USE_SD_TRANSCEIVER != 0U)
  44.     if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)
  45.     {
  46.       hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback;
  47.     }
  48. #endif

  50.     if(hsd->MspInitCallback == NULL)
  51.     {
  52.       hsd->MspInitCallback = HAL_SD_MspInit;
  53.     }

  55.     /* 初始化底层 */
  56.     hsd->MspInitCallback(hsd);
  57. #else
  58.     /* 初始化底层硬件 GPIO, CLOCK, CORTEX...etc */
  59.     HAL_SD_MspInit(hsd);
  60. #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
  61.   }

  63.   hsd->State = HAL_SD_STATE_BUSY;

  65.   /* 初始化卡参数 */
  66.   if (HAL_SD_InitCard(hsd) != HAL_OK)
  67.   {
  68.     return HAL_ERROR;
  69.   }

  71.   if( HAL_SD_GetCardStatus(hsd, &CardStatus) != HAL_OK)
  72.   {
  73.     return HAL_ERROR;
  74.   }
  75.   /* 获取卡速度等信息 */
  76.   speedgrade = CardStatus.UhsSpeedGrade;
  77.   unitsize = CardStatus.UhsAllocationUnitSize;
  78.   if ((hsd->SdCard.CardType == CARD_SDHC_SDXC) && ((speedgrade != 0U) || (unitsize != 0U)))
  79.   {
  80.     hsd->SdCard.CardSpeed = CARD_ULTRA_HIGH_SPEED;
  81.   }
  82.   else
  83.   {
  84.     if (hsd->SdCard.CardType == CARD_SDHC_SDXC)
  85.     {
  86.       hsd->SdCard.CardSpeed  = CARD_HIGH_SPEED;
  87.     }
  88.     else
  89.     {
  90.       hsd->SdCard.CardSpeed  = CARD_NORMAL_SPEED;
  91.     }

  93.   }
  94.   /* 配置总线位宽 */
  95.   if(HAL_SD_ConfigWideBusOperation(hsd, hsd->Init.BusWide) != HAL_OK)
  96.   {
  97.     return HAL_ERROR;
  98.   }

  100.   /* 验证卡初始化后是否就绪 */
  101.   tickstart = HAL_GetTick();
  102.   while((HAL_SD_GetCardState(hsd) != HAL_SD_CARD_TRANSFER))
  103.   {
  104.     if((HAL_GetTick()-tickstart) >=  SDMMC_DATATIMEOUT)
  105.     {
  106.       hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
  107.       hsd->State= HAL_SD_STATE_READY;
  108.       return HAL_TIMEOUT;
  109.     }
  110.   }

  112.   hsd->ErrorCode = HAL_SD_ERROR_NONE;

  114.   hsd->Context = SD_CONTEXT_NONE;

  116.   hsd->State = HAL_SD_STATE_READY;

  118.   return HAL_OK;
  119. }
复制代码

函数描述：

此函数用于初始化SD卡。

函数参数：

  第1个参数是SD_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
注意事项：

函数HAL_SD_MspInit用于初始化SD的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
如果形参hsd的结构体成员State没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量SD_HandleTypeDef SdHandle。
对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_SD_STATE_RESET  = 0x00U。

解决办法有三

方法1：用户自己初始化SD和涉及到的GPIO等。

方法2：定义SD_HandleTypeDef SdHandle为全局变量。

方法3：下面的方法

  1. if(HAL_SD_DeInit(&SdHandle) != HAL_OK)
  2. {
  3.     Error_Handler();
  4. }  
  5. if(HAL_SD_Init(&SdHandle) != HAL_OK)
  6. {
  7.     Error_Handler();
  8. }
复制代码

使用举例：

  1. SD_HandleTypeDef uSdHandle;

  3. uSdHandle.Instance = SDMMC1;

  5. /* if CLKDIV = 0 then SDMMC Clock frequency = SDMMC Kernel Clock
  6.      else SDMMC Clock frequency = SDMMC Kernel Clock / [2 * CLKDIV].
  7.      200MHz / (2*2) = 50MHz
  8. */
  9. uSdHandle.Init.ClockDiv            = 2;
  10. uSdHandle.Init.ClockPowerSave      = SDMMC_CLOCK_POWER_SAVE_DISABLE;
  11. uSdHandle.Init.ClockEdge           = SDMMC_CLOCK_EDGE_RISING;
  12. uSdHandle.Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE;
  13. uSdHandle.Init.BusWide             = SDMMC_BUS_WIDE_4B;
  14. if(HAL_SD_Init(&uSdHandle) != HAL_OK)
  15. {
  16.    sd_state = MSD_ERROR;
  17. }
复制代码

87.4.2 函数HAL_SD_DeInit
函数原型：

  1. HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
  2. {
  3.   /* 检查SD卡句柄是否有效 */
  4.   if(hsd == NULL)
  5.   {
  6.     return HAL_ERROR;
  7.   }

  9.   /* 检查参数 */
  10.   assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));

  12.   hsd->State = HAL_SD_STATE_BUSY;

  14. #if (USE_SD_TRANSCEIVER != 0U)
  15.   /* 关闭1.8V模式 */
  16.   if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)
  17.   {
  18. #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
  19.     if(hsd->DriveTransceiver_1_8V_Callback == NULL)
  20.     {
  21.       hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback;
  22.     }
  23.     hsd->DriveTransceiver_1_8V_Callback(RESET);
  24. #else
  25.     HAL_SD_DriveTransceiver_1_8V_Callback(RESET);
  26. #endif
  27.   }                                                                        
  28. #endif

  30.   /* 关闭SD卡电源 */
  31.   SD_PowerOFF(hsd);

  33. #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
  34.   if(hsd->MspDeInitCallback == NULL)
  35.   {
  36.     hsd->MspDeInitCallback = HAL_SD_MspDeInit;
  37.   }

  39.   /* 复位底层硬件 */
  40.   hsd->MspDeInitCallback(hsd);
  41. #else
  42.   /* 复位底层硬件 */
  43.   HAL_SD_MspDeInit(hsd);
  44. #endif

  46.   hsd->ErrorCode = HAL_SD_ERROR_NONE;
  47.   hsd->State = HAL_SD_STATE_RESET;

  49.   return HAL_OK;
  50. }
复制代码

函数描述：

用于复位SD总线初始化。

函数参数：

第1个参数是SD_HandleTypeDef类型结构体指针变量。
返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
87.4.3 函数HAL_SD_ReadBlocks
函数原型：

  1. HAL_StatusTypeDef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
  2. {
  3.   SDMMC_DataInitTypeDef config;
  4.   uint32_t errorstate;
  5.   uint32_t tickstart = HAL_GetTick();
  6.   uint32_t count, data, dataremaining;
  7.   uint32_t add = BlockAdd;
  8.   uint8_t *tempbuff = pData;

  10.   if(NULL == pData)
  11.   {
  12.     hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
  13.     return HAL_ERROR;
  14.   }

  16.   if(hsd->State == HAL_SD_STATE_READY)
  17.   {
  18.     hsd->ErrorCode = HAL_SD_ERROR_NONE;

  20.     if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
  21.     {
  22.       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
  23.       return HAL_ERROR;
  24.     }

  26.     hsd->State = HAL_SD_STATE_BUSY;

  28.     /* 初始化数据控制寄存器 */
  29.     hsd->Instance->DCTRL = 0U;

  31.     if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
  32.     {
  33.       add *= 512U;
  34.     }

  36.     /* 配置SD DPSM (Data Path State Machine) */
  37.     config.DataTimeOut   = SDMMC_DATATIMEOUT;
  38.     config.DataLength    = NumberOfBlocks * BLOCKSIZE;
  39.     config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
  40.     config.TransferDir   = SDMMC_TRANSFER_DIR_TO_SDMMC;
  41.     config.TransferMode  = SDMMC_TRANSFER_MODE_BLOCK;
  42.     config.DPSM          = SDMMC_DPSM_DISABLE;
  43.     (void)SDMMC_ConfigData(hsd->Instance, &config);
  44.     __SDMMC_CMDTRANS_ENABLE( hsd->Instance);

  46.     /* 查询方式块读取 */
  47.     if(NumberOfBlocks > 1U)
  48.     {
  49.       hsd->Context = SD_CONTEXT_READ_MULTIPLE_BLOCK;

  51.       /* 多块读取命令 */
  52.       errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
  53.     }
  54.     else
  55.     {
  56.       hsd->Context = SD_CONTEXT_READ_SINGLE_BLOCK;

  58.       /* 单块读取命令 */
  59.       errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
  60.     }
  61.     if(errorstate != HAL_SD_ERROR_NONE)
  62.     {
  63.       /* 清除所有静态标志 */
  64.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  65.       hsd->ErrorCode |= errorstate;
  66.       hsd->State = HAL_SD_STATE_READY;
  67.       hsd->Context = SD_CONTEXT_NONE;
  68.       return HAL_ERROR;
  69.     }

  71.     /* 查询SDMMC标志 */
  72.     dataremaining = config.DataLength;
  73.     while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
  74.     {
  75.       if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF) && (dataremaining >= 32U))
  76.       {
  77.         /* 从SDMMC Rx FIFO读取数据 */
  78.         for(count = 0U; count < 8U; count++)
  79.         {
  80.           data = SDMMC_ReadFIFO(hsd->Instance);
  81.           *tempbuff = (uint8_t)(data & 0xFFU);
  82.           tempbuff++;
  83.           *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
  84.           tempbuff++;
  85.           *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
  86.           tempbuff++;
  87.           *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
  88.           tempbuff++;
  89.         }
  90.         dataremaining -= 32U;
  91.       }

  93.       if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))
  94.       {
  95.         /* 清除所有静态标志 */
  96.         __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  97.         hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
  98.         hsd->State= HAL_SD_STATE_READY;
  99.         hsd->Context = SD_CONTEXT_NONE;
  100.         return HAL_TIMEOUT;
  101.       }
  102.     }
  103.     __SDMMC_CMDTRANS_DISABLE( hsd->Instance);

  105.     /* 多块读取发送停止传输命令 */
  106.     if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U))
  107.     {
  108.       if(hsd->SdCard.CardType != CARD_SECURED)
  109.       {
  110.         /* 发送停止传输命令 */
  111.         errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
  112.         if(errorstate != HAL_SD_ERROR_NONE)
  113.         {
  114.           /* 清除所有静态标志 */
  115.           __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  116.           hsd->ErrorCode |= errorstate;
  117.           hsd->State = HAL_SD_STATE_READY;
  118.           hsd->Context = SD_CONTEXT_NONE;
  119.           return HAL_ERROR;
  120.         }
  121.       }
  122.     }

  124.     /* 获取错误状态 */
  125.     if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
  126.     {
  127.       /* 清除所有静态标志 */
  128.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  129.       hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
  130.       hsd->State = HAL_SD_STATE_READY;
  131.       hsd->Context = SD_CONTEXT_NONE;
  132.       return HAL_ERROR;
  133.     }
  134.     else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
  135.     {
  136.       /* 清除所有静态标志 */
  137.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  138.       hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
  139.       hsd->State = HAL_SD_STATE_READY;
  140.       hsd->Context = SD_CONTEXT_NONE;
  141.       return HAL_ERROR;
  142.     }
  143.     else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
  144.     {
  145.       /* 清除所有静态标志 */
  146.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  147.       hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
  148.       hsd->State = HAL_SD_STATE_READY;
  149.       hsd->Context = SD_CONTEXT_NONE;
  150.       return HAL_ERROR;
  151.     }
  152.     else
  153.     {
  154.       /* 什么都不做 */
  155.     }

  157.     /* 清除所有静态标志 */
  158.     __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);

  160.     hsd->State = HAL_SD_STATE_READY;

  162.     return HAL_OK;
  163.   }
  164.   else
  165.   {
  166.     hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
  167.     return HAL_ERROR;
  168.   }
  169. }
复制代码

函数描述：

此函数主要用于SD卡数据读取。

函数参数：

  第1个参数是SD_HandleTypeDef类型结构体指针变量。
  第2个参数是接收数据的缓冲地址。
  第3个参数是要读取的扇区地址，即从第几个扇区开始读取（512字节为一个扇区）。
  第4个参数是读取的扇区数。
  第5个参数是传输过程的溢出时间，单位ms。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

  1. /**
  2.   * @brief  Reads block(s) from a specified address in an SD card, in polling mode.
  3.   * @param  pData: Pointer to the buffer that will contain the data to transmit
  4.   * @param  ReadAddr: Address from where data is to be read
  5.   * @param  NumOfBlocks: Number of SD blocks to read
  6.   * @param  Timeout: Timeout for read operation
  7.   * @retval SD status
  8.   */
  9. uint8_t BSP_SD_ReadBlocks(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks, uint32_t Timeout)
  10. {

  12.   if( HAL_SD_ReadBlocks(&uSdHandle, (uint8_t *)pData, ReadAddr, NumOfBlocks, Timeout) == HAL_OK)
  13.   {
  14.     return MSD_OK;
  15.   }
  16.   else
  17.   {
  18.     return MSD_ERROR;
  19.   }

  21. }
复制代码

87.4.4 函数HAL_SD_WriteBlocks
函数原型：

  1. HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
  2. {
  3.   SDMMC_DataInitTypeDef config;
  4.   uint32_t errorstate;
  5.   uint32_t tickstart = HAL_GetTick();
  6.   uint32_t count, data, dataremaining;
  7.   uint32_t add = BlockAdd;
  8.   uint8_t *tempbuff = pData;

  10.   if(NULL == pData)
  11.   {
  12.     hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
  13.     return HAL_ERROR;
  14.   }

  16.   if(hsd->State == HAL_SD_STATE_READY)
  17.   {
  18.     hsd->ErrorCode = HAL_SD_ERROR_NONE;

  20.     if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
  21.     {
  22.       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
  23.       return HAL_ERROR;
  24.     }

  26.     hsd->State = HAL_SD_STATE_BUSY;

  28.     /* 初始化数据控制寄存器 */
  29.     hsd->Instance->DCTRL = 0U;

  31.     if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
  32.     {
  33.       add *= 512U;
  34.     }

  36.     /* 配置SD DPSM */
  37.     config.DataTimeOut   = SDMMC_DATATIMEOUT;
  38.     config.DataLength    = NumberOfBlocks * BLOCKSIZE;
  39.     config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
  40.     config.TransferDir   = SDMMC_TRANSFER_DIR_TO_CARD;
  41.     config.TransferMode  = SDMMC_TRANSFER_MODE_BLOCK;
  42.     config.DPSM          = SDMMC_DPSM_DISABLE;
  43.     (void)SDMMC_ConfigData(hsd->Instance, &config);
  44.     __SDMMC_CMDTRANS_ENABLE( hsd->Instance);

  46.     /* 查询方式块写操作 */
  47.     if(NumberOfBlocks > 1U)
  48.     {
  49.       hsd->Context = SD_CONTEXT_WRITE_MULTIPLE_BLOCK;

  51.       /* 写多块命令 */
  52.       errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
  53.     }
  54.     else
  55.     {
  56.       hsd->Context = SD_CONTEXT_WRITE_SINGLE_BLOCK;

  58.       /* 写单块命令 */
  59.       errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
  60.     }
  61.     if(errorstate != HAL_SD_ERROR_NONE)
  62.     {
  63.       /* 清除所有静态命令 */
  64.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  65.       hsd->ErrorCode |= errorstate;
  66.       hsd->State = HAL_SD_STATE_READY;
  67.       hsd->Context = SD_CONTEXT_NONE;
  68.       return HAL_ERROR;
  69.     }

  71.     /* 查询方式块写操作 */
  72.     dataremaining = config.DataLength;
  73.     while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
  74.     {
  75.       if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXFIFOHE) && (dataremaining >= 32U))
  76.       {
  77.         /* 写数据到SDMMC Tx FIFO */
  78.         for(count = 0U; count < 8U; count++)
  79.         {
  80.           data = (uint32_t)(*tempbuff);
  81.           tempbuff++;
  82.           data |= ((uint32_t)(*tempbuff) << 8U);
  83.           tempbuff++;
  84.           data |= ((uint32_t)(*tempbuff) << 16U);
  85.           tempbuff++;
  86.           data |= ((uint32_t)(*tempbuff) << 24U);
  87.           tempbuff++;
  88.           (void)SDMMC_WriteFIFO(hsd->Instance, &data);
  89.         }
  90.         dataremaining -= 32U;
  91.       }

  93.       if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))
  94.       {
  95.         /* 清除所有静态标志 */
  96.         __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  97.         hsd->ErrorCode |= errorstate;
  98.         hsd->State = HAL_SD_STATE_READY;
  99.         hsd->Context = SD_CONTEXT_NONE;
  100.         return HAL_TIMEOUT;
  101.       }
  102.     }
  103.     __SDMMC_CMDTRANS_DISABLE( hsd->Instance);

  105.     /* 多块写操作，发送停止传输命令 */
  106.     if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U))
  107.     {
  108.       if(hsd->SdCard.CardType != CARD_SECURED)
  109.       {
  110.         /* 发送停止传输命令 */
  111.         errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
  112.         if(errorstate != HAL_SD_ERROR_NONE)
  113.         {
  114.           /* 清除所有静态传输标志 */
  115.           __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  116.           hsd->ErrorCode |= errorstate;
  117.           hsd->State = HAL_SD_STATE_READY;
  118.           hsd->Context = SD_CONTEXT_NONE;
  119.           return HAL_ERROR;
  120.         }
  121.       }
  122.     }

  124.     /* Get error state */
  125.     if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
  126.     {
  127.       /* 清除所有静态传输标志 */
  128.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  129.       hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
  130.       hsd->State = HAL_SD_STATE_READY;
  131.       hsd->Context = SD_CONTEXT_NONE;
  132.       return HAL_ERROR;
  133.     }
  134.     else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
  135.     {
  136.       /* 清除所有静态传输标志 */
  137.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  138.       hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
  139.       hsd->State = HAL_SD_STATE_READY;
  140.       hsd->Context = SD_CONTEXT_NONE;
  141.       return HAL_ERROR;
  142.     }
  143.     else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR))
  144.     {
  145.       /* 清除所有静态传输标志 */
  146.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  147.       hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
  148.       hsd->State = HAL_SD_STATE_READY;
  149.       hsd->Context = SD_CONTEXT_NONE;
  150.       return HAL_ERROR;
  151.     }
  152.     else
  153.     {
  154.       /* 什么都不做 */
  155.     }

  157.       /* 清除所有静态传输标志 */
  158.     __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);

  160.     hsd->State = HAL_SD_STATE_READY;

  162.     return HAL_OK;
  163.   }
  164.   else
  165.   {
  166.     hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
  167.     return HAL_ERROR;
  168.   }
  169. }
复制代码

函数描述：

此函数主要用于向SD卡写入数据。

函数参数：

  第1个参数是SD_HandleTypeDef类型结构体指针变量。
  第2个参数是要写入到SD卡的数据缓冲地址。
  第3个参数是要写入的扇区地址，即从第几个扇区开始写入（512字节为一个扇区）。
  第4个参数是读取的扇区数。
  第5个参数是传输过程的溢出时间，单位ms。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

  1. /**
  2.   * @brief  Writes block(s) to a specified address in an SD card, in polling mode.
  3.   * @param  pData: Pointer to the buffer that will contain the data to transmit
  4.   * @param  WriteAddr: Address from where data is to be written
  5.   * @param  NumOfBlocks: Number of SD blocks to write
  6.   * @param  Timeout: Timeout for write operation
  7.   * @retval SD status
  8.   */
  9. uint8_t BSP_SD_WriteBlocks(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks, uint32_t Timeout)
  10. {

  12.   if( HAL_SD_WriteBlocks(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks, Timeout) == HAL_OK)
  13.   {
  14.     return MSD_OK;
  15.   }
  16.   else
  17.   {
  18.     return MSD_ERROR;
  19.   }
  20. }
复制代码

87.4.5 函数HAL_SD_ReadBlocks_DMA
函数原型：

  1. HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
  2. {
  3.   SDMMC_DataInitTypeDef config;
  4.   uint32_t errorstate;
  5.   uint32_t add = BlockAdd;

  7.   if(NULL == pData)
  8.   {
  9.     hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
  10.     return HAL_ERROR;
  11.   }

  13.   if(hsd->State == HAL_SD_STATE_READY)
  14.   {
  15.     hsd->ErrorCode = HAL_SD_ERROR_NONE;

  17.     if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
  18.     {
  19.       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
  20.       return HAL_ERROR;
  21.     }

  23.     hsd->State = HAL_SD_STATE_BUSY;

  25.   /* 初始化数据控制寄存器 */
  26.     hsd->Instance->DCTRL = 0U;

  28.     hsd->pRxBuffPtr = pData;
  29.     hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;

  31.     if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
  32.     {
  33.       add *= 512U;
  34.     }

  36.   /* 配置SD DPSM (Data Path State Machine) */
  37.     config.DataTimeOut   = SDMMC_DATATIMEOUT;
  38.     config.DataLength    = BLOCKSIZE * NumberOfBlocks;
  39.     config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
  40.     config.TransferDir   = SDMMC_TRANSFER_DIR_TO_SDMMC;
  41.     config.TransferMode  = SDMMC_TRANSFER_MODE_BLOCK;
  42.     config.DPSM          = SDMMC_DPSM_DISABLE;
  43.     (void)SDMMC_ConfigData(hsd->Instance, &config);

  45.     __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
  46.     hsd->Instance->IDMABASE0 = (uint32_t) pData ;
  47.     hsd->Instance->IDMACTRL  = SDMMC_ENABLE_IDMA_SINGLE_BUFF;

  49.   /* DMA方式读取多个块 */
  50.     if(NumberOfBlocks > 1U)
  51.     {
  52.       hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA);

  54.    /* DMA方式读取多块命令 */
  55.       errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
  56.     }
  57.     else
  58.     {
  59.       hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_DMA);

  61.    /* 读取单块命令 */
  62.       errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
  63.     }
  64.     if(errorstate != HAL_SD_ERROR_NONE)
  65.     {
  66.    /* 清除所有静态标志 */
  67.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  68.       hsd->ErrorCode |= errorstate;
  69.       hsd->State = HAL_SD_STATE_READY;
  70.       hsd->Context = SD_CONTEXT_NONE;
  71.       return HAL_ERROR;
  72.     }

  74.   /* 使能传输中断 */
  75.     __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND));


  78.     return HAL_OK;
  79.   }
  80.   else
  81.   {
  82.     return HAL_BUSY;
  83.   }
  84. }
复制代码

函数描述：

此函数主要用于SD卡数据读取，DMA方式。

函数参数：

  第1个参数是SD_HandleTypeDef类型结构体指针变量。
  第2个参数是接收数据的缓冲地址。
  第3个参数是要读取的扇区地址，即从第几个扇区开始读取（512字节为一个扇区）。
  第4个参数是读取的扇区数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

  1. /**
  2. * @brief  Reads block(s) from a specified address in an SD card, in DMA mode.
  3. * @param  pData: Pointer to the buffer that will contain the data to transmit
  4. * @param  ReadAddr: Address from where data is to be read
  5. * @param  NumOfBlocks: Number of SD blocks to read
  6. * @retval SD status
  7. */
  8. uint8_t BSP_SD_ReadBlocks_DMA(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks)
  9. {

  11.   if( HAL_SD_ReadBlocks_DMA(&uSdHandle, (uint8_t *)pData, ReadAddr, NumOfBlocks) == HAL_OK)
  12.   {
  13.     return MSD_OK;
  14.   }
  15.   else
  16.   {
  17.     return MSD_ERROR;
  18.   }
  19. }
复制代码

87.4.6 函数HAL_SD_WriteBlocks_DMA
函数原型：

  1. HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
  2. {
  3.   SDMMC_DataInitTypeDef config;
  4.   uint32_t errorstate;
  5.   uint32_t add = BlockAdd;

  7.   if(NULL == pData)
  8.   {
  9.     hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
  10.     return HAL_ERROR;
  11.   }

  13.   if(hsd->State == HAL_SD_STATE_READY)
  14.   {
  15.     hsd->ErrorCode = HAL_SD_ERROR_NONE;

  17.     if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
  18.     {
  19.       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
  20.       return HAL_ERROR;
  21.     }

  23.     hsd->State = HAL_SD_STATE_BUSY;

  25.   /* 初始化数据控制寄存器 */
  26.     hsd->Instance->DCTRL = 0U;

  28.     hsd->pTxBuffPtr = pData;
  29.     hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;

  31.     if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
  32.     {
  33.       add *= 512U;
  34.     }

  36.   /* 配置SD DPSM (Data Path State Machine) */
  37.     config.DataTimeOut   = SDMMC_DATATIMEOUT;
  38.     config.DataLength    = BLOCKSIZE * NumberOfBlocks;
  39.     config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
  40.     config.TransferDir   = SDMMC_TRANSFER_DIR_TO_CARD;
  41.     config.TransferMode  = SDMMC_TRANSFER_MODE_BLOCK;
  42.     config.DPSM          = SDMMC_DPSM_DISABLE;
  43.     (void)SDMMC_ConfigData(hsd->Instance, &config);


  46.     __SDMMC_CMDTRANS_ENABLE( hsd->Instance);

  48.     hsd->Instance->IDMABASE0 = (uint32_t) pData ;
  49.     hsd->Instance->IDMACTRL  = SDMMC_ENABLE_IDMA_SINGLE_BUFF;

  51.   /* 查询模式写块 */
  52.     if(NumberOfBlocks > 1U)
  53.     {
  54.       hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA);

  56.     /* 多块写命令 */
  57.       errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
  58.     }
  59.     else
  60.     {
  61.       hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_DMA);

  63.     /* 单块写命令 */
  64.       errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
  65.     }
  66.     if(errorstate != HAL_SD_ERROR_NONE)
  67.     {
  68.     /* 清除静态标志 */
  69.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  70.       hsd->ErrorCode |= errorstate;
  71.       hsd->State = HAL_SD_STATE_READY;
  72.       hsd->Context = SD_CONTEXT_NONE;
  73.       return HAL_ERROR;
  74.     }

  76.   /* 使能传输中断 Enable */
  77.     __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND));

  79.     return HAL_OK;
  80.   }
  81.   else
  82.   {
  83.     return HAL_BUSY;
  84.   }
  85. }
复制代码

函数描述：

此函数主要用于向SD卡写入数据，DMA方式。

函数参数：

  第1个参数是SD_HandleTypeDef类型结构体指针变量。
  第2个参数是要写入到SD卡的数据缓冲地址。
  第3个参数是要写入的扇区地址，即从第几个扇区开始写入（512字节为一个扇区）。
  第4个参数是读取的扇区数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

  1. /**
  2. * @brief  Writes block(s) to a specified address in an SD card, in DMA mode.
  3. * @param  pData: Pointer to the buffer that will contain the data to transmit
  4. * @param  WriteAddr: Address from where data is to be written
  5. * @param  NumOfBlocks: Number of SD blocks to write
  6. * @retval SD status
  7. */
  8. uint8_t BSP_SD_WriteBlocks_DMA(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks)
  9. {

  11.   if( HAL_SD_WriteBlocks_DMA(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks) == HAL_OK)
  12.   {
  13.     return MSD_OK;
  14.   }
  15.   else
  16.   {
  17.     return MSD_ERROR;
  18.   }
  19. }
复制代码

87.4.7 函数HAL_SD_Erase
函数原型：

  1. HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd)
  2. {
  3.   uint32_t errorstate;
  4.   uint32_t start_add = BlockStartAdd;
  5.   uint32_t end_add = BlockEndAdd;

  7.   if(hsd->State == HAL_SD_STATE_READY)
  8.   {
  9.     hsd->ErrorCode = HAL_SD_ERROR_NONE;

  11.     if(end_add < start_add)
  12.     {
  13.       hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
  14.       return HAL_ERROR;
  15.     }

  17.     if(end_add > (hsd->SdCard.LogBlockNbr))
  18.     {
  19.       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
  20.       return HAL_ERROR;
  21.     }

  23.     hsd->State = HAL_SD_STATE_BUSY;

  25.   /* 检测是否支持擦除命令 */
  26.     if(((hsd->SdCard.Class) & SDMMC_CCCC_ERASE) == 0U)
  27.     {
  28.       /* 清除所有静态标志 */
  29.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  30.       hsd->ErrorCode |= HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
  31.       hsd->State = HAL_SD_STATE_READY;
  32.       return HAL_ERROR;
  33.     }

  35.     if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
  36.     {
  37.     /* 清除所有静态标志 */
  38.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  39.       hsd->ErrorCode |= HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
  40.       hsd->State = HAL_SD_STATE_READY;
  41.       return HAL_ERROR;
  42.     }

  44.   /* 对于高容量卡，获取起始块和结束块 */
  45.     if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
  46.     {
  47.       start_add *= 512U;
  48.       end_add   *= 512U;
  49.     }

  51.     /* 根据sd-card spec 1.0 ERASE_GROUP_START (CMD32) 和 erase_group_end(CMD33) */
  52.     if(hsd->SdCard.CardType != CARD_SECURED)
  53.     {
  54.     /* 发送CMD32 SD_ERASE_GRP_START命令带地址参数 */
  55.       errorstate = SDMMC_CmdSDEraseStartAdd(hsd->Instance, start_add);
  56.       if(errorstate != HAL_SD_ERROR_NONE)
  57.       {
  58.         /* 清除所有静态标志 */
  59.         __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  60.         hsd->ErrorCode |= errorstate;
  61.         hsd->State = HAL_SD_STATE_READY;
  62.         return HAL_ERROR;
  63.       }

  65.       /* 发送CMD33 SD_ERASE_GRP_END命令，带地址参数 */
  66.       errorstate = SDMMC_CmdSDEraseEndAdd(hsd->Instance, end_add);
  67.       if(errorstate != HAL_SD_ERROR_NONE)
  68.       {
  69.         /* 清除所有静态标志 */
  70.         __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  71.         hsd->ErrorCode |= errorstate;
  72.         hsd->State = HAL_SD_STATE_READY;
  73.         return HAL_ERROR;
  74.       }
  75.     }

  77.     /* 发送CMD38 ERASE命令 */
  78.     errorstate = SDMMC_CmdErase(hsd->Instance, 0UL);
  79.     if(errorstate != HAL_SD_ERROR_NONE)
  80.     {
  81.       /* 清除所有静态标志 */
  82.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
  83.       hsd->ErrorCode |= errorstate;
  84.       hsd->State = HAL_SD_STATE_READY;
  85.       return HAL_ERROR;
  86.     }

  88.     hsd->State = HAL_SD_STATE_READY;

  90.     return HAL_OK;
  91.   }
  92.   else
  93.   {
  94.     return HAL_BUSY;
  95.   }
  96. }
复制代码

函数描述：

此函数主要用于SD卡擦除。

函数参数：

  第1个参数是SD_HandleTypeDef类型结构体指针变量。
  第2个参数是擦除的起始扇区地址，地址单位是第几个扇区（512字节为一个扇区）。
  第3个参数是擦除的结束扇区地址，地址单位是第几个扇区（512字节为一个扇区）。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

  1. /**
  2. * @brief  Erases the specified memory area of the given SD card.
  3. * @param  StartAddr: Start byte address
  4. * @param  EndAddr: End byte address
  5. * @retval SD status
  6. */
  7. uint8_t BSP_SD_Erase(uint32_t StartAddr, uint32_t EndAddr)
  8. {

  10.   if( HAL_SD_Erase(&uSdHandle, StartAddr, EndAddr) == HAL_OK)
  11.   {
  12.     return MSD_OK;
  13.   }
  14.   else
  15.   {
  16.     return MSD_ERROR;
  17.   }
  18. }
复制代码

87.5 总结
本章节就为大家讲解这么多，更多SDMMC知识可以看STM32H7的参考手册。


赞 收藏 评论0 发布时间：2021-11-6 23:38

举报

0个回答

所属标签

关于
意法半导体
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
STM32N6 AI生态系统
STM32MCU,MPU高性能GUI
ST ACEPACK电源模块
意法半导体生物传感器
STM32Cube扩展软件包
关注我们
st-img 微信公众号
st-img 手机版