基于STM32Cube移植FatFs文件系统，f_Open返回FR_NOT

flqcandy 回答时间：2014-11-4 15:05:29

main.c
/* Includes ------------------------------------------------------------------*/
#include "stm32f4xx_hal.h"
#include "main.h"
#include "diskio.h"
/* Private variables ---------------------------------------------------------*/
SPI_HandleTypeDef hspi2;

/* USER CODE BEGIN 0 */
FATFS fs;// Work area (file system object) for logical drive
// DIR dir;
FIL fsrc, fdst;    // file objects
FRESULT fr;// FatFs function common result code
/* USER CODE END 0 */

/* Private function prototypes -----------------------------------------------*/
static void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_SPI2_Init(void);

int main(void)
{

  /* USER CODE BEGIN 1 */
  char buffer[100]; // file copy buffer
UINT br, bw;       // File R/W count
// DSTATUS status;
unsigned char w_buffer[]="123456789123456789123456789123456789";//??????
  /* USER CODE END 1 */

  /* MCU Configuration----------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* Configure the system clock */
  SystemClock_Config();

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_SPI2_Init();

  /* USER CODE BEGIN 2 */
// status = disk_initialize(0);
// if(status==0)
//          {
// return RES_OK;
//       }
  fr=f_mount(0,&fs);
//fr=f_opendir(&dir,"");
fr = f_open(&fsrc,"0:/srcfile.txt",FA_CREATE_ALWAYS|FA_WRITE);
if(fr==FR_OK)
   fr = f_write(&fsrc,w_buffer,strlen(w_buffer),&bw);
fr = f_close(&fsrc);
f_mount(0,NULL);
  /* USER CODE END 2 */

  /* USER CODE BEGIN 3 */
  /* Infinite loop */
  while (1)
  {

  }
  /* USER CODE END 3 */

}

/** System Clock Configuration
*/
static void SystemClock_Config(void)
{

  RCC_ClkInitTypeDef RCC_ClkInitStruct;
  RCC_OscInitTypeDef RCC_OscInitStruct;

  __PWR_CLK_ENABLE();

  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 15;
  RCC_OscInitStruct.PLL.PLLN = 192;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  HAL_RCC_OscConfig(&RCC_OscInitStruct);

  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK|RCC_CLOCKTYPE_PCLK1
                           |RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
  HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);

}

/* SPI2 init function */
void MX_SPI2_Init(void)
{

  hspi2.Instance = SPI2;
  hspi2.Init.Mode = SPI_MODE_MASTER;
  hspi2.Init.Direction = SPI_DIRECTION_2LINES;
  hspi2.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi2.Init.CLKPolarity = SPI_POLARITY_HIGH;
  hspi2.Init.CLKPhase = SPI_PHASE_2EDGE;
  hspi2.Init.NSS = SPI_NSS_SOFT;
  hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
  hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi2.Init.TIMode = SPI_TIMODE_DISABLED;
  hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_ENABLED;
  hspi2.Init.CRCPolynomial = 7;
  HAL_SPI_Init(&hspi2);

}

/** Configure pins as
      * Analog
      * Input
      * Output
      * EVENT_OUT
      * EXTI
*/
void MX_GPIO_Init(void)
{

  GPIO_InitTypeDef GPIO_InitStruct;

  /* GPIO Ports Clock Enable */
  __GPIOH_CLK_ENABLE();
  __GPIOC_CLK_ENABLE();
  __GPIOB_CLK_ENABLE();

  /*Configure GPIO pin : PB9 */
  GPIO_InitStruct.Pin = GPIO_PIN_9;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_MEDIUM;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

}

赞 0 评论

flqcandy 回答时间：2014-11-4 15:05:54

diskio.c
/* Includes ------------------------------------------------------------------*/
#include "diskio.h"
#include "ffconf.h"
#include "Spi_SD_Driver.h"
#include <stdio.h>

/* Private variables ---------------------------------------------------------*/
//extern MSD_CARDINFO SD0_CardInfo;

DSTATUS disk_initialize (
BYTE drv /* Physical drive nmuber (0..) */
)
{
int Status;
Status = SD_Init();
if(Status==0)
         {
return RES_OK;
      }else{
return STA_NOINIT;
      }
}

DSTATUS disk_status (
BYTE drv /* Physical drive nmuber (0..) */
)
{

return RES_OK;

}

/*-----------------------------------------------------------------------*/
/* Read Sector(s)                                                       */

DRESULT disk_read (
BYTE drv, /* Physical drive nmuber (0..) */
BYTE *buff, /* Data buffer to store read data */
DWORD sector, /* Sector address (LBA) */
BYTE count /* Number of sectors to read (1..255) */
)
{
int Status;
if( !count )
{
return RES_PARERR;  /* count²»ÄÜµÈÓÚ0£¬·ñÔò·µ»Ø²ÎÊý´íÎó */
}
if(count==1)          /* 1¸ösectorµÄ¶Á²Ù×÷ */
{
Status = SD_ReadSingleBlock( sector ,buff );
if(Status == 0){
return RES_OK;
}else{
return RES_ERROR;
}
}
else                   /* ¶à¸ösectorµÄ¶Á²Ù×÷ */
{
Status = SD_ReadMultiBlock( sector , buff ,count);
if(Status == 0){
return RES_OK;
}else{
return RES_ERROR;
}
}

}

/*-----------------------------------------------------------------------*/
/* Write Sector(s)                                                    */

