SD卡（Secure Digital Memory Card）即：安全数字内存卡，它是在MMC的基础上发展而来，是一种基于半导体快闪记忆器的新一代记忆设备，它被广泛地于便携式装置上使用，例如数码相机、个人数码助理(PDA)和多媒体播放器等。SD卡由日本松下、东芝及美国SanDisk公司于1999年8月共同开发研制。

$ w/ _& U8 F5 u$ k2 i9 f' Z

• SD卡简介
  
  , M1 B, C, F3 I4 ?4 ^/ L

SD非常小巧，可以嵌入到设备中，在嵌入式开发中，产品需要存储一些容量叫大的文件，就可能会运用到SD卡。SD卡按容量分类，可以分为3类：SD卡、SDHC卡、SDXC卡，如下表所示。

3 f/ Q8 {' E: N3 b

容量大小不同的SD卡，其内部的操作标准是不同的。很多外设会明确告诉用户本设备最大能够支持容量多大的外扩，不能无限制的扩存，因为容量越大，操作不同，对控制器的要求比较高。当前设备的控制器不足以支持大容量，所以有外扩限制。

! M  b0 v3 p2 m, L( v

SD卡由9个引脚与外部通信，支持SPI和SDIO两种模式，不同模式下，SD卡引脚功能描述如下表所示。

8 v& T/ d$ h$ D( h- F. F

• SD卡的物理结构
  
  " m8 H) E9 ^9 o. d7 `9 N. U1 i, G

5 F3 y( h3 s+ s

一张SD卡包括有存储单元、存储单元接口、电源检测、卡及接口控制器和接口驱动器5个部分。

8 ], S: W7 ]; U: Y  s

SD卡由9个引脚与外部通信，支持SPI和SDIO两种模式，不同模式下，SD卡引脚功能描述如下表所示。

/ F7 k% h- T' l" }: v3 S: o

0 b* N9 G& A9 n8 x7 ^5 D( U/ @

存储单元：是存储数据部件，存储单元通过存储单元接口与卡控制单元进行数据传输；

& Q) {# p% N+ w  W

电源检测单元：保证SD卡工作在合适的电压下，如出现掉电或上状态时，它会使控制单元和存储单元接口复位；

卡及接口控制单元：控制SD卡的运行状态，它包括有8个寄存器；

接口驱动器：控制SD卡引脚的输入输出。

9 X) I5 o8 e6 R/ Z* k9 A. @6 U. j

• SD卡内部寄存器
  
  & c+ b- W+ L# i$ O9 A3 {

SD卡总共有8个寄存器，用于设定或表示SD卡信息。这些寄存器只能通过对应的命令访问，程序控制中只需要发送组合命令就可以实现SD卡的控制以及读写操作。

% b# N( ]2 C; c8 I5 G  `3 T

% ~5 N2 [+ Q; d

• SDIO接口
  
  ; V6 G% F0 |" x- G; T8 P& V

SDIO全称是安全数字输入/输出接口，多媒体卡(MMC)、SD卡、SD I/O卡都有SDIO接口。STM32F407系列控制器有一个SDIO主机接口，它可以与MMC卡、SD卡、SD I/O卡以及CE-ATA设备进行数据传输。也就是说SDIO接口不仅仅只会操作SD卡，凡是符合SDIO接口通信的设备都可以被操作。

( ]/ G3 n9 _, y  p  S! F- C7 `# e

! n' P9 T, i* X0 k

SDIO 具有以下特性：

完全兼容 多媒体卡系统规范版本 4.2。卡支持三种不同数据总线模式：1 位（默认）、4 位和 8 位

完全兼容先前版本的多媒体卡（向前兼容性）

完全兼容 SD 存储卡规范版本2.0

完全兼容 SD I/O 卡规范版本 2.0 ： 卡支持两种不同数据总线模式：1 位（默认）和 4 位

完全支持 CE-ATA 功能（完全符合 CE-ATA  数字协议版本 1.1）

对于 8 位模式，数据传输高达 48 MHz

数据和命令输出使能信号，控制外部双向驱动程序。

SDIO 不具备兼容 SPI 的通信模式。

& \4 {# V3 E6 H6 L" ^: L4 f; E

• SDIO组成
  
  

SDIO 适配器块提供特定于 MMC/SD/SD I/O 卡的所有功能，如时钟生成单元、命令和数据传输。

* m! `4 V8 s# E. D; D* q  y  G

APB2 接口访问 SDIO 适配器寄存器，并且生成中断和 DMA 请求信号。

$ ]. G) S/ c5 Z( i: `6 ~- y

注：

1、默认情况下，SDIO_D0用于数据传输。初始化后，主机可以更改数据总线宽度。

2、SD 卡连接到总线，主机可以将数据传输配置为SDIO_D[3:0]

3、SDIO使用两个时钟信号：SDIO适配器时钟(SDIOCLK= 48 MHz)和APB2总线时钟(PCLK2)。

４、卡时钟（SDIO_CK）：每个时钟周期在命令和数据线上传输1位命令或数据。对于SD或SDI/O卡，时钟频率可以在0MHz至25MHz间变化，当数据正式稳定传输的时候配置为24MHz。SDIO_CK计算公式：SDIO_CK=SDIOCLK/(2+CLKDIV)

５、SDIO适配器时钟（SDIOCLK）：该时钟用于驱动SDIO适配器，可用于产生SDIO_CK时钟。对F4来说，SDIOCLK来自PLL48CK(48Mhz)。

６、F4：APB2总线接口时钟（PCLK2）：该时钟用于驱动SDIO的APB2总线接口，其频率为PCLK2=84Mhz。

注意：在SD卡初始化时，SDIO_CK不可以超过400Khz，初始化完成后，可以设置为最大频率（但不可以超过SD卡最大操作频率）。

$ Y1 c0 g, T6 y8 Q

该适配器由五个子单元组成：

1.适配器寄存器块 ：适配器寄存器模块包含所有系统寄存器。

2.控制单元   : 控制单元包含电源管理功能和存储卡时钟的时钟分频器。

3.命令路径 ：命令路径单元向卡发送命令并从卡接收响应。

4.数据路径 ：数据路径子单元负责与卡相互传输数据。

5.数据 FIFO ：数据 FIFO（先进先出）子单元是一个数据缓冲器，带发送和接收单元。FIFO 包含一个宽度为 32 位且深度为 32 字的数据缓冲器和发送/接收逻辑。（一共32 个单元，一个单元一个字）。所有的数据传输都要经过FIFO，便于管理。

' K# y% m0 K. p% M- J4 z

• SDIO 命令简介
  
  - P+ D; Z4 p1 K5 C: j# ]8 q! y

SD命令由主机发出，以广播命令和寻址命令为例，广播命令是针对与SD主机总线连接的所有从设备发送的，寻址命令是指定某个地址设备进行命令传输。

- ?; z; [8 w+ h' g$ S' r- d& E8 x) h

SD命令格式固定为48bit，都是通过CMD线连续传输的，数据线不参与。

( z" k2 n0 L& F! a- t

SD命令的组成如下：

起始位和终止位：命令的主体包含在起始位与终止位之间，它们都只包含一个数据位，起始位为 0，终止位为 1。
/ Y) m& `, r1 f0 @% ]$ O; ~

传输标志：用于区分传输方向，该位为 1 时表示命令，方向为主机传输到 SD 卡，该位为 0时表示响应，方向为 SD卡传输到主机。

命令主体内容包括命令、地址信息/参数和 CRC 校验三个部分。

命令号：它固定占用 6bit，所以总共有 64个命令(代号：CMD0~CMD63)，每个命令都有特定的用途，部分命令不适用于 SD 卡操作，只是专门用于 MMC卡或者SD I/O卡。

3 C, F& H! ~  N3 r

地址/参数：每个命令有 32bit地址信息/参数用于命令附加内容，例如，广播命令没有地址信息，这 32bit用于指定参数，而寻址命令这 32bit用于指定目标 SD卡的地址。

2 Z! y: \- @7 Q

CRC7 校验：长度为 7bit的校验位用于验证命令传输内容正确性，如果发生外部干扰导致传输数据个别位状态改变将导致校准失败，也意味着命令传输失败，SD卡不执行命令。

/ u6 ]# m0 E# L; A( l

