Picproje Elektronik Sitesi

DİJİTAL & ANALOG ELEKTRONİK => Malzeme Bilgisi => Konuyu başlatan: z - 15 Kasım 2013, 15:29:50

Başlık: SD kart komut seti
Gönderen: z - 15 Kasım 2013, 15:29:50
SD kart konnektörünü barındıran kit ve bir tane 8GB SD kart aldım ve kod yazmaya başlayacağım.

Google'da SD card command set diye arama yaptığımda bulunan dokümanlarda cmd0 cmd1,... şeklinde komut seti anlatımları var. Henüz detaylı olarak incelemedim ama ben doğrudan komut setinin atıyorum 0x40 0x30 gönder 0x44 cevap al gibi komutların hex karşılıklarını ve giden/gelen flag bitlerinin anlatımlarının olduğu dokümanı arıyorum. Henüz bulamadım.

İncelediğim dokumanlardan bazıları.

http://www.barissamanci.net/Makale/11/sd-kart-programlama-klavuzu/ (http://www.barissamanci.net/Makale/11/sd-kart-programlama-klavuzu/)
https://www.sdcard.org/downloads/pls/simplified_specs/archive/partE1_100.pdf (https://www.sdcard.org/downloads/pls/simplified_specs/archive/partE1_100.pdf)

Öyle bir dokuman bulayım ki programı yazmak için tamamen rehberim olsun.

Kim yardımcı olabilir?
Başlık: Ynt: SD kart komut seti
Gönderen: fgokcegoz - 15 Kasım 2013, 15:43:32
SPI üzerinden haberleştiriyorsanız, forumdan hasan isminde bir arkadaşın hazırladığı giriş seviyesinde işinizi bu döküman görebilir.
http://www.mediafire.com/?0f2iuwk8z62sdk0 (http://www.mediafire.com/?0f2iuwk8z62sdk0)

SDIO kullanıyorsanız pek işinize yaramayabilir ama sd kartı anlamak için yinede faydalı olur.
Başlık: Ynt: SD kart komut seti
Gönderen: ECHO - 15 Kasım 2013, 16:17:53
İbrahim DOĞAN'ın kitapları var   http://www.amazon.com/Card-Projects-Using-PIC-Microcontroller/dp/185617719X (http://www.amazon.com/Card-Projects-Using-PIC-Microcontroller/dp/185617719X)
Başlık: Ynt: SD kart komut seti
Gönderen: z - 15 Kasım 2013, 17:43:07
Sanırım anladım. CMD0 da kod 0 oluyor. CMD1 de de 1. Bu durumda Cmdx de x oluyor.

CMD yi 6 bitle kodluyoruz. Başına Host vs bitleri koyup asıl komutu olusturuyoruz.
Başlık: Ynt: SD kart komut seti
Gönderen: homer380 - 15 Kasım 2013, 17:57:10
Alıntı yapılan: fgokcegoz - 15 Kasım 2013, 15:43:32
http://www.mediafire.com/?0f2iuwk8z62sdk0 (http://www.mediafire.com/?0f2iuwk8z62sdk0)
burdaki döküman gerçekten güzel fakat 2gb üstünün komut dizilimi biraz farklı olabiliyormuş. bunu bizzat yaşadım. umarım istediğinizi bulursunuz vve bizide bu konuda bilgilendirirsiniz. kolay gelsin.
Başlık: Ynt: SD kart komut seti
Gönderen: Ramiz - 15 Kasım 2013, 21:21:48
Sd kartı ram yada eepromlardaki mantık ile kullanabiliyormuyuz? Yani 0. adres, 1. adres gibi?
Başlık: Ynt: SD kart komut seti
Gönderen: fgokcegoz - 15 Kasım 2013, 21:25:30
STM32F3xx için SPI üzerinden SD Kart Haberleşmesi için örnek kütüphane...

/**
  ******************************************************************************
  * @file    stm32373c_eval_spi_sd.c
  * @author  MCD Application Team
  * @version V1.0.0
  * @date    20-September-2012
  * @brief   This file provides a set of functions needed to manage the SPI SD
  *          Card memory mounted on STM32373C-EVAL board.
  *          It implements a high level communication layer for read and write
  *          from/to this memory. The needed STM32F37x hardware resources (SPI and
  *          GPIO) are defined in stm32373c_eval.h file, and the initialization is
  *          performed in SD_LowLevel_Init() function declared in stm32373c_eval.c
  *          file.
  *          You can easily tailor this driver to any other development board,
  *          by just adapting the defines for hardware resources and
  *          SD_LowLevel_Init() function.
  *           
  *          +-------------------------------------------------------+
  *          |                     Pin assignment                    |
  *          +-------------------------+---------------+-------------+
  *          |  STM32F0xx SPI Pins     |     SD        |    Pin      |
  *          +-------------------------+---------------+-------------+
  *          | SD_SPI_CS_PIN           |   ChipSelect  |    1        |
  *          | SD_SPI_MOSI_PIN / MOSI  |   DataIn      |    2        |
  *          |                         |   GND         |    3 (0 V)  |
  *          |                         |   VDD         |    4 (3.3 V)|
  *          | SD_SPI_SCK_PIN / SCLK   |   Clock       |    5        |
  *          |                         |   GND         |    6 (0 V)  |
  *          | SD_SPI_MISO_PIN / MISO  |   DataOut     |    7        |
  *          +-------------------------+---------------+-------------+
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; COPYRIGHT 2012 STMicroelectronics</center></h2>
  *
  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
  * You may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
  *
  *        http://www.st.com/software_license_agreement_liberty_v2
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "stm32373c_eval_spi_sd.h"

/** @addtogroup Utilities
  * @{
  */
 
/** @addtogroup STM32_EVAL
  * @{
  */

/** @addtogroup STM32373C_EVAL
  * @{
  */

/** @addtogroup STM32373C_EVAL_SPI_SD
  * @brief      This file includes the SD card driver of STM32373C-EVAL boards.
  * @{
  */

/** @defgroup STM32373C_EVAL_SPI_SD_Private_Types
  * @{
  */
/**
  * @}
  */


/** @defgroup STM32373C_EVAL_SPI_SD_Private_Defines
  * @{
  */
/**
  * @}
  */

/** @defgroup STM32373C_EVAL_SPI_SD_Private_Macros
  * @{
  */
/**
  * @}
  */
 

/** @defgroup STM32373C_EVAL_SPI_SD_Private_Variables
  * @{
  */

/**
  * @}
  */


/** @defgroup STM32373C_EVAL_SPI_SD_Private_Function_Prototypes
  * @{
  */
/**
  * @}
  */


/** @defgroup STM32373C_EVAL_SPI_SD_Private_Functions
  * @{
  */

/**
  * @brief  DeInitializes the SD/SD communication.
  * @param  None
  * @retval None
  */
void SD_DeInit(void)
{
  SD_LowLevel_DeInit();
}

/**
  * @brief  Initializes the SD/SD communication.
  * @param  None
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_Init(void)
{
  uint32_t i = 0;

  /*!< Initialize SD_SPI */
  SD_LowLevel_Init();

  /*!< SD chip select high */
  SD_CS_HIGH();

  /*!< Send dummy byte 0xFF, 10 times with CS high */
  /*!< Rise CS and MOSI for 80 clocks cycles */
  for (i = 0; i <= 9; i++)
  {
    /*!< Send dummy byte 0xFF */
    SD_WriteByte(SD_DUMMY_BYTE);
  }
 
  /*------------Put SD in SPI mode--------------*/
  /*!< SD initialized and set to SPI mode properly */
  return (SD_GoIdleState());
}

/**
* @brief  Detect if SD card is correctly plugged in the memory slot.
* @param  None
* @retval Return if SD is detected or not
*/
uint8_t SD_Detect(void)
{
  __IO uint8_t status = SD_PRESENT;

  /*!< Check GPIO to detect SD */
  if (GPIO_ReadInputData(SD_DETECT_GPIO_PORT) & SD_DETECT_PIN)
  {
    status = SD_NOT_PRESENT;
  }
  return status;
}

/**
  * @brief  Returns information about specific card.
  * @param  cardinfo: pointer to a SD_CardInfo structure that contains all SD
  *         card information.
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo)
{
  SD_Error status = SD_RESPONSE_FAILURE;

  SD_GetCSDRegister(&(cardinfo->SD_csd));
  status = SD_GetCIDRegister(&(cardinfo->SD_cid));
  cardinfo->CardCapacity = (cardinfo->SD_csd.DeviceSize + 1) ;
  cardinfo->CardCapacity *= (1 << (cardinfo->SD_csd.DeviceSizeMul + 2));
  cardinfo->CardBlockSize = 1 << (cardinfo->SD_csd.RdBlockLen);
  cardinfo->CardCapacity *= cardinfo->CardBlockSize;

  /*!< Returns the reponse */
  return status;
}