#if _READONLY == 0
DRESULT disk_write (
BYTE drv, /* Physical drive nmuber (0..) */
const BYTE *buff,          /* Data to be written */
DWORD sector, /* Sector address (LBA) */
BYTE count /* Number of sectors to write (1..255) */
)
{
int Status;
if( !count )
{
return RES_PARERR;  /* count²»ÄÜµÈÓÚ0£¬·ñÔò·µ»Ø²ÎÊý´íÎó */
}

if(count==1)          /* 1¸ösectorµÄÐ´²Ù×÷ */
{
Status = SD_WriteSingleBlock( sector , (uint8_t *)(&buff[0]) );
if(Status == 0){
return RES_OK;
}else{
return RES_ERROR;
}
}
else                   /* ¶à¸ösectorµÄÐ´²Ù×÷ */
{
Status = SD_WriteMultiBlock( sector , (uint8_t *)(&buff[0]) , count );
if(Status == 0){
return RES_OK;
}else{
return RES_ERROR;
}
}

}
#endif /* _READONLY */

/*-----------------------------------------------------------------------*/
/* Miscellaneous Functions                                              */

//DRESULT disk_ioctl (
// BYTE drv, /* Physical drive nmuber (0..) */
// BYTE ctrl, /* Control code */
// void *buff /* Buffer to send/receive control data */
//)
//{
// //MSD0_GetCardInfo(&SD0_CardInfo);
// switch (ctrl)
// {
// case CTRL_SYNC :
// return RES_OK;
// case GET_SECTOR_COUNT :
// //*(DWORD*)buff = SD0_CardInfo.Capacity/SD0_CardInfo.BlockSize;
//         return RES_OK;
// case GET_BLOCK_SIZE :
// //*(WORD*)buff = SD0_CardInfo.BlockSize;
//         return RES_OK;
// case CTRL_POWER :
// break;
// case CTRL_LOCK :
// break;
// case CTRL_EJECT :
// break;
//       /* MMC/SDC command */
// case MMC_GET_TYPE :
// break;
// case MMC_GET_CSD :
// break;
// case MMC_GET_CID :
// break;
// case MMC_GET_OCR :
// break;
// case MMC_GET_SDSTAT :
// break;
// }
//
//}
DRESULT disk_ioctl(BYTE drv,  /* Physical drive nmuber (0..) */
BYTE ctrl,  /* Control code */
void *buff /* Buffer to send/receive control data */
)
{
return RES_OK;

}

/* µÃµ½ÎÄ¼þCalendar¸ñÊ½µÄ½¨Á¢ÈÕÆÚ,ÊÇDWORD get_fattime (void) Äæ±ä»» */
/*-----------------------------------------------------------------------*/
/* User defined function to give a current time to fatfs module       */
/* 31-25: Year(0-127 org.1980), 24-21: Month(1-12), 20-16: Day(1-31) */
/* 15-11: Hour(0-23), 10-5: Minute(0-59), 4-0: Second(0-29 *2) */
DWORD get_fattime (void)
{

return 0;
}

赞 0 评论

flqcandy 回答时间：2014-11-4 15:12:06

SPI_SD_Driver.c分3部分上传，Part1：
/* Includes ------------------------------------------------------------------*/
//#include "config.h"
#include "Spi_SD_Driver.h"
#include "stm32f4xx.h"
#include "main.h"

u8  SD_Type=0;

/* Private functions ---------------------------------------------------------*/

// ÒÔÏÂÊÇSPIÄ£¿éµÄ³õÊ¼»¯´úÂë£¬ÅäÖÃ³ÉÖ÷»úÄ£Ê½£¬·ÃÎÊSD¿¨

/*******************************************************************************
* Function Name  : SPI_SetSpeed
* Description : SPIÉèÖÃËÙ¶ÈÎª¸ßËÙ
* Input       : u8 SpeedSet
*                Èç¹ûËÙ¶ÈÉèÖÃÊäÈë0£¬ÔòµÍËÙÄ£Ê½£¬·Ç0Ôò¸ßËÙÄ£Ê½
*                SPI_SPEED_HIGH 1
*                SPI_SPEED_LOW 0
* Output       : None
* Return       : None
*******************************************************************************/
void SPI_SetSpeed(u8 SpeedSet)
{

  hspi2.Instance=SPI2;
  hspi2.Init.Direction = SPI_DIRECTION_2LINES;
  hspi2.Init.DataSize = SPI_DATASIZE_8BIT;
  hspi2.Init.CLKPolarity = SPI_POLARITY_HIGH;
  hspi2.Init.CLKPhase = SPI_PHASE_2EDGE;
  hspi2.Init.NSS = SPI_NSS_SOFT;
  hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
  hspi2.Init.TIMode = SPI_TIMODE_DISABLED;
  hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_ENABLED;
hspi2.Init.CRCPolynomial = 7;
  if(SpeedSet==SPI_SPEED_LOW)
{
hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
}
else
{
      hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
}
  HAL_SPI_Init(&hspi2);

}
/*******************************************************************************
* Function Name  : SPI_ReadWriteByte
* Description : SPI¶ÁÐ´Ò»¸ö×Ö½Ú£¨·¢ËÍÍê³Éºó·µ»Ø±¾´ÎÍ¨Ñ¶¶ÁÈ¡µÄÊý¾Ý£©
* Input       : u8 TxData ´ý·¢ËÍµÄÊý
* Output       : None
* Return       : u8 RxData ÊÕµ½µÄÊý
*******************************************************************************/

u8 SPI_ReadWriteByte(u8 TxData)
{

u8 RxData;
HAL_SPI_TransmitReceive(&hspi2,&TxData,&RxData,1,1);
return RxData;

}

