stm32读写SD卡(SPI模式)

已于 2023-08-25 17:30:07 修改
阅读量3.7k 收藏 54
点赞数 8
分类专栏： 透明的stm32 文章标签： stm32 嵌入式硬件 单片机
于 2023-07-07 10:56:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30095023/article/details/131591790
版权

目录

一、SD卡简介

二、源码下载

三、移植条件

1、芯片参数

2、硬件连接

四、驱动代码

1、依赖宏如下

2、驱动代码实现

3、测试代码

4、运行截图

一、SD卡简介

SD卡有SD驱动模式和SPI驱动模式，本例中使用SPI模式驱动SD卡。

二、源码下载

https://download.csdn.net/download/qq_30095023/88014550

三、移植条件

1、芯片参数

芯片类型：STM32F103VET6。

flash大小为512KB,RAM大小 64KB。

2、硬件连接

本例使用TFT屏幕上的SD卡插口，测试所用SD卡容量大小为4GB。

 SD_CS、SPI_MOSI、SPI_MISO、SPI_CLK 与单片机连接。note:请确保屏幕电源连接正常。

如上图，红色框框所标记区域为TFT屏幕SD卡的SPI接口，将此接口与STM32单片机的SPI所对应的IO连接。

四、驱动代码

note: u8 、u16、u32等为自定义数据类型，编译报错请按需修改。LOG_XX为日志打印，请按需替换。

1、依赖宏如下

定义一些操作SD卡的命令和SD卡的类型。

//CMD定义
#define CMD0        0//卡复位
#define CMD1        1
#define CMD8        8//命令8 ，SEND_IF_COND
#define CMD9        9//命令9 ，读CSD数据
#define CMD10       10//命令10，读CID数据
#define CMD12       12//命令12，停止数据传输
#define CMD16       16//命令16，设置SectorSize 应返回0x00
#define CMD17       17//命令17，读sector
#define CMD18       18//命令18，读Multi sector
#define CMD23       23//命令23，设置多sector写入前预先擦除N个block
#define CMD24       24//命令24，写sector
#define CMD25       25//命令25，写Multi sector
#define CMD41       41//命令41，应返回0x00
#define CMD55       55//命令55，应返回0x01
#define CMD58       58//命令58，读OCR信息
#define CMD59       59//命令59，使能/禁止CRC，应返回0x00

//SD卡类型
#define ERR         0x00
#define MMC         0x01
#define V1          0x02
#define V2          0x04
#define V2HC        0x06

2、驱动代码实现

1）、ENTER_SD_BLOCK_SIZE定义SD卡的物理扇区大小为512Byte。

2）、函数SPI_Enable_T用来使能SPI接口，在SDinit的时候需要调用。

3）、函数inline u8 SPI_WriteByte_T用来单片机通过SPI读写SD卡，这里使用内联方式，减少函数调用过程中时间代价，有效提高SD卡的读写速率。关于inline关键字的详细用法请参考：

C语言基础知识--inline(内联)关键字_BIN-XYB的博客-CSDN博客

4）、 函数b_sd_read_write_byte用来读写数据。

5）、函数b_sd_send_cmd用来发送指令给SD卡。

6）、函数b_sd_read_data用来从SD卡读取指定长度的数据。

7）、函数b_sd_send_block_data用来向SD卡写入数据。

8）、函数b_sd_set_speed用来配置SPI通信速度。

9）、函数b_sd_init用来初始化SD卡，需要在使用SD卡前调用一次。

10）、函数b_sd_get_cid用来查询SD卡的CID。

11）、函数b_sd_get_csd用来查询SD卡的CSD。

12）、函数b_sd_read_sector用来读扇区数据，该接口一般用于FatFs文件系统。

13）、函数b_sd_write_sector用来写扇区数据，该接口一般用于FatFs文件系统。

FatFs文件系统移植请参考：FatFs移植到STM32(SD卡)_BIN-XYB的博客-CSDN博客

14）、函数b_sd_get_sector_number用来查询SD卡的扇区数量。

15）、函数b_sd_sync_data用来保存SD卡的数据。

完整源码如下：

#define ENTER_SD_BLOCK_SIZE      (512)
#define ENTER_SD_SECTOR_SIZE     (ENTER_SD_BLOCK_SIZE)


#define GPIO_TYPE      GPIOD   //GPIO组类型
#define SD_CS          SD_CS_Pin//片选引脚PD8
#define SPI            hspi2   //spi设备

