File content as of revision 4:fe6d2823b7cb:

#include "sdCardReader.h"


//helpers
int getSize(int* p){
  return (sizeof(p)/sizeof(*p));
}

int getSize(uint16_t* p){
  return (sizeof(p)/sizeof(*p));
}

//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);
  int 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.c_str());
  fflush(stdout);
  FILE *f = fopen(filename.c_str(), "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(filename.c_str(), "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 16 bit value: %" PRIu16, data);
  fflush(stdout);

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

  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 32 bit value:  %" PRIu32, data);
  //printf("\rWriting datapoint %d", data);
  fflush(stdout);

  int err = 0;
  //write and check for error
  if (endline){
    err = fprintf(f,"%" PRIu32 "\n",data);
  }else{
    err = fprintf(f,"%" PRIu32,data);
  }
  
  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);

  int err = 0;
  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<getSize(indexArr); 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 < getSize(data)-1; i++) {
    write_uint16_t(data[i], false, theFile);
  }
  write_uint16_t(data[getSize(data)], 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);
    }

    return err;
}