Diff: sdcard.cpp

Revision:

14:f5c62d30c6fc

Parent:

11:9a6545c2eb5d

Child:

15:208b146151ba

--- a/sdcard.cpp	Sat May 27 05:47:55 2017 +0000
+++ b/sdcard.cpp	Thu Jun 01 09:24:45 2017 +0000
@@ -1,14 +1,49 @@
- /*
+ // Exisiting code in Int_Demo_09May2017_suhasini/sdcard.cpp is deleted and replaced by new code 
+ //Nidhin 1/6/2017
+ 
+ 
  #include "mbed.h"
  #include <stdio.h>
  #include "SDFileSystem.h"
  #include "sdcard.h"
   #include "rtc.h"
+  #include "struct.h"
+  
+  Serial snd(USBTX,USBRX);
   
 
   SDFileSystem sd(PTE1, PTE3, PTE2, PTE4, "sd");
-  FILE *fp=NULL;
-
+  
+  FILE *fpecg;  // PPG and ECG File pointers for BP
+  FILE *fpppg;  //""          ""
+  
+  FILE *fpmain; // FILE pointer for main file
+  
+  FILE *fpbg;   // FILE pointer to BG file
+  FILE *fpeecg; // FILE pointer to ECG file
+  FILE *fpbp;   // FILE pointer to BP file
+  
+  FILE *fp;    // FILE pointer for random use
+  
+  
+  
+  int ecgloc = 0;  // PPG and eCG maximum locations
+  int ppgloc = 0;  
+  
+  int ebp = 0;      // variable for LOOP operation to read value from File i == ECG , j == PPG
+  int pbp = 0;
+  
+  //Function Added on 16/5/2017 by Nidhin
+ void sd_open_mainfile(int pid)
+ {
+ char buffer1[32];
+ sprintf(buffer1,"/sd/%d.csv",pid);
+  fp = fopen(buffer1,"a"); 
+    }
+  //------------------------------------------
+  
+  
+  
  void sd_open_GLCfile(int pid)     // opening the glc file
  {
      
@@ -27,15 +62,13 @@
  
   void sd_open_GLCfilee(int pid)    // only opening the glc file after entering TEST screen
  {
-     
-
   char buffer1[32];
   sprintf(buffer1,"/sd/%d_GLC.csv",pid);
-  fp = fopen(buffer1,"a"); 
-   fprintf(fp,"PATIENT ID %d\n",pid);
-  
+  fpbg = fopen(buffer1,"a"); 
+  fclose(fpbg);
+ } 
  
- } 
+ 
  
   void sd_open_ECGfile(int pid)         
  {
@@ -56,9 +89,9 @@
  {
      
   char buffer1[32];
-   sprintf(buffer1,"/sd/%d_ECG.csv",pid);
-  fp = fopen(buffer1,"a"); 
-  fprintf(fp,"PATIENT ID %d\n",pid );
+  sprintf(buffer1,"/sd/%d_ECG.csv",pid);
+  fpeecg = fopen(buffer1,"a"); 
+  //fclose(fpeecg);
  
  } 
  
@@ -83,122 +116,9 @@
  
   char buffer1[32];
   sprintf(buffer1,"/sd/%d_BP.csv",pid);
-  fp = fopen(buffer1,"a"); 
-  fprintf(fp,"PATIENT ID %d\n",pid );
- 
- } 
-  
- void sd_write (int value)      // writing data into the file
- {
-  
-  fprintf(fp,"%d\n", value); 
-  }
-  
-  void sd_close()            //closing the file
-  {
-   fclose(fp);
-   }*/
- 
- //----------------------------------------NEW ADD NIDHIN 28/4/2017-------------------------------//
- 
- #include "mbed.h"
- #include <stdio.h>
- #include "SDFileSystem.h"
- #include "sdcard.h"
-  #include "rtc.h"
-  
-  Serial snd(USBTX,USBRX);
-  
-
-  SDFileSystem sd(PTE1, PTE3, PTE2, PTE4, "sd");
-  FILE *fp;
-  FILE *fpecg;  // PPG and ECG File pointers for BP
-  FILE *fpppg;
-  
-  int ecgloc = 0;  // PPG and eCG maximum locations
-  int ppgloc = 0;  
-  
-  int ebp = 0;      // variable for LOOP operation to read value from File i == ECG , j == PPG
-  int pbp = 0;
-  
-  
- void sd_open_GLCfile(int pid)     // opening the glc file
- {
-     
-  char buffer[32];
-  char buffer1[32];
-  time_t  epoch_time1;
-  epoch_time1=rtc_read();
- // strftime(buffer, 32, "GLC_%s", pid);
-  
- sprintf(buffer1,"/sd/%d_GLC.csv",pid);   
-  fp = fopen(buffer1,"a"); 
-  fprintf(fp,"%s\n",ctime(&epoch_time1) );  //writing the date, time into the file
-  
- 
- }   
- 
-  void sd_open_GLCfilee(int pid)    // only opening the glc file after entering TEST screen
- {
-     
-
-  char buffer1[32];
-  sprintf(buffer1,"/sd/%d_GLC.csv",pid);
-  fp = fopen(buffer1,"a"); 
-   fprintf(fp,"PATIENT ID %d\n",pid);
-  
- 
- } 
- 
-  void sd_open_ECGfile(int pid)         
- {
-     
- // char buffer[32];
-  char buffer1[32];
-  time_t  epoch_time1;
-  epoch_time1=rtc_read();
-  // strftime(buffer, 32, "ECG_%d", pid);
-  
-  sprintf(buffer1,"/sd/%d_ECG.csv",pid);
-  fp = fopen(buffer1,"a"); 
-  fprintf(fp,"%s\n",ctime(&epoch_time1) );
- 
- } 
- 
-  void sd_open_ECGfilee(int pid)          // only opening the ECG file after entering TEST screen
- {
-     
-  char buffer1[32];
-   sprintf(buffer1,"/sd/%d_ECG.csv",pid);
-  fp = fopen(buffer1,"a"); 
-  fprintf(fp,"PATIENT ID %d\n",pid );
- 
- } 
- 
- 
-  void sd_open_BPfile(int pid)         
- {
-     
-  char buffer[32];
-  char buffer1[32];
-  time_t  epoch_time1;
-  epoch_time1=rtc_read();
-  // strftime(buffer, 32, "ECG_%d", pid);
-  
-  sprintf(buffer1,"/sd/%d_BP.csv",pid);
-  fp = fopen(buffer1,"a"); 
-  fprintf(fp,"%s\n",ctime(&epoch_time1) );
- } 
-
-void sd_open_BPfilee(int pid)          // only opening the BP file after entering TEST screen
- {
-     
- 
-  char buffer1[32];
-  sprintf(buffer1,"/sd/%d_BP.csv",pid);
-  fp = fopen(buffer1,"a"); 
-  fprintf(fp,"PATIENT ID %d\n",pid );
- 
+  fpbp = fopen(buffer1,"a"); 
+  //fprintf(fp,"PATIENT ID %d\n",pid );        Not required in new code as writing in hex
+ fclose(fpbp);
  } 
   
  void sd_write (int value)      // writing data into the file
