TF/SD卡开发驱动（SPI）

于 2024-07-16 15:31:56 发布
阅读量337 收藏 11
点赞数 11
分类专栏： 嵌入式模块开发 文章标签： 嵌入式硬件 SD卡
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ender_LJY/article/details/140467803
版权

  1. TF与SD卡本质上来说都是flash类型的存储器

可以理解为TF卡是SD卡的升级版，体积小功能强大，SD卡是传统意义上的存储卡，适用范围比较广，而SD卡的驱动方式有两种 SDIO  和  SPI，同理TF卡也是一样

（在资源足够的情况下，SDIO更适合SD/TF卡）当然SPI也是没问题的

SPI驱动(TF)SD卡

  1. 四线要求，全部外接上拉电阻，建议软件管理片选方便操作

  2. 对于SD卡的SPI模式在上电同步后应该马上进行CM0复位进入SPI模式，SDIO模式这步非必要，复位时序在正常情况下都是要求四线都是高电平，这也是为什么外接上拉电阻的原因，如果CS交给硬件管理，那么只会在发送数据的时候拉低CS，完成马上拉高CS，所以不符合这里的时序，还有一个问题就是MOSI在空闲时必须保持高电平，这点非常重要，就算外接上拉电阻复用后也会被拉下来，因为是输出，默认是输出低电平的，所以在发送时钟脉冲的时候MOSI初始为输入IO口就好了，在需要发送数据之前在复用到SPI上

     时钟脉冲：想一下SPI发送数据的时候是不是SCK,MOSI,MISO这几根线都会跳动，但是这里需要的始终脉冲期间MOSI和CS必须保持高电平，所以是不是我们只要不复用MOSI然后发数据是不是就可以实现SCK的跳动达到脉冲

      SD 卡在初始化的时候，SPI_CLK 的时钟频率不能超过 400KHz（这里非常重要,已经实践过频率过大确实会初始化失败）

3.SPI必须MODE3  初始化的时候 MOSI 和 CS需要自己管理  初始化的话有三种协议 SD V2.0  SD V1.0  MMC

其中 SD V2.0最常见也是目前用的比较多的

SD2.0初始化

1、先对从机 SD 卡发送至少 74 个以上的同步时钟，在上电同步期间，片选 CS 引脚和 MOSI 引脚必须为高电平（MOSI 引脚除发送命令或数据外，其余时刻都为高电平）

2，拉低片选 CS 引脚，发送命令 CMD0（0x40）复位 SD 卡，等待返回数据

3，在接收返回信息期间片选 CS 为低电平，判断数据为复位完成信号 0x01，SD 卡返回响应数据的 8 个时钟周期后再拉高片选 CS 信号，SD 卡进入 SPI 模式。如果返回其他值，重新上一步。

4，拉低片选 CS 引脚，发送命令 CMD8（0x48）查询 SD 卡的版本号，等待返回数据。

5，SD 卡返回响应数据后，先等待 8 个时钟周期再拉高片选 CS 信号，此时判断返回的响应数据，如果为4'b0001,(即2.7V~3.6V), SD卡位2.0版本，否则上一步。

6、拉低片选 CS 引脚，发送命令 CMD55（0x77）告诉 SD 卡下一次发送的命令是应用相关命令，等待返回数据。

7、SD 卡返回响应数据后，先等待 8 个时钟周期再拉高片选 CS 信号，此时判断返回的响应数据。如果返

回的数据为空闲信号 0x01，开始进行下一步

8、拉低片选 CS 引脚，发送命令 ACMD41（0x69）查询 SD 卡是否初始化完成，等待返回数据。

9、SD 卡返回响应数据后，先等待 8 个时钟周期再拉高片选 CS 信号，此时判断返回的响应数据若为0x00,则初始化完成。否则第6步。

SD 卡在初始化的时候，SPI_CLK 的时钟频率不能超过 400KHz，在初始化完成之后，再将 SPI_CLK 的时钟频率切换至SD 卡的最大时钟频率。

