其他鏈接
【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（一）-初步認識SD卡
【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（二）-了解SD總線，命令的相關介紹
【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（三）-SD卡的操作流程
【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（四）-介紹庫函數，獲取一些SD卡的信息
【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（五）-FatFs的介紹（暫定，待研究FatFs后，寫博客）
【STM32】使用SDIO進行SD卡讀寫，包含文件管理FatFs（六）-實現SD卡的讀取（暫定，完成第五篇博客后，填寫第六篇）
分享官方的庫函數文檔：https://pan.baidu.com/s/1IbthnVlBHS8IUr8zWs3XGA
庫函數的位置如下，以及一些庫函數的介紹
寫程序前，先來厘清思路，免得等等混亂了。我想對SD卡做相關操作，那么，具體的流程如下：
【1】STM32上電后
↓
【2】對幾個SDIO相關的引腳初始化（查芯片手冊，哪幾個引腳對應SDIO，還有時鍾也要設置）
↓
【3】設置中斷（SDIO中斷，還有優先級之類的）
↓
【4】復位SDIO外設寄存器（將SDIO外設寄存器，初始化為它們的默認復位值）
↓
【5】調用庫函數，SDIO初始化（庫函數名：SDIO_Init，一些初始化的東西，例如頻率，卡識別時要先設400K，后續數據傳輸時可以調高些，另外還有設置幾根數據線之類的）
↓
【6】調用庫函數，設置SDIO上電（庫函數名：SDIO_SetPowerState，要使用SD卡，就要把電源打開）
↓
【7】調用庫函數，使能SDIO時鍾（庫函數名：SDIO_ClockCmd，和SD卡交互數據需要時鍾）
↓
【8】調用發送命令的庫函數，開始發送命令(CMD)（我第三章博客講的【SD卡操作流程】，卡識別（卡識別模式）的時候，先發CMD0這個命令(命令的介紹在第二章博客)，然后等待響應之類的）
開始一系列識別SD卡的操作（我第一章博客說明了SD卡的種類，通過命令，獲得響應和沒獲得響應，都有對應的情況，請參考我第三章博客）
所以第8步驟的命令發送順序是：CMD0 -> CMD8 -> CMD55 -> CMD41 -> CMD2 -> CMD3（由於CMD41是特定應用命令，在CMD41之前，必須發送CMD55）
↓
【9】第8步驟最后發送了CMD3，進入數據傳輸模式，首先來獲取SD的容量，卡的塊大小之類的信息（發送CMD9命令）
↓
【10】前9個步驟算是初始化流程，然后就可以做你想要的操作了，例如讀取SD卡，或是寫入數據，擦除SD卡等等
以上就是大致的流程
我分了好幾篇博客，沒辦法，SD卡的操作相當繁瑣，如果一篇博客要講完所有東西，看的人一定頭暈死了，分類一下比較清楚
有了思路，就可以開始寫代碼了，直接從第二步開始
【2】對幾個SDIO相關的引腳初始化
先來看一張引腳圖
和SDIO有關的引腳就這些
但是，SD卡只支持4位數據傳輸，所以只占SDIO_D0 ~ SDIO_D3，再加上SDIO_CK、SDIO_CMD，就是圖上綠色框框內的這些
SDIO_D4、SDIO_D5、SDIO_D6、SDIO_D7，MMC卡應該會用的到（我第一章博客有介紹到），此刻無需理會
接下來對PC8、PC9、PC10、PC11、PC12，還有PD2做一些配置和使能時鍾的動作，我們可以寫一個函數方便調用
void mySD_init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
/* GPIOC and GPIOD Periph clock enable */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD , ENABLE); // 使能兩個時鍾，因為SDIO在兩個端口上，上面圖片有說明了，一個在PC，另一個在PD
GPIO_PinAFConfig(GPIOC, GPIO_PinSource8, GPIO_AF_SDIO); // PC8使用SDIO功能
GPIO_PinAFConfig(GPIOC, GPIO_PinSource9, GPIO_AF_SDIO); // PC9使用SDIO功能
GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_SDIO); // PC10使用SDIO功能
GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_SDIO); // PC11使用SDIO功能
GPIO_PinAFConfig(GPIOC, GPIO_PinSource12, GPIO_AF_SDIO); // PC12使用SDIO功能
GPIO_PinAFConfig(GPIOD, GPIO_PinSource2, GPIO_AF_SDIO); // PD2使用SDIO功能
/* Configure PC.08, PC.09, PC.10, PC.11 pins: D0, D1, D2, D3 pins */ // 配置PC8、PC9、PC10、PC11引腳
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 | GPIO_Pin_11;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(GPIOC, &GPIO_InitStructure);
/* Configure PD.02 CMD line */ // 配置PD2引腳
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_Init(GPIOD, &GPIO_InitStructure);
/* Configure PC.12 pin: CLK pin */ // 配置PC12引腳
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOC, &GPIO_InitStructure);
/*!< Configure SD_SPI_DETECT_PIN pin: SD Card detect pin */ // 如果你想用SPI來操作SD卡？
// GPIO_InitStructure.GPIO_Pin = SD_DETECT_PIN;
// GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
// GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
// GPIO_Init(SD_DETECT_GPIO_PORT, &GPIO_InitStructure);
/* Enable the SDIO APB2 Clock */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SDIO, ENABLE); // 使能SDIO時鍾，SDIO是掛在APB2總線上的
/* Enable the DMA2 Clock */
RCC_AHB1PeriphClockCmd(SD_SDIO_DMA_CLK, ENABLE); // 如果要使用DMA的話，使能DMA時鍾
}
按順序來，接下來是【3】設置中斷
static void myNVIC_Configuration(void)
{
NVIC_InitTypeDef NVIC_InitStructure;
/* Configure the NVIC Preemption Priority Bits */ // 嵌套向量中斷控制器組選擇
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
NVIC_InitStructure.NVIC_IRQChannel = SDIO_IRQn; // 配置SDIO中斷
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; // 搶斷優先級為0
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // 子優先級為0
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; // 使能中斷
NVIC_Init(&NVIC_InitStructure); // 初始化配置NVIC
NVIC_InitStructure.NVIC_IRQChannel = SD_SDIO_DMA_IRQn; // 使能SDIO DMA中斷
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; // 搶斷優先級為1
NVIC_Init(&NVIC_InitStructure); // 初始化配置NVIC
}
按順序來，接下來是【4】復位SDIO外設寄存器
void mySDIO_DeInit(void)
{
RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO, ENABLE);
RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO, DISABLE);
}
按順序來，接下來是【5】調用庫函數，SDIO初始化，由於剛開始是卡識別模式，所以時鍾最高設置400KHz，后續數據傳輸模式時，可以再調高
void mySDIO_init(void)
{
__IO SD_Error errorstatus = SD_OK;
uint32_t response = 0, count = 0, validvoltage = 0;
uint32_t SDType = SD_STD_CAPACITY;
/*!< Power ON Sequence -----------------------------------------------------*/
/*!< Configure the SDIO peripheral */
/*!< SDIO_CK = SDIOCLK / (SDIO_INIT_CLK_DIV + 2) */
/*!< on STM32F4xx devices, SDIOCLK is fixed to 48MHz */
/*!< SDIO_CK for initialization should not exceed 400 KHz */
SDIO_InitStructure.SDIO_ClockDiv = SDIO_INIT_CLK_DIV;
SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;
SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;
SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;
SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b;
SDIO_InitStructure.SDIO_HardwareFlowControl =
SDIO_HardwareFlowControl_Disable;
SDIO_Init(&SDIO_InitStructure);
}
按順序來，接下來是【6】調用庫函數，設置SDIO上電
void mySDIO_PowerOn(void)
{
/*!< Set Power State to ON */
SDIO_SetPowerState(SDIO_PowerState_ON);
}
按順序來，接下來是【7】調用庫函數，使能SDIO時鍾
void mySDIO_EnableClock(void)
{
/*!< Enable SDIO Clock */
SDIO_ClockCmd(ENABLE);
}
按順序來，接下來是【8】調用發送命令的庫函數，開始發送命令(CMD)
按照一開始的思路，我們要發送CMD0 -> CMD8 -> CMD55 -> CMD41 -> CMD2 -> CMD3
上代碼前，先解釋一下SDIO_SendCommand這個庫函數，這是發命令（CMD）用的
后續進行卡識別時，要發送CMD0、CMD8、CMD41等等（CMD41是特定應用命令，在它之前必須先發CMD55）
在卡識別結束后，對SD讀、寫、擦除等相關的操作，一律都是用這個庫函數來操作的
我們先來發送CMD0、CMD8、CMD55、CMD41這幾個命令，先判別此卡是什么類型
SD_Error mySD_Identify(void)
{
__IO SD_Error errorstatus = SD_OK;
uint32_t response = 0, count = 0, validvoltage = 0;
uint32_t SDType = SD_STD_CAPACITY;
/*!< CMD0: GO_IDLE_STATE ---------------------------------------------------*/ // 准備發送CMD0，開始一系列的卡識別
/*!< No CMD response required */
SDIO_CmdInitStructure.SDIO_Argument = 0x0;
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_GO_IDLE_STATE; // 設置命令為CMD0
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_No;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure); // 發送命令
errorstatus = CmdError(); // CmdError等待發送完成函數，下面另一個代碼塊有函數的內容
if (errorstatus != SD_OK)
{
/*!< CMD Response TimeOut (wait for CMDSENT flag) */ // 響應超時
return(errorstatus);
}
/*!< CMD8: SEND_IF_COND ----------------------------------------------------*/ // 准備發送CMD8
/*!< Send CMD8 to verify SD card interface operating condition */
/*!< Argument: - [31:12]: Reserved (shall be set to '0')
- [11:8]: Supply Voltage (VHS) 0x1 (Range: 2.7-3.6 V)
- [7:0]: Check Pattern (recommended 0xAA) */
/*!< CMD Response: R7 */
SDIO_CmdInitStructure.SDIO_Argument = SD_CHECK_PATTERN;
SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_IF_COND; // 設置命令為MD8
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure); // 發送命令
errorstatus = CmdResp7Error(); // 等待R7響應，我第二章博客有說明，另外下方另一個代碼塊有這個函數的內容
if (errorstatus == SD_OK)
{
CardType = SDIO_STD_CAPACITY_SD_CARD_V2_0; /*!< SD Card 2.0 */ // ************ 此SD卡是2.0協議的卡 ************
SDType = SD_HIGH_CAPACITY;
}
else
{
/*!< CMD55 */
SDIO_CmdInitStructure.SDIO_Argument = 0x00;
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD; // 設置命令為CMD55
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus = CmdResp1Error(SD_CMD_APP_CMD); // R1響應
}
/*!< CMD55 */
SDIO_CmdInitStructure.SDIO_Argument = 0x00;
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD; // 設置命令為CMD55
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus = CmdResp1Error(SD_CMD_APP_CMD); // R1響應
/*!< If errorstatus is Command TimeOut, it is a MMC card */
/*!< If errorstatus is SD_OK it is a SD card: SD card 2.0 (voltage range mismatch)
or SD card 1.x */
if (errorstatus == SD_OK) // 如果變量是SD_OK，那么此SD卡是1.0協議，否則就是MMC卡
{
/*!< SD CARD */
/*!< Send ACMD41 SD_APP_OP_COND with Argument 0x80100000 */
while ((!validvoltage) && (count < SD_MAX_VOLT_TRIAL))
{
/*!< SEND CMD55 APP_CMD with RCA as 0 */
SDIO_CmdInitStructure.SDIO_Argument = 0x00;
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus = CmdResp1Error(SD_CMD_APP_CMD); // R1響應
if (errorstatus != SD_OK)
{
return(errorstatus);
}
SDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_SD | SDType;
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_OP_COND; // 設置命令為CMD41
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus = CmdResp3Error(); // R3響應
if (errorstatus != SD_OK)
{
return(errorstatus);
}
response = SDIO_GetResponse(SDIO_RESP1);
validvoltage = (((response >> 31) == 1) ? 1 : 0);
count++;
}
if (count >= SD_MAX_VOLT_TRIAL)
{
errorstatus = SD_INVALID_VOLTRANGE;
return(errorstatus);
}
if (response &= SD_HIGH_CAPACITY)
{
CardType = SDIO_HIGH_CAPACITY_SD_CARD; // ************ 此SD卡是1.0協議的卡 ************
}
}/*!< else MMC Card */
return(errorstatus);
}
以下是等待函數和響應函數，對照上方的代碼塊，例如卡識別的時候，發送CMD0，會等待發送完成（執行CmdError等待函數），發送CMD8時，會需要一個響應（執行CmdResp7Error函數，等待R7響應）等等
/**
* @brief Checks for error conditions for CMD0.
* @param None
* @retval SD_Error: SD Card Error code.
*/
static SD_Error CmdError(void) // ------------ 等待發送命令，此函數沒有任何響應 ------------
{
SD_Error errorstatus = SD_OK;
uint32_t timeout;
timeout = SDIO_CMD0TIMEOUT; /*!< 10000 */
while ((timeout > 0) && (SDIO_GetFlagStatus(SDIO_FLAG_CMDSENT) == RESET))
{
timeout--;
}
if (timeout == 0)
{
errorstatus = SD_CMD_RSP_TIMEOUT;
return(errorstatus);
}
/*!< Clear all the static flags */
SDIO_ClearFlag(SDIO_STATIC_FLAGS);
return(errorstatus);
}
/**
* @brief Checks for error conditions for R1 response.
* @param cmd: The sent command index.
* @retval SD_Error: SD Card Error code.
*/
static SD_Error CmdResp1Error(uint8_t cmd) // ------------ R1響應 ------------
{
SD_Error errorstatus = SD_OK;
uint32_t status;
uint32_t response_r1;
status = SDIO->STA;
while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)))
{
status = SDIO->STA;
}
if (status & SDIO_FLAG_CTIMEOUT)
{
errorstatus = SD_CMD_RSP_TIMEOUT;
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
return(errorstatus);
}
else if (status & SDIO_FLAG_CCRCFAIL)
{
errorstatus = SD_CMD_CRC_FAIL;
SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);
return(errorstatus);
}
/*!< Check response received is of desired command */
if (SDIO_GetCommandResponse() != cmd)
{
errorstatus = SD_ILLEGAL_CMD;
return(errorstatus);
}
/*!< Clear all the static flags */
SDIO_ClearFlag(SDIO_STATIC_FLAGS);
/*!< We have received response, retrieve it for analysis */
response_r1 = SDIO_GetResponse(SDIO_RESP1);
if ((response_r1 & SD_OCR_ERRORBITS) == SD_ALLZERO)
{
return(errorstatus);
}
if (response_r1 & SD_OCR_ADDR_OUT_OF_RANGE)
{
return(SD_ADDR_OUT_OF_RANGE);
}
if (response_r1 & SD_OCR_ADDR_MISALIGNED)
{
return(SD_ADDR_MISALIGNED);
}
if (response_r1 & SD_OCR_BLOCK_LEN_ERR)
{
return(SD_BLOCK_LEN_ERR);
}
if (response_r1 & SD_OCR_ERASE_SEQ_ERR)
{
return(SD_ERASE_SEQ_ERR);
}
if (response_r1 & SD_OCR_BAD_ERASE_PARAM)
{
return(SD_BAD_ERASE_PARAM);
}
if (response_r1 & SD_OCR_WRITE_PROT_VIOLATION)
{
return(SD_WRITE_PROT_VIOLATION);
}
if (response_r1 & SD_OCR_LOCK_UNLOCK_FAILED)
{
return(SD_LOCK_UNLOCK_FAILED);
}
if (response_r1 & SD_OCR_COM_CRC_FAILED)
{
return(SD_COM_CRC_FAILED);
}
if (response_r1 & SD_OCR_ILLEGAL_CMD)
{
return(SD_ILLEGAL_CMD);
}
if (response_r1 & SD_OCR_CARD_ECC_FAILED)
{
return(SD_CARD_ECC_FAILED);
}
if (response_r1 & SD_OCR_CC_ERROR)
{
return(SD_CC_ERROR);
}
if (response_r1 & SD_OCR_GENERAL_UNKNOWN_ERROR)
{
return(SD_GENERAL_UNKNOWN_ERROR);
}
if (response_r1 & SD_OCR_STREAM_READ_UNDERRUN)
{
return(SD_STREAM_READ_UNDERRUN);
}
if (response_r1 & SD_OCR_STREAM_WRITE_OVERRUN)
{
return(SD_STREAM_WRITE_OVERRUN);
}
if (response_r1 & SD_OCR_CID_CSD_OVERWRIETE)
{
return(SD_CID_CSD_OVERWRITE);
}
if (response_r1 & SD_OCR_WP_ERASE_SKIP)
{
return(SD_WP_ERASE_SKIP);
}
if (response_r1 & SD_OCR_CARD_ECC_DISABLED)
{
return(SD_CARD_ECC_DISABLED);
}
if (response_r1 & SD_OCR_ERASE_RESET)
{
return(SD_ERASE_RESET);
}
if (response_r1 & SD_OCR_AKE_SEQ_ERROR)
{
return(SD_AKE_SEQ_ERROR);
}
return(errorstatus);
}
/**
* @brief Checks for error conditions for R2 (CID or CSD) response.
* @param None
* @retval SD_Error: SD Card Error code.
*/
static SD_Error CmdResp2Error(void) // ------------ R2響應 ------------
{
SD_Error errorstatus = SD_OK;
uint32_t status;
status = SDIO->STA;
while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CTIMEOUT | SDIO_FLAG_CMDREND)))
{
status = SDIO->STA;
}
if (status & SDIO_FLAG_CTIMEOUT)
{
errorstatus = SD_CMD_RSP_TIMEOUT;
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
return(errorstatus);
}
else if (status & SDIO_FLAG_CCRCFAIL)
{
errorstatus = SD_CMD_CRC_FAIL;
SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);
return(errorstatus);
}
/*!< Clear all the static flags */
SDIO_ClearFlag(SDIO_STATIC_FLAGS);
return(errorstatus);
}
/**
* @brief Checks for error conditions for R3 (OCR) response.
* @param None
* @retval SD_Error: SD Card Error code.
*/
static SD_Error CmdResp3Error(void) // ------------ R3響應 ------------
{
SD_Error errorstatus = SD_OK;
uint32_t status;
status = SDIO->STA;
while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)))
{
status = SDIO->STA;
}
if (status & SDIO_FLAG_CTIMEOUT)
{
errorstatus = SD_CMD_RSP_TIMEOUT;
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
return(errorstatus);
}
/*!< Clear all the static flags */
SDIO_ClearFlag(SDIO_STATIC_FLAGS);
return(errorstatus);
}
/**
* @brief Checks for error conditions for R6 (RCA) response.
* @param cmd: The sent command index.
* @param prca: pointer to the variable that will contain the SD card relative
* address RCA.
* @retval SD_Error: SD Card Error code.
*/
static SD_Error CmdResp6Error(uint8_t cmd, uint16_t *prca) // ------------ R6響應 ------------
{
SD_Error errorstatus = SD_OK;
uint32_t status;
uint32_t response_r1;
status = SDIO->STA;
while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CTIMEOUT | SDIO_FLAG_CMDREND)))
{
status = SDIO->STA;
}
if (status & SDIO_FLAG_CTIMEOUT)
{
errorstatus = SD_CMD_RSP_TIMEOUT;
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
return(errorstatus);
}
else if (status & SDIO_FLAG_CCRCFAIL)
{
errorstatus = SD_CMD_CRC_FAIL;
SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);
return(errorstatus);
}
/*!< Check response received is of desired command */
if (SDIO_GetCommandResponse() != cmd)
{
errorstatus = SD_ILLEGAL_CMD;
return(errorstatus);
}
/*!< Clear all the static flags */
SDIO_ClearFlag(SDIO_STATIC_FLAGS);
/*!< We have received response, retrieve it. */
response_r1 = SDIO_GetResponse(SDIO_RESP1);
if (SD_ALLZERO == (response_r1 & (SD_R6_GENERAL_UNKNOWN_ERROR | SD_R6_ILLEGAL_CMD | SD_R6_COM_CRC_FAILED)))
{
*prca = (uint16_t) (response_r1 >> 16);
return(errorstatus);
}
if (response_r1 & SD_R6_GENERAL_UNKNOWN_ERROR)
{
return(SD_GENERAL_UNKNOWN_ERROR);
}
if (response_r1 & SD_R6_ILLEGAL_CMD)
{
return(SD_ILLEGAL_CMD);
}
if (response_r1 & SD_R6_COM_CRC_FAILED)
{
return(SD_COM_CRC_FAILED);
}
return(errorstatus);
}
/**
* @brief Checks for error conditions for R7 response.
* @param None
* @retval SD_Error: SD Card Error code.
*/
static SD_Error CmdResp7Error(void) // ------------ R7響應 ------------
{
SD_Error errorstatus = SD_OK;
uint32_t status;
uint32_t timeout = SDIO_CMD0TIMEOUT;
status = SDIO->STA;
while (!(status & (SDIO_FLAG_CCRCFAIL | SDIO_FLAG_CMDREND | SDIO_FLAG_CTIMEOUT)) && (timeout > 0))
{
timeout--;
status = SDIO->STA;
}
if ((timeout == 0) || (status & SDIO_FLAG_CTIMEOUT))
{
/*!< Card is not V2.0 complient or card does not support the set voltage range */
errorstatus = SD_CMD_RSP_TIMEOUT;
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);
return(errorstatus);
}
if (status & SDIO_FLAG_CMDREND)
{
/*!< Card is SD V2.0 compliant */
errorstatus = SD_OK;
SDIO_ClearFlag(SDIO_FLAG_CMDREND);
return(errorstatus);
}
return(errorstatus);
}
最終，由CardType得知，此卡是哪一種類型的卡（SD卡1.0協議、SD卡2.0協議、MMC卡等等）
但是還沒完成，按照卡識別流程圖，最后還需要發送CMD2（要求卡返回它的CID）和CMD3（要求卡返回它的RCA地址），一切都完成，就可以進入數據傳輸模式
【題外話】其實我一直在想，CMD2、CMD3要不要和第9步驟的CMD9合並，后來想想還是算了，CMD9已經是數據傳輸模式，不要和流程圖搞混了
所以我用兩個函數【mySD_InitializeCards1】（CMD2、CMD3）、【mySD_InitializeCards2】（CMD9）來區分
SD_Error SD_InitializeCards1(void)
{
SD_Error errorstatus = SD_OK;
uint16_t rca = 0x01;
if (SDIO_GetPowerState() == SDIO_PowerState_OFF)
{
errorstatus = SD_REQUEST_NOT_APPLICABLE;
return(errorstatus);
}
if (SDIO_SECURE_DIGITAL_IO_CARD != CardType)
{
/*!< Send CMD2 ALL_SEND_CID */
SDIO_CmdInitStructure.SDIO_Argument = 0x0;
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_ALL_SEND_CID; // 設置命令為CMD2
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Long;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus = CmdResp2Error();
if (SD_OK != errorstatus)
{
return(errorstatus);
}
CID_Tab[0] = SDIO_GetResponse(SDIO_RESP1);
CID_Tab[1] = SDIO_GetResponse(SDIO_RESP2);
CID_Tab[2] = SDIO_GetResponse(SDIO_RESP3);
CID_Tab[3] = SDIO_GetResponse(SDIO_RESP4);
}
if ((SDIO_STD_CAPACITY_SD_CARD_V1_1 == CardType) || (SDIO_STD_CAPACITY_SD_CARD_V2_0 == CardType) || (SDIO_SECURE_DIGITAL_IO_COMBO_CARD == CardType)
|| (SDIO_HIGH_CAPACITY_SD_CARD == CardType))
{
/*!< Send CMD3 SET_REL_ADDR with argument 0 */
/*!< SD Card publishes its RCA. */
SDIO_CmdInitStructure.SDIO_Argument = 0x00;
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_REL_ADDR; // 設置命令為CMD3
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus = CmdResp6Error(SD_CMD_SET_REL_ADDR, &rca);
if (SD_OK != errorstatus)
{
return(errorstatus);
}
}
return(errorstatus);
｝
按照順序，接下來是【9】第8步驟最后發送了CMD3，進入數據傳輸模式，首先來獲取SD的容量，卡的塊大小之類的信息（發送CMD9命令）
SD_Error SD_InitializeCards2(void)
{
if (SDIO_SECURE_DIGITAL_IO_CARD != CardType)
{
RCA = rca;
/*!< Send CMD9 SEND_CSD with argument as card's RCA */
SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)(rca << 16);
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_CSD;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Long;
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus = CmdResp2Error();
if (SD_OK != errorstatus)
{
return(errorstatus);
}
CSD_Tab[0] = SDIO_GetResponse(SDIO_RESP1);
CSD_Tab[1] = SDIO_GetResponse(SDIO_RESP2);
CSD_Tab[2] = SDIO_GetResponse(SDIO_RESP3);
CSD_Tab[3] = SDIO_GetResponse(SDIO_RESP4);
}
errorstatus = SD_OK; /*!< All cards get intialized */
return(errorstatus);
}
一切都完成后，可以再次設置時鍾，已經不再是卡識別模式了，可以把速度調快些
並且做一些處理，后續想要知道一些信息，訪問SDCardInfo這個結構體就可以了
最終，選中SD卡，后續才可以做一些讀、寫、擦除操作
/*!< Configure the SDIO peripheral */
/*!< SDIO_CK = SDIOCLK / (SDIO_TRANSFER_CLK_DIV + 2) */
/*!< on STM32F4xx devices, SDIOCLK is fixed to 48MHz */
SDIO_InitStructure.SDIO_ClockDiv = SDIO_TRANSFER_CLK_DIV;
SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;
SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;
SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable;
SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b;
SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;
SDIO_Init(&SDIO_InitStructure);
/*----------------- Read CSD/CID MSD registers ------------------*/
errorstatus = SD_GetCardInfo(&SDCardInfo);
if (errorstatus == SD_OK)
{
/*----------------- Select Card --------------------------------*/
errorstatus = SD_SelectDeselect((uint32_t) (SDCardInfo.RCA << 16));
}
if (errorstatus == SD_OK)
{
errorstatus = SD_EnableWideBusOperation(SDIO_BusWide_4b);
}
最后是步驟【10】，要嘗試讀取SD卡，不過，這篇博客我想在這里結束了
因為我必須要另外研究一個新的東西，叫FATFS，這是一個文件管理系統
想象一下，你的硬盤里面可能會有分C盤、D盤、E盤。。。
每個盤下面可能會用文件夾區分檔案
例如
D:\音樂\中文歌...
D:\音樂\英文歌...
SD卡里面也有這種文件管理，等一切都研究完成，再來處理SD卡讀取的事情