Datafile.print: Print string problem

Dear,

i’am making a test station for detection of a crash. For getting al the data, i use sd-slot on the wireless shield. At the moment i have a working program, where i store mine data by putting every variable whit a datafile.print on the Sd card. (see Original program). The void loop is now 40 ms and only for “datafile.print” need i 30ms. For the moment is this to long.

Original Program:

  File dataFile = SD.open(filename,FILE_WRITE);         // DataFile word geopend en de volgende variabelen worden er in weg geschreven.
  if (dataFile){
   dataFile.print(Sensor1Reading);
   dataFile.print(",");
   dataFile.print(volt);
   dataFile.print(",");
   dataFile.print(afstand);
   dataFile.print(",");
   dataFile.print(acceleratiefactor);
   dataFile.print(",");
   dataFile.print(led1State);
   dataFile.print(",");
   dataFile.print(led2State);
   dataFile.print(",");
   dataFile.print(SeaftyState);
   dataFile.print(",");
   dataFile.println(Tijd);
   dataFile.close();
   
   Serial.print(Sensor1Reading);                       // Deze tekst word op de Serial monitor afgedrukt. 
   Serial.print(",");
   Serial.print(volt);
   Serial.print(",");
   Serial.print(afstand);
   Serial.print(",");
   Serial.print(acceleratiefactor);
   Serial.print(",");
   Serial.print(led1State);
   Serial.print(",");
   Serial.print(led2State);
   Serial.print(",");
   Serial.print(SeaftyState);
   Serial.print(",");
   Serial.println(Tijd);
   Serial.println(filename);
  
   //delay (500); //500ms 
   }
    
  else {Serial.println("error opening datalog.txt (controleer SD kaart)");
  Serial.println(filename);                           //Lukt het niet om weg te schrijven word volgende melding gegeven.
  delay (1000); //1000ms
  }
}

The solution is to not use so many “datafile.print”. And i have been trying by putting first all the variable in datastring. but here is my problem. I use different variables (char, string, time, etc.) and by char can’t I use “+ opperator”.

My program can you find under here.

But do you have tips or tricks to what type I best declare my variables or convert them. So i can put them together in one string so i just need one or 2 “datafile.print”.

Thank you for your time and effort.

Tim Matthijs

Program:

//Ultrasoon

#include <string.h>                                        // #include => oproepen van bibliotheek
#include <stdlib.h>
#include <SD.h>
#define aref_voltage 5.0                                   // De 5V word met de Aref verbonden en gedefineerd

//Pin deffinitie
const int Sensor1Pin = A15;                                // De 1e sensor word aan de analoge pin 15 verbonden
const int chipSelect = 4;                                  // Pin voor comunicatie SD kaart
const int SeaftyPin = 49;                                  // Pin die triggert wanneer de robot moet stil vallen
const int Led1Pin = 48;                                    // Pin verbonden met LED voor voltage.
const int Led2Pin = 47;                                    // Pin verbonden met LED voor acceleratiefactor

//Globel Variabelen
int Sensor1Reading = 0;                                    // De waarde van het analoog lezen
float voltage;                                             // De waarde van voltage (moet global om acceleratie te kunnen uitrekenen)
unsigned long Tijd;                                        // Tijd 
char filename[] = "ULTSON00.TXT";                          // Naam van text bestand op SD kaart
File logfile;
String SeaftyState = "0";
String datafilestring = "";