@@ -209,15 +129,15 @@
  //------------------------------------------------------
   
 //FILE *sd_BP_ecgwrite (int value)      // writing data into the file NIDHIN
-FILE *sd_BP_ecgwrite (int *fpdrum11)      // writing data into the file NIDHIN
+FILE *sd_BP_ecgwrite (uint32_t *fpdrum11)      // writing data into the file NIDHIN  
   {
-        fwrite(fpdrum11,sizeof(int),64, fpecg); 
+        fwrite(fpdrum11,sizeof(uint32_t),1, fpecg); //Change by Nidhin 30/5/2017 Direct writing to SD card. Org Val 64
         return fpecg;
   }
     
-FILE* sd_BP_ppgwrite (uint32_t *fpdrum21)      // writing data into the file NIDHIN
+FILE* sd_BP_ppgwrite (uint32_t *fpdrum21)      // //Change by Nidhin 30/5/2017 Direct writing to SD card.
   {
-       fwrite(fpdrum21,sizeof(uint32_t),64, fpppg); 
+       fwrite(fpdrum21,sizeof(uint32_t),1, fpppg); //Change by Nidhin 30/5/2017 Direct writing to SD card. OR Val 64
     return fpppg;
   }
   //-----------------------------------------------SD Read
@@ -282,13 +202,32 @@
   
   //--------------------------------------------------
   
-//void sd_bp_read(  
-  
-void sd_close()            //closing the file
+//FUNCTIONS TO CLOSE FILES
+//__________________________________________________  
+void sd_close()            //close the file with fp
   {
    
       fclose(fp);
    }
+//______________________________________________________   
+ void sd_close_ecg()          // Closes ECG file pinted by fpeecg
+ {
+   
+      fclose(fpeecg);
+ }
+//______________________________________________________
+ void sd_close_glc()          // Closes GLC file pinted by fpbg
+ {
+   
+      fclose(fpbg);
+ }
+ //_____________________________________________________
+ 
+ 
+ 
+ 
+ 
+ 
  //------------------------------------------  
  //REOPEN FUNCTIONs for reading data Nidhin
  
