elm-chan SDHC Anbindungsmöglichkeiten HW SW

[.. (Gast)]

Hi
neben eigenen Ansätze versuche ich z.Zt. auch verschiedene andere zur SD 
Card Anbindung. Bei elm-chan werde ich auf die schnelle nicht fündig, ob 
es sich als reines SPI Software Model oder reines Hardware Model oder 
auch für beides nutzen lässt.
Bin mir sicher, dass es sich in einem CFG File einstellen lässt.
Weiss jemand wo?

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

[Falk B. (falk)]

@ .. (Gast)

>Card Anbindung. Bei elm-chan werde ich auf die schnelle nicht fündig, ob
>es sich als reines SPI Software Model oder reines Hardware Model oder
>auch für beides nutzen lässt.

Beides

>Bin mir sicher, dass es sich in einem CFG File einstellen lässt.
>Weiss jemand wo?

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

Hier gar nicht. Lad dir die Beispiele runter, dort ist eine 
narrensichere Version mit Soft-SPI dabei.

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

http://elm-chan.org/fsw/ff/ffsample.zip

[.. (Gast)]

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


#include "diskio.h"    /* Common include file for FatFs and disk I/O layer */


/*-------------------------------------------------------------------------*/
/* Platform dependent macros and functions needed to be modified           */
/*-------------------------------------------------------------------------*/

#include <avr/io.h>      /* Include device specific declareation file here */


#define DO_INIT()          /* Initialize port for MMC DO as input */
#define DO      (PINB &  0x01)  /* Test for MMC DO ('H':true, 'L':false) */

#define DI_INIT()  DDRB  |= 0x02  /* Initialize port for MMC DI as output */
#define DI_H()    PORTB |= 0x02  /* Set MMC DI "high" */
#define DI_L()    PORTB &= 0xFD  /* Set MMC DI "low" */

#define CK_INIT()  DDRB  |= 0x04  /* Initialize port for MMC SCLK as output */
#define CK_H()    PORTB |= 0x04  /* Set MMC SCLK "high" */
#define  CK_L()    PORTB &= 0xFB  /* Set MMC SCLK "low" */

#define CS_INIT()  DDRB  |= 0x08  /* Initialize port for MMC CS as output */
#define  CS_H()    PORTB |= 0x08  /* Set MMC CS "high" */
#define CS_L()    PORTB &= 0xF7  /* Set MMC CS "low" */


static
void dly_us (UINT n)  /* Delay n microseconds (avr-gcc -Os) */
{
  do {
    PINB;
#if F_CPU >= 6000000
    PINB;
#endif
#if F_CPU >= 7000000
    PINB;
#endif
#if F_CPU >= 8000000
    PINB;
#endif
#if F_CPU >= 9000000
    PINB;
#endif
#if F_CPU >= 10000000
    PINB;
#endif
#if F_CPU >= 12000000
    PINB; PINB;
#endif
#if F_CPU >= 14000000
#error Too fast clock
#endif
  } while (--n);
}

Das Generic Beispiel bezieht sich auf einen AVR.
Bevor ich das versuche umzuschreiben, habe ich ein paar Fragen:

Was bedeutet das (PINB) :

..
#if F_CPU >= 10000000
    PINB;
#endif

#if F_CPU >= 12000000
    PINB; PINB;
#endif

Was geschieht durch "PINB" ?


Ich habe angefangen, es so umzuschreiben:

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


// Versuche es für den ESP8266 umzuschreiben:
#include "osapi.h"


#include "diskio.h"    /* Common include file for FatFs and disk I/O layer */


/*-------------------------------------------------------------------------*/
/* Platform dependent macros and functions needed to be modified           */
/*-------------------------------------------------------------------------*/

// wird hier nicht benötigt
// #include <avr/io.h>      /* Include device specific declareation file here */

// ESP8266 Device Specific haben wir hier: 
#include "ets_sys.h"

// und GPIO wird gebraucht
#include "gpio.h"

/* das wird mein Wire Plan:

 GPIO13 MISO = DO
 GPIO12 MOSI = MMC DI
 GPIO05 CLK  = CLK
 GPIO16 CS   = CS


*/


