[应用相关] STM32使用软件模拟spi读写sd卡(使用SD卡读卡器模块)

[复制链接]
135|0
heimaojingzhang 发表于 2025-10-16 10:10 | 显示全部楼层 |阅读模式
1.引言
介绍SD卡在嵌入式系统中的常见应用场景及重要性。
简述硬件SPI和软件模拟SPI的优缺点,说明软件模拟SPI的适用场景(如引脚资源紧张或硬件SPI被占用时)。
明确本文目标:通过软件模拟SPI实现STM32与SD卡的通信。
开发板:STM32F103RCT6
模块:读卡器模块(SD卡的内存一定要在32G以下)

463968ef1b0a37bac.jpg

2.SD卡与SPI协议基础
SD卡的物理结构及通信协议概述。

4398668ef1b12c8525.png

                                                                图SD卡物理结构

        SD卡有自己的寄存器,但他不能直接进行读写操作,需要通过命令来控制,SDIOx协议定义了一些命令用于实现某一特定功能,SD卡就根据收到的命令对内部寄存器进行修改。SPI协议童谣也可做到发送命令,但是有些SD卡的命令SPI并不支持。

82368ef1b1b2efb1.png

SPI模式下的引脚定义(CS、CLK、MISO、MOSI)和SPI协议的工作机制(时钟极性、相位、数据格式)及软件模拟的核心逻辑。
详情可以看快速了解spi协议

一个完整的SD卡操作过程是:主机发起“命令”,SD卡根据命令内容选择是否发送响应信息及数据等,如果是数据读/写操作,主机还需要发送停止读/写数据的命令来结束本次操作,直意味这主机发起命令后,SD卡卡伊没有响应,数据等过程,这取决与命令的含义。

7334468ef1b2380cc3.png

图SD卡命令格式

        SD 卡的命令固定为 48 位,由 6 个字节组成,字节 1 的最高 2 位固定为 01,低 6 位为命令 号(比如 CMD16,为 10000B 即 16 进制的 0X10,完整的 CMD16,第一个字节为 01010000, 即 0X10+0X40)。字节 2~5 为命令参数,有些命令是没有参数的。字节 6 的高七位为 CRC 值, 最低位恒定为 1。

562568ef1b293788c.png

图SD卡控制命令格式

3.软件模拟SPI的实现步骤
GPIO配置
设置STM32的GPIO引脚为推挽输出(CLK、MOSI、CS)和浮空输入(MISO),注意引脚速度与上拉电阻配置。

/*引脚配置层*/
#define SD_SPI                           SPI1
#define SD_SPI_CLK                       RCC_APB2Periph_SPI1
#define SD_SPI_APBxClock_FUN            RCC_APB2PeriphClockCmd
                 
#define SD_SPI_SCK_PIN                   GPIO_Pin_5               
#define SD_SPI_SCK_GPIO_PORT             GPIOC                       
#define SD_SPI_SCK_GPIO_CLK              RCC_APB2Periph_GPIOA
         
#define SD_SPI_MISO_PIN                  GPIO_Pin_6               
#define SD_SPI_MISO_GPIO_PORT            GPIOC                       
#define SD_SPI_MISO_GPIO_CLK             RCC_APB2Periph_GPIOA
         
#define SD_SPI_MOSI_PIN                  GPIO_Pin_7               
#define SD_SPI_MOSI_GPIO_PORT            GPIOC                       
#define SD_SPI_MOSI_GPIO_CLK             RCC_APB2Periph_GPIOA
         
#define SD_CS_PIN                        GPIO_Pin_4               
#define SD_CS_GPIO_PORT                  GPIOC                     
#define SD_CS_GPIO_CLK                   RCC_APB2Periph_GPIOA

#define SD_DETECT_PIN                    GPIO_Pin_0                 
#define SD_DETECT_GPIO_PORT              GPIOE                       
#define SD_DETECT_GPIO_CLK               RCC_APB2Periph_GPIOE

void MySPI_Init(void)
{
  /*GPIO初始化*/
  GPIO_InitTypeDef GPIO_InitStructure;
       
  /*开启时钟*/
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
       
  //*!< Configure SD_SPI pins: SCK */
  GPIO_InitStructure.GPIO_Pin = SD_SPI_SCK_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(SD_SPI_SCK_GPIO_PORT, &GPIO_InitStructure);

  /*!< Configure SD_SPI pins: MOSI */
  GPIO_InitStructure.GPIO_Pin = SD_SPI_MOSI_PIN;
  GPIO_Init(SD_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure);

  /*!< Configure SD_SPI pins: MISO */
  GPIO_InitStructure.GPIO_Pin = SD_SPI_MISO_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  
  GPIO_Init(SD_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);

  /*!< Configure SD_SPI_CS_PIN pin: SD Card CS pin */
  GPIO_InitStructure.GPIO_Pin = SD_CS_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(SD_CS_GPIO_PORT, &GPIO_InitStructure);
       
  /*设置默认电平*/
  SD_CS_HIGH();                                                                                            //SS默认高电平
  MySPI_W_SCK(1);                                                                                        //SCK默认低电平
}



CS片选引脚由于我用的是野火老师的底层,为了不做太多修改,所以用的野火老师自己的操作。


模拟SPI时序函数
实现基本的时钟信号生成(CLK翻转)、数据发送(MOSI)与接收(MISO采样)函数,示例代码片段:

/**
  * 函    数:SPI写SS引脚电平
  * 参    数:BitValue 协议层传入的当前需要写入SS的电平,范围0~1
  * 返 回 值:无
  * 注意事项:此函数需要用户实现内容,当BitValue为0时,需要置SS为低电平,当BitValue为1时,需要置SS为高电平
  */
void MySPI_W_SS(uint8_t BitValue)
{
        GPIO_WriteBit(SD_CS_GPIO_PORT, SD_CS_PIN, (BitAction)BitValue);                //根据BitValue,设置SS引脚的电平
}

/**
  * 函    数:SPI写SCK引脚电平
  * 参    数:BitValue 协议层传入的当前需要写入SCK的电平,范围0~1
  * 返 回 值:无
  * 注意事项:此函数需要用户实现内容,当BitValue为0时,需要置SCK为低电平,当BitValue为1时,需要置SCK为高电平
  */
void MySPI_W_SCK(uint8_t BitValue)
{
        GPIO_WriteBit(SD_SPI_SCK_GPIO_PORT, SD_SPI_SCK_PIN, (BitAction)BitValue);                //根据BitValue,设置SCK引脚的电平
}

/**
  * 函    数:SPI写MOSI引脚电平
  * 参    数:BitValue 协议层传入的当前需要写入MOSI的电平,范围0~1
  * 返 回 值:无
  * 注意事项:此函数需要用户实现内容,当BitValue为0时,需要置MOSI为低电平,当BitValue为1时,需要置MOSI为高电平
  */
void MySPI_W_MOSI(uint8_t BitValue)
{
        GPIO_WriteBit(SD_SPI_MOSI_GPIO_PORT, SD_SPI_MOSI_PIN, (BitAction)BitValue);                //根据BitValue,设置MOSI引脚的电平,BitValue要实现非0即1的特性
}

/**
  * 函    数:I2C读MISO引脚电平
  * 参    数:无
  * 返 回 值:协议层需要得到的当前MISO的电平,范围0~1
  * 注意事项:此函数需要用户实现内容,当前MISO为低电平时,返回0,当前MISO为高电平时,返回1
  */
uint8_t MySPI_R_MISO(void)
{
        return GPIO_ReadInputDataBit(SD_SPI_MISO_GPIO_PORT , SD_SPI_MISO_PIN);                        //读取MISO电平并返回
}

// 软件SPI写入一个字节
uint8_t SD_WriteByte(uint8_t data)
{
    uint8_t i, receive = 0;

    for(i = 0; i < 8; i++)
    {
        // 设置MOSI输出
        if(data & 0x80)
            MySPI_W_MOSI(1);
        else
            MySPI_W_MOSI(0);
        data <<= 1;

        // 产生时钟下降沿
        MySPI_W_SCK(0);
                                Delay_us(1);
//                                Delay_us(5);
        // 产生时钟上升沿
        MySPI_W_SCK(1);
        // 读取MISO输入
        receive <<= 1;
        if(MySPI_R_MISO())
            receive |= 0x01;

//                                Delay_us(5);
                                Delay_us(1);
    }

    return receive;
}

// 软件SPI读取一个字节
uint8_t SD_ReadByte(void)
{
    return SD_WriteByte(0xFF); // 发送0xFF同时接收数据
}


        为了能够与SD卡通过SPI协议通信,要注意SPI的时钟相位(CPHA)和时钟极性(CPOL)的设置,如下图,我们是通过软件模拟SPI协议,所以要通过手动拉高/拉低引脚来实现通信。首先当我们通过MOSI发送一位数据后,就要先拉底再拉高时钟信号产生上升沿来告诉从机要接收数据或主机接收数据。
