[笔记].菜农M0助学板之读SD卡块内容小练（库操作方式）

已发贴至：http://bbs.21ic.com/icview-231086-1-1.html

之前是移植到Nios II上，而且是用得IO模拟的，现在使用nuc1xx的spi核做的，不过还是参考了新唐的例程。关于sd的一些笔记，我贴在博客了。今天在此就不赘述了。http://www.cnblogs.com/yuphone/category/272287.html

上代码先。

main.h

#ifndef __MAIN_H__
#define __MAIN_H__

#include <stdio.h>

/*********************************************************
* 系统寄存器映射及库头文件
*********************************************************/
#include "NUC1xx.h" // 系统寄存器映射
#include "DrvSYS.h"
#include "DrvGPIO.h"
#include "DrvUART.h"
#include "DrvSPI.h"
#include "sd_card.h"
/**********************************************************
* 自定义宏
**********************************************************/
#define APP_DEBUG

#ifdef APP_DEBUG
    #define DEBUG printf
#else
    #define DEBUG(...) 
#endif

typedef enum{NO=0, YES=!NO}bool;

#endif /* __MAIN_H__ */

main.c

#include "main.h"
/**********************************************************
* 变量申明
**********************************************************/
volatile bool g_tmr0_5ms = NO;
/**********************************************************
* 函数申明
**********************************************************/
extern char GetChar(void);
extern void PFN_UART_CALLBACK(void);
/**********************************************************
* 系统上电初始化
**********************************************************/
void MAIN_INIT(void)
{
    UNLOCKREG();
    {   /* 配置系统时钟 */
        SYSCLK->PWRCON.XTL12M_EN = 1; //  设定12M外部晶振
        DrvSYS_Delay(5000); // 等待时钟就绪
        DrvSYS_SelectPLLSource(E_SYS_EXTERNAL_12M); // 选择12MHz为PLL输入
        DrvSYS_Open(50000000); // 打开50MHz
    }      
    {   /* 配置串口 */
        STR_UART_T param;
        
        DrvSYS_SelectIPClockSource(E_SYS_UART_CLKSRC, 0); //使能UART时钟
        DrvGPIO_InitFunction(E_FUNC_UART0);    // 复用功能引脚设置
                                                         
        param.u32BaudRate        = 115200;    // 波特率
        param.u8cDataBits        = DRVUART_DATABITS_8;  // 数据位
        param.u8cStopBits        = DRVUART_STOPBITS_1;  // 停止位
        param.u8cParity          = DRVUART_PARITY_NONE;    // 校验位
        param.u8cRxTriggerLevel  = DRVUART_FIFO_1BYTES;    // FIFO存储深度1字节
        param.u8TimeOut             = 0; // FIFO超时设定
        DrvUART_Open(UART_PORT0, &param); // 串口开启、结构体整体赋值
        
        // 串口的中断类型比较丰富，此处仅打开接收中断
        DrvUART_EnableInt(UART_PORT0, DRVUART_RDAINT, (PFN_DRVUART_CALLBACK*)PFN_UART_CALLBACK);
        DrvUART_ClearIntFlag(UART_PORT0, DRVUART_RDAINT);
    }
    {   /* 配置GPIO */
        NVIC_DisableIRQ(GPAB_IRQn);
        NVIC_DisableIRQ(GPCDE_IRQn);
        DrvGPIO_Open(E_GPB, 10, E_IO_OUTPUT); // 蜂鸣器 
        DrvGPIO_ClrBit(E_GPB, 10); // 关蜂鸣器
    }
    {   /* 配置TMR0 */
        NVIC_DisableIRQ(TMR0_IRQn);
        // 第一步 使能和选择定时器时钟源及使能定时器模块          
        SYSCLK->CLKSEL1.TMR0_S = 0; // 选择12Mhz作为定时器时钟源 
        SYSCLK->APBCLK.TMR0_EN =1;  // 使能定时器0
        TIMER0->TCSR.CEN = 1;       // 使能定时器模块
        // 第二步 选择操作模式    
        TIMER0->TCSR.MODE = 1; // 选择周期模式
        TIMER0->TCSR.CRST = 1; // 清加1计数器    
        // 第三步 输出时钟周期 = 定时器时钟源周期*(8位预分频因子 + 1) * (24位比较因子TCMP)
        TIMER0->TCSR.PRESCALE = 11; // 12分频
        TIMER0->TCMPR = 5000; // 12M/12/5000=200Hz, 5ms
        // 第四步 使能中断
        TIMER0->TISR.TIF = 1; // 清中断  
        TIMER0->TCSR.IE = 1; // 使能中断 
        NVIC_EnableIRQ(TMR0_IRQn);  // 使能TMR0中断
        // 第五步 使能定时器模块
        TIMER0->TCSR.CRST = 1; // 复位向上计数器
        TIMER0->TCSR.CEN = 1; // 使能TMR0
        //TIMER0->TCSR.TDR_EN=1; // 无需读取加1计数器值
    }
//    {   /* 配置SPI0主机模式 */
//        NVIC_DisableIRQ(SPI0_IRQn);
//        // 第一步 使能SPI0核
//        SYSCLK->APBCLK.SPI0_EN        =1;
//        SYS->IPRSTC2.SPI0_RST         =1;
//        SYS->IPRSTC2.SPI0_RST         =0;
//        // 第二步 设置除GPIO外的第一功能
//        SYS->GPCMFP.SPI0_SS0_I2SLRCLK =1;
//        SYS->GPCMFP.SPI0_CLK_I2SBCLK  =1;        
//        SYS->GPCMFP.SPI0_MISO0_I2SDI  =1;    
//        SYS->GPCMFP.SPI0_MOSI0_I2SDO  =1;
//        SYS->GPBMFP.TM2_SS01          =1;
//        // 第三步 设置除GPIO外的第二功能
//        SYS->ALTMFP.PC0_I2SLRCLK      =0;
//        SYS->ALTMFP.PC1_I2SBCLK       =0;
//        SYS->ALTMFP.PC2_I2SDI         =0;
//        SYS->ALTMFP.PC3_I2SDO         =0;
//        SYS->ALTMFP.PB10_S01          =1;
//        // 第四步 配置SPI0模式
//        SPI0->CNTRL.SLAVE = 0; // 0 主机模式；1 从机模式
//        SPI0->CNTRL.CLKP = 0; // 0 SCLK低电平闲置；1 SCLK高电平闲置
//        SPI0->CNTRL.TX_NEG = 0; // 0 上升沿传输；1 下降沿传输
//        SPI0->CNTRL.TX_BIT_LEN = 8; // [0 31] 一次传输8位
//        SPI0->CNTRL.TX_NUM = 0; // 0 每次传输完成一次收/发；1 每次传输完成两次收/发
//        SPI0->CNTRL.LSB = 0; // 0 优先发送MSB；1 优先发送LSB
//        // 第六步 配置从机选择
//        SPI0->SSR.AUTOSS = 1; // 0 设置或清除SSR.SSR来决定是否产生从机选择信号
//                              // 1 CNTRL.GO_BUSY设置后，SSR.SSR会由SPI核自动产生，只要一次收/发完成后结束
//        SPI0->SSR.SS_LVL = 0; // 0 高电平/上升沿有效；1 低电平/下降沿有效
//        // 第五步 设置时钟输出频率
//        // 设置SPI0的时钟分频器
//        SPI0->DIVIDER.DIVIDER = (uint16_t)((((DrvSYS_GetHCLKFreq()/2000000) + 1) >> 1) - 1); // 2MHz 
//        // 设置SPI0的第二个时钟分频器
//        // SPI0->DIVIDER.DIVIDER2 = (uint16_t)((((DrvSYS_GetHCLKFreq()/10000) + 1) >> 1) - 1); // 10kHz
//        SPI0->DIVIDER.DIVIDER2 = 0;
//        // 第六步
//        SPI0->TX[0] = 0; // 清TX[0]
//        // SPI0->TX[1] = 0; // 清TX[1]
//        SPI0->CNTRL.GO_BUSY = 1; // 触发一次SPI传输
//        // 第七步 设置中断
//        //SPI0->CNTRL.IE = 0; // 0 失能中断；1 使能中断
//        //SPI0->CNTRL.IE = 1; // 写1清中断标志
//        //NVIC_EnableIRQ(SPI0_IRQn);
//        
//    }
    LOCKREG();
}
/**********************************************************
* TMR0 ISR
**********************************************************/
void TMR0_IRQHandler(void) __irq
{   // 注意：ISR内必须清中断
    TIMER0->TISR.TIF = 1; // 清中断  

    g_tmr0_5ms = YES;   
}
/**********************************************************
* UART0 回调函数
**********************************************************/
void PFN_UART_CALLBACK(void)
{   // 注意：回调函数内无须清中断
    switch(GetChar()) {        
        default: 
            DEBUG("test");
            break;        
    }            
}
/**********************************************************
* 主函数
**********************************************************/
int main(void)
{
    MAIN_INIT(); // 上电初始化系统
    SD_CARD_Open();
    SD_CARD_DEMO();  
    
    while(1) {
        if(g_tmr0_5ms != NO) {
            g_tmr0_5ms = NO;
        }

        if(0) break; // 跳出大循环
    }
    
    SD_CARD_Close();
    DrvUART_Close(UART_PORT0);
    return 0;
}