// MISO ( GPIO13 )

// Bestand
// #define DO_INIT()          /* Initialize port for MMC DO as input */

// geändert in 
   #define DO_INIT()      {PIN_PULLUP_DIS(PERIPHS_IO_MUX_MTCK_U); PIN_PULLDWN_DIS(PERIPHS_IO_MUX_MTCK_U); PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, FUNC_GPIO13); GPIO_OUTPUT_SET(GPIO_ID_PIN(13), 1);}

// Bestand
// #define DO      (PINB &  0x01)  /* Test for MMC DO ('H':true, 'L':false) */

// geändert in
   #define DO      ((GPIO_INPUT_GET(13) & 0x01))


// MOSI ( GPIO 12 ) 

// Bestand
// #define DI_INIT()    DDRB  |= 0x02  /* Initialize port for MMC DI as output */
// geändert in 
   #define DI_INIT()    { PIN_PULLUP_DIS(PERIPHS_IO_MUX_MTDI_U); PIN_PULLDWN_DIS(PERIPHS_IO_MUX_MTDI_U);PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDI_U, FUNC_GPIO12);}

// Bestand
// #define DI_H()    PORTB |= 0x02  /* Set MMC DI "high" */
// geändert in 
   #define DI_H()    GPIO_OUTPUT_SET(GPIO_ID_PIN(12), 1) // GPIO_OUTPUT_SET(GPIO_ID_PIN(13), 0);} 

// Bestand
// #define DI_L()    PORTB &= 0xFD  /* Set MMC DI "low" */
// geändert in 
   #define DI_L()    GPIO_OUTPUT_SET(GPIO_ID_PIN(12), 0) // GPIO_OUTPUT_SET(GPIO_ID_PIN(13), 1); gpio16_output_set(0); GPIO_OUTPUT_SET(GPIO_ID_PIN(5), 0);}


// Bestand     
// CLK ( GPIO 5 )
// #define CK_INIT()  DDRB  |= 0x04  /* Initialize port for MMC SCLK as output */

// geändert in 
   #define CK_INIT()    {PIN_PULLUP_DIS(PERIPHS_IO_MUX_GPIO5_U); PIN_PULLDWN_DIS(PERIPHS_IO_MUX_GPIO5_U);PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO5_U, FUNC_GPIO5);}
// Bestand
// #define CK_H()    PORTB |= 0x04  /* Set MMC SCLK "high" */
// geändert in 
   #define CK_H()    GPIO_OUTPUT_SET(GPIO_ID_PIN(5), 1) // GPIO_OUTPUT_SET(GPIO_ID_PIN(12), 0); GPIO_OUTPUT_SET(GPIO_ID_PIN(13), 0);}
// Bestand
// #define CK_L()    PORTB &= 0xFB  /* Set MMC SCLK "low" */
// geändert in
   #define CK_L()    GPIO_OUTPUT_SET(GPIO_ID_PIN(5), 0) // GPIO_OUTPUT_SET(GPIO_ID_PIN(12), 1); GPIO_OUTPUT_SET(GPIO_ID_PIN(13), 1); gpio16_output_set(1);}


// CS ( GPIO16 )
// GPIO16 is "bit special", check gpio16.c
// Bestand
// #define CS_INIT()  DDRB  |= 0x08  /* Initialize port for MMC CS as output */
// geändert in 
   #define CS_INIT()  gpio16_output_conf()
// Bestand
// #define CS_H()    PORTB |= 0x08  /* Set MMC CS "high" */
// geändert in 
   #define CS_H()    gpio16_output_set(1) //  GPIO_OUTPUT_SET(GPIO_ID_PIN(5), 0); GPIO_OUTPUT_SET(GPIO_ID_PIN(12), 0); GPIO_OUTPUT_SET(GPIO_ID_PIN(13), 0);}
