你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

STM32开发进阶SD卡操作经验分享

[复制链接]
攻城狮Melo 发布时间:2023-4-11 19:23
微信图片_20230411192319.jpg
2 {, s; f0 h/ u, _9 d' }6 K
SD卡(Secure Digital Memory Card)即:安全数字内存卡,它是在MMC的基础上发展而来,是一种基于半导体快闪记忆器的新一代记忆设备,它被广泛地于便携式装置上使用,例如数码相机、个人数码助理(PDA)和多媒体播放器等。SD卡由日本松下、东芝及美国SanDisk公司于1999年8月共同开发研制。

6 W, t$ R; R' |7 m
  • SD卡简介

    . M0 h/ Y- |$ w8 o) j  p6 T, U
SD非常小巧,可以嵌入到设备中,在嵌入式开发中,产品需要存储一些容量叫大的文件,就可能会运用到SD卡。SD卡按容量分类,可以分为3类:SD卡、SDHC卡、SDXC卡,如下表所示。

8 d: r8 ?3 _8 M# l% X
微信图片_20230411192315.png
. J" C3 m# g5 w% o3 y
容量大小不同的SD卡,其内部的操作标准是不同的。很多外设会明确告诉用户本设备最大能够支持容量多大的外扩,不能无限制的扩存,因为容量越大,操作不同,对控制器的要求比较高。当前设备的控制器不足以支持大容量,所以有外扩限制。

4 z; a$ d# B+ _& B( ?
微信图片_20230411192311.png

- R) O1 e  G+ i9 j; P- P# B- p
SD卡由9个引脚与外部通信,支持SPI和SDIO两种模式,不同模式下,SD卡引脚功能描述如下表所示。