sd_card.h

#ifndef SD_CARD_H_
#define SD_CARD_H_

#include "main.h"

#define ENABLE_SD_CARD_DEBUG // 打开调试信息
// debug switch
#ifdef ENABLE_SD_CARD_DEBUG
    #define SD_CARD_DEBUG    DEBUG
#else
    #define SD_CARD_DEBUG(...)
#endif


uint8_t SD_CARD_SPI_Transfer(uint8_t byte);
uint8_t SD_CARD_Init(void);
//
void SD_CARD_Open(void);
void SD_CARD_Close(void);
uint8_t SD_CARD_Write_Sector(uint32_t addr,uint8_t *buf);
uint8_t SD_CARD_Read_Sector(uint8_t *CMD,uint8_t *buf,uint16_t n_bytes);
uint8_t SD_CARD_Read_Sector_Start(uint32_t sector);
static void SD_CARD_Read_Data(uint16_t n_bytes,uint8_t *buf);
void SD_CARD_Read_Data_LBA(uint32_t LBA,uint16_t n_bytes,uint8_t *buf);
void SD_CARD_Read_Sector_End(void);
static uint8_t SD_CARD_Read_CSD(uint8_t *buf);
static uint8_t SD_CARD_Read_CID(uint8_t *buf);
void SD_CARD_Get_Info(void);
void SD_CARD_DEMO(void);