图SPI模式(CPOL=1,CPHA=1)

9064168ef1b3b62578.png

4.文件系统集成与读写实现
FATFS文件系统移植
FATFS文件系统如果想要自己移植的或就去FAT官网,需要自己实现diskio.c中的底层驱动适配(如disk_read、disk_write调用软件SPI函数)。只要能够使用SPI实现SD卡的初始化,读/写,移植一般是没有问题的。我用的是野火老师的源码。ebf_stm32f103_mini_std_code: 野火STM32F103 MINI开发板 标准库教程配套代码 (gitee.com)

5.完整代码
/**
  ******************************************************************************
  * @file    stm32_eval_spi_sd.h
  * @author  MCD Application Team
  * @version V4.5.0
  * @date    07-March-2011
  * @brief   This file contains all the functions prototypes for the stm32_eval_spi_sd
  *          firmware driver.
  ******************************************************************************
  * @attention
  *
  * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
  * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
  * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
  * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
  * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  *
  * <h2><center>&copy; COPYRIGHT 2011 STMicroelectronics</center></h2>
  ******************************************************************************  
  */

/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __STM32_EVAL_SPI_SD_H
#define __STM32_EVAL_SPI_SD_H

#ifdef __cplusplus
extern "C" {
#endif

/* Includes ------------------------------------------------------------------*/
#include "stm32f10x.h"
#include "ff.h"   

/** @addtogroup Utilities
  * @{
  */
         
#define SD_SPI                           SPI1
#define SD_SPI_CLK                       RCC_APB2Periph_SPI1
#define SD_SPI_APBxClock_FUN            RCC_APB2PeriphClockCmd
                 
#define SD_SPI_SCK_PIN                   GPIO_Pin_5               
#define SD_SPI_SCK_GPIO_PORT             GPIOC                       
#define SD_SPI_SCK_GPIO_CLK              RCC_APB2Periph_GPIOA
         
#define SD_SPI_MISO_PIN                  GPIO_Pin_6               
#define SD_SPI_MISO_GPIO_PORT            GPIOC                       
#define SD_SPI_MISO_GPIO_CLK             RCC_APB2Periph_GPIOA
         
#define SD_SPI_MOSI_PIN                  GPIO_Pin_7               
#define SD_SPI_MOSI_GPIO_PORT            GPIOC                       
#define SD_SPI_MOSI_GPIO_CLK             RCC_APB2Periph_GPIOA
         
#define SD_CS_PIN                        GPIO_Pin_4               
#define SD_CS_GPIO_PORT                  GPIOC                     
#define SD_CS_GPIO_CLK                   RCC_APB2Periph_GPIOA

#define SD_DETECT_PIN                    GPIO_Pin_0                 
#define SD_DETECT_GPIO_PORT              GPIOE                       
#define SD_DETECT_GPIO_CLK               RCC_APB2Periph_GPIOE


/** @addtogroup STM32_EVAL
  * @{
  */

/** @addtogroup Common
  * @{
  */

/** @addtogroup STM32_EVAL_SPI_SD
  * @{
  */  

/** @defgroup STM32_EVAL_SPI_SD_Exported_Types
  * @{
  */

typedef enum
{
/**
  * @brief  SD reponses and error flags
  */
  SD_RESPONSE_NO_ERROR      = (0x00),
  SD_IN_IDLE_STATE          = (0x01),
  SD_ERASE_RESET            = (0x02),
  SD_ILLEGAL_COMMAND        = (0x04),
  SD_COM_CRC_ERROR          = (0x08),
  SD_ERASE_SEQUENCE_ERROR   = (0x10),
  SD_ADDRESS_ERROR          = (0x20),
  SD_PARAMETER_ERROR        = (0x40),
  SD_RESPONSE_FAILURE       = (0xFF),

/**
  * @brief  Data response error
  */
  SD_DATA_OK                = (0x05),
  SD_DATA_CRC_ERROR         = (0x0B),
  SD_DATA_WRITE_ERROR       = (0x0D),
  SD_DATA_OTHER_ERROR       = (0xFF)
} SD_Error;

/**
  * @brief  Card Specific Data: CSD Register   
  */
typedef struct
{
  __IO uint8_t  CSDStruct;            /*!< CSD structure */
  __IO uint8_t  SysSpecVersion;       /*!< System specification version */
  __IO uint8_t  Reserved1;            /*!< Reserved */
  __IO uint8_t  TAAC;                 /*!< Data read access-time 1 */
  __IO uint8_t  NSAC;                 /*!< Data read access-time 2 in CLK cycles */
  __IO uint8_t  MaxBusClkFrec;        /*!< Max. bus clock frequency */
  __IO uint16_t CardComdClasses;      /*!< Card command classes */
  __IO uint8_t  RdBlockLen;           /*!< Max. read data block length */
  __IO uint8_t  PartBlockRead;        /*!< Partial blocks for read allowed */
  __IO uint8_t  WrBlockMisalign;      /*!< Write block misalignment */
  __IO uint8_t  RdBlockMisalign;      /*!< Read block misalignment */
  __IO uint8_t  DSRImpl;              /*!< DSR implemented */
  __IO uint8_t  Reserved2;            /*!< Reserved */
  __IO uint32_t DeviceSize;           /*!< Device Size */
  __IO uint8_t  MaxRdCurrentVDDMin;   /*!< Max. read current @ VDD min */
  __IO uint8_t  MaxRdCurrentVDDMax;   /*!< Max. read current @ VDD max */
  __IO uint8_t  MaxWrCurrentVDDMin;   /*!< Max. write current @ VDD min */
  __IO uint8_t  MaxWrCurrentVDDMax;   /*!< Max. write current @ VDD max */
  __IO uint8_t  DeviceSizeMul;        /*!< Device size multiplier */
  __IO uint8_t  EraseGrSize;          /*!< Erase group size */
  __IO uint8_t  EraseGrMul;           /*!< Erase group size multiplier */
  __IO uint8_t  WrProtectGrSize;      /*!< Write protect group size */
  __IO uint8_t  WrProtectGrEnable;    /*!< Write protect group enable */
  __IO uint8_t  ManDeflECC;           /*!< Manufacturer default ECC */
  __IO uint8_t  WrSpeedFact;          /*!< Write speed factor */
  __IO uint8_t  MaxWrBlockLen;        /*!< Max. write data block length */
  __IO uint8_t  WriteBlockPaPartial;  /*!< Partial blocks for write allowed */
  __IO uint8_t  Reserved3;            /*!< Reserded */
  __IO uint8_t  ContentProtectAppli;  /*!< Content protection application */
  __IO uint8_t  FileFormatGrouop;     /*!< File format group */
  __IO uint8_t  CopyFlag;             /*!< Copy flag (OTP) */
  __IO uint8_t  PermWrProtect;        /*!< Permanent write protection */
  __IO uint8_t  TempWrProtect;        /*!< Temporary write protection */
  __IO uint8_t  FileFormat;           /*!< File Format */
  __IO uint8_t  ECC;                  /*!< ECC code */
  __IO uint8_t  CSD_CRC;              /*!< CSD CRC */
  __IO uint8_t  Reserved4;            /*!< always 1*/
} SD_CSD;

/**
  * @brief  Card Identification Data: CID Register   
  */
typedef struct
{
  __IO uint8_t  ManufacturerID;       /*!< ManufacturerID */
  __IO uint16_t OEM_AppliID;          /*!< OEM/Application ID */
  __IO uint32_t ProdName1;            /*!< Product Name part1 */
  __IO uint8_t  ProdName2;            /*!< Product Name part2*/
  __IO uint8_t  ProdRev;              /*!< Product Revision */
  __IO uint32_t ProdSN;               /*!< Product Serial Number */
  __IO uint8_t  Reserved1;            /*!< Reserved1 */
  __IO uint16_t ManufactDate;         /*!< Manufacturing Date */
  __IO uint8_t  CID_CRC;              /*!< CID CRC */
  __IO uint8_t  Reserved2;            /*!< always 1 */
} SD_CID;

/**
  * @brief SD Card information
  */
typedef struct
{
  SD_CSD SD_csd;
  SD_CID SD_cid;
  uint64_t CardCapacity;  /*!< Card Capacity */
  uint32_t CardBlockSize; /*!< Card Block Size */
} SD_CardInfo;


extern SD_CardInfo SDCardInfo;        //用于存储卡的信息

/**
  * @}
  */

/** @defgroup STM32_EVAL_SPI_SD_Exported_Constants
  * @{
  */

/**
  * @brief  Block Size
  */
#define SD_BLOCK_SIZE    0x200

/**
  * @brief  Dummy byte
  */
#define SD_DUMMY_BYTE   0xFF

/**
  * @brief  Start Data tokens:
  *         Tokens (necessary because at nop/idle (and CS active) only 0xff is
  *         on the data/command line)  
  */
#define SD_START_DATA_SINGLE_BLOCK_READ    0xFE  /*!< Data token start byte, Start Single Block Read */
#define SD_START_DATA_MULTIPLE_BLOCK_READ  0xFE  /*!< Data token start byte, Start Multiple Block Read */
#define SD_START_DATA_SINGLE_BLOCK_WRITE   0xFE  /*!< Data token start byte, Start Single Block Write */
#define SD_START_DATA_MULTIPLE_BLOCK_WRITE 0xFD  /*!< Data token start byte, Start Multiple Block Write */
#define SD_STOP_DATA_MULTIPLE_BLOCK_WRITE  0xFD  /*!< Data toke stop byte, Stop Multiple Block Write */

/**
  * @brief  SD detection on its memory slot
  */
#define SD_PRESENT        ((uint8_t)0x01)
#define SD_NOT_PRESENT    ((uint8_t)0x00)


/**
  * @brief  Commands: CMDxx = CMD-number | 0x40
  */
#define SD_CMD_GO_IDLE_STATE          0   /*!< CMD0 = 0x40 */
#define SD_CMD_SEND_OP_COND           1   /*!< CMD1 = 0x41 */
#define SD_CMD_SEND_IF_COND                                                8                /*!< CMD8 = 0x48 */
#define SD_CMD_SEND_CSD               9   /*!< CMD9 = 0x49 */
#define SD_CMD_SEND_CID               10  /*!< CMD10 = 0x4A */
#define SD_CMD_STOP_TRANSMISSION      12  /*!< CMD12 = 0x4C */
#define SD_CMD_SEND_STATUS            13  /*!< CMD13 = 0x4D */
#define SD_CMD_SET_BLOCKLEN           16  /*!< CMD16 = 0x50 */
#define SD_CMD_READ_SINGLE_BLOCK      17  /*!< CMD17 = 0x51 */
#define SD_CMD_READ_MULT_BLOCK        18  /*!< CMD18 = 0x52 */
#define SD_CMD_SET_BLOCK_COUNT        23  /*!< CMD23 = 0x57 */
#define SD_CMD_WRITE_SINGLE_BLOCK     24  /*!< CMD24 = 0x58 */
#define SD_CMD_WRITE_MULT_BLOCK       25  /*!< CMD25 = 0x59 */
#define SD_CMD_PROG_CSD               27  /*!< CMD27 = 0x5B */
#define SD_CMD_SET_WRITE_PROT         28  /*!< CMD28 = 0x5C */
#define SD_CMD_CLR_WRITE_PROT         29  /*!< CMD29 = 0x5D */
#define SD_CMD_SEND_WRITE_PROT        30  /*!< CMD30 = 0x5E */
#define SD_CMD_SD_ERASE_GRP_START     32  /*!< CMD32 = 0x60 */
#define SD_CMD_SD_ERASE_GRP_END       33  /*!< CMD33 = 0x61 */
#define SD_CMD_UNTAG_SECTOR           34  /*!< CMD34 = 0x62 */
#define SD_CMD_ERASE_GRP_START        35  /*!< CMD35 = 0x63 */
#define SD_CMD_ERASE_GRP_END          36  /*!< CMD36 = 0x64 */
#define SD_CMD_UNTAG_ERASE_GROUP      37  /*!< CMD37 = 0x65 */
#define SD_CMD_ERASE                  38  /*!< CMD38 = 0x66 */

#define SD_CMD_READ_OCR                                                                58 /*!< CMD58 */
#define SD_CMD_APP_CMD                                                                55 /*!< CMD55 返回0x01*/
#define SD_ACMD_SD_SEND_OP_COND                        41 /*!< ACMD41  返回0x00*/

//SD卡的类型
#define SD_TYPE_NOT_SD  0                //非SD卡
#define SD_TYPE_V1       1                //V1.0的卡
#define SD_TYPE_V2       2  //SDSC
#define SD_TYPE_V2HC     4         //SDHC



/** @defgroup STM32_EVAL_SPI_SD_Exported_Macros
  * @{
  */
/**
  * @brief  Select SD Card: ChipSelect pin low   
  */  
#define SD_CS_LOW()     GPIO_ResetBits(SD_CS_GPIO_PORT, SD_CS_PIN)
/**
  * @brief  Deselect SD Card: ChipSelect pin high   
  */
#define SD_CS_HIGH()    GPIO_SetBits(SD_CS_GPIO_PORT, SD_CS_PIN)
/**
  * @}
  */

/** @defgroup STM32_EVAL_SPI_SD_Exported_Functions
  * @{
  */
void SD_DeInit(void);  
SD_Error SD_Init(void);
uint8_t SD_Detect(void);
SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo);
SD_Error SD_GetCardType(void);
SD_Error SD_ReadBlock(uint8_t* pBuffer, uint64_t ReadAddr, uint16_t BlockSize);
SD_Error SD_ReadMultiBlocks(uint8_t* pBuffer, uint64_t ReadAddr, uint16_t BlockSize, uint32_t NumberOfBlocks);
SD_Error SD_WriteBlock(uint8_t* pBuffer, uint64_t WriteAddr, uint16_t BlockSize);
SD_Error SD_WriteMultiBlocks(uint8_t* pBuffer, uint64_t WriteAddr, uint16_t BlockSize, uint32_t NumberOfBlocks);
SD_Error SD_GetCSDRegister(SD_CSD* SD_csd);
SD_Error SD_GetCIDRegister(SD_CID* SD_cid);