以下为复位初始化用到的指令以及对应的返回数据

以下为读数据用到的指令  单块读   

CMD17:

    17|0X40, 块地址，块地址，块地址，块地址，0x01    返回 0x00  其中块地址32位，寻址范围4G多，符合逻辑

多块读

CMD18:

    18|0X40, 块地址，块地址，块地址，块地址，0x01    返回 0x00

停止命令

CMD12:

   12|0x40,0x00,0x00,0x00,0x00,0x01

以下为写数据常用的指令 单块写

CMD24:

24|0X40, 块地址，块地址，块地址，块地址，0x01    返回 0x00

多块写

CMD25:

         25|0X40, 块地址，块地址，块地址，块地址，0x01    返回 0x00

32MB以下的为标准容量 

32MB-4GB为大容量 

这里我驱动的是4GB的大容量TF卡  里面是以块进行区分 一个块占 512byte  地址以此对齐 可以直接写入不需要擦除，数据会自动覆盖  SPI的通信速率最高到12M

写单块方法：

1.发送CMD24，收到0x00表示成功

2.发送若干时钟

3.发送写单块开始字节0xFE

4.发送512个字节数据

5.发送2字节CRC（可以均为0xff）

6.连续读直到读到XXX00101表示数据写入成功

7.继续读进行忙检测（读到0x00表示SD卡正忙），当读到0xff表示写操作完成

写单块时序图：

源码

//***************************************************************************************************************************
//TF卡  SPI通信读取  MISO - PC4  SD_CLK - PC3  MOSI - PC5  CS - PC2  SPI1(1-2)     SPI0(0开头)

SPI_Handle_T hSPI;//SPI句柄
SPI_TransferConfig_T pTransferConfig;//通信参数配置句柄
void SPI0_Init(void)
{
    HAL_CLOCK_PeripheralClockEnable0(SYS_ENCLK0_GPIO);
    HAL_CLOCK_PeripheralClockEnable1(SYS_ENCLK1_SPI1);
    //片选脚自己管理
    HAL_GPIO_Init_Output(GPIOC,GPIO_PIN_2,GPIO_DRIVING_LEVEL0);
    HAL_GPIO_Init_Alternate(GPIOC,GPIO_PIN_3,GPIOC3_AF3_SPI0_SCK);
    HAL_GPIO_Init_Alternate(GPIOC,GPIO_PIN_4,GPIOC4_AF3_SPI0_MISO);
    //SPI控制器配置  MODE 3
    SPI_Config_T pConfig = {0};
    HAL_SPI_GetDefaultConfig(&pConfig,&pTransferConfig,SPI_MASTER_MODE);

    pConfig.mode = SPI_MASTER_MODE;//主模式
    pConfig.format = SPI_FORMAT_MOTOLORA;//SPI模式
    pConfig.polarity = SPI_CLOCK_POLARITY_HIGH;//时钟极性
    pConfig.phase = SPI_CLOCK_PHASE_START;//时钟相位
    pConfig.bitOrder = SPI_BIT_ORDER_MSB;
    pConfig.singleWire = SPI_FULL_DUPLEX;//双线
    pConfig.baudRate = 1000000;//时钟分频 = 200M/50M  SPI输出时钟 = 48/时钟分频  SD 卡在初始化的时候，SPI_CLK 的时钟频率不能超过 400KHz
    HAL_SPI_Init(SPI0_DEV,&pConfig,&hSPI);
    HAL_SPI_TransferConfig(&hSPI,&pTransferConfig);//更新通信配置
    //SPI传输配置
    SPI0_DEV->CTRL &= ~(1<<4);//MSB
    SPI0_DEV->CTRL |= 1;//SPI使能
    hSPI.dataWidth = 1;//数据帧字节大小S
    //hSPI.frameDelay = 1;//延迟帧
    SPI0_NSS_H;
}
//发送1byte数据的同时接收1byte
uint8_t SPI0_Sendread(uint8_t data)
{
    uint32_t count = 200;
    while(!(SPI0_DEV->SR & (1<<8)))//等待发送FIFO为空
    {
        count--;
        TIM2_Delay_ms(1);
        if(count == 0) return 0xaa;
    }
    SPI0_DEV->DR = data & 0xff;
    while(!(SPI0_DEV->SR & (1<<19)))//等待接受FIFO非空
    {
        count--;
        TIM2_Delay_ms(1);
        if(count == 0) return 0xaa;//超时错误值
    }
    return SPI0_DEV->DR & 0xff;
}