// Bestand
// #define CS_L()    PORTB &= 0xF7  /* Set MMC CS "low" */
// geändert in   
   #define CS_L()    gpio16_output_set(0) //  GPIO_OUTPUT_SET(GPIO_ID_PIN(5), 1); GPIO_OUTPUT_SET(GPIO_ID_PIN(12), 1); GPIO_OUTPUT_SET(GPIO_ID_PIN(13), 1);}




static
void dly_us (UINT n)  /* Delay n microseconds (avr-gcc -Os) */
{
  do {
//  if (n >= 10000) os_delay_us(10);
//  else 
// kurz und schmerzlos:

  os_delay_us(1);

    // Gedanke war quatsch..        
    //PINB;
    // 80MHz / 12 MHz = 7 ( 7 X 2 ) 
    //PINB;PINB;PINB;PINB;PINB;PINB;PINB;PINB;PINB;PINB;PINB;PINB;PINB;PINB;
    
/*
#if F_CPU >= 6000000
    PINB;
#endif
#if F_CPU >= 7000000
    PINB;
#endif
#if F_CPU >= 8000000
    PINB;
#endif
#if F_CPU >= 9000000
    PINB;
#endif
#if F_CPU >= 10000000
    PINB;
#endif
#if F_CPU >= 12000000
    PINB; PINB;
#endif
#if F_CPU >= 14000000
#error Too fast clock
#endif
*/    
    
  } while (--n);
}

Nachfolgend habe ich einige Debug Meldungen eingebaut
um den Status zu verfolgen, das läuft soweit das es:

a) die SDHC ( 16GB ) in den IDLE bringt
b) die SDHC antwortet dass es eine 2.7 - 3.6 V card ist

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

   Module Private Functions

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

/* MMC/SD command (SPI mode) */
#define CMD0  (0)      /* GO_IDLE_STATE */
#define CMD1  (1)      /* SEND_OP_COND */
#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 CMD13  (13)    /* SEND_STATUS */
#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 */
#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
DSTATUS Stat = STA_NOINIT;  /* Disk status */

static
BYTE CardType;      /* b0:MMC, b1:SDv1, b2:SDv2, b3:Block addressing */



/*-----------------------------------------------------------------------*/
/* Transmit bytes to the card (bitbanging)                               */
/*-----------------------------------------------------------------------*/

static
void ICACHE_FLASH_ATTR xmit_mmc (
  const BYTE* buff,  /* Data to be sent */
  UINT bc        /* Number of bytes to send */
)
{
  uart0_sendStr("global Debug: Transmit bytes to card \r\n");
  BYTE d;


  do {
    d = *buff++;  /* Get a byte to be sent */
    if (d & 0x80)DI_H() ;else DI_L();  /* bit7 */
    CK_H(); CK_L();
    if (d & 0x40)DI_H() ;else DI_L();   /* bit6 */
    CK_H(); CK_L();
    if (d & 0x20) DI_H() ; else DI_L();  /* bit5 */
    CK_H(); CK_L();
    if (d & 0x10) DI_H() ;else DI_L();  /* bit4 */
    CK_H(); CK_L();
    if (d & 0x08) DI_H() ;else DI_L();  /* bit3 */
    CK_H(); CK_L();
    if (d & 0x04) DI_H(); else DI_L();  /* bit2 */
    CK_H(); CK_L();
    if (d & 0x02) DI_H(); else DI_L();  /* bit1 */
    CK_H(); CK_L();
    if (d & 0x01) DI_H(); else DI_L();  /* bit0 */
    CK_H(); CK_L();
  } while (--bc);
}



/*-----------------------------------------------------------------------*/
/* Receive bytes from the card (bitbanging)                              */
/*-----------------------------------------------------------------------*/