, B( a/ }% s% ]) d
( _7 i. s: t$ G6 b. Q, b: f+ |. s, g
微信图片_20230411192306.png $ E1 x" Q' J1 S9 o/ K: ]  m
: o# Q: s( C! A# E8 S# I2 a! }
  • SD卡的物理结构

    : Q6 \8 S( I3 v) G  v: g. n, ^
/ b, l9 x$ H6 H
一张SD卡包括有存储单元、存储单元接口、电源检测、卡及接口控制器和接口驱动器5个部分。
" i7 O: l" d' z; A, R
微信图片_20230411192301.png
0 c8 E9 h& W9 g4 O' p6 e+ b
SD卡由9个引脚与外部通信,支持SPI和SDIO两种模式,不同模式下,SD卡引脚功能描述如下表所示。
# \8 @1 h+ f+ u( H0 w

5 S2 C3 _* i5 M* M; r4 g" x/ p1 j$ Q, ^
存储单元:是存储数据部件,存储单元通过存储单元接口与卡控制单元进行数据传输;
; h- X. m% Y" [# ^
电源检测单元:保证SD卡工作在合适的电压下,如出现掉电或上状态时,它会使控制单元和存储单元接口复位;
" I: S3 V, Y# H. J
卡及接口控制单元:控制SD卡的运行状态,它包括有8个寄存器;

2 @$ ~( n! [( M) ]# O
接口驱动器:控制SD卡引脚的输入输出。
2 h# a8 i/ R1 N- w4 T8 h

. L5 c1 l2 A7 O. }- n, g( ^
  • SD卡内部寄存器
    6 q. w+ |, Y$ Y) r& l, K% t1 b0 S
SD卡总共有8个寄存器,用于设定或表示SD卡信息。这些寄存器只能通过对应的命令访问,程序控制中只需要发送组合命令就可以实现SD卡的控制以及读写操作。

& Q4 `: [6 H6 H; b+ W+ }
微信图片_20230411192255.png

4 a3 X: i2 I& |; [
  • SDIO接口

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

( s. X1 c8 o% R4 W7 E* d
微信图片_20230411192250.png

$ `, E; u& M( Q
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 的通信模式。

! ~8 H3 l5 R1 ?" K/ X0 [) S. |) t
  • SDIO组成
    : J6 f4 a0 S; J( i
SDIO 适配器块提供特定于 MMC/SD/SD I/O 卡的所有功能,如时钟生成单元、命令和数据传输。

, j1 J  `. E6 r' E9 M8 C
APB2 接口访问 SDIO 适配器寄存器,并且生成中断和 DMA 请求信号。
% Q- @0 J3 y4 ^, L& ~2 t
微信图片_20230411192246.png

1 D! `9 g  O: i1 t9 D& p3 \$ M7 W
注:
1、默认情况下,SDIO_D0用于数据传输。初始化后,主机可以更改数据总线宽度。
2、SD 卡连接到总线,主机可以将数据传输配置为SDIO_D[3:0]
3、SDIO使用两个时钟信号:SDIO适配器时钟(SDIOCLK= 48 MHz)和APB2总线时钟(PCLK2)。
4、卡时钟(SDIO_CK):每个时钟周期在命令和数据线上传输1位命令或数据。对于SD或SDI/O卡,时钟频率可以在0MHz至25MHz间变化,当数据正式稳定传输的时候配置为24MHz。SDIO_CK计算公式:SDIO_CK=SDIOCLK/(2+CLKDIV)
5、SDIO适配器时钟(SDIOCLK):该时钟用于驱动SDIO适配器,可用于产生SDIO_CK时钟。对F4来说,SDIOCLK来自PLL48CK(48Mhz)。
6、F4:APB2总线接口时钟(PCLK2):该时钟用于驱动SDIO的APB2总线接口,其频率为PCLK2=84Mhz。
, W2 h9 j7 `9 a) l5 [" y
注意:在SD卡初始化时,SDIO_CK不可以超过400Khz,初始化完成后,可以设置为最大频率(但不可以超过SD卡最大操作频率)。
- L2 b4 R- J+ Q. w
微信图片_20230411192243.png
, X/ ~1 u" X8 ]/ v0 V
该适配器由五个子单元组成:
1.适配器寄存器块 :适配器寄存器模块包含所有系统寄存器。
2.控制单元   : 控制单元包含电源管理功能和存储卡时钟的时钟分频器。
3.命令路径 :命令路径单元向卡发送命令并从卡接收响应。
4.数据路径 :数据路径子单元负责与卡相互传输数据。
5.数据 FIFO :数据 FIFO(先进先出)子单元是一个数据缓冲器,带发送和接收单元。FIFO 包含一个宽度为 32 位且深度为 32 字的数据缓冲器和发送/接收逻辑。(一共32 个单元,一个单元一个字)。所有的数据传输都要经过FIFO,便于管理。

3 j4 }$ k' d7 _( Y, c
  • SDIO 命令简介

    . i" g1 ]3 l' S' v3 e
SD命令由主机发出,以广播命令和寻址命令为例,广播命令是针对与SD主机总线连接的所有从设备发送的,寻址命令是指定某个地址设备进行命令传输。

4 B: h/ X1 {/ C% p' X) r
SD命令格式固定为48bit,都是通过CMD线连续传输的,数据线不参与。

6 R6 x; Z% N$ g5 W1 c4 }2 r! F% s5 u
微信图片_20230411192239.png
2 y. z& i2 q$ ~* p; c, j' _
SD命令的组成如下:
起始位和终止位:命令的主体包含在起始位与终止位之间,它们都只包含一个数据位,起始位为 0,终止位为 1。8 h1 X8 o! V+ S& {2 D( Y
5 D( a7 g: T' T! F. Z; p) F
传输标志:用于区分传输方向,该位为 1 时表示命令,方向为主机传输到 SD 卡,该位为 0时表示响应,方向为 SD卡传输到主机。

) O( v6 U% s4 p! J9 ~& y/ c: l
命令主体内容包括命令、地址信息/参数和 CRC 校验三个部分。

) C  m; s2 @/ |4 i- B1 R  E
命令号:它固定占用 6bit,所以总共有 64个命令(代号:CMD0~CMD63),每个命令都有特定的用途,部分命令不适用于 SD 卡操作,只是专门用于 MMC卡或者SD I/O卡。
7 V% V( N! |1 v' C$ r7 ?. n7 h
地址/参数:每个命令有 32bit地址信息/参数用于命令附加内容,例如,广播命令没有地址信息,这 32bit用于指定参数,而寻址命令这 32bit用于指定目标 SD卡的地址。
% m7 N; }) K( c+ ]& h5 h
CRC7 校验:长度为 7bit的校验位用于验证命令传输内容正确性,如果发生外部干扰导致传输数据个别位状态改变将导致校准失败,也意味着命令传输失败,SD卡不执行命令。

8 W  z$ S6 U/ e" D# O
SD命令有4种类型:
1.无响应广播命令(bc),发送到所有卡,不返回任务响应;
2.带响应广播命令(bcr),发送到所有卡,同时接收来自所有卡响应;
3.寻址命令(ac),发送到选定卡,DAT线无数据传输;
5.寻址数据传输命令(adtc),发送到选定卡,DAT线有数据传输。
+ }. H% Y2 J& r8 n- P: Z
在标准中定义了两种类型的通用命令:特定应用命令(ACMD)和常规命令(GEN_CMD),也就是说在64个命令作为常规命令的基础上加了特定的命令

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

& s3 e! H* r+ f" z, l
SD命令响应由SD卡向主机发出,部分命令要求SD卡作出响应,这些响应多用于反馈SD卡的状态。基本特性如下:

, K4 U# y  o/ b
lSDIO总共有7个响应类型(代号:R1~R7),其中SD卡没有R4、R5类型响应。特定的命令对应有特定的响应类型,比如当主机发送CMD3命令时,可以得到响应R6。与命令一样,SD卡的响应也是通过CMD线连续传输的。根据响应内容大小可以分为短响应和长响应。短响应是48bit长度,只有R2类型是长响应,其长度为136bit。
; D& }5 r4 k" c# a1 o) Q
SDIO读数据
. ]0 W& r# S9 {
微信图片_20230411192236.png
2 z9 O  C8 t% Z; Z
单个块读操作与多个块的读操作除命令不同外,还体现在读操作结束时,单个块读取一个块自动结束,而多个块还需要主机发送停止命令。写操作类似,也要多发一个结束命令,只不过写操作写数据前需要检查卡的状态是否为忙状态。

" }4 B: P/ j+ ?4 w
SDIO写数据

- G' P9 \7 V0 \( n
微信图片_20230411192231.png

# z" z  P( h9 [1 ?) `
  • SD卡操作模式
    % P1 v6 u! G5 F- m
SD卡有多个版本,STM32控制器目前最高支持《Physical Layer SimplifiedSpecification V2.0》定义的SD卡,STM32控制器对SD卡进行数据读写之前需要识别卡的种类:V1.0标准卡、V2.0标准卡、V2.0高容量卡或者不被识别卡。
& d4 a2 _7 s1 B7 R0 o
SD卡系统定义了两种操作模式:卡识别模式和数据传输模式。
4 n) |7 I. L$ i! R: f
在系统复位后,主机处于卡识别模式,寻找总线上可用的SDIO设备;同时,SD卡也处于卡识别模式,直到被主机识别到,即当SD卡接收到SEND_RCA(CMD3)命令后,SD卡就会进入数据传输模式,而主机在总线上所有卡被识别后也进入数据传输模式。

' x1 y" `: U- ~: X# G
每个不同的操作模式下,SD卡都有不同状态,通过命令控制实现卡状态的切换,在不同的状态下做不同的事,比如在发送数据前需要SD卡处于传输状态,发送数据时,SD卡处于接收状态。
  T/ R, }  `" h# L* j+ a7 I4 Z( g
微信图片_20230411192227.png
( E1 d9 D2 |" r
  • 卡识别模式

    2 ?: l; P1 d+ m# p
微信图片_20230411192220.png
; t, ]# `& v4 |7 q% h- i& r/ s3 Y
①上电后,主机发送CMD0让所有卡软复位从而进入空闲状态。
②主机发送CMD8确定卡的电压范围,并识别是否为2.0的卡
③主机发送ACMD41识别或拒绝不匹配它的电压范围的卡,SD卡需要工作在特定的电压范围之内
④主机发送CMD2来控制所有卡返回它们的卡识别号CID(128位)
⑤主机发送CMD3命令,让卡推荐一个RCA(16)地址作为以后通信的标识,之后都以RCA值作为身份标识进行信息交互。

+ Q, k. X: J) |. q5 Y" ~* H
注:在卡识别过程中,要求SD卡工作在识别时钟频率FOD的状态下,在SD卡初始化时,SDIO_CK不可以超过400Khz
! I; b+ g: `) K7 D5 H; [
  • 数据传输模式
    ( T8 q( h  Z$ k! L9 O" \
微信图片_20230411192214.png

  k- j, F& ?2 e( d
只有SD卡系统处于数据传输模式下才可以进行数据读写操作。数据传输模式下可以将主机SD时钟频率设置为FPP,默认最高为25MHz,频率切换可以通过CMD4命令来实现。通过CMD7命令加上RCA值来选定指定的卡,选中后SD卡进入数据传输状态,就可以发送CMD17读单个块,CMD18读多个块,读多个块时只有发送CMD12命令才会停止。SD卡再次进入传输状态,若不想对卡有任何操作可以再次发送CMD7命令加上RCA值来取消指定的卡,写操作与上述原理相同。
5 ?& a' j' \, |3 P# S
  • SD卡普通模式操作实例
    * W" _* u( K  M: b( M
实验内容:向SD卡写入数据后读出
) v3 N% o8 z$ E5 i1 T
实验步骤:
6 y) k$ g, N* O+ C7 O
1.配置RCC,与以往不同的是SDIO适配器的时钟是单独配置的,需要专用的SDIOCLK,标准工作在48MHz

( N6 n) \" z$ O. p* d0 _: `9 _0 v# F
微信图片_20230411192210.png
; R. p+ N6 Q4 G' u, }/ z# ~3 b
2.配置SDIO
6 X* L: f, ^( u, y1 o) m- j
5 r# G+ R, g) Y4 r2 z) m4 z0 J0 Y' ^
微信图片_20230411192207.png
% \* E$ A7 ?, O/ o& m; H
微信图片_20230411192203.png