/*******************************************************************************
* Function Name  : SD_WaitReady
* Description : µÈ´ýSD¿¨Ready
* Input       : None
* Output       : None
* Return       : u8
*                0£º ³É¹¦
*                other£ºÊ§°Ü
*******************************************************************************/
u8 SD_WaitReady(void)
{
u8 r1;
u16 retry;
retry = 0;
do
{
      r1 = SPI_ReadWriteByte(0xFF);
      if(retry==0xfffe)
      {
         return 1;
      }
}while(r1!=0xFF);

return 0;
}

/*******************************************************************************
* Function Name  : SD_SendCommand
* Description : ÏòSD¿¨·¢ËÍÒ»¸öÃüÁî
* Input       : u8 cmd ÃüÁî
*                u32 arg  ÃüÁî²ÎÊý
*                u8 crc crcÐ£ÑéÖµ
* Output       : None
* Return       : u8 r1 SD¿¨·µ»ØµÄÏìÓ¦
*******************************************************************************/
u8 SD_SendCommand(u8 cmd, u32 arg, u8 crc)
{
unsigned char r1;
unsigned char Retry = 0;

//????????
SPI_ReadWriteByte(0xff);
//Æ¬Ñ¡¶ËÖÃµÍ£¬Ñ¡ÖÐSD¿¨
SD_CS_ENABLE();

//·¢ËÍ
SPI_ReadWriteByte(cmd | 0x40);                      //·Ö±ðÐ´ÈëÃüÁî
SPI_ReadWriteByte(arg >> 24);
SPI_ReadWriteByte(arg >> 16);
SPI_ReadWriteByte(arg >> 8);
SPI_ReadWriteByte(arg);
SPI_ReadWriteByte(crc);

//µÈ´ýÏìÓ¦£¬»ò³¬Ê±ÍË³ö
while((r1 = SPI_ReadWriteByte(0xFF))==0xFF)
{
      Retry++;
      if(Retry > 200)
      {
         break;
      }
}

//¹Ø±ÕÆ¬Ñ¡
SD_CS_DISABLE();
//ÔÚ×ÜÏßÉÏ¶îÍâÔö¼Ó8¸öÊ±ÖÓ£¬ÈÃSD¿¨Íê³ÉÊ£ÏÂµÄ¹¤×÷
SPI_ReadWriteByte(0xFF);

//·µ»Ø×´Ì¬Öµ
return r1;
}

/*******************************************************************************
* Function Name  : SD_SendCommand_NoDeassert
* Description : ÏòSD¿¨·¢ËÍÒ»¸öÃüÁî(½áÊøÊÇ²»Ê§ÄÜÆ¬Ñ¡£¬»¹ÓÐºóÐøÊý¾Ý´«À´£©
* Input       : u8 cmd ÃüÁî
*                u32 arg  ÃüÁî²ÎÊý
*                u8 crc crcÐ£ÑéÖµ
* Output       : None
* Return       : u8 r1 SD¿¨·µ»ØµÄÏìÓ¦
*******************************************************************************/
u8 SD_SendCommand_NoDeassert(u8 cmd, u32 arg, u8 crc)
{
unsigned char r1;
unsigned char Retry = 0;

//????????
SPI_ReadWriteByte(0xff);
//Æ¬Ñ¡¶ËÖÃµÍ£¬Ñ¡ÖÐSD¿¨
SD_CS_ENABLE();

//·¢ËÍ
SPI_ReadWriteByte(cmd | 0x40);                      //·Ö±ðÐ´ÈëÃüÁî
SPI_ReadWriteByte(arg >> 24);
SPI_ReadWriteByte(arg >> 16);
SPI_ReadWriteByte(arg >> 8);
SPI_ReadWriteByte(arg);
SPI_ReadWriteByte(crc);

//µÈ´ýÏìÓ¦£¬»ò³¬Ê±ÍË³ö
while((r1 = SPI_ReadWriteByte(0xFF))==0xFF)
{
      Retry++;
      if(Retry > 200)
      {
         break;
      }
}
//·µ»ØÏìÓ¦Öµ
return r1;
}

赞 0 评论

flqcandy 回答时间：2014-11-4 15:14:35

