87.1 初学者重要提示
0 [& W- ~6 k7 t* N0 L0 d3 h3 W- |  对于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：
  
3 o  C3 D+ }; M- g. Q87.2 SDMMC总线基础知识
87.2.1 SDMMC总线的硬件框图
认识一个外设，最好的方式就是看它的框图，方便我们快速的了解SDMMC的基本功能，然后再看手册了解细节。
) Z/ V% s- ~" @  G) y7 }  `

4 \! [- e- L) E* ?通过这个框图，我们可以得到如下信息：

sdmmc_ker_ck输入
; e* b% |. S; [6 m- [, }" ISDMMC内核时钟。

  sdmmc_hclk输入
AHB时钟。
# f& M; X9 h, l7 \# |, r& ]& l
  sdmmc_it输出
9 L- V) s# v2 D* w. t& ESDMMC全局中断。
/ Z' O$ f* J3 `# @
- H4 v( ]7 \: m# l; ]/ N  sdmmc_dataend_trg输出
! z8 f) ]% k4 ?9 j6 VMDMA的SDMMC数据接收触发信号。
+ W3 X5 _; M9 I/ b5 V: d* C) I
, r& v% k* B4 x8 K  SDMMC_CMD
$ i0 l, j' Y* l  qSD/SDIO/MMC卡双向/响应信号。
0 B* G; N0 V% U3 \; q$ A
5 Z! m1 \9 f5 q; z3 E5 Z  SDMMC_D[7:0]
SD/SDIO/MMC卡双向数据线。

/ x2 P6 a  H: F( z; P  SDMMC_CKIN
来自SD/SDIO/MMC卡的外部驱动器的时钟反馈（用于SDR12，SDR25，SDR50和DDR50）。

  SDMMC_CK
SD/SDIO/MMC卡的时钟。
9 V' K9 o) {+ ]' a" I9 Q8 ?
  SDMMC_CDIR
SDMMC_CMD信号的SD/SDIO/MMC卡I/O方向指示。

  A- e$ I/ l4 }% z) ], E, Z  SDMMC_D123DIR
, y7 h% X' \( ]# O# U1 ZSDMMC_D[3:1]数据线的SD/SDIO/MMC卡I/O方向指示。
( R! _' ]/ u& l8 a% L
  SDMMC_D0DIR
! j8 ^+ ~! n! z& m$ N% x! lSDMMC_D0数据线的SD/SDIO/MMC卡I/O方向指示。

6 ~( g6 X  P+ n  LSTM32H7有两个SDMMC控制器，SDMMC1和SDMMC2，这两个控制器支持的功能是一样的。
" @( N" X! o( |9 R) M7 L+ h/ Y# y
87.2.2 SDMMC时钟
) J/ F: N+ e. F; F0 O1 t9 e3 kSDMMC控制器的时钟来源：

  s" f* N1 E: s2 t% p% I0 }

  i, H% |8 U, q% I/ l4 V' O
+ }' y* m9 w/ G+ r* s9 M, ySDMMC1和SDMMC2时钟源是一样的：
9 m' z, X+ L+ [4 u
; B  |3 e2 f/ A

+ Y- I* Q: V+ B$ _/ H& v1 ]
87.2.3 SDMMC1和SDMMC2支持的RAM空间区别
2 f' N2 Y6 S$ [0 |注：大家应用时要特别注意这个问题。
1 n/ w7 l' j* T- F" k  A3 E( C
) @2 X5 G3 `* {! [使用STM32H7的SDIO1仅支持AXI SRAM，而SDIO2是AXI，SRAM1,SRAM2和SRAM3都支持的

* O6 N/ z- d+ {7 J# B; M
6 j) k7 s8 m* ~$ {' b87.2.4 SDMMC支持的速度
% v9 F# y. D& a; b0 u驱动SD卡支持的最大总线速度：
) A* k1 x% F# L& f1 m
- c6 k- O  x! R2 g

/ c6 }% {' V0 s驱动eMMC支持的最大总线速度：
; K& Z8 i; H6 A, G

4 N" S8 h8 ^' p$ T- w3 p关于这两个数据表，注意以下几点：
. a& @7 {8 f6 W
) q( x) H' `6 K& ]' d/ i. [  驱动SD卡最大支持4bit，驱动eMMC最大支持8bit。
3 @$ B7 ?& W- K9 z/ F9 p  针对信号电压1.8V或者1.2V，STM32H7需要外接专门的PHY芯片才可以驱动。
0 `  U, h4 H6 _1 ^6 }  最大IO翻转限制说的是SDR50，SDR104这种高速通信。平时用的DS，HS这种，无压力，刷满速不成问题。
; Q' W! r9 O3 M$ w: u$ A1 {87.2.5 SDMMC支持UHS-I模式
STM32H7的SDIO外接支持UHS-I 模式 (SDR12, SDR25, SDR50, SDR104和DDR50)需要1.8的电平转换器。STM32H7参考手册给了一个型号ST6G3244ME：
$ l: c0 ~8 Q* M0 y  x* G

; K' [, a* Z. K: ~

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

5 G% x6 T$ V5 z0 J: ?/ e" h87.3 SDMMC总线的HAL库用法
87.3.1 SDMMC总线结构体SD_TypeDef
5 o/ T- W( ~* F6 T! w8 bSDMMC总线相关的寄存器是通过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  */
   - i; h0 R5 T9 O6 ]6 Z) l/ K- A7 |& _
7.   __IO uint32_t CMD;            /*!< SDMMC command register,                   Address offset: 0x0C  */
   & e7 W; v0 M: Z' m6 f9 s  U
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  */
    ( q5 }" _4 E  r9 C! u
11.   __I uint32_t  RESP3;          /*!< SDMMC response 3 register,                Address offset: 0x1C  */
    + S: v8 Q! w3 @, `! Z, c
12.   __I uint32_t  RESP4;          /*!< SDMMC response 4 register,                Address offset: 0x20  */
    2 Q* N/ g% B6 I# l4 F! y: m0 ]
13.   __IO uint32_t DTIMER;         /*!< SDMMC data timer register,                Address offset: 0x24  */
    
14.   __IO uint32_t DLEN;           /*!< SDMMC data length register,               Address offset: 0x28  */
    & [$ N) v& m9 @5 t" J
15.   __IO uint32_t DCTRL;          /*!< SDMMC data control register,              Address offset: 0x2C  */
    , G. A' d; C3 Y# E) Z  [+ F- b
16.   __I uint32_t  DCOUNT;         /*!< SDMMC data counter register,              Address offset: 0x30  */
    
17.   __I uint32_t  STA;            /*!< SDMMC status register,                    Address offset: 0x34  */
    . B9 `. v- k, Y, Z( y6 |
18.   __IO uint32_t ICR;            /*!< SDMMC interrupt clear register,           Address offset: 0x38  */
      I# Q0 t5 x, P  j( V
19.   __IO uint32_t MASK;           /*!< SDMMC mask register,                      Address offset: 0x3C  */
    : ]5 e2 s/ B% ?6 z8 b; f4 L
20.   __IO uint32_t ACKTIME;        /*!< SDMMC Acknowledgement timer register,     Address offset: 0x40  */
    ) M' Z1 Z8 h3 h# R) c  ]. A4 L! Q4 z% P2 [
21.   uint32_t      RESERVED0[3];   /*!< Reserved, 0x44 - 0x4C - 0x4C                                    */
    ( p& k9 z. E* S9 P+ Q& G) Q
22.   __IO uint32_t IDMACTRL;       /*!< SDMMC DMA control register,               Address offset: 0x50  */
    + e) H9 L$ a# n4 Y. V' O9 [
23.   __IO uint32_t IDMABSIZE;      /*!< SDMMC DMA buffer size register,           Address offset: 0x54  */
    * C% o; J1 A: {3 d% v
24.   __IO uint32_t IDMABASE0;      /*!< SDMMC DMA buffer 0 base address register, Address offset: 0x58  */
    ! z$ p# s0 r% y- f% J$ H
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  */
    % t- r- D/ X" X" ]
28.   uint32_t      RESERVED2[222]; /*!< Reserved, 0x84-0x3F8                                            */
    9 c' d& A0 F5 y- O6 b# @
29.   __IO uint32_t IPVR;           /*!< SDMMC data FIFO register,                 Address offset: 0x3FC */
    ' k. X: W0 Z$ ^$ q0 H9 R
30. } SDMMC_TypeDef;

复制代码

+ |- E) [7 a; V5 l这个结构体的成员名称和排列次序和CPU的寄存器是一 一对应的。
' y% `2 p9 `6 L- C' A: F
__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：
7 i( |; j$ a/ W% Z
; Z) p2 v: q' F' l0 i8 j7 o- ^% m

1. #define     __O     volatile             /*!< Defines 'write only' permissions */
   - j" `9 g# v' m% k0 b9 L
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)
   
4. 
   7 `9 P1 M& q7 b: _, x* _0 H  r
5. #define SDMMC1_BASE           (D1_AHB1PERIPH_BASE + 0x7000UL)
   
6. #define SDMMC2_BASE           (D2_AHB2PERIPH_BASE + 0x2400UL)
   ( }4 M: S: {$ _2 N
7. 
   ( h+ w- H0 z- Y6 H+ ?/ U5 u
8. #define SDMMC1              ((SDMMC_TypeDef *) SDMMC1_BASE)
   
9. #define SDMMC2              ((SDMMC_TypeDef *) SDMMC2_BASE) <----- 展开这个宏，(SDMMC_TypeDef *)0x48022400

复制代码

# O' T2 ~; _( O* ]我们访问SDMMC1的CMD寄存器可以采用这种形式：SDMMC1->CMD = 0。
) X4 |# [2 D& k: h7 l+ O) }
3 y/ v* A) ?! h/ E. j87.3.2 SDMMC总线初始化结构体SD_InitTypeDef
6 W: p, o; y) A2 m+ o' B下面是SDMMC总线的初始化结构体：
  ?) ^4 W1 e& }

1. #define SD_InitTypeDef      SDMMC_InitTypeDef
   $ [' ~2 I1 [* i5 T$ B) l! E8 u
2. typedef struct
   9 y: E! D" H+ o5 v
3. {
   0 q) _1 C( k; K- k
4.   uint32_t ClockEdge;            
   : z' l0 Y, z' o7 U
5.   uint32_t ClockPowerSave;      
   6 N1 x3 L$ @1 a1 p. E8 B/ [+ b& ?
6.   uint32_t BusWide;            
   # ?3 a8 Y( _4 `3 X1 C
