21ic电子技术开发论坛 › 单片机与嵌入式系统 › GigaDevice GD32 MCU › GD32F207 操作SD卡
12
返回列表 发新帖我要提问

GD32F207 操作SD卡

[复制链接]
2262|28
 楼主| gaoke231 发表于 2020-3-31 23:14 | 显示全部楼层
检查SD可卡是不是出于运行状态
复制
  1. static SD_Err IsCardProgramming(uint8_t *pstatus)
    

  2. {
    

  3.     SD_Err Status = SD_OK;
    

  4.     __IO uint32_t respR1 = 0, status = 0;
    


  5. 

  6.     /* CMD13 to polling the state of the card */
    

  7.     SDIO_CmdInitStructure.SDIO_CMDParameter = (uint32_t) RCA << 16;
    

  8.     SDIO_CmdInitStructure.SDIO_CMDIndex = SDIO_SEND_STATUS;
    

  9.     SDIO_CmdInitStructure.SDIO_ResponseType = SDIO_RESPONSETYPE_SHORT;
    

  10.     SDIO_CmdInitStructure.SDIO_WaitINTState = SDIO_WAITINTSTATE_NO;
    

  11.     SDIO_CmdInitStructure.SDIO_CSMState = SDIO_CSMSTATE_ENABLE;
    

  12.     SDIO_SendCMD(&SDIO_CmdInitStructure);
    


  13. 

  14.     status = SDIO->STR;
    

  15.     while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CMDTMOUT)))
    

  16.     {
    

  17.         status = SDIO->STR;
    

  18.     }
    


  19. 

  20.     if (status & SDIO_FLAG_CMDTMOUT)
    

  21.     {
    

  22.         Status = SD_CMD_RSP_TIMEOUT;
    

  23.         SDIO_ClearBitState(SDIO_FLAG_CMDTMOUT);
    

  24.         return(Status);
    

  25.     }
    

  26.     else if (status & SDIO_FLAG_CCRCFAIL)
    

  27.     {
    

  28.         Status = SD_CMD_CRC_FAIL;
    

  29.         SDIO_ClearBitState(SDIO_FLAG_CCRCFAIL);
    

  30.         return(Status);
    

  31.     }
    


  32. 

  33.     status = (uint32_t)SDIO_GetCMDResponse();
    


  34. 

  35.     /* Check response received is of desired command */
    

  36.     if (status != SDIO_SEND_STATUS)
    

  37.     {
    

  38.         Status = SD_ILLEGAL_CMD;
    

  39.         return(Status);
    

  40.     }
    


  41. 

  42.     /* Clear all the static flags */
    

  43.     SDIO_ClearBitState(SDIO_STATIC_FLAGS);
    


  44. 


  45. 

  46.     /* We have received response, retrieve it for analysis  */
    

  47.     respR1 = SDIO_GetResponse(SDIO_RESP1);
    


  48. 

  49.     /* Find out card status */
    

  50.     *pstatus = (uint8_t) ((respR1 >> 9) & 0x0000000F);
    


  51. 

  52.     if ((respR1 & SD_R1_ERRORBITS) == SD_ALLZERO)
    

  53.     {
    

  54.         return(Status);
    

  55.     }
    


  56. 

  57.     if (respR1 & SD_R1_ADDR_OUT_OF_RANGE)
    

  58.     {
    

  59.         return(SD_ADDR_OUT_OF_RANGE);
    

  60.     }
    


  61. 

  62.     if (respR1 & SD_R1_ADDR_MISALIGNED)
    

  63.     {
    

  64.         return(SD_ADDR_MISALIGNED);
    

  65.     }
    


  66. 

  67.     if (respR1 & SD_R1_BLOCK_LEN_ERR)
    

  68.     {
    

  69.         return(SD_BLOCK_LEN_ERR);
    

  70.     }
    


  71. 

  72.     if (respR1 & SD_R1_ERASE_SEQ_ERR)
    

  73.     {
    

  74.         return(SD_ERASE_SEQ_ERR);
    

  75.     }
    


  76. 

  77.     if (respR1 & SD_R1_BAD_ERASE_PARAM)
    

  78.     {
    

  79.         return(SD_BAD_ERASE_PARAM);
    

  80.     }
    


  81. 

  82.     if (respR1 & SD_R1_WRITE_PROT_VIOLATION)
    

  83.     {
    

  84.         return(SD_WRITE_PROT_VIOLATION);
    

  85.     }
    


  86. 

  87.     if (respR1 & SD_R1_LOCK_UNLOCK_FAILED)
    

  88.     {
    

  89.         return(SD_LOCK_UNLOCK_FAILED);
    

  90.     }
    


  91. 

  92.     if (respR1 & SD_R1_COM_CRC_FAILED)
    

  93.     {
    

  94.         return(SD_COM_CRC_FAILED);
    

  95.     }
    


  96. 

  97.     if (respR1 & SD_R1_ILLEGAL_CMD)
    

  98.     {
    

  99.         return(SD_ILLEGAL_CMD);
    

  100.     }
    


  101. 

  102.     if (respR1 & SD_R1_CARD_ECC_FAILED)
    

  103.     {
    

  104.         return(SD_CARD_ECC_FAILED);
    

  105.     }
    


  106. 

  107.     if (respR1 & SD_R1_CC_ERROR)
    

  108.     {
    

  109.         return(SD_CC_ERROR);
    

  110.     }
    


  111. 

  112.     if (respR1 & SD_R1_GENERAL_UNKNOWN_ERROR)
    

  113.     {
    

  114.         return(SD_GENERAL_UNKNOWN_ERROR);
    

  115.     }
    


  116. 

  117.     if (respR1 & SD_R1_STREAM_READ_UNDERRUN)
    

  118.     {
    

  119.         return(SD_STREAM_READ_UNDERRUN);
    

  120.     }
    


  121. 

  122.     if (respR1 & SD_R1_STREAM_WRITE_OVERRUN)
    

  123.     {
    

  124.         return(SD_STREAM_WRITE_OVERRUN);
    

  125.     }
    


  126. 

  127.     if (respR1 & SD_R1_CID_CSD_OVERWRIETE)
    

  128.     {
    

  129.         return(SD_CID_CSD_OVERWRITE);
    

  130.     }
    


  131. 

  132.     if (respR1 & SD_R1_WP_ERASE_SKIP)
    

  133.     {
    

  134.         return(SD_WP_ERASE_SKIP);
    

  135.     }
    


  136. 

  137.     if (respR1 & SD_R1_CARD_ECC_DISABLED)
    

  138.     {
    

  139.         return(SD_CARD_ECC_DISABLED);
    

  140.     }
    


  141. 

  142.     if (respR1 & SD_R1_ERASE_RESET)
    

  143.     {
    

  144.         return(SD_ERASE_RESET);
    

  145.     }
    


  146. 

  147.     if (respR1 & SD_R1_AKE_SEQ_ERROR)
    

  148.     {
    

  149.         return(SD_AKE_SEQ_ERROR);
    

  150.     }
    


  151. 

  152.     return(Status);
    

  153. }


