GPIO模拟SDIO，四通道模式读取SD卡

已于 2024-07-13 08:49:21 修改
阅读量652 收藏 14
点赞数 14
文章标签： c语言
于 2024-07-12 12:00:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bfmipbwvfp/article/details/140374767
版权

用单片机读取SD卡常用SPI模式，特别是在没有SDIO的单片机，几乎成了默认的方法！但SPI模式速度最多25Mbit，很多单片机的spi速率还远达不到25Mbit，很多时候只能忍受Kbit级的速度！而SDIO模式可以4四通模式，这样即使用gpio模拟也很易达到Mbyte的读取速率！

本例用stc32g12k128单片机，24M主频时已经过Mbyte的平均速率，如用spi，只有用24M高高速spi的DMA模式才可以达到！本人找了网上好久没有找到相关的例程，所以自已码了一个，其中参考了前辈们关于sd的知识，代码纯手敲，给各位有须要的参考，如用得到拿去用，不喜勿喷！

核心代码共四个文件：

sdio.h设置接口等，如下。

--------------------------------------------------------分割线--------------------------------------------------#ifndef __SDIO_H
#define __SDIO_H    


#include "..\sys\sys.h"
//#define MAIN_Fosc 24000000UL
//接口定义
sbit SD_D0=P7^0;
sbit SD_D1=P7^1;
sbit SD_D2=P7^2;
sbit SD_D3=P7^3;
sbit SD_da=P7^4;  //读数据指示
sbit SD_EN=P7^5;  //卡插入检测
sbit SD_CMD=P7^6;
sbit SD_SCK=P7^7;

#define SDin P7&0x0f  //用于并行读写
#define SDout P7      //用于并行读写
#define CMDdelay 15  //用于初始化命令时钟脉冲调整。使时钟速率在要求的100-400KHZ；  

void SDioinit(void);
u8 SDread(void);
void SDwrite(u8 dat);
void SDsendcmd(u8 CMD);  //低速速模式发命令
void SDHisendcmd(u8 CMD);//高速模式发命令
void watit_8CR();
u8 SDRScmd(void);
void SDRS_response(u8 dat[17]);
unsigned char crc7_mmc(unsigned char *dat,int length);


#endif

--------------------------------------------------------分割线--------------------------------------------------

sdio.c用gpio模拟sdio时序，如下：：：：：：：：：：：：：：：：：：：：：：：：

/*
此源码用于用gpoi形成基本sdio时序。支持四通道读取，写入。
由于4通道写入的CRC16计算太费资源使得写入对比SPI模式没有优势，所以此例只
使用4通道读取功能，写入没有实现。
*/
#include "sdio.h"
u8 temp=0;
void sdiodelay(void) //用于延时调节命令的时钟，初始化时时钟要在100-400KHZ。
{ 
    u8 us=CMDdelay;
    while(--us);
}    

void SDioinit(void)
{
  SDout=0xff;

}


u8 SDread(void) //四通道读取1byte数据
{ 
    SD_SCK=0;
    SD_SCK=1;
  temp=SDout&0x0f;
    SD_SCK=0;
    temp<<=4;
  SD_SCK=1;
    return(SDout&0x0f|temp);

}


void SDwrite(u8 dat) //四通道写入取1byte数据
{ 
  
    SD_SCK=0;
    SDout=SDout&0xf0|(dat>>4);
    SD_SCK=1;
    dat&=0x0f;
    SD_SCK=0;
    SDout=SDout&0xf0|dat;
  SD_SCK=1;
    

}