7.   uint32_t HardwareFlowControl;  
   8 c. y4 n" _7 L; h9 [8 a* h% |
8.   uint32_t ClockDiv;            
   / S/ f2 u  Y1 P+ X; T/ U+ q' Y
9. #if (USE_SD_TRANSCEIVER != 0U)
   
10.   uint32_t TranceiverPresent;   
    
11. #endif
    7 k$ I0 L9 A$ T! l- \
12. }SDMMC_InitTypeDef;

复制代码

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

  ClockEdge
用于设置SDMMC的数据或者命令变化的时钟沿。

1. #define SDMMC_CLOCK_EDGE_RISING               ((uint32_t)0x00000000U)
   " V9 i) ~9 _1 f' v$ q( ?
2. #define SDMMC_CLOCK_EDGE_FALLING              SDMMC_CLKCR_NEGEDGE

复制代码

  ClockPowerSave
4 c+ I1 s% i8 @6 {' O4 W! t用于设置空闲状态，是否输出时钟。

1. #define SDMMC_CLOCK_POWER_SAVE_DISABLE         ((uint32_t)0x00000000U)
   , w- n4 U8 Z2 T+ l1 b0 s* U
2. #define SDMMC_CLOCK_POWER_SAVE_ENABLE          SDMMC_CLKCR_PWRSAV

复制代码

  BusWide
* x: ~! i; `# Q( h; a" @用于设置SDMMC总线位宽。
* y/ x% ]* ~; `. V5 Y6 \) Z$ O

1. #define SDMMC_BUS_WIDE_1B                      ((uint32_t)0x00000000U)
   
2. #define SDMMC_BUS_WIDE_4B                      SDMMC_CLKCR_WIDBUS_0
   3 A1 q, T2 u! Y1 R2 m
3. #define SDMMC_BUS_WIDE_8B                      SDMMC_CLKCR_WIDBUS_1

复制代码

8 B- n; g- o' X  HardwareFlowControl
% D1 [. W) D% B' T' }7 e# R用于设置时候使能硬件流控制。

1. #define SDMMC_HARDWARE_FLOW_CONTROL_DISABLE    ((uint32_t)0x00000000U)
   0 @+ ]3 F  b3 i- m4 l- p: t% Y& c
2. #define SDMMC_HARDWARE_FLOW_CONTROL_ENABLE     SDMMC_CLKCR_HWFC_EN

复制代码

9 N) t  {) R# R; ^" D  ClockDiv
3 I$ b1 E1 i5 R3 n! Q8 ]: ]用于设置SDMMC时钟分频，参数范围0到1023。

  TranceiverPresent
用于设置是否带1.8V收发器。
" j: W7 e* |  y" X6 U4 c

1. #define SDMMC_TRANSCEIVER_UNKNOWN             ((uint32_t)0x00000000U)
   
2. #define SDMMC_TRANSCEIVER_NOT_PRESENT         ((uint32_t)0x00000001U)
   6 n! m+ s" ^5 v: r& {, F  n( C
3. #define SDMMC_TRANSCEIVER_PRESENT             ((uint32_t)0x00000002U)

复制代码

% [" B$ z" g8 ?; T: z5 h0 ^- r3 P87.3.3 SDMMC接SD卡信息结构体HAL_SD_CardInfoTypeDef
下面是SDMMC总线的卡信息结构体：
1 t/ _# w# \6 E- `; ]- B" c+ W

1. typedef struct
   
2. {
   
3.   uint32_t CardType;                     /*!< Specifies the card Type                         */
   . o# [) B: K( r. }7 n5 ?% ?& f
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             */
   6 Z+ c( K4 h$ I6 k: t( b: [0 e1 H
7.   uint32_t BlockNbr;                     /*!< Specifies the Card Capacity in blocks           */
   ! F, N+ T9 _8 M
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           */
    6 S+ |. r3 k8 _3 A3 ~
11.   uint32_t CardSpeed;                    /*!< Specifies the card Speed                        */
    7 H- d* L' A7 Y: C/ \: p( G! a
12. }HAL_SD_CardInfoTypeDef;

复制代码

下面将结构体成员逐一做个说明：
+ B8 e0 M0 a! b( j3 b+ W( w
CardType
9 M' G" u" D# [: `卡类型。
5 r: a# N8 O3 G  _

1. /*!< SD Standard Capacity <2Go                        */
   & i4 ?! Y) a! d7 a
2. #define CARD_SDSC                  ((uint32_t)0x00000000U)
   
3. /*!< SD High Capacity <32Go, SD Extended Capacity <2To  */
   * s# f9 I. L" O* C
4. #define CARD_SDHC_SDXC             ((uint32_t)0x00000001U)  
   & S+ ]/ U& {1 L3 T  l3 j
5. #define CARD_SECURED               ((uint32_t)0x00000003U)

复制代码

. ]/ E: u, ]2 p" Z! Y, I6 Y. A  CardVersion
卡版本。

1. #define CARD_V1_X                  ((uint32_t)0x00000000U)
   * f" R# I* {* {! J4 q$ r
2. #define CARD_V2_X                  ((uint32_t)0x00000001U)

复制代码

  }2 V; u* B: ^  Class
  ^! u4 J: i  b& Q0 F! h. c8 E卡类型。
3 |" P  P( `9 H) \( j
+ u0 V& y9 [1 X8 l  RelCardAdd
2 n  ~% a6 Y7 [. y! e  m! q2 Y卡相对地址。

  BlockNbr
整个卡的块数。

  BlockSize
每个块的字节数。
* V/ @* p1 b* c) K
0 M+ O1 O# M0 p# a5 L! `  LogBlockNbr
整个卡的逻辑块数。
* _% d. N2 ~/ S' U# i0 R5 K/ j1 Q
  LogBlockSize
" m# o3 [3 y) }# k7 W. |; Q逻辑块大小

1. #define SPI_FIRSTBIT_MSB                              (0x00000000UL)
   
2. #define SPI_FIRSTBIT_LSB                              SPI_CFG2_LSBFRST

复制代码

CardSpeed
用于设置是否使能SPI总线的TI模式。
( }5 E7 i% o* J$ C2 ^

1. /*!< Normal Speed Card <12.5Mo/s , Spec Version 1.01    */
   
2. #define CARD_NORMAL_SPEED        ((uint32_t)0x00000000U)  
   ; z' ]3 O9 T  X8 b2 i
3. 
   
4. /*!< High Speed Card <25Mo/s , Spec version 2.00        */
   
5. #define CARD_HIGH_SPEED          ((uint32_t)0x00000100U)
   2 R' j1 @( n* l1 r" A7 U0 ~- S  R% y
6. 
   & J) p. v4 K" }
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)  

复制代码

" d( b) O5 U2 }4 o+ B& I3 x87.3.4 SDMMC总线句柄结构体SD_HandleTypeDef
+ D, K2 D& N9 h下面是SDMMC句柄结构体：
0 ?/ R; P! _  b/ {% D
' V' V2 S: |* A9 f8 |: U

1. #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
   ' G# I6 K2 T' F
2. typedef struct __SD_HandleTypeDef
   
3. #else
   ) x! b; ]* a# l$ Y0 P7 j7 ~
4. typedef struct
   
5. #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
   
6. {
   $ ?/ R- \+ F% j. H$ Q/ A9 f2 D1 W, R; W' n
7.   SD_TypeDef                   *Instance;        /*!< SD registers base address           */
   7 {  o# K+ [, Q% X4 o
8.   SD_InitTypeDef               Init;             /*!< SD required parameters              */
   ' l7 f$ f) ?& a% \; N9 @, a
9.   HAL_LockTypeDef              Lock;             /*!< SD locking object                   */
   " X0 f' P- c6 o' ^+ j
10.   uint8_t                      *pTxBuffPtr;      /*!< Pointer to SD Tx transfer Buffer    */
    
11.   uint32_t                     TxXferSize;       /*!< SD Tx Transfer size                 */
    - i7 _: ~: d, ?% ]( w% J. a5 R0 k
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                 */
    ' f) A+ F$ M' O/ w3 A2 j
15.   __IO HAL_SD_StateTypeDef     State;            /*!< SD card State                       */
    2 O) c5 \3 E7 s) V
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 */
    6 |1 V" @2 D# r
