標題: STM32F407VET6采集AD數(shù)據(jù),保存到SD卡中 源程序 [打印本頁]
作者: piczero    時間: 2021-11-28 06:24
標題: STM32F407VET6采集AD數(shù)據(jù),保存到SD卡中 源程序
  1. //單片機采用STM32F407VET6 ad采集數(shù)據(jù)，并將數(shù)據(jù)保存到sd中
  2. #include "sys.h"
  3. #include "delay.h"
  4. #include "usart.h"
  5. #include "led.h"
  6. #include "key.h"
  7. #include "adc.h"
  8. #include "sdio_sdcard.h"      
  9. #include "ff.h"  
  10. #include "exfuns.h"  
  11. #include "string.h"
  12. int main(void)
  13. {
  14.     float temp;
  15. u8 i,res;
  16. u8 ADc_Buff[200]=0;
  17. u8 ADc_temp[20]=0;
  18. NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//設置系統(tǒng)中斷優(yōu)先級分組2
  19. delay_init(168);  //延時初始化
  20. uart_init(115200);     //串口初始化波特率為115200
  21. LED_Init();      //初始化與LED連接的硬件接口  
  22. Adc_Init();             //初始化ADC

  24. SD_Init();
  25. exfuns_init();      //為fatfs相關變量申請內(nèi)存     
  26.     f_mount(fs[0],"0:",1);  //掛載SD卡
  27.   res=mf_open("0:/123/ADcData.txt",FA_OPEN_ALWAYS | FA_READ | FA_WRITE );//創(chuàng)建或打開一個文本文檔保存數(shù)據(jù)
  28. res=mf_open("0:/ADcData.txt",FA_OPEN_ALWAYS | FA_READ | FA_WRITE );//創(chuàng)建或打開一個文本文檔保存數(shù)據(jù)
  29. if(res==FR_OK)
  30.     {
  31.   printf("文件已經(jīng)存在!\r\n");
  32. }
  33. else
  34. {
  35.   printf("建立該文件!\r\n");
  36. }

  38. while(1)
  39. {
  40.   for(i=0;i<8;i++)
  41.   {
  42.    temp=(float)(Get_Adc_Average(i,20))*(3.3/4096);   //獲取計算后的帶小數(shù)的實際電壓值，比如3.1111
  43.    printf("通道%d=%f\r\n",i,temp);
  44.    sprintf(ADc_temp,"%f|",temp);
  45.    strcat(ADc_Buff,ADc_temp);  
  46.   }
  47.   strcat(ADc_Buff,"\r\n");
  48.   mf_lseek(mf_size());                  //將指針定位于文件尾部，準備追加數(shù)據(jù)
  49.   mf_write(ADc_Buff,strlen(ADc_Buff));  //將接收到的數(shù)據(jù)存入文件
  50.   mf_sync();   
  51.   
  52.   delay_ms(2000);
  53.   memset(ADc_temp,0,20);
  54.   memset(ADc_Buff,0,200);
  55.    mf_close( );
  56. }
  57. }
  58. #include "sdio_sdcard.h"
  59. #include "string.h"  
  60.    

  62. /*用于sdio初始化的結(jié)構(gòu)體*/
  63. SDIO_InitTypeDef SDIO_InitStructure;
  64. SDIO_CmdInitTypeDef SDIO_CmdInitStructure;
  65. SDIO_DataInitTypeDef SDIO_DataInitStructure;   
  66. SD_Error CmdError(void);  
  67. SD_Error CmdResp7Error(void);
  68. SD_Error CmdResp1Error(u8 cmd);
  69. SD_Error CmdResp3Error(void);
  70. SD_Error CmdResp2Error(void);
  71. SD_Error CmdResp6Error(u8 cmd,u16*prca);  
  72. SD_Error SDEnWideBus(u8 enx);   
  73. SD_Error IsCardProgramming(u8 *pstatus);
  74. SD_Error FindSCR(u16 rca,u32 *pscr);
  75. u8 convert_from_bytes_to_power_of_two(u16 NumberOfBytes);

  77. static u8 CardType=SDIO_STD_CAPACITY_SD_CARD_V1_1;  //SD卡類型（默認為1.x卡）
  78. static u32 CSD_Tab[4],CID_Tab[4],RCA=0;     //SD卡CSD,CID以及相對地址(RCA)數(shù)據(jù)
  79. static u8 DeviceMode=SD_DMA_MODE;         //工作模式,注意,工作模式必須通過SD_SetDeviceMode,后才算數(shù).這里只是定義一個默認的模式(SD_DMA_MODE)
  80. static u8 StopCondition=0;         //是否發(fā)送停止傳輸標志位,DMA多塊讀寫的時候用到  
  81. volatile SD_Error TransferError=SD_OK;     //數(shù)據(jù)傳輸錯誤標志,DMA讀寫時使用     
  82. volatile u8 TransferEnd=0;        //傳輸結(jié)束標志,DMA讀寫時使用
  83. SD_CardInfo SDCardInfo; //SD卡信息
  84. //THUMB指令不支持匯編內(nèi)聯(lián)
  85. //采用如下方法實現(xiàn)執(zhí)行匯編指令WFI  
  86. __asm void WFI_SET(void)
  87. {
  88. WFI;   
  89. }
  90. //關閉所有中斷(但是不包括fault和NMI中斷)
  91. __asm void INTX_DISABLE(void)
  92. {
  93. CPSID   I
  94. BX      LR   
  95. }
  96. //開啟所有中斷
  97. __asm void INTX_ENABLE(void)
  98. {
  99. CPSIE   I
  100. BX      LR  
  101. }
  102. //設置棧頂?shù)刂?br />
  103. //addr:棧頂?shù)刂?br />
  104. __asm void MSR_MSP(u32 addr)
  105. {
  106. MSR MSP, r0    //set Main Stack value
  107. BX r14
  108. }
  109. //SD_ReadDisk/SD_WriteDisk函數(shù)專用buf,當這兩個函數(shù)的數(shù)據(jù)緩存區(qū)地址不是4字節(jié)對齊的時候,
  110. //需要用到該數(shù)組,確保數(shù)據(jù)緩存區(qū)地址是4字節(jié)對齊的.
  111. __align(4) u8 SDIO_DATA_BUFFER[512];        


  114. void SDIO_Register_Deinit()
  115. {
  116. SDIO->POWER=0x00000000;
  117. SDIO->CLKCR=0x00000000;
  118. SDIO->ARG=0x00000000;
  119. SDIO->CMD=0x00000000;
  120. SDIO->DTIMER=0x00000000;
  121. SDIO->DLEN=0x00000000;
  122. SDIO->DCTRL=0x00000000;
  123. SDIO->ICR=0x00C007FF;
  124. SDIO->MASK=0x00000000;  
  125. }
  126. //初始化SD卡
  127. //返回值:錯誤代碼;(0,無錯誤)
  128. SD_Error SD_Init(void)
  129. {
  130.   GPIO_InitTypeDef  GPIO_InitStructure;
  131. NVIC_InitTypeDef NVIC_InitStructure;

  133. SD_Error errorstatus=SD_OK;  
  134.   

  136.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOD|RCC_AHB1Periph_DMA2, ENABLE);//使能GPIOC,GPIOD DMA2時鐘

  138.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SDIO, ENABLE);//SDIO時鐘使能

  140. RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO, ENABLE);//SDIO復位


  143.   GPIO_InitStructure.GPIO_Pin =GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12;  //PC8,9,10,11,12復用功能輸出
  144.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;//復用功能
  145.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//100M
  146.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  147.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;//上拉
  148.   GPIO_Init(GPIOC, &GPIO_InitStructure);// PC8,9,10,11,12復用功能輸出

  150. GPIO_InitStructure.GPIO_Pin =GPIO_Pin_2;
  151.   GPIO_Init(GPIOD, &GPIO_InitStructure);//PD2復用功能輸出

  153.   //引腳復用映射設置
  154. GPIO_PinAFConfig(GPIOC,GPIO_PinSource8,GPIO_AF_SDIO); //PC8,AF12
  155.   GPIO_PinAFConfig(GPIOC,GPIO_PinSource9,GPIO_AF_SDIO);
  156.   GPIO_PinAFConfig(GPIOC,GPIO_PinSource10,GPIO_AF_SDIO);
  157.   GPIO_PinAFConfig(GPIOC,GPIO_PinSource11,GPIO_AF_SDIO);
  158.   GPIO_PinAFConfig(GPIOC,GPIO_PinSource12,GPIO_AF_SDIO);
  159.   GPIO_PinAFConfig(GPIOD,GPIO_PinSource2,GPIO_AF_SDIO);

  161. RCC_APB2PeriphResetCmd(RCC_APB2Periph_SDIO, DISABLE);//SDIO結(jié)束復位
  162.   
  163.   //SDIO外設寄存器設置為默認值      
  164. SDIO_Register_Deinit();

  166.   NVIC_InitStructure.NVIC_IRQChannel = SDIO_IRQn;
  167. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;//搶占優(yōu)先級3
  168. NVIC_InitStructure.NVIC_IRQChannelSubPriority =0;  //子優(yōu)先級3
  169. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;   //IRQ通道使能
  170. NVIC_Init(&NVIC_InitStructure); //根據(jù)指定的參數(shù)初始化VIC寄存器、

  172.     errorstatus=SD_PowerON();   //SD卡上電
  173.   if(errorstatus==SD_OK)errorstatus=SD_InitializeCards();   //初始化SD卡               
  174.    if(errorstatus==SD_OK)errorstatus=SD_GetCardInfo(&SDCardInfo); //獲取卡信息
  175.   if(errorstatus==SD_OK)errorstatus=SD_SelectDeselect((u32)(SDCardInfo.RCA<<16));//選中SD卡   
  176.     if(errorstatus==SD_OK)errorstatus=SD_EnableWideBusOperation(SDIO_BusWide_4b); //4位寬度,如果是MMC卡,則不能用4位模式
  177.    if((errorstatus==SD_OK)||(SDIO_MULTIMEDIA_CARD==CardType))
  178. {        
  179.   SDIO_Clock_Set(SDIO_TRANSFER_CLK_DIV);   //設置時鐘頻率,SDIO時鐘計算公式:SDIO_CK時鐘=SDIOCLK/[clkdiv+2];其中,SDIOCLK固定為48Mhz
  180.   //errorstatus=SD_SetDeviceMode(SD_DMA_MODE); //設置為DMA模式
  181.   errorstatus=SD_SetDeviceMode(SD_POLLING_MODE);//設置為查詢模式
  182.   }
  183. return errorstatus;   
  184. }
  185. //SDIO時鐘初始化設置
  186. //clkdiv:時鐘分頻系數(shù)
  187. //CK時鐘=SDIOCLK/[clkdiv+2];(SDIOCLK時鐘固定為48Mhz)
  188. void SDIO_Clock_Set(u8 clkdiv)
  189. {
  190. u32 tmpreg=SDIO->CLKCR;
  191.    tmpreg&=0XFFFFFF00;
  192.   tmpreg|=clkdiv;   
  193. SDIO->CLKCR=tmpreg;
  194. }

  196. //卡上電
  197. //查詢所有SDIO接口上的卡設備,并查詢其電壓和配置時鐘
  198. //返回值:錯誤代碼;(0,無錯誤)
  199. SD_Error SD_PowerON(void)
  200. {
  201.   u8 i=0;
  202. SD_Error errorstatus=SD_OK;
  203. u32 response=0,count=0,validvoltage=0;
  204. u32 SDType=SD_STD_CAPACITY;

  206.   /*初始化時的時鐘不能大于400KHz*/
  207.   SDIO_InitStructure.SDIO_ClockDiv = SDIO_INIT_CLK_DIV; /* HCLK = 72MHz, SDIOCLK = 72MHz, SDIO_CK = HCLK/(178 + 2) = 400 KHz */
  208.   SDIO_InitStructure.SDIO_ClockEdge = SDIO_ClockEdge_Rising;
  209.   SDIO_InitStructure.SDIO_ClockBypass = SDIO_ClockBypass_Disable;  //不使用bypass模式，直接用HCLK進行分頻得到SDIO_CK
  210.   SDIO_InitStructure.SDIO_ClockPowerSave = SDIO_ClockPowerSave_Disable; // 空閑時不關閉時鐘電源
  211.   SDIO_InitStructure.SDIO_BusWide = SDIO_BusWide_1b;      //1位數(shù)據(jù)線
  212.   SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;//硬件流
  213.   SDIO_Init(&SDIO_InitStructure);
  214. SDIO_SetPowerState(SDIO_PowerState_ON); //上電狀態(tài),開啟卡時鐘   
  215.   SDIO->CLKCR|=1<<8;   //SDIOCK使能  

  217.   for(i=0;i<74;i++)
  218. {

  220.   SDIO_CmdInitStructure.SDIO_Argument = 0x0;//發(fā)送CMD0進入IDLE STAGE模式命令.
  221.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_GO_IDLE_STATE; //cmd0
  222.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_No;  //無響應
  223.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  224.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;  //則CPSM在開始發(fā)送命令之前等待數(shù)據(jù)傳輸結(jié)束。
  225.     SDIO_SendCommand(&SDIO_CmdInitStructure);     //寫命令進命令寄存器
  226.   
  227.   errorstatus=CmdError();
  228.   
  229.   if(errorstatus==SD_OK)break;
  230.   }
  231.   if(errorstatus)return errorstatus;//返回錯誤狀態(tài)

  233.   SDIO_CmdInitStructure.SDIO_Argument = SD_CHECK_PATTERN; //發(fā)送CMD8,短響應,檢查SD卡接口特性
  234.   SDIO_CmdInitStructure.SDIO_CmdIndex = SDIO_SEND_IF_COND; //cmd8
  235.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;  //r7
  236.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;    //關閉等待中斷
  237.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  238.   SDIO_SendCommand(&SDIO_CmdInitStructure);

  240.   errorstatus=CmdResp7Error();      //等待R7響應

  242.   if(errorstatus==SD_OK)         //R7響應正常
  243. {
  244.   CardType=SDIO_STD_CAPACITY_SD_CARD_V2_0;  //SD 2.0卡
  245.   SDType=SD_HIGH_CAPACITY;         //高容量卡
  246. }
  247.    
  248.    SDIO_CmdInitStructure.SDIO_Argument = 0x00;//發(fā)送CMD55,短響應
  249.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
  250.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  251.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  252.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  253.     SDIO_SendCommand(&SDIO_CmdInitStructure);  //發(fā)送CMD55,短響應  

  255.   errorstatus=CmdResp1Error(SD_CMD_APP_CMD);     //等待R1響應   

  257. if(errorstatus==SD_OK)//SD2.0/SD 1.1,否則為MMC卡
  258. {                  
  259.   //SD卡,發(fā)送ACMD41 SD_APP_OP_COND,參數(shù)為:0x80100000
  260.   while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL))
  261.   {                 
  262.     SDIO_CmdInitStructure.SDIO_Argument = 0x00;//發(fā)送CMD55,短響應
  263.       SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;   //CMD55
  264.       SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  265.       SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  266.       SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  267.       SDIO_SendCommand(&SDIO_CmdInitStructure);   //發(fā)送CMD55,短響應  
  268.    
  269.    errorstatus=CmdResp1Error(SD_CMD_APP_CMD);    //等待R1響應  
  270.    
  271.     if(errorstatus!=SD_OK)return errorstatus;    //響應錯誤
  272.       //acmd41，命令參數(shù)由支持的電壓范圍及HCS位組成，HCS位置一來區(qū)分卡是SDSc還是sdhc
  273.       SDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_SD | SDType; //發(fā)送ACMD41,短響應
  274.       SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_OP_COND;
  275.       SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;  //r3
  276.       SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  277.       SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  278.       SDIO_SendCommand(&SDIO_CmdInitStructure);
  279.    
  280.    errorstatus=CmdResp3Error();      //等待R3響應   
  281.    
  282.     if(errorstatus!=SD_OK)return errorstatus;    //響應錯誤
  283.    response=SDIO->RESP1;;          //得到響應
  284.    validvoltage=(((response>>31)==1)?1:0);   //判斷SD卡上電是否完成
  285.    count++;
  286.   }
  287.   if(count>=SD_MAX_VOLT_TRIAL)
  288.   {
  289.    errorstatus=SD_INVALID_VOLTRANGE;
  290.    return errorstatus;
  291.   }  
  292.   if(response&=SD_HIGH_CAPACITY)
  293.   {
  294.    CardType=SDIO_HIGH_CAPACITY_SD_CARD;
  295.   }
  296.   }else//MMC卡
  297. {
  298.   //MMC卡,發(fā)送CMD1 SDIO_SEND_OP_COND,參數(shù)為:0x80FF8000
  299.   while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL))
  300.   {                        
  301.    SDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_MMC;//發(fā)送CMD1,短響應   
  302.       SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_OP_COND;
  303.       SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;  //r3
  304.       SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  305.       SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  306.       SDIO_SendCommand(&SDIO_CmdInitStructure);
  307.    
  308.    errorstatus=CmdResp3Error();      //等待R3響應   
  309.    
  310.     if(errorstatus!=SD_OK)return errorstatus;    //響應錯誤  
  311.    response=SDIO->RESP1;;          //得到響應
  312.    validvoltage=(((response>>31)==1)?1:0);
  313.    count++;
  314.   }
  315.   if(count>=SD_MAX_VOLT_TRIAL)
  316.   {
  317.    errorstatus=SD_INVALID_VOLTRANGE;
  318.    return errorstatus;
  319.   }         
  320.   CardType=SDIO_MULTIMEDIA_CARD;   
  321.    }  
  322.    return(errorstatus);  
  323. }
  324. //SD卡 Power OFF
  325. //返回值:錯誤代碼;(0,無錯誤)
  326. SD_Error SD_PowerOFF(void)
  327. {

  329.   SDIO_SetPowerState(SDIO_PowerState_OFF);//SDIO電源關閉,時鐘停止
  330.   return SD_OK;   
  331. }   
  332. //初始化所有的卡,并讓卡進入就緒狀態(tài)
  333. //返回值:錯誤代碼
  334. SD_Error SD_InitializeCards(void)
  335. {
  336.   SD_Error errorstatus=SD_OK;
  337. u16 rca = 0x01;

  339.   if (SDIO_GetPowerState() == SDIO_PowerState_OFF) //檢查電源狀態(tài),確保為上電狀態(tài)
  340.   {
  341.     errorstatus = SD_REQUEST_NOT_APPLICABLE;
  342.     return(errorstatus);
  343.   }
  344.   if(SDIO_SECURE_DIGITAL_IO_CARD!=CardType)   //非SECURE_DIGITAL_IO_CARD
  345. {
  346.   SDIO_CmdInitStructure.SDIO_Argument = 0x0;//發(fā)送CMD2,取得CID,長響應
  347.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_ALL_SEND_CID;
  348.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Long;
  349.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  350.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  351.     SDIO_SendCommand(&SDIO_CmdInitStructure);//發(fā)送CMD2,取得CID,長響應
  352.   
  353.   errorstatus=CmdResp2Error();      //等待R2響應
  354.   
  355.   if(errorstatus!=SD_OK)return errorstatus;    //響應錯誤   
  356.   
  357.    CID_Tab[0]=SDIO->RESP1;
  358.   CID_Tab[1]=SDIO->RESP2;
  359.   CID_Tab[2]=SDIO->RESP3;
  360.   CID_Tab[3]=SDIO->RESP4;
  361. }
  362. 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))//判斷卡類型
  363. {
  364.   SDIO_CmdInitStructure.SDIO_Argument = 0x00;//發(fā)送CMD3,短響應
  365.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_REL_ADDR; //cmd3
  366.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r6
  367.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  368.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  369.     SDIO_SendCommand(&SDIO_CmdInitStructure); //發(fā)送CMD3,短響應
  370.   
  371.   errorstatus=CmdResp6Error(SD_CMD_SET_REL_ADDR,&rca);//等待R6響應
  372.   
  373.   if(errorstatus!=SD_OK)return errorstatus;    //響應錯誤      
  374. }   
  375.     if (SDIO_MULTIMEDIA_CARD==CardType)
  376.     {
  377.     SDIO_CmdInitStructure.SDIO_Argument = (u32)(rca<<16);//發(fā)送CMD3,短響應
  378.       SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_REL_ADDR; //cmd3
  379.       SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short; //r6
  380.       SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  381.       SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  382.       SDIO_SendCommand(&SDIO_CmdInitStructure); //發(fā)送CMD3,短響應  
  383.    
  384.       errorstatus=CmdResp2Error();      //等待R2響應   
  385.    
  386.     if(errorstatus!=SD_OK)return errorstatus;    //響應錯誤  
  387.     }
  388. if (SDIO_SECURE_DIGITAL_IO_CARD!=CardType)   //非SECURE_DIGITAL_IO_CARD
  389. {
  390.   RCA = rca;
  391.   
  392.     SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)(rca << 16);//發(fā)送CMD9+卡RCA,取得CSD,長響應
  393.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_CSD;
  394.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Long;
  395.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  396.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  397.     SDIO_SendCommand(&SDIO_CmdInitStructure);
  398.   
  399.   errorstatus=CmdResp2Error();      //等待R2響應   
  400.   if(errorstatus!=SD_OK)return errorstatus;    //響應錯誤      
  401.    
  402.   CSD_Tab[0]=SDIO->RESP1;
  403.    CSD_Tab[1]=SDIO->RESP2;
  404.   CSD_Tab[2]=SDIO->RESP3;      
  405.   CSD_Tab[3]=SDIO->RESP4;         
  406. }
  407. return SD_OK;//卡初始化成功
  408. }
  409. //得到卡信息
  410. //cardinfo:卡信息存儲區(qū)
  411. //返回值:錯誤狀態(tài)
  412. SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo)
  413. {
  414.   SD_Error errorstatus=SD_OK;
  415. u8 tmp=0;   
  416. cardinfo->CardType=(u8)CardType;     //卡類型
  417. cardinfo->RCA=(u16)RCA;       //卡RCA值
  418. tmp=(u8)((CSD_Tab[0]&0xFF000000)>>24);
  419. cardinfo->SD_csd.CSDStruct=(tmp&0xC0)>>6;  //CSD結(jié)構(gòu)
  420. cardinfo->SD_csd.SysSpecVersion=(tmp&0x3C)>>2; //2.0協(xié)議還沒定義這部分(為保留),應該是后續(xù)協(xié)議定義的
  421. cardinfo->SD_csd.Reserved1=tmp&0x03;   //2個保留位  
  422. tmp=(u8)((CSD_Tab[0]&0x00FF0000)>>16);   //第1個字節(jié)
  423. cardinfo->SD_csd.TAAC=tmp;         //數(shù)據(jù)讀時間1
  424. tmp=(u8)((CSD_Tab[0]&0x0000FF00)>>8);     //第2個字節(jié)
  425. cardinfo->SD_csd.NSAC=tmp;        //數(shù)據(jù)讀時間2
  426. tmp=(u8)(CSD_Tab[0]&0x000000FF);    //第3個字節(jié)
  427. cardinfo->SD_csd.MaxBusClkFrec=tmp;      //傳輸速度   
  428. tmp=(u8)((CSD_Tab[1]&0xFF000000)>>24);   //第4個字節(jié)
  429. cardinfo->SD_csd.CardComdClasses=tmp<<4;     //卡指令類高四位
  430. tmp=(u8)((CSD_Tab[1]&0x00FF0000)>>16);    //第5個字節(jié)
  431. cardinfo->SD_csd.CardComdClasses|=(tmp&0xF0)>>4;//卡指令類低四位
  432. cardinfo->SD_csd.RdBlockLen=tmp&0x0F;      //最大讀取數(shù)據(jù)長度
  433. tmp=(u8)((CSD_Tab[1]&0x0000FF00)>>8);   //第6個字節(jié)
  434. cardinfo->SD_csd.PartBlockRead=(tmp&0x80)>>7; //允許分塊讀
  435. cardinfo->SD_csd.WrBlockMisalign=(tmp&0x40)>>6; //寫塊錯位
  436. cardinfo->SD_csd.RdBlockMisalign=(tmp&0x20)>>5; //讀塊錯位
  437. cardinfo->SD_csd.DSRImpl=(tmp&0x10)>>4;
  438. cardinfo->SD_csd.Reserved2=0;      //保留
  439.   if((CardType==SDIO_STD_CAPACITY_SD_CARD_V1_1)||(CardType==SDIO_STD_CAPACITY_SD_CARD_V2_0)||(SDIO_MULTIMEDIA_CARD==CardType))//標準1.1/2.0卡/MMC卡
  440. {
  441.   cardinfo->SD_csd.DeviceSize=(tmp&0x03)<<10; //C_SIZE(12位)
  442.    tmp=(u8)(CSD_Tab[1]&0x000000FF);    //第7個字節(jié)
  443.   cardinfo->SD_csd.DeviceSize|=(tmp)<<2;
  444.    tmp=(u8)((CSD_Tab[2]&0xFF000000)>>24);  //第8個字節(jié)
  445.   cardinfo->SD_csd.DeviceSize|=(tmp&0xC0)>>6;
  446.    cardinfo->SD_csd.MaxRdCurrentVDDMin=(tmp&0x38)>>3;
  447.   cardinfo->SD_csd.MaxRdCurrentVDDMax=(tmp&0x07);
  448.    tmp=(u8)((CSD_Tab[2]&0x00FF0000)>>16);  //第9個字節(jié)
  449.   cardinfo->SD_csd.MaxWrCurrentVDDMin=(tmp&0xE0)>>5;
  450.   cardinfo->SD_csd.MaxWrCurrentVDDMax=(tmp&0x1C)>>2;
  451.   cardinfo->SD_csd.DeviceSizeMul=(tmp&0x03)<<1;//C_SIZE_MULT
  452.    tmp=(u8)((CSD_Tab[2]&0x0000FF00)>>8);    //第10個字節(jié)
  453.   cardinfo->SD_csd.DeviceSizeMul|=(tmp&0x80)>>7;
  454.    cardinfo->CardCapacity=(cardinfo->SD_csd.DeviceSize+1);//計算卡容量
  455.   cardinfo->CardCapacity*=(1<<(cardinfo->SD_csd.DeviceSizeMul+2));
  456.   cardinfo->CardBlockSize=1<<(cardinfo->SD_csd.RdBlockLen);//塊大小
  457.   cardinfo->CardCapacity*=cardinfo->CardBlockSize;
  458. }else if(CardType==SDIO_HIGH_CAPACITY_SD_CARD) //高容量卡
  459. {
  460.    tmp=(u8)(CSD_Tab[1]&0x000000FF);   //第7個字節(jié)
  461.   cardinfo->SD_csd.DeviceSize=(tmp&0x3F)<<16;//C_SIZE
  462.    tmp=(u8)((CSD_Tab[2]&0xFF000000)>>24);  //第8個字節(jié)
  463.    cardinfo->SD_csd.DeviceSize|=(tmp<<8);
  464.    tmp=(u8)((CSD_Tab[2]&0x00FF0000)>>16); //第9個字節(jié)
  465.    cardinfo->SD_csd.DeviceSize|=(tmp);
  466.    tmp=(u8)((CSD_Tab[2]&0x0000FF00)>>8);  //第10個字節(jié)
  467.    cardinfo->CardCapacity=(long long)(cardinfo->SD_csd.DeviceSize+1)*512*1024;//計算卡容量
  468.   cardinfo->CardBlockSize=512;    //塊大小固定為512字節(jié)
  469. }   
  470. cardinfo->SD_csd.EraseGrSize=(tmp&0x40)>>6;
  471. cardinfo->SD_csd.EraseGrMul=(tmp&0x3F)<<1;   
  472. tmp=(u8)(CSD_Tab[2]&0x000000FF);   //第11個字節(jié)
  473. cardinfo->SD_csd.EraseGrMul|=(tmp&0x80)>>7;
  474. cardinfo->SD_csd.WrProtectGrSize=(tmp&0x7F);
  475.   tmp=(u8)((CSD_Tab[3]&0xFF000000)>>24);  //第12個字節(jié)
  476. cardinfo->SD_csd.WrProtectGrEnable=(tmp&0x80)>>7;
  477. cardinfo->SD_csd.ManDeflECC=(tmp&0x60)>>5;
  478. cardinfo->SD_csd.WrSpeedFact=(tmp&0x1C)>>2;
  479. cardinfo->SD_csd.MaxWrBlockLen=(tmp&0x03)<<2;  
  480. tmp=(u8)((CSD_Tab[3]&0x00FF0000)>>16);  //第13個字節(jié)
  481. cardinfo->SD_csd.MaxWrBlockLen|=(tmp&0xC0)>>6;
  482. cardinfo->SD_csd.WriteBlockPaPartial=(tmp&0x20)>>5;
  483. cardinfo->SD_csd.Reserved3=0;
  484. cardinfo->SD_csd.ContentProtectAppli=(tmp&0x01);  
  485. tmp=(u8)((CSD_Tab[3]&0x0000FF00)>>8);  //第14個字節(jié)
  486. cardinfo->SD_csd.FileFormatGrouop=(tmp&0x80)>>7;
  487. cardinfo->SD_csd.CopyFlag=(tmp&0x40)>>6;
  488. cardinfo->SD_csd.PermWrProtect=(tmp&0x20)>>5;
  489. cardinfo->SD_csd.TempWrProtect=(tmp&0x10)>>4;
  490. cardinfo->SD_csd.FileFormat=(tmp&0x0C)>>2;
  491. cardinfo->SD_csd.ECC=(tmp&0x03);  
  492. tmp=(u8)(CSD_Tab[3]&0x000000FF);   //第15個字節(jié)
  493. cardinfo->SD_csd.CSD_CRC=(tmp&0xFE)>>1;
  494. cardinfo->SD_csd.Reserved4=1;   
  495. tmp=(u8)((CID_Tab[0]&0xFF000000)>>24);  //第0個字節(jié)
  496. cardinfo->SD_cid.ManufacturerID=tmp;      
  497. tmp=(u8)((CID_Tab[0]&0x00FF0000)>>16);  //第1個字節(jié)
  498. cardinfo->SD_cid.OEM_AppliID=tmp<<8;   
  499. tmp=(u8)((CID_Tab[0]&0x000000FF00)>>8);  //第2個字節(jié)
  500. cardinfo->SD_cid.OEM_AppliID|=tmp;     
  501. tmp=(u8)(CID_Tab[0]&0x000000FF);   //第3個字節(jié)
  502. cardinfo->SD_cid.ProdName1=tmp<<24;      
  503. tmp=(u8)((CID_Tab[1]&0xFF000000)>>24);   //第4個字節(jié)
  504. cardinfo->SD_cid.ProdName1|=tmp<<16;   
  505. tmp=(u8)((CID_Tab[1]&0x00FF0000)>>16);     //第5個字節(jié)
  506. cardinfo->SD_cid.ProdName1|=tmp<<8;   
  507. tmp=(u8)((CID_Tab[1]&0x0000FF00)>>8);  //第6個字節(jié)
  508. cardinfo->SD_cid.ProdName1|=tmp;     
  509. tmp=(u8)(CID_Tab[1]&0x000000FF);     //第7個字節(jié)
  510. cardinfo->SD_cid.ProdName2=tmp;     
  511. tmp=(u8)((CID_Tab[2]&0xFF000000)>>24);   //第8個字節(jié)
  512. cardinfo->SD_cid.ProdRev=tmp;   
  513. tmp=(u8)((CID_Tab[2]&0x00FF0000)>>16);  //第9個字節(jié)
  514. cardinfo->SD_cid.ProdSN=tmp<<24;   
  515. tmp=(u8)((CID_Tab[2]&0x0000FF00)>>8);   //第10個字節(jié)
  516. cardinfo->SD_cid.ProdSN|=tmp<<16;   
  517. tmp=(u8)(CID_Tab[2]&0x000000FF);      //第11個字節(jié)
  518. cardinfo->SD_cid.ProdSN|=tmp<<8;     
  519. tmp=(u8)((CID_Tab[3]&0xFF000000)>>24);   //第12個字節(jié)
  520. cardinfo->SD_cid.ProdSN|=tmp;        
  521. tmp=(u8)((CID_Tab[3]&0x00FF0000)>>16);   //第13個字節(jié)
  522. cardinfo->SD_cid.Reserved1|=(tmp&0xF0)>>4;
  523. cardinfo->SD_cid.ManufactDate=(tmp&0x0F)<<8;   
  524. tmp=(u8)((CID_Tab[3]&0x0000FF00)>>8);  //第14個字節(jié)
  525. cardinfo->SD_cid.ManufactDate|=tmp;      
  526. tmp=(u8)(CID_Tab[3]&0x000000FF);   //第15個字節(jié)
  527. cardinfo->SD_cid.CID_CRC=(tmp&0xFE)>>1;
  528. cardinfo->SD_cid.Reserved2=1;  
  529. return errorstatus;
  530. }
  531. //設置SDIO總線寬度(MMC卡不支持4bit模式)
  532. //wmode:位寬模式.0,1位數(shù)據(jù)寬度;1,4位數(shù)據(jù)寬度;2,8位數(shù)據(jù)寬度
  533. //返回值:SD卡錯誤狀態(tài)
  534. //設置SDIO總線寬度(MMC卡不支持4bit模式)
  535. //   @arg SDIO_BusWide_8b: 8-bit data transfer (Only for MMC)
  536. //   @arg SDIO_BusWide_4b: 4-bit data transfer
  537. //   @arg SDIO_BusWide_1b: 1-bit data transfer (默認)
  538. //返回值:SD卡錯誤狀態(tài)

  540. SD_Error SD_EnableWideBusOperation(u32 WideMode)
  541. {
  542.    SD_Error errorstatus=SD_OK;
  543.   if (SDIO_MULTIMEDIA_CARD == CardType)
  544.   {
  545.     errorstatus = SD_UNSUPPORTED_FEATURE;
  546.     return(errorstatus);
  547.   }

  549.   else if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
  550. {
  551.    if (SDIO_BusWide_8b == WideMode)   //2.0 sd不支持8bits
  552.     {
  553.       errorstatus = SD_UNSUPPORTED_FEATURE;
  554.       return(errorstatus);
  555.     }
  556.    else   
  557.   {
  558.    errorstatus=SDEnWideBus(WideMode);
  559.     if(SD_OK==errorstatus)
  560.    {
  561.     SDIO->CLKCR&=~(3<<11);  //清除之前的位寬設置   
  562.     SDIO->CLKCR|=WideMode;//1位/4位總線寬度
  563.     SDIO->CLKCR|=0<<14;   //不開啟硬件流控制
  564.    }
  565.   }  
  566. }
  567. return errorstatus;
  568. }
  569. //設置SD卡工作模式
  570. //Mode:
  571. //返回值:錯誤狀態(tài)
  572. SD_Error SD_SetDeviceMode(u32 Mode)
  573. {
  574. SD_Error errorstatus = SD_OK;
  575.   if((Mode==SD_DMA_MODE)||(Mode==SD_POLLING_MODE))DeviceMode=Mode;
  576. else errorstatus=SD_INVALID_PARAMETER;
  577. return errorstatus;     
  578. }
  579. //選卡
  580. //發(fā)送CMD7,選擇相對地址(rca)為addr的卡,取消其他卡.如果為0,則都不選擇.
  581. //addr:卡的RCA地址
  582. SD_Error SD_SelectDeselect(u32 addr)
  583. {
  584.   SDIO_CmdInitStructure.SDIO_Argument =  addr;//發(fā)送CMD7,選擇卡,短響應
  585.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEL_DESEL_CARD;
  586.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  587.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  588.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  589.   SDIO_SendCommand(&SDIO_CmdInitStructure);//發(fā)送CMD7,選擇卡,短響應

  591.   return CmdResp1Error(SD_CMD_SEL_DESEL_CARD);   
  592. }
  593. //SD卡讀取一個塊
  594. //buf:讀數(shù)據(jù)緩存區(qū)(必須4字節(jié)對齊!!)
  595. //addr:讀取地址
  596. //blksize:塊大小
  597. SD_Error SD_ReadBlock(u8 *buf,long long addr,u16 blksize)
  598. {   
  599. SD_Error errorstatus=SD_OK;
  600. u8 power;
  601.   u32 count=0,*tempbuff=(u32*)buf;//轉(zhuǎn)換為u32指針
  602. u32 timeout=SDIO_DATATIMEOUT;   
  603.   if(NULL==buf)
  604.   return SD_INVALID_PARAMETER;
  605.   SDIO->DCTRL=0x0; //數(shù)據(jù)控制寄存器清零(關DMA)
  606.   
  607. if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡
  608. {
  609.   blksize=512;
  610.   addr>>=9;
  611. }   
  612.    SDIO_DataInitStructure.SDIO_DataBlockSize= SDIO_DataBlockSize_1b ;//清除DPSM狀態(tài)機配置
  613.    SDIO_DataInitStructure.SDIO_DataLength= 0 ;
  614.    SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  615.    SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  616.    SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
  617.    SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  618.     SDIO_DataConfig(&SDIO_DataInitStructure);


  621. if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
  622. if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
  623. {
  624.   power=convert_from_bytes_to_power_of_two(blksize);
  625.   
  626.    
  627.   SDIO_CmdInitStructure.SDIO_Argument =  blksize;
  628.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
  629.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  630.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  631.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  632.     SDIO_SendCommand(&SDIO_CmdInitStructure);//發(fā)送CMD16+設置數(shù)據(jù)長度為blksize,短響應
  633.   
  634.   
  635.   errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1響應
  636.   
  637.   if(errorstatus!=SD_OK)return errorstatus;    //響應錯誤
  638.   
  639. }else return SD_INVALID_PARAMETER;     

  641.    SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4 ;//清除DPSM狀態(tài)機配置
  642.    SDIO_DataInitStructure.SDIO_DataLength= blksize ;
  643.    SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  644.    SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  645.    SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToSDIO;
  646.    SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  647.     SDIO_DataConfig(&SDIO_DataInitStructure);

  649.    SDIO_CmdInitStructure.SDIO_Argument =  addr;
  650.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_READ_SINGLE_BLOCK;
  651.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  652.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  653.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  654.     SDIO_SendCommand(&SDIO_CmdInitStructure);//發(fā)送CMD17+從addr地址出讀取數(shù)據(jù),短響應

  656. errorstatus=CmdResp1Error(SD_CMD_READ_SINGLE_BLOCK);//等待R1響應   
  657. if(errorstatus!=SD_OK)return errorstatus;     //響應錯誤  
  658.   if(DeviceMode==SD_POLLING_MODE)      //查詢模式,輪詢數(shù)據(jù)  
  659. {
  660.    INTX_DISABLE();//關閉總中斷(POLLING模式,嚴禁中斷打斷SDIO讀寫操作!!!)
  661.   while(!(SDIO->STA&((1<<5)|(1<<1)|(1<<3)|(1<<10)|(1<<9))))//無上溢/CRC/超時/完成(標志)/起始位錯誤
  662.   {
  663.    if(SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET)      //接收區(qū)半滿,表示至少存了8個字
  664.    {
  665.     for(count=0;count<8;count++)   //循環(huán)讀取數(shù)據(jù)
  666.     {
  667.      *(tempbuff+count)=SDIO->FIFO;
  668.     }
  669.     tempbuff+=8;  
  670.     timeout=0X7FFFFF;  //讀數(shù)據(jù)溢出時間
  671.    }else  //處理超時
  672.    {
  673.     if(timeout==0)return SD_DATA_TIMEOUT;
  674.     timeout--;
  675.    }
  676.   }
  677.   if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)  //數(shù)據(jù)超時錯誤
  678.   {            
  679.     SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);  //清錯誤標志
  680.    return SD_DATA_TIMEOUT;
  681.    }else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //數(shù)據(jù)塊CRC錯誤
  682.   {
  683.     SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);    //清錯誤標志
  684.    return SD_DATA_CRC_FAIL;     
  685.   }else if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET)  //接收fifo上溢錯誤
  686.   {
  687.     SDIO_ClearFlag(SDIO_FLAG_RXOVERR);  //清錯誤標志
  688.    return SD_RX_OVERRUN;   
  689.   }else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)  //接收起始位錯誤
  690.   {
  691.     SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清錯誤標志
  692.    return SD_START_BIT_ERR;   
  693.   }   
  694.   while(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET) //FIFO里面,還存在可用數(shù)據(jù)
  695.   {
  696.    *tempbuff=SDIO->FIFO; //循環(huán)讀取數(shù)據(jù)
  697.    tempbuff++;
  698.   }
  699.   INTX_ENABLE();//開啟總中斷
  700.   SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
  701.   
  702. }else if(DeviceMode==SD_DMA_MODE)
  703. {
  704.    TransferError=SD_OK;
  705.   StopCondition=0;   //單塊讀,不需要發(fā)送停止傳輸指令
  706.   TransferEnd=0;    //傳輸結(jié)束標置位，在中斷服務置1
  707.   SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<5)|(1<<9); //配置需要的中斷
  708.    SDIO->DCTRL|=1<<3;    //SDIO DMA使能
  709.       SD_DMA_Config((u32*)buf,blksize,DMA_DIR_PeripheralToMemory);
  710.    while(((DMA2->LISR&(1<<27))==RESET)&&(TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;//等待傳輸完成
  711.   if(timeout==0)return SD_DATA_TIMEOUT;//超時
  712.   if(TransferError!=SD_OK)errorstatus=TransferError;  
  713.     }   
  714.   return errorstatus;
  715. }
  716. //SD卡讀取多個塊
  717. //buf:讀數(shù)據(jù)緩存區(qū)
  718. //addr:讀取地址
  719. //blksize:塊大小
  720. //nblks:要讀取的塊數(shù)
  721. //返回值:錯誤狀態(tài)
  722. __align(4) u32 *tempbuff;
  723. SD_Error SD_ReadMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks)
  724. {
  725.   SD_Error errorstatus=SD_OK;
  726. u8 power;
  727.   u32 count=0;
  728. u32 timeout=SDIO_DATATIMEOUT;  
  729. tempbuff=(u32*)buf;//轉(zhuǎn)換為u32指針

  731.   SDIO->DCTRL=0x0;  //數(shù)據(jù)控制寄存器清零(關DMA)   
  732. if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡
  733. {
  734.   blksize=512;
  735.   addr>>=9;
  736. }  

  738.    SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ;//清除DPSM狀態(tài)機配置
  739.    SDIO_DataInitStructure.SDIO_DataLength= 0 ;
  740.    SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  741.    SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  742.    SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
  743.    SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  744.     SDIO_DataConfig(&SDIO_DataInitStructure);

  746. if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
  747. if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
  748. {
  749.   power=convert_from_bytes_to_power_of_two(blksize);     
  750.   
  751.    SDIO_CmdInitStructure.SDIO_Argument =  blksize;//發(fā)送CMD16+設置數(shù)據(jù)長度為blksize,短響應
  752.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
  753.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  754.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  755.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  756.   SDIO_SendCommand(&SDIO_CmdInitStructure);
  757.   
  758.   errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1響應  
  759.   
  760.   if(errorstatus!=SD_OK)return errorstatus;    //響應錯誤  
  761.   
  762. }else return SD_INVALID_PARAMETER;   

  764. if(nblks>1)           //多塊讀  
  765. {            
  766.      if(nblks*blksize>SD_MAX_DATA_LENGTH)return SD_INVALID_PARAMETER;//判斷是否超過最大接收長度
  767.   
  768.      SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4; ;//nblks*blksize,512塊大小,卡到控制器
  769.     SDIO_DataInitStructure.SDIO_DataLength= nblks*blksize ;
  770.     SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  771.     SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  772.     SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToSDIO;
  773.     SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  774.     SDIO_DataConfig(&SDIO_DataInitStructure);
  775.        SDIO_CmdInitStructure.SDIO_Argument =  addr;//發(fā)送CMD18+從addr地址出讀取數(shù)據(jù),短響應
  776.       SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_READ_MULT_BLOCK;
  777.      SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  778.      SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  779.      SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  780.      SDIO_SendCommand(&SDIO_CmdInitStructure);
  781.   
  782.   errorstatus=CmdResp1Error(SD_CMD_READ_MULT_BLOCK);//等待R1響應
  783.   
  784.   if(errorstatus!=SD_OK)return errorstatus;    //響應錯誤  
  785.   
  786.    if(DeviceMode==SD_POLLING_MODE)
  787.   {
  788.    INTX_DISABLE();//關閉總中斷(POLLING模式,嚴禁中斷打斷SDIO讀寫操作!!!)
  789.    while(!(SDIO->STA&((1<<5)|(1<<1)|(1<<3)|(1<<8)|(1<<9))))//無上溢/CRC/超時/完成(標志)/起始位錯誤
  790.    {
  791.     if(SDIO_GetFlagStatus(SDIO_FLAG_RXFIFOHF) != RESET)      //接收區(qū)半滿,表示至少存了8個字
  792.     {
  793.      for(count=0;count<8;count++)   //循環(huán)讀取數(shù)據(jù)
  794.      {
  795.       *(tempbuff+count)=SDIO->FIFO;
  796.      }
  797.      tempbuff+=8;  
  798.      timeout=0X7FFFFF;  //讀數(shù)據(jù)溢出時間
  799.     }else  //處理超時
  800.     {
  801.      if(timeout==0)return SD_DATA_TIMEOUT;
  802.      timeout--;
  803.     }
  804.    }  
  805.   if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)  //數(shù)據(jù)超時錯誤
  806.   {            
  807.     SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);  //清錯誤標志
  808.    return SD_DATA_TIMEOUT;
  809.    }else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //數(shù)據(jù)塊CRC錯誤
  810.   {
  811.     SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);    //清錯誤標志
  812.    return SD_DATA_CRC_FAIL;     
  813.   }else if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET)  //接收fifo上溢錯誤
  814.   {
  815.     SDIO_ClearFlag(SDIO_FLAG_RXOVERR);  //清錯誤標志
  816.    return SD_RX_OVERRUN;   
  817.   }else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)  //接收起始位錯誤
  818.   {
  819.     SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清錯誤標志
  820.    return SD_START_BIT_ERR;   
  821.   }   
  822.      
  823.   while(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET) //FIFO里面,還存在可用數(shù)據(jù)
  824.   {
  825.    *tempbuff=SDIO->FIFO; //循環(huán)讀取數(shù)據(jù)
  826.    tempbuff++;
  827.   }
  828.     if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET)  //接收結(jié)束
  829.    {
  830.     if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
  831.     {   
  832.      SDIO_CmdInitStructure.SDIO_Argument =  0;//發(fā)送CMD12+結(jié)束傳輸
  833.       SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;
  834.      SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  835.      SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  836.      SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  837.      SDIO_SendCommand(&SDIO_CmdInitStructure);
  838.      
  839.      errorstatus=CmdResp1Error(SD_CMD_STOP_TRANSMISSION);//等待R1響應   
  840.      
  841.      if(errorstatus!=SD_OK)return errorstatus;  
  842.     }
  843.     }
  844.    INTX_ENABLE();//開啟總中斷
  845.     SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
  846.    }else if(DeviceMode==SD_DMA_MODE)
  847.   {
  848.       TransferError=SD_OK;
  849.    StopCondition=1;   //多塊讀,需要發(fā)送停止傳輸指令
  850.    TransferEnd=0;    //傳輸結(jié)束標置位，在中斷服務置1
  851.    SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<5)|(1<<9); //配置需要的中斷
  852.     SDIO->DCTRL|=1<<3;         //SDIO DMA使能
  853.        SD_DMA_Config((u32*)buf,nblks*blksize,DMA_DIR_PeripheralToMemory);
  854.     while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待傳輸完成
  855.    if(timeout==0)return SD_DATA_TIMEOUT;//超時
  856.    while((TransferEnd==0)&&(TransferError==SD_OK));
  857.    if(TransferError!=SD_OK)errorstatus=TransferError;   
  858.   }   
  859.    }
  860. return errorstatus;
  861. }                        
  862. //SD卡寫1個塊
  863. //buf:數(shù)據(jù)緩存區(qū)
  864. //addr:寫地址
  865. //blksize:塊大小   
  866. //返回值:錯誤狀態(tài)
  867. SD_Error SD_WriteBlock(u8 *buf,long long addr,  u16 blksize)
  868. {
  869. SD_Error errorstatus = SD_OK;

  871. u8  power=0,cardstate=0;

  873. u32 timeout=0,bytestransferred=0;

  875. u32 cardstatus=0,count=0,restwords=0;

  877. u32 tlen=blksize;      //總長度(字節(jié))

  879. u32*tempbuff=(u32*)buf;     

  881.   if(buf==NULL)return SD_INVALID_PARAMETER;//參數(shù)錯誤  

  883.   SDIO->DCTRL=0x0;       //數(shù)據(jù)控制寄存器清零(關DMA)

  885. SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ;//清除DPSM狀態(tài)機配置
  886. SDIO_DataInitStructure.SDIO_DataLength= 0 ;
  887. SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  888. SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  889. SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
  890. SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  891.   SDIO_DataConfig(&SDIO_DataInitStructure);


  894. if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
  895.   if(CardType==SDIO_HIGH_CAPACITY_SD_CARD) //大容量卡
  896. {
  897.   blksize=512;
  898.   addr>>=9;
  899. }   
  900. if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
  901. {
  902.   power=convert_from_bytes_to_power_of_two(blksize);
  903.   
  904.   SDIO_CmdInitStructure.SDIO_Argument = blksize;//發(fā)送CMD16+設置數(shù)據(jù)長度為blksize,短響應  
  905.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
  906.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  907.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  908.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  909.   SDIO_SendCommand(&SDIO_CmdInitStructure);
  910.   
  911.   errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1響應  
  912.   
  913.   if(errorstatus!=SD_OK)return errorstatus;    //響應錯誤  
  914.   
  915. }else return SD_INVALID_PARAMETER;

  917.    SDIO_CmdInitStructure.SDIO_Argument = (u32)RCA<<16;//發(fā)送CMD13,查詢卡的狀態(tài),短響應  
  918.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;
  919.    SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  920.    SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  921.    SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  922.    SDIO_SendCommand(&SDIO_CmdInitStructure);
  923.    errorstatus=CmdResp1Error(SD_CMD_SEND_STATUS);  //等待R1響應  

  925. if(errorstatus!=SD_OK)return errorstatus;
  926. cardstatus=SDIO->RESP1;               
  927. timeout=SD_DATATIMEOUT;
  928.     while(((cardstatus&0x00000100)==0)&&(timeout>0))  //檢查READY_FOR_DATA位是否置位
  929. {
  930.   timeout--;  
  931.   
  932.   SDIO_CmdInitStructure.SDIO_Argument = (u32)RCA<<16;//發(fā)送CMD13,查詢卡的狀態(tài),短響應
  933.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;
  934.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  935.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  936.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  937.   SDIO_SendCommand(&SDIO_CmdInitStructure);
  938.   
  939.   errorstatus=CmdResp1Error(SD_CMD_SEND_STATUS); //等待R1響應   
  940.   
  941.   if(errorstatus!=SD_OK)return errorstatus;  
  942.   
  943.   cardstatus=SDIO->RESP1;               
  944. }
  945. if(timeout==0)return SD_ERROR;
  946.    SDIO_CmdInitStructure.SDIO_Argument = addr;//發(fā)送CMD24,寫單塊指令,短響應  
  947.    SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_WRITE_SINGLE_BLOCK;
  948.    SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  949.    SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  950.    SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  951.    SDIO_SendCommand(&SDIO_CmdInitStructure);

  953. errorstatus=CmdResp1Error(SD_CMD_WRITE_SINGLE_BLOCK);//等待R1響應  

  955. if(errorstatus!=SD_OK)return errorstatus;     

  957. StopCondition=0;         //單塊寫,不需要發(fā)送停止傳輸指令
  958. SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4; ; //blksize, 控制器到卡
  959. SDIO_DataInitStructure.SDIO_DataLength= blksize ;
  960. SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  961. SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  962. SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
  963. SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  964.   SDIO_DataConfig(&SDIO_DataInitStructure);


  967. timeout=SDIO_DATATIMEOUT;

  969. if (DeviceMode == SD_POLLING_MODE)
  970. {
  971.   INTX_DISABLE();//關閉總中斷(POLLING模式,嚴禁中斷打斷SDIO讀寫操作!!!)
  972.   while(!(SDIO->STA&((1<<10)|(1<<4)|(1<<1)|(1<<3)|(1<<9))))//數(shù)據(jù)塊發(fā)送成功/下溢/CRC/超時/起始位錯誤
  973.   {
  974.    if(SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE) != RESET)       //發(fā)送區(qū)半空,表示至少存了8個字
  975.    {
  976.     if((tlen-bytestransferred)<SD_HALFFIFOBYTES)//不夠32字節(jié)了
  977.     {
  978.      restwords=((tlen-bytestransferred)%4==0)?((tlen-bytestransferred)/4):((tlen-bytestransferred)/4+1);
  979.      
  980.      for(count=0;count<restwords;count++,tempbuff++,bytestransferred+=4)
  981.      {
  982.       SDIO->FIFO=*tempbuff;
  983.      }
  984.     }else
  985.     {
  986.      for(count=0;count<8;count++)
  987.      {
  988.       SDIO->FIFO=*(tempbuff+count);
  989.      }
  990.      tempbuff+=8;
  991.      bytestransferred+=32;
  992.     }
  993.     timeout=0X3FFFFFFF; //寫數(shù)據(jù)溢出時間
  994.    }else
  995.    {
  996.     if(timeout==0)return SD_DATA_TIMEOUT;
  997.     timeout--;
  998.    }
  999.   }
  1000.   if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)  //數(shù)據(jù)超時錯誤
  1001.   {            
  1002.     SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);  //清錯誤標志
  1003.    return SD_DATA_TIMEOUT;
  1004.    }else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //數(shù)據(jù)塊CRC錯誤
  1005.   {
  1006.     SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);    //清錯誤標志
  1007.    return SD_DATA_CRC_FAIL;     
  1008.   }else if(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET)  //接收fifo下溢錯誤
  1009.   {
  1010.     SDIO_ClearFlag(SDIO_FLAG_TXUNDERR);  //清錯誤標志
  1011.    return SD_TX_UNDERRUN;   
  1012.   }else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)  //接收起始位錯誤
  1013.   {
  1014.     SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清錯誤標志
  1015.    return SD_START_BIT_ERR;   
  1016.   }   
  1017.       
  1018.   INTX_ENABLE();//開啟總中斷
  1019.   SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記  
  1020. }else if(DeviceMode==SD_DMA_MODE)
  1021. {
  1022.      TransferError=SD_OK;
  1023.   StopCondition=0;   //單塊寫,不需要發(fā)送停止傳輸指令
  1024.   TransferEnd=0;    //傳輸結(jié)束標置位，在中斷服務置1
  1025.   SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置產(chǎn)生數(shù)據(jù)接收完成中斷
  1026.   SD_DMA_Config((u32*)buf,blksize,DMA_DIR_MemoryToPeripheral);    //SDIO DMA配置
  1027.     SDIO->DCTRL|=1<<3;        //SDIO DMA使能.  
  1028.    while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待傳輸完成
  1029.   if(timeout==0)
  1030.   {
  1031.      SD_Init();       //重新初始化SD卡,可以解決寫入死機的問題
  1032.    return SD_DATA_TIMEOUT;   //超時  
  1033.    }
  1034.   timeout=SDIO_DATATIMEOUT;
  1035.   while((TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;
  1036.    if(timeout==0)return SD_DATA_TIMEOUT;   //超時  
  1037.     if(TransferError!=SD_OK)return TransferError;
  1038.   }  
  1039.   SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
  1040.   errorstatus=IsCardProgramming(&cardstate);
  1041.   while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING)))
  1042. {
  1043.   errorstatus=IsCardProgramming(&cardstate);
  1044. }   
  1045. return errorstatus;
  1046. }
  1047. //SD卡寫多個塊
  1048. //buf:數(shù)據(jù)緩存區(qū)
  1049. //addr:寫地址
  1050. //blksize:塊大小
  1051. //nblks:要寫入的塊數(shù)
  1052. //返回值:錯誤狀態(tài)               
  1053. SD_Error SD_WriteMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks)
  1054. {
  1055. SD_Error errorstatus = SD_OK;
  1056. u8  power = 0, cardstate = 0;
  1057. u32 timeout=0,bytestransferred=0;
  1058. u32 count = 0, restwords = 0;
  1059. u32 tlen=nblks*blksize;    //總長度(字節(jié))
  1060. u32 *tempbuff = (u32*)buf;  
  1061.   if(buf==NULL)return SD_INVALID_PARAMETER; //參數(shù)錯誤  
  1062.   SDIO->DCTRL=0x0;       //數(shù)據(jù)控制寄存器清零(關DMA)   

  1064. SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ; //清除DPSM狀態(tài)機配置
  1065. SDIO_DataInitStructure.SDIO_DataLength= 0 ;
  1066. SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  1067. SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  1068. SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
  1069. SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  1070.   SDIO_DataConfig(&SDIO_DataInitStructure);

  1072. if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
  1073.   if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡
  1074. {
  1075.   blksize=512;
  1076.   addr>>=9;
  1077. }   
  1078. if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
  1079. {
  1080.   power=convert_from_bytes_to_power_of_two(blksize);
  1081.   
  1082.   SDIO_CmdInitStructure.SDIO_Argument = blksize; //發(fā)送CMD16+設置數(shù)據(jù)長度為blksize,短響應
  1083.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN;
  1084.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1085.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1086.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1087.   SDIO_SendCommand(&SDIO_CmdInitStructure);
  1088.   
  1089.   errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1響應  
  1090.   
  1091.   if(errorstatus!=SD_OK)return errorstatus;    //響應錯誤  
  1092.   
  1093. }else return SD_INVALID_PARAMETER;  
  1094. if(nblks>1)
  1095. {      
  1096.   if(nblks*blksize>SD_MAX_DATA_LENGTH)return SD_INVALID_PARAMETER;   
  1097.       if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
  1098.      {
  1099.    //提高性能
  1100.     SDIO_CmdInitStructure.SDIO_Argument = (u32)RCA<<16;  //發(fā)送ACMD55,短響應  
  1101.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
  1102.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1103.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1104.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1105.     SDIO_SendCommand(&SDIO_CmdInitStructure);
  1106.    
  1107.    errorstatus=CmdResp1Error(SD_CMD_APP_CMD);  //等待R1響應
  1108.    
  1109.    if(errorstatus!=SD_OK)return errorstatus;     
  1110.    
  1111.     SDIO_CmdInitStructure.SDIO_Argument =nblks;  //發(fā)送CMD23,設置塊數(shù)量,短響應   
  1112.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCK_COUNT;
  1113.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1114.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1115.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1116.     SDIO_SendCommand(&SDIO_CmdInitStructure);
  1117.      
  1118.     errorstatus=CmdResp1Error(SD_CMD_SET_BLOCK_COUNT);//等待R1響應
  1119.    
  1120.    if(errorstatus!=SD_OK)return errorstatus;  
  1121.       
  1122.   }
  1123.     SDIO_CmdInitStructure.SDIO_Argument =addr; //發(fā)送CMD25,多塊寫指令,短響應   
  1124.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_WRITE_MULT_BLOCK;
  1125.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1126.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1127.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1128.     SDIO_SendCommand(&SDIO_CmdInitStructure);
  1129.    errorstatus=CmdResp1Error(SD_CMD_WRITE_MULT_BLOCK); //等待R1響應        

  1131.   if(errorstatus!=SD_OK)return errorstatus;
  1132.         SDIO_DataInitStructure.SDIO_DataBlockSize= power<<4; ; //blksize, 控制器到卡
  1133.     SDIO_DataInitStructure.SDIO_DataLength= nblks*blksize ;
  1134.     SDIO_DataInitStructure.SDIO_DataTimeOut=SD_DATATIMEOUT ;
  1135.     SDIO_DataInitStructure.SDIO_DPSM=SDIO_DPSM_Enable;
  1136.     SDIO_DataInitStructure.SDIO_TransferDir=SDIO_TransferDir_ToCard;
  1137.     SDIO_DataInitStructure.SDIO_TransferMode=SDIO_TransferMode_Block;
  1138.     SDIO_DataConfig(&SDIO_DataInitStructure);
  1139.    
  1140.   if(DeviceMode==SD_POLLING_MODE)
  1141.      {
  1142.    timeout=SDIO_DATATIMEOUT;
  1143.    INTX_DISABLE();//關閉總中斷(POLLING模式,嚴禁中斷打斷SDIO讀寫操作!!!)
  1144.    while(!(SDIO->STA&((1<<4)|(1<<1)|(1<<8)|(1<<3)|(1<<9))))//下溢/CRC/數(shù)據(jù)結(jié)束/超時/起始位錯誤
  1145.    {
  1146.     if(SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE) != RESET)       //發(fā)送區(qū)半空,表示至少存了8字(32字節(jié))
  1147.     {   
  1148.      if((tlen-bytestransferred)<SD_HALFFIFOBYTES)//不夠32字節(jié)了
  1149.      {
  1150.       restwords=((tlen-bytestransferred)%4==0)?((tlen-bytestransferred)/4):((tlen-bytestransferred)/4+1);
  1151.       for(count=0;count<restwords;count++,tempbuff++,bytestransferred+=4)
  1152.       {
  1153.        SDIO->FIFO=*tempbuff;
  1154.       }
  1155.      }else           //發(fā)送區(qū)半空,可以發(fā)送至少8字(32字節(jié))數(shù)據(jù)
  1156.      {
  1157.       for(count=0;count<SD_HALFFIFO;count++)
  1158.       {
  1159.        SDIO->FIFO=*(tempbuff+count);
  1160.       }
  1161.       tempbuff+=SD_HALFFIFO;
  1162.       bytestransferred+=SD_HALFFIFOBYTES;
  1163.      }
  1164.      timeout=0X3FFFFFFF; //寫數(shù)據(jù)溢出時間
  1165.     }else
  1166.     {
  1167.      if(timeout==0)return SD_DATA_TIMEOUT;
  1168.      timeout--;
  1169.     }
  1170.    }
  1171.   if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)  //數(shù)據(jù)超時錯誤
  1172.   {            
  1173.     SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);  //清錯誤標志
  1174.    return SD_DATA_TIMEOUT;
  1175.    }else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //數(shù)據(jù)塊CRC錯誤
  1176.   {
  1177.     SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);    //清錯誤標志
  1178.    return SD_DATA_CRC_FAIL;     
  1179.   }else if(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET)  //接收fifo下溢錯誤
  1180.   {
  1181.     SDIO_ClearFlag(SDIO_FLAG_TXUNDERR);  //清錯誤標志
  1182.    return SD_TX_UNDERRUN;   
  1183.   }else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)  //接收起始位錯誤
  1184.   {
  1185.     SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清錯誤標志
  1186.    return SD_START_BIT_ERR;   
  1187.   }   
  1188.                     
  1189.    if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET)  //發(fā)送結(jié)束
  1190.    {               
  1191.     if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
  1192.     {   
  1193.      SDIO_CmdInitStructure.SDIO_Argument =0;//發(fā)送CMD12+結(jié)束傳輸   
  1194.      SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;
  1195.      SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1196.      SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1197.      SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1198.      SDIO_SendCommand(&SDIO_CmdInitStructure);
  1199.      
  1200.      errorstatus=CmdResp1Error(SD_CMD_STOP_TRANSMISSION);//等待R1響應   
  1201.      if(errorstatus!=SD_OK)return errorstatus;  
  1202.     }
  1203.    }
  1204.    INTX_ENABLE();//開啟總中斷
  1205.     SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
  1206.      }else if(DeviceMode==SD_DMA_MODE)
  1207.   {
  1208.      TransferError=SD_OK;
  1209.    StopCondition=1;   //多塊寫,需要發(fā)送停止傳輸指令
  1210.    TransferEnd=0;    //傳輸結(jié)束標置位，在中斷服務置1
  1211.    SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置產(chǎn)生數(shù)據(jù)接收完成中斷
  1212.    SD_DMA_Config((u32*)buf,nblks*blksize,DMA_DIR_MemoryToPeripheral);  //SDIO DMA配置
  1213.      SDIO->DCTRL|=1<<3;        //SDIO DMA使能.
  1214.    timeout=SDIO_DATATIMEOUT;
  1215.     while(((DMA2->LISR&(1<<27))==RESET)&&timeout)timeout--;//等待傳輸完成
  1216.    if(timeout==0)          //超時
  1217.    {           
  1218.       SD_Init();       //重新初始化SD卡,可以解決寫入死機的問題
  1219.      return SD_DATA_TIMEOUT;   //超時  
  1220.     }
  1221.    timeout=SDIO_DATATIMEOUT;
  1222.    while((TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;
  1223.     if(timeout==0)return SD_DATA_TIMEOUT;   //超時  
  1224.     if(TransferError!=SD_OK)return TransferError;  
  1225.   }
  1226.    }
  1227.   SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
  1228.   errorstatus=IsCardProgramming(&cardstate);
  1229.   while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING)))
  1230. {
  1231.   errorstatus=IsCardProgramming(&cardstate);
  1232. }   
  1233. return errorstatus;   
  1234. }
  1235. //SDIO中斷服務函數(shù)   
  1236. void SDIO_IRQHandler(void)
  1237. {           
  1238.   SD_ProcessIRQSrc();//處理所有SDIO相關中斷
  1239. }                     
  1240. //SDIO中斷處理函數(shù)
  1241. //處理SDIO傳輸過程中的各種中斷事務
  1242. //返回值:錯誤代碼
  1243. SD_Error SD_ProcessIRQSrc(void)
  1244. {
  1245. if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET)//接收完成中斷
  1246. {  
  1247.   if (StopCondition==1)
  1248.   {  
  1249.     SDIO_CmdInitStructure.SDIO_Argument =0;//發(fā)送CMD12+結(jié)束傳輸   
  1250.     SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_STOP_TRANSMISSION;
  1251.     SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1252.     SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1253.     SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1254.     SDIO_SendCommand(&SDIO_CmdInitStructure);
  1255.      
  1256.    TransferError=CmdResp1Error(SD_CMD_STOP_TRANSMISSION);
  1257.   }else TransferError = SD_OK;
  1258.    SDIO->ICR|=1<<8;//清除完成中斷標記
  1259.   SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
  1260.    TransferEnd = 1;
  1261.   return(TransferError);
  1262. }
  1263.   if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET)//數(shù)據(jù)CRC錯誤
  1264. {
  1265.   SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);    //清錯誤標志
  1266.   SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
  1267.      TransferError = SD_DATA_CRC_FAIL;
  1268.      return(SD_DATA_CRC_FAIL);
  1269. }
  1270.   if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)//數(shù)據(jù)超時錯誤
  1271. {
  1272.   SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);     //清中斷標志
  1273.   SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
  1274.      TransferError = SD_DATA_TIMEOUT;
  1275.      return(SD_DATA_TIMEOUT);
  1276. }
  1277.    if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET)//FIFO上溢錯誤
  1278. {
  1279.   SDIO_ClearFlag(SDIO_FLAG_RXOVERR);     //清中斷標志
  1280.   SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
  1281.      TransferError = SD_RX_OVERRUN;
  1282.      return(SD_RX_OVERRUN);
  1283. }
  1284.     if(SDIO_GetFlagStatus(SDIO_FLAG_TXUNDERR) != RESET)//FIFO下溢錯誤
  1285. {
  1286.   SDIO_ClearFlag(SDIO_FLAG_TXUNDERR);     //清中斷標志
  1287.   SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
  1288.      TransferError = SD_TX_UNDERRUN;
  1289.      return(SD_TX_UNDERRUN);
  1290. }
  1291. if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)//起始位錯誤
  1292. {
  1293.   SDIO_ClearFlag(SDIO_FLAG_STBITERR);    //清中斷標志
  1294.   SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
  1295.      TransferError = SD_START_BIT_ERR;
  1296.      return(SD_START_BIT_ERR);
  1297. }
  1298. return(SD_OK);
  1299. }
  1300.   
  1301. //檢查CMD0的執(zhí)行狀態(tài)
  1302. //返回值:sd卡錯誤碼
  1303. SD_Error CmdError(void)
  1304. {
  1305. SD_Error errorstatus = SD_OK;
  1306. u32 timeout=SDIO_CMD0TIMEOUT;   
  1307. while(timeout--)
  1308. {
  1309.   if(SDIO_GetFlagStatus(SDIO_FLAG_CMDSENT) != RESET)break; //命令已發(fā)送(無需響應)  
  1310. }     
  1311. if(timeout==0)return SD_CMD_RSP_TIMEOUT;  
  1312. SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
  1313. return errorstatus;
  1314. }  
  1315. //檢查R7響應的錯誤狀態(tài)
  1316. //返回值:sd卡錯誤碼
  1317. SD_Error CmdResp7Error(void)
  1318. {
  1319. SD_Error errorstatus=SD_OK;
  1320. u32 status;
  1321. u32 timeout=SDIO_CMD0TIMEOUT;
  1322.   while(timeout--)
  1323. {
  1324.   status=SDIO->STA;
  1325.   if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯誤/命令響應超時/已經(jīng)收到響應(CRC校驗成功)
  1326. }
  1327.   if((timeout==0)||(status&(1<<2))) //響應超時
  1328. {                        
  1329.   errorstatus=SD_CMD_RSP_TIMEOUT; //當前卡不是2.0兼容卡,或者不支持設定的電壓范圍
  1330.   SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);    //清除命令響應超時標志
  1331.   return errorstatus;
  1332. }  
  1333. if(status&1<<6)      //成功接收到響應
  1334. {           
  1335.   errorstatus=SD_OK;
  1336.   SDIO_ClearFlag(SDIO_FLAG_CMDREND);     //清除響應標志
  1337.   }
  1338. return errorstatus;
  1339. }   
  1340. //檢查R1響應的錯誤狀態(tài)
  1341. //cmd:當前命令
  1342. //返回值:sd卡錯誤碼
  1343. SD_Error CmdResp1Error(u8 cmd)
  1344. {   
  1345.     u32 status;
  1346. while(1)
  1347. {
  1348.   status=SDIO->STA;
  1349.   if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯誤/命令響應超時/已經(jīng)收到響應(CRC校驗成功)
  1350. }
  1351. if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET)     //響應超時
  1352. {                        
  1353.    SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);     //清除命令響應超時標志
  1354.   return SD_CMD_RSP_TIMEOUT;
  1355. }
  1356.   if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET)     //CRC錯誤
  1357. {                        
  1358.    SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);     //清除標志
  1359.   return SD_CMD_CRC_FAIL;
  1360. }  
  1361. if(SDIO->RESPCMD!=cmd)return SD_ILLEGAL_CMD;//命令不匹配
  1362.   SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
  1363. return (SD_Error)(SDIO->RESP1&SD_OCR_ERRORBITS);//返回卡響應
  1364. }
  1365. //檢查R3響應的錯誤狀態(tài)
  1366. //返回值:錯誤狀態(tài)
  1367. SD_Error CmdResp3Error(void)
  1368. {
  1369. u32 status;      
  1370.   while(1)
  1371. {
  1372.   status=SDIO->STA;
  1373.   if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯誤/命令響應超時/已經(jīng)收到響應(CRC校驗成功)
  1374. }
  1375.   if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET)     //響應超時
  1376. {            
  1377.   SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);   //清除命令響應超時標志
  1378.   return SD_CMD_RSP_TIMEOUT;
  1379. }  
  1380.    SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
  1381.   return SD_OK;         
  1382. }
  1383. //檢查R2響應的錯誤狀態(tài)
  1384. //返回值:錯誤狀態(tài)
  1385. SD_Error CmdResp2Error(void)
  1386. {
  1387. SD_Error errorstatus=SD_OK;
  1388. u32 status;
  1389. u32 timeout=SDIO_CMD0TIMEOUT;
  1390.   while(timeout--)
  1391. {
  1392.   status=SDIO->STA;
  1393.   if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯誤/命令響應超時/已經(jīng)收到響應(CRC校驗成功)
  1394. }
  1395.    if((timeout==0)||(status&(1<<2))) //響應超時
  1396. {                        
  1397.   errorstatus=SD_CMD_RSP_TIMEOUT;
  1398.   SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);   //清除命令響應超時標志
  1399.   return errorstatus;
  1400. }  
  1401. if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET)      //CRC錯誤
  1402. {           
  1403.   errorstatus=SD_CMD_CRC_FAIL;
  1404.   SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);  //清除響應標志
  1405.   }
  1406. SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
  1407.   return errorstatus;               
  1408. }
  1409. //檢查R6響應的錯誤狀態(tài)
  1410. //cmd:之前發(fā)送的命令
  1411. //prca:卡返回的RCA地址
  1412. //返回值:錯誤狀態(tài)
  1413. SD_Error CmdResp6Error(u8 cmd,u16*prca)
  1414. {
  1415. SD_Error errorstatus=SD_OK;
  1416. u32 status;         
  1417. u32 rspr1;
  1418.   while(1)
  1419. {
  1420.   status=SDIO->STA;
  1421.   if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯誤/命令響應超時/已經(jīng)收到響應(CRC校驗成功)
  1422. }
  1423. if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET)     //響應超時
  1424. {                        
  1425.    SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);   //清除命令響應超時標志
  1426.   return SD_CMD_RSP_TIMEOUT;
  1427. }   
  1428. if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET)      //CRC錯誤
  1429. {           
  1430.   SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL);     //清除響應標志
  1431.    return SD_CMD_CRC_FAIL;
  1432. }
  1433. if(SDIO->RESPCMD!=cmd)    //判斷是否響應cmd命令
  1434. {
  1435.    return SD_ILLEGAL_CMD;   
  1436. }     
  1437. SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
  1438. rspr1=SDIO->RESP1;     //得到響應   
  1439. if(SD_ALLZERO==(rspr1&(SD_R6_GENERAL_UNKNOWN_ERROR|SD_R6_ILLEGAL_CMD|SD_R6_COM_CRC_FAILED)))
  1440. {
  1441.   *prca=(u16)(rspr1>>16);   //右移16位得到,rca
  1442.   return errorstatus;
  1443. }
  1444.     if(rspr1&SD_R6_GENERAL_UNKNOWN_ERROR)return SD_GENERAL_UNKNOWN_ERROR;
  1445.     if(rspr1&SD_R6_ILLEGAL_CMD)return SD_ILLEGAL_CMD;
  1446.     if(rspr1&SD_R6_COM_CRC_FAILED)return SD_COM_CRC_FAILED;
  1447. return errorstatus;
  1448. }
  1449. //SDIO使能寬總線模式
  1450. //enx:0,不使能;1,使能;
  1451. //返回值:錯誤狀態(tài)
  1452. SD_Error SDEnWideBus(u8 enx)
  1453. {
  1454. SD_Error errorstatus = SD_OK;
  1455.   u32 scr[2]={0,0};
  1456. u8 arg=0X00;
  1457. if(enx)arg=0X02;
  1458. else arg=0X00;
  1459.   if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//SD卡處于LOCKED狀態(tài)      
  1460.   errorstatus=FindSCR(RCA,scr);      //得到SCR寄存器數(shù)據(jù)
  1461.   if(errorstatus!=SD_OK)return errorstatus;
  1462. if((scr[1]&SD_WIDE_BUS_SUPPORT)!=SD_ALLZERO)  //支持寬總線
  1463. {
  1464.     SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;//發(fā)送CMD55+RCA,短響應
  1465.       SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;
  1466.       SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1467.       SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1468.       SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1469.       SDIO_SendCommand(&SDIO_CmdInitStructure);
  1470.   
  1471.    errorstatus=CmdResp1Error(SD_CMD_APP_CMD);
  1472.   
  1473.    if(errorstatus!=SD_OK)return errorstatus;
  1474.   
  1475.     SDIO_CmdInitStructure.SDIO_Argument = arg;//發(fā)送ACMD6,短響應,參數(shù):10,4位;00,1位.
  1476.       SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_SD_SET_BUSWIDTH;
  1477.       SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1478.       SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1479.       SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1480.       SDIO_SendCommand(&SDIO_CmdInitStructure);
  1481.    
  1482.      errorstatus=CmdResp1Error(SD_CMD_APP_SD_SET_BUSWIDTH);
  1483.   
  1484.   return errorstatus;
  1485. }else return SD_REQUEST_NOT_APPLICABLE;    //不支持寬總線設置   
  1486. }               
  1487. //檢查卡是否正在執(zhí)行寫操作
  1488. //pstatus:當前狀態(tài).
  1489. //返回值:錯誤代碼
  1490. SD_Error IsCardProgramming(u8 *pstatus)
  1491. {
  1492.   vu32 respR1 = 0, status = 0;  
  1493.   
  1494.   SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16; //卡相對地址參數(shù)
  1495.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;//發(fā)送CMD13  
  1496.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1497.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1498.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1499.   SDIO_SendCommand(&SDIO_CmdInitStructure);
  1500.   
  1501. status=SDIO->STA;

  1503. while(!(status&((1<<0)|(1<<6)|(1<<2))))status=SDIO->STA;//等待操作完成
  1504.     if(SDIO_GetFlagStatus(SDIO_FLAG_CCRCFAIL) != RESET)   //CRC檢測失敗
  1505. {  
  1506.    SDIO_ClearFlag(SDIO_FLAG_CCRCFAIL); //清除錯誤標記
  1507.   return SD_CMD_CRC_FAIL;
  1508. }
  1509.     if(SDIO_GetFlagStatus(SDIO_FLAG_CTIMEOUT) != RESET)   //命令超時
  1510. {
  1511.   SDIO_ClearFlag(SDIO_FLAG_CTIMEOUT);   //清除錯誤標記
  1512.   return SD_CMD_RSP_TIMEOUT;
  1513. }
  1514.   if(SDIO->RESPCMD!=SD_CMD_SEND_STATUS)return SD_ILLEGAL_CMD;
  1515. SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
  1516. respR1=SDIO->RESP1;
  1517. *pstatus=(u8)((respR1>>9)&0x0000000F);
  1518. return SD_OK;
  1519. }
  1520. //讀取當前卡狀態(tài)
  1521. //pcardstatus:卡狀態(tài)
  1522. //返回值:錯誤代碼
  1523. SD_Error SD_SendStatus(uint32_t *pcardstatus)
  1524. {
  1525. SD_Error errorstatus = SD_OK;
  1526. if(pcardstatus==NULL)
  1527. {
  1528.   errorstatus=SD_INVALID_PARAMETER;
  1529.   return errorstatus;
  1530. }

  1532. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;//發(fā)送CMD13,短響應   
  1533.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;
  1534.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1535.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1536.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1537.   SDIO_SendCommand(&SDIO_CmdInitStructure);

  1539. errorstatus=CmdResp1Error(SD_CMD_SEND_STATUS); //查詢響應狀態(tài)
  1540. if(errorstatus!=SD_OK)return errorstatus;
  1541. *pcardstatus=SDIO->RESP1;//讀取響應值
  1542. return errorstatus;
  1543. }
  1544. //返回SD卡的狀態(tài)
  1545. //返回值:SD卡狀態(tài)
  1546. SDCardState SD_GetState(void)
  1547. {
  1548. u32 resp1=0;
  1549. if(SD_SendStatus(&resp1)!=SD_OK)return SD_CARD_ERROR;
  1550. else return (SDCardState)((resp1>>9) & 0x0F);
  1551. }
  1552. //查找SD卡的SCR寄存器值
  1553. //rca:卡相對地址
  1554. //pscr:數(shù)據(jù)緩存區(qū)(存儲SCR內(nèi)容)
  1555. //返回值:錯誤狀態(tài)     
  1556. SD_Error FindSCR(u16 rca,u32 *pscr)
  1557. {
  1558. u32 index = 0;
  1559. SD_Error errorstatus = SD_OK;
  1560. u32 tempscr[2]={0,0};  

  1562. SDIO_CmdInitStructure.SDIO_Argument = (uint32_t)8;  //發(fā)送CMD16,短響應,設置Block Size為8字節(jié)
  1563.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SET_BLOCKLEN; //  cmd16
  1564.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;  //r1
  1565.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1566.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1567.   SDIO_SendCommand(&SDIO_CmdInitStructure);

  1569.   errorstatus=CmdResp1Error(SD_CMD_SET_BLOCKLEN);

  1571.   if(errorstatus!=SD_OK)return errorstatus;  

  1573.   SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16;
  1574.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_APP_CMD;//發(fā)送CMD55,短響應  
  1575.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;
  1576.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1577.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1578.   SDIO_SendCommand(&SDIO_CmdInitStructure);

  1580.   errorstatus=CmdResp1Error(SD_CMD_APP_CMD);
  1581.   if(errorstatus!=SD_OK)return errorstatus;

  1583.   SDIO_DataInitStructure.SDIO_DataTimeOut = SD_DATATIMEOUT;
  1584.   SDIO_DataInitStructure.SDIO_DataLength = 8;  //8個字節(jié)長度,block為8字節(jié),SD卡到SDIO.
  1585.   SDIO_DataInitStructure.SDIO_DataBlockSize = SDIO_DataBlockSize_8b  ;  //塊大小8byte
  1586.   SDIO_DataInitStructure.SDIO_TransferDir = SDIO_TransferDir_ToSDIO;
  1587.   SDIO_DataInitStructure.SDIO_TransferMode = SDIO_TransferMode_Block;
  1588.   SDIO_DataInitStructure.SDIO_DPSM = SDIO_DPSM_Enable;
  1589.   SDIO_DataConfig(&SDIO_DataInitStructure);  
  1590.   SDIO_CmdInitStructure.SDIO_Argument = 0x0;
  1591.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SD_APP_SEND_SCR; //發(fā)送ACMD51,短響應,參數(shù)為0
  1592.   SDIO_CmdInitStructure.SDIO_Response = SDIO_Response_Short;  //r1
  1593.   SDIO_CmdInitStructure.SDIO_Wait = SDIO_Wait_No;
  1594.   SDIO_CmdInitStructure.SDIO_CPSM = SDIO_CPSM_Enable;
  1595.   SDIO_SendCommand(&SDIO_CmdInitStructure);

  1597.   errorstatus=CmdResp1Error(SD_CMD_SD_APP_SEND_SCR);
  1598.   if(errorstatus!=SD_OK)return errorstatus;         
  1599.   while(!(SDIO->STA&(SDIO_FLAG_RXOVERR|SDIO_FLAG_DCRCFAIL|SDIO_FLAG_DTIMEOUT|SDIO_FLAG_DBCKEND|SDIO_FLAG_STBITERR)))
  1600. {
  1601.   if(SDIO_GetFlagStatus(SDIO_FLAG_RXDAVL) != RESET)//接收FIFO數(shù)據(jù)可用
  1602.   {
  1603.    *(tempscr+index)=SDIO->FIFO; //讀取FIFO內(nèi)容
  1604.    index++;
  1605.    if(index>=2)break;
  1606.   }
  1607. }
  1608.   if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)  //數(shù)據(jù)超時錯誤
  1609.   {            
  1610.     SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);  //清錯誤標志
  1611.    return SD_DATA_TIMEOUT;
  1612.    }else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //數(shù)據(jù)塊CRC錯誤
  1613.   {
  1614.     SDIO_ClearFlag(SDIO_FLAG_DCRCFAIL);    //清錯誤標志
  1615.    return SD_DATA_CRC_FAIL;     
  1616.   }else if(SDIO_GetFlagStatus(SDIO_FLAG_RXOVERR) != RESET)  //接收fifo上溢錯誤
  1617.   {
  1618.     SDIO_ClearFlag(SDIO_FLAG_RXOVERR);  //清錯誤標志
  1619.    return SD_RX_OVERRUN;   
  1620.   }else if(SDIO_GetFlagStatus(SDIO_FLAG_STBITERR) != RESET)  //接收起始位錯誤
  1621.   {
  1622.     SDIO_ClearFlag(SDIO_FLAG_STBITERR);//清錯誤標志
  1623.    return SD_START_BIT_ERR;   
  1624.   }  
  1625.    SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有標記
  1626. //把數(shù)據(jù)順序按8位為單位倒過來.   
  1627. *(pscr+1)=((tempscr[0]&SD_0TO7BITS)<<24)|((tempscr[0]&SD_8TO15BITS)<<8)|((tempscr[0]&SD_16TO23BITS)>>8)|((tempscr[0]&SD_24TO31BITS)>>24);
  1628. *(pscr)=((tempscr[1]&SD_0TO7BITS)<<24)|((tempscr[1]&SD_8TO15BITS)<<8)|((tempscr[1]&SD_16TO23BITS)>>8)|((tempscr[1]&SD_24TO31BITS)>>24);
  1629.   return errorstatus;
  1630. }
  1631. //得到NumberOfBytes以2為底的指數(shù).
  1632. //NumberOfBytes:字節(jié)數(shù).
  1633. //返回值:以2為底的指數(shù)值
  1634. u8 convert_from_bytes_to_power_of_two(u16 NumberOfBytes)
  1635. {
  1636. u8 count=0;
  1637. while(NumberOfBytes!=1)
  1638. {
  1639.   NumberOfBytes>>=1;
  1640.   count++;
  1641. }
  1642. return count;
  1643. }   
  1644. //配置SDIO DMA  
  1645. //mbuf:存儲器地址
  1646. //bufsize:傳輸數(shù)據(jù)量
  1647. //dir:方向;DMA_DIR_MemoryToPeripheral  存儲器-->SDIO(寫數(shù)據(jù));DMA_DIR_PeripheralToMemory SDIO-->存儲器(讀數(shù)據(jù));
  1648. void SD_DMA_Config(u32*mbuf,u32 bufsize,u32 dir)
  1649. {   
  1650.   DMA_InitTypeDef  DMA_InitStructure;

  1652. while (DMA_GetCmdStatus(DMA2_Stream3) != DISABLE){}//等待DMA可配置
  1653.   
  1654.   DMA_DeInit(DMA2_Stream3);//清空之前該stream3上的所有中斷標志


  1657.   DMA_InitStructure.DMA_Channel = DMA_Channel_4;  //通道選擇
  1658.   DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&SDIO->FIFO;//DMA外設地址
  1659.   DMA_InitStructure.DMA_Memory0BaseAddr = (u32)mbuf;//DMA 存儲器0地址
  1660.   DMA_InitStructure.DMA_DIR = dir;//存儲器到外設模式
  1661.   DMA_InitStructure.DMA_BufferSize = 0;//數(shù)據(jù)傳輸量
  1662.   DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;//外設非增量模式
  1663.   DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;//存儲器增量模式
  1664.   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;//外設數(shù)據(jù)長度:32位
  1665.   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;//存儲器數(shù)據(jù)長度:32位
  1666.   DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;// 使用普通模式
  1667.   DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;//最高優(yōu)先級
  1668.   DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Enable;   //FIFO使能      
  1669.   DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;//全FIFO
  1670.   DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_INC4;//外設突發(fā)4次傳輸
  1671.   DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_INC4;//存儲器突發(fā)4次傳輸
  1672.   DMA_Init(DMA2_Stream3, &DMA_InitStructure);//初始化DMA Stream
  1673. DMA_FlowControllerConfig(DMA2_Stream3,DMA_FlowCtrl_Peripheral);//外設流控制
  1674.   
  1675.   DMA_Cmd(DMA2_Stream3 ,ENABLE);//開啟DMA傳輸  
  1676. }   

  1678. //讀SD卡
  1679. //buf:讀數(shù)據(jù)緩存區(qū)
  1680. //sector:扇區(qū)地址
  1681. //cnt:扇區(qū)個數(shù)
  1682. //返回值:錯誤狀態(tài);0,正常;其他,錯誤代碼;           
  1683. u8 SD_ReadDisk(u8*buf,u32 sector,u8 cnt)
  1684. {
  1685. u8 sta=SD_OK;
  1686. long long lsector=sector;
  1687. u8 n;
  1688. if(CardType!=SDIO_STD_CAPACITY_SD_CARD_V1_1)lsector<<=9;
  1689. if((u32)buf%4!=0)
  1690. {
  1691.    for(n=0;n<cnt;n++)
  1692.   {
  1693.     sta=SD_ReadBlock(SDIO_DATA_BUFFER,lsector+512*n,512);//單個sector的讀操作
  1694.    memcpy(buf,SDIO_DATA_BUFFER,512);
  1695.    buf+=512;
  1696.   }
  1697. }else
  1698. {
  1699.   if(cnt==1)sta=SD_ReadBlock(buf,lsector,512);     //單個sector的讀操作
  1700.   else sta=SD_ReadMultiBlocks(buf,lsector,512,cnt);//多個sector  
  1701. }
  1702. return sta;
  1703. }
  1704. //寫SD卡
  1705. //buf:寫數(shù)據(jù)緩存區(qū)
  1706. //sector:扇區(qū)地址
  1707. //cnt:扇區(qū)個數(shù)
  1708. //返回值:錯誤狀態(tài);0,正常;其他,錯誤代碼;
  1709. u8 SD_WriteDisk(u8*buf,u32 sector,u8 cnt)
  1710. {
  1711. u8 sta=SD_OK;
  1712. u8 n;
  1713. long long lsector=sector;
  1714. if(CardType!=SDIO_STD_CAPACITY_SD_CARD_V1_1)lsector<<=9;
  1715. if((u32)buf%4!=0)
  1716. {
  1717.    for(n=0;n<cnt;n++)
  1718.   {
  1719.    memcpy(SDIO_DATA_BUFFER,buf,512);
  1720.     sta=SD_WriteBlock(SDIO_DATA_BUFFER,lsector+512*n,512);//單個sector的寫操作
  1721.    buf+=512;
  1722.   }
  1723. }else
  1724. {
  1725.   if(cnt==1)sta=SD_WriteBlock(buf,lsector,512);     //單個sector的寫操作
  1726.   else sta=SD_WriteMultiBlocks(buf,lsector,512,cnt); //多個sector  
  1727. }
  1728. return sta;
  1729. }
復制代碼

代碼下載: 6-ADC采集+文件系統(tǒng).7z (829.79 KB, 下載次數(shù): 76)
作者: 1311565821    時間: 2023-9-19 14:24
下載之后直接編譯報錯



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1