File content as of revision 1:45627bbdeb69:

#include "sdCardReader.h"


//private essential methods
// Try to mount the filesystem
void SDCardReader::mountFileSystem(){
    printf("Mounting the filesystem... ");
    fflush(stdout);
    int err = m_fs.mount(&this);
    printf("%s\n", (err ? "Fail :(" : "OK"));
    if (err) {
        // Reformat if we can't mount the filesystem
        // this should only happen on the first boot
        printf("No filesystem found, formatting... ");
        fflush(stdout);
        err = m_fs.reformat(&this);
        printf("%s\n", (err ? "Fail :(" : "OK"));
        if (err) {
            error("error: %s (%d)\n", strerror(-err), err);
        }
    }
}

void SDCardReader::unmountFileSystem(){
  printf("Unmounting... ");
  fflush(stdout);
  err = m_fs.unmount();
  printf("%s\n", (err < 0 ? "Fail :(" : "OK"));
  if (err < 0) {
    error("error: %s (%d)\n", strerror(-err), err);
  } 
}


FILE* SDCardReader::openFile(string filename){
  printf("Opening \"/fs/%s\"... ",filename);
  fflush(stdout);
  FILE *f = fopen("/fs/"+filename, "r+");
  printf("%s\n", (!f ? "Fail :(" : "OK"));
  if (!f) {
    // Create the file if it doesn't exist
    printf("No file found, creating a new file... ");
    fflush(stdout);
    f = fopen("/fs/"+filename, "w+");
    printf("%s\n", (!f ? "Fail :(" : "OK"));
    if (!f) {
      error("error: %s (%d)\n", strerror(errno), -errno);
    }
  }
  return f;
}

void SDCardReader::write_uint16_t(uint16_t data, bool endline, FILE* fileToUse){
  FILE *f = fileToUse;
  printf("%s\n", (!f ? "Fail :(" : "OK"));
  
  printf("\rWriting datapoint %d", data);
  fflush(stdout);

  //write and check for error
  if (endline){
    err = fprintf(f, "%d\n",);
  }else{
    err = fprintf(f, "%d",);
  }

  if (err < 0) {
    printf("Fail :(\n");
    error("error: %s (%d)\n", strerror(errno), -errno);
  }
}


void SDCardReader::write_uint32_t(uint32_t data, bool endline, FILE* fileToUse){
  FILE *f = fileToUse;
  printf("%s\n", (!f ? "Fail :(" : "OK"));
  
  printf("\rWriting datapoint %d", data);
  fflush(stdout);

  //write and check for error
  if (endline){
    err = fprintf(f, "%d\n",);
  }else{
    err = fprintf(f, "%d ",);
  }
  
  if (err < 0) {
    printf("Fail :(\n");
    error("error: %s (%d)\n", strerror(errno), -errno);
  } 
}


void SDCardReader::closeFile(FILE* fileToClose){
  // Close the file which also flushes any cached writes
  printf("Closing file...");
  fflush(stdout);
  err = fclose(fileToClose);
  printf("%s\n", (err < 0 ? "Fail :(" : "OK"));
  if (err < 0) {
    error("error: %s (%d)\n", strerror(errno), -errno);
  } 
}


int SDCardReader::fullWriteProcedure(string filename,int* indexArr, uint32_t* timeArr, uint16_t** allData){
  mountFileSystem();
  FILE* theFile = openFile(filename);

  for (int i = 0; i < indexArr.size; i++){
    writeDataPoint(theFile,indexArr[i],timeArr[i], allData[i]);
  }
  
  closeFile(theFile);
  unmountFileSystem();

  return 1;
}

//use circular buffers instead of strings
//write as 1st column, index. 2nd column timestamp. 3rd column data1. 4th data2. etc.
//pass in array of circular buffers 
int SDCardReader::writeDataPoint(FILE* theFile, int index, uint32_t timestamp, uint16_t* data){
  //  FILE* theFile = openFile(filename);

  //write index
  write_uint16_t(index, false, theFile);
  //write timestamp
  write_uint32_t(timestamp, false, theFile);

  //write data
  for (int i = 0; i < data.size-1; i++) {
    write_uint16_t(data[i], false, theFile);
  }
  write_uint16_t(data[data.size], false, theFile);
  
  closeFile(theFile);
  
  // call the SDBlockDevice instance de-initialisation method.
    this->deinit();
    
    return 0;
}

int SDCardReader::eraseData(){
    printf("Initializing the block device... ");
    fflush(stdout);
    int err = this.init();
    printf("%s\n", (err ? "Fail :(" : "OK"));
    if (err) {
        error("error: %s (%d)\n", strerror(-err), err);
    }

    printf("Erasing the block device... ");
    fflush(stdout);
    err = this.erase(0, this.size());
    printf("%s\n", (err ? "Fail :(" : "OK"));
    if (err) {
        error("error: %s (%d)\n", strerror(-err), err);
    }

    printf("Deinitializing the block device... ");
    fflush(stdout);
    err = this.deinit();
    printf("%s\n", (err ? "Fail :(" : "OK"));
    if (err) {
        error("error: %s (%d)\n", strerror(-err), err);
    }
} 
    

/** Extras */
/*int SDCardReader::writeBlock(uint8_t* blockToWrite, int dataLength){

    if ( 0 != this->init()) {
       printf("Init failed \n");
       return -1;
    }
    
     // set the frequency
    if ( 0 != this->frequency(5000000)) {
        printf("Error setting frequency \n");
    }
    
    dataLength = 4096;
    
    printf("%i\n",this->program(blockToWrite, 0, dataLength));
    if (0 == this->program(blockToWrite, 0, dataLength)){
        printf("Block Written!");    
        //read back contents of block
        if ( 0 == this->read(blockToWrite, 0, dataLength)) {
            // print the contents of the block
            printf("%s", blockToWrite);
        }
    }
     // call the SDBlockDevice instance de-initialisation method.
    this->deinit();
     
     return 0;
}