[原创][连载].基于SOPC的简易数码相框 - Nios II SBTE部分（软件部分） - SD卡（SPI模式）驱动

上一讲，我们完成了Nios II SBTE的配置工作。下面讲解如何根据已有参考资料（手册及代码）编写SD卡驱动。

准备工具及资料

1. WinHex

2. Efronc的博文SD/MMC 接口及上电时序、SD/MMC 内部寄存器、SD/MMC SPI模式下命令集

驱动编写及调试

步骤1 添加sd_card文件夹到APP工程路径

如何添加，请参考[原创][连载].基于SOPC的简易数码相框 – Nios II SBTE部分（软件部分） - 配置工作。

步骤2 编写代码

SD卡有很多标准，此处选用最简单的SD 1-线模式，即SPI模式。

代码2.1 sd_card.h

#ifndef SD_CARD_H_
#define SD_CARD_H_

#include "my_types.h"
#include "my_regs.h"

#define ENABLE_SD_CARD_DEBUG // turn on debug message

void SD_CARD_Port_Init();
void SD_CARD_Write_Byte(u8 byte);
u8 SD_CARD_Read_Byte();
u8 SD_CARD_Write_CMD(u8 *CMD);
//
u8 SD_CARD_Init();
u8 SD_CARD_Write_Sector(u32 addr,u8 *buf);
u8 SD_CARD_Read_Sector(u8 *CMD,u8 *buf,u16 n_bytes);
u8 SD_CARD_Read_Sector_Start(u32 sector);
void SD_CARD_Read_Data(u16 n_bytes,u8 *buf);
void SD_CARD_Read_Data_LBA(u32 LBA,u16 n_bytes,u8 *buf);
void SD_CARD_Read_Sector_End();
u8 SD_CARD_Read_CSD(u8 *buf);
u8 SD_CARD_Read_CID(u8 *buf);
void SD_CARD_Get_Info(void);
void SD_CARD_DEMO(void);

#endif /* SD_CARD_H_ */

第5~6行，加入自定义的宏，统一代码风格。第9行，打开调试信息显示开关。调试正确后，可用添加注释的方式的关闭开关。

第12行void SD_CARD_Port_Init()，为SPI接口的初始函数。

第13~14行void SD_CARD_Write_Byte(u8 byte)和u8 SD_CARD_Read_Byte()，为SPI写字节和读字节函数。

第15行u8 SD_CARD_Write_CMD(u8 *CMD)，为SD卡写命令函数。

第17行u8 SD_CARD_Init()，为SD卡的初始化函数。这个函数需要特别注意，因为SPI模式的模式的SD卡需要低速率收发数据来初始化SD卡。

第18~19行u8 SD_CARD_Write_Sector(u32 addr,u8 *buf)和u8 SD_CARD_Read_Sector(u8 *CMD,u8 *buf,u16 n_bytes)为SD卡写块和读块函数；需要注意的是，一般的SD卡的块有512字节，而通过WinHex 查看的SD卡的每个扇区也是512字节。为了统一风格，此处一律写作Sector。

第21行void SD_CARD_Read_Data_LBA(u32 LBA,u16 n_bytes,u8 *buf)，比较好用，其参数LBA为Winhex中可查看的扇区地址，及逻辑块地址；有了这个函数，我们后续的工作就方便了需要。

第24~25行u8 SD_CARD_Read_CSD(u8 *buf)和u8 SD_CARD_Read_CID(u8 *buf)，为读取SD卡的CSD和CID寄存器函数。

其他的函数请参考源代码自行解析。

代码2.2 sd_card.c

#include <unistd.h>
#include "sd_card.h"

// debug switch
#ifdef ENABLE_SD_CARD_DEBUG
#include "debug.h"
#define SD_CARD_DEBUG(x)  DEBUG(x)
#else
#define SD_CARD_DEBUG(x)
#endif

// error macro
#define INIT_CMD0_ERROR   0x01
#define INIT_CMD1_ERROR   0x02
#define WRITE_BLOCK_ERROR 0x03
#define READ_BLOCK_ERROR  0x04

// SD-CARD(SPI mode) initial with low speed
// insert a certain delay
#define SD_CARD_INIT_DELAY usleep(10)

