2 GB dan daha büyük kapasitede SD kartların kullanımı

[z]

Yazdığım kodlar 2GB SD kart kullanıyor. Ancak piyasada 2GB SD kart çok azaldı ve fiyatları 8GB vs den daha pahalı.

SD kart komut seti bildiğim kadarıyla açık değil. Üyelik vs ardından temin ediliyor (du).

Arduino da durum nedir? Keil, MicroC vs de durum nedir? (2 GB dan daha yüksek kapasitede SD kart kullanan örnekler varmı?)

[Mucit23]

Bildiğim kadarıyla Arduino da 2GB dan yukarısını desteklemiyor.

[diot]

Komut seti aramak şart değilki. fat 16 da 2gb üst sınır . 8gbleri 2gb formatla  geri kalanı formatsız kalsın.

[mistek]

Bende 2GB SD kart bulamadım. Mecburen 8GB almak zorunda kaldım. Bu konuyu merak ediyorum.

[veliusta]

ARduino 32GB = http://www.seeedstudio.com/depot/SD-Card-Shield-V4-p-1381.html

[ErsinErce]

https://www.sdcard.org/downloads/pls/simplified_specs/index.html

buradan protokolleri inceleyebilirsiniz sd komut seti ve kullanımları şekilli vs açıklanmış durumda

[tekosis]

Komut seti aramak şart değilki. fat 16 da 2gb üst sınır . 8gbleri 2gb formatla  geri kalanı formatsız kalsın.

bu iş nasıl oluyor? bu şekilde 8gb kartı 2gb gibi mcu ile kullanabiliyor muyuz?

[diot]

mbr yi fat 16 ile oluşturunuz. sonra normal biçimleyin. elinizde 2 gb lik bir sd kart olur. xp altında fdisk ile halledebilirsiniz.

[z]

Olay FAT ile alakalı değil. SD kartın komut seti ile ilgili. (FAT işin sonraki aşaması)

Eğer 8 GB SD karta low level erişim yapılabilse gerisi FAT vs işleri. İnit işleminde SD karta ne yollanması gerektiği belli değil. Verilen linklere bir göz atmak lazım.

2GB SD, 8 GB HCSD (High Capacity SD)

http://www.cncdesigner.com/wordpress/?p=3609

[Erhan YILMAZ]

Nesi açık değil hocam anlamadım. Daha dün Elm Chan'ın petit fat kütüphanesi ile 16 gb sd(Fat32) karttan okuma yaptım.

http://elm-chan.org/fsw/ff/00index_e.html
http://elm-chan.org/fsw/ff/00index_p.html

[z]

Zor bela SD kartların init işlemlerinde kullanılan SD kart komutlarına ulaşmıştım. 8 GB için HCSD kartların init işlemlerinin nasıl olduğu bilgisine ihtiyacım var.

Derli toplu bilgi varsa bilmek isterim.



mesaj birleştirme:: 30 Ocak 2015, 21:33:15
Nette bir kütüphane buldum. Sanırım aradığım bilgiler içinde var.

/*-----------------------------------------------------------------------*/
/* SPI controls (Platform dependent)                                     */
/*-----------------------------------------------------------------------*/

#include "diskio.h"
#include "fatfs_sd.h"

/* MMC/SD command */
#define CMD0	(0)			/* GO_IDLE_STATE */
#define CMD1	(1)			/* SEND_OP_COND (MMC) */
#define	ACMD41	(0x80+41)	/* SEND_OP_COND (SDC) */
#define CMD8	(8)			/* SEND_IF_COND */
#define CMD9	(9)			/* SEND_CSD */
#define CMD10	(10)		/* SEND_CID */
#define CMD12	(12)		/* STOP_TRANSMISSION */
#define ACMD13	(0x80+13)	/* SD_STATUS (SDC) */
#define CMD16	(16)		/* SET_BLOCKLEN */
#define CMD17	(17)		/* READ_SINGLE_BLOCK */
#define CMD18	(18)		/* READ_MULTIPLE_BLOCK */
#define CMD23	(23)		/* SET_BLOCK_COUNT (MMC) */
#define	ACMD23	(0x80+23)	/* SET_WR_BLK_ERASE_COUNT (SDC) */
#define CMD24	(24)		/* WRITE_BLOCK */
#define CMD25	(25)		/* WRITE_MULTIPLE_BLOCK */
#define CMD32	(32)		/* ERASE_ER_BLK_START */
#define CMD33	(33)		/* ERASE_ER_BLK_END */
#define CMD38	(38)		/* ERASE */
#define CMD55	(55)		/* APP_CMD */
#define CMD58	(58)		/* READ_OCR */

