SD Karte via SPI. Komisches Verhalten.

[Franz (Gast)]

Hallo!

Ich weiß es gibt schon genug Threads bzgl. SD Karten, nur habe ich 
nichts gefunden was mir bei meinem Problem helfen würde: Ich habe an 
mein STM32F4 Discovery Board ein SD-Karten Breakout Board via SPI nach 
der allgemein Bekannten Vorgangsweise angeschlossen: 
[[http://elm-chan.org/docs/mmc/mmc_e.html]]

Dazu habe ich eines der Beispiele hergenommen und auf den STM32 
portiert. Im Prinzip funktioniert das auch wunderbar. Ich kann Daten von 
der SD-Karte einlesen und daten darauf schreiben. Jetzt zum eigentlichen 
Problem: Ich habe das ganze mit 5 Karten verschiedener Größe (256Mb - 
4Gb) getestet. Es funktioniert mit allen karten wunderbar, nur bei der 
Karte mit 256Mb zeigt sich folgendes Verhalten: Die Karte wird 
prinzipiell erkannt, also disk_initialize() gibt keinen Fehler zurück, 
nur kann ich weder Daten von der Karte lesen noch Daten darauf 
schreiben. Beim Schreiben kommt nicht mal ein Fehler zurück, jedoch 
werden die Daten nicht geschrieben. Die Karte funktioniert sonst 
einwandfrei, mit dem USB-Kartenleser funktionierts.

Eigentlich hätte ich mir beim disk_initialize() einen Fehler erwartet, 
so wies bei den meisten der Fall ist, wenn die Karte nicht funktioniert.

Hat vlt. irgendwer eine Idee was hier das Problem sein könnte?

Lg,
Franz

[asdf (Gast)]

Zum Debuggen könntest du einen Logic Analyzer ans SPI hängen und genauer 
schauen was da passiert.

[Jim M. (turboj)]

Franz schrieb:
> Beim Schreiben kommt nicht mal ein Fehler zurück, jedoch
> werden die Daten nicht geschrieben. Die Karte funktioniert sonst
> einwandfrei, mit dem USB-Kartenleser funktionierts.

Sind die Daten auch noch da, wenn Du die Karte aus dem Lesegerät 
entnommen und wieder eingesteckt hast?

[holger (Gast)]

SPI zu schnell?

[Franz (Gast)]

Hallo!

Danke erstmal für die Antworten!

@asdf:
Logicanalyzer hab ich leider keinen, nur ein Oszi und damit ist es 
leider nicht so leicht die gesamte Kommunikation zu analysieren.

Jim Meba schrieb:
> Franz schrieb:
>> Beim Schreiben kommt nicht mal ein Fehler zurück, jedoch
>> werden die Daten nicht geschrieben. Die Karte funktioniert sonst
>> einwandfrei, mit dem USB-Kartenleser funktionierts.
>
> Sind die Daten auch noch da, wenn Du die Karte aus dem Lesegerät
> entnommen und wieder eingesteckt hast?

Ja die Daten sind dann auch noch da. Das habe ich natürlich getestet. 
Ich habe die Karte auch nicht anders formatiert. Alle sind FAT16 
formatiert.

holger schrieb:
> SPI zu schnell?
Die Baudrate ist auf ca. 164Khz eingestellt, diese wird in meinem Code 
auch nicht erhöht nach der Initialisierung. SD Karten sollten ja mehrere 
MHz vertragen, das sollte also nicht das Problem sein.

Im Prinzip wäre es mir ja egal, da ich ja des öfteren davon gehört habe, 
dass manche SD-Karten einfach nicht funktionieren. Nur lässt sich bei 
diesen Fällen die Karte erst gar nicht initialisieren, was bei mir aber 
einwandfrei funktioniert.

Sonst noch ideen?

Lg,
Franz


PS: Werde euch später noch den Code hochladen, vlt sieht ja da gleich 
jmd einen Fehler.

[Franz (Gast)]

Hallo!

Hier die SPI-initialisierung

void SPI_Configuration(void)
{
  SPI_InitTypeDef  SPI_InitStructure;

  /* SPI configuration -------------------------------------------------------*/
  SPI_I2S_DeInit(SPI2);
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
  SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  SPI_InitStructure.SPI_CRCPolynomial = 7;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;

  SPI_Init(SPI2, &SPI_InitStructure);
  SPI_CalculateCRC(SPI2, DISABLE);
  /* Enable the SPI peripheral */
  SPI_Cmd(SPI2, ENABLE);
}

Und hier die funktionen in diskio.c:

/*
 * low_level_functions.c
 *
 *  Created on: Jul 12, 2013
 *      Author: franz
 */

#include <stm32f4xx.h>
#include <stm32_configuration.h>
#include <diskio.h>
#include <helperFunctions.h>

/*-----------------------------------------------------------------------*/
/* MMCv3/SDv1/SDv2 (in SPI mode) control module  (C)ChaN, 2010           */
/*-----------------------------------------------------------------------*/


#define CS_HIGH()  {GPIO_SetBits(GPIOB, GPIO_Pin_12); Delay(10);}
#define CS_LOW()  {GPIO_ResetBits(GPIOB, GPIO_Pin_12);Delay(10);}

#define FCLK_SLOW() ;
#define FCLK_FAST() ;


/**
 * @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_ReadInputDataBit(SD_DETECT_GPIO_PORT, SD_DETECT_PIN) != Bit_RESET)
  {
    status = SD_NOT_PRESENT;
  }
  return status;
}


/*--------------------------------------------------------------------------

   Module Private Functions

---------------------------------------------------------------------------*/

/* Definitions for MMC/SDC 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 Stat = STA_NOINIT;  /* Disk status */

static volatile
BYTE Timer1, Timer2;  /* 100Hz decrement timer */

static
BYTE CardType;      /* Card type flags */


/*-----------------------------------------------------------------------*/
/* Power Control  (Platform dependent)                                   */
/*-----------------------------------------------------------------------*/
/* When the target system does not support socket power control, there   */
/* is nothing to do in these functions and chk_power always returns 1.   */

static
int power_status (void)    /* Socket power state: 0=off, 1=on */
{
  return 1;
}

static
void power_on (void)
{
  /*Nothing to do here, hardware initialization is already done*/
  return;
}

static
void power_off (void)
{
  /* We do not turn power off*/
  return;
}



/*-----------------------------------------------------------------------*/
/* Transmit/Receive data from/to MMC via SPI  (Platform dependent)       */
/*-----------------------------------------------------------------------*/

/* Exchange a byte */
static
BYTE xchg_spi (    /* Returns received data */
  BYTE dat    /* Data to be sent */
)
{
    /* Loop while DR register in not empty */
    while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET)
    {
    }

    /* Send a Byte through the SPI peripheral */
    SPI_I2S_SendData(SPI2, dat);

    /* Wait to receive a Byte */
    while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET)
    {
    }

    /* Return the Byte read from the SPI bus */
    return (uint8_t)SPI_I2S_ReceiveData(SPI2);
}


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

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


  Timer2 = wt / 10;
  do
    d = xchg_spi(0xFF);
  while (d != 0xFF && Timer2);

  return (d == 0xFF) ? 1 : 0;
}



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

