Grabar datos en SD varias veces

Buenas de nuevo.
Quisiera poder grabar datos en una SD en el mismo archivo, solo encuentro ejemplos de grabación por temporización, que al terminar el if se cierra el archivo, y como se puede seguir escribiendo en el?
tengo este codigo que sera la grabacion de unos contadores, que solo quiero que se graben al haber un cambio en ellos, pero no quisiera 50 archivos con esos cambios, me gustaría mas que se quedara un archivo contadores2021 hasta el año siguiente que seria contadores2022. y dentro de estos archivos se quedaran todos los datos. Lo del cambio de nombre del archivo ya lo tengo pensado pero ahora me interesa saber como arreglar lo de escribir todos los datos en un mismo archivo.

#include <SD.h>

File LecturaContadores;
int contador1 =0;
int contador2 =0;
int contador3 =0;
 int contador4; // es para la activacion del if
unsigned long tiempoAhora=0;
unsigned long tiempoPasado=0;
int tiempoespera = 1000;

void setup()
{
  Serial.begin(9600);
  Serial.print("Iniciando SD ...");
  if (!SD.begin(10)) {                         //donde esta conectada la cs de la targeta
    Serial.println("No se pudo inicializar");
    return;
  }
  Serial.println("inicializacion exitosa");
}

void loop()
{
  LecturaContadores = SD.open("contadores2021.csv", FILE_WRITE);//abrimos  el archivo
  tiempoAhora = millis();
  if (  tiempoAhora - tiempoPasado > tiempoespera){
    tiempoPasado=tiempoAhora;
    contador4= contador1;
    contador1= contador1+1;
    contador2=contador2+2;
    contador3=contador3+5;
  }

  
  if (LecturaContadores) { 
        
       /* int sensor1 = analogRead(0);
        int sensor2 = analogRead(1);
        int sensor3 = analogRead(2);*/
       if (contador4 != contador1){
        Serial.print("Escribiendo SD: ");
        LecturaContadores.print("Tiempo(ms)=");
        LecturaContadores.print(millis());
        LecturaContadores.print(", contador1=");
        LecturaContadores.print(contador1);
        LecturaContadores.print(", contador2=");
        LecturaContadores.print(contador2);
        LecturaContadores.print(", contador3=");
        LecturaContadores.print(contador3);
        LecturaContadores.print(", contador4=");
        LecturaContadores.println(contador4);
        contador4=contador1;      
        LecturaContadores.close(); //cerramos el archivo
      }
        Serial.print("Tiempo(ms)=");
        Serial.print(millis());
        Serial.print(", contador1=");
        Serial.print(contador1);
        Serial.print(", contador2=");
        Serial.print(contador2);
        Serial.print(", contador3=");
        Serial.println(contador3); 
 } else {
    Serial.println("Error al abrir el archivo");
  }
  
}

haber si me podeis orientar, porque es necesario que se cierre el archivo para poder luego llevar la SD al pc,¿verdad?.

Solucionado, es un tema Fisico de la SD al no poner un delay en el loop, se abria y se cerraba demasiado rapido el archivo y la Sd o el lector de tarjeta no podia cerrar o abrir el archivo a tiempo y se solopaban las ordenes de cierre y apertura

Bueno, creia que lo havia solucinado, pero no. He intentado poner unos millis(). pero no funciona bien la cosa despues de mas o menos 50 escrituras, deja de abrir el archivo y me da error.
haber si ustedes que teneis un conocimiento mas profundo sobre arduino me podeis orientar.
Creo que el problema esta en los millis() pero no estoy seguro.

#include <SD.h>

File LecturaContadores;
int contador1 =1;
int contador2 =0;
int contador3 =0;
 int contador4; // es para la activacion del if