#define SD_CS_DISABLE()         GPIO_TYPE->BSRR=SD_CS//GPIO置位（拉高）
#define SD_CS_ENABLE()          GPIO_TYPE->BRR=SD_CS//GPIO复位（拉低）

static u8 SPI_Enable_T(SPI_HandleTypeDef *hspi)
{
    if ((hspi->Instance->CR1 & SPI_CR1_SPE) != SPI_CR1_SPE)
    {
      __HAL_SPI_ENABLE(hspi);
    }
    return 0;
}

static inline u8 SPI_WriteByte_T(SPI_HandleTypeDef* hspi,u8 Byte)
{
    while((hspi->Instance->SR&SPI_FLAG_TXE)==RESET);//等待发送区空
    hspi->Instance->DR=Byte;//发送一个byte 
    while((hspi->Instance->SR&SPI_FLAG_RXNE)==RESET);//等待接收完一个byte
    return hspi->Instance->DR;//返回收到的数据
}

#define SPI_WriteByte(spi_x, data) SPI_WriteByte_T(&spi_x, data)
#define SPI_Enable(spi_x) SPI_Enable_T(&spi_x)

u8 b_sd_read_write_byte(u8 tx_data)
{
    u8 rx_data = SPI_WriteByte(SPI, tx_data);
    return rx_data;
}

static int b_sd_send_cmd(u8 cmd,u32 arg, u8 crc)
{
    u8 r1;
    u8 retry;

    SD_CS_DISABLE();
    b_sd_read_write_byte(0XFF);
    SD_CS_ENABLE();
    do
    {
        retry = b_sd_read_write_byte(0XFF);
    }while(retry!=0xFF);

    b_sd_read_write_byte(cmd | 0x40);
    b_sd_read_write_byte(arg >> 24);
    b_sd_read_write_byte(arg >> 16);
    b_sd_read_write_byte(arg >> 8);
    b_sd_read_write_byte(arg);
    b_sd_read_write_byte(crc);

  if(cmd == CMD12)
    {
        b_sd_read_write_byte(0XFF);
    }
    do
    {
        r1 = b_sd_read_write_byte(0xFF);
    }while(r1 & 0X80);

    return r1;
}

static u8 sd_type = 0;
static u8 b_sd_read_data(u8 *data, u16 len)
{
    u8 r1 = 0;
    SD_CS_ENABLE();
    do
    {
        r1 = b_sd_read_write_byte(0xFF);
    }while(r1 != 0xFE);
    
    while(len--)
    {
        *data = b_sd_read_write_byte(0xFF);
        data++;
    }
    b_sd_read_write_byte(0xFF);
    b_sd_read_write_byte(0xFF);
    return 0;
}

static u8 b_sd_send_block_data(u8* data, u8 cmd)
{
    u16 t;
    u8 r1;
    do{
        r1 = b_sd_read_write_byte(0xFF);
    }while(r1 != 0xFF);

    b_sd_read_write_byte(cmd);
    if(cmd != 0XFD)//不是结束指令
    {
        for(t = 0; t < ENTER_SD_BLOCK_SIZE; t++)
        {
            b_sd_read_write_byte(data[t]);//提高速度,减少函数传参时间
        }
        b_sd_read_write_byte(0xFF);//忽略crc
        b_sd_read_write_byte(0xFF);
        t = b_sd_read_write_byte(0xFF);//接收响应
        if((t & 0x1F) != 0x05)
        {
            return 2;//响应错误
        }
    }
    return 0;//写入成功
}

inline void b_sd_set_speed(u32 speed)
{
    hspi2.Init.BaudRatePrescaler = speed;
}