void setup() {                                             // Deze loop word alleen maar doorlopen bij het opstarten.
    Serial.begin(9600);                                    // start de serieële communicatie op aan 9600bits per seconde.
    analogReference(EXTERNAL);                             // Voor de analoge uitlezing zal de referentie extern worden aangelegt
    Serial.print("Initializing SD card...");               // Deze tekst word op de Serial monitor afgedrukt. 
    
    pinMode(10,OUTPUT);                                    // Definitie Welk soort de pin is. (input/output)
    pinMode(Led1Pin,OUTPUT);
    pinMode(Led2Pin,OUTPUT);
    pinMode(SeaftyPin,OUTPUT);
            
    if (!SD.begin(chipSelect)) {                           // Als we de SD kaart niet kunnen opstarten. Dit melden en opnieuw testen.
    Serial.println ("Card failed, or not present");
    return;
    }
    
    Serial.println("card Initialized.");  
  
    
    for (uint8_t i = 0; i < 100; i++) {                   // In de fillename worden de 2 nullen in de char variabele gedefineert als
    filename[6] = i/10 + '0';                             // een 2 digit getal dat kan optellen van 0 tot 99. 
    filename[7] = i%10 + '0';
    if (! SD.exists(filename)) {                          // Op de SD kaart word er gecontroleerd op de Fille al bestaat. Bestaat de
    logfile = SD.open(filename, FILE_WRITE);              // file niet. Maar het aan en open.
    break;
    }
  }  
    File dataFile = SD.open(filename,FILE_WRITE);         
  if (dataFile){
   dataFile.println("Sensor lezen,Voltage(V),Afstand(mm),Acceleratiefactor ,Led status,Tijd (ms)"); // Schrijf deze tekst weg op de SD kaart in de dataFile.
   dataFile.close();  
   Serial.println("Sensor lezen,Voltage(V),Afstand(mm),Acceleratiefactor ,Led status,Tijd (ms)");
 }     
 digitalWrite(SeaftyPin,LOW);                              // Zet de uitgang "SeaftyPin" laag.
  
 }
 
void loop()                                               // Het programma
{
  // Locale Variabelen:
  float versnelling1;
  float versnelling2;
  float acceleratiefactor;
  Tijd = millis();                                         //De variabele tijd zal aan duiden hoelang het programa al draait in ms
  String led1State = "0";                                   // Declareer de variabel led1State. 
  String led2State = "0";                                   // Declareer de variabel led2State. 
 
  versnelling2 = voltage; 
  
  int Sensor1Reading = analogRead(Sensor1Pin);            // De analoge input word gelezen en in een waarde omgezet tussen 1024 en 0 (10bit resolutie) gegeven.
                                                          // Aref word als hoogste waarde bekeken en dan word er een verdeling van 1024 delen gemaakt.
                                                          // Dit geeft een naukeurigheid van 0.00488V bij een Aref van 5V.
  
  voltage = Sensor1Reading * aref_voltage / 1024;         // Zet de analoge waarde om naar voltage. geberuik de referentie voltage
  char volt[8] = "";
  dtostrf(voltage,6,2,volt);                              // Zet de String Voltage om naar een karakteristiek variabel.
//dtostrf(FLOAT,WIDTH,PRECSISION,BUFFER)
  
  float distance = (voltage / aref_voltage * 10)+5;                    // Bepaal via de spanning de afstand tussen sensor en breekplaat.
  char afstand [8] = "";
  dtostrf(distance,6,2,afstand);
  
  if(voltage > 2 && voltage < 3)  {                       // Zolang de spanning tussen bepaalde waarde blijft zal de uitgang laag blijven
    digitalWrite(Led1Pin,LOW);
    led1State = 0;
  }
  else {digitalWrite(Led1Pin,HIGH);                        // Zo niet word de uitgang hoog.
    led1State = "1";
    digitalWrite(SeaftyPin,HIGH);
    SeaftyState = "1";
  }
  
  versnelling1 = voltage;                                
  if(Tijd > 500) {                                       // Om er vroeg tijdig te schakelen word pas na 500ms gekeken naar deze vergelijking.
    acceleratiefactor = versnelling1 - versnelling2;     // De Acceleratiefactor word uitgerekend. Zo lang dat hij onder de 0.5 blijft word er niet geschakeld. 
    if(acceleratiefactor >= -0.5 && acceleratiefactor <= 0.5){
      digitalWrite(Led2Pin,LOW);
      led2State = "0";      
    }
    
    else {digitalWrite(Led2Pin,HIGH);
       led2State = "1";
       digitalWrite(SeaftyPin,HIGH);
       SeaftyState = "1";
  }
}
  datafilestring = Sensor1Reading+","+volt+","+afstand+","+acceleratiefacotr+","+led1State+","+led2State+","+SeaftyState+","; 
  File dataFile = SD.open(filename,FILE_WRITE);         // DataFile word geopend en de volgende variabelen worden er in weg geschreven.
  if (dataFile){
    dataFile.print(datafilestring);
    dataFile.println(Tijd);
      
   Serial.print(datafilestring);                       // Deze tekst word op de Serial monitor afgedrukt. 
   Serial.println(Tijd);
   
   //delay (500); //500ms 
   }
    
  else {Serial.println("error opening datalog.txt (controleer SD kaart)");
  Serial.println(filename);                           //Lukt het niet om weg te schrijven word volgende melding gegeven.
  delay (1000); //1000ms
  }
}

