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

[复制链接]

STMCU小助手发布时间：2021-12-26 16:43

文章
文章封面:
文章简介:	对于SDMMC控制SD卡或者eMMC，掌握本章的知识点就够用了，更深入的认识可以看STM32H7的参考手册。

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的基本功能，然后再看手册了解细节。

通过这个框图，我们可以得到如下信息：
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控制器的时钟来源：

SDMMC1和SDMMC2时钟源是一样的：

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

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

% K$ J8 f+ z0 `4 Y6 ~3 v
87.2.4 SDMMC支持的速度
驱动SD卡支持的最大总线速度：

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

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

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

# f% A8 G9 w, `8 l0 L87.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中可以找到这个类型定义：

#define SD_TypeDef SDMMC_TypeDef! }% |' [ T: x, x! T/ x5 ]8 s; O
typedef struct7 I0 I9 [7 W9 K h/ k7 b1 O
{
i6 g; R( I6 F9 J; ?- j
__IO uint32_t POWER; /*!< SDMMC power control register, Address offset: 0x00 */
" K0 @' G" M/ h" t
__IO uint32_t CLKCR; /*!< SDMMC clock control register, Address offset: 0x04 */
1 n; `+ l( U4 W5 o9 f c. B
__IO uint32_t ARG; /*!< SDMMC argument register, Address offset: 0x08 */
1 S( L% r1 m2 \# L E
__IO uint32_t CMD; /*!< SDMMC command register, Address offset: 0x0C */
# ~2 m1 V1 V e# e) R
__I uint32_t RESPCMD; /*!< SDMMC command response register, Address offset: 0x10 */) ?# E: C F; M3 O& G
__I uint32_t RESP1; /*!< SDMMC response 1 register, Address offset: 0x14 */
* f( C9 R3 J- t! J; W1 ]* t8 }1 f" B
__I uint32_t RESP2; /*!< SDMMC response 2 register, Address offset: 0x18 */
; n' r! B2 a; l' Z
__I uint32_t RESP3; /*!< SDMMC response 3 register, Address offset: 0x1C */
, y. l) I# T2 i$ t
__I uint32_t RESP4; /*!< SDMMC response 4 register, Address offset: 0x20 */
2 J* [/ }/ h$ A" V w6 O
__IO uint32_t DTIMER; /*!< SDMMC data timer register, Address offset: 0x24 */) k0 @8 s( i7 z( k! f
__IO uint32_t DLEN; /*!< SDMMC data length register, Address offset: 0x28 */- W- [; \$ v6 M% Z6 m) G: w
__IO uint32_t DCTRL; /*!< SDMMC data control register, Address offset: 0x2C */
. E0 V" e F* I* [8 A1 h
__I uint32_t DCOUNT; /*!< SDMMC data counter register, Address offset: 0x30 */6 c x9 Q1 a" N2 g
__I uint32_t STA; /*!< SDMMC status register, Address offset: 0x34 */# w. W5 u `4 v! ~: `0 k
__IO uint32_t ICR; /*!< SDMMC interrupt clear register, Address offset: 0x38 */
7 k# D: k9 k' |6 ~
__IO uint32_t MASK; /*!< SDMMC mask register, Address offset: 0x3C */
, Z8 U0 y& }, b$ J
__IO uint32_t ACKTIME; /*!< SDMMC Acknowledgement timer register, Address offset: 0x40 */; T/ N x% ^' R+ O! u3 K
uint32_t RESERVED0[3]; /*!< Reserved, 0x44 - 0x4C - 0x4C */) h* i- Q j. m- p0 h5 p
__IO uint32_t IDMACTRL; /*!< SDMMC DMA control register, Address offset: 0x50 */1 J0 \* ^* Y/ d. A3 x
__IO uint32_t IDMABSIZE; /*!< SDMMC DMA buffer size register, Address offset: 0x54 */
9 }& _! g B; H7 g: f0 m+ I
__IO uint32_t IDMABASE0; /*!< SDMMC DMA buffer 0 base address register, Address offset: 0x58 */8 |, y9 @$ i7 c+ D, f9 Q, \! Y S
__IO uint32_t IDMABASE1; /*!< SDMMC DMA buffer 1 base address register, Address offset: 0x5C */. ?$ [( Y. t5 R2 c, X
uint32_t RESERVED1[8]; /*!< Reserved, 0x60-0x7C */. i' @3 T2 L9 r: T- ?
__IO uint32_t FIFO; /*!< SDMMC data FIFO register, Address offset: 0x80 */; {. {9 Z' k0 U6 o2 R4 J0 W9 u
uint32_t RESERVED2[222]; /*!< Reserved, 0x84-0x3F8 */
2 p+ D6 J$ G* {" N+ Y" r0 ^
__IO uint32_t IPVR; /*!< SDMMC data FIFO register, Address offset: 0x3FC */' F6 q8 S: B7 d' v) I
} SDMMC_TypeDef;

复制代码

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

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

#define __O volatile /*!< Defines 'write only' permissions */) K+ j- x' v9 ]0 K- F. h7 }
#define __IO volatile /*!< Defines 'read / write' permissions */

复制代码

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

#define PERIPH_BASE (0x40000000UL)
6 @" m; p0 k* E
#define D1_AHB1PERIPH_BASE (PERIPH_BASE + 0x12000000UL)% u" e: s8 F. d9 d; ]
#define D2_AHB2PERIPH_BASE (PERIPH_BASE + 0x08020000UL). R; t% Z2 y; N% |# t
( Z! h6 g$ g; v8 X3 o4 F# b
#define SDMMC1_BASE (D1_AHB1PERIPH_BASE + 0x7000UL)
1 @( L1 }4 e6 b ^
#define SDMMC2_BASE (D2_AHB2PERIPH_BASE + 0x2400UL)
9 ]6 m9 a A. G) D1 W, k
4 i( L$ X8 A4 B4 \7 s! W6 [3 N
#define SDMMC1 ((SDMMC_TypeDef *) SDMMC1_BASE)
$ A0 ^) ]( j1 r
#define SDMMC2 ((SDMMC_TypeDef *) SDMMC2_BASE) <----- 展开这个宏，(SDMMC_TypeDef *)0x48022400

复制代码

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

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

#define SD_InitTypeDef SDMMC_InitTypeDef
( p$ c' P0 g7 R
typedef struct
' T: J. i7 l" A( I6 n1 F6 R9 k
{
: l& {* \7 e1 ] [& \; d- G
uint32_t ClockEdge;
V \- u, F2 ^* y, y
uint32_t ClockPowerSave;
5 } B$ q) w* x# L
uint32_t BusWide;
8 f* d* o, ^& L8 ]
uint32_t HardwareFlowControl; $ J1 ^, `- T2 K+ L- O
uint32_t ClockDiv; ( c+ A1 _. i |) f: ?: M- f
#if (USE_SD_TRANSCEIVER != 0U)
( B. t) k+ o( s- C% X
uint32_t TranceiverPresent;
' i* I' v4 M& ]) ?" U
#endif
?$ a1 U( D% \
}SDMMC_InitTypeDef;

复制代码

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

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

#define SDMMC_CLOCK_EDGE_RISING ((uint32_t)0x00000000U)
+ n. \# a; {4 N G7 s
#define SDMMC_CLOCK_EDGE_FALLING SDMMC_CLKCR_NEGEDGE

复制代码

ClockPowerSave
用于设置空闲状态，是否输出时钟。

#define SDMMC_CLOCK_POWER_SAVE_DISABLE ((uint32_t)0x00000000U)5 T0 @! D9 _) A! h/ ]
#define SDMMC_CLOCK_POWER_SAVE_ENABLE SDMMC_CLKCR_PWRSAV

复制代码

BusWide
用于设置SDMMC总线位宽。

#define SDMMC_BUS_WIDE_1B ((uint32_t)0x00000000U). Y. v! L* Y) t( b( y+ c3 @
#define SDMMC_BUS_WIDE_4B SDMMC_CLKCR_WIDBUS_0
5 p: v7 {/ N! ~: L
#define SDMMC_BUS_WIDE_8B SDMMC_CLKCR_WIDBUS_1

复制代码

HardwareFlowControl
用于设置时候使能硬件流控制。

#define SDMMC_HARDWARE_FLOW_CONTROL_DISABLE ((uint32_t)0x00000000U)/ [- j! F( `/ j3 Q% ^
#define SDMMC_HARDWARE_FLOW_CONTROL_ENABLE SDMMC_CLKCR_HWFC_EN

复制代码

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

TranceiverPresent
用于设置是否带1.8V收发器。

#define SDMMC_TRANSCEIVER_UNKNOWN ((uint32_t)0x00000000U)
8 X# O. b7 S, a" }; s3 _
#define SDMMC_TRANSCEIVER_NOT_PRESENT ((uint32_t)0x00000001U)" J/ i& d4 \ j8 r
#define SDMMC_TRANSCEIVER_PRESENT ((uint32_t)0x00000002U)

复制代码

+ B: |7 W1 _2 L# `) G8 L# v" {% R
87.3.3 SDMMC接SD卡信息结构体HAL_SD_CardInfoTypeDef
下面是SDMMC总线的卡信息结构体：

typedef struct8 X0 j* ~8 Q( s3 a
{0 ^: J' P9 @, Q: }2 m( v2 G
uint32_t CardType; /*!< Specifies the card Type */
- a; I" x+ T4 Y$ e8 Y0 K8 T# E+ D
uint32_t CardVersion; /*!< Specifies the card version */ v1 {9 J! A( G# @7 a# x
uint32_t Class; /*!< Specifies the class of the card class */$ s+ w8 Y" u5 J# V2 u
uint32_t RelCardAdd; /*!< Specifies the Relative Card Address */
: B5 c+ Q& O; j/ k( }
uint32_t BlockNbr; /*!< Specifies the Card Capacity in blocks */. Z, e4 C9 V( W" T# k( }4 h; A. i0 V
uint32_t BlockSize; /*!< Specifies one block size in bytes */
) Y2 w# [- |3 g4 \
uint32_t LogBlockNbr; /*!< Specifies the Card logical Capacity in blocks */
% T3 m0 O; O& X; E+ {5 T: |" [
uint32_t LogBlockSize; /*!< Specifies logical block size in bytes */
5 x- B2 Z& d: x+ U! b
uint32_t CardSpeed; /*!< Specifies the card Speed *// m6 f! u# s. F; X- D
}HAL_SD_CardInfoTypeDef;

复制代码

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

CardType
卡类型。

/*!< SD Standard Capacity <2Go */
6 H2 W) n; f t, ^3 L- o
#define CARD_SDSC ((uint32_t)0x00000000U) 3 s0 Z! F, O! _! L
/*!< SD High Capacity <32Go, SD Extended Capacity <2To */
m& C7 y& m. \: Q v; S/ |2 h+ I
#define CARD_SDHC_SDXC ((uint32_t)0x00000001U) 3 g$ F' p3 E. A1 T, J
#define CARD_SECURED ((uint32_t)0x00000003U)

复制代码

CardVersion

卡版本。

#define CARD_V1_X ((uint32_t)0x00000000U)* g+ E; y2 J8 D/ {
#define CARD_V2_X ((uint32_t)0x00000001U)

复制代码

  Class

卡类型。

  RelCardAdd

卡相对地址。

  BlockNbr
整个卡的块数。

  BlockSize

每个块的字节数。

  LogBlockNbr

整个卡的逻辑块数。

  LogBlockSize

逻辑块大小

#define SPI_FIRSTBIT_MSB (0x00000000UL)
9 `4 _+ n0 `+ k0 i* G
#define SPI_FIRSTBIT_LSB SPI_CFG2_LSBFRST

复制代码

CardSpeed
用于设置是否使能SPI总线的TI模式。

/*!< Normal Speed Card <12.5Mo/s , Spec Version 1.01 */% Q, X9 s; Y0 k) m' G9 B
#define CARD_NORMAL_SPEED ((uint32_t)0x00000000U) 6 }. V B$ C/ k4 U6 S
0 g) x3 |* B+ z, \2 b1 Y
/*!< High Speed Card <25Mo/s , Spec version 2.00 */ + y% }. G/ L( h
#define CARD_HIGH_SPEED ((uint32_t)0x00000100U) J t6 M! W9 w, _, U
, j+ H8 f$ K' s+ C: |6 p
/*!< UHS-I SD Card <50Mo/s for SDR50, DDR5 Cards) j8 E# W8 n5 `3 a, C9 s
and <104Mo/s for SDR104, Spec version 3.01 */
! i) {: d7 \6 I; d' W# I
#define CARD_ULTRA_HIGH_SPEED ((uint32_t)0x00000200U)

复制代码

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

#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
3 {5 |' r2 b2 }4 f# |- R8 P
typedef struct __SD_HandleTypeDef
4 y5 Y/ Y# J, G$ D& z/ x$ O, Q
#else
9 K8 y: W& m# o" |/ b6 z
typedef struct
6 ?+ [ D, ^+ T/ i' w5 L
#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
; l, e& G$ C5 a$ h# Q9 `# F5 X
{1 Q5 @ b+ R) L3 }1 v
SD_TypeDef *Instance; /*!< SD registers base address */
( U. O3 w8 q& ], E
SD_InitTypeDef Init; /*!< SD required parameters */, w) \! X2 c3 _- c: c# _% F
HAL_LockTypeDef Lock; /*!< SD locking object */" r6 ~3 {7 r* P6 i2 W
uint8_t *pTxBuffPtr; /*!< Pointer to SD Tx transfer Buffer */
2 {: Y/ T. q# X
uint32_t TxXferSize; /*!< SD Tx Transfer size */0 @ L1 K) e+ D" _
uint8_t *pRxBuffPtr; /*!< Pointer to SD Rx transfer Buffer */
; Y. a* D2 O( o! h8 y
uint32_t RxXferSize; /*!< SD Rx Transfer size */
& C9 Y% w, M J7 L K0 T8 q* M
__IO uint32_t Context; /*!< SD transfer context */
$ ^7 m. F' G: t* s3 i K
__IO HAL_SD_StateTypeDef State; /*!< SD card State */
+ [$ P: Y/ L1 M! m& s6 B' x' E) Z7 d
__IO uint32_t ErrorCode; /*!< SD Card Error codes */
: _& P9 t/ t' @' k1 n C
HAL_SD_CardInfoTypeDef SdCard; /*!< SD Card information */) o8 ~6 S% x" F" X$ p6 G
uint32_t CSD[4]; /*!< SD card specific data table */. Q, t% O0 e! n" L- G/ [
uint32_t CID[4]; /*!< SD card identification number table *// ^# B! E; L2 d+ p: X" l
8 C5 B! ?: i+ X
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
6 `: ]$ ?* }7 I/ Z" J. O
void (* TxCpltCallback) (struct __SD_HandleTypeDef *hsd);
3 g* G+ l% `; j- j7 [
void (* RxCpltCallback) (struct __SD_HandleTypeDef *hsd);6 K$ R2 ?% }# L9 r
void (* ErrorCallback) (struct __SD_HandleTypeDef *hsd);1 K% I3 l9 D7 r! n8 W. B
void (* AbortCpltCallback) (struct __SD_HandleTypeDef *hsd);( b9 t# } g6 L" O" L
void (* Read_DMADblBuf0CpltCallback) (struct __SD_HandleTypeDef *hsd);3 Y2 l2 X9 r# r$ H* u- K; b
void (* Read_DMADblBuf1CpltCallback) (struct __SD_HandleTypeDef *hsd);8 Q# [) |" ?; y/ I& p; v/ w
void (* Write_DMADblBuf0CpltCallback) (struct __SD_HandleTypeDef *hsd);6 [: x5 Z4 [/ A* l
void (* Write_DMADblBuf1CpltCallback) (struct __SD_HandleTypeDef *hsd);6 R; @9 G& T. c7 r
#if (USE_SD_TRANSCEIVER != 0U)
- r+ i' P% F8 d. s0 C1 ]
void (* DriveTransceiver_1_8V_Callback) (FlagStatus status);
6 X# ?$ w, Z( {6 m
#endif /* USE_SD_TRANSCEIVER */
6 {9 w; `3 R+ ?$ L1 {
) c& y1 n+ o ~# S" K# r. K2 |, {1 F
void (* MspInitCallback) (struct __SD_HandleTypeDef *hsd);3 A- i% O8 Q/ B! T# _7 W$ @
void (* MspDeInitCallback) (struct __SD_HandleTypeDef *hsd);
1 p; r" H0 y4 }' t4 n/ x& O
#endif /* USE_HAL_SD_REGISTER_CALLBACKS */8 j$ v# q0 Z) P" @/ a
}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
函数原型：

HAL_StatusTypeDef HAL_SD_Init(SD_HandleTypeDef *hsd)
7 a3 O; s) S9 y2 j$ N7 j$ a
{& M) ^3 \ P; w5 x
HAL_SD_CardStatusTypeDef CardStatus;
, s0 |3 t$ U# m
uint32_t speedgrade, unitsize;
3 V9 g5 B( f& F
uint32_t tickstart;. A8 g6 E+ [6 h
& @( y" U4 d( Q d' b) a
/* 检查句柄是否有效 */
6 G, h7 K1 h3 W t8 ]# f
if(hsd == NULL)
/ B' E- c* d3 M1 F; @# t' e
{
* k3 V t, l$ p3 Y2 ~& s. k- k; z
return HAL_ERROR;
0 i+ x4 Q- B5 J7 c6 u
}
$ I; @! L- K: |8 w5 T* k
" E5 C9 ]" ^" w8 L; v5 x, Y5 B, v
/* 检查参数 */
5 @# e" p7 T" c4 J5 X
assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));
# Z' V' ~# f* h" X" r# n. ^
assert_param(IS_SDMMC_CLOCK_EDGE(hsd->Init.ClockEdge));
' C2 ?4 ^$ B: M* |' o' A# U( V
assert_param(IS_SDMMC_CLOCK_POWER_SAVE(hsd->Init.ClockPowerSave));+ ~0 z* _; @ O* U& ]
assert_param(IS_SDMMC_BUS_WIDE(hsd->Init.BusWide));
5 v% N3 d) e2 ]6 @8 C8 o, h( G6 \3 A
assert_param(IS_SDMMC_HARDWARE_FLOW_CONTROL(hsd->Init.HardwareFlowControl));. I0 _* `9 n+ F
assert_param(IS_SDMMC_CLKDIV(hsd->Init.ClockDiv));
2 N& z0 T7 Q# s4 `% `. s6 J; J
* x4 r. a8 v2 ^, y# h( s1 H
if(hsd->State == HAL_SD_STATE_RESET)
i, Q$ x/ V5 U) V0 o2 w5 x" r( M
{
( s; t; g# R6 z- H0 r$ `7 ]
/* 开锁 */) g' O! Y0 x0 J' Q L7 ~. U
hsd->Lock = HAL_UNLOCKED;
: v- O0 _. p" A/ O! l9 R
. P3 ]: I! \; _3 u# q: S( t
#if (USE_SD_TRANSCEIVER != 0U)
3 [5 }& H$ V& m
/* 兼容 */
8 i1 {7 p) J w4 e: m2 }: w
if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_UNKNOWN)9 G: |: J* _% J/ Q
{
- n% w6 ]* ~* d9 g
hsd->Init.TranceiverPresent = SDMMC_TRANSCEIVER_PRESENT;
9 k7 ~: Y/ u* a, p
}
9 D0 b G. o! q3 A6 y9 c
#endif$ x, C4 w3 ]2 P& ?! o# b
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)2 T$ l) z7 }3 j3 v4 m; X! Z, M
/* 复位回调 */
% x. _8 \" N- ^# t! _
hsd->TxCpltCallback = HAL_SD_TxCpltCallback;7 }2 j8 x, K, h- }5 h( D2 U8 A! ^
hsd->RxCpltCallback = HAL_SD_RxCpltCallback;
" G: j- b9 e _5 l p- J
hsd->ErrorCallback = HAL_SD_ErrorCallback;
# ^+ f4 j2 r- C7 d9 O- G
hsd->AbortCpltCallback = HAL_SD_AbortCallback;
) {* ]1 N' @/ g/ Y, }2 ?
hsd->Read_DMADblBuf0CpltCallback = HAL_SDEx_Read_DMADoubleBuf0CpltCallback;; Z+ D; Q$ i, S
hsd->Read_DMADblBuf1CpltCallback = HAL_SDEx_Read_DMADoubleBuf1CpltCallback;' p2 u5 j( G$ F9 w4 \' \
hsd->Write_DMADblBuf0CpltCallback = HAL_SDEx_Write_DMADoubleBuf0CpltCallback;9 B/ A9 b4 C3 ^' v+ x1 v8 `
hsd->Write_DMADblBuf1CpltCallback = HAL_SDEx_Write_DMADoubleBuf1CpltCallback;
1 A" K7 O; X3 V' }
#if (USE_SD_TRANSCEIVER != 0U)
6 r; C/ h8 l* {% p
if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)$ U( O3 n" |. v' i4 w- H
{1 N2 b* W1 I: R* {/ E* I
hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback;: c x( P& X. `0 z1 X
}
3 [: z1 f/ _) X5 A. |
#endif
+ T2 u! ~& ]8 M: ?% \# D
, f1 N; z5 f6 s
if(hsd->MspInitCallback == NULL)! q( A7 y6 P g& L
{
# N: }3 ?% V2 }8 ^
hsd->MspInitCallback = HAL_SD_MspInit;2 _. d; o( t2 q0 c
}/ L* C5 ^. c) G& g3 A5 O4 ~& c6 J2 ^
0 E. h( m4 u F( `! V
/* 初始化底层 */
0 m; d+ {: p1 Q" L# w4 V; `
hsd->MspInitCallback(hsd);
2 m G* K5 s6 t+ G/ {: D
#else
$ C5 ?1 i( H3 C9 p- M* u) F
/* 初始化底层硬件 GPIO, CLOCK, CORTEX...etc */+ z5 ~! ^7 ? |9 {
HAL_SD_MspInit(hsd);
' n3 \# ? |+ w4 E+ A
#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
# V$ P0 c& J, r& M ~; @
}
) [) S9 \ o. a
+ _9 o7 b3 e& O; c8 K5 I: Z
hsd->State = HAL_SD_STATE_BUSY;
' I0 ]8 b& g% ^
8 H# C4 y& d1 _1 l
/* 初始化卡参数 */: @% B& c+ }9 m/ d
if (HAL_SD_InitCard(hsd) != HAL_OK)8 b0 q9 e; } F" {7 B% [5 o: o
{
0 }+ T& w1 w+ K4 ~, w; b
return HAL_ERROR;
+ X; l' \5 Q4 E' g0 w
}) s6 F1 ~8 o, z+ s/ [. M
* G H. I4 F& X4 t) W5 U
if( HAL_SD_GetCardStatus(hsd, &CardStatus) != HAL_OK)
6 N& y6 c2 n8 o( q T8 ^
{5 C5 Q- I& M3 N3 T1 A
return HAL_ERROR;/ k- c" c/ v1 h9 X# Q
}
- Y, g+ m& V- U+ g
/* 获取卡速度等信息 */
6 g( d R4 Z+ J. t O
speedgrade = CardStatus.UhsSpeedGrade;% G, k) k( ?. {0 ?
unitsize = CardStatus.UhsAllocationUnitSize;
+ ^3 @3 q1 O( t0 `- d; r9 ^: U
if ((hsd->SdCard.CardType == CARD_SDHC_SDXC) && ((speedgrade != 0U) || (unitsize != 0U)))# k J3 p+ W1 P6 ]( m- T) k
{
- f2 B' o: L. [' g$ ]8 t3 H
hsd->SdCard.CardSpeed = CARD_ULTRA_HIGH_SPEED;
0 ~% t# U$ p* ^) Z+ d$ ^
}
& D* Q: Q3 c; s* M$ t7 O8 l1 z
else
$ ? K+ N3 q% z/ m2 C& V$ U, r$ p
{
. J1 B3 X5 I1 m- t/ u2 e6 [3 p& C
if (hsd->SdCard.CardType == CARD_SDHC_SDXC)7 o; a( @# x' K0 o
{# ?5 r) T0 a- p) i3 W% [1 N0 D
hsd->SdCard.CardSpeed = CARD_HIGH_SPEED;
8 o) _. [% Z9 W% l- U( B$ K
}
; S) X5 z [4 O+ b2 z1 S
else
2 O& y" |, a% y2 ?: C4 g. s. p
{# p5 ^" B; M+ v7 f
hsd->SdCard.CardSpeed = CARD_NORMAL_SPEED;
" I# N% I) E/ `5 f- ?0 l
}
8 G2 D# Y% B0 v8 g1 m O- S2 z
}
7 F0 B7 O- T% p4 a0 g
/* 配置总线位宽 */
; J8 ~0 _/ d/ `
if(HAL_SD_ConfigWideBusOperation(hsd, hsd->Init.BusWide) != HAL_OK)
4 P6 B& y3 b/ F7 Z$ ~! n5 U2 t( I
{
f8 u: j7 i: g' r0 Q, w3 i' Q6 O
return HAL_ERROR;% @" q# `7 i: c0 T* W5 M: D! V3 w2 l
}
, \: M! ?5 V* G- b8 R
3 ]* V- `6 y+ B
/* 验证卡初始化后是否就绪 */
4 y( M6 I; Y6 j F. h7 p
tickstart = HAL_GetTick();
- f' R" @5 {& c# c7 ?
while((HAL_SD_GetCardState(hsd) != HAL_SD_CARD_TRANSFER))" a) R* q3 I g \; g
{8 S3 W& ~$ s" X- \% O$ |! q1 X
if((HAL_GetTick()-tickstart) >= SDMMC_DATATIMEOUT)
2 ?, U( I+ i4 t% K j
{
1 K" N( z4 Z+ R3 V* q5 L0 Q
hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
) U. E, r# H0 Z5 |# @% o
hsd->State= HAL_SD_STATE_READY;
u$ A9 s+ N: X
return HAL_TIMEOUT;' \" x4 Q) j) X; I. ?% w
}, K; b8 i& k: ]0 `4 n
}% [5 i- B" |2 b% P7 k G! p8 K/ e
# @( D# C, I$ p) v
hsd->ErrorCode = HAL_SD_ERROR_NONE;
4 N5 X. j" k5 k# Z/ X: i
0 h2 j" Z/ X& z4 h
hsd->Context = SD_CONTEXT_NONE;
7 F3 A1 a# f" z$ p8 i
% w$ _+ R$ W: h0 u$ J
hsd->State = HAL_SD_STATE_READY;; u5 t! D2 m. i! n
" Y3 t3 u. z# y/ R7 C0 d- i* U, k
return HAL_OK;
9 q% w- Y& x8 s( D9 ?
}

复制代码

函数描述：

此函数用于初始化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：下面的方法

if(HAL_SD_DeInit(&SdHandle) != HAL_OK)
) {9 j! `( L% \" v
{
+ L" V0 @$ t1 N) V
Error_Handler();
8 ^; P" i- k, _& U* A. W
} * N: l/ z$ G5 e
if(HAL_SD_Init(&SdHandle) != HAL_OK)
- g- Y0 ^2 J0 S# A& f; m8 l
{
: q) N7 p: l( c' b0 Z+ L
Error_Handler();/ M+ B2 v% K6 x, o5 G2 n% [4 T
}

复制代码

使用举例：

SD_HandleTypeDef uSdHandle;
% p$ f: M. h) B+ e' I* B6 [
7 D9 U: }1 e$ W9 J% `
uSdHandle.Instance = SDMMC1;
5 u Q. W" o# J" t' b
N6 [9 |3 l# i7 p6 h
/* if CLKDIV = 0 then SDMMC Clock frequency = SDMMC Kernel Clock
$ l& u3 y% L- i9 V3 g' A/ a, b+ C
else SDMMC Clock frequency = SDMMC Kernel Clock / [2 * CLKDIV].+ `+ _8 J) X* |" e7 P* [' j
200MHz / (2*2) = 50MHz7 r( G& Z `7 `2 a+ {3 G
*/+ w m: O+ c# R! B6 Q
uSdHandle.Init.ClockDiv = 2;
+ C$ [2 P% {& z- c
uSdHandle.Init.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE;
% H9 P' ]/ x' B; f% J6 \
uSdHandle.Init.ClockEdge = SDMMC_CLOCK_EDGE_RISING;
) `3 h4 I* U8 f. a6 V# J
uSdHandle.Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE;
. N+ w. p. G2 h1 q1 c) R1 E
uSdHandle.Init.BusWide = SDMMC_BUS_WIDE_4B;/ I( X7 X* P) _, M3 t( B5 o
if(HAL_SD_Init(&uSdHandle) != HAL_OK): }; m' Y/ {9 O4 ?8 ?) y
{8 B, L4 h! X7 W* H, i$ r. i" u
sd_state = MSD_ERROR;
+ l3 Y+ i' J6 E, w2 x# q2 l
}

复制代码

# [1 U n1 A- S4 B
87.4.2 函数HAL_SD_DeInit
函数原型：

HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)4 @6 `1 H) Q' s$ `- l6 R3 q. S
{5 M9 c; P3 s4 u+ R& S4 c. B2 Q
/* 检查SD卡句柄是否有效 */
9 e+ M, b3 I7 m; w
if(hsd == NULL)
# y% g E) W- i1 ~' c
{
. z7 B# T( x1 C% ^1 p v* ?
return HAL_ERROR;
: m/ q( m* F! y$ `" |. @
}2 \; B' ^8 q: F9 \! i2 u: R6 S. _
4 i, G4 `. o' e- L8 P
/* 检查参数 */5 \4 t8 _' `! L7 G8 @4 X, \; l
assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));6 y A1 Q( S9 B$ Q% z+ j
( H; Z: o+ x& X' m; W2 y* y0 H
hsd->State = HAL_SD_STATE_BUSY;
# g c$ [& J; J' m( W3 `- J
3 ^2 q" L9 A4 J: n
#if (USE_SD_TRANSCEIVER != 0U)
) o* O. x+ `$ B1 r3 ^- B& a
/* 关闭1.8V模式 */3 k; H3 b# A* T5 \+ i) |( Y
if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)
9 @ ^- B. R' c/ {' g
{8 N; R( } ]$ S; P
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)8 u, n- @" h$ k4 t
if(hsd->DriveTransceiver_1_8V_Callback == NULL)0 o5 l% s, j# W0 R
{$ k- A1 f# A i* k
hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback;
4 W6 N! {% k* N* j, ?1 x$ x
}
: S: x* S$ _- d1 q4 d9 c2 l$ W1 z6 D
hsd->DriveTransceiver_1_8V_Callback(RESET);
4 O4 J5 C0 J' P0 {" a1 O5 Y
#else0 r4 Z" |+ e) {5 F8 W: H* A7 X
HAL_SD_DriveTransceiver_1_8V_Callback(RESET);% z- z/ X' R) ~
#endif 9 O, O8 ^5 E: j6 m3 h. L
} % e8 f0 M5 a4 r& y1 X" Y
#endif/ T* ]! `. U- U, J: U& F1 A% R! v
7 @4 Q+ F$ ^& X4 U- W+ F- O2 I
/* 关闭SD卡电源 */
6 e* u. ~. `* C4 t6 S2 A: ]
SD_PowerOFF(hsd);8 z. G" @2 p5 `$ h+ i
! A o3 H1 L1 k% W
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)3 l+ N" J- ~0 X- F5 P2 K w
if(hsd->MspDeInitCallback == NULL)
+ ~0 m2 @- q# G. v6 ]
{
' x4 C" d$ n, H5 p: Y" Z
hsd->MspDeInitCallback = HAL_SD_MspDeInit;4 e6 D: r4 E" O) D" s, z
}
! f" ^! ~+ \6 i
7 o& A p0 [" [- Y" z! x
/* 复位底层硬件 */
: y# T1 ` b4 o; w' A
hsd->MspDeInitCallback(hsd);
% M$ q' c: x; w: T% S* w
#else9 x+ @ d4 w& D% ~/ _
/* 复位底层硬件 *// }% b% A: x; K" t6 C- H+ q8 |3 I( r
HAL_SD_MspDeInit(hsd);. Z% ?+ V! t6 l( M! Z$ i' p7 a
#endif
: k% W' R( [- S# j1 w3 L
. [) `) X9 g+ h2 h0 l6 A! S
hsd->ErrorCode = HAL_SD_ERROR_NONE;- L. Z* T" I& H/ [: F7 a
hsd->State = HAL_SD_STATE_RESET;. k1 \/ i! f) L) u0 \9 x
3 p |& L% s' L% P% Z
return HAL_OK;
1 \- t& P8 @" H$ B
}

复制代码

函数描述：

用于复位SD总线初始化。

函数参数：

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

87.4.3 函数HAL_SD_ReadBlocks
函数原型：

HAL_StatusTypeDef HAL_SD_ReadBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)) h, b$ O6 d! t+ ^' X- U, [
{
, O# o3 S8 }' x# |4 I8 s) B( o
SDMMC_DataInitTypeDef config;9 f: f- N% c- }7 S" i6 q9 G' X
uint32_t errorstate;* z+ x3 ~2 t6 `% P
uint32_t tickstart = HAL_GetTick();' \# D, s7 H* [" E9 W7 J! h
uint32_t count, data, dataremaining;, L M+ {, Q7 s9 L' R2 C P
uint32_t add = BlockAdd;6 r& Y, ?7 y% I6 I! Y
uint8_t *tempbuff = pData;9 D# [$ d1 c* Y) E' `
. s3 i. j' Z5 A/ W. K+ C3 C
if(NULL == pData)
% m. p# X# O% J' ^2 E9 ?
{
& U' \4 U; T& c# q) I8 K
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;+ Y8 n5 \9 Y' t8 a9 t) `
return HAL_ERROR;/ |5 b" l, U+ L- T) Z" K9 |+ x
}
6 ?% c: o& z& i% Y
: y2 k: R* W; a. _% K
if(hsd->State == HAL_SD_STATE_READY)5 v3 ?5 f1 o6 S3 U* j0 i+ y# F
{' W1 H- l5 P' i: u! v; u+ P
hsd->ErrorCode = HAL_SD_ERROR_NONE;& n0 \7 Z: E* v3 L' o4 ]
- F! J' N' ?2 z; D7 |* X
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
: N( M: u$ b0 G5 k
{$ C. l$ [- o9 e+ K3 q0 x% k
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;0 z7 W3 @) _( i# C
return HAL_ERROR;
! R) J8 z% k4 v% @6 B8 x# ]; R
}
3 t. T7 K$ t' _# t# s5 I* | z
9 b6 ]) \3 P* r) o* n
hsd->State = HAL_SD_STATE_BUSY;
5 }7 {; ]: @& f1 R* b
/ o" b5 `* F6 C& k7 o/ g" @
/* 初始化数据控制寄存器 */2 q& a0 h3 V( M* l
hsd->Instance->DCTRL = 0U;& a3 u J: _ p6 k% R" J5 ]" T
0 C# t; B; @; I. h7 N( b
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
! p( P) _/ X$ W X1 Q
{
% {/ a7 |" f( s4 z( G! W
add *= 512U;
: ?0 z" p* N4 \6 \( R9 M* a
}/ R3 y5 P' b6 O% I
^. ]: l/ C% ?
/* 配置SD DPSM (Data Path State Machine) */! Q4 U0 E# t+ W( \& J
config.DataTimeOut = SDMMC_DATATIMEOUT;0 h/ V3 a- V: s# v: z
config.DataLength = NumberOfBlocks * BLOCKSIZE;
) k! h+ [& ?5 a0 c3 A# U
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;* ~ R, {1 t$ |
config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
5 y5 h. ]% b. A, I/ v
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
) L( I5 A% S+ C5 _8 D5 a8 r
config.DPSM = SDMMC_DPSM_DISABLE;
1 `6 d) Z- b" }: V/ P+ x5 N
(void)SDMMC_ConfigData(hsd->Instance, &config);
5 h7 V/ z9 f) `' V; F
__SDMMC_CMDTRANS_ENABLE( hsd->Instance);
6 c6 R) o( o5 C, F% G
# R' s$ r9 Z; ~' K
/* 查询方式块读取 */
1 f! k9 g6 X9 L& ^9 _* |$ d
if(NumberOfBlocks > 1U)
" k) H% t% m9 G$ }1 n
{
( }+ z1 Q+ Q3 ?9 l$ t
hsd->Context = SD_CONTEXT_READ_MULTIPLE_BLOCK;$ C0 z& k. \2 e( C- \! ~; e
( O; \' \4 T8 r
/* 多块读取命令 */
# Z7 p* N3 B' t
errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add); c# A$ L7 P) [0 w' R
}
4 k9 U4 d6 x# a
else9 {3 Z& X$ f$ r0 |& G" w
{
r+ j. K" a7 t$ U! q
hsd->Context = SD_CONTEXT_READ_SINGLE_BLOCK;
9 V' ~4 P/ x# \, \$ y8 `) Y- l8 ~
' w2 ~& `* G) O+ Q
/* 单块读取命令 */
0 X' Z6 c! I" |' g0 Q
errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);3 U* c" b& `: {
}! V% ^/ \3 Z9 t! M+ V# C1 v: I
if(errorstate != HAL_SD_ERROR_NONE)9 O5 A9 r; x! Z6 U2 D
{
+ S: ^ ]2 [" J9 O$ g9 l
/* 清除所有静态标志 */; ^7 l b1 `5 I/ j7 U
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
& _+ q2 J. u+ b6 q q# L
hsd->ErrorCode |= errorstate;
+ v) \1 k) X4 |6 W
hsd->State = HAL_SD_STATE_READY;2 z! T4 b, d" D: K2 H! m/ h* j5 \
hsd->Context = SD_CONTEXT_NONE;
) U. H& G9 p% g2 {6 x7 ]$ z
return HAL_ERROR;
$ c( N! i# {" o1 x2 o p: ]6 n! s
}0 U8 m3 X, F1 ~- i" F
- ?8 [7 O+ u9 Q: z0 h: D9 Q, i
/* 查询SDMMC标志 */" p4 f4 `9 [$ j: k1 t
dataremaining = config.DataLength;# R2 K" N' P4 t+ {7 p" k" l+ j
while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))5 Q& I1 u9 @; T* K9 U' v
{; A" [' L7 @- t7 ]3 E/ U P$ p" }9 K' L
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF) && (dataremaining >= 32U))
: i$ @& d5 Q @" k, A5 n# k
{
) p1 K, a/ G6 Z5 g' j& b
/* 从SDMMC Rx FIFO读取数据 */6 V* _. I$ X. L) ~6 n5 [! i7 c
for(count = 0U; count < 8U; count++)7 M; ? j: d& G" [ B+ I5 ]5 i
{# |8 x" ~ |& `2 @! Y4 L9 S |2 I5 X
data = SDMMC_ReadFIFO(hsd->Instance);
* p8 n% ?5 ^* ?& n- A: `1 J9 _
*tempbuff = (uint8_t)(data & 0xFFU);
; A% [4 `& T' x+ ]
tempbuff++;# @/ Y, r8 K1 L' ~: H( D
*tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
. o1 Y9 A% t+ [7 c
tempbuff++;
& T6 F9 x F/ V2 j6 b S
*tempbuff = (uint8_t)((data >> 16U) & 0xFFU); e2 y" h" z# j
tempbuff++;
( C$ M9 o& p( q! b. ~
*tempbuff = (uint8_t)((data >> 24U) & 0xFFU);( a$ q* ?0 v% w* k1 h
tempbuff++;
; |! k. @ h4 Y' G1 \
}
1 ]# @5 ?. x' E: D \0 r4 e# v
dataremaining -= 32U;, ?9 K* _- Q5 Z N
}
. p9 \* w N: C- |
% e3 T" ]' H# H+ G1 t: R
if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))+ n( E6 n/ T/ S9 j( R& E
{
0 E+ z! j& m1 `7 W) k, N8 y
/* 清除所有静态标志 */
- a0 _0 Y$ a) ^7 Q5 t; u; \) c
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
" p" Q% X ~$ i9 Y7 @
hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
) t T9 L# n' q5 R' s) H
hsd->State= HAL_SD_STATE_READY;
! D2 e' S" I* X
hsd->Context = SD_CONTEXT_NONE;
# ?1 x( M" ?, E
return HAL_TIMEOUT;5 H+ W! T' M ?( g6 i
}
- {" l( I6 h7 F* h7 j$ T# H
}
. S/ o* S7 C8 x- n) U k. E1 X; o4 l
__SDMMC_CMDTRANS_DISABLE( hsd->Instance);+ h$ [+ \% Z# j% w I+ O' P: A3 c
1 Q0 \+ g% c* [7 f
/* 多块读取发送停止传输命令 */! J3 D0 D" k1 O- [" X2 R( X
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U))
6 c. Y- n- W" P# ~# Z
{& Z/ M; n) e- H
if(hsd->SdCard.CardType != CARD_SECURED)" k/ j/ h5 t2 a
{) ^2 D- K% I0 L% N# t$ \& H! z( X
/* 发送停止传输命令 */
" ^$ T( w5 c3 g8 {$ O0 l; W
errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
$ _$ y N# g+ P; C0 U3 H; Q
if(errorstate != HAL_SD_ERROR_NONE)& c; h$ r% @+ i$ o' ~, B
{
# \( {. `. A2 k! E
/* 清除所有静态标志 */
) K+ J9 s; E. M" u/ C, {
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);/ D/ m9 {* d: X( M; H9 X( \
hsd->ErrorCode |= errorstate;
4 O1 ~8 L" J$ P- z
hsd->State = HAL_SD_STATE_READY;
1 t" S' b# S* \, E0 K8 x# [2 B; y6 q+ |
hsd->Context = SD_CONTEXT_NONE;
5 X: H7 e# ]9 m# ]
return HAL_ERROR;
0 m5 M! F; Y3 O' ?
}
2 _% W1 Z6 f9 O% ~ [' T' q
}) D) {$ e, G4 H- m
}
) \% k( `5 i1 Q( |. N
/ T. l0 {5 T1 m' z2 v7 C+ E
/* 获取错误状态 */& E9 }4 T4 s* k
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))3 }0 B! C. K2 Q
{
9 o O3 ~& Z) @. ~$ A5 Q2 Z
/* 清除所有静态标志 */
6 {6 W, x( r2 L/ j/ U9 v
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
$ ]* v k& q3 w* ?4 W( k- I
hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;3 B: h) j) {5 U( P; u4 n3 {2 i5 A
hsd->State = HAL_SD_STATE_READY;$ X' y& e" ?8 i0 ?
hsd->Context = SD_CONTEXT_NONE;) I0 H% J( e8 V, I" r
return HAL_ERROR;* U j, x: f( m e
}
( f% H, Z/ h9 p
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))4 J6 b( Z" x6 V8 {# g( L
{9 b( z# v& l( C4 u& t, |' A
/* 清除所有静态标志 */& r r4 y/ @+ o8 g( M2 A9 I
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
# @/ h6 r4 w3 H% N
hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
% ?$ t* Q' a# t3 ]
hsd->State = HAL_SD_STATE_READY;
% T3 z5 ?# p0 H! m2 A5 h6 ~
hsd->Context = SD_CONTEXT_NONE;
; M: U0 U; B. I- a" v
return HAL_ERROR;# b- R6 x! f* s6 |
}' f: l4 M" @2 h! _
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
( q1 K7 t: |+ x+ H8 [# g! ` D/ j
{1 q' K3 G. l- w: z5 s
/* 清除所有静态标志 *// j) w, p$ y; t0 z
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);6 E l, {* |) A6 V: n/ b
hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
2 G9 Q7 G+ I% b. n: c) b$ d
hsd->State = HAL_SD_STATE_READY;
1 q" F6 U, V" T* D) H
hsd->Context = SD_CONTEXT_NONE;
6 V1 s. r- t3 w% D- z5 @
return HAL_ERROR;
* d4 G4 _! @7 m# _2 h1 C$ D
}( i2 H$ J2 C; u
else! n( \# S7 U! E) B1 P G& x5 t
{! E! h2 c* J8 K" c6 A% p
/* 什么都不做 */: j% L ^# g. m" z" _. d" b a
}
5 t5 M# ^- t$ r& s4 G6 `
a8 Q( ~/ ?, @5 V% p I" a
/* 清除所有静态标志 */3 {, a' k' J$ e! S
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
8 R% s. I8 T2 R
4 |3 n6 R: k9 C) ^
hsd->State = HAL_SD_STATE_READY;+ [/ q' G7 W& T% }" b
4 H* y7 k5 V" Z. `; k9 b4 k7 p" W
return HAL_OK;! d8 X/ s7 N) \& x; J
}
# k/ E) X- e, }* ]
else" Y: D5 z: O) ^ m# z
{
$ p- _1 v) ^& l! E
hsd->ErrorCode |= HAL_SD_ERROR_BUSY;+ w7 V- u, e- a3 U1 f5 m, C5 W, G& V
return HAL_ERROR;
3 x4 A1 J' C( R8 Y* x- s9 _
}' x0 \" s9 Q4 W# }% A( d/ x: N( S
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**
& T+ n0 M l7 d2 H6 ?
* @brief Reads block(s) from a specified address in an SD card, in polling mode.& s& }, G1 q! H/ ]" f @
* @param pData: Pointer to the buffer that will contain the data to transmit
( @, S" S( Q' y+ k# u2 A$ @' a
* @param ReadAddr: Address from where data is to be read% P% S: F% p5 ?! v/ Y$ r7 K9 n
* @param NumOfBlocks: Number of SD blocks to read
' B) L8 r" ~# Z- b0 d4 _' V
* @param Timeout: Timeout for read operation. X6 t+ w" k3 I' ~
* @retval SD status
/ a8 `3 A- K3 Z' \8 M% D5 e9 \
*/8 _* b( L4 O# L
uint8_t BSP_SD_ReadBlocks(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks, uint32_t Timeout)
" B( s. y' M7 _3 U. d7 j1 Z
{
8 ^* B9 G0 l& ?8 T6 G2 k% m J
4 x6 E9 V4 ] H. R
if( HAL_SD_ReadBlocks(&uSdHandle, (uint8_t *)pData, ReadAddr, NumOfBlocks, Timeout) == HAL_OK)
: t& \: x( ^* S
{8 j: l C! p* N) [
return MSD_OK;
$ x, p/ B" e3 ^# T+ E: e
}
2 a4 Z) p/ ^% ?4 h# v6 G
else
6 n3 E# T7 e4 T% h: g! l, s- ^! U% _
{/ {6 W- o% x. H- R- Z
return MSD_ERROR;$ [1 {. e7 r3 U% O
}
& Q+ [3 _) ^& y0 a3 u
. K; j3 K- i* Y/ R' p. x! |
}

复制代码

87.4.4 函数HAL_SD_WriteBlocks
函数原型：

HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
0 r1 O0 q0 P: J8 s. \" v$ O9 y( W8 H5 W
{
% v2 ~2 i Z8 [' ]. h
SDMMC_DataInitTypeDef config;
5 S/ V" q$ N. F. L
uint32_t errorstate;5 _3 O) j- f! L
uint32_t tickstart = HAL_GetTick();; }1 ^3 t/ C' p. b! B7 m
uint32_t count, data, dataremaining;$ I$ t3 t, e$ v2 a
uint32_t add = BlockAdd;
3 ]' k' e9 t7 B. t* y6 ]# m
uint8_t *tempbuff = pData;
( k" i3 v; ~6 A3 x) G$ O0 u
! q' k- |6 n' ?, F7 Y' s, i% y6 o
if(NULL == pData)
T5 t6 c. v1 o( _) R3 K- j7 u
{: F p) c$ e5 w5 U4 r
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
5 O8 G& t& f3 L: a
return HAL_ERROR;( X% U1 B3 T! u( w4 h2 Y
}
6 \9 e) Z5 [6 a( U8 O
3 \3 r# _3 l% t0 B" k$ O6 R
if(hsd->State == HAL_SD_STATE_READY)0 f7 e d5 {5 G! b' _
{
# t6 K }# A; r. N) U
hsd->ErrorCode = HAL_SD_ERROR_NONE;
/ F4 v _1 s- `* J9 V. p, Q
( B# p0 x4 {7 J
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
; o8 J4 B6 f6 w; b9 s" v0 ^
{
8 \1 ~' K/ }! x& y5 E9 f" o
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;( i! ]8 O; a4 N6 a! R
return HAL_ERROR;1 S+ T: |2 W8 a; K8 L# q7 F
}' z R4 h. `& B" q% u4 l
/ b0 O5 t" q+ z
hsd->State = HAL_SD_STATE_BUSY;
+ _' U+ s3 v0 Q( `/ A
2 [$ d& Q* D7 P3 c6 T) A3 c
/* 初始化数据控制寄存器 */( e" e, W) [+ \3 l1 O3 z
hsd->Instance->DCTRL = 0U;
5 X. M5 m6 l) U3 B+ ^3 V1 S$ F
; B5 g, f1 T$ y
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)" _' y8 z& |& N
{
2 f9 S2 E- H7 R' w- i. i
add *= 512U;! |5 k3 f& F* u
}
+ `: |' @9 n0 g; l( D: ~3 E
2 e8 t" `. ?6 w6 @+ P6 r& A
/* 配置SD DPSM */. L( z: g( `7 O V; K% X
config.DataTimeOut = SDMMC_DATATIMEOUT;2 }- b; W0 d$ v" I1 E. _ q" l
config.DataLength = NumberOfBlocks * BLOCKSIZE;4 ]! x6 K% l, L5 p$ ~* }
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
/ L/ _. }% S( \
config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
# t8 l8 D% F& D
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
2 T0 ?, N: D: L( ~! p9 _. ?
config.DPSM = SDMMC_DPSM_DISABLE;
2 |( r2 s% f3 X2 _
(void)SDMMC_ConfigData(hsd->Instance, &config);
/ M- M: s t* r+ V
__SDMMC_CMDTRANS_ENABLE( hsd->Instance);
- d( @" V/ y5 ?: V5 [0 l. l6 v
9 X! g6 ^" Y5 R2 v7 N f0 k
/* 查询方式块写操作 */- k8 O/ R2 w$ V- j7 f# j
if(NumberOfBlocks > 1U): w2 d$ v A$ K4 |" l
{8 X) e1 J) j& L; \+ f
hsd->Context = SD_CONTEXT_WRITE_MULTIPLE_BLOCK;
1 s, S; N: a8 @, U! n
) Y( @- G0 H- o$ Q' q' I
/* 写多块命令 */( B) D+ k' s" A* V
errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
2 `) G/ U- b! O# y! }! i+ t
}) \, x7 m0 i9 i- N! x$ z
else
. s+ q, ]8 k) h7 C5 \
{ M; m+ p; Z6 h0 A3 H
hsd->Context = SD_CONTEXT_WRITE_SINGLE_BLOCK;' A' O. Z: |$ ^' J7 Q0 A
( p% N$ ~" B a3 e4 _
/* 写单块命令 */
, `+ A' L* j$ I ^
errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);9 I: E" n9 P( `) r
}2 @0 x W7 f9 K E( w& P7 W
if(errorstate != HAL_SD_ERROR_NONE). m2 g) ^1 q3 G% }. R- e3 G6 y
{0 V' F: a7 y0 E4 v) T
/* 清除所有静态命令 */
6 `5 E" q. k: \- j/ w
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);2 ^' J* [0 [1 l5 y6 V
hsd->ErrorCode |= errorstate;
9 f' Z6 P1 _2 S8 I: @+ E W: h! G
hsd->State = HAL_SD_STATE_READY;
. @- ?8 f4 E; y2 h% J5 @
hsd->Context = SD_CONTEXT_NONE;- r+ t8 I' M. K1 k! r2 Z! j' \3 }
return HAL_ERROR;
. b) i/ C2 ^% W/ u/ T
}
7 V) t4 v- R/ J; B$ }5 r n6 A
) i4 L$ F* ~4 J0 N' F4 [
/* 查询方式块写操作 */
& J7 [1 e' s9 U0 C' n. e9 V- G
dataremaining = config.DataLength;
e' b# a3 U" b8 s
while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
5 x" A; v0 }- o3 K# w
{
- B& n' S$ r; [3 L
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXFIFOHE) && (dataremaining >= 32U))
' y1 [3 r1 v" ~! n
{0 ]. |7 }) z8 H2 j9 s. x$ ?/ m
/* 写数据到SDMMC Tx FIFO */
- B* a; y; r3 {; g* k* [% k0 H4 ?3 f
for(count = 0U; count < 8U; count++)
0 A+ |+ x2 f8 x1 X' r V- ?
{7 l% N% C+ w, A. c5 w/ _: T
data = (uint32_t)(*tempbuff);
- _4 B; }0 W9 M- e( c( k
tempbuff++;5 H9 s8 ]& H# L
data |= ((uint32_t)(*tempbuff) << 8U);
( f: I b1 d6 z6 D# R2 h( y
tempbuff++;
5 [" g+ b q, x" X5 j$ L& a3 f
data |= ((uint32_t)(*tempbuff) << 16U);
$ [2 ^2 g3 s# ~9 m, X8 i, U
tempbuff++;
7 i; \& k5 Z2 m4 i6 E. P/ C
data |= ((uint32_t)(*tempbuff) << 24U);
9 `0 Y- q, ]3 R( R5 `8 c7 Y
tempbuff++;9 y8 u/ J+ b) Q7 k
(void)SDMMC_WriteFIFO(hsd->Instance, &data);# G6 S0 F& k- p) K
}
' z% W7 h) s3 F, @8 N) z1 Y9 c6 o
dataremaining -= 32U;
: U/ m: u( `( L* t; p' `1 u7 W) e
}1 j% I- I7 }( Z2 ^9 h4 H5 K
; s/ I7 H7 E) B8 t/ ~- u+ n. [7 [
if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))5 U4 j9 T# \+ C, E5 I% @& n
{, P$ L5 u+ J& o& k" m/ }+ L$ q: X
/* 清除所有静态标志 */
' K/ d; o4 u$ @$ z4 I: f
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
1 I2 I- F8 n# k- v
hsd->ErrorCode |= errorstate;
! p) v( h% m* z8 f
hsd->State = HAL_SD_STATE_READY;8 G- R* m2 d. e) H4 M
hsd->Context = SD_CONTEXT_NONE;
7 M% W2 e3 Z; Q, U
return HAL_TIMEOUT;% O) y z3 r$ v1 a8 A; M1 A
}
& g/ F4 d. |" t# m7 O/ j
}) W) Y: p0 ^; p+ S) m
__SDMMC_CMDTRANS_DISABLE( hsd->Instance);% c) ?/ B$ R" ?4 Y
& _7 X \8 D/ R+ {
/* 多块写操作，发送停止传输命令 */( ~1 D' O& |: u: V% W3 B7 d
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U))
9 F. [1 ]- v; W2 T( p; a% \
{
% n8 j. a* W) Q" I9 f! v. [! r( q
if(hsd->SdCard.CardType != CARD_SECURED)2 p' u1 |/ k5 _3 B9 s
{4 ]' C- _ o% z
/* 发送停止传输命令 */
' `1 a5 P8 C) h: m
errorstate = SDMMC_CmdStopTransfer(hsd->Instance);+ _/ d; G" t& s* R- v- \
if(errorstate != HAL_SD_ERROR_NONE)
! y0 \! j5 y8 y" `3 J, G; V9 }% C
{; m; T' D, E& r2 x z
/* 清除所有静态传输标志 */
; x5 v; }1 c, k* A# s0 h
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);8 x! D, x8 e1 t( V2 ^: g
hsd->ErrorCode |= errorstate;
9 W' `7 V- b* l8 | p
hsd->State = HAL_SD_STATE_READY;* U) l A" i" b2 ?, H: `, [+ V; I8 c
hsd->Context = SD_CONTEXT_NONE; F" a* t i& e$ K
return HAL_ERROR;; u3 b' t8 X5 U$ @ j" T& w
}
) C# }8 X1 c- c' H$ G4 A' C
}
$ u7 m5 `+ F8 M7 v/ S5 k2 |
}
; y! ]4 X$ v! c; u
8 G, c# {( s$ E/ G8 M( u) \& u
/* Get error state */
1 R/ [- _( g2 S2 N/ b2 K
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))
& Q1 [5 L5 j' }+ f; E; l
{, u* x. U2 L! g: l
/* 清除所有静态传输标志 */3 N: M/ t& J8 ?+ o8 h$ e
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
7 f8 t; x* }4 y6 Y- ?
hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
, i' O: {2 J& O: n6 S# Y- B
hsd->State = HAL_SD_STATE_READY;
6 ~) o q$ U7 A3 ? A3 a
hsd->Context = SD_CONTEXT_NONE;: D( d, m9 l* M. ~* s7 e4 G
return HAL_ERROR;
8 j, w* O s) V7 ]3 G& |: w
}
# Q+ c+ C0 K! p/ e2 e# p6 g
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))2 u6 J p3 Z" {, \+ W
{3 ?0 w% K h( J: x, c5 L
/* 清除所有静态传输标志 */
* n. }5 Q" J. C1 j. p* C9 O
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);8 y& ~ R5 f E' e, E3 s
hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;; {+ p/ R, a" m6 h6 b' B
hsd->State = HAL_SD_STATE_READY;
5 {6 d8 b3 k( A7 V5 i* O% |) P
hsd->Context = SD_CONTEXT_NONE;% ?9 {/ a( A2 T3 _+ m! d8 X% J
return HAL_ERROR;
) f/ ?" s, E+ h8 I. y* k! q5 X' k% n
}
- [' {" f, A7 R6 g& r) R: q
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR))+ h, u8 c. c( J0 w5 W1 p6 g
{
. P% A5 V7 F! m& L6 I
/* 清除所有静态传输标志 */' u- K: [# i! Q5 } w3 e
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);, }, _( c9 m m- F
hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;; G# I5 {* R! A9 q9 U% ?
hsd->State = HAL_SD_STATE_READY;) p# v! T% y' K+ f9 ^; {7 l
hsd->Context = SD_CONTEXT_NONE;& A2 q8 a% v* l3 d4 i! {( D- D
return HAL_ERROR;
( Q/ T& u2 M9 }6 r
}4 z l- A4 N8 J
else
8 X2 u' O8 {( X3 T/ H N7 o
{ [9 o/ H- m5 \
/* 什么都不做 */0 z6 _% U# _$ D$ V) a e" T+ O
}) J8 t$ ?5 \ C& t8 D& L; ]) O
# R5 `) T& W2 l6 C. O% L! v
/* 清除所有静态传输标志 */. S. s' x" B4 [$ x
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);6 G* |4 [& I) m
. t" A0 i8 }' M1 L' w
hsd->State = HAL_SD_STATE_READY;
K# ]3 _6 x. U) w9 ^- ?
; |! w+ t, j3 E& n4 n+ @1 L
return HAL_OK;
/ J7 K7 w6 p$ f* R6 }0 v
}
: E" W( a4 l. Q5 {2 V5 _0 f% i
else; N/ {, O! m( ~% F8 c1 @. {
{4 M: q( A/ ]$ p
hsd->ErrorCode |= HAL_SD_ERROR_BUSY;; V; S" }) w% g T
return HAL_ERROR;
) F& p/ S( \" s# ]9 ]! a' e2 j
}
( s+ C; d! U; j. }
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**
' _3 x2 y6 Y8 A8 Y2 L, {* q
* @brief Writes block(s) to a specified address in an SD card, in polling mode.- x' w" L& K$ r, x! w U
* @param pData: Pointer to the buffer that will contain the data to transmit
8 g" L* x* G1 x; b# e
* @param WriteAddr: Address from where data is to be written
) K6 B& B$ G$ w8 ^9 k3 d* T( w: _- N
* @param NumOfBlocks: Number of SD blocks to write
% C- I# m8 A7 {2 Z+ A6 F
* @param Timeout: Timeout for write operation$ k J, l' L0 u( s9 y
* @retval SD status
7 z8 m' d, {* r* S
*/; D% K2 h1 p/ ^
uint8_t BSP_SD_WriteBlocks(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks, uint32_t Timeout)
9 b5 y5 W; a @* @7 J( G9 D
{
. V- N6 j, `0 \+ z; o
9 b# s! `/ E! X. M- {
if( HAL_SD_WriteBlocks(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks, Timeout) == HAL_OK)
7 e9 ^6 O/ q1 h* |: O9 g( v2 L! D4 r( n
{# f W" p$ l2 e2 q- q# C5 J
return MSD_OK;
' O2 x u' U8 D7 L" K
}0 q- q G+ C- V( X3 m
else" c3 C2 X3 C$ G5 ]; \/ ^
{
' h0 a- e. x8 i, C
return MSD_ERROR;
+ i/ a& q+ b# H. Z" M1 p
}" |" W7 p$ Y% \' r2 b
}

复制代码

* }3 y6 ^% s6 e- p w O
87.4.5 函数HAL_SD_ReadBlocks_DMA
函数原型：

HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
, \1 F3 r: E" R" X) a: n& p
{
7 i8 Y2 j R E+ ?2 f8 g8 h+ Q6 u
SDMMC_DataInitTypeDef config;
! _+ W* `* X9 D
uint32_t errorstate;, |6 M* ^2 v, i, Y6 h
uint32_t add = BlockAdd;( @# B) l; x/ N1 j
) _6 W5 q2 S3 Z( o7 n, ?# o) {
if(NULL == pData)/ X% x/ s7 g% `
{
( d( L M& J0 t! [0 E
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;0 |* B3 }+ y j7 d, e, a
return HAL_ERROR;
% c- N7 g0 m6 }- r2 [+ [
}
. i% |$ u' `: M a# U8 {
2 [* P# V5 p! ^+ X- i, x
if(hsd->State == HAL_SD_STATE_READY)
: v4 z, q8 l7 A1 U
{0 U0 J2 l7 w3 b' {7 b6 ~
hsd->ErrorCode = HAL_SD_ERROR_NONE;: ]0 r: \8 s( i/ e5 ~, ~, \' X' h
( l# c) H7 E' o) y) _. }4 V
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
2 b' a! d, N" C9 ~6 x0 _) L
{( I4 D5 p, ?5 i& ]1 I
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
: ?) U/ f8 A7 E8 k% r+ \
return HAL_ERROR;
- \- r- u- o! B) L
}
Y6 r# R) n6 U7 p( [, h
( s* t4 n3 G- M2 l! V/ k% |
hsd->State = HAL_SD_STATE_BUSY;) X( T O) ? `- d! ~
' q" |. K( A& X/ N" y! ?5 O6 c5 x: L4 W
/* 初始化数据控制寄存器 */
8 g2 |7 X5 w8 }' [- F' t/ r6 [
hsd->Instance->DCTRL = 0U;
& |* C4 \/ s- g. b, O( U0 F9 a
2 E. H- o3 y0 K5 o
hsd->pRxBuffPtr = pData;
5 _1 f7 V) T2 e/ w. f0 b. Z3 x
hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;
8 H8 M, p: n$ i: i8 C
2 S) Y0 J; s: Q% z! N/ q6 W, V) b) B/ i
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
: q: }+ T2 k$ p2 ?( `2 u
{
, M) X" Y5 e; C. w
add *= 512U;
d, I" e9 n8 l! {/ _, l% i
}4 F8 \6 M5 J F
, k' a0 P4 O7 q# b& F3 @
/* 配置SD DPSM (Data Path State Machine) */0 T% N! c3 l* p W$ B8 B' G
config.DataTimeOut = SDMMC_DATATIMEOUT;
2 b1 n8 T, Y9 J: t1 Q! p% _$ K- u
config.DataLength = BLOCKSIZE * NumberOfBlocks;! B/ ]3 }6 k+ a7 T0 l1 O9 \' P* S
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;: q6 ]3 W7 }1 w' ^% o6 K. E; D
config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;5 G) H9 Q. f9 z5 R+ ]/ d
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
3 L: b4 E2 b- E5 H( m6 U# p) g
config.DPSM = SDMMC_DPSM_DISABLE;! g1 r, b7 Z; X. J! A
(void)SDMMC_ConfigData(hsd->Instance, &config);
8 X0 z, k! L# F1 M, ^4 J
* E* f# j5 m/ Y
__SDMMC_CMDTRANS_ENABLE( hsd->Instance);
/ b0 x' V$ L: G2 g
hsd->Instance->IDMABASE0 = (uint32_t) pData ;( Y* f y; Q& C6 b, j
hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF;; E8 d1 k# \+ p4 S1 S- j: B
. W. M8 `2 e7 ~, S+ r5 i3 [
/* DMA方式读取多个块 */+ Y& k9 K& n {) W) z3 ~
if(NumberOfBlocks > 1U)# B/ a: V K* [( d+ s0 c Y |
{
. K5 }) f, @. }5 h) }1 f( R+ V
hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
+ c1 j- ~0 y: N6 q0 u+ C
: U% T/ n9 a5 N% ^4 I' M0 t4 W
/* DMA方式读取多块命令 */4 f2 S& p* \0 @7 \" r
errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
! a# _ y6 [; `9 C
}
5 I4 [( V `# u3 W# q6 G6 R
else3 L' v% `, J1 [/ @5 D0 p5 w) U
{+ W4 p5 J' w- P0 }
hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_DMA);1 ]. c6 l! \3 A, n$ |9 Q: v- g
" Q0 s5 Q. k- `7 u" [; v
/* 读取单块命令 */
0 M6 B9 {2 u5 n
errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
, h- h7 Y' J5 i" [" x% h& L
}
m3 e: n4 f7 Z7 V
if(errorstate != HAL_SD_ERROR_NONE)5 a$ L" O. e1 E2 C+ F) z
{2 Q6 }. m0 G3 [2 h& @
/* 清除所有静态标志 */7 R8 x+ c5 P, B: H" u
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);' ^+ T7 H) l5 l& j$ ^3 G( {) e8 Y" f) ]
hsd->ErrorCode |= errorstate;! \& e' \/ u7 b, R4 h7 T
hsd->State = HAL_SD_STATE_READY;9 E, c) U7 r! D
hsd->Context = SD_CONTEXT_NONE;: K- r7 u8 r) f+ n" R4 R/ M$ r
return HAL_ERROR;
# ^: }+ N, |, J' z% X
}* J/ b4 f9 f0 i
! _* y* T/ @8 B; J
/* 使能传输中断 */$ }- M6 d/ g1 F5 g6 }/ Q
__HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND));
! v) v2 D0 b: w9 G( {8 r, ^
' V" a2 A' D3 O1 F8 M' o, s
8 g: D; i9 b6 [' x
return HAL_OK;
' H+ F5 b* N8 Q% N4 w
}
3 h; h0 O7 }! x* C0 ?; h9 m
else
8 X& J! _4 c/ t) a- n3 h
{7 r! M) N/ n. ~& r" ?
return HAL_BUSY;0 o$ C! a5 I+ S) c( |
}4 c3 q& j( I/ a6 F9 q0 z
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**4 k7 }) k- {) K; J
* @brief Reads block(s) from a specified address in an SD card, in DMA mode.
* o$ ^$ Z1 T V: _; E i
* @param pData: Pointer to the buffer that will contain the data to transmit" j! B) G2 |7 l5 f
* @param ReadAddr: Address from where data is to be read% x3 B: c: p5 ~" o: m( \/ x
* @param NumOfBlocks: Number of SD blocks to read
2 U/ l6 ^+ X* O+ C& A
* @retval SD status3 I7 [; W7 Q4 K5 e
*/
! m; _% [: K8 f5 P
uint8_t BSP_SD_ReadBlocks_DMA(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks) u" E7 L* ^: }7 P
{
0 s4 Q( v& O4 x$ N+ u" @+ e9 t" E
. }% O" e; \7 \/ J F
if( HAL_SD_ReadBlocks_DMA(&uSdHandle, (uint8_t *)pData, ReadAddr, NumOfBlocks) == HAL_OK)6 h4 b' c1 F0 B
{7 O' G0 j- n2 o
return MSD_OK;- j% w- z6 ~$ V- }# E) c" K
}
6 e8 \' J5 I" d5 {" e
else
5 O G" r2 g4 P" B- ?
{/ ^' q, D; X# y/ C0 C
return MSD_ERROR;
+ K' U5 O$ F+ Y5 A' |- Q, J
}& n4 p+ G3 j4 m/ [7 d! L' r [( H
}

复制代码

87.4.6 函数HAL_SD_WriteBlocks_DMA
函数原型：

HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)0 d* @( _8 M1 c. o' u$ _/ U5 I
{
7 I- x! f( U1 M: b$ m6 Q
SDMMC_DataInitTypeDef config; ~/ N4 R. v% h% B% M& u2 }( H
uint32_t errorstate;
' c$ V0 r! x# N$ K
uint32_t add = BlockAdd;
3 r3 j9 `2 ^ @+ s' r
0 M9 ~" d t( ?* J4 G
if(NULL == pData)
' K; F8 A* d) ~( c- C' G
{1 _) i" L: x" n) X+ T) X3 x
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;- I% h }$ L' |: ^6 m
return HAL_ERROR;( X: \% w% A6 T. Z# [
}0 s. V9 W3 ~/ g
! q$ D4 d. D$ d$ Z
if(hsd->State == HAL_SD_STATE_READY)! u4 s; Y& I, n! a; v
{- D* g/ y3 @2 \8 z( q
hsd->ErrorCode = HAL_SD_ERROR_NONE;
3 v! U7 F4 H, {, E& L% D( W
3 {: |: B$ d' E) K
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))2 }4 D: H% A0 i" @
{7 ^9 G# q% S! Y" w! Z, e+ U) c
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
( y* u1 h# {! Y$ G/ Y2 `
return HAL_ERROR;2 ~+ M. J5 W8 ]- R: g6 o
}9 N6 ?4 g# y. G) d' L" E
hsd->State = HAL_SD_STATE_BUSY;
; x) P: q" S1 H) X L" ?/ o
+ k4 A4 \ S( ~* a5 O q
/* 初始化数据控制寄存器 */2 r% P1 }9 _! W
hsd->Instance->DCTRL = 0U;
- H8 u$ s3 R! ? J5 @
( I; i# y) i" b3 I) @
hsd->pTxBuffPtr = pData;( c2 e% e% u9 g# @
hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;
7 W* a8 y7 N, ~7 k- G; i; v( a
_3 d& x: k8 ]. q4 _# I
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
$ D4 v3 [# q- ~
{
$ @" I" {( n' n4 y# c/ C
add *= 512U;* m: O% V: l5 J' v9 \# a* g5 ]
}+ A0 N* J1 C( K& s( R6 ~0 s: y- c/ l
: n; N$ Y; g6 L5 n( n5 u! j0 ~# T
/* 配置SD DPSM (Data Path State Machine) */1 }- p- A" l- W' x l
config.DataTimeOut = SDMMC_DATATIMEOUT;
& P( v& y9 A2 A0 h( f y9 p4 x
config.DataLength = BLOCKSIZE * NumberOfBlocks;$ x; b9 P0 U' e. S% u. r0 z$ ~; z) `
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
8 s$ O E& L1 j6 ?" ^2 T
config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
) j7 J0 x' N8 J1 J
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;' s- \3 }2 j6 C/ O+ q) |3 h' p
config.DPSM = SDMMC_DPSM_DISABLE;, `$ z( B7 @# D
(void)SDMMC_ConfigData(hsd->Instance, &config);
5 ~5 q; E( f, O, j! [3 F
0 O: W1 E" v1 d% e8 |$ M# n
* H! d8 D% ]8 ]& r* V0 l
__SDMMC_CMDTRANS_ENABLE( hsd->Instance);5 ^( c9 d; y' C# P; [
, y. Z; v* M9 y) h$ p5 E: A! ^
hsd->Instance->IDMABASE0 = (uint32_t) pData ;
% T+ _. m% {5 m2 B0 k
hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF;9 n! g5 X' B- j+ Q; j. E$ e
& ?% o! D6 ?4 L/ n
/* 查询模式写块 */) s, [2 s7 i+ m2 |) g( [
if(NumberOfBlocks > 1U)$ Q2 f; |6 Y" n' Y8 ]
{: Q( A" w/ x0 `- U. g
hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA);3 Z& c; p- K9 A. Q7 A1 G
8 R5 I# y% Q$ s2 B" T$ S9 _& ~
/* 多块写命令 */ M) m( v7 Z" E7 m
errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
. |) T3 ` v, G3 T N) L: ~5 h
}
$ G- h; S u: G- V7 D5 ]
else
! B& \( }3 s: Q, N. I$ e8 n7 F
{
/ ^: e4 H6 N, `3 o2 a# N
hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_DMA);
5 ?" B& o4 V! y
- ~) H6 s$ M: I# O* J
/* 单块写命令 */
5 D5 c# g: K. T/ `( ?( L
errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
0 \9 m0 v' o0 I* F! ?& f2 _8 v0 Y, T
}: H; R5 C; K# ?2 {$ v; r2 K
if(errorstate != HAL_SD_ERROR_NONE)1 T+ K/ V; O- a5 o3 E
{
8 u4 M9 w: _5 H7 ]
/* 清除静态标志 */
" a7 e( }) t* y4 b- Y
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
; g4 c4 i6 x' N0 {0 ?4 ^, i6 f/ E3 x, v
hsd->ErrorCode |= errorstate;' O2 y$ [2 G5 i3 ~3 Y. k5 I
hsd->State = HAL_SD_STATE_READY;* z# @- W! J4 f3 w% n: {# D: m& ]' k
hsd->Context = SD_CONTEXT_NONE;9 K6 o& W- Z. g4 g
return HAL_ERROR;
3 s! ~3 ]" B* M( p( V# u: N% a# n
}( P. N: I! Y. X3 \$ E
& Y/ Y6 N7 }0 i
/* 使能传输中断 Enable */" W: u4 q9 p4 q& C
__HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND));) L9 P d+ I, H* I: x) T* F/ D2 R8 z2 s
, f0 s# G, j) M. ?) k
return HAL_OK;+ T8 y% W8 ]( M
}# K# C n5 M" Q; `& F
else/ m9 Y% }* \" B
{! B! h$ o8 Z0 R) g3 w8 O
return HAL_BUSY;$ a' G6 Q- V5 z g* }" I+ L
}
+ U) ]/ L4 d% Y
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**
* E& ~) H0 D3 F3 l9 W0 x
* @brief Writes block(s) to a specified address in an SD card, in DMA mode.3 y1 [9 W, i7 m5 G9 A8 A
* @param pData: Pointer to the buffer that will contain the data to transmit. x' u7 I. \- L4 B5 z8 J1 l
* @param WriteAddr: Address from where data is to be written
2 O' P+ O9 S# C3 Y& J& ^& k+ f
* @param NumOfBlocks: Number of SD blocks to write
6 g* C+ S' d/ t# b$ @$ N" K$ g. O: _
* @retval SD status
4 X+ c/ X0 B: C6 r* ^8 \7 \& o4 F4 J
*/
; @2 i8 H: e: p# S7 i% k! }& T
uint8_t BSP_SD_WriteBlocks_DMA(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks)
0 Z# Q. ]# v ~- G& M# G X' E
{
6 |4 F$ r5 J3 ~* j, W$ L
( Q% T& O3 U% X! P
if( HAL_SD_WriteBlocks_DMA(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks) == HAL_OK)6 w' F' W+ H$ g4 P
{
' G8 E' x1 b; u! X2 P1 D! i
return MSD_OK;
# |" M! @2 f1 ?
}
4 u. x2 c. M- l8 m' f1 X7 J
else/ D6 I1 t. ~' p6 l" y# P2 W8 T3 V
{
6 ^. r- O7 @* x) q4 J
return MSD_ERROR;2 j3 a" m, p3 j* L5 H+ D+ B7 y
}2 i: t9 k: k* Z
}

复制代码

87.4.7 函数HAL_SD_Erase
函数原型：

HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd)
1 p# v$ d0 F( [& u
{
$ e' ]* i9 h Z a" N! Z% c
uint32_t errorstate;3 `0 {9 a1 \: V4 @9 Y7 S
uint32_t start_add = BlockStartAdd;
6 F* W$ U: l7 I/ j) \3 @, M3 C
uint32_t end_add = BlockEndAdd;$ D, Y! k* L- `" D: G5 b
5 Z' x7 B/ j5 M# ?& S
if(hsd->State == HAL_SD_STATE_READY)
# t8 P* r+ v9 X/ V8 Y1 B( j. R! T
{
$ N' j6 @/ u6 c/ @
hsd->ErrorCode = HAL_SD_ERROR_NONE;- N' K8 k1 q$ F( i+ O: y8 x( J) Z
; e# V: `5 G* C/ N7 B
if(end_add < start_add)
* E1 Y+ e% d2 q
{+ r! v# z$ j' f: k- _
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;- l, e& |, L: b6 H8 ~$ i
return HAL_ERROR;0 \' x3 z4 f2 ^+ \% g8 _/ E
}# t2 ^& N& [* K" B# D
" ?3 {; ~0 ]4 U! ?2 Y: T, _
if(end_add > (hsd->SdCard.LogBlockNbr))
- H# [6 G9 B! C
{
. m. A, R8 i/ Q% T( a8 r M6 q7 P+ A
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
/ [& b0 Q) g4 A `$ f+ K
return HAL_ERROR;- R! R6 C9 y. a0 T' v9 a5 Q
}
5 ^- ]7 H* C p4 s! t9 U3 Q
6 s F' K5 a5 i, R: \) D, g
hsd->State = HAL_SD_STATE_BUSY;
- \; U& B4 `2 H: L9 q0 _6 N8 D' v
7 I: H3 L+ s+ o% l9 `* K/ X
/* 检测是否支持擦除命令 */% K H( i8 i4 ?' q9 Q3 Y, p
if(((hsd->SdCard.Class) & SDMMC_CCCC_ERASE) == 0U)
- G ~. k `, F- ]4 @# t
{6 T1 A5 L( M9 M2 r5 r! Z4 v; T2 t& e
/* 清除所有静态标志 */% |2 R8 Y" \, _: N
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);& q$ D$ N: u1 X1 n2 ~& z
hsd->ErrorCode |= HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;3 B, d& y# `# T4 Y
hsd->State = HAL_SD_STATE_READY;
$ S, v7 o9 F5 F1 o& |
return HAL_ERROR;5 x4 D7 H! n6 I/ S! M
}
0 }9 j e- {' g& \, r
) T: Q4 j0 ]: j" g% Y' K$ H# c5 [
if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED); C# ^' _! m$ S, J5 |& ]
{" j8 r- } ^* }; E$ @6 S3 r; w
/* 清除所有静态标志 */
) i% h+ k0 L0 D
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);3 ?: _6 ~5 l0 y8 r' D/ i' {
hsd->ErrorCode |= HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
. `' p5 F: U+ a3 i9 l; w" X
hsd->State = HAL_SD_STATE_READY;
5 w2 I3 U4 M& q4 ^) ]0 j+ Z
return HAL_ERROR;
; p1 @! v" u7 }# M4 X; d
}
8 j8 W+ C" W/ x/ ?& ~0 Q9 @
! C4 D( D3 z" G. Z
/* 对于高容量卡，获取起始块和结束块 */
. U! }2 _% x2 i+ I% S* z
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)+ t( n; ^5 V& p1 \- f2 C2 k$ h: ?
{
& [: `1 Z7 [- k6 y1 o
start_add *= 512U;
. b0 ]6 A) s/ n( W3 k
end_add *= 512U;
2 Q: q9 Z0 \' v9 X6 n
}
/ T) p) @- o4 @. n" M
* ^4 T W h0 O& x
/* 根据sd-card spec 1.0 ERASE_GROUP_START (CMD32) 和 erase_group_end(CMD33) */
: V: _* E7 S) J7 e1 O$ O! ^
if(hsd->SdCard.CardType != CARD_SECURED)
; K) G& h# ^5 G2 L% j' t
{
/ b3 V5 ~8 m3 q" g6 I! I+ I4 m
/* 发送CMD32 SD_ERASE_GRP_START命令带地址参数 */8 `& I" o' b* ]6 H S; ^6 P' H
errorstate = SDMMC_CmdSDEraseStartAdd(hsd->Instance, start_add);
4 Z0 r" `- L, d: i2 }) @+ e
if(errorstate != HAL_SD_ERROR_NONE)+ V# H6 Y6 e7 U2 A
{
1 t- v" u) E; R9 d! f; K4 I
/* 清除所有静态标志 */
: |7 }' g- n* i8 D1 p
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
8 |) B4 P W- {# o9 \% \
hsd->ErrorCode |= errorstate;7 E8 O+ F. S9 T* J
hsd->State = HAL_SD_STATE_READY;
; j8 |/ q5 j& b$ g( d7 ~0 I: x" L, A
return HAL_ERROR;
, j0 F5 t! l$ x1 o/ T8 Y* m' e
}& ~7 j: b0 z! j
' H1 ~% q( H# q- l" ]0 |
/* 发送CMD33 SD_ERASE_GRP_END命令，带地址参数 */
) ~3 m0 n2 j" d! R
errorstate = SDMMC_CmdSDEraseEndAdd(hsd->Instance, end_add);
7 ^2 W* F7 S2 Z( O( i
if(errorstate != HAL_SD_ERROR_NONE)
+ J- y5 N4 M8 N! ?0 @
{
3 s2 ~/ C. }& Q& I
/* 清除所有静态标志 */$ T8 @2 V7 _: d! O# T4 B- q+ \0 o
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);. ]# q4 b1 d; x8 a2 _
hsd->ErrorCode |= errorstate;
* `( N0 B+ Y- t! K; i5 ~% _
hsd->State = HAL_SD_STATE_READY;
2 f5 w( U) N: q
return HAL_ERROR;
& N( q( ?4 X/ s; \0 ?
}
, Z6 h [% @4 E! N' O
}
8 H5 ^- p, p# |. X8 t, q
$ X% p6 }4 U T7 a
/* 发送CMD38 ERASE命令 */: N' H% D+ _0 Z) \. L) _5 Z0 J
errorstate = SDMMC_CmdErase(hsd->Instance, 0UL);9 P" E7 v- e$ d1 k# g5 {9 C
if(errorstate != HAL_SD_ERROR_NONE)
8 r: i( E% ~4 M- U8 v5 ]
{
5 C( j, z" O5 {8 c2 {# |5 B
/* 清除所有静态标志 */
J2 V! Q0 O9 Y8 M
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);* g4 c* Z+ F" A- q
hsd->ErrorCode |= errorstate;$ c% Q" c, z. ~2 y8 g
hsd->State = HAL_SD_STATE_READY;
% D& q' e4 |$ L' g
return HAL_ERROR;9 c, e1 z& l) m$ @' K! ^% k
}8 V% @6 ^$ z. M5 D$ o _ C
7 F8 K8 [( C" s# r/ y9 R; x+ K
hsd->State = HAL_SD_STATE_READY;! [$ p f7 n7 k8 u' y, p2 l l" y
\2 v2 L* Q' h" u8 G
return HAL_OK;
' i) P% x9 `# k+ d, E
}5 ~( C* `7 [0 `6 u0 U- l
else
' Y0 o7 L/ `% I; l" e. z. a$ J; ^
{
# A V5 ]1 H0 y- _
return HAL_BUSY;& |+ |. w- e8 V3 X# F/ P9 `
}: K0 l: r; G# N; ~8 c g
}