/**
  * @brief  Reads a block of data from the SD.
  * @param  pBuffer: pointer to the buffer that receives the data read from the
  *                  SD.
  * @param  ReadAddr: SD's internal address to read from.
  * @param  BlockSize: the SD card Data block size.
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_ReadBlock(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t BlockSize)
{
  uint32_t i = 0;
  SD_Error rvalue = SD_RESPONSE_FAILURE;
 
  /*!< SD chip select low */
  SD_CS_LOW();
 
  /*!< Send CMD17 (SD_CMD_READ_SINGLE_BLOCK) to read one block */
  SD_SendCmd(SD_CMD_READ_SINGLE_BLOCK, ReadAddr, 0xFF);
 
  /*!< Check if the SD acknowledged the read block command: R1 response (0x00: no errors) */
  if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
  {
    /*!< Now look for the data token to signify the start of the data */
    if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
    {
      /*!< Read the SD block data : read NumByteToRead data */
      for (i = 0; i < BlockSize; i++)
      {
        /*!< Save the received data */
        *pBuffer = SD_ReadByte();
       
        /*!< Point to the next location where the byte read will be saved */
        pBuffer++;
      }
      /*!< Get CRC bytes (not really needed by us, but required by SD) */
      SD_ReadByte();
      SD_ReadByte();
      /*!< Set response value to success */
      rvalue = SD_RESPONSE_NO_ERROR;
    }
  }
  /*!< SD chip select high */
  SD_CS_HIGH();
 
  /*!< Send dummy byte: 8 Clock pulses of delay */
  SD_WriteByte(SD_DUMMY_BYTE);
 
  /*!< Returns the reponse */
  return rvalue;
}

/**
  * @brief  Reads multiple block of data from the SD.
  * @param  pBuffer: pointer to the buffer that receives the data read from the
  *                  SD.
  * @param  ReadAddr: SD's internal address to read from.
  * @param  BlockSize: the SD card Data block size.
  * @param  NumberOfBlocks: number of blocks to be read.
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_ReadMultiBlocks(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t BlockSize, uint32_t NumberOfBlocks)
{
  uint32_t i = 0, Offset = 0;
  SD_Error rvalue = SD_RESPONSE_FAILURE;
 
  /*!< SD chip select low */
  SD_CS_LOW();
  /*!< Data transfer */
  while (NumberOfBlocks--)
  {
    /*!< Send CMD17 (SD_CMD_READ_SINGLE_BLOCK) to read one block */
    SD_SendCmd (SD_CMD_READ_SINGLE_BLOCK, ReadAddr + Offset, 0xFF);
    /*!< Check if the SD acknowledged the read block command: R1 response (0x00: no errors) */
    if (SD_GetResponse(SD_RESPONSE_NO_ERROR))
    {
      return  SD_RESPONSE_FAILURE;
    }
    /*!< Now look for the data token to signify the start of the data */
    if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
    {
      /*!< Read the SD block data : read NumByteToRead data */
      for (i = 0; i < BlockSize; i++)
      {
        /*!< Read the pointed data */
        *pBuffer = SD_ReadByte();
        /*!< Point to the next location where the byte read will be saved */
        pBuffer++;
      }
      /*!< Set next read address*/
      Offset += 512;
      /*!< get CRC bytes (not really needed by us, but required by SD) */
      SD_ReadByte();
      SD_ReadByte();
      /*!< Set response value to success */
      rvalue = SD_RESPONSE_NO_ERROR;
    }
    else
    {
      /*!< Set response value to failure */
      rvalue = SD_RESPONSE_FAILURE;
    }
  }
  /*!< SD chip select high */
  SD_CS_HIGH();
  /*!< Send dummy byte: 8 Clock pulses of delay */
  SD_WriteByte(SD_DUMMY_BYTE);
  /*!< Returns the reponse */
  return rvalue;
}

/**
  * @brief  Writes a block on the SD
  * @param  pBuffer: pointer to the buffer containing the data to be written on
  *                  the SD.
  * @param  WriteAddr: address to write on.
  * @param  BlockSize: the SD card Data block size.
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_WriteBlock(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t BlockSize)
{
  uint32_t i = 0;
  SD_Error rvalue = SD_RESPONSE_FAILURE;

  /*!< SD chip select low */
  SD_CS_LOW();

  /*!< Send CMD24 (SD_CMD_WRITE_SINGLE_BLOCK) to write multiple block */
  SD_SendCmd(SD_CMD_WRITE_SINGLE_BLOCK, WriteAddr, 0xFF);
 
  /*!< Check if the SD acknowledged the write block command: R1 response (0x00: no errors) */
  if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
  {
    /*!< Send a dummy byte */
    SD_WriteByte(SD_DUMMY_BYTE);

    /*!< Send the data token to signify the start of the data */
    SD_WriteByte(0xFE);

    /*!< Write the block data to SD : write count data by block */
    for (i = 0; i < BlockSize; i++)
    {
      /*!< Send the pointed byte */
      SD_WriteByte(*pBuffer);
      /*!< Point to the next location where the byte read will be saved */
      pBuffer++;
    }
    /*!< Put CRC bytes (not really needed by us, but required by SD) */
    SD_ReadByte();
    SD_ReadByte();
    /*!< Read data response */
    if (SD_GetDataResponse() == SD_DATA_OK)
    {
      rvalue = SD_RESPONSE_NO_ERROR;
    }
  }
  /*!< SD chip select high */
  SD_CS_HIGH();
  /*!< Send dummy byte: 8 Clock pulses of delay */
  SD_WriteByte(SD_DUMMY_BYTE);

  /*!< Returns the reponse */
  return rvalue;
}

/**
  * @brief  Writes many blocks on the SD
  * @param  pBuffer: pointer to the buffer containing the data to be written on
  *                  the SD.
  * @param  WriteAddr: address to write on.
  * @param  BlockSize: the SD card Data block size.
  * @param  NumberOfBlocks: number of blocks to be written.
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_WriteMultiBlocks(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t BlockSize, uint32_t NumberOfBlocks)
{
  uint32_t i = 0, Offset = 0;
  SD_Error rvalue = SD_RESPONSE_FAILURE;

  /*!< SD chip select low */
  SD_CS_LOW();
  /*!< Data transfer */
  while (NumberOfBlocks--)
  {
    /*!< Send CMD24 (SD_CMD_WRITE_SINGLE_BLOCK) to write blocks */
    SD_SendCmd(SD_CMD_WRITE_SINGLE_BLOCK, WriteAddr + Offset, 0xFF);
    /*!< Check if the SD acknowledged the write block command: R1 response (0x00: no errors) */
    if (SD_GetResponse(SD_RESPONSE_NO_ERROR))
    {
      return SD_RESPONSE_FAILURE;
    }
    /*!< Send dummy byte */
    SD_WriteByte(SD_DUMMY_BYTE);
    /*!< Send the data token to signify the start of the data */
    SD_WriteByte(SD_START_DATA_SINGLE_BLOCK_WRITE);
    /*!< Write the block data to SD : write count data by block */
    for (i = 0; i < BlockSize; i++)
    {
      /*!< Send the pointed byte */
      SD_WriteByte(*pBuffer);
      /*!< Point to the next location where the byte read will be saved */
      pBuffer++;
    }
    /*!< Set next write address */
    Offset += 512;
    /*!< Put CRC bytes (not really needed by us, but required by SD) */
    SD_ReadByte();
    SD_ReadByte();
    /*!< Read data response */
    if (SD_GetDataResponse() == SD_DATA_OK)
    {
      /*!< Set response value to success */
      rvalue = SD_RESPONSE_NO_ERROR;
    }
    else
    {
      /*!< Set response value to failure */
      rvalue = SD_RESPONSE_FAILURE;
    }
  }
  /*!< SD chip select high */
  SD_CS_HIGH();
  /*!< Send dummy byte: 8 Clock pulses of delay */
  SD_WriteByte(SD_DUMMY_BYTE);
  /*!< Returns the reponse */
  return rvalue;
}