2 x" ~: M+ P) D( b6 f( H1 y
3.编写代码
  1. , Y+ B* [% |! x6 G
  2. //mian.c* b  z, k2 g4 ~8 V* \# W! Q
  3. #include "main.h"
    8 |2 J- t4 x  }1 G2 b. o
  4. #include "stm32f4xx_hal.h"- w# Y$ ?" B2 d% Y; i
  5. #include "sdio.h"6 G% X5 J! w7 X8 g* r
  6. #include "usart.h"! f0 L; v1 b" v* N" }4 A/ B% x
  7. #include "gpio.h"
    ) S( V! h- F6 b
  8. #define SDBUF_SIZE   1024
    7 {$ W0 m6 A1 X9 |
  9. uint8_t SDBUF_TX[SDBUF_SIZE],SDBUF_RX[SDBUF_SIZE];//数据传输的buf,一个用于传输,一个用于接收3 f; }! a+ b' A- J( m! o+ J$ Q+ X
  10. //定义全局变量,最好不定义局部变量,防止因过大造成栈溢出
    5 C+ P+ V$ [5 v
  11. int main(void): d5 V) c5 G" k6 a% [
  12. {3 ~: Y: {* v7 }8 y8 H3 t" t0 z+ H, ?% s
  13.       uint32_t i;
      ]- h$ E) I, k% @; r: o
  14.       HAL_SD_CardInfoTypeDef pCardInfo;//定义结构体用来接收卡信息
    7 V8 }' H, P) ~# ?4 W' R( K1 }
  15.       HAL_Init();) e5 z! r' J( m) `  v
  16.       SystemClock_Config();, A- i: `; K5 H
  17.       MX_GPIO_Init();
    ( ]& i: T  R; ]% N
  18.       MX_SDIO_SD_Init();5 a% p# A" }/ m: R( H0 `
  19.       MX_USART1_UART_Init();
    / E# e* Z7 U" T" N4 o& F  w9 P
  20.       printf("this is sd test\n");
    ; E, p. w# H) V" R3 |/ v
  21.       //卡识别结束后就可以调用HAL_SD_GetCardInfo()函数获取卡信息并打印
    + d, n7 |, ~9 K. a0 a" {/ K
  22.       HAL_SD_GetCardInfo(&hsd, &pCardInfo);
    4 M2 `4 Q% x3 I! O, b7 @$ Z6 u
  23.       printf("pCardInfo.CardType = %u\n",pCardInfo.CardType);
    2 p5 n$ }; |. s9 l7 A
  24.       printf("pCardInfo.CardVersion = %u\n",pCardInfo.CardVersion);//版本1 L6 D5 e+ Z3 z# g1 x/ A9 M
  25.       printf("pCardInfo.BlockNbr = %u\n",pCardInfo.BlockNbr);//SD卡块数4 H& }  b# i/ G1 E5 L! \( W3 ]
  26.       printf("pCardInfo.BlockSize = %u\n",pCardInfo.BlockSize);//每一块大小2 G3 p$ m' c( P5 Y* d
  27.       /*--------------------SD卡写测试----------------------------------*/
    % H' z- s% g' e# J  q* k" F. @
  28.       memset(SDBUF_TX, 0x8, SDBUF_SIZE);  /、填充TXbuf为0x8
    , V; t# ?4 Y( H! s2 T7 b" N
  29.       /**
    & w: L; W& `; ]$ Z. h, s
  30.          //函数功能及参数描述                             
    7 f6 X" c7 l' D" m
  31.         *HAL_StatusTypeDef HAL_SD_WriteBlocks(SD_HandleTypeDef *hsd, uint8_t *pData,
    . Q+ S& j/ W5 M7 D$ v, o9 V$ U
  32.                       *uint32_t BlockAdd, uint32_t NumberOfBlocks, uint32_t Timeout)
    4 G  d! j7 a, p- D2 {# ?
  33.         * @param  hsd Pointer to SD handle
    0 g: L$ [# M& q; ~5 ?  z
  34.         * @param  pData pointer to the buffer that will contain the data to transmit
    ! R+ ?2 B' U. d$ u$ j# S
  35.         * @param  BlockAdd Block Address where data will be written,从哪一个块开始写  & z) n8 o$ `7 a/ ?" j" E
  36.         * @param  NumberOfBlocks Number of SD blocks to write   写几个块5 \" G& Q1 K5 i8 [% U
  37.         * @param  Timeout Specify timeout value 超时时间- x4 {# r  V7 i' S3 O% f
  38.         * @retval HAL status
    - g$ X+ T5 A" z( v6 t( \7 A
  39.         if( HAL_SD_WriteBlocks(&hsd, SDBUF_TX, 0 , 2, 1000) == HAL_OK)
    $ [- U2 ?8 d7 D
  40.         {
    * ]; n3 r6 x0 \/ K6 J3 N, j" m
  41.             while(HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER);//处于传输状态退出$ M! {! w$ A6 K
  42.             printf("WriteBlocks Successfully\n");
    2 t+ x$ X6 ?. b' m2 R
  43.             for(i=0; i<SDBUF_SIZE; i++)
    6 C2 {; c- x' l8 G
  44.             {* K9 ^$ t' B, a
  45.                 printf("%d ",SDBUF_TX[i]);  `8 U1 f1 t7 C# J
  46.             }
    6 b% R" L9 O2 M
  47.             printf("\r\n");
    4 B4 r5 o1 h% h
  48.         }( ?3 R  n8 j1 M% h7 h* `  W+ O
  49.         else" f/ k) z2 V" b" H5 N3 l; b' y
  50.         {+ l. x9 Z. Z0 P4 X4 i
  51.             printf("WriteBlocks Failed\n");3 h  B6 w; X7 }
  52.         }8 C  E. |+ B+ j
  53.         /*--------------------SD 卡读测试----------------------------------*/- ^3 X- H# H) ^& P  ^8 T
  54.         //与HAL_SD_WriteBlocks函数的参数功能相同
    # m! U8 S: g$ t# L
  55.         if( HAL_SD_ReadBlocks(&hsd, SDBUF_RX , 0, 2, 1000) == HAL_OK)
    ; f& x) X7 I7 K
  56.         {
    ' n6 y0 B  z" Q' I
  57.             while(HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER);//返回到传输状态退出
    4 s! A- w( q* N2 s
  58.             printf("ReadBlocks Successfully\n");  ^: i6 P5 ]5 o9 K2 Q
  59.             for(i=0; i<SDBUF_SIZE; i++)$ o/ L# R6 f3 l8 V+ W
  60.             {
    9 {- A( E3 x$ C- l5 o
  61.                 printf("%d ",SDBUF_RX[i]);3 Z! F2 p8 I- R8 c% A! N
  62.             }
    4 y0 J2 K: {8 b2 y
  63.             printf("\r\n");/ L# J, F" p* C. _6 y2 v3 D
  64.         }
    ( P7 H' p" D% E$ ?
  65.         else
    ! @$ z7 R& c0 S5 ?1 o! Y
  66.         {3 q. f$ A8 U! I; `
  67.             printf("ReadBlocks Failed\n");  z6 g8 ^9 }7 Q: p- ?2 X0 |6 S  D
  68.         }
    * L8 {& }; W1 o' ?0 p' m% {( Z$ N4 d3 l
  69.         /*--------------------SD 擦除测试----------------------------------*/
    ) ~+ E% J/ U1 d5 q$ x
  70.         if (HAL_SD_Erase(&hsd, 0, 1) == HAL_OK )) J) A1 r5 }' b) H' d# H
  71.         {% D3 c$ z& A7 k1 P
  72.             while(HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER);) a3 r: I/ e* l9 F7 ]
  73.             printf("SD_Erase Successfully\n");7 V* |# G9 @4 t: X" S4 U! R
  74.         }
    ( l  j1 E! I+ C1 K/ ^" p8 p
  75.         else, [* L# A8 {) E5 e0 l
  76.         {
    2 G6 p; J3 B( d! F9 ~5 x0 t
  77.             printf("SD_Erase Failed\n");1 b# e0 S5 h0 W- d2 [6 G
  78.         }9 R; X8 U% s0 h1 x; L) E
  79.         /*--------------------SD 卡读测试----------------------------------*/
    & ?7 K/ f2 E% G1 V: h0 r. N
  80.         if( HAL_SD_ReadBlocks(&hsd, SDBUF_RX , 0, 2, 1000) == HAL_OK): {' ]0 a9 z. V+ e$ C
  81.         {
    & z+ f" A4 T8 A4 Y9 q& ^
  82.             while(HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER);' v; W- }  G1 Z3 J, z+ G. J# b
  83.             printf("ReadBlocks Successfully\n");
    ! H- H. |# L7 H, P4 L& k
  84.             for(i=0; i<SDBUF_SIZE; i++)& N3 R: G5 \7 s, v. g" E
  85.             {  ^& [! }2 c- L5 N
  86.                 printf("%d ",SDBUF_RX[i]);+ b, b5 v) c' v- u
  87.             }& D; N8 W& K4 E" H
  88.             printf("\r\n");
    ' \: {* j2 o1 F, K
  89.             }
    - y6 O6 ?' \. J, C' n1 r2 @- A
  90.         else. Z8 q7 n! B0 r# p& A; p
  91.         {
    - W; |" Q% `  w- D* u, O6 Q& M
  92.             printf("ReadBlocks Failed\n");
    # W6 ^" p' F3 `" S, d. t  _/ Q. D
  93.         }
    % h6 `. y8 U. f& x* }& c
  94.         while (1)$ c7 p2 l* v% g
  95.         {/ ]  z, L  C$ W4 i" m8 h% O
  96.         }  " [9 {1 ?: v; }0 {4 X% i
  97. }
复制代码
  1. //sdio.c( L4 f/ M# p, z
  2. //此代码为工程自动生成,非用户编写,这里只做分析* }2 ^9 {; q" ^. o& Z" m
  3. #include "sdio.h"0 ?. r+ m* o5 Q# v" w3 }
  4. #include "gpio.h"
    1 N6 }$ M4 T4 M  s
  5. /* USER CODE BEGIN 0 */
    7 b2 H+ X6 J  e) k0 s
  6. /* USER CODE END 0 */
    2 b: A/ K" H8 l" V1 e+ M
  7. SD_HandleTypeDef hsd;7 R4 U: H- K% N) h6 ?9 Y: G% o& A* r
  8. /* SDIO init function */
    2 C# T1 \5 c8 L1 d
  9. void MX_SDIO_SD_Init(void)   //初始化配置
    . p6 Z, [! ]0 Q
  10. {
    ' c8 F( q$ U5 B5 [& B1 [
  11.   hsd.Instance = SDIO;    //SDIO句柄,整个系统中只有这一个
    $ a$ }- X  ~) g% d3 Y; [+ T6 J. d; o
  12.   hsd.Init.ClockEdge = SDIO_CLOCK_EDGE_RISING;8 N' e3 G9 x. v0 C' V
  13.   hsd.Init.ClockBypass = SDIO_CLOCK_BYPASS_DISABLE;
    ' R& k* v5 Y0 R7 N
  14.   hsd.Init.ClockPowerSave = SDIO_CLOCK_POWER_SAVE_DISABLE;3 K7 M4 D6 s. }( s
  15.   hsd.Init.BusWide = SDIO_BUS_WIDE_1B;   //初始化时设置数据宽度为1位0 U2 E0 ]7 f: w/ S1 K( a0 Z
  16.   hsd.Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;. Y: z$ B8 C! \4 t, \
  17.   hsd.Init.ClockDiv = 0;
    : J& m& |. S; {: i4 [. y
  18. //HAL_SD_Init()函数内部做了很多事去识别SD卡,具体的卡识别代码分析在下方0 P. M0 f) E5 z% J
  19. if (HAL_SD_Init(&hsd) != HAL_OK)
    ) R3 Z# J/ l! ]  K7 G
  20.   {5 k  H( t' }) K) I+ ?* H3 v; O
  21.     _Error_Handler(__FILE__, __LINE__);
    & _4 G; a3 u, N  ~# I2 r' w* `
  22.   }
    ) e/ c6 y' E0 f8 D  e: |
  23. //初始化结束后重新配置数据宽度为4位& N, ]! e" {  i$ b
  24. if (HAL_SD_ConfigWideBusOperation(&hsd, SDIO_BUS_WIDE_4B) != HAL_OK) ) n2 r) F) k' e6 v2 q# i
  25.   {( z& I. {$ E- e' [( u1 ?' X
  26.     _Error_Handler(__FILE__, __LINE__);
    " C- `3 O8 w4 ]- M! P% n, F
  27.   }7 ?& |0 |2 g6 P. {4 C- `+ h0 N4 P
  28. }
    : u- G2 O  }' \: g
  29. //卡识别代码如下# E, ~2 |  J6 U& U+ Q2 |* M2 k+ s5 C
  30. HAL_StatusTypeDef HAL_SD_InitCard(SD_HandleTypeDef *hsd)
    2 M, ~$ Z9 K2 u# z
  31. {$ a: o0 ^( r! d; I
  32.   uint32_t errorstate = HAL_SD_ERROR_NONE;
    ! i5 D6 l' G( D" q  O2 U  y
  33.   SD_InitTypeDef Init;' ~9 ]6 S* b+ M6 l# q( i  z/ r$ X6 s
  34. /* Default SDIO peripheral configuration for SD card initialization */8 j1 k3 u& S; c* _
  35. //完成卡识别
    0 P. B* T) q7 O1 G
  36.   Init.ClockEdge           = SDIO_CLOCK_EDGE_RISING;9 H6 X1 A/ q, y' r
  37.   Init.ClockBypass         = SDIO_CLOCK_BYPASS_DISABLE;
    8 H8 o0 m5 N, y7 U, p* E; ~. V
  38.   Init.ClockPowerSave      = SDIO_CLOCK_POWER_SAVE_DISABLE;! A6 z# m4 C( U/ w/ ?# L# e
  39.   Init.BusWide             = SDIO_BUS_WIDE_1B;
    1 R; n' ?# J3 W' ^0 ^* L3 h
  40.   Init.HardwareFlowControl = SDIO_HARDWARE_FLOW_CONTROL_DISABLE;; p, T/ P$ g7 e6 ^' v
  41.   Init.ClockDiv            = SDIO_INIT_CLK_DIV;4 T, ?0 y0 D" f* b
  42. //SDIO_CK卡识别阶段要求时钟小于400KHz,宏定义
    7 D. [& {" R3 |! u9 m% ~
  43. //SDIO_CK计算公式:SDIO_CK=SDIOCLK/(2+CLKDIV); T! v3 b* y/ ?
  44. /* SDIO Initialization Frequency (400KHz max) */
    $ `1 u2 O* X, P+ o
  45. /*#define SDIO_INIT_CLK_DIV     ((uint8_t)0x76)*/
    * P, }/ I- h- W
  46. /* Initialize SDIO peripheral interface with default configuration */
    ' a; B% A5 Z( U8 C% m) N/ g. O
  47.   SDIO_Init(hsd->Instance, Init);
    9 L) U  b, k% i" Z# m1 M
  48. /* Disable SDIO Clock */
      t; F8 L7 w- r9 Y( E9 @
  49.   __HAL_SD_DISABLE(hsd); : H$ G) q7 G( ]) _9 \3 M  R! O
  50. /* Set Power State to ON 对SD卡进行上电 */8 u: [7 U, R+ |: j' r! W: U
  51.   SDIO_PowerState_ON(hsd->Instance);9 w- ~3 C& ^# ^6 x7 a  o% i6 U' D1 k
  52. /* Enable SDIO Clock */
    + K% M. ^7 W4 D
  53.   __HAL_SD_ENABLE(hsd);
    - f6 ^$ \" a1 n4 M4 d
  54. /* Required power up waiting time before starting the SD initialization ! A& d0 B7 ?6 j9 z8 ~1 t+ v) r& ]& @
  55.   sequence */
    * \/ Q1 G1 l$ ^) [5 q' [8 S
  56.   HAL_Delay(2U);6 [+ P+ g! o- I: C% X
  57. /* Identify card operating voltage */9 X) Q' F2 G* h* B4 |  @
  58.   errorstate = SD_PowerON(hsd);
    3 Y3 V9 p& x7 ^* w5 @8 Y
  59. if(errorstate != HAL_SD_ERROR_NONE)5 j/ }9 h6 y) J8 R$ C: f$ D
  60.   {4 S" ?$ w; v" Z" j4 X! m
  61.     hsd->State = HAL_SD_STATE_READY;$ q) B7 t* |$ s  f3 y( J
  62.     hsd->ErrorCode |= errorstate;
    9 {, a, S4 L5 i$ J/ f8 y: H  [: y
  63. return HAL_ERROR;
    " B! n; J* }  U  W) b, o3 P# B
  64.   }
    4 L6 m5 O  r$ D, O# z( `4 M
  65. /* Card initialization */) p3 j! v/ h! O
  66.   errorstate = SD_InitCard(hsd);
    : K$ b. ?* a3 y$ k: M
  67. if(errorstate != HAL_SD_ERROR_NONE): z, E1 n, \8 b3 G1 Q3 j
  68.   {4 W$ N; ^. i) a: d, z
  69.     hsd->State = HAL_SD_STATE_READY;
    / v3 O2 x- m) L! @( Q6 l
  70.     hsd->ErrorCode |= errorstate;8 I1 D" M( R' h, G
  71.     return HAL_ERROR;# ~$ L+ x7 h* Z& e  ~3 q, ?  s& i
  72.   }
    1 I) m) @) S, f! ]% h7 p
  73. return HAL_OK;# l; j3 h* g) f* |' v7 M% y1 S
  74. }
