Revision 1:45627bbdeb69, committed 2018-04-03

Comitter:

DVLevine

Date:

Tue Apr 03 22:41:46 2018 -0400

Parent:

0:ebe71c7e7854

Child:

2:c2cfb0ebc3bd

Commit message:

Heavily revised and refactored code. SDCardReader class should be about pat, before reviewing syntax bugs. DataRecorder needs to be fleshed out using SDCardReader Implementation.

Changed in this revision

--- a/dataRecorder.cpp	Tue Apr 03 21:50:25 2018 +0000
+++ b/dataRecorder.cpp	Tue Apr 03 22:41:46 2018 -0400
@@ -1,13 +1,57 @@
+#include "dataRecorder.h"
 
-#include "dataRecorder.h"
+/* CONSTRUCTOR*/
 
 DataRecorder::DataRecorder(){
-      uint32_t bytes_written = 0;
-      blockDistance_Index = 0;
-      //uint8_t separator = ' ';
+  //Initialize SDCard Reader Class
+  m_saveBuddy = new SDCardReader();
+
+  //Initialize data quantity as 0
+  m_data_quantity = 0;
 };
 
 
+/* PUBLIC METHODS */
+
+int DataRecorder::getQuantityStored(){
+  return m_data_quantity;
+}
+
+
+uint16_t DataRecorder::popLastDataPoint(){
+  return m_buf_data.pop();
+}
+
+uint32_t DataRecorder::popLastTimeStamp(){
+  return m_buf_timestamp.pop();
+}
+
+void DataRecorder::logDistancePoint(uint16_t value){
+  m_buf_data.push(value);
+  
+}
+
+void DataRecorder::logTimeStamp(uint32_t value){
+  m_buf_timestamp.push(value);
+}
+/** Save logged data to SD card **/
+void DataRecorder::saveLoggedData(string filename){
+  //iterate over buffer and use the sd card commands
+
+
+
+}
+//saves buffer to sd card and clears it    
+void DataRecorder::saveLoggedDataAndClearBuffer(string filename){
+  saveLoggedData(filename);
+  // then eraseBuffers();
+}
+
+
+/* PRIVATE METHODS */
+
+
+
 //private buffer load in method
 void DataRecorder::pushEleToBuffer(uint16_t inputVal){
   buf_distance.push(inputVal);
@@ -62,42 +106,9 @@
     //buf_distance        
 }
         
-        
-//saves buffer to sd card and clears it    
-int WriteDataAndClearBuffer();
-    
 
+void DataRecorder::savePoint(uint16_t value);
 
 
 
-/*
-
-  uint32_t bytes_written = 0;
-    
-    while (!buf.full()) {
-        buf.push(data_stream[bytes_written++]);
-    }
-    
-    printf("Circular buffer is full: \"%s\" or empty: \"%s\" \n", 
-           (buf.full()? "true":"false"), 
-           (buf.empty()? "true":"false") );
-    printf ("Bytes written %d \n", bytes_written);
-    
-    // If buffer is full, contents will be over-written
-    buf.push(data_stream[bytes_written++]);
-    
-    char data;
-    printf ("Buffer contents: ");
-    while (!buf.empty()) {
-        buf.pop(data);
-        printf("%c", data);
-    }
-    printf("\n");
- 
-    printf("Circular buffer is full: \"%s\" or empty: \"%s\" \n", 
-           (buf.full()? "true":"false"), 
-           (buf.empty()? "true":"false") );
- 
-    return 0;
-    
-    */
\ No newline at end of file
+void DataRecorder::pushEleToBuffer(uint16_t);

--- a/dataRecorder.h	Tue Apr 03 21:50:25 2018 +0000
+++ b/dataRecorder.h	Tue Apr 03 22:41:46 2018 -0400
@@ -1,58 +1,67 @@
 #include "mbed.h"
 #include "platform/CircularBuffer.h"
- 
-#define BUF_SIZE    150
+#include "sdCardReader.h"
 
+
+//converts number to string
 #include <sstream>
 #define SSTR( x ) static_cast< std::ostringstream & >(( std::ostringstream() << std::dec << x ) ).str()
 