#endif /* SD_CARD_H_ */

sd_card.c

#include "sd_card.h"

// 错误宏定义
#define INIT_CMD0_ERROR     0x01
#define INIT_CMD1_ERROR     0x02
#define WRITE_BLOCK_ERROR   0x03
#define READ_BLOCK_ERROR    0x04

#define Delay_Us DrvSYS_Delay // us级延时
#define SD_CARD_Set_nCS DrvSPI_ClrSS(eDRVSPI_PORT1, eDRVSPI_SS0) // nCS = 1
#define SD_CARD_Clr_nCS DrvSPI_SetSS(eDRVSPI_PORT1, eDRVSPI_SS0) // nCS = 0

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

typedef struct{
    uint8_t data[16];
    uint32_t capacity_MB;
    uint8_t READ_BL_LEN;
    uint16_t C_SIZE;
    uint8_t C_SIZE_MULT;
}CSD_Info_STR;

uint16_t gByteOffset=0; // 某字节在扇区内的偏移地址
uint16_t gSectorOffset=0; // 扇区在SD卡内的偏移地址
uint8_t gSectorOpened = 0; // 0 关闭扇区；1 打开扇区

// 打开SD卡
void SD_CARD_Open(void)
{
    DrvSYS_SetIPClock(E_SYS_SPI1_CLK,1);
    DrvGPIO_InitFunction(E_FUNC_SPI1); // enable SPI funztion and pin 
    
    DrvSPI_Open(eDRVSPI_PORT1,eDRVSPI_MASTER,eDRVSPI_TYPE1,8, FALSE);
    DrvSPI_DisableAutoSS(eDRVSPI_PORT1);
    DrvSPI_SetSlaveSelectActiveLevel(eDRVSPI_PORT1, eDRVSPI_ACTIVE_LOW_FALLING);
    DrvSPI_SetEndian(eDRVSPI_PORT1, eDRVSPI_MSB_FIRST);
    DrvSPI_SetClockFreq(eDRVSPI_PORT1,300000,0);
    
    while(SD_CARD_Init() != 0x55);
    SD_CARD_DEBUG(("SD卡初始化完成\r"));
   
    DrvSPI_SetClockFreq(eDRVSPI_PORT1,10000000,0);
}