/**
  * @brief  Read the CSD card register.
  *         Reading the contents of the CSD register in SPI mode is a simple
  *         read-block transaction.
  * @param  SD_csd: pointer on an SCD register structure
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_GetCSDRegister(SD_CSD* SD_csd)
{
  uint32_t i = 0;
  SD_Error rvalue = SD_RESPONSE_FAILURE;
  uint8_t CSD_Tab[16];

  /*!< SD chip select low */
  SD_CS_LOW();
  /*!< Send CMD9 (CSD register) or CMD10(CSD register) */
  SD_SendCmd(SD_CMD_SEND_CSD, 0, 0xFF);
  /*!< Wait for response in the R1 format (0x00 is no errors) */
  if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
  {
    if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
    {
      for (i = 0; i < 16; i++)
      {
        /*!< Store CSD register value on CSD_Tab */
        CSD_Tab[i] = SD_ReadByte();
      }
    }
    /*!< Get CRC bytes (not really needed by us, but required by SD) */
    SD_WriteByte(SD_DUMMY_BYTE);
    SD_WriteByte(SD_DUMMY_BYTE);
    /*!< Set response value to success */
    rvalue = SD_RESPONSE_NO_ERROR;
  }
  /*!< SD chip select high */
  SD_CS_HIGH();
  /*!< Send dummy byte: 8 Clock pulses of delay */
  SD_WriteByte(SD_DUMMY_BYTE);

  /*!< Byte 0 */
  SD_csd->CSDStruct = (CSD_Tab[0] & 0xC0) >> 6;
  SD_csd->SysSpecVersion = (CSD_Tab[0] & 0x3C) >> 2;
  SD_csd->Reserved1 = CSD_Tab[0] & 0x03;

  /*!< Byte 1 */
  SD_csd->TAAC = CSD_Tab[1];

  /*!< Byte 2 */
  SD_csd->NSAC = CSD_Tab[2];

  /*!< Byte 3 */
  SD_csd->MaxBusClkFrec = CSD_Tab[3];

  /*!< Byte 4 */
  SD_csd->CardComdClasses = CSD_Tab[4] << 4;

  /*!< Byte 5 */
  SD_csd->CardComdClasses |= (CSD_Tab[5] & 0xF0) >> 4;
  SD_csd->RdBlockLen = CSD_Tab[5] & 0x0F;

  /*!< Byte 6 */
  SD_csd->PartBlockRead = (CSD_Tab[6] & 0x80) >> 7;
  SD_csd->WrBlockMisalign = (CSD_Tab[6] & 0x40) >> 6;
  SD_csd->RdBlockMisalign = (CSD_Tab[6] & 0x20) >> 5;
  SD_csd->DSRImpl = (CSD_Tab[6] & 0x10) >> 4;
  SD_csd->Reserved2 = 0; /*!< Reserved */

  SD_csd->DeviceSize = (CSD_Tab[6] & 0x03) << 10;

  /*!< Byte 7 */
  SD_csd->DeviceSize |= (CSD_Tab[7]) << 2;

  /*!< Byte 8 */
  SD_csd->DeviceSize |= (CSD_Tab[8] & 0xC0) >> 6;

  SD_csd->MaxRdCurrentVDDMin = (CSD_Tab[8] & 0x38) >> 3;
  SD_csd->MaxRdCurrentVDDMax = (CSD_Tab[8] & 0x07);

  /*!< Byte 9 */
  SD_csd->MaxWrCurrentVDDMin = (CSD_Tab[9] & 0xE0) >> 5;
  SD_csd->MaxWrCurrentVDDMax = (CSD_Tab[9] & 0x1C) >> 2;
  SD_csd->DeviceSizeMul = (CSD_Tab[9] & 0x03) << 1;
  /*!< Byte 10 */
  SD_csd->DeviceSizeMul |= (CSD_Tab[10] & 0x80) >> 7;
   
  SD_csd->EraseGrSize = (CSD_Tab[10] & 0x40) >> 6;
  SD_csd->EraseGrMul = (CSD_Tab[10] & 0x3F) << 1;

  /*!< Byte 11 */
  SD_csd->EraseGrMul |= (CSD_Tab[11] & 0x80) >> 7;
  SD_csd->WrProtectGrSize = (CSD_Tab[11] & 0x7F);

  /*!< Byte 12 */
  SD_csd->WrProtectGrEnable = (CSD_Tab[12] & 0x80) >> 7;
  SD_csd->ManDeflECC = (CSD_Tab[12] & 0x60) >> 5;
  SD_csd->WrSpeedFact = (CSD_Tab[12] & 0x1C) >> 2;
  SD_csd->MaxWrBlockLen = (CSD_Tab[12] & 0x03) << 2;

  /*!< Byte 13 */
  SD_csd->MaxWrBlockLen |= (CSD_Tab[13] & 0xC0) >> 6;
  SD_csd->WriteBlockPaPartial = (CSD_Tab[13] & 0x20) >> 5;
  SD_csd->Reserved3 = 0;
  SD_csd->ContentProtectAppli = (CSD_Tab[13] & 0x01);

  /*!< Byte 14 */
  SD_csd->FileFormatGrouop = (CSD_Tab[14] & 0x80) >> 7;
  SD_csd->CopyFlag = (CSD_Tab[14] & 0x40) >> 6;
  SD_csd->PermWrProtect = (CSD_Tab[14] & 0x20) >> 5;
  SD_csd->TempWrProtect = (CSD_Tab[14] & 0x10) >> 4;
  SD_csd->FileFormat = (CSD_Tab[14] & 0x0C) >> 2;
  SD_csd->ECC = (CSD_Tab[14] & 0x03);

  /*!< Byte 15 */
  SD_csd->CSD_CRC = (CSD_Tab[15] & 0xFE) >> 1;
  SD_csd->Reserved4 = 1;

  /*!< Return the reponse */
  return rvalue;
}

/**
  * @brief  Read the CID card register.
  *         Reading the contents of the CID register in SPI mode is a simple
  *         read-block transaction.
  * @param  SD_cid: pointer on an CID register structure
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_GetCIDRegister(SD_CID* SD_cid)
{
  uint32_t i = 0;
  SD_Error rvalue = SD_RESPONSE_FAILURE;
  uint8_t CID_Tab[16];
 
  /*!< SD chip select low */
  SD_CS_LOW();
 
  /*!< Send CMD10 (CID register) */
  SD_SendCmd(SD_CMD_SEND_CID, 0, 0xFF);
 
  /*!< Wait for response in the R1 format (0x00 is no errors) */
  if (!SD_GetResponse(SD_RESPONSE_NO_ERROR))
  {
    if (!SD_GetResponse(SD_START_DATA_SINGLE_BLOCK_READ))
    {
      /*!< Store CID register value on CID_Tab */
      for (i = 0; i < 16; i++)
      {
        CID_Tab[i] = SD_ReadByte();
      }
    }
    /*!< Get CRC bytes (not really needed by us, but required by SD) */
    SD_WriteByte(SD_DUMMY_BYTE);
    SD_WriteByte(SD_DUMMY_BYTE);
    /*!< Set response value to success */
    rvalue = SD_RESPONSE_NO_ERROR;
  }
  /*!< SD chip select high */
  SD_CS_HIGH();
  /*!< Send dummy byte: 8 Clock pulses of delay */
  SD_WriteByte(SD_DUMMY_BYTE);

  /*!< Byte 0 */
  SD_cid->ManufacturerID = CID_Tab[0];

  /*!< Byte 1 */
  SD_cid->OEM_AppliID = CID_Tab[1] << 8;

  /*!< Byte 2 */
  SD_cid->OEM_AppliID |= CID_Tab[2];

  /*!< Byte 3 */
  SD_cid->ProdName1 = CID_Tab[3] << 24;

  /*!< Byte 4 */
  SD_cid->ProdName1 |= CID_Tab[4] << 16;

  /*!< Byte 5 */
  SD_cid->ProdName1 |= CID_Tab[5] << 8;

  /*!< Byte 6 */
  SD_cid->ProdName1 |= CID_Tab[6];

  /*!< Byte 7 */
  SD_cid->ProdName2 = CID_Tab[7];

  /*!< Byte 8 */
  SD_cid->ProdRev = CID_Tab[8];

  /*!< Byte 9 */
  SD_cid->ProdSN = CID_Tab[9] << 24;

  /*!< Byte 10 */
  SD_cid->ProdSN |= CID_Tab[10] << 16;

  /*!< Byte 11 */
  SD_cid->ProdSN |= CID_Tab[11] << 8;

  /*!< Byte 12 */
  SD_cid->ProdSN |= CID_Tab[12];

  /*!< Byte 13 */
  SD_cid->Reserved1 |= (CID_Tab[13] & 0xF0) >> 4;
  SD_cid->ManufactDate = (CID_Tab[13] & 0x0F) << 8;

  /*!< Byte 14 */
  SD_cid->ManufactDate |= CID_Tab[14];

  /*!< Byte 15 */
  SD_cid->CID_CRC = (CID_Tab[15] & 0xFE) >> 1;
  SD_cid->Reserved2 = 1;

  /*!< Return the reponse */
  return rvalue;
}

/**
  * @brief  Send 5 bytes command to the SD card.
  * @param  Cmd: The user expected command to send to SD card.
  * @param  Arg: The command argument.
  * @param  Crc: The CRC.
  * @retval None
  */
void SD_SendCmd(uint8_t Cmd, uint32_t Arg, uint8_t Crc)
{
  uint32_t i = 0x00;
 
  uint8_t Frame[6];
 
  Frame[0] = (Cmd | 0x40); /*!< Construct byte 1 */
 
  Frame[1] = (uint8_t)(Arg >> 24); /*!< Construct byte 2 */
 
  Frame[2] = (uint8_t)(Arg >> 16); /*!< Construct byte 3 */
 
  Frame[3] = (uint8_t)(Arg >> 8); /*!< Construct byte 4 */
 
  Frame[4] = (uint8_t)(Arg); /*!< Construct byte 5 */
 
  Frame[5] = (Crc); /*!< Construct CRC: byte 6 */
 
  for (i = 0; i < 6; i++)
  {
    SD_WriteByte(Frame[i]); /*!< Send the Cmd bytes */
  }
}

/**
  * @brief  Get SD card data response.
  * @param  None
  * @retval The SD status: Read data response xxx0<status>1
  *         - status 010: Data accecpted
  *         - status 101: Data rejected due to a crc error
  *         - status 110: Data rejected due to a Write error.
  *         - status 111: Data rejected due to other error.
  */