回复

收藏1 举报

 楼主| gaoke231 发表于 2020-3-31 23:15 | 显示全部楼层
初始化SD卡的GPIO
复制
  1. static void GPIO_Configuration(void)
    

  2. {
    

  3.     GPIO_InitPara  GPIO_InitStructure;
    


  4. 

  5.     /* Enable GPIOC and GPIOD clock */
    

  6.     RCC_APB2PeriphClock_Enable(RCC_APB2PERIPH_GPIOC | RCC_APB2PERIPH_GPIOD, ENABLE);
    


  7. 

  8.     /* Configure relative ports(PC8, PC9, PC10, PC11, PC12: D0, D1, D2, D3, CLK pin) */
    

  9.     GPIO_InitStructure.GPIO_Pin = GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12;
    

  10.     GPIO_InitStructure.GPIO_Speed = GPIO_SPEED_50MHZ;
    

  11.     GPIO_InitStructure.GPIO_Mode = GPIO_MODE_AF_PP;
    

  12.     GPIO_Init(GPIOC, &GPIO_InitStructure);
    


  13. 

  14.     /* Configure PD2(CMD line) */
    

  15.     GPIO_InitStructure.GPIO_Pin = GPIO_PIN_2;
    

  16.     GPIO_Init(GPIOD, &GPIO_InitStructure);
    

  17. }