// 关闭SD卡
void SD_CARD_Close(void)
{
    DrvSPI_Close(eDRVSPI_PORT1);
}


// 收发一个字节
static uint8_t SD_CARD_SPI_Transfer(uint8_t byte)
{
    uint32_t SPIdata=(uint32_t)byte;
    DrvSPI_BurstTransfer(eDRVSPI_PORT1,1,2);
    DrvSPI_SingleWrite(eDRVSPI_PORT1,&SPIdata);
    while (DrvSPI_IsBusy(eDRVSPI_PORT1));
    DrvSPI_DumpRxRegister(eDRVSPI_PORT1,&SPIdata,1);
    return (uint8_t)SPIdata;
}


// SD卡写命令
static uint8_t SD_CARD_Write_CMD(uint8_t *CMD)
{
    uint8_t temp,retry;
    uint8_t i;

    SD_CARD_Set_nCS; // 失能SD卡
    SD_CARD_SPI_Transfer(0xFF); // 发8个脉冲
    SD_CARD_Clr_nCS; // 使能SD卡

    // 写6个字节到SD卡
    for(i=0;i<6;i++) SD_CARD_SPI_Transfer(*CMD++);

    // 读取16位响应
    SD_CARD_SPI_Transfer(0xFF); // 第一个字节无效
    retry=0;
    do{ // 只取最后一个字节
        temp=SD_CARD_SPI_Transfer(0xFF);
        retry++;
    }while((temp==0xFF) && (retry<100));
    
    return temp;
}


// 初始化SD卡；SPI模式
static uint8_t SD_CARD_Init(void)
{
    uint8_t retry,temp;
    uint8_t i;
    uint8_t CMD[]={0x40,0x00,0x00,0x00,0x00,0x95};

    SD_CARD_Set_nCS;
    Delay_Us(10*1000);    
    for(i=0;i<10;i++) // 最少先发74个脉冲
        SD_CARD_SPI_Transfer(0xFF);
    SD_CARD_Clr_nCS;

    retry=0;
    do{
        temp=SD_CARD_Write_CMD(CMD);
        retry++;
        if(retry==200) 
            return INIT_CMD0_ERROR;
    }while(temp!=1);

    CMD[0]=0x41;// CMD[1]
    CMD[5]=0xFF;
    retry=0;
    do{ 
        temp=SD_CARD_Write_CMD(CMD);
        retry++;
        if(retry==100)    
            return INIT_CMD1_ERROR;
    }while(temp!=0);

    SD_CARD_Set_nCS; // 失能SD卡
    
    return 0x55; // 初始化完成
}