static
void deselect (void)
{
  CS_HIGH();
  xchg_spi(0xFF);  /* Dummy clock (force DO hi-z for multiple slave SPI) */
}



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

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

  if (wait_ready(500)) return 1;  /* OK */
  deselect();
  return 0;  /* Timeout */
}



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

static
int rcvr_datablock (
  BYTE *buff,      /* Data buffer to store received data */
  UINT btr      /* Byte count (must be multiple of 4) */
)
{
  BYTE token;


  Timer1 = 20;
  do {              /* Wait for data packet in timeout of 200ms */
    token = xchg_spi(0xFF);
  } while ((token == 0xFF) && Timer1);
  if (token != 0xFE) return 0;  /* If not valid data token, retutn with error */

  do
  {
    *buff++ =xchg_spi(0xFF);
    *buff++ =xchg_spi(0xFF);
  }while(btr -= 2);
  xchg_spi(0xFF);          /* Discard CRC */
  xchg_spi(0xFF);

  return 1;            /* Return with success */
}



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

#if  _USE_WRITE
static
int xmit_datablock (
  const BYTE *buff,  /* 512 byte data block to be transmitted */
  BYTE token      /* Data/Stop token */
)
{
  BYTE resp;
  uint16_t wc;

  if (!wait_ready(500)) return 0;

  xchg_spi(token);          /* Xmit data token */
  if (token != 0xFD) {  /* Is data token */
    wc = 512;
    do {              /* transmit the 512 byte data block to MMC */
      xchg_spi(*buff++);
      xchg_spi(*buff++);
    } while (wc-=2);
    xchg_spi(0xFF);          /* CRC (Dummy) */
    xchg_spi(0xFF);
    resp = xchg_spi(0xFF);      /* Reveive data response */
    //debug(USART2, "xchg_spi: %d", resp);
    if ((resp & 0x1F) != 0x05)    /* If not accepted, return with error */
      return 0;
  }

  return 1;
}
#endif



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