void SD_SendCmd(uint8_t Cmd, uint32_t Arg, uint8_t Crc);
SD_Error SD_GetResponse(uint8_t Response);
uint8_t SD_GetDataResponse(void);
SD_Error SD_GoIdleState(void);
uint16_t SD_GetStatus(void);

uint8_t SD_WriteByte(uint8_t byte);
uint8_t SD_ReadByte(void);
FRESULT f_read_co(FIL* fp, void* buff, UINT btr, UINT* br);
FRESULT f_write_co(FIL* fp, const void* buff, UINT btw, UINT* bw);
FRESULT create_data_file(FIL* fp,char *filename);
FRESULT write_data(FIL* fp, char *filename, char *time, double ax, double ay, double az, double roll, double gx,double gy, double gz,
        double ax2, double ay2, double az2, double roll2, double gx2, double gy2, double gz2);
#ifdef __cplusplus
}
#endif

#endif /* __STM32_EVAL_SPI_SD_H */
/**
  * @}
  */

/**
  * @}
  */

/**
  * @}
  */

/**
  * @}
  */

/**
  * @}
  */   

/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/



/**
  ******************************************************************************
  * @file    stm32_eval_spi_sd.c
  * @author  MCD Application Team
  * @version V4.5.0
  * @date    07-March-2011
  * @brief   This file provides a set of functions needed to manage the SPI SD
  *          Card memory mounted on STM32xx-EVAL board (refer to stm32_eval.h
  *          to know about the boards supporting this memory).
  *          It implements a high level communication layer for read and write
  *          from/to this memory. The needed STM32 hardware resources (SPI and
  *          GPIO) are defined in stm32xx_eval.h file, and the initialization is
  *          performed in SD_LowLevel_Init() function declared in stm32xx_eval.c
  *          file.
  *          You can easily tailor this driver to any other development board,
  *          by just adapting the defines for hardware resources and
  *          SD_LowLevel_Init() function.
  *            
  *          +-------------------------------------------------------+
  *          |                     Pin assignment                    |
  *          +-------------------------+---------------+-------------+
  *          |  STM32 SPI Pins         |     SD        |    Pin      |
  *          +-------------------------+---------------+-------------+
  *          | SD_SPI_CS_PIN           |   ChipSelect  |    1        |
  *          | SD_SPI_MOSI_PIN / MOSI  |   DataIn      |    2        |
  *          |                         |   GND         |    3 (0 V)  |
  *          |                         |   VDD         |    4 (3.3 V)|
  *          | SD_SPI_SCK_PIN / SCLK   |   Clock       |    5        |
  *          |                         |   GND         |    6 (0 V)  |
  *          | SD_SPI_MISO_PIN / MISO  |   DataOut     |    7        |
  *          +-------------------------+---------------+-------------+
  ******************************************************************************
  * @attention
  *
  * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
  * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
  * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY
  * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
  * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
  * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
  *
  * <h2><center>&copy; COPYRIGHT 2011 STMicroelectronics</center></h2>
  ******************************************************************************  
  */

/* Includes ------------------------------------------------------------------*/
#include "./sdcard/bsp_spi_sdcard.h"
#include "Delay.h"
#include "stdio.h"
#include "string.h"

#define SD_BLOCKSIZE 512 //SD卡块大小
#define NULL 0