Part2:
/*******************************************************************************
* Function Name  : SD_Init
* Description : ³õÊ¼»¯SD¿¨
* Input       : None
* Output       : None
* Return       : u8
*                0£ºNO_ERR
*                1£ºTIME_OUT
*                99£ºNO_CARD
*******************************************************************************/
u8 SD_Init(void)
{
u16 i;    // ÓÃÀ´Ñ»·¼ÆÊý
u8 r1;    // ´æ·ÅSD¿¨µÄ·µ»ØÖµ
u16 retry;  // ÓÃÀ´½øÐÐ³¬Ê±¼ÆÊý
u8 buff[6];

//Èç¹ûÃ»ÓÐ¼ì²âµ½¿¨²åÈë£¬Ö±½ÓÍË³ö£¬·µ»Ø´íÎó±êÖ¾
// if(!SD_DET())
// {
//       //return 99;
//       return STA_NODISK;  //  FatFS´íÎó±êÖ¾£ºÃ»ÓÐ²åÈë´ÅÅÌ
// }

//SD¿¨ÉÏµç
// SD_PWR_ON();
// ´¿ÑÓÊ±£¬µÈ´ýSD¿¨ÉÏµçÍê³É

/*******************************************************
//Õâ¸öµØ·½Òª¼ÓÒ»¾ä,ÉèÖÃSPIËÙ¶ÈÎªµÍËÙ¡£
//ÎªÊ²Ã´ÓÐµÄ¿¨¿ÉÒÔÄØ£¿ÒòÎªSPI³õÊ¼»¯Ê±ÊÇµÍËÙµÄ£¬SD¿¨³õÊ¼»¯
//Íê³ÉºóÉèÖÃÎª¸ßËÙ£¬ÓÐµÄ¿¨Ö»Òª³õÊ¼»¯Ò»´Î¾ÍÐÐ£¬³ÌÐò¾Íok£»
//µ«ÓÐµÄ¿¨ÐèÒª¶à´Î¸´Î»£¬ºÇºÇ£¬Õâ¸öµØ·½²îÕâÒ»¾ä£¬
//ÕâÖÖ¿¨¾ÍÓÃ²»³É¿©£¡
*******************************************************/
SPI_SetSpeed(0); //ÉèÖÃSPIËÙ¶ÈÎªµÍËÙ

//ÏÈ²úÉú>74¸öÂö³å£¬ÈÃSD¿¨×Ô¼º³õÊ¼»¯Íê³É
for(i=0;i<10;i++)
{
      SPI_ReadWriteByte(0xFF);
}

//-----------------SD¿¨¸´Î»µ½idle¿ªÊ¼-----------------
//Ñ»·Á¬Ðø·¢ËÍCMD0£¬Ö±µ½SD¿¨·µ»Ø0x01,½øÈëIDLE×´Ì¬
//³¬Ê±ÔòÖ±½ÓÍË³ö
SD_CS_ENABLE();
retry = 0;
do
{
      //·¢ËÍCMD0£¬ÈÃSD¿¨½øÈëIDLE×´Ì¬
      r1 = SD_SendCommand(CMD0, 0, 0x95);
      retry++;
}while((r1 != 0x01) && (retry<200));

//Ìø³öÑ»·ºó£¬¼ì²éÔÒò£º³õÊ¼»¯³É¹¦£¿or ÖØÊÔ³¬Ê±£¿
if(retry==200)
{
      return 1; //³¬Ê±·µ»Ø1
}
// retry=20;
// do
// {
// r1=SD_SendCommand(CMD0,0,0x95);
// }while((r1!=0x01)&&retry--);
// SD_Type=0;
//-----------------SD¿¨¸´Î»µ½idle½áÊø-----------------

//»ñÈ¡¿¨Æ¬µÄSD°æ±¾ÐÅÏ¢
r1 = SD_SendCommand_NoDeassert(8, 0x1aa, 0x87);

//Èç¹û¿¨Æ¬°æ±¾ÐÅÏ¢ÊÇv1.0°æ±¾µÄ£¬¼´r1=0x05£¬Ôò½øÐÐÒÔÏÂ³õÊ¼»¯
if(r1 == 0x05)
{
      //ÉèÖÃ¿¨ÀàÐÍÎªSDV1.0£¬Èç¹ûºóÃæ¼ì²âµ½ÎªMMC¿¨£¬ÔÙÐÞ¸ÄÎªMMC
      SD_Type = SD_TYPE_V1;

      //Èç¹ûÊÇV1.0¿¨£¬CMD8Ö¸ÁîºóÃ»ÓÐºóÐøÊý¾Ý
      //Æ¬Ñ¡ÖÃ¸ß£¬½áÊø±¾´ÎÃüÁî
      SD_CS_DISABLE();
      //¶à·¢8¸öCLK£¬ÈÃSD½áÊøºóÐø²Ù×÷
      SPI_ReadWriteByte(0xFF);

      //-----------------SD¿¨¡¢MMC¿¨³õÊ¼»¯¿ªÊ¼-----------------

      //·¢¿¨³õÊ¼»¯Ö¸ÁîCMD55+ACMD41
      // Èç¹ûÓÐÓ¦´ð£¬ËµÃ÷ÊÇSD¿¨£¬ÇÒ³õÊ¼»¯Íê³É
      // Ã»ÓÐ»ØÓ¦£¬ËµÃ÷ÊÇMMC¿¨£¬¶îÍâ½øÐÐÏàÓ¦³õÊ¼»¯
      retry = 0;
      do
      {
         //ÏÈ·¢CMD55£¬Ó¦·µ»Ø0x01£»·ñÔò³ö´í
         r1 = SD_SendCommand(CMD55, 0, 0);
         if(r1 != 0x01)
         {
            return r1;
         }
         //µÃµ½ÕýÈ·ÏìÓ¦ºó£¬·¢ACMD41£¬Ó¦µÃµ½·µ»ØÖµ0x00£¬·ñÔòÖØÊÔ200´Î
         r1 = SD_SendCommand(ACMD41, 0, 0);
         retry++;
      }while((r1!=0x00) && (retry<400));

      // ÅÐ¶ÏÊÇ³¬Ê±»¹ÊÇµÃµ½ÕýÈ·»ØÓ¦
      // ÈôÓÐ»ØÓ¦£ºÊÇSD¿¨£»Ã»ÓÐ»ØÓ¦£ºÊÇMMC¿¨

      //----------MMC¿¨¶îÍâ³õÊ¼»¯²Ù×÷¿ªÊ¼------------
      if(retry==400)
      {
         retry = 0;
         //·¢ËÍMMC¿¨³õÊ¼»¯ÃüÁî£¨Ã»ÓÐ²âÊÔ£©
         do
         {
            r1 = SD_SendCommand(1, 0, 0);
            retry++;
         }while((r1!=0x00)&& (retry<400));
         if(retry==400)
         {
            return 1; //MMC¿¨³õÊ¼»¯³¬Ê±
         }
         //Ð´Èë¿¨ÀàÐÍ
         SD_Type = SD_TYPE_MMC;
      }
      //----------MMC¿¨¶îÍâ³õÊ¼»¯²Ù×÷½áÊø------------

      //ÉèÖÃSPIÎª¸ßËÙÄ£Ê½
      SPI_SetSpeed(1);

SPI_ReadWriteByte(0xFF);

      //½ûÖ¹CRCÐ£Ñé
      /*
r1 = SD_SendCommand(CMD59, 0, 0x01);
      if(r1 != 0x00)
      {
         return r1;  //ÃüÁî´íÎó£¬·µ»Ør1
      }
      */
      //ÉèÖÃSector Size
      r1 = SD_SendCommand(CMD16, 512, 0xff);
      if(r1 != 0x00)
      {
         return r1;  //ÃüÁî´íÎó£¬·µ»Ør1
      }
      //-----------------SD¿¨¡¢MMC¿¨³õÊ¼»¯½áÊø-----------------

}//SD¿¨ÎªV1.0°æ±¾µÄ³õÊ¼»¯½áÊø

//ÏÂÃæÊÇV2.0¿¨µÄ³õÊ¼»¯
//ÆäÖÐÐèÒª¶ÁÈ¡OCRÊý¾Ý£¬ÅÐ¶ÏÊÇSD2.0»¹ÊÇSD2.0HC¿¨
else if( r1 == 0x01)
{
      //V2.0µÄ¿¨£¬CMD8ÃüÁîºó»á´«»Ø4×Ö½ÚµÄÊý¾Ý£¬ÒªÌø¹ýÔÙ½áÊø±¾ÃüÁî
      buff[0] = SPI_ReadWriteByte(0xFF);  //should be 0x00
      buff[1] = SPI_ReadWriteByte(0xFF);  //should be 0x00
      buff[2] = SPI_ReadWriteByte(0xFF);  //should be 0x01
      buff[3] = SPI_ReadWriteByte(0xFF);  //should be 0xAA

      SD_CS_DISABLE();
      //the next 8 clocks
      SPI_ReadWriteByte(0xFF);

      //ÅÐ¶Ï¸Ã¿¨ÊÇ·ñÖ§³Ö2.7V-3.6VµÄµçÑ¹·¶Î§
      if(buff[2]==0x01 && buff[3]==0xAA)
      {
         //Ö§³ÖµçÑ¹·¶Î§£¬¿ÉÒÔ²Ù×÷
         retry = 0;
         //·¢¿¨³õÊ¼»¯Ö¸ÁîCMD55+ACMD41
do
{
r1 = SD_SendCommand(CMD55, 0, 0);
if(r1!=0x01)
{
return r1;
}
r1 = SD_SendCommand(ACMD41, 0x40000000, 0);
            if(retry>200)
            {
                  return r1;  //³¬Ê±Ôò·µ»Ør1×´Ì¬
            }
         }while(r1!=0);

         //³õÊ¼»¯Ö¸Áî·¢ËÍÍê³É£¬½ÓÏÂÀ´»ñÈ¡OCRÐÅÏ¢

         //-----------¼ø±ðSD2.0¿¨°æ±¾¿ªÊ¼-----------
         r1 = SD_SendCommand_NoDeassert(CMD58, 0, 0);
         if(r1!=0x00)
         {
            return r1;  //Èç¹ûÃüÁîÃ»ÓÐ·µ»ØÕýÈ·Ó¦´ð£¬Ö±½ÓÍË³ö£¬·µ»ØÓ¦´ð
         }
         //¶ÁOCRÖ¸Áî·¢³öºó£¬½ô½Ó×ÅÊÇ4×Ö½ÚµÄOCRÐÅÏ¢
         buff[0] = SPI_ReadWriteByte(0xFF);
         buff[1] = SPI_ReadWriteByte(0xFF);
         buff[2] = SPI_ReadWriteByte(0xFF);
         buff[3] = SPI_ReadWriteByte(0xFF);

         //OCR½ÓÊÕÍê³É£¬Æ¬Ñ¡ÖÃ¸ß
         SD_CS_DISABLE();
         SPI_ReadWriteByte(0xFF);

         //¼ì²é½ÓÊÕµ½µÄOCRÖÐµÄbit30Î»£¨CCS£©£¬È·¶¨ÆäÎªSD2.0»¹ÊÇSDHC
         //Èç¹ûCCS=1£ºSDHC CCS=0£ºSD2.0
         if(buff[0]&0x40) //¼ì²éCCS
         {
            SD_Type = SD_TYPE_V2HC;
         }
         else
         {
            SD_Type = SD_TYPE_V2;
         }
         //-----------¼ø±ðSD2.0¿¨°æ±¾½áÊø-----------
         //ÉèÖÃSPIÎª¸ßËÙÄ£Ê½
         SPI_SetSpeed(1);
      }

}
return r1;
}

