STM32F407VET6采集AD數(shù)據(jù),保存到SD卡中源程序

ID:241682 · 發(fā)表于 2021-11-28 06:24

//單片機(jī)采用STM32F407VET6 ad采集數(shù)據(jù)，并將數(shù)據(jù)保存到sd中
#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "led.h"
#include "key.h"
#include "adc.h"
#include "sdio_sdcard.h"
#include "ff.h"
#include "exfuns.h"
#include "string.h"
int main(void)
{
float temp;
u8 i,res;
u8 ADc_Buff[200]=0;
u8 ADc_temp[20]=0;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//設(shè)置系統(tǒng)中斷優(yōu)先級(jí)分組2
delay_init(168); //延時(shí)初始化
uart_init(115200); //串口初始化波特率為115200
LED_Init(); //初始化與LED連接的硬件接口
Adc_Init(); //初始化ADC
SD_Init();
exfuns_init(); //為fatfs相關(guān)變量申請(qǐng)內(nèi)存
f_mount(fs[0],"0:",1); //掛載SD卡
res=mf_open("0:/123/ADcData.txt",FA_OPEN_ALWAYS | FA_READ | FA_WRITE );//創(chuàng)建或打開一個(gè)文本文檔保存數(shù)據(jù)
res=mf_open("0:/ADcData.txt",FA_OPEN_ALWAYS | FA_READ | FA_WRITE );//創(chuàng)建或打開一個(gè)文本文檔保存數(shù)據(jù)
if(res==FR_OK)
{
printf("文件已經(jīng)存在!\r\n");
}
else
{
printf("建立該文件!\r\n");
}
while(1)
{
for(i=0;i<8;i++)
{
temp=(float)(Get_Adc_Average(i,20))*(3.3/4096); //獲取計(jì)算后的帶小數(shù)的實(shí)際電壓值，比如3.1111
printf("通道%d=%f\r\n",i,temp);
sprintf(ADc_temp,"%f|",temp);
strcat(ADc_Buff,ADc_temp);
}
strcat(ADc_Buff,"\r\n");
mf_lseek(mf_size()); //將指針定位于文件尾部，準(zhǔn)備追加數(shù)據(jù)
mf_write(ADc_Buff,strlen(ADc_Buff)); //將接收到的數(shù)據(jù)存入文件
mf_sync();
delay_ms(2000);
memset(ADc_temp,0,20);
memset(ADc_Buff,0,200);
mf_close( );
}
}
#include "sdio_sdcard.h"
#include "string.h"
/*用于sdio初始化的結(jié)構(gòu)體*/
SDIO_InitTypeDef SDIO_InitStructure;
SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
SDIO_DataInitTypeDef SDIO_DataInitStructure;
SD_Error CmdError(void);
SD_Error CmdResp7Error(void);
SD_Error CmdResp1Error(u8 cmd);
SD_Error CmdResp3Error(void);
SD_Error CmdResp2Error(void);
SD_Error CmdResp6Error(u8 cmd,u16*prca);
SD_Error SDEnWideBus(u8 enx);
SD_Error IsCardProgramming(u8 *pstatus);
SD_Error FindSCR(u16 rca,u32 *pscr);
u8 convert_from_bytes_to_power_of_two(u16 NumberOfBytes);
static u8 CardType=SDIO_STD_CAPACITY_SD_CARD_V1_1; //SD卡類型（默認(rèn)為1.x卡）
static u32 CSD_Tab[4],CID_Tab[4],RCA=0; //SD卡CSD,CID以及相對(duì)地址(RCA)數(shù)據(jù)
static u8 DeviceMode=SD_DMA_MODE; //工作模式,注意,工作模式必須通過SD_SetDeviceMode,后才算數(shù).這里只是定義一個(gè)默認(rèn)的模式(SD_DMA_MODE)
static u8 StopCondition=0; //是否發(fā)送停止傳輸標(biāo)志位,DMA多塊讀寫的時(shí)候用到
volatile SD_Error TransferError=SD_OK; //數(shù)據(jù)傳輸錯(cuò)誤標(biāo)志,DMA讀寫時(shí)使用
volatile u8 TransferEnd=0; //傳輸結(jié)束標(biāo)志,DMA讀寫時(shí)使用
SD_CardInfo SDCardInfo; //SD卡信息
//THUMB指令不支持匯編內(nèi)聯(lián)
//采用如下方法實(shí)現(xiàn)執(zhí)行匯編指令WFI
__asm void WFI_SET(void)
{
WFI;
}
//關(guān)閉所有中斷(但是不包括fault和NMI中斷)
__asm void INTX_DISABLE(void)
{
CPSID I
BX LR
}
//開啟所有中斷
__asm void INTX_ENABLE(void)
{
CPSIE I
BX LR
}
//設(shè)置棧頂?shù)刂?br />
//addr:棧頂?shù)刂?br />
__asm void MSR_MSP(u32 addr)
{
MSR MSP, r0 //set Main Stack value
BX r14
}
//SD_ReadDisk/SD_WriteDisk函數(shù)專用buf,當(dāng)這兩個(gè)函數(shù)的數(shù)據(jù)緩存區(qū)地址不是4字節(jié)對(duì)齊的時(shí)候,
//需要用到該數(shù)組,確保數(shù)據(jù)緩存區(qū)地址是4字節(jié)對(duì)齊的.
__align(4) u8 SDIO_DATA_BUFFER[512];
void SDIO_Register_Deinit()
{
SDIO->POWER=0x00000000;
SDIO->CLKCR=0x00000000;
SDIO->ARG=0x00000000;
SDIO->CMD=0x00000000;
SDIO->DTIMER=0x00000000;
SDIO->DLEN=0x00000000;
SDIO->DCTRL=0x00000000;
SDIO->ICR=0x00C007FF;
SDIO->MASK=0x00000000;
}
//初始化SD卡
//返回值:錯(cuò)誤代碼;(0,無錯(cuò)誤)
SD_Error SD_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
SD_Error errorstatus=SD_OK;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOD|RCC_AHB1Periph_DMA2, ENABLE);//使能GPIOC,GPIOD DMA2時(shí)鐘
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SDIO, ENABLE);//SDIO時(shí)鐘使能
RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO, ENABLE);//SDIO復(fù)位
GPIO_InitStructure.GPIO_Pin =GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12; //PC8,9,10,11,12復(fù)用功能輸出
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//復(fù)用功能
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//100M
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
GPIO_Init(GPIOC, &GPIO_InitStructure);// PC8,9,10,11,12復(fù)用功能輸出
GPIO_InitStructure.GPIO_Pin =GPIO_Pin_2;
GPIO_Init(GPIOD, &GPIO_InitStructure);//PD2復(fù)用功能輸出
//引腳復(fù)用映射設(shè)置
GPIO_PinAFConfig(GPIOC,GPIO_PinSource8,GPIO_AF_SDIO); //PC8,AF12
GPIO_PinAFConfig(GPIOC,GPIO_PinSource9,GPIO_AF_SDIO);
GPIO_PinAFConfig(GPIOC,GPIO_PinSource10,GPIO_AF_SDIO);
GPIO_PinAFConfig(GPIOC,GPIO_PinSource11,GPIO_AF_SDIO);
GPIO_PinAFConfig(GPIOC,GPIO_PinSource12,GPIO_AF_SDIO);
GPIO_PinAFConfig(GPIOD,GPIO_PinSource2,GPIO_AF_SDIO);
RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO, DISABLE);//SDIO結(jié)束復(fù)位
//SDIO外設(shè)寄存器設(shè)置為默認(rèn)值
SDIO_Register_Deinit();
NVIC_InitStructure.NVIC_IRQChannel = SDIO_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;//搶占優(yōu)先級(jí)3
NVIC_InitStructure.NVIC_IRQChannelSubPriority =0; //子優(yōu)先級(jí)3
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //IRQ通道使能
NVIC_Init(&NVIC_InitStructure); //根據(jù)指定的參數(shù)初始化VIC寄存器、
errorstatus=SD_PowerON(); //SD卡上電
if(errorstatus==SD_OK)errorstatus=SD_InitializeCards(); //初始化SD卡
if(errorstatus==SD_OK)errorstatus=SD_GetCardInfo(&SDCardInfo); //獲取卡信息
if(errorstatus==SD_OK)errorstatus=SD_SelectDeselect((u32)(SDCardInfo.RCA<<16));//選中SD卡
if(errorstatus==SD_OK)errorstatus=SD_EnableWideBusOperation(SDIO_BusWide_4b); //4位寬度,如果是MMC卡,則不能用4位模式
if((errorstatus==SD_OK)||(SDIO_MULTIMEDIA_CARD==CardType))
{
SDIO_Clock_Set(SDIO_TRANSFER_CLK_DIV); //設(shè)置時(shí)鐘頻率,SDIO時(shí)鐘計(jì)算公式:SDIO_CK時(shí)鐘=SDIOCLK/[clkdiv+2];其中,SDIOCLK固定為48Mhz
//errorstatus=SD_SetDeviceMode(SD_DMA_MODE); //設(shè)置為DMA模式
errorstatus=SD_SetDeviceMode(SD_POLLING_MODE);//設(shè)置為查詢模式
}
return errorstatus;
}
//SDIO時(shí)鐘初始化設(shè)置
//clkdiv:時(shí)鐘分頻系數(shù)
//CK時(shí)鐘=SDIOCLK/[clkdiv+2];(SDIOCLK時(shí)鐘固定為48Mhz)
void SDIO_Clock_Set(u8 clkdiv)
{
u32 tmpreg=SDIO->CLKCR;
tmpreg&=0XFFFFFF00;
tmpreg|=clkdiv;
SDIO->CLKCR=tmpreg;
}
//卡上電
//查詢所有SDIO接口上的卡設(shè)備,并查詢其電壓和配置時(shí)鐘
//返回值:錯(cuò)誤代碼;(0,無錯(cuò)誤)
SD_Error SD_PowerON(void)
{
u8 i=0;
SD_Error errorstatus=SD_OK;
u32 response=0,count=0,validvoltage=0;
u32 SDType=SD_STD_CAPACITY;
/*初始化時(shí)的時(shí)鐘不能大于400KHz*/
SDIO_InitStructure.SDIO_ClockDiv = SDIO_INIT_CLK_DIV; /* HCLK = 72MHz, SDIOCLK = 72MHz, SDIO_CK = HCLK/(178 + 2) = 400 KHz */
SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;
SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable; //不使用bypass模式，直接用HCLK進(jìn)行分頻得到SDIO_CK
SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable; // 空閑時(shí)不關(guān)閉時(shí)鐘電源
SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b; //1位數(shù)據(jù)線
SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;//硬件流
SDIO_Init(&SDIO_InitStructure);
SDIO_SetPowerState(SDIO_PowerState_ON); //上電狀態(tài),開啟卡時(shí)鐘
SDIO->CLKCR|=1<<8; //SDIOCK使能
for(i=0;i<74;i++)
{
SDIO_CmdInitStructure.SDIO_Argument = 0x0;//發(fā)送CMD0進(jìn)入IDLE STAGE模式命令.
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_GO_IDLE_STATE; //cmd0
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_No; //無響應(yīng)
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable; //則CPSM在開始發(fā)送命令之前等待數(shù)據(jù)傳輸結(jié)束。
SDIO_SendCommand(&SDIO_CmdInitStructure); //寫命令進(jìn)命令寄存器
errorstatus=CmdError();
if(errorstatus==SD_OK)break;
}
if(errorstatus)return errorstatus;//返回錯(cuò)誤狀態(tài)
SDIO_CmdInitStructure.SDIO_Argument = SD_CHECK_PATTERN; //發(fā)送CMD8,短響應(yīng),檢查SD卡接口特性
SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_IF_COND; //cmd8
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r7
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No; //關(guān)閉等待中斷
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp7Error(); //等待R7響應(yīng)
if(errorstatus==SD_OK) //R7響應(yīng)正常
{
CardType=SDIO_STD_CAPACITY_SD_CARD_V2_0; //SD 2.0卡
SDType=SD_HIGH_CAPACITY; //高容量卡
}
SDIO_CmdInitStructure.SDIO_Argument = 0x00;//發(fā)送CMD55,短響應(yīng)
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); //發(fā)送CMD55,短響應(yīng)
errorstatus=CmdResp1Error(SD_CMD_APP_CMD); //等待R1響應(yīng)
if(errorstatus==SD_OK)//SD2.0/SD 1.1,否則為MMC卡
{
//SD卡,發(fā)送ACMD41 SD_APP_OP_COND,參數(shù)為:0x80100000
while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL))
{
SDIO_CmdInitStructure.SDIO_Argument = 0x00;//發(fā)送CMD55,短響應(yīng)
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); //發(fā)送CMD55,短響應(yīng)
errorstatus=CmdResp1Error(SD_CMD_APP_CMD); //等待R1響應(yīng)
if(errorstatus!=SD_OK)return errorstatus; //響應(yīng)錯(cuò)誤
//acmd41，命令參數(shù)由支持的電壓范圍及HCS位組成，HCS位置一來區(qū)分卡是SDSc還是sdhc
SDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_SD | SDType; //發(fā)送ACMD41,短響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_OP_COND;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r3
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp3Error(); //等待R3響應(yīng)
if(errorstatus!=SD_OK)return errorstatus; //響應(yīng)錯(cuò)誤
response=SDIO->RESP1;; //得到響應(yīng)
validvoltage=(((response>>31)==1)?1:0); //判斷SD卡上電是否完成
count++;
}
if(count>=SD_MAX_VOLT_TRIAL)
{
errorstatus=SD_INVALID_VOLTRANGE;
return errorstatus;
}
if(response&=SD_HIGH_CAPACITY)
{
CardType=SDIO_HIGH_CAPACITY_SD_CARD;
}
}else//MMC卡
{
//MMC卡,發(fā)送CMD1 SDIO_SEND_OP_COND,參數(shù)為:0x80FF8000
while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL))
{
SDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_MMC;//發(fā)送CMD1,短響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_OP_COND;
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r3
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp3Error(); //等待R3響應(yīng)
if(errorstatus!=SD_OK)return errorstatus; //響應(yīng)錯(cuò)誤
response=SDIO->RESP1;; //得到響應(yīng)
validvoltage=(((response>>31)==1)?1:0);
count++;
}
if(count>=SD_MAX_VOLT_TRIAL)
{
errorstatus=SD_INVALID_VOLTRANGE;
return errorstatus;
}
CardType=SDIO_MULTIMEDIA_CARD;
}
return(errorstatus);
}
//SD卡 Power OFF
//返回值:錯(cuò)誤代碼;(0,無錯(cuò)誤)
SD_Error SD_PowerOFF(void)
{
SDIO_SetPowerState(SDIO_PowerState_OFF);//SDIO電源關(guān)閉,時(shí)鐘停止
return SD_OK;
}
//初始化所有的卡,并讓卡進(jìn)入就緒狀態(tài)
//返回值:錯(cuò)誤代碼
SD_Error SD_InitializeCards(void)
{
SD_Error errorstatus=SD_OK;
u16 rca = 0x01;
if (SDIO_GetPowerState() == SDIO_PowerState_OFF) //檢查電源狀態(tài),確保為上電狀態(tài)
{
errorstatus = SD_REQUEST_NOT_APPLICABLE;
return(errorstatus);
}
if(SDIO_SECURE_DIGITAL_IO_CARD!=CardType) //非SECURE_DIGITAL_IO_CARD
{
SDIO_CmdInitStructure.SDIO_Argument = 0x0;//發(fā)送CMD2,取得CID,長(zhǎng)響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_ALL_SEND_CID;
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);//發(fā)送CMD2,取得CID,長(zhǎng)響應(yīng)
errorstatus=CmdResp2Error(); //等待R2響應(yīng)
if(errorstatus!=SD_OK)return errorstatus; //響應(yīng)錯(cuò)誤
CID_Tab[0]=SDIO->RESP1;
CID_Tab[1]=SDIO->RESP2;
CID_Tab[2]=SDIO->RESP3;
CID_Tab[3]=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))//判斷卡類型
{
SDIO_CmdInitStructure.SDIO_Argument = 0x00;//發(fā)送CMD3,短響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_REL_ADDR; //cmd3
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r6
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure); //發(fā)送CMD3,短響應(yīng)
errorstatus=CmdResp6Error(SD_CMD_SET_REL_ADDR,&rca);//等待R6響應(yīng)
if(errorstatus!=SD_OK)return errorstatus; //響應(yīng)錯(cuò)誤
}
if (SDIO_MULTIMEDIA_CARD==CardType)
{
SDIO_CmdInitStructure.SDIO_Argument = (u32)(rca<<16);//發(fā)送CMD3,短響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_REL_ADDR; //cmd3
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r6
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure); //發(fā)送CMD3,短響應(yīng)
errorstatus=CmdResp2Error(); //等待R2響應(yīng)
if(errorstatus!=SD_OK)return errorstatus; //響應(yīng)錯(cuò)誤
}
if (SDIO_SECURE_DIGITAL_IO_CARD!=CardType) //非SECURE_DIGITAL_IO_CARD
{
RCA = rca;
SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)(rca << 16);//發(fā)送CMD9+卡RCA,取得CSD,長(zhǎng)響應(yīng)
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(); //等待R2響應(yīng)
if(errorstatus!=SD_OK)return errorstatus; //響應(yīng)錯(cuò)誤
CSD_Tab[0]=SDIO->RESP1;
CSD_Tab[1]=SDIO->RESP2;
CSD_Tab[2]=SDIO->RESP3;
CSD_Tab[3]=SDIO->RESP4;
}
return SD_OK;//卡初始化成功
}
//得到卡信息
//cardinfo:卡信息存儲(chǔ)區(qū)
//返回值:錯(cuò)誤狀態(tài)
SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo)
{
SD_Error errorstatus=SD_OK;
u8 tmp=0;
cardinfo->CardType=(u8)CardType; //卡類型
cardinfo->RCA=(u16)RCA; //卡RCA值
tmp=(u8)((CSD_Tab[0]&0xFF000000)>>24);
cardinfo->SD_csd.CSDStruct=(tmp&0xC0)>>6; //CSD結(jié)構(gòu)
cardinfo->SD_csd.SysSpecVersion=(tmp&0x3C)>>2; //2.0協(xié)議還沒定義這部分(為保留),應(yīng)該是后續(xù)協(xié)議定義的
cardinfo->SD_csd.Reserved1=tmp&0x03; //2個(gè)保留位
tmp=(u8)((CSD_Tab[0]&0x00FF0000)>>16); //第1個(gè)字節(jié)
cardinfo->SD_csd.TAAC=tmp; //數(shù)據(jù)讀時(shí)間1
tmp=(u8)((CSD_Tab[0]&0x0000FF00)>>8); //第2個(gè)字節(jié)
cardinfo->SD_csd.NSAC=tmp; //數(shù)據(jù)讀時(shí)間2
tmp=(u8)(CSD_Tab[0]&0x000000FF); //第3個(gè)字節(jié)
cardinfo->SD_csd.MaxBusClkFrec=tmp; //傳輸速度
tmp=(u8)((CSD_Tab[1]&0xFF000000)>>24); //第4個(gè)字節(jié)
cardinfo->SD_csd.CardComdClasses=tmp<<4; //卡指令類高四位
tmp=(u8)((CSD_Tab[1]&0x00FF0000)>>16); //第5個(gè)字節(jié)
cardinfo->SD_csd.CardComdClasses|=(tmp&0xF0)>>4;//卡指令類低四位
cardinfo->SD_csd.RdBlockLen=tmp&0x0F; //最大讀取數(shù)據(jù)長(zhǎng)度
tmp=(u8)((CSD_Tab[1]&0x0000FF00)>>8); //第6個(gè)字節(jié)
cardinfo->SD_csd.PartBlockRead=(tmp&0x80)>>7; //允許分塊讀
cardinfo->SD_csd.WrBlockMisalign=(tmp&0x40)>>6; //寫塊錯(cuò)位
cardinfo->SD_csd.RdBlockMisalign=(tmp&0x20)>>5; //讀塊錯(cuò)位
cardinfo->SD_csd.DSRImpl=(tmp&0x10)>>4;
cardinfo->SD_csd.Reserved2=0; //保留
if((CardType==SDIO_STD_CAPACITY_SD_CARD_V1_1)||(CardType==SDIO_STD_CAPACITY_SD_CARD_V2_0)||(SDIO_MULTIMEDIA_CARD==CardType))//標(biāo)準(zhǔn)1.1/2.0卡/MMC卡
{
cardinfo->SD_csd.DeviceSize=(tmp&0x03)<<10; //C_SIZE(12位)
tmp=(u8)(CSD_Tab[1]&0x000000FF); //第7個(gè)字節(jié)
cardinfo->SD_csd.DeviceSize|=(tmp)<<2;
tmp=(u8)((CSD_Tab[2]&0xFF000000)>>24); //第8個(gè)字節(jié)
cardinfo->SD_csd.DeviceSize|=(tmp&0xC0)>>6;
cardinfo->SD_csd.MaxRdCurrentVDDMin=(tmp&0x38)>>3;
cardinfo->SD_csd.MaxRdCurrentVDDMax=(tmp&0x07);
tmp=(u8)((CSD_Tab[2]&0x00FF0000)>>16); //第9個(gè)字節(jié)
cardinfo->SD_csd.MaxWrCurrentVDDMin=(tmp&0xE0)>>5;
cardinfo->SD_csd.MaxWrCurrentVDDMax=(tmp&0x1C)>>2;
cardinfo->SD_csd.DeviceSizeMul=(tmp&0x03)<<1;//C_SIZE_MULT
tmp=(u8)((CSD_Tab[2]&0x0000FF00)>>8); //第10個(gè)字節(jié)
cardinfo->SD_csd.DeviceSizeMul|=(tmp&0x80)>>7;
cardinfo->CardCapacity=(cardinfo->SD_csd.DeviceSize+1);//計(jì)算卡容量
cardinfo->CardCapacity*=(1<<(cardinfo->SD_csd.DeviceSizeMul+2));
cardinfo->CardBlockSize=1<<(cardinfo->SD_csd.RdBlockLen);//塊大小
cardinfo->CardCapacity*=cardinfo->CardBlockSize;
}else if(CardType==SDIO_HIGH_CAPACITY_SD_CARD) //高容量卡
{
tmp=(u8)(CSD_Tab[1]&0x000000FF); //第7個(gè)字節(jié)
cardinfo->SD_csd.DeviceSize=(tmp&0x3F)<<16;//C_SIZE
tmp=(u8)((CSD_Tab[2]&0xFF000000)>>24); //第8個(gè)字節(jié)
cardinfo->SD_csd.DeviceSize|=(tmp<<8);
tmp=(u8)((CSD_Tab[2]&0x00FF0000)>>16); //第9個(gè)字節(jié)
cardinfo->SD_csd.DeviceSize|=(tmp);
tmp=(u8)((CSD_Tab[2]&0x0000FF00)>>8); //第10個(gè)字節(jié)
cardinfo->CardCapacity=(long long)(cardinfo->SD_csd.DeviceSize+1)*512*1024;//計(jì)算卡容量
cardinfo->CardBlockSize=512; //塊大小固定為512字節(jié)
}
cardinfo->SD_csd.EraseGrSize=(tmp&0x40)>>6;
cardinfo->SD_csd.EraseGrMul=(tmp&0x3F)<<1;
tmp=(u8)(CSD_Tab[2]&0x000000FF); //第11個(gè)字節(jié)
cardinfo->SD_csd.EraseGrMul|=(tmp&0x80)>>7;
cardinfo->SD_csd.WrProtectGrSize=(tmp&0x7F);
tmp=(u8)((CSD_Tab[3]&0xFF000000)>>24); //第12個(gè)字節(jié)
cardinfo->SD_csd.WrProtectGrEnable=(tmp&0x80)>>7;
cardinfo->SD_csd.ManDeflECC=(tmp&0x60)>>5;
cardinfo->SD_csd.WrSpeedFact=(tmp&0x1C)>>2;
cardinfo->SD_csd.MaxWrBlockLen=(tmp&0x03)<<2;
tmp=(u8)((CSD_Tab[3]&0x00FF0000)>>16); //第13個(gè)字節(jié)
cardinfo->SD_csd.MaxWrBlockLen|=(tmp&0xC0)>>6;
cardinfo->SD_csd.WriteBlockPaPartial=(tmp&0x20)>>5;
cardinfo->SD_csd.Reserved3=0;
cardinfo->SD_csd.ContentProtectAppli=(tmp&0x01);
tmp=(u8)((CSD_Tab[3]&0x0000FF00)>>8); //第14個(gè)字節(jié)
cardinfo->SD_csd.FileFormatGrouop=(tmp&0x80)>>7;
cardinfo->SD_csd.CopyFlag=(tmp&0x40)>>6;
cardinfo->SD_csd.PermWrProtect=(tmp&0x20)>>5;
cardinfo->SD_csd.TempWrProtect=(tmp&0x10)>>4;
cardinfo->SD_csd.FileFormat=(tmp&0x0C)>>2;
cardinfo->SD_csd.ECC=(tmp&0x03);
tmp=(u8)(CSD_Tab[3]&0x000000FF); //第15個(gè)字節(jié)
cardinfo->SD_csd.CSD_CRC=(tmp&0xFE)>>1;
cardinfo->SD_csd.Reserved4=1;
tmp=(u8)((CID_Tab[0]&0xFF000000)>>24); //第0個(gè)字節(jié)
cardinfo->SD_cid.ManufacturerID=tmp;
tmp=(u8)((CID_Tab[0]&0x00FF0000)>>16); //第1個(gè)字節(jié)
cardinfo->SD_cid.OEM_AppliID=tmp<<8;
tmp=(u8)((CID_Tab[0]&0x000000FF00)>>8); //第2個(gè)字節(jié)
cardinfo->SD_cid.OEM_AppliID|=tmp;
tmp=(u8)(CID_Tab[0]&0x000000FF); //第3個(gè)字節(jié)
cardinfo->SD_cid.ProdName1=tmp<<24;
tmp=(u8)((CID_Tab[1]&0xFF000000)>>24); //第4個(gè)字節(jié)
cardinfo->SD_cid.ProdName1|=tmp<<16;
tmp=(u8)((CID_Tab[1]&0x00FF0000)>>16); //第5個(gè)字節(jié)
cardinfo->SD_cid.ProdName1|=tmp<<8;
tmp=(u8)((CID_Tab[1]&0x0000FF00)>>8); //第6個(gè)字節(jié)
cardinfo->SD_cid.ProdName1|=tmp;
tmp=(u8)(CID_Tab[1]&0x000000FF); //第7個(gè)字節(jié)
cardinfo->SD_cid.ProdName2=tmp;
tmp=(u8)((CID_Tab[2]&0xFF000000)>>24); //第8個(gè)字節(jié)
cardinfo->SD_cid.ProdRev=tmp;
tmp=(u8)((CID_Tab[2]&0x00FF0000)>>16); //第9個(gè)字節(jié)
cardinfo->SD_cid.ProdSN=tmp<<24;
tmp=(u8)((CID_Tab[2]&0x0000FF00)>>8); //第10個(gè)字節(jié)
cardinfo->SD_cid.ProdSN|=tmp<<16;
tmp=(u8)(CID_Tab[2]&0x000000FF); //第11個(gè)字節(jié)
cardinfo->SD_cid.ProdSN|=tmp<<8;
tmp=(u8)((CID_Tab[3]&0xFF000000)>>24); //第12個(gè)字節(jié)
cardinfo->SD_cid.ProdSN|=tmp;
tmp=(u8)((CID_Tab[3]&0x00FF0000)>>16); //第13個(gè)字節(jié)
cardinfo->SD_cid.Reserved1|=(tmp&0xF0)>>4;
cardinfo->SD_cid.ManufactDate=(tmp&0x0F)<<8;
tmp=(u8)((CID_Tab[3]&0x0000FF00)>>8); //第14個(gè)字節(jié)
cardinfo->SD_cid.ManufactDate|=tmp;
tmp=(u8)(CID_Tab[3]&0x000000FF); //第15個(gè)字節(jié)
cardinfo->SD_cid.CID_CRC=(tmp&0xFE)>>1;
cardinfo->SD_cid.Reserved2=1;
return errorstatus;
}
//設(shè)置SDIO總線寬度(MMC卡不支持4bit模式)
//wmode:位寬模式.0,1位數(shù)據(jù)寬度;1,4位數(shù)據(jù)寬度;2,8位數(shù)據(jù)寬度
//返回值:SD卡錯(cuò)誤狀態(tài)
//設(shè)置SDIO總線寬度(MMC卡不支持4bit模式)
// @arg SDIO_BusWide_8b: 8-bit data transfer (Only for MMC)
// @arg SDIO_BusWide_4b: 4-bit data transfer
// @arg SDIO_BusWide_1b: 1-bit data transfer (默認(rèn))
//返回值:SD卡錯(cuò)誤狀態(tài)
SD_Error SD_EnableWideBusOperation(u32 WideMode)
{
SD_Error errorstatus=SD_OK;
if (SDIO_MULTIMEDIA_CARD == CardType)
{
errorstatus = SD_UNSUPPORTED_FEATURE;
return(errorstatus);
}
else if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
{
if (SDIO_BusWide_8b == WideMode) //2.0 sd不支持8bits
{
errorstatus = SD_UNSUPPORTED_FEATURE;
return(errorstatus);
}
else
{
errorstatus=SDEnWideBus(WideMode);
if(SD_OK==errorstatus)
{
SDIO->CLKCR&=~(3<<11); //清除之前的位寬設(shè)置
SDIO->CLKCR|=WideMode;//1位/4位總線寬度
SDIO->CLKCR|=0<<14; //不開啟硬件流控制
}
}
}
return errorstatus;
}
//設(shè)置SD卡工作模式
//Mode:
//返回值:錯(cuò)誤狀態(tài)
SD_Error SD_SetDeviceMode(u32 Mode)
{
SD_Error errorstatus = SD_OK;
if((Mode==SD_DMA_MODE)||(Mode==SD_POLLING_MODE))DeviceMode=Mode;
else errorstatus=SD_INVALID_PARAMETER;
return errorstatus;
}
//選卡
//發(fā)送CMD7,選擇相對(duì)地址(rca)為addr的卡,取消其他卡.如果為0,則都不選擇.
//addr:卡的RCA地址
SD_Error SD_SelectDeselect(u32 addr)
{
SDIO_CmdInitStructure.SDIO_Argument = addr;//發(fā)送CMD7,選擇卡,短響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEL_DESEL_CARD;
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);//發(fā)送CMD7,選擇卡,短響應(yīng)
return CmdResp1Error(SD_CMD_SEL_DESEL_CARD);
}
//SD卡讀取一個(gè)塊
//buf:讀數(shù)據(jù)緩存區(qū)(必須4字節(jié)對(duì)齊!!)
//addr:讀取地址
//blksize:塊大小
SD_Error SD_ReadBlock(u8 *buf,long long addr,u16 blksize)
{
SD_Error errorstatus=SD_OK;
u8 power;
u32 count=0,*tempbuff=(u32*)buf;//轉(zhuǎn)換為u32指針
u32 timeout=SDIO_DATATIMEOUT;
if(NULL==buf)
return SD_INVALID_PARAMETER;
SDIO->DCTRL=0x0; //數(shù)據(jù)控制寄存器清零(關(guān)DMA)
if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡
{
blksize=512;
addr>>=9;
}
SDIO_DataInitStructure.SDIO_DataBlockSize= SDIO_DataBlockSize_1b ;//清除DPSM狀態(tài)機(jī)配置
SDIO_DataInitStructure.SDIO_DataLength= 0 ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
{
power=convert_from_bytes_to_power_of_two(blksize);
SDIO_CmdInitStructure.SDIO_Argument = blksize;
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
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);//發(fā)送CMD16+設(shè)置數(shù)據(jù)長(zhǎng)度為blksize,短響應(yīng)
errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1響應(yīng)
if(errorstatus!=SD_OK)return errorstatus; //響應(yīng)錯(cuò)誤
}else return SD_INVALID_PARAMETER;
SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4 ;//清除DPSM狀態(tài)機(jī)配置
SDIO_DataInitStructure.SDIO_DataLength= blksize ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToSDIO;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
SDIO_CmdInitStructure.SDIO_Argument = addr;
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
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);//發(fā)送CMD17+從addr地址出讀取數(shù)據(jù),短響應(yīng)
errorstatus=CmdResp1Error(SD_CMD_READ_SINGLE_BLOCK);//等待R1響應(yīng)
if(errorstatus!=SD_OK)return errorstatus; //響應(yīng)錯(cuò)誤
if(DeviceMode==SD_POLLING_MODE) //查詢模式,輪詢數(shù)據(jù)
{
INTX_DISABLE();//關(guān)閉總中斷(POLLING模式,嚴(yán)禁中斷打斷SDIO讀寫操作!!!)
while(!(SDIO->STA&((1<<5)|(1<<1)|(1<<3)|(1<<10)|(1<<9))))//無上溢/CRC/超時(shí)/完成(標(biāo)志)/起始位錯(cuò)誤
{
if(SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET) //接收區(qū)半滿,表示至少存了8個(gè)字
{
for(count=0;count<8;count++) //循環(huán)讀取數(shù)據(jù)
{
*(tempbuff+count)=SDIO->FIFO;
}
tempbuff+=8;
timeout=0X7FFFFF; //讀數(shù)據(jù)溢出時(shí)間
}else //處理超時(shí)
{
if(timeout==0)return SD_DATA_TIMEOUT;
timeout--;
}
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET) //數(shù)據(jù)超時(shí)錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清錯(cuò)誤標(biāo)志
return SD_DATA_TIMEOUT;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //數(shù)據(jù)塊CRC錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清錯(cuò)誤標(biāo)志
return SD_DATA_CRC_FAIL;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET) //接收fifo上溢錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清錯(cuò)誤標(biāo)志
return SD_RX_OVERRUN;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清錯(cuò)誤標(biāo)志
return SD_START_BIT_ERR;
}
while(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET) //FIFO里面,還存在可用數(shù)據(jù)
{
*tempbuff=SDIO->FIFO; //循環(huán)讀取數(shù)據(jù)
tempbuff++;
}
INTX_ENABLE();//開啟總中斷
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標(biāo)記
}else if(DeviceMode==SD_DMA_MODE)
{
TransferError=SD_OK;
StopCondition=0; //單塊讀,不需要發(fā)送停止傳輸指令
TransferEnd=0; //傳輸結(jié)束標(biāo)置位，在中斷服務(wù)置1
SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<5)|(1<<9); //配置需要的中斷
SDIO->DCTRL|=1<<3; //SDIO DMA使能
SD_DMA_Config((u32*)buf,blksize,DMA_DIR_PeripheralToMemory);
while(((DMA2->LISR&(1<<27))==RESET)&&(TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;//等待傳輸完成
if(timeout==0)return SD_DATA_TIMEOUT;//超時(shí)
if(TransferError!=SD_OK)errorstatus=TransferError;
}
return errorstatus;
}
//SD卡讀取多個(gè)塊
//buf:讀數(shù)據(jù)緩存區(qū)
//addr:讀取地址
//blksize:塊大小
//nblks:要讀取的塊數(shù)
//返回值:錯(cuò)誤狀態(tài)
__align(4) u32 *tempbuff;
SD_Error SD_ReadMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks)
{
SD_Error errorstatus=SD_OK;
u8 power;
u32 count=0;
u32 timeout=SDIO_DATATIMEOUT;
tempbuff=(u32*)buf;//轉(zhuǎn)換為u32指針
SDIO->DCTRL=0x0; //數(shù)據(jù)控制寄存器清零(關(guān)DMA)
if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡
{
blksize=512;
addr>>=9;
}
SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ;//清除DPSM狀態(tài)機(jī)配置
SDIO_DataInitStructure.SDIO_DataLength= 0 ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
{
power=convert_from_bytes_to_power_of_two(blksize);
SDIO_CmdInitStructure.SDIO_Argument = blksize;//發(fā)送CMD16+設(shè)置數(shù)據(jù)長(zhǎng)度為blksize,短響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
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_SET_BLOCKLEN); //等待R1響應(yīng)
if(errorstatus!=SD_OK)return errorstatus; //響應(yīng)錯(cuò)誤
}else return SD_INVALID_PARAMETER;
if(nblks>1) //多塊讀
{
if(nblks*blksize>SD_MAX_DATA_LENGTH)return SD_INVALID_PARAMETER;//判斷是否超過最大接收長(zhǎng)度
SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4; ;//nblks*blksize,512塊大小,卡到控制器
SDIO_DataInitStructure.SDIO_DataLength= nblks*blksize ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToSDIO;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
SDIO_CmdInitStructure.SDIO_Argument = addr;//發(fā)送CMD18+從addr地址出讀取數(shù)據(jù),短響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_READ_MULT_BLOCK;
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_READ_MULT_BLOCK);//等待R1響應(yīng)
if(errorstatus!=SD_OK)return errorstatus; //響應(yīng)錯(cuò)誤
if(DeviceMode==SD_POLLING_MODE)
{
INTX_DISABLE();//關(guān)閉總中斷(POLLING模式,嚴(yán)禁中斷打斷SDIO讀寫操作!!!)
while(!(SDIO->STA&((1<<5)|(1<<1)|(1<<3)|(1<<8)|(1<<9))))//無上溢/CRC/超時(shí)/完成(標(biāo)志)/起始位錯(cuò)誤
{
if(SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET) //接收區(qū)半滿,表示至少存了8個(gè)字
{
for(count=0;count<8;count++) //循環(huán)讀取數(shù)據(jù)
{
*(tempbuff+count)=SDIO->FIFO;
}
tempbuff+=8;
timeout=0X7FFFFF; //讀數(shù)據(jù)溢出時(shí)間
}else //處理超時(shí)
{
if(timeout==0)return SD_DATA_TIMEOUT;
timeout--;
}
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET) //數(shù)據(jù)超時(shí)錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清錯(cuò)誤標(biāo)志
return SD_DATA_TIMEOUT;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //數(shù)據(jù)塊CRC錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清錯(cuò)誤標(biāo)志
return SD_DATA_CRC_FAIL;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET) //接收fifo上溢錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清錯(cuò)誤標(biāo)志
return SD_RX_OVERRUN;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清錯(cuò)誤標(biāo)志
return SD_START_BIT_ERR;
}
while(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET) //FIFO里面,還存在可用數(shù)據(jù)
{
*tempbuff=SDIO->FIFO; //循環(huán)讀取數(shù)據(jù)
tempbuff++;
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET) //接收結(jié)束
{
if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
{
SDIO_CmdInitStructure.SDIO_Argument = 0;//發(fā)送CMD12+結(jié)束傳輸
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;
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_STOP_TRANSMISSION);//等待R1響應(yīng)
if(errorstatus!=SD_OK)return errorstatus;
}
}
INTX_ENABLE();//開啟總中斷
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標(biāo)記
}else if(DeviceMode==SD_DMA_MODE)
{
TransferError=SD_OK;
StopCondition=1; //多塊讀,需要發(fā)送停止傳輸指令
TransferEnd=0; //傳輸結(jié)束標(biāo)置位，在中斷服務(wù)置1
SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<5)|(1<<9); //配置需要的中斷
SDIO->DCTRL|=1<<3; //SDIO DMA使能
SD_DMA_Config((u32*)buf,nblks*blksize,DMA_DIR_PeripheralToMemory);
while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待傳輸完成
if(timeout==0)return SD_DATA_TIMEOUT;//超時(shí)
while((TransferEnd==0)&&(TransferError==SD_OK));
if(TransferError!=SD_OK)errorstatus=TransferError;
}
}
return errorstatus;
}
//SD卡寫1個(gè)塊
//buf:數(shù)據(jù)緩存區(qū)
//addr:寫地址
//blksize:塊大小
//返回值:錯(cuò)誤狀態(tài)
SD_Error SD_WriteBlock(u8 *buf,long long addr, u16 blksize)
{
SD_Error errorstatus = SD_OK;
u8 power=0,cardstate=0;
u32 timeout=0,bytestransferred=0;
u32 cardstatus=0,count=0,restwords=0;
u32 tlen=blksize; //總長(zhǎng)度(字節(jié))
u32*tempbuff=(u32*)buf;
if(buf==NULL)return SD_INVALID_PARAMETER;//參數(shù)錯(cuò)誤
SDIO->DCTRL=0x0; //數(shù)據(jù)控制寄存器清零(關(guān)DMA)
SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ;//清除DPSM狀態(tài)機(jī)配置
SDIO_DataInitStructure.SDIO_DataLength= 0 ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
if(CardType==SDIO_HIGH_CAPACITY_SD_CARD) //大容量卡
{
blksize=512;
addr>>=9;
}
if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
{
power=convert_from_bytes_to_power_of_two(blksize);
SDIO_CmdInitStructure.SDIO_Argument = blksize;//發(fā)送CMD16+設(shè)置數(shù)據(jù)長(zhǎng)度為blksize,短響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
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_SET_BLOCKLEN); //等待R1響應(yīng)
if(errorstatus!=SD_OK)return errorstatus; //響應(yīng)錯(cuò)誤
}else return SD_INVALID_PARAMETER;
SDIO_CmdInitStructure.SDIO_Argument = (u32)RCA<<16;//發(fā)送CMD13,查詢卡的狀態(tài),短響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;
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_SEND_STATUS); //等待R1響應(yīng)
if(errorstatus!=SD_OK)return errorstatus;
cardstatus=SDIO->RESP1;
timeout=SD_DATATIMEOUT;
while(((cardstatus&0x00000100)==0)&&(timeout>0)) //檢查READY_FOR_DATA位是否置位
{
timeout--;
SDIO_CmdInitStructure.SDIO_Argument = (u32)RCA<<16;//發(fā)送CMD13,查詢卡的狀態(tài),短響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;
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_SEND_STATUS); //等待R1響應(yīng)
if(errorstatus!=SD_OK)return errorstatus;
cardstatus=SDIO->RESP1;
}
if(timeout==0)return SD_ERROR;
SDIO_CmdInitStructure.SDIO_Argument = addr;//發(fā)送CMD24,寫單塊指令,短響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
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_WRITE_SINGLE_BLOCK);//等待R1響應(yīng)
if(errorstatus!=SD_OK)return errorstatus;
StopCondition=0; //單塊寫,不需要發(fā)送停止傳輸指令
SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4; ; //blksize, 控制器到卡
SDIO_DataInitStructure.SDIO_DataLength= blksize ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
timeout=SDIO_DATATIMEOUT;
if (DeviceMode == SD_POLLING_MODE)
{
INTX_DISABLE();//關(guān)閉總中斷(POLLING模式,嚴(yán)禁中斷打斷SDIO讀寫操作!!!)
while(!(SDIO->STA&((1<<10)|(1<<4)|(1<<1)|(1<<3)|(1<<9))))//數(shù)據(jù)塊發(fā)送成功/下溢/CRC/超時(shí)/起始位錯(cuò)誤
{
if(SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE) != RESET) //發(fā)送區(qū)半空,表示至少存了8個(gè)字
{
if((tlen-bytestransferred)<SD_HALFFIFOBYTES)//不夠32字節(jié)了
{
restwords=((tlen-bytestransferred)%4==0)?((tlen-bytestransferred)/4):((tlen-bytestransferred)/4+1);
for(count=0;count<restwords;count++,tempbuff++,bytestransferred+=4)
{
SDIO->FIFO=*tempbuff;
}
}else
{
for(count=0;count<8;count++)
{
SDIO->FIFO=*(tempbuff+count);
}
tempbuff+=8;
bytestransferred+=32;
}
timeout=0X3FFFFFFF; //寫數(shù)據(jù)溢出時(shí)間
}else
{
if(timeout==0)return SD_DATA_TIMEOUT;
timeout--;
}
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET) //數(shù)據(jù)超時(shí)錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清錯(cuò)誤標(biāo)志
return SD_DATA_TIMEOUT;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //數(shù)據(jù)塊CRC錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清錯(cuò)誤標(biāo)志
return SD_DATA_CRC_FAIL;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET) //接收fifo下溢錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_TXUNDERR); //清錯(cuò)誤標(biāo)志
return SD_TX_UNDERRUN;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清錯(cuò)誤標(biāo)志
return SD_START_BIT_ERR;
}
INTX_ENABLE();//開啟總中斷
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標(biāo)記
}else if(DeviceMode==SD_DMA_MODE)
{
TransferError=SD_OK;
StopCondition=0; //單塊寫,不需要發(fā)送停止傳輸指令
TransferEnd=0; //傳輸結(jié)束標(biāo)置位，在中斷服務(wù)置1
SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置產(chǎn)生數(shù)據(jù)接收完成中斷
SD_DMA_Config((u32*)buf,blksize,DMA_DIR_MemoryToPeripheral); //SDIO DMA配置
SDIO->DCTRL|=1<<3; //SDIO DMA使能.
while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待傳輸完成
if(timeout==0)
{
SD_Init(); //重新初始化SD卡,可以解決寫入死機(jī)的問題
return SD_DATA_TIMEOUT; //超時(shí)
}
timeout=SDIO_DATATIMEOUT;
while((TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;
if(timeout==0)return SD_DATA_TIMEOUT; //超時(shí)
if(TransferError!=SD_OK)return TransferError;
}
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標(biāo)記
errorstatus=IsCardProgramming(&cardstate);
while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING)))
{
errorstatus=IsCardProgramming(&cardstate);
}
return errorstatus;
}
//SD卡寫多個(gè)塊
//buf:數(shù)據(jù)緩存區(qū)
//addr:寫地址
//blksize:塊大小
//nblks:要寫入的塊數(shù)
//返回值:錯(cuò)誤狀態(tài)
SD_Error SD_WriteMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks)
{
SD_Error errorstatus = SD_OK;
u8 power = 0, cardstate = 0;
u32 timeout=0,bytestransferred=0;
u32 count = 0, restwords = 0;
u32 tlen=nblks*blksize; //總長(zhǎng)度(字節(jié))
u32 *tempbuff = (u32*)buf;
if(buf==NULL)return SD_INVALID_PARAMETER; //參數(shù)錯(cuò)誤
SDIO->DCTRL=0x0; //數(shù)據(jù)控制寄存器清零(關(guān)DMA)
SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ; //清除DPSM狀態(tài)機(jī)配置
SDIO_DataInitStructure.SDIO_DataLength= 0 ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡
{
blksize=512;
addr>>=9;
}
if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
{
power=convert_from_bytes_to_power_of_two(blksize);
SDIO_CmdInitStructure.SDIO_Argument = blksize; //發(fā)送CMD16+設(shè)置數(shù)據(jù)長(zhǎng)度為blksize,短響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
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_SET_BLOCKLEN); //等待R1響應(yīng)
if(errorstatus!=SD_OK)return errorstatus; //響應(yīng)錯(cuò)誤
}else return SD_INVALID_PARAMETER;
if(nblks>1)
{
if(nblks*blksize>SD_MAX_DATA_LENGTH)return SD_INVALID_PARAMETER;
if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
{
//提高性能
SDIO_CmdInitStructure.SDIO_Argument = (u32)RCA<<16; //發(fā)送ACMD55,短響應(yīng)
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響應(yīng)
if(errorstatus!=SD_OK)return errorstatus;
SDIO_CmdInitStructure.SDIO_Argument =nblks; //發(fā)送CMD23,設(shè)置塊數(shù)量,短響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCK_COUNT;
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_SET_BLOCK_COUNT);//等待R1響應(yīng)
if(errorstatus!=SD_OK)return errorstatus;
}
SDIO_CmdInitStructure.SDIO_Argument =addr; //發(fā)送CMD25,多塊寫指令,短響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
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_WRITE_MULT_BLOCK); //等待R1響應(yīng)
if(errorstatus!=SD_OK)return errorstatus;
SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4; ; //blksize, 控制器到卡
SDIO_DataInitStructure.SDIO_DataLength= nblks*blksize ;
SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
SDIO_DataConfig(&SDIO_DataInitStructure);
if(DeviceMode==SD_POLLING_MODE)
{
timeout=SDIO_DATATIMEOUT;
INTX_DISABLE();//關(guān)閉總中斷(POLLING模式,嚴(yán)禁中斷打斷SDIO讀寫操作!!!)
while(!(SDIO->STA&((1<<4)|(1<<1)|(1<<8)|(1<<3)|(1<<9))))//下溢/CRC/數(shù)據(jù)結(jié)束/超時(shí)/起始位錯(cuò)誤
{
if(SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE) != RESET) //發(fā)送區(qū)半空,表示至少存了8字(32字節(jié))
{
if((tlen-bytestransferred)<SD_HALFFIFOBYTES)//不夠32字節(jié)了
{
restwords=((tlen-bytestransferred)%4==0)?((tlen-bytestransferred)/4):((tlen-bytestransferred)/4+1);
for(count=0;count<restwords;count++,tempbuff++,bytestransferred+=4)
{
SDIO->FIFO=*tempbuff;
}
}else //發(fā)送區(qū)半空,可以發(fā)送至少8字(32字節(jié))數(shù)據(jù)
{
for(count=0;count<SD_HALFFIFO;count++)
{
SDIO->FIFO=*(tempbuff+count);
}
tempbuff+=SD_HALFFIFO;
bytestransferred+=SD_HALFFIFOBYTES;
}
timeout=0X3FFFFFFF; //寫數(shù)據(jù)溢出時(shí)間
}else
{
if(timeout==0)return SD_DATA_TIMEOUT;
timeout--;
}
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET) //數(shù)據(jù)超時(shí)錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清錯(cuò)誤標(biāo)志
return SD_DATA_TIMEOUT;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //數(shù)據(jù)塊CRC錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清錯(cuò)誤標(biāo)志
return SD_DATA_CRC_FAIL;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET) //接收fifo下溢錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_TXUNDERR); //清錯(cuò)誤標(biāo)志
return SD_TX_UNDERRUN;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清錯(cuò)誤標(biāo)志
return SD_START_BIT_ERR;
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET) //發(fā)送結(jié)束
{
if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
{
SDIO_CmdInitStructure.SDIO_Argument =0;//發(fā)送CMD12+結(jié)束傳輸
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;
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_STOP_TRANSMISSION);//等待R1響應(yīng)
if(errorstatus!=SD_OK)return errorstatus;
}
}
INTX_ENABLE();//開啟總中斷
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標(biāo)記
}else if(DeviceMode==SD_DMA_MODE)
{
TransferError=SD_OK;
StopCondition=1; //多塊寫,需要發(fā)送停止傳輸指令
TransferEnd=0; //傳輸結(jié)束標(biāo)置位，在中斷服務(wù)置1
SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置產(chǎn)生數(shù)據(jù)接收完成中斷
SD_DMA_Config((u32*)buf,nblks*blksize,DMA_DIR_MemoryToPeripheral); //SDIO DMA配置
SDIO->DCTRL|=1<<3; //SDIO DMA使能.
timeout=SDIO_DATATIMEOUT;
while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待傳輸完成
if(timeout==0) //超時(shí)
{
SD_Init(); //重新初始化SD卡,可以解決寫入死機(jī)的問題
return SD_DATA_TIMEOUT; //超時(shí)
}
timeout=SDIO_DATATIMEOUT;
while((TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;
if(timeout==0)return SD_DATA_TIMEOUT; //超時(shí)
if(TransferError!=SD_OK)return TransferError;
}
}
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標(biāo)記
errorstatus=IsCardProgramming(&cardstate);
while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING)))
{
errorstatus=IsCardProgramming(&cardstate);
}
return errorstatus;
}
//SDIO中斷服務(wù)函數(shù)
void SDIO_IRQHandler(void)
{
SD_ProcessIRQSrc();//處理所有SDIO相關(guān)中斷
}
//SDIO中斷處理函數(shù)
//處理SDIO傳輸過程中的各種中斷事務(wù)
//返回值:錯(cuò)誤代碼
SD_Error SD_ProcessIRQSrc(void)
{
if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET)//接收完成中斷
{
if (StopCondition==1)
{
SDIO_CmdInitStructure.SDIO_Argument =0;//發(fā)送CMD12+結(jié)束傳輸
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;
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);
TransferError=CmdResp1Error(SD_CMD_STOP_TRANSMISSION);
}else TransferError = SD_OK;
SDIO->ICR|=1<<8;//清除完成中斷標(biāo)記
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關(guān)閉相關(guān)中斷
TransferEnd = 1;
return(TransferError);
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)//數(shù)據(jù)CRC錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清錯(cuò)誤標(biāo)志
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關(guān)閉相關(guān)中斷
TransferError = SD_DATA_CRC_FAIL;
return(SD_DATA_CRC_FAIL);
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)//數(shù)據(jù)超時(shí)錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清中斷標(biāo)志
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關(guān)閉相關(guān)中斷
TransferError = SD_DATA_TIMEOUT;
return(SD_DATA_TIMEOUT);
}
if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET)//FIFO上溢錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清中斷標(biāo)志
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關(guān)閉相關(guān)中斷
TransferError = SD_RX_OVERRUN;
return(SD_RX_OVERRUN);
}
if(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET)//FIFO下溢錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_TXUNDERR); //清中斷標(biāo)志
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關(guān)閉相關(guān)中斷
TransferError = SD_TX_UNDERRUN;
return(SD_TX_UNDERRUN);
}
if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)//起始位錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_STBITERR); //清中斷標(biāo)志
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關(guān)閉相關(guān)中斷
TransferError = SD_START_BIT_ERR;
return(SD_START_BIT_ERR);
}
return(SD_OK);
}
//檢查CMD0的執(zhí)行狀態(tài)
//返回值:sd卡錯(cuò)誤碼
SD_Error CmdError(void)
{
SD_Error errorstatus = SD_OK;
u32 timeout=SDIO_CMD0TIMEOUT;
while(timeout--)
{
if(SDIO_GetFlagStatus(SDIO_FLAG_CMDSENT) != RESET)break; //命令已發(fā)送(無需響應(yīng))
}
if(timeout==0)return SD_CMD_RSP_TIMEOUT;
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標(biāo)記
return errorstatus;
}
//檢查R7響應(yīng)的錯(cuò)誤狀態(tài)
//返回值:sd卡錯(cuò)誤碼
SD_Error CmdResp7Error(void)
{
SD_Error errorstatus=SD_OK;
u32 status;
u32 timeout=SDIO_CMD0TIMEOUT;
while(timeout--)
{
status=SDIO->STA;
if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯(cuò)誤/命令響應(yīng)超時(shí)/已經(jīng)收到響應(yīng)(CRC校驗(yàn)成功)
}
if((timeout==0)||(status&(1<<2))) //響應(yīng)超時(shí)
{
errorstatus=SD_CMD_RSP_TIMEOUT; //當(dāng)前卡不是2.0兼容卡,或者不支持設(shè)定的電壓范圍
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令響應(yīng)超時(shí)標(biāo)志
return errorstatus;
}
if(status&1<<6) //成功接收到響應(yīng)
{
errorstatus=SD_OK;
SDIO_ClearFlag(SDIO_FLAG_CMDREND); //清除響應(yīng)標(biāo)志
}
return errorstatus;
}
//檢查R1響應(yīng)的錯(cuò)誤狀態(tài)
//cmd:當(dāng)前命令
//返回值:sd卡錯(cuò)誤碼
SD_Error CmdResp1Error(u8 cmd)
{
u32 status;
while(1)
{
status=SDIO->STA;
if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯(cuò)誤/命令響應(yīng)超時(shí)/已經(jīng)收到響應(yīng)(CRC校驗(yàn)成功)
}
if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET) //響應(yīng)超時(shí)
{
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令響應(yīng)超時(shí)標(biāo)志
return SD_CMD_RSP_TIMEOUT;
}
if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET) //CRC錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除標(biāo)志
return SD_CMD_CRC_FAIL;
}
if(SDIO->RESPCMD!=cmd)return SD_ILLEGAL_CMD;//命令不匹配
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標(biāo)記
return (SD_Error)(SDIO->RESP1&SD_OCR_ERRORBITS);//返回卡響應(yīng)
}
//檢查R3響應(yīng)的錯(cuò)誤狀態(tài)
//返回值:錯(cuò)誤狀態(tài)
SD_Error CmdResp3Error(void)
{
u32 status;
while(1)
{
status=SDIO->STA;
if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯(cuò)誤/命令響應(yīng)超時(shí)/已經(jīng)收到響應(yīng)(CRC校驗(yàn)成功)
}
if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET) //響應(yīng)超時(shí)
{
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令響應(yīng)超時(shí)標(biāo)志
return SD_CMD_RSP_TIMEOUT;
}
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標(biāo)記
return SD_OK;
}
//檢查R2響應(yīng)的錯(cuò)誤狀態(tài)
//返回值:錯(cuò)誤狀態(tài)
SD_Error CmdResp2Error(void)
{
SD_Error errorstatus=SD_OK;
u32 status;
u32 timeout=SDIO_CMD0TIMEOUT;
while(timeout--)
{
status=SDIO->STA;
if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯(cuò)誤/命令響應(yīng)超時(shí)/已經(jīng)收到響應(yīng)(CRC校驗(yàn)成功)
}
if((timeout==0)||(status&(1<<2))) //響應(yīng)超時(shí)
{
errorstatus=SD_CMD_RSP_TIMEOUT;
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令響應(yīng)超時(shí)標(biāo)志
return errorstatus;
}
if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET) //CRC錯(cuò)誤
{
errorstatus=SD_CMD_CRC_FAIL;
SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除響應(yīng)標(biāo)志
}
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標(biāo)記
return errorstatus;
}
//檢查R6響應(yīng)的錯(cuò)誤狀態(tài)
//cmd:之前發(fā)送的命令
//prca:卡返回的RCA地址
//返回值:錯(cuò)誤狀態(tài)
SD_Error CmdResp6Error(u8 cmd,u16*prca)
{
SD_Error errorstatus=SD_OK;
u32 status;
u32 rspr1;
while(1)
{
status=SDIO->STA;
if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯(cuò)誤/命令響應(yīng)超時(shí)/已經(jīng)收到響應(yīng)(CRC校驗(yàn)成功)
}
if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET) //響應(yīng)超時(shí)
{
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除命令響應(yīng)超時(shí)標(biāo)志
return SD_CMD_RSP_TIMEOUT;
}
if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET) //CRC錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除響應(yīng)標(biāo)志
return SD_CMD_CRC_FAIL;
}
if(SDIO->RESPCMD!=cmd) //判斷是否響應(yīng)cmd命令
{
return SD_ILLEGAL_CMD;
}
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標(biāo)記
rspr1=SDIO->RESP1; //得到響應(yīng)
if(SD_ALLZERO==(rspr1&(SD_R6_GENERAL_UNKNOWN_ERROR|SD_R6_ILLEGAL_CMD|SD_R6_COM_CRC_FAILED)))
{
*prca=(u16)(rspr1>>16); //右移16位得到,rca
return errorstatus;
}
if(rspr1&SD_R6_GENERAL_UNKNOWN_ERROR)return SD_GENERAL_UNKNOWN_ERROR;
if(rspr1&SD_R6_ILLEGAL_CMD)return SD_ILLEGAL_CMD;
if(rspr1&SD_R6_COM_CRC_FAILED)return SD_COM_CRC_FAILED;
return errorstatus;
}
//SDIO使能寬總線模式
//enx:0,不使能;1,使能;
//返回值:錯(cuò)誤狀態(tài)
SD_Error SDEnWideBus(u8 enx)
{
SD_Error errorstatus = SD_OK;
u32 scr[2]={0,0};
u8 arg=0X00;
if(enx)arg=0X02;
else arg=0X00;
if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//SD卡處于LOCKED狀態(tài)
errorstatus=FindSCR(RCA,scr); //得到SCR寄存器數(shù)據(jù)
if(errorstatus!=SD_OK)return errorstatus;
if((scr[1]&SD_WIDE_BUS_SUPPORT)!=SD_ALLZERO) //支持寬總線
{
SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;//發(fā)送CMD55+RCA,短響應(yīng)
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);
if(errorstatus!=SD_OK)return errorstatus;
SDIO_CmdInitStructure.SDIO_Argument = arg;//發(fā)送ACMD6,短響應(yīng),參數(shù):10,4位;00,1位.
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
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_SD_SET_BUSWIDTH);
return errorstatus;
}else return SD_REQUEST_NOT_APPLICABLE; //不支持寬總線設(shè)置
}
//檢查卡是否正在執(zhí)行寫操作
//pstatus:當(dāng)前狀態(tài).
//返回值:錯(cuò)誤代碼
SD_Error IsCardProgramming(u8 *pstatus)
{
vu32 respR1 = 0, status = 0;
SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16; //卡相對(duì)地址參數(shù)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;//發(fā)送CMD13
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);
status=SDIO->STA;
while(!(status&((1<<0)|(1<<6)|(1<<2))))status=SDIO->STA;//等待操作完成
if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET) //CRC檢測(cè)失敗
{
SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除錯(cuò)誤標(biāo)記
return SD_CMD_CRC_FAIL;
}
if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET) //命令超時(shí)
{
SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT); //清除錯(cuò)誤標(biāo)記
return SD_CMD_RSP_TIMEOUT;
}
if(SDIO->RESPCMD!=SD_CMD_SEND_STATUS)return SD_ILLEGAL_CMD;
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標(biāo)記
respR1=SDIO->RESP1;
*pstatus=(u8)((respR1>>9)&0x0000000F);
return SD_OK;
}
//讀取當(dāng)前卡狀態(tài)
//pcardstatus:卡狀態(tài)
//返回值:錯(cuò)誤代碼
SD_Error SD_SendStatus(uint32_t *pcardstatus)
{
SD_Error errorstatus = SD_OK;
if(pcardstatus==NULL)
{
errorstatus=SD_INVALID_PARAMETER;
return errorstatus;
}
SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;//發(fā)送CMD13,短響應(yīng)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;
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_SEND_STATUS); //查詢響應(yīng)狀態(tài)
if(errorstatus!=SD_OK)return errorstatus;
*pcardstatus=SDIO->RESP1;//讀取響應(yīng)值
return errorstatus;
}
//返回SD卡的狀態(tài)
//返回值:SD卡狀態(tài)
SDCardState SD_GetState(void)
{
u32 resp1=0;
if(SD_SendStatus(&resp1)!=SD_OK)return SD_CARD_ERROR;
else return (SDCardState)((resp1>>9) & 0x0F);
}
//查找SD卡的SCR寄存器值
//rca:卡相對(duì)地址
//pscr:數(shù)據(jù)緩存區(qū)(存儲(chǔ)SCR內(nèi)容)
//返回值:錯(cuò)誤狀態(tài)
SD_Error FindSCR(u16 rca,u32 *pscr)
{
u32 index = 0;
SD_Error errorstatus = SD_OK;
u32 tempscr[2]={0,0};
SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)8; //發(fā)送CMD16,短響應(yīng),設(shè)置Block Size為8字節(jié)
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN; // cmd16
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r1
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN);
if(errorstatus!=SD_OK)return errorstatus;
SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;//發(fā)送CMD55,短響應(yīng)
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);
if(errorstatus!=SD_OK)return errorstatus;
SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
SDIO_DataInitStructure.SDIO_DataLength = 8; //8個(gè)字節(jié)長(zhǎng)度,block為8字節(jié),SD卡到SDIO.
SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_8b ; //塊大小8byte
SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToSDIO;
SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
SDIO_DataConfig(&SDIO_DataInitStructure);
SDIO_CmdInitStructure.SDIO_Argument = 0x0;
SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_SEND_SCR; //發(fā)送ACMD51,短響應(yīng),參數(shù)為0
SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r1
SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
SDIO_SendCommand(&SDIO_CmdInitStructure);
errorstatus=CmdResp1Error(SD_CMD_SD_APP_SEND_SCR);
if(errorstatus!=SD_OK)return errorstatus;
while(!(SDIO->STA&(SDIO_FLAG_RXOVERR|SDIO_FLAG_DCRCFAIL|SDIO_FLAG_DTIMEOUT|SDIO_FLAG_DBCKEND|SDIO_FLAG_STBITERR)))
{
if(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET)//接收FIFO數(shù)據(jù)可用
{
*(tempscr+index)=SDIO->FIFO; //讀取FIFO內(nèi)容
index++;
if(index>=2)break;
}
}
if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET) //數(shù)據(jù)超時(shí)錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT); //清錯(cuò)誤標(biāo)志
return SD_DATA_TIMEOUT;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //數(shù)據(jù)塊CRC錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL); //清錯(cuò)誤標(biāo)志
return SD_DATA_CRC_FAIL;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET) //接收fifo上溢錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_RXOVERR); //清錯(cuò)誤標(biāo)志
return SD_RX_OVERRUN;
}else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET) //接收起始位錯(cuò)誤
{
SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清錯(cuò)誤標(biāo)志
return SD_START_BIT_ERR;
}
SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標(biāo)記
//把數(shù)據(jù)順序按8位為單位倒過來.
*(pscr+1)=((tempscr[0]&SD_0TO7BITS)<<24)|((tempscr[0]&SD_8TO15BITS)<<8)|((tempscr[0]&SD_16TO23BITS)>>8)|((tempscr[0]&SD_24TO31BITS)>>24);
*(pscr)=((tempscr[1]&SD_0TO7BITS)<<24)|((tempscr[1]&SD_8TO15BITS)<<8)|((tempscr[1]&SD_16TO23BITS)>>8)|((tempscr[1]&SD_24TO31BITS)>>24);
return errorstatus;
}
//得到NumberOfBytes以2為底的指數(shù).
//NumberOfBytes:字節(jié)數(shù).
//返回值:以2為底的指數(shù)值
u8 convert_from_bytes_to_power_of_two(u16 NumberOfBytes)
{
u8 count=0;
while(NumberOfBytes!=1)
{
NumberOfBytes>>=1;
count++;
}
return count;
}
//配置SDIO DMA
//mbuf:存儲(chǔ)器地址
//bufsize:傳輸數(shù)據(jù)量
//dir:方向;DMA_DIR_MemoryToPeripheral 存儲(chǔ)器-->SDIO(寫數(shù)據(jù));DMA_DIR_PeripheralToMemory SDIO-->存儲(chǔ)器(讀數(shù)據(jù));
void SD_DMA_Config(u32*mbuf,u32 bufsize,u32 dir)
{
DMA_InitTypeDef DMA_InitStructure;
while (DMA_GetCmdStatus(DMA2_Stream3) != DISABLE){}//等待DMA可配置
DMA_DeInit(DMA2_Stream3);//清空之前該stream3上的所有中斷標(biāo)志
DMA_InitStructure.DMA_Channel = DMA_Channel_4; //通道選擇
DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&SDIO->FIFO;//DMA外設(shè)地址
DMA_InitStructure.DMA_Memory0BaseAddr = (u32)mbuf;//DMA 存儲(chǔ)器0地址
DMA_InitStructure.DMA_DIR = dir;//存儲(chǔ)器到外設(shè)模式
DMA_InitStructure.DMA_BufferSize = 0;//數(shù)據(jù)傳輸量
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;//外設(shè)非增量模式
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;//存儲(chǔ)器增量模式
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;//外設(shè)數(shù)據(jù)長(zhǎng)度:32位
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;//存儲(chǔ)器數(shù)據(jù)長(zhǎng)度:32位
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;// 使用普通模式
DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;//最高優(yōu)先級(jí)
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable; //FIFO使能
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;//全FIFO
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_INC4;//外設(shè)突發(fā)4次傳輸
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_INC4;//存儲(chǔ)器突發(fā)4次傳輸
DMA_Init(DMA2_Stream3, &DMA_InitStructure);//初始化DMA Stream
DMA_FlowControllerConfig(DMA2_Stream3,DMA_FlowCtrl_Peripheral);//外設(shè)流控制
DMA_Cmd(DMA2_Stream3 ,ENABLE);//開啟DMA傳輸
}
//讀SD卡
//buf:讀數(shù)據(jù)緩存區(qū)
//sector:扇區(qū)地址
//cnt:扇區(qū)個(gè)數(shù)
//返回值:錯(cuò)誤狀態(tài);0,正常;其他,錯(cuò)誤代碼;
u8 SD_ReadDisk(u8*buf,u32 sector,u8 cnt)
{
u8 sta=SD_OK;
long long lsector=sector;
u8 n;
if(CardType!=SDIO_STD_CAPACITY_SD_CARD_V1_1)lsector<<=9;
if((u32)buf%4!=0)
{
for(n=0;n<cnt;n++)
{
sta=SD_ReadBlock(SDIO_DATA_BUFFER,lsector+512*n,512);//單個(gè)sector的讀操作
memcpy(buf,SDIO_DATA_BUFFER,512);
buf+=512;
}
}else
{
if(cnt==1)sta=SD_ReadBlock(buf,lsector,512); //單個(gè)sector的讀操作
else sta=SD_ReadMultiBlocks(buf,lsector,512,cnt);//多個(gè)sector
}
return sta;
}
//寫SD卡
//buf:寫數(shù)據(jù)緩存區(qū)
//sector:扇區(qū)地址
//cnt:扇區(qū)個(gè)數(shù)
//返回值:錯(cuò)誤狀態(tài);0,正常;其他,錯(cuò)誤代碼;
u8 SD_WriteDisk(u8*buf,u32 sector,u8 cnt)
{
u8 sta=SD_OK;
u8 n;
long long lsector=sector;
if(CardType!=SDIO_STD_CAPACITY_SD_CARD_V1_1)lsector<<=9;
if((u32)buf%4!=0)
{
for(n=0;n<cnt;n++)
{
memcpy(SDIO_DATA_BUFFER,buf,512);
sta=SD_WriteBlock(SDIO_DATA_BUFFER,lsector+512*n,512);//單個(gè)sector的寫操作
buf+=512;
}
}else
{
if(cnt==1)sta=SD_WriteBlock(buf,lsector,512); //單個(gè)sector的寫操作
else sta=SD_WriteMultiBlocks(buf,lsector,512,cnt); //多個(gè)sector
}
return sta;
}