20. 
    2 Y0 X" B( T" B0 u" f4 T2 A$ q
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);
      v! G% E5 z: D, |  s: B. K+ J6 ^5 Y6 [
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);
    * Z9 |) K8 n+ [3 g0 q5 J: y
29.   void (* Write_DMADblBuf1CpltCallback)   (struct __SD_HandleTypeDef *hsd);
    7 W6 K! ?3 J% m* |
30. #if (USE_SD_TRANSCEIVER != 0U)
    
31.   void (* DriveTransceiver_1_8V_Callback) (FlagStatus status);
    % `- V+ l5 m9 U. P  v
32. #endif /* USE_SD_TRANSCEIVER */
    
33. 
    + c( [# ~0 d9 h% k% j1 {+ d% A5 Z
34.   void (* MspInitCallback)                (struct __SD_HandleTypeDef *hsd);
    ! N& h7 D7 p; Z2 v
35.   void (* MspDeInitCallback)              (struct __SD_HandleTypeDef *hsd);
    5 x5 h3 H. o; F5 j& Y3 n
36. #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
    
37. }SD_HandleTypeDef;

复制代码

注意事项：

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

. {& [4 V: X, W9 c1 e  #define   USE_HAL_SD_REGISTER_CALLBACKS   1
8 o. }* A% D, W3 b
) f0 D& a  x+ Y- n通过函数HAL_SD_RegisterCallback注册回调，取消注册使用函数HAL_SD_UnRegisterCallback。

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

  SD_TypeDef   *Instance
4 B: ~: ^4 h7 e( B这个参数是寄存器的例化，方便操作寄存器。
1 N  M5 m: \1 g1 x8 T
+ ?3 ~% t0 c( c. Y$ A& J) ~+ w& N  SD_InitTypeDef  Init
这个参数在本章节3.2小节已经进行了详细说明。
1 x/ k. ]- P; H* n' O: w* _% X' z
87.4 SDMMC总线源文件stm32h7xx_hal_sd.c
此文件涉及到的函数较多，这里把几个常用的函数做个说明：

' g& e9 R/ M4 Y0 Z1 d  HAL_SD_Init
2 Y. x6 Z; ]7 {% N& ~$ D6 I  HAL_SD_DeInit
  HAL_SD_ReadBlocks
4 ~- w; m0 b) R  HAL_SD_WriteBlocks
8 N0 q! h0 e; r0 H  HAL_SD_ReadBlocks_DMA
+ c9 M6 k  Q$ D/ T  HAL_SD_WriteBlocks_DMA
  HAL_SD_Erase
( b$ t8 @7 y9 \8 D: z5 ~87.4.1 函数HAL_SD_Init
函数原型：

1 ]  J3 C4 c0 D+ f% R0 m6 O

1. HAL_StatusTypeDef HAL_SD_Init(SD_HandleTypeDef *hsd)
   2 ^* U5 E) L. B7 T
2. {
   
3.   HAL_SD_CardStatusTypeDef CardStatus;
   
4.   uint32_t speedgrade, unitsize;
   " E8 W- X5 Q7 p' h! k0 u
5.   uint32_t tickstart;
   9 `1 I# a) ~% ?) f9 \
6. 
   6 t5 m& ^" q- i5 E
7.   /* 检查句柄是否有效 */
   - y7 b7 W: c: e6 `
8.   if(hsd == NULL)
   
9.   {
   
10.     return HAL_ERROR;
    $ A: [6 P" g5 V5 ~1 T$ j
11.   }
    
12. 
    
13.   /* 检查参数 */
    , S5 ]) F. S$ D4 o2 p# y
14.   assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));
    
15.   assert_param(IS_SDMMC_CLOCK_EDGE(hsd->Init.ClockEdge));
    ) a$ M6 c; N/ J$ Y8 d
16.   assert_param(IS_SDMMC_CLOCK_POWER_SAVE(hsd->Init.ClockPowerSave));
    5 R) ^6 V8 F3 v) v2 e
17.   assert_param(IS_SDMMC_BUS_WIDE(hsd->Init.BusWide));
      S0 j+ R+ F+ `1 D: L2 z& B
18.   assert_param(IS_SDMMC_HARDWARE_FLOW_CONTROL(hsd->Init.HardwareFlowControl));
    
19.   assert_param(IS_SDMMC_CLKDIV(hsd->Init.ClockDiv));
    0 k0 p1 W7 i1 O1 o% L; L
20. 
    
21.   if(hsd->State == HAL_SD_STATE_RESET)
    # a( G6 |3 \; p* g+ S
22.   {
    
23.     /* 开锁 */
    
24.     hsd->Lock = HAL_UNLOCKED;
    / f# x1 f! }/ O+ U( O9 S7 Q1 A
25. 
    , j5 j9 V& ?: Y0 s& ~* y
26. #if (USE_SD_TRANSCEIVER != 0U)
    3 N& Z: T5 g+ H
27.     /* 兼容 */
    
28.     if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_UNKNOWN)
    5 L7 h4 A2 ^5 b# X% T- e
29.     {
    2 n. K7 r6 |: k+ o7 ?" h* Z# ^! H
30.       hsd->Init.TranceiverPresent = SDMMC_TRANSCEIVER_PRESENT;
    5 a& \1 b4 I5 H( I  ^5 N
31.     }
    9 B7 q9 b% W( N7 k- t5 O4 n0 n9 z& z
32. #endif
    
33. #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
    1 o7 y6 q" h- w( G! P8 F( ^% ?3 [
34.     /* 复位回调 */
    * n# Q+ r, s6 ^" W$ s
35.     hsd->TxCpltCallback    = HAL_SD_TxCpltCallback;
    
36.     hsd->RxCpltCallback    = HAL_SD_RxCpltCallback;
    " L( {" ~3 K" Z2 D: y% S4 D
37.     hsd->ErrorCallback     = HAL_SD_ErrorCallback;
    
38.     hsd->AbortCpltCallback = HAL_SD_AbortCallback;
    
39.     hsd->Read_DMADblBuf0CpltCallback = HAL_SDEx_Read_DMADoubleBuf0CpltCallback;
    ! }3 X5 B3 z& r, }
40.     hsd->Read_DMADblBuf1CpltCallback = HAL_SDEx_Read_DMADoubleBuf1CpltCallback;
    
41.     hsd->Write_DMADblBuf0CpltCallback = HAL_SDEx_Write_DMADoubleBuf0CpltCallback;
    : P/ Z; c' x: Q3 H# Y4 S* Y: n
42.     hsd->Write_DMADblBuf1CpltCallback = HAL_SDEx_Write_DMADoubleBuf1CpltCallback;
    6 e2 A) R- v/ f+ ]3 Q
43. #if (USE_SD_TRANSCEIVER != 0U)
    
44.     if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)
    - v/ c1 b) N3 C" @$ S0 k
45.     {
    
46.       hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback;
    4 c- ^, \9 E+ w0 J  G# b  a1 q& d
47.     }
    $ K9 O& ]! P- w6 y+ s
48. #endif
    
49. 
    
50.     if(hsd->MspInitCallback == NULL)
    
51.     {
    
52.       hsd->MspInitCallback = HAL_SD_MspInit;
    
53.     }
    ) R5 ^2 T* R( I0 Y+ f2 _
54. 
    + d( R2 y4 r% O
55.     /* 初始化底层 */
    
56.     hsd->MspInitCallback(hsd);
    
57. #else
    6 j+ R1 Q4 C, X7 \6 a  o( i7 i
58.     /* 初始化底层硬件 GPIO, CLOCK, CORTEX...etc */
    . _/ q9 V8 b* O8 K3 P% i* Q
59.     HAL_SD_MspInit(hsd);
    
60. #endif /* USE_HAL_SD_REGISTER_CALLBACKS */
    
61.   }
    
62. 
    . |7 B! g7 D" G- ], W$ k- d( q8 M
63.   hsd->State = HAL_SD_STATE_BUSY;
    
64. 
    " v& t. h8 w; e, H5 k& e
65.   /* 初始化卡参数 */
    
66.   if (HAL_SD_InitCard(hsd) != HAL_OK)
    . U. m7 T! }2 b2 ^
67.   {
    
68.     return HAL_ERROR;
    
69.   }
    9 e: c  G1 s/ R
70. 
    
71.   if( HAL_SD_GetCardStatus(hsd, &CardStatus) != HAL_OK)
    ; ~" Z& p8 x0 T8 g' A
72.   {
    
73.     return HAL_ERROR;
    
74.   }
    
75.   /* 获取卡速度等信息 */
    . n; R, N/ I' e. z) ^
76.   speedgrade = CardStatus.UhsSpeedGrade;
    
77.   unitsize = CardStatus.UhsAllocationUnitSize;
    
78.   if ((hsd->SdCard.CardType == CARD_SDHC_SDXC) && ((speedgrade != 0U) || (unitsize != 0U)))
    0 ^, P+ H( x8 {& }) b
79.   {
    
80.     hsd->SdCard.CardSpeed = CARD_ULTRA_HIGH_SPEED;
    
81.   }
    % ?$ p7 T. z$ `6 R
82.   else
    : E, a1 u2 M$ D
83.   {
    
84.     if (hsd->SdCard.CardType == CARD_SDHC_SDXC)
    
85.     {
    + \+ X2 Y' r# _8 B, q
86.       hsd->SdCard.CardSpeed  = CARD_HIGH_SPEED;
    - [7 Z6 A  Y4 R; A- _! ^3 w
87.     }
    : s; w( }4 w6 Q2 Q+ }) N
88.     else
    ; G5 s; C' B# R& p
89.     {
    / l+ b2 Y' _, s& ^8 _: ?+ |
90.       hsd->SdCard.CardSpeed  = CARD_NORMAL_SPEED;
    
91.     }
    8 x5 C5 P. ~1 w3 T+ J. O
92. 
    & Y. @# D  M6 n) \- R. F
93.   }
    5 \8 N4 N6 w2 D7 }
94.   /* 配置总线位宽 */
      ]3 t( L& d% N( ?8 B! t( x, v- Q' o
95.   if(HAL_SD_ConfigWideBusOperation(hsd, hsd->Init.BusWide) != HAL_OK)
    
96.   {
    2 J$ ~( V( W, z" \' g
97.     return HAL_ERROR;
    - j; M' C7 y- `. q1 z
98.   }
    
99. 
      e% v5 a! u% e8 k: c" p6 ^
100.   /* 验证卡初始化后是否就绪 */
     
101.   tickstart = HAL_GetTick();
     
102.   while((HAL_SD_GetCardState(hsd) != HAL_SD_CARD_TRANSFER))
     
103.   {
       ?* D: {, S7 r+ v) ?
104.     if((HAL_GetTick()-tickstart) >=  SDMMC_DATATIMEOUT)
     $ Y' o% u8 s0 j8 S& G4 m
105.     {
     
106.       hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
     ! M7 Z8 a' Q& r" x# d  G+ @$ ?
107.       hsd->State= HAL_SD_STATE_READY;
     * s4 {( u, v6 |* l  r" \6 d  O: G
108.       return HAL_TIMEOUT;
     0 o0 r8 v( r. r+ E6 H, i# _
109.     }
     
110.   }
     
111. 
     0 P. O1 K: i8 Z$ N. v, e
112.   hsd->ErrorCode = HAL_SD_ERROR_NONE;
     7 G! x/ m" f/ {& N
113. 
     ; ]. l8 i- |) w+ z: g: X
114.   hsd->Context = SD_CONTEXT_NONE;
     , N1 q' E; ]5 C! ~9 _
115. 
     
116.   hsd->State = HAL_SD_STATE_READY;
     
117. 
     
118.   return HAL_OK;
     ) P. E0 N, ^% H: Y; _! Y. d