复制代码
. D0 e! k% _% B
  • SD卡DMA模式操作实例
    - G3 z" D1 }! S! e+ Y+ Q

    $ w. f- S. d) v' b% T
当SD卡中有大量的音视频需要读取时,整个过程需要CPU干预,这样CPU的利用率就会降低,因此大量数据的传输最好启用DMA。
' s' {  t; U6 P( W1 H
实验内容:向SD卡写入数据后读出。

2 O1 f/ M2 K" b" }8 C" ~
实验步骤:工程的时钟配置和SDIO配置与普通模式相同,只有一点不同需要打开SDIO的全局中断,因为SDIO发送与接收完成后都需要中断去生成DMA请求。设置SDIO全局中断优先级更高一些,因为它内部还有很多其他中断,发生错误时更需要处理。
+ j$ {: S% T$ h5 `* u
微信图片_20230411192200.png
! V# L* A, O, s6 v" \' ~4 c& N
配置DMA

* P& D" y. h, y/ g- u+ O; O- g
微信图片_20230411192156.png
0 i5 S+ b# ?" b
编写代码:
  1. //mian.c
      V& b4 o8 R+ u7 D
  2. * y' f+ z* `  D
  3. #include "main.h"
    8 C4 m. `* O9 O- r6 R
  4. #include "stm32f4xx_hal.h"3 l; P' F  H1 ~% ^3 j2 D
  5. #include "dma.h"
    ' ?7 m3 t! t: H9 B% H
  6. #include "sdio.h"5 @+ f9 p9 ]8 {. x' N7 G! ?
  7. #include "usart.h"
    . u. t: h" L0 ~7 j7 w
  8. #include "gpio.h"* o* T) Y; d" a8 @$ A

  9. . h* J) {5 F' V: Q6 e) L1 I
  10. #define SDBUF_SIZE   10243 W- b: r! P8 l
  11. uint8_t SDBUF_TX[SDBUF_SIZE],SDBUF_RX[SDBUF_SIZE];//数据传输的buf,一个用于传输,一个用于接收
    ; a, M8 _7 o, n- `! `
  12. //定义全局变量,最好不定义局部变量,防止因过大造成栈溢出
    ' f5 @1 O  x% g9 v. e
  13. uint8_t DMA_SEND_OK, DMA_RCV_OK;
    / R5 E3 l( j; ~9 s7 u# J7 |
  14. 4 f) L4 R: y; c- `- G. L6 k, f# }+ \
  15. int main(void)
    : R1 V2 P$ W- b; V
  16. {5 I7 `" c7 {+ [; F7 c0 |
  17.       uint32_t i;( U" U; b$ L' Q0 X6 S1 r& X7 W0 s
  18.       HAL_SD_CardInfoTypeDef pCardInfo;//定义结构体用来接收卡信息7 ?" s" S4 g7 ]; X' l) U$ r+ K
  19.       HAL_Init();# P+ n8 m% G( R6 K- `3 ?% m! j
  20.       SystemClock_Config();, Y( Y/ ?& O2 d. E2 n3 A2 l9 u
  21.       MX_GPIO_Init();& V+ \8 z. ]! a+ E9 I2 m
  22.       MX_DMA_Init();+ l3 D! h8 ?( b: @: R. t
  23.       MX_SDIO_SD_Init();
    , g7 ]2 q' f4 O7 r
  24.       MX_USART1_UART_Init();6 w$ a: ]  ?! [$ u5 y0 ]
  25. # ]5 F/ z" C  e2 a
  26.       printf("this is sd test\n");5 Q8 D0 \! b/ ]. r1 o! ]" `9 f
  27.       //卡识别结束后就可以调用HAL_SD_GetCardInfo()函数获取卡信息并打印
    * y* A+ W/ g9 d2 c7 S3 U$ t- P) ?. z' n
  28.       HAL_SD_GetCardInfo(&hsd, &pCardInfo);
    ' G7 c* d; I/ p% ^9 W2 `
  29.       printf("pCardInfo.CardType = %u\n",pCardInfo.CardType);8 a$ }; B* G/ K, L4 v+ H
  30.       printf("pCardInfo.CardVersion = %u\n",pCardInfo.CardVersion);//版本/ N7 t# d; x* l; y, E; ?
  31.       printf("pCardInfo.BlockNbr = %u\n",pCardInfo.BlockNbr);//SD卡块数2 L, J7 K, n* Z
  32.       printf("pCardInfo.BlockSize = %u\n",pCardInfo.BlockSize);//每一块大小7 M, o! P9 |$ j/ ?9 d
  33.       /*------------------- SD DMA 写测试-------------------------------------*/5 @5 J! o( ?7 B2 l" l6 f$ z0 d0 R
  34.       memset(SDBUF_TX, 0x2, SDBUF_SIZE );( Y4 T, Z6 g- u6 ?4 H
  35.       DMA_SEND_OK = 0;  //设置发送完成标志位为0,完成时为1
    % O; S' Q& C. F' ?! B3 S/ t4 m0 M, y
  36.        /**/ v* ]% a/ K. Y) g" Y6 l
  37.        //函数原型3 v: X( ~2 x# m1 A
  38.        *HAL_StatusTypeDef HAL_SD_WriteBlocks_DMA(SD_HandleTypeDef *hsd, uint8_t *pData, 3 Z8 A) e) W7 \) C& Q
  39.                                              uint32_t BlockAdd, uint32_t NumberOfBlocks)
    ' \# d  o4 k' R( j
  40.       
    9 Y  _+ s% ?! o9 q" r
  41.         * @param  hsd Pointer to SD handle
    1 F$ |# y8 @, O/ f% s$ ~
  42.         * @param  pData Pointer to the buffer that will contain the data to transmit
      W; ?# z' K7 [3 y) z; Q( U' f; a0 E
  43.         * @param  BlockAdd Block Address where data will be written  从哪个块开始写
    0 G3 z2 O4 c" q% T5 v
  44.         * @param  NumberOfBlocks Number of blocks to write  写几个块; {& \6 I6 N  ^' j9 z: v9 K7 i4 y. L' j
  45.         * @retval HAL status! g- g5 d% [6 I# I) r
  46.         */, M- x. u  A" R  J6 f0 |
  47.       
    / }* n; [& k2 B4 s) d3 R( B+ d4 E
  48.       if( HAL_SD_WriteBlocks_DMA(&hsd, SDBUF_TX, 0, 1) == HAL_OK )& G# N/ B# k/ m, t% Q, c
  49.       {
    2 Y  l0 o. v' E7 I
  50.           //等待DMA传输完成,并且SD卡状态为传输状态8 L) E7 }2 s" e5 D0 ^7 Q+ B8 ?: A
  51.           while( (DMA_SEND_OK ==0 ) || (HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER));  6 M0 R# u+ J9 `. K$ S
  52.           printf("WriteBlocks Successfully\n");& L) l9 t) |8 D& R' H; ?# r
  53.       ( {2 s9 F  a3 u: x5 U
  54.           for(i=0; i<SDBUF_SIZE; i++)
    / Z8 ?) G2 ~& ^2 B" y2 o0 R
  55.           {
    - Y/ \/ q7 l! L! x* |
  56.             printf("%d ",SDBUF_TX[i]);
    + \1 ~% ?, a7 A9 h* O
  57.           }
    " W# E% `! S& x$ K
  58.           printf("\r\n"); ' {" C9 W6 ?  W0 y+ S9 \
  59.           }3 ]; E/ O/ ~, A3 h+ {) ^2 A
  60.           else0 U0 U- M( b$ `$ }
  61.           {8 a+ E- {/ R% {' T1 }
  62.              printf("WriteBlocks Failed\n");6 G- q. B, n  Q1 [. `) @
  63.           }8 M3 B" W' f; \, d% I+ [& r! Z: v
  64.       
    8 `+ S8 g1 L& E' O
  65.           /*------------------- SD DMA 读测试-------------------------------------*/( y2 I# v5 z% ~+ ]2 s( {* l
  66.           DMA_RCV_OK = 0;   //设置读取完成标志位为0,完成时为1
    . E5 r# ~/ B% P- A* L- U& n. f. \
  67.           if(HAL_SD_ReadBlocks_DMA(&hsd, SDBUF_RX, 0, 1) == HAL_OK)
    * m/ I  ?3 u/ Z/ [& h
  68.           {0 N2 p# B7 U& r$ f! S$ I9 m! H
  69.               while( (DMA_RCV_OK ==0) || (HAL_SD_GetCardState(&hsd) != HAL_SD_CARD_TRANSFER));          0 O5 p+ b9 E5 H
  70.               printf("ReadBlocks Successfully\n");         
    3 L, q/ I, i& x* x# `
  71.               for(i=0; i<SDBUF_SIZE; i++)
    ' U2 K  @. O! ~( N' R8 B9 R
  72.               {
    , ]+ v0 B. T5 r
  73.                 printf("%d ",SDBUF_RX[i]);5 c! g; O  v$ J3 C
  74.               }
    ) |& z" y. b  U! Z8 v* w* d( `
  75.               printf("\r\n");# d- t% j: o4 O/ H/ j' W% Y
  76.            }- {; L  ~+ {  m6 S8 H
  77.             else
    7 j2 D. j! E: J7 Z8 S+ d& T) f) j
  78.             {2 U6 d. R6 v( }5 s/ D( l! W
  79.               printf("ReadBlocks Failed\n");
    ; s. U4 D. L; S
  80.             }& q, i5 @6 f( _$ ]# B9 A4 v
  81.             while (1){}
    / H' J" s1 o) C2 O* K
  82. }