//命令数据格式   uint8_t *buff传入装一帧数据的数组地址   
// uint8_t CMD_value 指定命令的序号 比如CMD0就填0  不支持的命令将打印错误
// 返回填充好命令的数据地址
uint8_t * TF_CMD(uint8_t *buff,uint8_t CMD_value)
{
    switch(CMD_value)
    {
    case 0:
        *buff = 0x00 | 0x40;
        *(buff + 1) = 0x00;
        *(buff + 2) = 0x00;
        *(buff + 3) = 0x00;
        *(buff + 4) = 0x00;
        *(buff + 5) = 0x95;
        break; // The CMD res 0X01 (复位成功)
    case 1:
        *buff = 1 | 0x40;
        *(buff + 1) = 0x00;
        *(buff + 2) = 0x00;
        *(buff + 3) = 0x00;
        *(buff + 4) = 0x00;
        *(buff + 5) = 0xff;
        break; // The CMD res 0X01 (复位成功)
    case 8:
        *buff = 8 | 0x40;
        *(buff + 1) = 0x00;
        *(buff + 2) = 0x00;
        *(buff + 3) = 0x01;
        *(buff + 4) = 0xAA;
        *(buff + 5) = 0x87;
        break;//  The CMD res 0X01 0x00 0x00 0x01 0xaa
    case 12:
        *buff = 12 | 0x40;
        *(buff + 1) = 0x00;
        *(buff + 2) = 0x00;
        *(buff + 3) = 0x00;
        *(buff + 4) = 0x00;
        *(buff + 5) = 0x01;
        break;//  停止命令 用来停止多块读
    case 17:
        *buff = 17 | 0x40;
        *(buff + 1) = 0x00;
        *(buff + 2) = 0x00;
        *(buff + 3) = 0x00;
        *(buff + 4) = 0x00;
        *(buff + 5) = 0x01;
        break;//  单块读  中间4字节参数为地址，这里只是初始化  返回0x00
    case 18:
        *buff = 18 | 0x40;
        *(buff + 1) = 0x00;
        *(buff + 2) = 0x00;
        *(buff + 3) = 0x00;
        *(buff + 4) = 0x00;
        *(buff + 5) = 0x01;
        break;//  多块读  中间4字节参数为地址，这里只是初始化  返回0x00
    case 24:
        *buff = 24 | 0x40;
        *(buff + 1) = 0x00;
        *(buff + 2) = 0x00;
        *(buff + 3) = 0x00;
        *(buff + 4) = 0x00;
        *(buff + 5) = 0x01;
        break;//  单块写  中间4字节参数为地址，这里只是初始化  返回0x00
    case 25:
        *buff = 25 | 0x40;
        *(buff + 1) = 0x00;
        *(buff + 2) = 0x00;
        *(buff + 3) = 0x00;
        *(buff + 4) = 0x00;
        *(buff + 5) = 0x01;
        break;//  多块写  中间4字节参数为地址，这里只是初始化  返回0x00
    case 55:
        *buff = 55 | 0x40;
        *(buff + 1) = 0x00;
        *(buff + 2) = 0x00;
        *(buff + 3) = 0x00;
        *(buff + 4) = 0x00;
        *(buff + 5) = 0x01;
        break;//  send ACMD41 之前必须发送该命令
    case 58:
        *buff = 58 | 0x40;
        *(buff + 1) = 0x00;
        *(buff + 2) = 0x00;
        *(buff + 3) = 0x00;
        *(buff + 4) = 0x00;
        *(buff + 5) = 0x01;
        break;//  The CMD res 0X00 0xc0 0xff 0x080 0x00   电压范围 2.7-3.6V
    case 41:      
        *buff = 41 | 0x40;
        *(buff + 1) = 0x40;//高容量40  标准容量 00
        *(buff + 2) = 0x00;
        *(buff + 3) = 0x00;
        *(buff + 4) = 0x00;
        *(buff + 5) = 0x01;
        break;//  The CMD res 0x00 初始化完成  ACMD41发送之前需要发送 CMD55
    default:printf("CMD ERROE!\n");break;
    }
    return buff;
}
//TF卡发送时钟脉冲 同步上电 时钟脉冲个数  时钟脉冲期间CS和MOSI必须为高电平 1num = 8个时钟脉冲
void TF_Send_clocks(uint8_t num)
{
    uint8_t txbuff = 0xff;
    uint8_t rxbuff = 0;
    HAL_GPIO_Init_Input(GPIOC,GPIO_PIN_5,GPIO_NOPULL);//输入模式拉高MOSI
    for(uint8_t i = 0;i < num;i++)
    {
        //HAL_SPI_TransmitReceive(&hSPI,&txbuff,&rxbuff,1,1,TIMEOUT_WAIT_FOREVER);
        SPI0_Sendread(0xff);
    }
}
//TF卡发送命令 并接收相对应的数据  如果匹配则表示命令成功 
// uint8_t CMDNum为命令序号  返回接收到的数据 第一个数据在低位
uint32_t TF_Send_CMD(uint8_t CMDNum)
{
    uint8_t Txbuff[6] = {0};
    uint32_t data = 0;
    
    TF_CMD(Txbuff,CMDNum);//命令填充
    SPI0_NSS_L;//片选拉低开始建立通信
    HAL_GPIO_Init_Alternate(GPIOC,GPIO_PIN_5,GPIOC5_AF3_SPI0_MOSI);//MOSI复用
    for(uint8_t i = 0;i<6;i++)
    {
        SPI0_Sendread(Txbuff[i]);
    }
    HAL_GPIO_Init_Input(GPIOC,GPIO_PIN_5,GPIO_NOPULL);//输入模式拉高MOSI
    SPI0_Sendread(0x00);//等待一个8位数据后接收数据
    data |= SPI0_Sendread(0x00) & 0xff;
    data |= (SPI0_Sendread(0x00) & 0xff) << 8;
    data |= (SPI0_Sendread(0x00) & 0xff) << 16;
    data |= (SPI0_Sendread(0x00) & 0xff) << 24;
    SPI0_NSS_H;//CS拉高后给时钟脉冲
    TF_Send_clocks(2);
    return data;
}
//TF卡一帧数据为6byte   上电初始化复位TF卡  SPI的输入输出脚已经被外接上拉电阻 还有CS也被上拉
void TF_RES_Init(void)
{
    uint32_t data = 0;
    uint8_t num = 250;
    uint8_t res = 0;
    uint8_t count = 0;
    SPI0_Init();
    L:
    TIM2_Delay_ms(300);//等待上电稳定
    //发送大于74个时钟脉冲
    TF_Send_clocks(30);
    data = TF_Send_CMD(0);//发送命令0
    if((data & 0xff) == 0x01)
    {
        res = 1;
    }
    //复位成功 进入IDLE状态
    if(res)
    {
        data = TF_Send_CMD(8);//CMD 8 查询是否2.0SD卡还是MMC卡
        if((data & 0x0f) == 0x01)//SD V2.0
        {
            while(num--)
            {
                data = TF_Send_CMD(55);
                if((data & 0xff) == 0x01)//表示使用ACMD命令
                {
                    data = TF_Send_CMD(41);
                    if((data & 0xff) == 0x00)
                    {
                          printf("SD-SPI V2.0 Init 0K  2.7~3.3V!\n");
                          //初始化完可以进行提速
                          SPI0_DEV->CTRL &= ~1;//SPI失能能
                          SPI0_DEV->BR = 4;// 总线48Mhz 这里是分频 如果通信不稳定就降低速率 这里只能填偶数
                          SPI0_DEV->CTRL |= 1;//SPI使能
                          TF_Send_clocks(50);//时钟脉冲
                        return;
                    }
                }
            }
            printf("SD V2.0 ERROR!\n");
        }
        else//SD V1.X/MMC V3
        {
             TF_Send_CMD(55);
             data = TF_Send_CMD(41);
             if((data & 0xff) <= 0x01)// 1 || 0 表示进入 SD V1.0
             {
                while(num--)
                {
                    data = TF_Send_CMD(55);
                    if((data & 0xff) == 0x01)//表示使用ACMD命令
                    {
                        data = TF_Send_CMD(41);
                        if((data & 0xff) == 0x00)
                        {
                            printf("SD-SPI V1.0 Init 0K!\n");
                            return;
                        }
                    }
                }
                printf("SD V1.0 ERROR!\n");
            }
            else//MMC卡不支持 CMD55 + CMD41
            {
                 data = TF_Send_CMD(1);//CMD1
                 while(num--)
                 {
                    if(data == 0x00)
                    {
                        printf("MMC-SPI Init 0K!\n");
                        return;
                    }
                    data = TF_Send_CMD(1);
                 }
                 printf("MMC ERROR!\n");
            }
         }
    }
    else
    {
        count++;
        if(count < 3)
        {
            goto L;
        }
        else
        {
            SPI0_NSS_H;
            TF_Send_clocks(2);
            printf("RES_ERROR\n");
        }
    }
}