-// include circular buffer
+// Define circular buffer size
+#define BUF_SIZE    150
+
+
+/** Data Recorder is a class that stores data measurements in a ring buffer. 
+It contains an SD Card Reader with a filesystem to store measurements when required  **/
 
 class DataRecorder{
   public:
     DataRecorder();
-    
-    int getNumStored();
-    uint16_t popLastValue();
-    
-    
-    uint8_t* getDistanceBlock();
-    int getDistanceDataLength();
+
+    /** Get Information **/
+    // gets the number of values stored in the circular buffer
+    int getQuantityStored();
     
-    //writes input value to buffer
-    void LogDistancePoint(uint16_t value);
-    
-    void savePoint(uint16_t value);
-        
-        
+    // pops the last value off of the circular buffer 
+    uint16_t popLastDataPoint();
+    uint32_t popLastTimeStamp();
+
+    /** Set Information **/
+    void logDistancePoint(uint16_t value);
+    void logTimeStamp(uint32_t value);
+ 
+    /** Save logged data to SD card **/
+    void saveLoggedData(string filename);
     //saves buffer to sd card and clears it    
-    int WriteDataAndClearBuffer();
-    
+    void saveLoggedDataAndClearBuffer(string filename);
+
     
   private:
-  
-    
+
+    void savePoint(uint16_t value);
     void pushEleToBuffer(uint16_t);
     // input values are converted to char arrays
     // iterate over char array to add values to buffer
     // buffer contents it turned into a uint8_t array and written to 
     // sd card
+
+    /* Buffers for Data Storage */
+    CircularBuffer<uint16_t, BUF_SIZE> buf_data;
+    CircularBuffer<uint32_t, BUF_SIZE> buf_timestamp;
+
+    // Count for buffers
+    int m_data_quantity;
     
-    // clear pops all elements out of buffer.
-    CircularBuffer<char, BUF_SIZE> buf;
-    char data_stream[];// = "DataToBeAddedToBuffer";
-    uint32_t bytes_written;// = 0;
-    int m;
-    const uint8_t separator = ' ';
-  
-    //sdcard blocks
-    uint8_t blockDistance[4096];
-    int blockDistance_Index;
+    /* SD Card Interface Object  */
+    SDCardReader* m_saveBuddy;
+
+
+
     
     //specialized buffers
-    CircularBuffer<uint16_t, BUF_SIZE> buf_distance;
-    CircularBuffer<uint16_t, BUF_SIZE> buf_kalmanAngle;
-    CircularBuffer<uint32_t, BUF_SIZE> buf_timestamp;
+    //CircularBuffer<uint16_t, BUF_SIZE> buf_distance;
+    //CircularBuffer<uint16_t, BUF_SIZE> buf_kalmanAngle;
+    //CircularBuffer<uint32_t, BUF_SIZE> buf_timestamp;
     
     /*CircularBuffer<char, BUF_SIZE> buf_accX;
     CircularBuffer<char, BUF_SIZE> buf_accY;
@@ -61,38 +70,15 @@
     CircularBuffer<char, BUF_SIZE> buf_gyroY;
     CircularBuffer<char, BUF_SIZE> buf_gyroZ;*/
     
-    
+    //sdcard blocks
+    //uint8_t blockDistance[4096];
+    //int blockDistance_Index;
+
+    // clear pops all elements out of buffer.
+    /*CircularBuffer<char, BUF_SIZE> buf;
+    char data_stream[];// = "DataToBeAddedToBuffer";
+    uint32_t bytes_written;// = 0;
+    int m;
+    const uint8_t separator = ' ';*/
     
 };
-
-/*
-
-  uint32_t bytes_written = 0;
-    
-    while (!buf.full()) {
-        buf.push(data_stream[bytes_written++]);
-    }
-    
-    printf("Circular buffer is full: \"%s\" or empty: \"%s\" \n", 
-           (buf.full()? "true":"false"), 
-           (buf.empty()? "true":"false") );
-    printf ("Bytes written %d \n", bytes_written);
-    
-    // If buffer is full, contents will be over-written
-    buf.push(data_stream[bytes_written++]);
-    
-    char data;
-    printf ("Buffer contents: ");
-    while (!buf.empty()) {
-        buf.pop(data);
-        printf("%c", data);
-    }
-    printf("\n");
- 
-    printf("Circular buffer is full: \"%s\" or empty: \"%s\" \n", 
-           (buf.full()? "true":"false"), 
-           (buf.empty()? "true":"false") );
- 
-    return 0;
-    
-    */
\ No newline at end of file