static
void ICACHE_FLASH_ATTR rcvr_mmc (
  BYTE *buff,  /* Pointer to read buffer */
  UINT bc    /* Number of bytes to receive */
)
{
  BYTE r;

  uart0_sendStr("global Debug: Receive bytes from card \r\n");
  DI_H();  /* Send 0xFF */

  do {
    r = 0;   if (DO) r++;  /* bit7 */
    CK_H(); CK_L();
    r <<= 1; if (DO) r++;  /* bit6 */
    CK_H(); CK_L();
    r <<= 1; if (DO) r++;  /* bit5 */
    CK_H(); CK_L();
    r <<= 1; if (DO) r++;  /* bit4 */
    CK_H(); CK_L();
    r <<= 1; if (DO) r++;  /* bit3 */
    CK_H(); CK_L();
    r <<= 1; if (DO) r++;  /* bit2 */
    CK_H(); CK_L();
    r <<= 1; if (DO) r++;  /* bit1 */
    CK_H(); CK_L();
    r <<= 1; if (DO) r++;  /* bit0 */
    CK_H(); CK_L();
    *buff++ = r;      /* Store a received byte */
  } while (--bc);
}



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

static
int ICACHE_FLASH_ATTR wait_ready (void)  /* 1:OK, 0:Timeout */
{
  BYTE d;
  UINT tmr;

  uart0_sendStr("global Debug: Wait for card ready \r\n");
  for (tmr = 5000; tmr; tmr--) {  /* Wait for ready in timeout of 500ms */
    rcvr_mmc(&d, 1);
    if (d == 0xFF) break;
    dly_us(100);
  }

  return tmr ? 1 : 0;
}



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

static
void ICACHE_FLASH_ATTR deselect (void)
{
  uart0_sendStr("global Debug: deselect bus free \r\n");
#ifdef DEBI
  uart0_sendStr("Debug: deselect \r\n");
#endif
  BYTE d;

  CS_H();        /* Set CS# high */
  rcvr_mmc(&d, 1);  /* Dummy clock (force DO hi-z for multiple slave SPI) */
}



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

static
int ICACHE_FLASH_ATTR select (void)  /* 1:OK, 0:Timeout */
{
  uart0_sendStr("Global Debug: select and wait for ready \r\n");
#ifdef DEBI
  uart0_sendStr("Debug: select \r\n");
#endif

  BYTE d;

  CS_L();        /* Set CS# low */
  rcvr_mmc(&d, 1);  /* Dummy clock (force DO enabled) */
  if (wait_ready()) return 1;  /* Wait for card ready */

  deselect();
  return 0;      /* Failed */
}



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

static
int ICACHE_FLASH_ATTR rcvr_datablock (  /* 1:OK, 0:Failed */
  BYTE *buff,      /* Data buffer to store received data */
  UINT btr      /* Byte count */
)
{
  BYTE d[2];
  UINT tmr;

  uart0_sendStr("global Debug: Receive a data packet from card \r\n");
  for (tmr = 1000; tmr; tmr--) {  /* Wait for data packet in timeout of 100ms */
    rcvr_mmc(d, 1);
    if (d[0] != 0xFF) break;
    dly_us(100);
  }
  if (d[0] != 0xFE) return 0;    /* If not valid data token, return with error */

  rcvr_mmc(buff, btr);      /* Receive the data block into buffer */
  rcvr_mmc(d, 2);          /* Discard CRC */

  return 1;            /* Return with success */
}



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

static
int ICACHE_FLASH_ATTR xmit_datablock (  /* 1:OK, 0:Failed */
  const BYTE *buff,  /* 512 byte data block to be transmitted */
  BYTE token      /* Data/Stop token */
)
{
  uart0_sendStr("Debug: Send Data Packet to the Card \r\n");
  BYTE d[2];


  if (!wait_ready()) return 0;

  d[0] = token;
  xmit_mmc(d, 1);        /* Xmit a token */
  if (token != 0xFD) {    /* Is it data token? */
    xmit_mmc(buff, 512);  /* Xmit the 512 byte data block to MMC */
    rcvr_mmc(d, 2);      /* Xmit dummy CRC (0xFF,0xFF) */
    rcvr_mmc(d, 1);      /* Receive data response */
    if ((d[0] & 0x1F) != 0x05)  /* If not accepted, return with error */
      return 0;
  }

  return 1;
}



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