//记录卡的类型
uint8_t  SD_Type = SD_TYPE_NOT_SD;        //存储卡的类型
SD_CardInfo SDCardInfo;        //用于存储卡的信息


/*引脚配置层*/

/**
  * 函    数:SPI写SS引脚电平
  * 参    数:BitValue 协议层传入的当前需要写入SS的电平,范围0~1
  * 返 回 值:无
  * 注意事项:此函数需要用户实现内容,当BitValue为0时,需要置SS为低电平,当BitValue为1时,需要置SS为高电平
  */
void MySPI_W_SS(uint8_t BitValue)
{
        GPIO_WriteBit(SD_CS_GPIO_PORT, SD_CS_PIN, (BitAction)BitValue);                //根据BitValue,设置SS引脚的电平
}

/**
  * 函    数:SPI写SCK引脚电平
  * 参    数:BitValue 协议层传入的当前需要写入SCK的电平,范围0~1
  * 返 回 值:无
  * 注意事项:此函数需要用户实现内容,当BitValue为0时,需要置SCK为低电平,当BitValue为1时,需要置SCK为高电平
  */
void MySPI_W_SCK(uint8_t BitValue)
{
        GPIO_WriteBit(SD_SPI_SCK_GPIO_PORT, SD_SPI_SCK_PIN, (BitAction)BitValue);                //根据BitValue,设置SCK引脚的电平
}

/**
  * 函    数:SPI写MOSI引脚电平
  * 参    数:BitValue 协议层传入的当前需要写入MOSI的电平,范围0~1
  * 返 回 值:无
  * 注意事项:此函数需要用户实现内容,当BitValue为0时,需要置MOSI为低电平,当BitValue为1时,需要置MOSI为高电平
  */
void MySPI_W_MOSI(uint8_t BitValue)
{
        GPIO_WriteBit(SD_SPI_MOSI_GPIO_PORT, SD_SPI_MOSI_PIN, (BitAction)BitValue);                //根据BitValue,设置MOSI引脚的电平,BitValue要实现非0即1的特性
}

/**
  * 函    数:I2C读MISO引脚电平
  * 参    数:无
  * 返 回 值:协议层需要得到的当前MISO的电平,范围0~1
  * 注意事项:此函数需要用户实现内容,当前MISO为低电平时,返回0,当前MISO为高电平时,返回1
  */
uint8_t MySPI_R_MISO(void)
{
        return GPIO_ReadInputDataBit(SD_SPI_MISO_GPIO_PORT , SD_SPI_MISO_PIN);                        //读取MISO电平并返回
}

/**
  * @brief  DeInitializes the SD/SD communication.
  * @param  None
  * @retval None
  */
//void SD_DeInit(void)
//{
//        GPIO_InitTypeDef  GPIO_InitStructure;
//  
//  SPI_Cmd(SD_SPI, DISABLE); /*!< SD_SPI disable */
//  SPI_I2S_DeInit(SD_SPI);   /*!< DeInitializes the SD_SPI */
//  
//  /*!< SD_SPI Periph clock disable */
//  RCC_APB1PeriphClockCmd(SD_SPI_CLK, DISABLE);
//  /*!< DeRemap SPI3 Pins */
//  GPIO_PinRemapConfig(GPIO_Remap_SPI3, DISABLE);  
//  
//  /*!< Configure SD_SPI pins: SCK */
//  GPIO_InitStructure.GPIO_Pin = SD_SPI_SCK_PIN;
//  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
//  GPIO_Init(SD_SPI_SCK_GPIO_PORT, &GPIO_InitStructure);

//  /*!< Configure SD_SPI pins: MISO */
//  GPIO_InitStructure.GPIO_Pin = SD_SPI_MISO_PIN;
//  GPIO_Init(SD_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);

//  /*!< Configure SD_SPI pins: MOSI */
//  GPIO_InitStructure.GPIO_Pin = SD_SPI_MOSI_PIN;
//  GPIO_Init(SD_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure);

//  /*!< Configure SD_SPI_CS_PIN pin: SD Card CS pin */
//  GPIO_InitStructure.GPIO_Pin = SD_CS_PIN;
//  GPIO_Init(SD_CS_GPIO_PORT, &GPIO_InitStructure);

//  /*!< Configure SD_SPI_DETECT_PIN pin: SD Card detect pin */
//  GPIO_InitStructure.GPIO_Pin = SD_DETECT_PIN;
//  GPIO_Init(SD_DETECT_GPIO_PORT, &GPIO_InitStructure);

//}

void MySPI_Init(void)
{
        /*GPIO初始化*/
        GPIO_InitTypeDef GPIO_InitStructure;
       
        /*开启时钟*/
        RCC_APB2PeriphClockCmd(SD_SPI_CLK, ENABLE);
       
        //  /*!< Configure SD_SPI pins: SCK */
  GPIO_InitStructure.GPIO_Pin = SD_SPI_SCK_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(SD_SPI_SCK_GPIO_PORT, &GPIO_InitStructure);

  /*!< Configure SD_SPI pins: MOSI */
  GPIO_InitStructure.GPIO_Pin = SD_SPI_MOSI_PIN;
  GPIO_Init(SD_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure);

  /*!< Configure SD_SPI pins: MISO */
  GPIO_InitStructure.GPIO_Pin = SD_SPI_MISO_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;  
  GPIO_Init(SD_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);

  /*!< Configure SD_SPI_CS_PIN pin: SD Card CS pin */
  GPIO_InitStructure.GPIO_Pin = SD_CS_PIN;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(SD_CS_GPIO_PORT, &GPIO_InitStructure);
       
        /*设置默认电平*/
        SD_CS_HIGH();                                                                                        //SS默认高电平
        MySPI_W_SCK(1);                                                                                        //SCK默认低电平
}


/**
  * @brief  Initializes the SD/SD communication.
  * @param  None
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_Init(void)
{
  uint32_t i = 0;

  /*!< Initialize SD_SPI */
        MySPI_Init();
       
  /*!< SD chip select high */
  SD_CS_HIGH();

  /*!< Send dummy byte 0xFF, 10 times with CS high */
  /*!< Rise CS and MOSI for 80 clocks cycles */
  for (i = 0; i <= 9; i++)
  {
    /*!< Send dummy byte 0xFF */
    SD_WriteByte(SD_DUMMY_BYTE);
  }
       
        //获取卡的类型,最多尝试10次
        i=0;
        do
        {               
                /*------------Put SD in SPI mode--------------*/
                /*!< SD initialized and set to SPI mode properly */
                SD_GoIdleState();

                /*Get card type*/
                SD_GetCardType();
               
        }while(SD_Type == SD_TYPE_NOT_SD && i++ >10);
       
        //不支持的卡
        if(SD_Type == SD_TYPE_NOT_SD)
                return SD_RESPONSE_FAILURE;
                       
        return SD_GetCardInfo(&SDCardInfo);       
       
}

/**
* @brief  Detect if SD card is correctly plugged in the memory slot.
* @param  None
* @retval Return if SD is detected or not
*/
uint8_t SD_Detect(void)
{
  __IO uint8_t status = SD_PRESENT;

  /*!< Check GPIO to detect SD */
//  if (GPIO_ReadInputData(SD_DETECT_GPIO_PORT) & SD_DETECT_PIN)
//  {
//    status = SD_NOT_PRESENT;
//  }
  return status;
}

/**
  * @brief  Returns information about specific card.
  * @param  cardinfo: pointer to a SD_CardInfo structure that contains all SD
  *         card information.
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo)
{
  SD_Error status = SD_RESPONSE_FAILURE;

  status = SD_GetCSDRegister(&(cardinfo->SD_csd));
  status = SD_GetCIDRegister(&(cardinfo->SD_cid));
       
        if ((SD_Type == SD_TYPE_V1) || (SD_Type == SD_TYPE_V2))
        {

  cardinfo->CardCapacity = (cardinfo->SD_csd.DeviceSize + 1) ;
  cardinfo->CardCapacity *= (1 << (cardinfo->SD_csd.DeviceSizeMul + 2));
  cardinfo->CardBlockSize = 1 << (cardinfo->SD_csd.RdBlockLen);
  cardinfo->CardCapacity *= cardinfo->CardBlockSize;

        }
        else if (SD_Type == SD_TYPE_V2HC)
        {
          cardinfo->CardCapacity = (uint64_t)(cardinfo->SD_csd.DeviceSize + 1) * 512 * 1024;
    cardinfo->CardBlockSize = 512;   
        }       
       
  /*!< Returns the reponse */
  return status;
}