SD命令有4种类型：

1.无响应广播命令(bc)，发送到所有卡，不返回任务响应；

2.带响应广播命令(bcr)，发送到所有卡，同时接收来自所有卡响应；

3.寻址命令(ac)，发送到选定卡，DAT线无数据传输；

5.寻址数据传输命令(adtc)，发送到选定卡，DAT线有数据传输。

在标准中定义了两种类型的通用命令：特定应用命令(ACMD)和常规命令(GEN_CMD)，也就是说在64个命令作为常规命令的基础上加了特定的命令

2 V3 ?. R9 ~; j: ?) t& C

要使用SD卡制造商特定的ACMD命令如ACMD6，需要在发送该命令之前无发送CMD55命令，告知SD卡接下来的命令为特定应用命令。CMD55命令只对紧接的第一个命令有效，SD卡如果检测到CMD55之后的第一条命令为ACMD则执行其特定应用功能，如果检测发现不是ACMD命令，则执行标准命令。

- Q& B2 x5 g3 j9 _# f

SD命令响应由SD卡向主机发出，部分命令要求SD卡作出响应，这些响应多用于反馈SD卡的状态。基本特性如下：

% L6 B- O; B1 ?2 w7 A1 P

lSDIO总共有7个响应类型(代号：R1~R7)，其中SD卡没有R4、R5类型响应。特定的命令对应有特定的响应类型，比如当主机发送CMD3命令时，可以得到响应R6。与命令一样，SD卡的响应也是通过CMD线连续传输的。根据响应内容大小可以分为短响应和长响应。短响应是48bit长度，只有R2类型是长响应，其长度为136bit。

