Escribir nombre archivo según los anteriores en la SD

El código ahora lo tengo así:

#include <SD.h>

#define TOT_LAP_POS 13
#define TOT_TIME_POS 33
#define BEST_LAP_POS 60
#define AVERAGE_POS 83

// Las siguientes se usan en caso de leer el tiempo de una vuelta (número de un dígito)
#define FIRST_LAP_OFFS_T 96
#define LAP_ONE_DIGIT_SIZE 21 // Se deduce desde la 'L' hasta el segundo cambio de línea (segundo "\r\n") 

// Las siguientes se usan en caso de leer el tiempo de una vuelta (número de dos dígitos).
// Así se podrían leer hasta 100 vueltas registradas.
#define LAP_TEN_OFFS_T 285
#define LAP_TWO_DIGITS_SIZE 22 // Se deduce desde la 'L' hasta el segundo cambio de línea (segundo "\r\n")

File myFile;

char SES[13];
unsigned long mejor_vuelta = 4294967295UL;
unsigned long tiempo_actual;
unsigned long tiempo_anterior;
unsigned long tiempo_inicial;
unsigned int lap = 1;

void setup() {
  Serial.begin(9600);
  if (!SD.begin(4)) {
    Serial.println("SD fail");
    while (1);
  }
  sd_card_create();
  tiempo_anterior = millis();
  tiempo_inicial = tiempo_anterior;
}

void loop() {
  if (Serial.available()) {
    switch (Serial.read()) {
      case 'w':
        tiempo_actual = millis();
        sd_w();
        total();
        best();
        average();
        lap_w();
        tiempo_anterior = tiempo_actual;
        break;

      case 'n':
        mejor_vuelta = 4294967295UL;
        lap = 1;
        Serial.println("Crear nuevo archivo.");
        sd_card_create();
        tiempo_anterior = millis();
        tiempo_inicial = tiempo_anterior;
        break;

      default:
        Serial.println("Comando desconocido");
    }
    Serial.flush();
  }

}

void sd_card_create() {
  unsigned int num = 1;
  Serial.println("Preparando...");

  sprintf(SES, "ses%d.txt", num);

  while (SD.exists(SES)) {
    Serial.print(SES);
    Serial.println(" ya existe");
    num++;
    sprintf(SES, "ses%d.txt", num);
  }
  Serial.print(SES);
  Serial.println(" creado");
  myFile = SD.open(SES, FILE_WRITE);
  //myFile = SD.open("orenes1.txt", FILE_WRITE);
  if (myFile) {
    myFile.print(F("Total laps:\r\n000\r\n\r\nTotal time:\r\n00:00:00:000\r\n\r\nBest lap:\r\n00:00:000\r\n\r\nAverage:\r\n00:00:000\r\n\r\n"));
    Serial.println("Listo. Introduce comando.");
    myFile.close();
  }
  else {
    Serial.println("Error");
  }
}
//********************************************************** SD WRITING
void sd_w() {
  myFile = SD.open(SES, FILE_WRITE);
  myFile.seek(TOT_LAP_POS);
  if (lap < 10) { 
    myFile.print("00");
    myFile.print(lap);

  }
  if (lap > 9 && lap < 100) {
    myFile.print("0");
    myFile.print(lap);

  }
  if (lap > 99) {
    myFile.print(lap);

  }

}
//******************************************************

void total() {
  unsigned long m, mu, md, s, su, sd, l, lu, ld, lc, tot;
  tot = tiempo_actual - tiempo_inicial;
  m = tot / 60000;
  mu = m % 10;
  md = (m - mu) / 10;
  s = (tot / 1000) - (m * 60);
  su = s % 10;
  sd = (s - su) / 10;
  l = tot - (s * 1000) - (m * 60000);
  lu = l % 10;
  ld = ((l - lu) / 10) % 10;
  lc = (l - (ld * 10) - lu) / 100;
  myFile.seek(TOT_TIME_POS);
  myFile.print(md);
  myFile.print(mu);
  myFile.print(":");
  myFile.print(sd);
  myFile.print(su);
  myFile.print(":");
  myFile.print(lc);
  myFile.print(ld);
  myFile.print(lu);
}