static volatile DSTATUS TM_FATFS_SD_Stat = STA_NOINIT;	/* Physical drive status */

static BYTE TM_FATFS_SD_CardType;			/* Card type flags */

/* Initialize MMC interface */
static void init_spi (void) {
	TM_DELAY_Init();
	
	TM_SPI_Init(FATFS_SPI, FATFS_SPI_PINSPACK);
	FATFS_CS_HIGH;
	
	Delayms(10);
}


/* Exchange a byte */
static BYTE xchg_spi (
	BYTE dat	/* Data to send */
)
{
	//FATFS_DEBUG_SEND_USART("xchg_spi: inside");
	return TM_SPI_Send(FATFS_SPI, dat);
}


/* Receive multiple byte */
static void rcvr_spi_multi (
	BYTE *buff,		/* Pointer to data buffer */
	UINT btr		/* Number of bytes to receive (even number) */
)
{
	FATFS_DEBUG_SEND_USART("rcvr_spi_multi: inside");
	
	TM_SPI_ReadMulti(FATFS_SPI, buff, 0xFF, btr);
	
	FATFS_DEBUG_SEND_USART("rcvr_spi_multi: done"); 
}


#if _USE_WRITE
/* Send multiple byte */
static void xmit_spi_multi (
	const BYTE *buff,	/* Pointer to the data */
	UINT btx			/* Number of bytes to send (even number) */
)
{
	FATFS_DEBUG_SEND_USART("xmit_spi_multi: inside");
	
	TM_SPI_WriteMulti(FATFS_SPI, (uint8_t *)buff, btx);
}
#endif


/*-----------------------------------------------------------------------*/
/* Wait for card ready                                                   */
/*-----------------------------------------------------------------------*/

static int wait_ready (	/* 1:Ready, 0:Timeout */
	UINT wt			/* Timeout [ms] */
)
{
	BYTE d;

	TM_DELAY_SetTime2(wt);
	do {
		d = xchg_spi(0xFF);
	} while (d != 0xFF && TM_DELAY_Time2());	/* Wait for card goes ready or timeout */
	if (d == 0xFF) {
		FATFS_DEBUG_SEND_USART("wait_ready: OK");
	} else {
		FATFS_DEBUG_SEND_USART("wait_ready: timeout");
	}
	return (d == 0xFF) ? 1 : 0;
}



/*-----------------------------------------------------------------------*/
/* Deselect card and release SPI                                         */
/*-----------------------------------------------------------------------*/

static void deselect (void)
{
	FATFS_CS_HIGH;			/* CS = H */
	xchg_spi(0xFF);			/* Dummy clock (force DO hi-z for multiple slave SPI) */
	FATFS_DEBUG_SEND_USART("deselect: ok");
}



/*-----------------------------------------------------------------------*/
/* Select card and wait for ready                                        */
/*-----------------------------------------------------------------------*/

static int select (void)	/* 1:OK, 0:Timeout */
{
	FATFS_CS_LOW;
	xchg_spi(0xFF);	/* Dummy clock (force DO enabled) */

	if (wait_ready(500)) {
		FATFS_DEBUG_SEND_USART("select: OK");
		return 1;	/* OK */
	}
	FATFS_DEBUG_SEND_USART("select: no");
	deselect();
	return 0;	/* Timeout */
}



/*-----------------------------------------------------------------------*/
/* Receive a data packet from the MMC                                    */
/*-----------------------------------------------------------------------*/