uint8_t SD_GetDataResponse(void)
{
  uint32_t i = 0;
  uint8_t response, rvalue;

  while (i <= 64)
  {
    /*!< Read resonse */
    response = SD_ReadByte();
    /*!< Mask unused bits */
    response &= 0x1F;
    switch (response)
    {
      case SD_DATA_OK:
      {
        rvalue = SD_DATA_OK;
        break;
      }
      case SD_DATA_CRC_ERROR:
        return SD_DATA_CRC_ERROR;
      case SD_DATA_WRITE_ERROR:
        return SD_DATA_WRITE_ERROR;
      default:
      {
        rvalue = SD_DATA_OTHER_ERROR;
        break;
      }
    }
    /*!< Exit loop in case of data ok */
    if (rvalue == SD_DATA_OK)
      break;
    /*!< Increment loop counter */
    i++;
  }

  /*!< Wait null data */
  while (SD_ReadByte() == 0);

  /*!< Return response */
  return response;
}

/**
  * @brief  Returns the SD response.
  * @param  None
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_GetResponse(uint8_t Response)
{
  uint32_t Count = 0xFFF;

  /* Check if response is got or a timeout is happen */
  while ((SD_ReadByte() != Response) && Count)
  {
    Count--;
  }

  if (Count == 0)
  {
    /* After time out */
    return SD_RESPONSE_FAILURE;
  }
  else
  {
    /* Right response got */
    return SD_RESPONSE_NO_ERROR;
  }
}

/**
  * @brief  Returns the SD status.
  * @param  None
  * @retval The SD status.
  */
uint16_t SD_GetStatus(void)
{
  uint16_t Status = 0;

  /*!< SD chip select low */
  SD_CS_LOW();

  /*!< Send CMD13 (SD_SEND_STATUS) to get SD status */
  SD_SendCmd(SD_CMD_SEND_STATUS, 0, 0xFF);

  Status = SD_ReadByte();
  Status |= (uint16_t)(SD_ReadByte() << 8);

  /*!< SD chip select high */
  SD_CS_HIGH();

  /*!< Send dummy byte 0xFF */
  SD_WriteByte(SD_DUMMY_BYTE);

  return Status;
}

/**
  * @brief  Put SD in Idle state.
  * @param  None
  * @retval The SD Response:
  *         - SD_RESPONSE_FAILURE: Sequence failed
  *         - SD_RESPONSE_NO_ERROR: Sequence succeed
  */
SD_Error SD_GoIdleState(void)
{
  /*!< SD chip select low */
  SD_CS_LOW();
 
  /*!< Send CMD0 (SD_CMD_GO_IDLE_STATE) to put SD in SPI mode */
  SD_SendCmd(SD_CMD_GO_IDLE_STATE, 0, 0x95);
 
  /*!< Wait for In Idle State Response (R1 Format) equal to 0x01 */
  if (SD_GetResponse(SD_IN_IDLE_STATE))
  {
    /*!< No Idle State Response: return response failue */
    return SD_RESPONSE_FAILURE;
  }
  /*----------Activates the card initialization process-----------*/
  do
  {
    /*!< SD chip select high */
    SD_CS_HIGH();
   
    /*!< Send Dummy byte 0xFF */
    SD_WriteByte(SD_DUMMY_BYTE);
   
    /*!< SD chip select low */
    SD_CS_LOW();
   
    /*!< Send CMD1 (Activates the card process) until response equal to 0x0 */
    SD_SendCmd(SD_CMD_SEND_OP_COND, 0, 0xFF);
    /*!< Wait for no error Response (R1 Format) equal to 0x00 */
  }
  while (SD_GetResponse(SD_RESPONSE_NO_ERROR));
 
  /*!< SD chip select high */
  SD_CS_HIGH();
 
  /*!< Send dummy byte 0xFF */
  SD_WriteByte(SD_DUMMY_BYTE);
 
  return SD_RESPONSE_NO_ERROR;
}

/**
  * @brief  Write a byte on the SD.
  * @param  Data: byte to send.
  * @retval None
  */
uint8_t SD_WriteByte(uint8_t Data)
{
  /*!< Wait until the transmit buffer is empty */
  while(SPI_I2S_GetFlagStatus(SD_SPI, SPI_I2S_FLAG_TXE) == RESET)
  {
  }
 
  /*!< Send the byte */
  SPI_SendData8(SD_SPI, Data);
 
  /*!< Wait to receive a byte*/
  while(SPI_I2S_GetFlagStatus(SD_SPI, SPI_I2S_FLAG_RXNE) == RESET)
  {
  }
 
  /*!< Return the byte read from the SPI bus */
  return SPI_ReceiveData8(SD_SPI);
}

/**
  * @brief  Read a byte from the SD.
  * @param  None
  * @retval The received byte.
  */
uint8_t SD_ReadByte(void)
{
  uint8_t Data = 0;
 
  /*!< Wait until the transmit buffer is empty */
  while (SPI_I2S_GetFlagStatus(SD_SPI, SPI_I2S_FLAG_TXE) == RESET)
  {
  }
  /*!< Send the byte */
  SPI_SendData8(SD_SPI, SD_DUMMY_BYTE);

  /*!< Wait until a data is received */
  while (SPI_I2S_GetFlagStatus(SD_SPI, SPI_I2S_FLAG_RXNE) == RESET)
  {
  }
  /*!< Get the received data */
  Data = SPI_ReceiveData8(SD_SPI);

  /*!< Return the shifted data */
  return Data;
}

/**
  * @}
  */


/**
  * @}
  */


/**
  * @}
  */

/**
  * @}
  */

/**
  * @}
  */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/




/**
  ******************************************************************************
  * @file    stm32373c_eval_spi_sd.h
  * @author  MCD Application Team
  * @version V1.0.0
  * @date    20-September-2012
  * @brief   This file contains all the functions prototypes for the stm32373c_eval_spi_sd
  *          firmware driver.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; COPYRIGHT 2012 STMicroelectronics</center></h2>
  *
  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
  * You may not use this file except in compliance with the License.
  * You may obtain a copy of the License at:
  *
  *        http://www.st.com/software_license_agreement_liberty_v2
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  ******************************************************************************
  */

/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __STM32373C_EVAL_SPI_SD_H
#define __STM32373C_EVAL_SPI_SD_H