//读取块数据  一块读 512byte  返回0读取成功
//uint32_t chunkaddr 要读取的块地址 1表示块1的地址   
//uint8_t *Rbuff 读取数据的缓冲区
uint8_t TF_Readdata(uint32_t chunkaddr,uint8_t *Rxbuff)
{
    uint8_t Tbuff[6] = {0};
    uint8_t data = 0xff;
    uint8_t num = 20;
    uint16_t delay = 500;//超时判断值
    
    chunkaddr *= 512;
    
    TF_CMD(Tbuff,17);//CMD17填充
    Tbuff[1] = chunkaddr >> 24;//地址参数填充
    Tbuff[2] = chunkaddr >> 16;
    Tbuff[3] = chunkaddr >> 8;
    Tbuff[4] = chunkaddr & 0xff;
    // 读取命令填充完毕
    SPI0_NSS_L;//CS拉低开始通信
    HAL_GPIO_Init_Alternate(GPIOC,GPIO_PIN_5,GPIOC5_AF3_SPI0_MOSI);//MOSI复用
    for(uint8_t i = 0;i < 6;i++)
    {
        SPI0_Sendread(Tbuff[i]);
    }
    HAL_GPIO_Init_Input(GPIOC,GPIO_PIN_5,GPIO_NOPULL);//输入模式拉高MOSI
    SPI0_Sendread(0x00);//等待一个8位数据后接收数据（提速后需要思考这里）
    while(num--)
    {
        data = SPI0_Sendread(0x00);
        if(data == 0)//CMD生效
        {
            while(delay)//开始读
            {
                 data = SPI0_Sendread(0x00);
                 if(data == 0xfe)//数据起始字节
                 {
                     for(uint16_t i = 0;i < 512;i++)
                     {
                         Rxbuff[i] = SPI0_Sendread(0x00);
                     }
                     SPI0_Sendread(0x00);//两个CRC直接忽略
                     SPI0_Sendread(0x00);//两个CRC直接忽略
                     break;
                 }
                 delay--;
            }
            SPI0_NSS_H;//CS拉高结束通信
            TF_Send_clocks(2);//时钟脉冲
            if(delay == 0) return 1;
            else return 0;
        }
    }
    SPI0_NSS_H;//CS拉高结束通信
    TF_Send_clocks(2);//时钟脉冲
    return 1;
}
//写入数据到块  一次写一块 512byte  返回0写入成功
//uint32_t chunkaddr 要写入的块地址 1表示块1的地址   
//uint8_t *Rbuff 写入数据的缓冲区 最少512
uint8_t TF_Writedata(uint32_t chunkaddr,uint8_t *Txbuff)
{
    uint8_t Tbuff[6] = {0};
    uint8_t data = 0xff;
    uint8_t num = 20;
    uint16_t delay = 500;//超时判断值
    chunkaddr *= 512;
    
    TF_CMD(Tbuff,24);//CMD24填充
    Tbuff[1] = chunkaddr >> 24;//地址参数填充
    Tbuff[2] = chunkaddr >> 16;
    Tbuff[3] = chunkaddr >> 8;
    Tbuff[4] = chunkaddr & 0xff;
    // 读取命令填充完毕
    SPI0_NSS_L;//CS拉低开始通信
    HAL_GPIO_Init_Alternate(GPIOC,GPIO_PIN_5,GPIOC5_AF3_SPI0_MOSI);//MOSI复用
    for(uint8_t i = 0;i < 6;i++)
    {
        SPI0_Sendread(Tbuff[i]);
    }
    HAL_GPIO_Init_Input(GPIOC,GPIO_PIN_5,GPIO_NOPULL);//输入模式拉高MOSI
    SPI0_Sendread(0x00);//等待一个8位数据后接收数据（提速后需要思考这里）
    while(num--)
    {
        data = SPI0_Sendread(0x00);
        if(data == 0)//CMD生效
        {
            TF_Send_clocks(2);//发送一点时钟脉冲
            HAL_GPIO_Init_Alternate(GPIOC,GPIO_PIN_5,GPIOC5_AF3_SPI0_MOSI);//MOSI复用
            SPI0_Sendread(0xFE);//开始字节
            for(uint16_t i = 0;i<512;i++)
            {
                SPI0_Sendread(Txbuff[i]);
            }
            SPI0_Sendread(0xff);//两个CRC
            SPI0_Sendread(0xff);//两个CRC
            HAL_GPIO_Init_Input(GPIOC,GPIO_PIN_5,GPIO_NOPULL);//输入模式拉高MOSI
            while(delay)
            {
                data = SPI0_Sendread(0xff);//连续读
                if((data & 0x1f) == 0x05)//表示写操作成功
                {
                    while(delay)
                    {
                        data = SPI0_Sendread(0xff);//连续读
                        if(data == 0xff)//直到不忙碌
                        {
                            break;
                        }
                        delay--;
                    }
                    break;
                }
                delay--;
            }
            SPI0_NSS_H;//CS拉高结束通信
            TF_Send_clocks(2);//时钟脉冲
            if(delay == 0) return 1;
            else return 0;
        }
    }
    printf("CMD ERROR\n");
    SPI0_NSS_H;//CS拉高结束通信
    TF_Send_clocks(2);//时钟脉冲
    return 1;
}
//读取块数据  一块读 512byte  返回0读取成功
//uint32_t chunkaddr 要读取的块地址 1表示块1的地址   
//uint8_t *Rbuff 读取数据的缓冲区
//uint32_t chunklen 为要读取的块数量
uint8_t TF_ReadSector(uint32_t chunkaddr,uint8_t *Rxbuff,uint32_t chunklen)
{
    uint8_t res = 1;
    if(chunklen == 0) return 1;
    while(chunklen)
    {
       res = TF_Readdata(chunkaddr,Rxbuff);
       chunkaddr += 1;
       Rxbuff += 512;
       chunklen--;
    }
    
    return res;
}
//写入数据到块  一次写一块 512byte  返回0写入成功
//uint32_t chunkaddr 要写入的块地址 1表示块1的地址   
//uint8_t *Rbuff 写入数据的缓冲区 最少512
//chunklen 要写入块的数量
uint8_t TF_WriteSector(uint32_t chunkaddr,uint8_t *Txbuff,uint32_t chunklen)
{
    uint8_t res = 1;
    if(chunklen == 0) return 1;
    while(chunklen)
    {
       res = TF_Writedata(chunkaddr,Txbuff);
       chunkaddr += 1;
       Txbuff += 512;
       chunklen--;
    }
    return res;
}
//******************************************************************************************************************************************************

