Problema en Lectura/Escritura de SD con Mega2560, Osciloscopio con Arduino

Hola, ¿podrían ayudarme con mi código por favor?
La verdad intento hacer un osciloscopio desde 0 con el Mega2560, pero me he atorado en el proceso de guardado de datos, la idea general es poder visualizar una onda de 0-10v en un GLCD KS0108, todo el proceso de adquisición funciona bastante bien, revise el foro a ver si alguien tuvo el mismo problema pero no encontré nada parecido, es por eso que les molesto.

Cuando intento guardar los datos en la SD utilizando la Ethernet Shield w5100, no me deja inicializar la microSD, para colmo no sé que ha pasado, pues anteriormente funcionaba sin problemas, mas ahora no es posible y no me dá ningún motivo ni error, solo que cuando ejecuto el siguiente codigo:

  Serial.print("Initializing SD card...");
  if (!SD.begin(4)) {
    Serial.println("initialization failed!");
    return;
  }

Obtengo la respuesta que está programada:

initialization failed!

Les repito antes funcionaba correctamente, ya intenté formatear la microSD a FAT32 y FAT16 y no hay problema con eso, he intentado escribir datos sobre la microSD utilizando un adaptador para PC y no me da problemas al hacerlo, así que no se, pero para mí la SD funciona correctamente.
Ya intenté cargar los ejemplos nativos de arduino, y aunque antes funcionan ahora no lo hacen.(Es por eso que creo que el código que hice está bien)
La pregunta del Millón es ¿Se puede inutilizar la microSD para el arduino sin afectarla para la PC? o ¿Existe algo que no estoy tomando en cuenta o he borrado accidentalmente?

Si me pueden ayudar les agradecería un montón, pues la intención que tengo de guardar en la SD es que en lo posterior pueda hacer análisis del espectro sin utilizar la computadora para eso, sino tan solo recuperar los datos de la SD y listo, a la final el proyecto será publicado para que otros lo puedan tomar como base en algún desarrollo. (Como debe de ser con Open Source :D)

Si necesitan información extra por favor no duden en pedirla.

Muchas gracias por su tiempo.

PD. El código completo lo voy a poner en un comentario, porque al parecer he excedido los 9500 caracteres permitidos.

He posteado el código completo porque sé que se hará más fácil para ustedes ayudarme, además de que de esta forma alguien mas puede usarlo para sus proyectos.

////////////////////////////////////////////////////////////////////////
/////////////////////////////IMPORTANTE (Nota personal)////////////////////////
//No se puede usar el pin 50, 51, 52 y 53, porque se utilizan para la SD, el pin 53 debe estar como salida y cargado high para que se pueda leer la SD
////////////////////////////////////////////////////////////////////////

//La mayor cantidad de datos que se guardará en el Arduino es de 1536 datos del tipo double
//////////////ADICIÓN DE LIBRERÍAS NECESARIAS PARA EJECUTAR EL PROGRAMA//////////////
// include the library header
#include <glcd.h>
// include the Fonts
#include <fonts/allFonts.h>
//Include the SD Library
#include <SPI.h>
#include <SD.h>

//////////////DECLARACIÓN DE VARIABLES//////////////

File myFile; //Crea un objeto File al que se exportará los datos

int led13 = 13;
byte t = 0;
int lengthDatSav = 511;
double DatSav[512]; 
double DatSav2[512]; 
double DatSav3[512]; 
byte ban = 0;
byte cont1 = 0;
byte cont2 = 0;
byte cont3 = 0;
int m = 0;
int a = 1;
byte xa = 0;
byte ya = 0;
///////////////////////////CONFIGURACIÓN INICIAL//////////////////////////////////
void setup()
{
  Serial.begin(9600);
  pinMode(2, INPUT);   // Pulsante para guardado de datos
  pinMode(led13, OUTPUT);   // Led de aviso
  pinMode(53, OUTPUT);     // Se utiliza de esta forma en el Mega
  digitalWrite(53, HIGH);      // DESHABILITA EL w5100 (Escudo Ethernet)
// Initialize the GLCD 
  GLCD.Init();
 // Fuente predeterminada en el área de texto del GLCD
  GLCD.SelectFont(System5x7);
  ya= 63 - analogRead(A0)/16;	//Leo el dato para que el osciloscopio inicie desde esta posición
  initvar();	//Inicializo las variables (arrays DatSav, DatSav2 y DatSav3)
//  intro();  //Posible Caratula
  GLCD.ClearScreen(); //Limpio el GLCD
}