static
BYTE send_cmd (    /* Returns R1 resp (bit7==1:Send failed) */
  BYTE cmd,    /* Command index */
  DWORD arg    /* Argument */
)
{
  BYTE n, res;


  if (cmd & 0x80) {  /* ACMD<n> is the command sequense of CMD55-CMD<n> */
    cmd &= 0x7F;
    res = send_cmd(CMD55, 0);
    if (res > 1) return res;
  }

  /* Select the card and wait for ready */
  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) + Stop */
  if (cmd == CMD8) n = 0x87;      /* Valid CRC for CMD8(0x1AA) Stop */
  xchg_spi(n);

  /* Receive command response */
  if (cmd == CMD12) xchg_spi(0xFF);    /* Skip a stuff byte when stop reading */
  n = 10;                /* Wait for a valid response in timeout of 10 attempts */
  do
    res = xchg_spi(0xFF);
  while ((res & 0x80) && --n);

  return res;      /* Return with the response value */
}



/*--------------------------------------------------------------------------

   Public Functions

---------------------------------------------------------------------------*/


/*-----------------------------------------------------------------------*/
/* Initialize Disk Drive                                                 */
/*-----------------------------------------------------------------------*/

DSTATUS disk_initialize (
  BYTE pdrv    /* Physical drive nmuber (0) */
)
{
  BYTE n, cmd, ty, ocr[4];


  if (pdrv) return STA_NOINIT;    /* Supports only single drive */
  power_off();            /* Turn off the socket power to reset the card */
  if (Stat & STA_NODISK) return Stat;  /* No card in the socket */
  power_on();              /* Turn on the socket power */
  FCLK_SLOW();
  for (n = 10; n; n--) xchg_spi(0xFF);  /* 80 dummy clocks */

  ty = 0;
  if (send_cmd(CMD0, 0) == 1) {      /* Enter Idle state */
    Timer1 = 100;            /* Initialization timeout of 1000 msec */
    if (send_cmd(CMD8, 0x1AA) == 1) {  /* SDv2? */
      debug(USART2, "SDv2\n\r");
      for (n = 0; n < 4; n++) ocr[n] = xchg_spi(0xFF);    /* Get trailing return value of R7 resp */
      if (ocr[2] == 0x01 && ocr[3] == 0xAA) {        /* The card can work at vdd range of 2.7-3.6V */
        while (Timer1 && send_cmd(ACMD41, 1UL << 30));  /* Wait for leaving idle state (ACMD41 with HCS bit) */
        if (Timer1 && 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;  /* SDv2 */
        }
      }
    } else {              /* SDv1 or MMCv3 */
      if (send_cmd(ACMD41, 0) <= 1)   {
        debug(USART2, "SDv1\n\r");
        ty = CT_SD1; cmd = ACMD41;  /* SDv1 */
      } else {
        debug(USART2, "MMCv3\n\r");
        ty = CT_MMC; cmd = CMD1;  /* MMCv3 */
      }
      while (Timer1 && send_cmd(cmd, 0));      /* Wait for leaving idle state */
      if (!Timer1 || send_cmd(CMD16, 512) != 0)  /* Set R/W block length to 512 */
        ty = 0;
    }
  }
  CardType = ty;
  deselect();

  if (ty) {      /* Initialization succeded */
    Stat &= ~STA_NOINIT;    /* Clear STA_NOINIT */
    FCLK_FAST();
  } else {      /* Initialization failed */
    power_off();
  }

  return Stat;
}



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