补充：

后续使用功能的时候发现了一个BUG，就是写好的读写函数在访问14000以上的块地址时失败，且固定失败 返回0x08，但是在这个快地址以下是没有一点问题的，我寻思不是有700多万块嘛，后来找到了原因，

寻址方式不同，我的卡是SDHC大容量卡   之前按字节去寻址 块地址默认乘了一个512  

嵌入式阿役
关注
  • 11
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux驱动开发：掌握SPI通信机制
小灰灰的博客
04-24 888
SPI（Serial Peripheral Interface）是一种同步串行通信接口，用于短距离通信，它支持全双工通信，通常用于传感器、SD卡和液晶屏等外设。SCLK（时钟线）：由主设备提供时钟信号。MOSI（主出从入线）：主设备向从设备发送数据。MISO（主入从出线）：从设备向主设备发送数据。SS（片选线）：主设备通过这条线选择特定的从设备通信。
TF/SD卡stm32的spi程序
12-09
总结，使用STM32的SPI程序与TF/SD卡进行通信涉及到理解SD卡协议、配置STM32的SPI接口、执行初始化序列以及正确处理数据传输。理解这些知识点对于开发基于STM32的嵌入式系统，尤其是需要扩展存储功能的应用至关重要。...
SD/TF卡驱动（一）--------SD卡相关简介
LH_SMD的博客
11-30 7685
一、概要 前段时间公司提出需求需要在EFR32BG22上用到TF卡，但是并不着急，然后以我的性格而言，你要么不说，这一说出扣我就手痒，于是，就。。。。。。 对于SD/TF卡而言，有两种驱动方式：SDIO和SPI，前者更适合SD卡的驱动，更加稳定、快速和方便。但是对于EFR32BG22来说，并没有SDIO的硬件接口，这里只能用SPI来驱动它。 EFR32自带硬件SPI，之前也用它来驱动过ADS1220(一款TI的24位ADC芯片)，有兴趣的可以过去看看： ADS1220驱动代码 可能因为理解不够，在用硬件SP
SD nand 与 SD卡的SPI模式驱动
深圳市雷龙发展有限公司
05-10 1394
首先简单介绍下SD卡和SD nand：SD卡，也称之为内存卡，在早些年间的手机上出现过，主要用来存储数据；SD nand，贴片式SD卡，使用起来和SD卡一致，不同的是采用，通常采用LGA-8封装，尺寸为8mm x 6mm x 0.75mm，重点是采用贴片封装，可以直接贴在板卡上，直接解决了SD卡固定问题，再也不用为SD卡的接触稳定性操心！SD nand 与 SD卡除了封装上的区别，使用起来基本没什么不一样，因此下文中不再做区分，统一以SD nand作为描述。
RT-Thread使用——SPI驱动SD/TF卡挂载文件系统
weixin_44735205的博客
06-21 422
基于RT-Thread操作系统，实现用SPI驱动SD卡并挂载文件系统
Micro SD 卡（TF卡） spi 模式实现方法
11-07
Micro SD卡，又称TF卡，是现代移动设备中常见的存储介质。在SPI（Serial Peripheral Interface）模式下与Micro SD卡通信，能够实现简单、高效的读写操作。以下是实现SPI模式与Micro SD卡交互的关键步骤和注意事项： ...
TF卡SDIO/SPI接口驱动程序和嵌入FATFS文件系统
10-19
在嵌入式系统开发中，TF卡（也称为Micro SD卡）因其小巧的尺寸和大容量存储能力，常被用于扩展设备的存储空间。本文将深入探讨TF卡的SDIO和SPI接口驱动程序的实现，以及如何将FATFS文件系统嵌入到这样的驱动程序中，...
sdcard驱动，支持SD卡、TF卡
08-13
本文将深入探讨如何为STM32开发SD卡和TF卡驱动程序，以及如何利用`sdcad.c`和`sdcad.h`这两个关键文件来实现这一功能。 首先，我们需要理解SD卡和TF卡的工作原理。它们都是基于MMC（MultiMediaCard）协议，遵循SD...
cmu读写SD/TF 卡(spi方式)
10-23
- PB375A-SDK可能是提供CMU SPI驱动程序和示例代码的软件开发工具包。开发者可以参考其中的API函数和示例，了解如何在具体项目中集成SD/TF卡读写功能。 综上所述，使用SPI方式与SD/TF卡交互涉及到MCU的SPI接口配置...
嵌入式硬件电路常用设计软件
了不起的小白君的博客
07-04 1887
Cadence Allegro是Cadence公司推出的先进PCB（Printed Circuit Board，印刷电路板）设计布线工具，也是目前最高端、最主流的PCB软件代表之一。Multisim是美国国家仪器（NI）有限公司推出的以Windows为基础的仿真工具，适用于板级的模拟/数字电路板的设计工作。Altium Designer（简称AD）是Protel的升级版，是一款集电路原理图设计、PCB设计、嵌入式软件开发以及FPGA设计等功能于一体的综合性设计软件。
简约清新PPT模板，适用于工作总结，工作计划
07-15
【作品名称】：简约清新PPT模板，适用于工作总结，工作计划 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
Android中SQLite使用方法.docx
07-15
数据库
存储图片到SQL-SERVER数据库中.doc
07-15
数据库
【精美排版】sql数据库基础面试题复习题测验题全.docx
07-15
数据库
华北计算机系统工程研究所考研10个学院，65个专业课历年考试真题及答案汇总整理，备考资料题库视频.pdf
07-15
华北计算机系统工程研究所考研10个学院，65个专业课历年考试真题及答案汇总整理，备考资料题库视频.pdf
2204.02810v2.pdf
07-15
2204.02810v2.pdf
VS 2022的limits.h
07-15
limits.h详细内容
Unity稀疏体素化八叉树
最新发布
07-15
遍历速度相当快，因为​​访问树内的任何（体素）节点都保证了 O(log n) 对数时间复杂度（如果后续遍历相邻节点从起始节点而不是根节点进行，则效果会更好）。由于节点数比均匀网格的单元数少得多，因此遍历速度加快，因为覆盖整个空间的节点数更少；因此，需要的遍历时间更少。 它非常节省内存，因为较大的未占用空间不是显式存储的，而是因为没有为该空间分配节点。除此之外，如果我们消除节点总是像体素一样小的限制，较大的占用空间也可以缩小为更大的占用节点。
stm32 spi读写tf卡
04-30
STM32是一种非常强大的微控制器，它支持多种外围设备的连接和控制。其中，SPI通信接口是其中的一种，是一种串行通信协议，它可以实现高速和可靠的数据传输。TF卡（TransFlash卡，也称MicroSD卡）则是一种常见的存储设备，也可以通过SPI接口进行读写操作。下面，我们来具体了解一下如何用STM32实现SPI读写TF卡。 首先，需要在STM32的开发环境中配置SPI通信接口，包括设置时钟频率、设置帧格式（如数据位数、极性等）等。然后，需要通过SPI接口与TF卡进行通信，这个过程可以通过STM32提供的SPI驱动库来实现。通信的具体过程包括向TF卡发送命令（如读写数据）、等待TF卡回应确认等。在操作TF卡时需要特别注意一些细节，比如写入数据时需要先清空原有数据，读取数据时需要判断是否已经读到最后一个扇区等。 总的来说，使用STM32实现SPI读写TF卡需要具备一定的硬件和软件知识。但是，一旦掌握了相关技能，就可以轻松实现高速、可靠的数据传输，为各种嵌入式系统的开发提供有力支持。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值