// 写入一个块（扇区）
uint8_t SD_CARD_Write_Sector(uint32_t addr,uint8_t *buf)
{
    uint8_t temp,retry;
    uint16_t i;
    uint8_t CMD[]={0x58,0x00,0x00,0x00,0x00,0xFF}; // CMD24

    // 地址转换：逻辑块（扇区）地址 --> 字节地址
    addr=addr << 9;
    CMD[1]=((addr & 0xFF000000) >>24 );
    CMD[2]=((addr & 0x00FF0000) >>16 );
    CMD[3]=((addr & 0x0000FF00) >>8 );


    retry=0;
    do{ 
        temp=SD_CARD_Write_CMD(CMD);
        retry++;
        if(retry==100) 
            return temp;
    } while(temp!=0);

    // 写数据前，先发100个脉冲；100/8=13
    for(i=0;i<13;i++) SD_CARD_SPI_Transfer(0xFF);

    // 写入开始字节
    SD_CARD_SPI_Transfer(0xFE);

    // 写入512个字节
    for(i=0;i<512;i++) SD_CARD_SPI_Transfer(*buf++);

    SD_CARD_SPI_Transfer(0xFF); // 假读；读取CRC
    SD_CARD_SPI_Transfer(0xFF); // 假读；读取CRC

    // 读取响应
    temp=SD_CARD_SPI_Transfer(0xFF);
    if( (temp & 0x1F)!=0x05 ) {// 数据被接收否？    
        SD_CARD_Set_nCS; // 失能SD卡        
        return WRITE_BLOCK_ERROR;
    }

    // 等待，只到SD卡不忙
    while(SD_CARD_SPI_Transfer(0xFF)!=0xFF);

    SD_CARD_Set_nCS; // 失能SD卡
    
    return 0;
}


// 读取块（扇区）内的字节（一般情况下，1块对应512字节）
uint8_t SD_CARD_Read_Sector(uint8_t *CMD,uint8_t *buf,uint16_t n_bytes)
{
    uint16_t i;
    uint8_t retry,temp;

    retry=0;
    do{ 
        temp=SD_CARD_Write_CMD(CMD);
        retry++;
        if(retry==100) 
            return READ_BLOCK_ERROR;
    }while(temp!=0);

    // 读开始字节(0xFEh)
    while(SD_CARD_SPI_Transfer(0xFF)!=0xFE);
    
    // 读取n个字节
    for(i=0;i<n_bytes;i++) *buf++=SD_CARD_SPI_Transfer(0xFF);

    SD_CARD_SPI_Transfer(0xFF); // 假读；读取CRC
    SD_CARD_SPI_Transfer(0xFF); // 假读；读取CRC

    SD_CARD_Set_nCS; // 失能SD卡
    
    return 0;
}


// 开始读取某个扇区
uint8_t SD_CARD_Read_Sector_Start(uint32_t sector)
{
    uint8_t retry;
    uint8_t CMD[]={0x51,0x00,0x00,0x00,0x00,0xFF}; // CMD16
    uint8_t temp;

    // 地址转换：逻辑块（扇区）地址 --> 字节地址
    sector=sector << 9;
    CMD[1]=((sector & 0xFF000000) >>24 );
    CMD[2]=((sector & 0x00FF0000) >>16 );
    CMD[3]=((sector & 0x0000FF00) >>8 );

    retry=0;
    do{
        temp=SD_CARD_Write_CMD(CMD);
        retry++;
        if(retry==100) 
            return READ_BLOCK_ERROR;
    }while(temp!=0);

    // 读开始字节(0xFEh)
    while(SD_CARD_SPI_Transfer(0xFF) != 0xFE);

    gSectorOpened = 1; // 将扇区打开标志置一
    
    return 0;
}


static void SD_CARD_Read_Data(uint16_t n_bytes, uint8_t *buf)
{
    uint16_t i;
    for(i=0; ((i<n_bytes) && (gByteOffset<512)); i++) {
        *buf++ = SD_CARD_SPI_Transfer(0xFF);
        gByteOffset++; // 读完一个字节；将扇区内的字节偏移地址加一
    }
    if(gByteOffset == 512) {
        gByteOffset=0; // 将扇区内的字节偏移地址清零
        
        SD_CARD_SPI_Transfer(0xFF); // 假读；读取CRC
        SD_CARD_SPI_Transfer(0xFF); // 假读；读取CRC
        
        gSectorOffset++; // 读完一个扇区；将SD卡内的扇区偏移地址加一
        
        gSectorOpened = 0; // 读完一个扇区后，扇区打开标志清零
        SD_CARD_Set_nCS; // 失能SD卡
    }
}