/**
  * @brief  Reads a block of data from the SD.
  * @param  pBuffer: pointer to the buffer that receives the data read from the
  *                  SD.
  * @param  ReadAddr: SD's internal address to read from.
  * @param  BlockSize: the SD card Data block size.
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_ReadBlock(uint8_t* pBuffer, uint64_t ReadAddr, uint16_t BlockSize)
{
  uint32_t i = 0;
  SD_Error rvalue = SD_RESPONSE_FAILURE;
       
        //SDHC卡块大小固定为512,且读命令中的地址的单位是sector
        if (SD_Type == SD_TYPE_V2HC)
  {
    BlockSize = 512;
    ReadAddr /= 512;
  }

  /*!< SD chip select low */
  SD_CS_LOW();

  /*!< Send CMD17 (SD_CMD_READ_SINGLE_BLOCK) to read one block */
  SD_SendCmd(SD_CMD_READ_SINGLE_BLOCK, ReadAddr, 0xFF);

  /*!< Check if the SD acknowledged the read block command: R1 response (0x00: no errors) */
  if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
  {
    /*!< Now look for the data token to signify the start of the data */
    if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
    {
      /*!< Read the SD block data : read NumByteToRead data */
      for (i = 0; i < BlockSize; i++)
      {
        /*!< Save the received data */
        *pBuffer = SD_ReadByte();

        /*!< Point to the next location where the byte read will be saved */
        pBuffer++;
      }
      /*!< Get CRC bytes (not really needed by us, but required by SD) */
      SD_ReadByte();
      SD_ReadByte();
      /*!< Set response value to success */
      rvalue = SD_RESPONSE_NO_ERROR;
    }
  }
  /*!< SD chip select high */
  SD_CS_HIGH();

  /*!< Send dummy byte: 8 Clock pulses of delay */
  SD_WriteByte(SD_DUMMY_BYTE);

  /*!< Returns the reponse */
  return rvalue;
}

/**
  * @brief  Reads multiple block of data from the SD.
  * @param  pBuffer: pointer to the buffer that receives the data read from the
  *                  SD.
  * @param  ReadAddr: SD's internal address to read from.
  * @param  BlockSize: the SD card Data block size.
  * @param  NumberOfBlocks: number of blocks to be read.
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_ReadMultiBlocks(uint8_t* pBuffer, uint64_t ReadAddr, uint16_t BlockSize, uint32_t NumberOfBlocks)
{
  uint32_t i = 0, Offset = 0;
  SD_Error rvalue = SD_RESPONSE_FAILURE;
       
        //SDHC卡块大小固定为512,且读命令中的地址的单位是sector
        if (SD_Type == SD_TYPE_V2HC)
  {
    BlockSize = 512;
    ReadAddr /= 512;
  }

  /*!< SD chip select low */
  SD_CS_LOW();
  /*!< Data transfer */
  while (NumberOfBlocks--)
  {
    /*!< Send CMD17 (SD_CMD_READ_SINGLE_BLOCK) to read one block */
    SD_SendCmd (SD_CMD_READ_SINGLE_BLOCK, ReadAddr + Offset, 0xFF);
    /*!< Check if the SD acknowledged the read block command: R1 response (0x00: no errors) */
    if (SD_GetResponse(SD_RESPONSE_NO_ERROR))
    {
      return  SD_RESPONSE_FAILURE;
    }
    /*!< Now look for the data token to signify the start of the data */
    if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
    {
      /*!< Read the SD block data : read NumByteToRead data */
      for (i = 0; i < BlockSize; i++)
      {
        /*!< Read the pointed data */
        *pBuffer = SD_ReadByte();
        /*!< Point to the next location where the byte read will be saved */
        pBuffer++;
      }
      /*!< Set next read address*/
      Offset += BlockSize;
      /*!< get CRC bytes (not really needed by us, but required by SD) */
      SD_ReadByte();
      SD_ReadByte();
      /*!< Set response value to success */
      rvalue = SD_RESPONSE_NO_ERROR;
    }
    else
    {
      /*!< Set response value to failure */
      rvalue = SD_RESPONSE_FAILURE;
    }

    /* 添加 Send dummy byte 防止读操作失败 */
    SD_WriteByte(SD_DUMMY_BYTE);
  }
  /*!< SD chip select high */
  SD_CS_HIGH();
  /*!< Send dummy byte: 8 Clock pulses of delay */
  SD_WriteByte(SD_DUMMY_BYTE);
  /*!< Returns the reponse */
  return rvalue;
}

/**
  * @brief  Writes a block on the SD
  * @param  pBuffer: pointer to the buffer containing the data to be written on
  *                  the SD.
  * @param  WriteAddr: address to write on.
  * @param  BlockSize: the SD card Data block size.
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_WriteBlock(uint8_t* pBuffer, uint64_t WriteAddr, uint16_t BlockSize)
{
  uint32_t i = 0;
  SD_Error rvalue = SD_RESPONSE_FAILURE;
       
        //SDHC卡块大小固定为512,且写命令中的地址的单位是sector
        if (SD_Type == SD_TYPE_V2HC)
  {
    BlockSize = 512;
    WriteAddr /= 512;
  }

  /*!< SD chip select low */
  SD_CS_LOW();

  /*!< Send CMD24 (SD_CMD_WRITE_SINGLE_BLOCK) to write multiple block */
  SD_SendCmd(SD_CMD_WRITE_SINGLE_BLOCK, WriteAddr, 0xFF);

  /*!< Check if the SD acknowledged the write block command: R1 response (0x00: no errors) */
  if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
  {
    /*!< Send a dummy byte */
    SD_WriteByte(SD_DUMMY_BYTE);

    /*!< Send the data token to signify the start of the data */
    SD_WriteByte(0xFE);

    /*!< Write the block data to SD : write count data by block */
    for (i = 0; i < BlockSize; i++)
    {
      /*!< Send the pointed byte */
      SD_WriteByte(*pBuffer);
      /*!< Point to the next location where the byte read will be saved */
      pBuffer++;
    }
    /*!< Put CRC bytes (not really needed by us, but required by SD) */
    SD_ReadByte();
    SD_ReadByte();

    /*!< Read data response */
    if (SD_GetDataResponse() == SD_DATA_OK)
    {
      rvalue = SD_RESPONSE_NO_ERROR;
    }
  }
  /*!< SD chip select high */
  SD_CS_HIGH();
  /*!< Send dummy byte: 8 Clock pulses of delay */
  SD_WriteByte(SD_DUMMY_BYTE);

  /*!< Returns the reponse */
  return rvalue;
}

/**
  * @brief  Writes many blocks on the SD
  * @param  pBuffer: pointer to the buffer containing the data to be written on
  *                  the SD.
  * @param  WriteAddr: address to write on.
  * @param  BlockSize: the SD card Data block size.
  * @param  NumberOfBlocks: number of blocks to be written.
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_WriteMultiBlocks(uint8_t* pBuffer, uint64_t WriteAddr, uint16_t BlockSize, uint32_t NumberOfBlocks)
{
  uint32_t i = 0, Offset = 0;
  SD_Error rvalue = SD_RESPONSE_FAILURE;
       
        //SDHC卡块大小固定为512,且写命令中的地址的单位是sector
        if (SD_Type == SD_TYPE_V2HC)
  {
    BlockSize = 512;
    WriteAddr /= 512;
  }

  /*!< SD chip select low */
  SD_CS_LOW();
  /*!< Data transfer */
  while (NumberOfBlocks--)
  {
    /*!< Send CMD24 (SD_CMD_WRITE_SINGLE_BLOCK) to write blocks */
    SD_SendCmd(SD_CMD_WRITE_SINGLE_BLOCK, WriteAddr + Offset, 0xFF);
    /*!< Check if the SD acknowledged the write block command: R1 response (0x00: no errors) */
    if (SD_GetResponse(SD_RESPONSE_NO_ERROR))
    {
      return SD_RESPONSE_FAILURE;
    }
    /*!< Send dummy byte */
    SD_WriteByte(SD_DUMMY_BYTE);
    /*!< Send the data token to signify the start of the data */
    SD_WriteByte(SD_START_DATA_SINGLE_BLOCK_WRITE);
    /*!< Write the block data to SD : write count data by block */
    for (i = 0; i < BlockSize; i++)
    {
      /*!< Send the pointed byte */
      SD_WriteByte(*pBuffer);
      /*!< Point to the next location where the byte read will be saved */
      pBuffer++;
    }
    /*!< Set next write address */
    Offset += BlockSize;
    /*!< Put CRC bytes (not really needed by us, but required by SD) */
    SD_ReadByte();
    SD_ReadByte();
    /*!< Read data response */
    if (SD_GetDataResponse() == SD_DATA_OK)
    {
      /*!< Set response value to success */
      rvalue = SD_RESPONSE_NO_ERROR;
    }
    else
    {
      /*!< Set response value to failure */
      rvalue = SD_RESPONSE_FAILURE;
    }
  }
  /*!< SD chip select high */
  SD_CS_HIGH();
  /*!< Send dummy byte: 8 Clock pulses of delay */
  SD_WriteByte(SD_DUMMY_BYTE);
  /*!< Returns the reponse */
  return rvalue;
}