/*******************************************************************************
* Function Name  : SD_ReceiveData
* Description : ´ÓSD¿¨ÖÐ¶Á»ØÖ¸¶¨³¤¶ÈµÄÊý¾Ý£¬·ÅÖÃÔÚ¸ø¶¨Î»ÖÃ
* Input       : u8 *data(´æ·Å¶Á»ØÊý¾ÝµÄÄÚ´æ>len)
*                u16 len(Êý¾Ý³¤¶È£©
*                u8 release(´«ÊäÍê³ÉºóÊÇ·ñÊÍ·Å×ÜÏßCSÖÃ¸ß 0£º²»ÊÍ·Å 1£ºÊÍ·Å£©
* Output       : None
* Return       : u8
*                0£ºNO_ERR
*                other£º´íÎóÐÅÏ¢
*******************************************************************************/
u8 SD_ReceiveData(u8 *data, u16 len, u8 release)
{
u16 retry;
u8 r1;

// Æô¶¯Ò»´Î´«Êä
SD_CS_ENABLE();
//µÈ´ýSD¿¨·¢»ØÊý¾ÝÆðÊ¼ÁîÅÆ0xFE
retry = 0;
do
{
      r1 = SPI_ReadWriteByte(0xFF);
      retry++;
      if(retry>2000)  //2000´ÎµÈ´ýºóÃ»ÓÐÓ¦´ð£¬ÍË³ö±¨´í
      {
         SD_CS_DISABLE();
         return 1;
      }
}while(r1 != 0xFE);
//¿ªÊ¼½ÓÊÕÊý¾Ý
while(len--)
{
      *data = SPI_ReadWriteByte(0xFF);
      data++;
}
//ÏÂÃæÊÇ2¸öÎ±CRC£¨dummy CRC£©
SPI_ReadWriteByte(0xFF);
SPI_ReadWriteByte(0xFF);
//°´ÐèÊÍ·Å×ÜÏß£¬½«CSÖÃ¸ß
if(release == RELEASE)
{
      //´«Êä½áÊø
      SD_CS_DISABLE();
      SPI_ReadWriteByte(0xFF);
}

return 0;
}