But do you have tips or tricks to what type I best declare my variables or convert them. So i can put them together in one string so i just need one or 2 "datafile.print".

You can create a character array, and use sprintf() to populate that array with all kinds of data.

The void loop is now 40 ms and only for "datafile.print" need i 30ms. For the moment is this to long.

How did you measure this? Why is keeping the write time under 30ms important when you have this:

  delay (1000); //1000ms

And does that comment contribute anything?

I'will try it.

The delay (1000) happens when i have a error. Than whil i print this error to my serial monitor. Would i erase this delay. would it go to fast to read.

For testing mine time. I erase every "serial.print" except "Serial.println(Tijd)". This will print the time that mine program is working in msec. And than is just a subtraction.

For testing mine time. I erase every "serial.print" except "Serial.println(Tijd)". This will print the time that mine program is working in msec. And than is just a subtraction.

That counts, then, the time to open and close the file.

Can you determine (or even guess) what takes the most time?

I have blown mine arduino up and waiting for a new one. Tomorrow I can borrow one from a college. But i compiled mine program and no errors for the moment.

But i have one question. I haven’t put “Tijd” in the "sprintf() function because i don’t know witch type it is.

unsigned long Tijd = millis(). In what type would i declare it? And wouldn’t it be to large for mine char buff?

  Tijd = millis();                                         //De variabele tijd zal aan duiden hoelang het programa al draait in ms
  String led1State = "0";                                   // Declareer de variabel led1State. 
  String led2State = "0";
String SeaftyState = "0"; 
int Sensor1Reading = analogRead(Sensor1Pin);
char volt[8] = "";
 char afstand [8] = "";
 float acceleratiefactor;

char datafilestring []= "";
sprintf(datafilestring,"%i,%c,%c,%c,%s,%s,%s,",Sensor1Reading,volt,afstand,acceleratiefactor,led1State,led2State,SeaftyState);

My regards,
Tim Matthijs

I have blown mine arduino up

How?

But i have one question. I haven't put "Tijd" in the "sprintf() function because i don't know witch type it is.

You must know what type it is. You can't have a variable that does not have a type.

unsigned long Tijd = millis().

See? Right there, you prove that you do know the type. What you might not know is the format specifier to use with that type. The unsigned part is not relevant when choosing the format specifier, only the type, long, which is short for long integer. So, the format specifier is %ld.

And wouldn't it be to large for mine char buff?

Way too large.

led1State can not be output using %s. %s is for strings, not String objects. In fact, sprintf() can not deal with String objects at all.

There is no reason for you to be wasting resources with String objects. Use char arrays. If you don't know how, learn.

char datafilestring []= "";

The compiler will count initializers to determine the size of the array. You provided one - the NULL terminator - so you get an array able to holf one character.

sprintf(datafilestring,"%i,%c,%c,%c,%s,%s,%s,",Sensor1Reading,volt,afstand,acceleratiefactor,led1State,led2State,SeaftyState);

This will fail. You are trying to write a whole bunch of characters and a trailing NULL, into a one character array. That will not work.

[quote]
How?[/quote]

I think by short-circuiting the arduino whit 24V. But it is still a question