/**
  * @brief  Read the CSD card register.
  *         Reading the contents of the CSD register in SPI mode is a simple
  *         read-block transaction.
  * @param  SD_csd: pointer on an SCD register structure
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_GetCSDRegister(SD_CSD* SD_csd)
{
  uint32_t i = 0;
  SD_Error rvalue = SD_RESPONSE_FAILURE;
  uint8_t CSD_Tab[16];

  /*!< SD chip select low */
  SD_CS_LOW();
  /*!< Send CMD9 (CSD register) or CMD10(CSD register) */
  SD_SendCmd(SD_CMD_SEND_CSD, 0, 0xFF);
  /*!< Wait for response in the R1 format (0x00 is no errors) */
  if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
  {
    if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
    {
      for (i = 0; i < 16; i++)
      {
        /*!< Store CSD register value on CSD_Tab */
        CSD_Tab = SD_ReadByte();
      }
    }
    /*!< Get CRC bytes (not really needed by us, but required by SD) */
    SD_WriteByte(SD_DUMMY_BYTE);
    SD_WriteByte(SD_DUMMY_BYTE);
    /*!< Set response value to success */
    rvalue = SD_RESPONSE_NO_ERROR;
  }
  /*!< SD chip select high */
  SD_CS_HIGH();
  /*!< Send dummy byte: 8 Clock pulses of delay */
  SD_WriteByte(SD_DUMMY_BYTE);

  /*!< Byte 0 */
  SD_csd->CSDStruct = (CSD_Tab[0] & 0xC0) >> 6;
  SD_csd->SysSpecVersion = (CSD_Tab[0] & 0x3C) >> 2;
  SD_csd->Reserved1 = CSD_Tab[0] & 0x03;

  /*!< Byte 1 */
  SD_csd->TAAC = CSD_Tab[1];

  /*!< Byte 2 */
  SD_csd->NSAC = CSD_Tab[2];

  /*!< Byte 3 */
  SD_csd->MaxBusClkFrec = CSD_Tab[3];

  /*!< Byte 4 */
  SD_csd->CardComdClasses = CSD_Tab[4] << 4;

  /*!< Byte 5 */
  SD_csd->CardComdClasses |= (CSD_Tab[5] & 0xF0) >> 4;
  SD_csd->RdBlockLen = CSD_Tab[5] & 0x0F;

  /*!< Byte 6 */
  SD_csd->PartBlockRead = (CSD_Tab[6] & 0x80) >> 7;
  SD_csd->WrBlockMisalign = (CSD_Tab[6] & 0x40) >> 6;
  SD_csd->RdBlockMisalign = (CSD_Tab[6] & 0x20) >> 5;
  SD_csd->DSRImpl = (CSD_Tab[6] & 0x10) >> 4;
  SD_csd->Reserved2 = 0; /*!< Reserved */

  SD_csd->DeviceSize = (CSD_Tab[6] & 0x03) << 10;

        //V1卡与SDSC卡的信息
  if ((SD_Type == SD_TYPE_V1) || (SD_Type == SD_TYPE_V2))
        {
                /*!< Byte 7 */
                SD_csd->DeviceSize |= (CSD_Tab[7]) << 2;

                /*!< Byte 8 */
                SD_csd->DeviceSize |= (CSD_Tab[8] & 0xC0) >> 6;

                SD_csd->MaxRdCurrentVDDMin = (CSD_Tab[8] & 0x38) >> 3;
                SD_csd->MaxRdCurrentVDDMax = (CSD_Tab[8] & 0x07);

                /*!< Byte 9 */
                SD_csd->MaxWrCurrentVDDMin = (CSD_Tab[9] & 0xE0) >> 5;
                SD_csd->MaxWrCurrentVDDMax = (CSD_Tab[9] & 0x1C) >> 2;
                SD_csd->DeviceSizeMul = (CSD_Tab[9] & 0x03) << 1;
                /*!< Byte 10 */
                SD_csd->DeviceSizeMul |= (CSD_Tab[10] & 0x80) >> 7;
  }
        //SDHC卡的信息
        else if (SD_Type == SD_TYPE_V2HC)
        {
                SD_csd->DeviceSize = (CSD_Tab[7] & 0x3F) << 16;

                SD_csd->DeviceSize |= (CSD_Tab[8] << 8);

                SD_csd->DeviceSize |= (CSD_Tab[9]);               
        }
               
               
  SD_csd->EraseGrSize = (CSD_Tab[10] & 0x40) >> 6;
  SD_csd->EraseGrMul = (CSD_Tab[10] & 0x3F) << 1;

  /*!< Byte 11 */
  SD_csd->EraseGrMul |= (CSD_Tab[11] & 0x80) >> 7;
  SD_csd->WrProtectGrSize = (CSD_Tab[11] & 0x7F);

  /*!< Byte 12 */
  SD_csd->WrProtectGrEnable = (CSD_Tab[12] & 0x80) >> 7;
  SD_csd->ManDeflECC = (CSD_Tab[12] & 0x60) >> 5;
  SD_csd->WrSpeedFact = (CSD_Tab[12] & 0x1C) >> 2;
  SD_csd->MaxWrBlockLen = (CSD_Tab[12] & 0x03) << 2;

  /*!< Byte 13 */
  SD_csd->MaxWrBlockLen |= (CSD_Tab[13] & 0xC0) >> 6;
  SD_csd->WriteBlockPaPartial = (CSD_Tab[13] & 0x20) >> 5;
  SD_csd->Reserved3 = 0;
  SD_csd->ContentProtectAppli = (CSD_Tab[13] & 0x01);

  /*!< Byte 14 */
  SD_csd->FileFormatGrouop = (CSD_Tab[14] & 0x80) >> 7;
  SD_csd->CopyFlag = (CSD_Tab[14] & 0x40) >> 6;
  SD_csd->PermWrProtect = (CSD_Tab[14] & 0x20) >> 5;
  SD_csd->TempWrProtect = (CSD_Tab[14] & 0x10) >> 4;
  SD_csd->FileFormat = (CSD_Tab[14] & 0x0C) >> 2;
  SD_csd->ECC = (CSD_Tab[14] & 0x03);

  /*!< Byte 15 */
  SD_csd->CSD_CRC = (CSD_Tab[15] & 0xFE) >> 1;
  SD_csd->Reserved4 = 1;

  /*!< Return the reponse */
  return rvalue;
}

/**
  * @brief  Read the CID card register.
  *         Reading the contents of the CID register in SPI mode is a simple
  *         read-block transaction.
  * @param  SD_cid: pointer on an CID register structure
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_GetCIDRegister(SD_CID* SD_cid)
{
  uint32_t i = 0;
  SD_Error rvalue = SD_RESPONSE_FAILURE;
  uint8_t CID_Tab[16];

  /*!< SD chip select low */
  SD_CS_LOW();

  /*!< Send CMD10 (CID register) */
  SD_SendCmd(SD_CMD_SEND_CID, 0, 0xFF);

  /*!< Wait for response in the R1 format (0x00 is no errors) */
  if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
  {
    if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
    {
      /*!< Store CID register value on CID_Tab */
      for (i = 0; i < 16; i++)
      {
        CID_Tab = SD_ReadByte();
      }
    }
    /*!< Get CRC bytes (not really needed by us, but required by SD) */
    SD_WriteByte(SD_DUMMY_BYTE);
    SD_WriteByte(SD_DUMMY_BYTE);
    /*!< Set response value to success */
    rvalue = SD_RESPONSE_NO_ERROR;
  }
  /*!< SD chip select high */
  SD_CS_HIGH();
  /*!< Send dummy byte: 8 Clock pulses of delay */
  SD_WriteByte(SD_DUMMY_BYTE);

  /*!< Byte 0 */
  SD_cid->ManufacturerID = CID_Tab[0];

  /*!< Byte 1 */
  SD_cid->OEM_AppliID = CID_Tab[1] << 8;

  /*!< Byte 2 */
  SD_cid->OEM_AppliID |= CID_Tab[2];

  /*!< Byte 3 */
  SD_cid->ProdName1 = CID_Tab[3] << 24;

  /*!< Byte 4 */
  SD_cid->ProdName1 |= CID_Tab[4] << 16;

  /*!< Byte 5 */
  SD_cid->ProdName1 |= CID_Tab[5] << 8;

  /*!< Byte 6 */
  SD_cid->ProdName1 |= CID_Tab[6];

  /*!< Byte 7 */
  SD_cid->ProdName2 = CID_Tab[7];

  /*!< Byte 8 */
  SD_cid->ProdRev = CID_Tab[8];

  /*!< Byte 9 */
  SD_cid->ProdSN = CID_Tab[9] << 24;

  /*!< Byte 10 */
  SD_cid->ProdSN |= CID_Tab[10] << 16;

  /*!< Byte 11 */
  SD_cid->ProdSN |= CID_Tab[11] << 8;

  /*!< Byte 12 */
  SD_cid->ProdSN |= CID_Tab[12];

  /*!< Byte 13 */
  SD_cid->Reserved1 |= (CID_Tab[13] & 0xF0) >> 4;
  SD_cid->ManufactDate = (CID_Tab[13] & 0x0F) << 8;

  /*!< Byte 14 */
  SD_cid->ManufactDate |= CID_Tab[14];

  /*!< Byte 15 */
  SD_cid->CID_CRC = (CID_Tab[15] & 0xFE) >> 1;
  SD_cid->Reserved2 = 1;

  /*!< Return the reponse */
  return rvalue;
}