void SDsendcmd(u8 CMD)  //限速发送接收，用于初始化时使用
{ 

    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    sdiodelay();
    SD_SCK=1;
  sdiodelay();    
    CMD<<=1;
    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    sdiodelay();
    SD_SCK=1;
  sdiodelay();    
    CMD<<=1;
    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    sdiodelay();
    SD_SCK=1;
  sdiodelay();    
    CMD<<=1;
    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    sdiodelay();
    SD_SCK=1;
  sdiodelay();    
    CMD<<=1;
    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    sdiodelay();
    SD_SCK=1;
  sdiodelay();    
    CMD<<=1;
    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    sdiodelay();
    SD_SCK=1;
  sdiodelay();    
    CMD<<=1;
    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    sdiodelay();
    SD_SCK=1;
  sdiodelay();    
    CMD<<=1;
    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    sdiodelay();
    SD_SCK=1;
  sdiodelay();    
    CMD<<=1;    
    
}
void SDHisendcmd(u8 CMD)   //全速发送命令
{ 
    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    SD_SCK=1;
  CMD<<=1;
    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    SD_SCK=1;
  CMD<<=1;
    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    SD_SCK=1;
  CMD<<=1;
    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    SD_SCK=1;
  CMD<<=1;
    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    SD_SCK=1;
  CMD<<=1;
    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    SD_SCK=1;
  CMD<<=1;
    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    SD_SCK=1;
  CMD<<=1;
    SD_SCK=0;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    SD_SCK=1;
  CMD<<=1;
    
}


void watit_8CR()  //等待8个时钟周期。
{ 
  u8 temp=0xff,CMD=0xff,i=8;
    
    while(i--)
    {
    SD_SCK=1;
  (CMD&0x80)?SD_CMD=1:SD_CMD=0;
    temp<<=1;    
    sdiodelay();
    SD_SCK=0;    
    sdiodelay();
    temp|=SD_CMD;
    CMD<<=1;    

    }

    
}
u8 SDRScmd(void)  //接收回复，用于初始化时和设置卡。


{ 
  u8 temp;
    
    SD_SCK=0;    
  sdiodelay();    
  temp<<=1;
    SD_SCK=1;
  sdiodelay();
    temp|=SD_CMD;
    SD_SCK=0;    
  sdiodelay();    
  temp<<=1;
    SD_SCK=1;
  sdiodelay();
    temp|=SD_CMD;
    SD_SCK=0;    
  sdiodelay();    
  temp<<=1;
    SD_SCK=1;
  sdiodelay();
    temp|=SD_CMD;
    SD_SCK=0;    
  sdiodelay();    
  temp<<=1;
    SD_SCK=1;
  sdiodelay();
    temp|=SD_CMD;
    SD_SCK=0;    
  sdiodelay();    
  temp<<=1;
    SD_SCK=1;
  sdiodelay();
    temp|=SD_CMD;
    SD_SCK=0;    
  sdiodelay();    
  temp<<=1;
    SD_SCK=1;
  sdiodelay();
    temp|=SD_CMD;
    SD_SCK=0;    
  sdiodelay();    
  temp<<=1;
    SD_SCK=1;
  sdiodelay();
    temp|=SD_CMD;
    SD_SCK=0;    
  sdiodelay();    
  temp<<=1;
    SD_SCK=1;
  sdiodelay();
    temp|=SD_CMD;
    
    return temp;
    
}


void SDRS_response(u8 dat[17]) //接收回复
{u8 i=500,j=8;
    
    while(i--)
    {
  SD_SCK=0;    
  sdiodelay();    
    SD_SCK=1;
    sdiodelay();
        if(SD_CMD==0)//返回开始
            {  
              dat[0]<<=1;
                    dat[0]|=SD_CMD;
                    SD_SCK=0;
                    sdiodelay();
                
                    SD_SCK=1;
                    sdiodelay();
                  dat[0]<<=1;
                    dat[0]|=SD_CMD;
                                    SD_SCK=0;
                    sdiodelay();
                    SD_SCK=1;
                    sdiodelay();
                  dat[0]<<=1;
                    dat[0]|=SD_CMD;
                                    SD_SCK=0;
                    sdiodelay();
                    SD_SCK=1;
                    sdiodelay();
                  dat[0]<<=1;
                    dat[0]|=SD_CMD;
                                    SD_SCK=0;
                    sdiodelay();
                    SD_SCK=1;
                    sdiodelay();
                  dat[0]<<=1;
                    dat[0]|=SD_CMD;
                                        SD_SCK=0;
                    sdiodelay();
                    SD_SCK=1;
                    sdiodelay();
                  dat[0]<<=1;
                    dat[0]|=SD_CMD;
                                        SD_SCK=0;
                    sdiodelay();
                    SD_SCK=1;
                    sdiodelay();
                  dat[0]<<=1;
                    dat[0]|=SD_CMD;
                                        SD_SCK=0;
                    sdiodelay();
                    SD_SCK=1;
                    sdiodelay();
                  dat[0]<<=1;
                    dat[0]|=SD_CMD;
        
            
                for(j=1;j<17;j++)dat[j]=SDRScmd();
                break;
            }
        
    }
    
    
}    