//******************************************************
void best() {
  unsigned long tiempo_vuelta = tiempo_actual - tiempo_anterior;

  if (tiempo_vuelta < mejor_vuelta) {
    mejor_vuelta = tiempo_vuelta;
    unsigned long m, mu, md, s, su, sd, l, lu, ld, lc;
    m = mejor_vuelta / 60000;
    mu = m % 10;
    md = (m - mu) / 10;
    s = (mejor_vuelta / 1000) - (m * 60);
    su = s % 10;
    sd = (s - su) / 10;
    l = mejor_vuelta - (s * 1000) - (m * 60000);
    lu = l % 10;
    ld = ((l - lu) / 10) % 10;
    lc = (l - (ld * 10) - lu) / 100;
    myFile.seek(BEST_LAP_POS);
    myFile.print(md);
    myFile.print(mu);
    myFile.print(":");
    myFile.print(sd);
    myFile.print(su);
    myFile.print(":");
    myFile.print(lc);
    myFile.print(ld);
    myFile.print(lu);
  }
}
//************************************************************
void average() {
  unsigned long m, mu, md, s, su, sd, l, lu, ld, lc, media;
  
  media = tiempo_actual - tiempo_inicial / lap;
  
  m = media / 60000;
  mu = m % 10;
  md = (m - mu) / 10;
  s = (media / 1000) - (m * 60);
  su = s % 10;
  sd = (s - su) / 10;
  l = media - (s * 1000) - (m * 60000);
  lu = l % 10;
  ld = ((l - lu) / 10) % 10;
  lc = (l - (ld * 10) - lu) / 100;
  myFile.seek(AVERAGE_POS);
  myFile.print(md);
  myFile.print(mu);
  myFile.print(":");
  myFile.print(sd);
  myFile.print(su);
  myFile.print(":");
  myFile.print(lc);
  myFile.print(ld);
  myFile.print(lu);
  myFile.close();
  }
//***********************************************
void lap_w() {
  
  myFile = SD.open(SES, FILE_WRITE);
  if (myFile) {
    unsigned long m, mu, md, s, su, sd, l, lu, ld, lc, tiempo_vuelta;
    tiempo_vuelta = tiempo_actual - tiempo_anterior;
    Serial.print("Tiempo de la vuelta (ms): ");
    Serial.println(tiempo_vuelta);
    m = tiempo_vuelta / 60000;
    mu = m % 10;
    md = (m - mu) / 10;
    s = (tiempo_vuelta / 1000) - (m * 60);
    su = s % 10;
    sd = (s - su) / 10;
    l = tiempo_vuelta - (s * 1000) - (m * 60000);
    lu = l % 10;
    ld = ((l - lu) / 10) % 10;
    lc = (l - (ld * 10) - lu) / 100;

    /*if (lap < 10)
      myFile.seek(FIRST_LAP_OFFS_T + (LAP_ONE_DIGIT_SIZE * (lap - 1)));
      else if (lap < 100)
      myFile.seek(LAP_TEN_OFFS_T + (LAP_TWO_DIGIT_SIZE * (lap - 1)));
      else
      Serial.println("No se ha programado para leer más de 100 vueltas");*/

    myFile.print("Lap ");
    myFile.print(lap);
    myFile.println(':');
    myFile.print(md);
    myFile.print(mu);
    myFile.print(":");
    myFile.print(sd);
    myFile.print(su);
    myFile.print(":");
    myFile.print(lc);
    myFile.print(ld);
    myFile.println(lu);
    myFile.println();
    Serial.println("Lap written");
    myFile.close();
    lap++;
  }
}

Y los resultados son los siguientes:

Monitor serie:

Preparando...
ses1.txt ya existe
ses2.txt ya existe
ses3.txt ya existe
ses4.txt creado
Listo. Introduce comando.
Tiempo de la vuelta (ms): 3059
Lap written
Tiempo de la vuelta (ms): 3979
Lap written
Tiempo de la vuelta (ms): 4072
Lap written
Tiempo de la vuelta (ms): 1699
Lap written
Tiempo de la vuelta (ms): 7279
Lap written
Crear nuevo archivo.
Preparando...
ses1.txt ya existe
ses2.txt ya existe
ses3.txt ya existe
ses4.txt ya existe
ses5.txt creado
Listo. Introduce comando.
Tiempo de la vuelta (ms): 2172
Lap written
Tiempo de la vuelta (ms): 4416
Lap written
Tiempo de la vuelta (ms): 2884
Lap written
Tiempo de la vuelta (ms): 3314
Lap written
Tiempo de la vuelta (ms): 2902
Lap written

