【经验分享】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都支持的

9 T" y5 g/ P, h% a( s" l* e8 \
87.2.4 SDMMC支持的速度
驱动SD卡支持的最大总线速度：

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

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

  驱动SD卡最大支持4bit，驱动eMMC最大支持8bit。
  针对信号电压1.8V或者1.2V，STM32H7需要外接专门的PHY芯片才可以驱动。
  最大IO翻转限制说的是SDR50，SDR104这种高速通信。平时用的DS，HS这种，无压力，刷满速不成问题。

( g; T; J/ N* c0 \& p87.2.5 SDMMC支持UHS-I模式
STM32H7的SDIO外接支持UHS-I 模式 (SDR12, SDR25, SDR50, SDR104和DDR50)需要1.8的电平转换器。STM32H7参考手册给了一个型号ST6G3244ME：

, l: r8 A* w0 |8 y7 J87.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
" f/ f4 |" \3 c
typedef struct
l& _! B7 m$ g" _4 E6 T
{
" c) t. U O" D! X( S
__IO uint32_t POWER; /*!< SDMMC power control register, Address offset: 0x00 */
+ Z0 O, d* {. {! f5 U# Y
__IO uint32_t CLKCR; /*!< SDMMC clock control register, Address offset: 0x04 */
+ a; j% P2 z- z4 @8 B
__IO uint32_t ARG; /*!< SDMMC argument register, Address offset: 0x08 */
0 h3 x6 ~, \5 k- H# @
__IO uint32_t CMD; /*!< SDMMC command register, Address offset: 0x0C */
$ `: o% {: ~" Z ?$ Z
__I uint32_t RESPCMD; /*!< SDMMC command response register, Address offset: 0x10 */
; }5 B3 a1 P. d& G
__I uint32_t RESP1; /*!< SDMMC response 1 register, Address offset: 0x14 */
I6 Q l! B4 A2 K l, L" e
__I uint32_t RESP2; /*!< SDMMC response 2 register, Address offset: 0x18 */$ g: @6 R" k t) F% A! F
__I uint32_t RESP3; /*!< SDMMC response 3 register, Address offset: 0x1C */
, f: \9 F( Q/ I) K, `0 C* C
__I uint32_t RESP4; /*!< SDMMC response 4 register, Address offset: 0x20 */
- u, @1 h ?- x; ^& V# i% m
__IO uint32_t DTIMER; /*!< SDMMC data timer register, Address offset: 0x24 */
@3 o3 s) r1 B
__IO uint32_t DLEN; /*!< SDMMC data length register, Address offset: 0x28 */, z" }; o; I7 v8 A& |- F9 n
__IO uint32_t DCTRL; /*!< SDMMC data control register, Address offset: 0x2C */
7 R+ m) L' [2 k& T5 Q1 C
__I uint32_t DCOUNT; /*!< SDMMC data counter register, Address offset: 0x30 *// b( e7 a1 p& ^( i4 P) G" O/ }
__I uint32_t STA; /*!< SDMMC status register, Address offset: 0x34 */
, @4 h0 ^5 J, I4 J# ~
__IO uint32_t ICR; /*!< SDMMC interrupt clear register, Address offset: 0x38 */' u) z: Y% \" g0 I+ u5 b, L
__IO uint32_t MASK; /*!< SDMMC mask register, Address offset: 0x3C */
# {+ K3 |+ N# q0 X, _ y
__IO uint32_t ACKTIME; /*!< SDMMC Acknowledgement timer register, Address offset: 0x40 */7 @" _8 a* P% c
uint32_t RESERVED0[3]; /*!< Reserved, 0x44 - 0x4C - 0x4C */5 A8 w, [# |4 A, L* l' x/ q- P5 K
__IO uint32_t IDMACTRL; /*!< SDMMC DMA control register, Address offset: 0x50 */
/ D7 M q/ L3 q/ V3 S
__IO uint32_t IDMABSIZE; /*!< SDMMC DMA buffer size register, Address offset: 0x54 */4 P4 }+ Z; E3 i+ S1 }7 x
__IO uint32_t IDMABASE0; /*!< SDMMC DMA buffer 0 base address register, Address offset: 0x58 */
4 e$ n" l7 M4 z8 E
__IO uint32_t IDMABASE1; /*!< SDMMC DMA buffer 1 base address register, Address offset: 0x5C */
' D7 M2 P r u) K; m& v" B
uint32_t RESERVED1[8]; /*!< Reserved, 0x60-0x7C */3 z, N7 e( x! b. s9 J
__IO uint32_t FIFO; /*!< SDMMC data FIFO register, Address offset: 0x80 */
, e, `7 ?7 ]; X1 m! T) `9 q( \3 o2 k: [
uint32_t RESERVED2[222]; /*!< Reserved, 0x84-0x3F8 */( V1 |& K m! D/ x' U1 D
__IO uint32_t IPVR; /*!< SDMMC data FIFO register, Address offset: 0x3FC */( s- G" Z% S, B p
} SDMMC_TypeDef;

复制代码

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

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

#define __O volatile /*!< Defines 'write only' permissions */
/ s1 P1 d/ X# k
#define __IO volatile /*!< Defines 'read / write' permissions */

复制代码

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

#define PERIPH_BASE (0x40000000UL)
8 U7 v. V# P2 u" x
#define D1_AHB1PERIPH_BASE (PERIPH_BASE + 0x12000000UL)
6 k* M3 K$ ?6 k, p5 l/ P$ @5 t
#define D2_AHB2PERIPH_BASE (PERIPH_BASE + 0x08020000UL)& F6 S9 \& i; @1 V& R+ B( t
- M8 I. L: y, b. s) v- ^ ~
#define SDMMC1_BASE (D1_AHB1PERIPH_BASE + 0x7000UL)1 r9 ^6 F' {3 `+ P% t$ m" m+ ]
#define SDMMC2_BASE (D2_AHB2PERIPH_BASE + 0x2400UL)) e+ t) \) {& l# M
& n9 X* n1 L, @$ @
#define SDMMC1 ((SDMMC_TypeDef *) SDMMC1_BASE)
3 {# t! ?1 K6 Q( y: ]8 x1 }. n3 q
#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
# a8 V; P0 F+ N$ T% t2 O1 i
typedef struct- S0 F+ ]4 M; y: U, E. j
{0 t5 F2 q/ V; j1 u5 Z4 }, U
uint32_t ClockEdge; $ O: {0 R! d S# l, Y$ I
uint32_t ClockPowerSave;
7 e' f, }* \: ?+ z$ x
uint32_t BusWide; / o+ C6 ^) Y3 A" [/ `" s
uint32_t HardwareFlowControl; . {1 i% q5 k7 t* ]$ y4 D
uint32_t ClockDiv;
, k5 \; f3 h8 v' v3 J
#if (USE_SD_TRANSCEIVER != 0U)# ^3 }3 q6 `# W$ ^$ d: u
uint32_t TranceiverPresent;
. S+ n" Z+ e9 S7 n( K5 n
#endif 7 I& C: _1 e% B5 e. P: A+ r6 |
}SDMMC_InitTypeDef;

复制代码

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

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

#define SDMMC_CLOCK_EDGE_RISING ((uint32_t)0x00000000U)
4 @0 I, w* S' ~% w" }7 w! y
#define SDMMC_CLOCK_EDGE_FALLING SDMMC_CLKCR_NEGEDGE

复制代码

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

#define SDMMC_CLOCK_POWER_SAVE_DISABLE ((uint32_t)0x00000000U)0 y2 T! k4 u7 h5 s) t7 Z7 e
#define SDMMC_CLOCK_POWER_SAVE_ENABLE SDMMC_CLKCR_PWRSAV

复制代码

BusWide
用于设置SDMMC总线位宽。

#define SDMMC_BUS_WIDE_1B ((uint32_t)0x00000000U)9 U9 e) j. U( v5 A" U/ X' I, g
#define SDMMC_BUS_WIDE_4B SDMMC_CLKCR_WIDBUS_0
3 e0 e4 @( C/ }$ ~; p
#define SDMMC_BUS_WIDE_8B SDMMC_CLKCR_WIDBUS_1

复制代码

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

#define SDMMC_HARDWARE_FLOW_CONTROL_DISABLE ((uint32_t)0x00000000U), q& t0 N0 B3 O1 ^) N0 f
#define SDMMC_HARDWARE_FLOW_CONTROL_ENABLE SDMMC_CLKCR_HWFC_EN

复制代码

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

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

#define SDMMC_TRANSCEIVER_UNKNOWN ((uint32_t)0x00000000U). ]0 G+ v" x" D Z% h
#define SDMMC_TRANSCEIVER_NOT_PRESENT ((uint32_t)0x00000001U)
8 j4 r( G2 `: A7 L, g7 F$ z- w- |
#define SDMMC_TRANSCEIVER_PRESENT ((uint32_t)0x00000002U)

复制代码

4 s! o. L# a( Q
87.3.3 SDMMC接SD卡信息结构体HAL_SD_CardInfoTypeDef
下面是SDMMC总线的卡信息结构体：

typedef struct
) \6 o/ M& R% ]% u5 B Y/ B
{
' J/ p& t! b% S- }( v" d
uint32_t CardType; /*!< Specifies the card Type */
3 w5 n$ j5 |# _4 j) P6 i
uint32_t CardVersion; /*!< Specifies the card version */
7 w$ \' d0 l0 |2 M/ u* |
uint32_t Class; /*!< Specifies the class of the card class */
7 i! B+ F( b) z
uint32_t RelCardAdd; /*!< Specifies the Relative Card Address */
+ r' X* ^+ a% f, h$ t2 |- _# P! |7 w
uint32_t BlockNbr; /*!< Specifies the Card Capacity in blocks */
' J& D1 J/ r8 a, @( \( ?
uint32_t BlockSize; /*!< Specifies one block size in bytes */
' [' L/ ]& j8 q. }; w* R
uint32_t LogBlockNbr; /*!< Specifies the Card logical Capacity in blocks */
) ^6 f$ G' j( {: ~% o
uint32_t LogBlockSize; /*!< Specifies logical block size in bytes */
- |0 K: `1 C9 O0 S" C6 M! Y2 J
uint32_t CardSpeed; /*!< Specifies the card Speed */ o( F, l0 {2 _ e4 _
}HAL_SD_CardInfoTypeDef;

复制代码

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

CardType
卡类型。

/*!< SD Standard Capacity <2Go */
) S1 g5 g& A" o6 T: T$ F& p
#define CARD_SDSC ((uint32_t)0x00000000U) # m! ^- Q8 ~6 ~& Z/ z1 A
/*!< SD High Capacity <32Go, SD Extended Capacity <2To */
7 b0 I8 w4 ?& u, B
#define CARD_SDHC_SDXC ((uint32_t)0x00000001U) $ c8 b% _* k# [" \# d, M+ U% p7 K
#define CARD_SECURED ((uint32_t)0x00000003U)

复制代码

CardVersion

卡版本。

#define CARD_V1_X ((uint32_t)0x00000000U)
+ P- ]" q( t2 S
#define CARD_V2_X ((uint32_t)0x00000001U)

复制代码

  Class

卡类型。

  RelCardAdd

卡相对地址。

  BlockNbr
整个卡的块数。

  BlockSize

每个块的字节数。

  LogBlockNbr

整个卡的逻辑块数。

  LogBlockSize

逻辑块大小

#define SPI_FIRSTBIT_MSB (0x00000000UL)
2 F, h F) u" A) `" a. e7 i
#define SPI_FIRSTBIT_LSB SPI_CFG2_LSBFRST

复制代码

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

/*!< Normal Speed Card <12.5Mo/s , Spec Version 1.01 */9 k2 N% Z( E X" j0 J0 i/ c& p/ [7 _
#define CARD_NORMAL_SPEED ((uint32_t)0x00000000U)
/ e) @4 p [3 @ |( }9 v
' }! _: ]" n1 n3 }, i# Z+ H( q
/*!< High Speed Card <25Mo/s , Spec version 2.00 */ Z ^* S) q% g' j
#define CARD_HIGH_SPEED ((uint32_t)0x00000100U)
/ B3 P2 Z7 O) e6 _ P+ f
# G! T8 I$ j0 b. H# f3 s& n
/*!< UHS-I SD Card <50Mo/s for SDR50, DDR5 Cards V1 O5 S( L- I- W+ M
and <104Mo/s for SDR104, Spec version 3.01 */
: A- s/ B: ?' c B! e0 J
#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)) j5 u Y4 v$ P) ^ X8 U) B# H2 v
typedef struct __SD_HandleTypeDef6 ~/ B A1 v+ F b& c: H
#else/ C$ `* B- H0 Y7 j o+ o! Z4 e
typedef struct
4 A( p3 {* J, R2 s
#endif /* USE_HAL_SD_REGISTER_CALLBACKS */3 n4 T5 n' U0 Z: e" _
{/ h3 h) `9 Q$ |' J: \4 V
SD_TypeDef *Instance; /*!< SD registers base address */8 C5 Q6 X3 _. m4 J L
SD_InitTypeDef Init; /*!< SD required parameters */
7 u9 q9 ~/ t0 p' _
HAL_LockTypeDef Lock; /*!< SD locking object */
3 k$ F+ e1 W9 d; P* q
uint8_t *pTxBuffPtr; /*!< Pointer to SD Tx transfer Buffer */4 b1 t4 v7 l% V3 M% h* a
uint32_t TxXferSize; /*!< SD Tx Transfer size */
! h8 y) f) P$ `4 u" X' J
uint8_t *pRxBuffPtr; /*!< Pointer to SD Rx transfer Buffer */
( X3 m" r7 \$ A9 M: F/ v3 o
uint32_t RxXferSize; /*!< SD Rx Transfer size */
6 {% O& h4 j* |
__IO uint32_t Context; /*!< SD transfer context */
& I8 p+ ]2 C- |, H" T
__IO HAL_SD_StateTypeDef State; /*!< SD card State */
' E8 V: M- `8 _5 g/ K
__IO uint32_t ErrorCode; /*!< SD Card Error codes */9 K1 B1 e$ m' M" o" o/ j- F1 l
HAL_SD_CardInfoTypeDef SdCard; /*!< SD Card information */- ]: G0 E( @) w; |. K$ N- d v8 z
uint32_t CSD[4]; /*!< SD card specific data table */
6 j7 V% v5 b' V6 l* f1 x
uint32_t CID[4]; /*!< SD card identification number table */! u! N- y/ i1 o; w
; t: n+ p: P6 w2 }. _2 B
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
( F* q3 ?+ n3 a0 g% ^( V
void (* TxCpltCallback) (struct __SD_HandleTypeDef *hsd);2 n) u, N+ w6 f) S
void (* RxCpltCallback) (struct __SD_HandleTypeDef *hsd); R# v) Y p4 s
void (* ErrorCallback) (struct __SD_HandleTypeDef *hsd);. C" N" Y" Q8 z! Y" E, L% C. B$ a
void (* AbortCpltCallback) (struct __SD_HandleTypeDef *hsd);* _8 ]" Y9 _* W9 J4 ^* r
void (* Read_DMADblBuf0CpltCallback) (struct __SD_HandleTypeDef *hsd); \( z6 F$ S) S& N4 k
void (* Read_DMADblBuf1CpltCallback) (struct __SD_HandleTypeDef *hsd);
3 m ~! m$ a: ?1 `; y1 C
void (* Write_DMADblBuf0CpltCallback) (struct __SD_HandleTypeDef *hsd);/ m: ?" d& ~4 f; p9 p
void (* Write_DMADblBuf1CpltCallback) (struct __SD_HandleTypeDef *hsd);" c7 Z" s8 x; n4 N# [
#if (USE_SD_TRANSCEIVER != 0U)7 G7 `' U( l1 v: K2 ^5 ?9 o* F$ J
void (* DriveTransceiver_1_8V_Callback) (FlagStatus status);4 ?( t7 R! [, P! n
#endif /* USE_SD_TRANSCEIVER */) h: ^9 p% | F" f' n( ?
/ X' g+ Y& U" K/ G" J5 F. C; u
void (* MspInitCallback) (struct __SD_HandleTypeDef *hsd);+ I7 K# d, ?& ]) o- r5 e
void (* MspDeInitCallback) (struct __SD_HandleTypeDef *hsd);
2 ~, }2 s% A' u. f: W2 ~
#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
5 d1 o. A, S9 \6 v/ X- B' p, \
}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)
1 S+ o- H9 T( q' X
{7 `- O/ E; \- Z6 F+ j
HAL_SD_CardStatusTypeDef CardStatus;! O0 h# J2 O6 [* t, i* W% P
uint32_t speedgrade, unitsize;
0 n3 o+ L/ V# _2 Z
uint32_t tickstart;
o3 o8 P" D& o+ H4 o2 x
; I9 ?/ Q6 ]2 ]1 I2 t
/* 检查句柄是否有效 */
: {* g& u; k5 }1 i- w
if(hsd == NULL)5 P1 o% l% I& U z! r9 y* [
{; S- H, d. _0 C5 d' j/ E) x
return HAL_ERROR;( t7 _( `# b5 B4 k( _
}
# g* [, h8 J9 K. x" D( Z
4 t- Z$ J6 b8 I" }5 U
/* 检查参数 */
H6 n4 u4 _& d. m. R% f0 U' I$ H6 X
assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));) n% x! K* i+ @ \6 l( o% \# i& N2 N
assert_param(IS_SDMMC_CLOCK_EDGE(hsd->Init.ClockEdge));
: @: G4 B+ n* s f& h/ |" l2 \& ^
assert_param(IS_SDMMC_CLOCK_POWER_SAVE(hsd->Init.ClockPowerSave));
' P- i4 F* i( M8 h/ D
assert_param(IS_SDMMC_BUS_WIDE(hsd->Init.BusWide));
% B5 p! {! ]) K& i" M- }2 K* }
assert_param(IS_SDMMC_HARDWARE_FLOW_CONTROL(hsd->Init.HardwareFlowControl));1 u* s; j8 x' W& C# F3 G& \" ?
assert_param(IS_SDMMC_CLKDIV(hsd->Init.ClockDiv));
6 M; z& d6 u& ^ I- _* v6 M$ s
if(hsd->State == HAL_SD_STATE_RESET): y+ B9 z! R7 S3 N' ~
{
/ B3 f4 {( I9 T) k* x8 p( c o% |
/* 开锁 */
m) |: K) V0 D
hsd->Lock = HAL_UNLOCKED;! w7 p3 v* O, \$ V
% ?" V7 x8 q( X5 A0 t- V
#if (USE_SD_TRANSCEIVER != 0U)8 S! Z& O; X7 L( u' F0 F
/* 兼容 */
* P* ?2 O- L6 W" S7 r
if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_UNKNOWN)
$ @% \0 y+ A: B6 o
{, R8 T M& I. @: g1 g! V
hsd->Init.TranceiverPresent = SDMMC_TRANSCEIVER_PRESENT;# c/ y a4 w* c! l/ W. ^" L, C$ {
}
4 {* U$ w" j) B
#endif
3 l! x/ ~1 H1 S6 e
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)$ y4 Z1 S# V7 {6 a1 R& z
/* 复位回调 */
+ P {& l+ r9 m$ E
hsd->TxCpltCallback = HAL_SD_TxCpltCallback;
5 J4 M* x @( Y: g% Y
hsd->RxCpltCallback = HAL_SD_RxCpltCallback;
# y; H- S5 m# P9 @* [
hsd->ErrorCallback = HAL_SD_ErrorCallback;' P! u2 |' n- V6 T u3 w; K! u) d+ @
hsd->AbortCpltCallback = HAL_SD_AbortCallback;! ?. H' w1 S; E" ^' H$ {7 O
hsd->Read_DMADblBuf0CpltCallback = HAL_SDEx_Read_DMADoubleBuf0CpltCallback;; Z7 y" P* W. V" H" W% ~
hsd->Read_DMADblBuf1CpltCallback = HAL_SDEx_Read_DMADoubleBuf1CpltCallback;: W2 s( z* x, u0 {7 C: h: \
hsd->Write_DMADblBuf0CpltCallback = HAL_SDEx_Write_DMADoubleBuf0CpltCallback;- N1 p0 ?; [2 t4 z/ A$ j/ u( i
hsd->Write_DMADblBuf1CpltCallback = HAL_SDEx_Write_DMADoubleBuf1CpltCallback;
! z/ `( G) H$ N+ ^, ?6 f& u
#if (USE_SD_TRANSCEIVER != 0U)6 S- U3 e4 O; C
if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)
2 y2 B, _, K4 T. R, h
{+ P4 t- Y- b, d4 j
hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback;
: o7 x3 q+ ^. J5 A8 L( ~+ i9 W
}% Z" ]1 P' f, ~1 _9 v/ R5 X% a
#endif / t0 W; q N X! m: S7 k! a' J
/ X0 ^7 V' v5 a# p
if(hsd->MspInitCallback == NULL): h( S7 u$ [; K& V! N* _
{
6 \- V8 Q6 |6 a, ^# H- m- h! U
hsd->MspInitCallback = HAL_SD_MspInit;* y$ E7 w! n i& L
}. e% Q3 H7 n7 J5 f6 s
8 l. w& l! g9 l) T( j8 L
/* 初始化底层 */
. M5 ^$ N2 N. J' R& b
hsd->MspInitCallback(hsd);5 c" o% \. Z/ ~& e& J0 O/ ^: z
#else6 m. C. `1 u, g7 X. h5 j8 y+ U9 J
/* 初始化底层硬件 GPIO, CLOCK, CORTEX...etc */
9 C3 }6 B! S) u3 } L
HAL_SD_MspInit(hsd);# [) x( L: \5 ?$ |
#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
9 [3 {' I1 s& t. V$ ^8 B
}
+ v+ p* D9 s' g" {% I- v
0 {" V1 U' f! h4 V0 N/ p
hsd->State = HAL_SD_STATE_BUSY;
6 e/ ]4 T j1 c: \, }
5 [$ f3 R$ V( s7 w. l0 D! J
/* 初始化卡参数 */& X& H6 ]- r. ?. i( W: c. ?
if (HAL_SD_InitCard(hsd) != HAL_OK)
0 N, w) I- t S, \' v
{
' W. m0 }4 r% O0 U8 d: |& P
return HAL_ERROR;
5 d9 ]4 z6 i9 j) j2 @
}3 y4 F3 f0 E7 g# Z# E8 I
/ V3 A. W! z$ o! g
if( HAL_SD_GetCardStatus(hsd, &CardStatus) != HAL_OK)
5 E' V% I; G: K- E/ V) [/ A
{
# O* I, u9 O! f* |3 K0 w' O5 h3 g
return HAL_ERROR;
; }' J# Y c M6 I
}
. d+ i" M- B0 u" [% j4 q+ Z3 Y+ g
/* 获取卡速度等信息 *// m; W5 U8 S' x4 I7 W
speedgrade = CardStatus.UhsSpeedGrade;, G; h, [( {' N- h2 T6 L" e
unitsize = CardStatus.UhsAllocationUnitSize;5 }! V' b, F5 B3 k7 v
if ((hsd->SdCard.CardType == CARD_SDHC_SDXC) && ((speedgrade != 0U) || (unitsize != 0U)))
, Z3 A' \9 X, @- w
{
. Y; E$ D ~8 X! L d8 p
hsd->SdCard.CardSpeed = CARD_ULTRA_HIGH_SPEED;
# N. C. d, r' F0 Z' h
}
: ]! n6 E7 g! w. P7 j8 M8 q
else
7 V3 T1 B, W4 e H: ~9 ^
{
! G9 `" G$ d' b" ~, |! Y$ l& c
if (hsd->SdCard.CardType == CARD_SDHC_SDXC)8 D$ U# B/ W8 u, Z
{
: _& O2 H$ K, y& c. t
hsd->SdCard.CardSpeed = CARD_HIGH_SPEED;
1 Z8 o5 g* k5 K, d6 C
}
0 U+ k7 }% Z ~) }4 H0 X
else5 J# I# c1 m' V) J. P p
{* h a5 |: a, ?6 Z
hsd->SdCard.CardSpeed = CARD_NORMAL_SPEED;* @+ ]2 k- X; C$ x
}
* ?& z) K! z- P) A" _
6 O2 f+ I4 w8 y, y% n
}, W" _9 f `! r: {
/* 配置总线位宽 */0 U9 V3 ~$ e- N$ y4 V: h
if(HAL_SD_ConfigWideBusOperation(hsd, hsd->Init.BusWide) != HAL_OK)5 u W/ r" K* a9 u
{9 D8 x$ N: B% r! r3 S+ p
return HAL_ERROR;
4 t* a* v' Y- j6 N* q7 r* R
}
3 b, _# S; y; `/ w6 R) ?
# M9 U {$ y8 Y; \
/* 验证卡初始化后是否就绪 */; D% P0 ^9 {4 U' M3 s% C% n7 H
tickstart = HAL_GetTick();
- s3 R$ _; O; g- A) D8 o+ L
while((HAL_SD_GetCardState(hsd) != HAL_SD_CARD_TRANSFER))
# F0 ^% f1 [+ R2 t' _5 |0 A2 b/ q+ R
{. X D t4 a5 D0 B
if((HAL_GetTick()-tickstart) >= SDMMC_DATATIMEOUT)! W0 a+ X- U5 t; i
{! ]5 d) h& b$ s
hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;" [ {& w8 a% N7 Z
hsd->State= HAL_SD_STATE_READY;
( h$ H. a2 a6 h: z
return HAL_TIMEOUT;) R4 c7 J" q) a- J1 ^# L
}: K- G0 ]+ G3 `1 F9 L3 p, U& D' Y
}5 o5 g4 s% L& `: M# E
9 F* U- f$ A& a& b% T2 @) F+ I
hsd->ErrorCode = HAL_SD_ERROR_NONE;2 r+ i$ j; i0 T' Z. i
1 @: z/ E8 z5 K* ]
hsd->Context = SD_CONTEXT_NONE;
* Z* U/ W) x' _
' ?+ |, a$ `% k8 P. G( k- H" B
hsd->State = HAL_SD_STATE_READY;& L7 M; v5 o& R) k
* F2 j; d0 v) Y0 W3 w" S2 M8 m
return HAL_OK;8 p: C: k5 ~' ~+ o1 r+ E
}