unsigned long tiempoAhora0=0;
unsigned long tiempoPasado0=0;
unsigned long tiempoAhora1=0;
unsigned long tiempoPasado1=0;
unsigned long tiempoAhora2=0;
unsigned long tiempoPasado2=0;
int tiempoespera = 20000;
int a=0;
int i =0;
void setup()
{
  Serial.begin(9600);
  Serial.print("Iniciando SD ...");
  if (!SD.begin(10)) {                         //donde esta conectada la cs de la targeta
    Serial.println("No se pudo inicializar");
    return;
  }
  Serial.println("inicializacion exitosa");


}
void loop()
{ 
  tiempoAhora0 = millis();
  if (  tiempoAhora0 - tiempoPasado0 > tiempoespera){
    tiempoPasado0=tiempoAhora0;
    LecturaContadores = SD.open("contado.csv", FILE_WRITE);//abrimos  el archivo
  
 
  tiempoAhora1 = millis();
  if (  tiempoAhora1 - tiempoPasado1 > tiempoespera){
    tiempoPasado1=tiempoAhora1;
   if( i<10){
    contador4= contador1;
    contador1= contador1+1;
    contador2=contador2+2;
    contador3=contador3+5;
    i++;
    }
    else{
      i=0;
      contador1 =0;
      contador2 =0;
      contador3=0;
      contador4=0;
    }
  }


  if (LecturaContadores) { 
        
     
       if (contador4 != contador1){
        a=a+1;
       
        Serial.print("Escribiendo SD: ");
        Serial.print( "grabaciones  " );
        Serial.println(a);
       // LecturaContadores.print("Tiempo(ms)=");
       // LecturaContadores.print(millis());
        LecturaContadores.print(", contador1=");
        LecturaContadores.print(contador1);
        LecturaContadores.print(", contador2=");
        LecturaContadores.print(contador2);
        LecturaContadores.print(", contador3=");
        LecturaContadores.print(contador3);
        LecturaContadores.print(", contador4=");
        LecturaContadores.println(contador4);
        contador4=contador1;      
        LecturaContadores.close(); //cerramos el archivo
     
      }
             
 } else {
    Serial.println("Error al abrir el archivo");
  }}
  
}

esto es un resumen del monitor Serial.

22:51:50.343 -> Iniciando SD... inicializacion exitosa 
22:52:11.910 -> Escribiendo SD: grabaciones  1
22:52:31.930 -> Escribiendo SD: grabaciones  2
22:52:51.911 -> Escribiendo SD: grabaciones  3
22:53:11.917 -> Escribiendo SD: grabaciones  4
22:53:31.909 -> Escribiendo SD: grabaciones  5
22:54:11.879 -> Escribiendo SD: grabaciones  6
22:54:31.899 -> Escribiendo SD: grabaciones  7
22:54:51.872 -> Escribiendo SD: grabaciones  8
22:55:11.903 -> Escribiendo SD: grabaciones  9
22:55:51.891 -> Escribiendo SD: grabaciones  10
        

23:17:11.767 -> Escribiendo SD: grabaciones  55
23:17:51.765 -> Escribiendo SD: grabaciones  56
23:18:11.754 -> Escribiendo SD: grabaciones  57
23:18:31.737 -> Escribiendo SD: grabaciones  58
23:19:11.747 -> Error al abrir el archivo
23:19:31.744 -> Error al abrir el archivo

Comienzo señalándote algunos errores