/**
  * @brief  Send 5 bytes command to the SD card.
  * @param  Cmd: The user expected command to send to SD card.
  * @param  Arg: The command argument.
  * @param  Crc: The CRC.
  * @retval None
  */
void SD_SendCmd(uint8_t Cmd, uint32_t Arg, uint8_t Crc)
{
  uint32_t i = 0x00;

  uint8_t Frame[6];

  Frame[0] = (Cmd | 0x40); /*!< Construct byte 1 */

  Frame[1] = (uint8_t)(Arg >> 24); /*!< Construct byte 2 */

  Frame[2] = (uint8_t)(Arg >> 16); /*!< Construct byte 3 */

  Frame[3] = (uint8_t)(Arg >> 8); /*!< Construct byte 4 */

  Frame[4] = (uint8_t)(Arg); /*!< Construct byte 5 */

  Frame[5] = (Crc); /*!< Construct CRC: byte 6 */

  for (i = 0; i < 6; i++)
  {
    SD_WriteByte(Frame); /*!< Send the Cmd bytes */
  }
}

/**
  * @brief  Get SD card data response.
  * @param  None
  * @retval The SD status: Read data response xxx0<status>1
  *         - status 010: Data accecpted
  *         - status 101: Data rejected due to a crc error
  *         - status 110: Data rejected due to a Write error.
  *         - status 111: Data rejected due to other error.
  */
uint8_t SD_GetDataResponse(void)
{
  uint32_t i = 0;
  uint8_t response, rvalue;

  while (i <= 64)
  {
    /*!< Read resonse */
    response = SD_ReadByte();
    /*!< Mask unused bits */
    response &= 0x1F;
    switch (response)
    {
      case SD_DATA_OK:
      {
        rvalue = SD_DATA_OK;
        break;
      }
      case SD_DATA_CRC_ERROR:
        return SD_DATA_CRC_ERROR;
      case SD_DATA_WRITE_ERROR:
        return SD_DATA_WRITE_ERROR;
      default:
      {
        rvalue = SD_DATA_OTHER_ERROR;
        break;
      }
    }
    /*!< Exit loop in case of data ok */
    if (rvalue == SD_DATA_OK)
      break;
    /*!< Increment loop counter */
    i++;
  }

  /*!< Wait null data */
  while (SD_ReadByte() == 0);

  /*!< Return response */
  return response;
}

/**
  * @brief  Returns the SD response.
  * @param  None
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_GetResponse(uint8_t Response)
{
  uint32_t Count = 0xFFF;

  /*!< Check if response is got or a timeout is happen */
  while ((SD_ReadByte() != Response) && Count)
  {
    Count--;
  }
  if (Count == 0)
  {
    /*!< After time out */
    return SD_RESPONSE_FAILURE;
  }
  else
  {
    /*!< Right response got */
    return SD_RESPONSE_NO_ERROR;
  }
}

/**
  * @brief  Returns the SD status.
  * @param  None
  * @retval The SD status.
  */
uint16_t SD_GetStatus(void)
{
  uint16_t Status = 0;

  /*!< SD chip select low */
  SD_CS_LOW();

  /*!< Send CMD13 (SD_SEND_STATUS) to get SD status */
  SD_SendCmd(SD_CMD_SEND_STATUS, 0, 0xFF);

  Status = SD_ReadByte();
  Status |= (uint16_t)(SD_ReadByte() << 8);

  /*!< SD chip select high */
  SD_CS_HIGH();

  /*!< Send dummy byte 0xFF */
  SD_WriteByte(SD_DUMMY_BYTE);

  return Status;
}

/**
  * @brief  获取SD卡的版本类型,并区分SDSC和SDHC
  * @param  无
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_GetCardType(void)
{
  uint32_t i = 0;
        uint32_t Count = 0xFFF;

  uint8_t R7R3_Resp[4];
        uint8_t R1_Resp;

        SD_CS_HIGH();
       
        /*!< Send Dummy byte 0xFF */
        SD_WriteByte(SD_DUMMY_BYTE);
       
        /*!< SD chip select low */
        SD_CS_LOW();       


  /*!< Send CMD8 */
  SD_SendCmd(SD_CMD_SEND_IF_COND, 0x1AA, 0x87);        

  /*!< Check if response is got or a timeout is happen */
  while (( (R1_Resp = SD_ReadByte()) == 0xFF) && Count)
  {
    Count--;
  }
  if (Count == 0)
  {
    /*!< After time out */
    return SD_RESPONSE_FAILURE;
  }

        //响应 = 0x05   非V2.0的卡
        if(R1_Resp == (SD_IN_IDLE_STATE|SD_ILLEGAL_COMMAND))
        {
                  /*----------Activates the card initialization process-----------*/
                do
                {
                        /*!< SD chip select high */
                        SD_CS_HIGH();
                       
                        /*!< Send Dummy byte 0xFF */
                        SD_WriteByte(SD_DUMMY_BYTE);
                       
                        /*!< SD chip select low */
                        SD_CS_LOW();
                       
                        /*!< 发送CMD1完成V1 版本卡的初始化 */
                        SD_SendCmd(SD_CMD_SEND_OP_COND, 0, 0xFF);
                        /*!< Wait for no error Response (R1 Format) equal to 0x00 */
                }
                while (SD_GetResponse(SD_RESPONSE_NO_ERROR));
                //V1版本的卡完成初始化
               
                SD_Type = SD_TYPE_V1;
               
                //不处理MMC卡
               
                //初始化正常
                       
        }       
        //响应 0x01   V2.0的卡
  else if (R1_Resp == SD_IN_IDLE_STATE)
  {
      /*!< 读取CMD8 的R7响应 */
      for (i = 0; i < 4; i++)
      {
        R7R3_Resp = SD_ReadByte();
      }
                       
                        /*!< SD chip select high */
                        SD_CS_HIGH();
                       
                        /*!< Send Dummy byte 0xFF */
                        SD_WriteByte(SD_DUMMY_BYTE);
                       
                        /*!< SD chip select low */
                        SD_CS_LOW();
                       
                        //判断该卡是否支持2.7-3.6V电压
                        if(R7R3_Resp[2]==0x01 && R7R3_Resp[3]==0xAA)
                        {
                                        //支持电压范围,可以操作
                                        Count = 200;
                                        //发卡初始化指令CMD55+ACMD41                                                               
                                do
                    {
                                        //CMD55,以强调下面的是ACMD命令
                            SD_SendCmd(SD_CMD_APP_CMD, 0, 0xFF);                                       
                                        if (!SD_GetResponse(SD_RESPONSE_NO_ERROR)) // SD_IN_IDLE_STATE
                                                return SD_RESPONSE_FAILURE; //超时返回

                                        //ACMD41命令带HCS检查位
                            SD_SendCmd(SD_ACMD_SD_SEND_OP_COND, 0x40000000, 0xFF);

                                        if(Count-- == 0)   
                                                return SD_RESPONSE_FAILURE; //重试次数超时
         }while(SD_GetResponse(SD_RESPONSE_NO_ERROR));
                               
                                 //初始化指令完成,读取OCR信息,CMD58
                                 
                                 //-----------鉴别SDSC SDHC卡类型开始-----------               
                               
                                 Count = 200;
                                 do
                                        {
                                                /*!< SD chip select high */
                                                SD_CS_HIGH();
                                               
                                                /*!< Send Dummy byte 0xFF */
                                                SD_WriteByte(SD_DUMMY_BYTE);
                                               
                                                /*!< SD chip select low */
                                                SD_CS_LOW();
                                               
                                                /*!< 发送CMD58 读取OCR寄存器 */
                                                SD_SendCmd(SD_CMD_READ_OCR, 0, 0xFF);                                       
                                        }
                                        while ( SD_GetResponse(SD_RESPONSE_NO_ERROR) || Count-- == 0);

                                        if(Count == 0)
                                                return SD_RESPONSE_FAILURE; //重试次数超时

                                        //响应正常,读取R3响应
                                       
                                          /*!< 读取CMD58的R3响应 */
                                                for (i = 0; i < 4; i++)
                                                {
                                                        R7R3_Resp = SD_ReadByte();
                                                }               
                                               
                                                //检查接收到OCR中的bit30(CCS)
                                                //CCS = 0:SDSC                         CCS = 1:SDHC
            if(R7R3_Resp[0]&0x40)    //检查CCS标志
            {
                SD_Type = SD_TYPE_V2HC;
            }
            else
            {
                SD_Type = SD_TYPE_V2;
            }
            //-----------鉴别SDSC SDHC版本卡的流程结束-----------                         
                        }
  }

        /*!< SD chip select high */
  SD_CS_HIGH();
  /*!< Send dummy byte: 8 Clock pulses of delay */
  SD_WriteByte(SD_DUMMY_BYTE);
       
        //初始化正常返回
        return SD_RESPONSE_NO_ERROR;
}