119. }

复制代码

函数描述：
" y! U3 t$ M' T$ M
: B9 S* W5 `; `$ P& m. ?( c' v此函数用于初始化SD卡。
- H* Y  q1 y2 C1 U# @6 S
函数参数：
! T" P( q% e5 r' U" e
$ L9 B2 w% U; J* \0 l% x0 r  第1个参数是SD_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
7 t; Q# C4 @. c; {  E# k  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
( ?$ R6 }% j2 K1 e注意事项：

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

解决办法有三

+ N" O& {  i  U+ ?3 u" v方法1：用户自己初始化SD和涉及到的GPIO等。

, I6 G9 g, v9 o& `方法2：定义SD_HandleTypeDef SdHandle为全局变量。
/ A9 w& M) n0 i9 }" G7 G+ c# C5 _6 u
' m  s" }7 S1 A. u0 S' C; o1 \1 T* u方法3：下面的方法

1. if(HAL_SD_DeInit(&SdHandle) != HAL_OK)
   ' M( E3 G0 ~5 K/ q$ C0 c
2. {
   
3.     Error_Handler();
   ! [" X3 a4 U% {
4. }  
   
5. if(HAL_SD_Init(&SdHandle) != HAL_OK)
   8 G; g8 e2 v* Q& X( y
6. {
   
7.     Error_Handler();
   
8. }

复制代码

使用举例：

" Z, Q$ h$ |/ G( @5 o: B. g

1. SD_HandleTypeDef uSdHandle;
   
2. 
   9 o1 g) C/ m) N# g' t# t
3. uSdHandle.Instance = SDMMC1;
   0 t: _& d5 S0 t. F! {/ R
4. 
   
5. /* if CLKDIV = 0 then SDMMC Clock frequency = SDMMC Kernel Clock
   
6.      else SDMMC Clock frequency = SDMMC Kernel Clock / [2 * CLKDIV].
   + F: c8 U# M  S: C- t
7.      200MHz / (2*2) = 50MHz
   * |; s0 o( L. g' |  z
8. */
   
9. uSdHandle.Init.ClockDiv            = 2;
   $ c' P: f  Z1 K6 I; r- `
10. uSdHandle.Init.ClockPowerSave      = SDMMC_CLOCK_POWER_SAVE_DISABLE;
    ! [! {& I; N+ O, i  e% s. e$ B
11. uSdHandle.Init.ClockEdge           = SDMMC_CLOCK_EDGE_RISING;
    8 x; t. w" w) @
12. uSdHandle.Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE;
    
13. uSdHandle.Init.BusWide             = SDMMC_BUS_WIDE_4B;
      s5 M0 l2 c& ^* S, h8 _
14. if(HAL_SD_Init(&uSdHandle) != HAL_OK)
    
15. {
    2 a" T( i; _. R  p
16.    sd_state = MSD_ERROR;
    
17. }

复制代码

87.4.2 函数HAL_SD_DeInit
. [5 _( q% f+ Q7 G: z函数原型：

1. HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
   ! y" \5 J0 @" H% Q; U5 r; h
2. {
   4 ~8 g4 G, X$ b3 q- [/ z
3.   /* 检查SD卡句柄是否有效 */
   
4.   if(hsd == NULL)
   
5.   {
   + ?# S3 `4 ]7 A4 v! B  w
6.     return HAL_ERROR;
   
7.   }
   $ C8 c! Q. n5 T* D3 y$ a
8. 
   4 v( C& w( j) s! l
9.   /* 检查参数 */
   1 ^* P! @# P/ o2 U1 H
10.   assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));
    
11. 
    0 u% p8 m$ Q. S. r5 ~0 Q5 f
12.   hsd->State = HAL_SD_STATE_BUSY;
    
13. 
    
14. #if (USE_SD_TRANSCEIVER != 0U)
    1 t1 l$ k- Y8 T3 A! {$ {
15.   /* 关闭1.8V模式 */
    
16.   if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)
    8 l; }+ z1 |8 e, R
17.   {
    # n! h6 F& m+ x+ Q* P! o9 w6 @+ x# E+ L
18. #if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
    ( J; z) T: M! _& P& j& R7 ]
19.     if(hsd->DriveTransceiver_1_8V_Callback == NULL)
    
20.     {
    , L' P1 g6 U% Y
21.       hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback;
    : H( d8 _; _; ~% X$ }
22.     }
    * e$ [1 U: H6 e. H+ M
23.     hsd->DriveTransceiver_1_8V_Callback(RESET);
    
24. #else
    
25.     HAL_SD_DriveTransceiver_1_8V_Callback(RESET);
    
26. #endif
    " Y  n6 G, I2 ^, e9 M5 r" y
27.   }                                                                        
    7 O3 D: ]- H, P6 ?5 ~
28. #endif
    , f  o/ S3 _1 x
29. 
    ( I1 |$ @: q  W3 y
30.   /* 关闭SD卡电源 */
    1 t# G. T: x' y' R+ e# a  I, r7 f
31.   SD_PowerOFF(hsd);
    
32. 
    9 a  W2 o/ x) I8 B+ _& V* p
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;
    $ v. {* m2 Z7 v$ o& h$ j, E
37.   }
    
38. 
    3 t5 T: N3 g5 i  x& @6 I) W& D
39.   /* 复位底层硬件 */
    
40.   hsd->MspDeInitCallback(hsd);
    
41. #else
    
42.   /* 复位底层硬件 */
    
43.   HAL_SD_MspDeInit(hsd);
    
44. #endif
    
45. 
    2 I$ e+ k3 j7 K: L. ?% D; O: Z- c
46.   hsd->ErrorCode = HAL_SD_ERROR_NONE;
    6 H- W6 b. ~0 p! f0 I
47.   hsd->State = HAL_SD_STATE_RESET;
    9 o* K" i: ?" A; T
48. 
    * S0 ^- Y; Y7 _
49.   return HAL_OK;
    
50. }

复制代码

函数描述：
' T6 I. q6 Y( D6 f
8 Y% r# M! ?6 |/ _9 u8 T用于复位SD总线初始化。

' r9 V4 f" N% J$ {% D+ B函数参数：

第1个参数是SD_HandleTypeDef类型结构体指针变量。
" @, b2 I; r& H2 K3 k1 X/ n  H 返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
. l2 F# w  C( l( l87.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)
   8 ]6 d8 I# \3 v9 \, U/ ^3 p
2. {
   - I( c9 Z9 e% e% i
3.   SDMMC_DataInitTypeDef config;
   
4.   uint32_t errorstate;
   + |" j& Z; z& B) M
5.   uint32_t tickstart = HAL_GetTick();
   5 o* Z% D( {0 a2 Y3 E9 L. \4 b
6.   uint32_t count, data, dataremaining;
   6 g7 d" L; z! D- a% m! s
7.   uint32_t add = BlockAdd;
   0 d( g, }2 {8 x
8.   uint8_t *tempbuff = pData;
   0 c. Z7 j; ^/ S# K2 v% v5 ]& Q3 ^
9. 
   9 s+ [% J# f/ u8 _( i5 \- y1 h
10.   if(NULL == pData)
    % Y" Z' \' K& p5 ~: Z/ l4 L
11.   {
    
12.     hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
    
13.     return HAL_ERROR;
    
14.   }
    : }; e/ b6 W4 l8 C% d6 }8 y
15. 
    
16.   if(hsd->State == HAL_SD_STATE_READY)
    . o# K* \( x6 L  Z
17.   {
    4 r8 K# j, ~3 y8 \6 i6 F# m9 @7 d
18.     hsd->ErrorCode = HAL_SD_ERROR_NONE;
    ; S. O+ M) \/ g. u$ }
19. 
    - p! h  D" ?' i" o* k& I
20.     if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
    
21.     {
    
22.       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
    
23.       return HAL_ERROR;
    
24.     }
    7 @* i/ C' T. X$ W
25. 
    
26.     hsd->State = HAL_SD_STATE_BUSY;
    
27. 
    
28.     /* 初始化数据控制寄存器 */
    
29.     hsd->Instance->DCTRL = 0U;
    - k8 z* q# j( F6 U
30. 
    
31.     if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
    ) b% A$ g. n) C  \1 W9 k' m
32.     {
    
33.       add *= 512U;
    
34.     }
    0 X9 Y& J' ]5 y2 Y; Z. ^$ i; n
35. 
    
36.     /* 配置SD DPSM (Data Path State Machine) */
    : |6 q8 G' l* E/ S
37.     config.DataTimeOut   = SDMMC_DATATIMEOUT;
    * P6 x) I5 J7 E9 w) T
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);
    9 Z5 E0 Z) Y, @8 q' u$ D% x