SES4.TXT

Total laps:
005

Total time:
00:20:088000

Best lap:
00:01:699

Average:
00:21:476

Lap 1:
00:03:059

Lap 2:
00:03:979

Lap 3:
00:04:072

Lap 4:
00:01:699

Lap 5:
00:07:279

SES5.TXT

Total laps:
005

Total time:
00:15:688000

Best lap:
00:02:172

Average:
00:36:236

Lap 1:
00:02:172

Lap 2:
00:04:416

Lap 3:
00:02:884

Lap 4:
00:03:314

Lap 5:
00:02:902

En conclusión: por qué dices que no se escribe bien?
Seguro que la protección contra escritura no te está fastidiando la vida?

PD: por qué en el tiempo total se me están escribiendo más ceros de la cuenta? :confused:

Lucario448: En conclusión: por qué dices que no se escribe bien? Seguro que la protección contra escritura no te está fastidiando la vida?

Utilizo microSD, a no ser que yo no lo sepa, pero creo que no tienen protección contra escritura.

No se si es por como tengo todo el código en general por lo que me está dando problemas. Utilizando el 75% de la RAM, ¿puede que de esos fallos y reinicios?.

Edito: Voy a probar también a poner un regulador de 5V aparte, a ver si por casualidad fuera por tema de consumo ya que tiene que alimentar un LCD, el IRDA, tarjetero y los 4 pulsadores, ya que estoy alimentándolo todo desde el arduino.

orenes: Utilizo microSD, a no ser que yo no lo sepa, pero creo que no tienen protección contra escritura.

Si al leerlo desde una PC (sin adaptador de tamaño) puedes ponerle/borrarle archivos, entonces ese no es el problema.

orenes: No se si es por como tengo todo el código en general por lo que me está dando problemas. Utilizando el 75% de la RAM, ¿puede que de esos fallos y reinicios?.

Eso dependería de cuantas funciones llama otra (y a qué "nivel de recursividad"). Con el código completo quizá sería más encontrar algo.

orenes: Edito: Voy a probar también a poner un regulador de 5V aparte, a ver si por casualidad fuera por tema de consumo ya que tiene que alimentar un LCD, el IRDA, tarjetero y los 4 pulsadores, ya que estoy alimentándolo todo desde el arduino.

A eso sí no sé qué decir, pero todo cabe dentro de las posibilidades.

Buenas, siento por no haber contestado antes, pero me desesperé con el tema y lo aparqué un tiempo y ahora vuelvo con el tema de nuevo.

#include <FastIO.h>
#include <I2CIO.h>
#include <LCD.h>
#include <LiquidCrystal.h>
#include <LiquidCrystal_I2C.h>




char ses[13];
#include <SD.h>


File myFile;

#include <Wire.h>



#define I2C_ADDR    0x27
LiquidCrystal_I2C             lcd(I2C_ADDR,2, 1, 0, 4, 5, 6, 7);

#define TOT_LAP_POS 13
#define TOT_TIME_POS 33
#define BEST_LAP_POS 60
#define AVERAGE_POS 83

#include <IRremote.h>
#include <IRremoteInt.h>




const byte bleft = A0; //Renombrar a las entradas, left también será escape/atrás.
const byte bdown = A1;
const byte bright = A2; //Right también será OK.
const byte bup = A3;
byte up = 0; //Estado de los botones.
byte down = 0;
byte left = 0;
byte right = 0;
byte pul = 1;
byte m, mu=0,md=0;                          //Declaramos las variables que vamos a usar
byte s, su=0,sd=0;
int l;
byte lu=0,ld=0,lc=0;
byte actual,antigua,actual2,antigua2;
long int tiempo,inicio,mejor_vuelta,tiempo_libre,tiempo_actual,total,media,vis;
int lap =1;
byte remote = 8;
IRrecv irrecv(remote);
decode_results results;
long int codigo=0;
long int codigo2=0;
byte irda=0;
byte mar=1;
byte pan=0;
int vmin = 500;
int i;
const byte chipSelect = 10;