回复

收藏1 举报

 楼主| gaoke231 发表于 2020-3-31 23:16 | 显示全部楼层
初始化DMA 作为SDIO传输
复制
  1. static void DMA_TxConfiguration(uint32_t *BufferSRC, uint32_t BufferSize)
    

  2. {
    

  3.     DMA_InitPara DMA_InitStructure;
    


  4. 

  5.     DMA_ClearBitState(DMA2_FLAG_TC4 | DMA2_FLAG_TE4 | DMA2_FLAG_HT4 | DMA2_FLAG_GL4);
    


  6. 

  7.     /* DMA2 Channel4 disable */
    

  8.     DMA_Enable(DMA2_CHANNEL4, DISABLE);
    


  9. 

  10.     /* DMA2 Channel4 Config */
    

  11.     DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SDIO_FIFO_ADDR;
    

  12.     DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)BufferSRC;
    

  13.     DMA_InitStructure.DMA_DIR = DMA_DIR_PERIPHERALDST;
    

  14.     DMA_InitStructure.DMA_BufferSize = BufferSize / 4;
    

  15.     DMA_InitStructure.DMA_PeripheralInc = DMA_PERIPHERALINC_DISABLE;
    

  16.     DMA_InitStructure.DMA_MemoryInc = DMA_MEMORYINC_ENABLE;
    

  17.     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PERIPHERALDATASIZE_WORD;
    

  18.     DMA_InitStructure.DMA_MemoryDataSize = DMA_MEMORYDATASIZE_WORD;
    

  19.     DMA_InitStructure.DMA_Mode = DMA_MODE_NORMAL;
    

  20.     DMA_InitStructure.DMA_Priority = DMA_PRIORITY_HIGH;
    

  21.     DMA_InitStructure.DMA_MTOM = DMA_MEMTOMEM_DISABLE;
    

  22.     DMA_Init(DMA2_CHANNEL4, &DMA_InitStructure);
    


  23. 

  24.     /* DMA2 Channel4 enable */
    

  25.     DMA_Enable(DMA2_CHANNEL4, ENABLE);
    


  26. 

  27. }


回复

收藏1 举报

 楼主| gaoke231 发表于 2020-3-31 23:17 | 显示全部楼层
