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

: j% V2 _; I7 c3 }% j/ b4 x$ E$ \87.2.4 SDMMC支持的速度
驱动SD卡支持的最大总线速度：

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

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

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

) n5 d! X2 N! |- p0 S, e( Y87.2.5 SDMMC支持UHS-I模式
STM32H7的SDIO外接支持UHS-I 模式 (SDR12, SDR25, SDR50, SDR104和DDR50)需要1.8的电平转换器。STM32H7参考手册给了一个型号ST6G3244ME：

- M% z) @) ]% e% N v87.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_TypeDef0 E: Z. p$ O2 }! S4 t B
typedef struct6 {' L# t+ z9 e/ j. J: w
{
+ u7 C) _! ~* G d7 Z
__IO uint32_t POWER; /*!< SDMMC power control register, Address offset: 0x00 */% g) N6 Q8 J3 r$ W2 w
__IO uint32_t CLKCR; /*!< SDMMC clock control register, Address offset: 0x04 */* v2 l m( z5 x, ?$ [ x
__IO uint32_t ARG; /*!< SDMMC argument register, Address offset: 0x08 */4 Q" Z& u9 q/ f; T5 B; a# }
__IO uint32_t CMD; /*!< SDMMC command register, Address offset: 0x0C */! B& N" J* l' t5 L% ? H; g+ b( f
__I uint32_t RESPCMD; /*!< SDMMC command response register, Address offset: 0x10 */
9 i) n4 T" |% @) L6 h( h! t7 E
__I uint32_t RESP1; /*!< SDMMC response 1 register, Address offset: 0x14 */
7 e* |: }. S- Z; X" b
__I uint32_t RESP2; /*!< SDMMC response 2 register, Address offset: 0x18 */
3 x* M: X& w2 m$ z+ o
__I uint32_t RESP3; /*!< SDMMC response 3 register, Address offset: 0x1C */ ^' [% \% S6 _* V) r' J" U, q* \
__I uint32_t RESP4; /*!< SDMMC response 4 register, Address offset: 0x20 */
3 g3 e9 m2 G% K8 P+ Y9 L3 ]
__IO uint32_t DTIMER; /*!< SDMMC data timer register, Address offset: 0x24 */
4 _1 n. Y3 F' A* ^& a X% f& M/ V
__IO uint32_t DLEN; /*!< SDMMC data length register, Address offset: 0x28 */8 K O! L: p/ t' s- [, \( j% I
__IO uint32_t DCTRL; /*!< SDMMC data control register, Address offset: 0x2C */ y4 S! H7 H. P/ f2 @ b7 ~7 w8 Y! e
__I uint32_t DCOUNT; /*!< SDMMC data counter register, Address offset: 0x30 */. A2 W4 G9 w' y5 I l* O' X
__I uint32_t STA; /*!< SDMMC status register, Address offset: 0x34 */
8 g# `0 {' `# z
__IO uint32_t ICR; /*!< SDMMC interrupt clear register, Address offset: 0x38 */
5 [3 ^+ V. l$ p [% E- x/ ~
__IO uint32_t MASK; /*!< SDMMC mask register, Address offset: 0x3C */
6 o( c* l9 ^- I$ R5 v0 Y& t8 L m
__IO uint32_t ACKTIME; /*!< SDMMC Acknowledgement timer register, Address offset: 0x40 */4 ^+ M. r7 s- P$ \& X* f
uint32_t RESERVED0[3]; /*!< Reserved, 0x44 - 0x4C - 0x4C */
: q) ^( U" R' O" S( b: \
__IO uint32_t IDMACTRL; /*!< SDMMC DMA control register, Address offset: 0x50 */* \ {! E6 C+ W5 I, ^
__IO uint32_t IDMABSIZE; /*!< SDMMC DMA buffer size register, Address offset: 0x54 */
% ?& W* t8 ~/ t& X) C# _( k0 @
__IO uint32_t IDMABASE0; /*!< SDMMC DMA buffer 0 base address register, Address offset: 0x58 */% m; ~1 x( } I1 v2 @
__IO uint32_t IDMABASE1; /*!< SDMMC DMA buffer 1 base address register, Address offset: 0x5C */% U+ b- D! ^8 o0 } Y* I& `6 E
uint32_t RESERVED1[8]; /*!< Reserved, 0x60-0x7C */
+ E& [, N, _9 k# p2 M" u( g
__IO uint32_t FIFO; /*!< SDMMC data FIFO register, Address offset: 0x80 */
% x8 J ?3 G2 X9 }
uint32_t RESERVED2[222]; /*!< Reserved, 0x84-0x3F8 */
' ?& q1 a' y6 t( K# H/ K
__IO uint32_t IPVR; /*!< SDMMC data FIFO register, Address offset: 0x3FC */
/ N' c, T+ T u: n' K3 r: T7 j( Q
} SDMMC_TypeDef;

复制代码

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

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

#define __O volatile /*!< Defines 'write only' permissions */" {5 u3 u" ?, r5 a. |5 b; a, X
#define __IO volatile /*!< Defines 'read / write' permissions */

复制代码

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

#define PERIPH_BASE (0x40000000UL)
# X) w+ G, w, H, d
#define D1_AHB1PERIPH_BASE (PERIPH_BASE + 0x12000000UL)
( g7 }0 M& f2 P7 M$ w$ S* N' e5 _
#define D2_AHB2PERIPH_BASE (PERIPH_BASE + 0x08020000UL)
4 M% y9 z& I8 E7 d+ P5 I
# e) e d* f, J0 ~7 W/ }2 R8 L
#define SDMMC1_BASE (D1_AHB1PERIPH_BASE + 0x7000UL)
) ` q8 W Z/ B3 ^7 o4 a6 y8 _
#define SDMMC2_BASE (D2_AHB2PERIPH_BASE + 0x2400UL)3 P" p0 v' S) f U- ~$ c/ F
#define SDMMC1 ((SDMMC_TypeDef *) SDMMC1_BASE)! M4 C+ Q2 i, |. _" g0 I$ T& 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* Y# X+ }! q G4 x) ?' H
typedef struct+ L/ v; A7 {# ?9 f) n
{
2 d, n0 ?4 t7 T$ q) Y- P
uint32_t ClockEdge;
3 a6 X" a5 T6 v! e5 p' g
uint32_t ClockPowerSave; 9 i! `, u- \- J8 \% N6 P
uint32_t BusWide;
8 H- C" D7 Y! L9 U
uint32_t HardwareFlowControl; 5 E% J" {. g! {) R1 C
uint32_t ClockDiv;
+ V) y+ C k( l2 F. W
#if (USE_SD_TRANSCEIVER != 0U)
- v. D; k" ~1 |+ ?
uint32_t TranceiverPresent; / g( [, {8 ^4 z* G1 H9 J
#endif % M& g0 H& h* a+ ?- Y
}SDMMC_InitTypeDef;

复制代码

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

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

#define SDMMC_CLOCK_EDGE_RISING ((uint32_t)0x00000000U)1 Q" Z/ B& H: A) F; E
#define SDMMC_CLOCK_EDGE_FALLING SDMMC_CLKCR_NEGEDGE

复制代码

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

#define SDMMC_CLOCK_POWER_SAVE_DISABLE ((uint32_t)0x00000000U)( U. t ^9 F2 l, R) O
#define SDMMC_CLOCK_POWER_SAVE_ENABLE SDMMC_CLKCR_PWRSAV

复制代码

BusWide
用于设置SDMMC总线位宽。

#define SDMMC_BUS_WIDE_1B ((uint32_t)0x00000000U)4 H3 T9 v e# f7 O2 J
#define SDMMC_BUS_WIDE_4B SDMMC_CLKCR_WIDBUS_0
+ X) g* o: _: w# A
#define SDMMC_BUS_WIDE_8B SDMMC_CLKCR_WIDBUS_1

复制代码

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

#define SDMMC_HARDWARE_FLOW_CONTROL_DISABLE ((uint32_t)0x00000000U)- z0 M" P6 r& O- `* _9 w% B
#define SDMMC_HARDWARE_FLOW_CONTROL_ENABLE SDMMC_CLKCR_HWFC_EN

复制代码

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

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

#define SDMMC_TRANSCEIVER_UNKNOWN ((uint32_t)0x00000000U)
/ M2 i, O" V7 H* r% I9 \! }+ v. n
#define SDMMC_TRANSCEIVER_NOT_PRESENT ((uint32_t)0x00000001U)
- [; s: G7 X8 F" n+ z+ h
#define SDMMC_TRANSCEIVER_PRESENT ((uint32_t)0x00000002U)

复制代码

% c9 \# a8 E- g3 P' j87.3.3 SDMMC接SD卡信息结构体HAL_SD_CardInfoTypeDef
下面是SDMMC总线的卡信息结构体：

typedef struct
+ ^! }, C( f# t8 H
{4 w- ~. x3 R7 K3 ~ \, v
uint32_t CardType; /*!< Specifies the card Type */
1 F6 ~3 M) O$ H+ h8 S
uint32_t CardVersion; /*!< Specifies the card version */0 A- p. D! {( R% X. j7 Z% E
uint32_t Class; /*!< Specifies the class of the card class */
" P# u4 |. j+ M* n
uint32_t RelCardAdd; /*!< Specifies the Relative Card Address */1 D6 z% E1 N6 R4 L2 ?
uint32_t BlockNbr; /*!< Specifies the Card Capacity in blocks */( l2 p+ V7 T) d4 \, c! U. N
uint32_t BlockSize; /*!< Specifies one block size in bytes */- R- T. H* @ H+ [; C# F
uint32_t LogBlockNbr; /*!< Specifies the Card logical Capacity in blocks */! R1 k: w* a) ]' d5 M* |
uint32_t LogBlockSize; /*!< Specifies logical block size in bytes */
8 a* K9 J8 n+ H, Y4 k. l, a
uint32_t CardSpeed; /*!< Specifies the card Speed */
\2 R# l9 |& h6 l1 b
}HAL_SD_CardInfoTypeDef;

复制代码

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

CardType
卡类型。

/*!< SD Standard Capacity <2Go */2 K4 t; ?% g* o
#define CARD_SDSC ((uint32_t)0x00000000U)
( S% A" R$ w- R. W
/*!< SD High Capacity <32Go, SD Extended Capacity <2To */
$ B4 J- D) u4 Q( @% Y, i: V. r
#define CARD_SDHC_SDXC ((uint32_t)0x00000001U)
i* l4 E. A. A c
#define CARD_SECURED ((uint32_t)0x00000003U)

复制代码

CardVersion

卡版本。

#define CARD_V1_X ((uint32_t)0x00000000U)
- e" W6 ?0 x4 S* f! @7 T! `+ ~
#define CARD_V2_X ((uint32_t)0x00000001U)

复制代码

  Class

卡类型。

  RelCardAdd

卡相对地址。

  BlockNbr
整个卡的块数。

  BlockSize

每个块的字节数。

  LogBlockNbr

整个卡的逻辑块数。

  LogBlockSize

逻辑块大小

#define SPI_FIRSTBIT_MSB (0x00000000UL)
0 S G) v" J4 j( \8 b" I: Q9 M! i
#define SPI_FIRSTBIT_LSB SPI_CFG2_LSBFRST

复制代码

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

/*!< Normal Speed Card <12.5Mo/s , Spec Version 1.01 */- x* O. D& C! ^! x" _7 \1 l! B# h
#define CARD_NORMAL_SPEED ((uint32_t)0x00000000U) 8 X6 C d1 i! J0 H1 e3 l
* ]( D" n( b, J G0 s) |9 \ c1 u
/*!< High Speed Card <25Mo/s , Spec version 2.00 */ ! Y/ ^1 c, s, O" U' @
#define CARD_HIGH_SPEED ((uint32_t)0x00000100U) 4 k7 W% [3 C. x7 P$ V; y
5 w1 Q! d6 d/ O
/*!< UHS-I SD Card <50Mo/s for SDR50, DDR5 Cards
+ B* Y9 X5 t5 M9 }2 Z
and <104Mo/s for SDR104, Spec version 3.01 */! e7 s1 @, b# Y
#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)* l, a0 a2 |" T) _1 }9 @% [
typedef struct __SD_HandleTypeDef
. a9 z; q; B% H2 m; L* s
#else2 Y B; H6 [* ^) Y: \% u4 P) a
typedef struct
% Y: ?+ ^! h# K" ]0 l" W3 |- J$ h
#endif /* USE_HAL_SD_REGISTER_CALLBACKS */' ~( ?2 ^! P- Q2 q- U
{2 P% {9 I" ]8 h4 x6 B
SD_TypeDef *Instance; /*!< SD registers base address */7 Y; Z F+ Z/ [$ v) s$ _
SD_InitTypeDef Init; /*!< SD required parameters */
! w d6 |9 o3 ]
HAL_LockTypeDef Lock; /*!< SD locking object */' y- q/ s5 ~0 c+ p
uint8_t *pTxBuffPtr; /*!< Pointer to SD Tx transfer Buffer */6 ~/ ?- ?) j8 k) e! ~
uint32_t TxXferSize; /*!< SD Tx Transfer size */. y" ^7 c6 d/ K- A4 @2 C5 X7 o
uint8_t *pRxBuffPtr; /*!< Pointer to SD Rx transfer Buffer */
7 I F: R: t& S# ^. r( z8 ?. ?0 t
uint32_t RxXferSize; /*!< SD Rx Transfer size */
; }/ H8 W- M8 o$ T- N/ l1 t
__IO uint32_t Context; /*!< SD transfer context */3 m7 N4 B/ q7 W/ N
__IO HAL_SD_StateTypeDef State; /*!< SD card State */
4 q2 ~ M( q2 @) k* C9 X4 s
__IO uint32_t ErrorCode; /*!< SD Card Error codes */
* C( C5 P- a( c. O
HAL_SD_CardInfoTypeDef SdCard; /*!< SD Card information */
! Z$ l% }+ B4 {# P0 f6 i
uint32_t CSD[4]; /*!< SD card specific data table */; }0 T" {9 j% V9 Y* c5 O
uint32_t CID[4]; /*!< SD card identification number table */$ F7 T* T2 U: x5 p) D l9 W
$ ]8 A3 a* ~/ B0 a
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)3 b3 Z3 e+ R5 [# b- q& W
void (* TxCpltCallback) (struct __SD_HandleTypeDef *hsd);) I' H1 R2 c1 E2 p( ]% l( v" P
void (* RxCpltCallback) (struct __SD_HandleTypeDef *hsd);" ~9 i" {0 l2 J: s! k
void (* ErrorCallback) (struct __SD_HandleTypeDef *hsd);
, ^, c! x( i1 Q% r4 Y
void (* AbortCpltCallback) (struct __SD_HandleTypeDef *hsd);% E& g2 b. |! U( ]- k: N
void (* Read_DMADblBuf0CpltCallback) (struct __SD_HandleTypeDef *hsd);0 F' B6 y' U! G2 R
void (* Read_DMADblBuf1CpltCallback) (struct __SD_HandleTypeDef *hsd);, l; ]$ P! H: E
void (* Write_DMADblBuf0CpltCallback) (struct __SD_HandleTypeDef *hsd);+ `1 ?8 ?3 b+ f
void (* Write_DMADblBuf1CpltCallback) (struct __SD_HandleTypeDef *hsd);
. a# U! v# f6 b3 T
#if (USE_SD_TRANSCEIVER != 0U)
% Y( k. V u; C
void (* DriveTransceiver_1_8V_Callback) (FlagStatus status);3 U/ W. [3 s; H8 J. \& `6 E
#endif /* USE_SD_TRANSCEIVER */
6 I y) l+ t2 ?+ [
$ N2 ?6 E' ]# o# I s; i8 X
void (* MspInitCallback) (struct __SD_HandleTypeDef *hsd);
& i, ~1 L) ]6 N0 v- h( V# h; Y
void (* MspDeInitCallback) (struct __SD_HandleTypeDef *hsd);
" X1 \2 q7 |8 K/ j4 I8 u
#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
. o: C/ u. A9 n7 A6 I
}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)
. Y0 `, |* E0 K9 A
{/ H/ e$ A7 E1 \7 A
HAL_SD_CardStatusTypeDef CardStatus;
+ t7 l4 [- ~ ~; ^$ n
uint32_t speedgrade, unitsize;* a) v" F* R: k5 a* h5 c) K. G
uint32_t tickstart;
1 o% n! W# X. Q3 N4 ?4 c
& Q7 f# ]/ j0 N1 C
/* 检查句柄是否有效 */
8 S% i: Z7 A# F8 n |
if(hsd == NULL)$ |4 ^. |5 N& [# I( S A
{3 @4 x* t# z( Y3 \6 ?' o
return HAL_ERROR;
& ^6 f2 g. m9 y8 O. K
}
! ?4 R# I2 ?4 j: Z
: e' z" }0 Y& y. G0 R2 C0 l" x
/* 检查参数 */
( C2 P9 q! g! G6 C
assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));% |3 Z& k( }0 t4 q
assert_param(IS_SDMMC_CLOCK_EDGE(hsd->Init.ClockEdge));$ d: J/ I% |2 B4 b! [% T: ~% a
assert_param(IS_SDMMC_CLOCK_POWER_SAVE(hsd->Init.ClockPowerSave));7 \* a1 c+ Q# o% ~ H6 Q; W/ u
assert_param(IS_SDMMC_BUS_WIDE(hsd->Init.BusWide));) _ l1 A0 d, {: o6 P/ B$ i% v
assert_param(IS_SDMMC_HARDWARE_FLOW_CONTROL(hsd->Init.HardwareFlowControl));
7 o I: l: [0 i( E4 K
assert_param(IS_SDMMC_CLKDIV(hsd->Init.ClockDiv));+ |& o0 u! q/ r0 S6 [! ?
8 h4 ^3 U7 F r `
if(hsd->State == HAL_SD_STATE_RESET)! R& T& `/ Z- _9 L
{9 Y- e h9 b! I7 s" H* S$ Y* `7 B
/* 开锁 */
, z9 a6 I* H8 J
hsd->Lock = HAL_UNLOCKED;1 \1 `. W% I; d1 K0 k9 I0 ]
: V) R1 m8 }' i3 s+ {
#if (USE_SD_TRANSCEIVER != 0U)# {) b$ _# a1 u3 d& D
/* 兼容 */$ X* d* B( V8 N
if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_UNKNOWN)" W* m, X- D/ s' R/ B1 U
{
* }# q, O% ?0 @) N! M( _
hsd->Init.TranceiverPresent = SDMMC_TRANSCEIVER_PRESENT;2 V, {- @+ d2 s3 Y
}
1 b7 |0 m4 k6 Z. S
#endif
" k- t7 t L, |9 W
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)6 `3 l7 y O4 \( J8 `$ P
/* 复位回调 */% }" I; \ A, j) e. h, v
hsd->TxCpltCallback = HAL_SD_TxCpltCallback;
! g% \2 ~1 H+ o: l
hsd->RxCpltCallback = HAL_SD_RxCpltCallback;
3 @- R# _; b7 V2 ]
hsd->ErrorCallback = HAL_SD_ErrorCallback;1 J2 B8 U2 G E3 N5 L5 l+ ~, E
hsd->AbortCpltCallback = HAL_SD_AbortCallback;
6 }- U2 L* o, v( n1 A1 M" Q' H$ ?
hsd->Read_DMADblBuf0CpltCallback = HAL_SDEx_Read_DMADoubleBuf0CpltCallback;, h5 ]) A( p' t
hsd->Read_DMADblBuf1CpltCallback = HAL_SDEx_Read_DMADoubleBuf1CpltCallback;9 ^ {1 |7 N: L' ~/ _" i
hsd->Write_DMADblBuf0CpltCallback = HAL_SDEx_Write_DMADoubleBuf0CpltCallback;
4 M2 \2 A# I5 X8 b
hsd->Write_DMADblBuf1CpltCallback = HAL_SDEx_Write_DMADoubleBuf1CpltCallback;7 M( W: m3 c6 ]6 Z: R
#if (USE_SD_TRANSCEIVER != 0U)1 `3 c9 A" X0 M6 C1 S7 d
if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)
9 k! [" h& ^: Y* h9 y
{5 ]0 [5 h. H" D4 w4 ~
hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback;- Y/ B7 d. N; ^- K ]& ~
}& r' v5 x O8 J& h) O5 N. o
#endif ' G$ z n# q b2 `
, A- } m0 }4 Z* ] M8 X
if(hsd->MspInitCallback == NULL)
6 y0 x) V5 g8 v
{1 i. G9 x- P% F9 t& u
hsd->MspInitCallback = HAL_SD_MspInit;
. k5 J! B4 k* h+ N
}2 f/ g! ~' x8 ~
6 X0 S! W1 H! C* \7 W7 `
/* 初始化底层 */( ~/ b1 u# b f% ?
hsd->MspInitCallback(hsd);
, |# Y( M, A# H- A
#else0 R1 v( y, w8 G. M3 Q
/* 初始化底层硬件 GPIO, CLOCK, CORTEX...etc */
$ i" b5 l; `9 p, [/ u; i
HAL_SD_MspInit(hsd);$ O3 N( g& f3 m! G9 a) P
#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
0 L$ y* U# a: w
}
3 q7 p( u& k4 m# J7 M2 u8 X4 g
6 y( y. s% Y- e' I2 f$ O8 B6 L5 x
hsd->State = HAL_SD_STATE_BUSY;
/ E7 h6 F3 n1 z8 d
% W$ S0 z& D; r% B: |' G F
/* 初始化卡参数 */5 X+ k( c, B( u) s3 f+ m
if (HAL_SD_InitCard(hsd) != HAL_OK)
' |' D6 Y' K" `- Z9 M8 j
{
7 ~$ d! f3 h* q: F+ f
return HAL_ERROR;) u. a/ P6 l; @; W
}
& h" N: s- T# y4 B k
7 b% D# O \5 y$ p: e
if( HAL_SD_GetCardStatus(hsd, &CardStatus) != HAL_OK). G0 t; E) ^) l! {% w* n" z% G
{
8 {* i! g; U/ Z6 c
return HAL_ERROR;) b) M; q8 X( P6 {) a& @/ F
}. ]5 ^) K8 ~. t# ]
/* 获取卡速度等信息 */
9 k. s7 N9 w o! v9 K1 Q
speedgrade = CardStatus.UhsSpeedGrade;4 U) M/ `, H; I- [9 O7 c
unitsize = CardStatus.UhsAllocationUnitSize;
0 m' Z6 E4 l4 r/ g
if ((hsd->SdCard.CardType == CARD_SDHC_SDXC) && ((speedgrade != 0U) || (unitsize != 0U)))
5 l& R0 w5 Q: R0 v8 w0 ?( p. c/ ^
{0 T+ x E# _1 [7 l5 w
hsd->SdCard.CardSpeed = CARD_ULTRA_HIGH_SPEED;
# t( F8 m/ j8 D
}
* x7 m4 R9 X1 d# u
else
! {; b' e, R5 z- n# v, A$ v; C6 @
{ L& f2 ?: g$ ?$ F$ m, A+ n' v5 a
if (hsd->SdCard.CardType == CARD_SDHC_SDXC)* w5 G/ L/ w, j) n
{% }+ A1 K! [$ w T3 v
hsd->SdCard.CardSpeed = CARD_HIGH_SPEED;3 J: D; M N `; K2 Z8 r( D
} K n* K& a; o* |+ }4 @
else! R( k& q9 S- w- p7 @
{
1 q) R6 j; h, |5 Y
hsd->SdCard.CardSpeed = CARD_NORMAL_SPEED;! m0 b! o! b) {2 _+ ?8 G. e
}9 y+ b: c6 u4 B- i- u9 b5 t
7 o( Q7 g- q; \: A9 d
}
+ ?( I# ?6 v a/ Q/ D+ e8 v0 o! X$ l
/* 配置总线位宽 */% O; \, A6 @. a7 T# U, e
if(HAL_SD_ConfigWideBusOperation(hsd, hsd->Init.BusWide) != HAL_OK)
3 Q6 d, P' [6 m; v
{& a4 F1 ~: g7 X
return HAL_ERROR;
9 _' d$ `1 x/ s- \/ O
}
3 q y' V5 M) J% A3 c/ \7 D/ q
% P) S, l' O# }" W( N, B6 S
/* 验证卡初始化后是否就绪 */
# v* z( M# L8 _" z% _
tickstart = HAL_GetTick();: ~. C. m2 J' M( Y# M9 H/ Q: O
while((HAL_SD_GetCardState(hsd) != HAL_SD_CARD_TRANSFER))
5 O7 A! s! m! L; }1 c4 W# ]$ F4 c
{
. P; I! Q' P- K
if((HAL_GetTick()-tickstart) >= SDMMC_DATATIMEOUT)
7 L: o5 C1 q* r& z! c( n
{
8 z! { M! r, s$ l2 |
hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;4 j5 D& M8 g% S/ Y |( o
hsd->State= HAL_SD_STATE_READY;
+ U" r, t& B: j* [9 ^" t3 A0 Y
return HAL_TIMEOUT;
( Y0 C% b1 ]( f/ K9 I
}
8 H+ M2 E$ f+ o' `" P/ n: ~2 a1 b
}' y- N5 u- i' F4 B
6 g$ D# D' {( s$ `2 H* e7 j2 b
hsd->ErrorCode = HAL_SD_ERROR_NONE;
& y% W: o0 Q4 V9 A, i1 H& r% k5 j
2 P# \" B8 |) _( ~) [3 \ B9 E7 I
hsd->Context = SD_CONTEXT_NONE;
3 A! R# |: f$ C
8 e. z3 w7 F+ `4 _; K" ]) r
hsd->State = HAL_SD_STATE_READY;+ G, [6 Q7 u" \
0 e1 U- v, z5 ]8 _" G( K A9 r
return HAL_OK;
' o) r6 `! H6 e. q: \4 a
}

复制代码

函数描述：

此函数用于初始化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)
6 h8 f- x# N# g/ u9 u/ o
{# Z f! i9 v4 d% C5 r7 ?
Error_Handler();
+ l2 V+ o6 n% G; D9 S- r& Q. G3 r
}
/ t" b, ~* ^/ h, s+ L- k
if(HAL_SD_Init(&SdHandle) != HAL_OK)1 [6 Q4 s5 Y0 b& }
{
, E% d8 R/ g1 p- X& }& J, N
Error_Handler();1 x9 G$ o, x% L( ?
}

复制代码

使用举例：

SD_HandleTypeDef uSdHandle;1 _8 Y& o6 [4 b8 Q. R
' r8 N& h2 Y4 J
uSdHandle.Instance = SDMMC1;% E" D& R- B. `$ r
/ h6 M5 |4 [) z0 P% p
/* if CLKDIV = 0 then SDMMC Clock frequency = SDMMC Kernel Clock) @2 E" I& s+ `: Z7 `
else SDMMC Clock frequency = SDMMC Kernel Clock / [2 * CLKDIV].& ~# a1 }& r5 l V! W3 `6 H6 q5 U
200MHz / (2*2) = 50MHz
3 P# _" [& S; w! g( ]( U) z
*/+ r1 C/ {2 G* e, q6 w5 x
uSdHandle.Init.ClockDiv = 2;
/ ?# Z0 p$ {3 n, H2 P4 H% J! q5 \
uSdHandle.Init.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE;
/ ]! M+ s/ L" G# \7 i' G" v5 s
uSdHandle.Init.ClockEdge = SDMMC_CLOCK_EDGE_RISING;
2 }* g5 }" |/ Z" I
uSdHandle.Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE;- k- A% D* |1 J; K0 T3 W) i
uSdHandle.Init.BusWide = SDMMC_BUS_WIDE_4B;( s* y) S3 T* O. H; q8 z
if(HAL_SD_Init(&uSdHandle) != HAL_OK)
5 p5 J) S& ]- z( C, Q
{) i! t b& Y6 H3 R& F
sd_state = MSD_ERROR;
. _0 V( y. G5 ^1 z: n7 }; K! U* Z" ~
}