void setup() { 
 lcd.begin(16,2); //Comienza comunicación con lcd.
 lcd.setCursor(4,0);
 lcd.print("LOADING");
 lcd.setBacklightPin(3,POSITIVE); 
 lcd.setBacklight(HIGH);

Serial.begin(9600);

 pinMode(bleft,INPUT);
 pinMode(bdown,INPUT);
 pinMode(bright,INPUT);
 pinMode(bup,INPUT);
 
 actual=LOW;
 antigua=LOW;
 
 pinMode(10,OUTPUT);
 if (!SD.begin(chipSelect)) {
  lcd.setCursor(3,0);
  lcd.print("NO SD CARD");
  lcd.setCursor(6,1);
  lcd.print("CHECK");
  return;
 }
 lcd.clear();
 lcd.setCursor(5,0);
 lcd.print("SD CARD");
 lcd.setCursor(7,1);
 lcd.print("OK");
 delay(2000);
 main_menu();
}
void loop() {
}

void main_menu(){                                                     //MENÚ SESIÓN LIBRE
  lcd.clear();
  while(pul == 1){
    lcd.setCursor(6,0);
    lcd.print("MENU");
    lcd.setCursor(0,1);
    lcd.print("   FREE SEASON  ");
      
  up = digitalRead(bup); //Lectura de los estados de los botones.
  down = digitalRead(bdown);
  right = digitalRead(bright);
  
    if(right == HIGH){
      pul=11;
      delay(250);
      ready_menu();
    }
    else if(down == HIGH){
      pul=2;
      delay(250);
      select_channel_menu();
    }
    else if(up == HIGH){
      pul=3;
      delay(250);
   //   read_sd_menu();
    }
  }
}
//***********************************************************
void ready_menu(){                                              //MENÚ READY
  lcd.clear();
  while(pul == 11){
    lcd.setCursor(4,0);
    lcd.print("ARE YOU");
    lcd.setCursor(5,1);
    lcd.print("READY?");

    left = digitalRead(bleft);
    right = digitalRead(bright);

    if(left == HIGH){
      pul=1;
      delay(250);
      main_menu();
    }
    if(right == HIGH){
      //pul=12;
      //free_season();  
      sd_card_create(); 
    }
  }
}
//*******************************************
void free_season(){                           //SESIÓN LIBRE
   
  irrecv.enableIRIn(); //Habilita infrarrojos.
  lcd.clear();
  lcd.setCursor(4,0);
  lcd.print("STARTING");
  lap=1;
  tiempo_actual=0;
  mejor_vuelta=0;
  tiempo_libre=0;
  mar=0;
  total=0;
  media=0;
  
  
  while(pul == 12){
  up = digitalRead(bup); //Lectura de los estados de los botones.
  down = digitalRead(bdown);
  left = digitalRead(bleft);
  right = digitalRead(bright);
  inicio=0;
  
    if(left == HIGH){
      pul=1;
      delay(250);
      main_menu();
    }
    
    if(irrecv.decode(&results)){
        codigo2=results.value;
        if(codigo == codigo2){
          
          lcd.clear();
          lcd.setCursor(2,0);
          lcd.print("001");
          inicio=millis();
          irda=1;
          
        }
    }
    while(irda == 1){       
      tiempo=millis()-inicio;
      m=tiempo/60000;                     
      mu=m%10;                           
      md=(m-mu)/10;                       
      s=(tiempo/1000)-(m*60);            
      su=s%10;                            
      sd=(s-su)/10;                       
      l=tiempo-(s*1000)-(m*60000);        
      lu=l%10;                           
      ld=((l-lu)/10)%10;                  
      lc=(l-(ld*10)-lu)/100;              
      lcd.setCursor(7, 0);                
      lcd.print(md);                      
      lcd.print(mu);               
      lcd.print(":");
      lcd.print(sd);
      lcd.print(su);
      lcd.print(":");
      lcd.print(lc);
      lcd.print(ld);
      lcd.print(lu);
      lcd.setCursor(0,0);
      lcd.print("L:"); 
      
      
      actual=digitalRead(bup); 
    if(actual == HIGH && antigua == LOW){
      pan++;
    }
    antigua=actual;
    
    actual2=digitalRead(bdown);
    if(actual2 == HIGH &&  antigua2 == LOW){
      pan--;
    }
    antigua2=actual2;

    if(pan == -1){
      pan=1;
    }
    if(pan== 1){
      vis=tiempo_actual;
      lcd.setCursor(0,1);
      lcd.print("LAP ");
    }
    if(pan == 2){
      pan=0;
    }
    if(pan == 0){
      vis=mejor_vuelta;
      lcd.setCursor(0,1);
      lcd.print("BEST");
    }
      
      left=digitalRead(bleft);
      if(left == HIGH){
        pul=1;
        irda=0;
        codigo2=0;
        main_menu();

        
      }
      
      if(irrecv.decode(&results)){
        Serial.println(results.value);
        Serial.println(codigo);
        if(results.value == codigo  && vmin <=tiempo){
          tiempo_actual=tiempo;
          tiempo_libres();
          laps();
          inicio=millis();
        irrecv.resume();
      }}
      
      
      m=vis/60000;                     
      mu=m%10;                           
      md=(m-mu)/10;                       
      s=(vis/1000)-(m*60);            
      su=s%10;                            
      sd=(s-su)/10;                       
      l=vis-(s*1000)-(m*60000);        
      lu=l%10;                           
      ld=((l-lu)/10)%10;                  
      lc=(l-(ld*10)-lu)/100;              
      lcd.setCursor(7, 1);                
      lcd.print(md);                      
      lcd.print(mu);               
      lcd.print(":");
      lcd.print(sd);
      lcd.print(su);
      lcd.print(":");
      lcd.print(lc);
      lcd.print(ld);
      lcd.print(lu);

      
    } 
  }
}
//*********************************************************************
void tiempo_libres(){                                                  //TIEMPOS SESIÓN LIBRE

  total=total+tiempo_actual;
  media=total/(lap-1);

 
   
  if(mejor_vuelta == 0){
    mejor_vuelta=tiempo_actual;
  }
  if(mejor_vuelta >= tiempo_actual){
    mejor_vuelta=tiempo_actual;
  }
}

