SD卡驱动代码
本文地址：http://dsyn.tongxinmao.com/Article/Detail/id/53
#ifndef _MMC_SD_H_
#define _MMC_SD_H_
#include "stm32f10x.h"
//Mini STM32开发板
//SD卡 驱动
//正点原子@ALIENTEK
//2010/6/13
//SD传输数据结束后是否释放总线宏定义
#define NO_RELEASE 0
#define RELEASE 1
// SD卡类型定义
#define SD_TYPE_MMC 0
#define SD_TYPE_V1 1
#define SD_TYPE_V2 2
#define SD_TYPE_V2HC 4
// SD卡指令表
#define CMD0 0 //卡复位
#define CMD1 1
#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 ACMD23 23 //命令23，设置多sector写入前预先擦除N个block
#define CMD24 24 //命令24，写sector
#define CMD25 25 //命令25，写Multi sector
#define ACMD41 41 //命令41，应返回0x00
#define CMD55 55 //命令55，应返回0x01
#define CMD58 58 //命令58，读OCR信息
#define CMD59 59 //命令59，使能/禁止CRC，应返回0x00
//数据写入回应字意义
#define MSD_DATA_OK 0x05
#define MSD_DATA_CRC_ERROR 0x0B
#define MSD_DATA_WRITE_ERROR 0x0D
#define MSD_DATA_OTHER_ERROR 0xFF
//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
//这部分应根据具体的连线来修改!
//Mini STM32使用的是PA3作为SD卡的CS脚.
//#define SD_CS PAout(3) //SD卡片选引脚
#define SD_CS_PORT GPIOA
#define SD_CS_CLK RCC_APB2Periph_GPIOA
#define SD_CS_PIN GPIO_Pin_3
#define Set_SD_CS {GPIO_SetBits(SD_CS_PORT,SD_CS_PIN);}
#define Clr_SD_CS {GPIO_ResetBits(SD_CS_PORT,SD_CS_PIN);}
extern u8 SD_Type;//SD卡的类型
//函数申明区
u8 SD_WaitReady(void); //等待SD卡就绪
u8 SD_SendCommand(u8 cmd, u32 arg, u8 crc); //SD卡发送一个命令
u8 SD_SendCommand_NoDeassert(u8 cmd, u32 arg, u8 crc);
u8 SD_Init(void); //SD卡初始化
u8 SD_Idle_Sta(void); //设置SD卡到挂起模式
u8 SD_ReceiveData(u8 *data, u16 len, u8 release);//SD卡读数据
u8 SD_GetCID(u8 *cid_data); //读SD卡CID
u8 SD_GetCSD(u8 *csd_data); //读SD卡CSD
u32 SD_GetCapacity(void); //取SD卡容量
//USB 读卡器 SD卡操作函数
u8 MSD_WriteBuffer(u8* pBuffer, u32 WriteAddr, u32 NumByteToWrite);
u8 MSD_ReadBuffer(u8* pBuffer, u32 ReadAddr, u32 NumByteToRead);
u8 SD_ReadSingleBlock(u32 sector, u8 *buffer); //读一个sector
u8 SD_WriteSingleBlock(u32 sector, const u8 *buffer); //写一个sector
u8 SD_ReadMultiBlock(u32 sector, u8 *buffer, u8 count); //读多个sector
u8 SD_WriteMultiBlock(u32 sector, const u8 *data, u8 count);//写多个sector
u8 SD_Read_Bytes(unsigned long address,unsigned char *buf,unsigned int offset,unsigned int bytes);//读取一byte
#endif#include "stm32f10x.h"
#include "mmc_sd.h"
#include "spi.h"
//#include "usart.h"
//#include "SysTickDelay.h"
u8 SD_Type=0;//SD卡的类型
//等待SD卡回应
//Response:要得到的回应值
//返回值:0,成功得到了该回应值
// 其他,得到回应值失败
u8 SD_GetResponse(u8 Response)
{
u16 Count=0xFFF;//等待次数
while ((SPIx_ReadWriteByte(0XFF)!=Response)&&Count)Count--;//等待得到准确的回应
if (Count==0)return MSD_RESPONSE_FAILURE;//得到回应失败
else return MSD_RESPONSE_NO_ERROR;//正确回应
}
//等待SD卡写入完成
//返回值:0,成功;
// 其他,错误代码;
u8 SD_WaitDataReady(void)
{
u8 r1=MSD_DATA_OTHER_ERROR;
u32 retry;
retry=0;
do
{
r1=SPIx_ReadWriteByte(0xFF)&0X1F;//读到回应
if(retry==0xfffe)return 1;
retry++;
switch (r1)
{
case MSD_DATA_OK://数据接收正确了
r1=MSD_DATA_OK;
break;
case MSD_DATA_CRC_ERROR: //CRC校验错误
return MSD_DATA_CRC_ERROR;
case MSD_DATA_WRITE_ERROR://数据写入错误
return MSD_DATA_WRITE_ERROR;
default://未知错误
r1=MSD_DATA_OTHER_ERROR;
break;
}
}while(r1==MSD_DATA_OTHER_ERROR); //数据错误时一直等待
retry=0;
while(SPIx_ReadWriteByte(0XFF)==0)//读到数据为0,则数据还未写完成
{
retry++;
//delay_us(10);//SD卡写等待需要较长的时间
if(retry>=0XFFFFFFFE)return 0XFF;//等待失败了
};
return 0;//成功了
}
//向SD卡发送一个命令
//输入: u8 cmd 命令
// u32 arg 命令参数
// u8 crc crc校验值
//返回值:SD卡返回的响应
u8 SD_SendCommand(u8 cmd, u32 arg, u8 crc)
{
u8 r1;
u8 Retry=0;
Set_SD_CS;
SPIx_ReadWriteByte(0xff);//高速写命令延时
SPIx_ReadWriteByte(0xff);
SPIx_ReadWriteByte(0xff);
//片选端置低，选中SD卡
Clr_SD_CS;
//发送
SPIx_ReadWriteByte(cmd | 0x40);//分别写入命令
SPIx_ReadWriteByte(arg >> 24);
SPIx_ReadWriteByte(arg >> 16);
SPIx_ReadWriteByte(arg >> 8);
SPIx_ReadWriteByte(arg);
SPIx_ReadWriteByte(crc);
//等待响应，或超时退出
while((r1=SPIx_ReadWriteByte(0xFF))==0xFF)
{
Retry++;
if(Retry>200)break;
}
//关闭片选
Set_SD_CS;
//在总线上额外增加8个时钟，让SD卡完成剩下的工作
SPIx_ReadWriteByte(0xFF);
//返回状态值
return r1;
}
//向SD卡发送一个命令(结束是不失能片选，还有后续数据传来）
//输入:u8 cmd 命令
// u32 arg 命令参数
// u8 crc crc校验值
//返回值:SD卡返回的响应
u8 SD_SendCommand_NoDeassert(u8 cmd, u32 arg, u8 crc)
{
u8 Retry=0;
u8 r1;
SPIx_ReadWriteByte(0xff);//高速写命令延时
SPIx_ReadWriteByte(0xff);
Clr_SD_CS;//片选端置低，选中SD卡
//发送
SPIx_ReadWriteByte(cmd | 0x40); //分别写入命令
SPIx_ReadWriteByte(arg >> 24);
SPIx_ReadWriteByte(arg >> 16);
SPIx_ReadWriteByte(arg >> 8);
SPIx_ReadWriteByte(arg);
SPIx_ReadWriteByte(crc);
//等待响应，或超时退出
while((r1=SPIx_ReadWriteByte(0xFF))==0xFF)
{
Retry++;
if(Retry>200)break;
}
//返回响应值
return r1;
}
//把SD卡设置到挂起模式
//返回值:0,成功设置
// 1,设置失败
u8 SD_Idle_Sta(void)
{
u16 i;
u8 retry;
for(i=0;i<0xf00;i++);//纯延时，等待SD卡上电完成
//先产生>74个脉冲，让SD卡自己初始化完成
for(i=0;i<10;i++)SPIx_ReadWriteByte(0xFF);
//-----------------SD卡复位到idle开始-----------------
//循环连续发送CMD0，直到SD卡返回0x01,进入IDLE状态
//超时则直接退出
retry = 0;
do
{
//发送CMD0，让SD卡进入IDLE状态
i = SD_SendCommand(CMD0, 0, 0x95);
retry++;
}while((i!=0x01)&&(retry<200));
//跳出循环后，检查原因：初始化成功？or 重试超时？
if(retry==200)return 1; //失败
return 0;//成功
}
//初始化SD卡
//如果成功返回,则会自动设置SPI速度为18Mhz
//返回值:0：NO_ERR
// 1：TIME_OUT
// 99：NO_CARD
u8 SD_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
u8 r1; // 存放SD卡的返回值
u16 retry; // 用来进行超时计数
u8 buff[6];
//设置硬件上与SD卡相关联的控制引脚输出
//避免NRF24L01/W25X16等的影响
//RCC->APB2ENR|=1<<2; //PORTA时钟使能
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );
//GPIOA->CRL&=0XFFF000FF;
//GPIOA->CRL|=0X00033300;//PA2.3.4 推挽
//GPIOA->ODR|=0X7<<2; //PA2.3.4上拉
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2|GPIO_Pin_3|GPIO_Pin_4;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP ; //推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_SetBits(GPIOA,GPIO_Pin_2);
GPIO_SetBits(GPIOA,GPIO_Pin_3);
GPIO_SetBits(GPIOA,GPIO_Pin_4);
SPIx_Init();
SPIx_SetSpeed(SPI_SPEED_256);//设置到低速模式
Set_SD_CS;
if(SD_Idle_Sta()) return 1;//超时返回1 设置到idle 模式失败
//-----------------SD卡复位到idle结束-----------------
//获取卡片的SD版本信息
Clr_SD_CS;
r1 = SD_SendCommand_NoDeassert(8, 0x1aa,0x87);
//如果卡片版本信息是v1.0版本的，即r1=0x05，则进行以下初始化
if(r1 == 0x05)
{
//设置卡类型为SDV1.0，如果后面检测到为MMC卡，再修改为MMC
SD_Type = SD_TYPE_V1;
//如果是V1.0卡，CMD8指令后没有后续数据
//片选置高，结束本次命令
Set_SD_CS;
//多发8个CLK，让SD结束后续操作
SPIx_ReadWriteByte(0xFF);
//-----------------SD卡、MMC卡初始化开始-----------------
//发卡初始化指令CMD55+ACMD41
// 如果有应答，说明是SD卡，且初始化完成
// 没有回应，说明是MMC卡，额外进行相应初始化
retry = 0;
do
{
//先发CMD55，应返回0x01；否则出错
r1 = SD_SendCommand(CMD55, 0, 0);
if(r1 == 0XFF)return r1;//只要不是0xff,就接着发送
//得到正确响应后，发ACMD41，应得到返回值0x00，否则重试200次
r1 = SD_SendCommand(ACMD41, 0, 0);
retry++;
}while((r1!=0x00) && (retry<400));
// 判断是超时还是得到正确回应
// 若有回应：是SD卡；没有回应：是MMC卡
//----------MMC卡额外初始化操作开始------------
if(retry==400)
{
retry = 0;
//发送MMC卡初始化命令（没有测试）
do
{
r1 = SD_SendCommand(1,0,0);
retry++;
}while((r1!=0x00)&& (retry<400));
if(retry==400)return 1; //MMC卡初始化超时
//写入卡类型
SD_Type = SD_TYPE_MMC;
}
//----------MMC卡额外初始化操作结束------------
//设置SPI为高速模式
SPIx_SetSpeed(SPI_SPEED_4);
SPIx_ReadWriteByte(0xFF);
//禁止CRC校验
r1 = SD_SendCommand(CMD59, 0, 0x95);
if(r1 != 0x00)return r1; //命令错误，返回r1
//设置Sector Size
r1 = SD_SendCommand(CMD16, 512, 0x95);
if(r1 != 0x00)return r1;//命令错误，返回r1
//-----------------SD卡、MMC卡初始化结束-----------------
}//SD卡为V1.0版本的初始化结束
//下面是V2.0卡的初始化
//其中需要读取OCR数据，判断是SD2.0还是SD2.0HC卡
else if(r1 == 0x01)
{
//V2.0的卡，CMD8命令后会传回4字节的数据，要跳过再结束本命令
buff[0] = SPIx_ReadWriteByte(0xFF); //should be 0x00
buff[1] = SPIx_ReadWriteByte(0xFF); //should be 0x00
buff[2] = SPIx_ReadWriteByte(0xFF); //should be 0x01
buff[3] = SPIx_ReadWriteByte(0xFF); //should be 0xAA
Set_SD_CS;
SPIx_ReadWriteByte(0xFF);//the next 8 clocks
//判断该卡是否支持2.7V-3.6V的电压范围
//if(buff[2]==0x01 && buff[3]==0xAA) //不判断，让其支持的卡更多
{
retry = 0;
//发卡初始化指令CMD55+ACMD41
do
{
r1 = SD_SendCommand(CMD55, 0, 0);
if(r1!=0x01)return r1;
r1 = SD_SendCommand(ACMD41, 0x40000000, 0);
if(retry>200)return r1; //超时则返回r1状态
}while(r1!=0);
//初始化指令发送完成，接下来获取OCR信息
//-----------鉴别SD2.0卡版本开始-----------
r1 = SD_SendCommand_NoDeassert(CMD58, 0, 0);
if(r1!=0x00)
{
Set_SD_CS;//释放SD片选信号
return r1; //如果命令没有返回正确应答，直接退出，返回应答
}//读OCR指令发出后，紧接着是4字节的OCR信息
buff[0] = SPIx_ReadWriteByte(0xFF);
buff[1] = SPIx_ReadWriteByte(0xFF);
buff[2] = SPIx_ReadWriteByte(0xFF);
buff[3] = SPIx_ReadWriteByte(0xFF);
//OCR接收完成，片选置高
Set_SD_CS;
SPIx_ReadWriteByte(0xFF);
//检查接收到的OCR中的bit30位（CCS），确定其为SD2.0还是SDHC
//如果CCS=1：SDHC CCS=0：SD2.0
if(buff[0]&0x40)SD_Type = SD_TYPE_V2HC; //检查CCS
else SD_Type = SD_TYPE_V2;
//-----------鉴别SD2.0卡版本结束-----------
//设置SPI为高速模式
SPIx_SetSpeed(SPI_SPEED_4);
}
}
return r1;
}
//从SD卡中读回指定长度的数据，放置在给定位置
//输入: u8 *data(存放读回数据的内存>len)
// u16 len(数据长度）
// u8 release(传输完成后是否释放总线CS置高 0：不释放 1：释放）
//返回值:0：NO_ERR
// other：错误信息
u8 SD_ReceiveData(u8 *data, u16 len, u8 release)
{
// 启动一次传输
Clr_SD_CS;
if(SD_GetResponse(0xFE))//等待SD卡发回数据起始令牌0xFE
{
Set_SD_CS;
return 1;
}
while(len--)//开始接收数据
{
*data=SPIx_ReadWriteByte(0xFF);
data++;
}
//下面是2个伪CRC（dummy CRC）
SPIx_ReadWriteByte(0xFF);
SPIx_ReadWriteByte(0xFF);
if(release==RELEASE)//按需释放总线，将CS置高
{
Set_SD_CS;//传输结束
SPIx_ReadWriteByte(0xFF);
}
return 0;
}
//获取SD卡的CID信息，包括制造商信息
//输入: u8 *cid_data(存放CID的内存，至少16Byte）
//返回值:0：NO_ERR
// 1：TIME_OUT
// other：错误信息
u8 SD_GetCID(u8 *cid_data)
{
u8 r1;
//发CMD10命令，读CID
r1 = SD_SendCommand(CMD10,0,0xFF);
if(r1 != 0x00)return r1; //没返回正确应答，则退出，报错
SD_ReceiveData(cid_data,16,RELEASE);//接收16个字节的数据
return 0;
}
//获取SD卡的CSD信息，包括容量和速度信息
//输入:u8 *cid_data(存放CID的内存，至少16Byte）
//返回值:0：NO_ERR
// 1：TIME_OUT
// other：错误信息
u8 SD_GetCSD(u8 *csd_data)
{
u8 r1;
r1=SD_SendCommand(CMD9,0,0xFF);//发CMD9命令，读CSD
if(r1)return r1; //没返回正确应答，则退出，报错
SD_ReceiveData(csd_data, 16, RELEASE);//接收16个字节的数据
return 0;
}
//获取SD卡的容量（字节）
//返回值:0： 取容量出错
// 其他:SD卡的容量(字节)
u32 SD_GetCapacity(void)
{
u8 csd[16];
u32 Capacity;
u8 r1;
u16 i;
u16 temp;
//取CSD信息，如果期间出错，返回0
if(SD_GetCSD(csd)!=0) return 0;
//如果为SDHC卡，按照下面方式计算
if((csd[0]&0xC0)==0x40)
{
Capacity=((u32)csd[8])<<8;
Capacity+=(u32)csd[9]+1;
Capacity = (Capacity)*1024;//得到扇区数
Capacity*=512;//得到字节数
}
else
{
i = csd[6]&0x03;
i<<=8;
i += csd[7];
i<<=2;
i += ((csd[8]&0xc0)>>6);
//C_SIZE_MULT
r1 = csd[9]&0x03;
r1<<=1;
r1 += ((csd[10]&0x80)>>7);
r1+=2;//BLOCKNR
temp = 1;
while(r1)
{
temp*=2;
r1--;
}
Capacity = ((u32)(i+1))*((u32)temp);
// READ_BL_LEN
i = csd[5]&0x0f;
//BLOCK_LEN
temp = 1;
while(i)
{
temp*=2;
i--;
}
//The final result
Capacity *= (u32)temp;//字节为单位
}
return (u32)Capacity;
}
//读SD卡的一个block
//输入:u32 sector 取地址（sector值，非物理地址）
// u8 *buffer 数据存储地址（大小至少512byte）
//返回值:0： 成功
// other：失败
u8 SD_ReadSingleBlock(u32 sector, u8 *buffer)
{
u8 r1;
//设置为高速模式
SPIx_SetSpeed(SPI_SPEED_4);
//如果不是SDHC，给定的是sector地址，将其转换成byte地址
if(SD_Type!=SD_TYPE_V2HC)
{
sector = sector<<9;
}
r1 = SD_SendCommand(CMD17, sector, 0);//读命令
if(r1 != 0x00)return r1;
r1 = SD_ReceiveData(buffer, 512, RELEASE);
if(r1 != 0)return r1; //读数据出错！
else return 0;
}
//写入SD卡的一个block(未实际测试过)
//输入:u32 sector 扇区地址（sector值，非物理地址）
// u8 *buffer 数据存储地址（大小至少512byte）
//返回值:0： 成功
// other：失败
u8 SD_WriteSingleBlock(u32 sector, const u8 *data)
{
u8 r1;
u16 i;
u16 retry;
//设置为高速模式
//SPIx_SetSpeed(SPI_SPEED_HIGH);
//如果不是SDHC，给定的是sector地址，将其转换成byte地址
if(SD_Type!=SD_TYPE_V2HC)
{
sector = sector<<9;
}
r1 = SD_SendCommand(CMD24, sector, 0x00);
if(r1 != 0x00)
{
return r1; //应答不正确，直接返回
}
//开始准备数据传输
Clr_SD_CS;
//先放3个空数据，等待SD卡准备好
SPIx_ReadWriteByte(0xff);
SPIx_ReadWriteByte(0xff);
SPIx_ReadWriteByte(0xff);
//放起始令牌0xFE
SPIx_ReadWriteByte(0xFE);
//放一个sector的数据
for(i=0;i<512;i++)
{
SPIx_ReadWriteByte(*data++);
}
//发2个Byte的dummy CRC
SPIx_ReadWriteByte(0xff);
SPIx_ReadWriteByte(0xff);
//等待SD卡应答
r1 = SPIx_ReadWriteByte(0xff);
if((r1&0x1F)!=0x05)
{
Set_SD_CS;
return r1;
}
//等待操作完成
retry = 0;
while(!SPIx_ReadWriteByte(0xff))
{
retry++;
if(retry>0xfffe) //如果长时间写入没有完成，报错退出
{
Set_SD_CS;
return 1; //写入超时返回1
}
}
//写入完成，片选置1
Set_SD_CS;
SPIx_ReadWriteByte(0xff);
return 0;
}
//读SD卡的多个block(实际测试过)
//输入:u32 sector 扇区地址（sector值，非物理地址）
// u8 *buffer 数据存储地址（大小至少512byte）
// u8 count 连续读count个block
//返回值:0： 成功
// other：失败
u8 SD_ReadMultiBlock(u32 sector, u8 *buffer, u8 count)
{
u8 r1;
//SPIx_SetSpeed(SPI_SPEED_HIGH);//设置为高速模式
//如果不是SDHC，将sector地址转成byte地址
if(SD_Type!=SD_TYPE_V2HC)sector = sector<<9;
//SD_WaitDataReady();
//发读多块命令
r1 = SD_SendCommand(CMD18, sector, 0);//读命令
if(r1 != 0x00)return r1;
do//开始接收数据
{
if(SD_ReceiveData(buffer, 512, NO_RELEASE) != 0x00)break;
buffer += 512;
} while(--count);
//全部传输完毕，发送停止命令
SD_SendCommand(CMD12, 0, 0);
//释放总线
Set_SD_CS;
SPIx_ReadWriteByte(0xFF);
if(count != 0)return count; //如果没有传完，返回剩余个数
else return 0;
}
//写入SD卡的N个block(未实际测试过)
//输入:u32 sector 扇区地址（sector值，非物理地址）
// u8 *buffer 数据存储地址（大小至少512byte）
// u8 count 写入的block数目
//返回值:0： 成功
// other：失败
u8 SD_WriteMultiBlock(u32 sector, const u8 *data, u8 count)
{
u8 r1;
u16 i;
//SPIx_SetSpeed(SPI_SPEED_HIGH);//设置为高速模式
if(SD_Type != SD_TYPE_V2HC)sector = sector<<9;//如果不是SDHC，给定的是sector地址，将其转换成byte地址
if(SD_Type != SD_TYPE_MMC) r1 = SD_SendCommand(ACMD23, count, 0x00);//如果目标卡不是MMC卡，启用ACMD23指令使能预擦除
r1 = SD_SendCommand(CMD25, sector, 0x00);//发多块写入指令
if(r1 != 0x00)return r1; //应答不正确，直接返回
Clr_SD_CS;//开始准备数据传输
SPIx_ReadWriteByte(0xff);//先放3个空数据，等待SD卡准备好
SPIx_ReadWriteByte(0xff);
//--------下面是N个sector写入的循环部分
do
{
//放起始令牌0xFC 表明是多块写入
SPIx_ReadWriteByte(0xFC);
//放一个sector的数据
for(i=0;i<512;i++)
{
SPIx_ReadWriteByte(*data++);
}
//发2个Byte的dummy CRC
SPIx_ReadWriteByte(0xff);
SPIx_ReadWriteByte(0xff);
//等待SD卡应答
r1 = SPIx_ReadWriteByte(0xff);
if((r1&0x1F)!=0x05)
{
Set_SD_CS; //如果应答为报错，则带错误代码直接退出
return r1;
}
//等待SD卡写入完成
if(SD_WaitDataReady()==1)
{
Set_SD_CS; //等待SD卡写入完成超时，直接退出报错
return 1;
}
}while(--count);//本sector数据传输完成
//发结束传输令牌0xFD
r1 = SPIx_ReadWriteByte(0xFD);
if(r1==0x00)
{
count = 0xfe;
}
if(SD_WaitDataReady()) //等待准备好
{
Set_SD_CS;
return 1;
}
//写入完成，片选置1
Set_SD_CS;
SPIx_ReadWriteByte(0xff);
return count; //返回count值，如果写完则count=0，否则count=1
}
//在指定扇区,从offset开始读出bytes个字节
//输入:u32 sector 扇区地址（sector值，非物理地址）
// u8 *buf 数据存储地址（大小<=512byte）
// u16 offset 在扇区里面的偏移量
// u16 bytes 要读出的字节数
//返回值:0： 成功
// other：失败
u8 SD_Read_Bytes(unsigned long address,unsigned char *buf,unsigned int offset,unsigned int bytes)
{
u8 r1;u16 i=0;
r1=SD_SendCommand(CMD17,address<<9,0);//发送读扇区命令
if(r1)return r1; //应答不正确，直接返回
Clr_SD_CS;//选中SD卡
if(SD_GetResponse(0xFE))//等待SD卡发回数据起始令牌0xFE
{
Set_SD_CS; //关闭SD卡
return 1;//读取失败
}
for(i=0;i<offset;i++)SPIx_ReadWriteByte(0xff);//跳过offset位
for(;i<offset+bytes;i++)*buf++=SPIx_ReadWriteByte(0xff);//读取有用数据
for(;i<512;i++) SPIx_ReadWriteByte(0xff); //读出剩余字节
SPIx_ReadWriteByte(0xff);//发送伪CRC码
SPIx_ReadWriteByte(0xff);
Set_SD_CS;//关闭SD卡
return 0;
}上一篇：C语言MD5算法源码
下一篇：SD卡字符图片