unsigned char crc7_mmc(unsigned char *dat,int length) //用于计算发送命令时的CRC7
{
    u8 i;
    u8 crc = 0;        // Initial value
    while (length--)
    {
        crc ^= *dat++;        // crc ^= *data; data++;
        for (i = 0; i < 8; i++)
        {
            if (crc & 0x80)
                crc = (crc << 1) ^ 0x12;        // 0x12 = 0x09<<(8-7) 多项式 x7+x3+1 0x85
            else
                crc <<= 1;
        }
    }
    
    return crc >> 1;
}    


u16 crc16_ccitt(u8 *dat, u16 length)  //CRC-16/CCITT        x16+x12+x5+1
{
    u8 i;
    u16 crc = 0;        // Initial value
    while(length--)
    {
        crc ^= *dat++;        // crc ^= *dat; dat++;
        for (i = 0; i < 8; ++i)
        {
            if (crc & 1)
                crc = (crc >> 1) ^ 0x8408;        // 0x8408 = reverse 0x1021
            else
                crc = (crc >> 1);
        }
    }
    return crc;
}

sd.h为sd卡的基本设置：

#ifndef __SD_H
#define __SD_H
#include "sdio.h"

extern u8 SD_Type;//SD卡的类型 
extern u8 Response[17];//命令返回数组

//错误码定义
//-------------------------------------------------------------
#define INIT_CMD0_ERROR     0x01 //CMD0错误
#define INIT_CMD1_ERROR     0x02 //CMD1错误
#define WRITE_BLOCK_ERROR   0x03 //写块错误
#define READ_BLOCK_ERROR    0x04 //读块错误
//-------------------------------------------------------------


// SD卡类型定义  
#define SD_TYPE_ERR     0X00
#define SD_TYPE_V2      0X04
#define SD_TYPE_V2HC    0X06

//SD传输数据结束后是否释放总线宏定义  
#define NO_RELEASE      0
#define RELEASE         1    


//SD卡回应标记字
#define MSD_RESPONSE_NO_ERROR      0x00
#define MSD_IN_IDLE_STATE          0x01
#define MSD_ERASE_RESET            0x02
#define MSD_ILLEGAL_COMMAND        0x04
#define MSD_COM_CRC_ERROR          0x08
#define MSD_ERASE_SEQUENCE_ERROR   0x10
#define MSD_ADDRESS_ERROR          0x20
#define MSD_PARAMETER_ERROR        0x40
#define MSD_RESPONSE_FAILURE       0xFF     

// SD卡指令表         
#define CMD0    0       //卡复位
#define CMD1    1
#define CMD2    2       //获取CID寄存器
#define CMD3    3       //获取CID寄存器
#define CMD7    7       //获取CID寄存器
#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
#define TRY_TIME 10    //向SD卡写入命令之后，读取SD卡的回应次数，即读TRY_TIME次，如果在TRY_TIME次中读不到回应，产生超时错误，命令写入失败


u8 SD_WaitReady(void);                        //等待SD卡准备
u8 SD_Init(void);                            //初始化
u8 SD_SendCmd(u8 cmd, u32 arg);        //写命令
u8 SDRScmd(void);
void SD_readsent(u32 add);
void SD_readblock(u8 buf[],u32 add);
void SD_readMblock(u8 buf[],u32 add,u32 num);//读多个扇区
#endif

--------------------------------------------------------分割线--------------------------------------------------

sd.c为sd卡的初始化和读取函数实现。

/*
此源码用于用gpoi模拟sdio实现sd卡使用4通道读取功能，写入没有实现（CRC16校检太费时，没有优势）。
由于现市面上的卡都是2.0以上的大容量卡，所以本例只支持2.0版以上SD卡。
*/
#include "sd.h"
//#include ".\src\uart1.h"
//#include "delay.h"

u8 SD_Type=0;//SD卡的类型 
u8 Response[17]={0xff,0xff,0xff,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};//命令返回数组
u16 SD_RCA;  //卡自荐的地址，host 需要保存下来以便后续使用 CMD7 来选中此卡。