//********************************************************
void laps(){ //VUELTAS
  
    lap++;
    if(lap<10){
    lcd.setCursor(2,0);
    lcd.print("00");
    lcd.setCursor(4,0);
    lcd.print(lap);  
  }
  if(lap>9 && lap<100){
    lcd.setCursor(2,0);
    lcd.print("0");
    lcd.setCursor(3,0);
    lcd.print(lap);
  }
  if(lap>99){
    lcd.setCursor(2,0);
    lcd.print(lap);
  }
  
 sd_w();
  
}
//***********************************************************
void select_channel_menu(){                           //MENÚ SELECCIÓN DE CANAL
  lcd.clear();
  while(pul == 2){
    lcd.setCursor(6,0);
    lcd.print("MENU");
    lcd.setCursor(0,1);
    lcd.print(" SELECT CHANNEL ");
  
  up = digitalRead(bup); //Lectura de los estados de los botones.
  down = digitalRead(bdown);
  right = digitalRead(bright);

      if(down == HIGH){
      pul=3;
      delay(250);
      read_sd_menu();
    }
    else if(up == HIGH){
      pul=1;
      delay(250);
      main_menu();
    }
    else if(right == HIGH){
      pul=21;
      delay(250);
      select_channel();
    }
  }
}
//*********************************************************
void select_channel(){
  irrecv.enableIRIn(); //Habilita infrarrojos.
  lcd.clear();
  while(pul == 21){
    
    up = digitalRead(bup); //Lectura de los estados de los botones.
    left = digitalRead(bleft);
    right = digitalRead(bright);

    lcd.setCursor(1,0);
    lcd.print("SELECT CHANNEL");

    if(left == HIGH){
      pul=2;
      delay(250);
      select_channel_menu();
    }
  
    if(irrecv.decode(&results)){
      lcd.setCursor(3,1);
      lcd.print(results.value,HEX);
      codigo=results.value;
      delay(300);
      irrecv.resume();
    }
    if(right == HIGH){
      pul=2;
      delay(250);
      select_channel_menu();
    }
  }
}
//********************************************************

void read_sd_menu(){                                      //MENÚ TARJETA SD
  lcd.clear();
  while(pul == 3){
    lcd.setCursor(6,0);
    lcd.print("MENU");
    lcd.setCursor(0,1);
    lcd.print("    READ SD     ");
  
  up = digitalRead(bup); //Lectura de los estados de los botones.
  down = digitalRead(bdown);
  right = digitalRead(bright);

    if(down == HIGH){
      pul=1;
      delay(250);
      main_menu();
    }
    else if(up == HIGH){
      pul=2;
      delay(250);
      select_channel_menu();
    }
    else if(right == HIGH){
      pul=31;
      sd_card_create();
      delay(250);
    }
  }
}