static
BYTE ICACHE_FLASH_ATTR send_cmd (    /* Returns command response (bit7==1:Send failed)*/
  BYTE cmd,    /* Command byte */
  DWORD arg    /* Argument */
)
{
  if ((GPIO_INPUT_GET(13) & 0x01)) uart0_sendStr("MISO: TRUE(1)\r\n"); else uart0_sendStr("MISO: FALSE(0)\r\n");
  
  uart0_sendStr("Debug: Send Command Packet to the card \r\n");
  BYTE n, d, buf[6];


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

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

  /* Send a command packet */
  buf[0] = 0x40 | cmd;      /* Start + Command index */
  buf[1] = (BYTE)(arg >> 24);    /* Argument[31..24] */
  buf[2] = (BYTE)(arg >> 16);    /* Argument[23..16] */
  buf[3] = (BYTE)(arg >> 8);    /* Argument[15..8] */
  buf[4] = (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)) */
  buf[5] = n;
  xmit_mmc(buf, 6);

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

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



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

   Public Functions

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


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

DSTATUS ICACHE_FLASH_ATTR disk_status (
  BYTE drv      /* Drive number (always 0) */
)
{
  if (drv) return STA_NOINIT;

  return Stat;
}



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

DSTATUS ICACHE_FLASH_ATTR disk_initialize (
  BYTE drv    /* Physical drive nmuber (0) */
)
{
  uart0_sendStr("Debug: disk init \r\n");
  BYTE n, ty, cmd, buf[4];
  UINT tmr;
  DSTATUS s;


  if (drv) return RES_NOTRDY;
  uart0_sendStr("Debug: disk init delay 1 \r\n");
  
//  1 * 1000 * 1000 = 1 sec
//    1   * 1000 = 1 ms
//           1    = 1 us
  
  // dly_us(10000);      /* 10ms */
    os_delay_us(10 * 1000);
    
  uart0_sendStr("Debug: disk init delay 2 \r\n");
  CS_INIT(); CS_H();    /* Initialize port pin tied to CS */
  uart0_sendStr("Debug: CS init done \r\n");
  CK_INIT(); CK_L();    /* Initialize port pin tied to SCLK */
  uart0_sendStr("Debug: CK init done \r\n");
  DI_INIT();        /* Initialize port pin tied to DI */
  uart0_sendStr("Debug: DI init done \r\n");
  DO_INIT();        /* Initialize port pin tied to DO */
  uart0_sendStr("Debug: DO init done \r\n");
  uint8_t ccc[2]={0};
  uart0_sendStr("Debug: Try 80 dummy clocks ..\r\n");
  for (n = 10; n ; n--) {
        os_sprintf(ccc,"%i\r\n",n);
        uart0_sendStr(">: ");
        uart0_sendStr(ccc);
        rcvr_mmc(buf, 1);  /* Apply 80 dummy clocks and the card gets ready to receive command */
  }

  //  for (n = 10; n; n--) rcvr_mmc(buf, 1);  /* Apply 80 dummy clocks and the card gets ready to receive command */
    
  uart0_sendStr("Debug: 80 dummy clocks done\r\n");
    
  ty = 0;
  if (send_cmd(CMD0, 0) == 1) {      /* Enter Idle state */
    uart0_sendStr("global Debug: IDLE OK\r\n");
    if (send_cmd(CMD8, 0x1AA) == 1) {  /* SDv2? */
      rcvr_mmc(buf, 4);              /* Get trailing return value of R7 resp */
      if (buf[2] == 0x01 && buf[3] == 0xAA) {    /* The card can work at vdd range of 2.7-3.6V */
        uart0_sendStr("global Debug: Card works 2.7 - 3.6 V \r\n");
        for (tmr = 1000; tmr; tmr--) {      /* Wait for leaving idle state (ACMD41 with HCS bit) */
          if (send_cmd(ACMD41, 1UL << 30) == 0) break;
          dly_us(1000);
        }
        if (tmr && send_cmd(CMD58, 0) == 0) {  /* Check CCS bit in the OCR */
          rcvr_mmc(buf, 4);
          ty = (buf[0] & 0x40) ? CT_SD2 | CT_BLOCK : CT_SD2;  /* SDv2 */
        }
      }
    } else {              /* SDv1 or MMCv3 */
      if (send_cmd(ACMD41, 0) <= 1)   {
        ty = CT_SD1; cmd = ACMD41;  /* SDv1 */
      } else {
        ty = CT_MMC; cmd = CMD1;  /* MMCv3 */
      }
      for (tmr = 1000; tmr; tmr--) {      /* Wait for leaving idle state */
        if (send_cmd(cmd, 0) == 0) break;
        dly_us(1000);
      }
      if (!tmr || send_cmd(CMD16, 512) != 0)  /* Set R/W block length to 512 */
        ty = 0;
    }
  }
  CardType = ty;
  s = ty ? 0 : STA_NOINIT;
  Stat = s;

  deselect();

  return s;
}



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