赞 0 评论

flqcandy 回答时间：2014-11-4 15:15:47

Part3:
/*******************************************************************************
* Function Name  : SD_GetCID
* Description : »ñÈ¡SD¿¨µÄCIDÐÅÏ¢£¬°üÀ¨ÖÆÔìÉÌÐÅÏ¢
* Input       : u8 *cid_data(´æ·ÅCIDµÄÄÚ´æ£¬ÖÁÉÙ16Byte£©
* Output       : None
* Return       : u8
*                0£ºNO_ERR
*                1£ºTIME_OUT
*                other£º´íÎóÐÅÏ¢
*******************************************************************************/
u8 SD_GetCID(u8 *cid_data)
{
u8 r1;

//·¢CMD10ÃüÁî£¬¶ÁCID
r1 = SD_SendCommand(CMD10, 0, 0xFF);
if(r1 != 0x00)
{
      return r1;  //Ã»·µ»ØÕýÈ·Ó¦´ð£¬ÔòÍË³ö£¬±¨´í
}
//½ÓÊÕ16¸ö×Ö½ÚµÄÊý¾Ý
SD_ReceiveData(cid_data, 16, RELEASE);

return 0;
}

/*******************************************************************************
* Function Name  : SD_GetCSD
* Description : »ñÈ¡SD¿¨µÄCSDÐÅÏ¢£¬°üÀ¨ÈÝÁ¿ºÍËÙ¶ÈÐÅÏ¢
* Input       : u8 *cid_data(´æ·ÅCIDµÄÄÚ´æ£¬ÖÁÉÙ16Byte£©
* Output       : None
* Return       : u8
*                0£ºNO_ERR
*                1£ºTIME_OUT
*                other£º´íÎóÐÅÏ¢
*******************************************************************************/
u8 SD_GetCSD(u8 *csd_data)
{
u8 r1;

//·¢CMD9ÃüÁî£¬¶ÁCSD
r1 = SD_SendCommand(CMD9, 0, 0xFF);
if(r1 != 0x00)
{
      return r1;  //Ã»·µ»ØÕýÈ·Ó¦´ð£¬ÔòÍË³ö£¬±¨´í
}
//½ÓÊÕ16¸ö×Ö½ÚµÄÊý¾Ý
SD_ReceiveData(csd_data, 16, RELEASE);

return 0;
}

/*******************************************************************************
* Function Name  : SD_GetCapacity
* Description : »ñÈ¡SD¿¨µÄÈÝÁ¿
* Input       : None
* Output       : None
* Return       : u32 capacity
*                0£º È¡ÈÝÁ¿³ö´í
*******************************************************************************/
u32 SD_GetCapacity(void)
{
u8 csd[16];
u32 Capacity;
u8 r1;
u16 i;
u16 temp;

//È¡CSDÐÅÏ¢£¬Èç¹ûÆÚ¼ä³ö´í£¬·µ»Ø0
if(SD_GetCSD(csd)!=0)
{
      return 0;
}

//Èç¹ûÎªSDHC¿¨£¬°´ÕÕÏÂÃæ·½Ê½¼ÆËã
if((csd[0]&0xC0)==0x40)
{
      Capacity =  (((u32)csd[8])<<8 + (u32)csd[9] +1)*(u32)1024;
}
else
{
      //ÏÂÃæ´úÂëÎªÍøÉÏ°æ±¾
      ////////////formula of the capacity///////////////
      //
      //  memory capacity = BLOCKNR * BLOCK_LEN
      //
      // BLOCKNR = (C_SIZE + 1)* MULT
      //
      //          C_SIZE_MULT+2
      // MULT = 2
      //
      //             READ_BL_LEN
      // BLOCK_LEN = 2
      /**********************************************/
      //C_SIZE
i = csd[6]&0x03;
i<<=8;
i += csd[7];
i<<=2;
i += ((csd[8]&0xc0)>>6);

      //C_SIZE_MULT
r1 = csd[9]&0x03;
r1<<=1;
r1 += ((csd[10]&0x80)>>7);

      //BLOCKNR
r1+=2;
temp = 1;
while(r1)
{
temp*=2;
r1--;
}
Capacity = ((u32)(i+1))*((u32)temp);

      // READ_BL_LEN
i = csd[5]&0x0f;
      //BLOCK_LEN
temp = 1;
while(i)
{
temp*=2;
i--;
}
      //The final result
Capacity *= (u32)temp;
//Capacity /= 512;
}
return (u32)Capacity;
}