//******************************************************************** SD CARD
void sd_card_create(){
    int num = 1;

  
  Serial.println("Opened");
  Serial.println("Testing");

  sprintf(ses, "%d.txt", num);

  while (SD.exists(ses)) {
    Serial.print(num);
    Serial.println(" Exists");
    num++;
    sprintf(ses, "%d.txt", num);
  }
  Serial.println(ses);
  Serial.println(" creating");
  myFile = SD.open(ses, FILE_WRITE);
 // myFile = SD.open("ORENES.txt", FILE_WRITE);
  if (myFile) {
    myFile.print(F("Total laps:\r\n000\r\n\r\nTotal time:\r\n00:00:00:000\r\n\r\nBest lap:\r\n00:00:000\r\n\r\nAverage:\r\n00:00:000\r\n\r\n"));
    Serial.println("Writing");
    myFile.flush();
    delay(10);
    pul=12;
    free_season();
  }
  else {
    Serial.println("Error");
  }
}
//********************************************************** SD WRITING
  void sd_w(){
   i = lap-1;
  myFile = SD.open(ses, FILE_WRITE);
      if(i<10){
      myFile.seek(TOT_LAP_POS);
      myFile.print("00");
      myFile.print(i);
     
    }
  if(i>9 && i<100){
    myFile.seek(TOT_LAP_POS);
    myFile.print("0");
    myFile.print(i);
 
 }
    if(i>99){
      myFile.seek(TOT_LAP_POS);
      myFile.print(i);

    }
    best();
}
//******************************************************
 void best(){

     m=mejor_vuelta/60000;                     
     mu=m%10;                           
     md=(m-mu)/10;                       
     s=(mejor_vuelta/1000)-(m*60);            
     su=s%10;                            
     sd=(s-su)/10;                       
     l=mejor_vuelta-(s*1000)-(m*60000);        
     lu=l%10;                           
     ld=((l-lu)/10)%10;                  
     lc=(l-(ld*10)-lu)/100;
     myFile.seek(BEST_LAP_POS);                           
     myFile.print(md);                      
     myFile.print(mu);               
     myFile.print(":");
     myFile.print(sd);
     myFile.print(su);
     myFile.print(":");
     myFile.print(lc);
     myFile.print(ld);
     myFile.print(lu);
    average();
}
//************************************************************
void average(){
     m=mejor_vuelta/60000;                     
     mu=m%10;                           
     md=(m-mu)/10;                       
     s=(media/1000)-(m*60);            
     su=s%10;                            
     sd=(s-su)/10;                       
     l=media-(s*1000)-(m*60000);        
     lu=l%10;                           
     ld=((l-lu)/10)%10;                  
     lc=(l-(ld*10)-lu)/100;
     myFile.seek(AVERAGE_POS);                           
     myFile.print(md);                      
     myFile.print(mu);               
     myFile.print(":");
     myFile.print(sd);
     myFile.print(su);
     myFile.print(":");
     myFile.print(lc);
     myFile.print(ld);
     myFile.print(lu);
     myFile.close();
     lap_w();
}
//***********************************************
void lap_w(){
  myFile = SD.open(ses, FILE_WRITE);
  if(myFile){
  Serial.println(tiempo_actual);
     m=tiempo_actual/60000;                     
     mu=m%10;                           
     md=(m-mu)/10;                       
     s=(tiempo_actual/1000)-(m*60);            
     su=s%10;                            
     sd=(s-su)/10;                       
     l=tiempo_actual-(s*1000)-(m*60000);        
     lu=l%10;                           
     ld=((l-lu)/10)%10;                  
     lc=(l-(ld*10)-lu)/100;
     myFile.println("");
     myFile.print("LAP:");   
     myFile.println(i);                        
     myFile.print(md);                      
     myFile.print(mu);               
     myFile.print(":");
     myFile.print(sd);
     myFile.print(su);
     myFile.print(":");
     myFile.print(lc);
     myFile.print(ld);
     myFile.println(lu);
     Serial.println("Lap written");
  myFile.close();
}
}

Dejo el código de todo lo que llevo hecho y ahora empezaré con desde cero pero empezando primero con la SD para ir descartando fallos de código, creo que así sería más fácil encontrar el gazapo.

No se yo, pero a lo mejor es muchísimo código para lo que es en realidad.

Saludos.