if (  tiempoAhora1 - tiempoPasado1 > tiempoespera){

tiempoespera debe definirse como unsigned long al igual que los otros y ya que no varía agrega un const unsigned long

const unsigned long tiempoespera = 20000;

Seguramente en ese tiempo se superan los 20000 mseg en entero y por eso el error.
Igualmente hay cosas para seguir mejorando.

A ver como funciona esto.
Para mi usas exceso de variables que llevan millis() y no hay diferencia en milisegundos dentro de 1 ciclo

#include <SD.h>

File LecturaContadores;
int contador1 =1;
int contador2 =0;
int contador3 =0;
int contador4; // es para la activacion del if
unsigned long tiempoAhora0;
unsigned long tiempoPasado0;
unsigned long tiempoAhora1;
unsigned long tiempoPasado1;
unsigned long tiempoAhora2;
unsigned long tiempoPasado2;
const unsigned long tiempoespera = 20000;
int a = 0;
int i = 0;

void setup()
{
  Serial.begin(9600);
  Serial.print("Iniciando SD ...");
  if (!SD.begin(10)) {                         //donde esta conectada la cs de la targeta
        Serial.println("No se pudo inicializar");
        return;
  }
  Serial.println("inicializacion exitosa");
}

void loop() { 
    tiempoAhora0 = millis();
    if (tiempoAhora0 - tiempoPasado0 > tiempoespera) {
        LecturaContadores = SD.open("contado.csv", FILE_WRITE);//abrimos  el archivo
        if( i<10){
            contador4 = contador1;
            contador1 = contador1+1;
            contador2 = contador2+2;
            contador3 = contador3+5;
            i++;
        }
        else{
            i=0;
            contador1 = 0;
            contador2 = 0;
            contador3 = 0;
            contador4 = 0;
        }
        tiempoPasado0 = tiempoAhora0;
    }

    if (LecturaContadores) { 
       if (contador4 != contador1){
           a=a+1;
       
        Serial.print("Escribiendo SD: ");
        Serial.print( "grabaciones  " );
        Serial.println(a);
        // LecturaContadores.print("Tiempo(ms)=");
        // LecturaContadores.print(millis());
        LecturaContadores.print(", contador1=");
        LecturaContadores.print(contador1);
        LecturaContadores.print(", contador2=");
        LecturaContadores.print(contador2);
        LecturaContadores.print(", contador3=");
        LecturaContadores.print(contador3);
        LecturaContadores.print(", contador4=");
        LecturaContadores.println(contador4);
        contador4=contador1;      
        LecturaContadores.close(); //cerramos el archivo
    }
             
    } else {
        Serial.println("Error al abrir el archivo");
    }
  }
}

Gracias Surbyte, pero el ejemplo que me has mandado, no me consigue abrir el archivo, creo que va tan rapido que no puede la tarjeta fisicamente el abrir el archivo antes de cerrarlo.
he vuelto a poner todos los temporizadores, haber que sucede, lo que si he cambiado es el tipo de dato en el tiempo de espera a como tu me aconsejas const unsigned long. haber que ocurre.

nada a los 60 ciclos se bloquea y error al abrir el archivo.
la tarjeta es una SDHC de 8GB.

#include <SD.h>

File LecturaContadores;
int contador1 =1;
int contador2 =0;
int contador3 =0;
 int contador4; // es para la activacion del if
unsigned long tiempoAhora0=0;
unsigned long tiempoPasado0=0;
unsigned long tiempoAhora1=0;
unsigned long tiempoPasado1=0;
unsigned long tiempoAhora2=0;
unsigned long tiempoPasado2=0;
const unsigned long tiempoespera = 20000;
int a=0;
int i =0;
void setup()
{
  Serial.begin(9600);
  Serial.print("Iniciando SD ...");
  if (!SD.begin(10)) {                         //donde esta conectada la cs de la targeta
    Serial.println("No se pudo inicializar");
    return;
  }
  Serial.println("inicializacion exitosa");


}
void loop()
{ 
  tiempoAhora0 = millis();
  if (  tiempoAhora0 - tiempoPasado0 > tiempoespera){
   // tiempoPasado0=tiempoAhora0;
    LecturaContadores = SD.open("contado.csv", FILE_WRITE);//abrimos  el archivo
  
 
  tiempoAhora1 = millis();
  if (  tiempoAhora1 - tiempoPasado1 > tiempoespera){
    tiempoPasado1=tiempoAhora1;
   if( i<10){
    contador4= contador1;
    contador1= contador1+1;
    contador2=contador2+2;
    contador3=contador3+5;
    i++;
    }
    else{
      i=0;
      contador1 =0;
      contador2 =0;
      contador3=0;
      contador4=0;
    }
    tiempoPasado0=tiempoAhora0;
  }


  if (LecturaContadores) { 
        
     
       if (contador4 != contador1){
        a=a+1;
       
        Serial.print("Escribiendo SD: ");
        Serial.print( "grabaciones  " );
        Serial.println(a);
       // LecturaContadores.print("Tiempo(ms)=");
       // LecturaContadores.print(millis());
        LecturaContadores.print(", contador1=");
        LecturaContadores.print(contador1);
        LecturaContadores.print(", contador2=");
        LecturaContadores.print(contador2);
        LecturaContadores.print(", contador3=");
        LecturaContadores.print(contador3);
        LecturaContadores.print(", contador4=");
        LecturaContadores.println(contador4);
        contador4=contador1;      
        LecturaContadores.close(); //cerramos el archivo
     
      }
             
 } else {
    Serial.println("Error al abrir el archivo");
  }}
  
}