static int rcvr_datablock (	/* 1:OK, 0:Error */
	BYTE *buff,			/* Data buffer */
	UINT btr			/* Data block length (byte) */
)
{
	BYTE token;
	
	FATFS_DEBUG_SEND_USART("rcvr_datablock: inside");
	
	//Timer1 = 200;
	
	TM_DELAY_SetTime2(200);
	do {							// Wait for DataStart token in timeout of 200ms 
		token = xchg_spi(0xFF);
		// This loop will take a time. Insert rot_rdq() here for multitask envilonment. 
	} while ((token == 0xFF) && TM_DELAY_Time2());
	if (token != 0xFE) {
		FATFS_DEBUG_SEND_USART("rcvr_datablock: token != 0xFE");
		return 0;		// Function fails if invalid DataStart token or timeout 
	}

	rcvr_spi_multi(buff, btr);		// Store trailing data to the buffer 
	xchg_spi(0xFF); xchg_spi(0xFF);			// Discard CRC 
	FATFS_DEBUG_SEND_USART("rcvr_datablock: return = 1");
	return 1;						// Function succeeded 
}



/*-----------------------------------------------------------------------*/
/* Send a data packet to the MMC                                         */
/*-----------------------------------------------------------------------*/

#if _USE_WRITE
static int xmit_datablock (	/* 1:OK, 0:Failed */
	const BYTE *buff,	/* Ponter to 512 byte data to be sent */
	BYTE token			/* Token */
)
{
	BYTE resp;
	
	FATFS_DEBUG_SEND_USART("xmit_datablock: inside");

	if (!wait_ready(500)) {
		FATFS_DEBUG_SEND_USART("xmit_datablock: not ready");
		return 0;		/* Wait for card ready */
	}
	FATFS_DEBUG_SEND_USART("xmit_datablock: ready");

	xchg_spi(token);					/* Send token */
	if (token != 0xFD) {				/* Send data if token is other than StopTran */
		xmit_spi_multi(buff, 512);		/* Data */
		xchg_spi(0xFF); xchg_spi(0xFF);	/* Dummy CRC */

		resp = xchg_spi(0xFF);				/* Receive data resp */
		if ((resp & 0x1F) != 0x05)		/* Function fails if the data packet was not accepted */
			return 0;
	}
	return 1;
}
#endif


/*-----------------------------------------------------------------------*/
/* Send a command packet to the MMC                                      */
/*-----------------------------------------------------------------------*/

static BYTE send_cmd (		/* Return value: R1 resp (bit7==1:Failed to send) */
	BYTE cmd,		/* Command index */
	DWORD arg		/* Argument */
)
{
	BYTE n, res;

	FATFS_DEBUG_SEND_USART("send_cmd: inside");
	
	if (cmd & 0x80) {	/* Send a CMD55 prior to ACMD<n> */
		FATFS_DEBUG_SEND_USART("send_cmd: 0x80 bit set");
		cmd &= 0x7F;
		res = send_cmd(CMD55, 0);
		if (res > 1) return res;
	}

	/* Select the card and wait for ready except to stop multiple block read */
	if (cmd != CMD12) {
		FATFS_DEBUG_SEND_USART("send_cmd: cmd != CMD12");
		deselect();
		if (!select()) return 0xFF;
	}

	/* Send command packet */
	xchg_spi(0x40 | cmd);				/* Start + command index */
	xchg_spi((BYTE)(arg >> 24));		/* Argument[31..24] */
	xchg_spi((BYTE)(arg >> 16));		/* Argument[23..16] */
	xchg_spi((BYTE)(arg >> 8));			/* Argument[15..8] */
	xchg_spi((BYTE)arg);				/* Argument[7..0] */
	n = 0x01;							/* Dummy CRC + Stop */
	if (cmd == CMD0) n = 0x95;			/* Valid CRC for CMD0(0) */
	if (cmd == CMD8) n = 0x87;			/* Valid CRC for CMD8(0x1AA) */
	xchg_spi(n);

	/* Receive command resp */
	if (cmd == CMD12) {
		FATFS_DEBUG_SEND_USART("send_cmd: CMD12, receive command resp");
		xchg_spi(0xFF);					/* Diacard following one byte when CMD12 */
	}
	n = 10;								/* Wait for response (10 bytes max) */
	do
		res = xchg_spi(0xFF);
	while ((res & 0x80) && --n);

	return res;							/* Return received response */
}