u8 b_sd_init(void)
{
    u8 r1;
    u8 buff[6] = {0};
    u16 retry; 
    u8 i;

    SPI_Enable(SPI);

    b_sd_set_speed(SPI_BAUDRATEPRESCALER_256);
    SD_CS_DISABLE();
    for(retry = 0; retry < 10; retry++)
    {
        b_sd_read_write_byte(0XFF);
    }
    
    do//SD卡进入IDLE状态
    {
        r1 = b_sd_send_cmd(CMD0 ,0, 0x95);
    }while(r1 != 0x01);
    
    //查看SD卡的类型
    sd_type = 0;
    r1 = b_sd_send_cmd(CMD8, 0x1AA, 0x87);
    if(r1 == 0x01)
    {
        for(i = 0; i < 4; i++)
        {
            buff[i] = b_sd_read_write_byte(0XFF);//Get trailing return value of R7 resp
        }
        if(buff[2] == 0X01 && buff[3] == 0XAA)//卡是否支持2.7~3.6V
        {
            retry = 0XFFFE;
            do
            {
                b_sd_send_cmd(CMD55, 0, 0X01);//发送CMD55
                r1 = b_sd_send_cmd(CMD41, 0x40000000, 0X01);//发送CMD41
            }while(r1 && retry--);
            if(retry && b_sd_send_cmd(CMD58, 0, 0X01) == 0)//鉴别SD2.0卡版本开始
            {
                for(i = 0; i < 4; i++)
                {
                    buff[i] = b_sd_read_write_byte(0XFF);//得到OCR值
                }
                if(buff[0] & 0x40)
                {
                    sd_type = V2HC;
                }else {
                    sd_type = V2;
                }
            }
        }
        else
        {
            b_sd_send_cmd(CMD55, 0, 0X01);//发送CMD55
            r1 = b_sd_send_cmd(CMD41, 0, 0X01);//发送CMD41
            if(r1 <= 1)
            {
                sd_type = V1;
                retry = 0XFFFE;
                do //等待退出IDLE模式
                {
                    b_sd_send_cmd(CMD55, 0, 0X01);//发送CMD55
                    r1 = b_sd_send_cmd(CMD41,0,0X01);//发送CMD41
                }while(r1 && retry--);
            }else//MMC卡不支持CMD55+CMD41识别
            {
                sd_type = MMC;//MMC V3
                retry = 0XFFFE;
                do //等待退出IDLE模式
                {
                    r1 = b_sd_send_cmd(CMD1, 0, 0X01);//发送CMD1
                }while(r1 && retry--);
            }
            if(retry == 0 || b_sd_send_cmd(CMD16, 512, 0X01) != 0)
            {
                sd_type = 0;//错误的卡
            }
        }
    }
    SD_CS_DISABLE();
    b_sd_set_speed(SPI_BAUDRATEPRESCALER_2);
    if(sd_type)
    {
        return HAL_OK;
    }
    else
    {
        return HAL_ERROR;
    }
}

u8 b_sd_get_cid(u8* cid_data)
{
    u8 r1 = b_sd_send_cmd(CMD10, 0, 0x01);//读取CID寄存器
    if(r1 == 0x00)
    {
        r1 = b_sd_read_data(cid_data,16);
    }
    SD_CS_DISABLE();
    if(r1 != 0) 
    {
        return HAL_ERROR;
    }
    else
    {
        return HAL_OK;
    }
}