Bueno, parece que he conseguido que funcione, aunque no se si lo ara en el programa principal, pero en este parece que ya lo hace
Escribiendo SD: grabaciones 312 tiempo en segundos: 1
Escribiendo SD: grabaciones 313 tiempo en segundos: 1
Escribiendo SD: grabaciones 314 tiempo en segundos: 1
Escribiendo SD: grabaciones 315 tiempo en segundos: 1

#include <SD.h>

File LecturaContadores;
int contador1 =1;
int contador2 =0;
int contador3 =0;
int contador4; // es para la activacion del if
unsigned long tiempoAhora0=0;
unsigned long tiempoPasado0=0;
unsigned long tiempoAhora1=0;
unsigned long tiempoPasado1=0;
unsigned long tiempoAhora2=0;
unsigned long tiempoPasado2=0;
const unsigned long tiempoespera = 2000;
unsigned long TiempoAnterior_del_IF=0;
int a=0;
int i =0;
void setup()
{
  Serial.begin(9600);
  Serial.print("Iniciando SD ...");
  if (!SD.begin(10)) {                         //donde esta conectada la cs de la targeta
    Serial.println("No se pudo inicializar");
    return;
  }
  Serial.println("inicializacion exitosa");


}
void loop() { 
  ///====== retraso el tiempo de apertura del archivo para que tenga tiempo la tarjeta de cerrar el archivo

     tiempoAhora0 = millis();
  if (  tiempoAhora0 - tiempoPasado0 > tiempoespera){
      tiempoPasado0=tiempoAhora0;
      LecturaContadores = SD.open("contado.csv", FILE_WRITE);//abrimos  el archivo

   //===== retraso para que le de tiempo a la targeta a estar abierto el archivo

  //     tiempoAhora1 = millis();
  //   if (  tiempoAhora1 - tiempoPasado1 > tiempoespera){
  //       tiempoPasado1=tiempoAhora1;

          if( i<10){
            contador4= contador1;
            contador1= contador1+1;
            contador2=contador2+2;
            contador3=contador3+5;
            i++;
          }
         else{
            i=0;
            contador1 =1;
            contador2 =0;
            contador3=0;
            contador4=0;
           }
       }


   // if (LecturaContadores) { 
    while  (LecturaContadores) {
        
       if (contador4 != contador1){
          a=a+1;   
          Serial.print("Escribiendo SD: ");
          Serial.print( "grabaciones  " );
          Serial.print(a);
          Serial.print("    tiempo en segundos: ");
          Serial.println((millis()-TiempoAnterior_del_IF)/1000);
          LecturaContadores.print(", contador1=");
          LecturaContadores.print(contador1);
          LecturaContadores.print(", contador2=");
          LecturaContadores.print(contador2);
          LecturaContadores.print(", contador3=");
          LecturaContadores.print(contador3);
          LecturaContadores.print(", contador4=");
          LecturaContadores.println(contador4);
          contador4=contador1;      
          LecturaContadores.close(); //cerramos el archivo
          TiempoAnterior_del_IF = millis();
        }           
    // }
  else{
    Serial.println("error al abrir archivo");
     }
  }
}

He colocado un while esperando a que este abierto el archivo.
pero tengo una duda si observais el resultado del monitor serial, me dice que ha pasado solo 1 segundo en cada ciclo del while. y por lo menos tendria que pasar 2 segundos, alguien sabe porque?.
Gracias por la ayuda. :+1:

Veo algunas cosas raras.

