目录
一、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 0x062、驱动代码实现
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、运行截图
文章来源：https://www.toymoban.com/news/detail-729211.html
可以看到，成功查到SD数据。文章来源地址https://www.toymoban.com/news/detail-729211.html
到了这里，关于stm32读写SD卡(SPI模式)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