/*******************************************************************************
* Function Name  : SD_ReadSingleBlock
* Description : ¶ÁSD¿¨µÄÒ»¸öblock
* Input       : u32 sector È¡µØÖ·£¨sectorÖµ£¬·ÇÎïÀíµØÖ·£©
*                u8 *buffer Êý¾Ý´æ´¢µØÖ·£¨´óÐ¡ÖÁÉÙ512byte£©
* Output       : None
* Return       : u8 r1
*                0£º ³É¹¦
*                other£ºÊ§°Ü
*******************************************************************************/
u8 SD_ReadSingleBlock(u32 sector, u8 *buffer)
{
u8 r1;

//ÉèÖÃÎª¸ßËÙÄ£Ê½
SPI_SetSpeed(SPI_SPEED_LOW);

//Èç¹û²»ÊÇSDHC£¬½«sectorµØÖ·×ª³ÉbyteµØÖ·
if(SD_Type!=SD_TYPE_V2HC)
{
      sector = sector<<9;
}

r1 = SD_SendCommand(CMD17, sector, 0);//¶ÁÃüÁî

if(r1 != 0x00)
{
      return r1;
}

r1 = SD_ReceiveData(buffer, 512, RELEASE);
if(r1 != 0)
{
      return r1; //¶ÁÊý¾Ý³ö´í£¡
}
else
{
      return 0;
}
}

/*******************************************************************************
* Function Name  : SD_WriteSingleBlock
* Description : Ð´ÈëSD¿¨µÄÒ»¸öblock
* Input       : u32 sector ÉÈÇøµØÖ·£¨sectorÖµ£¬·ÇÎïÀíµØÖ·£©
*                u8 *buffer Êý¾Ý´æ´¢µØÖ·£¨´óÐ¡ÖÁÉÙ512byte£©
* Output       : None
* Return       : u8 r1
*                0£º ³É¹¦
*                other£ºÊ§°Ü
*******************************************************************************/
u8 SD_WriteSingleBlock(u32 sector, const u8 *data)
{
u8 r1;
u16 i;
u16 retry;

//ÉèÖÃÎª¸ßËÙÄ£Ê½
SPI_SetSpeed(SPI_SPEED_LOW);

//Èç¹û²»ÊÇSDHC£¬¸ø¶¨µÄÊÇsectorµØÖ·£¬½«Æä×ª»»³ÉbyteµØÖ·
if(SD_Type!=SD_TYPE_V2HC)
{
      sector = sector<<9;
}

r1 = SD_SendCommand(CMD24, sector, 0x00);
if(r1 != 0x00)
{
      return r1;  //Ó¦´ð²»ÕýÈ·£¬Ö±½Ó·µ»Ø
}

//¿ªÊ¼×¼±¸Êý¾Ý´«Êä
SD_CS_ENABLE();
//ÏÈ·Å3¸ö¿ÕÊý¾Ý£¬µÈ´ýSD¿¨×¼±¸ºÃ
SPI_ReadWriteByte(0xff);
SPI_ReadWriteByte(0xff);
SPI_ReadWriteByte(0xff);
//·ÅÆðÊ¼ÁîÅÆ0xFE
SPI_ReadWriteByte(0xFE);

//·ÅÒ»¸ösectorµÄÊý¾Ý
for(i=0;i<512;i++)
{
      SPI_ReadWriteByte(*data++);
}
//·¢2¸öByteµÄdummy CRC
SPI_ReadWriteByte(0xff);
SPI_ReadWriteByte(0xff);

//µÈ´ýSD¿¨Ó¦´ð
r1 = SPI_ReadWriteByte(0xff);
if((r1&0x1F)!=0x05)
{
      SD_CS_DISABLE();
      return r1;
}

//µÈ´ý²Ù×÷Íê³É
retry = 0;
while(!SPI_ReadWriteByte(0xff))
{
      retry++;
      if(retry>0xfffe)       //Èç¹û³¤Ê±¼äÐ´ÈëÃ»ÓÐÍê³É£¬±¨´íÍË³ö
      {
         SD_CS_DISABLE();
         return 1;          //Ð´Èë³¬Ê±·µ»Ø1
      }
}

//Ð´ÈëÍê³É£¬Æ¬Ñ¡ÖÃ1
SD_CS_DISABLE();
SPI_ReadWriteByte(0xff);

return 0;
}

赞 0 评论

flqcandy 回答时间：2014-11-4 15:16:45