while  (LecturaContadores) {

quien te asegura que el while sale cuando haces esto?

 LecturaContadores.close(); //cerramos el archivo

Porque creo que has supuesto que al cerrarlo LecturaContadores se pone en 0 y es la variable con la que controlas el while, asi que verifica.

Por otro lado porque dentro del while haces esto?

contador4 = contador1;  

Si cuando i <10 tmb lo haces. Debes tener cuidado con eso ,porque luego da lugar a malas interpretaciones.
En un solo lugar debes incrementar o no a contador4. No en diferentes.

Tienes toda la razon Surbyte, estuve probando varias cosas como retirar la tarjeta y en mi desconocimiento, vi que el while no respondia.
Otra cosa aprendida.

Nada, me he liado la manta a la cabeza y he modificado todo el codigo.
utilizando el programa basico para la escritura de la SD he echo modificaciones, recordando los detalles que me has indicado Surbyte, Gracias.
este es el nuevo codigo.

#include <SD.h>

File LecturaContadores;

//=====Variables contadores y tiempo
int contador1 =1;
int contador2 =0;
int contador3 =0;
int contador4; // es para la activacion del if
unsigned long tiempoAhora0=0;
unsigned long tiempoPasado0=0;
unsigned long tiempoAhora1=0;
unsigned long tiempoPasado1=0;
unsigned long tiempoAhora2=0;
unsigned long tiempoPasado2=0;
const unsigned long tiempoespera = 1000;
int a=0;
int i =0;

void setup()
{
   Serial.begin(9600);
     Serial.print("Iniciando SD ...");
       if (!SD.begin(10)) {
         Serial.println("No se pudo inicializar");
         return;
         }
     Serial.println("inicializacion exitosa");
  
      if(!SD.exists("datalog.csv"))
       {
       LecturaContadores = SD.open("datalog.csv", FILE_WRITE);
          if (LecturaContadores) {
              Serial.println("Archivo nuevo, Escribiendo encabezado(fila 1)");
                 LecturaContadores.close();
                  } else {
                    Serial.println("Error creando el archivo datalog.csv");
                     }
        }
  
}


void Inicializacion_SD(){
       Serial.begin(9600);
       Serial.print("Iniciando SD ...");
          if (!SD.begin(10)) {
             Serial.println("No se pudo inicializar");
              return;
              }
       Serial.println("inicializacion exitosa");
   }

void loop()
{
  tiempoAhora0 = millis();
  if (  tiempoAhora0 - tiempoPasado0 > tiempoespera){
      tiempoPasado0=tiempoAhora0;

if( i<10){
            //contador4= contador1;
            contador1= contador1+1;
            contador2=contador2+2;
            contador3=contador3+5;
            i++;
          }
         else{
            i=0;
            contador1 =0;
            contador2 =0;
            contador3=0;
            contador4=0;
           }

 if (contador4 != contador1){
  Abrir_Archivo_escribe();
 }
  }
}
  void Abrir_Archivo_escribe()
     {
      
       LecturaContadores = SD.open("datalog.csv", FILE_WRITE);//abrimos  el archivo
  
       if (LecturaContadores) { 
            a=a+1;   
          Serial.print("   Tiempo(ms)=");
          Serial.print(millis());
          Serial.print("   Escribiendo SD: ");
          Serial.print( "   grabaciones  " );
          Serial.print(a);
          Serial.print( "  contador1  ");
          Serial.print( contador1);
          Serial.print( "  contador4  ");
          Serial.println(contador4);
         
          LecturaContadores.print(", contador1=");
          LecturaContadores.print(contador1);
          LecturaContadores.print(", contador2=");
          LecturaContadores.print(contador2);
          LecturaContadores.print(", contador3=");
          LecturaContadores.print(contador3);
          LecturaContadores.print(", contador4=");
          LecturaContadores.println(contador4);
          contador4 = contador1;
        
        LecturaContadores.close(); //cerramos el archivo
        
             
                    
  
  } else {
    // if the file didn't open, print an error:
    Serial.println("Error al abrir el archivo");
    Inicializacion_SD();
  }
 
}

y este es el resultado en el monitor serial.
Creo que se aprecia el momento que contador 4 y contador 1 son iguales por un retraso en la escritura de 2 segundos.

Tiempo(ms)=1007   Escribiendo SD:    grabaciones  1  contador1  2  contador4  0
  Tiempo(ms)=2010   Escribiendo SD:    grabaciones  2  contador1  3  contador4  2
  Tiempo(ms)=3010   Escribiendo SD:    grabaciones  3  contador1  4  contador4  3
  Tiempo(ms)=4012   Escribiendo SD:    grabaciones  4  contador1  5  contador4  4
  Tiempo(ms)=5012   Escribiendo SD:    grabaciones  5  contador1  6  contador4  5
  Tiempo(ms)=6013   Escribiendo SD:    grabaciones  6  contador1  7  contador4  6
  Tiempo(ms)=7014   Escribiendo SD:    grabaciones  7  contador1  8  contador4  7
  Tiempo(ms)=8015   Escribiendo SD:    grabaciones  8  contador1  9  contador4  8
  Tiempo(ms)=9016   Escribiendo SD:    grabaciones  9  contador1  10  contador4  9
  Tiempo(ms)=10017   Escribiendo SD:    grabaciones  10  contador1  11  contador4  10
  **Tiempo(ms)=12019   Escribiendo SD:    grabaciones  11  contador1  1  contador4  0**
  Tiempo(ms)=13021   Escribiendo SD:    grabaciones  12  contador1  2  contador4  1
  Tiempo(ms)=14022   Escribiendo SD:    grabaciones  13  contador1  3  contador4  2
  Tiempo(ms)=15024   Escribiendo SD:    grabaciones  14  contador1  4  contador4  3
  Tiempo(ms)=16024   Escribiendo SD:    grabaciones  15  contador1  5  contador4  4
  Tiempo(ms)=17026   Escribiendo SD:    grabaciones  16  contador1  6  contador4  5
  Tiempo(ms)=18026   Escribiendo SD:    grabaciones  17  contador1  7  contador4  6
  Tiempo(ms)=19027   Escribiendo SD:    grabaciones  18  contador1  8  contador4  7
  Tiempo(ms)=20028   Escribiendo SD:    grabaciones  19  contador1  9  contador4  8
  Tiempo(ms)=21029   Escribiendo SD:    grabaciones  20  contador1  10  contador4  9
  **Tiempo(ms)=23031   Escribiendo SD:    grabaciones  21  contador1  1  contador4  0**
  Tiempo(ms)=24032   Escribiendo SD:    grabaciones  22  contador1  2  contador4  1
  Tiempo(ms)=25033   Escribiendo SD:    grabaciones  23  contador1  3  contador4  2
  Tiempo(ms)=26034   Escribiendo SD:    grabaciones  24  contador1  4  contador4  3
  Tiempo(ms)=27035   Escribiendo SD:    grabaciones  25  contador1  5  contador4  4
  Tiempo(ms)=28037   Escribiendo SD:    grabaciones  26  contador1  6  contador4  5
  Tiempo(ms)=29037   Escribiendo SD:    grabaciones  27  contador1  7  contador4  6
  Tiempo(ms)=30039   Escribiendo SD:    grabaciones  28  contador1  8  contador4  7
  Tiempo(ms)=31039   Escribiendo SD:    grabaciones  29  contador1  9  contador4  8
  Tiempo(ms)=32040   Escribiendo SD:    grabaciones  30  contador1  10  contador4  9
  **Tiempo(ms)=34042   Escribiendo SD:    grabaciones  31  contador1  1  contador4  0**
  Tiempo(ms)=35043   Escribiendo SD:    grabaciones  32  contador1  2  contador4  1
  Tiempo(ms)=36044   Escribiendo SD:    grabaciones  33  contador1  3  contador4  2
  Tiempo(ms)=37045   Escribiendo SD:    grabaciones  34  contador1  4  contador4  3
  Tiempo(ms)=38046   Escribiendo SD:    grabaciones  35  contador1  5  contador4  4
  Tiempo(ms)=39047   Escribiendo SD:    grabaciones  36  contador1  6  contador4  5
  Tiempo(ms)=40048   Escribiendo SD:    grabaciones  37  contador1  7  contador4  6
  Tiempo(ms)=41050   Escribiendo SD:    grabaciones  38  contador1  8  contador4  7
  Tiempo(ms)=42050   Escribiendo SD:    grabaciones  39  contador1  9  contador4  8
  Tiempo(ms)=43052   Escribiendo SD:    grabaciones  40  contador1  10  contador4  9
  **Tiempo(ms)=45053   Escribiendo SD:    grabaciones  41  contador1  1  contador4  0**
  Tiempo(ms)=46054   Escribiendo SD:    grabaciones  42  contador1  2  contador4  1
  Tiempo(ms)=47055   Escribiendo SD:    grabaciones  43  contador1  3  contador4  2
  Tiempo(ms)=48056   Escribiendo SD:    grabaciones  44  contador1  4  contador4  3
  Tiempo(ms)=49057   Escribiendo SD:    grabaciones  45  contador1  5  contador4  4
  Tiempo(ms)=50058   Escribiendo SD:    grabaciones  46  contador1  6  contador4  5
  Tiempo(ms)=51059   Escribiendo SD:    grabaciones  47  contador1  7  contador4  6
  Tiempo(ms)=52061   Escribiendo SD:    grabaciones  48  contador1  8  contador4  7
  Tiempo(ms)=53062   Escribiendo SD:    grabaciones  49  contador1  9  contador4  8
  Tiempo(ms)=54064   Escribiendo SD:    grabaciones  50  contador1  10  contador4  9
  **Tiempo(ms)=56066   Escribiendo SD:    grabaciones  51  contador1  1  contador4  0**
  Tiempo(ms)=57066   Escribiendo SD:    grabaciones  52  contador1  2  contador4  1
  Tiempo(ms)=58067   Escribiendo SD:    grabaciones  53  contador1  3  contador4  2
  Tiempo(ms)=59068   Escribiendo SD:    grabaciones  54  contador1  4  contador4  3

La grabación demora 2 segundos porque has puesto que grabe cuando contador4 y contador1 sean diferentes, cuando los pones a 0, deben pasar dos iteracciones para que eso ocurra.
El código esta bien aunque supongo que es de aprendizaje, porque no le encuentro mas objetivo que didáctico.

Es didáctico, pero lo quiero implementar en uno más grande que si que son lectura de contadores reales. Pinza amperimetrica, carga los valores en diferentes Contadores según él horario y este Código es para que se graven cada vez que hay un cambio en uno de los contadores. por lo que entre consumo de kwh y kwh pasa bastante tiempo.
el proyecto empezo tomando medidas con una pinza y ya tiene casi 800 lineas jaja
que tambien estoy por resolver el otro que estoy liado para reducir codigo que es el de los festivos, en el que gracias a tu inestimable ayuda progresa, Gracias, de verdad.

Bueno, ves, todo esto que comentas constituye un proyecto pero al ponerlo en hilos separados y hasta que lo comentaste no le vi que estaban ligados.
Es bueno que uno plantee un problema y luego se resuelvan pequeñas cosas que forman parte del proyecto mayor.
Considéralo.

aunque se que nos son las normas del foro, te pruegunto Surbyte,
estoy intentando usar los ultimos valores para intentar que al arrancar arduino, lea esa ultima fila y cambie los valores de contador 1, 2 y3 que en el principio son 0 a los valores que estubieran en ultimo lugar.
Consigo leer los datos de la SD, que porcierto los tengo en columnas solo los valores y separados por una coma.
pero como separo esos valores para que arduino los asigne a las variables?.
P.D. no es el codigo lo que pido, si no la orientacion para seguir.
por ejemplo:
contador1------- contador 2----- contador 3
1---------------------3------------------------ 5
6 ------------------- 7 -------------------1234857

Hay varias maneras pero dependen de como es que apagas el Arduino.
Versión 1. EEPROM
Si se apaga de golpe como creo habías preguntado en otro hilo (ves que tener un único hilo ayuda a seguir la idea genral?), entonces supongamos que detectas ese momento y como parte de la tarea salvas los ultimos datos en la EEPROM, entonces al arrancar recuperas esos valores y listo.

Versión 2. Leo todas las lineas, y simplemente las cuento, me quedo con el ultimo registro y sigo a partir de ahi. Es una lectura ciega digamos, donde el o las variables se van pisando o sea cada lectura modifica el valor anterior. Terminas con los ultimos valores y ahi es donde continúas.

Yo

La segunda parte es la que intentó hacer, y he visto como leer la última línea, pero no consiguió que funcione bien mañana miro de subir las, pruebas con los códigos.