u8 b_sd_get_csd(u8 *csd_data)
{
    u8 r1 = b_sd_send_cmd(CMD9, 0, 0x01);//发CMD9命令，读CSD寄存器
    if(r1 == 0)
    {
        r1 = b_sd_read_data(csd_data, 16);//接收16个字节的数据
    }
    SD_CS_DISABLE();//取消片选
    if(r1)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

s32 b_sd_read_sector(u32 sector, u8 number, u8*data, u32 timeout)
{
    u8 r1;
    if(sd_type != V2HC)
    {
        sector <<= 9;//转换为字节地址
    }
    if(number == 1)
    {
        r1 = b_sd_send_cmd(CMD17, sector, 0X01);//读命令
        if(r1 == 0)//指令发送成功
        {
            r1 = b_sd_read_data(data, ENTER_SD_SECTOR_SIZE);//接收512个字节
        }
    }
    else
    {
        r1 = b_sd_send_cmd(CMD18, sector, 0X01);//连续读命令
        do
        {
            r1 = b_sd_read_data(data, ENTER_SD_SECTOR_SIZE);//接收512个字节
            data += ENTER_SD_SECTOR_SIZE;
        }while(--number && r1 == 0);
        b_sd_send_cmd(CMD12, 0, 0X01);//发送停止命令
    }
    SD_CS_DISABLE();//取消片选
    return HAL_OK;
}


s32 b_sd_write_sector(u32 sector, u8 number, u8 *data, u32 timeout)
{
    u8 r1;
    if(sd_type != V2HC)
    {
        sector *= ENTER_SD_SECTOR_SIZE;//转换为字节地址
    }

    if(number == 1)
    {
        r1 = b_sd_send_cmd(CMD24, sector, 0X01);//读命令
        if(r1 == 0)//指令发送成功
        {
            r1 = b_sd_send_block_data(data, 0xFE);//写512个字节
        }
    }else
    {
        if(sd_type != MMC)
        {
            b_sd_send_cmd(CMD55, 0, 0X01);
            b_sd_send_cmd(CMD23, number, 0X01);//发送指令
        }
        r1 = b_sd_send_cmd(CMD25, sector, 0X01);//连续读命令
        if(r1 == 0)
        {
            do
            {
                r1 = b_sd_send_block_data(data, 0xFC);//接收512个字节
                data += ENTER_SD_SECTOR_SIZE;
            }while(--number && r1 == 0);
            r1 = b_sd_send_block_data(0, 0xFD);//接收512个字节
        }
    }   
    SD_CS_DISABLE();//取消片选
    return HAL_OK;
}

u32 b_sd_get_sector_number(void)
{
    u8 csd[16];
    u32 capacity;
    u16 csize;

    //取CSD信息，如果期间出错，返回0
    if(b_sd_get_csd(csd)!=0)
    {
        return 0;
    }
    //如果为SDHC卡，按照下面方式计算
    if((csd[0] & 0xC0) == 0x40)//V2.00的卡
    {
        csize = csd[9] + ((u16)csd[8] << 8) + 1;
        capacity = (u32)csize << 10;//得到扇区数
    }
    else//V1.XX的卡
    {
        u8 n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
        csize = (csd[8] >> 6) + ((u16)csd[7] << 2) + ((u16)(csd[6] & 3) << 10) + 1;
        capacity= (u32)csize << (n - 9);//得到扇区数
    }
    return capacity;
}

u32 b_sd_get_sector_size(void)
{
    return ENTER_SD_SECTOR_SIZE;
}

u32 b_sd_get_block_size(void)
{
    return ENTER_SD_BLOCK_SIZE;
}

u32 b_sd_sync_data(void)
{
    SD_CS_ENABLE();//片选
    do{
        HAL_Delay(5);
    }while(b_sd_read_write_byte(0xFF)!=0xFF);
    SD_CS_DISABLE();//取消片选
    return 0;
}

3、测试代码

void b_sd_test_demo(void)
{
    static u8 test_buffer[ENTER_SD_SECTOR_SIZE] = {0};
    LOG_INFO("start b_sd_init\r\n");
    u8 ret = b_sd_init();
    u8 *p = test_buffer;
    LOG_INFO("b_sd_init:%d\r\n", sd_type);
    
    memset(test_buffer, 0, ENTER_SD_SECTOR_SIZE);
    ret = b_sd_get_cid(test_buffer);
    LOG_INFO("cid:%02X,%02X,%02X,%02X\r\n", p[0],p[1],p[2],p[3]);
    LOG_INFO("cid:%02X,%02X,%02X,%02X\r\n", p[4],p[5],p[6],p[7]);
    LOG_INFO("cid:%02X,%02X,%02X,%02X\r\n", p[8],p[9],p[10],p[11]);
    LOG_INFO("cid:%02X,%02X,%02X,%02X\r\n", p[12],p[13],p[14],p[15]);
    LOG_INFO("b_sd_get_cid:%d\r\n", ret);
    
    memset(test_buffer, 0, ENTER_SD_SECTOR_SIZE);
    ret = b_sd_get_csd(test_buffer);
    LOG_INFO("csd:%02X,%02X,%02X,%02X\r\n", p[0],p[1],p[2],p[3]);
    LOG_INFO("csd:%02X,%02X,%02X,%02X\r\n", p[4],p[5],p[6],p[7]);
    LOG_INFO("csd:%02X,%02X,%02X,%02X\r\n", p[8],p[9],p[10],p[11]);
    LOG_INFO("csd:%02X,%02X,%02X,%02X\r\n", p[12],p[13],p[14],p[15]);
    LOG_INFO("b_sd_get_csd:%d\r\n", ret);

    u32 num = b_sd_get_sector_number();
    LOG_INFO("b_sd_get_sector_number:%d\r\n", num);
}

 测试代码先sd初始化，然后查询cid,csd，再查询SD容量。

4、运行截图

可以看到，成功查到SD数据。

BIN-XYB
关注
  • 8
    点赞
  • 踩
  • 54
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
termux获取sd卡读写权限_stm32 SPI读写储存卡（MicroSD TF卡）
weixin_39629467的博客
11-21 2513
简述花了较长的时间，来弄读写储存卡(大部分教程讲的比较全但是不是很容易懂)，这里希望我的代码经验能够帮助到你。操作分析及实现0.整个流程1、上电以后储存卡的初始化2、如何进行读写实现1.上电以后储存卡的初始化上电给MicroSD卡至少74个时钟信号发送CDM0 (x041)复位发送CMD1 让MicroSD卡进入SPI模式2.如何进行读写这里主要对1,3进行详细的讨论你需要知道的是spi通信是怎样...
STM32 SPI方式读写SD卡
fansongsen的专栏
09-15 7703
前段时间在51上模拟SPI实现了对SD卡的读取，效果还算不错，最近将其移植到STM32上，不过使用硬件SPI和使用软件SPI还是有差别的。   代码如下：   void User_SPIInit(void) {  GPIO_InitTypeDef GPIO_InitStructure;    SPI_InitTypeDef SPI_InitStructure;    RCC_A
STM32在SPI模式下读写SD卡
05-17
这个文档详细介绍了STM32在SPI模式下初始化、读写SD卡的知识，并且还给了这部分的硬件连接图，写得非常详细。
STM32存储左右互搏 SPI总线读写SD/MicroSD/TF卡
Pegasus的软件博客
03-11 1917
SD/MicroSD/TF卡是基于FLASH的一种常见非易失存储单元，由接口协议电路和FLASH构成。市面上由不同尺寸和不同容量的卡，手机领域用的TF卡实际就是MicroSD卡，尺寸比SD卡小，而电路和协议操作则是一样。这里介绍STM32CUBEIDE开发平台HAL库SPI总线操作SD/MicroSD/TF卡的例程。
ESP32学习笔记（44）——SD卡使用（SPI方式
最新发布
2401_85015097的博客
05-16 571
写于 2021 年 8 月 16 日。式知识点，真正体系化！
STM32使用SPI方式读写SD 卡
热门推荐
qq_54496810的博客
12-21 1万+
掌握SD卡协议原理，用STM32F103 完成对SD卡的数据读取（FAT文件模式）
STM32系列文章（ FatFs文件系统——使用SPI读写MicroSD卡）
创客之家
03-28 1334
介绍STM32通过SPI口读取SD卡上的FatFs文件系统
STM32-SPI方式驱动SD卡，包含标准库、HAL库、LL库三种另加HAL库的FATFS代码，共4个工程
03-06
STM32驱动SD卡，使用SPI方式，压缩包内包含标准库、LL库、HAL库三种库的SPI驱动SD卡代码外加HAL库版本的FatFS的代码，作者使用的是正点原子MiniSTM32开发板V2，STM32RBT6那一款，32G的mircosd卡加卡托，已经测试通过！
STM32开发_利用SPI协议读写SD卡、介绍SD卡SPI时序
11-22 1万+
SD卡支持两种总线方式：SD方式与SPI方式。其中SD方式采用6线制，使用CLK、CMD、DAT0~DAT3进行数据通信。而SPI方式采用4线制，使用CS、CLK、DataIn、DataOut进行数据通信。SD方式时的数据传输速度与SPI方式要快，采用单片机对SD卡进行读写时一般都采用SPI模式。采用不同的初始化方式可以使SD卡工作于SD方式或SPI方式。
SD卡SPI模式入门教程
阿荣嵌入式
09-24 1万+
SD卡简介 SD卡是一种基于半导体快闪记忆器的新一代记忆设备，英文全称Secure Digital Memory Card，中文名又称安全数码卡。 尺寸分类 按尺寸分类，SD卡分为：标准尺寸，Mini SD，Micro SD（TF卡）。 SD卡和TF卡有哪些区别呢？ SD卡和TF卡主要有以下区别和联系： 卡体尺寸不同，SD卡要比TF卡大（TF卡称作Micro SD card）； 管教定义不同；SD卡管脚要比TF卡多； TF卡插入卡套可作为SD卡使用；反之则不行。 在嵌入式领域，尤其是小设备，通常使用T
SD卡 SPI模式操作（1）初始化SD卡
Simgo的博客
02-01 4748
SPI模式是MCU在没有SDIO的情况下控制MMC和SD卡的备用操作模式。比起SDIO模式，SPI模式的传输协议稍微简单一些，代价是传输速度也会变慢。本文将介绍如何让SD卡在SPI模式下使用。
【嵌入式】用STM32F103c8t6芯片完成对SD卡的数据读写
qq_59531651的博客
12-23 1万+
目录（一）SD卡协议1、SD卡的体系架构2、SD卡寄存器列表3、SD卡初始化（SPI模式）4、SD卡读写（SPI模式）（二）STM32CubeMX（三）Keil代码修改（四）电路连接（五）烧录运行结果（六）心得体会（七）参考链接 （一）SD卡协议 SD Host Controller Simplified Specification（以下简称：主机协议）用来标准化SD主机控制器，针对的是SD卡主机控制器厂商。这个协议不是强制的，在我们阅读SD驱动代码的时候，如果涉及到SD卡主机控制的代码，我们可能需要翻一下
卡spi驱动代码_stm32 SPI读写储存卡（MicroSD TF卡）
weixin_32696821的博客
01-06 1265
简述花了较长的时间，来弄读写储存卡(大部分教程讲的比较全但是不是很容易懂)，这里希望我的代码经验能够帮助到你。操作分析及实现0.整个流程1、上电以后储存卡的初始化2、如何进行读写实现1.上电以后储存卡的初始化上电给MicroSD卡至少74个时钟信号发送CDM0 (x041)复位发送CMD1 让MicroSD卡进入SPI模式2.如何进行读写这里主要对1,3进行详细的讨论你需要知道的是spi通信是怎样...
STM32读写SD卡中的FAT文件_FATFS读写txt_stm32SD_stm32SD卡_
10-03
本节将详细介绍如何使用STM32通过FAT文件系统读写SD卡中的TXT文件。 1. **FATFS文件系统** FAT文件系统（File Allocation Table）是一种常见的磁盘分区格式，包括FAT16、FAT32和VFAT等版本。在STM32中，我们通常...
STM32 SPI读写SD卡
12-18
STM32 SPI读写SD卡是一项常见的嵌入式系统任务，尤其在开发基于STM32微控制器的便携式或数据存储设备时。这个过程涉及STM32与SD卡之间的通信，利用SPI（Serial Peripheral Interface）协议进行数据传输。本文将深入...
STM32cube配置TFAST模式SPI读写SD卡
05-13
总之，STM32Cube配置TFAST模式SPI读写SD卡涉及微控制器的外设选择、参数配置、时钟树设定以及SPI协议的实现。通过正确理解和运用这些知识点，开发者可以构建高效、可靠的嵌入式系统，实现高速数据存储功能。
STM32F10x工程使用SPI方式读写SD卡TF卡.zip
12-07
STM32F10x工程_使用SPI方式读写TF卡SD卡 此程序模板为stm32F103c8t6所用；2.编译环境Keil5.14，库函数版本3.5；3.实现功能：在TF卡/SD卡根目录下创建文件MEng.txt,并把数组bmpheader写入该文件；4.硬件说明：SPI2...
STM32_SPI_SD_card.rar_SD卡 STM32_SD卡SPI_STM32 SPI读写_spi sd卡stm32_
07-15
本篇文章将详细讲解如何利用STM32的SPI接口与SD卡进行通信，实现数据的读写操作。 首先，我们要了解SD卡的工作原理。SD卡是一种非易失性存储设备，广泛应用于移动设备、数码相机等，它通过SPI（Serial Peripheral ...
stm32 SD(SDSC)卡的学习与SPI 模式应用（卡槽介绍）
qq_35653974的博客
09-01 3635
stm32 SD(SDSC)卡的学习与SPI 模式应用（卡槽介绍）
stm32 spi sd卡
09-01
您好！对于在STM32微控制器上使用SPI与SD卡进行通信，您可以按照以下步骤进行操作： 1. 硬件连接：将SD卡的MISO、MOSI、CLK和CS引脚分别连接到STM32的对应SPI引脚。还需要为SD卡提供电源和地线。 2. 配置SPI：在STM32上，您需要初始化并配置SPI接口。您可以使用STM32提供的库函数来实现这一点。确保将SPI设置为主模式，并根据SD卡规范设置传输速率和数据位顺序。 3. 初始化SD卡：为了与SD卡进行通信，您需要发送一系列初始化命令。这些命令包括复位、使能卡片以及设置传输速率等。您可以参考SD卡规范和SD卡供应商的文档来了解这些初始化命令的详细信息。 4. 读写数据：一旦SD卡成功初始化，您可以使用SPI接口发送读写命令和数据。例如，发送读取块命令来读取SD卡上的数据块，或者发送写块命令来向SD卡写入数据块。 需要注意的是，与SD卡通信涉及到一些细节和时序要求，如时钟极性、相位、速率等。确保按照SD卡规范和STM32的要求进行正确设置。 此外，为了方便操作，您还可以使用现成的库函数或第三方库来简化SD卡的读写操作。这些库函数通常提供了更高级的接口，使得读写操作变得更加简单和可靠。 希望以上信息对您有所帮助！如有任何问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值