! y* I  l' o6 ^

SDIO读数据

6 c( }0 w- p" ?, x2 L/ y

: F# _; u7 t- J0 I' a( E

单个块读操作与多个块的读操作除命令不同外，还体现在读操作结束时，单个块读取一个块自动结束，而多个块还需要主机发送停止命令。写操作类似，也要多发一个结束命令，只不过写操作写数据前需要检查卡的状态是否为忙状态。

SDIO写数据

• SD卡操作模式
  
  3 B! e, Q2 `$ P8 \. k

SD卡有多个版本，STM32控制器目前最高支持《Physical Layer SimplifiedSpecification V2.0》定义的SD卡，STM32控制器对SD卡进行数据读写之前需要识别卡的种类：V1.0标准卡、V2.0标准卡、V2.0高容量卡或者不被识别卡。

5 ~0 {- U1 M5 E' Z" M

SD卡系统定义了两种操作模式：卡识别模式和数据传输模式。

在系统复位后，主机处于卡识别模式，寻找总线上可用的SDIO设备；同时，SD卡也处于卡识别模式，直到被主机识别到，即当SD卡接收到SEND_RCA(CMD3)命令后，SD卡就会进入数据传输模式，而主机在总线上所有卡被识别后也进入数据传输模式。

每个不同的操作模式下，SD卡都有不同状态，通过命令控制实现卡状态的切换，在不同的状态下做不同的事，比如在发送数据前需要SD卡处于传输状态，发送数据时，SD卡处于接收状态。

• 卡识别模式
  
  

" P  O3 h" ^- z" i& r

①上电后，主机发送CMD0让所有卡软复位从而进入空闲状态。

②主机发送CMD8确定卡的电压范围，并识别是否为2.0的卡

③主机发送ACMD41识别或拒绝不匹配它的电压范围的卡，SD卡需要工作在特定的电压范围之内

④主机发送CMD2来控制所有卡返回它们的卡识别号CID（128位)

⑤主机发送CMD3命令，让卡推荐一个RCA（16）地址作为以后通信的标识，之后都以RCA值作为身份标识进行信息交互。

注：在卡识别过程中，要求SD卡工作在识别时钟频率FOD的状态下，在SD卡初始化时，SDIO_CK不可以超过400Khz

/ r7 M6 G* Z6 I& c& M8 |) B, L# a) L

• 数据传输模式
  
  * w+ o  i8 V4 _1 g8 c' M

只有SD卡系统处于数据传输模式下才可以进行数据读写操作。数据传输模式下可以将主机SD时钟频率设置为FPP，默认最高为25MHz，频率切换可以通过CMD4命令来实现。通过CMD7命令加上RCA值来选定指定的卡，选中后SD卡进入数据传输状态，就可以发送CMD17读单个块，CMD18读多个块，读多个块时只有发送CMD12命令才会停止。SD卡再次进入传输状态，若不想对卡有任何操作可以再次发送CMD7命令加上RCA值来取消指定的卡，写操作与上述原理相同。

, i. s# z8 \" G

• SD卡普通模式操作实例
  
  / b" L1 a5 w1 s9 u) i- U- Q& O

实验内容：向SD卡写入数据后读出

实验步骤：

7 T' \, k; a- ~# F: v) m% h6 G5 N

1.配置RCC，与以往不同的是SDIO适配器的时钟是单独配置的，需要专用的SDIOCLK，标准工作在48MHz

7 s+ C8 A" I9 V: w" X+ t2 F: O( R' m. p

2.配置SDIO
( o: S: B1 v) Y" n  z5 ^* y

% I! z0 Z1 V9 D/ l% `' ]