DRESULT ICACHE_FLASH_ATTR disk_read (
  BYTE drv,      /* Physical drive nmuber (0) */
  BYTE *buff,      /* Pointer to the data buffer to store read data */
  DWORD sector,    /* Start sector number (LBA) */
  UINT count      /* Sector count (1..128) */
)
{
  uart0_sendStr("Debug: Disk read \r\n");
  BYTE cmd;


  if (disk_status(drv) & STA_NOINIT) return RES_NOTRDY;
  if (!(CardType & CT_BLOCK)) sector *= 512;  /* Convert LBA to byte address if needed */

  cmd = count > 1 ? CMD18 : CMD17;      /*  READ_MULTIPLE_BLOCK : READ_SINGLE_BLOCK */
  if (send_cmd(cmd, sector) == 0) {
    do {
      if (!rcvr_datablock(buff, 512)) break;
      buff += 512;
    } while (--count);
    if (cmd == CMD18) send_cmd(CMD12, 0);  /* STOP_TRANSMISSION */
  }
  deselect();

  return count ? RES_ERROR : RES_OK;
}



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

DRESULT ICACHE_FLASH_ATTR disk_write (
  BYTE drv,      /* Physical drive nmuber (0) */
  const BYTE *buff,  /* Pointer to the data to be written */
  DWORD sector,    /* Start sector number (LBA) */
  UINT count      /* Sector count (1..128) */
)
{
  uart0_sendStr("Debug: Disk Write \r\n");
  if (disk_status(drv) & STA_NOINIT) return RES_NOTRDY;
  if (!(CardType & CT_BLOCK)) sector *= 512;  /* Convert LBA 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;
}


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

DRESULT ICACHE_FLASH_ATTR disk_ioctl (
  BYTE drv,    /* Physical drive nmuber (0) */
  BYTE ctrl,    /* Control code */
  void *buff    /* Buffer to send/receive control data */
)
{
  DRESULT res;
  BYTE n, csd[16];
  DWORD cs;


  if (disk_status(drv) & STA_NOINIT) return RES_NOTRDY;  /* Check if card is in the socket */

  res = RES_ERROR;
  switch (ctrl) {
    case CTRL_SYNC :    /* Make sure that no pending write process */
      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 */
          cs = csd[9] + ((WORD)csd[8] << 8) + ((DWORD)(csd[7] & 63) << 16) + 1;
          *(DWORD*)buff = cs << 10;
        } else {          /* SDC ver 1.XX or MMC */
          n = (csd[5] & 15) + ((csd[10] & 128) >> 7) + ((csd[9] & 3) << 1) + 2;
          cs = (csd[8] >> 6) + ((WORD)csd[7] << 2) + ((WORD)(csd[6] & 3) << 10) + 1;
          *(DWORD*)buff = cs << (n - 9);
        }
        res = RES_OK;
      }
      break;

    case GET_BLOCK_SIZE :  /* Get erase block size in unit of sector (DWORD) */
      *(DWORD*)buff = 128;
      res = RES_OK;
      break;

    default:
      res = RES_PARERR;
  }

  deselect();

  return res;
}

Den Versuch ( Auszug user_main.c ) , ein File anzulegen, darauf zu 
schreiben will nicht klappen