44.     __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
    ! w2 `! r; W; D/ k
45. 
    
46.     /* 查询方式块读取 */
    
47.     if(NumberOfBlocks > 1U)
    ) ?8 q; V# P; @% f5 e$ s" [6 D
48.     {
    
49.       hsd->Context = SD_CONTEXT_READ_MULTIPLE_BLOCK;
    ( m' K- F' m( m$ J2 {. l
50. 
    
51.       /* 多块读取命令 */
    
52.       errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
    / q# A3 {/ ^* g" O9 p" \
53.     }
    1 L5 b' N  D! z4 W
54.     else
    
55.     {
    ! m9 }  S  f, p6 {& z9 P- {8 r( e
56.       hsd->Context = SD_CONTEXT_READ_SINGLE_BLOCK;
    
57. 
    
58.       /* 单块读取命令 */
    5 f  a; \5 l4 {- T6 A
59.       errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
    
60.     }
    ' o7 v) X- M; n( E
61.     if(errorstate != HAL_SD_ERROR_NONE)
    
62.     {
    ; m( X9 A. N5 J6 L/ Z" i
63.       /* 清除所有静态标志 */
    
64.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
    
65.       hsd->ErrorCode |= errorstate;
    ' M) R6 N( f/ t( c( c8 ^
66.       hsd->State = HAL_SD_STATE_READY;
    
67.       hsd->Context = SD_CONTEXT_NONE;
    0 q2 t$ O7 f) f# P7 e" m/ t- ~
68.       return HAL_ERROR;
    # k( v: W: i- x1 O8 f* f
69.     }
    
70. 
    $ z: T, z7 ^% O7 Z' a* ^8 _
71.     /* 查询SDMMC标志 */
    
72.     dataremaining = config.DataLength;
    6 k& m: z, G4 _
73.     while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
    / |7 z. m# g! J$ ?. r+ c/ g
74.     {
    
75.       if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF) && (dataremaining >= 32U))
    8 {: I6 c7 M  ]( h9 a
76.       {
    4 S6 W' k* a8 x5 {5 ^
77.         /* 从SDMMC Rx FIFO读取数据 */
    
78.         for(count = 0U; count < 8U; count++)
    
79.         {
    
80.           data = SDMMC_ReadFIFO(hsd->Instance);
    9 g! Z" A& K# `+ ?/ g7 [
81.           *tempbuff = (uint8_t)(data & 0xFFU);
    ' ^% S" R) e0 U" P% i
82.           tempbuff++;
    
83.           *tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
    * P' n0 Z, I4 D# c' t4 B; A. a0 Q
84.           tempbuff++;
    
85.           *tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
    : |$ ^1 R+ f# I# e- }. T$ V
86.           tempbuff++;
    
87.           *tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
    
88.           tempbuff++;
    1 N: G; ^8 t' |% C3 N( A5 n
89.         }
    
90.         dataremaining -= 32U;
    * Z& A9 J- U: Q4 U, ^
91.       }
    
92. 
    
93.       if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))
    ) V/ r1 d: Z* Z6 N) W% y7 w2 t
94.       {
    
95.         /* 清除所有静态标志 */
    
96.         __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
    . [$ M7 y) W3 n, [8 u; ?9 L% L: F! a
97.         hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
    $ i- B- c8 T0 D( g! a% O1 g) A
98.         hsd->State= HAL_SD_STATE_READY;
    / m* P- N8 q- y
99.         hsd->Context = SD_CONTEXT_NONE;
    
100.         return HAL_TIMEOUT;
     2 U( U" X: i$ _$ f$ @6 h
101.       }
     ( m, O" s7 r' r
102.     }
       F% E( Y7 Y: f6 B+ L9 U" H2 P
103.     __SDMMC_CMDTRANS_DISABLE( hsd->Instance);
     
104. 
     
105.     /* 多块读取发送停止传输命令 */
     
106.     if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U))
     
107.     {
     
108.       if(hsd->SdCard.CardType != CARD_SECURED)
     7 h$ a1 P9 G. |- R' }3 t
109.       {
     
110.         /* 发送停止传输命令 */
     
111.         errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
     $ i. ^& o. C0 i
112.         if(errorstate != HAL_SD_ERROR_NONE)
     
113.         {
     
114.           /* 清除所有静态标志 */
     6 T2 H, K6 |" n0 b; O: j
115.           __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
     
116.           hsd->ErrorCode |= errorstate;
     4 {6 [! G: V6 C# z0 \; d% E
117.           hsd->State = HAL_SD_STATE_READY;
     
118.           hsd->Context = SD_CONTEXT_NONE;
     
119.           return HAL_ERROR;
     ' P: q, o3 R! j' `# @0 P3 h/ v
120.         }
     
121.       }
     
122.     }
     
123. 
     
124.     /* 获取错误状态 */
     
125.     if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
     
126.     {
     3 ^" H4 ]5 y! F1 M5 D
127.       /* 清除所有静态标志 */
     : s0 C% p- s1 O* t. }6 o3 i4 S. V% \. L
128.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
     
129.       hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
       G: i: Q! [9 Y7 L9 W8 _* H$ }
130.       hsd->State = HAL_SD_STATE_READY;
     
131.       hsd->Context = SD_CONTEXT_NONE;
     $ D/ Y& n5 z' }/ H& I  ?
132.       return HAL_ERROR;
     
133.     }
     
134.     else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
     5 D: v3 w; U+ u' t% C2 |! H
135.     {
     
136.       /* 清除所有静态标志 */
     
137.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
     
138.       hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
     * b7 P" A3 N! g( ]. h
139.       hsd->State = HAL_SD_STATE_READY;
     
140.       hsd->Context = SD_CONTEXT_NONE;
     * o, }* H: D/ t& ^! P4 _& J/ P# K" Y
141.       return HAL_ERROR;
     1 i& {9 S* c; G8 A3 v' r: S
142.     }
     3 D: N' r$ M$ e# u. E4 Q( g8 |
143.     else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
     $ w' B& {. K7 r6 l" L
144.     {
     7 B4 O$ q- \- o4 Y, M0 c
145.       /* 清除所有静态标志 */
     , g: V4 U6 Q" G; O, {8 A. e0 W1 [
146.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
     - X/ Y2 w. ?, M: V+ P' D
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.     }
     2 g" x; b7 `+ @
152.     else
     
153.     {
     ' \$ h. [+ b$ V+ P3 ~
154.       /* 什么都不做 */
     . }* u$ ~2 [! z! n5 F: y' j) W
155.     }
       W9 w) ]- I, K9 V7 j: o. ]
156. 
     
157.     /* 清除所有静态标志 */
     
158.     __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
     
159. 
     
160.     hsd->State = HAL_SD_STATE_READY;
     
161. 
     
162.     return HAL_OK;
     
163.   }
     
164.   else
     4 [: p0 K" b6 T; l% m
165.   {
     
166.     hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
     
167.     return HAL_ERROR;
     & y1 x& _$ w7 K; C5 A( w
168.   }
     
169. }

复制代码

, |( q% D. B/ F$ q5 _函数描述：

此函数主要用于SD卡数据读取。
2 o2 O+ [! |! P/ X
. _/ y! l: W+ X1 Q2 I  z# k函数参数：
$ ]8 l) n) u" w( c
' h+ T$ R  z% S' {: `$ X  第1个参数是SD_HandleTypeDef类型结构体指针变量。
  T+ O; X, I7 o  第2个参数是接收数据的缓冲地址。
7 w5 J1 y% a! m  第3个参数是要读取的扇区地址，即从第几个扇区开始读取（512字节为一个扇区）。
  第4个参数是读取的扇区数。
  第5个参数是传输过程的溢出时间，单位ms。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
& R% A" ^+ B$ Y3 ^3 M- l1 J使用举例：
" r  p% x2 x" y8 H' ]9 L( _! @
# w0 g: c. X! F) B9 l) G+ |

1. /**
   0 E5 o$ b3 i2 z& g6 `8 J  |
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
   ( H5 K  t; K' \% y( J3 O
4.   * @param  ReadAddr: Address from where data is to be read
   ! K* t' Z$ v& _4 V, E$ R
5.   * @param  NumOfBlocks: Number of SD blocks to read
   ! J6 H# m) r# O) }3 G
6.   * @param  Timeout: Timeout for read operation
   
7.   * @retval SD status
   ; g: H4 T2 U6 c' g; O
8.   */
   
9. uint8_t BSP_SD_ReadBlocks(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks, uint32_t Timeout)
   # v# {3 I+ k; A1 v2 S
10. {
    
11. 
    
12.   if( HAL_SD_ReadBlocks(&uSdHandle, (uint8_t *)pData, ReadAddr, NumOfBlocks, Timeout) == HAL_OK)
    
13.   {
    
14.     return MSD_OK;
    
15.   }
    
16.   else
    8 o; [+ N' C3 r8 k
17.   {
    
18.     return MSD_ERROR;
    
19.   }
    
20. 
    
21. }

复制代码

8 Z5 `$ G4 ]( R8 Q) t87.4.4 函数HAL_SD_WriteBlocks
, E! z7 I7 s& d+ C6 O/ t4 r+ m函数原型：

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;
   . k  o& _: {0 ?1 s+ H6 k
4.   uint32_t errorstate;
   2 w9 W2 n$ n, z2 w* H+ \
5.   uint32_t tickstart = HAL_GetTick();
   
6.   uint32_t count, data, dataremaining;
   5 p8 N6 n2 q. K' _
7.   uint32_t add = BlockAdd;
   
8.   uint8_t *tempbuff = pData;
   
9. 
   
10.   if(NULL == pData)
    ; n5 b: ]8 j6 ]$ F
11.   {
    
12.     hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
    7 X- r1 m5 T/ N: z6 z7 M* h- Y/ G
13.     return HAL_ERROR;
      W8 c- U" S( t8 O: n$ N
14.   }
    
15. 
    - v  q+ g2 n0 m* f
16.   if(hsd->State == HAL_SD_STATE_READY)
    . ^, {, N& K  U0 ^3 N+ U
17.   {
    
18.     hsd->ErrorCode = HAL_SD_ERROR_NONE;
    3 s) f2 i& K; U8 X$ O# B1 B
19. 
    ' M1 P# X: g, _/ z0 d6 ?
20.     if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
    $ c, J: H9 [& V) y
21.     {
    
22.       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
    
23.       return HAL_ERROR;
    
24.     }
    0 ]7 N5 z1 |3 _2 Y
25. 
    , U3 o6 Q! W$ T% b2 D7 m
26.     hsd->State = HAL_SD_STATE_BUSY;
    ( C( i6 X2 I  W4 y
27. 
    : D1 a0 x" H& l! y. i1 i
28.     /* 初始化数据控制寄存器 */
    
29.     hsd->Instance->DCTRL = 0U;
    $ s2 H" q  m. _$ W. n9 q+ D4 M5 n
30. 
    
31.     if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
    ; [* w2 M- Y% P/ {. Y3 F" z! C+ D: w" Z
32.     {
    
33.       add *= 512U;
    7 x; O& n/ l" G# s
34.     }
    7 q, e* j% c( S" w  k- E
35. 
    
36.     /* 配置SD DPSM */
    5 s1 K3 L3 q+ Z. o7 a' s5 i9 {
37.     config.DataTimeOut   = SDMMC_DATATIMEOUT;
    8 J$ L- s. P8 b9 c
38.     config.DataLength    = NumberOfBlocks * BLOCKSIZE;
    / b4 m) ^: ^+ g  {: ?
39.     config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
    ! a( @- H, t' t; ~
40.     config.TransferDir   = SDMMC_TRANSFER_DIR_TO_CARD;
      q: {( E: D. d" y3 _/ @/ C$ j
41.     config.TransferMode  = SDMMC_TRANSFER_MODE_BLOCK;
    $ W; C& q( [4 v. d0 t! T* F
42.     config.DPSM          = SDMMC_DPSM_DISABLE;
    
43.     (void)SDMMC_ConfigData(hsd->Instance, &config);
    - l' R, ~# W8 f8 C7 e
44.     __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
    ( p+ u7 ?1 r5 y+ |& m, ]; a
45. 
    
46.     /* 查询方式块写操作 */
    0 G" `6 w. ~& \9 N" B' I. \. \
47.     if(NumberOfBlocks > 1U)
    " t1 Y& ]$ k/ l6 n
48.     {
      }- J8 G, Z0 i8 C- v4 ?- b5 V1 t
49.       hsd->Context = SD_CONTEXT_WRITE_MULTIPLE_BLOCK;
    
50. 
    7 T5 P0 w' J4 y* X
51.       /* 写多块命令 */
    
52.       errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
    - r. p# p6 n5 U1 |: J
53.     }
    
54.     else
    , N6 z4 r6 T9 \. t
55.     {
    
56.       hsd->Context = SD_CONTEXT_WRITE_SINGLE_BLOCK;
    ' @  _) e4 p. L2 I; v3 O. v- T
57. 
    ( k- s& Z3 p0 t9 f3 k. y- f* _$ n
58.       /* 写单块命令 */
    
59.       errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
    
60.     }
    ' m. O' M2 I+ t. K+ [# v- y" X# M8 W
61.     if(errorstate != HAL_SD_ERROR_NONE)
    5 v6 A- g7 \% o/ l$ e
62.     {
    ) [( {7 U: S7 ?8 v8 E1 d, o
63.       /* 清除所有静态命令 */
    , }, {% h/ ^2 M
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;
    + c) L+ J& x' }  M( Q
68.       return HAL_ERROR;
    - ^" E# ?5 R, E) r! k
69.     }
    % M; P, ]6 o! i
70. 
    
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))
    8 |  L" y6 j2 `' z6 ]
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++;
    . G+ G0 \4 N# s7 `" o
84.           data |= ((uint32_t)(*tempbuff) << 16U);
    9 M. O% m+ ^% m+ d
85.           tempbuff++;
    
86.           data |= ((uint32_t)(*tempbuff) << 24U);
    ( b! _. k% ^1 I3 ~: x2 f
87.           tempbuff++;
    - x) d. l5 j5 |1 C9 U1 `
88.           (void)SDMMC_WriteFIFO(hsd->Instance, &data);
    + _0 t, {5 D$ P, k
89.         }
    5 J* R0 u- g6 d2 m; V5 g$ c8 \
90.         dataremaining -= 32U;
    . ~; W: D% q2 U: |3 e
91.       }
    6 A7 `' M. D& \5 j1 ~! f9 e3 L
92. 
    
93.       if(((HAL_GetTick()-tickstart) >=  Timeout) || (Timeout == 0U))
    
94.       {
    
95.         /* 清除所有静态标志 */
    
96.         __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
    4 X! F) R0 _& ~6 k
97.         hsd->ErrorCode |= errorstate;
    
98.         hsd->State = HAL_SD_STATE_READY;
    . P4 z4 k- B$ T; _1 J
99.         hsd->Context = SD_CONTEXT_NONE;
    # R" C/ P, P" \/ F+ u- Z6 Z# h
100.         return HAL_TIMEOUT;
     , U* ~! ?6 e+ W
101.       }
       M- ^+ h+ r, I: X4 E# ~3 ~
102.     }
     
103.     __SDMMC_CMDTRANS_DISABLE( hsd->Instance);
     
104. 
     
105.     /* 多块写操作，发送停止传输命令 */
     : b7 `/ `( O8 N# Q1 N6 h, z1 h3 L
106.     if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U))
     
107.     {
     
108.       if(hsd->SdCard.CardType != CARD_SECURED)
     
109.       {
     - q3 A! Y2 }8 B" |0 K3 f, [5 L1 t
110.         /* 发送停止传输命令 */
     
111.         errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
     8 {$ r- c5 h) [* G+ B# |
112.         if(errorstate != HAL_SD_ERROR_NONE)
     $ n" Y6 @! _8 K8 ^# g1 C
113.         {
     ; K1 k. y2 q( _& X1 J( v" B2 V
114.           /* 清除所有静态传输标志 */
     1 n) [/ I$ c. c2 c
115.           __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
     
116.           hsd->ErrorCode |= errorstate;
     
117.           hsd->State = HAL_SD_STATE_READY;
     1 s8 I9 O" J: ]. F& y+ ?& A) Q  q
118.           hsd->Context = SD_CONTEXT_NONE;
     ( l  X: ~8 Q  H  C) F$ ?! P7 V5 [: y
119.           return HAL_ERROR;
     7 x9 {/ N7 e  {8 B7 u# C
120.         }
     / n  R; b: ~5 g) h2 j
121.       }
     
122.     }
     
123. 
     $ d, u7 E2 E  w& j; T7 f9 Q
124.     /* Get error state */
     
125.     if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
     / d: a5 n+ P4 m  f9 F0 m
126.     {
     . Z) q* P* q* |2 y
127.       /* 清除所有静态传输标志 */
     ; W6 u/ W# [. |, M
128.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
     & b; O) {* d' s" O+ m1 r+ [
129.       hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
     ' T' ~* H' w- ?# n/ `" v: o
130.       hsd->State = HAL_SD_STATE_READY;
     ! h  V+ ]# m0 j7 F4 C
131.       hsd->Context = SD_CONTEXT_NONE;
     5 H9 A- C- v1 D: ]4 s) A
132.       return HAL_ERROR;
     5 u. c  d6 V5 P* D
133.     }
     
134.     else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
     $ y+ U. {! P# N$ E! \: F) B
135.     {
     : w: B2 S* h$ N( A' c/ |
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;
     ) P' y9 O' w" d, a7 S' n9 e* ]
140.       hsd->Context = SD_CONTEXT_NONE;
     
141.       return HAL_ERROR;
     * g1 {- i% q) D# ]( }
142.     }
     . \$ k7 V/ {7 }! K2 @, l8 q
143.     else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR))
     