#ifdef __cplusplus
extern "C" {
#endif

/* Includes ------------------------------------------------------------------*/
#include "stm32373c_eval.h"

/** @addtogroup Utilities
  * @{
  */
 
/** @addtogroup STM32_EVAL
  * @{
  */

/** @addtogroup STM32373C_EVAL
  * @{
  */

/** @addtogroup STM32373C_EVAL_SPI_SD
  * @{
  */ 

/** @defgroup STM32373C_EVAL_SPI_SD_Exported_Types
  * @{
  */

typedef enum
{
/**
  * @brief  SD reponses and error flags
  */
  SD_RESPONSE_NO_ERROR      = (0x00),
  SD_IN_IDLE_STATE          = (0x01),
  SD_ERASE_RESET            = (0x02),
  SD_ILLEGAL_COMMAND        = (0x04),
  SD_COM_CRC_ERROR          = (0x08),
  SD_ERASE_SEQUENCE_ERROR   = (0x10),
  SD_ADDRESS_ERROR          = (0x20),
  SD_PARAMETER_ERROR        = (0x40),
  SD_RESPONSE_FAILURE       = (0xFF),

/**
  * @brief  Data response error
  */
  SD_DATA_OK                = (0x05),
  SD_DATA_CRC_ERROR         = (0x0B),
  SD_DATA_WRITE_ERROR       = (0x0D),
  SD_DATA_OTHER_ERROR       = (0xFF)
} SD_Error;

/**
  * @brief  Card Specific Data: CSD Register
  */
typedef struct
{
  __IO uint8_t  CSDStruct;            /*!< CSD structure */
  __IO uint8_t  SysSpecVersion;       /*!< System specification version */
  __IO uint8_t  Reserved1;            /*!< Reserved */
  __IO uint8_t  TAAC;                 /*!< Data read access-time 1 */
  __IO uint8_t  NSAC;                 /*!< Data read access-time 2 in CLK cycles */
  __IO uint8_t  MaxBusClkFrec;        /*!< Max. bus clock frequency */
  __IO uint16_t CardComdClasses;      /*!< Card command classes */
  __IO uint8_t  RdBlockLen;           /*!< Max. read data block length */
  __IO uint8_t  PartBlockRead;        /*!< Partial blocks for read allowed */
  __IO uint8_t  WrBlockMisalign;      /*!< Write block misalignment */
  __IO uint8_t  RdBlockMisalign;      /*!< Read block misalignment */
  __IO uint8_t  DSRImpl;              /*!< DSR implemented */
  __IO uint8_t  Reserved2;            /*!< Reserved */
  __IO uint32_t DeviceSize;           /*!< Device Size */
  __IO uint8_t  MaxRdCurrentVDDMin;   /*!< Max. read current @ VDD min */
  __IO uint8_t  MaxRdCurrentVDDMax;   /*!< Max. read current @ VDD max */
  __IO uint8_t  MaxWrCurrentVDDMin;   /*!< Max. write current @ VDD min */
  __IO uint8_t  MaxWrCurrentVDDMax;   /*!< Max. write current @ VDD max */
  __IO uint8_t  DeviceSizeMul;        /*!< Device size multiplier */
  __IO uint8_t  EraseGrSize;          /*!< Erase group size */
  __IO uint8_t  EraseGrMul;           /*!< Erase group size multiplier */
  __IO uint8_t  WrProtectGrSize;      /*!< Write protect group size */
  __IO uint8_t  WrProtectGrEnable;    /*!< Write protect group enable */
  __IO uint8_t  ManDeflECC;           /*!< Manufacturer default ECC */
  __IO uint8_t  WrSpeedFact;          /*!< Write speed factor */
  __IO uint8_t  MaxWrBlockLen;        /*!< Max. write data block length */
  __IO uint8_t  WriteBlockPaPartial;  /*!< Partial blocks for write allowed */
  __IO uint8_t  Reserved3;            /*!< Reserded */
  __IO uint8_t  ContentProtectAppli;  /*!< Content protection application */
  __IO uint8_t  FileFormatGrouop;     /*!< File format group */
  __IO uint8_t  CopyFlag;             /*!< Copy flag (OTP) */
  __IO uint8_t  PermWrProtect;        /*!< Permanent write protection */
  __IO uint8_t  TempWrProtect;        /*!< Temporary write protection */
  __IO uint8_t  FileFormat;           /*!< File Format */
  __IO uint8_t  ECC;                  /*!< ECC code */
  __IO uint8_t  CSD_CRC;              /*!< CSD CRC */
  __IO uint8_t  Reserved4;            /*!< always 1*/
} SD_CSD;

/**
  * @brief  Card Identification Data: CID Register   
  */
typedef struct
{
  __IO uint8_t  ManufacturerID;       /*!< ManufacturerID */
  __IO uint16_t OEM_AppliID;          /*!< OEM/Application ID */
  __IO uint32_t ProdName1;            /*!< Product Name part1 */
  __IO uint8_t  ProdName2;            /*!< Product Name part2*/
  __IO uint8_t  ProdRev;              /*!< Product Revision */
  __IO uint32_t ProdSN;               /*!< Product Serial Number */
  __IO uint8_t  Reserved1;            /*!< Reserved1 */
  __IO uint16_t ManufactDate;         /*!< Manufacturing Date */
  __IO uint8_t  CID_CRC;              /*!< CID CRC */
  __IO uint8_t  Reserved2;            /*!< always 1 */
} SD_CID;

/**
  * @brief SD Card information
  */
typedef struct
{
  SD_CSD SD_csd;
  SD_CID SD_cid;
  uint32_t CardCapacity;  /*!< Card Capacity */
  uint32_t CardBlockSize; /*!< Card Block Size */
} SD_CardInfo;

/**
  * @}
  */
 
/** @defgroup STM32373C_EVAL_SPI_SD_Exported_Constants
  * @{
  */
   
/**
  * @brief  Block Size
  */
#define SD_BLOCK_SIZE    0x200

/**
  * @brief  Dummy byte
  */
#define SD_DUMMY_BYTE   0xFF

/**
  * @brief  Start Data tokens:
  *         Tokens (necessary because at nop/idle (and CS active) only 0xff is
  *         on the data/command line) 
  */
#define SD_START_DATA_SINGLE_BLOCK_READ    0xFE  /*!< Data token start byte, Start Single Block Read */
#define SD_START_DATA_MULTIPLE_BLOCK_READ  0xFE  /*!< Data token start byte, Start Multiple Block Read */
#define SD_START_DATA_SINGLE_BLOCK_WRITE   0xFE  /*!< Data token start byte, Start Single Block Write */
#define SD_START_DATA_MULTIPLE_BLOCK_WRITE 0xFD  /*!< Data token start byte, Start Multiple Block Write */
#define SD_STOP_DATA_MULTIPLE_BLOCK_WRITE  0xFD  /*!< Data toke stop byte, Stop Multiple Block Write */

/**
  * @brief  SD detection on its memory slot
  */
#define SD_PRESENT        ((uint8_t)0x01)
#define SD_NOT_PRESENT    ((uint8_t)0x00)


/**
  * @brief  Commands: CMDxx = CMD-number | 0x40
  */
#define SD_CMD_GO_IDLE_STATE          0   /*!< CMD0 = 0x40 */
#define SD_CMD_SEND_OP_COND           1   /*!< CMD1 = 0x41 */
#define SD_CMD_SEND_CSD               9   /*!< CMD9 = 0x49 */
#define SD_CMD_SEND_CID               10  /*!< CMD10 = 0x4A */
#define SD_CMD_STOP_TRANSMISSION      12  /*!< CMD12 = 0x4C */
#define SD_CMD_SEND_STATUS            13  /*!< CMD13 = 0x4D */
#define SD_CMD_SET_BLOCKLEN           16  /*!< CMD16 = 0x50 */
#define SD_CMD_READ_SINGLE_BLOCK      17  /*!< CMD17 = 0x51 */
#define SD_CMD_READ_MULT_BLOCK        18  /*!< CMD18 = 0x52 */
#define SD_CMD_SET_BLOCK_COUNT        23  /*!< CMD23 = 0x57 */
#define SD_CMD_WRITE_SINGLE_BLOCK     24  /*!< CMD24 = 0x58 */
#define SD_CMD_WRITE_MULT_BLOCK       25  /*!< CMD25 = 0x59 */
#define SD_CMD_PROG_CSD               27  /*!< CMD27 = 0x5B */
#define SD_CMD_SET_WRITE_PROT         28  /*!< CMD28 = 0x5C */
#define SD_CMD_CLR_WRITE_PROT         29  /*!< CMD29 = 0x5D */
#define SD_CMD_SEND_WRITE_PROT        30  /*!< CMD30 = 0x5E */
#define SD_CMD_SD_ERASE_GRP_START     32  /*!< CMD32 = 0x60 */
#define SD_CMD_SD_ERASE_GRP_END       33  /*!< CMD33 = 0x61 */
#define SD_CMD_UNTAG_SECTOR           34  /*!< CMD34 = 0x62 */
#define SD_CMD_ERASE_GRP_START        35  /*!< CMD35 = 0x63 */
#define SD_CMD_ERASE_GRP_END          36  /*!< CMD36 = 0x64 */
#define SD_CMD_UNTAG_ERASE_GROUP      37  /*!< CMD37 = 0x65 */
#define SD_CMD_ERASE                  38  /*!< CMD38 = 0x66 */

/**
  * @}
  */
 
/** @defgroup STM32373C_EVAL_SPI_SD_Exported_Macros
  * @{
  */
/**
  * @brief  Select SD Card: ChipSelect pin low   
  */ 
#define SD_CS_LOW()     GPIO_ResetBits(SD_CS_GPIO_PORT, SD_CS_PIN)
/**
  * @brief  Deselect SD Card: ChipSelect pin high   
  */
#define SD_CS_HIGH()    GPIO_SetBits(SD_CS_GPIO_PORT, SD_CS_PIN)
/**
  * @}
  */

/** @defgroup STM32373C_EVAL_SPI_SD_Exported_Functions
  * @{
  */
void SD_DeInit(void); 
SD_Error SD_Init(void);
uint8_t SD_Detect(void);
SD_Error SD_GetCardInfo(SD_CardInfo *cardinfo);
SD_Error SD_ReadBlock(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t BlockSize);
SD_Error SD_ReadMultiBlocks(uint8_t* pBuffer, uint32_t ReadAddr, uint16_t BlockSize, uint32_t NumberOfBlocks);
SD_Error SD_WriteBlock(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t BlockSize);
SD_Error SD_WriteMultiBlocks(uint8_t* pBuffer, uint32_t WriteAddr, uint16_t BlockSize, uint32_t NumberOfBlocks);
SD_Error SD_GetCSDRegister(SD_CSD* SD_csd);
SD_Error SD_GetCIDRegister(SD_CID* SD_cid);

void SD_SendCmd(uint8_t Cmd, uint32_t Arg, uint8_t Crc);
SD_Error SD_GetResponse(uint8_t Response);
uint8_t SD_GetDataResponse(void);
SD_Error SD_GoIdleState(void);
uint16_t SD_GetStatus(void);

uint8_t SD_WriteByte(uint8_t byte);
uint8_t SD_ReadByte(void);

#ifdef __cplusplus
}
#endif

#endif /* __STM32373C_EVAL_SPI_SD_H */
/**
  * @}
  */

/**
  * @}
  */

/**
  * @}
  */

/**
  * @}
  */

/**
  * @}
  */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
Başlık: Ynt: SD kart komut seti
Gönderen: engerex - 15 Kasım 2013, 21:47:23
https://www.sdcard.org/developers/overview/sdio/sdio_spec/Simplified_SDIO_Card_Spec.pdf (https://www.sdcard.org/developers/overview/sdio/sdio_spec/Simplified_SDIO_Card_Spec.pdf)
Başlık: Ynt: SD kart komut seti
Gönderen: mdargut - 16 Kasım 2013, 00:13:29
http://elm-chan.org/docs/mmc/mmc_e.html (http://elm-chan.org/docs/mmc/mmc_e.html)
Başlık: Ynt: SD kart komut seti
Gönderen: CLR - 16 Kasım 2013, 00:38:29
Alıntı yapılan: Ramiz - 15 Kasım 2013, 21:21:48
Sd kartı ram yada eepromlardaki mantık ile kullanabiliyormuyuz? Yani 0. adres, 1. adres gibi?