SD卡上锁
复制
  1. SD_Err SD_Lock_Unlock(uint8_t lockstate)
    

  2. {
    

  3.     SD_Err Status = SD_OK;
    

  4.     u8 cardstate = 0;
    

  5.     u32 pwd1,pwd2,cardstatus,timeout;
    


  6. 

  7.     /* Check if the card command class supports Lock/Unlock command */
    

  8.     if ((SD_CCC_LOCK_UNLOCK&SDIOInfo.SD_csd.CardComdClasses) == 0)
    

  9.     {
    

  10.         Status = SD_REQUEST_NOT_APPLICABLE;
    

  11.         return(Status);
    

  12.     }
    

  13.     /* PWD pattern */
    

  14.     pwd1 = (0x01020600|lockstate);
    

  15.     pwd2 = 0x03040506;
    


  16. 

  17.     /* Clear all DSM configuration */
    

  18.     SDIO_DataInitStructure.SDIO_DataTimeOut = 0;
    

  19.     SDIO_DataInitStructure.SDIO_DataLength = 0;
    

  20.     SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DATABLOCKSIZE_1B;
    

  21.     SDIO_DataInitStructure.SDIO_TransDirection = SDIO_TRANSDIRECTION_TOCARD;
    

  22.     SDIO_DataInitStructure.SDIO_TransMode = SDIO_TRANSMODE_BLOCK;
    

  23.     SDIO_DataInitStructure.SDIO_DSMState = SDIO_DSMSTATE_DISABLE;
    

  24.     SDIO_DataConfig(&SDIO_DataInitStructure);
    

  25.     SDIO_DMA_Enable(DISABLE);
    


  26. 

  27.     /* CMD16 Set Block Size for Card */
    

  28.     SDIO_CmdInitStructure.SDIO_CMDParameter = (uint32_t) 8;
    

  29.     SDIO_CmdInitStructure.SDIO_CMDIndex = SDIO_SET_BLOCKLEN;
    

  30.     SDIO_CmdInitStructure.SDIO_ResponseType = SDIO_RESPONSETYPE_SHORT;
    

  31.     SDIO_CmdInitStructure.SDIO_WaitINTState = SDIO_WAITINTSTATE_NO;
    

  32.     SDIO_CmdInitStructure.SDIO_CSMState = SDIO_CSMSTATE_ENABLE;
    

  33.     SDIO_SendCMD(&SDIO_CmdInitStructure);
    


  34. 

  35.     /* Check CMD errors */
    

  36.     Status = Check_Err_R1(SDIO_SET_BLOCKLEN);
    

  37.     if (Status != SD_OK)
    

  38.     {
    

  39.         return(Status);
    

  40.     }
    


  41. 

  42.     cardstatus = SDIO_GetResponse(SDIO_RESP1);
    


  43. 

  44.     /* Wait till card is ready for data writing */
    

  45.     SDIO_CmdInitStructure.SDIO_CMDParameter = (uint32_t) (RCA << 16);
    

  46.     SDIO_CmdInitStructure.SDIO_CMDIndex = SDIO_SEND_STATUS;
    

  47.     SDIO_CmdInitStructure.SDIO_ResponseType = SDIO_RESPONSETYPE_SHORT;
    

  48.     SDIO_CmdInitStructure.SDIO_WaitINTState = SDIO_WAITINTSTATE_NO;
    

  49.     SDIO_CmdInitStructure.SDIO_CSMState = SDIO_CSMSTATE_ENABLE;
    

  50.     SDIO_SendCMD(&SDIO_CmdInitStructure);
    


  51. 

  52.     Status = Check_Err_R1(SDIO_SEND_STATUS);
    


  53. 

  54.     if (Status != SD_OK)
    

  55.     {
    

  56.         return(Status);
    

  57.     }
    


  58. 

  59.     cardstatus = SDIO_GetResponse(SDIO_RESP1);
    


  60. 

  61.     timeout = 10000;
    


  62. 

  63.     while (((cardstatus & 0x00000100) == 0) && (timeout > 0))
    

  64.     {
    

  65.         /* CMD13 to polling the state of the card */
    

  66.         timeout--;
    

  67.         SDIO_CmdInitStructure.SDIO_CMDParameter = (uint32_t) (RCA << 16);
    

  68.         SDIO_CmdInitStructure.SDIO_CMDIndex = SDIO_SEND_STATUS;
    

  69.         SDIO_CmdInitStructure.SDIO_ResponseType = SDIO_RESPONSETYPE_SHORT;
    

  70.         SDIO_CmdInitStructure.SDIO_WaitINTState = SDIO_WAITINTSTATE_NO;
    

  71.         SDIO_CmdInitStructure.SDIO_CSMState = SDIO_CSMSTATE_ENABLE;
    

  72.         SDIO_SendCMD(&SDIO_CmdInitStructure);
    


  73. 

  74.         /* Check CMD errors */
    

  75.         Status = Check_Err_R1(SDIO_SEND_STATUS);
    

  76.         if (Status != SD_OK)
    

  77.         {
    

  78.             return(Status);
    

  79.         }
    


  80. 

  81.         cardstatus = SDIO_GetResponse(SDIO_RESP1);
    

  82.     }
    


  83. 

  84.     if (timeout == 0)
    

  85.     {
    

  86.         return(SD_ERROR);
    

  87.     }
    


  88. 

  89.      /* CMD42 LOCK_UNLOCK */
    

  90.     SDIO_CmdInitStructure.SDIO_CMDParameter = (uint32_t)0x00000000;
    

  91.     SDIO_CmdInitStructure.SDIO_CMDIndex = SDIO_LOCK_UNLOCK;
    

  92.     SDIO_CmdInitStructure.SDIO_ResponseType = SDIO_RESPONSETYPE_SHORT;
    

  93.     SDIO_CmdInitStructure.SDIO_WaitINTState = SDIO_WAITINTSTATE_NO;
    

  94.     SDIO_CmdInitStructure.SDIO_CSMState = SDIO_CSMSTATE_ENABLE;
    

  95.     SDIO_SendCMD(&SDIO_CmdInitStructure);
    


  96. 

  97.     /* Check CMD errors */
    

  98.     Status = Check_Err_R1(SDIO_LOCK_UNLOCK);
    

  99.     if (Status != SD_OK)
    

  100.     {
    

  101.         return(Status);
    

  102.     }
    


  103. 

  104.     cardstatus = SDIO_GetResponse(SDIO_RESP1);
    


  105. 

  106.     /* SDIO data transmisson config */
    

  107.     SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
    

  108.     SDIO_DataInitStructure.SDIO_DataLength = 8;
    

  109.     SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DATABLOCKSIZE_8B;
    

  110.     SDIO_DataInitStructure.SDIO_TransDirection = SDIO_TRANSDIRECTION_TOCARD;
    

  111.     SDIO_DataInitStructure.SDIO_TransMode = SDIO_TRANSMODE_BLOCK;
    

  112.     SDIO_DataInitStructure.SDIO_DSMState = SDIO_DSMSTATE_ENABLE;
    

  113.     SDIO_DataConfig(&SDIO_DataInitStructure);
    


  114. 

  115.     /* Write PWD pattern */
    

  116.     SDIO_WriteData(pwd1);
    

  117.     SDIO_WriteData(pwd2);
    


  118. 

  119.     if (SDIO_GetBitState(SDIO_FLAG_DTTMOUT) != RESET)
    

  120.     {
    

  121.         SDIO_ClearBitState(SDIO_FLAG_DTTMOUT);
    

  122.         Status = SD_DATA_TIMEOUT;
    

  123.         return(Status);
    

  124.     }
    

  125.     else if (SDIO_GetBitState(SDIO_FLAG_DTCRCFAIL) != RESET)
    

  126.     {
    

  127.         SDIO_ClearBitState(SDIO_FLAG_DTCRCFAIL);
    

  128.         Status = SD_DATA_CRC_FAIL;
    

  129.         return(Status);
    

  130.     }
    

  131.     else if (SDIO_GetBitState(SDIO_FLAG_TXURE) != RESET)
    

  132.     {
    

  133.         SDIO_ClearBitState(SDIO_FLAG_TXURE);
    

  134.         Status = SD_TX_UNDERRUN;
    

  135.         return(Status);
    

  136.     }
    

  137.     else if (SDIO_GetBitState(SDIO_FLAG_STBITE) != RESET)
    

  138.     {
    

  139.         SDIO_ClearBitState(SDIO_FLAG_STBITE);
    

  140.         Status = SD_START_BIT_ERR;
    

  141.         return(Status);
    

  142.     }
    


  143. 

  144.     /* Clear all the static flags */
    

  145.     SDIO_ClearBitState(SDIO_STATIC_FLAGS);
    


  146. 

  147.     /* Wait till the card is in programming state */
    

  148.     Status = IsCardProgramming(&cardstate);
    

  149.     while ((Status == SD_OK) && ((cardstate == SD_CARD_PROGRAMMING) || (cardstate == SD_CARD_RECEIVING)))
    

  150.     {
    

  151.         Status = IsCardProgramming(&cardstate);
    

  152.     }
    


  153. 

  154.     return(Status);
    

  155. }


回复

收藏1 举报

renzheshengui 发表于 2020-4-7 14:13 | 显示全部楼层
非常感谢楼主分享
回复

收藏1 举报

wakayi 发表于 2020-4-7 14:13 | 显示全部楼层
非常感谢楼主分享
回复

收藏1 举报

wowu 发表于 2020-4-7 14:14 | 显示全部楼层
非常感谢楼主分享
回复

收藏1 举报

xiaoqizi 发表于 2020-4-7 14:14 | 显示全部楼层
非常感谢楼主分享
回复

收藏1 举报

磨砂 发表于 2020-4-7 14:14 | 显示全部楼层
非常感谢楼主分享
回复

收藏1 举报

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

本版积分规则

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