144.     {
     * x+ V* H6 |6 C: V! l8 U# |( Y
145.       /* 清除所有静态传输标志 */
     
146.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
     6 R8 J: S" e! c
147.       hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;
     ) K9 J3 ~0 P, e: ]) d
148.       hsd->State = HAL_SD_STATE_READY;
     
149.       hsd->Context = SD_CONTEXT_NONE;
     $ Z& v& D8 u6 o/ i% @
150.       return HAL_ERROR;
     
151.     }
     
152.     else
     $ [. c! g" ]; G0 K
153.     {
     
154.       /* 什么都不做 */
     0 [0 ]+ m7 A( u6 F
155.     }
     
156. 
     
157.       /* 清除所有静态传输标志 */
     
158.     __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
     ; v4 g( ^- X' o6 o+ P
159. 
     
160.     hsd->State = HAL_SD_STATE_READY;
     7 L9 i9 a4 {" M- ^# k2 s8 \( u
161. 
     
162.     return HAL_OK;
       x% w' l% \  q: a( [
163.   }
     
164.   else
     ( a- A2 P4 G& q; x
165.   {
     
166.     hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
     
167.     return HAL_ERROR;
     
168.   }
     
169. }

复制代码

函数描述：
. `9 ^! H* g% m" s; A* G
/ c" Z. ?' @$ H* d3 y, l4 C此函数主要用于向SD卡写入数据。
9 l7 d8 w# [9 z& l
函数参数：
/ F, B% ]/ D- B/ x
  第1个参数是SD_HandleTypeDef类型结构体指针变量。
& ~) l' f8 q1 u# ^+ ]/ m+ v$ }  第2个参数是要写入到SD卡的数据缓冲地址。
  第3个参数是要写入的扇区地址，即从第几个扇区开始写入（512字节为一个扇区）。
0 {9 y) _7 @/ Z% {  第4个参数是读取的扇区数。
  第5个参数是传输过程的溢出时间，单位ms。
& G( U+ |! Y7 i$ r) U+ V' A  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

# s: [: j7 z& ]1 i. ?" _3 W- M/ j

1. /**
   3 R- N. U1 T' ~, d" c+ {2 B+ j  N
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
   1 |# Z3 h  [+ N) h  x( L
8.   */
   
9. uint8_t BSP_SD_WriteBlocks(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks, uint32_t Timeout)
   2 ~: N1 b  ]3 n$ ^2 Y: `9 K
10. {
    , C8 p& O7 N0 Q/ a( j* r
11. 
    
12.   if( HAL_SD_WriteBlocks(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks, Timeout) == HAL_OK)
    
13.   {
    
14.     return MSD_OK;
    0 F: C! w7 C5 R3 r9 t
15.   }
    
16.   else
      |) l' b3 |* V' o
17.   {
    
18.     return MSD_ERROR;
    5 o- c  l  e( S4 [# L1 M
19.   }
    
20. }

复制代码

9 c, Y. P' I7 W: o87.4.5 函数HAL_SD_ReadBlocks_DMA
函数原型：

* q) Y' h; X; G7 A

1. HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
   
2. {
   , m( I9 K9 K  M
3.   SDMMC_DataInitTypeDef config;
   7 h$ n: b, H" k0 P6 v
4.   uint32_t errorstate;
   
5.   uint32_t add = BlockAdd;
   
6. 
   
7.   if(NULL == pData)
   
8.   {
   
9.     hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
   
10.     return HAL_ERROR;
    1 B$ L+ K  M- A$ U% }; u8 c5 D
11.   }
    4 f7 ?+ x" m4 ^, [) Y5 q+ ^
12. 
    $ S5 o% n: Y* Q5 B/ j% S( L1 n
13.   if(hsd->State == HAL_SD_STATE_READY)
    6 d; V  @. [0 k+ r( C1 h7 b
14.   {
    
15.     hsd->ErrorCode = HAL_SD_ERROR_NONE;
    
16. 
    
17.     if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
    / h2 J0 ?' L8 d( b# {
18.     {
    
19.       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
    
20.       return HAL_ERROR;
    9 h! W: q0 m$ A! o
21.     }
    - m# O% E; A( y. Q- a; K
22. 
    
23.     hsd->State = HAL_SD_STATE_BUSY;
    ' x& ]: S0 x" l9 W; t0 y' k
24. 
    
25.   /* 初始化数据控制寄存器 */
    , t8 h/ R- G# ?2 p) M, O
26.     hsd->Instance->DCTRL = 0U;
    
27. 
    
28.     hsd->pRxBuffPtr = pData;
    
29.     hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;
    
30. 
    * u) ]: q$ X9 z# r
31.     if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
    - O" j$ U' ~; s
32.     {
    : g/ G3 X/ L7 I4 ~" E: n% b% U% P
33.       add *= 512U;
    3 B+ V+ d3 W  P9 n3 o
34.     }
    
35. 
    
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;
    " `, Z3 f" [) V5 [# n2 L2 j
41.     config.TransferMode  = SDMMC_TRANSFER_MODE_BLOCK;
    : H, p: x$ b  F1 t/ E! W
42.     config.DPSM          = SDMMC_DPSM_DISABLE;
    . ~: ~) M/ y1 `( R
43.     (void)SDMMC_ConfigData(hsd->Instance, &config);
    * P9 P$ Y% @  {1 c8 [
44. 
    & f$ K7 k( c% k( F% Y) d6 G
45.     __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
    ( a; H# t/ y% e, O+ z; |
46.     hsd->Instance->IDMABASE0 = (uint32_t) pData ;
    
47.     hsd->Instance->IDMACTRL  = SDMMC_ENABLE_IDMA_SINGLE_BUFF;
    ! G: E9 p( O$ }0 Q% T
48. 
    $ W4 L8 f& P. i3 K) ]6 c
49.   /* DMA方式读取多个块 */
    
50.     if(NumberOfBlocks > 1U)
    
51.     {
    
52.       hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
    
53. 
    : o, L% L  n, `9 S/ f3 x
54.    /* DMA方式读取多块命令 */
    
55.       errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
    9 v, [: C4 \* N6 i7 N* |
56.     }
    : S# K( N+ U& J; z( W+ w! @
57.     else
    
58.     {
    
59.       hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_DMA);
    
60. 
    8 d/ \) O" {& T) ?" J
61.    /* 读取单块命令 */
    
62.       errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
    . f; s3 F& n( r+ \" r/ ^
63.     }
    
64.     if(errorstate != HAL_SD_ERROR_NONE)
    
65.     {
    7 D0 j+ o9 E* v! m! W% E
66.    /* 清除所有静态标志 */
    3 j/ z; [" w- X; I
67.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
    ! G: `2 n7 K1 J7 |7 F6 n
68.       hsd->ErrorCode |= errorstate;
    + n/ ~  q0 b  t" Y5 m  s
69.       hsd->State = HAL_SD_STATE_READY;
    
70.       hsd->Context = SD_CONTEXT_NONE;
    3 V0 I$ [* {- B' Q, C
71.       return HAL_ERROR;
    
72.     }
    & O/ B+ l' v; y1 `( a2 B) K: K
73. 
    
74.   /* 使能传输中断 */
    ' U" J* _: R* Z- V* |$ j$ h$ B
75.     __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND));
    
76. 
    
77. 
    % o$ Y& O" z- Z" b# X
78.     return HAL_OK;
    ; ]/ c3 a0 Q& W' l' i8 @
79.   }
    
80.   else
    
81.   {
    0 @) ]) r" g7 I( R
82.     return HAL_BUSY;
    ) c. N4 S9 F! |) i7 N
