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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › STM32F407VET6采集AD数据,保存到SD卡中 源程序
返回列表 发新帖
查看: 2379|回复: 1
打印 上一主题 下一主题
收起左侧

STM32F407VET6采集AD数据,保存到SD卡中 源程序

[复制链接]
跳转到指定楼层
楼主
ID:241682 发表于 2021-11-28 06:24 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
  1. //单片机采用STM32F407VET6 ad采集数据，并将数据保存到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);//设置系统中断优先级分组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相关变量申请内存     
  26.     f_mount(fs[0],"0:",1);  //挂载SD卡
  27.   res=mf_open("0:/123/ADcData.txt",FA_OPEN_ALWAYS | FA_READ | FA_WRITE );//创建或打开一个文本文档保存数据
  28. res=mf_open("0:/ADcData.txt",FA_OPEN_ALWAYS | FA_READ | FA_WRITE );//创建或打开一个文本文档保存数据
  29. if(res==FR_OK)
  30.     {
  31.   printf("文件已经存在!\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);   //获取计算后的带小数的实际电压值，比如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());                  //将指针定位于文件尾部，准备追加数据
  49.   mf_write(ADc_Buff,strlen(ADc_Buff));  //将接收到的数据存入文件
  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初始化的结构体*/
  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)数据
  79. static u8 DeviceMode=SD_DMA_MODE;         //工作模式,注意,工作模式必须通过SD_SetDeviceMode,后才算数.这里只是定义一个默认的模式(SD_DMA_MODE)
  80. static u8 StopCondition=0;         //是否发送停止传输标志位,DMA多块读写的时候用到  
  81. volatile SD_Error TransferError=SD_OK;     //数据传输错误标志,DMA读写时使用     
  82. volatile u8 TransferEnd=0;        //传输结束标志,DMA读写时使用
  83. SD_CardInfo SDCardInfo; //SD卡信息
  84. //THUMB指令不支持汇编内联
  85. //采用如下方法实现执行汇编指令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. //设置栈顶地址
  103. //addr:栈顶地址
  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函数专用buf,当这两个函数的数据缓存区地址不是4字节对齐的时候,
  110. //需要用到该数组,确保数据缓存区地址是4字节对齐的.
  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结束复位
  162.   
  163.   //SDIO外设寄存器设置为默认值      
  164. SDIO_Register_Deinit();

  166.   NVIC_InitStructure.NVIC_IRQChannel = SDIO_IRQn;
  167. NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0;//抢占优先级3
  168. NVIC_InitStructure.NVIC_IRQChannelSubPriority =0;  //子优先级3
  169. NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;   //IRQ通道使能
  170. NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化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:时钟分频系数
  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位数据线
  212.   SDIO_InitStructure.SDIO_HardwareFlowControl = SDIO_HardwareFlowControl_Disable;//硬件流
  213.   SDIO_Init(&SDIO_InitStructure);
  214. SDIO_SetPowerState(SDIO_PowerState_ON); //上电状态,开启卡时钟   
  215.   SDIO->CLKCR|=1<<8;   //SDIOCK使能  

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

  220.   SDIO_CmdInitStructure.SDIO_Argument = 0x0;//发送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在开始发送命令之前等待数据传输结束。
  225.     SDIO_SendCommand(&SDIO_CmdInitStructure);     //写命令进命令寄存器
  226.   
  227.   errorstatus=CmdError();
  228.   
  229.   if(errorstatus==SD_OK)break;
  230.   }
  231.   if(errorstatus)return errorstatus;//返回错误状态

  233.   SDIO_CmdInitStructure.SDIO_Argument = SD_CHECK_PATTERN; //发送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;//发送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);  //发送CMD55,短响应  

  255.   errorstatus=CmdResp1Error(SD_CMD_APP_CMD);     //等待R1响应   

  257. if(errorstatus==SD_OK)//SD2.0/SD 1.1,否则为MMC卡
  258. {                  
  259.   //SD卡,发送ACMD41 SD_APP_OP_COND,参数为:0x80100000
  260.   while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL))
  261.   {                 
  262.     SDIO_CmdInitStructure.SDIO_Argument = 0x00;//发送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);   //发送CMD55,短响应  
  268.    
  269.    errorstatus=CmdResp1Error(SD_CMD_APP_CMD);    //等待R1响应  
  270.    
  271.     if(errorstatus!=SD_OK)return errorstatus;    //响应错误
  272.       //acmd41，命令参数由支持的电压范围及HCS位组成，HCS位置一来区分卡是SDSc还是sdhc
  273.       SDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_SD | SDType; //发送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卡,发送CMD1 SDIO_SEND_OP_COND,参数为:0x80FF8000
  299.   while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL))
  300.   {                        
  301.    SDIO_CmdInitStructure.SDIO_Argument = SD_VOLTAGE_WINDOW_MMC;//发送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. //初始化所有的卡,并让卡进入就绪状态
  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) //检查电源状态,确保为上电状态
  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;//发送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);//发送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;//发送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); //发送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);//发送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); //发送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);//发送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:卡信息存储区
  411. //返回值:错误状态
  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结构
  420. cardinfo->SD_csd.SysSpecVersion=(tmp&0x3C)>>2; //2.0协议还没定义这部分(为保留),应该是后续协议定义的
  421. cardinfo->SD_csd.Reserved1=tmp&0x03;   //2个保留位  
  422. tmp=(u8)((CSD_Tab[0]&0x00FF0000)>>16);   //第1个字节
  423. cardinfo->SD_csd.TAAC=tmp;         //数据读时间1
  424. tmp=(u8)((CSD_Tab[0]&0x0000FF00)>>8);     //第2个字节
  425. cardinfo->SD_csd.NSAC=tmp;        //数据读时间2
  426. tmp=(u8)(CSD_Tab[0]&0x000000FF);    //第3个字节
  427. cardinfo->SD_csd.MaxBusClkFrec=tmp;      //传输速度   
  428. tmp=(u8)((CSD_Tab[1]&0xFF000000)>>24);   //第4个字节
  429. cardinfo->SD_csd.CardComdClasses=tmp<<4;     //卡指令类高四位
  430. tmp=(u8)((CSD_Tab[1]&0x00FF0000)>>16);    //第5个字节
  431. cardinfo->SD_csd.CardComdClasses|=(tmp&0xF0)>>4;//卡指令类低四位
  432. cardinfo->SD_csd.RdBlockLen=tmp&0x0F;      //最大读取数据长度
  433. tmp=(u8)((CSD_Tab[1]&0x0000FF00)>>8);   //第6个字节
  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个字节
  443.   cardinfo->SD_csd.DeviceSize|=(tmp)<<2;
  444.    tmp=(u8)((CSD_Tab[2]&0xFF000000)>>24);  //第8个字节
  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个字节
  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个字节
  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个字节
  461.   cardinfo->SD_csd.DeviceSize=(tmp&0x3F)<<16;//C_SIZE
  462.    tmp=(u8)((CSD_Tab[2]&0xFF000000)>>24);  //第8个字节
  463.    cardinfo->SD_csd.DeviceSize|=(tmp<<8);
  464.    tmp=(u8)((CSD_Tab[2]&0x00FF0000)>>16); //第9个字节
  465.    cardinfo->SD_csd.DeviceSize|=(tmp);
  466.    tmp=(u8)((CSD_Tab[2]&0x0000FF00)>>8);  //第10个字节
  467.    cardinfo->CardCapacity=(long long)(cardinfo->SD_csd.DeviceSize+1)*512*1024;//计算卡容量
  468.   cardinfo->CardBlockSize=512;    //块大小固定为512字节
  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个字节
  473. cardinfo->SD_csd.EraseGrMul|=(tmp&0x80)>>7;
  474. cardinfo->SD_csd.WrProtectGrSize=(tmp&0x7F);
  475.   tmp=(u8)((CSD_Tab[3]&0xFF000000)>>24);  //第12个字节
  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个字节
  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个字节
  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个字节
  493. cardinfo->SD_csd.CSD_CRC=(tmp&0xFE)>>1;
  494. cardinfo->SD_csd.Reserved4=1;   
  495. tmp=(u8)((CID_Tab[0]&0xFF000000)>>24);  //第0个字节
  496. cardinfo->SD_cid.ManufacturerID=tmp;      
  497. tmp=(u8)((CID_Tab[0]&0x00FF0000)>>16);  //第1个字节
  498. cardinfo->SD_cid.OEM_AppliID=tmp<<8;   
  499. tmp=(u8)((CID_Tab[0]&0x000000FF00)>>8);  //第2个字节
  500. cardinfo->SD_cid.OEM_AppliID|=tmp;     
  501. tmp=(u8)(CID_Tab[0]&0x000000FF);   //第3个字节
  502. cardinfo->SD_cid.ProdName1=tmp<<24;      
  503. tmp=(u8)((CID_Tab[1]&0xFF000000)>>24);   //第4个字节
  504. cardinfo->SD_cid.ProdName1|=tmp<<16;   
  505. tmp=(u8)((CID_Tab[1]&0x00FF0000)>>16);     //第5个字节
  506. cardinfo->SD_cid.ProdName1|=tmp<<8;   
  507. tmp=(u8)((CID_Tab[1]&0x0000FF00)>>8);  //第6个字节
  508. cardinfo->SD_cid.ProdName1|=tmp;     
  509. tmp=(u8)(CID_Tab[1]&0x000000FF);     //第7个字节
  510. cardinfo->SD_cid.ProdName2=tmp;     
  511. tmp=(u8)((CID_Tab[2]&0xFF000000)>>24);   //第8个字节
  512. cardinfo->SD_cid.ProdRev=tmp;   
  513. tmp=(u8)((CID_Tab[2]&0x00FF0000)>>16);  //第9个字节
  514. cardinfo->SD_cid.ProdSN=tmp<<24;   
  515. tmp=(u8)((CID_Tab[2]&0x0000FF00)>>8);   //第10个字节
  516. cardinfo->SD_cid.ProdSN|=tmp<<16;   
  517. tmp=(u8)(CID_Tab[2]&0x000000FF);      //第11个字节
  518. cardinfo->SD_cid.ProdSN|=tmp<<8;     
  519. tmp=(u8)((CID_Tab[3]&0xFF000000)>>24);   //第12个字节
  520. cardinfo->SD_cid.ProdSN|=tmp;        
  521. tmp=(u8)((CID_Tab[3]&0x00FF0000)>>16);   //第13个字节
  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个字节
  525. cardinfo->SD_cid.ManufactDate|=tmp;      
  526. tmp=(u8)(CID_Tab[3]&0x000000FF);   //第15个字节
  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位数据宽度;1,4位数据宽度;2,8位数据宽度
  533. //返回值:SD卡错误状态
  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卡错误状态

  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. //返回值:错误状态
  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. //发送CMD7,选择相对地址(rca)为addr的卡,取消其他卡.如果为0,则都不选择.
  581. //addr:卡的RCA地址
  582. SD_Error SD_SelectDeselect(u32 addr)
  583. {
  584.   SDIO_CmdInitStructure.SDIO_Argument =  addr;//发送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);//发送CMD7,选择卡,短响应

  591.   return CmdResp1Error(SD_CMD_SEL_DESEL_CARD);   
  592. }
  593. //SD卡读取一个块
  594. //buf:读数据缓存区(必须4字节对齐!!)
  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;//转换为u32指针
  602. u32 timeout=SDIO_DATATIMEOUT;   
  603.   if(NULL==buf)
  604.   return SD_INVALID_PARAMETER;
  605.   SDIO->DCTRL=0x0; //数据控制寄存器清零(关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状态机配置
  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);//发送CMD16+设置数据长度为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状态机配置
  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);//发送CMD17+从addr地址出读取数据,短响应

  656. errorstatus=CmdResp1Error(SD_CMD_READ_SINGLE_BLOCK);//等待R1响应   
  657. if(errorstatus!=SD_OK)return errorstatus;     //响应错误  
  658.   if(DeviceMode==SD_POLLING_MODE)      //查询模式,轮询数据  
  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)      //接收区半满,表示至少存了8个字
  664.    {
  665.     for(count=0;count<8;count++)   //循环读取数据
  666.     {
  667.      *(tempbuff+count)=SDIO->FIFO;
  668.     }
  669.     tempbuff+=8;  
  670.     timeout=0X7FFFFF;  //读数据溢出时间
  671.    }else  //处理超时
  672.    {
  673.     if(timeout==0)return SD_DATA_TIMEOUT;
  674.     timeout--;
  675.    }
  676.   }
  677.   if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)  //数据超时错误
  678.   {            
  679.     SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);  //清错误标志
  680.    return SD_DATA_TIMEOUT;
  681.    }else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //数据块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里面,还存在可用数据
  695.   {
  696.    *tempbuff=SDIO->FIFO; //循环读取数据
  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;   //单块读,不需要发送停止传输指令
  706.   TransferEnd=0;    //传输结束标置位，在中断服务置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:读数据缓存区
  718. //addr:读取地址
  719. //blksize:块大小
  720. //nblks:要读取的块数
  721. //返回值:错误状态
  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;//转换为u32指针

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

  738.    SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ;//清除DPSM状态机配置
  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;//发送CMD16+设置数据长度为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;//发送CMD18+从addr地址出读取数据,短响应
  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)      //接收区半满,表示至少存了8个字
  792.     {
  793.      for(count=0;count<8;count++)   //循环读取数据
  794.      {
  795.       *(tempbuff+count)=SDIO->FIFO;
  796.      }
  797.      tempbuff+=8;  
  798.      timeout=0X7FFFFF;  //读数据溢出时间
  799.     }else  //处理超时
  800.     {
  801.      if(timeout==0)return SD_DATA_TIMEOUT;
  802.      timeout--;
  803.     }
  804.    }  
  805.   if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)  //数据超时错误
  806.   {            
  807.     SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);  //清错误标志
  808.    return SD_DATA_TIMEOUT;
  809.    }else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //数据块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里面,还存在可用数据
  824.   {
  825.    *tempbuff=SDIO->FIFO; //循环读取数据
  826.    tempbuff++;
  827.   }
  828.     if(SDIO_GetFlagStatus(SDIO_FLAG_DATAEND) != RESET)  //接收结束
  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;//发送CMD12+结束传输
  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;   //多块读,需要发送停止传输指令
  850.    TransferEnd=0;    //传输结束标置位，在中断服务置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:数据缓存区
  864. //addr:写地址
  865. //blksize:块大小   
  866. //返回值:错误状态
  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;      //总长度(字节)

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

  881.   if(buf==NULL)return SD_INVALID_PARAMETER;//参数错误  

  883.   SDIO->DCTRL=0x0;       //数据控制寄存器清零(关DMA)

  885. SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ;//清除DPSM状态机配置
  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;//发送CMD16+设置数据长度为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;//发送CMD13,查询卡的状态,短响应  
  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;//发送CMD13,查询卡的状态,短响应
  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;//发送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;         //单块写,不需要发送停止传输指令
  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))))//数据块发送成功/下溢/CRC/超时/起始位错误
  973.   {
  974.    if(SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE) != RESET)       //发送区半空,表示至少存了8个字
  975.    {
  976.     if((tlen-bytestransferred)<SD_HALFFIFOBYTES)//不够32字节了
  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; //写数据溢出时间
  994.    }else
  995.    {
  996.     if(timeout==0)return SD_DATA_TIMEOUT;
  997.     timeout--;
  998.    }
  999.   }
  1000.   if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)  //数据超时错误
  1001.   {            
  1002.     SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);  //清错误标志
  1003.    return SD_DATA_TIMEOUT;
  1004.    }else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //数据块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;   //单块写,不需要发送停止传输指令
  1024.   TransferEnd=0;    //传输结束标置位，在中断服务置1
  1025.   SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置产生数据接收完成中断
  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:数据缓存区
  1049. //addr:写地址
  1050. //blksize:块大小
  1051. //nblks:要写入的块数
  1052. //返回值:错误状态               
  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;    //总长度(字节)
  1060. u32 *tempbuff = (u32*)buf;  
  1061.   if(buf==NULL)return SD_INVALID_PARAMETER; //参数错误  
  1062.   SDIO->DCTRL=0x0;       //数据控制寄存器清零(关DMA)   

  1064. SDIO_DataInitStructure.SDIO_DataBlockSize= 0; ; //清除DPSM状态机配置
  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; //发送CMD16+设置数据长度为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;  //发送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;  //发送CMD23,设置块数量,短响应   
  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; //发送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/数据结束/超时/起始位错误
  1145.    {
  1146.     if(SDIO_GetFlagStatus(SDIO_FLAG_TXFIFOHE) != RESET)       //发送区半空,表示至少存了8字(32字节)
  1147.     {   
  1148.      if((tlen-bytestransferred)<SD_HALFFIFOBYTES)//不够32字节了
  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           //发送区半空,可以发送至少8字(32字节)数据
  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; //写数据溢出时间
  1165.     }else
  1166.     {
  1167.      if(timeout==0)return SD_DATA_TIMEOUT;
  1168.      timeout--;
  1169.     }
  1170.    }
  1171.   if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)  //数据超时错误
  1172.   {            
  1173.     SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);  //清错误标志
  1174.    return SD_DATA_TIMEOUT;
  1175.    }else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //数据块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)  //发送结束
  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;//发送CMD12+结束传输   
  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;   //多块写,需要发送停止传输指令
  1210.    TransferEnd=0;    //传输结束标置位，在中断服务置1
  1211.    SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置产生数据接收完成中断
  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中断服务函数   
  1236. void SDIO_IRQHandler(void)
  1237. {           
  1238.   SD_ProcessIRQSrc();//处理所有SDIO相关中断
  1239. }                     
  1240. //SDIO中断处理函数
  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;//发送CMD12+结束传输   
  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)//数据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)//数据超时错误
  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的执行状态
  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; //命令已发送(无需响应)  
  1310. }     
  1311. if(timeout==0)return SD_CMD_RSP_TIMEOUT;  
  1312. SDIO_ClearFlag(SDIO_STATIC_FLAGS);//清除所有标记
  1313. return errorstatus;
  1314. }  
  1315. //检查R7响应的错误状态
  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错误/命令响应超时/已经收到响应(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响应的错误状态
  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错误/命令响应超时/已经收到响应(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响应的错误状态
  1366. //返回值:错误状态
  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错误/命令响应超时/已经收到响应(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响应的错误状态
  1384. //返回值:错误状态
  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错误/命令响应超时/已经收到响应(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响应的错误状态
  1410. //cmd:之前发送的命令
  1411. //prca:卡返回的RCA地址
  1412. //返回值:错误状态
  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错误/命令响应超时/已经收到响应(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. //返回值:错误状态
  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状态      
  1460.   errorstatus=FindSCR(RCA,scr);      //得到SCR寄存器数据
  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;//发送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;//发送ACMD6,短响应,参数: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. //检查卡是否正在执行写操作
  1488. //pstatus:当前状态.
  1489. //返回值:错误代码
  1490. SD_Error IsCardProgramming(u8 *pstatus)
  1491. {
  1492.   vu32 respR1 = 0, status = 0;  
  1493.   
  1494.   SDIO_CmdInitStructure.SDIO_Argument = (uint32_t) RCA << 16; //卡相对地址参数
  1495.   SDIO_CmdInitStructure.SDIO_CmdIndex = SD_CMD_SEND_STATUS;//发送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. //读取当前卡状态
  1521. //pcardstatus:卡状态
  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;//发送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); //查询响应状态
  1540. if(errorstatus!=SD_OK)return errorstatus;
  1541. *pcardstatus=SDIO->RESP1;//读取响应值
  1542. return errorstatus;
  1543. }
  1544. //返回SD卡的状态
  1545. //返回值:SD卡状态
  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:数据缓存区(存储SCR内容)
  1555. //返回值:错误状态     
  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;  //发送CMD16,短响应,设置Block Size为8字节
  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;//发送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个字节长度,block为8字节,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; //发送ACMD51,短响应,参数为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数据可用
  1602.   {
  1603.    *(tempscr+index)=SDIO->FIFO; //读取FIFO内容
  1604.    index++;
  1605.    if(index>=2)break;
  1606.   }
  1607. }
  1608.   if(SDIO_GetFlagStatus(SDIO_FLAG_DTIMEOUT) != RESET)  //数据超时错误
  1609.   {            
  1610.     SDIO_ClearFlag(SDIO_FLAG_DTIMEOUT);  //清错误标志
  1611.    return SD_DATA_TIMEOUT;
  1612.    }else if(SDIO_GetFlagStatus(SDIO_FLAG_DCRCFAIL) != RESET) //数据块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. //把数据顺序按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为底的指数.
  1632. //NumberOfBytes:字节数.
  1633. //返回值:以2为底的指数值
  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:传输数据量
  1647. //dir:方向;DMA_DIR_MemoryToPeripheral  存储器-->SDIO(写数据);DMA_DIR_PeripheralToMemory SDIO-->存储器(读数据);
  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;//数据传输量
  1662.   DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;//外设非增量模式
  1663.   DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;//存储器增量模式
  1664.   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;//外设数据长度:32位
  1665.   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;//存储器数据长度:32位
  1666.   DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;// 使用普通模式
  1667.   DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;//最高优先级
  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;//外设突发4次传输
  1671.   DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_INC4;//存储器突发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:读数据缓存区
  1680. //sector:扇区地址
  1681. //cnt:扇区个数
  1682. //返回值:错误状态;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:写数据缓存区
  1706. //sector:扇区地址
  1707. //cnt:扇区个数
  1708. //返回值:错误状态;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采集+文件系统.7z (829.79 KB, 下载次数: 76)

评分

参与人数 1黑币 +30 收起 理由
admin + 30 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏5 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:114007 发表于 2023-9-19 14:24 | 只看该作者
下载之后直接编译报错
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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