void TM_FATFS_InitPins(void) {
	GPIO_InitTypeDef GPIO_InitStruct;
	
	RCC_AHB1PeriphClockCmd(FATFS_CS_RCC, ENABLE);	
	
	GPIO_InitStruct.GPIO_Pin = FATFS_CS_PIN;
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
	GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_DOWN;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;
	
	GPIO_Init(FATFS_CS_PORT, &GPIO_InitStruct);
	
#if FATFS_USE_DETECT_PIN > 0
	RCC_AHB1PeriphClockCmd(FATFS_USE_DETECT_PIN_RCC, ENABLE);
	
	GPIO_InitStruct.GPIO_Pin = FATFS_USE_DETECT_PIN_PIN;
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;
	GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;
	
	GPIO_Init(FATFS_USE_DETECT_PIN_PORT, &GPIO_InitStruct);
#endif

#if FATFS_USE_WRITEPROTECT_PIN > 0
	RCC_AHB1PeriphClockCmd(FATFS_USE_WRITEPROTECT_PIN_RCC, ENABLE);
	
	GPIO_InitStruct.GPIO_Pin = FATFS_USE_WRITEPROTECT_PIN_PIN;
	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;
	GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
	GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;
	
	GPIO_Init(FATFS_USE_WRITEPROTECT_PIN_PORT, &GPIO_InitStruct);
#endif
}


uint8_t TM_FATFS_Detect(void) {
#if FATFS_USE_DETECT_PIN > 0
	return GPIO_ReadInputDataBit(FATFS_USE_DETECT_PIN_PORT, FATFS_USE_DETECT_PIN_PIN) == Bit_RESET;
#else
	return 1;
#endif
}

uint8_t TM_FATFS_WriteEnabled(void) {
#if FATFS_USE_WRITEPROTECT_PIN > 0
	return GPIO_ReadInputDataBit(FATFS_USE_WRITEPROTECT_PIN_PORT, FATFS_USE_WRITEPROTECT_PIN_PIN) == Bit_RESET;
#else
	return 1;
#endif	
}


DSTATUS TM_FATFS_SD_disk_initialize (void) {
	BYTE n, cmd, ty, ocr[4];

	FATFS_DEBUG_SEND_USART("disk_initialize: inside");
	
	//Initialize CS pin
	TM_FATFS_InitPins();
	init_spi();
	
	if (!TM_FATFS_Detect()) {
		return STA_NODISK;
	}
	for (n = 10; n; n--) {
		xchg_spi(0xFF);
	}
	ty = 0;
	if (send_cmd(CMD0, 0) == 1) {				/* Put the card SPI/Idle state */
		FATFS_DEBUG_SEND_USART("disk_initialize: CMD0 = 1");
		//Timer1 = 1000;						/* Initialization timeout = 1 sec */
		TM_DELAY_SetTime2(1000);
		if (send_cmd(CMD8, 0x1AA) == 1) {	/* SDv2? */
			for (n = 0; n < 4; n++) ocr[n] = xchg_spi(0xFF);	/* Get 32 bit return value of R7 resp */
			if (ocr[2] == 0x01 && ocr[3] == 0xAA) {				/* Is the card supports vcc of 2.7-3.6V? */
				while (TM_DELAY_Time2() && send_cmd(ACMD41, 1UL << 30)) ;	/* Wait for end of initialization with ACMD41(HCS) */
				if (TM_DELAY_Time2() && send_cmd(CMD58, 0) == 0) {		/* Check CCS bit in the OCR */
					for (n = 0; n < 4; n++) {
						ocr[n] = xchg_spi(0xFF);
					}
					ty = (ocr[0] & 0x40) ? CT_SD2 | CT_BLOCK : CT_SD2;	/* Card id SDv2 */
				}
			}
		} else {	/* Not SDv2 card */
			if (send_cmd(ACMD41, 0) <= 1) 	{	/* SDv1 or MMC? */
				ty = CT_SD1; cmd = ACMD41;	/* SDv1 (ACMD41(0)) */
			} else {
				ty = CT_MMC; cmd = CMD1;	/* MMCv3 (CMD1(0)) */
			}
			while (TM_DELAY_Time2() && send_cmd(cmd, 0));			/* Wait for end of initialization */
			if (TM_DELAY_Time2() || send_cmd(CMD16, 512) != 0) {	/* Set block length: 512 */
				ty = 0;
			}
		}
	}
	TM_FATFS_SD_CardType = ty;	/* Card type */
	FATFS_DEBUG_SEND_USART("disk_initialize: deselecting");
	deselect();

	if (ty) {			/* OK */
		TM_FATFS_SD_Stat &= ~STA_NOINIT;	/* Clear STA_NOINIT flag */
	} else {			/* Failed */
		TM_FATFS_SD_Stat = STA_NOINIT;
	}

	if (!TM_FATFS_WriteEnabled()) {
		TM_FATFS_SD_Stat |= STA_PROTECT;
	} else {
		TM_FATFS_SD_Stat &= ~STA_PROTECT;
	}
	
	return TM_FATFS_SD_Stat;
}