///


//等待卡准备好
//返回值:0,准备好了;其他,错误代码
u8 SD_WaitReady(void)
{
    u32 t=500;
  while(t--)SDsendcmd(0xff); 
    return 1;
}


//向SD卡发送一个命令
//输入: u8 cmd   命令 
//      u32 arg  命令参数
//      u8 crc   crc校验值       
//返回值:SD卡返回的响应                                                              
u8 SD_SendCmd(u8 cmd, u32 arg)
{

    u8 Retry=0; 
    u8 crc;
  u8 dat[5];
        Response[0]=0xff;
        dat[0]=(u8)(cmd | 0x40);
        dat[1]=(u8)(arg>>24);
        dat[2]=(u8)(arg>>16);
        dat[3]=(u8)(arg>>8);
        dat[4]=(u8)(arg);
      crc=(crc7_mmc(dat,5)<<1)+1;
    SDsendcmd(dat[0]);       //分别写入命令    最高2位固定为1  
    SDsendcmd(dat[1]);        //命令参数 2-5字节  4个字节 32位
    SDsendcmd(dat[2]);
    SDsendcmd(dat[3]);
    SDsendcmd(dat[4]);      
    SDsendcmd(crc); 
                                     //停止传数据命令
    //if(cmd==CMD12)SDsendcmd(0xff);//Skip a stuff byte when stop reading
      SDRS_response(Response);
      watit_8CR();
    return Response[0];
}

//初始化SD卡
u8 SD_Init(void)
{
  u8 r1;      // 存放SD卡的返回值
  u16 retry;  // 用来进行超时计数

    
     SD_WaitReady();
    r1=SD_SendCmd(CMD0,0);//进入IDLE状态      即复位sd卡 空闲状态
  watit_8CR();
    

     
     SD_Type=0;//默认无卡
     
    
        SD_SendCmd(CMD8,0x1AA);//SD V2.0      发送接口状态命令                                          
                                          //如果返回值为1 则是 SDV2.0版本
      
            if(Response[3]==0x01&&Response[4]==0xaa)//卡是否支持2.7~3.6V
            {  
                 
                retry=64;
         do
                        {
                            SD_SendCmd(55,0x00000000);
                            Response[1]=0x00;
                          SD_SendCmd(41,0x403c0000);
                        }while(((Response[1]&0x80)!=0x80)&& retry--);//OCR[31]=1 时上电操作是否完成
                        
                        //OCR[31]=1 时，OCR[30] (CCS) 指示了卡是否为大容量卡。
                        //CMD8 无响应，ACMD41 响应的 OCR[30]=0 ：SD 1.X 卡。
                        //CMD8 有响应，ACMD41 响应的 OCR[30]=0 ：SD 2.0 非大容量卡。
                        //CMD8 有响应，ACMD41 响应的 OCR[30]=1 ：SDHC 2.0 大容量卡。
                        
                        if(Response[1]&0x40)SD_Type=SD_TYPE_V2HC;//CMD8 有响应，ACMD41 响应的 OCR[30]=1 ：SDHC 2.0 大容量卡。    
                        else SD_Type=SD_TYPE_V2; 
    
                    r1=SD_SendCmd(CMD2,0x00000000); //获取CID寄存器    
                                       //R2 类响应136BIT，其中包含了 CID 寄存器 (如图13) ，是该卡的识别号，host 可以忽略 CID 的内容。
            
                    r1=SD_SendCmd(CMD3,0x00000000);//进入数据传输模式。
                        
                    SD_RCA=((u16)Response[1]<<8)|Response[2]; // 获取RCA (16bit) ，这是卡自荐的地址，host 需要保存下来以便后续使用 CMD7 来选中此卡。
                        
          r1=SD_SendCmd(CMD7,(u32)(SD_RCA)<<16);    //选中卡    
                        
                    r1=SD_SendCmd(55,(u32)(SD_RCA)<<16);  //CMD55，参数必须是RCA
                    r1=SD_SendCmd(6, 0x00000002);    //ACMD6，打开4bit传输模式选中卡
          r1=SD_SendCmd(CMD16,0x00000200);    //设置块为512byte，不能设为其它。
                     //SD_WaitReady();    
                    
            }
        

    
    SDout=0xff;
    if(SD_Type)return 0;    //如果没有采集到SD卡版本 返回0成功。
    else if(r1)return r1; //初始化失败。       
    return 0xaa;//其他错误
}
    