3.编写代码

1. 
   
2. //mian.c
   $ n% T) e$ V' t3 G
3. #include "main.h"
   5 t( t( n0 J* X  m$ D/ E
4. #include "stm32f4xx_hal.h"
   # }. b7 @$ g% O9 Z8 Y' w
5. #include "sdio.h"
   
6. #include "usart.h"
   4 g( L  s: d: U& Q7 C! ^6 d" I
7. #include "gpio.h"
   / e* w8 Y. [5 \( p4 F
8. #define SDBUF_SIZE   1024
   
9. uint8_t SDBUF_TX[SDBUF_SIZE],SDBUF_RX[SDBUF_SIZE];//数据传输的buf，一个用于传输，一个用于接收
   
10. //定义全局变量，最好不定义局部变量，防止因过大造成栈溢出
    
11. int main(void)
    6 U% b4 q/ m# k) s' ~$ l/ s8 W
12. {
    ; ^1 E. r0 a" H" u1 r. o+ r4 J
13.       uint32_t i;
    4 ~! i; n9 [* W1 y+ ^
14.       HAL_SD_CardInfoTypeDef pCardInfo;//定义结构体用来接收卡信息
    
15.       HAL_Init();
    
16.       SystemClock_Config();
    
17.       MX_GPIO_Init();
    " H, @% y! \: H, J
18.       MX_SDIO_SD_Init();
    
19.       MX_USART1_UART_Init();
    ( h+ x! \9 d! J% w( u
20.       printf("this is sd test\n");
    " h! t3 _3 X% X0 |+ a
21.       //卡识别结束后就可以调用HAL_SD_GetCardInfo()函数获取卡信息并打印
    
22.       HAL_SD_GetCardInfo(&hsd, &pCardInfo);
    
23.       printf("pCardInfo.CardType = %u\n",pCardInfo.CardType);
    # {. n  W. d  t; j3 j
24.       printf("pCardInfo.CardVersion = %u\n",pCardInfo.CardVersion);//版本
    ) O' i/ V/ o4 k' q% R, I
25.       printf("pCardInfo.BlockNbr = %u\n",pCardInfo.BlockNbr);//SD卡块数
    + X( I. P! @: u, f) B7 M& i  P' [
26.       printf("pCardInfo.BlockSize = %u\n",pCardInfo.BlockSize);//每一块大小
    8 V9 [% Z& w5 U" ]% C' T7 R5 F# U3 A
27.       /*--------------------SD卡写测试----------------------------------*/
    3 {8 \" n1 R- N! n- Q7 z
28.       memset(SDBUF_TX, 0x8, SDBUF_SIZE);  /、填充TXbuf为0x8
    + _' S7 q* B% ~6 M: @7 h: t) S( q& v0 K
29.       /**
    
30.          //函数功能及参数描述                             
    
31.         *HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint8_t *pData,
    " Q7 \; \! \4 q  z
32.                       *uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
    * H3 }- E: E$ I1 i# W; b
33.         * @param  hsd Pointer to SD handle
    
34.         * @param  pData pointer to the buffer that will contain the data to transmit
    
35.         * @param  BlockAdd Block Address where data will be written，从哪一个块开始写  
    
36.         * @param  NumberOfBlocks Number of SD blocks to write   写几个块
    
37.         * @param  Timeout Specify timeout value 超时时间
    
38.         * @retval HAL status
    $ \! f: M7 R1 F6 ^
39.         if( HAL_SD_WriteBlocks(&hsd, SDBUF_TX, 0 , 2, 1000) == HAL_OK)
    ( E6 a; Q) h+ n( b( }) b2 f2 O7 k5 J
40.         {
    * ]  r3 C+ A+ }  J7 p6 `* F
41.             while(HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER);//处于传输状态退出
    
42.             printf("WriteBlocks Successfully\n");
    
43.             for(i=0; i<SDBUF_SIZE; i++)
    9 F0 @/ W4 J; t
44.             {
    
45.                 printf("%d ",SDBUF_TX[i]);
    - y* n8 ?, a  h" C- e
46.             }
    ; l) e4 T3 A' d- N( f
47.             printf("\r\n");
    
48.         }
    1 c9 Y% U) ^+ X6 _7 ?: S
49.         else
    
50.         {
    
51.             printf("WriteBlocks Failed\n");
    
52.         }
    4 A9 j( u$ T" b( q" N9 p
53.         /*--------------------SD 卡读测试----------------------------------*/
    , Y) o0 j1 E; ^: p5 p" Q8 o
54.         //与HAL_SD_WriteBlocks函数的参数功能相同
    
55.         if( HAL_SD_ReadBlocks(&hsd, SDBUF_RX , 0, 2, 1000) == HAL_OK)
    2 q! y6 _/ @; k
56.         {
    ( f7 a6 @' F' z$ S  w
57.             while(HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER);//返回到传输状态退出
    - E( ]) t8 r6 C6 x$ L5 v# g
58.             printf("ReadBlocks Successfully\n");
    ( S6 X) f. U) E3 \: |
59.             for(i=0; i<SDBUF_SIZE; i++)
    % V/ w% w# h$ X2 R$ H
60.             {
    " m! R1 ^3 Z, d) y. ^1 ~
61.                 printf("%d ",SDBUF_RX[i]);
    
62.             }
    
63.             printf("\r\n");
    
64.         }
    
65.         else
    
66.         {
    
67.             printf("ReadBlocks Failed\n");
    . c3 B) e7 G+ ]1 D+ b. |8 {
68.         }
    / ^6 X) I) \7 J
69.         /*--------------------SD 擦除测试----------------------------------*/
    . {( m! g, A& v6 v, w  F0 D
70.         if (HAL_SD_Erase(&hsd, 0, 1) == HAL_OK )
    
71.         {
    3 @2 F8 p8 O+ w
72.             while(HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER);
    
73.             printf("SD_Erase Successfully\n");
    * @0 N9 W6 ~6 I+ `
74.         }
    
75.         else
    
76.         {
    3 Y  P- q2 ]5 M5 b, X
77.             printf("SD_Erase Failed\n");
    8 ~8 m: v1 z4 ^& C$ x
78.         }
    
79.         /*--------------------SD 卡读测试----------------------------------*/
    ; n( ]- X4 Q) O
80.         if( HAL_SD_ReadBlocks(&hsd, SDBUF_RX , 0, 2, 1000) == HAL_OK)
    + w2 C1 M- g, |( j& r
81.         {
    
82.             while(HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER);
    % L* M8 ^9 A. a3 t8 Q, U4 B
83.             printf("ReadBlocks Successfully\n");
    7 k- N/ `9 F+ m/ U6 u2 }4 ]% ~
84.             for(i=0; i<SDBUF_SIZE; i++)
    
85.             {
    : F6 B, a1 M8 q) G5 S8 E
86.                 printf("%d ",SDBUF_RX[i]);
    : d3 `' A1 s2 ]4 Q! C! ], s
87.             }
    
88.             printf("\r\n");
    
89.             }
    
90.         else
    9 G) S! P8 G8 S
91.         {
    
92.             printf("ReadBlocks Failed\n");
      b! q/ b  ]: p- F4 U2 I2 q9 v* M
93.         }
    
94.         while (1)
    
95.         {
    & V* g" H# b) N( Y
96.         }  
    
97. }

复制代码

1. //sdio.c
   : _& x8 r  I6 o5 m) [
2. //此代码为工程自动生成，非用户编写，这里只做分析
   ! Z+ v! u3 o$ w# e, Q' ]
3. #include "sdio.h"
   
4. #include "gpio.h"
   + H9 D# z6 n5 h8 h
5. /* USER CODE BEGIN 0 */
   
6. /* USER CODE END 0 */
   2 ^# X. T  D$ B, x
7. SD_HandleTypeDef hsd;
   7 P! i+ `+ Q, `
8. /* SDIO init function */
   
9. void MX_SDIO_SD_Init(void)   //初始化配置
   2 ?* D7 N0 E6 T0 \1 O
10. {
    5 E9 X6 M( ^! w  v* W9 i
11.   hsd.Instance = SDIO;    //SDIO句柄，整个系统中只有这一个
    
12.   hsd.Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;
    . J& ^; d3 N+ ~$ V2 }. C6 |' ~
13.   hsd.Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
      m- C) o3 ?) c+ g- L; {, J
14.   hsd.Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;
    ; e0 R5 @: t2 q( W+ {4 j/ w8 R
15.   hsd.Init.BusWide = SDIO_BUS_WIDE_1B;   //初始化时设置数据宽度为1位
    9 W+ x, _# _9 B0 |8 j! b
16.   hsd.Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
    3 ~  }( n. i2 O) h
17.   hsd.Init.ClockDiv = 0;
    , {  U7 q( a2 q; G6 y
18. //HAL_SD_Init()函数内部做了很多事去识别SD卡，具体的卡识别代码分析在下方
    
19. if (HAL_SD_Init(&hsd) != HAL_OK)
    8 Y2 j: t- y' K# @! P* w$ x
20.   {
    6 |+ L& N5 j) I+ K& [; {
21.     _Error_Handler(__FILE__, __LINE__);
    ! S  m9 q  T: J- A7 I! e: I
22.   }
    3 \0 e( D% t; ?4 Q2 A' e
23. //初始化结束后重新配置数据宽度为4位
    ( P% `; R  }2 z$ v  ~: V
24. if (HAL_SD_ConfigWideBusOperation(&hsd, SDIO_BUS_WIDE_4B) != HAL_OK)
    
25.   {
    0 }: m4 }1 T* N8 s8 e( n
26.     _Error_Handler(__FILE__, __LINE__);
    % l1 z# _: O3 w5 T, P; T
27.   }
    
28. }
    3 M9 C% L- h- b/ V
29. //卡识别代码如下
    $ U! P+ T7 x5 h" u8 s/ B6 n2 a8 a
30. HAL_StatusTypeDef HAL_SD_InitCard(SD_HandleTypeDef *hsd)
    
31. {
    
32.   uint32_t errorstate = HAL_SD_ERROR_NONE;
    
33.   SD_InitTypeDef Init;
    
34. /* Default SDIO peripheral configuration for SD card initialization */
    * C) O/ N! T9 @( Q7 |2 n$ ?; G! l
35. //完成卡识别
    
36.   Init.ClockEdge           = SDIO_CLOCK_EDGE_RISING;
    
37.   Init.ClockBypass         = SDIO_CLOCK_BYPASS_DISABLE;
    9 }, e$ j5 g1 n$ b
38.   Init.ClockPowerSave      = SDIO_CLOCK_POWER_SAVE_DISABLE;
    
39.   Init.BusWide             = SDIO_BUS_WIDE_1B;
    
40.   Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;
    ; D' R! _( @& L& ]6 i9 M' Q3 y
41.   Init.ClockDiv            = SDIO_INIT_CLK_DIV;
    2 z, v& A! p& X" e  w# c& f
42. //SDIO_CK卡识别阶段要求时钟小于400KHz,宏定义
    1 Q  }. z; ?- F* E
43. //SDIO_CK计算公式：SDIO_CK=SDIOCLK/(2+CLKDIV)
    
44. /* SDIO Initialization Frequency (400KHz max) */
    / d* |$ o$ F! k0 m, a5 c0 |
45. /*#define SDIO_INIT_CLK_DIV     ((uint8_t)0x76)*/
    6 {+ d3 u. S- T
46. /* Initialize SDIO peripheral interface with default configuration */
    4 v1 n' R, H2 {, G/ a- a. x
47.   SDIO_Init(hsd->Instance, Init);
    ' h& ?1 }" {- i4 z2 i
48. /* Disable SDIO Clock */
    # t* x% k# Z: P. h; A
49.   __HAL_SD_DISABLE(hsd);
    2 C: k: e/ C) Q$ @: t2 d  M
50. /* Set Power State to ON 对SD卡进行上电 */
    
51.   SDIO_PowerState_ON(hsd->Instance);
    . h% B8 l! d. I7 `& O( E4 C+ C8 v
52. /* Enable SDIO Clock */
    + K: i0 b3 C2 l5 R9 _6 F* W- b
53.   __HAL_SD_ENABLE(hsd);
    
54. /* Required power up waiting time before starting the SD initialization
    
55.   sequence */
    
56.   HAL_Delay(2U);
    
57. /* Identify card operating voltage */
    ) h/ H3 I( e9 K% ?2 V
58.   errorstate = SD_PowerON(hsd);
    
59. if(errorstate != HAL_SD_ERROR_NONE)
    ; x4 E) A7 D, R
60.   {
    5 w  {. J# p5 e6 r
61.     hsd->State = HAL_SD_STATE_READY;
    
62.     hsd->ErrorCode |= errorstate;
    
63. return HAL_ERROR;
    
64.   }
    
65. /* Card initialization */
    
66.   errorstate = SD_InitCard(hsd);
    % f& b$ ^# `/ S  n3 l
67. if(errorstate != HAL_SD_ERROR_NONE)
    
68.   {
      K! t+ O( s: B- e. x$ T9 |# H
69.     hsd->State = HAL_SD_STATE_READY;
    
70.     hsd->ErrorCode |= errorstate;
    
71.     return HAL_ERROR;
    
72.   }
    5 k( ^) v# r6 E$ B1 ~+ r4 P' E3 c9 V
73. return HAL_OK;
    3 P5 j# R& j7 s% ^
74. }

复制代码

# v" ~" S( f$ ?# A

• SD卡ＤＭＡ模式操作实例
  
  
  

当SD卡中有大量的音视频需要读取时，整个过程需要CPU干预，这样CPU的利用率就会降低，因此大量数据的传输最好启用DMA。

( k# G' v. Y& C$ D) j$ g* P

实验内容：向SD卡写入数据后读出。

实验步骤：工程的时钟配置和SDIO配置与普通模式相同，只有一点不同需要打开SDIO的全局中断，因为SDIO发送与接收完成后都需要中断去生成DMA请求。设置SDIO全局中断优先级更高一些，因为它内部还有很多其他中断，发生错误时更需要处理。

: F2 K: r6 A  C8 x- t

配置DMA

; N8 L9 Q5 A8 y* X: \

编写代码:

1. //mian.c
   $ w& b9 M" @( E  w& H& w
2. 
   
3. #include "main.h"
   
4. #include "stm32f4xx_hal.h"
   * @# |9 p: F2 w- [: _. Q! _) p
5. #include "dma.h"
   # E# a+ H0 [" i! A; `
6. #include "sdio.h"
   
7. #include "usart.h"
   
8. #include "gpio.h"
   # p+ n* l, I" H
9. 
   : N2 V0 ~% J2 t) [  W# {2 j! T: C
10. #define SDBUF_SIZE   1024
    
11. uint8_t SDBUF_TX[SDBUF_SIZE],SDBUF_RX[SDBUF_SIZE];//数据传输的buf，一个用于传输，一个用于接收
    + D  L# j, j% H# T" o8 o- B
12. //定义全局变量，最好不定义局部变量，防止因过大造成栈溢出
    0 ^7 j$ y, X6 C8 |. v. h4 w8 J
13. uint8_t DMA_SEND_OK, DMA_RCV_OK;
    
14. 
    $ h3 ?8 ~0 {/ h
15. int main(void)
    
16. {
    ! g! x. x) g; }- H2 s  V
17.       uint32_t i;
    7 y3 H7 ]0 ?, e. A
18.       HAL_SD_CardInfoTypeDef pCardInfo;//定义结构体用来接收卡信息
    
19.       HAL_Init();
    
20.       SystemClock_Config();
    * W: Y+ f0 d8 H/ R; B
21.       MX_GPIO_Init();
      s$ W8 r4 f# h# ^" H6 k) B
22.       MX_DMA_Init();
    
23.       MX_SDIO_SD_Init();
    
24.       MX_USART1_UART_Init();
      I7 f" a% H4 N% V  U' I3 m
25. 
    
26.       printf("this is sd test\n");
    
27.       //卡识别结束后就可以调用HAL_SD_GetCardInfo()函数获取卡信息并打印
    % X/ n0 Q) T8 @' j- m! M0 n8 t
28.       HAL_SD_GetCardInfo(&hsd, &pCardInfo);
    9 _9 Y+ ^: s9 L
29.       printf("pCardInfo.CardType = %u\n",pCardInfo.CardType);
    
30.       printf("pCardInfo.CardVersion = %u\n",pCardInfo.CardVersion);//版本
    7 w) x; c* L8 B( K
31.       printf("pCardInfo.BlockNbr = %u\n",pCardInfo.BlockNbr);//SD卡块数
    
32.       printf("pCardInfo.BlockSize = %u\n",pCardInfo.BlockSize);//每一块大小
    
33.       /*------------------- SD DMA 写测试-------------------------------------*/
    : [0 z9 k" o4 {# V( |, J
34.       memset(SDBUF_TX, 0x2, SDBUF_SIZE );
    8 B9 [; h' N3 n6 w" j6 I
35.       DMA_SEND_OK = 0;　　//设置发送完成标志位为０，完成时为１
    
36.        /**
    - I6 I2 _% F# Y. |+ r: R
37.        //函数原型
    % D7 P5 F9 t5 J4 \9 Z0 Y' I/ _
38.        *HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData,
    / m# ?3 T1 q% f# `- V  c1 x- c
39.                                              uint32_t BlockAdd, uint32_t NumberOfBlocks)
    : X5 J0 Y& p& x$ D0 k/ `5 Q
40.       
    , [) v! B* X7 M+ A; N! `% u
41.         * @param  hsd Pointer to SD handle
    ( y. ?* w% M# ^- S
42.         * @param  pData Pointer to the buffer that will contain the data to transmit
    $ x8 ]  W8 ^; p+ t" V
43.         * @param  BlockAdd Block Address where data will be written  从哪个块开始写
    
44.         * @param  NumberOfBlocks Number of blocks to write　　写几个块
    - o5 }7 S% F' t0 ~8 g5 R! [
45.         * @retval HAL status
    ) X( |' L6 Y0 E; j
46.         */
    , B; B4 \( h6 e8 i- S8 C9 J
47.       
    
48.       if( HAL_SD_WriteBlocks_DMA(&hsd, SDBUF_TX, 0, 1) == HAL_OK )
    2 Z8 [& {: }3 o% e7 c
49.       {
    
50.           //等待DMA传输完成，并且SD卡状态为传输状态
    0 ~7 n  ]) D: H6 o1 w3 a
51.           while( (DMA_SEND_OK ==0 ) || (HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER));  
    
52.           printf("WriteBlocks Successfully\n");
    ( ^$ W6 [" G' I
53.       
    ( z7 ~' S. ?8 h* Q) p2 a
54.           for(i=0; i<SDBUF_SIZE; i++)
    
55.           {
    
56.             printf("%d ",SDBUF_TX[i]);
    " U( t; b+ L; i7 F4 ]. c3 ^
57.           }
    7 q1 r# s; n* v( @& [$ N; x
58.           printf("\r\n");
    : J3 _6 ?& ^7 f" H  D' Y4 u
59.           }
    
60.           else
    " L+ n: Y" D6 ~% Q8 M
61.           {
    ! H- {9 \# H8 g$ v0 y7 q
62.              printf("WriteBlocks Failed\n");
    
63.           }
    0 w3 D1 d( q/ u; N
64.       
    
65.           /*------------------- SD DMA 读测试-------------------------------------*/
    6 Z% S, F- R1 B$ t: Z
66.           DMA_RCV_OK = 0;　　　//设置读取完成标志位为０，完成时为１
    . T3 A( U, s6 i( w. ?) \& r, Q3 L
67.           if(HAL_SD_ReadBlocks_DMA(&hsd, SDBUF_RX, 0, 1) == HAL_OK)
    
68.           {
    8 x, W4 `2 d% \. B: j9 N& @7 T
69.               while( (DMA_RCV_OK ==0) || (HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER));         
    
70.               printf("ReadBlocks Successfully\n");         
    . n0 p: u# b( V0 A+ x- L/ h3 j
71.               for(i=0; i<SDBUF_SIZE; i++)
    7 s. l  ]  N! I/ }; `  f7 r$ N
72.               {
    
73.                 printf("%d ",SDBUF_RX[i]);
    . j/ e, |5 g. H. @8 r, ^
74.               }
    . m1 W7 q$ Z' |9 n) Y
75.               printf("\r\n");
    
76.            }
    
77.             else
    
78.             {
    
79.               printf("ReadBlocks Failed\n");
    
80.             }
    8 [& [% c& z2 f
81.             while (1){}
    
82. }

复制代码

0 e+ U  {( Z5 M* r% S

1. 
   
2. //sdio.c
   2 }2 d; d( G0 h0 C
3. 
   
4. extern uint8_t DMA_SEND_OK, DMA_RCV_OK;
   ; y4 |4 E( ]* v
5. //发送完成中断处理
   ) N! o% P, ~& \, g* c7 g) m2 g5 K
6. void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd)
   2 ]9 ~4 ^: d2 S; V, x) r, \9 o9 o
7. {
   
8.   DMA_SEND_OK = 1;
   
9. }
   
10. //接收完成中断处理
    # d5 r& n" z6 W$ U( F
11. void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd)
    # }/ d2 J7 |0 _0 H9 k# P& ^' k
12. {
    
13.   DMA_RCV_OK = 1;
    
14. }

复制代码

' }* `3 q/ r  O9 i* X% s至此，ARM开发进阶知识已全部更新完毕！下一系列介绍物联网操作系统开发！
  _7 [% R  W5 q" l6 J( ]
0 ^, J; N3 M, \4 Z
, |# F7 u0 c$ a: _) B" x转载自： 骆驼听海
如有侵权请联系删除