/*-----------------------------------------------------------------------*/
/* Get Disk Status                                                       */
/*-----------------------------------------------------------------------*/

DSTATUS TM_FATFS_SD_disk_status (void) {
	FATFS_DEBUG_SEND_USART("fatfs_sd_disk_status");
	
	if (!TM_FATFS_Detect()) {
		FATFS_DEBUG_SEND_USART("not detected");
		return STA_NOINIT;
	}
	
	if (!TM_FATFS_WriteEnabled()) {
		TM_FATFS_SD_Stat |= STA_PROTECT;
	} else {
		TM_FATFS_SD_Stat &= ~STA_PROTECT;
	}
	
	return TM_FATFS_SD_Stat;	/* Return disk status */
}



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

DRESULT TM_FATFS_SD_disk_read (
	BYTE *buff,		/* Data buffer to store read data */
	DWORD sector,	/* Sector address (LBA) */
	UINT count		/* Number of sectors to read (1..128) */
)
{
	FATFS_DEBUG_SEND_USART("disk_read: inside");
	if (!TM_FATFS_Detect() || (TM_FATFS_SD_Stat & STA_NOINIT)) {
		return RES_NOTRDY;
	}

	if (!(TM_FATFS_SD_CardType & CT_BLOCK)) {
		sector *= 512;	/* LBA ot BA conversion (byte addressing cards) */
	}

	if (count == 1) {	/* Single sector read */
		if ((send_cmd(CMD17, sector) == 0)	/* READ_SINGLE_BLOCK */
			&& rcvr_datablock(buff, 512))
			count = 0;
	} else {				/* Multiple sector read */
		if (send_cmd(CMD18, sector) == 0) {	/* READ_MULTIPLE_BLOCK */
			do {
				if (!rcvr_datablock(buff, 512)) {
					break;
				}
				buff += 512;
			} while (--count);
			send_cmd(CMD12, 0);				/* STOP_TRANSMISSION */
		}
	}
	deselect();

	return count ? RES_ERROR : RES_OK;	/* Return result */
}



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