// 读取指定逻辑块地址（扇区偏移地址）内的数据；logic block address，LBA
void SD_CARD_Read_Data_LBA(uint32_t LBA,uint16_t n_bytes,uint8_t *buf)
{   // 如果某扇区被读完，则打开下一个扇区
    if(gByteOffset == 0) while(SD_CARD_Read_Sector_Start(LBA));
    SD_CARD_Read_Data(n_bytes,buf);
}


// 假读；读完某扇区内剩余的字节
void SD_CARD_Read_Sector_End(void)
{
    uint8_t temp[1];
    while((gByteOffset!=0x00) | (gSectorOpened==1))
        SD_CARD_Read_Data(1,temp); // 假读
}


// 读SD卡的CSD寄存器
static uint8_t SD_CARD_Read_CSD(uint8_t *buf)
{ 
    uint8_t CMD[]={0x49,0x00,0x00,0x00,0x00,0xFF};
    return SD_CARD_Read_Sector(CMD,buf,16); // 读取16个字节
}


// 读SD卡的CID寄存器
static uint8_t SD_CARD_Read_CID(uint8_t *buf)
{ 
    uint8_t CMD[]={0x4A,0x00,0x00,0x00,0x00,0xFF};
    return SD_CARD_Read_Sector(CMD,buf,16); // 读取16个字节
}


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:\r");
    SD_CARD_DEBUG("    Manufacturer ID(MID): 0x%.2X\r", CID.CID.MID);
    SD_CARD_DEBUG("    OEM/Application ID(OLD): %c%c\r", CID.CID.OLD[0], CID.CID.OLD[1]);
    SD_CARD_DEBUG("    Product Name(PNM): %c%c%c%c%c\r", CID.CID.PNM[0], CID.CID.PNM[1], CID.CID.PNM[2], CID.CID.PNM[3], CID.CID.PNM[4]);
    SD_CARD_DEBUG("    Product Revision: 0x%.2X\r", CID.CID.PRV);
    SD_CARD_DEBUG("    Serial Number(PSN): 0x%.2X%.2X%.2X%.2X\r", CID.CID.PSN[0], CID.CID.PSN[1], CID.CID.PSN[2], CID.CID.PSN[3]);
    SD_CARD_DEBUG("    Manufacture Date Code(MDT): 0x%.1X%.2X\r", CID.CID.MDT[0] & 0x0F, CID.CID.MDT[1]);
    SD_CARD_DEBUG("    CRC-7 Checksum(CRC7):0x%.2X\r", CID.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:\r");
    SD_CARD_DEBUG("    max.read data block length: %d\r", 1<<CSD.READ_BL_LEN);
    SD_CARD_DEBUG("    device size: %d\r", CSD.C_SIZE);
    SD_CARD_DEBUG("    device size multiplier: %d\r", CSD.C_SIZE_MULT);
    SD_CARD_DEBUG("    device capacity: %d MB\r", CSD.capacity_MB);
}


void SD_CARD_DEMO(void)
{
    uint16_t i;
    uint8_t buf[512];
    
    SD_CARD_DEBUG("\r");    
    SD_CARD_DEBUG("开始读取SD卡信息\r");   
    SD_CARD_Get_Info(); // 读取CID和CSD
    SD_CARD_DEBUG("SD卡信息读取完毕\r");
    
    SD_CARD_DEBUG("\r");
    SD_CARD_DEBUG("开始读取SD卡的第一个块（扇区）\r");
    SD_CARD_Read_Data_LBA(0,512,buf); // 读取SD卡的第一个块（扇区）
    for(i=0; i<512; i++) {
        if(i%16 == 0) SD_CARD_DEBUG("0x%.3X ", i);
        SD_CARD_DEBUG("%.2X ", buf[i]);
        if((i+1) % 8 == 0) SD_CARD_DEBUG(" ");
        if((i+1) % 16 == 0) SD_CARD_DEBUG("\r");
    }
    SD_CARD_DEBUG("读取SD卡的第一个块（扇区）完毕\r");
}