复制代码

函数描述：

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

函数参数：

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

/**
3 [1 t- O& Q3 Y
* @brief Erases the specified memory area of the given SD card.
; ?) e' [% l& j0 n; \
* @param StartAddr: Start byte address) O+ i F5 c! [ s5 H
* @param EndAddr: End byte address
* @retval SD status* n! G' F+ x7 F1 i+ G3 J u" ?
*/
* T \3 {4 A! P6 ~3 R
uint8_t BSP_SD_Erase(uint32_t StartAddr, uint32_t EndAddr)
2 ~- v$ \! r4 x' O4 m1 f
{
# `8 Y. v3 p4 \( I5 }
0 n9 |! F: F% c) n+ e# i+ s: l
if( HAL_SD_Erase(&uSdHandle, StartAddr, EndAddr) == HAL_OK)
; Z) I b9 ~6 K2 l, r0 z& o) p; K( u
{
/ _% k! [7 F: C% T
return MSD_OK;
( ?$ Q9 s9 s2 o) `; `
}
3 h3 k& H N* ^8 V
else
3 H- M5 Q8 i, y2 B& i' j
{6 ~% y7 H% G% f6 A$ e- H- N+ R
return MSD_ERROR;: C& u9 ?& U& y, P, L
}
, U+ w: W, B- g) |; R
}