复制代码

函数描述：

此函数用于初始化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)2 e. x. j; \5 b6 u' Y. g
{9 |9 H. P- m5 ~0 S& E% g3 K; C
Error_Handler();" Z1 J8 L( \: G3 [
}
) @+ S7 f, P$ u! X, ^
if(HAL_SD_Init(&SdHandle) != HAL_OK)5 J6 a2 a7 N! z
{
8 I: E+ y! n3 Z' j
Error_Handler();7 s! w& a7 o$ n# P: n* x& c$ S
}

复制代码

使用举例：

SD_HandleTypeDef uSdHandle;
+ Q& l+ c% V2 l2 I1 \
& p% h+ n7 x9 s( J9 h. H) v4 u6 Q
uSdHandle.Instance = SDMMC1;5 _5 l! P; G6 j* F4 }; N
* Q2 \* P! V2 {5 T
/* if CLKDIV = 0 then SDMMC Clock frequency = SDMMC Kernel Clock, B% ^" @% m7 `9 P6 M n- h
else SDMMC Clock frequency = SDMMC Kernel Clock / [2 * CLKDIV]., Q/ o) h1 u$ g2 ?
200MHz / (2*2) = 50MHz: |; L, e `- I3 Q* x8 c! K7 F& D0 k* J
*/! P R7 Y# q3 {. w) D! W
uSdHandle.Init.ClockDiv = 2; , b1 P; a8 `; h, e1 @
uSdHandle.Init.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE;
1 S! S$ C, k' o6 ?. _) u
uSdHandle.Init.ClockEdge = SDMMC_CLOCK_EDGE_RISING;
L& R' {# h% N3 E
uSdHandle.Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE;; q& ^) Q6 M$ |& q+ v
uSdHandle.Init.BusWide = SDMMC_BUS_WIDE_4B;
0 v/ E* s0 q+ N O T
if(HAL_SD_Init(&uSdHandle) != HAL_OK)
- F7 C8 t8 X; b5 B8 L; j
{
' f% F& o8 A0 J, K6 _3 }
sd_state = MSD_ERROR;" C- g' o8 @+ M0 _: c+ G
}

复制代码

1 w. \' a1 F1 P9 e, G; R' ]6 K87.4.2 函数HAL_SD_DeInit
函数原型：

HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
! K& T2 F& _0 A3 `$ l3 k
{ v- q K6 v/ d6 k6 {1 |' f# h
/* 检查SD卡句柄是否有效 */! t7 e5 F6 M; G: r/ o: Q# ]
if(hsd == NULL), G7 W# c4 E }; Z
{/ G$ h' O6 g0 D" c. x
return HAL_ERROR;1 M2 `2 T9 r/ ^
}& z# _, A1 `8 E2 p G: ~
) S* j9 b/ A* ?- K! x+ D' ~1 M
/* 检查参数 */. C1 i2 W9 z# J# j, L* D8 ?
assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));; V4 G. Q# }/ b5 {( `
7 x& s3 @1 H* q2 _% M
hsd->State = HAL_SD_STATE_BUSY;9 ^# G6 V5 n9 ^, r' G0 x
+ V2 M# ^/ T7 Z8 ?. G& v- m
#if (USE_SD_TRANSCEIVER != 0U)
3 A- W/ X5 Q- N' t
/* 关闭1.8V模式 */' i' c u& m; ~2 F5 b
if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)2 b0 Z- z; K$ c6 U- K
{
. _& ]$ ?# H) T
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
) h( s+ x2 P- r" Z- h8 R% X
if(hsd->DriveTransceiver_1_8V_Callback == NULL)# u- t$ |+ a: h' m @
{- F3 E) D* r+ q7 G/ O8 v
hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback;- f6 `( i' O, ?: h9 f5 b# a3 F- Q7 w$ K
}
9 X' m- I5 ^& j4 y: l% B+ h1 ~$ ?! k
hsd->DriveTransceiver_1_8V_Callback(RESET);
6 q7 Q* o: k' N+ v6 J* q7 b, l
#else
* F7 w/ F: ^$ Z1 [8 _
HAL_SD_DriveTransceiver_1_8V_Callback(RESET);
4 U/ P5 [! f4 J1 K8 t: w4 [
#endif
9 V1 z! F* P, o$ y& I* |
} 5 j( j3 Y8 c# f6 m! a/ f
#endif6 Q. z: i* o, C; j% Q
. j0 ]2 ^4 F8 @% O8 w& [
/* 关闭SD卡电源 */
# }! H9 d( b" M2 ]$ J3 u- `
SD_PowerOFF(hsd);
2 u. A; r. P( G* r5 Q2 b2 F8 w
( q& o1 o1 X! U" H1 N% O: `2 n
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)4 O$ R7 i" M) K) C) @/ R9 K# P1 ]
if(hsd->MspDeInitCallback == NULL)7 }# O% t3 H; o
{
3 e& d' b% s: Y) d# d- A
hsd->MspDeInitCallback = HAL_SD_MspDeInit;! D5 j. J. N- @
}
% y9 T, ]& i! {/ v' P) t% Z+ ~( |
5 Z. U. y2 f4 r" A( \
/* 复位底层硬件 */
]0 I# T, K. [1 q# |# A
hsd->MspDeInitCallback(hsd);6 C( C3 X* ]* S: m9 T y
#else' S. f8 g1 R2 M; r0 W1 g
/* 复位底层硬件 */7 Z3 Y7 u$ m0 t6 X3 Z; r' H" a
HAL_SD_MspDeInit(hsd);( d$ p( B- g# V1 q! l! u4 D
#endif / L+ x' T4 f- I$ H, E% }3 h+ Q
7 S7 g5 c& \% |1 i6 H2 u$ @0 x
hsd->ErrorCode = HAL_SD_ERROR_NONE;
# @3 ~: ~2 S+ r N( B
hsd->State = HAL_SD_STATE_RESET;
* Z8 x6 B6 e7 [2 ^5 M
0 d" c8 e4 O6 N1 e
return HAL_OK;/ T: J5 L& j7 R. e1 Y& i
}

复制代码

函数描述：

用于复位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)+ F/ Z2 u- P# D/ h ^/ m9 p7 |
{; @7 l* x3 A7 o+ [) }, i
SDMMC_DataInitTypeDef config;
& B3 b8 p/ |9 e% m S
uint32_t errorstate;
9 c3 S4 ]# x( s; h3 S, [ M0 _
uint32_t tickstart = HAL_GetTick();. m& Z# m! \4 |; q, d7 e
uint32_t count, data, dataremaining;
; c: W% Z% w4 N1 e& T& ]
uint32_t add = BlockAdd;
% N; r& o2 c, f, Z7 m) ?+ E! p" X
uint8_t *tempbuff = pData;
5 D, W/ z4 K! r1 h
; H0 k4 O' h, g1 R, Y0 i
if(NULL == pData)
/ | L' m% r& E) ^3 z
{
3 j* m& j, X d7 n
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
8 j8 o7 z! J. C; o
return HAL_ERROR;$ w. n; g( J" _' i9 Q
}7 b& P# ]- J- ~2 X. |
3 i2 S3 Y2 Q1 P/ G/ S$ ^: w
if(hsd->State == HAL_SD_STATE_READY)% D6 a; A/ ^+ H Z
{# l2 T+ T" P" p4 h' p9 I; |9 B3 {! A
hsd->ErrorCode = HAL_SD_ERROR_NONE;
3 g9 G0 M% T& V7 t- Y( }( _
! c U; f7 G4 o2 x J: X$ Y
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
# `% h% m0 t2 T" {1 K
{" x5 N6 A( s4 k/ o' U2 Z
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;$ S1 B( z, |; K& m$ g3 V* L
return HAL_ERROR;7 m3 v6 N! Q8 D9 |
}
# L" C$ i% q8 ?! u( q! W
4 |# Z# Y+ T. k& w4 O8 q# l7 z
hsd->State = HAL_SD_STATE_BUSY;
# `. M2 w8 ~' `
0 K" [9 }! \( {- u* ~0 X: s
/* 初始化数据控制寄存器 */
" U1 |; Z! k3 i3 v! P2 J* i
hsd->Instance->DCTRL = 0U;& A' E: `6 K0 h0 K2 Q
' F8 M! I" K2 A9 g" V
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
7 r. J: C$ m( A3 A4 e% l
{
w* x* W9 A, F9 r: r0 W! R
add *= 512U;
g. G7 \2 K3 B; w& W
}4 `3 l1 x) C R6 F3 I8 h F
6 U0 Q9 C% D |& J! o. G0 ^" p
/* 配置SD DPSM (Data Path State Machine) */
) c4 T2 P; v6 e4 I8 G# `
config.DataTimeOut = SDMMC_DATATIMEOUT;" J U, D3 a1 {. n* ~
config.DataLength = NumberOfBlocks * BLOCKSIZE;
0 M* r+ ]! B3 _1 _, s. o2 C
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;$ ?5 D3 j: M Z, M: t/ \7 ]/ L- E0 D) u
config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;8 H9 Z: U! C% O5 O7 @2 _/ j
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
$ ~1 S e/ w/ k4 w+ @! {
config.DPSM = SDMMC_DPSM_DISABLE;. \0 `- b7 S1 c5 l! |! s
(void)SDMMC_ConfigData(hsd->Instance, &config);3 D$ Y; P# }( \; X2 _0 L; {
__SDMMC_CMDTRANS_ENABLE( hsd->Instance);
6 R1 x! K! w8 D. k8 ~5 E$ d/ ^8 Z
9 d' R F H8 a+ ]) e& X2 v: _/ O' b
/* 查询方式块读取 */
& N: y# h& P. ?, \; k2 V6 f5 Y- t
if(NumberOfBlocks > 1U)% B" X- R- f' e7 b) i# L; D
{
a. [( q1 c8 L( v9 g3 h: X2 k5 Q
hsd->Context = SD_CONTEXT_READ_MULTIPLE_BLOCK;
5 P. @/ K6 t/ q% o: S# t4 F7 O
( O* U( Y$ _. s; h4 x8 j9 j \# _
/* 多块读取命令 */
; w+ j, Y9 X* h/ J; e! {4 V
errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
5 A- H% ~- A1 l5 F) @5 }2 Z0 B
}. O# l8 m. _: {! A1 @
else
, A1 r& r' \; T P
{' I# v( N6 p* I
hsd->Context = SD_CONTEXT_READ_SINGLE_BLOCK;! h& m, \9 D% j- s# T
- d4 Q" i0 K7 I E
/* 单块读取命令 */
1 g3 f8 q1 |. h( o4 K9 P6 ^
errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
1 l" {0 t& {- _9 _
}
if(errorstate != HAL_SD_ERROR_NONE)! r: D& f9 V$ e6 l- e% n
{
. l8 o4 V, P7 m$ z; x8 ^0 J
/* 清除所有静态标志 */" s& b4 C/ M: N
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
' ^8 p& N9 W: ~; {
hsd->ErrorCode |= errorstate;
) y/ |3 ]! w/ V% s, ^
hsd->State = HAL_SD_STATE_READY;
hsd->Context = SD_CONTEXT_NONE;, \( |1 Y" q# ^% o
return HAL_ERROR;
: y4 M- Z4 e! A( ?, l3 o
}
) F; q% _+ {+ G
; m- `9 g0 K# P" w1 f% k
/* 查询SDMMC标志 */$ t* D# f6 E9 X7 x% j
dataremaining = config.DataLength;. h2 z+ @1 d9 K' ?
while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
5 [5 V8 J) Q" j9 n0 j
{8 f# N) L7 E; }% a. L
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF) && (dataremaining >= 32U))
4 ]( u; u$ R8 Q D8 u* J
{( h4 }" _4 u1 ?$ c6 r% V8 \
/* 从SDMMC Rx FIFO读取数据 */6 N% n$ E: a9 X8 X! C+ a6 Q
for(count = 0U; count < 8U; count++)7 S- q+ \- x6 l& n3 z
{
4 j4 ?. {3 I* Y; R& \& G
data = SDMMC_ReadFIFO(hsd->Instance);
; G$ w! J" I4 P( |7 ]; N
*tempbuff = (uint8_t)(data & 0xFFU);
7 e1 l0 Q) n! W" J
tempbuff++;
6 J4 y3 @! x- [2 ]5 O) ?
*tempbuff = (uint8_t)((data >> 8U) & 0xFFU);
: m% N) m9 n: ?( [: W
tempbuff++;5 |( v A) H4 \* z6 o
*tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
4 s: v" M6 A8 K% s. E0 x
tempbuff++;) F4 }7 k) _/ q8 x/ o: ]& j
*tempbuff = (uint8_t)((data >> 24U) & 0xFFU);
2 Z E* V+ k* `$ ~: u4 o# E
tempbuff++;9 m5 c7 p9 m9 a/ G" x
}
; _; m1 ]9 M+ p
dataremaining -= 32U;+ ?# y4 O: c j" {- p7 W0 Z4 s Y8 e
}7 e: m& `) f" s& @2 N
3 x/ i \5 }1 z: g& N2 [$ t
if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
" A2 Q z: L& W' w
{! r& E1 K5 [: y. N6 G
/* 清除所有静态标志 */
2 N1 a' H0 P! a) W6 u
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);- |& T" ^. G, }7 q9 }5 @1 k
hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;2 U6 d' V6 G$ A
hsd->State= HAL_SD_STATE_READY;8 }2 ], _; J6 @- z/ N# F
hsd->Context = SD_CONTEXT_NONE;
- ?# d, L q6 c
return HAL_TIMEOUT;( B; _! p6 O9 G. R( M4 E
}3 I& q6 x p9 u7 d
}% U, G( N. ~: k4 N' V# B' w( w7 `
__SDMMC_CMDTRANS_DISABLE( hsd->Instance);' D3 O; f: y& \4 F
Z; [! f+ y7 A- y) @; W$ F. x
/* 多块读取发送停止传输命令 */6 u% `6 U) C' Q1 S; U! P3 J8 [
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U))0 E4 y; b3 W5 L& h
{
! _4 s+ D$ q3 ] s' Y6 w, G1 [9 ~
if(hsd->SdCard.CardType != CARD_SECURED)
5 z) q- H$ u- l4 L7 _( ]
{
8 u9 g* l' }) O
/* 发送停止传输命令 */
: M- ?% M& B" I7 K. K" X! B& O- ?$ {
errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
1 B6 e: f5 J$ R) @1 v# u
if(errorstate != HAL_SD_ERROR_NONE)
9 {& M: c! J$ W* L# c; E6 K
{( ^# w) G, d* G& f: v% O& D6 }
/* 清除所有静态标志 */
$ d, _: r- R% X
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);# r- e& l/ E5 _7 N) A2 Z
hsd->ErrorCode |= errorstate;
4 Z; b/ ]. X' E& x+ R( V8 z8 Y4 a
hsd->State = HAL_SD_STATE_READY;) A( _# }# U o, p( Q& ]
hsd->Context = SD_CONTEXT_NONE;
/ O0 `2 n9 Y2 L# G
return HAL_ERROR;/ v8 P* ?9 }" R2 [1 D
}+ H; _4 x( E4 J( Q+ ^0 p
}
; V3 s6 V! u1 k( c) M7 i$ S
}
* h0 M7 @2 f8 t
, R* x0 s- S$ ~* F" d
/* 获取错误状态 *// V! S- F9 i" ] \9 Q" D
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))9 V2 `/ c3 _* X$ ^2 D8 g9 e0 {+ B
{: w2 Y2 J. l/ V1 S+ o
/* 清除所有静态标志 */% Q [: ^5 K* v L: G$ o' Z9 s! ~
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
* x% ^1 d+ V; ^9 F
hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;- U5 v) Y7 K4 R" |
hsd->State = HAL_SD_STATE_READY;
/ C2 s, z# q) ~: s, r( g. E
hsd->Context = SD_CONTEXT_NONE;
* X0 `* N$ }# j
return HAL_ERROR;
/ C; n* T6 d T' z) h+ E5 M, ?
}
3 k. a6 g% l" z% K$ C' H
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
- S5 `! x1 X) N) C
{& R5 {* C- @) z8 B
/* 清除所有静态标志 */7 R2 F/ c5 n8 o; q' V3 V& T
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
+ M/ D9 T+ o. U( E3 b; s8 @) q
hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
5 B7 e& B9 h- h: {2 {& N: C! @
hsd->State = HAL_SD_STATE_READY;
8 ?! _: D3 Q) V! u
hsd->Context = SD_CONTEXT_NONE;9 M) D/ _) P; g, e
return HAL_ERROR;& o c( L4 A# X" Q/ z) v& S- C
}" R/ Q* O0 N- _! p/ Q; j6 _
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
) L" j6 i. b* Z) M; r" x8 I, x
{
% g! M, r' d. R4 B/ S
/* 清除所有静态标志 */
& \+ F( W3 W5 e
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);$ A) x; h7 W8 o4 K
hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;9 e$ w9 }/ _- z. E
hsd->State = HAL_SD_STATE_READY;- r f. \& d# q3 ~: Y/ k
hsd->Context = SD_CONTEXT_NONE;
- \! z7 \2 U# _1 ~1 h. k$ g; l- @0 N
return HAL_ERROR;
/ C: @8 X& H/ _' i$ h p
}
& u& ^$ r; |) V/ n
else3 M( u* y% U, o/ ~
{
% w+ ~# T# f( @; p7 e) x" `, z
/* 什么都不做 */5 q# h% h$ v( H. T9 Q
}
P. q: n& n, u1 A
) V% C- \% h* j! j# k: E; m
/* 清除所有静态标志 */
# k4 T2 Q G- ~) \% O& Z$ U
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
) b: J2 Q. Y- X$ }. P, @
% D; O- n! h# @ u1 D
hsd->State = HAL_SD_STATE_READY;( Q$ B' g7 [1 B3 B2 n4 ~
5 h1 e0 r% q* R
return HAL_OK;9 j! x6 }9 v% v
}) u6 ?" q& [6 C. o2 h4 ~' e
else
* V8 D* F. N( g# d! p& P6 d
{
R+ K0 w0 k, `; l
hsd->ErrorCode |= HAL_SD_ERROR_BUSY;, w3 ?: [* L1 M& Z7 \4 n3 N* N
return HAL_ERROR;
4 I9 j m- E4 z/ W( c- U/ @4 n
}
# Q2 F9 q4 ?9 P4 m( R: G0 ]
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**9 }* `; S9 t/ m6 v- p
* @brief Reads block(s) from a specified address in an SD card, in polling mode.8 O8 J" b$ e- q7 P0 R
* @param pData: Pointer to the buffer that will contain the data to transmit( @; x3 h3 S# p5 |. U& w
* @param ReadAddr: Address from where data is to be read+ z& d) u' b, `9 P1 W o
* @param NumOfBlocks: Number of SD blocks to read# d/ y- n9 a' N+ x) [! P: B
* @param Timeout: Timeout for read operation, k6 Z& i3 z7 A2 Q- X& i. W
* @retval SD status
4 Y7 A+ h/ h9 L" Q) q& Z
*/
5 j- \% ^- v$ S, Q: T
uint8_t BSP_SD_ReadBlocks(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks, uint32_t Timeout)
, [0 L4 t- }$ Q' w8 r: I0 o4 \3 ~1 q2 J
{
/ o4 l$ p1 `. ?$ E
* ?& y; K, V2 u; x
if( HAL_SD_ReadBlocks(&uSdHandle, (uint8_t *)pData, ReadAddr, NumOfBlocks, Timeout) == HAL_OK); p4 v4 p* }7 Z) \8 B i1 @) x
{6 E' A' q# @, V/ E9 H8 p
return MSD_OK;
. N( b N% O; v4 t0 X& f2 ]0 H
}" P0 [" O2 i- s: w x6 K0 v
else8 S# T6 B) ^2 I! M9 Z/ c. s6 @" k
{
8 e9 l; {8 S+ b, x6 e. U; C& D6 d
return MSD_ERROR;
: B) {) @; x1 N3 h
}! ?" R1 n& T- w1 M
, W6 s, P+ ]& p- d1 \4 W5 M
}

复制代码

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)% A& v" I1 O- O, I9 Q
{, Z* k) x' o) c
SDMMC_DataInitTypeDef config;
6 l5 i- \2 B& e4 q1 i& z; O# _' h
uint32_t errorstate;$ _$ F1 b0 P$ {3 C X5 g( L
uint32_t tickstart = HAL_GetTick();
! R' e9 i# q+ ]+ ~! j! B5 H6 w* @
uint32_t count, data, dataremaining;
. D8 T' t. Q8 N6 n% P" }9 d
uint32_t add = BlockAdd;" w% A% Q/ n, y0 F( v
uint8_t *tempbuff = pData;
6 M, p' f( V. k( A5 D
2 o6 n5 [0 m2 B* R4 D
if(NULL == pData)
, F/ i- c: v( }
{* Y3 z2 P- A" B8 f0 C
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;4 R/ i* I! f1 W6 @! P+ W- A
return HAL_ERROR;
8 h* t$ ^% c6 N7 C
}; ~) i8 q" H: s; j' ^
0 C! d! A I4 f; g L
if(hsd->State == HAL_SD_STATE_READY)* `8 z: T6 H9 W: F5 i. t
{" r5 S( v& r9 y+ r; ^/ X: N
hsd->ErrorCode = HAL_SD_ERROR_NONE;3 q1 E j3 K/ U% f
& \: N% s+ ^8 W9 j3 G& k
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))/ `' U% n" ~7 `4 H
{6 r) m, N2 i N! l
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;4 y9 Y' j3 J& Z8 v9 M' Y3 n% r M) R6 x) N
return HAL_ERROR;
) }( H- A, l0 I: s$ h
}( I& \0 E3 ^' J) i+ r/ A7 W$ U
) R9 U) G5 v4 `. {8 B0 L
hsd->State = HAL_SD_STATE_BUSY;; P2 w5 b9 `2 n3 M+ |: X4 G
& |) s$ A; H9 N9 Q x3 A- Y+ t
/* 初始化数据控制寄存器 *// t4 u4 l8 s) ~. i; k
hsd->Instance->DCTRL = 0U;
& D$ d: q. b# L5 C5 w+ J" L8 |
' C) t4 ]6 A6 N/ M B9 p5 {0 b
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)1 a# B, E( B+ V0 r, P: {
{% B8 ^0 p' w0 ~7 N
add *= 512U;5 H, b) J$ E" d: M
}; c0 M9 h& Z% i5 |$ g' k6 ?5 L
+ o, Z6 ~5 V5 r8 B
/* 配置SD DPSM */; J& X4 B# r5 Q
config.DataTimeOut = SDMMC_DATATIMEOUT;
2 ?/ s. l; c. e# m, O7 n$ O
config.DataLength = NumberOfBlocks * BLOCKSIZE;# ^8 F+ R- p, m/ W3 D
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;4 z; V7 X$ y! |
config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
7 Q4 s" j X, H% {$ y% d5 ]: N
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;$ q' z5 Q2 M0 A; k; t+ I
config.DPSM = SDMMC_DPSM_DISABLE;
+ ^7 B/ @" v; @+ K' z9 [( b
(void)SDMMC_ConfigData(hsd->Instance, &config);
* e9 w/ f0 S; o$ y6 P7 G
__SDMMC_CMDTRANS_ENABLE( hsd->Instance);
l" k6 ~' t4 B, K+ x5 |
- ]! _ f) L# b; C& g' ?( v
/* 查询方式块写操作 */- G: ?* M6 T: k/ B
if(NumberOfBlocks > 1U); w# u0 s* s! i
{& `- t! S: m$ P3 i; i
hsd->Context = SD_CONTEXT_WRITE_MULTIPLE_BLOCK;6 b1 F- p" ~( t: ?$ `2 G$ j
5 E/ t1 s/ x' M% \& a
/* 写多块命令 */
0 |0 P3 ?8 W( R, z; F$ d" t N
errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
' [6 {( @# e7 p: h* T: `
}, r3 v1 l! @ X) D7 S7 F) U$ x
else8 a" u: l' C) Q" i1 x
{# s' B3 p2 Q, p4 Q% z3 M
hsd->Context = SD_CONTEXT_WRITE_SINGLE_BLOCK;
- ?9 d' |' j) c* K2 H; G! r
4 O2 x3 \) ^) R6 D
/* 写单块命令 */" `# h- x- s# b* T
errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);$ K% B* k. B# z& y
}
, K1 p0 D. z3 H' H
if(errorstate != HAL_SD_ERROR_NONE)6 p9 Y2 p" |) H, T8 R. q
{# w4 D4 U6 t+ u. x) t
/* 清除所有静态命令 */
7 s8 O9 T- y) K! L
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
; V" }4 b1 F R8 D! G0 M+ `
hsd->ErrorCode |= errorstate;
z8 S3 ~# @! P) d% y; K
hsd->State = HAL_SD_STATE_READY;$ k: ^4 w8 E# @* ]$ r
hsd->Context = SD_CONTEXT_NONE;3 |. E( g; F( u" X9 d
return HAL_ERROR;
0 a+ ^5 @% H; ^. p [
}1 L4 ?, n7 P8 d+ ]/ b
+ {4 z, T$ V5 ]1 l6 y' y
/* 查询方式块写操作 */
3 e7 q) B$ j' s% n3 C
dataremaining = config.DataLength;
! S! w+ o% L8 C: _6 E" s
while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))0 n: M% c9 {1 A3 a) u" H) @6 }
{; R' |; H& m, D- Q0 N9 |- q- f; ~
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXFIFOHE) && (dataremaining >= 32U)); }6 K4 x. t0 U1 ]. ]) O
{
; @9 X. d G1 Z* j2 D" w- D8 q
/* 写数据到SDMMC Tx FIFO */
3 F# M0 n( ` x5 a
for(count = 0U; count < 8U; count++)
) F& q9 W% @8 Q) M J4 ?
{
9 h, ^% H) O Q+ E+ k* X
data = (uint32_t)(*tempbuff);2 `) d) G7 h; t$ u
tempbuff++;
3 `- N; c3 N5 r5 n4 S/ T4 A/ \
data |= ((uint32_t)(*tempbuff) << 8U);
$ W% X ~. |- W5 f
tempbuff++;3 B0 ]# H# b: r& J' ^
data |= ((uint32_t)(*tempbuff) << 16U); `7 A' u$ x- j f* G
tempbuff++;3 }: ~( o1 Z4 U# y% N
data |= ((uint32_t)(*tempbuff) << 24U);7 d! l2 z; a- X0 _# Y9 _
tempbuff++;
+ Y7 j7 f4 A- g6 x
(void)SDMMC_WriteFIFO(hsd->Instance, &data);; ^" w. R# e2 U+ P% m
}
9 g- x! A+ s3 v
dataremaining -= 32U;
$ b1 N O$ f. T+ d
}
9 X: p$ y9 v5 e. S, \9 |
/ z; I2 W5 ]5 E# Z& o7 ^
if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))1 r0 n+ |6 Z, R" g
{$ s3 U: x$ O) y; }$ O
/* 清除所有静态标志 */
[( g& B5 L( P: o
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
' J, H; }+ L! q/ {5 {4 f: U
hsd->ErrorCode |= errorstate;- l; ~! Y# ~. S5 n
hsd->State = HAL_SD_STATE_READY;' W5 ]# }$ D3 N7 U9 N' i
hsd->Context = SD_CONTEXT_NONE;
6 d. H3 Q3 |! U8 J
return HAL_TIMEOUT;
; q$ b$ t: T4 V" H0 f) B' v
}; p8 {2 [) l+ Z9 d
}
. _) N% m Q, u' [1 C
__SDMMC_CMDTRANS_DISABLE( hsd->Instance);1 l( A1 m8 ^8 f( o: z* A
1 T; h4 n$ z2 Z4 {
/* 多块写操作，发送停止传输命令 */" D* O7 Y6 P1 L) I1 m
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U)); }" y* l0 l% d& B; ~- g) o# n5 K
{
& w3 \& L+ ^) o: T, q
if(hsd->SdCard.CardType != CARD_SECURED)( M, w/ o, a4 e( L& u% @4 k, {
{9 r% i; b" C% z6 y# h+ b
/* 发送停止传输命令 */: V0 N, \( ?7 q$ l! U6 \ L0 w" `- E
errorstate = SDMMC_CmdStopTransfer(hsd->Instance);9 W8 L$ ?5 u" l4 h. X
if(errorstate != HAL_SD_ERROR_NONE)
. R1 N5 V! ]8 b5 w" Z4 x$ k
{
6 L2 c2 w! K5 O, P e3 C# \2 ^' p
/* 清除所有静态传输标志 */
0 h' g' O' s" N, I( a t: u2 j, y' T
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);+ |. q% E; L, o( D d
hsd->ErrorCode |= errorstate;3 s0 T" f4 e0 M, F# L" P
hsd->State = HAL_SD_STATE_READY;
A" H/ ]& C. s; e! T; Z4 G
hsd->Context = SD_CONTEXT_NONE;9 Y. i" u1 P2 Z* U4 @
return HAL_ERROR;' V! s! m- Y8 k3 ~9 n
}* e4 s& s f! y4 R+ F( b4 g4 A, r
}" _+ w/ }: Z7 _: f3 _
}0 n3 j3 D3 C5 [
) F; ]- t% _+ J( }
/* Get error state */
9 l; i2 [+ a3 v
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))+ r3 G0 L. P" Y* d6 F0 V
{" Y8 Q, w% _' L: s0 K
/* 清除所有静态传输标志 */3 W3 ~6 d2 X- `# g* b
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);" V% p0 K- d4 b8 S
hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
, w/ u/ B& f& e$ ]4 E! A4 `/ x9 [
hsd->State = HAL_SD_STATE_READY;
1 Z6 j, C+ P' \, J8 S( j
hsd->Context = SD_CONTEXT_NONE;
% D0 X6 \* z! I! S' a a. B
return HAL_ERROR;
- a- ]9 S+ ]% i9 ^$ H$ U
}+ |! @* z+ d/ J2 I# ~/ E3 A
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL)), E# I3 T5 w0 D+ U4 V; A3 L9 t, n
{
/ R. K# }4 y: C3 U! y: A
/* 清除所有静态传输标志 */& _/ X/ w) M, k5 T6 x
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
+ V5 n$ ]! O3 m8 T8 O; A) M
hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
* ~6 m6 b- L; b! J- [
hsd->State = HAL_SD_STATE_READY;
; ~1 X3 k0 T, ]9 E4 c/ U) D3 ]. x
hsd->Context = SD_CONTEXT_NONE;
p. f: [$ n! m8 K7 E
return HAL_ERROR;
# X3 }2 U" g, R. A) u
}
! C' L' q+ P3 a( {5 G0 R
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR))
$ o7 X1 D7 j3 w+ X" ]
{! S8 t5 v4 C: ?4 b; l
/* 清除所有静态传输标志 */8 ]& h$ L( y) I _6 r
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
2 O2 p7 f2 I5 @, p) D4 p
hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;/ ?! f. A" v" c& e8 t
hsd->State = HAL_SD_STATE_READY;
1 E9 }% K N- B( N( y
hsd->Context = SD_CONTEXT_NONE;; z+ |' V8 E; F( ^
return HAL_ERROR;
3 d/ H k7 ]: b
}" t9 Z, r6 ?- r( V# C% z+ N" U
else
* m x4 M9 [3 |; {/ E5 N' R" v
{
5 j- ]8 u: b, s3 C, O5 B7 h6 L
/* 什么都不做 */- c+ G2 N1 l" ]4 V0 O/ t- D. B( O, S
}" ?, s5 d& F# G* P7 e6 D, q" f. @
% l) h, @' T& _; T+ W
/* 清除所有静态传输标志 */1 E$ P- q, b& ?5 _ K) I
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);/ _0 p/ r. c; l- E0 U
1 K& _) f z, N- i
hsd->State = HAL_SD_STATE_READY;! C( u3 e7 F; V Z( M+ c
) T% g( E/ x1 W: A
return HAL_OK;9 [0 \) }4 h. \4 P4 \
}
# W- B s( k: @0 z% ^' K( M
else' E4 W8 [; c3 A* P% J* _
{0 J$ U& E) i: S& T' V) e% Z
hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
6 x, V. ^/ e+ f
return HAL_ERROR;
3 f; T% B/ G/ w& r, W# z
}& p5 T# y# d0 V% y! {7 q" v1 o( _
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**
8 x3 f1 D6 _9 Z
* @brief Writes block(s) to a specified address in an SD card, in polling mode.
- |; M4 C- V' L" ?2 i1 d. v
* @param pData: Pointer to the buffer that will contain the data to transmit
2 D7 z" b3 X* @* b n$ v
* @param WriteAddr: Address from where data is to be written
( k% a& s" I2 }6 G/ e
* @param NumOfBlocks: Number of SD blocks to write
' M. X; y! p( ~& P% j% j
* @param Timeout: Timeout for write operation
; p! ], M+ L# b' e; ?
* @retval SD status
1 y4 k9 o* X/ N5 m
*/
; q5 u8 p% g3 r5 d0 B o
uint8_t BSP_SD_WriteBlocks(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks, uint32_t Timeout)
/ n9 _5 P# \+ H* ~" G& o! h
{
& V- t/ a* y8 e
2 j( l. p8 |! W- L0 p4 K
if( HAL_SD_WriteBlocks(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks, Timeout) == HAL_OK)
$ u9 b, _. q* Q
{
1 o7 y; ?7 |7 h' A
return MSD_OK;
0 M# A" E6 {- Z, s8 ?6 Q# T2 n" Y
}/ f- W' z8 x. U9 V/ \% l
else
2 K9 T/ Y4 W9 F- O# s" p
{! L& h& x) H. f5 J1 |
return MSD_ERROR;
+ z ]4 W* V, B- f6 x" ~+ e
}
% x. k9 Q. K3 _1 Y6 F, o0 m- v
}