void loop()
{
//Principal (Adquisición)
//Si el pulsante está en HIGH muestro en el GLCD, caso contrario guardo los datos de DatSav, DatSav2 y DatSav3 en la SD
if(digitalRead(2)==1)
{
   GLCD.ClearScreen(); 
  lineas();	//Grafico las líneas de referencia en el GLCD
  cont1=cont1+1; 	//Contador que me ayuda a determinar en que posición del array estoy (0-127, 128-255, 256-383, 384-511)
  for (byte i=0; i <= 128; i++)		//adquiero los datos y los imprimo en la pantalla a la vez
  {
    double yg = analogRead(A0)/4;   //Adquisión de datos desde 0 a 255 (se puede implementar map function)
    if(m<=(lengthDatSav))
    {
      DatSav[m] = yg*10/255;	//Conversión de byte a double, los datos van de 0 a 10v
      m = m+1;
    }
    else if ((cont2 = 0) &&  (m>lengthDatSav) )	//Codigo para guardar la primera porción de datos en un array (DatSav2 = DatSav)
    {
      for (int j=0; j <= lengthDatSav; j++)
      {
        DatSav2[j]=DatSav[j];
        DatSav[j]=0;
      }
      cont1=0;
      cont2=1;
      m=0;
    }
    else	//Codigo para guardar la segunda porción de datos en un array (DatSav3 = DatSav2, y luego  DatSav2 = DatSav)

    {
      for (int j=0; j <= lengthDatSav; j++)
      {
        DatSav3[j]=DatSav2[j];
      }
      for (int j=0; j <= lengthDatSav; j++)
      {
        DatSav2[j]=DatSav[j];
        DatSav[j]=0;
      }
        cont1=0;
        cont2=0;        
        m=0;
    }
    byte y = 63 - yg/4; //El GLCD permite máximo 128x64 puntos así que el límite que le doy es 63 contando desde cero 
    GLCD.DrawLine(xa, ya, i , y, BLACK); //Grafico líneas en el GLCD para que se vea mejor
    xa = i;
    ya = y;    
    delay(t);//Tiempo de retardo(opción no muy buena para tener  time/div)
   }   
    xa=0;  
}
else
{
    SaveSD();//Si el pulsante fue activado guardo los datos en la SD
}
}
///////////Solo hace parpadear el led hasta que se establezca la comunicación por el puerto serial, no lo uso todavía, pues no implemento el software en el PC aún, aunque la idea principal es no usar el PC
void establishContact() {
  while (Serial.available() <= 0) {
    digitalWrite(led13,HIGH);
    delay(100);
    digitalWrite(led13,LOW);    
    delay(100);
  }
}


/////////////////////////////////////////////////////////////////////////////////
//Pantallazo inicial en el GLCD, puede ser reemplazado con cualquier bitmap
void intro()
{
  GLCD.CursorTo(7, 0);              
  GLCD.print("UPS 2013");           
  delay(3000);
  GLCD.ClearScreen(); 
}

/////////////////////////////////////////////////////////////////////////////////
//Dibuja las líneas de división en la pantalla, son útiles para una referencia del espectador acerca del valor de la variable con respecto al tiempo.
//Dibujar Líneas de división
void lineas()
{
//X
  GLCD.DrawLine(0, 32, 127 , 32, BLACK);
//Lineas Principales
  for (byte i=0; i <= 132; i=i+16)
   {
    if (i>=126)
     {
        i = 127;
     }
    GLCD.DrawLine(i, 30, i , 34, BLACK);        
   }   
//Lineas Secundarias
//Crea subdivisiones utilizando pequeñas lineas sobre las principales
  for (byte i=0; i <= 128; i=i+4)
   {
    if (i>=126)
     {
        i = 127;
     }
    GLCD.DrawLine(i, 31, i , 33, BLACK);        
   }   

//Y
 GLCD.DrawLine(64, 0, 64 , 63, BLACK); 
//Lineas Principales
 for (byte i=0; i <= 64; i=i+16)
  {
   if (i>=63)
     {
        i = 63;
     }
    GLCD.DrawLine(62, i, 66 , i, BLACK);   
   }    

//Lineas Secundarias
 for (byte i=0; i <= 64; i=i+4)
  {
   if (i>=63)
     {
        i = 63;
     }
    GLCD.DrawLine(63, i, 65 , i, BLACK);   
   } 
}

void initvar()//Me permite iniciar los arrays desde cero.
{
    for(int i=0; i<=lengthDatSav;i++)
  {
     DatSav[i] = 0;       //Inicializo el array
     DatSav2[i] = 0;       //Inicializo el array     
     DatSav3[i] = 0;       //Inicializo el array          
  }
}

/////////////////////////////////////////////////////////////////////////////////
/////////////////////POSIBLE AREA DEL PROBLEMA////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
void SaveSD()
{
  Serial.print("Initializing SD card...");
  if (!SD.begin(4)) {
    Serial.println("initialization failed!");
    return;
  }
  Serial.println("initialization done.");
  myFile = SD.open("datos.txt", FILE_WRITE);
  if (myFile) {
    Serial.print("Writing to datos.txt...");
//Guardo los datos de los arrays en la SD para procesarlos luego, el guardado se da desde el ultimo array hasta el primero
    for(int i=0;i<=lengthDatSav;i++)
    {
      myFile.println(DatSav3[i]);
    }
    for(int i=0;i<=lengthDatSav;i++)
    {
      myFile.println(DatSav2[i]);
    }
//guardo solo hasta el dato que he adquirido, es decir si cont1 estaba en 3 cuando se active el pulsante el DatSav tendrá solo 384 datos válidos, los demás no me sirven asi que no los envío al SD
    int resto = lengthDatSav-cont1*128;
    for(int i=0;i<=resto;i++)
    {
      myFile.println(DatSav[i]);
    }
//Codigo para en el futuro hacer un indexado de archivos automático, por el momento solo me dice donde acaban las muestras del guardado actual
      String stringOne = "Muestra: ";
      String stringThree = stringOne + a;
      myFile.println(stringThree);
	// close the file:
    myFile.close();
    Serial.println("done.");
  initvar();
  } else {
    Serial.println("error opening datos.txt");
    myFile.close();
  }
  a++;//Será utilizado para la indexación de muestras u archivos, al momento es inútil.
}

Si no funciona en PC, no funcionaría en Arduino, y viceversa. El interfaz es único y común, hasta donde yo sé.

Algo estará jodido en el Arduino o su entorno.
Céntrate en volver a echar a andar alguno de los ejemplos que antes te funcionaban ...