[quote]The compiler will count initializers to determine the size of the array. You provided one - the NULL terminator - so you get an array able to holf one character.[/quote]

I understand you, but when mine "Tijd" is unsigned long. How can i determent how long mine array will be? I did it like this. But now i will get trouble whit "Tijd"
[code]char datafilestring[50] = "";
  sprintf(datafilestring,"%i,%c,%c,%f,%c,%c,%c,%ld",Sensor1Reading,volt,afstand,acceleratiefactor,led1State,led2State,SeaftyState,Tijd);

A sec solution would be that i datafille.print the Tijd alone like this.

char datafilestring[50] = "";
  sprintf(datafilestring,"%i,%c,%c,%f,%c,%c,%c,",Sensor1Reading,volt,afstand,acceleratiefactor,led1State,led2State,SeaftyState,);
  
  File dataFile = SD.open(filename,FILE_WRITE);         // DataFile word geopend en de volgende variabelen worden er in weg geschreven.
  if (dataFile){
    dataFile.print(datafilestring);
    dataFile.println(Tijd);
    dataFile.close();
      
   Serial.print(datafilestring);                       // Deze tekst word op de Serial monitor afgedrukt. 
   Serial.println(Tijd);

[/code]

Would this work? Thank you PaulS for your time and effort.

Best regards, Tim Matthijs

I think by short-circuiting the arduino whit 24V.

Ouch. That would do it.

I understand you, but when mine “Tijd” is unsigned long. How can i determent how long mine array will be?

You should assume that each variable will take the maximum space possible. For an unsigned long, the maximum value that is can hold is 4,294,967,295. That’s 10 characters, without the commas that won’t be part of the output.

I did it like this. But now i will get trouble whit “Tijd”

That array is now probably large enough. The %c format specifier is for characters (single characters). Have you changed the type of led1State, and the other String objects?

That array is now probably large enough. The %c format specifier is for characters (single characters). Have you changed the type of led1State, and the other String objects?

I made them char … [2] = “” And for give them value => led1State [0] == 1.

This is the program now:

void loop()                                               // Het programma
{
  // Locale Variabelen:
  float versnelling1;
  float versnelling2;
  float acceleratiefactor;
  Tijd = millis();                                         //De variabele tijd zal aan duiden hoelang het programa al draait in ms
  char led1State[2] = "";                                   // Declareer de variabel led1State. 
  char led2State[2] = "";                                   // Declareer de variabel led2State. 
 
  versnelling2 = voltage; 
  
  int Sensor1Reading = analogRead(Sensor1Pin);            // De analoge input word gelezen en in een waarde omgezet tussen 1024 en 0 (10bit resolutie) gegeven.
                                                          // Aref word als hoogste waarde bekeken en dan word er een verdeling van 1024 delen gemaakt.
                                                          // Dit geeft een naukeurigheid van 0.00488V bij een Aref van 5V.
  
  voltage = Sensor1Reading * aref_voltage / 1024;         // Zet de analoge waarde om naar voltage. geberuik de referentie voltage
  char volt[8] = "";
  dtostrf(voltage,6,2,volt);                              // Zet de String Voltage om naar een karakteristiek variabel.
//dtostrf(FLOAT,WIDTH,PRECSISION,BUFFER)
  
  float distance = (voltage / aref_voltage * 10)+5;                    // Bepaal via de spanning de afstand tussen sensor en breekplaat.
  char afstand [8] = "";
  dtostrf(distance,6,2,afstand);
  
  if(voltage > 2 && voltage < 3)  {                       // Zolang de spanning tussen bepaalde waarde blijft zal de uitgang laag blijven
    digitalWrite(Led1Pin,LOW);
    led1State[0] == 0;
  }
  else {digitalWrite(Led1Pin,HIGH);                        // Zo niet word de uitgang hoog.
    led1State[0] == 1;
    digitalWrite(SeaftyPin,HIGH);
    SeaftyState[0] == 1;
  }
  
  versnelling1 = voltage;                                
  if(Tijd > 500) {                                       // Om er vroeg tijdig te schakelen word pas na 500ms gekeken naar deze vergelijking.
    acceleratiefactor = versnelling1 - versnelling2;     // De Acceleratiefactor word uitgerekend. Zo lang dat hij onder de 0.5 blijft word er niet geschakeld. 
    if(acceleratiefactor >= -0.5 && acceleratiefactor <= 0.5){
      digitalWrite(Led2Pin,LOW);
      led2State [0] == 0;      
    }
    
    else {digitalWrite(Led2Pin,HIGH);
       led2State [0] == 1;
       digitalWrite(SeaftyPin,HIGH);
       SeaftyState [0] == 1;
  }
}
  char datafilestring[50] = "";
  sprintf(datafilestring,"%i,%c,%c,%f,%c,%c,%c,%ld",Sensor1Reading,volt,afstand,acceleratiefactor,led1State,led2State,SeaftyState,Tijd);
  
  File dataFile = SD.open(filename,FILE_WRITE);         // DataFile word geopend en de volgende variabelen worden er in weg geschreven.
  if (dataFile){
    dataFile.println(datafilestring);
    dataFile.close();
      
   Serial.print(datafilestring);                       // Deze tekst word op de Serial monitor afgedrukt. 
      
   //delay (500); //500ms 
   }
    
  else {Serial.println("error opening datalog.txt (controleer SD kaart)");
  Serial.println(filename);                           //Lukt het niet om weg te schrijven word volgende melding gegeven.
  delay (1000); //1000ms
  }
}
    led1State[0] == 1;

This is an equality test. You failed. You want a single = here. And in 2 other places.

  sprintf(datafilestring,"%i,%c,%c,%f,%c,%c,%c,%ld",Sensor1Reading,volt,afstand,acceleratiefactor,led1State,led2State,SeaftyState,Tijd);

Spaces and carriage returns are allowed...

Sensor1Reading is an int, so %i is correct.

volt, afstand, led1State, led2State, and SeaftyState are char arrays, not chars, so %c is wrong - should be %s.

The %f format specifier is not supported (for acceleratiefactor). That's why you had to use dtostrf() for volt and afstand. You need to create another array, and use dtostrf() to populate it, for acceleratiefactor.

Dear paulS,

The program works and i have been testing on the reaction time.

On the original program i chance a little bit to be faster. But Because it is fast it is very unstable for the reaction time. From 21ms to 31ms and over 10 min i had 6 maximums of 250ms.

//Ultrasoon

#include <string.h>                                        // #include => oproepen van bibliotheek
#include <stdlib.h>
#include <SD.h>
#define aref_voltage 5.0                                   // De 5V word met de Aref verbonden en gedefineerd

//Pin deffinitie
const int Sensor1Pin = A15;                                // De 1e sensor word aan de analoge pin 15 verbonden
const int chipSelect = 4;                                  // Pin voor comunicatie SD kaart
const int SeaftyPin = 49;                                  // Pin die triggert wanneer de robot moet stil vallen
const int Led1Pin = 48;                                    // Pin verbonden met LED voor voltage.
const int Led2Pin = 47;                                    // Pin verbonden met LED voor acceleratiefactor

//Globel Variabelen
int Sensor1Reading = 0;                                    // De waarde van het analoog lezen
float voltage;                                             // De waarde van voltage (moet global om acceleratie te kunnen uitrekenen)
unsigned long Tijd;                                        // Tijd 
char filename[] = "ULTSON00.TXT";                            // Naam van text bestand op SD kaart
File logfile;
String SeaftyState  = "0";

  float versnelling1;
  float versnelling2;
  float acceleratiefactor;
  String led1State = "0";                                   // Declareer de variabel led1State. 
  String led2State = "0";                                   // Declareer de variabel led2State. 
 

void setup() {                                             // Deze loop word alleen maar doorlopen bij het opstarten.
    Serial.begin(9600);                                    // start de serieële communicatie op aan 9600bits per seconde.
    analogReference(EXTERNAL);                             // Voor de analoge uitlezing zal de referentie extern worden aangelegt
    Serial.print("Initializing SD card...");               // Deze tekst word op de Serial monitor afgedrukt. 
    
    pinMode(10,OUTPUT);                                    // Definitie Welk soort de pin is. (input/output)
    pinMode(Led1Pin,OUTPUT);
    pinMode(Led2Pin,OUTPUT);
    pinMode(SeaftyPin,OUTPUT);
            
    if (!SD.begin(chipSelect)) {                           // Als we de SD kaart niet kunnen opstarten. Dit melden en opnieuw testen.
    Serial.println ("Card failed, or not present");
    return;
    }
    
    Serial.println("card Initialized.");  
  
    
    for (uint8_t i = 0; i < 100; i++) {                   // In de fillename worden de 2 nullen in de char variabele gedefineert als
    filename[6] = i/10 + '0';                             // een 2 digit getal dat kan optellen van 0 tot 99. 
    filename[7] = i%10 + '0';
    if (! SD.exists(filename)) {                          // Op de SD kaart word er gecontroleerd op de Fille al bestaat. Bestaat de
    logfile = SD.open(filename, FILE_WRITE);              // file niet. Maar het aan en open.
    break;
    }
  }  
    File dataFile = SD.open(filename,FILE_WRITE);         
  if (dataFile){
   dataFile.println("Sensor lezen,Voltage(V),Afstand(mm),Acceleratiefactor ,Led1 status,Led2 status,Seafty status,Tijd (ms)"); // Schrijf deze tekst weg op de SD kaart in de dataFile.
   dataFile.close();  
   Serial.println("Sensor lezen,Voltage(V),Afstand(mm),Acceleratiefactor ,Led1 status,Led2 status,Seafty status,Tijd (ms)");
 }     
 digitalWrite(SeaftyPin,LOW);                              // Zet de uitgang "SeaftyPin" laag.
  
 }
 
void loop()                                               // Het programma
{
  // Locale Variabelen:
  Tijd = millis();                                         //De variabele tijd zal aan duiden hoelang het programa al draait in ms
 
  versnelling2 = voltage; 
  
  int Sensor1Reading = analogRead(Sensor1Pin);            // De analoge input word gelezen en in een waarde omgezet tussen 1024 en 0 (10bit resolutie) gegeven.
                                                          // Aref word als hoogste waarde bekeken en dan word er een verdeling van 1024 delen gemaakt.
                                                          // Dit geeft een naukeurigheid van 0.00488V bij een Aref van 5V.
  
  voltage = Sensor1Reading * aref_voltage / 1024;         // Zet de analoge waarde om naar voltage. geberuik de referentie voltage

  
  float distance = (voltage / aref_voltage * 10)+5;                    // Bepaal via de spanning de afstand tussen sensor en breekplaat.

  
  if(voltage > 2 && voltage < 3)  {                       // Zolang de spanning tussen bepaalde waarde blijft zal de uitgang laag blijven
    digitalWrite(Led1Pin,LOW);
    led1State = "0";
  }
  else {digitalWrite(Led1Pin,HIGH);                        // Zo niet word de uitgang hoog.
    led1State = "1";
    digitalWrite(SeaftyPin,HIGH);
    SeaftyState = "1";
  }
  
  versnelling1 = voltage;                                
  if(Tijd > 500) {                                       // Om er vroeg tijdig te schakelen word pas na 500ms gekeken naar deze vergelijking.
    acceleratiefactor = versnelling1 - versnelling2;     // De Acceleratiefactor word uitgerekend. Zo lang dat hij onder de 0.5 blijft word er niet geschakeld. 
    if(acceleratiefactor >= -0.5 && acceleratiefactor <= 0.5){
      digitalWrite(Led2Pin,LOW);
      led2State = "0";      
    }
    
    else {digitalWrite(Led2Pin,HIGH);
       led2State = "1";
       digitalWrite(SeaftyPin,HIGH);
       SeaftyState = "1";
  }
}
   
  File dataFile = SD.open(filename,FILE_WRITE);         // DataFile word geopend en de volgende variabelen worden er in weg geschreven.
  if (dataFile){
   dataFile.print(Sensor1Reading);
   dataFile.print(",");
   dataFile.print(voltage);
   dataFile.print(",");
   dataFile.print(distance);
   dataFile.print(",");
   dataFile.print(acceleratiefactor);
   dataFile.print(",");
   dataFile.print(led1State);
   dataFile.print(",");
   dataFile.print(led2State);
   dataFile.print(",");
   dataFile.print(SeaftyState);
   dataFile.print(",");
   dataFile.println(Tijd);
   dataFile.close();
   

   
  
   delay (5); //5ms 
   }
    
  else {Serial.println("error opening datalog.txt (controleer SD kaart)");
  Serial.println(filename);                           //Lukt het niet om weg te schrijven word volgende melding gegeven.
  delay (1000); //1000ms
  }
}

sec Program. Is the program where i Put the variable first in the char array before “dataFile.print”. This is a slower program but much more stabel. 36ms -39ms. And over 10 min only one piek of 250ms (I thing this is problem of arduio self).

//Ultrasoon

#include <string.h>                                        // #include => oproepen van bibliotheek
#include <stdlib.h>
#include <stdio.h>
#include <SD.h>
#define aref_voltage 5.0                                   // De 5V word met de Aref verbonden en gedefineerd

//Pin deffinitie
const int Sensor1Pin = A15;                                // De 1e sensor word aan de analoge pin 15 verbonden
const int chipSelect = 4;                                  // Pin voor comunicatie SD kaart
const int SeaftyPin = 49;                                  // Pin die triggert wanneer de robot moet stil vallen
const int Led1Pin = 48;                                    // Pin verbonden met LED voor voltage.
const int Led2Pin = 47;                                    // Pin verbonden met LED voor acceleratiefactor

//Globel Variabelen
int Sensor1Reading = 0;                                    // De waarde van het analoog lezen
float voltage;                                             // De waarde van voltage (moet global om acceleratie te kunnen uitrekenen)
unsigned long Tijd;                                        // Tijd 
char filename[] = "ULTSON00.TXT";                          // Naam van text bestand op SD kaart
File logfile;



//Variabelen voor het programma:
  float versnelling1;
  float versnelling2;
  float acceleratiefactor;
  char led1State[2] = "";                                   // Declareer de variabel led1State. 
  char led2State[2] = "";                                  // Declareer de variabel led2State. 
  char SeaftyState [2] = "";
  char volt[8] = "";
  char afstand [8] = "";
  char acceleratie [8] = "";
  char datafilestring[50] = "";


void setup() {                                             // Deze loop word alleen maar doorlopen bij het opstarten.
    Serial.begin(9600);                                    // start de serieële communicatie op aan 9600bits per seconde.
    analogReference(EXTERNAL);                             // Voor de analoge uitlezing zal de referentie extern worden aangelegt
    Serial.print("Initializing SD card...");               // Deze tekst word op de Serial monitor afgedrukt. 
    
    pinMode(10,OUTPUT);                                    // Definitie Welk soort de pin is. (input/output)
    pinMode(Led1Pin,OUTPUT);
    pinMode(Led2Pin,OUTPUT);
    pinMode(SeaftyPin,OUTPUT);
            
    if (!SD.begin(chipSelect)) {                           // Als we de SD kaart niet kunnen opstarten. Dit melden en opnieuw testen.
    Serial.println ("Card failed, or not present");
    return;
    }
    
    Serial.println("card Initialized.");  
  
    
    for (uint8_t i = 0; i < 100; i++) {                   // In de fillename worden de 2 nullen in de char variabele gedefineert als
    filename[6] = i/10 + '0';                             // een 2 digit getal dat kan optellen van 0 tot 99. 
    filename[7] = i%10 + '0';
    if (! SD.exists(filename)) {                          // Op de SD kaart word er gecontroleerd op de Fille al bestaat. Bestaat de
    logfile = SD.open(filename, FILE_WRITE);              // file niet. Maar het aan en open.
    break;
    }
  }  
    File dataFile = SD.open(filename,FILE_WRITE);         
  if (dataFile){
   dataFile.println("Sensor lezen,Voltage(V),Afstand(mm),Acceleratiefactor ,Led1 status,Led2 status,Seafty status,Tijd (ms)"); // Schrijf deze tekst weg op de SD kaart in de dataFile.
   dataFile.close();  
   Serial.println("Sensor lezen,Voltage(V),Afstand(mm),Acceleratiefactor ,Led1 status,Led2 status,Seafty status,Tijd (ms)");
 }     
 digitalWrite(SeaftyPin,LOW); // Zet de uitgang "SeaftyPin" laag.
 SeaftyState [0] = '0'; 
 }
 
void loop()                                               // Het programma
{
  Tijd = millis();                                         //De variabele tijd zal aan duiden hoelang het programa al draait in ms
  versnelling2 = voltage; 
  
  int Sensor1Reading = analogRead(Sensor1Pin);            // De analoge input word gelezen en in een waarde omgezet tussen 1024 en 0 (10bit resolutie) gegeven.
                                                          // Aref word als hoogste waarde bekeken en dan word er een verdeling van 1024 delen gemaakt.
                                                          // Dit geeft een naukeurigheid van 0.00488V bij een Aref van 5V.
  
  voltage = Sensor1Reading * aref_voltage / 1024;         // Zet de analoge waarde om naar voltage. geberuik de referentie voltage
  dtostrf(voltage,5,2,volt);                              // Zet de String Voltage om naar een karakteristiek variabel.
//dtostrf(FLOAT,WIDTH,PRECSISION,BUFFER)
  
  float distance = (voltage / aref_voltage * 10)+5;       // Bepaal via de spanning de afstand tussen sensor en breekplaat.
  dtostrf(distance,5,2,afstand);
  
  if(voltage > 2 && voltage < 3)  {                       // Zolang de spanning tussen bepaalde waarde blijft zal de uitgang laag blijven
    digitalWrite(Led1Pin,LOW);
    led1State[0] = '0';
  }
  else {digitalWrite(Led1Pin,HIGH);                        // Zo niet word de uitgang hoog.
    led1State[0] = '1';
    digitalWrite(SeaftyPin,HIGH);
    SeaftyState[0] = '1';
  }
  
  versnelling1 = voltage;                                
  if(Tijd > 2000) {                                       // Om er vroeg tijdig te schakelen word pas na 500ms gekeken naar deze vergelijking.
    acceleratiefactor = versnelling1 - versnelling2;     // De Acceleratiefactor word uitgerekend. Zo lang dat hij onder de 0.5 blijft word er niet geschakeld. 
    dtostrf(acceleratiefactor,5,2,acceleratie);
    
    if(acceleratiefactor >= -0.5 && acceleratiefactor <= 0.5){
      digitalWrite(Led2Pin,LOW);
      led2State [0] = '0';      
    }
    
    else {digitalWrite(Led2Pin,HIGH);
       led2State [0] = '1';
       digitalWrite(SeaftyPin,HIGH);
       SeaftyState [0] = '1';
  }
}

  sprintf(datafilestring,"%i,%s,%s,%s,%s,%s,%s,%ld",Sensor1Reading,volt,afstand,acceleratie,led1State,led2State,SeaftyState,Tijd);
  
  File dataFile = SD.open(filename,FILE_WRITE);         // DataFile word geopend en de volgende variabelen worden er in weg geschreven.
  if (dataFile){
    dataFile.println(datafilestring);
    dataFile.close();
      
   Serial.println(datafilestring);                       // Deze tekst word op de Serial monitor afgedrukt. 
      
   //delay (500); //500ms 
   }
    
  else {Serial.println("error opening datalog.txt (controleer SD kaart)");
  Serial.println(filename);                           //Lukt het niet om weg te schrijven word volgende melding gegeven.
  delay (1000); //1000ms
  }
}

PaulS, Thank you for all your help.

Best regards,
Tim matthijs