--- a/sd-driver.lib	Tue Apr 03 21:50:25 2018 +0000
+++ b/sd-driver.lib	Tue Apr 03 22:41:46 2018 -0400
@@ -1,1 +1,1 @@
-https://os.mbed.com/users/DVLevine/code/sd-driver_compatible_with_MAX32630FTHR/#58ae39d380f4
+https://os.mbed.com/users/DVLevine/code/sd-driver_compatible_with_MAX32630FTHR/#69bfc1595ae5

--- a/sdCardReader.cpp	Tue Apr 03 21:50:25 2018 +0000
+++ b/sdCardReader.cpp	Tue Apr 03 22:41:46 2018 -0400
@@ -1,91 +1,143 @@
 #include "sdCardReader.h"
 
-//SDCardReader::SDCardReader(){
-   //this = new SDBlockDevice(MBED_CONF_SD_SPI_MOSI, MBED_CONF_SD_SPI_MISO, MBED_CONF_SD_SPI_CLK, MBED_CONF_SD_SPI_CS);   
-//}
+
+//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);
+  } 
+}
 
 
-int SDCardReader::writeBlock(uint8_t* blockToWrite, int dataLength){
-        //printf("%i\n",dataLength);
-    if ( 0 != this->init()) {
-       printf("Init failed \n");
-       return -1;
-    }
-    
-    printf("lul");
-     // set the frequency
-    if ( 0 != this->frequency(5000000)) {
-        printf("Error setting frequency \n");
+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);
     }