#if _USE_WRITE
DRESULT TM_FATFS_SD_disk_write (
	const BYTE *buff,	/* Data to be written */
	DWORD sector,		/* Sector address (LBA) */
	UINT count			/* Number of sectors to write (1..128) */
)
{
	FATFS_DEBUG_SEND_USART("disk_write: inside");
	if (!TM_FATFS_Detect()) {
		return RES_ERROR;
	}
	if (!TM_FATFS_WriteEnabled()) {
		FATFS_DEBUG_SEND_USART("disk_write: Write protected!!! \n---------------------------------------------");
		return RES_WRPRT;
	}
	if (TM_FATFS_SD_Stat & STA_NOINIT) {
		return RES_NOTRDY;	/* Check drive status */
	}
	if (TM_FATFS_SD_Stat & STA_PROTECT) {
		return RES_WRPRT;	/* Check write protect */
	}

	if (!(TM_FATFS_SD_CardType & CT_BLOCK)) {
		sector *= 512;	/* LBA ==> BA conversion (byte addressing cards) */
	}

	if (count == 1) {	/* Single sector write */
		if ((send_cmd(CMD24, sector) == 0)	/* WRITE_BLOCK */
			&& xmit_datablock(buff, 0xFE))
			count = 0;
	} else {				/* Multiple sector write */
		if (TM_FATFS_SD_CardType & CT_SDC) send_cmd(ACMD23, count);	/* Predefine number of sectors */
		if (send_cmd(CMD25, sector) == 0) {	/* WRITE_MULTIPLE_BLOCK */
			do {
				if (!xmit_datablock(buff, 0xFC)) {
					break;
				}
				buff += 512;
			} while (--count);
			if (!xmit_datablock(0, 0xFD)) {	/* STOP_TRAN token */
				count = 1;
			}
		}
	}
	deselect();

	return count ? RES_ERROR : RES_OK;	/* Return result */
}
#endif


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

#if _USE_IOCTL
DRESULT TM_FATFS_SD_disk_ioctl (
	BYTE cmd,		/* Control code */
	void *buff		/* Buffer to send/receive control data */
)
{
	DRESULT res;
	BYTE n, csd[16];
	DWORD *dp, st, ed, csize;

	if (TM_FATFS_SD_Stat & STA_NOINIT) {
		return RES_NOTRDY;	/* Check if drive is ready */
	}
	if (!TM_FATFS_Detect()) {
		return RES_NOTRDY;
	}

	res = RES_ERROR;

	switch (cmd) {
	case CTRL_SYNC :		/* Wait for end of internal write process of the drive */
		if (select()) res = RES_OK;
		break;

	case GET_SECTOR_COUNT :	/* Get drive capacity in unit of sector (DWORD) */
		if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) {
			if ((csd[0] >> 6) == 1) {	/* SDC ver 2.00 */
				csize = csd[9] + ((WORD)csd[8] << 8) + ((DWORD)(csd[7] & 63) << 16) + 1;
				*(DWORD*)buff = csize << 10;
			} else {					/* SDC ver 1.XX or MMC ver 3 */
				n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
				csize = (csd[8] >> 6) + ((WORD)csd[7] << 2) + ((WORD)(csd[6] & 3) << 10) + 1;
				*(DWORD*)buff = csize << (n - 9);
			}
			res = RES_OK;
		}
		break;

	case GET_BLOCK_SIZE :	/* Get erase block size in unit of sector (DWORD) */
		if (TM_FATFS_SD_CardType & CT_SD2) {	/* SDC ver 2.00 */
			if (send_cmd(ACMD13, 0) == 0) {	/* Read SD status */
				xchg_spi(0xFF);
				if (rcvr_datablock(csd, 16)) {				/* Read partial block */
					for (n = 64 - 16; n; n--) xchg_spi(0xFF);	/* Purge trailing data */
					*(DWORD*)buff = 16UL << (csd[10] >> 4);
					res = RES_OK;
				}
			}
		} else {					/* SDC ver 1.XX or MMC */
			if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) {	/* Read CSD */
				if (TM_FATFS_SD_CardType & CT_SD1) {	/* SDC ver 1.XX */
					*(DWORD*)buff = (((csd[10] & 63) << 1) + ((WORD)(csd[11] & 128) >> 7) + 1) << ((csd[13] >> 6) - 1);
				} else {					/* MMC */
					*(DWORD*)buff = ((WORD)((csd[10] & 124) >> 2) + 1) * (((csd[11] & 3) << 3) + ((csd[11] & 224) >> 5) + 1);
				}
				res = RES_OK;
			}
		}
		break;

	case CTRL_ERASE_SECTOR :	/* Erase a block of sectors (used when _USE_ERASE == 1) */
		if (!(TM_FATFS_SD_CardType & CT_SDC)) break;				/* Check if the card is SDC */
		if (TM_FATFS_SD_disk_ioctl(MMC_GET_CSD, csd)) break;	/* Get CSD */
		if (!(csd[0] >> 6) && !(csd[10] & 0x40)) break;	/* Check if sector erase can be applied to the card */
		dp = buff; st = dp[0]; ed = dp[1];				/* Load sector block */
		if (!(TM_FATFS_SD_CardType & CT_BLOCK)) {
			st *= 512; ed *= 512;
		}
		if (send_cmd(CMD32, st) == 0 && send_cmd(CMD33, ed) == 0 && send_cmd(CMD38, 0) == 0 && wait_ready(30000))	/* Erase sector block */
			res = RES_OK;	/* FatFs does not check result of this command */
		break;

	default:
		res = RES_PARERR;
	}

	deselect();

	return res;
}
#endif

