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ı?)
Bildiğim kadarıyla Arduino da 2GB dan yukarısını desteklemiyor.
Komut seti aramak şart değilki. fat 16 da 2gb üst sınır . 8gbleri 2gb formatla geri kalanı formatsız kalsın.
Bende 2GB SD kart bulamadım. Mecburen 8GB almak zorunda kaldım. Bu konuyu merak ediyorum.
ARduino 32GB = http://www.seeedstudio.com/depot/SD-Card-Shield-V4-p-1381.html (http://www.seeedstudio.com/depot/SD-Card-Shield-V4-p-1381.html)
https://www.sdcard.org/downloads/pls/simplified_specs/index.html (https://www.sdcard.org/downloads/pls/simplified_specs/index.html)
buradan protokolleri inceleyebilirsiniz sd komut seti ve kullanımları şekilli vs açıklanmış durumda
Alıntı yapılan: diot - 30 Ocak 2015, 13:07:09
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?
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.
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 (http://www.cncdesigner.com/wordpress/?p=3609)
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_e.html)
http://elm-chan.org/fsw/ff/00index_p.html (http://elm-chan.org/fsw/ff/00index_p.html)
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
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ı.
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.
ccs de yazılmış çalışan denediğiniz sd kart stack i varmı?
dosya adını 8 karakterden fazla yazabilmem lazım.
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.
Aman FATFS i CCS de çalıştırmaya uğraşmayın, ANSI C derleyicilerde çalışıyor, CCS maalesef ANSI C olmadığı için sıkıntılı
SPI interface üzerinden SD ve HCSD kartların kullanımı hakkında güncel dokümanım. (http://www.cncdesigner.com/wordpress/wp-content/uploads/SPI-SD-Card.pdf)
ellerin dert görmesin hocam.
Tuttuğum şu notlar var:
İlgili ilk kısmını ayrıca yazayım;
Alıntı yapılan: RaMu
;...
; CMD58 ALTPROGRAMI
; CMD16 GEREKLİMİ DEĞİLMİ KONTROLÜYLE GEREKLİYSE CMD16 DA İŞLENİYOR
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
;,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
;DURUM1 İN ACMD41 KISMI BAŞARILI OLURSA BURAYA GELİR, BURADA CMD58 İLE DURUM1 E DEVAM EDİLİR
;BURAYA KADAR BAŞARILI OLUNDUYSA KART SD CARD VER2 DİR ARTIK CMD58 İLE BLOCK ADDRESS Mİ BYTE ADDRESS Mİ BAKILACAK
;CMD58 READ_OCR (READ OPERATION CONDITION REGISTER) KOMUTUDUR
;GERİBİLDİRİMİ R1 RESPONSE+32bit OCR REGISTERI YANİ 5 BYTE ŞEKLİNDEDİR
;GELEN OCR REGISTER ININ 30. bitine BAKACAĞIZ (CCS bitidir)
;CCS: Card Capacity Status (ACMD41 Response)(Simp. Spec. page21)
;CCS=1 İSE SD CARD VER2 BLOCK ADDRESS KARTDIR
;CCS;0 İSE SD CARD VER2 BYTE ADDRESS KARTDIR CMD16 KULLANIP BLOCK ADDRESS ŞEKLE GETİRİLİR
;CMD58 [7AH,00H,00H,00H,00H,FDH] ŞEKLİNDEDİR
Buda tam çaılış haldeki algoritma;
Alıntı yapılan: RaMu
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
;POWER_ON SEQUENCE
;ÖNCELİKLE SD KARTA GERİLİM UYGULANDIKTAN SONRA EN AZ 1 MİLİSANİYE BEKLENİR
;BURADA CS VE DI HATTLARI 1'DE TUTULUP, SCLK HATTINDAN EN AZ 74 BOŞ CLOCK GÖNDERİLİR, SD KART ENERJİLENDİĞİNDE
;BU 74 CLOCK PALSİ BOYUNCA CS HATTINA BAKAR EĞER CS HATTI 1 İSE INITALIZATION SEQUENCE E GEÇER.
;DI(programda SD_DI olarak yazılacak) SD KARTIN DATA INPUT PİNİDİR,
;BU HATTI 1 DE TUTMA İŞİ, SD KARTA 74 CLOCK PALSİ BOYUNCA FFh DATASI GÖNDERİLEREK YAPILIR
;,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
;power on sequence den sonra
;SD KART INACTIVE STATE DEDİR
;ARTIK SD CARD KOMUT KABUL EDEBİLECEK HALE GELDİ, BURADA SD CARD SD MOD DENEN DOĞAL MODUNDADIR, BİZ
;SPI MODA GEÇİRMEYE ÇALIŞACAĞIZ
;SD KARTI SPI MODA GEÇİRMEK İÇİN; SD CARD IN CS HATTI 0 A ÇEKİLİP, SD CARD A CMD0 GÖNDERİLİR
;SD CARD DA KOMUTLAR 6 BYTE UZUNLUĞUNDADIR VE MSB Sİ ÖNCE GÖNDERİLİR
;SD CARD DA CRC CORRECTION DENEN BİR DOĞRULAMA VARDIR (BKNZ SD SPECS. SAYFA 83 MODE SELECTION), SPI MODDA
;CRC KONTROLÜ KAPALIDIR (İSTENİRSE CMD59 İLE AKTİFLEŞTİRİLEBİLİR) FAKAT BİZ HENÜZ SPI MODA
;GEÇMEDİĞİMİZDEN CMD0 I CRC Sİ İLE BİRLİKTE GÖNDERMELİYİZ YANİ CMD0 <40h,00h,00h,00h,00h,95h> ŞEKLİNDEDİR
;SD CARD IN CMD0 A GERİBİLDİRİMİ 01h (IDLE STATE) R1 RESPONSE ŞEKLİNDE OLMALIDIR (BKNZ R1 RESPONSE)
;...
;CMD8
;CMD0 GÖNDERİP 01H R1 RESPONSE ALDIK, KART IDLE STATE DE VE SPI MODA GEÇİLDİ
;ARTIK CMD8 GÖNDERİP R7 RESPONSE ALMAMIZ LAZIM, R7 RESPONSE 5 BYTE DIR VE İLK BYTE I R1 RESPONSE DUR
;CMD8 CRC Sİ İLE BİRLİKTE ŞU ŞEKİLDEDİR <40H,00H,00H,01H,AAH,87H>
;ALMAMIZ GEREKEN RESPONSE ŞU ŞEKİLDEDİR <01h,00H,00H,01H,AAH> BİZİM İÇİN SON 2 BYTE OLAN 01AA KISMI YETERLİDİR
;GELEN RESPONSE DA BU KISMIN 01AA OLUP OLMADIĞINA BAKACAĞIZ
;DURUM1 R7 RESPONSE DÜŞÜK 12 BİTİ 1AA ŞEKLİNDE GELDİ
;HATA R7 RESPONSE DÜŞÜK 12 BİTİ 1AA ŞEKLİNDE GELMEDİ
;DURUM2 R7 RESPONSE HİÇ GELMEDİ ÖYLEYSE DURUM2 YE DALLANILACAK
;CMD8 (Argument 0x000001AA, CRC 0x87) -> Response 0x01 0x000001AA -> Means it's
; SDC V2+ card, the Voltage range 2.7V~3.6V is supported -> OK
;************************************************************************************************************************
;|||||||||||||||||||||||||||||AÇIKLAMA İÇİN BAKINIZ ACMD41 ALTPROGRAMI|||||||||||||||||||||||||||||||||||||||||||||||||||
CALL ACMD41 ;DURUM1 İÇİN ACMD41
;************************************************************************************************************************
CALL CMD58 ;DURUM1 DE ACMD41 BAŞARIYLA UYGULANDIYSA CMD58 İLE DEVAM EDİLİR
;CMD58 İÇİNDE CMD16 İLE BLOCK SIZE DEĞİŞTİRME GEREKLİMİ DEĞİLMİ KISMI
;İNCELENİP ONA GÖRE İŞLEM YAPILIYOR
GOTO SUCCEEDED ;CMD58 BAŞARILI İSE GİRİŞ İŞLEMİ BAŞARILIDIR
DURUM2 NOP ;CMD8 UYGULANDIĞINDA RESPONSE ALINAMAZSA BURAYA GELİR
; BURADA ACMD41 UYGULANIR BAŞARILI OLURSA KART SD CARD VER1 BYTE ADDRESS DEMEKTİR
; ARDINA CMD16 UYGULANIP CARD BLOCK ADDRESS MODA ALINIR
;CMD16 DA BAŞARI İLE UYGULANIRSA GİRİŞ BAŞARILI DEMEKTİR SUCCEEDED E DALLANILIR
CALL ACMD41 ;DURUM2 İÇİN ACMD41
CALL CMD16 ;SD VER1 BYTE ADDRESS KARTIMIZ VAR, KART CMD16 İLE BLOCK ADDRESS YAPILIYOR
GOTO SUCCEEDED
;**************************************************************************************************************
;_____________________________________________________________________________________________________________
; |
; |
; |
SUCCEEDED NOP ;INIALIZATION SUCCESSFULL BAŞARI İLE SPI MODA GİRİLDİ VE KART OKUMA YAZMAYA HAZIR HALDE |
; |
;BURADA ÖNCELİKLE SPI İN YÜKSEK FREKANSTA ÇALIŞMASI İÇİN AYAR YAPILACAK |
; |
; |
;_____________________________________________________________________________________________________________|
;**************************************************************************************************************
;//////////////////////////////////////// ACMD41 ALTPROGRAMI /////////////////////////////////////////////
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
;,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
;ACMD41 SYF 32 VE 37 YE BAK
; DURUM1
;CMD8 DEN DÜŞÜK 12 BİT 1AA ŞEKLİNDE RESPONSE ALDIK YANİ DURUM1 İLE DEVAM EDECEĞİZ
;ACMD41 UYGULAYIP SONRASINDA CMD58 GÖNDERECEĞİZ, CMD58 DEN GELEN OCR RESPONSE DA CCS biti 0 İSE CMD16 GÖNDERECEĞİZ,
;CMD58 DEN GELEN OCR RESPONSE DA CCS biti 1 İSE GİRİŞ İŞLEMİ TAMAM SUCCESSFULL A GİT DİYECEĞİZ (CCS biti OCR bit 30 DUR)
; DURUM2
;CMD8 DEN RESPONSE ALINAMAZSA YİNE ACMD41 UYGULANIR FAKAT DEVAMINDA CMD58 GÖNDERİLMEDEN, CMD16 GÖNDERİLİR
;BU ALTPROGRAM DURUM1 DURUM2 KONTROLÜ YAPMAZ SADECE ACMD41 İ GÖNDERİR VE GELN R1 RESPONSE A BAKAR, RESPONSE GELMEZSE
;UNKNOWN CARD HATASI VERİR, DURUM1 DURUM2 KONTROLÜ ACMD41 DEN BİR ÖNCEKİ KOMUT OLAN CMD8 DE YAPILIR, KONTROL ŞÖYLE YAPILIR
;CMD8 GÖNDERİLİP R7 RESPONSE ÇAĞRILIR "CALL R7_RESPONSE " R7_RESPONSE ALTPROGRAMINDA GERİBİLDİRİM ALINAMAZSA DURUM2 YE DALLANIR
;ARTIK ACMD41 İLE INITIALIZATION (GİRİŞ) PROSEDÜRÜNE GEÇECEĞİZ
;ACMD<n> (APPLICATION COMMAND <n> DEMEKTİR) UYGULAMASI CMD55 VE ARDINA CMD<n> ŞEKLİNDEDİR
;ACMD41 APP_SEND_OP_COND (APPLICATION SEND OPERATION CONDITIONS) SD KARTTAN ÇALIŞMA KOŞULLARINI
;BİLDİRMESİNİ İSTER, SD KARTIN VERSİYONU ÇALIŞMA VOLTAJI, BLOCK SİZE GİBİ ŞEYLERİ ÖĞENİRİZ
;ACMD41 DE CMD55 İÇİN R1 RESPONSE ALINIR, 00H OLMALIDIR (BELKİ 01H DIR, yok 00h mış)????????????????????????????????????????
;CMD41 KISMI İÇİNDE R1 RESPONSE ALINIR, 00H OLMALIDIR
;CMD55 <77H,00H,00H,00H,00H,65H> ŞEKLİNDEDİR
;CMD41 <69H,00H,00H,00H,00H,E5H> ŞEKLİNDEDİR
;ACMD41 İÇİN DİREK 00H RESPONSE LARI ALINAMAYABİLİR BU YÜZDEN BİR MÜDDET TEKRAR DENEMEK LAZIM
CALL R1_RESPONSE ;GELEN 1 BYTE LIK R1 RESPONSE UNU BYTE5 E YAZAR
MOVLW 00H
SUBWF BYTE5,W
BTFSS STATUS,Z ;R1 RESPONSE=00h MI?
GOTO ACMD41_TEKRAR ;HAYIR RESPONSE YANLIŞ ;BURADA PROBLEM OLABİLİR?????
;R1=00H EVET RESPONSE DOĞRU
RETURN
;ACMD41 İN DURUM1 VE DURUM2 İÇİN ORTAK KISMI BURAYA KADAR BU KISIM SONUNA RETURN EKLENİP ALTPROGRAM HALİNE GETİRİLEBİLR+yapıldı
;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
;\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ACMD41 ALTPROGRAMI SON \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
; CMD16 ALTPROGRAMI ;
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
;,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
;DURUM1 İÇİN CMD58 İLE CARD VERSİYONU KONTROL EDİLDİ VE CARD SD VER2 BYTE ADDRESS ŞEKLİNDEYSE ARTIK CMD16 UYGULANIR
;DURUM2 İÇİN DİREK ACMD41 DEN SONRA KART SD VER1 OLDUĞUNDAN CMD16 UYGULANIR
;CMD16 (SET_BLOCKLEN) YAZMA-OKUMA BLOCK BOYUTUNU (UZUNLUĞUNU) SEÇME KOMUTUDUR
;DAHA ÖNCEDE BAHSETTİĞİMİZ GİBİ KOMUTLAR 6 BYTE UZUNLUĞUNDADIR MSB Sİ ÖNCE GÖNDERİLİR
;GÖNDERİLECEK İLK BYTE (BYTE5) KOMUTTUR, DEVAMINDA 32 bit (4 BYTE) ARGUMENT VARDIR, SON BYTE CRC DİR
;BLOCK SIZE BAHSEDİLEN ARGUMENT DE BELİRTİLİR YANİ BYTE4,3,2,1 İ "512" SAYISINI OLUŞTURACAK ŞEKİLDE YAZMALIYIZ
;SONUÇ OLARAK 512 BYTE OLARAK BLOCK SIZE BELİRTMEK İÇİN CMD16 ŞU ŞEKİLDE OLUR [50H,00H,00H,02H,00H,01H]
;CMD16 YA R1 GERİBİLDİRİMİ YAPILIR R1 RESPONSE 00H OLANA KADAR CMD16 5-10 DEFA DENENİR SONRA PES EDİLİR
; 01H DA OLABİLİR BİLMİYORUM????????????????????????????????????????
RETURN ;R1=00H EVET RESPONSE DOĞRU, ARTIK İŞLEM TAMAM BAŞARIYLA GİRİŞ YAPILDI SUCCEEDED KISMINA GEÇİLİR
;...
; CMD58 ALTPROGRAMI
; CMD16 GEREKLİMİ DEĞİLMİ KONTROLÜYLE GEREKLİYSE CMD16 DA İŞLENİYOR
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
;,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
;DURUM1 İN ACMD41 KISMI BAŞARILI OLURSA BURAYA GELİR, BURADA CMD58 İLE DURUM1 E DEVAM EDİLİR
;BURAYA KADAR BAŞARILI OLUNDUYSA KART SD CARD VER2 DİR ARTIK CMD58 İLE BLOCK ADDRESS Mİ BYTE ADDRESS Mİ BAKILACAK
;CMD58 READ_OCR (READ OPERATION CONDITION REGISTER) KOMUTUDUR
;GERİBİLDİRİMİ R1 RESPONSE+32bit OCR REGISTERI YANİ 5 BYTE ŞEKLİNDEDİR
;GELEN OCR REGISTER ININ 30. bitine BAKACAĞIZ (CCS bitidir)
;CCS: Card Capacity Status (ACMD41 Response)(Simp. Spec. page21)
;CCS=1 İSE SD CARD VER2 BLOCK ADDRESS KARTDIR
;CCS;0 İSE SD CARD VER2 BYTE ADDRESS KARTDIR CMD16 KULLANIP BLOCK ADDRESS ŞEKLE GETİRİLİR
;CMD58 [7AH,00H,00H,00H,00H,FDH] ŞEKLİNDEDİR
CALL R1_RESPONSE
MOVLW 00H ;01H YAZMIŞIM
SUBWF BYTE5
BTFSS STATUS,Z
GOTO CMD58_TEKRAR ;HAYIR R1 01H DEĞİL BÖYLE BİR HATA VERMEMESİ LAZIM
;DEVAM ;EVET R1 01H İSTEDİĞİMİZ GİBİ, R7 RESPONSE ÇAĞRILIP KALAN 4 BYTE ALINIR CCS BİTİ KONTROL EDİLİR
CALL R7_RESPONSE ;GELEN 5 BYTE (R1+OCR) GERİBİLDİRİMİNİN R1 DEN SONRAKİ 4 BYTE INI BYTE4,3,2,1 E KAYDEDER,
;BYTE4 <bit6> (OCR <bit30>) CCS biti LAZIM,
BTFSS BYTE4,7 ;OCR BİT 31 BUSY BİT SET Mİ YANİ İNİTİALİZATİON TAMAMLANDI MI?
GOTO HATA ;HAYIR TAMAMLANMAMIŞ
;EVET TAMAMLANDI
BTFSS BYTE4,6 ;CCS biti [OCR bit30] 1 Mİ?
CALL CMD16;HAYIR YANİ SD VER2 BYTE ADDRESS KARTDIR CMD16 İLE BLOCK ADDRESS E ÇEVRİLMELİDİR CMD16 KULLAN
RETURN;EVET YANİ SD VER2 BLOCK ADDRESS KARTDIR CMD16 KULLANMAYA GEREK YOK TAMAM DÖN
;AŞAĞIDAKİ GİBİ İDİ YANLIŞ
;RETURN ;GOTO SUCCEEDED ;HAYIR SD VER2 BLOCK ADDRESS KARTDIR CMD16YA GEREK YOK
;CALL CMD16 ;EVET SD VER2 BYTE ADDRESS KARTDIR CMD16 İLE BLOCK SIZE 512 BYTE YAPILMALIDIR
;CMD_16 İLE İLGİLİ AÇIKLAMALAR (BKNZ:) ALTPROGRAM KISMINDA YAPILDI
;RETURN ;GOTO SUCCEEDED ;CMD16 BAŞARILI İSE BURAYA GELİR VE GİRİŞ İŞLEM BAŞARILI DEMEKTİR SUCCEEDED E DALLANILIR
; CMD58 ALTPROGRAMI SON
;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
; R1_RESPONSE ALT PROGRAMI
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
;R1_RESPOSE ALTPROGRAMI SD CARD DAN GELEN 1 BYTE LIK GERİBİLDİRİMİ RESPONSE BYTE5 DEĞİŞKENİNE YAZAR GERİ DÖNER
;DÖNDÜĞÜ YERDE RESPONSE İSTENDİĞİ GİBİ DEĞİLSE KOMUT 8 DEFA TEKRARLANIP İSTENEN RESPONSE ALINMAYA ÇALIŞILIR
;YİNEDE İSTENEN RESPONSE ALINMAZSA KOMUT İÇİN NO RESPONSE (VEYA TIME OUT) DURUMUNDA UYGULANMASI GEREKEN UYGULANIR
;R1_RESPONSE HER ÇAĞRILDIĞINDA 8 DEFA FFH HARİCİ DEĞERDE RESPONSE ALMAYA ÇALIŞIR
; R7_RESPONSE ALTPROGRAMI
;----------------------------------------------------------------------------------------------------------------------------------
;R7_RESPONSE ALTPROGRAMI SD CARD DAN GELEN 5 BYTE LIK R7 GERİBİLDİRİMİNİN (R1_RESPONSE+4BYTE) R1 DEN SONRAKİ
;4 BYTE INI BYTE4,3,2,1 E YAZAR, R7_RESPONSE İSTEYEN KOMUTLAR ÖNCELİKLE R1_RESPONSE ALTPROGRAMINI ÇAĞIRIP
;00H OLMASINA BAKAR 00H DEĞİLSE KOMUTU TEKRARLAMAK GEREKİR, R1_RESPONSE=00H OLARAK ALINDIKTAN SONRA
;R7_RESPONSE ÇAĞRILIP KALAN 4 BYTE GERİBİLDİRİM ALINIR VE ONA GÖRE GEREKEN İŞLEM YAPILIR
;R1_RESPONSE KISMININ 00H OLMASINA ÇAĞIRAN KISIM BAKIP 8 DEFA VEYA DAHA FAZLA KOMUTU TEKRARLAR SONUÇTA GEREKLİ GERİBİLDİRİM
;ALINAMAZSA KOMUT İÇİN NO_RESPONSE (VEYA TIMEOUT) DURUMUNDA YAPILMASI GEREKLİ İŞLEM YAPILIR
SEND_CMD VE SEND_CMD0 ALTPROGRAMLARI
;-----------------------------------------------------------------------------------------------------------------------------
; BYTE5,4,3,2,1,0 DAKİ 6 BYTE KOMUTU SPI DAN GÖNDERME ALTPROGRAMI
;GÖNDERME ESNASINDA GELEN VERİLER YİNE BYTE5,4,3,2,1,0 A KAYDEDİLİR, GEREKSİZ HEPSİ FFH DIR ZATEN
;KOMUT GÖNDERİMİNDE ÖNCELİKLE SD CARD IN KOMUT ALMAYA UYGUN OLUP OLMADIĞINA BAKILIR
;BUNUN İÇİN SD CARD A FFH CEVABI ALINANA KADAR FFH GÖNDERİLİR, FFH CEVABI ALINDIĞINDA ARRTIK KOMUT GÖNDERİLEBİLİR DEMEKTİR
;CMD0 İÇİN FFH ALANA KADAR FFH GÖNDERME İŞLEMİ YAPILMAZ, CMD0 SD INITIALIZATION KISMINDA GÖNDERİLDİĞİNDEN
;FFH CEVABI VERMESİ MÜMKÜN OLMAYABİLİR BUDA KOMUTUN İŞLENEMEMESİNE SEBEP OLUR
;_______________________________________________________________________________________
; 1 BLOCK=512 BYTE YAZMA DENEMESİ
;---------------------------------------------------------------------------------------------------------
;CMD24 SINGLE BLOCK WRITE KOMUTU İLE (CMD16 İLE ÖNCEDEN SEÇİLMİŞ BLOCK UZUNLUĞUNDA BİZDE 512 BYTE) YAZMA YAPILIR
;CMD24 [31:0] BİTLERİ SD CARD A YAZILACAK ADRESİ BELİRTİR
;CMD24 GÖNDERİLİP KABULL EDİLDİKTEN SONRA HER KOMUT İÇİN OLDUĞU GİBİ R1 RESPONSE GELİR 00H OLMALIDIR
;ARTIK KART KOMUTU KABUL ETTİ VE YAZILACAK VERİYİ GÖNDERMEMİZİ BEKLİYOR
;VERİ 1 BYTE START BLOCK TOKEN + 512 BYTE YAZILACAK VERİ + 2 BYTE CRC ŞEKLİNDE SD KARTA GÖNDERİLİR
;CRC KONTROLÜ YAPILMIYORSA BU CRC BYTELARI 0 OLARAK GÖNDERİLİR, GÖNDERMEK ZORUNLUDUR
;START BLOCK TOKEN DEĞERİ FEh DIR
;VERİ GÖNDERİMİNİN HEMEN ARDINDAN SD CARD DAN 1 BYTE DATA RESPONSE GELİR
;DATA RESPONSE DÜŞÜK 4 BİTİ '0101' İSE YAZMA BAŞARILI DEMEKTİR
;DATA RESPONSE BU 1 BYTE IN DEVAMINDA BUSY BİLGİSİDE GÖNDERİR
;KART GELEN VERİYİ HAFIZASINA AKTARIRKEN MEŞGÜL OLDUĞUNU ANLATMAYA ÇALIŞIR
;MEŞGÜL OLMA DURUMU KART TARAFINDAN SD_DO HATTINI LOW (0) DA TUTARAK BİLDİRİLİR
Elm Chan üstat yapmış yayınlamış zaten yılladır kullanılıyor. üretici firmalar bile kullanıyor. Her şeyi açık.
Buldum dediğinizde Elm Chan'ın kütüphanesi zaten.
http://elm-chan.org/fsw/ff/00index_e.html (http://elm-chan.org/fsw/ff/00index_e.html)
http://elm-chan.org/fsw/ff/00index_p.html (http://elm-chan.org/fsw/ff/00index_p.html)