// CID info structure
typedef union
{
u8 data[16];
struct
{
u8 MID;   // Manufacture ID; Binary
u8 OLD[2];// OEM/Application ID; ASCII
u8 PNM[5];// Product Name; ASCII
u8 PRV;   // Product Revision; BCD
u8 PSN[4];// Serial Number; Binary
u8 MDT[2];// Manufacture Data Code; BCD; upper 4 bits of first byte are reserved
u8 CRC;   // CRC7_checksum; Binary; LSB are reserved
};
}CID_Info_STR;

// CSD info structure
typedef struct
{
u8 data[16];
u32 capacity_MB;
u8 READ_BL_LEN;
u16 C_SIZE;
u8 C_SIZE_MULT;
}CSD_Info_STR;

// flags
u16 gByteOffset=0;       // byte offset in one sector
u16 gSectorOffset=0;     // sector offset in SD-CARD
bool gSectorOpened=FALSE;// set to 1 when a sector is opened.
bool gSD_CARDInit=FALSE; // set it to 1 when SD-CARD is initialized

// SD-CARD port init
void SD_CARD_Port_Init()
{
sd_CLK=1;
sd_DOUT=1;
sd_nCS=1;
}

// write a byte to SD-CARD
void SD_CARD_Write_Byte(u8 byte)
{
u8 i;
for(i=0;i<8;i++)
{ // MSB First
sd_DIN=(byte >> (7-i)) & 0x1;
sd_CLK=0;if(gSD_CARDInit) SD_CARD_INIT_DELAY;
sd_CLK=1;if(gSD_CARDInit) SD_CARD_INIT_DELAY;
}
}

// read a byte to SD-CARD
u8 SD_CARD_Read_Byte()
{
u8 i,byte;
byte=0;
for(i=0;i<8;i++)
{ // MSB First
sd_CLK=0;if(gSD_CARDInit) SD_CARD_INIT_DELAY;
byte<<=1;if(sd_DOUT) byte++;
sd_CLK=1;if(gSD_CARDInit) SD_CARD_INIT_DELAY;
}
return byte;
}

// write a command to SD-CARD
// return: the second byte of response register of SD-CARD
u8 SD_CARD_Write_CMD(u8 *CMD)
{
u8 temp,retry;
u8 i;

sd_nCS=1; // set chipselect (disable SD-CARD)
SD_CARD_Write_Byte(0xFF); // send 8 clock impulse
sd_nCS=0; // clear chipselect (enable SD-CARD)

// write 6 bytes command to SD-CARD
for(i=0;i<6;i++) SD_CARD_Write_Byte(*CMD++);

// get 16 bits response
SD_CARD_Read_Byte(); // read the first byte, ignore it.
retry=0;
do
{ // only last 8 bits is valid
temp=SD_CARD_Read_Byte();
retry++;
}
while((temp==0xff) && (retry<100));
return temp;
}

// SD-CARD initialization(SPI mode)
u8 SD_CARD_Init()
{
u8 retry,temp;
u8 i;
u8 CMD[]={0x40,0x00,0x00,0x00,0x00,0x95};

SD_CARD_Port_Init();
usleep(1000);

SD_CARD_DEBUG(("SD-CARD Init!\n"));
gSD_CARDInit=TRUE; // Set init flag of SD-CARD

for(i=0;i<10;i++) SD_CARD_Write_Byte(0xff);// send 74 clock at least!!!

// write CMD0 to SD-CARD
retry=0;
do
{ // retry 200 times to write CMD0
temp=SD_CARD_Write_CMD(CMD);
retry++;
if(retry==200) return INIT_CMD0_ERROR;// CMD0 error!
}
while(temp!=1);

//write CMD1 to SD-CARD
CMD[0]=0x41;// Command 1
CMD[5]=0xFF;
retry=0;
do
{ // retry 100 times to write CMD1
temp=SD_CARD_Write_CMD(CMD);
retry++;
if(retry==100)  return INIT_CMD1_ERROR;// CMD1 error!
}
while(temp!=0);

gSD_CARDInit=FALSE; // clear init flag of SD-CARD

sd_nCS=1; // disable SD-CARD
SD_CARD_DEBUG(("SD-CARD Init Suc!\n"));
return 0x55;// All commands have been taken.
}