@@ -313,7 +252,7 @@
     {
 
     
-    fread(a,sizeof(int), 1,fpecg);
+    fread(a,sizeof(uint32_t), 1,fpecg);
     // snd.printf("\n%d", a[0]); Commented May3_2017 (Nidhin)
         if(a[0] > ecgmax)
             {
@@ -387,54 +326,198 @@
     
     char buffer3[32];
     sprintf(buffer3, "/sd/%d_BP.csv", pid);
-    fp = fopen(buffer3, "a");
+    fpbp = fopen(buffer3, "a");                   // Opens BP file with FILE pointer fpbp in APPEND mode
 
     //buffer1[32] = ""; 
-    sprintf(buffer3, "/sd/%d_BP_ECG.csv", pid);
-    fpecg = fopen(buffer3, "r");
+    sprintf(buffer3, "/sd/%d_BP_ECG.csv", pid);   
+    fpecg = fopen(buffer3, "r");                  // Opens ECG file of BP with FILE pointer fpecg in READ mode
 
     //char buffer1[32] = "";
     sprintf(buffer3, "/sd/%d_BP_PPG.csv", pid);
-    fpppg = fopen(buffer3, "r");
+    fpppg = fopen(buffer3, "r");                  // Opens PPG file of BP with FILE pointer fpppg in READ mode
 
     for(int i=0; i<16; i++)
     {
     int ecgbuf[64] = {0} ;
-    fread(ecgbuf, sizeof(int), 64, fpecg);
-    fwrite(ecgbuf, sizeof(int), 64, fp);
+    fread(ecgbuf, sizeof(uint32_t), 64, fpecg);
+    fwrite(ecgbuf, sizeof(uint32_t), 64, fpbp);   // Copy ECG data of BP into BP file
     }
 
     for(int i=0; i<26; i++)
     {
     int ppgbuf[64] = {0} ;
-    fread(ppgbuf, sizeof(int), 64, fpppg);
-    fwrite(ppgbuf, sizeof(int), 64, fp);
+    fread(ppgbuf, sizeof(uint32_t), 64, fpppg);
+    fwrite(ppgbuf, sizeof(uint32_t), 64, fpbp);  // Copy PPG data of BP into BP file
     }
 
-    fclose(fpecg);
-    fclose(fpppg);
-    fclose(fp);
+    fclose(fpecg);                                  // Closes the ECG file of BP
+    fclose(fpppg);                                  // Closes the PPG file of BP
+    fclose(fpbp);                                   // Closes the BP file
 
     //char buffer1[32] = "";
-    int status = 0 ;
+    int status = 1 ;
     sprintf(buffer3, "/sd/%d_BP_ECG.csv", pid);
-    status = remove(buffer3);
+    status = remove(buffer3);                         //Removes ECG file of BP and updates status with 0 if successful
     
     
     if( status == 0 )
-        snd.printf("\nECG file delete : Successful");
+        snd.printf("\nECG file delete : Successful");   // Checks for SUCCESS
     else 
         snd.printf("\nECG file delete : UnSuccessful");
    
     
     //char buffer1[32] = "";
-    status = 0 ;
+    status = 1 ;
     sprintf(buffer3, "/sd/%d_BP_PPG.csv", pid);
-    status = remove(buffer3);
+    status = remove(buffer3);                           //Removes PPG file of BP and updates status with 0 if successful
     
     if( status == 0 )
-        snd.printf("\nPPG file delete : Successful");
+        snd.printf("\nPPG file delete : Successful");   // Checks for SUCCESS
     else 
         snd.printf("\nPPG file delete : UnSuccessful");
        
+}
+
+//Creating strcuture file Common to All Functions
+void structure_file(BLEMsg_info *ptr, int pid)
+{
+char buffer3[32];
+sprintf(buffer3, "/sd/%d.csv", pid);        //Printing file path to the buffer
+fpmain = fopen(buffer3, "a");               // open the file PID.csv with FILE pointer fpmain
+fwrite(ptr, sizeof(uint8_t),26, fpmain );   // writing the Structure into the file
+fclose(fpmain);                             // Close File
+}
+
+//Copy Data into file.
+
+void bpfile_mainfile(int pid)                       //Copy data of bp file to main
+{
+    char buffer3[32];
+    sprintf(buffer3, "/sd/%d.csv", pid);
+    fpmain = fopen(buffer3, "a");                   // Opens Main file with FILE pointer "fpmain" in APPEND mode
+    
+    sprintf(buffer3, "/sd/%d_BP.csv", pid);
+    fpbp = fopen(buffer3, "r");                     // Opens BP file with FILE pointer "fpbp" in READ mode
+    
+    
+    for(int i=0; i<21; i++)
+    {
+    int bigbuf[128] = {0} ;
+    fread(bigbuf, sizeof(uint32_t), 128, fpbp);
+    fwrite(bigbuf, sizeof(uint32_t), 128, fpmain);  // Copy BP raw data into main file 
+    }
+    fclose(fpbp);                                   // Close BP file
+    fclose(fpmain);                                 // Close Main File
+    
+    int success;
+    sprintf(buffer3, "/sd/%d_BP.csv", pid);
+    success = remove(buffer3);                      // Should return zero on success
+}
+
+//------------New function added to print ECG data to Sd card using fwrite
+void sd_ecgwrite(int *ecg_ptr)
+{
+   fwrite(ecg_ptr, sizeof(int), 1, fpeecg); 
+}
+
+
+//------------ Function to write ECG data to main file
+void ecgfile_mainfile(int pid)
+{
+    char buffer3[32];
+    sprintf(buffer3, "/sd/%d.csv", pid);       
+    fpmain = fopen(buffer3, "a");             // Main File is opened in Append mode
+    
+    sprintf(buffer3, "/sd/%d_ECG.csv", pid);  // ECG file is opened in read mode
+    fpeecg = fopen(buffer3, "r");
+    
+    for(int i=0; i<10; i++)
+    {
+    int bigbuf[100] = {0} ;
+    fread(bigbuf, sizeof(int),100 , fpeecg);
+    fwrite(bigbuf, sizeof(int), 100, fpmain);
+    }
+    fclose(fpeecg);                               // Both files are Closed
+    fclose(fpmain);
+    
+    /*
+    sprintf(buffer3, "/sd/%d_ECG.csv", pid);  // ECG file is opened in write mode to empty the file
+    fpeecg = fopen(buffer3, "w");
+    fclose(fpecg);  
+    */                           // File is closed
+    int success;
+    sprintf(buffer3, "/sd/%d_ECG.csv", pid);
+    success = remove(buffer3);  
+}
+
+
+//---------------------- Function to write GLC data to GLC file
+void sd_glcwrite(uint32_t *glc_ptr, int pid)
+{
+    char buffer3[32];
+    sprintf(buffer3, "/sd/%d_GLC.csv", pid);       
+    fpbg = fopen(buffer3, "a");  
+    
+    fwrite(glc_ptr, sizeof(uint32_t), 2, fpbg);
+    fclose(fpbg);
+   
+}
+
+// --------------------------Fuinction to write GLC data to Main file
+
+void glcfile_mainfile(int pid)
+{
+    char buffer3[32];
+    sprintf(buffer3, "/sd/%d.csv", pid);       
+    fpmain = fopen(buffer3, "a");             // Main File is opened in Append mode
+    
+    sprintf(buffer3, "/sd/%d_GLC.csv", pid);  // BG file is opened in read mode
+    fpbg = fopen(buffer3, "r");
+    
+    for(int i=0; i<2; i++)
+    {
+    int bigbuf[2] = {0} ;
+    fread(bigbuf, sizeof(int),2 , fpbg);      
+    fwrite(bigbuf, sizeof(int), 2, fpmain);
+    }
+    fclose(fpbg);                               // Both files are Closed
+    fclose(fpmain);
+    
+    int success;
+    sprintf(buffer3, "/sd/%d_GLC.csv", pid);  
+    success = remove(buffer3);                           // GLC file is deleted
+}
+
+
+void delete_subfiles(int pid)
+{
+    char buffer3[32];  
+    int success1 , success2, success3;
+    success1 = 1 ;
+    sprintf(buffer3, "/sd/%d_BP.csv", pid);
+    success1 = remove(buffer3);                           //Removes PPG file of BP and updates status with 0 if successful
+    
+    if( success1 == 0 )
+        snd.printf("\nBP file delete : Successful");   // Checks for SUCCESS
+    else 
+        snd.printf("\nBP file delete : UnSuccessful");
+
+    success2 = 1 ;
+    sprintf(buffer3, "/sd/%d_GLC.csv", pid);
+    success2 = remove(buffer3);                           //Removes GLC file and updates status with 0 if successful
+    
+    if( success2 == 0 )
+        snd.printf("\nGLC file delete : Successful");   // Checks for SUCCESS
+    else 
+        snd.printf("\nGLC file delete : UnSuccessful");
+
+    success3 = 1 ;
+    sprintf(buffer3, "/sd/%d_ECG.csv", pid);
+    success3 = remove(buffer3);                           //Removes ECG file and updates status with 0 if successful
+    
+    if( success3 == 0 )
+        snd.printf("\nECG file delete : Successful");   // Checks for SUCCESS
+    else 
+        snd.printf("\nECG file delete : UnSuccessful");
+
 }
\ No newline at end of file