由于字数限制，3部分没传完，只能补一部分啦，Part4:
/*******************************************************************************
* Function Name  : SD_ReadMultiBlock
* Description : ¶ÁSD¿¨µÄ¶à¸öblock
* Input       : u32 sector È¡µØÖ·£¨sectorÖµ£¬·ÇÎïÀíµØÖ·£©
*                u8 *buffer Êý¾Ý´æ´¢µØÖ·£¨´óÐ¡ÖÁÉÙ512byte£©
*                u8 count Á¬Ðø¶Ácount¸öblock
* Output       : None
* Return       : u8 r1
*                0£º ³É¹¦
*                other£ºÊ§°Ü
*******************************************************************************/
u8 SD_ReadMultiBlock(u32 sector, u8 *buffer, u8 count)
{
u8 r1;

//ÉèÖÃÎª¸ßËÙÄ£Ê½
SPI_SetSpeed(SPI_SPEED_LOW);

//Èç¹û²»ÊÇSDHC£¬½«sectorµØÖ·×ª³ÉbyteµØÖ·
if(SD_Type!=SD_TYPE_V2HC)
{
      sector = sector<<9;
}
//SD_WaitReady();
//·¢¶Á¶à¿éÃüÁî
r1 = SD_SendCommand(CMD18, sector, 0);//¶ÁÃüÁî
if(r1 != 0x00)
{
      return r1;
}
//¿ªÊ¼½ÓÊÕÊý¾Ý
do
{
      if(SD_ReceiveData(buffer, 512, NO_RELEASE) != 0x00)
      {
         break;
      }
      buffer += 512;
} while(--count);

//È«²¿´«ÊäÍê±Ï£¬·¢ËÍÍ£Ö¹ÃüÁî
SD_SendCommand(CMD12, 0, 0);
//ÊÍ·Å×ÜÏß
SD_CS_DISABLE();
SPI_ReadWriteByte(0xFF);

if(count != 0)
{
      return count; //Èç¹ûÃ»ÓÐ´«Íê£¬·µ»ØÊ£Óà¸öÊý
}
else
{
      return 0;
}
}

/*******************************************************************************
* Function Name  : SD_WriteMultiBlock
* Description : Ð´ÈëSD¿¨µÄN¸öblock
* Input       : u32 sector ÉÈÇøµØÖ·£¨sectorÖµ£¬·ÇÎïÀíµØÖ·£©
*                u8 *buffer Êý¾Ý´æ´¢µØÖ·£¨´óÐ¡ÖÁÉÙ512byte£©
*                u8 count Ð´ÈëµÄblockÊýÄ¿
* Output       : None
* Return       : u8 r1
*                0£º ³É¹¦
*                other£ºÊ§°Ü
*******************************************************************************/
u8 SD_WriteMultiBlock(u32 sector, const u8 *data, u8 count)
{
u8 r1;
u16 i=0;

//ÉèÖÃÎª¸ßËÙÄ£Ê½
SPI_SetSpeed(SPI_SPEED_LOW);

//Èç¹û²»ÊÇSDHC£¬¸ø¶¨µÄÊÇsectorµØÖ·£¬½«Æä×ª»»³ÉbyteµØÖ·
if(SD_Type != SD_TYPE_V2HC)
{
      sector = sector<<9;
}
//Èç¹ûÄ¿±ê¿¨²»ÊÇMMC¿¨£¬ÆôÓÃACMD23Ö¸ÁîÊ¹ÄÜÔ¤²Á³ý
if(SD_Type != SD_TYPE_MMC)
{
      r1 = SD_SendCommand(ACMD23, count, 0x00);
}
//·¢¶à¿éÐ´ÈëÖ¸Áî
r1 = SD_SendCommand(CMD25, sector, 0x00);
if(r1 != 0x00)
{
      return r1;  //Ó¦´ð²»ÕýÈ·£¬Ö±½Ó·µ»Ø
}

//¿ªÊ¼×¼±¸Êý¾Ý´«Êä
SD_CS_ENABLE();
//ÏÈ·Å3¸ö¿ÕÊý¾Ý£¬µÈ´ýSD¿¨×¼±¸ºÃ
SPI_ReadWriteByte(0xff);
SPI_ReadWriteByte(0xff);

//--------ÏÂÃæÊÇN¸ösectorÐ´ÈëµÄÑ»·²¿·Ö
do
{
      //·ÅÆðÊ¼ÁîÅÆ0xFC ±íÃ÷ÊÇ¶à¿éÐ´Èë
      SPI_ReadWriteByte(0xFC);

      //·ÅÒ»¸ösectorµÄÊý¾Ý
      for(i=0;i<512;i++)
      {
         SPI_ReadWriteByte(*data++);
      }
      //·¢2¸öByteµÄdummy CRC
      SPI_ReadWriteByte(0xff);
      SPI_ReadWriteByte(0xff);

      //µÈ´ýSD¿¨Ó¦´ð
      r1 = SPI_ReadWriteByte(0xff);
      if((r1&0x1F)!=0x05)
      {
         SD_CS_DISABLE(); //Èç¹ûÓ¦´ðÎª±¨´í£¬Ôò´ø´íÎó´úÂëÖ±½ÓÍË³ö
         return r1;
      }

      //µÈ´ýSD¿¨Ð´ÈëÍê³É
      if(SD_WaitReady()==1)
      {
         SD_CS_DISABLE(); //µÈ´ýSD¿¨Ð´ÈëÍê³É³¬Ê±£¬Ö±½ÓÍË³ö±¨´í
         return 1;
      }

      //±¾sectorÊý¾Ý´«ÊäÍê³É
}while(--count);

//·¢½áÊø´«ÊäÁîÅÆ0xFD
r1 = SPI_ReadWriteByte(0xFD);
if(r1==0x00)
{
      count =  0xfe;
}

if(SD_WaitReady())
{
      while(1)
      {
      }
}

//Ð´ÈëÍê³É£¬Æ¬Ñ¡ÖÃ1
SD_CS_DISABLE();
SPI_ReadWriteByte(0xff);

return count; //·µ»ØcountÖµ£¬Èç¹ûÐ´ÍêÔòcount=0£¬·ñÔòcount=1
}

赞 0 评论