// writing a Block(512Byte, 1 sector) to SD-CARD
// return 0 if sector writing is completed.
u8 SD_CARD_Write_Sector(u32 addr,u8 *buf)
{
u8 temp,retry;
u16 i;

// CMD24 for writing blocks
u8 CMD[]={0x58,0x00,0x00,0x00,0x00,0xFF};
SD_CARD_DEBUG(("Write A Sector Starts!!\n"));

addr=addr << 9;// addr=addr * 512

CMD[1]=((addr & 0xFF000000) >>24 );
CMD[2]=((addr & 0x00FF0000) >>16 );
CMD[3]=((addr & 0x0000FF00) >>8 );

// write CMD24 to SD-CARD(write 1 block/512 bytes, 1 sector)
retry=0;
do
{ // retry 100 times to write CMD24
temp=SD_CARD_Write_CMD(CMD);
retry++;
if(retry==100) return(temp);//CMD24 error!
}
while(temp!=0);

// before writing, send 100 clock to SD-CARD
for(i=0;i<100;i++) SD_CARD_Read_Byte();

// write start byte to SD-CARD
SD_CARD_Write_Byte(0xFE);

SD_CARD_DEBUG(("\n"));
// now write real bolck data(512 bytes) to SD-CARD
for(i=0;i<512;i++) SD_CARD_Write_Byte(*buf++);

SD_CARD_DEBUG(("CRC-Byte\n"));
SD_CARD_Write_Byte(0xFF);// dummy CRC
SD_CARD_Write_Byte(0xFF);// dummy CRC

// read response
temp=SD_CARD_Read_Byte();
if( (temp & 0x1F)!=0x05 ) // data block accepted ?
{
sd_nCS=1; // disable SD-CARD
return WRITE_BLOCK_ERROR;// error!
}

// wait till SD-CARD is not busy
while(SD_CARD_Read_Byte()!=0xff){};

sd_nCS=1; // disable SD-CARD

SD_CARD_DEBUG(("Write Sector suc!!\n"));
return 0;
}

// read bytes in a block(normally 512KB, 1 sector) from SD-CARD
// return 0 if no error.
u8 SD_CARD_Read_Sector(u8 *CMD,u8 *buf,u16 n_bytes)
{
u16 i;
u8 retry,temp;

// write CMD to SD-CARD
retry=0;
do
{ // Retry 100 times to write CMD
temp=SD_CARD_Write_CMD(CMD);
retry++;
if(retry==100) return READ_BLOCK_ERROR;// block read error!
}
while(temp!=0);

// read start byte form SD-CARD (0xFE/Start Byte)
while(SD_CARD_Read_Byte()!=0xfe);

// read bytes in a block(normally 512KB, 1 sector) from SD-CARD
for(i=0;i<n_bytes;i++)  *buf++=SD_CARD_Read_Byte();

SD_CARD_Read_Byte();// dummy CRC
SD_CARD_Read_Byte();// dummy CRC

sd_nCS=1; // disable SD-CARD
return 0;
}

// return: [0]-success or something error!
u8 SD_CARD_Read_Sector_Start(u32 sector)
{
u8 retry;
// CMD16 for reading Blocks
u8 CMD[]={0x51,0x00,0x00,0x00,0x00,0xFF};
u8 temp;

// address conversation(logic block address-->byte address)
sector=sector << 9;// sector=sector * 512
CMD[1]=((sector & 0xFF000000) >>24 );
CMD[2]=((sector & 0x00FF0000) >>16 );
CMD[3]=((sector & 0x0000FF00) >>8 );

// write CMD16 to SD-CARD
retry=0;
do
{
temp=SD_CARD_Write_CMD(CMD);
retry++;
if(retry==100) return READ_BLOCK_ERROR;// READ_BLOCK_ERROR
}
while( temp!=0 );

// read start byte form SD-CARD (feh/start byte)
while (SD_CARD_Read_Byte() != 0xfe);

SD_CARD_DEBUG(("Open a Sector Succ!\n"));
gSectorOpened=TRUE;
return 0;
}

void SD_CARD_Read_Data(u16 n_bytes,u8 *buf)
{
u16 i;
for(i=0;((i<n_bytes) && (gByteOffset<512));i++)
{
*buf++=SD_CARD_Read_Byte();
gByteOffset++;// increase byte offset in a sector
}
if(gByteOffset==512)
{
SD_CARD_Read_Byte(); // Dummy CRC
SD_CARD_Read_Byte(); // Dummy CRC
gByteOffset=0;       // clear byte offset in a sector
gSectorOffset++;     // one sector is read completely
gSectorOpened=FALSE; // set to 1 when a sector is opened
sd_nCS=1;            // disable SD-CARD
}
}

// read block date by logic block address(sector offset)
void SD_CARD_Read_Data_LBA(u32 LBA,u16 n_bytes,u8 *buf)
{ // if one sector is read completely; open the next sector
if(gByteOffset==0) SD_CARD_Read_Sector_Start(LBA);
SD_CARD_Read_Data(n_bytes,buf);
}