-    printf("huh");
-    
-   // uint8_t lala[512] = "NOOMBA";
-   // blockToWrite = lala;
-    dataLength = 4096;
-    
-    //blockToWrite = uint8 lala[512]
-    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);
-        }
-    }
-     printf("what?");
-     // call the SDBlockDevice instance de-initialisation method.
-    this->deinit();
-     
-     return 0;
+  }
+  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
-int SDCardReader::writeData(string title, string dataToWrite){
-    /* uint8_t m_title[512];// = reinterpret_cast<const uint8_t*>(&title[0]);
-     uint8_t m_data[1024];// = reinterpret_cast<const uint8_t*>(&dataToWrite[0]);
-     
-     m_title = reinterpret_cast<const uint8_t*>(&title[0]);
-     m_data = reinterpret_cast<const uint8_t*>(&dataToWrite[0]);*/
-     
-     vector<uint8_t> myTitleVector(title.begin(), title.end());
-     uint8_t *m_title = &myTitleVector[0];
-     
-     vector<uint8_t> myDataVector(dataToWrite.begin(), dataToWrite.end());
-     uint8_t *m_data = &myDataVector[0];
-     
-     if ( 0 != this->init()) {
-        printf("Init failed \n");
-        return -1;
-    }
-     // set the frequency
-    if ( 0 != this->frequency(5000000)) {
-        printf("Error setting frequency \n");
-    }
-    
-    printf("writing");
-    
-    
-    //Writing title
-     // Write some the data block to the device
-    if ( 0 == this->program(m_title, 0, 512)) {
-        // read the data block from the device
-        if ( 0 == this->read(m_title, 0, 512)) {
-            // print the contents of the block
-            printf("%s", m_title);
-        }
-    }
-    
-     //Writing data
-    if ( 0 == this->program(m_data, 0, 1024)) {
-        // read the data block from the device
-        if ( 0 == this->read(m_data, 0, 1024)) {
-            // print the contents of the block
-            printf("%s", m_data);
-        }
-    }
-    
-        // call the SDBlockDevice instance de-initialisation method.
+//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;
@@ -115,86 +167,37 @@
     if (err) {
         error("error: %s (%d)\n", strerror(-err), err);
     }
-}
+} 
+    
+
+/** Extras */
+/*int SDCardReader::writeBlock(uint8_t* blockToWrite, int dataLength){
 
-// Try to mount the filesystem
-void SDCardReader::mountFileSystem(){
-    printf("Mounting the filesystem... ");
-    fflush(stdout);
-    int err = 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 = fs.reformat(&this);
-        printf("%s\n", (err ? "Fail :(" : "OK"));
-        if (err) {
-            error("error: %s (%d)\n", strerror(-err), err);
+    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;
 }
 
-// Open file
-FILE * SDCardReader::writeFile(string filename, dataRecorder* myDataRecorder); 
-    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);
-        }
 
-        for (int i = 0; i < 10; i++) {
-            printf("\rWriting numbers (%d/%d)... ", i, 10);
-            fflush(stdout);
-            err = fprintf(f, "    %d\n", i);
-            if (err < 0) {
-                printf("Fail :(\n");
-                error("error: %s (%d)\n", strerror(errno), -errno);
-            }
-        }
-        printf("\rWriting numbers (%d/%d)... OK\n", 10, 10);
-
-        printf("Seeking file... ");
-        fflush(stdout);
-        err = fseek(f, 0, SEEK_SET);
-        printf("%s\n", (err < 0 ? "Fail :(" : "OK"));
-        if (err < 0) {
-            error("error: %s (%d)\n", strerror(errno), -errno);
-        }
-    }
-    
-     // Go through and increment the numbers
-    for (int i = 0; i < 10; i++) {
-        printf("\rIncrementing numbers (%d/%d)... ", i, 10);
-        fflush(stdout);
-
-        // Get current stream position
-        long pos = ftell(f);
-
-        // Parse out the number and increment
-        int32_t number;
-        fscanf(f, "%d", &number);
-        number += 1;
-
-        // Seek to beginning of number
-        fseek(f, pos, SEEK_SET);
-    
-        // Store number
-        fprintf(f, "    %d\n", number);
-
-        // Flush between write and read on same file
-        fflush(f);
-    }
-    
-    
-
-

--- a/sdCardReader.h	Tue Apr 03 21:50:25 2018 +0000
+++ b/sdCardReader.h	Tue Apr 03 22:41:46 2018 -0400
@@ -6,6 +6,7 @@
 #include "vector"
 #include <errno.h>
 #include "HeapBlockDevice.h"
+#include "platform/CircularBuffer.h"
 
 // File systems
 //#include "LittleFileSystem.h"
@@ -13,24 +14,25 @@
 
 class SDCardReader : public SDBlockDevice{
     public:
-        SDCardReader(PinName a=MBED_CONF_SD_SPI_MOSI, PinName b=MBED_CONF_SD_SPI_MISO, PinName c=MBED_CONF_SD_SPI_CLK, PinName d=MBED_CONF_SD_SPI_CS):SDBlockDevice(a, b, c, d){
-            };
-        
-        //static SDBlockDevice m_sd(MBED_CONF_SD_SPI_MOSI, MBED_CONF_SD_SPI_MISO, MBED_CONF_SD_SPI_CLK, MBED_CONF_SD_SPI_CS);
-        //SDBlockDevice* m_sd;//(MBED_CONF_SD_SPI_MOSI, MBED_CONF_SD_SPI_MISO, MBED_CONF_SD_SPI_CLK, MBED_CONF_SD_SPI_CS);
-        
-        // File system declaration
-        FATFileSystem fs("fs");
-        
-        int writeBlock(uint8_t* blockToWrite, int dataLength);        
-        int writeData(string title, string dataToWrite);
-        
-        int writeFile(string filename); 
-        int eraseData();
-        //string readData();       
+        SDCardReader(PinName a=MBED_CONF_SD_SPI_MOSI, PinName b=MBED_CONF_SD_SPI_MISO, PinName c=MBED_CONF_SD_SPI_CLK, PinName d=MBED_CONF_SD_SPI_CS):SDBlockDevice(a, b, c, d){};
+        	
+  	FILE* openFile(string filename);
+	void closeFile(FILE* fileToClose);
+
+	int writeDataPoint(int index, uint32_t timestamp, uint16_t* data);
+	int eraseData();
+
+	int fullWriteProcedure(string filename,int* indexArr, uint32_t* timeArr, uint16_t** allData);
+		
+	void mountFileSystem();
+	void unmountFileSystem();
+	
     private:
-        FILE * mountFileSystem();
-        
-    
-        uint8_t block[512]; // block of data;
+
+	void write_uint16_t(uint16_t data, bool endline, FILE* fileToUse);
+	void write_uint32_t(uint32_t data, bool endline, FILE* fileToUse);
+
+
+	// Define file system
+        FATFileSystem m_fs("fs");
 };