arduino mega + shield ethernet card compatible

Muy buenas a tod@s:
Tengo un arduino mega 2560 y una shield ethernet card compatible con mega. La duda q tengo es como usar el lector de tarjetas micro SD que lleva la placa, para poder alojar una página web.
Después de estar buscando información estoy un poco confuso, a ver si alguien q tenga las ideas claras puede echarme una mano.
Mi primera pregunta es que toda la información tanto la de la ethernet como la de la tarjeta micro sd van por el pin de icsp, los otros pines el 1,2,3,4,...,13 se pueden utilizar, ¿es correcto esto?.
Hablan de configurar el pin 53 como salida, pero yo no tengo resultado....Estoy simplemente intentado echar a andar el tema de la tarjeta, que debería ser una cosa sencilla, pero no lo esta siendo. Utilizo la librería que trae el propio arduino la SD.h, con el ejemplo de Cardinfo.
Al principio de dicho ejemplo, pone una configuración del circuito para el bus spi, supongo q esto ya va por el icsp, y no hace falta hacer nada, ¿no?
Bueno como veis estoy un poco liado con las cosillas a ver si una mano me empuja un poquillo....Gracias..

Hola, iaguezno.
Pon tu esquema y tu código, y la salida serial de Cardinfo a ver si podemos sacar algo en claro.
Efectivamente, en el mega debes declarar el pin 53 como salida. Debes, además ver qué pines utiliza tu shield como CS para la SD y la Ethernet y tenerlo en cuenta en los init de los módulos. Los demás pines son comunes para los dos módulos y los debería tomar del ICSP.

Buenas…conseguí que fuera de la siguiente manera:
Configurar el pin 53 como salida, y en chipSelect=8:

/*
  SD card test 
   
 This example shows how use the utility libraries on which the'
 SD library is based in order to get info about your SD card.
 Very useful for testing a card when you're not sure whether its working or not.
 	
 The circuit:
  * SD card attached to SPI bus as follows:
 ** MOSI - pin 11 on Arduino Uno/Duemilanove/Diecimila
 ** MISO - pin 12 on Arduino Uno/Duemilanove/Diecimila
 ** CLK - pin 13 on Arduino Uno/Duemilanove/Diecimila
 ** CS - depends on your SD card shield or module. 
 		Pin 4 used here for consistency with other Arduino examples

 
 created  28 Mar 2011
 by Limor Fried 
 modified 9 Apr 2012
 by Tom Igoe
 */
 // include the SD library:
#include <SD.h>

// set up variables using the SD utility library functions:
Sd2Card card;
SdVolume volume;
SdFile root;

// change this to match your SD shield or module;
// Arduino Ethernet shield: pin 4
// Adafruit SD shields and modules: pin 10
// Sparkfun SD shield: pin 8
const int chipSelect = 8;    

void setup()
{
  pinMode(53, OUTPUT);
 // Open serial communications and wait for port to open:
  Serial.begin(9600);
   while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }


  Serial.print("\nInitializing SD card...");
  // On the Ethernet Shield, CS is pin 4. It's set as an output by default.
  // Note that even if it's not used as the CS pin, the hardware SS pin 
  // (10 on most Arduino boards, 53 on the Mega) must be left as an output 
  // or the SD library functions will not work. 
  pinMode(53, OUTPUT);     // change this to 53 on a mega


  // we'll use the initialization code from the utility libraries
  // since we're just testing if the card is working!
  if (!card.init(SPI_HALF_SPEED, chipSelect)) {
    Serial.println("initialization failed. Things to check:");
    Serial.println("* is a card is inserted?");
    Serial.println("* Is your wiring correct?");
    Serial.println("* did you change the chipSelect pin to match your shield or module?");
    return;
  } else {
   Serial.println("Wiring is correct and a card is present."); 
  }

  // print the type of card
  Serial.print("\nCard type: ");
  switch(card.type()) {
    case SD_CARD_TYPE_SD1:
      Serial.println("SD1");
      break;
    case SD_CARD_TYPE_SD2:
      Serial.println("SD2");
      break;
    case SD_CARD_TYPE_SDHC:
      Serial.println("SDHC");
      break;
    default:
      Serial.println("Unknown");
  }

  // Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32
  if (!volume.init(card)) {
    Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");
    return;
  }


  // print the type and size of the first FAT-type volume
  uint32_t volumesize;
  Serial.print("\nVolume type is FAT");
  Serial.println(volume.fatType(), DEC);
  Serial.println();
  
  volumesize = volume.blocksPerCluster();    // clusters are collections of blocks
  volumesize *= volume.clusterCount();       // we'll have a lot of clusters
  volumesize *= 512;                            // SD card blocks are always 512 bytes
  Serial.print("Volume size (bytes): ");
  Serial.println(volumesize);
  Serial.print("Volume size (Kbytes): ");
  volumesize /= 1024;
  Serial.println(volumesize);
  Serial.print("Volume size (Mbytes): ");
  volumesize /= 1024;
  Serial.println(volumesize);

  
  Serial.println("\nFiles found on the card (name, date and size in bytes): ");
  root.openRoot(volume);
  
  // list all files in the card with date and size
  root.ls(LS_R | LS_DATE | LS_SIZE);
}


void loop(void) {
  
}

Viendo lo que pone en la marca de SD, se corresponde a Sparkfun SD shield que es el pin 8. Non entiendo vien la diferencia entre las tres :
// Arduino Ethernet shield: pin 4
// Adafruit SD shields and modules: pin 10
// Sparkfun SD shield: pin 8
pq según el enlace que pongo a continuación se corresponde en forma y aspecto a la Arduino Ethernet shield:

http://arduino.cc/de/Reference/SDCardNotes#.UwZ50Pl5MYk

Y la otra pregunta es que me corrijas si estoy equivocado:
La tarjeta adruino mega y la shield ethernet card se comunican por icsp, quu se conectan poniendo una encima de la otra, (o por los pines 50,51,52,53). Ahora es donde viene la duda, el pin CS (8 en mi caso ), es le que se utiliza para poder comunicar la tarjeta arduino mega con la card que está en la tarjeta Ethernet(). He leido por la web q utiliza el 4 para comunicarse con el chip wiznet. Entonces recapitulando cuando quiere comunicarse por icsp, utiliza el pin 4 para la tarjeta ethernet y el 8 para la card, ¿es cierto ?..no me queria quedar con la duda…gracias

Efectivamente, los pines MISO, MOSI Y CLK son comunes y los extrae del ICSP. Previamente a trabajar con un dispositivo se selecciona el dispositivo a leer o escribir a través de su pin SS particular, y después se desactiva, para decirle a dicho dispositivo que “se acabó su turno”.