// dummy read out the rest bytes in a sector
void SD_CARD_Read_Sector_End()
{
u8 temp[1];
while((gByteOffset!=0x00) | (gSectorOpened==TRUE))
SD_CARD_Read_Data(1,temp); // dummy read
}

// read CSD registers of SD-CARD
// return 0 if no error.
u8 SD_CARD_Read_CSD(u8 *buf)
{ // command for reading CSD registers
u8 CMD[]={0x49,0x00,0x00,0x00,0x00,0xFF};
return SD_CARD_Read_Sector(CMD,buf,16);// read 16 bytes
}

// read CID register of SD-CARD
// return 0 if no error.
u8 SD_CARD_Read_CID(u8 *buf)
{ // command for reading CID registers
u8 CMD[]={0x4A,0x00,0x00,0x00,0x00,0xFF};
return SD_CARD_Read_Sector(CMD,buf,16);//read 16 bytes
}

void SD_CARD_Get_Info(void)
{
CID_Info_STR CID;
CSD_Info_STR CSD;

SD_CARD_Read_CID(CID.data);
SD_CARD_DEBUG(("SD-CARD CID:\n"));
SD_CARD_DEBUG(("  Manufacturer ID(MID): 0x%.2X\n", CID.MID));
SD_CARD_DEBUG(("  OEM/Application ID(OLD): %c%c\n", CID.OLD[0], CID.OLD[1]));
SD_CARD_DEBUG(("  Product Name(PNM): %c%c%c%c%c\n", CID.PNM[0], CID.PNM[1], CID.PNM[2], CID.PNM[3], CID.PNM[4]));
SD_CARD_DEBUG(("  Product Revision: 0x%.2X\n", CID.PRV));
SD_CARD_DEBUG(("  Serial Number(PSN): 0x%.2X%.2X%.2X%.2X\n", CID.PSN[0], CID.PSN[1], CID.PSN[2], CID.PSN[3]));
SD_CARD_DEBUG(("  Manufacture Date Code(MDT): 0x%.1X%.2X\n", CID.MDT[0] & 0x0F, CID.MDT[1]));
SD_CARD_DEBUG(("  CRC-7 Checksum(CRC7):0x%.2X\n", CID.CRC >> 1));

SD_CARD_Read_CSD(CSD.data);
CSD.C_SIZE = ((CSD.data[6]&0x03) << 10) | (CSD.data[7] << 2) | ((CSD.data[8]&0xC0) >>6);
CSD.C_SIZE_MULT = ((CSD.data[9]&0x03) << 1) | ((CSD.data[10]&0x80) >> 7);
CSD.READ_BL_LEN = (CSD.data[5]&0x0F);
CSD.capacity_MB = (((CSD.C_SIZE)+1) << (((CSD.C_SIZE_MULT) +2) + (CSD.READ_BL_LEN))) >> 20;
SD_CARD_DEBUG(("SD-CARD CSD:\n"));
SD_CARD_DEBUG(("  max.read data block length: %d\n", 1<<CSD.READ_BL_LEN));
SD_CARD_DEBUG(("  device size: %d\n", CSD.C_SIZE));
SD_CARD_DEBUG(("  device size multiplier: %d\n", CSD.C_SIZE_MULT));
SD_CARD_DEBUG(("  device capacity: %d MB\n", CSD.capacity_MB));
}

void SD_CARD_DEMO(void)
{
u16 i;
u8 buf[512];

// init SD-CARD
while(SD_CARD_Init() != 0x55);
// Get CID & CSD
SD_CARD_Get_Info();
// read the 1st block(sector) of SD-Card
SD_CARD_Read_Data_LBA(0,512,buf);
for(i=0; i<512; i++)
{
SD_CARD_DEBUG(("%.2X ", buf[i]));
if((i+1) % 16 == 0) SD_CARD_DEBUG(("\n"));
}
}

源码很长，我简单说明其中比较重要的几点。

第58行，申明一个bool型的全局变量bool gSD_CARDInit=FALSE；我们在u8 SD_CARD_Init()函数中将此变量置一或清零，然后在函数void SD_CARD_Write_Byte(u8 byte)和u8 SD_CARD_Read_Byte()检测此变量，以实现慢速率SPI初始化SD卡。

我们拿void SD_CARD_Write_Byte(u8 byte)做说明。