[z]

8 GB kartda Read komutunun ardından CMD17 cevabının 2GB dakinden farklı olduğunu gördüm. 

8GB kartlarda  CMD17 öncesinde CMD16 komutu ile sektör boyunu 512 byte yapınca artık 8GB SD kartı okuyabiliyorum.
Halbuki 2GB kartlarda init aşamasında bir kez CMD16 kullanmam yetiyordu.

Ancak 8GB SD kartta yazma komutu bu kadar kolay olmadı.

CMD17 ve CMD24 kesinlikle 2GB ve 8GB kartlarda farklı.

[z]

Nihayet 2GB dan  büyük SD kartlardaki sorunu buldum ve sizlere çok önemli bir trick vereceğim.

Ver:2 Kartlarda eğer kartımız 2GB yada altında ise

CMD16 ile sektor boyu 512 byte olarak ayarlıyordum.  HCSD kartlarda sektor zaten 512 byte.

HCSD olmayan kartlarda CMD17 yada CMD24 ile okuma yada yazma yapılırken fiziksel sektor adresimiz, sektör adresi x 512 olarak hesaplanıp parametre olarak yollanıyordu.

Aynı işlemi HSCD kartlarda da yapıyordum. (Hatam bu imiş)

Ancak sebebini anlamadığım şekilde sorunlar çıkıyordu ve nihayetinde 2GB neyime yetmiyor diyip HCSD kartlardaki bu sorunun üstüne gitmekten vazgeçmiştim.

Piyasada 2GB kartların azalması üzerine karaborsa durumu oluştu ve fiyatları yüksek kapasiteli olanların da üstüne çıktı. Zira hala pek çok eski makine 2GB üstü kartlara destek vermiyor. Dolayısı ile 2GB kartlara hala ihtiyaç var.

Neyse HCSD kartlarda CMD17 ve CMD24 de fiziksel sektör adresi olarak doğrudan sektör adresi verilince sorun bitiyor.

Daha açık ifade ile;

Eğer SD kartta 512. byte'ı okuyacaksanız parametreniz 512 iken
HCSD kartta parametreniz 512 değil sadece 1 olacak.

Benim acilen oyun havası bulup göbek atmam lazım.


mesaj birleştirme:: 06 Şubat 2015, 07:04:33
Tabiki formatlama rutinimi 2GB karta göre yazdığım için 2GB üstü kartı formatlasam bile kart gene 2GB görünecek.

2GB neyime yetmez diyip formatlama işlemine müdahale etmeyi düşünmüyorum.

[ahmet_zxc]

ccs de yazılmış çalışan denediğiniz sd kart stack i varmı?

dosya adını 8 karakterden fazla yazabilmem lazım.

[Burak B]

FatFS' i tüm C derleyicileri ile kullanabilirsiniz. 32GB dahil tüm kartları okuyabiliyorum SPI, SDIO. Bunun dışında SPI FLASH/SRAM hafızalar ile de kullanabiliyorsunuz. Ancak "wear leveling"  sorunu için önlem almak gerekiyor. Ayrıca UNICODE ve LFN (Long file name) desteği de mevcut. Code page dahil kullanabiliyorsunuz.