复制代码

# q! i; C4 E2 a8 G
87.4.2 函数HAL_SD_DeInit
函数原型：

HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)
! ]+ y, z t9 t! n
{+ d+ D3 V; ^6 t
/* 检查SD卡句柄是否有效 */
8 h' y7 Q( @( m" m* k- U
if(hsd == NULL)
9 [8 M1 B4 b) q" x0 {( V( C- `) N
{) w1 Y! z" p4 U% g2 f4 p
return HAL_ERROR;7 i, F k6 d3 i5 @. W( D$ W% x& a
}2 n, T3 E2 `0 \4 T* Y
* y# z k7 D+ N2 \- B
/* 检查参数 */3 H( N3 R5 |. t! ~$ J
assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));6 b' H" S; A2 v6 @! O7 c
[( D% O9 N( m5 o
hsd->State = HAL_SD_STATE_BUSY;
! Y+ a8 E9 T! r/ S
. i% D6 {3 D8 c( E
#if (USE_SD_TRANSCEIVER != 0U)
6 S) z1 Y( M3 F; t/ y
/* 关闭1.8V模式 */2 j" L' l4 Z! T7 }, e1 h
if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)
3 c3 s6 z, d# f; o5 ]7 r
{
7 X. a- z. k) _' f+ \4 e
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
, {7 T1 x5 B5 E
if(hsd->DriveTransceiver_1_8V_Callback == NULL)
' u8 M: u6 ^! T0 ?4 P
{
# r8 B# t9 i X8 X- a7 ?4 V$ B `
hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback;' `) U+ k3 ~. s6 E, u
}
4 k/ I/ L" T: H$ P- p7 Y
hsd->DriveTransceiver_1_8V_Callback(RESET);4 N0 K- J8 X8 G! [& I9 T
#else
( q$ C5 V3 g% b2 x
HAL_SD_DriveTransceiver_1_8V_Callback(RESET);
# `7 m7 Z0 g8 `3 U
#endif 9 ^/ a: y$ U" F3 h& ~3 k$ m: ]
}
1 f! D' a, V. U& \; {# C2 e
#endif# L/ L; W. h9 B7 R3 [" ^/ o
" k; c/ j" ~( R5 Y$ z
/* 关闭SD卡电源 */
- n, [3 V! A; ^' D! H
SD_PowerOFF(hsd);
) P7 |" ^9 o" C7 e: B+ Y$ ]/ _* e. b
( F" d: m: }' {9 L: ]
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)0 m! r! Z7 y) z2 E: O
if(hsd->MspDeInitCallback == NULL)
+ ^, y; T! e( O9 M
{' c L7 ~% [3 i3 c4 n P
hsd->MspDeInitCallback = HAL_SD_MspDeInit;% g$ B$ V1 T3 Y: W0 B2 s: D
}
1 |4 S! ]8 `- ~, y9 V8 {7 \" `
/* 复位底层硬件 */4 F3 I! u% \' }& b; l: L
hsd->MspDeInitCallback(hsd);7 V t7 X7 ?) ]2 S V
#else% g( F0 d$ [: K8 ~" L5 W; j$ h
/* 复位底层硬件 */
% q _) J- U8 j& e, b, c2 Z9 c% B
HAL_SD_MspDeInit(hsd);
" K# p" }4 O0 i: q. g3 k% l
#endif
: I% x# ~ l5 ^: ?0 Z
8 g) m$ H$ t5 N) z7 o N
hsd->ErrorCode = HAL_SD_ERROR_NONE;
: F. D! ]0 h' W! \' `4 v6 e6 T, |
hsd->State = HAL_SD_STATE_RESET;6 G0 t6 d# g# D( K% @) z8 {9 D u
; A& O: g8 ^" t( c
return HAL_OK;
1 f- J; r; Q. @* d. 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)
' X1 J t) Q. H
{! Z* L& a; a9 B
SDMMC_DataInitTypeDef config;
2 b& O' H! G" k$ [$ y% o
uint32_t errorstate;
, u; O! p0 ?) R
uint32_t tickstart = HAL_GetTick();) ~+ a+ V0 L A' T
uint32_t count, data, dataremaining;
3 ^# W* n9 j. a/ H% v" z: u
uint32_t add = BlockAdd;
" v) o# ]0 I- |% V6 _7 L9 Y3 f, u; h6 a
uint8_t *tempbuff = pData;3 j1 D/ i B0 h
5 L9 u, F& g Q' f6 E
if(NULL == pData)
7 p% V" {& J+ \/ o
{$ n0 a2 i7 B/ `$ C5 d. r
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;1 L# f2 Y8 f, v" J8 c t
return HAL_ERROR;& [6 u. @: A2 i+ M! S# ]) B- c
}
% _5 Q" g7 a9 y5 Z0 _
% x$ H$ |9 @- {: s
if(hsd->State == HAL_SD_STATE_READY)
, T9 v: p; e3 o8 j5 @
{" e( {4 a. o+ Y9 U' }* _- p- G
hsd->ErrorCode = HAL_SD_ERROR_NONE;- D% L1 R# A3 ]" T
# h$ n6 j1 {; g3 v5 m* t
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))4 l ]# k) M5 Y7 U! K0 _& @
{
; F; o) @/ g# e$ {; T6 a
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;( U" f: P" q5 `
return HAL_ERROR;& k# b1 k* _$ i$ b1 h/ `
}
3 G8 j1 \: f3 C. x% ]2 B7 K) W' Q
2 l# {. d8 B7 r4 f% W* F. y& G0 H
hsd->State = HAL_SD_STATE_BUSY;- Y( u( G) |- U0 q5 }
, b$ q1 @# E* A. M1 N( W6 w
/* 初始化数据控制寄存器 */
( h: e& {- R: D k; S
hsd->Instance->DCTRL = 0U;
+ }1 C& F. k/ P8 L1 d+ V
8 G6 |2 N% Q6 O9 I8 ~; w
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
, ~6 t8 U1 z9 r
{
, v) L" P# T- f! Y; U
add *= 512U;
. y6 {5 M; U5 g+ k7 Z- ?9 o
}8 M* `# i6 U9 F' U2 C
F) q/ g+ M, d2 A
/* 配置SD DPSM (Data Path State Machine) */
& E# U9 X" p ~4 f, [5 u" C: o$ Q
config.DataTimeOut = SDMMC_DATATIMEOUT;" b+ Z' w! ~% }3 \" z2 w
config.DataLength = NumberOfBlocks * BLOCKSIZE;
. V2 d5 t& H W
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
8 y/ w- \8 ]6 X8 l( u p
config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;
* s% g* m. n# S6 V. Y
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
% {% z$ R9 c# s
config.DPSM = SDMMC_DPSM_DISABLE;
( D" M+ w8 \# ^; m( i/ i9 I
(void)SDMMC_ConfigData(hsd->Instance, &config);
S0 {* u' d: s/ X$ r" {' j
__SDMMC_CMDTRANS_ENABLE( hsd->Instance);4 ~6 _5 @8 r" x. P5 F
5 u% C, L# x4 l' b
/* 查询方式块读取 */" |% @6 Q( G& d W( p# |
if(NumberOfBlocks > 1U)+ E; K9 a9 t6 t: t& _0 Z& V, V
{
: l% ]8 M1 G( V# H
hsd->Context = SD_CONTEXT_READ_MULTIPLE_BLOCK;: [1 A- H5 J- o k9 t! n
5 h: R6 s7 i U h, y- D7 z- ]
/* 多块读取命令 */4 w" S2 [. H( ?1 x% W" }
errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);; X; [; b# w1 K- J
}% \% A2 ]( A# o" h* V5 Y
else
6 n' G) o- O Y) r0 `" {
{
0 ]3 V' I/ \9 @8 d6 e4 u$ H! N
hsd->Context = SD_CONTEXT_READ_SINGLE_BLOCK;
$ K4 f7 ?9 N( G8 u6 Q
o! `0 D! B" R6 K* F8 f/ z
/* 单块读取命令 */; V, ]" H% v- r& N1 w3 m( t
errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);2 _, E+ s: \+ y) d
}
; W$ n3 n6 ?2 X4 K
if(errorstate != HAL_SD_ERROR_NONE)
" [- M$ a1 l/ C
{% p" F# K6 t) p9 r) }; v, K$ W
/* 清除所有静态标志 */
/ ] E; h+ v3 _( _6 y6 N
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);7 p h% r* o# \- Y; ] @
hsd->ErrorCode |= errorstate;
% m6 g0 f; N' z( x) [$ x, T
hsd->State = HAL_SD_STATE_READY;
" e7 b" r" M) t% r. A! `
hsd->Context = SD_CONTEXT_NONE;& N4 a0 K- U/ G- M4 a) I1 B
return HAL_ERROR;
! e, r: _$ B3 a% }7 W
}
3 ^, ]7 L, G' s) e& j
% T p5 ?8 X3 L4 v" X/ f) r
/* 查询SDMMC标志 */( q: ^& N8 }5 Y# O' C8 r
dataremaining = config.DataLength;
2 N4 b3 U7 k" d" V, t
while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))0 @) H! x) c+ |- C: U9 A3 M
{' ~" ]9 N" x! @% T6 y, U d
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF) && (dataremaining >= 32U))
% Y Y# j, L. J
{) G7 E& v9 p" M. z0 ~: o S
/* 从SDMMC Rx FIFO读取数据 */1 N" E& {( K. C4 r. ~5 I$ p3 I
for(count = 0U; count < 8U; count++): t' B7 P) R7 P' k0 ]. C! q. v
{, j, E; g2 Z' R4 R+ Q, M
data = SDMMC_ReadFIFO(hsd->Instance);3 V: h1 _# @$ x$ o
*tempbuff = (uint8_t)(data & 0xFFU);6 `/ V7 C8 E# V& o* P: _7 S
tempbuff++;1 N, ]7 q1 U0 T2 M4 j, F
*tempbuff = (uint8_t)((data >> 8U) & 0xFFU);- `) V) v+ U2 U6 Q
tempbuff++;( w6 }( J" C$ |. i& r
*tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
/ h, ~, i: p9 S2 R7 s/ @, }2 F2 h
tempbuff++;& X" r q+ h8 M9 I! P7 [) r) L& K
*tempbuff = (uint8_t)((data >> 24U) & 0xFFU);; W- G0 \* Q2 ~" A9 X/ Q( f
tempbuff++;
. z6 T- l& o6 T E' f; g. b* K2 S
}
. l/ o0 o* {7 W* S$ Q" D
dataremaining -= 32U;0 ~5 y+ [% w( B& R
}
4 K) _5 O$ B6 R7 d9 B r
) l* |, t ^3 U! K. t
if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
. ^+ l0 d1 m) W& @& \- j
{
& c# O: }$ E. w, X6 R# Q! A) z6 e
/* 清除所有静态标志 */: ^8 i g, @ ~, t+ a
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);7 e/ P! @) \, @, b
hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;1 Z o9 N u/ |. I. x3 E9 X/ Z! C
hsd->State= HAL_SD_STATE_READY;5 I4 M$ o5 f% z# [) Z! [" b o3 E) {6 w
hsd->Context = SD_CONTEXT_NONE;% @6 S" Q. f, S# s5 U0 K
return HAL_TIMEOUT;
; Y, N( p$ v, c4 [
}+ z9 ` t$ B! H5 Z
}
* \+ \8 d7 O# }, G* W
__SDMMC_CMDTRANS_DISABLE( hsd->Instance);
4 @+ L6 \ V0 w# ^7 }
7 x3 y+ E# | ?/ B* S
/* 多块读取发送停止传输命令 */- ]+ n* n& l4 C: r- ^4 D
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U))8 d. |; |5 c* u1 T
{& w; y( H' O# H- o) o
if(hsd->SdCard.CardType != CARD_SECURED)$ G2 j* i& t8 U; ` ], b
{0 h1 j9 K2 }; w( ]& c" J8 s) F- }
/* 发送停止传输命令 */3 N0 z) q( j2 _
errorstate = SDMMC_CmdStopTransfer(hsd->Instance);$ ]0 L+ V0 u) D$ s y7 B- z
if(errorstate != HAL_SD_ERROR_NONE): V; O( o/ a* n
{
- q" f* l v; j* d' ^& o
/* 清除所有静态标志 */
$ x2 [4 b! u/ t5 a, {
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);2 Z3 E2 \9 w% i$ R$ l; r
hsd->ErrorCode |= errorstate;
2 @: P- Q" E) o* e3 C( d2 ?1 R0 \
hsd->State = HAL_SD_STATE_READY;3 P8 y3 r3 H6 q4 Y2 ^ L4 O+ P9 K
hsd->Context = SD_CONTEXT_NONE;, z% I9 y" @* C
return HAL_ERROR;
6 h/ f" [* X9 X7 a% z
}2 @; D. j$ J% E& W
}
! t* k/ c: I0 ]4 g
}$ u) M$ x( I+ s$ i
1 y) L& Y% r1 p" x3 j
/* 获取错误状态 */6 W8 T i2 Z- ~
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))0 n. T' O' a. [9 |
{1 ?8 h b' a( F" U
/* 清除所有静态标志 */! m$ }1 M& k. D2 a; l& m4 o; F: ~
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);' p7 H7 r, l* ?
hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
: ^5 }) _9 H0 p5 G3 X
hsd->State = HAL_SD_STATE_READY;) R2 j8 Z4 L5 t: r, K! o1 N
hsd->Context = SD_CONTEXT_NONE;
0 X6 x+ M% C2 Q
return HAL_ERROR;+ c8 q# n, ~1 x8 }
}
) S# z6 j# ]7 F. M( o
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))- y8 Z* N6 |0 p; i. g7 i
{9 {2 N: g( G+ y, \' l* v: b
/* 清除所有静态标志 */5 r) y# U* F4 k/ t6 h) i q9 ~# l
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);3 A- M$ H! e# c
hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;
9 p' ]- B" K+ z* i) I
hsd->State = HAL_SD_STATE_READY;* `' J1 {1 x" t. n8 a2 J( P9 N
hsd->Context = SD_CONTEXT_NONE;4 K. N. V% i9 ?4 [2 j
return HAL_ERROR;' C1 l- d% J% n! z0 b
}
0 c4 p5 q: \6 ]. J% [
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))" [/ Z+ v7 h* h
{8 y1 `$ D V* \8 j
/* 清除所有静态标志 */
4 ]' \3 H. x x: h) J
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);: i5 \2 L% {5 t2 j4 C
hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;
: x7 l! T9 T' O' h! u4 @* N, {) |
hsd->State = HAL_SD_STATE_READY;3 G# P. W o R: R+ {/ Q( a
hsd->Context = SD_CONTEXT_NONE;
+ S7 O/ J. l# c8 o! C& n1 Z2 ^; G( W
return HAL_ERROR;
: \2 `# e; @8 E* w* e
}& Y; e7 F$ d$ p9 {
else1 @* A8 o3 \4 E
{
2 O+ z( V$ n, C! K2 O7 \
/* 什么都不做 */1 ?6 Q) w' |1 l! g. D _
}
$ }6 J- U8 d. B& ]
. O* g5 O4 u/ E3 T4 g. g P
/* 清除所有静态标志 */6 c- e* x- W- U' X- z! `
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
- w8 c! V! i$ m6 N1 ?6 l0 j: B
7 \3 j) \1 a' A# o
hsd->State = HAL_SD_STATE_READY;+ U' ~% ]# S4 y$ e% d5 t
; W6 {0 q% n/ e. z8 L, F
return HAL_OK;
5 j3 M5 a, X6 W- ~' t* T4 A
}
6 q' ?: |* n3 z: z! j" j
else
. W$ A$ O6 u2 y! }8 C
{
% ^$ O& |( P' N1 f2 I6 C
hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
. l& s* j6 D/ C& e6 G
return HAL_ERROR;
3 p2 Y8 Z" F' |7 L4 i
}
5 |/ c# T9 D* r( r( F6 \! P' V4 v( Z) R
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**
2 i! @6 s1 l% H n8 i0 O
* @brief Reads block(s) from a specified address in an SD card, in polling mode.! T& d+ {5 _& ~& \
* @param pData: Pointer to the buffer that will contain the data to transmit
8 g! e: P$ P' e$ Z! B# d
* @param ReadAddr: Address from where data is to be read
9 ^2 ^( x5 T" S# ^8 Z7 n7 o
* @param NumOfBlocks: Number of SD blocks to read8 K7 e! @8 Q% q3 A8 j
* @param Timeout: Timeout for read operation
5 k. P" R, T% E/ o' g
* @retval SD status" _ v* ~) p5 l3 i+ s/ D9 x; X; k& f
*/& I4 R% q+ h( j0 a4 Z
uint8_t BSP_SD_ReadBlocks(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks, uint32_t Timeout)( i4 I# O+ B/ }1 ~; ~
{
/ t) V, x5 k9 r
+ o" H, C2 E# S* P, f1 U
if( HAL_SD_ReadBlocks(&uSdHandle, (uint8_t *)pData, ReadAddr, NumOfBlocks, Timeout) == HAL_OK)) ]# V1 D) y3 ]5 W& K; K3 v0 h/ C
{2 y) i/ q" @& z- q) W8 V& h
return MSD_OK;: E6 N& r9 {: j" O% f
}8 w& g2 ]8 d( _ v+ Q0 B: S
else4 N7 G) Q5 B' ?7 t0 P
{3 Z6 G& @" W5 \5 E: ]) S/ `4 Q
return MSD_ERROR;
3 R. a8 Y; W" c' D, t) v' B4 H
}: k( K0 a8 h% D3 C. P* k9 `
) z( a& o9 @' y: z7 h7 f" |
}

复制代码

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)6 @+ ^7 {! k. J/ B0 d0 G1 c3 r Q
{6 y( K) I+ Q) @# N' c
SDMMC_DataInitTypeDef config;
) j7 ~) d- k6 E! G' H+ y+ d, E
uint32_t errorstate;% [- H4 [2 Q! c. C
uint32_t tickstart = HAL_GetTick();# f V+ X' B+ I+ V! }
uint32_t count, data, dataremaining;
- S! W# o' Q" \$ \0 K
uint32_t add = BlockAdd;# i a# L1 M) ?
uint8_t *tempbuff = pData;
* s4 _5 K7 P* W# R
" b ?% G, Z) }5 v' g3 L
if(NULL == pData)! Z4 r2 L: M/ s1 N
{
) }5 [" f* d% T0 g$ W$ X2 a
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;# |7 F8 t5 i0 u$ q4 n: Z
return HAL_ERROR;
+ b) s h& \. b$ ~
}
5 H! E, _0 f+ f4 l1 {/ L
0 J( s* F4 [, d- J3 Y- b! f
if(hsd->State == HAL_SD_STATE_READY)
8 q' a- h& q h
{
( Z, O- z5 I( J: D+ p* q. G2 u' w
hsd->ErrorCode = HAL_SD_ERROR_NONE;
" T4 y) h7 b5 n$ M& w- O2 R4 ^
7 l" ~6 T& ?2 `# K D- T! H* ~
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr)). H; f7 j8 t" o3 E( u g; D% a
{
" W" T1 s0 I" G0 t$ k6 S
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;; {" F4 p: W' F* G4 W5 N/ o$ r5 {
return HAL_ERROR;
3 j# D3 L! ?- x! z2 t
}! p1 `' B# r% M1 B0 p3 h
# a# o% r" X. a& C0 A! w* V, p
hsd->State = HAL_SD_STATE_BUSY;
! i$ L' u/ ^+ n* s% U7 A* Y( T
3 @$ p% A; K% w5 J: j% O i
/* 初始化数据控制寄存器 */
" w* z p3 o$ I* ~4 e
hsd->Instance->DCTRL = 0U;7 Y6 \5 k @1 A1 M3 _+ b* R a
& q# S, [5 y# N& g- u. }2 I
if(hsd->SdCard.CardType != CARD_SDHC_SDXC), \/ b' }! B! p, ~& }
{
7 k2 ]. a/ W; e5 ]8 V9 ~
add *= 512U;( |+ v" C P* X- U6 F3 U
}0 w. d& @3 C( ` S0 m4 O% D9 l" m) [
) P. J4 W8 l' ~0 w3 O
/* 配置SD DPSM */. P# t+ n& G! k" c* \& L
config.DataTimeOut = SDMMC_DATATIMEOUT;
]- n( n" v; P% x2 B1 Y5 X& f8 A
config.DataLength = NumberOfBlocks * BLOCKSIZE;
6 U Y8 w0 l- o$ n4 O# T7 ]; T' l
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;7 q0 Q6 M; F) B8 o6 f3 V
config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
% B1 q' J) }4 J/ _. f6 z+ t
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;8 i3 r! D" V! C5 M
config.DPSM = SDMMC_DPSM_DISABLE;
* t+ Q7 u/ \9 [# t
(void)SDMMC_ConfigData(hsd->Instance, &config);
( d8 z! n0 e7 Y8 a; Z! l6 |: U
__SDMMC_CMDTRANS_ENABLE( hsd->Instance);
9 x/ G9 W! s4 S, j. @# R- Y4 p
( J/ M4 }& N5 v
/* 查询方式块写操作 */
3 c9 x- t5 q' r k& E
if(NumberOfBlocks > 1U)
& j2 ` ^0 e- C+ _, l
{
2 Q1 [' k' V) ]0 o; g
hsd->Context = SD_CONTEXT_WRITE_MULTIPLE_BLOCK;
4 H( e5 p; s6 |( m
5 M# m) m: q6 v# ~& F
/* 写多块命令 */
`# \: z- Y- w5 N
errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
3 t& {3 ?/ D7 m6 c
}' H5 @6 [( d6 `& T
else
, G; ]; t! J; a ~- }; e @
{# b# w+ o4 j+ l" [, Z8 r
hsd->Context = SD_CONTEXT_WRITE_SINGLE_BLOCK;6 F# F/ _6 s5 V% e/ n$ Q) r8 Z
5 n( ~5 U' h, ^+ E
/* 写单块命令 */
( f) g& |" i1 T( Q; n" E8 q# Z9 j* m
errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
) j2 @5 f2 y4 F% A$ E
}
- p/ T& C/ M8 B+ A$ g$ J- Y
if(errorstate != HAL_SD_ERROR_NONE)
: S" N/ A) h, J2 m
{. N+ l1 w4 P6 ~( G; m* X6 X+ H
/* 清除所有静态命令 */
; X, C) `) h$ e& B5 v9 E0 ]; S( d
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);& r f$ x& t4 [& v. g: ^2 q( O
hsd->ErrorCode |= errorstate;& ^5 F% v( G. A" T/ M/ c4 F
hsd->State = HAL_SD_STATE_READY;
; u F) c" H. L: f( ~
hsd->Context = SD_CONTEXT_NONE;
( l' o' ]2 S9 U# r+ I2 J
return HAL_ERROR;
% z- N [& K# Q$ |0 o! @
}
( N& J, I, ?7 f! f
. O: E G6 a( E; J
/* 查询方式块写操作 */+ P2 N" I% n' c$ y
dataremaining = config.DataLength;
' d8 Y7 a6 W2 x& @$ T; R* Y
while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
5 t! \6 y: P, _2 r% X
{# I1 p3 V1 u! C, j
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXFIFOHE) && (dataremaining >= 32U))# V, l% f+ h4 }$ z
{
+ q& u+ p% F2 [3 [& G$ U
/* 写数据到SDMMC Tx FIFO *// `$ t1 j8 ?: k, }
for(count = 0U; count < 8U; count++)# D# y+ m2 y8 w i, D2 [! e0 f% u; A' z
{
: d$ X' d2 z7 s/ ?
data = (uint32_t)(*tempbuff);
1 H4 t+ X$ I3 ]. w; h
tempbuff++;
; S# ^8 D) F4 A
data |= ((uint32_t)(*tempbuff) << 8U);- R) I# m: E) H' S
tempbuff++;; w5 ^6 O* P+ o6 V0 B: C
data |= ((uint32_t)(*tempbuff) << 16U);2 T7 G+ N) r& @, n. M, T- Y
tempbuff++;8 B0 M2 M0 @/ U& c' X: A
data |= ((uint32_t)(*tempbuff) << 24U);
3 ` \* J7 {9 S
tempbuff++;/ L* h1 q7 O$ z: C
(void)SDMMC_WriteFIFO(hsd->Instance, &data);1 ] k! d+ n4 i7 u% c! z) s$ d2 }
}
% N6 P M h5 r8 t, s
dataremaining -= 32U;9 ~: Y, }0 ?& W* I3 D6 O' g
}. ^. e6 E$ F+ q4 }6 b% O
1 N% B8 B7 [( Y }' S# v2 g. L
if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))2 U6 g' s, D9 |; w
{
/ J# [; r) W3 C% P
/* 清除所有静态标志 */
$ w3 g/ J( T7 Q
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);% [, P3 M4 h! Z. X+ p* o
hsd->ErrorCode |= errorstate;
: l" R: C& _5 C {
hsd->State = HAL_SD_STATE_READY;7 \4 H4 |( y" C
hsd->Context = SD_CONTEXT_NONE;9 {- T% w9 C0 {; U% `
return HAL_TIMEOUT;
( R0 X A" k* @4 `
}$ M0 ~1 i1 c* ^9 p; `
}- M' ], @) _; S; l/ b
__SDMMC_CMDTRANS_DISABLE( hsd->Instance);' u Y) K" @% \+ W5 v! n$ M0 a
5 L: L8 N: v# {5 f& f8 m6 v
/* 多块写操作，发送停止传输命令 */ Y8 ?( }3 r: |9 C1 p
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U))
3 u, ]+ H2 `" t$ B* a+ }( p8 p
{# V% ]& V V9 P
if(hsd->SdCard.CardType != CARD_SECURED)! W" C$ C* m2 w$ ?3 o
{* X" P6 o% @/ Y! q' x0 {
/* 发送停止传输命令 */
7 E6 ^0 _( v; G: G9 I" I
errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
3 T' f! T; o8 S5 S! x
if(errorstate != HAL_SD_ERROR_NONE)- C6 S, X% i+ @6 V* m. j
{5 e1 L9 @) a/ n6 R/ B) m/ z* G2 ~- M
/* 清除所有静态传输标志 */
* g6 l8 K3 @% j$ p
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
/ Z+ ^) V) j& h" {) N
hsd->ErrorCode |= errorstate;8 Z; s3 u# [$ H7 v+ b/ g& ~+ D! H% |0 \
hsd->State = HAL_SD_STATE_READY;0 t8 Z# f$ l$ Y M: ?
hsd->Context = SD_CONTEXT_NONE;( P a& H3 R' H% v% j
return HAL_ERROR;
* M6 ?$ `5 J4 A4 r# {& I, n8 h; l
}
4 T0 |) r, A: B8 D' L) H |
}
& B' [ p; g3 Y' U$ Q o
}
. |/ K6 ~0 q! n2 F, R6 r9 D8 d
9 u* U3 _! _# }0 X. h% \$ E
/* Get error state */
/ E; c2 ?0 N: q, G; o) v
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))/ y: o4 g. Q+ A: e8 S2 U( e H
{
7 H: I$ Y7 T9 ^9 `# v; p1 ]" \
/* 清除所有静态传输标志 */
- f) ]7 C1 p, Q
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);$ j3 t/ t$ ~* K
hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;$ p% U% ]; t' }
hsd->State = HAL_SD_STATE_READY;
4 k# v$ c7 Y: M% M2 L" `4 o
hsd->Context = SD_CONTEXT_NONE;9 }# m6 n# `0 [1 h t$ ~9 m* q
return HAL_ERROR;7 [7 ?& N( |" x% ^
}1 e& v2 B* a, y& Q# g
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
- I* A& x# V; f" w
{, j3 A0 A+ g9 x, T" {
/* 清除所有静态传输标志 */7 e. B/ } j7 y9 A- M8 l
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);# n3 j1 F2 u- U. a3 `8 F2 V+ Z, f! P9 \
hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;) J3 S6 h+ g# ^" {( f3 l1 a2 u
hsd->State = HAL_SD_STATE_READY;
' `) A- v# W. _& N% d2 Z) N" X. I
hsd->Context = SD_CONTEXT_NONE;; {' V! o, Z) E/ _) k* Q- d
return HAL_ERROR;
9 Q1 Z8 ~# V# D& x+ J
}- z$ S# {+ d/ W7 t- i# P# L
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR))
+ U6 V ?* o( m8 X h
{# M. x& ~9 U6 _5 u4 N( o2 N# @" j
/* 清除所有静态传输标志 */
1 f- w, }4 E5 h! n& {5 U: E6 g6 i
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);- H6 Y! B8 u4 D& N3 O: d# U
hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;' g1 d# A1 {1 A+ ~/ @6 y5 F
hsd->State = HAL_SD_STATE_READY;% M* v* W+ `# i
hsd->Context = SD_CONTEXT_NONE; B3 z" N2 p7 _9 y% l$ N2 m4 J" J
return HAL_ERROR;4 g7 p; q/ D2 i; F' R
}& t2 s- V% y; C& h- \
else# G, L* J$ h- i$ Q
{
! f! z+ M2 Z( ?" [6 v& C/ Z* J G
/* 什么都不做 */
$ S4 d- i7 h$ L* B5 {$ ?
}
q& N2 ~$ t5 Z0 y" h
: G2 v' c; u7 T: e
/* 清除所有静态传输标志 */
$ b; h' d- q6 I: [6 `$ ~* Q
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
; ]- A- G6 w5 m" \& p
! ^, p0 \, ^0 N+ a
hsd->State = HAL_SD_STATE_READY;
' }/ a# q' r2 [3 w4 @5 |. H
( j9 D9 u8 v$ H7 h8 S
return HAL_OK;
) S8 r! `+ P" p$ @7 c S
}
$ n2 [; n( x5 Y0 b1 r
else
; d& w$ i0 `5 G8 `
{
# i7 e6 b: I) X+ D/ {; Z
hsd->ErrorCode |= HAL_SD_ERROR_BUSY;) X+ G- k2 m0 w4 q7 K2 |$ U
return HAL_ERROR;
, C# w0 ]! _. a8 s3 T
}, ?( M7 g4 X. V& _& |
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**
7 B( ?& u; i& ]" {& h: t! W
* @brief Writes block(s) to a specified address in an SD card, in polling mode./ W# M' ~+ X- [0 d8 `. Y
* @param pData: Pointer to the buffer that will contain the data to transmit
Y' A/ X1 z5 P& V$ }9 ]6 Y
* @param WriteAddr: Address from where data is to be written
# c4 Z$ a$ u, T4 I7 n
* @param NumOfBlocks: Number of SD blocks to write
5 f0 Y1 ]. ]& Z
* @param Timeout: Timeout for write operation4 I9 X4 ?6 D8 y" t0 i
* @retval SD status8 g4 _5 F; Z a& Y2 Y
*/- X* p- \: `# j* l8 a( e
uint8_t BSP_SD_WriteBlocks(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks, uint32_t Timeout)
$ o) U9 S! I2 E; { b
{+ I4 x( b3 t+ W4 P, D) O# T7 N2 s% ~ X
1 f8 u9 N' Z3 u, |% | D
if( HAL_SD_WriteBlocks(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks, Timeout) == HAL_OK)
- U$ z" B. q i
{( a, m3 \1 t9 }! D6 h& H
return MSD_OK;3 {) D' S( x( B e! p
}
- W5 \8 N' U( i7 g) ]
else# C) u: z% \7 f& }9 t- L
{
- f/ I6 F3 z6 P9 Q4 q; P
return MSD_ERROR;
" n" L2 E) M/ w( |. y6 a
}) u( H! Y ?( Z8 [/ I
}

复制代码

' t0 e' D1 N% S
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)' e3 L% p* h: f- ]9 R
{. B+ ^9 H" ]) n/ @ c
SDMMC_DataInitTypeDef config;' Z/ ~3 {6 i* \: ^
uint32_t errorstate;. S+ ~) {6 y5 e! c
uint32_t add = BlockAdd;" W8 ?$ v3 U, z3 A
4 f) s& \/ `% m$ O9 D
if(NULL == pData)
! `- B9 F5 a3 X. Z" A
{
; X& z X: p' \% l. e' h% {
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;$ H9 O6 S, g/ Y0 q* B$ c4 l; F
return HAL_ERROR;& g2 u J5 G2 r7 l% q, G
}
. J- S2 @9 V" W6 |0 C
$ ]& _; C! P5 a/ D. s
if(hsd->State == HAL_SD_STATE_READY)
- i) ^2 d6 k; s: J! k; N
{; {: p, ?4 l7 d( s
hsd->ErrorCode = HAL_SD_ERROR_NONE;
, f* J+ { U4 ]8 C d* g. V5 @
, N9 t) c0 a& Z/ d
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))0 t9 h9 `; o1 I9 _* N7 n5 x
{
' C4 t6 j. Z" k" {
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
1 `+ J/ A4 V$ I6 W+ I/ O6 E
return HAL_ERROR;8 o! l/ ^, D z5 r. I; q0 n2 `
}
. z, w# | l+ @9 s2 {+ }
8 Q1 D" ?5 ]) r; Z. G0 ^
hsd->State = HAL_SD_STATE_BUSY;+ M; H7 i6 z) Z) K& ?* }/ ^6 d0 G T
5 v6 L/ b% ^. W* e1 Q5 P/ F
/* 初始化数据控制寄存器 */
2 f1 G4 o ?; c9 Y$ ]
hsd->Instance->DCTRL = 0U;
' f# D( ^: b1 a9 c& }% U
Z% f+ O9 ?4 i7 {2 U! q$ o+ ]0 v1 q
hsd->pRxBuffPtr = pData;3 \3 M& I3 E& [# l: L4 N
hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;$ I( W! B) ?. y: k- w
# S& d) x5 g4 F1 [# S" }
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)% e* V4 d. X- T; {
{ x w! p, \ W/ J; K, E" r
add *= 512U;: R) Q4 n7 Q1 | t
}
# H1 L6 Q$ T6 s* C. _+ D2 ~
Q' b- U" ^; k o' u. i3 L4 X* W
/* 配置SD DPSM (Data Path State Machine) */8 E/ R( j( b7 g( e" a2 Y! r
config.DataTimeOut = SDMMC_DATATIMEOUT;
( ~; k" N% o" e7 R2 b' O, ^; k. N ?
config.DataLength = BLOCKSIZE * NumberOfBlocks;
: i8 e2 H3 |; {) r5 [' A$ q" \
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;. k' }6 G% U( u! q1 E' M1 X
config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;; |, H* f+ h; Y/ P$ c8 C8 H1 S
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;) u( [; v0 a8 R
config.DPSM = SDMMC_DPSM_DISABLE;- e9 w4 ^" a5 C h( Q
(void)SDMMC_ConfigData(hsd->Instance, &config);
6 r7 u& j; l0 I5 L! ~7 W$ y
2 M3 Q5 O/ i0 b) M+ j
__SDMMC_CMDTRANS_ENABLE( hsd->Instance);
6 X6 i/ N9 k4 V3 s. _
hsd->Instance->IDMABASE0 = (uint32_t) pData ;
$ }6 x) _* \/ g7 W, R
hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF; x# b. b% o; Q- V8 A" E; n% |! Z
5 [# c# j, v. ]3 P
/* DMA方式读取多个块 */
' p- E9 d/ j* _/ J
if(NumberOfBlocks > 1U)
, @' k3 W2 C. \, {
{
2 a. v/ G7 P$ t9 G1 ^! @
hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA);. @0 x$ Q% w6 y$ k2 G9 a7 \& R
8 ?" ~6 Z% O/ ^% ]
/* DMA方式读取多块命令 */* S! N, C! [- [' r8 }- P
errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
" U. E @. L6 b e* D% a
}
- X) V0 Q: Z$ L, s4 ^" c" [2 i
else, m* B; `0 M" Q- X
{& _ T, V1 i$ d+ C; P7 v
hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_DMA);7 C m5 `! V. o/ R) E9 u; l
5 S {% m2 t7 T1 G* w
/* 读取单块命令 */
: g, p& l8 a o% |8 ]
errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);
3 |0 Y$ Q. ~: p! k
}
7 W( O) A4 U4 d1 d- r3 x- u7 i: Z4 u+ E
if(errorstate != HAL_SD_ERROR_NONE)' C9 p4 d; M G; j
{0 s! L1 K- M. B4 O o0 O/ Z
/* 清除所有静态标志 */
6 y4 V0 l W F" l* X7 ^$ M
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
/ E4 v8 ?' V# L$ Q4 l* Y4 ]$ D
hsd->ErrorCode |= errorstate;
% b8 x: J! D" p& X! {" Z
hsd->State = HAL_SD_STATE_READY;' s+ H; G; k( S8 y, J, l2 H1 I
hsd->Context = SD_CONTEXT_NONE;
; C7 e. T7 i% V: c3 ^7 I9 Q2 b
return HAL_ERROR;8 p% w# b3 R* ?4 }3 F
}
( \; u, R( R6 _$ Y0 e; u
, s+ s$ s$ O+ }' |
/* 使能传输中断 */: P3 S$ B/ E3 k; n$ L% P3 m% h
__HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND));
. h# P& z% ~& s6 m
& U* Y" A% C* `6 f! u, x
+ F, L0 Q O4 ?6 K" x1 w
return HAL_OK; B$ M% U4 q5 b3 z1 s5 X6 u& l
}
% o. F. o* r2 {/ g3 U! O
else. b. N4 v+ F% }, u
{
) U( s9 l0 ]/ r
return HAL_BUSY;& K5 Y, F6 p+ }8 t
}. `+ F2 L4 |0 m0 a' R
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**
0 r5 d3 Y2 l, F" L( E, p
* @brief Reads block(s) from a specified address in an SD card, in DMA mode.- W( ?; J% d2 n0 h% q
* @param pData: Pointer to the buffer that will contain the data to transmit
) ^1 w" ?3 i( g+ X. b& ]
* @param ReadAddr: Address from where data is to be read' o. o* O; V9 q0 M- \& W
* @param NumOfBlocks: Number of SD blocks to read
% z% a& v2 Y9 i, A% L: F0 T
* @retval SD status
& D) S% E' ^. J. J: H' X* P1 u
*/# @( j: L# h. \. m
uint8_t BSP_SD_ReadBlocks_DMA(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks)! K( C! l! ]' `4 S& R6 \5 H
{
! u h0 I# e, |$ F, i
* |: N2 X" d1 R( n
if( HAL_SD_ReadBlocks_DMA(&uSdHandle, (uint8_t *)pData, ReadAddr, NumOfBlocks) == HAL_OK)
' X' b: C; `# F; k4 N7 V$ M
{( q' N1 P; ^/ f% p4 H
return MSD_OK;
9 H. E+ E) ~7 ?1 k
}+ c. Q. z# ~* R9 I! e& P
else- T7 @- y3 N* w* X& h& @1 i8 Z
{6 r3 F7 u& B* T' ~
return MSD_ERROR;
, S1 l: V9 N+ b- K( |
}
* \! C/ {2 b: f% @
}

复制代码

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)
1 c" y3 T0 F& y3 }
{4 m. P. `2 ^2 x$ b" k. n V
SDMMC_DataInitTypeDef config;
# j! ?* X+ s# L8 K8 E- n& M
uint32_t errorstate;: b' N. t7 o0 }( O
uint32_t add = BlockAdd;; P" n! E# _( ]. X' M6 T
; K% T( W$ `- }# d! ?
if(NULL == pData)
, G; S# a* t& D( E/ d, T3 z
{
; E% D- d3 d/ X' o. O' P
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
/ d" e1 \, l6 a8 e
return HAL_ERROR;6 p) p2 s+ Q0 D& X$ u
}6 Z0 x3 m7 j# Y0 {) P
1 y" S3 }, } r& L; ^% d
if(hsd->State == HAL_SD_STATE_READY)
7 M+ f" I( @' B: R' N" _
{
0 @# Z: |; [8 \ J
hsd->ErrorCode = HAL_SD_ERROR_NONE;( e' H/ g' y- y! J: _( r! @
# @0 D# n8 y7 _% O, X: v3 \5 _
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))4 M) w$ |1 x& i7 I t7 G
{
/ _3 _* q9 M0 }/ i5 a' _9 i. H. r
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
- |8 N) P4 `% X6 k
return HAL_ERROR;5 @1 B& _5 I. M" [) T9 ?
}5 a8 W6 b: h/ n! b; U3 L
2 [6 J7 G" u/ o6 v3 {! F( m% [7 [
hsd->State = HAL_SD_STATE_BUSY;
" T+ ~9 a. S! A/ Z" O
. f) C, x0 c8 f. R
/* 初始化数据控制寄存器 */* |* e) j) e9 c$ F2 e
hsd->Instance->DCTRL = 0U;* |* ~# C' h! q
6 B/ L' Q% C1 z m" v+ p
hsd->pTxBuffPtr = pData;
2 T5 B( p# g6 x! m
hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;2 Q8 m5 \, ^0 G; i
- `, ?2 {5 ?! E7 A6 g; ]
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
8 o& U/ `- S& \- k' }8 h. d4 F
{/ g% o- y `" `6 z, q/ w
add *= 512U;
. p9 ?4 ]( t5 J4 r, j2 w5 V$ C8 o
}- _. Y2 M, O$ h' _/ k
3 {5 B+ S: d: b$ p/ N9 Y; U
/* 配置SD DPSM (Data Path State Machine) */$ Y$ ?3 C! _! {4 I
config.DataTimeOut = SDMMC_DATATIMEOUT;* ~: p" W0 E6 U6 O/ }+ T
config.DataLength = BLOCKSIZE * NumberOfBlocks;
8 n1 O) ?. S# z% ]% r* G! a
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;7 {) L6 ~, Z( w8 q ] |
config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
, r& w& `& c3 E
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
" ]9 Y- J; ~0 H7 W
config.DPSM = SDMMC_DPSM_DISABLE;
) E0 v2 v9 q& O. g
(void)SDMMC_ConfigData(hsd->Instance, &config);& U( @- u5 b8 u; S/ |. e- f
* [# W% A( D: c7 l2 f
- | ^- P$ q9 x$ A2 U2 \# s9 r
__SDMMC_CMDTRANS_ENABLE( hsd->Instance);
% ~% e+ u" W1 G' W) Z5 O0 g$ d; T
& n6 b+ W: G2 Q0 M
hsd->Instance->IDMABASE0 = (uint32_t) pData ;, n' v- @3 y: {6 k6 W
hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF;" Z) g/ H% N6 l7 ~1 T2 W# @, t% L
9 {+ H G6 l" v' _; j
/* 查询模式写块 */
$ w: `4 V1 D$ U+ ]- b/ C$ m
if(NumberOfBlocks > 1U)! y$ ^$ I% R& J; [6 M
{
/ f* X: Z7 z% H
hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA);: z2 s3 {5 o/ u9 r( H# _% ~" k
$ F0 @+ ~* W+ ?
/* 多块写命令 */
6 @, R2 a8 {, b
errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
7 V% w8 s+ n- a( k
}
3 z0 }: Q! V- K# x6 n e
else
1 P+ b) \, k4 h, @, j
{" w1 Z7 C8 b9 R" ^2 i! G6 s; d5 O! x
hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_DMA);
: u; V/ y5 F3 k; B& H- Z( b
& L G1 [0 T2 p3 ~- F5 R' D
/* 单块写命令 */% r/ x8 L6 }: x$ u& a2 A0 q
errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
( Q; Z9 n7 b- j, I8 V1 p
}- m; `8 g1 B+ @% e% j8 Z S
if(errorstate != HAL_SD_ERROR_NONE)" W2 _2 Z$ ^. N
{
9 O4 a7 J& k9 K6 H" w' @
/* 清除静态标志 */
, V9 M; v0 ^; v( c
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
L, X# L6 ~" N/ C' ~6 b
hsd->ErrorCode |= errorstate;
p$ C# x' P4 ]! d& i( f8 V8 x2 Z
hsd->State = HAL_SD_STATE_READY;
/ D2 L3 o9 j1 k1 X$ {- A8 W
hsd->Context = SD_CONTEXT_NONE;% l, V( T; d- Y5 q6 }
return HAL_ERROR;7 H7 [. c' @/ I/ W, F5 N6 y
}6 d6 Z' J) y5 B, E1 f& B3 Z1 t
# c3 E, R8 w% _% N$ R
/* 使能传输中断 Enable */& n0 s" w. z2 u! C
__HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND));+ G" C6 K. @3 i# B
, W/ M1 c5 J3 q H- \. B! C& v
return HAL_OK;$ V ~2 g' q6 L* O' ~5 R+ d3 K0 T
}( s% ^1 h( E+ q; \: h
else# O+ s! A x% {1 Q: G
{
; l# u1 [: D3 C/ ^$ m
return HAL_BUSY;) x, v7 j0 |. w. Q
}
- J6 M+ Q" v3 G9 W
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**
& H1 O$ W" A" o' L; u! V
* @brief Writes block(s) to a specified address in an SD card, in DMA mode.0 A- k3 |, K; f( B7 m8 f9 j2 ]
* @param pData: Pointer to the buffer that will contain the data to transmit
) i) f. L. c5 G _- Z
* @param WriteAddr: Address from where data is to be written
/ P ^# v/ w% S4 _3 F! c: K
* @param NumOfBlocks: Number of SD blocks to write3 D3 t, C2 y5 K$ L5 z
* @retval SD status
: \" }7 ]2 v2 ~ H+ O# x% B
*/ s* \$ o3 T7 F0 r
uint8_t BSP_SD_WriteBlocks_DMA(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks)# n) a- v$ @+ O P; p( h
{
! |) t8 U, s$ q4 l# b0 h. W8 Y9 ?
( g# c, a& P* I) L' C
if( HAL_SD_WriteBlocks_DMA(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks) == HAL_OK)5 q5 S/ L, {) @
{
2 \; l" A- U7 n" b8 H+ C
return MSD_OK;* m* f0 g# I; K1 a' F- z
} Q$ o8 }5 ^4 j1 j7 t9 C
else% M4 }# g3 v; d$ ~1 b4 `* b
{1 M1 o* o5 Z- H
return MSD_ERROR;7 m. D9 v1 n, T2 C
}, f& _" v- r' A* Y* f
}

复制代码

87.4.7 函数HAL_SD_Erase
函数原型：

HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd)
& E& ?# D. c- |; b( h. t
{
4 y; {' h# z4 Z# E* q6 [
uint32_t errorstate;
+ j0 K( G1 J0 Q( D# {: Z
uint32_t start_add = BlockStartAdd;
uint32_t end_add = BlockEndAdd;" j8 a0 i+ o' t4 T
* ]* [0 ?% j, A# P! B; ~6 W
if(hsd->State == HAL_SD_STATE_READY)
$ v8 X' e* r/ ~3 P
{
/ F9 F2 t, y! |& M8 b
hsd->ErrorCode = HAL_SD_ERROR_NONE;: V; _) `% T( \0 Z$ Y$ D
5 i3 I7 }+ E2 K
if(end_add < start_add)) n3 D5 O1 W: _2 q5 T3 ?; I
{
8 f9 i# y0 _& c# z6 N% k, o
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;/ Q7 n. z }2 W4 U
return HAL_ERROR;& R. Z& d& {- ^( o
}5 |; U) H4 x& P3 \! z
/ f" m# r# x, a+ Z, a; y
if(end_add > (hsd->SdCard.LogBlockNbr))
1 O; D7 t/ f3 F2 B
{
* ~# O2 R' h( v7 t/ _9 H: @
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;7 O; y# W2 I) S9 M4 O( p
return HAL_ERROR;) S5 M G. P9 z- v$ I; `
}+ w- K+ R O0 h4 `# `6 C# U" w
. ~& ~! o2 I7 ?
hsd->State = HAL_SD_STATE_BUSY; n9 p) ~/ d! U. r8 t/ [" ]
: T+ W; d7 h, {; z
/* 检测是否支持擦除命令 */6 v, i. k5 D0 c' K A# \ D& z
if(((hsd->SdCard.Class) & SDMMC_CCCC_ERASE) == 0U)
) V1 W0 w& a- K, @8 Z
{5 W' x! [! v3 e& |, f" K& G; [
/* 清除所有静态标志 */
`. y8 }9 s5 H3 G
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
$ \9 K, Z- M3 d4 \( i# [
hsd->ErrorCode |= HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;0 C2 {# }# _1 o& m1 D: c( Z/ o
hsd->State = HAL_SD_STATE_READY;6 B: V9 D1 x/ A+ y
return HAL_ERROR;
" D c+ T+ b! {9 }' T( s. D
}4 @0 o! y; W/ N( o* \" W7 |
4 \" ^, O' r1 h2 `3 i: e% k
if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)
{
" Z# I1 [: s5 C- O' X' u, f
/* 清除所有静态标志 */
; U" c, X2 |2 w0 v0 J- t! M
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
$ j9 M! U/ E3 a- a; v! v& Y. k
hsd->ErrorCode |= HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
' b6 `4 w! v% S m6 m
hsd->State = HAL_SD_STATE_READY;/ P+ k9 [& l8 L
return HAL_ERROR;; P3 J" g }- g5 _ E3 y( V ^
}
9 ~; B( f5 a4 u. f; S% S
9 u7 ~' D- {4 T1 d2 W- n
/* 对于高容量卡，获取起始块和结束块 */1 E* U0 e/ g6 v! }% Q3 p, C
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
% d5 D' ~' }. A# y) ^2 |+ L6 R# X
{
" D; b$ ?/ i) L5 U7 g+ Z4 y
start_add *= 512U;6 g$ e' s" H3 j1 {! W z
end_add *= 512U;# h4 C8 c/ H6 D7 D
}
. q9 V$ ^$ J" L' M, b5 f9 \8 o4 U
& ~0 ?* S5 X# X( r- g1 t# _( D' G0 ^
/* 根据sd-card spec 1.0 ERASE_GROUP_START (CMD32) 和 erase_group_end(CMD33) */( l: _# r% W" a$ n) L$ P ]
if(hsd->SdCard.CardType != CARD_SECURED)
3 B7 M, Z& M6 [5 @! S% _
{+ {# q7 {4 j/ M) v% v
/* 发送CMD32 SD_ERASE_GRP_START命令带地址参数 */
/ J" t" R9 Z& n. r9 H, L
errorstate = SDMMC_CmdSDEraseStartAdd(hsd->Instance, start_add);
; V, o+ H9 g* F k
if(errorstate != HAL_SD_ERROR_NONE)) m6 ]9 m3 h6 p' e* D' n
{
+ A9 ^% O! f5 r& O
/* 清除所有静态标志 */
1 m' N2 E& o0 J
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);" z& h* }0 s5 u: p) _+ v$ x) z
hsd->ErrorCode |= errorstate;
$ g- w/ M3 d5 J% `9 }4 F G
hsd->State = HAL_SD_STATE_READY;
) \1 j$ S1 c8 z8 q& P7 J8 [( l* r
return HAL_ERROR;
/ ]! ^" A! d) |1 R
}* W7 r% i2 J: ]4 V& R: k+ ~
! @$ D9 }4 x+ W
/* 发送CMD33 SD_ERASE_GRP_END命令，带地址参数 */
9 K; f2 v- @/ z# w e0 C6 R
errorstate = SDMMC_CmdSDEraseEndAdd(hsd->Instance, end_add);
. ]# i# T8 N/ T4 Q
if(errorstate != HAL_SD_ERROR_NONE)9 b6 i) t+ n& V% Q
{ I3 O X0 T4 y: N- Q
/* 清除所有静态标志 */1 s7 c$ a: W! S# |- f0 Q6 k5 H
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);$ W6 o! k+ x! ?' s6 L
hsd->ErrorCode |= errorstate;
2 p* B) j; d- V4 K& W; U
hsd->State = HAL_SD_STATE_READY;! F/ J$ V* ~* [; E- h
return HAL_ERROR;
) ~+ s9 `% l3 b# P9 s' a
}
6 P6 z: k/ ?" |. Z" J
}
8 E* B3 E8 U9 q8 l; B; J9 Q
2 L" H) Q8 R; a( ?* r
/* 发送CMD38 ERASE命令 */
/ H7 `" a: Z6 C( ~% Z
errorstate = SDMMC_CmdErase(hsd->Instance, 0UL);" f& ^# j0 T! W! g7 A4 ~
if(errorstate != HAL_SD_ERROR_NONE) _2 A3 h. L3 ?1 `
{- e% q" D# f; v$ y( H) ]3 n
/* 清除所有静态标志 */
* |8 G/ D% F) j: Z( W4 L2 q
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
8 [. M" [0 K$ U8 N- V/ [) P
hsd->ErrorCode |= errorstate;) ~- X0 D& V7 ~" `& b
hsd->State = HAL_SD_STATE_READY;
5 _; q; I( e* s
return HAL_ERROR;1 Z, j; a. C1 E; S9 H6 t! \
}9 l' \5 m1 h9 I& v, c2 ?
& W9 Z& @1 |7 v* K+ W9 ~6 a7 N
hsd->State = HAL_SD_STATE_READY;; d* e2 |1 `* H r; J
- k2 E# y) I9 ]5 w9 L
return HAL_OK;
& P+ J% S+ M! A
}, c2 {& S6 e; n2 w, X1 g
else
/ }: \! p6 Y3 K( F9 X) P% Z
{- ~& [4 Y$ Q& s- K. Y1 s- o" _+ M% h
return HAL_BUSY;8 O" n0 y% B$ R6 k
}* a2 e( t& n0 @7 ]' @ i, T8 S
}

复制代码

函数描述：

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

函数参数：

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

/**2 w6 |# V, U3 |2 i3 L
* @brief Erases the specified memory area of the given SD card.
. r, a. P. i' [2 j
* @param StartAddr: Start byte address
2 c. L' ?" C ^( p- m
* @param EndAddr: End byte address
/ _# w# Q" _5 t; }* D
* @retval SD status! u" v5 v8 H3 V, x) D% {/ T; r
*/
2 i- G A3 A4 a6 a3 p) f
uint8_t BSP_SD_Erase(uint32_t StartAddr, uint32_t EndAddr)& e- R2 w2 \% F, T
{
1 \2 n6 T4 u/ H2 D+ B+ g' Q
, a+ \4 n9 }7 r5 B8 g& L
if( HAL_SD_Erase(&uSdHandle, StartAddr, EndAddr) == HAL_OK)
' \/ J! p" ]" q0 O$ H$ t
{
$ w j b* h4 V
return MSD_OK;
7 K9 A1 F- g% z& [% f( D
}
: b. Q+ |/ U0 l- J: {) S
else
, |2 L7 H7 L h2 ?
{+ ]; \2 r6 |6 S6 a6 ?0 ]/ g) ]
return MSD_ERROR;0 w8 c& A, k" h+ n' G
}/ ?9 I* F2 x( B5 n4 K I
}