void SD_readblock(u8 buf[],u32 add)//读取一个扇区数据
{
      int i=0,j=-1,cn=0;
        u8 CRC=0;
      u8 dat[5];
    if(SD_Type!=SD_TYPE_V2HC)add <<= 9;//转换为字节地址
        dat[0]=(u8)(17 | 0x40);
        dat[1]=(u8)(add>>24);
        dat[2]=(u8)(add>>16);
        dat[3]=(u8)(add>>8);
        dat[4]=(u8)(add);
      CRC=(crc7_mmc(dat,5)<<1)+1;
    
    SDHisendcmd(dat[0]);//发送读命令
    SDHisendcmd(dat[1]);
  SDHisendcmd(dat[2]);
  SDHisendcmd(dat[3]);
  SDHisendcmd(dat[4]);
  SDHisendcmd(CRC);
    P7=0xff;
    for(i=0;i<1024;i++) // 接收数据
     {
        
        SD_SCK=0;
        SD_SCK=1;    
        if(!SD_D0)
            {    
                  P74=0;
            for(j=0;j<512;j++)
                {
                    SD_SCK=0;
                    SD_SCK=1;
                    buf[j]=SDout;
                    SD_SCK=0;
                    buf[j]<<=4;
                    SD_SCK=1;
                    buf[j]|=(SDout&0x0f);                
                }
                P74=1;
                SDread();
                SDread();//接收crc16，丢弃。
                SDread();
                SDread();
                
                SDread();
                SDread();
                SDread();
                SDread();
                
                SDread();                        
                break;
            }
    }

}

void SD_readMblock(u8 buf[],u32 add,s32 num)//读取num个扇区数据
{
    
      u32 i,j,k=0;
        u8 CRC=0;
      u8 dat[5];
    if(SD_Type!=SD_TYPE_V2HC)add <<= 9;//转换为字节地址
        dat[0]=(u8)(18 | 0x40);
        dat[1]=(u8)(add>>24);
        dat[2]=(u8)(add>>16);
        dat[3]=(u8)(add>>8);
        dat[4]=(u8)(add);
      CRC=(crc7_mmc(dat,5)<<1)+1;
    
    SDHisendcmd(dat[0]);//发送读命令
    SDHisendcmd(dat[1]);
  SDHisendcmd(dat[2]);
  SDHisendcmd(dat[3]);
  SDHisendcmd(dat[4]);
  SDHisendcmd(CRC);
    SDout=0xff;
    num--;    
    for(i=0;i<10240;i++) // 接收数据
     {
        
        SD_SCK=0;
        SD_SCK=1;    
        if(!SD_D0)
            {    
                  P74=0;
            for(j=0;j<512;j++)
                {
                    SD_SCK=0;
                    SD_SCK=1;
                    buf[k]=SDout;
                    SD_SCK=0;
                    buf[k]<<=4;
                    SD_SCK=1;
                    buf[k]|=(SDout&0x0f);    
                    k++;
                }
                P74=1;
                SDread();
                SDread();//接收crc16，丢弃。
                SDread();
                SDread();
                
                SDread();
                SDread();
                SDread();
                SDread();
                
                SDread();                        
                if(num<1)break;
                num--;
            }
    }

        SDHisendcmd(0x4c);//发送读命令CMD12
        SDHisendcmd(0);
        SDHisendcmd(0);
        SDHisendcmd(0);
        SDHisendcmd(0);
        SDHisendcmd(0x61);
    
    for(i=0;i<1024;i++) // 接收数据
     {
        
        SD_SCK=0;
        SD_SCK=1;    
        if(SD_CMD==0)
            {    

             for(j=0;j<64;j++)
                {
                    SD_SCK=0;
                    SD_SCK=1;

                }
                
                break;
                
            }
    }

}