Hayır block olarak yazılır
Başlık: Ynt: SD kart komut seti
Gönderen: camby - 16 Kasım 2013, 05:25:10
Evet hocam sd nin kendi dokumanlari var , tabi bir de fat32 icin elm chen
Başlık: Ynt: SD kart komut seti
Gönderen: kantirici - 16 Kasım 2013, 08:57:50
Alıntı yapılan: CLR - 16 Kasım 2013, 00:38:29
Hayır block olarak yazılır

Hazırcılık yaparak bir şey sorayım, diyelim 100 byte veri yazacağız. Bunun için bir blok yazmamız gerek yani 512 byte. Daha sonra ise bu yüz byte'ın bittigi yerden itibaren bir 100 byte daha yazmak istesek ve önceki 100 byte'ı bilmiyor olsak işlemler nasıl yürüyor acaba?
Başlık: Ynt: SD kart komut seti
Gönderen: CLR - 16 Kasım 2013, 10:41:10
Kolay, 512 byte okursun, 100. byte'tan sonra ram'e yeni 100 byte'ını eklersin sonra 512'sini sd karta yazarsın
Başlık: Ynt: SD kart komut seti
Gönderen: Ramiz - 16 Kasım 2013, 12:53:43
Alıntı yapılan: CLR - 16 Kasım 2013, 10:41:10
Kolay, 512 byte okursun, 100. byte'tan sonra ram'e yeni 100 byte'ını eklersin sonra 512'sini sd karta yazarsın

Daha önceden 8mb lık spi flashlar ile çalışmıştım. 3 mb a 2-3€ ödediğimi anımsıyorum.. Demek sd kart a 512 byte lık paketler halinde, istediğimizi yazıp okuyabiliyoruz. Öyleyse hafıza gerektiren projelerde, flash ic yerine sd kart kullanabiliriz :)

