设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › Cortex M3 M0 M4开发 › 移植SD卡驱动(最大支持32GB)
返回列表 发新帖
查看: 7999|回复: 0
收起左侧

移植SD卡驱动(最大支持32GB)

[复制链接]
ID:75926 发表于 2015-4-10 17:14 | 显示全部楼层 |阅读模式
移植之前只需要实现
void SD_LowLevel_Init(void);//初始化IO
uint8_t SD_WriteByte(uint8_t Data);//使用SPI 方式写8位数据
uint8_t SD_ReadByte(void)//使用SPI方式读取8位数据
#define SD_CS_LOW()     //拉高CS
#define SD_CS_HIGH()    //拉低CS
这三个函数和2个宏的具体实现就可以在不同的平台上使用SD卡
  1. SD_Error SD_Init(void)
  2. {
  3.   uint32_t i = 0;

  5.   /*!< Initialize SD_SPI */
  6.   SD_LowLevel_Init();

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

  11.   /*!< Send dummy byte 0xFF, 10 times with CS high */
  12.   /*!< Rise CS and MOSI for 80 clocks cycles */
  13.   for (i = 0; i <= 9; i++)
  14.   {
  15.     /*!< Send dummy byte 0xFF */
  16.     SD_WriteByte(SD_DUMMY_BYTE);
  17.   }
  18.   /*------------Put SD in SPI mode--------------*/
  19.   /*!< SD initialized and set to SPI mode properly */
  20.   return (SD_GoIdleState());
  21. }

  23. /**
  24.   * @brief  Returns information about specific card.
  25.   * @param  cardinfo: pointer to a SD_CardInfo structure that contains all SD
  26.   *         card information.
  27.   * @retval The SD Response:
  28.   *         - SD_RESPONSE_FAILURE: Sequence failed
  29.   *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  30.   */
  31. SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo)
  32. {
  33.   SD_Error status = SD_RESPONSE_FAILURE;

  35.   status = SD_GetCSDRegister(&(cardinfo->SD_csd));
  36.   status = SD_GetCIDRegister(&(cardinfo->SD_cid));
  37.   cardinfo->CardCapacity = (cardinfo->SD_csd.DeviceSize + 1) ;
  38.   cardinfo->CardCapacity *= (1 << (cardinfo->SD_csd.DeviceSizeMul + 2));
  39.   cardinfo->CardBlockSize = 1 << (cardinfo->SD_csd.RdBlockLen);
  40.   cardinfo->CardCapacity *= cardinfo->CardBlockSize;

  42.   /*!< Returns the reponse */
  43.   return status;
  44. }

  46. /**
  47.   * @brief  Reads a block of data from the SD.
  48.   * @param  pBuffer: pointer to the buffer that receives the data read from the
  49.   *                  SD.
  50.   * @param  ReadAddr: SD's internal address to read from.
  51.   * @param  BlockSize: the SD card Data block size.
  52.   * @retval The SD Response:
  53.   *         - SD_RESPONSE_FAILURE: Sequence failed
  54.   *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  55.   */
  56. SD_Error SD_ReadBlock(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t BlockSize)
  57. {
  58.   uint32_t i = 0;
  59.   SD_Error rvalue = SD_RESPONSE_FAILURE;

  61.   /*!< SD chip select low */
  62.   SD_CS_LOW();
  63.   
  64.   /*!< Send CMD17 (SD_CMD_READ_SINGLE_BLOCK) to read one block */
  65.   SD_SendCmd(SD_CMD_READ_SINGLE_BLOCK, ReadAddr, 0xFF);
  66.   
  67.   /*!< Check if the SD acknowledged the read block command: R1 response (0x00: no errors) */
  68.   if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
  69.   {
  70.     /*!< Now look for the data token to signify the start of the data */
  71.     if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
  72.     {
  73.       /*!< Read the SD block data : read NumByteToRead data */
  74.       for (i = 0; i < BlockSize; i++)
  75.       {
  76.         /*!< Save the received data */
  77.         *pBuffer = SD_ReadByte();
  78.       
  79.         /*!< Point to the next location where the byte read will be saved */
  80.         pBuffer++;
  81.       }
  82.       /*!< Get CRC bytes (not really needed by us, but required by SD) */
  83.       SD_ReadByte();
  84.       SD_ReadByte();
  85.       /*!< Set response value to success */
  86.       rvalue = SD_RESPONSE_NO_ERROR;
  87.     }
  88.   }
  89.   /*!< SD chip select high */
  90.   SD_CS_HIGH();
  91.   
  92.   /*!< Send dummy byte: 8 Clock pulses of delay */
  93.   SD_WriteByte(SD_DUMMY_BYTE);
  94.   
  95.   /*!< Returns the reponse */
  96.   return rvalue;
  97. }

  99. /**
  100.   * @brief  Reads multiple block of data from the SD.
  101.   * @param  pBuffer: pointer to the buffer that receives the data read from the
  102.   *                  SD.
  103.   * @param  ReadAddr: SD's internal address to read from.
  104.   * @param  BlockSize: the SD card Data block size.
  105.   * @param  NumberOfBlocks: number of blocks to be read.
  106.   * @retval The SD Response:
  107.   *         - SD_RESPONSE_FAILURE: Sequence failed
  108.   *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  109.   */
  110. SD_Error SD_ReadMultiBlocks(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t BlockSize, uint32_t NumberOfBlocks)
  111. {
  112.   uint32_t i = 0, Offset = 0;
  113.   SD_Error rvalue = SD_RESPONSE_FAILURE;
  114.   
  115.   /*!< SD chip select low */
  116.   SD_CS_LOW();
  117.   /*!< Data transfer */
  118.   while (NumberOfBlocks--)
  119.   {
  120.     /*!< Send CMD17 (SD_CMD_READ_SINGLE_BLOCK) to read one block */
  121.     SD_SendCmd (SD_CMD_READ_SINGLE_BLOCK, ReadAddr + Offset, 0xFF);
  122.     /*!< Check if the SD acknowledged the read block command: R1 response (0x00: no errors) */
  123.     if (SD_GetResponse(SD_RESPONSE_NO_ERROR))
  124.     {
  125.       return  SD_RESPONSE_FAILURE;
  126.     }
  127.     /*!< Now look for the data token to signify the start of the data */
  128.     if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
  129.     {
  130.       /*!< Read the SD block data : read NumByteToRead data */
  131.       for (i = 0; i < BlockSize; i++)
  132.       {
  133.         /*!< Read the pointed data */
  134.         *pBuffer = SD_ReadByte();
  135.         /*!< Point to the next location where the byte read will be saved */
  136.         pBuffer++;
  137.       }
  138.       /*!< Set next read address*/
  139.       Offset += 512;
  140.       /*!< get CRC bytes (not really needed by us, but required by SD) */
  141.       SD_ReadByte();
  142.       SD_ReadByte();
  143.       /*!< Set response value to success */
  144.       rvalue = SD_RESPONSE_NO_ERROR;
  145.     }
  146.     else
  147.     {
  148.       /*!< Set response value to failure */
  149.       rvalue = SD_RESPONSE_FAILURE;
  150.     }
  151.   }
  152.   /*!< SD chip select high */
  153.   SD_CS_HIGH();
  154.   /*!< Send dummy byte: 8 Clock pulses of delay */
  155.   SD_WriteByte(SD_DUMMY_BYTE);
  156.   /*!< Returns the reponse */
  157.   return rvalue;
  158. }

  160. /**
  161.   * @brief  Writes a block on the SD
  162.   * @param  pBuffer: pointer to the buffer containing the data to be written on
  163.   *                  the SD.
  164.   * @param  WriteAddr: address to write on.
  165.   * @param  BlockSize: the SD card Data block size.
  166.   * @retval The SD Response:
  167.   *         - SD_RESPONSE_FAILURE: Sequence failed
  168.   *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  169.   */
  170. SD_Error SD_WriteBlock(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t BlockSize)
  171. {
  172.   uint32_t i = 0;
  173.   SD_Error rvalue = SD_RESPONSE_FAILURE;

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

  178.   /*!< Send CMD24 (SD_CMD_WRITE_SINGLE_BLOCK) to write multiple block */
  179.   SD_SendCmd(SD_CMD_WRITE_SINGLE_BLOCK, WriteAddr, 0xFF);
  180.   
  181.   /*!< Check if the SD acknowledged the write block command: R1 response (0x00: no errors) */
  182.   if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
  183.   {
  184.     /*!< Send a dummy byte */
  185.     SD_WriteByte(SD_DUMMY_BYTE);

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

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

  202.     /*!< Read data response */
  203.     if (SD_GetDataResponse() == SD_DATA_OK)
  204.     {
  205.       rvalue = SD_RESPONSE_NO_ERROR;
  206.     }
  207.   }
  208.   /*!< SD chip select high */
  209.   SD_CS_HIGH();
  210.   /*!< Send dummy byte: 8 Clock pulses of delay */
  211.   SD_WriteByte(SD_DUMMY_BYTE);

  213.   /*!< Returns the reponse */
  214.   return rvalue;
  215. }

  217. /**
  218.   * @brief  Writes many blocks on the SD
  219.   * @param  pBuffer: pointer to the buffer containing the data to be written on
  220.   *                  the SD.
  221.   * @param  WriteAddr: address to write on.
  222.   * @param  BlockSize: the SD card Data block size.
  223.   * @param  NumberOfBlocks: number of blocks to be written.
  224.   * @retval The SD Response:
  225.   *         - SD_RESPONSE_FAILURE: Sequence failed
  226.   *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  227.   */
  228. SD_Error SD_WriteMultiBlocks(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t BlockSize, uint32_t NumberOfBlocks)
  229. {
  230.   uint32_t i = 0, Offset = 0;
  231.   SD_Error rvalue = SD_RESPONSE_FAILURE;

  233.   /*!< SD chip select low */
  234.   SD_CS_LOW();
  235.   /*!< Data transfer */
  236.   while (NumberOfBlocks--)
  237.   {
  238.     /*!< Send CMD24 (SD_CMD_WRITE_SINGLE_BLOCK) to write blocks */
  239.     SD_SendCmd(SD_CMD_WRITE_SINGLE_BLOCK, WriteAddr + Offset, 0xFF);
  240.     /*!< Check if the SD acknowledged the write block command: R1 response (0x00: no errors) */
  241.     if (SD_GetResponse(SD_RESPONSE_NO_ERROR))
  242.     {
  243.       return SD_RESPONSE_FAILURE;
  244.     }
  245.     /*!< Send dummy byte */
  246.     SD_WriteByte(SD_DUMMY_BYTE);
  247.     /*!< Send the data token to signify the start of the data */
  248.     SD_WriteByte(SD_START_DATA_SINGLE_BLOCK_WRITE);
  249.     /*!< Write the block data to SD : write count data by block */
  250.     for (i = 0; i < BlockSize; i++)
  251.     {
  252.       /*!< Send the pointed byte */
  253.       SD_WriteByte(*pBuffer);
  254.       /*!< Point to the next location where the byte read will be saved */
  255.       pBuffer++;
  256.     }
  257.     /*!< Set next write address */
  258.     Offset += 512;
  259.     /*!< Put CRC bytes (not really needed by us, but required by SD) */
  260.     SD_ReadByte();
  261.     SD_ReadByte();
  262.     /*!< Read data response */
  263.     if (SD_GetDataResponse() == SD_DATA_OK)
  264.     {
  265.       /*!< Set response value to success */
  266.       rvalue = SD_RESPONSE_NO_ERROR;
  267.     }
  268.     else
  269.     {
  270.       /*!< Set response value to failure */
  271.       rvalue = SD_RESPONSE_FAILURE;
  272.     }
  273.   }
  274.   /*!< SD chip select high */
  275.   SD_CS_HIGH();
  276.   /*!< Send dummy byte: 8 Clock pulses of delay */
  277.   SD_WriteByte(SD_DUMMY_BYTE);
  278.   /*!< Returns the reponse */
  279.   return rvalue;
  280. }

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

  297.   /*!< SD chip select low */
  298.   SD_CS_LOW();
  299.   /*!< Send CMD9 (CSD register) or CMD10(CSD register) */
  300.   SD_SendCmd(SD_CMD_SEND_CSD, 0, 0xFF);
  301.   /*!< Wait for response in the R1 format (0x00 is no errors) */
  302.   if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
  303.   {
  304.     if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
  305.     {
  306.       for (i = 0; i < 16; i++)
  307.       {
  308.         /*!< Store CSD register value on CSD_Tab */
  309.         CSD_Tab[i] = SD_ReadByte();
  310.       }
  311.     }
  312.     /*!< Get CRC bytes (not really needed by us, but required by SD) */
  313.     SD_WriteByte(SD_DUMMY_BYTE);
  314.     SD_WriteByte(SD_DUMMY_BYTE);
  315.     /*!< Set response value to success */
  316.     rvalue = SD_RESPONSE_NO_ERROR;
  317.   }
  318.   /*!< SD chip select high */
  319.   SD_CS_HIGH();
  320.   /*!< Send dummy byte: 8 Clock pulses of delay */
  321.   SD_WriteByte(SD_DUMMY_BYTE);

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

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

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

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

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

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

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

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

  353.   /*!< Byte 7 */
  354.   SD_csd->DeviceSize |= (CSD_Tab[7]) << 2;

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

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

  362.   /*!< Byte 9 */
  363.   SD_csd->MaxWrCurrentVDDMin = (CSD_Tab[9] & 0xE0) >> 5;
  364.   SD_csd->MaxWrCurrentVDDMax = (CSD_Tab[9] & 0x1C) >> 2;
  365.   SD_csd->DeviceSizeMul = (CSD_Tab[9] & 0x03) << 1;
  366.   /*!< Byte 10 */
  367.   SD_csd->DeviceSizeMul |= (CSD_Tab[10] & 0x80) >> 7;
  368.    
  369.   SD_csd->EraseGrSize = (CSD_Tab[10] & 0x40) >> 6;
  370.   SD_csd->EraseGrMul = (CSD_Tab[10] & 0x3F) << 1;

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

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

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

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

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

  400.   /*!< Return the reponse */
  401.   return rvalue;
  402. }

  404. /**
  405.   * @brief  Read the CID card register.
  406.   *         Reading the contents of the CID register in SPI mode is a simple
  407.   *         read-block transaction.
  408.   * @param  SD_cid: pointer on an CID register structure
  409.   * @retval The SD Response:
  410.   *         - SD_RESPONSE_FAILURE: Sequence failed
  411.   *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  412.   */
  413. SD_Error SD_GetCIDRegister(SD_CID* SD_cid)
  414. {
  415.   uint32_t i = 0;
  416.   SD_Error rvalue = SD_RESPONSE_FAILURE;
  417.   uint8_t CID_Tab[16];
  418.   
  419.   /*!< SD chip select low */
  420.   SD_CS_LOW();
  421.   
  422.   /*!< Send CMD10 (CID register) */
  423.   SD_SendCmd(SD_CMD_SEND_CID, 0, 0xFF);
  424.   
  425.   /*!< Wait for response in the R1 format (0x00 is no errors) */
  426.   if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
  427.   {
  428.     if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
  429.     {
  430.       /*!< Store CID register value on CID_Tab */
  431.       for (i = 0; i < 16; i++)
  432.       {
  433.         CID_Tab[i] = SD_ReadByte();
  434.       }
  435.     }
  436.     /*!< Get CRC bytes (not really needed by us, but required by SD) */
  437.     SD_WriteByte(SD_DUMMY_BYTE);
  438.     SD_WriteByte(SD_DUMMY_BYTE);
  439.     /*!< Set response value to success */
  440.     rvalue = SD_RESPONSE_NO_ERROR;
  441.   }
  442.   /*!< SD chip select high */
  443.   SD_CS_HIGH();
  444.   /*!< Send dummy byte: 8 Clock pulses of delay */
  445.   SD_WriteByte(SD_DUMMY_BYTE);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  497.   /*!< Return the reponse */
  498.   return rvalue;
  499. }

  501. /**
  502.   * @brief  Send 5 bytes command to the SD card.
  503.   * @param  Cmd: The user expected command to send to SD card.
  504.   * @param  Arg: The command argument.
  505.   * @param  Crc: The CRC.
  506.   * @retval None
  507.   */
  508. void SD_SendCmd(uint8_t Cmd, uint32_t Arg, uint8_t Crc)
  509. {
  510.   uint32_t i = 0x00;
  511.   
  512.   uint8_t Frame[6];
  513.   
  514.   Frame[0] = (Cmd | 0x40); /*!< Construct byte 1 */
  515.   
  516.   Frame[1] = (uint8_t)(Arg >> 24); /*!< Construct byte 2 */
  517.   
  518.   Frame[2] = (uint8_t)(Arg >> 16); /*!< Construct byte 3 */
  519.   
  520.   Frame[3] = (uint8_t)(Arg >> 8); /*!< Construct byte 4 */
  521.   
  522.   Frame[4] = (uint8_t)(Arg); /*!< Construct byte 5 */
  523.   
  524.   Frame[5] = (Crc); /*!< Construct CRC: byte 6 */
  525.   
  526.   for (i = 0; i < 6; i++)
  527.   {
  528.     SD_WriteByte(Frame[i]); /*!< Send the Cmd bytes */
  529.   }
  530. }

  532. /**
  533.   * @brief  Get SD card data response.
  534.   * @param  None
  535.   * @retval The SD status: Read data response xxx0<status>1
  536.   *         - status 010: Data accecpted
  537.   *         - status 101: Data rejected due to a crc error
  538.   *         - status 110: Data rejected due to a Write error.
  539.   *         - status 111: Data rejected due to other error.
  540.   */
  541. uint8_t SD_GetDataResponse(void)
  542. {
  543.   uint32_t i = 0;
  544.   uint8_t response, rvalue;

  546.   while (i <= 64)
  547.   {
  548.     /*!< Read resonse */
  549.     response = SD_ReadByte();
  550.     /*!< Mask unused bits */
  551.     response &= 0x1F;
  552.     switch (response)
  553.     {
  554.       case SD_DATA_OK:
  555.       {
  556.         rvalue = SD_DATA_OK;
  557.         break;
  558.       }
  559.       case SD_DATA_CRC_ERROR:
  560.         return SD_DATA_CRC_ERROR;
  561.       case SD_DATA_WRITE_ERROR:
  562.         return SD_DATA_WRITE_ERROR;
  563.       default:
  564.       {
  565.         rvalue = SD_DATA_OTHER_ERROR;
  566.         break;
  567.       }
  568.     }
  569.     /*!< Exit loop in case of data ok */
  570.     if (rvalue == SD_DATA_OK)
  571.       break;
  572.     /*!< Increment loop counter */
  573.     i++;
  574.   }

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

  579.   /*!< Return response */
  580.   return response;
  581. }

  583. /**
  584.   * @brief  Returns the SD response.
  585.   * @param  None
  586.   * @retval The SD Response:
  587.   *         - SD_RESPONSE_FAILURE: Sequence failed
  588.   *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  589.   */
  590. SD_Error SD_GetResponse(uint8_t Response)
  591. {
  592.   uint32_t Count = 0xFFF;

  594.   /*!< Check if response is got or a timeout is happen */
  595.   while ((SD_ReadByte() != Response) && Count)
  596.   {
  597.     Count--;
  598.   }
  599.   if (Count == 0)
  600.   {
  601.     /*!< After time out */
  602.     return SD_RESPONSE_FAILURE;
  603.   }
  604.   else
  605.   {
  606.     /*!< Right response got */
  607.     return SD_RESPONSE_NO_ERROR;
  608.   }
  609. }

  611. /**
  612.   * @brief  Returns the SD status.
  613.   * @param  None
  614.   * @retval The SD status.
  615.   */
  616. uint16_t SD_GetStatus(void)
  617. {
  618.   uint16_t Status = 0;

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

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

  626.   Status = SD_ReadByte();
  627.   Status |= (uint16_t)(SD_ReadByte() << 8);

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

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

  635.   return Status;
  636. }

  638. /**
  639.   * @brief  Put SD in Idle state.
  640.   * @param  None
  641.   * @retval The SD Response:
  642.   *         - SD_RESPONSE_FAILURE: Sequence failed
  643.   *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  644.   */
  645. SD_Error SD_GoIdleState(void)
  646. {
  647.   /*!< SD chip select low */
  648.   SD_CS_LOW();
  649.   
  650.   /*!< Send CMD0 (SD_CMD_GO_IDLE_STATE) to put SD in SPI mode */
  651.   SD_SendCmd(SD_CMD_GO_IDLE_STATE, 0, 0x95);
  652.   
  653.   /*!< Wait for In Idle State Response (R1 Format) equal to 0x01 */
  654.   if (SD_GetResponse(SD_IN_IDLE_STATE))
  655.   {
  656.     /*!< No Idle State Response: return response failue */
  657.     return SD_RESPONSE_FAILURE;
  658.   }
  659.   /*----------Activates the card initialization process-----------*/
  660.   do
  661.   {
  662.     /*!< SD chip select high */
  663.     SD_CS_HIGH();
  664.    
  665.     /*!< Send Dummy byte 0xFF */
  666.     SD_WriteByte(SD_DUMMY_BYTE);
  667.    
  668.     /*!< SD chip select low */
  669.     SD_CS_LOW();
  670.    
  671.     /*!< Send CMD1 (Activates the card process) until response equal to 0x0 */
  672.     SD_SendCmd(SD_CMD_SEND_OP_COND, 0, 0xFF);
  673.     /*!< Wait for no error Response (R1 Format) equal to 0x00 */
  674.   }
  675.   while (SD_GetResponse(SD_RESPONSE_NO_ERROR));
  676.   
  677.   /*!< SD chip select high */
  678.   SD_CS_HIGH();
  679.   
  680.   /*!< Send dummy byte 0xFF */
  681.   SD_WriteByte(SD_DUMMY_BYTE);
  682.   
  683.   return SD_RESPONSE_NO_ERROR;
  684. }




  689. /*******************************************************END**************************************/

  691. typedef enum
  692. {
  693. /**
  694.   * @brief  SD reponses and error flags
  695.   */
  696.   SD_RESPONSE_NO_ERROR      = (0x00),
  697.   SD_IN_IDLE_STATE          = (0x01),
  698.   SD_ERASE_RESET            = (0x02),
  699.   SD_ILLEGAL_COMMAND        = (0x04),
  700.   SD_COM_CRC_ERROR          = (0x08),
  701.   SD_ERASE_SEQUENCE_ERROR   = (0x10),
  702.   SD_ADDRESS_ERROR          = (0x20),
  703.   SD_PARAMETER_ERROR        = (0x40),
  704.   SD_RESPONSE_FAILURE       = (0xFF),

  706. /**
  707.   * @brief  Data response error
  708.   */
  709.   SD_DATA_OK                = (0x05),
  710.   SD_DATA_CRC_ERROR         = (0x0B),
  711.   SD_DATA_WRITE_ERROR       = (0x0D),
  712.   SD_DATA_OTHER_ERROR       = (0xFF)
  713. } SD_Error;

  715. /**
  716.   * @brief  Card Specific Data: CSD Register   
  717.   */
  718. typedef struct
  719. {
  720.   __IO uint8_t  CSDStruct;            /*!< CSD structure */
  721.   __IO uint8_t  SysSpecVersion;       /*!< System specification version */
  722.   __IO uint8_t  Reserved1;            /*!< Reserved */
  723.   __IO uint8_t  TAAC;                 /*!< Data read access-time 1 */
  724.   __IO uint8_t  NSAC;                 /*!< Data read access-time 2 in CLK cycles */
  725.   __IO uint8_t  MaxBusClkFrec;        /*!< Max. bus clock frequency */
  726.   __IO uint16_t CardComdClasses;      /*!< Card command classes */
  727.   __IO uint8_t  RdBlockLen;           /*!< Max. read data block length */
  728.   __IO uint8_t  PartBlockRead;        /*!< Partial blocks for read allowed */
  729.   __IO uint8_t  WrBlockMisalign;      /*!< Write block misalignment */
  730.   __IO uint8_t  RdBlockMisalign;      /*!< Read block misalignment */
  731.   __IO uint8_t  DSRImpl;              /*!< DSR implemented */
  732.   __IO uint8_t  Reserved2;            /*!< Reserved */
  733.   __IO uint32_t DeviceSize;           /*!< Device Size */
  734.   __IO uint8_t  MaxRdCurrentVDDMin;   /*!< Max. read current @ VDD min */
  735.   __IO uint8_t  MaxRdCurrentVDDMax;   /*!< Max. read current @ VDD max */
  736.   __IO uint8_t  MaxWrCurrentVDDMin;   /*!< Max. write current @ VDD min */
  737.   __IO uint8_t  MaxWrCurrentVDDMax;   /*!< Max. write current @ VDD max */
  738.   __IO uint8_t  DeviceSizeMul;        /*!< Device size multiplier */
  739.   __IO uint8_t  EraseGrSize;          /*!< Erase group size */
  740.   __IO uint8_t  EraseGrMul;           /*!< Erase group size multiplier */
  741.   __IO uint8_t  WrProtectGrSize;      /*!< Write protect group size */
  742.   __IO uint8_t  WrProtectGrEnable;    /*!< Write protect group enable */
  743.   __IO uint8_t  ManDeflECC;           /*!< Manufacturer default ECC */
  744.   __IO uint8_t  WrSpeedFact;          /*!< Write speed factor */
  745.   __IO uint8_t  MaxWrBlockLen;        /*!< Max. write data block length */
  746.   __IO uint8_t  WriteBlockPaPartial;  /*!< Partial blocks for write allowed */
  747.   __IO uint8_t  Reserved3;            /*!< Reserded */
  748.   __IO uint8_t  ContentProtectAppli;  /*!< Content protection application */
  749.   __IO uint8_t  FileFormatGrouop;     /*!< File format group */
  750.   __IO uint8_t  CopyFlag;             /*!< Copy flag (OTP) */
  751.   __IO uint8_t  PermWrProtect;        /*!< Permanent write protection */
  752.   __IO uint8_t  TempWrProtect;        /*!< Temporary write protection */
  753.   __IO uint8_t  FileFormat;           /*!< File Format */
  754.   __IO uint8_t  ECC;                  /*!< ECC code */
  755.   __IO uint8_t  CSD_CRC;              /*!< CSD CRC */
  756.   __IO uint8_t  Reserved4;            /*!< always 1*/
  757. } SD_CSD;

  759. /**
  760.   * @brief  Card Identification Data: CID Register   
  761.   */
  762. typedef struct
  763. {
  764.   __IO uint8_t  ManufacturerID;       /*!< ManufacturerID */
  765.   __IO uint16_t OEM_AppliID;          /*!< OEM/Application ID */
  766.   __IO uint32_t ProdName1;            /*!< Product Name part1 */
  767.   __IO uint8_t  ProdName2;            /*!< Product Name part2*/
  768.   __IO uint8_t  ProdRev;              /*!< Product Revision */
  769.   __IO uint32_t ProdSN;               /*!< Product Serial Number */
  770.   __IO uint8_t  Reserved1;            /*!< Reserved1 */
  771.   __IO uint16_t ManufactDate;         /*!< Manufacturing Date */
  772.   __IO uint8_t  CID_CRC;              /*!< CID CRC */
  773.   __IO uint8_t  Reserved2;            /*!< always 1 */
  774. } SD_CID;

  776. /**
  777.   * @brief SD Card information
  778.   */
  779. typedef struct
  780. {
  781.   SD_CSD SD_csd;
  782.   SD_CID SD_cid;
  783.   uint32_t CardCapacity;  /*!< Card Capacity */
  784.   uint32_t CardBlockSize; /*!< Card Block Size */
  785. } SD_CardInfo;


  788. #define SD_BLOCK_SIZE    0x200


  791. #define SD_DUMMY_BYTE   0xFF


  794. #define SD_START_DATA_SINGLE_BLOCK_READ    0xFE  /*!< Data token start byte, Start Single Block Read */
  795. #define SD_START_DATA_MULTIPLE_BLOCK_READ  0xFE  /*!< Data token start byte, Start Multiple Block Read */
  796. #define SD_START_DATA_SINGLE_BLOCK_WRITE   0xFE  /*!< Data token start byte, Start Single Block Write */
  797. #define SD_START_DATA_MULTIPLE_BLOCK_WRITE 0xFD  /*!< Data token start byte, Start Multiple Block Write */
  798. #define SD_STOP_DATA_MULTIPLE_BLOCK_WRITE  0xFD  /*!< Data toke stop byte, Stop Multiple Block Write */


  801. #define SD_PRESENT        ((uint8_t)0x01)
  802. #define SD_NOT_PRESENT    ((uint8_t)0x00)


  805. #define SD_CMD_GO_IDLE_STATE          0   /*!< CMD0 = 0x40 */
  806. #define SD_CMD_SEND_OP_COND           1   /*!< CMD1 = 0x41 */
  807. #define SD_CMD_SEND_CSD               9   /*!< CMD9 = 0x49 */
  808. #define SD_CMD_SEND_CID               10  /*!< CMD10 = 0x4A */
  809. #define SD_CMD_STOP_TRANSMISSION      12  /*!< CMD12 = 0x4C */
  810. #define SD_CMD_SEND_STATUS            13  /*!< CMD13 = 0x4D */
  811. #define SD_CMD_SET_BLOCKLEN           16  /*!< CMD16 = 0x50 */
  812. #define SD_CMD_READ_SINGLE_BLOCK      17  /*!< CMD17 = 0x51 */
  813. #define SD_CMD_READ_MULT_BLOCK        18  /*!< CMD18 = 0x52 */
  814. #define SD_CMD_SET_BLOCK_COUNT        23  /*!< CMD23 = 0x57 */
  815. #define SD_CMD_WRITE_SINGLE_BLOCK     24  /*!< CMD24 = 0x58 */
  816. #define SD_CMD_WRITE_MULT_BLOCK       25  /*!< CMD25 = 0x59 */
  817. #define SD_CMD_PROG_CSD               27  /*!< CMD27 = 0x5B */
  818. #define SD_CMD_SET_WRITE_PROT         28  /*!< CMD28 = 0x5C */
  819. #define SD_CMD_CLR_WRITE_PROT         29  /*!< CMD29 = 0x5D */
  820. #define SD_CMD_SEND_WRITE_PROT        30  /*!< CMD30 = 0x5E */
  821. #define SD_CMD_SD_ERASE_GRP_START     32  /*!< CMD32 = 0x60 */
  822. #define SD_CMD_SD_ERASE_GRP_END       33  /*!< CMD33 = 0x61 */
  823. #define SD_CMD_UNTAG_SECTOR           34  /*!< CMD34 = 0x62 */
  824. #define SD_CMD_ERASE_GRP_START        35  /*!< CMD35 = 0x63 */
  825. #define SD_CMD_ERASE_GRP_END          36  /*!< CMD36 = 0x64 */
  826. #define SD_CMD_UNTAG_ERASE_GROUP      37  /*!< CMD37 = 0x65 */
  827. #define SD_CMD_ERASE                  38  /*!< CMD38 = 0x66 */





  833. SD_Error SD_Init(void);
  834. uint8_t SD_Detect(void);
  835. SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo);
  836. SD_Error SD_ReadBlock(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t BlockSize);
  837. SD_Error SD_ReadMultiBlocks(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t BlockSize, uint32_t NumberOfBlocks);
  838. SD_Error SD_WriteBlock(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t BlockSize);
  839. SD_Error SD_WriteMultiBlocks(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t BlockSize, uint32_t NumberOfBlocks);
  840. SD_Error SD_GetCSDRegister(SD_CSD* SD_csd);
  841. SD_Error SD_GetCIDRegister(SD_CID* SD_cid);

  843. void SD_SendCmd(uint8_t Cmd, uint32_t Arg, uint8_t Crc);
  844. SD_Error SD_GetResponse(uint8_t Response);
  845. uint8_t SD_GetDataResponse(void);
  846. SD_Error SD_GoIdleState(void);
  847. uint16_t SD_GetStatus(void);

  849. uint8_t SD_WriteByte(uint8_t byte);
  850. uint8_t SD_ReadByte(void);
复制代码



回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表