SD card : writing data out slower the reading data in

Hello everyone,

I'm hopping someone can enlighten me regarding this issue. I'm trying to record emg (analog sensor) data while I read some emg data previously stored in a SD card. The problem is when I compered the amount of bytes read to whats been written is really off. This worries me because that means I'm loosing valuable data.

Here it is my code based from the SD library.

Thank you in Advanced.

/*
  SD card datalogger
 
 This example shows how to log data from three analog sensors 
 to an SD card using the SD library.
  
 The circuit:
 * SD card attached to SPI bus as follows:
 ** UNO:  MOSI - pin 11, MISO - pin 12, CLK - pin 13, CS - pin 4 (CS pin can be changed)
  and pin #10 (SS) must be an output
 ** Mega:  MOSI - pin 51, MISO - pin 50, CLK - pin 52, CS - pin 4 (CS pin can be changed)
  and pin #52 (SS) must be an output
 ** Leonardo: Connect to hardware SPI via the ICSP header
    Pin 4 used here for consistency with other Arduino examples
 
 created  24 Nov 2010
 modified 9 Apr 2012 by Tom Igoe
 
 This example code is in the public domain.
   
 */

#include <SPI.h>
#include <SD.h>

// On the Ethernet Shield, CS is pin 4. Note that even if it's not
// used as the CS pin, the hardware CS pin (10 on most Arduino boards,
// 53 on the Mega) must be left as an output or the SD library
// functions will not work.
const int chipSelect = 10;

File dataFile;
File dataFileRead;

void setup()
{
 // 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("Initializing SD card...");
  // make sure that the default chip select pin is set to
  // output, even if you don't use it:
  pinMode(SS, OUTPUT);
  
  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    while (1) ;
  }
  Serial.println("card initialized.");
  
  // Open up the file we're going to log to!
  dataFile = SD.open("emgdata4.txt", FILE_WRITE);
  if (! dataFile) {
    Serial.println("error opening emgdata4.txt");
    // Wait forever since we cant write data
    while (1) ;
  }

  dataFileRead = SD.open("datalog.txt");
  if (dataFileRead){
    //read until there is nothing else
    while (dataFileRead.available()){
      Serial.write(dataFileRead.read());

    }
    // close the file:
    dataFileRead.close();

  }else{
    Serial.println("error opening datalog.txt");
  }


}

void loop()
{
  // make a string for assembling the data to log:
  String dataString = "";

  // read three sensors and append to the string:
  for (int analogPin = 0; analogPin < 3; analogPin++) {
    int sensor = analogRead(analogPin);
    dataString += String(sensor);
    if (analogPin < 2) {
      dataString += ","; 
    }
  }

  dataFile.println(dataString);

  // print to the serial port too:
  //Serial.println(dataString);
  
  // The following line will 'save' the file to the SD card after every
  // line of data - this will use more power and slow down how much data
  // you can read but it's safer! 
  // If you want to speed up the system, remove the call to flush() and it
  // will save the file only every 512 bytes - every time a sector on the 
  // SD card is filled with data.
  dataFile.flush();
  
  // Take 1 measurement every 500 milliseconds
  //delay(1 );
}

I'm trying to record emg (analog sensor) data while I read some emg data previously stored in a SD card.

No, you aren't. On start up, you read some data. While running, you piss resources away uselessly writing data.

The problem is when I compered the amount of bytes read to whats been written is really off.

But, I'm not going to provide any proof.

This worries me because that means I'm loosing valuable data.

But, I'm not going to provide any proof.

Get rid of the stupid String class. It is doing NOTHING to help you. If fact, it is GUARANTEED to cause you problems. Stuffing all the data into a buffer, and wrapping the buffer in a class, so it can be unwrapped and copied to another buffer is doing nothing but waste time.

gbernal:
The problem is when I compered the amount of bytes read to whats been written is really off.

Can you show an example?