Peki bilgileri fat olarak saklamak istesem neler oluyor? Mesela fat kutuphanem var. sd içersinde text dosyası yaratıp, içersine birşeyler yazıp, silebiliyorum. Bu durumda işler nasıl ilerliyor?
Başlık: Ynt: SD kart komut seti
Gönderen: CLR - 16 Kasım 2013, 18:15:14
File sistemden bahsediyorsun, file sistem içinde, hangi dosyanın nerede olduğunu, hangi sektörden başladığı ve kaç sektör yer kapladığı belli, ilgili sektörlerden okuyup yazıyorsun. Örnekler programları incelersen daha anlaşılır olacaktır.
Başlık: Ynt: SD kart komut seti
Gönderen: z - 22 Kasım 2013, 13:56:14
Bu da benim SD kartlarla ilgili yazım (http://www.cncdesigner.com/wordpress/?p=3609)
Başlık: Ynt: SD kart komut seti
Gönderen: M_B - 22 Kasım 2013, 14:54:12
Alıntı yapılan: z - 22 Kasım 2013, 13:56:14
Bu da benim SD kartlarla ilgili yazım (http://www.cncdesigner.com/wordpress/?p=3609)
Hocam Klavyenize saglık.  Devamını beklıyorum.
Birde hocam Fat konusuna değinecek misiniz ?
Başlık: Ynt: SD kart komut seti
Gönderen: z - 22 Kasım 2013, 15:37:14
Fat kodlarını yazabilirsem yazısını da hazırlarım.
Başlık: Ynt: SD kart komut seti
Gönderen: ercan_t - 22 Kasım 2013, 15:41:32
hocam eline sağlık
Sd kart calışması hakkında detaylı bilgi olmuş

benim kafama takılan şu
CPU                  SD Kiti
MISO----------MISO
MOSI----------MOSI
SCLK----------SCLK
SEL   ----------CS


MISO ---- MOSI
MOSI ---- MISO

olması gerekmiyormuydu yanlış mı hatırlıyorum acep.

kolay gelsin...
Başlık: Ynt: SD kart komut seti
Gönderen: z - 22 Kasım 2013, 16:18:30
Bu tamemen kartı tasarlayan adamların karta ne yazdığı ile alakalı.

Hiç yazı olmasaydı;

Masterın outputu, Slavein inputuna bağlanır.
Master input   Slave outputa bağlanır.
Karşılıklı CLK lar da birbirine.

Elimdeki kartın üstüne pinlerin yanına adamlar işlemci kartının hangi pinin bağlanacağını yazmışlar. Bu nedenle açıklamamı karta göre yazdım. (Bu yanlış anlamayı engelleyecek şekilde yazımı editleyeyim)
Başlık: Ynt: SD kart komut seti
Gönderen: z - 23 Kasım 2013, 23:04:00
SD kart calismalari agir aksak giderken su sonuca vardim.

SD card organizasyonuna uye olunmadigi surece adam akilli her soruya aninda cevap veren dokumanlara ulasilamayacak galiba.

Organizasyonun internetteki kucuk dokumanlarinda bir suru hata var. Millet SD kart programi yazacam diye perisan olmus, forumlarda vs sorularin biri bin para.

Iyi bir dokuman bulmayi hala cok istiyorum.

Başlık: Ynt: SD kart komut seti
Gönderen: Burak B - 24 Kasım 2013, 02:33:35
@z yazınızı beğendim oldukça buraların dilinden olmuş. Bahsettiğiniz dökümanın tam olanına google vasıtasıyla erişebilirsiniz. "Confidental" bir dökümandır. SDIO Spec v3.00 için simplified versiyonda olmayan bilgileri barındırıyor.
Başlık: Ynt: SD kart komut seti
Gönderen: z - 24 Kasım 2013, 06:55:29
Hocam bildigin dokuman varsa link verirmisin?

Benim yanit bulmakta zorlandigim konular.

SD card SPI modu komutlarinin parametreleri nedir? Gelen cevabin formati nedir? Gelen datalarin bit bazinda anlami nedir?

Malesef internette buldugum dokumanlar tum komutlar icin bu sorulari cevaplamiyor.

Başlık: Ynt: SD kart komut seti
Gönderen: z - 24 Kasım 2013, 12:43:08
Su ana kadar buldugum en iyi dokumanlar.

http://media.digikey.com/pdf/Data%20Sheets/ATP%20Electronics%20PDFs/IG_SD_SDHC_Card_Spec_Rev2.6.pdf (http://media.digikey.com/pdf/Data%20Sheets/ATP%20Electronics%20PDFs/IG_SD_SDHC_Card_Spec_Rev2.6.pdf)

http://alumni.cs.ucr.edu/~amitra/sdcard/ProdManualSDCardv1.9.pdf (http://alumni.cs.ucr.edu/~amitra/sdcard/ProdManualSDCardv1.9.pdf)

https://www.sdcard.org/downloads/pls/simplified_specs/part1_410.pdf (https://www.sdcard.org/downloads/pls/simplified_specs/part1_410.pdf)
Başlık: Ynt: SD kart komut seti
Gönderen: RaMu - 24 Kasım 2013, 22:08:48
Elimdeki sd card datasheetleri bunlar;
başka bilen varsa eklesin tam halleri bulunmuyor aslında,
para istiyor adamlar, hatta yanlış hatırlamıyorsam
misal sd kart kullanabilen bir ürün çıkartacaksanız
sd card associations a üye olup 1000 $ bayılmak gerekiyor.

(https://lh4.googleusercontent.com/-pW2D5JQpYmg/UpJbtUxSxzI/AAAAAAAAAUE/K5lwc_EkA_M/w422-h429-no/1.JPG)

link;
https://www.dropbox.com/s/8m6ydr14ui52dmg/SD%20DATASHEETS%202.rar (https://www.dropbox.com/s/8m6ydr14ui52dmg/SD%20DATASHEETS%202.rar)
Başlık: Ynt: SD kart komut seti
Gönderen: mistek - 24 Kasım 2013, 22:23:40
Alıntı yapılan: RaMu - 24 Kasım 2013, 22:08:48
hatta yanlış hatırlamıyorsam
misal sd kart kullanabilen bir ürün çıkartacaksanız
sd card associations a üye olup 1000 $ bayılmak gerekiyor.


Yok artık!

Sd kartı satın alıyoruz zaten birde üzerine para verip ürün geliştireceğiz öyle mi?
Başlık: Ynt: SD kart komut seti
Gönderen: engerex - 24 Kasım 2013, 22:49:44
 Ücret konusunda wikide şunlar var.

Membership cost      SD Card Association: US$2,000/year, general; US$4,500/year, executive
Specification cost      Simplified spec: Free. Full spec: Free to members, US$1,000/year to R&D non-members
Host license      Yes, US$1,000/year. No, if using SPI-mode only.

http://en.wikipedia.org/wiki/Secure_Digital#Comparison_to_other_flash_memory_formats (http://en.wikipedia.org/wiki/Secure_Digital#Comparison_to_other_flash_memory_formats)
Başlık: Ynt: SD kart komut seti
Gönderen: z - 25 Kasım 2013, 13:28:06
Bu adamlar şerefsizin önde gidenleri.

SD kart dediğimiz nesne komut seti olan işlemci vari bir düzenek. Komut kümesi ve detayları olursa kolaycacık kodları yazılabilir. Ama sülalesini ..... herifleri bilgiyi organizasyon ayağına parayla veriyorlar. Adım gibi eminim verecekleri dokuman da bizim STM32F4 rehber dokumanı gibi açık anlaşılır dokuman değildir.

USB bile bana daha sevimli geldi ortalıkta dokümanları var hiç olmazsa. SD organizasyonunu ...keyim.

Açık kaynak kod, Linux vs zırvalıklarından bahsetmeyin bana bir daha.

Başlık: Ynt: SD kart komut seti
Gönderen: z - 25 Kasım 2013, 14:31:03
SD kartı SPI modunda init ederken max 400Khz dee çalıştırabiliyoruz. Peki init işlemi bitti artık SD kartın çalışabileceği en yüksek hızda çalışmak istiyorum.

SPI modunda SD kartı nasıl yüksek hıza alacağım?
Başlık: Ynt: SD kart komut seti
Gönderen: CoşkuN - 25 Kasım 2013, 14:47:56
Alıntı yapılan: z - 25 Kasım 2013, 14:31:03
SD kartı SPI modunda init ederken max 400Khz dee çalıştırabiliyoruz. Peki init işlemi bitti artık SD kartın çalışabileceği en yüksek hızda çalışmak istiyorum.

SPI modunda SD kartı nasıl yüksek hıza alacağım?
H
Hocam karta video veya resim gibi büyük boyutta ve hızlı bir kayıt mı yapacaksınız? Hız ihtiyacınız neden yüksek?
Başlık: Ynt: SD kart komut seti
Gönderen: Erol YILMAZ - 25 Kasım 2013, 14:53:32
pudn.com dan belki birşeyler çıkabilir.
Başlık: Ynt: SD kart komut seti
Gönderen: Mr.Java - 25 Kasım 2013, 15:19:01
Yalniz @Z hocamıza teşekkürler şiir gibi yazmış.Devamını bekliyorum.

İyi çalışmalar...
Başlık: Ynt: SD kart komut seti
Gönderen: Erol YILMAZ - 25 Kasım 2013, 15:26:54
https://dl.dropboxusercontent.com/u/75981557/SD%20KART.rar

birşeyler var burada.
Başlık: Ynt: SD kart komut seti
Gönderen: z - 25 Kasım 2013, 15:41:17
Alıntı yapılan: CoşkuN - 25 Kasım 2013, 14:47:56
Hocam karta video veya resim gibi büyük boyutta ve hızlı bir kayıt mı yapacaksınız? Hız ihtiyacınız neden yüksek?

Kart izin veriyorsa neden yavaş modda kullanayım?
Başlık: Ynt: SD kart komut seti
Gönderen: engerex - 25 Kasım 2013, 16:42:56
MikroE kütüphanelerinde hız konusunda şöyle bir şey var.

  //--- set up SPI for MMC init (low speed)
........
  SPI3_Init_Advanced(_SPI_FPCLK_DIV64, ..........
........
      // reinitialize spi at higher speed
      SPI3_Init_Advanced(_SPI_FPCLK_DIV2, ...........
.......
Başlık: Ynt: SD kart komut seti
Gönderen: RaMu - 25 Kasım 2013, 17:09:01
Hocam yanlış hatırlamıyorsam hiçbirşey yapmanıza gerek yoktur,
sadece initialization için düşük hızda giriş yapıp
daha sonra giriş başarılı olduktan sonra yani
yüksek hızda iletişim kurabiliyorsunuz.
Uzun zamandır uğraşmadığım için yanlış hatırlıyor olabilirim.
Başlık: Ynt: SD kart komut seti
Gönderen: z - 25 Kasım 2013, 17:09:23
Kullandığım işlemci açısından SPI hızını ayarlamak sorun değil. Sorun SPI kart, kardeşim ben hızımı artıracağım bunu da sana bildiriyorum tarzında bir komut olup olmadığını bilemememden kaynaklanıyor.

Init işlemi ardından SPI clk frekansını 18Mhz yaptım ve sorun çıkarmadan haberleşebiliyorum. Fakat bu şekilde kafama göre frekansı değiştirmek ne kadar doğru bilmiyorum.
Başlık: Ynt: SD kart komut seti
Gönderen: RaMu - 25 Kasım 2013, 17:12:49
Öyleyse doğru hatırladım sanırım.
Hocam daha ne isteyelim işte
kart giriş işlemini yap gerisini bana bırak diyor
frekansı değiştireceğim diye bir bilgi gönderme işiyle uğraşmaya gerek kalmıyor.
Başlık: Ynt: SD kart komut seti
Gönderen: z - 25 Kasım 2013, 17:36:39
SD kartın CSD registerinde max çalışma frekansı yazıyormuş. Bu registeri okumak gerekecek.

Aksi takdirde yaptığımız işlem Turkish metod olacak.

CSD frekansına ait parametre nasıl okunacak?

Sequence to read a card's "CSD" bytes (capacity etc)

Send: 49h,00h,00h,00h,00h,01h

Read: xx - NCR Time
Read: xx - Get Command Response (Should be 00h)
Read: until FEh received - Wait for Data token

Read: yy * 16 - Get 16 bytes from CSD
Read: zz -  Read CRC lo byte
Read: zz -  Read CRC hi byte
Read: clk - Read 0x32 or 0x5A

Böyle gidiyor...

Bu komutla sadece clk frekansini değil kart kapasitesini vs ogrenebiliyoruz.

http://www.retroleum.co.uk/electronics-articles/basic-mmc-card-access/ (http://www.retroleum.co.uk/electronics-articles/basic-mmc-card-access/)

Okunan verileri yorumlamak için

http://users.ece.utexas.edu/~valvano/EE345M/SD_Physical_Layer_Spec.pdf (http://users.ece.utexas.edu/~valvano/EE345M/SD_Physical_Layer_Spec.pdf) sayfa 78

Başlık: Ynt: SD kart komut seti
Gönderen: z - 26 Kasım 2013, 05:08:48
SD kart icinde ne var ne yok sektor bazinda gorebilmek adina PC icin HEX okuma programindan bahsedilmisti.
Bu programin linkini verebilirmisiniz?
Başlık: Ynt: SD kart komut seti
Gönderen: fgokcegoz - 26 Kasım 2013, 08:15:11
Alıntı yapılan: z - 26 Kasım 2013, 05:08:48
SD kart icinde ne var ne yok sektor bazinda gorebilmek adina PC icin HEX okuma programindan bahsedilmisti.
Bu programin linkini verebilirmisiniz?

http://download.cnet.com/WinHex/3000-2352_4-10057691.html (http://download.cnet.com/WinHex/3000-2352_4-10057691.html)
Başlık: Ynt: SD kart komut seti
Gönderen: z - 26 Kasım 2013, 12:04:49
Link için teşekkürler. Programı çalıştırdım fakat SD kartta örneğin 0.sectoru nasıl okuyacağımı bulamadım.
Başlık: Ynt: SD kart komut seti
Gönderen: fgokcegoz - 26 Kasım 2013, 14:53:38
Üst kısımdaki tools sekmesinden open disk ile açacaksınız hocam. Açılan pencereden sd kartın takılı olduğu sürücüyü seçince, alt kısımda görünecek zaten... Sağ taraftaki blokta hangi sektör de olduğunuzu görebiliyorsunuz. (logic sector diye yazıyor.) Sektörler arası gri çizgiyle bölümlenmiş. Birde istediğiniz offsete, üst kısımdaki navigation sekmesindeki go to offset ile gideceksiniz...
Başlık: Ynt: SD kart komut seti
Gönderen: engerex - 26 Kasım 2013, 19:02:56
 Win-HEX çok iyi tercih. Disk için F9, RAM için CTRL+F9 kısayollarını kullanabilirsiniz.
Başlık: Ynt: SD kart komut seti
Gönderen: Elektroemre - 26 Kasım 2013, 22:50:27
elm-chan amcada karınca kararınca şurada bir şeyler karalamış;

http://elm-chan.org/docs/mmc/mmc_e.html (http://elm-chan.org/docs/mmc/mmc_e.html)

Bu vesile il bir kez daha saygıyla anıyoruz kendisini.
Başlık: Ynt: SD kart komut seti
Gönderen: z - 27 Kasım 2013, 02:14:23
Garip bir sorunla karsilastim.

2GB SD karti 0...118 sektorlerini okuyabiliyorum. 119 da takiliyor.
8GB SD kartin ise sadece 0. sektorunu okuyabiliyorum.

Bu sorun hakkinda ne dusunuyorsunuz?

Başlık: Ynt: SD kart komut seti
Gönderen: RaMu - 27 Kasım 2013, 02:45:13
WinHex (HxD) programıyla pcde okurken mi çıkıyor sorun
öyleyse küreklemeniz gerekebilir.
Başlık: Ynt: SD kart komut seti
Gönderen: z - 27 Kasım 2013, 02:47:27
Tabi ya belirtmeliydim.

Kendi islemcim (STM32F103) icin yazdigim programda bu sorunu yasiyorum.
Başlık: Ynt: SD kart komut seti
Gönderen: RaMu - 27 Kasım 2013, 02:58:54
8Gbyte için bişey diyemeyeceğim ben sadece 2 GB ile çalışmıştım
öncelikle bence okuyamadığınıza kesin karar verelim
winhex crackli değilse pcde kart üzerinde nokta değişiklik yapılamıyor (neyse)
bir txt açıp sd kart içine, winhex ile adresini bulup (118 den sonraki bir sector e denk gelecek şekilde)
txt nin içine belli bir karakter doldurup
stm ile okumayı denemek iyi olur,
yoksa genelde sectorler 00h dolu oluyor zaten.

Bunun yanında birçok sebep olabilir
ama ben nedense belli bir kısımdan sonrasını hiç okuyamamak gibi bir sorunla karşılaşmamıştım,
aklıma gelenler sd kart fiziksel kilidi kapalı olabilir (8gb hiç boot sector (sector 0) hariç okunamıyorda bu özellikle olabilir)
veya sd karta yazılımsal kilidi yanlışlıkla açmış olabilirsiniz
yanlış hatırlamıyorsam kısmi kilitlemede yapılabiliyordu buda 2gb için durumu açıklayabilir
böyle ise
başka kartlarla deneme yapıp gerçekten böylemi anlamaya çalışabilir,
veya pc için sd kart formatlama sağlam formatlama ( sd associations unda var ) programı ile sd kartı fabrika ayarlarına getirmek iyi olur,
ayrıca winhexde bu gibi birçek şeyi yapabiliyor,
hatta bir seferinde fill disk ile sd kartı sector 0 dahil 00 ile doldurmuş ve
daha sonra boot sectorü başka bir sd karttan alıp sildiğim sd karta yazmak zorunda kalmıştım.
Başlık: Ynt: SD kart komut seti
Gönderen: z - 27 Kasım 2013, 04:09:29
Tek blok okuma komutu CMD17den sonra sektor no ve Dummy CRC gonderiyorum.

Ilk cevabin 0x00 sonraki cevabin ixe 0xFE olmasi gerekiyor. Daha sonra ise 512 adet data ve 2 byte CRC okuyorum.

2GB kartta 118. sektore kadar her sey yolunda.

119. sektoru okumak istedigimde 0x00 cevabi ardindan bir turlu oxFE cevabi gelmiyor surekli oxFF geliyor.

119..255 sektorlerinde ayni sorun devam ediyor. 256 dan sonra gene sektorler okunuyor. Taaki 256+119a kadar.

0x000...0x076 ok
0x076...0x0ff  sorun
0x100 ..0x176 ok
0x177...   sorun

------------------------------------------

8GB kartda sifirinci sektorde sorun yok.

Fakat 1. sektoru okumak istedigimde 0x00 dan sonra oxFE degil ox08 aliyorum. 0x08 i error token olarak dusunursek bunun anlami out of range demek.



Başlık: Ynt: SD kart komut seti
Gönderen: Burak B - 27 Kasım 2013, 11:02:51
Şöyle anlatayım; bazı çinli zibidiler 2Gb lik flashi sdkartın içine koyduktan sonra SD kontrolcüsünün veya flash kontrolcüsünün diyelim konfigürasyonunu 8GB gibi ayarlıyor. Sonra sizin elinize geliyor bu kart 8gb diye alıyorsunuz yani. 1,2,3 dosya yüklüyorsunuz hiç 2Gb' yi geçmediğiniz için sorunsuz gibi duruyor. Ama günlerden bir gün 2Gb aşılınca işin pis yüzü çıkıyor ortaya. Bu bahsettiğim yöntemi flash disklerde daha çok uyguluyorlar. SD kartlar içinde geçerli bir yöntemdir. Çünkü SD kartların kontrolcülerini üreten firmalar aynı zamanda flash disklerin kontrolcülerini üreten firmalar. Yani 100' lerce ürünü aynı anda programlayabilecek yazılımlar geliştirip ürünlerini konfigüre ediyorlar. Sonra bu yazılımlar bahsettiğim zibidi çinlilerin eline geçiyor. Sonuç durum ortada. 16GB diye flash bellek al 256MB çıksın. :)
Başlık: Ynt: SD kart komut seti
Gönderen: z - 27 Kasım 2013, 11:25:32
İnternette bulduğum bir örnekten sonra hatamı anladım.

Okuma yaparken CMD17 + 32 bit adres yolluyordum. Bu durumda

0. sektörü okumak için  CMD17 + 0x00000000 gönderirken
1. sektörü okumak için  CMD17 + 0x00000001 gönderiyorum.

Halbuki;

0. sektörü okumak için  CMD17 + 0x00000000 gönderirken
1. sektörü okumak için  CMD17 + 0x00000200 göndermem gerekiyor.   512 adresini oku diyor.

-----------------

Evde card okuyucum olmadığı için işyerine gelince şöyle bir sorun farkettim.

0 sektörü okuduğumda PC nin okuduğu ile benim okuduğum uyuşmuyor.

Winhex logical sektor 0'ı okuyor. Physical sector seçeneği kapalı.

Muhtemelen ben fiziksel 0 sektörünü okuyorum. PC ise lojik 0 sektörü.


Bu aşamadan sonra MBR ve FAT yapısına girmek gerekecek.
Başlık: Ynt: SD kart komut seti
Gönderen: engerex - 27 Kasım 2013, 13:12:56
 Bir kaç hatırlatmam olacak.

Piyasadaki SD veya microSD kart girişli dijital fotoğraf makinesi, kamera, mp3 player, telefonların eski olanlarında max: 2GB, 4GB, 16GB, 32GB gibi limitler var. (Windows Mobile bir telefonum vardı. max: 2GB destekliyordu. Fazlasını tanımıyordu. Bir yama ile 8GB kart kullanıyordum.)
FAT16'nın max:2GB ve max:4GB desteklere sahip bir kaç sürümü var. Daha fazlasını desteklemiyor.
FAT32 max: 2TB ve 16TB destekler.
Şu karakerleri dosya adlarında kullanmamalısınz. / \ : * ? " < > |

SD-SC (Standart Capacity) kart max:2 GB destekliyor. (4GB olanlarıda varmış.)
SD-HC (High Capacity) 4-32GB arasını destekliyor. (SD Versiyon 2.0)
SD-XC max: 32GB üstü

SD ile microSD sadece arasındaki fiziksel farktan fazlasıda var. Örneğin SDXC max:256GB destekler. microSDXC max:128GB destekler. Bu yüzden SD microSD arasında başka farklar da olabilir.

http://en.wikipedia.org/wiki/Secure_Digital (http://en.wikipedia.org/wiki/Secure_Digital)
http://en.wikipedia.org/wiki/Comparison_of_file_systems (http://en.wikipedia.org/wiki/Comparison_of_file_systems)

mesaj birleştirme:: 27 Kasım 2013, 13:22:04

Disk için bir HEX editor buldum. Güzel araçlara sahip. Renklendirme olayı işi kolaylaştırıyor. Active@ Disk Editor 3

http://www.disk-editor.org/ (http://www.disk-editor.org/)

(http://www.disk-editor.org/images/screens/HexEditor11.gif)
Başlık: Ynt: SD kart komut seti
Gönderen: z - 28 Kasım 2013, 13:33:48
Evet nihayet 2GB SD kart okuma işlemi ile sorunum kalmadı. Yaptığım en büyük hata CMD16 ve CMD17 komutlarının parametrelerindeymiş.

SD kart okuma işlemi ile ilgili yazımı pdf olarak da hazırladım. (http://www.cncdesigner.com/wordpress/wp-content/uploads/SPI-+-SD-Card.pdf)

Başlık: Ynt: SD kart komut seti
Gönderen: serhat1990 - 29 Kasım 2013, 16:29:22
Hocam emeğinize sağlık . Teşekkürler bu güzel paylaşım için . Bende bu konu ile uzun zamandır bir çalışma yapmak istiyordum fakat döküman eksikliği ve yeterli zaman bulamama nedeniyle erteliyordum . Dökümanı inceleme fırsatım oldu gerçekten çok basitçe fazla kafa karıştırmadan anlatılmış .  Bu konuda çok iyi bir kaynak olmuş .

İyi çalışmalar dilerim , saygılarımla ...
Başlık: Ynt: SD kart komut seti
Gönderen: sseedat - 31 Temmuz 2014, 22:42:58
merhabalar

4GB'lık  bir sd card dan veri okumaya çalışıyorum ama nedense istediğim adresten bir türlü data okuyamadım.

kartın 0x00000000 adresinde başlayarak dataları okuyabiliyorum fakat  0x00000040 gibi bir adresten başlayarak nedense data okuyamadım


(http://s1.postimg.cc/4txiaw32z/Untitled.jpg) (http://postimg.cc/image/4txiaw32z/)

adresi bu şekilde gönderiyorum

        SpiWriteData(0x00);
   SpiWriteData(0x00);
   SpiWriteData(0x00);
   SpiWriteData(0x40);
Başlık: Ynt: SD kart komut seti
Gönderen: RaMu - 01 Ağustos 2014, 01:00:15
Birkaç mesaj yukarıda (mesaj 51)
z hocanın mesajını okudunmu
o mesajdaki gibi dene.