UINT bw;
     uint8_t what;
     uint8_t www[10] = {0};
     uart0_sendStr("global Debug: Try f_mount\r\n");
     
     what = f_mount(&FatFs, "", 0); // "", 0;    // Give a work area to the default drive 
     os_sprintf(www,"Mount: %i\r\n", what);
     uart0_sendStr(www);   
         
           
        uart0_sendStr("global Debug: Try f_open \r\n");
       if (f_open(&Fil, "newfile.txt", FA_WRITE | FA_CREATE_ALWAYS) == FR_OK) {  //  Create a file 
       
         uart0_sendStr("global Debug: Try f_write \r\n");
         f_write(&Fil, "It works!\r\n", 11, &bw);  // Write data to the file 
         
         uart0_sendStr("global Debug: Try f_close \r\n");
         f_close(&Fil);                // Close the file 

     
     // led brauche ich noch keine..
       //*  if (bw == 11) {    // Lights green LED if data written well 
           // DDRB |= 0x10; PORTB |= 0x10;  /* Set PB4 high 
           // GPIO_OUTPUT_SET(GPIO_ID_PIN(2), 0);
         }
    //*   }
    for (;;);

Ich denke, dass 80 MHz (80 000 000 ) zu schnell für Bit Banged ist, was 
meint ihr?

[.. (Gast)]

Anbei SDHC -
an der Wire Technik kann es normal nicht liegen, gleiches funktioniert 
mit anderen Ansätzen einwandfrei. Wäre schön wenn "Elm Chan" Ansatz noch 
klappen würde.

[Leo C. (rapid)]

.. schrieb:
> Was geschieht durch "PINB" ?

$ echo '#include <avr/io.h>^M PINB; /*PINB*/' | avr-gcc -mmcu=atmega8 -E -C - |grep PINB
/* PINB */
 (*(volatile uint8_t *)((0x16) + 0x20)); /*PINB*/

[.. (Gast)]

Leo C. schrieb:
>

> /* PINB */
>  (*(volatile uint8_t *)((0x16) + 0x20)); /*PINB*/
>

Danke dir Leo für deine Mühe + Hilfe!

Ok - habe es nun hinbekommen mit dem Ansatz von 'Elm Chan'.
Beide Sachen laufen - Bit Banging / SPI Mode.
Wobei mir der SPI Mode jetzt doch besser passt für 'Elm Chan'.
Dabei sind für den ESP8266 ein paar zusätzliche Anpassungen nötig.
Halt euch auf den laufenden.

@Falk Brunner
Du scheinst ja auch Stunden damit vollbracht zu haben;
im Gegensatz zu der Meinung, die Beispiele sind sofort brauchbar,
hast du selber erst erkennen müssen, dass noch einiges umgeschrieben
werden muss - ich habe die gleiche Erfahrung heute Nacht machen müssen 
:)

Ist war das ein Grauss ( ESP bedingt ) -
aber jetzt läuft es.

;-)

[Falk B. (falk)]

@ .. (Gast)

>Du scheinst ja auch Stunden damit vollbracht zu haben;

Nur beim ATXmega

>im Gegensatz zu der Meinung, die Beispiele sind sofort brauchbar,
>hast du selber erst erkennen müssen, dass noch einiges umgeschrieben
>werden muss

Da muss nichts umgeschireben werden, "nur" richtig hingeschrieben. Beim 
1. Versuch ging es sofort, dort war es ein normaler ATmega ohne 
FIFO. Der FIFO beim ATXmega (USART im SPI Mode) war das Problem, 
dazu noch ein aktiver Interrupt.

>Ist war das ein Grauss ( ESP bedingt ) -
>aber jetzt läuft es.

Der Graus lag nicht am COntroller sondern vor der Tastatur.

[.. (Gast)]

Falk B. schrieb:

> Der Graus lag nicht am COntroller sondern vor der Tastatur.

Ja ich kenn das Gefühl :)

[kettenrad (Gast)]

Ich hab mal diesen Ansatz umgesetzt:
http://www.esp8266.com/viewtopic.php?f=34&t=2496&sid=d4c3e3a22a4419e110f58bc7e345c505