/**
  * @brief  Put SD in Idle state.
  * @param  None
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_GoIdleState(void)
{
  /*!< SD chip select low */
  SD_CS_LOW();

  /*!< Send CMD0 (SD_CMD_GO_IDLE_STATE) to put SD in SPI mode */
  SD_SendCmd(SD_CMD_GO_IDLE_STATE, 0, 0x95);

  /*!< Wait for In Idle State Response (R1 Format) equal to 0x01 */
  if (SD_GetResponse(SD_IN_IDLE_STATE))
  {
    /*!< No Idle State Response: return response failue */
    return SD_RESPONSE_FAILURE;
  }

        SD_CS_HIGH();
       
        /*!< Send Dummy byte 0xFF */
        SD_WriteByte(SD_DUMMY_BYTE);       


        //正常返回
        return SD_RESPONSE_NO_ERROR ;
}

// 软件SPI写入一个字节
uint8_t SD_WriteByte(uint8_t data)
{
    uint8_t i, receive = 0;

    for(i = 0; i < 8; i++)
    {
        // 设置MOSI输出
        if(data & 0x80)
            MySPI_W_MOSI(1);
        else
            MySPI_W_MOSI(0);
        data <<= 1;

        // 产生时钟下降沿
        MySPI_W_SCK(0);
                                Delay_us(1);
//                                Delay_us(5);
        // 产生时钟上升沿
        MySPI_W_SCK(1);
        // 读取MISO输入
        receive <<= 1;
        if(MySPI_R_MISO())
            receive |= 0x01;

//                                Delay_us(5);
                                Delay_us(1);
    }

    return receive;
}

// 软件SPI读取一个字节
uint8_t SD_ReadByte(void)
{
    return SD_WriteByte(0xFF); // 发送0xFF同时接收数据
}
/**
  * @brief  读取文件数据,通过循环读取一小部分数据实现
  * @param  FIL* fp:文件对象指针
  * @param  void* buff:存放读出数据的首地址
  * @param  UINT btr:读取数据的字节数
  * @param  UINT* br:指示成功读取的字节个数
  * @retval 操作结果
  */

FRESULT f_read_co(FIL* fp, void* buff, UINT btr, UINT* br)
{
        FRESULT rc = FR_OK; // 函数返回值
        UINT ui_index = 0; // 当前要读的位置
        UINT ui_read_back = 0; // 从f_read()返回的当前读了多少个字节
        UINT ui_read_once = 0; // 本地调用f_read(), 要读取多少字节

        if (NULL != br) {
                *br = 0;// 如果传入的br参数不为空,则将其值设置为0
        }

        for (ui_index = 0; ui_index < btr;) {
                // 计算本次调用f_read()要读取多少字节,最多为SD_BLOCKSIZE
                ui_read_once = ((btr - ui_index) >= SD_BLOCKSIZE) ? SD_BLOCKSIZE : (btr - ui_index);
                ui_read_back = 0;// 每次循环前将ui_read_back重置为0
                rc = f_read(fp, (BYTE*)buff + ui_index, ui_read_once, &ui_read_back);// 调用f_read()读取数据


                ui_index += ui_read_back;// 更新已读取的字节数

                if (NULL != br) {
                        *br += ui_read_back;// 如果传入的br参数不为空,更新br的值
                }

                if (ui_read_once != ui_read_back) {
                        break; // 如果本次读取未达到预期字节数,跳出循环,表示读取完成
                }
        }

        return rc;// 返回函数执行状态
}

/**
  * @brief  写入文件数据,通过循环写入一小部分数据实现
  * @param  FIL* fp:文件对象指针
  * @param  void* buff:存放写入数据的首地址
  * @param  UINT btr:写入数据的字节数
  * @param  UINT* br:指示成功写入的字节个数
  * @retval 操作结果
  */

FRESULT f_write_co(FIL* fp, const void* buff, UINT btw, UINT* bw)
{
        FRESULT rc = FR_OK; // 函数返回值
        UINT ui_index = 0; // 当前要写的内容的位置索引
        UINT ui_write_back = 0; // 由f_write返回的写了多少字节
        UINT ui_write_once = 0; // 一次写多少个字节, 必须 <= 512字节, 否则FatFs写失败(只有前512字节正确, 后面都是0)

        if (NULL != bw) {
                *bw = 0;// 如果传入的bw参数不为空,则将其值设置为0
        }

        for (ui_index = 0; ui_index < btw;) {
                // 计算本次调用f_write()要写入多少字节,最多为SD_BLOCKSIZE
                ui_write_once = ((btw - ui_index) >= SD_BLOCKSIZE) ? SD_BLOCKSIZE : (btw - ui_index);
                ui_write_back = 0;// 每次循环前将ui_write_back重置为0
                rc = f_write(fp, (BYTE*)buff + ui_index, ui_write_once, &ui_write_back);// 调用f_write()写入数据


                ui_index += ui_write_back;// 更新已写入的字节数

                if (NULL != bw) {
                        *bw += ui_write_back;// 如果传入的bw参数不为空,更新bw的值
                }

                if (ui_write_once != ui_write_back) {
                        break; // 如果本次写入未达到预期字节数,跳出循环,表示写入完成
                }
        }

        return rc;// 返回函数执行状态
}


/**
  * @brief  写入陀螺仪数据
  * @retval 操作结果
  */
FRESULT write_data(FIL* file, char *filename, char *time, double ax, double ay, double az, double roll, double gx,double gy, double gz,
        double ax2, double ay2, double az2, double roll2, double gx2, double gy2, double gz2)
{
                FRESULT res_sd;               /* 文件操作结果 */
                UINT fnum;                                       /* 文件成功读写数量 */
               
                char data[200];
                sprintf(data,"%s,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f,%f\r\n",time,ax,ay,az,roll,gx,gy,gz,ax2,ay2,az2,roll2,gx2,gy2,gz2);
               
//                f_lseek(file,f_size(file));
                if(res_sd == FR_OK)
                {
                                res_sd=f_write(file,data,strlen(data),&fnum);
                                if(res_sd==FR_OK)
                                {
                                                printf("》文件写入成功,写入字节数据:%d\n",fnum);       
                                }
                                else
                                {
                                                printf("!!文件写入失败:(%d)\n",res_sd);
                                }   
                }
                /* 不再读写,关闭文件 */
                return res_sd;
}

/**
  * @brief  对写入数据文件格式初始化
        *        @param         filename :写入文件名
        * @retval 操作结果
  */
FRESULT create_data_file(FIL* file,char *filename)
{
                FRESULT res_sd;               /* 文件操作结果 */
                UINT fnum;                                       /* 文件成功读写数量 */
                char data[200];
       
                sprintf(data, "time,ax,ay,az,roll,gx,gy,gz,ax2,ay2,az2,roll2,gx2,gy2,gz2\r\n");
                res_sd = f_open(file, filename, FA_WRITE | FA_CREATE_ALWAYS);
                if(res_sd == FR_OK)
                {
                                res_sd=f_write(file, data,strlen(data),&fnum);
                                if(res_sd==FR_OK)
                                {
                                                printf("》文件格式初始化成功,写入字节数据:%d\n",fnum);       
                                }
                                else
                                {
                                                printf("!!文件写入失败:(%d)\n",res_sd);
                                }   
                }
                /* 不再读写,关闭文件 */
                return res_sd;
}

/**
  * @}
  */

/**
  * @}
  */

/**
  * @}
  */  

/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/



6.调试与常见问题解决
SD卡未响应首先要排查能否正确发送命令,数据线不能接错MOSI连接MOSI,MISO连接MISO。SPI交换数据是一定要按照时序来操作,如果不能成功的话,可以适当增加延时。
————————————————
版权声明:本文为CSDN博主「德涵玉润」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/hanhanhan233/article/details/148925135

您需要登录后才可以回帖 登录 | 注册

本版积分规则

112

主题

4379

帖子

4

粉丝
快速回复 在线客服 返回列表 返回顶部