// read a byte to SD-CARD
u8 SD_CARD_Read_Byte()
{
u8 i,byte;
byte=0;
for(i=0;i<8;i++)
{ // MSB First
sd_CLK=0;if(gSD_CARDInit) SD_CARD_INIT_DELAY;
byte<<=1;if(sd_DOUT) byte++;
sd_CLK=1;if(gSD_CARDInit) SD_CARD_INIT_DELAY;
}
return byte;
}

由于是采用GPIO模拟SPI总线，而Nios II（100MHz nios/f）的GPIO比较慢，因此无需延时即可实现25MHz的速率。但是初始化SD卡的时候必须采用

低于400KHz的时钟，需要插入适当延时。我以前也说过Nios II的延时不准，故此延时需要多次调试。我在第23行，使用一个宏来设定需要插入的延时。

由于CID寄存器的信息与字节比较对齐，因此第27~40行，使用了联合体来储存CID寄存器。而CSD寄存器内容比较零散，就没有采用联合体，而是使用了结构体（第44~51行）来存储信息。这样做的目的主要是为了理解方便，但是对存储器是比较浪费的。

第326行void SD_CARD_DEMO(void)函数中，先初始化SD卡，然后读取其第0个块（扇区）的内容。

关于SD（SPI）的寄存器结构、存储结构和指令体系等，请自行认真阅读相关资料，此处不解析。

步骤3 调用SD卡驱动函数

代码3.1 main.c

#include <stdio.h>                    // printf()
#include <unistd.h>                   // usleep()
#include "my_types.h"                 // 数据类型
#include "debug.h"                    // debug
#include "sd_card.h"

#define ENABLE_APP_DEBUG // turn on debug message
#ifdef ENABLE_APP_DEBUG
#define APP_DEBUG(x)    DEBUG(x)
#else
#define APP_DEBUG(x)
#endif

int main(void)
{
SD_CARD_DEMO();
while(1)
{
}
return 0;
}

jtag-uart打印的信息截图如下。



（黄色为SD卡初始化调试信息；绿色为CID寄存器信息；青色为CSD寄存器信息）



（第0扇区的内容）

下面我们通过WinHex读取SD卡的第一扇区的内容，注意与上图对比。





对比数据显示，SD_CARD_Read_Data_LBA函数可实现SD卡块读取动作。

其他问题

下面讲下如何在SD卡内读取二进制文件。我先使用Notspad++（或记事本）新建一个文件，保存为SD卡的某个位置，命名为test.bin。

简单起见，我直接把sd_card.h另存到我的SD卡内（FAT32格式），命名为test.bin。







（查看test.bin的属性）

在FAT16/32内，文件的数据总是从某个扇区的0字节开始连续存储的，若文件较大则需要连续存储n个扇区；需要注意的是最后的一个扇区如果没有存满，则补0。上面我们通过查看属性，得知test.bin的文件大小为718字节，即需要占用718/512=1.4，取2，即2个扇区。下面使用WinHex来查看文件的数据如何存储。Crtl+F7，打开目录查看器，选择test.bin文件。注意到test.bin的标识id和左下角显示的扇区地址移植。拖动





拖动文本，直到文本的结尾。 观察

和

，即占用了第81336和81337两个扇区。知道了扇区地址和扇区内的字节偏移，即可使用void SD_CARD_Read_Data_LBA(u32 LBA,u16 n_bytes,u8 *buf)函数读取到想要的数据。

源码下载

lcd_at_nios_nii_part.zip

目录

1 [原创][连载].基于SOPC的简易数码相框 - Quartus II部分（硬件部分）

2 [原创][连载].基于SOPC的简易数码相框 - Nios II SBTE部分（软件部分）- 配置工作

3 [原创][连载].基于SOPC的简易数码相框 - Nios II SBTE部分（软件部分）- SD卡（SPI模式）驱动

4 [原创][连载].基于SOPC的简易数码相框 - Nios II SBTE部分（软件部分）- TFT-LCD（控制器为ILI9325）驱动

5 [原创][连载].基于SOPC的简易数码相框 - Nios II SBTE部分（软件部分）- 从SD卡内读取图片文件，然后显示在TFT-LCD上

6 [原创][连载].基于SOPC的简易数码相框 - Nios II SBTE部分（软件部分）- 优化工作

7 [原创][连载].基于SOPC的简易数码相框 - Nios II SBTE部分（软件部分）- ADS7843触摸屏驱动测试