复制代码

r) x$ K; R7 s8 v7 h) g
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)4 o T% ?5 m% W l8 |+ N
{
: C: G5 B M ?$ b! s7 h
SDMMC_DataInitTypeDef config;
# a* i4 R) G* J1 o& W7 H3 ~, O( S9 i7 W
uint32_t errorstate;
2 G+ ]3 n5 X5 M! J
uint32_t add = BlockAdd;3 V3 ^2 B. E& j5 M& [! @% r4 F6 Z
9 { q' T% J6 ~/ k
if(NULL == pData)
) C0 [2 C. M) ~- Q
{" L1 E) M+ S2 g; [4 p
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
0 T1 i0 T$ Z: O
return HAL_ERROR; F, U) K" V! ^
}) i h B4 Y/ ^8 N# j
% N. ]% P' n1 i. \
if(hsd->State == HAL_SD_STATE_READY)
p) P+ i; d* g8 }0 n3 S0 i# f0 d
{) n7 q8 o% ~, q; x1 Q
hsd->ErrorCode = HAL_SD_ERROR_NONE;
2 p m$ I8 A1 w# E
$ q8 J8 i. {4 S- b: ^5 b
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))/ B$ `$ ]. a' ^% n& W
{
y1 r p3 E5 |* b: s" Y3 J
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;6 J# W" u% B" U) [0 r
return HAL_ERROR;: F1 G9 a1 W# ]3 B6 {" u
}' Y- t6 P2 w+ J' Q8 M* C* T! b% O& @
8 y5 X6 f/ u R, v3 s9 N' U
hsd->State = HAL_SD_STATE_BUSY;
$ H+ f2 d7 A; r8 }. A9 f1 H
( k h1 U; |) E% a/ Z# A
/* 初始化数据控制寄存器 */
' s! H b9 g$ b: s
hsd->Instance->DCTRL = 0U;8 C, ], a% D) e2 X3 h( h
$ x1 v3 V- O1 J; m* {
hsd->pRxBuffPtr = pData;& }& r3 g. ?/ I3 F/ {$ K1 B
hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;
5 F9 z: c% T% R$ c) Q2 R8 V7 K9 P
7 A( {0 \1 f/ O
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
S2 B! `$ n* c1 |! b" t0 H
{) A: B9 S& s+ w0 H/ p) Z. e- z
add *= 512U;
2 [' u* b7 s- s4 A
} u1 Y/ E, p+ q! i
+ [* b6 m+ C/ a( g8 k
/* 配置SD DPSM (Data Path State Machine) */
4 o' G7 k: x( \* A1 p4 E
config.DataTimeOut = SDMMC_DATATIMEOUT;5 a' u0 h; t1 l
config.DataLength = BLOCKSIZE * NumberOfBlocks;
+ M% U3 D+ s2 v2 T) D) t5 ?
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
- G7 U: X1 w' K/ `( o& N
config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;1 M1 n+ ~6 D! t1 I
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
9 v6 r' S4 N# l2 C
config.DPSM = SDMMC_DPSM_DISABLE;3 U4 n/ T4 U: [9 U
(void)SDMMC_ConfigData(hsd->Instance, &config);% U1 R6 \9 {( H/ I$ c& z! I8 A
/ J$ p9 Y* [: ^
__SDMMC_CMDTRANS_ENABLE( hsd->Instance);
5 o' } H( z( v
hsd->Instance->IDMABASE0 = (uint32_t) pData ;8 L N. t4 \/ G N
hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF; @: H4 y& k, h0 N
4 e \6 v6 b4 f5 M6 n$ k3 Z$ h0 u) d
/* DMA方式读取多个块 */; u* g% C3 L( k
if(NumberOfBlocks > 1U)
% m: h' q3 N( }
{
$ H5 m8 Q) E6 r7 k& x8 L4 w. C9 C
hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA);( ~8 c* o8 s0 w" B
; V: p4 L! c$ H- k
/* DMA方式读取多块命令 */
i, w! S* c5 w/ p
errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);% y. ~, G" z# w9 o
}
4 t! D# ]5 n0 M+ U9 k3 `) x; r
else: s: B) ?7 Y; q8 r+ j
{. p0 a k. J6 w0 K) _3 e
hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_DMA);
: C5 f! ~* y1 t. k. {8 i& h
6 b( W* m: W7 \! Z
/* 读取单块命令 */
( A( L9 y* q2 l- n) x& z2 s
errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);2 |2 ?! }# y4 p! D2 F/ Q: |
}
/ M& y2 a9 v' V' u
if(errorstate != HAL_SD_ERROR_NONE)# |8 W' x% k# ?. H+ X+ ^( P2 q. c U
{" E9 N T1 L9 u1 c3 z/ F( K
/* 清除所有静态标志 */
+ n8 c' S2 w3 w/ `
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
: l1 j `3 J- \! {. {# e: Z
hsd->ErrorCode |= errorstate;$ j6 e i: _5 A* s1 Q
hsd->State = HAL_SD_STATE_READY;
' X+ ]+ y& c- F
hsd->Context = SD_CONTEXT_NONE;
' y, |- f: Y/ O1 Q4 T- F( A+ Z6 M
return HAL_ERROR;1 K7 K" w% k- r/ z
}1 U# |& s3 U* G: {" i3 `
* H. e( d9 ?& w4 g6 w8 ^
/* 使能传输中断 */8 j% B5 l; O$ [* l1 p8 G# J
__HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND));
! g V1 I+ ^: Y
" E7 Q7 \+ l, y* m- m
6 J8 D1 K9 K+ w: B1 ?+ o
return HAL_OK;$ ?3 d, _. _& d& [, K+ V
}
5 Z$ E1 h# N: E
else
# x5 s% C5 M ~7 Q6 i- s% {( j
{$ C2 b7 [# H Z/ A& ^ L
return HAL_BUSY;
9 H& L+ {/ k8 V
}$ E0 }0 C( r2 A/ E: e7 u% z: Y
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**# `2 I7 N9 O# |( d. a7 J
* @brief Reads block(s) from a specified address in an SD card, in DMA mode.+ e) x6 f& p2 e- V6 b6 T8 d
* @param pData: Pointer to the buffer that will contain the data to transmit
3 B5 a: ^6 P5 s9 A+ r8 L
* @param ReadAddr: Address from where data is to be read6 c% c1 C6 I- d
* @param NumOfBlocks: Number of SD blocks to read
* e4 y% {8 O- K2 V
* @retval SD status
* ?9 K% d# Z% Q3 g1 W' h m6 A- Z
*/% L J4 ~' c& H
uint8_t BSP_SD_ReadBlocks_DMA(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks)+ |+ N9 s t: H d# k: |
{
4 P/ J+ w w* c. K8 c% q
9 v/ ^$ G# n" M$ Q) R1 K0 B& ?- t$ @' O
if( HAL_SD_ReadBlocks_DMA(&uSdHandle, (uint8_t *)pData, ReadAddr, NumOfBlocks) == HAL_OK)3 c a9 H9 R2 f
{
: L4 r- I9 `* P! \5 u
return MSD_OK;! A+ X' H. G' X/ }2 C
}
+ ]. ~& l8 o8 a; b" G4 {
else
7 T8 N7 h9 E3 I Q# f
{+ {* c2 ]3 U6 S& G- p
return MSD_ERROR;
6 ?& Y/ V, d* S4 _
}
5 Z! ?( Z1 F% ]2 m8 w& r
}

复制代码

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)
# ~7 o5 q2 A5 x! ?
{
6 d z6 \8 N0 i( B: P; ?) U1 u
SDMMC_DataInitTypeDef config;6 F% D8 u1 l, d- v( ~+ ]
uint32_t errorstate;
2 E* y' o9 W: c8 P, m$ n8 A8 {
uint32_t add = BlockAdd;. _7 I/ U* S& e5 T8 m4 Q% o. g( A1 i
$ v) t& {% u) M! k% K# J, Y3 X+ C
if(NULL == pData)! w3 L' T1 ^' g" [7 j- b, K
{" M4 A* @7 W0 B. w
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;' q/ Q1 J2 G7 [3 u- }1 C
return HAL_ERROR;
1 P+ q) s) d- ^3 q, Z3 ]
}
! |! r- K0 i% {( g
8 y; v4 @7 Q# |$ N# ~. h
if(hsd->State == HAL_SD_STATE_READY)' M. @) n& S8 C; h; V
{
9 ^9 T% J T" {% z# p6 c, w
hsd->ErrorCode = HAL_SD_ERROR_NONE;
2 i( L: w3 p# r# { S, z- A
( ~ j- H# l; _. p6 p7 l
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))/ u8 j) j' Y% N; x0 W
{. p+ n# D$ d }* W% N
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
' B/ {" f: A4 m( \0 I) V1 ^% n0 e
return HAL_ERROR;0 L' U" _2 h: @+ ]7 I2 b
}( }" E' V+ g y' w1 q1 b- W
9 n3 h: Y3 z9 K1 }
hsd->State = HAL_SD_STATE_BUSY;% s) R8 c5 h& [5 |
9 }2 b S8 g6 V# ?$ B: r
/* 初始化数据控制寄存器 */
: y' ?5 q$ J D8 ?: k3 j9 H9 S" y. e
hsd->Instance->DCTRL = 0U;3 {* ]9 l$ T1 [. G5 \
1 Q; P: Q# K) U
hsd->pTxBuffPtr = pData;
0 I+ d* ^9 J8 J. E" h9 [7 A( I5 B
hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;8 |2 ?( m4 r: G9 S" \/ ]; a0 Z c
) ^7 ]7 t. o9 b, s
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)7 e$ \9 i; \/ L
{
5 M1 n5 e& X9 I+ C8 s. Y5 J( s1 |
add *= 512U;7 N- n C4 @( x# |1 c
}1 i u* n1 O* G: h: ^* H
- R% u8 i9 R, i. v7 h7 y: G6 g
/* 配置SD DPSM (Data Path State Machine) */
5 Q7 S- l" [3 V& R4 I
config.DataTimeOut = SDMMC_DATATIMEOUT;
3 s* T" e# p1 H6 L% Z
config.DataLength = BLOCKSIZE * NumberOfBlocks;# Y- r" X( o; i* Q* x8 S: B$ h
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
& G; [6 X* n: u& d3 d3 _% d. P9 m {
config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
! Q+ M7 O0 s# }% d- \ j$ l
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
( k1 E: d4 j4 r* T" p1 X( f9 l: T
config.DPSM = SDMMC_DPSM_DISABLE;
6 f; ?" O2 ?2 j9 ~3 T) y, E
(void)SDMMC_ConfigData(hsd->Instance, &config);! \2 X6 M! P- _, E
$ i' a* J" _ f+ B. f: ^
( _0 ?( N w4 ~
__SDMMC_CMDTRANS_ENABLE( hsd->Instance);0 m# X# v5 y9 f9 Q8 d$ d' {2 v
2 q# z/ N" c0 U) Y+ k6 r3 j
hsd->Instance->IDMABASE0 = (uint32_t) pData ;
1 ?5 N$ d( {2 z/ z( t
hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF;
5 g) r6 ?- m& @4 H( u& {
4 y# Y9 @0 W- N- W
/* 查询模式写块 */
' L3 |3 A# d( ?
if(NumberOfBlocks > 1U) H# @% ?* o; Q9 y: q! |( ?
{
' X% g2 _, Z! O
hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
" C. N! X z0 j4 u
7 h; X- Z) s5 j) o' c* O
/* 多块写命令 */
' o% F0 z' B, g! ~- ~1 N \- s
errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add); t$ U0 N y3 o5 V
}! U% v% ~ z/ o
else
1 O7 ^3 _6 r. b8 _- E
{
, y- ^) P- s, I* v
hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_DMA);
' i X0 N2 k' L2 ~! Y5 R
4 y' E9 \& B5 v2 u
/* 单块写命令 */
4 |; @! C* k- u' S! g
errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
* _" S+ w3 j/ y3 S% E) q
}
$ C: X3 _- a" _. d2 j
if(errorstate != HAL_SD_ERROR_NONE)
2 R$ K2 h# n9 d7 {+ U7 V
{
D: I% I$ u; _# p% A0 j
/* 清除静态标志 *// @$ V9 F: ?5 k, j
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);0 }1 Y! m) {; E( g) R6 a
hsd->ErrorCode |= errorstate;
7 \. e v7 t5 Z% D" ~7 b
hsd->State = HAL_SD_STATE_READY;
7 D* H. J5 O# _# m
hsd->Context = SD_CONTEXT_NONE;' B, t/ h% x' i) }% U6 Z: F7 w
return HAL_ERROR;
1 k( G" ~& N/ r4 M
}, r" m7 C- H! A6 f j
* t( X" C: B- E* }
/* 使能传输中断 Enable */# h4 O6 D+ F8 W
__HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND));0 \ F! U0 B; v
* a' j- n* \" `! @2 Q
return HAL_OK;
( K- V0 U, A: p( b# d" n
}8 s* @( P. r. n, j0 O; U
else& o f* }; {- |0 [. D
{
6 m! c% f' O& x) g4 K. W
return HAL_BUSY;
% Q) S7 o) m6 Y( ^9 l" d4 _0 @3 R6 K
}
% G/ r+ ~8 X: h
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**
3 \/ |$ H; Q9 u$ r0 e3 ^
* @brief Writes block(s) to a specified address in an SD card, in DMA mode.& B, L! ?! t0 n+ D7 _5 F5 l' K
* @param pData: Pointer to the buffer that will contain the data to transmit
1 q+ y1 s, l6 M
* @param WriteAddr: Address from where data is to be written
' Q6 H' Y3 j3 L" L5 W
* @param NumOfBlocks: Number of SD blocks to write9 l! g( @! `1 C2 E5 {( k. U5 ^2 l3 {) o
* @retval SD status
. I* Q! M/ x+ Y' m+ q3 }3 y
*/
: q; @, A( W! W# e
uint8_t BSP_SD_WriteBlocks_DMA(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks)
P0 T8 T3 ?6 y* C% |
{
4 E, V% U6 M+ |, ]1 z/ [
% ]* h6 s* W+ y. W
if( HAL_SD_WriteBlocks_DMA(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks) == HAL_OK)
6 g7 j8 @# \$ u# H& Y# M/ O% X
{
# d. D! b7 |# L& R- [
return MSD_OK;
0 _+ W; t8 x# y4 e9 ^) d
}& O a& p, v& N4 c2 H
else& n! v# b( O' L; I# x, S
{# a4 P9 S+ }, K
return MSD_ERROR;7 c( R7 T0 p( [- k0 i H/ x3 G6 X
}
( X \& B( c: `7 k9 Y& [' C
}

复制代码

87.4.7 函数HAL_SD_Erase
函数原型：

HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd)2 C% U6 A: L& ]6 f- t+ t1 ^: _# r
{/ H0 j( p/ ~2 X7 M+ B
uint32_t errorstate;
& n& g1 K4 \+ r. v' Y7 t
uint32_t start_add = BlockStartAdd;
h' I, `' C" f3 b% r
uint32_t end_add = BlockEndAdd;
6 ~$ Q# |. e; Y; i
0 {0 E) Z: O) d, C# h$ e
if(hsd->State == HAL_SD_STATE_READY)
" I! e+ Z$ l. d! |& g. _
{* U |/ u7 g6 C6 K" ?
hsd->ErrorCode = HAL_SD_ERROR_NONE;; F9 Z' |3 r2 s& Y3 J/ d
2 q! F2 C u5 Y' W4 I! c( d
if(end_add < start_add)
8 Z7 I$ D2 B$ T$ ?8 S& o6 X
{/ X7 h3 z. [* `/ B
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;5 F& w# {7 R' }5 ^, T* F' _# Y+ ?1 K
return HAL_ERROR;
E8 J, W* e, L( |) t9 m# q/ @& ^
}
& u0 n! Q& \& Y& g- M
1 T3 K3 m) Q A- |4 m
if(end_add > (hsd->SdCard.LogBlockNbr))
- V2 r8 W! L/ X( ?, n
{# Q% r6 Z& Q4 f9 m9 t2 I
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;, q5 ?: y3 _1 S9 e
return HAL_ERROR;
/ E3 }( Q) s# a4 H' C; r
}9 `3 x( u6 j; E; A2 z6 v8 Z
. i1 V" o8 p T8 Q
hsd->State = HAL_SD_STATE_BUSY;- a3 z& r0 {) v, l S. r! u8 l5 N, O
1 W. q" b- g s0 x" T
/* 检测是否支持擦除命令 */
, Y8 v7 u3 B4 @& `- a# {1 c( }2 F
if(((hsd->SdCard.Class) & SDMMC_CCCC_ERASE) == 0U)
* F' Z. b7 p* h K, Y; g; D
{
1 ~9 i) ?1 e' Y! k4 z) \1 M% G& f8 d
/* 清除所有静态标志 *// i5 Q# Q8 C+ T: T0 n/ b5 V8 @
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
% _) Y3 s4 H2 s# C6 ]
hsd->ErrorCode |= HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;
0 @5 |, ]' L* U8 m
hsd->State = HAL_SD_STATE_READY;
3 g! @8 M m& G
return HAL_ERROR;6 M9 j- j( Q* E4 }- _
}' H) F% g& H# o8 z1 [( X" d
! K- b2 U4 A; {
if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)4 n0 ^1 F" T7 d/ M* f/ \
{
9 O# `. X1 v7 U) ]
/* 清除所有静态标志 */
) D7 X N3 ?! h% ^
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
) u9 w/ r0 h5 ~0 j. `4 a
hsd->ErrorCode |= HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
9 l6 d3 K P5 n% Q9 x4 z5 B3 O1 I
hsd->State = HAL_SD_STATE_READY;
y& V2 F9 Q3 l$ {: R- t @4 h0 V
return HAL_ERROR;
]) H$ b; }$ _3 w- X
}' \5 D$ v1 T3 s4 g' u
% j9 J4 d9 \0 W( h8 y, e
/* 对于高容量卡，获取起始块和结束块 */* U5 L/ k4 R8 k8 [* S
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)! o& T6 S. d& i, j) y
{- M. Q; K6 o# M6 b5 v
start_add *= 512U;
* Z$ u" s" f5 M# _! x- `6 `, R: _' r# y
end_add *= 512U;
/ J9 C2 q. c$ C; o9 \/ ]% A8 E% W3 Q9 K
}
7 U7 f: S! d; L5 W# K
' R! C l4 @0 ~" @1 Q9 L+ M8 X- `
/* 根据sd-card spec 1.0 ERASE_GROUP_START (CMD32) 和 erase_group_end(CMD33) */% @( G p0 i% y9 J# z3 O) v
if(hsd->SdCard.CardType != CARD_SECURED)
, G1 _1 i/ F7 k
{
+ [7 H6 }8 s. @7 q# R8 K
/* 发送CMD32 SD_ERASE_GRP_START命令带地址参数 *// @0 u2 R, a7 @% [ z* ?5 n
errorstate = SDMMC_CmdSDEraseStartAdd(hsd->Instance, start_add);/ ?/ @! R- C8 F' i$ k
if(errorstate != HAL_SD_ERROR_NONE)
' Z2 E- r6 [/ J- l+ s& b1 j$ l
{
# Y1 G8 r% v% j3 @. I
/* 清除所有静态标志 */
4 q; O A4 i7 u5 [+ X
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);1 M' X5 S8 T) h
hsd->ErrorCode |= errorstate;
) ]6 R3 _1 T4 ]2 G! F% }
hsd->State = HAL_SD_STATE_READY;. B. Z4 l* {! C- p* t
return HAL_ERROR;
- s8 E$ a2 W3 l& E2 K- p4 f+ M
}: A$ e- g& v, W! h! T5 T$ T
; k. W$ g: [6 a
/* 发送CMD33 SD_ERASE_GRP_END命令，带地址参数 */
, h! ~. n! Z3 ?8 T* Y) P
errorstate = SDMMC_CmdSDEraseEndAdd(hsd->Instance, end_add);
6 h" H- u1 Q* |' c' a. o+ d
if(errorstate != HAL_SD_ERROR_NONE)
1 Y8 e' I! Y6 U" X( A2 r
{: g2 U* `6 k- \
/* 清除所有静态标志 */
, U) n- \' G+ l8 e* Z
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);4 y4 s8 b7 B i
hsd->ErrorCode |= errorstate;
. n- U( t3 o' s* o# I1 @
hsd->State = HAL_SD_STATE_READY;
- n+ B4 O m( U$ r( |+ N# A
return HAL_ERROR;
, o) s9 q/ o; Z) A
}
4 o# q5 A1 O: s% I1 I' y: [+ B
}# Q4 r1 W: r, P& Y+ P
# ?8 L% S7 R3 d6 ]& F1 u
/* 发送CMD38 ERASE命令 */
* |* L4 r& ~0 f5 q9 H- L% A
errorstate = SDMMC_CmdErase(hsd->Instance, 0UL);
4 O' E# o4 V% N! G+ k D
if(errorstate != HAL_SD_ERROR_NONE)
! |) m4 b0 C" }' ?* K; z2 k' y
{, `) o1 c* q$ n1 S/ w
/* 清除所有静态标志 */
( \! h1 r5 n7 h- e
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
J' q! T3 I' K5 t$ }: h
hsd->ErrorCode |= errorstate;+ Z6 s; v" K: f2 r- X: |0 ]
hsd->State = HAL_SD_STATE_READY;
4 v" W" C& @0 ~. Z/ Y3 Q+ Q. t
return HAL_ERROR;
* U, G; M0 q/ E
}
/ n4 l+ ^, E2 v0 V( ?
# ]# q6 C3 O( Q# z- S
hsd->State = HAL_SD_STATE_READY;1 U8 u( Z$ {% I% |
" w/ Y4 k9 [) Y0 N3 D( G$ ~- z
return HAL_OK;
0 e1 A% Y+ i3 U' t( \) r
}8 x: R/ O# \8 x+ U, g, p
else
* j. |3 O. L9 J; r: j% }0 J
{& H2 W$ N; d1 u, g- L
return HAL_BUSY;
9 Z. l$ F/ g5 t r, U j
}4 v+ n; I: ?& X' k2 _, R
}

复制代码

函数描述：

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

函数参数：

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

/**
) X/ ]$ z3 Z4 [) Z- p- v
* @brief Erases the specified memory area of the given SD card.4 }6 O% e, s3 y* \) ~) L
* @param StartAddr: Start byte address4 P% b# l+ w$ A
* @param EndAddr: End byte address
/ ?9 Q6 L% c7 b" r2 c+ b
* @retval SD status
3 \4 `! {2 {" r( y
*/
) t9 r7 X U5 \: \9 V
uint8_t BSP_SD_Erase(uint32_t StartAddr, uint32_t EndAddr)+ H7 V7 M1 Z- D ?- k$ T
{- r0 e2 s+ A0 G) {/ k3 i
" R7 x+ k* b# _% q6 B G
if( HAL_SD_Erase(&uSdHandle, StartAddr, EndAddr) == HAL_OK)2 I$ a6 O' d9 d8 q
{: k- L ]8 s0 O, h# ]3 O4 G% q* l. J7 d6 m
return MSD_OK;) ~3 P, h) y; v* Y& W
}) }$ O- G) B) l* h+ `* T
else
) C, c# I$ v0 `/ U, B# O
{
* [% M; d% z; Q; `5 b! }! |
return MSD_ERROR;
1 c0 B: {3 q9 T7 ^9 e6 a
}+ P& `+ I( p9 i8 L |; W( x
}