83.   }
    & C, I: f' z# l7 D* T
84. }

复制代码

9 ]+ s, e. Y! y- t函数描述：
. h( e3 _9 k# m' o; J
此函数主要用于SD卡数据读取，DMA方式。
; [& g8 q& Q" c8 }% @8 w& N* k
0 m/ |6 V4 z& o( i0 H. V( D- p7 }函数参数：

* M9 @$ D4 P! ^% T. ^  第1个参数是SD_HandleTypeDef类型结构体指针变量。
4 g) s. S% R7 U% _/ q  第2个参数是接收数据的缓冲地址。
  第3个参数是要读取的扇区地址，即从第几个扇区开始读取（512字节为一个扇区）。
  第4个参数是读取的扇区数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
& A6 u5 g- Q1 ^6 O: F使用举例：
7 Z( r1 g: H+ b3 Z2 z

1. /**
   6 P0 E1 C, X* F. `' o
2. * @brief  Reads block(s) from a specified address in an SD card, in DMA mode.
   ) Z; Z$ n  ?" t( T( X
3. * @param  pData: Pointer to the buffer that will contain the data to transmit
   . ^& Q, W- Z, l2 n" w+ W
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. {
   : P1 }; z. A9 M: [' U
10. 
    
11.   if( HAL_SD_ReadBlocks_DMA(&uSdHandle, (uint8_t *)pData, ReadAddr, NumOfBlocks) == HAL_OK)
    
12.   {
    
13.     return MSD_OK;
    2 o: Z# ^3 S6 w# @4 {: D7 _
14.   }
    + @' c6 R1 K" n6 p/ t
15.   else
    
16.   {
    
17.     return MSD_ERROR;
    
18.   }
    7 ?# j% t  L2 f4 u6 n3 b
19. }

复制代码

87.4.6 函数HAL_SD_WriteBlocks_DMA
函数原型：

* o+ Z0 B8 N' |: V6 a' B" |3 J

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;
   
6. 
   
7.   if(NULL == pData)
   % D" N5 `2 m5 B
8.   {
   ) u( q# ]/ `' b' A8 I4 z
9.     hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
   1 J  ~* }/ ]8 s) L1 B3 p' Z. V7 N- l
10.     return HAL_ERROR;
    8 D0 Z3 T. c( A" R/ f
11.   }
    
12. 
    
13.   if(hsd->State == HAL_SD_STATE_READY)
    9 O) i; I0 ^. Q4 O9 {+ X" ~, a
14.   {
    
15.     hsd->ErrorCode = HAL_SD_ERROR_NONE;
    
16. 
    
17.     if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
    . f( v: ^; A4 t, f
18.     {
    
19.       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
    
20.       return HAL_ERROR;
    
21.     }
    
22. 
    
23.     hsd->State = HAL_SD_STATE_BUSY;
    ( [9 T% N; k7 u9 t2 ]  a) e
24. 
    ; j0 F+ x2 a; E' U9 o5 l' a; z0 D
25.   /* 初始化数据控制寄存器 */
    2 d0 g* B( }8 f9 S
26.     hsd->Instance->DCTRL = 0U;
    
27. 
    
28.     hsd->pTxBuffPtr = pData;
    
29.     hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;
    
30. 
    
31.     if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
    6 R6 Y. k( X, ~* \1 C( D$ N
32.     {
    
33.       add *= 512U;
    
34.     }
    ' `: P- n7 ~! x4 r  p' i8 C
35. 
    6 {  v+ C3 [* N( `) Y
36.   /* 配置SD DPSM (Data Path State Machine) */
    " _9 G# ]1 h3 i7 y
37.     config.DataTimeOut   = SDMMC_DATATIMEOUT;
    5 Q$ e# o2 E6 H3 a1 ^" }& l
38.     config.DataLength    = BLOCKSIZE * NumberOfBlocks;
    
39.     config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
    
40.     config.TransferDir   = SDMMC_TRANSFER_DIR_TO_CARD;
    ( }$ D! X% u$ ~
41.     config.TransferMode  = SDMMC_TRANSFER_MODE_BLOCK;
    # n- y7 ]4 M0 u4 W+ O, l& c9 a
42.     config.DPSM          = SDMMC_DPSM_DISABLE;
    
43.     (void)SDMMC_ConfigData(hsd->Instance, &config);
    & q: U) G9 \; U/ B% Y# g( i3 m: W
44. 
    # J2 n- F  F. X
45. 
    0 y" K- i. \6 O
46.     __SDMMC_CMDTRANS_ENABLE( hsd->Instance);
    
47. 
    7 S5 B; a& p3 [4 R# V( h$ Z
48.     hsd->Instance->IDMABASE0 = (uint32_t) pData ;
    
49.     hsd->Instance->IDMACTRL  = SDMMC_ENABLE_IDMA_SINGLE_BUFF;
    
50. 
    
51.   /* 查询模式写块 */
    ; J& W3 S5 f1 m0 H
52.     if(NumberOfBlocks > 1U)
    
53.     {
    
54.       hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
    - d+ w0 ?9 B9 H( J6 m/ R8 V
55. 
    
56.     /* 多块写命令 */
    + r- Z& c% x7 r
57.       errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
    / c5 a$ h+ M5 l2 o; X7 Y" D/ h
58.     }
    
59.     else
    8 s: f# Z1 m, F+ \5 F( V3 M; p; w
60.     {
    3 X  ]* S6 T( p+ B
61.       hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_DMA);
    
62. 
    : G# O8 n( K1 E! Y
63.     /* 单块写命令 */
    0 F, F9 r: B- y" m) s; Q
64.       errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
    
65.     }
    * O& C8 X1 O' K; ~; K1 Q
66.     if(errorstate != HAL_SD_ERROR_NONE)
    
67.     {
    0 v& @& k5 r( o# }, L# _
68.     /* 清除静态标志 */
    
69.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
    
70.       hsd->ErrorCode |= errorstate;
    * v7 F% _0 n. e: Q9 |, F4 H: N  M
71.       hsd->State = HAL_SD_STATE_READY;
    
72.       hsd->Context = SD_CONTEXT_NONE;
    8 {% o1 ]3 C* L% j% }$ ?9 w# t
73.       return HAL_ERROR;
    ' X0 L5 y' I5 F( J- ^& I- e
74.     }
    
75. 
    
76.   /* 使能传输中断 Enable */
    
77.     __HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND));
    / V1 j2 C* e0 d, ^; S% W
78. 
    ; L/ U$ s0 v7 n# t
79.     return HAL_OK;
    1 K% o8 C) ?9 W
80.   }
    ) X6 e+ \: P+ q# ?6 K9 ^. h: _4 L
81.   else
    . A/ W! S; m* C
82.   {
    . C2 O- K$ m3 l# S) C. r; d7 h
83.     return HAL_BUSY;
    4 F3 p2 B' x" \
84.   }
    
85. }

复制代码

函数描述：

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

* b# m0 @6 |. y8 w8 h0 C' u6 `函数参数：

0 t  Z- J$ X1 _  第1个参数是SD_HandleTypeDef类型结构体指针变量。
  第2个参数是要写入到SD卡的数据缓冲地址。
) l8 u0 `, F  a% p; _% S5 B  第3个参数是要写入的扇区地址，即从第几个扇区开始写入（512字节为一个扇区）。
  第4个参数是读取的扇区数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：
+ P8 t4 c# x8 V: a$ K4 b0 b
# T, ~8 _: V3 y* S0 v: Y$ j

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
     W* a/ a0 {! Z: v
4. * @param  WriteAddr: Address from where data is to be written
   $ @% R2 G5 F. Y# a# `
5. * @param  NumOfBlocks: Number of SD blocks to write
   - b* V7 `/ a/ u& l
6. * @retval SD status
   5 l5 v6 C2 @; q& O. Z
7. */
   
8. uint8_t BSP_SD_WriteBlocks_DMA(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks)
   / o# }. C. O: @
9. {
   
10. 
    
11.   if( HAL_SD_WriteBlocks_DMA(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks) == HAL_OK)
    2 V% I) I7 j( Q$ T, X9 q& |; \
12.   {
    , J9 k- i2 \" \0 {
13.     return MSD_OK;
    
14.   }
    
15.   else
    2 {7 Q% X! A8 X1 K! N, B
16.   {
    ; c. k3 a: Y5 r. A! R: e/ \. I
17.     return MSD_ERROR;
    
18.   }
    2 M; w8 S7 _1 l/ m; D* w
19. }

复制代码

' H3 [, B8 K9 J, \0 K87.4.7 函数HAL_SD_Erase
函数原型：
# ]0 n+ ?) Z. }7 A
! q# ~! Y- c( R' s" B/ p

1. HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd)
     _9 `+ Q$ A4 S; K; Y
2. {
   
3.   uint32_t errorstate;
   
4.   uint32_t start_add = BlockStartAdd;
   
5.   uint32_t end_add = BlockEndAdd;
   
6. 
   
7.   if(hsd->State == HAL_SD_STATE_READY)
   
8.   {
   
9.     hsd->ErrorCode = HAL_SD_ERROR_NONE;
   7 z1 T+ V! |1 x+ I" @
10. 
    
11.     if(end_add < start_add)
    
12.     {
    1 O0 Z7 N* i" L/ Q, k
13.       hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
    
14.       return HAL_ERROR;
    
15.     }
    ( P  e% @# }5 B5 ]3 d' p; L) d2 }
16. 
    . p, @/ v. j- S  M9 X5 z" }9 f
17.     if(end_add > (hsd->SdCard.LogBlockNbr))
    
18.     {
    3 B+ G: u* _6 c, q  x
19.       hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
    
20.       return HAL_ERROR;
    $ T4 W5 h& S- ]. [: O, B$ K
21.     }
    
22. 
    
23.     hsd->State = HAL_SD_STATE_BUSY;
    6 b* x/ |5 F6 a
24. 
    
25.   /* 检测是否支持擦除命令 */
    
26.     if(((hsd->SdCard.Class) & SDMMC_CCCC_ERASE) == 0U)
    5 x( L/ p5 ~- @. i, P3 i" {; i
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.     }
    / K+ l' u3 G. z8 F1 S2 q
34. 
    
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);
    ! g, H, J) g9 \( B+ L/ y' Y
39.       hsd->ErrorCode |= HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
    
40.       hsd->State = HAL_SD_STATE_READY;
    
41.       return HAL_ERROR;
    . q, F0 x2 w* b8 J
42.     }
    9 p. T3 X; u4 |6 r; H( a% ?
43. 
    
44.   /* 对于高容量卡，获取起始块和结束块 */
    
45.     if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
    ( E5 }: T5 W) ?5 W" x  X$ p+ C
46.     {
    : k3 x1 y" T. J/ r
47.       start_add *= 512U;
    ) F+ o$ ^4 {  }
48.       end_add   *= 512U;
    % w( U" F% v' o9 |) h" ~
49.     }
    
50. 
    
51.     /* 根据sd-card spec 1.0 ERASE_GROUP_START (CMD32) 和 erase_group_end(CMD33) */
      V% g2 ~$ {& |& a$ Y& Z5 A! S  v
52.     if(hsd->SdCard.CardType != CARD_SECURED)
    ! F0 L/ @* r  I5 M2 G- _& K, h" Y
53.     {
    
54.     /* 发送CMD32 SD_ERASE_GRP_START命令带地址参数 */
    
55.       errorstate = SDMMC_CmdSDEraseStartAdd(hsd->Instance, start_add);
    7 O9 R4 ?# T! |$ {- ]
56.       if(errorstate != HAL_SD_ERROR_NONE)
    
57.       {
    + {; c* G& v: c
58.         /* 清除所有静态标志 */
    
59.         __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
    * f' A0 R% `  ^  u1 n
60.         hsd->ErrorCode |= errorstate;
    / j1 N  w6 ]. A" t# h
61.         hsd->State = HAL_SD_STATE_READY;
    8 i1 d1 @- i) |6 o+ \( v
62.         return HAL_ERROR;
    
63.       }
    5 G; S, L8 [) W9 \9 x5 R
64. 
    % _" |8 j* }  `1 s' e- x  I- ]
65.       /* 发送CMD33 SD_ERASE_GRP_END命令，带地址参数 */
    ! N1 M0 B% u9 R% {2 u
66.       errorstate = SDMMC_CmdSDEraseEndAdd(hsd->Instance, end_add);
    3 V. v3 `  F, _
67.       if(errorstate != HAL_SD_ERROR_NONE)
    
68.       {
    
69.         /* 清除所有静态标志 */
    / ^2 q6 F  l) _7 u9 b
70.         __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
    " r' G/ R$ z1 \
71.         hsd->ErrorCode |= errorstate;
    , m9 O/ m: X' Z% j9 T8 l  e
72.         hsd->State = HAL_SD_STATE_READY;
    ! _  A: X( \  k8 F, z2 @  C
73.         return HAL_ERROR;
    
74.       }
    / Z: X, w' {8 r7 E
75.     }
    
76. 
    
77.     /* 发送CMD38 ERASE命令 */
    0 b' M$ u5 l6 n! f, V4 F  z
78.     errorstate = SDMMC_CmdErase(hsd->Instance, 0UL);
    
79.     if(errorstate != HAL_SD_ERROR_NONE)
    # a) s8 W6 l7 K5 F4 }
80.     {
    
81.       /* 清除所有静态标志 */
    ! t! j0 t( X/ U4 L' `
82.       __HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
    ) ]' J9 M6 ]3 ~; D+ B' p1 B
83.       hsd->ErrorCode |= errorstate;
    6 t" ^& F3 @0 s4 ]: A/ \% A
84.       hsd->State = HAL_SD_STATE_READY;
    
85.       return HAL_ERROR;
    
86.     }
    
87. 
    
88.     hsd->State = HAL_SD_STATE_READY;
    0 ]' d1 k7 Y' V0 C' ]6 i' S
89. 
    
90.     return HAL_OK;
    ! o! B; @4 t5 v
91.   }
    
92.   else
    
93.   {
    
94.     return HAL_BUSY;
    
95.   }
    
96. }

复制代码

函数描述：
  i2 U, ?6 E5 A8 K3 C
) z+ o8 M0 a* v) p1 j8 B2 A此函数主要用于SD卡擦除。
* p" J4 P$ _3 K- W' @
/ ?! Z) t2 b4 S3 K# Y5 {8 G0 ~函数参数：

  第1个参数是SD_HandleTypeDef类型结构体指针变量。
  第2个参数是擦除的起始扇区地址，地址单位是第几个扇区（512字节为一个扇区）。
  第3个参数是擦除的结束扇区地址，地址单位是第几个扇区（512字节为一个扇区）。
5 y$ t, t* m5 l- H  |* r  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：
8 T) N% \$ [. D1 q
6 F% P+ R) {( E7 x

1. /**
   
2. * @brief  Erases the specified memory area of the given SD card.
   
3. * @param  StartAddr: Start byte address
   1 R2 ?- E4 M+ |: u7 e; O5 h
4. * @param  EndAddr: End byte address
   
5. * @retval SD status
   
6. */
   
7. uint8_t BSP_SD_Erase(uint32_t StartAddr, uint32_t EndAddr)
   
8. {
   ( @0 R/ g/ x6 f: L4 F
9. 
   ( b' I! s+ y7 g" V. Y8 p
10.   if( HAL_SD_Erase(&uSdHandle, StartAddr, EndAddr) == HAL_OK)
    % H' f% l* T5 O# k( b4 j% g
11.   {
    % ^. D- B1 u* l" Z' W4 @4 _2 o
12.     return MSD_OK;
    # Q% z1 p0 b4 ]& t1 J, L
13.   }
    
14.   else
    + y; V2 ?9 l; {% \# |5 U
15.   {
    ( [) T( Q6 H! x- a5 m
16.     return MSD_ERROR;
    
17.   }
    " V) H; ~5 M2 l1 g
18. }

复制代码

87.5 总结
, Q  {. e  }) @2 S& {. w本章节就为大家讲解这么多，更多SDMMC知识可以看STM32H7的参考手册。
8 m  ^0 G* K8 p: t  p
# V4 G+ {- D7 X' G: @7 d& B