DSTATUS disk_status (
  BYTE pdrv    /* Physical drive nmuber (0) */
)
{
  if (pdrv) return STA_NOINIT;  /* Supports only single drive */
  return Stat;
}



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

DRESULT disk_read (
  BYTE pdrv,      /* Physical drive nmuber (0) */
  BYTE *buff,      /* Pointer to the data buffer to store read data */
  DWORD sector,    /* Start sector number (LBA) */
  BYTE count      /* Sector count (1..255) */
)
{
  if (pdrv || !count) return RES_PARERR;
  if (Stat & STA_NOINIT) return RES_NOTRDY;

  if (!(CardType & CT_BLOCK)) sector *= 512;  /* Convert to byte address if needed */

  if (count == 1) {  /* Single block read */
    if ((send_cmd(CMD17, sector) == 0)  /* READ_SINGLE_BLOCK */
      && rcvr_datablock(buff, 512))
      count = 0;
  }
  else {        /* Multiple block 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;
}



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

#if _USE_WRITE
DRESULT disk_write (
  BYTE pdrv,      /* Physical drive nmuber (0) */
  const BYTE *buff,  /* Pointer to the data to be written */
  DWORD sector,    /* Start sector number (LBA) */
  BYTE count      /* Sector count (1..255) */
)
{
  if (pdrv || !count) return RES_PARERR;
  if (Stat & STA_NOINIT) return RES_NOTRDY;
  if (Stat & STA_PROTECT) return RES_WRPRT;

  if (!(CardType & CT_BLOCK)) sector *= 512;  /* Convert to byte address if needed */

  if (count == 1) {  /* Single block write */
    if ((send_cmd(CMD24, sector) == 0)  /* WRITE_BLOCK */
      && xmit_datablock(buff, 0xFE))
      count = 0;
  }
  else {        /* Multiple block write */
    if (CardType & CT_SDC) send_cmd(ACMD23, count);
    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;
}
#endif


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

#if _USE_IOCTL
DRESULT disk_ioctl (
  BYTE pdrv,    /* Physical drive nmuber (0) */
  BYTE cmd,    /* Control code */
  void *buff    /* Buffer to send/receive control data */
)
{
  DRESULT res;
  BYTE n, csd[16], *ptr = buff;
  DWORD *dp, st, ed, csize;


  if (pdrv) return RES_PARERR;

  res = RES_ERROR;

  if (cmd == CTRL_POWER) {
    switch (ptr[0]) {
    case 0:    /* Sub control code (POWER_OFF) */
      power_off();    /* Power off */
      res = RES_OK;
      break;
    case 1:    /* Sub control code (POWER_GET) */
      ptr[1] = (BYTE)power_status();
      res = RES_OK;
      break;
    default :
      res = RES_PARERR;
    }
  }
  else {
    if (Stat & STA_NOINIT) return RES_NOTRDY;

    switch (cmd) {
    case CTRL_SYNC :    /* Make sure that no pending write process. Do not remove this or written sector might not left updated. */
      if (select()) res = RES_OK;
      break;

    case GET_SECTOR_COUNT :  /* Get number of sectors on the disk (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*/
          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 (CardType & CT_SD2) {  /* SDv2? */
        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 {          /* SDv1 or MMCv3 */
        if ((send_cmd(CMD9, 0) == 0) && rcvr_datablock(csd, 16)) {  /* Read CSD */
          if (CardType & CT_SD1) {  /* SDv1 */
            *(DWORD*)buff = (((csd[10] & 63) << 1) + ((WORD)(csd[11] & 128) >> 7) + 1) << ((csd[13] >> 6) - 1);
          } else {          /* MMCv3 */
            *(DWORD*)buff = ((WORD)((csd[10] & 124) >> 2) + 1) * (((csd[11] & 3) << 3) + ((csd[11] & 224) >> 5) + 1);
          }
          res = RES_OK;
        }
      }
      break;

    /* Following commands are never used by FatFs module */

    case MMC_GET_TYPE :    /* Get card type flags (1 byte) */
      *ptr = CardType;
      res = RES_OK;
      break;

    case MMC_GET_CSD :    /* Receive CSD as a data block (16 bytes) */
      if (send_cmd(CMD9, 0) == 0    /* READ_CSD */
        && rcvr_datablock(ptr, 16))
        res = RES_OK;
      break;

    case MMC_GET_CID :    /* Receive CID as a data block (16 bytes) */
      if (send_cmd(CMD10, 0) == 0    /* READ_CID */
        && rcvr_datablock(ptr, 16))
        res = RES_OK;
      break;

    case MMC_GET_OCR :    /* Receive OCR as an R3 resp (4 bytes) */
      if (send_cmd(CMD58, 0) == 0) {  /* READ_OCR */
        for (n = 4; n; n--) *ptr++ = xchg_spi(0xFF);
        res = RES_OK;
      }
      break;

    case MMC_GET_SDSTAT :  /* Receive SD statsu as a data block (64 bytes) */
      if (send_cmd(ACMD13, 0) == 0) {  /* SD_STATUS */
        xchg_spi(0xFF);
        if (rcvr_datablock(ptr, 64))
          res = RES_OK;
      }
      break;

    default:
      res = RES_PARERR;
    }

    deselect();
  }

  return res;
}
#endif


/*-----------------------------------------------------------------------*/
/* Device Timer Interrupt Procedure                                      */
/*-----------------------------------------------------------------------*/
/* This function must be called in period of 10ms                        */

void disk_timerproc (void)
{
  BYTE n, s;


  n = Timer1;        /* 100Hz decrement timer */
  if (n) Timer1 = --n;
  n = Timer2;
  if (n) Timer2 = --n;

  s = Stat;

//  if (SOCKWP)        /* Write protected */
//    s |= STA_PROTECT;
//  else          /* Write enabled */
//    s &= ~STA_PROTECT;

  if (SD_Detect() == SD_PRESENT)      /* Card inserted */
    s &= ~STA_NODISK;
  else          /* Socket empty */
    s |= (STA_NODISK | STA_NOINIT);

  Stat = s;        /* Update MMC status */
}


DWORD get_fattime(void)
{
  return 0;
}

Vlt fällt ja jemanden was auf. Danke.

Lg
Franz

[Franz (Gast)]

Hallo!

Die besagte SD-Karte hat gestern den Geist aufgegeben. D.h sie 
funktioniert auch nicht mehr mit dem USB-Card Reader. Außerdem sind bei 
einem Filesystem Check einige Fehler aufgetreten, bevor sie tatsächlich 
kaputtgegangen ist. Evtl. hing der Fehler damit zusammen. Ich werde dem 
jedenfalls nicht weiter nachgehen.

Vlt kann den Code oben ja trotzdem jmd gebrauchen :)

Lg,
Franz