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

% ~0 n7 d5 @( G$ ?7 L
87.2.4 SDMMC支持的速度
驱动SD卡支持的最大总线速度：

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

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

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

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

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

#define SD_TypeDef SDMMC_TypeDef
* Z# Y8 Y- ~1 W
typedef struct6 G( J- Z1 X" K; v9 N1 y
{
, m U* W D. k% l P2 h
__IO uint32_t POWER; /*!< SDMMC power control register, Address offset: 0x00 */" g. n k; _3 g+ }5 W( F
__IO uint32_t CLKCR; /*!< SDMMC clock control register, Address offset: 0x04 */
( i3 S* k. ^$ L- V
__IO uint32_t ARG; /*!< SDMMC argument register, Address offset: 0x08 */* D2 X# ~5 N ?; p* ^
__IO uint32_t CMD; /*!< SDMMC command register, Address offset: 0x0C */
6 Y. F- ~4 M, d7 r# z7 d* F
__I uint32_t RESPCMD; /*!< SDMMC command response register, Address offset: 0x10 */4 Q( ~( C9 ^- W1 W6 [& F: V
__I uint32_t RESP1; /*!< SDMMC response 1 register, Address offset: 0x14 */6 D, _4 v4 q5 b& E
__I uint32_t RESP2; /*!< SDMMC response 2 register, Address offset: 0x18 */9 O* I6 P4 C! u: R, R
__I uint32_t RESP3; /*!< SDMMC response 3 register, Address offset: 0x1C */
- y' n) H: a/ B4 q! J, s8 B, z4 c
__I uint32_t RESP4; /*!< SDMMC response 4 register, Address offset: 0x20 */
1 h* h* d0 b B" @7 p& V
__IO uint32_t DTIMER; /*!< SDMMC data timer register, Address offset: 0x24 */
3 G. n0 C0 f$ n( i
__IO uint32_t DLEN; /*!< SDMMC data length register, Address offset: 0x28 */
. x8 }+ G9 Y6 b+ ?# E4 Q. Q
__IO uint32_t DCTRL; /*!< SDMMC data control register, Address offset: 0x2C */
& z% \" |( |' o# _$ W# K7 `4 R
__I uint32_t DCOUNT; /*!< SDMMC data counter register, Address offset: 0x30 */
5 p; D# y% T; ]6 S/ q# R
__I uint32_t STA; /*!< SDMMC status register, Address offset: 0x34 */) N% b% [$ y3 s/ r' m$ x: g" |+ k
__IO uint32_t ICR; /*!< SDMMC interrupt clear register, Address offset: 0x38 */% l& P9 s/ y) ^9 z0 L* E
__IO uint32_t MASK; /*!< SDMMC mask register, Address offset: 0x3C */
__IO uint32_t ACKTIME; /*!< SDMMC Acknowledgement timer register, Address offset: 0x40 */
7 t5 X+ @4 w( Z
uint32_t RESERVED0[3]; /*!< Reserved, 0x44 - 0x4C - 0x4C */! B' ^! D! u8 @4 S9 y7 M9 n: R
__IO uint32_t IDMACTRL; /*!< SDMMC DMA control register, Address offset: 0x50 */
) |: U3 f, p$ r# e" A
__IO uint32_t IDMABSIZE; /*!< SDMMC DMA buffer size register, Address offset: 0x54 */( H( J1 j' g, v# k% P- g
__IO uint32_t IDMABASE0; /*!< SDMMC DMA buffer 0 base address register, Address offset: 0x58 */8 j- i' \! I d% R- u% A. `) h6 e
__IO uint32_t IDMABASE1; /*!< SDMMC DMA buffer 1 base address register, Address offset: 0x5C */) `& R/ O# I. k0 k6 M. |$ g
uint32_t RESERVED1[8]; /*!< Reserved, 0x60-0x7C */
6 G' o3 C3 y) ~3 |
__IO uint32_t FIFO; /*!< SDMMC data FIFO register, Address offset: 0x80 */
/ _3 |7 v( T( x7 j/ e8 c F; a
uint32_t RESERVED2[222]; /*!< Reserved, 0x84-0x3F8 */5 K' `. T* u8 ~3 x3 v
__IO uint32_t IPVR; /*!< SDMMC data FIFO register, Address offset: 0x3FC */
: t5 C4 O" l1 h7 S& A% E
} SDMMC_TypeDef;

复制代码

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

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

#define __O volatile /*!< Defines 'write only' permissions */9 z% E* j& x. G; q( W
#define __IO volatile /*!< Defines 'read / write' permissions */

复制代码

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

#define PERIPH_BASE (0x40000000UL) 4 e7 K9 C, ~) `9 v( j7 [
#define D1_AHB1PERIPH_BASE (PERIPH_BASE + 0x12000000UL)% D0 w( X0 K8 K& ?- F
#define D2_AHB2PERIPH_BASE (PERIPH_BASE + 0x08020000UL)8 E. B# N$ h$ s: i. x9 c
7 W# g' W$ d' X; u* U* J
#define SDMMC1_BASE (D1_AHB1PERIPH_BASE + 0x7000UL)
; [1 C5 k- V2 T2 }
#define SDMMC2_BASE (D2_AHB2PERIPH_BASE + 0x2400UL)
6 s V7 }. p' C- E% r1 w
3 ]" l/ ]& y: y% n
#define SDMMC1 ((SDMMC_TypeDef *) SDMMC1_BASE)8 g- X, {" v5 F8 ]# O
#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
+ r; Q; L7 u/ c& q6 _/ x# P! u
typedef struct+ d" b" K. s1 L R
{
- v* m. x" p0 b7 f( T4 O, h
uint32_t ClockEdge; ! c: n; k& {, ~/ h
uint32_t ClockPowerSave; " F7 ^$ y% V$ @- L# n$ U/ m
uint32_t BusWide; ; l& g7 W' D$ h* k$ a
uint32_t HardwareFlowControl; " W# o1 t0 w% m
uint32_t ClockDiv; 4 Z2 R! z5 a4 ~& |7 g0 s$ _
#if (USE_SD_TRANSCEIVER != 0U)
( x' g, f0 s9 z6 e8 ]) W, a- j0 ~
uint32_t TranceiverPresent;
, N& o( x" j/ U6 d' h
#endif . s- f. \; s. I8 A
}SDMMC_InitTypeDef;

复制代码

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

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

#define SDMMC_CLOCK_EDGE_RISING ((uint32_t)0x00000000U)
3 V& t( C; ^) y+ T4 f9 y' Z
#define SDMMC_CLOCK_EDGE_FALLING SDMMC_CLKCR_NEGEDGE

复制代码

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

#define SDMMC_CLOCK_POWER_SAVE_DISABLE ((uint32_t)0x00000000U)
5 [* K! s* V3 g7 O. M0 ]- |" W
#define SDMMC_CLOCK_POWER_SAVE_ENABLE SDMMC_CLKCR_PWRSAV

复制代码

BusWide
用于设置SDMMC总线位宽。

#define SDMMC_BUS_WIDE_1B ((uint32_t)0x00000000U)
$ L2 H& v$ B4 \* X2 S4 Y5 E1 z- P
#define SDMMC_BUS_WIDE_4B SDMMC_CLKCR_WIDBUS_04 ?2 [& H8 }# L! w, f
#define SDMMC_BUS_WIDE_8B SDMMC_CLKCR_WIDBUS_1

复制代码

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

#define SDMMC_HARDWARE_FLOW_CONTROL_DISABLE ((uint32_t)0x00000000U)
; d' K1 a& i, ^0 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)
( X0 G) R% O0 x) I- Y; d
#define SDMMC_TRANSCEIVER_NOT_PRESENT ((uint32_t)0x00000001U)8 I' o! u# D6 s3 X0 h7 |3 C4 w4 y# T0 C
#define SDMMC_TRANSCEIVER_PRESENT ((uint32_t)0x00000002U)

复制代码

: R* j2 h" K# T% Z+ H' w _
87.3.3 SDMMC接SD卡信息结构体HAL_SD_CardInfoTypeDef
下面是SDMMC总线的卡信息结构体：

typedef struct
2 P. `: c5 H9 r( @
{
! _3 y" ?6 P, D& I5 H- F6 x+ s
uint32_t CardType; /*!< Specifies the card Type */
# U0 \, r3 e' h
uint32_t CardVersion; /*!< Specifies the card version */
! R# p, q5 d4 @1 ^" S
uint32_t Class; /*!< Specifies the class of the card class */
; h# C. E( W0 d( W) L4 r& l8 \# d# K
uint32_t RelCardAdd; /*!< Specifies the Relative Card Address */
. {$ u0 `) {$ m+ q
uint32_t BlockNbr; /*!< Specifies the Card Capacity in blocks */
1 p$ i& g* O0 R3 D9 [3 q5 l$ N
uint32_t BlockSize; /*!< Specifies one block size in bytes */+ l0 s& r j3 T! h. V2 S
uint32_t LogBlockNbr; /*!< Specifies the Card logical Capacity in blocks */
. R) Z7 f {# \9 o
uint32_t LogBlockSize; /*!< Specifies logical block size in bytes */
! k" X* B2 i: S+ i3 _; M
uint32_t CardSpeed; /*!< Specifies the card Speed */# X( w5 M$ R9 {9 a; Q5 D+ o- m6 _5 c
}HAL_SD_CardInfoTypeDef;

复制代码

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

CardType
卡类型。

/*!< SD Standard Capacity <2Go *// q1 d; Z+ I4 n7 i- i3 ~
#define CARD_SDSC ((uint32_t)0x00000000U)
7 f5 Y+ e3 g. W: H5 }; C: h
/*!< SD High Capacity <32Go, SD Extended Capacity <2To */
, y! m0 z5 [' r/ v
#define CARD_SDHC_SDXC ((uint32_t)0x00000001U)
; h3 j/ D- j( M- T f/ ^+ ?
#define CARD_SECURED ((uint32_t)0x00000003U)

复制代码

CardVersion

卡版本。

#define CARD_V1_X ((uint32_t)0x00000000U)9 e2 @+ i) I2 r- t/ f
#define CARD_V2_X ((uint32_t)0x00000001U)

复制代码

  Class

卡类型。

  RelCardAdd

卡相对地址。

  BlockNbr
整个卡的块数。

  BlockSize

每个块的字节数。

  LogBlockNbr

整个卡的逻辑块数。

  LogBlockSize

逻辑块大小

#define SPI_FIRSTBIT_MSB (0x00000000UL)
& v: j' o y8 H' j7 T* X" G
#define SPI_FIRSTBIT_LSB SPI_CFG2_LSBFRST

复制代码

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

/*!< Normal Speed Card <12.5Mo/s , Spec Version 1.01 */3 ^0 D; n3 p6 y! m
#define CARD_NORMAL_SPEED ((uint32_t)0x00000000U)
l P+ @& t6 P
/ V( t8 V) @7 f4 F
/*!< High Speed Card <25Mo/s , Spec version 2.00 */
( g5 w' N! U7 a L
#define CARD_HIGH_SPEED ((uint32_t)0x00000100U)
. l! A' ^/ W; @9 U X9 C& V! \
1 {, h: t+ D/ D
/*!< UHS-I SD Card <50Mo/s for SDR50, DDR5 Cards
' W) c* g! I9 S2 ~: R1 u1 ~
and <104Mo/s for SDR104, Spec version 3.01 */
) D( s2 ]0 b% _. R& s/ [1 Y4 U
#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)* B$ J: L, x7 g" j# l5 u
typedef struct __SD_HandleTypeDef
4 o. L8 ^# v5 o
#else0 W k: z, k& N% G
typedef struct; v b/ n% D) q D# @8 s9 ?8 Z
#endif /* USE_HAL_SD_REGISTER_CALLBACKS */6 b" O$ d0 L2 M6 U; _
{! R& n( g, ~: ?7 l% t/ Y! s
SD_TypeDef *Instance; /*!< SD registers base address */
, d! q" \( [4 b- f" g3 }. K' C% w
SD_InitTypeDef Init; /*!< SD required parameters */
' W8 R8 i5 b$ \
HAL_LockTypeDef Lock; /*!< SD locking object */3 Z( j1 Z+ M# v
uint8_t *pTxBuffPtr; /*!< Pointer to SD Tx transfer Buffer */" Z# X c( V1 E" s% G
uint32_t TxXferSize; /*!< SD Tx Transfer size */' O# G) z$ v4 k- C/ q( w1 n
uint8_t *pRxBuffPtr; /*!< Pointer to SD Rx transfer Buffer */
1 g+ Y8 b: r+ C& { s" D
uint32_t RxXferSize; /*!< SD Rx Transfer size */) Z' ` s3 S/ D }1 k; K
__IO uint32_t Context; /*!< SD transfer context */
* G3 \9 e% R+ m# g+ M
__IO HAL_SD_StateTypeDef State; /*!< SD card State */
# s8 F9 \& Q; ~( P: [) a
__IO uint32_t ErrorCode; /*!< SD Card Error codes */
! ]' ` I% M0 T6 L. b
HAL_SD_CardInfoTypeDef SdCard; /*!< SD Card information *// W. S+ s( S" S% T& f6 k
uint32_t CSD[4]; /*!< SD card specific data table */8 i; L0 ?2 X9 L0 t
uint32_t CID[4]; /*!< SD card identification number table */5 k& M8 ?+ x8 W& s. k
* u/ p2 x) ~# r+ T
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
4 g5 c0 W7 [8 y
void (* TxCpltCallback) (struct __SD_HandleTypeDef *hsd);" ?! v, y9 q l7 G
void (* RxCpltCallback) (struct __SD_HandleTypeDef *hsd);
% ^, w# T5 @2 y+ i
void (* ErrorCallback) (struct __SD_HandleTypeDef *hsd);+ e, W1 o9 ~* J0 |0 \
void (* AbortCpltCallback) (struct __SD_HandleTypeDef *hsd);
% W. ?" F$ r- j. R( ]4 p% h
void (* Read_DMADblBuf0CpltCallback) (struct __SD_HandleTypeDef *hsd);
& o4 S( Y; V) O. p7 e3 C' B
void (* Read_DMADblBuf1CpltCallback) (struct __SD_HandleTypeDef *hsd);
( b, Y7 Y! R7 }7 C6 l V( {
void (* Write_DMADblBuf0CpltCallback) (struct __SD_HandleTypeDef *hsd);4 ]9 a; o0 o. `1 w
void (* Write_DMADblBuf1CpltCallback) (struct __SD_HandleTypeDef *hsd);
3 j1 J5 T- e7 n% n
#if (USE_SD_TRANSCEIVER != 0U)( |5 E4 ~+ a! t5 H9 ~" O9 r
void (* DriveTransceiver_1_8V_Callback) (FlagStatus status);7 }3 }; Q3 T. v( S
#endif /* USE_SD_TRANSCEIVER */8 d* N. g$ Q5 @! l2 D
0 T6 ]% ^7 r7 i d$ o+ H6 l
void (* MspInitCallback) (struct __SD_HandleTypeDef *hsd);' H* y" ?8 G# E5 j7 u$ U# A5 Q d, |
void (* MspDeInitCallback) (struct __SD_HandleTypeDef *hsd);- f2 y7 b T. G! W9 n$ j1 [) k8 ^
#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
! A7 x8 N! X; s' P. x/ q7 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)4 ~. ?" e) k/ y5 x3 s( K6 U! E
{# G9 K5 H7 t3 m, B( R4 y" |
HAL_SD_CardStatusTypeDef CardStatus;8 p7 M9 m7 A |& E# z* U% n8 f
uint32_t speedgrade, unitsize;$ a' o; L/ h6 y9 b: }8 j' m" a
uint32_t tickstart;+ h. F7 E- \9 I% v% W
% t/ _! [8 P+ u6 t( d4 V3 }) p6 V2 f
/* 检查句柄是否有效 */
# h- b/ K. _5 f& ^" z A
if(hsd == NULL)9 J. x+ v/ ^5 i, O% S
{
]# m+ r6 x$ w" B: |! w
return HAL_ERROR;
& m [7 [. w- k# m, z
}
$ }" K4 {! `1 Z$ d, v6 w
3 \0 s7 S1 h2 I5 I% E
/* 检查参数 */
& y. O+ J( |# q; c H7 s
assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));2 o, K: y. r9 v/ B; D( G, ]
assert_param(IS_SDMMC_CLOCK_EDGE(hsd->Init.ClockEdge));
2 g* i3 y9 {- l1 g0 Q: q
assert_param(IS_SDMMC_CLOCK_POWER_SAVE(hsd->Init.ClockPowerSave));0 J1 q& o' w* T0 V+ I
assert_param(IS_SDMMC_BUS_WIDE(hsd->Init.BusWide));
- s5 ~$ R3 p3 g0 l. Z3 C; m
assert_param(IS_SDMMC_HARDWARE_FLOW_CONTROL(hsd->Init.HardwareFlowControl));3 l% d! |: }" \# V) j
assert_param(IS_SDMMC_CLKDIV(hsd->Init.ClockDiv));
, @$ V2 Z- b* O6 j+ Z9 }4 {4 e2 z
* g! Z" v" H4 F3 u
if(hsd->State == HAL_SD_STATE_RESET)" d T+ _9 r3 }. a) V b8 P: W$ W
{
8 Y! ^8 _; V; P9 e
/* 开锁 */: [' Y7 S5 u) ^3 M' u
hsd->Lock = HAL_UNLOCKED;
' J6 d1 m; D% K. e
#if (USE_SD_TRANSCEIVER != 0U)1 L1 F9 R6 f- ~5 b( @" T9 q
/* 兼容 */
: l, U7 w. _) J7 y) B7 E9 l
if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_UNKNOWN)0 Z) b2 j) v9 k) f' e. b
{* o* N' b9 A4 _: S
hsd->Init.TranceiverPresent = SDMMC_TRANSCEIVER_PRESENT;- E& B* \9 {6 W8 G$ r$ C: W
}
. s& p) _" w, S* n: }" Z6 i
#endif( g# B8 U! v0 V9 x1 r- j
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
2 R o7 a( Q# L8 t1 f
/* 复位回调 */
" G! W7 p, O ^7 O9 |" B' Z5 ^
hsd->TxCpltCallback = HAL_SD_TxCpltCallback;+ _1 I1 z" i& w, s+ N
hsd->RxCpltCallback = HAL_SD_RxCpltCallback;
" }* C& t {# t! H
hsd->ErrorCallback = HAL_SD_ErrorCallback;
1 O+ g3 h# P& O' w4 y; w
hsd->AbortCpltCallback = HAL_SD_AbortCallback;
% x8 k4 A) O' }3 R- @) ~" _
hsd->Read_DMADblBuf0CpltCallback = HAL_SDEx_Read_DMADoubleBuf0CpltCallback;& ^' D, m- T: C, x. V0 f
hsd->Read_DMADblBuf1CpltCallback = HAL_SDEx_Read_DMADoubleBuf1CpltCallback;
7 T0 a5 h" C/ B4 }
hsd->Write_DMADblBuf0CpltCallback = HAL_SDEx_Write_DMADoubleBuf0CpltCallback;
$ l P' K2 M- O% K% {! b2 J4 _
hsd->Write_DMADblBuf1CpltCallback = HAL_SDEx_Write_DMADoubleBuf1CpltCallback;% _+ z( u1 j, Y. p: m/ D
#if (USE_SD_TRANSCEIVER != 0U); A1 G0 y2 y+ J7 S/ Z
if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)" ~6 f) s; P, g+ k0 k
{
% H+ n; C- ~9 {7 ^- k0 I4 V
hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback;
) S9 L* F& Z4 H/ |: k
}
|! L" j/ X5 R8 M) N" _
#endif 0 |# m! m- _) l. m0 j: x8 X8 z8 o
0 R5 z+ Z5 _: N: Z. M2 F5 m
if(hsd->MspInitCallback == NULL)% [) M! A m p, h7 M& w: M( k" B
{0 h4 h: S" g8 `9 z0 e" D- f
hsd->MspInitCallback = HAL_SD_MspInit;
3 D$ X, r6 l' J0 |: U1 E
}
" H& `: ^& D+ i! E9 G1 i' q7 e
' @' ?7 I! R8 M/ c1 c. t& {* j
/* 初始化底层 */8 w1 g4 a! M) j( G2 ]7 ^* H
hsd->MspInitCallback(hsd);
0 T% z5 ^2 y7 J8 }3 o
#else/ U3 w& y: P& c3 U# ?
/* 初始化底层硬件 GPIO, CLOCK, CORTEX...etc */
. Y$ N/ F; [1 f( b# w u4 `
HAL_SD_MspInit(hsd);
( O. r+ R+ Q' Z/ ]4 e% g+ y5 p3 D3 x, q
#endif /* USE_HAL_SD_REGISTER_CALLBACKS */
* c4 d+ r5 h0 x
}( X! E0 T, W- u' ~( h
; l, o; a8 ?* z8 m
hsd->State = HAL_SD_STATE_BUSY;/ K# ]9 f( N. t
& N1 P# `3 R$ o5 S" x' r9 E. b
/* 初始化卡参数 */3 F/ ^1 e" D+ x8 \3 o6 a0 p; e
if (HAL_SD_InitCard(hsd) != HAL_OK)
# e6 \+ J1 ?+ ^" n( x0 i4 B
{ I4 w5 A* J3 l/ \" x+ O R! a
return HAL_ERROR;) b4 e: \* r& f$ Y" t3 I
}' z2 L4 P' K1 F( I: l2 }" ]
( W: ? A& y1 z: ]' k7 G# ~
if( HAL_SD_GetCardStatus(hsd, &CardStatus) != HAL_OK)3 h) y/ V) M9 g& ^# m
{" O3 h0 k' j# F
return HAL_ERROR;: T5 o/ M# @ f, R3 C* o! |
}) g& h+ Y% w6 x9 }( p) p1 s
/* 获取卡速度等信息 */9 M0 h' R' |* F& f n& R% e% ~+ d/ V; I
speedgrade = CardStatus.UhsSpeedGrade;
7 a- y) x Q$ ?1 P; ^
unitsize = CardStatus.UhsAllocationUnitSize;4 a9 [ `2 [$ o( |
if ((hsd->SdCard.CardType == CARD_SDHC_SDXC) && ((speedgrade != 0U) || (unitsize != 0U)))7 t8 V! o" }5 f0 E/ h
{
! F# V) t3 X& B: I+ p4 s
hsd->SdCard.CardSpeed = CARD_ULTRA_HIGH_SPEED;
' X5 B' j/ V& a4 a. t1 E
}$ `# B1 ^* l7 c8 Q1 A
else$ X; B/ a" ]. q5 d, ]+ j
{
% U, R1 C) p; A3 q9 K1 w
if (hsd->SdCard.CardType == CARD_SDHC_SDXC)' w+ U& t. u8 b# F( Z
{1 g9 I7 \' j* ]- x9 t, k
hsd->SdCard.CardSpeed = CARD_HIGH_SPEED;
3 ^7 _# P/ }8 k- u+ W% _ ?4 T
}
' Q$ m" }* S& \* Y
else
) {* q+ q/ y4 i5 N2 r) t, Z
{6 R; l* h/ D% y2 g0 h e( a
hsd->SdCard.CardSpeed = CARD_NORMAL_SPEED;8 i# S7 y/ B- y! e; @
}$ @0 k1 s7 m9 r; y, c5 \. F
0 N: w+ t" H, N% W+ i) h
}! Y, \0 g; X5 G$ H1 T0 z
/* 配置总线位宽 */
, ?* Z, M4 z5 i P' _
if(HAL_SD_ConfigWideBusOperation(hsd, hsd->Init.BusWide) != HAL_OK)
, d }5 [6 F' x" j
{
* o5 T+ X4 A# L. Z4 j; E
return HAL_ERROR;
5 `* @0 @. K* p4 Z
}7 J% S( p' f% e9 {6 R* d# r
! F6 |- L) h0 [" b; Z
/* 验证卡初始化后是否就绪 */* c% z; e1 h4 P! N+ C1 g5 D& V
tickstart = HAL_GetTick();
+ n1 N1 m( [" u/ f6 g" S. ^
while((HAL_SD_GetCardState(hsd) != HAL_SD_CARD_TRANSFER))
+ B, m5 i* T9 R
{
# H* F, D/ v6 }! [3 K- e# \3 m4 j
if((HAL_GetTick()-tickstart) >= SDMMC_DATATIMEOUT)
6 ^- H/ c3 I" P! W6 x
{3 a% a0 a+ L( B$ Z1 x
hsd->ErrorCode = HAL_SD_ERROR_TIMEOUT;
7 ^' c5 p5 V2 _8 d; D
hsd->State= HAL_SD_STATE_READY;
8 e5 c) Z5 Z0 w$ i: S% L! M
return HAL_TIMEOUT;
9 w& l- S' r' h2 _
}
. N) _* j. O- h* e& M3 g% j
}
7 _& ~! v# \( n5 d: S4 h
0 C8 [. _3 G9 Y! v! k/ j0 @9 d+ h" h
hsd->ErrorCode = HAL_SD_ERROR_NONE;3 l$ E, h; h6 C* V$ Z \1 l& d
4 ~( _, }& I- A# {$ B/ m1 w8 [
hsd->Context = SD_CONTEXT_NONE;4 f. ?* [! H" w! Z! @' ^
- o( a, [7 m+ [- I7 h
hsd->State = HAL_SD_STATE_READY; ?; G/ U1 i" m) l& X1 m' p
- K5 n* _0 c: J. n! R+ e
return HAL_OK;
6 d# N) b$ Q8 X1 Z3 v/ |
}

复制代码

函数描述：

此函数用于初始化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)7 F7 ?! X+ Y/ C3 s' {% Q
{9 y* A" d& s8 ` b
Error_Handler();
, I- @9 }/ a) H G( m/ L
}
+ ]( S+ I& c" k# y
if(HAL_SD_Init(&SdHandle) != HAL_OK), o% P C% `7 D
{9 b* z1 R( B. J
Error_Handler();
* q3 D( j" Z( Y& _7 d2 ~
}

复制代码

使用举例：

SD_HandleTypeDef uSdHandle;# Y6 {2 B1 M# F6 E; E: h5 \
* F) i [& U/ O$ F3 Q3 g
uSdHandle.Instance = SDMMC1;
" i+ l+ M6 d7 N, j
: l. v* a. u3 e0 C4 t+ }
/* if CLKDIV = 0 then SDMMC Clock frequency = SDMMC Kernel Clock
: @5 Z! e1 f: d5 z6 o8 t
else SDMMC Clock frequency = SDMMC Kernel Clock / [2 * CLKDIV].
+ X$ w& }/ @. p. l
200MHz / (2*2) = 50MHz: Q8 e( N) P$ i. Y
*/7 [/ V! V, b7 E) r2 j
uSdHandle.Init.ClockDiv = 2;
' e- x; y; k) t
uSdHandle.Init.ClockPowerSave = SDMMC_CLOCK_POWER_SAVE_DISABLE;
# S" w- ]( n. n% s' d6 y% b
uSdHandle.Init.ClockEdge = SDMMC_CLOCK_EDGE_RISING;
: j. e, l: X: X$ K* [
uSdHandle.Init.HardwareFlowControl = SDMMC_HARDWARE_FLOW_CONTROL_DISABLE;
: e; O2 {- C; t ^/ Z6 B9 p
uSdHandle.Init.BusWide = SDMMC_BUS_WIDE_4B;' Y7 J9 V$ f V* O& H6 q0 T
if(HAL_SD_Init(&uSdHandle) != HAL_OK)
; K: o5 t% N/ ?3 `7 r2 n2 Y/ G
{
2 a# r8 p e( k* m, _
sd_state = MSD_ERROR;1 Q; Q5 W' ?0 \9 }
}

复制代码

* i4 b# J+ Y3 g# Y. x
87.4.2 函数HAL_SD_DeInit
函数原型：

HAL_StatusTypeDef HAL_SD_DeInit(SD_HandleTypeDef *hsd)* d6 D! u6 z2 X8 e
{- U/ Y1 _0 t! |" F; }+ L# ~
/* 检查SD卡句柄是否有效 */% Y7 {2 `/ w+ A5 a) R; n2 M
if(hsd == NULL)
+ K( s& S4 |1 t
{
3 p9 q# z( C- D$ Y! R, N4 ^1 p
return HAL_ERROR;
) t& @: }4 t9 X* s( a' n) F& V
}
/ C- a- p, y9 G, |0 l
! D' L" ^- S* N3 |; Z6 G1 [9 K& ? f
/* 检查参数 */
. M7 N# Z) N% @& L
assert_param(IS_SDMMC_ALL_INSTANCE(hsd->Instance));: M$ y+ l2 m/ g# j# ?9 p4 f
: F. \# ]0 r2 f9 q# x1 Z
hsd->State = HAL_SD_STATE_BUSY;2 @1 |8 l' M( T" z8 j
* o( B0 w- X' N! W
#if (USE_SD_TRANSCEIVER != 0U)
1 @& c2 Z+ ] _( O4 n
/* 关闭1.8V模式 */4 W# b- |8 F% G% p7 o+ b
if (hsd->Init.TranceiverPresent == SDMMC_TRANSCEIVER_PRESENT)$ l6 b, y; F! r3 p* l
{
- s! S$ o; a* P- _, V8 G7 J1 f
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)5 ^" a' Z+ R E8 e
if(hsd->DriveTransceiver_1_8V_Callback == NULL)3 o# x# E, b+ ^- x: a
{0 G# L8 N) ^& B% N* }9 a
hsd->DriveTransceiver_1_8V_Callback = HAL_SD_DriveTransceiver_1_8V_Callback;1 E8 K4 z q4 ?; v
}$ S, X: r" _$ R
hsd->DriveTransceiver_1_8V_Callback(RESET);
( J0 r$ T5 k& G
#else
2 H) _# p3 Q# ~4 ?" v
HAL_SD_DriveTransceiver_1_8V_Callback(RESET);" @ d& ]) c0 G
#endif
. d, _# S- B& ~! e% a* T6 m3 x
} 2 g/ h/ M5 w6 Y w; ^
#endif
8 b+ n* g% `2 o! k8 Q& d( t
/ W( v" ~: j7 y( F
/* 关闭SD卡电源 */ c7 M7 }& J; D
SD_PowerOFF(hsd);2 X' p' A& O+ c T6 S$ [
( j' C; C! |3 U0 F! {! l9 v% r/ a k
#if defined (USE_HAL_SD_REGISTER_CALLBACKS) && (USE_HAL_SD_REGISTER_CALLBACKS == 1U)
. a& P$ _! I5 ]2 h5 F4 _; N, I
if(hsd->MspDeInitCallback == NULL)% F) W8 D. q/ @( Y9 P
{/ T6 r. q' ]) g* ?- q, {
hsd->MspDeInitCallback = HAL_SD_MspDeInit;/ K m0 A8 \! y3 Y& ?" Z' D
}
, w! i1 Q, s& [7 Z- U
: v6 v( r/ f; R V
/* 复位底层硬件 */9 t9 r3 i; w# \: @8 ]7 N
hsd->MspDeInitCallback(hsd);
6 J$ Q* f- W3 A# n
#else4 W; v1 i; S* i- V/ c. |, \ B3 S
/* 复位底层硬件 */9 [& U* S% e& B! P# \
HAL_SD_MspDeInit(hsd);( ^( z: X+ k% r, f( e% I
#endif & L) I) n. a- j
# P' j) k- ?: J5 y: i* P" y# E
hsd->ErrorCode = HAL_SD_ERROR_NONE;
; M% j3 a& \6 R
hsd->State = HAL_SD_STATE_RESET;8 S9 ~* I6 O# C- N3 M
- m) J6 d* H* |! d
return HAL_OK;
" E) `9 w8 z1 f' O" D( X
}

复制代码

函数描述：

用于复位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)
. m7 O# H5 N& p7 B$ l. B
{. b" D5 r5 }6 S1 b2 u
SDMMC_DataInitTypeDef config;
' G1 u9 h( h4 R, k$ J6 A( C/ ^; `% s
uint32_t errorstate;. G( I4 N6 E2 Y1 V& _' m' a7 ^) k) y# M
uint32_t tickstart = HAL_GetTick();1 Z ]9 D2 b) M, t# x" r
uint32_t count, data, dataremaining;# \- |& W- C' {8 R
uint32_t add = BlockAdd;
- a; q F9 H; V' T0 ^
uint8_t *tempbuff = pData;& Y& i) t# g! ]8 n1 c
$ h% @8 x+ v/ I, @1 R2 g ?2 ^* v0 E
if(NULL == pData)
! J$ D9 }, {) M9 o. i6 Y
{) m9 ^3 O, B5 G+ y) u z
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;% D0 @% V9 I! F' A# I% E% d3 G
return HAL_ERROR;
2 U% t3 A( o' E% k$ n9 J8 y6 t
}. G7 B2 g* {9 \0 V. ]! m; ^) L0 F& D N
( _- U0 G0 | r" r3 K9 F; i
if(hsd->State == HAL_SD_STATE_READY)
0 m( |, ~+ M6 D$ ~2 c
{
- G7 o' |% U; D1 ?& y* Q
hsd->ErrorCode = HAL_SD_ERROR_NONE;& C( y, ~- {/ u2 A7 e2 f3 Z
" ^* W# q- P' w2 M! U. B
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
2 q& l2 C5 ~, P* g
{
+ z2 S* j( g3 d+ G4 W. C8 e$ _
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
7 Z$ v8 }* m" Y+ C$ ~
return HAL_ERROR;0 c, l/ N+ o: f
}
4 Y/ s5 G5 k; Q! i. ]4 r- g: h
$ W2 Z: t" A$ S2 N1 C& t
hsd->State = HAL_SD_STATE_BUSY;
" T# z0 q# p' H, v
( G; x: [" @0 |' |2 ?3 d0 K7 h2 S
/* 初始化数据控制寄存器 */
. @( m& |: }6 {% n2 M- O
hsd->Instance->DCTRL = 0U;
- }3 R; @: r6 K% u, T/ I
3 C2 r& _, ]7 M9 N/ q$ m
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)9 F9 ]7 A3 ~0 Q
{& e |# t8 b* x. f! c5 O$ E6 S
add *= 512U;4 |; V2 m9 X0 f, ]8 Z7 `. D
}
0 C6 p0 m" J8 x; F3 E8 f
$ @5 P* @ V; d2 M' N
/* 配置SD DPSM (Data Path State Machine) */1 g$ i' T9 p/ ~7 B( _. R7 W
config.DataTimeOut = SDMMC_DATATIMEOUT;
. T3 h* D/ h( j1 h
config.DataLength = NumberOfBlocks * BLOCKSIZE;& ]& l% k% o/ R* u8 X9 E
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
2 B) W# }" l# O
config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;, s! E: a( }- o1 P
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;6 F. Q& X0 f9 ?* j% W x
config.DPSM = SDMMC_DPSM_DISABLE;/ ?0 {9 \* ^5 z( X8 f+ r+ t
(void)SDMMC_ConfigData(hsd->Instance, &config);
, J+ j% y# y$ V) Q& L/ h# V
__SDMMC_CMDTRANS_ENABLE( hsd->Instance); [1 [# I' G Z) F
d! }. Z. v; G( n; i7 U2 f
/* 查询方式块读取 */ w* A( H/ B( M- r3 S y0 S; K
if(NumberOfBlocks > 1U)5 x: Q0 e* O" h; J$ h
{' S. z& r5 }2 k) l q) x# n
hsd->Context = SD_CONTEXT_READ_MULTIPLE_BLOCK;; e) N n$ q l$ @ E
! k5 }( Y8 E @1 z G
/* 多块读取命令 */8 F: o) h2 H5 }! N# g2 _
errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
% E4 B/ z2 ?: @* |+ F) M
}- X0 B: c' c$ N8 h; N0 l
else
4 r4 f0 I5 J1 A7 b, L
{
! ~5 g+ }2 v8 D, n9 @2 s0 R8 R3 P0 v
hsd->Context = SD_CONTEXT_READ_SINGLE_BLOCK;% H4 W2 ]- Z. ?; E+ |$ D
& @9 y6 n# U3 w* g, b: b0 K
/* 单块读取命令 */
m# t- g1 V$ M: n& X
errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);. n+ f( d7 X' m7 E) a# ]
}
l( D) ?" e$ q
if(errorstate != HAL_SD_ERROR_NONE)" Z' |% P. B; Y% o
{
" t2 }) q/ f+ Y, r
/* 清除所有静态标志 */
4 z( K5 N( w) b3 y( s$ d6 M
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);- y7 ]: k8 n1 D6 Q9 }, i* ?7 t
hsd->ErrorCode |= errorstate;$ d( H& p6 U& J3 S2 D5 ]
hsd->State = HAL_SD_STATE_READY;
/ g+ I( k5 V1 ?
hsd->Context = SD_CONTEXT_NONE;
* u9 \2 f7 k4 C
return HAL_ERROR;4 {4 q/ k/ d# \( i R6 h1 b
}
/ E$ S8 E* _# C) c+ ^
" Y% f5 a6 P8 H! o, H/ }
/* 查询SDMMC标志 */% k* h$ |% ~1 B7 D: }
dataremaining = config.DataLength;
9 D9 \/ x. n: Y; P4 w5 R4 W% n
while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))# K% w/ g+ w' X' S' Y
{2 X- C0 m8 T+ i# Y! n
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXFIFOHF) && (dataremaining >= 32U))
; Q+ \; V. j- g' s8 A1 D4 ?: S
{% q- o4 F0 y% x4 [. M
/* 从SDMMC Rx FIFO读取数据 */ a9 @# v4 F! H7 J+ E
for(count = 0U; count < 8U; count++)* B9 H* _, P+ V& Y$ x, g" n
{
& r5 ]1 W! f. G! f5 V/ H
data = SDMMC_ReadFIFO(hsd->Instance);, I) q b" h" G. Y
*tempbuff = (uint8_t)(data & 0xFFU);5 y, z) A3 g9 r" e- Z
tempbuff++;
* \/ z# k1 m# O3 h8 H( S
*tempbuff = (uint8_t)((data >> 8U) & 0xFFU);, s0 Z! B& p' a! S# {
tempbuff++;' E5 e/ L1 F3 j
*tempbuff = (uint8_t)((data >> 16U) & 0xFFU);
5 p1 G2 [6 g/ o# \ P- B
tempbuff++;
/ x( U7 `; \" P/ B$ r3 E3 U' A
*tempbuff = (uint8_t)((data >> 24U) & 0xFFU);# [, d, Q3 @" o5 |5 d
tempbuff++;
* X, X! [* y# W+ d* @3 t' s
}
! I( y1 I, ]/ I8 R M" M! V" O b
dataremaining -= 32U;/ v h8 H9 A' L; n1 S- @& R
}9 @' i. [6 m$ o6 r
9 _, |4 n" T0 u; M4 [+ {" R4 g
if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))
! j- r0 v* g5 R/ [3 p9 k" g
{
) C7 ^6 ~+ i! g$ W
/* 清除所有静态标志 */* U6 O- N( T& f8 {
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);8 ^% @, X: e+ \3 V* l
hsd->ErrorCode |= HAL_SD_ERROR_TIMEOUT;
3 P5 _) S, W# E) {% T
hsd->State= HAL_SD_STATE_READY;
9 s) k+ j/ K6 }4 o$ ` m( z
hsd->Context = SD_CONTEXT_NONE;
k1 H: D6 W. L
return HAL_TIMEOUT;
1 M) u; R* b. G2 X; @
}
& N s* P2 d5 R
}$ V0 F: D( f' I( E+ x( }! Z* P$ P0 X
__SDMMC_CMDTRANS_DISABLE( hsd->Instance);
' U% G6 [) D4 Z% i$ ~ ^0 O
2 @6 r2 b/ T2 t: L% [
/* 多块读取发送停止传输命令 */
+ F1 K5 ~9 K2 Q9 d2 L3 |
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U))$ o- E" f# d7 T
{
# y$ S8 P% j" T$ Y" {' o* Y
if(hsd->SdCard.CardType != CARD_SECURED). z/ D- D: ?* N: D" Q
{$ A, J2 {" M: b8 d" Y. K
/* 发送停止传输命令 */
7 O- q1 O7 ^# J/ q+ } x6 P
errorstate = SDMMC_CmdStopTransfer(hsd->Instance);8 R4 M2 t# n8 R5 w& |. @
if(errorstate != HAL_SD_ERROR_NONE)( }0 l; P! z$ {2 p# e% ~0 |4 M* m
{
2 C# d$ v2 E2 Y+ `& S5 f/ N" D
/* 清除所有静态标志 */6 j1 z4 g( M- Q3 A
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);: N- M0 a- W! x) R% V
hsd->ErrorCode |= errorstate;
# A3 b$ a# ]& T& l9 E
hsd->State = HAL_SD_STATE_READY;3 I' d, d4 B3 U& @9 i
hsd->Context = SD_CONTEXT_NONE;
d! A6 p3 f& q. W, p- Y1 C3 O
return HAL_ERROR;
9 Q9 b. i" {6 o, L
}' w% q& A# S+ ]' H: f8 f9 |
}1 u0 `# c: {1 _! b# ^
}
5 k1 L3 l, O F( ~6 q
$ F4 B+ j5 t6 q% b2 i
/* 获取错误状态 */' T% P5 w; x6 K! D+ J3 m
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))/ S. L( E$ l5 l0 {" Q6 W
{/ L( F+ A$ u2 M! F3 m
/* 清除所有静态标志 */
0 ?% b$ Y& f8 W
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
3 g% x8 l. h8 N. S; ^3 P6 c0 O: c
hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
7 e" |) p. a& R3 N2 t. r
hsd->State = HAL_SD_STATE_READY;$ E& h* u7 e) A$ v3 V
hsd->Context = SD_CONTEXT_NONE;9 I% F! e% { ]) a' \
return HAL_ERROR;
7 N# s; h6 q8 P9 Z! W
}
/ O6 h6 N' _2 j x( \
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))* N1 m9 e% ?' b4 H6 f5 ?
{3 ?0 Z8 f: s) R4 A6 E3 I
/* 清除所有静态标志 */
3 h3 y# R+ g) B! Y; ~
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);: u2 ^6 ^5 d0 i# C {9 z
hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;: p. O+ D% f" n- P d- T
hsd->State = HAL_SD_STATE_READY;0 T) x. f: {7 C. U% R' h3 j
hsd->Context = SD_CONTEXT_NONE;0 f: X0 [5 L6 I) W& v6 G. _8 w- m
return HAL_ERROR;% t% _# v* }$ V r$ s) g9 |6 A
}
. P e9 c" p) X* r+ X$ e% P
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_RXOVERR))
, q, m# k- W# e* ^: I7 z! J/ d0 r
{. [ K( p0 ]; `) _! y
/* 清除所有静态标志 */' Z* q( n% O; d7 r
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
' ]! B, I3 H( q2 |5 Q
hsd->ErrorCode |= HAL_SD_ERROR_RX_OVERRUN;, c! c" G$ F/ o- f* U
hsd->State = HAL_SD_STATE_READY;
& D" R( ?0 F. x1 S' X$ T
hsd->Context = SD_CONTEXT_NONE;
* y7 I# h5 H; Z" O
return HAL_ERROR;5 C4 d9 Y8 Q7 j2 P) B, `, g7 C4 D
}, s6 b$ E$ [. o2 m) S
else: B* Q1 I3 [5 H4 `% H( I1 W
{
+ u2 K" I1 D8 I$ q5 s
/* 什么都不做 */! x+ t ]5 i9 t' x) `3 F1 J Z8 }0 `
}
$ c- o' K& P" o: W, B$ `
' ]6 T0 G6 I# w; R$ M
/* 清除所有静态标志 */
8 L! q( _ ?. v: C
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
9 a ~' p5 s# m
2 Q# E' |1 K/ J
hsd->State = HAL_SD_STATE_READY;/ A G$ h) y7 ~9 d- c; v
& ?! @# |$ x5 ^5 R
return HAL_OK;$ e' @6 f$ y" i7 ], C& w' f9 n& P
}, a2 V& Q1 K) L
else+ t. S- U$ l1 Q
{
# v- B; i& M$ D# K# N! @
hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
, {) L7 C; t- \' |" B; x
return HAL_ERROR;
" I/ J5 v" Q/ |; r/ C
}& W& Q4 Z; w" k# W+ l
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**
/ q+ s: k. s5 ]: U2 D- N2 F
* @brief Reads block(s) from a specified address in an SD card, in polling mode.
1 @5 l+ \0 y* U) D
* @param pData: Pointer to the buffer that will contain the data to transmit0 s: p8 O; |* T% A/ y6 g$ ^
* @param ReadAddr: Address from where data is to be read& U0 w* ^0 V, L g, i2 C; M
* @param NumOfBlocks: Number of SD blocks to read
" j% P1 _/ p' A5 H
* @param Timeout: Timeout for read operation
7 D f; G1 w- J7 B
* @retval SD status) f/ V; U7 w$ Z7 a
*/1 I8 p$ S" m" x# d- d
uint8_t BSP_SD_ReadBlocks(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks, uint32_t Timeout)
+ X3 r, L$ o2 j# a) v, q( h% [9 y7 X
{
+ }/ o: W6 d& G9 J
4 X5 i) x, |* U3 A% r5 M8 P6 p$ m$ m
if( HAL_SD_ReadBlocks(&uSdHandle, (uint8_t *)pData, ReadAddr, NumOfBlocks, Timeout) == HAL_OK)
$ y0 K7 @5 F4 \
{( h& M! f( g: M8 `5 z; g
return MSD_OK;
/ q3 z" k6 U* q4 J' m
}7 b' s) l7 P% Q+ J
else
% [9 ]9 Q$ }$ x' Y
{5 L$ R, K2 G) B8 X/ p
return MSD_ERROR;
: S0 \$ W6 A Z2 w
}. W$ o7 ]+ ~; j: C
( f1 M! I1 T$ ~
}

复制代码

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)% q& K2 n% |& A& r j
{
" o, h. Q, d9 j u: \/ E
SDMMC_DataInitTypeDef config;
: F+ d0 h( e6 B% |9 G
uint32_t errorstate;
9 P- K) y: [7 X. E7 ]
uint32_t tickstart = HAL_GetTick();! Q# z5 G% u o, f2 F/ \
uint32_t count, data, dataremaining;+ ~" B; B9 J/ o( T
uint32_t add = BlockAdd;
# X, q/ G# B6 [# u0 U" N
uint8_t *tempbuff = pData;* N: x% Z7 L' u/ Q/ j( ?7 w% A
4 o3 b# T, {4 @% V; a% g& }
if(NULL == pData)0 b8 D% _' ~, h
{3 x! B3 t7 s4 @
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
* x0 \; |# u' w) E" i
return HAL_ERROR;, ^" n3 X4 I8 @
}/ n* g& T+ j! l- ]! q. n5 e5 Y
. a$ o- G j' t! r1 u
if(hsd->State == HAL_SD_STATE_READY)8 d' b0 K+ g- h6 Q$ X( W
{6 h* ]! `) m) {2 G) Q9 v2 l
hsd->ErrorCode = HAL_SD_ERROR_NONE;2 G& ^1 {. Y' t4 A5 S
9 \$ } y5 r) J# U5 k7 z; l# k
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
+ a6 c$ E/ _# \0 w' w/ p
{
/ w; l9 n4 B7 B' f& q+ F
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
% H: C: L2 c. ?$ K, k
return HAL_ERROR;* Y! R' a" {% }' d' p: L4 u1 C
}! z' j/ @ m- z, V+ X" O& D
% R6 i2 |2 v3 N) V# {6 I
hsd->State = HAL_SD_STATE_BUSY;0 k7 U4 Y) ?+ H! f4 `0 x. X r
1 h' \0 I6 V6 |' m) U
/* 初始化数据控制寄存器 */* h, K, ]4 O+ h8 Y
hsd->Instance->DCTRL = 0U;
1 T6 H. \+ ?& k& ?- M' }
# v- [& g3 d+ V3 q' Z% a
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)! P; J- Z) ?! l% k" ^
{1 Q H& @' k' \7 F
add *= 512U;
; v U* T+ ^9 O# y' c
}
6 R, ^* p7 J# G/ E. Z$ t/ L
& p2 j6 A) R1 E( A% o& ]
/* 配置SD DPSM */
4 ~9 j3 ]* `$ d( x5 y& {) }' b$ ~& \
config.DataTimeOut = SDMMC_DATATIMEOUT;
7 y% m( Y5 P0 t
config.DataLength = NumberOfBlocks * BLOCKSIZE;
! q3 q+ E+ J% k7 Y' F
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;: T, v+ D6 z6 C5 S+ K% {. m
config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;7 @% E% E* Z/ k) Y6 W1 \
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
1 B# b, p" Z: a4 J: k) p
config.DPSM = SDMMC_DPSM_DISABLE;
; R* u) f( @, y
(void)SDMMC_ConfigData(hsd->Instance, &config);, w7 ~' a. P9 S' F1 Y
__SDMMC_CMDTRANS_ENABLE( hsd->Instance);
{; W" ?+ q$ s; ]2 w
9 w' O$ S: m$ U% Z& @4 j
/* 查询方式块写操作 */ e" P+ b6 C6 W! J/ R3 `% z" H5 @
if(NumberOfBlocks > 1U)
/ ?0 N$ Y5 J2 T+ E d+ ?1 L3 p) [
{
, n1 L8 D3 M$ K' c- ]8 Q
hsd->Context = SD_CONTEXT_WRITE_MULTIPLE_BLOCK;
: ~$ a3 P Y u& m5 {3 S, h" j
1 I0 z6 A j4 u
/* 写多块命令 */) x4 t0 s F I- I
errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
$ [0 E4 j7 h& Z
}4 n% J- ~: \0 C, }0 o- L
else& J$ D8 }" x* Y$ d; J; D( M' E! {
{
" C9 F7 b3 ]0 g. \' k/ F M
hsd->Context = SD_CONTEXT_WRITE_SINGLE_BLOCK;
- j8 W+ {# i' V/ }3 w5 P
1 @7 i4 j% a5 o0 @/ l
/* 写单块命令 */
! L. h. B+ ?7 v; |. b7 U! I! k
errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);
' o! [; G. S( s- u
}
/ w& }8 e! R; L w
if(errorstate != HAL_SD_ERROR_NONE)
1 j8 K; _# z+ [/ v: a P" `) U
{
7 ?4 _, t, q' r; {1 W6 Q
/* 清除所有静态命令 */5 h. q7 }& g9 k: |5 J
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
6 ]" g: m1 l4 K7 |+ B
hsd->ErrorCode |= errorstate;# N* i" j$ X! ]
hsd->State = HAL_SD_STATE_READY;
. k$ f4 n" b' D2 j( C
hsd->Context = SD_CONTEXT_NONE;
1 C) C6 {# C! m- `# U( j2 a
return HAL_ERROR;! A) y5 a; C/ q; [) r% g
}
' X6 c& \/ k* ]; ~" I
' U9 V# ^1 ~1 d3 b: n
/* 查询方式块写操作 */% K; i' l3 c P( y/ m+ ~( F: F
dataremaining = config.DataLength;' n! p# L9 H( e% z$ R
while(!__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR | SDMMC_FLAG_DCRCFAIL | SDMMC_FLAG_DTIMEOUT | SDMMC_FLAG_DATAEND))
5 a3 Q* o* F' u2 I7 F' A
{6 f, e2 [" B6 d. `9 \, G% a6 n
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXFIFOHE) && (dataremaining >= 32U))
! b u+ H! m4 E+ C# ]3 ^$ [
{
7 D C. g6 u5 {
/* 写数据到SDMMC Tx FIFO */
6 A5 g4 q; x6 c! C9 k% z1 F/ V- ^+ |
for(count = 0U; count < 8U; count++): B( d+ l0 V" K0 s. B! H7 @
{
4 O1 ?' a$ T1 B z) N2 Q) J
data = (uint32_t)(*tempbuff);
+ E6 }: n! s" ~1 i, G) V
tempbuff++;0 Q! A0 q. ~# j# V
data |= ((uint32_t)(*tempbuff) << 8U);
9 p3 l2 K% A; g) B* e( y9 w
tempbuff++;; F% J8 K9 a7 J1 Y1 K6 {! _; F% p
data |= ((uint32_t)(*tempbuff) << 16U);" c* n0 D+ o b) |) [
tempbuff++;
9 `. `) B5 z: p* F( j: K
data |= ((uint32_t)(*tempbuff) << 24U);
5 d1 ^( ]2 W) Z3 I
tempbuff++;
( y' B b/ G/ a2 T& c
(void)SDMMC_WriteFIFO(hsd->Instance, &data);
- y8 k- q( i( V" C6 _
}# @# a7 A2 G6 h. J% y: v: `
dataremaining -= 32U;
& T% d6 a! ~0 U. [; m
}
, t# A5 {+ E3 F
+ G4 p& o6 |2 }) N% T
if(((HAL_GetTick()-tickstart) >= Timeout) || (Timeout == 0U))! f% H" q7 o% b) e5 u+ B
{. d& L1 a; W2 k
/* 清除所有静态标志 */
" S3 A p1 h3 p. }- F& K6 w' {
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);) S0 q6 O0 m' y! M
hsd->ErrorCode |= errorstate;
( @* E8 N+ h, a+ o- I' M* r' q; r
hsd->State = HAL_SD_STATE_READY;
0 N) b+ a; ?8 ]$ N
hsd->Context = SD_CONTEXT_NONE;! s4 W8 n8 {2 l% ]; ^3 v
return HAL_TIMEOUT;/ g+ s! d9 X! ~; Z
}# ?6 C& A5 t- e$ y
}
. h8 v+ o/ W0 |$ t% L, k6 R' k
__SDMMC_CMDTRANS_DISABLE( hsd->Instance);
1 h! D$ D" ^& |; M+ @
8 x1 T' g3 L1 J( b$ _& q5 t$ h
/* 多块写操作，发送停止传输命令 */0 v' [# L# q7 b
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DATAEND) && (NumberOfBlocks > 1U))
$ o8 Z& p/ W# Z
{
; Q, R$ e8 q. h5 ]. h( ]
if(hsd->SdCard.CardType != CARD_SECURED)& W* x: o" r1 T& F' Y) U+ ^9 B
{; D, s& L, e2 L
/* 发送停止传输命令 */
$ |% V: h E) A: _! z8 m1 V
errorstate = SDMMC_CmdStopTransfer(hsd->Instance);
! @" ?+ ?# d3 U
if(errorstate != HAL_SD_ERROR_NONE)! n* `5 \9 n( ]+ A, h6 g( L
{; O. Q% A# ^ k7 j$ d
/* 清除所有静态传输标志 */$ [7 g7 G6 w) O" R" N5 A
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
0 q* H- @: T7 L3 I/ W4 U
hsd->ErrorCode |= errorstate;
6 } |: V0 S3 n- u; M, }' A
hsd->State = HAL_SD_STATE_READY;
3 z( x0 S/ |" W/ u
hsd->Context = SD_CONTEXT_NONE;, m; m: P+ I/ Z1 n# Z
return HAL_ERROR;+ I O8 I! H4 d( F: G
}
( z/ b8 X. J& Y) ?2 x
}
5 [1 ~2 v+ w9 {
}
1 p" X$ V: \5 ]) f$ L, K; a5 r
# N- N+ L0 S. G
/* Get error state */
/ ]& S( I0 q- t! a
if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DTIMEOUT))* @, j* o8 W+ }" w6 H
{' Y1 Z0 O1 { h# M9 y* Z0 F
/* 清除所有静态传输标志 */
7 d: K' p1 w7 n; K% U/ l$ Z# E0 q1 k
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);1 @( i' y, B( o) I& u5 ~5 s
hsd->ErrorCode |= HAL_SD_ERROR_DATA_TIMEOUT;
: S6 j; Z1 s4 i6 ~4 c
hsd->State = HAL_SD_STATE_READY;
( j N5 q6 V: Y4 M1 V
hsd->Context = SD_CONTEXT_NONE;
# ^2 c8 c! L. D0 m3 m
return HAL_ERROR;) p, f# T; \* Y* G
}
7 L1 y5 P5 s( Q4 O6 o( m
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_DCRCFAIL))
7 n! F# b7 I1 l
{/ Q0 w A. x2 Z; q3 I( Y
/* 清除所有静态传输标志 */! [* T: x+ t0 g1 [6 a5 C) n0 c
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS); I8 v- K9 i4 N" z J
hsd->ErrorCode |= HAL_SD_ERROR_DATA_CRC_FAIL;$ k' A8 `# _/ }0 A% P
hsd->State = HAL_SD_STATE_READY;2 N6 d& |# d ]& c0 V8 F/ s
hsd->Context = SD_CONTEXT_NONE;: b1 o5 p+ p8 H3 h
return HAL_ERROR;- r6 J1 b0 K: T0 I2 N- r+ m) K
}
& ^: Y* r+ }: B; D! E0 n1 c) r- Y
else if(__HAL_SD_GET_FLAG(hsd, SDMMC_FLAG_TXUNDERR))
1 O. P7 h- Y+ L6 E. q5 n6 u4 Z
{3 a4 p- I {* f9 W, T3 T
/* 清除所有静态传输标志 */ u( r" O# `' `1 i- F: @4 d' i
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
- |% Z5 o! u# S: W) Z2 P
hsd->ErrorCode |= HAL_SD_ERROR_TX_UNDERRUN;, s3 s4 d7 k$ F1 m
hsd->State = HAL_SD_STATE_READY;: s( q; l( o0 ~9 E" ^; Y
hsd->Context = SD_CONTEXT_NONE;
' O* E4 y3 \7 K# d3 O: {8 A" |
return HAL_ERROR;
/ [6 u, ^5 O0 b9 ? j) C
}+ C8 }2 w+ a1 i5 q! K; n! F9 b* C
else
9 M+ x8 e9 J4 R( ?
{
1 V& X$ z' W5 w6 \/ C3 ~# H
/* 什么都不做 */8 x6 {% {% }4 O- l1 b
}" u& A- a9 {/ ~" d
1 O; T) E" C# f5 q
/* 清除所有静态传输标志 */
8 ]& s( {$ \- \: A3 h
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_DATA_FLAGS);
& X( B1 i" k7 h9 P* [
7 W; Z! J7 @) f7 N. P+ h" o
hsd->State = HAL_SD_STATE_READY;
$ Z9 ~2 M3 J$ A6 t$ \0 }3 m7 N
4 d! r$ x$ z6 Z- W0 B: I
return HAL_OK;; V' e) y; \# s" a+ E- z* u
}
+ k7 U: r8 z+ H) R2 m# U2 x, _
else# I5 m1 G; F& _. N) X1 d
{ W* n l: `, H/ a a& x3 K2 j
hsd->ErrorCode |= HAL_SD_ERROR_BUSY;
6 }# m7 ^, N! f: O
return HAL_ERROR;( c" i U0 E$ [' ?/ I# L
}
2 }7 \# R. p* h0 V
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**( q2 d$ D7 N% M6 F) F3 H; J
* @brief Writes block(s) to a specified address in an SD card, in polling mode.
, y1 H% v1 ~. k" `: F% U
* @param pData: Pointer to the buffer that will contain the data to transmit
% `& H9 K0 J2 G; ?- R6 H1 _
* @param WriteAddr: Address from where data is to be written
" s# C5 N B* ]
* @param NumOfBlocks: Number of SD blocks to write
) [, v/ V1 |% V o
* @param Timeout: Timeout for write operation& `1 c! h1 g+ b5 }% b7 @
* @retval SD status
1 f7 {/ k3 |) X( C7 Y7 v
*/' [# K+ f2 ~' @5 G) L2 l9 D& T
uint8_t BSP_SD_WriteBlocks(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks, uint32_t Timeout)5 t* B/ ?: Z+ Y: P( w
{
4 I( ?( b& g4 Z1 n
: n4 f$ @, z% d/ w/ U6 j; e$ ~
if( HAL_SD_WriteBlocks(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks, Timeout) == HAL_OK)
9 i1 W$ L4 W) N9 |: k7 T5 Z
{
- o; z/ g H6 e; F& i
return MSD_OK;
/ b: m" k+ P. |- Y* R2 Z1 ]
}: q, i$ P) N( i2 c- u4 o) n
else
4 D7 k% r+ [2 C& p& d% _
{
0 d8 @# _4 C; ^8 j$ M
return MSD_ERROR;9 L( m+ {/ m, T. F
}
# \# b/ k4 r$ t8 x
}

复制代码

+ ? [: y {7 e* ]' O- [87.4.5 函数HAL_SD_ReadBlocks_DMA
函数原型：

HAL_StatusTypeDef HAL_SD_ReadBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, uint32_t BlockAdd, uint32_t NumberOfBlocks)
) a& g+ U* o5 |* O% Q
{
7 ^* @0 _) N% n6 f" U2 x
SDMMC_DataInitTypeDef config;
1 r. Q4 q# `! Q% x' [" @) c
uint32_t errorstate;/ m- V( f+ n+ _7 T' u) @ M
uint32_t add = BlockAdd;
4 J" p% {' \5 s' Y: l* F; @& b
6 L4 ^& @3 B8 |" ?8 h5 Z6 A0 `
if(NULL == pData)( p) F& C. ^, p
{2 E0 @+ g5 q7 m3 F7 c
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
9 X1 }# K2 ^* n& o: t! \! Z# E# `
return HAL_ERROR;
+ B6 C& s+ j; d- {2 p& c% g
}
4 Y( J1 w4 q; J9 p
- _+ `7 I/ @* y8 `7 P! _; J
if(hsd->State == HAL_SD_STATE_READY)
" H9 t' Y5 T; n4 W- m* m9 m
{
# {$ R. L! @$ e( w6 X4 ~
hsd->ErrorCode = HAL_SD_ERROR_NONE;1 i6 w8 B& {/ k* e
0 u: ^( ]! y) @3 K# B. z
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
; r. `8 z E$ Y" `
{& z( g7 Q; G1 f/ Z7 C3 {
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;# L! S. q) \' Q
return HAL_ERROR;
4 P4 C' T: r8 i; Z
}
2 Z+ U! F: d, F
" I) N2 O. r0 }- B5 n
hsd->State = HAL_SD_STATE_BUSY;
# v+ d7 k; t1 q5 x( t4 |# p0 |. g$ E0 F
3 n2 E: t8 k' k/ T0 x8 W% v
/* 初始化数据控制寄存器 */) [- y# x s$ K
hsd->Instance->DCTRL = 0U;$ c5 P8 h. l3 s& j3 L1 k
& A# Y6 O5 G4 q- a
hsd->pRxBuffPtr = pData;) p/ b4 l" W) i$ q% q
hsd->RxXferSize = BLOCKSIZE * NumberOfBlocks;
' Y( ?3 o$ R" o
/ u E' A* V2 @9 L0 N, v' ]. \
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)/ _. R: E% f" d- J. s
{
- ~: }5 U1 @$ [; z
add *= 512U;
8 p0 |: K4 ]) G3 }7 f4 s
}# L5 a# F. z' W
( u8 D' V5 E8 r0 `
/* 配置SD DPSM (Data Path State Machine) */
! s6 x" F; Q" e' P8 f6 P- @
config.DataTimeOut = SDMMC_DATATIMEOUT;
8 j" b6 r; E5 ^+ u: b v! c7 g+ f# i
config.DataLength = BLOCKSIZE * NumberOfBlocks;! f' [6 Q* o4 M
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
( ^: I5 j. j8 u0 ~
config.TransferDir = SDMMC_TRANSFER_DIR_TO_SDMMC;4 H7 U4 P6 H/ _! G
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
5 C$ {! W- g2 f% E
config.DPSM = SDMMC_DPSM_DISABLE;- [0 U' C; \* Z1 S, S9 r+ N; Z: g
(void)SDMMC_ConfigData(hsd->Instance, &config);7 d/ F8 U3 z- k; {( D, m6 l# m8 t6 C$ q4 @
. G; A( d7 n1 O
__SDMMC_CMDTRANS_ENABLE( hsd->Instance);
; h- Z/ ?' J6 g, [
hsd->Instance->IDMABASE0 = (uint32_t) pData ;/ a: c# Z+ A' D" _% N
hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF;" f# M* l, a2 `& R3 ~5 s* K: o1 o
8 y+ j, u) S8 G% W/ n+ P1 b
/* DMA方式读取多个块 */
2 H9 g! `3 ]' k$ g
if(NumberOfBlocks > 1U)
3 Y7 C+ M4 i- @$ ?: r# f% B, l
{+ H2 Q' S, U( M' U( S2 A
hsd->Context = (SD_CONTEXT_READ_MULTIPLE_BLOCK | SD_CONTEXT_DMA);
% l4 D1 h! K2 d
, ^; p4 `6 i( j. H; w* U- x$ L1 b: ~3 ~
/* DMA方式读取多块命令 */
; f) h% d( T9 [: u8 F
errorstate = SDMMC_CmdReadMultiBlock(hsd->Instance, add);
; s7 Y; W5 X0 a% |% j; t
}" B) j) A O9 i l2 \
else
6 N6 O8 ]% `2 k- o
{
( o4 f, y# o) v5 A4 ?- ]
hsd->Context = (SD_CONTEXT_READ_SINGLE_BLOCK | SD_CONTEXT_DMA);; G9 e ` Z1 r9 u# b
$ k* f. M/ I2 n! K
/* 读取单块命令 */# [7 i" X. l- C2 Y: {0 K: Q4 g
errorstate = SDMMC_CmdReadSingleBlock(hsd->Instance, add);3 W& {% O( n5 D# I' T5 H# |
}
+ [# k- \ C B
if(errorstate != HAL_SD_ERROR_NONE)) ]: W0 ^; Z2 S3 ]( Z* }- ^7 ?; a3 V
{$ R+ `7 m, C# M [$ w
/* 清除所有静态标志 */$ _% `, E- P7 `0 x$ p7 d
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);$ _! j' l$ E( b2 L7 N# Z7 i% i
hsd->ErrorCode |= errorstate;& {5 l% B6 H! O5 q
hsd->State = HAL_SD_STATE_READY;; m. N/ x$ o% Z8 ~& E$ J
hsd->Context = SD_CONTEXT_NONE;
- c$ t" U' x/ h8 G
return HAL_ERROR;/ c4 ]9 }% P+ S1 I. U
}
- u( u7 s8 H0 m9 w1 W
1 s; `6 F$ {$ K4 m0 O; {) v
/* 使能传输中断 */. K. H( Q6 n( Z0 x% \9 I
__HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_RXOVERR | SDMMC_IT_DATAEND));2 W2 ]4 J9 M0 l1 y9 m1 R! ^
7 V0 ^/ n4 h6 ~7 Q' R
1 m, Z4 Y0 U8 J6 O( ?
return HAL_OK;
_2 h" S9 X# k
}
% S, F, k, A7 e) n" }4 H
else/ q( q& g* [3 F; \3 U
{- i; c" a! C3 t1 @5 E4 T3 i! p
return HAL_BUSY;' D: V; N- b* I& ]+ x
}, X9 b c& K5 i9 w
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**
6 p1 |2 M3 C( t1 y g8 Q f
* @brief Reads block(s) from a specified address in an SD card, in DMA mode.: P' A* s9 R6 J, R
* @param pData: Pointer to the buffer that will contain the data to transmit
O) k$ J! @5 @$ a- s
* @param ReadAddr: Address from where data is to be read" V0 X# @9 ^* P
* @param NumOfBlocks: Number of SD blocks to read/ t& a- A" G/ `& R. e# R
* @retval SD status% J8 [, G8 @% H, L8 Q% u
*/
7 c# T) E! K x9 q* \$ Q
uint8_t BSP_SD_ReadBlocks_DMA(uint32_t *pData, uint32_t ReadAddr, uint32_t NumOfBlocks)
" n( R$ z7 M) |, o6 H+ N
{" Z- q( P" v3 I' x" d6 Q `
" F2 {; f5 P& a1 f5 E. Z! W$ f2 P
if( HAL_SD_ReadBlocks_DMA(&uSdHandle, (uint8_t *)pData, ReadAddr, NumOfBlocks) == HAL_OK)9 G5 a8 }5 r# {
{
+ I7 K% l w2 f; n
return MSD_OK;
6 u8 ?1 \$ D4 x% i- i
}+ P5 w* p8 r; v. _8 X0 x
else
, x# o6 X/ S4 h
{9 K2 C" c5 i2 n
return MSD_ERROR;
' x7 D ~) b5 Y# ^; d
}
) f% [7 x4 R9 Z( t" w) B N
}

复制代码

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)$ I$ z' Z+ J- p0 p/ w6 [
{
. j z: M* G' [) ^+ `; u
SDMMC_DataInitTypeDef config;1 W' I* p, z0 |; R
uint32_t errorstate;# W* l0 X; Q# g% X* g- L
uint32_t add = BlockAdd;2 q4 s! g c/ W7 x
# C( U" H8 p& I& S
if(NULL == pData) G6 p4 E1 Z# H8 S+ x$ g) T: t" @1 e
{
6 N' g9 X' y2 x* ~1 l
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
, [7 U4 t$ w* F' t6 v2 g) ?- H f
return HAL_ERROR;
4 U6 S# T! j6 s6 |
}
! b. L7 @) o- p
' j0 t" ^; t, H# W5 a+ v3 r
if(hsd->State == HAL_SD_STATE_READY)6 F- g! U/ ?# s/ m* F! S
{
$ H, |, o% B$ {# l* [
hsd->ErrorCode = HAL_SD_ERROR_NONE;
/ d3 u0 ^: M: M: D2 D
if((add + NumberOfBlocks) > (hsd->SdCard.LogBlockNbr))
; G1 i: h3 s' }
{ B* ]! C% s4 w8 V6 I* c( S
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;
* {$ H: G* M8 \0 p) t% e+ F1 R
return HAL_ERROR;
# z4 V- w0 `. o3 a
}
$ ]7 Z' ?' G- w
( ?3 j, c) {" ?# G# x# @$ F
hsd->State = HAL_SD_STATE_BUSY;
: v! y5 Y" y. `9 _! v+ g; K% C
/ l) |6 i9 |% s" l
/* 初始化数据控制寄存器 */ w, z# F: @: p+ l* |5 J9 ^; g
hsd->Instance->DCTRL = 0U;, x& p, n, z* {; K
% y9 {% K/ j6 F, j# h7 J, Q
hsd->pTxBuffPtr = pData;
) e6 B9 }* U* `0 C o F8 A6 L
hsd->TxXferSize = BLOCKSIZE * NumberOfBlocks;
3 y8 n9 ^5 [" R& f
1 F; J, Q$ N3 F9 _- d
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
/ ?0 r' ^* F' c
{
+ j7 k! C9 V6 h8 Y9 v8 h
add *= 512U;5 J3 X) r9 g" _- o, ]+ F
}8 C" N! Y; X- z$ o5 p" L" u; a4 x; V
Y+ y2 f, s# I7 s+ F+ t
/* 配置SD DPSM (Data Path State Machine) */
+ k3 F% R I! ?
config.DataTimeOut = SDMMC_DATATIMEOUT;
3 A8 |- w" q( ]2 }
config.DataLength = BLOCKSIZE * NumberOfBlocks;% b3 w7 y5 T& C$ O. H% x
config.DataBlockSize = SDMMC_DATABLOCK_SIZE_512B;
3 J; _7 O6 G& G5 s
config.TransferDir = SDMMC_TRANSFER_DIR_TO_CARD;
+ d6 U! l" h3 z( D e8 M6 y
config.TransferMode = SDMMC_TRANSFER_MODE_BLOCK;
9 |# l) u( M& ]7 W
config.DPSM = SDMMC_DPSM_DISABLE;
# v/ p7 A8 S" c+ ~7 o3 M
(void)SDMMC_ConfigData(hsd->Instance, &config);& _' o* i' ?. f, R- \
# l5 ?9 N% N! p' o- @
2 ~: c0 K' t+ Q* m: E6 d
__SDMMC_CMDTRANS_ENABLE( hsd->Instance);
) W- B8 V: j% X5 N
5 E* V5 T, ~5 v' w' G8 {# n% o
hsd->Instance->IDMABASE0 = (uint32_t) pData ;
! t+ `' Q# U' q2 R# x5 M0 ]
hsd->Instance->IDMACTRL = SDMMC_ENABLE_IDMA_SINGLE_BUFF;. `$ X. e6 X1 p" {+ R1 q2 {
9 G1 d8 B' \3 ~
/* 查询模式写块 */2 z) s2 K$ t# T1 a& `; O
if(NumberOfBlocks > 1U)
V& _/ [) ]9 T9 ^ v! ~
{
/ e7 C, v( c. V: F
hsd->Context = (SD_CONTEXT_WRITE_MULTIPLE_BLOCK | SD_CONTEXT_DMA);: {! H0 c! L$ E! T8 e
# M" E, r6 z, i; c
/* 多块写命令 */, F# u, x3 f0 O( [6 k+ n+ l2 f
errorstate = SDMMC_CmdWriteMultiBlock(hsd->Instance, add);
# R# S" y( g6 K5 r! ~" o' J" V
}
: S# J4 \7 Q6 x8 _( v; S/ i
else
$ A" e; Z( S! f% c5 X/ m
{) t, y5 U/ ?/ A: @
hsd->Context = (SD_CONTEXT_WRITE_SINGLE_BLOCK | SD_CONTEXT_DMA);) _8 v7 O, `( e p' l
6 l3 d% J* L9 @$ T% x4 g
/* 单块写命令 */# c2 F5 o' g q8 V e
errorstate = SDMMC_CmdWriteSingleBlock(hsd->Instance, add);$ M4 g2 B+ k |+ T6 S
}
; k& ^$ m( U7 _
if(errorstate != HAL_SD_ERROR_NONE)' D0 p: r9 ]( r2 q& n
{8 ^, q5 n' h# N/ y7 G8 l7 J) l
/* 清除静态标志 */
' Q& ^+ L, d. i& b
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
( J( h M- b' q; Z' @
hsd->ErrorCode |= errorstate;' n; V0 W6 Q2 s# P4 x
hsd->State = HAL_SD_STATE_READY;
$ ~/ M9 M0 O' `! `
hsd->Context = SD_CONTEXT_NONE;
$ L1 j1 P4 i* A) y
return HAL_ERROR;) ]# b7 [3 g! A: Y& _
}
& k m& o) R1 j m6 r4 \: R6 k
6 l: e" @: h+ K% B% G
/* 使能传输中断 Enable */' L: K$ A6 [( H8 Z
__HAL_SD_ENABLE_IT(hsd, (SDMMC_IT_DCRCFAIL | SDMMC_IT_DTIMEOUT | SDMMC_IT_TXUNDERR | SDMMC_IT_DATAEND));
9 ]8 z9 {. U4 ?; N; a5 d. }- Z
% }. `% [, o2 y# i! s3 Z8 A
return HAL_OK;
7 {3 x, Y; P# p, c
}
( Q' y1 H2 f7 ?. I: ~4 i/ E
else
+ V; p& K5 b* A5 @2 f( B* R# \8 t* y
{; q% t7 T# Z9 l
return HAL_BUSY;" ?. c8 A3 x# X6 ^; a; ]
}
0 g- s/ w) i# I; [* @& }8 q
}

复制代码

函数描述：

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

函数参数：

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

使用举例：

/**
5 e) m7 q% _$ D0 Y% C
* @brief Writes block(s) to a specified address in an SD card, in DMA mode.
8 ^' a! L& c$ j% B. A, M4 X
* @param pData: Pointer to the buffer that will contain the data to transmit
; ?" J! y% {. i6 d) r- w
* @param WriteAddr: Address from where data is to be written
) Q* I" ~! T/ R7 Q
* @param NumOfBlocks: Number of SD blocks to write4 F9 ^7 W% h( c( X
* @retval SD status6 J- C4 O+ o6 A! W9 N* q
*/
* e/ b0 z2 F: O: Y
uint8_t BSP_SD_WriteBlocks_DMA(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks)
: H5 K* }, C) {+ C Y
{+ h! \* Z2 W" \! _6 a) [+ n8 B
- a3 W$ ?& y: t! R- N1 G& t1 L+ M
if( HAL_SD_WriteBlocks_DMA(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks) == HAL_OK)6 C J. A$ B; ^- ^
{
" z5 N8 t$ ~+ t! k7 _
return MSD_OK;
! X/ }7 H+ H2 \) L
}
# P: g2 k* A/ T2 P1 k9 o+ |- p
else+ }% {( @. ~8 H% k
{
, t) y. p4 W5 k! N6 P4 A
return MSD_ERROR;" |7 w+ V9 t! H, G" n9 q
}
; \! A0 ]4 V# Z7 V
}

复制代码

87.4.7 函数HAL_SD_Erase
函数原型：

HAL_StatusTypeDef HAL_SD_Erase(SD_HandleTypeDef *hsd, uint32_t BlockStartAdd, uint32_t BlockEndAdd)
$ l# T* `0 f6 L! D
{) w+ Y( N1 e; N
uint32_t errorstate;) [; P0 S7 j( R; Q: a2 j/ y
uint32_t start_add = BlockStartAdd;
5 u y% Y" E. g b
uint32_t end_add = BlockEndAdd;# [4 X* c4 @% G7 l7 e# s. [5 \/ b
# _/ D6 c) P( q, p1 h! B, Q
if(hsd->State == HAL_SD_STATE_READY)
3 @& h* n# I Z; L
{: ?: \! M3 a$ S9 G+ u
hsd->ErrorCode = HAL_SD_ERROR_NONE;
" H8 ?$ R: q- @" p; z8 c. Y6 k
& k5 q/ a8 M7 U/ l
if(end_add < start_add)
- ?; L% X' D" ^& l, s$ q
{) A# i3 T, S8 E) B. U. \- D
hsd->ErrorCode |= HAL_SD_ERROR_PARAM;
$ J, N3 j. b1 u- U7 g: p2 X
return HAL_ERROR;
4 H+ \' W& x. E/ i- b6 M
}( U% C- Q N5 i! {3 U
: `# B0 ] h- o7 O! X$ S8 S
if(end_add > (hsd->SdCard.LogBlockNbr))' T2 X, }2 |8 w( _# n7 l6 g1 M/ z
{2 ], a9 m% y4 R
hsd->ErrorCode |= HAL_SD_ERROR_ADDR_OUT_OF_RANGE;# d1 U+ K% U8 v$ k( ^
return HAL_ERROR;& _. _& N8 G4 J2 _9 w8 r
}5 P% k4 J1 B; u- y8 B
6 n3 E- T" C4 u/ ~* g: m
hsd->State = HAL_SD_STATE_BUSY;
( V L' s1 z2 t# N8 N" j
# m! `+ ^. ~- G: F5 L- U% n
/* 检测是否支持擦除命令 */
8 u. F' L: m( _# U/ k
if(((hsd->SdCard.Class) & SDMMC_CCCC_ERASE) == 0U)
) } A$ S2 ~# |
{
# F) G2 z! P1 w/ e$ p/ G
/* 清除所有静态标志 */. t# E" S% o) A6 H
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
; q+ e1 L1 f3 Z: b. Q# e
hsd->ErrorCode |= HAL_SD_ERROR_REQUEST_NOT_APPLICABLE;9 L7 x/ Y1 @0 x
hsd->State = HAL_SD_STATE_READY;% i# F f0 @+ v' R4 C9 w4 N
return HAL_ERROR;
; x( R- W+ C1 U9 A
}
* F+ i7 D5 {' s }9 f- Q" _1 X
4 m8 _( p6 b1 F& P
if((SDMMC_GetResponse(hsd->Instance, SDMMC_RESP1) & SDMMC_CARD_LOCKED) == SDMMC_CARD_LOCKED)- U% H/ o2 Z% t" N* a/ Q- v& N
{
6 `2 ?: g6 |: B- Y* p3 l5 S
/* 清除所有静态标志 */
/ D, @ e3 L8 ~$ J* B! D* r
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
# @( `4 x/ q* n
hsd->ErrorCode |= HAL_SD_ERROR_LOCK_UNLOCK_FAILED;
. d$ s' v; {9 s, @. C( V0 ~1 r
hsd->State = HAL_SD_STATE_READY;
4 L t! T0 F5 C9 w
return HAL_ERROR;2 y8 ~ N1 L( [8 [# K, T
}
S' f' y3 B- [$ f7 i7 F4 M
* }; `% ^6 l& P$ A
/* 对于高容量卡，获取起始块和结束块 */5 }6 @: t6 g& i
if(hsd->SdCard.CardType != CARD_SDHC_SDXC)
% J' A% b4 Y$ _) ?
{2 v+ }$ T: D: O
start_add *= 512U;
/ r) `' S {6 J/ u/ d. A, K
end_add *= 512U;
5 Y! Z, f. y- h. f6 L# u6 N
}$ q8 T6 g9 V6 ?" _$ _5 a
' f# r! ~- g, x6 q
/* 根据sd-card spec 1.0 ERASE_GROUP_START (CMD32) 和 erase_group_end(CMD33) */
8 h) i1 P$ y* s: n6 U' c
if(hsd->SdCard.CardType != CARD_SECURED)
7 t# B' p! T' z4 B6 k
{
+ S+ M. _7 R( l
/* 发送CMD32 SD_ERASE_GRP_START命令带地址参数 */
: g% j3 J: g1 _$ d+ }$ l' ?# ?- t
errorstate = SDMMC_CmdSDEraseStartAdd(hsd->Instance, start_add);
' |; ?, S# w6 h1 z
if(errorstate != HAL_SD_ERROR_NONE)7 ~* s6 y& t* {) B: z
{8 ]. {; d* Y' M3 z- g
/* 清除所有静态标志 */1 p8 H2 S+ ^( Q+ h+ |
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);, Q) r3 J% ^' J. g6 x
hsd->ErrorCode |= errorstate;& o& e( E/ Q2 C) [9 m: P M: [, @
hsd->State = HAL_SD_STATE_READY;
3 C+ H- {9 U% X0 |( m
return HAL_ERROR;
3 D; E! l1 _! J& W w; g4 ^2 F
}
6 H( \. m# o0 c
8 X* U, C+ Y3 s9 B' u& O/ ?
/* 发送CMD33 SD_ERASE_GRP_END命令，带地址参数 */9 q! X$ F4 g, I O; ?+ g) C( t3 n; j
errorstate = SDMMC_CmdSDEraseEndAdd(hsd->Instance, end_add);3 c" I; n/ `1 f* T9 K
if(errorstate != HAL_SD_ERROR_NONE)$ Q; p+ K6 f0 g, o
{# T$ S. N5 |' [5 ~
/* 清除所有静态标志 */
! V3 t# b2 a; \4 s1 J
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);9 P; u! I2 X2 B2 J1 g/ b7 p$ f
hsd->ErrorCode |= errorstate;4 r' f6 p! v0 F! P+ j
hsd->State = HAL_SD_STATE_READY;0 L. a7 D5 u6 l+ k
return HAL_ERROR;
4 |1 Z$ i( f1 |: G; g8 P E% z
}0 q7 R! Y7 V# t
}
0 `, _/ V, B; @7 D6 g
: X, v5 C: t* z( P) d/ E
/* 发送CMD38 ERASE命令 */ v& A! E# Z* `, z9 V4 `
errorstate = SDMMC_CmdErase(hsd->Instance, 0UL);0 O" I1 z5 B3 t% u% i
if(errorstate != HAL_SD_ERROR_NONE)
* y1 M; u. Q0 [3 `% n2 B
{" j/ C- _4 e! n9 L
/* 清除所有静态标志 *// ^- e9 O3 N3 X @# M" O$ N
__HAL_SD_CLEAR_FLAG(hsd, SDMMC_STATIC_FLAGS);
+ B9 J0 N1 w. r A. M% I
hsd->ErrorCode |= errorstate;
6 H& N, M; G) J y; l' |0 |
hsd->State = HAL_SD_STATE_READY;
7 \# y: c' Z( A$ b7 [: n; t
return HAL_ERROR;1 [; p1 k! B, F5 s* S9 Y
}# ]3 ^+ z8 d- P: s, D' O4 X b4 ~( g
+ k# _% e" v' p
hsd->State = HAL_SD_STATE_READY;
* `! y+ m# A ~* q; u! g5 [" y+ Z! R
8 p( \+ ^, u7 x' y
return HAL_OK;
/ I! ^$ F1 | A* \1 ~+ ~ y
}5 H8 x% r4 D! Z- \- V9 A \2 R
else
: M: a0 m, l3 H; [* z7 z+ n7 L4 p
{: t5 g- s/ C6 N; e6 D
return HAL_BUSY;! P# G _8 P$ I
}( c3 W% U) V+ b: T/ T. U( o
}

复制代码

函数描述：

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

函数参数：

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

/**
% ^, d* S( F% g$ I/ N |' _: f
* @brief Erases the specified memory area of the given SD card.# Z3 w+ b) a- k6 |0 f2 G
* @param StartAddr: Start byte address; E0 p5 `- P7 r4 l, l a6 Q; E0 w
* @param EndAddr: End byte address
! A! W2 q. e+ W, A2 h- P' n
* @retval SD status i n& y9 r9 s+ f( T" x
*/# U( E E3 A$ P8 T7 Q6 r0 h" }. y
uint8_t BSP_SD_Erase(uint32_t StartAddr, uint32_t EndAddr)
" A- T( R( |' X0 a
{
+ i& |" W8 P4 S% ?2 W$ C0 a& [; h
/ C' m7 F6 ?" G. i* r
if( HAL_SD_Erase(&uSdHandle, StartAddr, EndAddr) == HAL_OK)$ C6 Z- _+ B; }, y
{5 N- S$ N* H/ j+ U2 u: {
return MSD_OK;
9 v, ?. N, d2 N: q& J4 _0 L
}' P/ h2 E7 `: V# B! T. b
else6 d& {2 s5 @' c; e3 _" @, X9 f
{( E! F0 K% i& L" C2 Z7 V
return MSD_ERROR;
# O5 R1 ?7 g0 e: e- K4 p. x; w# S
}
# k0 H- \1 O/ b* v, o; f, P
}