bfmipbwvfp
关注
  • 14
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
STM32F4——SD卡相关操作
任长江
10-20 5266
一、简介：     SD卡从MMC基础发展而来，一种记忆设备，广泛用于便携设备，SD卡按容量分为：SD卡（0~2G）、SDHC卡（2~32G）和SDXC卡（32G~2T）。对于SD的使用过程中相应引脚和对应模式如下图所示： 二、相关寄存器：     对于SD卡相关寄存器如下图所示： 三、SD卡相关操作及指令：     1、初始化；     SD卡的初始化操作是相对比较复杂的，流
GPIO模拟SDIO，四通道模式读取SD卡FATFS的主文件，用于FATFS读取
07-13
GPIO模拟SDIO，四通道模式读取SD卡FATFS的主文件，用于FATFS读取
基于FATFS文件系统使用SDIO的4线模式在SD卡上写入数据（一）
xuxing1993的博客
06-21 2552
第一部分 FATFS系统的特点和原理 FatFs是一个为小型嵌入式系统设计的通用FAT（FileAllocation Table）文件系统模块。FatFs的编写遵循ANSI C，并且完全与磁盘I/O层分开。因此，它独立于硬件构架。它可以被嵌入到低成本的微控制器中，如AVR、8051、PIC、ARM、Z80、68K等等，而不需要做任何修改。 图1.1FATFS示意图 其特点是：
SDIO接口（4）——SDIO通信
dkmknjk的博客
08-31 5829
SD总线上的通信基于命令和数据位流，这些命令和数据位流由起始位启动，并由停止位终止。SDIO总线上的设置和控制都是通过命令来实现，SDIO总线上都是HOST端发起请求，然后DEVICE端回应请求，其中请求和应答中会包含数据信息。...
FPGA基于SDIO-4线模式读写SD卡、TF卡、SDNAND
qq_36703670的博客
03-30 1583
这些易失性存储器使用的频率是最高的，但同时有些非易失性存储器也常常会使用到，一般对于存储参数类的小容量存储器会使用eeprom（iic接口）、flash（spi）接口等。网上基于SD2.0的协议介绍也比较多，在此就不太详细的介绍协议细节，主要介绍FPGA读写SD卡需要的具体内容。 发送 cmd8，如果 sd 卡有响应，则 sd 卡属于 sdhc 类型，并且工作电压正常，初始化工程。如 果 sd 卡无响应，则 sd 卡可能属于 sdsc 类型，或者工作电压不正常，或者当前卡不属于 sd 卡，初始化失败。
STM32F4_SD卡
light_2025的博客
08-28 1382
要使用SD卡制造商特定的ACMD命令，需要在发送该命令之前发送CMD55命令，告知SD卡接下来的命令为特定应用命令，CMD55只对紧接着的第一个命令有效，SD卡如果检测到CMD55之后的命令为ACMD则执行特定应用命令，如果检测发现不是ACMD命令，则执行常规命令GEN_CMD；卡及接口控制单元的8个寄存器只能通过对应的命令去访问，SDIO定义了64个命令，每个命令都有特殊的意义，可以实现某一特定的功能，SD卡接收到命令后，根据命令要求对SD卡内部寄存器进行修改，从而实现SD卡的控制及读写操作；
STM32CUBEMX_SDIO和FATFS_读写SD卡
weixin_50183638的博客
12-29 1308
STM32CUBEMX_SDIO和FATFS_读写SD卡
linux下gpio口模拟spi,stm32 gpio口模拟spi接口程序
weixin_42522964的博客
05-15 286
做单片机开发的时候经常需要用到模拟spi接口，这种写法不错的，很多类似的。#define MOSI_H GPIO_SetBits(GPIOB, GPIO_Pin_10)#define MOSI_L GPIO_ResetBits(GPIOB, GPIO_Pin_10)#define SCLK_H GPIO_SetBits(GPIOB, GPIO_Pin_13)#define SCLK_L GPIO_...
SD卡驱动(SDIO模式)
01-04
在SDIO模式下，SD卡不仅可以作为存储设备，还能支持其他功能如Wi-Fi、GPS等扩展模块。STM32F407系列芯片内置了SDIO接口，提供了硬件层面的支持。 二、STM32F407 SDIO硬件接口 STM32F407的SDIO接口包含多个引脚，如...
STM32F103VET6 单片机 SD卡U盘，通过SDIO 4位接口控制SD卡虚拟为U盘 软件例程源码.rar
03-24
3. **SD卡模式切换**：SD卡可以工作在SPI模式或SDIO模式，这里我们使用SDIO模式，需要发送CMD52和CMD53命令将SD卡切换到4位数据线模式。 4. **块大小设置**：根据应用需求，可以设置不同的块大小，通常有512字节的...
13 SD卡读写-SDIO接口.rar_SDIO_stm32 SDIO_stm32 SD卡_stm32 sdio接口
09-24
STM32是一款基于ARM Cortex-M内核的微控制器，广泛应用于嵌入式系统设计中，尤其是在IoT（物联网）和...掌握这些知识点，开发者就能够有效地利用STM32进行SD卡的数据存储和读取，为嵌入式系统提供可靠的存储方案。
GPIO模拟SPI
yove_12的专栏
05-27 1967
一 SPI协议概括 SPI，是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。是Motorola首先在其MC68HCXX系列处理器上定义的。SPI接口主要应用在 EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，
【stm32】GPIO介绍及使用
最新发布
qq_62917398的博客
07-14 1063
GPIO（General Purpose Input Output）通用输入输出口可配置为8种输入输出模式引脚电平：0V~3.3V，部分引脚可容忍5V输出模式下可控制端口输出高低电平，用以驱动LED、控制蜂鸣器、模拟通信协议输出时序等输入模式下可读取端口的高低电平或电压，用于读取按键输入、外接模块电平信号输入、ADC电压采集、模拟通信协议接收数据等1.LED：发光二极管，正向通电点亮，反向通电不亮发光二极管如何分辨正负极：如果是引脚没有剪过的LED，那其中长脚是正极，短脚是负极。
使用MCU的 GPIO口 模拟SDIO时序读写TF/SD卡的可能性。
thtfcccj的博客
05-11 1162
在SD准备期间，需不间断一直发送频率为100kHz- 400kHz的时钟(约几ms), 以让SD卡初始化，在初始化完成后，时钟频率为0-25MHZ。，发送指令，此函数内部计算好校验码后依次发出，在U8指令信息的b7置位时，接收响应,接收的响应保存入SDIO单例化结构中。上层在带写数据的指令发出后，立即调用此函数写出一块数据，长度固定为512，在内部提交计算好CRC16校验码，在尾部发出。2. 描述中的由host→card共6位指令的“CMDn”，中的n对应0-63，为标准指令，后跟对应32位数据。
STM32F4实现SD卡读写
xhj1021的博客
02-27 5376
熟悉SD卡和SDIO工作原理。掌握SD卡的读写。
使用STM32F407实现USB读卡器功能 SDIO DMA 参考官方例程
热门推荐
slong127的博客
12-21 1万+
刚开始学习使用STM32的USB，之前的USB虚拟串口就折腾了半天，在网上找的资料大部分都不知道从哪直接复制过来的，没有多大参考意义，这次的读卡器也是一样，几乎翻遍了能找到的资料，照猫画虎编辑代码却都不成功，后来发现直接找STM32官方的例程看是最靠谱的，重点：一定要看和自己使用的库版本一致的例程，高手除外。 话不多说，进入主题，首先介绍一下开发环境： 1、keil 版本 5.16 2、cube ...
利用SPI协议读写SD卡
山有木兮
12-23 4105
利用SPI模式SDIO协议读写SD卡
Linux内核（九）WIFI ----- SDIO接口驱动
weixin_43564241的博客
07-05 3964
SDIO接口的WIFI： 1、WIFI是一个sdio卡设备 2、具备wifi功能 SDIO接口的WIFI驱动就是在WIFI外面套上一个SDIO驱动的外壳SDIO部分代码结构： drivers/mmc 下有 mmc卡、sd卡、sdio 卡驱动。 |- mmc | |- card // 因为记忆卡都是块设备，当然需要提供块设备的驱动程序，这部分是实现将你的SD卡如何实现为块设备的 | |- core // 是整个MMC的核心存，
STM32高级篇SDIO模式下的MicroSD卡读取
在本资源中，我们将通过一个实验来演示如何使用STM32微控制器的SDIO接口来读取MicroSD卡。实验中，我们将使用4位数据线模式，通过串口将测试信息打印出来。 硬件连接： * PC12-SDIO-CLK：CLK * PC10-SDIO-D2：DATA...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值