*.jpeg Bilder im Webbrowser von der SD-Karte am esp07;

[.. (Gast)]

kettenrad schrieb:
> Ich hab mal diesen Ansatz umgesetzt:
> 
http://www.esp8266.com/viewtopic.php?f=34&t=2496&sid=d4c3e3a22a4419e110f58bc7e345c505
>
> *.jpeg Bilder im Webbrowser von der SD-Karte am esp07;

yeapp super! - hi kettenrad -
mit der arduino ide und dem esphttpd wifi server?

in der unof. luna mit mit toolchain ist das projekt 'esphttpd' noch 
nicht auf sd card umgestellt so weit ich mal gesehen habe.

auch sprite hat versucht, den elm chan einzubinden und ist gescheitert; 
in einem thread schreibt er auch, dass nur unsinn gelesen wurde  - 
daher mach ich mir nichts draus, wenn es bei mir nicht gleich geklappt 
hat beim esp - auch wenn hier 1000ende andere es schon gescvhafft haben 
( avr denke ich ) - ...

ich hab elm chan jetzt für xtensa ide von der pike auf und finde, dass 
elm chan doch eine gute ausgangsbasis ist - auch der server flutet 
besser, als der esphttpd der arduino ide; sobald ich meine database für 
den esp fertig habe, poste ich das komplette projekt.

lg
;-)

[.. (Gast)]

#push
sprite / april 2015
http://www.esp8266.com/viewtopic.php?f=34&t=2496#p14500

arduino ide / jun 2015
http://www.esp8266.com/viewtopic.php?f=32&t=3558

jan/2015
http://www.esp8266.com/viewtopic.php?f=11&t=741&start=5#p7351

[kettenrad (Gast)]

Vielleicht kann jemand helfen?

Ich benutze Arduino IDE 1.6.5 mit dem Beispiel SDWebServer.
compilieren --> kein Problem;
flashen --> wunderbar;
reset ;
Monitor - ausgabe zeigt, das das Webmodul(WIFI) nicht gestartet wird.
Pin GPIO15 (auf Bord) abgezogen und den Start und die Anmeldung auf 
Router(Fritz Box) abgewartet, Gpio 15 angesteckt und die SD- Karte 
initiiert.

Dann läuft auch z.B. der Editor zum Einfügen von Dateien...

Problem:
- mit dem Hinzufügen von
const int chipSelect = 2;
und/oder dem Ändern des pins_arduino.h mit:
#if defined(ESP8266)
static const uint8_t SS    = 2;
static const uint8_t MOSI  = 13;
static const uint8_t MISO  = 12;
static const uint8_t SCK   = 14;
#else
static const uint8_t SS    = 15;
static const uint8_t MOSI  = 13;
static const uint8_t MISO  = 12;
static const uint8_t SCK   = 14;
#endif  //  (ESP8266)
ist es nicht getan;

Irgentetwas macht Sprite noch anders, --- aber was?

http://www.esp8266.com/viewtopic.php?f=34&t=2496&sid=d4c3e3a22a4419e110f58bc7e345c505

Er hat erfolgreich den CS für die SD-Karte auf GPIO5 umgebogen, aber wo 
und wie ...?

[kettenrad (Gast)]

!! gelöst  !!
- statt in den unendlichen Tiefen der lowlevel Funktionen rumzufummeln, 
habe ich nun im sketch SDWebServer.ino (fast am Ende) die Zeile 
geändert:

if (SD.begin(SS)){

in

if (SD.begin(2)){

... das war's ;

[kettenrad (Gast)]

-- eleganter und richtiger ist:

if (SD.begin(chipSelect)){

den weiter oben definierten "chipSelect" anzugeben ..

[.. (Gast)]

..zu spät..
aber genau das wars ;-)
..

[.. (Gast)]

da ja solved -
hier das base projekt:

elm chan ansatz mit dem esp8266 und (H)SPI

Beitrag "Re: IDE für ESP8266 mit vielen Example"

viel spass
;-)