复制代码
: u( u6 A6 ]8 _  V! N( v# G& S4 H

  1. 9 W' ^7 q5 L' u% }: b
  2. //sdio.c
    , j+ T! s* A" ^# j
  3. : B) V9 U: a) ~
  4. extern uint8_t DMA_SEND_OK, DMA_RCV_OK;. c# P, a. I' h6 w1 {
  5. //发送完成中断处理2 h6 {* b0 Y* s4 t( K7 E6 m' _
  6. void HAL_SD_TxCpltCallback(SD_HandleTypeDef *hsd). G/ x2 z8 q3 T; |' ?3 j& [
  7. {8 p7 O/ `+ o0 d) s
  8.   DMA_SEND_OK = 1;
    0 r' l' [9 \0 M8 Q% B3 N3 E
  9. }( I  L( K$ e- R4 e0 x; j2 F
  10. //接收完成中断处理3 Z* r7 d' ?3 |2 G4 `
  11. void HAL_SD_RxCpltCallback(SD_HandleTypeDef *hsd). n% e* V6 X0 v; @3 ^
  12. {$ |! I# y% s" V+ `$ w8 n! @5 j
  13.   DMA_RCV_OK = 1;
    9 o, H. I" N/ q) v* r6 X$ ?8 J; Q& f0 w
  14. }
复制代码

' V+ p5 z0 a+ K7 [至此,ARM开发进阶知识已全部更新完毕!下一系列介绍物联网操作系统开发!! O* w% K/ ]" {) K* M- L8 l! A$ r

. [! z1 }+ c; s0 J* w3 t
: |' J4 _0 U7 [* O  Y- s" x, E" A
转载自: 骆驼听海. t' s$ I2 D2 @0 B9 J' D- I! ?5 p6 J
如有侵权请联系删除
6 V7 k" L- v6 t! M1 c
赞 收藏 评论0 发布时间:2023-4-11 19:23

举报

0个回答

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版