code with new display driver ili9341
Dependencies: SDFileSystem ds3231 eeprom_Nikita mbed testUniGraphic_150217
Fork of Int_Demo_09May2017_Suhasini_HRavg_Nik_BT_ba_update4thJuly17_nikita7july by
sdcard.cpp@17:22a87e12fb3a, 2017-06-09 (annotated)
- Committer:
- nidhinvarghese
- Date:
- Fri Jun 09 08:45:30 2017 +0000
- Revision:
- 17:22a87e12fb3a
- Parent:
- 15:208b146151ba
- Child:
- 19:1650bbc923cc
ECG code hanging but BP and GLC working
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
nidhinvarghese | 14:f5c62d30c6fc | 1 | // Exisiting code in Int_Demo_09May2017_suhasini/sdcard.cpp is deleted and replaced by new code |
nidhinvarghese | 14:f5c62d30c6fc | 2 | //Nidhin 1/6/2017 |
nidhinvarghese | 14:f5c62d30c6fc | 3 | |
nidhinvarghese | 14:f5c62d30c6fc | 4 | |
nikitateggi | 1:8316c23ec6b9 | 5 | #include "mbed.h" |
nikitateggi | 1:8316c23ec6b9 | 6 | #include <stdio.h> |
nikitateggi | 1:8316c23ec6b9 | 7 | #include "SDFileSystem.h" |
nikitateggi | 1:8316c23ec6b9 | 8 | #include "sdcard.h" |
nikitateggi | 1:8316c23ec6b9 | 9 | #include "rtc.h" |
nidhinvarghese | 14:f5c62d30c6fc | 10 | #include "struct.h" |
nidhinvarghese | 14:f5c62d30c6fc | 11 | |
nidhinvarghese | 14:f5c62d30c6fc | 12 | Serial snd(USBTX,USBRX); |
nikitateggi | 3:9a06c2bed650 | 13 | |
nikitateggi | 1:8316c23ec6b9 | 14 | |
nikitateggi | 1:8316c23ec6b9 | 15 | SDFileSystem sd(PTE1, PTE3, PTE2, PTE4, "sd"); |
nidhinvarghese | 14:f5c62d30c6fc | 16 | |
nidhinvarghese | 14:f5c62d30c6fc | 17 | FILE *fpecg; // PPG and ECG File pointers for BP |
nidhinvarghese | 14:f5c62d30c6fc | 18 | FILE *fpppg; //"" "" |
nidhinvarghese | 14:f5c62d30c6fc | 19 | |
nidhinvarghese | 14:f5c62d30c6fc | 20 | FILE *fpmain; // FILE pointer for main file |
nidhinvarghese | 14:f5c62d30c6fc | 21 | |
nidhinvarghese | 14:f5c62d30c6fc | 22 | FILE *fpbg; // FILE pointer to BG file |
nidhinvarghese | 14:f5c62d30c6fc | 23 | FILE *fpeecg; // FILE pointer to ECG file |
nidhinvarghese | 14:f5c62d30c6fc | 24 | FILE *fpbp; // FILE pointer to BP file |
nidhinvarghese | 14:f5c62d30c6fc | 25 | |
nidhinvarghese | 14:f5c62d30c6fc | 26 | FILE *fp; // FILE pointer for random use |
nidhinvarghese | 14:f5c62d30c6fc | 27 | |
nidhinvarghese | 14:f5c62d30c6fc | 28 | |
nidhinvarghese | 14:f5c62d30c6fc | 29 | |
nidhinvarghese | 14:f5c62d30c6fc | 30 | int ecgloc = 0; // PPG and eCG maximum locations |
nidhinvarghese | 14:f5c62d30c6fc | 31 | int ppgloc = 0; |
nidhinvarghese | 14:f5c62d30c6fc | 32 | |
nidhinvarghese | 14:f5c62d30c6fc | 33 | int ebp = 0; // variable for LOOP operation to read value from File i == ECG , j == PPG |
nidhinvarghese | 14:f5c62d30c6fc | 34 | int pbp = 0; |
nidhinvarghese | 14:f5c62d30c6fc | 35 | |
nidhinvarghese | 14:f5c62d30c6fc | 36 | //Function Added on 16/5/2017 by Nidhin |
nidhinvarghese | 14:f5c62d30c6fc | 37 | void sd_open_mainfile(int pid) |
nidhinvarghese | 14:f5c62d30c6fc | 38 | { |
nidhinvarghese | 14:f5c62d30c6fc | 39 | char buffer1[32]; |
nidhinvarghese | 14:f5c62d30c6fc | 40 | sprintf(buffer1,"/sd/%d.csv",pid); |
nidhinvarghese | 14:f5c62d30c6fc | 41 | fp = fopen(buffer1,"a"); |
nidhinvarghese | 14:f5c62d30c6fc | 42 | } |
nidhinvarghese | 14:f5c62d30c6fc | 43 | //------------------------------------------ |
nidhinvarghese | 14:f5c62d30c6fc | 44 | |
nidhinvarghese | 14:f5c62d30c6fc | 45 | |
nidhinvarghese | 14:f5c62d30c6fc | 46 | |
nikitateggi | 4:6bd81bb1790d | 47 | void sd_open_GLCfile(int pid) // opening the glc file |
nikitateggi | 1:8316c23ec6b9 | 48 | { |
nikitateggi | 1:8316c23ec6b9 | 49 | |
nikitateggi | 1:8316c23ec6b9 | 50 | char buffer[32]; |
nikitateggi | 1:8316c23ec6b9 | 51 | char buffer1[32]; |
nikitateggi | 1:8316c23ec6b9 | 52 | time_t epoch_time1; |
nikitateggi | 1:8316c23ec6b9 | 53 | epoch_time1=rtc_read(); |
nikitateggi | 1:8316c23ec6b9 | 54 | // strftime(buffer, 32, "GLC_%s", pid); |
nikitateggi | 1:8316c23ec6b9 | 55 | |
nikitateggi | 4:6bd81bb1790d | 56 | sprintf(buffer1,"/sd/%d_GLC.csv",pid); |
nikitateggi | 1:8316c23ec6b9 | 57 | fp = fopen(buffer1,"a"); |
nikitateggi | 4:6bd81bb1790d | 58 | fprintf(fp,"%s\n",ctime(&epoch_time1) ); //writing the date, time into the file |
nikitateggi | 1:8316c23ec6b9 | 59 | |
nikitateggi | 1:8316c23ec6b9 | 60 | |
nikitateggi | 1:8316c23ec6b9 | 61 | } |
nikitateggi | 3:9a06c2bed650 | 62 | |
nikitateggi | 4:6bd81bb1790d | 63 | void sd_open_GLCfilee(int pid) // only opening the glc file after entering TEST screen |
nikitateggi | 2:3b7b71bfc941 | 64 | { |
nikitateggi | 2:3b7b71bfc941 | 65 | char buffer1[32]; |
nikitateggi | 4:6bd81bb1790d | 66 | sprintf(buffer1,"/sd/%d_GLC.csv",pid); |
nidhinvarghese | 14:f5c62d30c6fc | 67 | fpbg = fopen(buffer1,"a"); |
nidhinvarghese | 14:f5c62d30c6fc | 68 | fclose(fpbg); |
nidhinvarghese | 14:f5c62d30c6fc | 69 | } |
nikitateggi | 1:8316c23ec6b9 | 70 | |
nidhinvarghese | 14:f5c62d30c6fc | 71 | |
nikitateggi | 4:6bd81bb1790d | 72 | |
nikitateggi | 4:6bd81bb1790d | 73 | void sd_open_ECGfile(int pid) |
nikitateggi | 1:8316c23ec6b9 | 74 | { |
nikitateggi | 1:8316c23ec6b9 | 75 | |
nikitateggi | 1:8316c23ec6b9 | 76 | // char buffer[32]; |
nikitateggi | 1:8316c23ec6b9 | 77 | char buffer1[32]; |
nikitateggi | 1:8316c23ec6b9 | 78 | time_t epoch_time1; |
nikitateggi | 1:8316c23ec6b9 | 79 | epoch_time1=rtc_read(); |
nikitateggi | 1:8316c23ec6b9 | 80 | // strftime(buffer, 32, "ECG_%d", pid); |
nikitateggi | 1:8316c23ec6b9 | 81 | |
nikitateggi | 2:3b7b71bfc941 | 82 | sprintf(buffer1,"/sd/%d_ECG.csv",pid); |
nikitateggi | 1:8316c23ec6b9 | 83 | fp = fopen(buffer1,"a"); |
nikitateggi | 1:8316c23ec6b9 | 84 | fprintf(fp,"%s\n",ctime(&epoch_time1) ); |
nikitateggi | 4:6bd81bb1790d | 85 | |
nikitateggi | 1:8316c23ec6b9 | 86 | } |
nikitateggi | 1:8316c23ec6b9 | 87 | |
nikitateggi | 4:6bd81bb1790d | 88 | void sd_open_ECGfilee(int pid) // only opening the ECG file after entering TEST screen |
nikitateggi | 2:3b7b71bfc941 | 89 | { |
nikitateggi | 2:3b7b71bfc941 | 90 | |
nikitateggi | 2:3b7b71bfc941 | 91 | char buffer1[32]; |
nidhinvarghese | 14:f5c62d30c6fc | 92 | sprintf(buffer1,"/sd/%d_ECG.csv",pid); |
nidhinvarghese | 14:f5c62d30c6fc | 93 | fpeecg = fopen(buffer1,"a"); |
nidhinvarghese | 14:f5c62d30c6fc | 94 | //fclose(fpeecg); |
nikitateggi | 4:6bd81bb1790d | 95 | |
nikitateggi | 2:3b7b71bfc941 | 96 | } |
nikitateggi | 4:6bd81bb1790d | 97 | |
nikitateggi | 4:6bd81bb1790d | 98 | |
nikitateggi | 4:6bd81bb1790d | 99 | void sd_open_BPfile(int pid) |
nikitateggi | 1:8316c23ec6b9 | 100 | { |
nikitateggi | 1:8316c23ec6b9 | 101 | |
nikitateggi | 1:8316c23ec6b9 | 102 | char buffer[32]; |
nikitateggi | 1:8316c23ec6b9 | 103 | char buffer1[32]; |
nikitateggi | 1:8316c23ec6b9 | 104 | time_t epoch_time1; |
nikitateggi | 1:8316c23ec6b9 | 105 | epoch_time1=rtc_read(); |
nikitateggi | 1:8316c23ec6b9 | 106 | // strftime(buffer, 32, "ECG_%d", pid); |
nikitateggi | 1:8316c23ec6b9 | 107 | |
nikitateggi | 2:3b7b71bfc941 | 108 | sprintf(buffer1,"/sd/%d_BP.csv",pid); |
nikitateggi | 1:8316c23ec6b9 | 109 | fp = fopen(buffer1,"a"); |
nikitateggi | 1:8316c23ec6b9 | 110 | fprintf(fp,"%s\n",ctime(&epoch_time1) ); |
nikitateggi | 1:8316c23ec6b9 | 111 | } |
nikitateggi | 1:8316c23ec6b9 | 112 | |
nikitateggi | 4:6bd81bb1790d | 113 | void sd_open_BPfilee(int pid) // only opening the BP file after entering TEST screen |
nikitateggi | 4:6bd81bb1790d | 114 | { |
nikitateggi | 4:6bd81bb1790d | 115 | |
nikitateggi | 1:8316c23ec6b9 | 116 | |
nikitateggi | 4:6bd81bb1790d | 117 | char buffer1[32]; |
nikitateggi | 4:6bd81bb1790d | 118 | sprintf(buffer1,"/sd/%d_BP.csv",pid); |
nidhinvarghese | 14:f5c62d30c6fc | 119 | fpbp = fopen(buffer1,"a"); |
nidhinvarghese | 14:f5c62d30c6fc | 120 | //fprintf(fp,"PATIENT ID %d\n",pid ); Not required in new code as writing in hex |
nidhinvarghese | 14:f5c62d30c6fc | 121 | fclose(fpbp); |
nidhinvarghese | 8:adf2ba7e6412 | 122 | } |
nidhinvarghese | 8:adf2ba7e6412 | 123 | |
nidhinvarghese | 8:adf2ba7e6412 | 124 | void sd_write (int value) // writing data into the file |
nidhinvarghese | 8:adf2ba7e6412 | 125 | { |
nidhinvarghese | 8:adf2ba7e6412 | 126 | fprintf(fp,"%d\n", value); |
nidhinvarghese | 8:adf2ba7e6412 | 127 | } |
nidhinvarghese | 8:adf2ba7e6412 | 128 | |
nidhinvarghese | 8:adf2ba7e6412 | 129 | //------------------------------------------------------ |
nidhinvarghese | 8:adf2ba7e6412 | 130 | |
nidhinvarghese | 8:adf2ba7e6412 | 131 | //FILE *sd_BP_ecgwrite (int value) // writing data into the file NIDHIN |
nidhinvarghese | 15:208b146151ba | 132 | FILE *sd_BP_ecgwrite (int32_t *fpdrum11) // writing data into the file NIDHIN |
nidhinvarghese | 8:adf2ba7e6412 | 133 | { |
nidhinvarghese | 15:208b146151ba | 134 | fwrite(fpdrum11,sizeof(int32_t),1, fpecg); //Change by Nidhin 30/5/2017 Direct writing to SD card. Org Val 64 |
nidhinvarghese | 8:adf2ba7e6412 | 135 | return fpecg; |
nidhinvarghese | 8:adf2ba7e6412 | 136 | } |
nidhinvarghese | 8:adf2ba7e6412 | 137 | |
nidhinvarghese | 14:f5c62d30c6fc | 138 | FILE* sd_BP_ppgwrite (uint32_t *fpdrum21) // //Change by Nidhin 30/5/2017 Direct writing to SD card. |
nidhinvarghese | 8:adf2ba7e6412 | 139 | { |
nidhinvarghese | 14:f5c62d30c6fc | 140 | fwrite(fpdrum21,sizeof(uint32_t),1, fpppg); //Change by Nidhin 30/5/2017 Direct writing to SD card. OR Val 64 |
nidhinvarghese | 8:adf2ba7e6412 | 141 | return fpppg; |
nidhinvarghese | 8:adf2ba7e6412 | 142 | } |
nidhinvarghese | 8:adf2ba7e6412 | 143 | //-----------------------------------------------SD Read |
nidhinvarghese | 8:adf2ba7e6412 | 144 | |
nidhinvarghese | 8:adf2ba7e6412 | 145 | void sd_reopen_BPfilee(int pid) // only opening the BP file after entering TEST screen |
nidhinvarghese | 8:adf2ba7e6412 | 146 | { |
nidhinvarghese | 8:adf2ba7e6412 | 147 | |
nidhinvarghese | 8:adf2ba7e6412 | 148 | |
nidhinvarghese | 8:adf2ba7e6412 | 149 | char buffer1[32]; |
nidhinvarghese | 8:adf2ba7e6412 | 150 | sprintf(buffer1,"/sd/%d_BP.csv",pid); |
nidhinvarghese | 8:adf2ba7e6412 | 151 | fp = fopen(buffer1,"r"); |
nidhinvarghese | 8:adf2ba7e6412 | 152 | //fprintf(fp,"PATIENT ID %d\n",pid ); |
nidhinvarghese | 8:adf2ba7e6412 | 153 | |
nidhinvarghese | 8:adf2ba7e6412 | 154 | |
nidhinvarghese | 8:adf2ba7e6412 | 155 | } |
nidhinvarghese | 8:adf2ba7e6412 | 156 | //------------------------------------------------- |
nidhinvarghese | 8:adf2ba7e6412 | 157 | |
nidhinvarghese | 8:adf2ba7e6412 | 158 | |
nidhinvarghese | 8:adf2ba7e6412 | 159 | //--------------------------------------- |
nidhinvarghese | 8:adf2ba7e6412 | 160 | |
nidhinvarghese | 8:adf2ba7e6412 | 161 | |
nidhinvarghese | 8:adf2ba7e6412 | 162 | void sd_open_BP_ECGfile(int pid) |
nidhinvarghese | 8:adf2ba7e6412 | 163 | { |
nidhinvarghese | 8:adf2ba7e6412 | 164 | |
nidhinvarghese | 8:adf2ba7e6412 | 165 | //char buffer[32]; |
nidhinvarghese | 8:adf2ba7e6412 | 166 | char buffer1[32]; |
nidhinvarghese | 8:adf2ba7e6412 | 167 | //time_t epoch_time1; |
nidhinvarghese | 8:adf2ba7e6412 | 168 | //epoch_time1=rtc_read(); |
nidhinvarghese | 8:adf2ba7e6412 | 169 | // strftime(buffer, 32, "ECG_%d", pid); |
nidhinvarghese | 8:adf2ba7e6412 | 170 | |
nidhinvarghese | 8:adf2ba7e6412 | 171 | sprintf(buffer1,"/sd/%d_BP_ECG.csv",pid); |
nidhinvarghese | 8:adf2ba7e6412 | 172 | fpecg = fopen(buffer1,"a"); |
nidhinvarghese | 8:adf2ba7e6412 | 173 | if (fpecg == NULL) |
nidhinvarghese | 8:adf2ba7e6412 | 174 | { |
nidhinvarghese | 8:adf2ba7e6412 | 175 | exit(1); |
nidhinvarghese | 8:adf2ba7e6412 | 176 | } |
nidhinvarghese | 8:adf2ba7e6412 | 177 | //fprintf(fpecg,"%s\n",ctime(&epoch_time1) ); |
nidhinvarghese | 8:adf2ba7e6412 | 178 | |
nidhinvarghese | 8:adf2ba7e6412 | 179 | } |
nidhinvarghese | 8:adf2ba7e6412 | 180 | |
nidhinvarghese | 8:adf2ba7e6412 | 181 | |
nidhinvarghese | 8:adf2ba7e6412 | 182 | void sd_open_BP_PPGfile(int pid) |
nidhinvarghese | 8:adf2ba7e6412 | 183 | { |
nidhinvarghese | 8:adf2ba7e6412 | 184 | |
nidhinvarghese | 8:adf2ba7e6412 | 185 | char buffer1[32]; |
nidhinvarghese | 8:adf2ba7e6412 | 186 | //time_t epoch_time1; |
nidhinvarghese | 8:adf2ba7e6412 | 187 | //epoch_time1=rtc_read(); |
nidhinvarghese | 8:adf2ba7e6412 | 188 | // strftime(buffer, 32, "ECG_%d", pid); |
nidhinvarghese | 8:adf2ba7e6412 | 189 | |
nidhinvarghese | 8:adf2ba7e6412 | 190 | sprintf(buffer1,"/sd/%d_BP_PPG.csv",pid); |
nidhinvarghese | 8:adf2ba7e6412 | 191 | fpppg = fopen(buffer1,"a"); |
nidhinvarghese | 8:adf2ba7e6412 | 192 | if(fpppg == NULL) |
nidhinvarghese | 8:adf2ba7e6412 | 193 | { |
nidhinvarghese | 8:adf2ba7e6412 | 194 | exit(1); |
nidhinvarghese | 8:adf2ba7e6412 | 195 | } |
nidhinvarghese | 8:adf2ba7e6412 | 196 | |
nidhinvarghese | 8:adf2ba7e6412 | 197 | //fprintf(fpppg,"%s\n",ctime(&epoch_time1) ); |
nidhinvarghese | 8:adf2ba7e6412 | 198 | |
nidhinvarghese | 8:adf2ba7e6412 | 199 | } |
nidhinvarghese | 8:adf2ba7e6412 | 200 | |
nidhinvarghese | 8:adf2ba7e6412 | 201 | |
nidhinvarghese | 8:adf2ba7e6412 | 202 | |
nidhinvarghese | 8:adf2ba7e6412 | 203 | //-------------------------------------------------- |
nidhinvarghese | 8:adf2ba7e6412 | 204 | |
nidhinvarghese | 14:f5c62d30c6fc | 205 | //FUNCTIONS TO CLOSE FILES |
nidhinvarghese | 14:f5c62d30c6fc | 206 | //__________________________________________________ |
nidhinvarghese | 14:f5c62d30c6fc | 207 | void sd_close() //close the file with fp |
nidhinvarghese | 8:adf2ba7e6412 | 208 | { |
nikitateggi | 1:8316c23ec6b9 | 209 | |
nidhinvarghese | 8:adf2ba7e6412 | 210 | fclose(fp); |
nidhinvarghese | 8:adf2ba7e6412 | 211 | } |
nidhinvarghese | 14:f5c62d30c6fc | 212 | //______________________________________________________ |
nidhinvarghese | 14:f5c62d30c6fc | 213 | void sd_close_ecg() // Closes ECG file pinted by fpeecg |
nidhinvarghese | 14:f5c62d30c6fc | 214 | { |
nidhinvarghese | 14:f5c62d30c6fc | 215 | |
nidhinvarghese | 14:f5c62d30c6fc | 216 | fclose(fpeecg); |
nidhinvarghese | 14:f5c62d30c6fc | 217 | } |
nidhinvarghese | 14:f5c62d30c6fc | 218 | //______________________________________________________ |
nidhinvarghese | 14:f5c62d30c6fc | 219 | void sd_close_glc() // Closes GLC file pinted by fpbg |
nidhinvarghese | 14:f5c62d30c6fc | 220 | { |
nidhinvarghese | 14:f5c62d30c6fc | 221 | |
nidhinvarghese | 14:f5c62d30c6fc | 222 | fclose(fpbg); |
nidhinvarghese | 14:f5c62d30c6fc | 223 | } |
nidhinvarghese | 14:f5c62d30c6fc | 224 | //_____________________________________________________ |
nidhinvarghese | 14:f5c62d30c6fc | 225 | |
nidhinvarghese | 14:f5c62d30c6fc | 226 | |
nidhinvarghese | 14:f5c62d30c6fc | 227 | |
nidhinvarghese | 14:f5c62d30c6fc | 228 | |
nidhinvarghese | 14:f5c62d30c6fc | 229 | |
nidhinvarghese | 14:f5c62d30c6fc | 230 | |
nidhinvarghese | 8:adf2ba7e6412 | 231 | //------------------------------------------ |
nidhinvarghese | 8:adf2ba7e6412 | 232 | //REOPEN FUNCTIONs for reading data Nidhin |
nidhinvarghese | 8:adf2ba7e6412 | 233 | |
nidhinvarghese | 8:adf2ba7e6412 | 234 | int sd_BP_ECGMAX(int pid) |
nidhinvarghese | 8:adf2ba7e6412 | 235 | { |
nidhinvarghese | 8:adf2ba7e6412 | 236 | |
nidhinvarghese | 8:adf2ba7e6412 | 237 | char buffer1[32]; |
nidhinvarghese | 8:adf2ba7e6412 | 238 | |
nidhinvarghese | 8:adf2ba7e6412 | 239 | sprintf(buffer1,"/sd/%d_BP_ECG.csv",pid); |
nidhinvarghese | 8:adf2ba7e6412 | 240 | fpecg = fopen(buffer1,"r"); |
nidhinvarghese | 8:adf2ba7e6412 | 241 | if(fpecg == NULL) |
nidhinvarghese | 8:adf2ba7e6412 | 242 | { |
nidhinvarghese | 8:adf2ba7e6412 | 243 | exit(1); |
nidhinvarghese | 8:adf2ba7e6412 | 244 | } |
nidhinvarghese | 8:adf2ba7e6412 | 245 | |
nidhinvarghese | 8:adf2ba7e6412 | 246 | else |
nidhinvarghese | 8:adf2ba7e6412 | 247 | { |
nidhinvarghese | 8:adf2ba7e6412 | 248 | int ecgmax = 0; |
nidhinvarghese | 8:adf2ba7e6412 | 249 | int a[1] = {0}; |
nidhinvarghese | 8:adf2ba7e6412 | 250 | int samplesecg =0; |
nidhinvarghese | 8:adf2ba7e6412 | 251 | for(ebp=0; ebp<1024; ebp++) |
nidhinvarghese | 8:adf2ba7e6412 | 252 | { |
nidhinvarghese | 8:adf2ba7e6412 | 253 | |
nidhinvarghese | 8:adf2ba7e6412 | 254 | |
nidhinvarghese | 14:f5c62d30c6fc | 255 | fread(a,sizeof(uint32_t), 1,fpecg); |
nidhinvarghese | 11:9a6545c2eb5d | 256 | // snd.printf("\n%d", a[0]); Commented May3_2017 (Nidhin) |
nidhinvarghese | 8:adf2ba7e6412 | 257 | if(a[0] > ecgmax) |
nidhinvarghese | 8:adf2ba7e6412 | 258 | { |
nidhinvarghese | 8:adf2ba7e6412 | 259 | ecgmax=a[0]; |
nidhinvarghese | 8:adf2ba7e6412 | 260 | ecgloc= ebp +1; |
nidhinvarghese | 8:adf2ba7e6412 | 261 | } |
nidhinvarghese | 8:adf2ba7e6412 | 262 | else |
nidhinvarghese | 8:adf2ba7e6412 | 263 | samplesecg =ebp+1; |
nidhinvarghese | 8:adf2ba7e6412 | 264 | |
nidhinvarghese | 8:adf2ba7e6412 | 265 | } |
nidhinvarghese | 8:adf2ba7e6412 | 266 | } |
nidhinvarghese | 8:adf2ba7e6412 | 267 | fclose (fpecg); |
nidhinvarghese | 8:adf2ba7e6412 | 268 | return ecgloc; |
nidhinvarghese | 8:adf2ba7e6412 | 269 | } |
nidhinvarghese | 8:adf2ba7e6412 | 270 | |
nidhinvarghese | 8:adf2ba7e6412 | 271 | // Function to calculate PPG MAx and location |
nidhinvarghese | 8:adf2ba7e6412 | 272 | |
nidhinvarghese | 8:adf2ba7e6412 | 273 | int sd_BP_PPGMAX(int pid) |
nidhinvarghese | 8:adf2ba7e6412 | 274 | { |
nidhinvarghese | 8:adf2ba7e6412 | 275 | |
nidhinvarghese | 8:adf2ba7e6412 | 276 | char buffer1[32]; |
nidhinvarghese | 8:adf2ba7e6412 | 277 | |
nidhinvarghese | 8:adf2ba7e6412 | 278 | sprintf(buffer1,"/sd/%d_BP_PPG.csv",pid); |
nidhinvarghese | 8:adf2ba7e6412 | 279 | fpppg = fopen(buffer1,"r"); |
nidhinvarghese | 8:adf2ba7e6412 | 280 | if(fpppg == NULL) |
nidhinvarghese | 8:adf2ba7e6412 | 281 | { |
nidhinvarghese | 8:adf2ba7e6412 | 282 | exit(1); |
nidhinvarghese | 8:adf2ba7e6412 | 283 | } |
nidhinvarghese | 8:adf2ba7e6412 | 284 | |
nidhinvarghese | 8:adf2ba7e6412 | 285 | else |
nidhinvarghese | 8:adf2ba7e6412 | 286 | { |
nidhinvarghese | 8:adf2ba7e6412 | 287 | uint32_t ppgmax = 0; |
nidhinvarghese | 8:adf2ba7e6412 | 288 | uint32_t b[1] ={0}; |
nidhinvarghese | 8:adf2ba7e6412 | 289 | int samplesppg = 0; |
nidhinvarghese | 8:adf2ba7e6412 | 290 | for(pbp=0; pbp<1664; pbp++) |
nidhinvarghese | 8:adf2ba7e6412 | 291 | { |
nidhinvarghese | 8:adf2ba7e6412 | 292 | fread(b, sizeof(uint32_t),1, fpppg); |
nidhinvarghese | 11:9a6545c2eb5d | 293 | // snd.printf("\n%d", b[0]); Commented May3_2017 (Nidhin) |
nidhinvarghese | 8:adf2ba7e6412 | 294 | |
nidhinvarghese | 8:adf2ba7e6412 | 295 | if((pbp>ecgloc) && (pbp< (ecgloc+350))) |
nidhinvarghese | 8:adf2ba7e6412 | 296 | { |
nidhinvarghese | 8:adf2ba7e6412 | 297 | if(b[0] > ppgmax) |
nidhinvarghese | 8:adf2ba7e6412 | 298 | { |
nidhinvarghese | 8:adf2ba7e6412 | 299 | ppgmax=b[0]; |
nidhinvarghese | 8:adf2ba7e6412 | 300 | ppgloc= pbp+1; |
nidhinvarghese | 8:adf2ba7e6412 | 301 | } |
nidhinvarghese | 8:adf2ba7e6412 | 302 | else |
nidhinvarghese | 8:adf2ba7e6412 | 303 | samplesppg =pbp+1; |
nidhinvarghese | 8:adf2ba7e6412 | 304 | } |
nidhinvarghese | 8:adf2ba7e6412 | 305 | else |
nidhinvarghese | 8:adf2ba7e6412 | 306 | samplesppg = pbp+1; |
nidhinvarghese | 8:adf2ba7e6412 | 307 | } |
nidhinvarghese | 8:adf2ba7e6412 | 308 | } |
nidhinvarghese | 8:adf2ba7e6412 | 309 | fclose (fpppg); |
nidhinvarghese | 8:adf2ba7e6412 | 310 | return ppgloc; |
nidhinvarghese | 8:adf2ba7e6412 | 311 | } |
nidhinvarghese | 10:aeff3309002a | 312 | |
nidhinvarghese | 8:adf2ba7e6412 | 313 | //fread(buffer, 1, size, fp) |
nidhinvarghese | 8:adf2ba7e6412 | 314 | //fwrite(&buffer, , |
nidhinvarghese | 10:aeff3309002a | 315 | //----------------------------------------------------28/4/2017--------------------------------- |
nidhinvarghese | 10:aeff3309002a | 316 | //---------------------------------------------------------------------------------------------- |
nidhinvarghese | 10:aeff3309002a | 317 | |
nidhinvarghese | 10:aeff3309002a | 318 | |
nidhinvarghese | 10:aeff3309002a | 319 | |
nidhinvarghese | 10:aeff3309002a | 320 | //------- FUNCTION TO CREATE SINGLE BP FILE --------2/5/2017 (NIDHIN)---------------// |
nidhinvarghese | 10:aeff3309002a | 321 | void create_single_BPfile(int pid) |
nidhinvarghese | 10:aeff3309002a | 322 | { |
nidhinvarghese | 10:aeff3309002a | 323 | |
nidhinvarghese | 10:aeff3309002a | 324 | //int ecgbuf[64] = {0}; |
nidhinvarghese | 10:aeff3309002a | 325 | //uint32_t ppgbuf[64] = {0}; |
nidhinvarghese | 10:aeff3309002a | 326 | |
nidhinvarghese | 10:aeff3309002a | 327 | char buffer3[32]; |
nidhinvarghese | 10:aeff3309002a | 328 | sprintf(buffer3, "/sd/%d_BP.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 329 | fpbp = fopen(buffer3, "a"); // Opens BP file with FILE pointer fpbp in APPEND mode |
nidhinvarghese | 10:aeff3309002a | 330 | |
nidhinvarghese | 10:aeff3309002a | 331 | //buffer1[32] = ""; |
nidhinvarghese | 14:f5c62d30c6fc | 332 | sprintf(buffer3, "/sd/%d_BP_ECG.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 333 | fpecg = fopen(buffer3, "r"); // Opens ECG file of BP with FILE pointer fpecg in READ mode |
nidhinvarghese | 10:aeff3309002a | 334 | |
nidhinvarghese | 10:aeff3309002a | 335 | //char buffer1[32] = ""; |
nidhinvarghese | 10:aeff3309002a | 336 | sprintf(buffer3, "/sd/%d_BP_PPG.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 337 | fpppg = fopen(buffer3, "r"); // Opens PPG file of BP with FILE pointer fpppg in READ mode |
nidhinvarghese | 10:aeff3309002a | 338 | |
nidhinvarghese | 10:aeff3309002a | 339 | for(int i=0; i<16; i++) |
nidhinvarghese | 10:aeff3309002a | 340 | { |
nidhinvarghese | 10:aeff3309002a | 341 | int ecgbuf[64] = {0} ; |
nidhinvarghese | 14:f5c62d30c6fc | 342 | fread(ecgbuf, sizeof(uint32_t), 64, fpecg); |
nidhinvarghese | 14:f5c62d30c6fc | 343 | fwrite(ecgbuf, sizeof(uint32_t), 64, fpbp); // Copy ECG data of BP into BP file |
nidhinvarghese | 10:aeff3309002a | 344 | } |
nidhinvarghese | 10:aeff3309002a | 345 | |
nidhinvarghese | 10:aeff3309002a | 346 | for(int i=0; i<26; i++) |
nidhinvarghese | 10:aeff3309002a | 347 | { |
nidhinvarghese | 10:aeff3309002a | 348 | int ppgbuf[64] = {0} ; |
nidhinvarghese | 14:f5c62d30c6fc | 349 | fread(ppgbuf, sizeof(uint32_t), 64, fpppg); |
nidhinvarghese | 14:f5c62d30c6fc | 350 | fwrite(ppgbuf, sizeof(uint32_t), 64, fpbp); // Copy PPG data of BP into BP file |
nidhinvarghese | 10:aeff3309002a | 351 | } |
nidhinvarghese | 10:aeff3309002a | 352 | |
nidhinvarghese | 14:f5c62d30c6fc | 353 | fclose(fpecg); // Closes the ECG file of BP |
nidhinvarghese | 14:f5c62d30c6fc | 354 | fclose(fpppg); // Closes the PPG file of BP |
nidhinvarghese | 14:f5c62d30c6fc | 355 | fclose(fpbp); // Closes the BP file |
nidhinvarghese | 10:aeff3309002a | 356 | |
nidhinvarghese | 10:aeff3309002a | 357 | //char buffer1[32] = ""; |
nidhinvarghese | 14:f5c62d30c6fc | 358 | int status = 1 ; |
nidhinvarghese | 10:aeff3309002a | 359 | sprintf(buffer3, "/sd/%d_BP_ECG.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 360 | status = remove(buffer3); //Removes ECG file of BP and updates status with 0 if successful |
nidhinvarghese | 11:9a6545c2eb5d | 361 | |
nidhinvarghese | 11:9a6545c2eb5d | 362 | |
nidhinvarghese | 10:aeff3309002a | 363 | if( status == 0 ) |
nidhinvarghese | 14:f5c62d30c6fc | 364 | snd.printf("\nECG file delete : Successful"); // Checks for SUCCESS |
nidhinvarghese | 10:aeff3309002a | 365 | else |
nidhinvarghese | 10:aeff3309002a | 366 | snd.printf("\nECG file delete : UnSuccessful"); |
nidhinvarghese | 11:9a6545c2eb5d | 367 | |
nidhinvarghese | 11:9a6545c2eb5d | 368 | |
nidhinvarghese | 10:aeff3309002a | 369 | //char buffer1[32] = ""; |
nidhinvarghese | 14:f5c62d30c6fc | 370 | status = 1 ; |
nidhinvarghese | 10:aeff3309002a | 371 | sprintf(buffer3, "/sd/%d_BP_PPG.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 372 | status = remove(buffer3); //Removes PPG file of BP and updates status with 0 if successful |
nidhinvarghese | 11:9a6545c2eb5d | 373 | |
nidhinvarghese | 10:aeff3309002a | 374 | if( status == 0 ) |
nidhinvarghese | 14:f5c62d30c6fc | 375 | snd.printf("\nPPG file delete : Successful"); // Checks for SUCCESS |
nidhinvarghese | 10:aeff3309002a | 376 | else |
nidhinvarghese | 10:aeff3309002a | 377 | snd.printf("\nPPG file delete : UnSuccessful"); |
nidhinvarghese | 11:9a6545c2eb5d | 378 | |
nidhinvarghese | 14:f5c62d30c6fc | 379 | } |
nidhinvarghese | 14:f5c62d30c6fc | 380 | |
nidhinvarghese | 14:f5c62d30c6fc | 381 | //Creating strcuture file Common to All Functions |
nidhinvarghese | 14:f5c62d30c6fc | 382 | void structure_file(BLEMsg_info *ptr, int pid) |
nidhinvarghese | 14:f5c62d30c6fc | 383 | { |
nidhinvarghese | 14:f5c62d30c6fc | 384 | char buffer3[32]; |
nidhinvarghese | 14:f5c62d30c6fc | 385 | sprintf(buffer3, "/sd/%d.csv", pid); //Printing file path to the buffer |
nidhinvarghese | 14:f5c62d30c6fc | 386 | fpmain = fopen(buffer3, "a"); // open the file PID.csv with FILE pointer fpmain |
nidhinvarghese | 14:f5c62d30c6fc | 387 | fwrite(ptr, sizeof(uint8_t),26, fpmain ); // writing the Structure into the file |
nidhinvarghese | 14:f5c62d30c6fc | 388 | fclose(fpmain); // Close File |
nidhinvarghese | 14:f5c62d30c6fc | 389 | } |
nidhinvarghese | 14:f5c62d30c6fc | 390 | |
nidhinvarghese | 14:f5c62d30c6fc | 391 | //Copy Data into file. |
nidhinvarghese | 14:f5c62d30c6fc | 392 | |
nidhinvarghese | 14:f5c62d30c6fc | 393 | void bpfile_mainfile(int pid) //Copy data of bp file to main |
nidhinvarghese | 14:f5c62d30c6fc | 394 | { |
nidhinvarghese | 14:f5c62d30c6fc | 395 | char buffer3[32]; |
nidhinvarghese | 14:f5c62d30c6fc | 396 | sprintf(buffer3, "/sd/%d.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 397 | fpmain = fopen(buffer3, "a"); // Opens Main file with FILE pointer "fpmain" in APPEND mode |
nidhinvarghese | 14:f5c62d30c6fc | 398 | |
nidhinvarghese | 14:f5c62d30c6fc | 399 | sprintf(buffer3, "/sd/%d_BP.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 400 | fpbp = fopen(buffer3, "r"); // Opens BP file with FILE pointer "fpbp" in READ mode |
nidhinvarghese | 14:f5c62d30c6fc | 401 | |
nidhinvarghese | 14:f5c62d30c6fc | 402 | |
nidhinvarghese | 14:f5c62d30c6fc | 403 | for(int i=0; i<21; i++) |
nidhinvarghese | 14:f5c62d30c6fc | 404 | { |
nidhinvarghese | 14:f5c62d30c6fc | 405 | int bigbuf[128] = {0} ; |
nidhinvarghese | 14:f5c62d30c6fc | 406 | fread(bigbuf, sizeof(uint32_t), 128, fpbp); |
nidhinvarghese | 14:f5c62d30c6fc | 407 | fwrite(bigbuf, sizeof(uint32_t), 128, fpmain); // Copy BP raw data into main file |
nidhinvarghese | 14:f5c62d30c6fc | 408 | } |
nidhinvarghese | 14:f5c62d30c6fc | 409 | fclose(fpbp); // Close BP file |
nidhinvarghese | 14:f5c62d30c6fc | 410 | fclose(fpmain); // Close Main File |
nidhinvarghese | 14:f5c62d30c6fc | 411 | |
nidhinvarghese | 14:f5c62d30c6fc | 412 | int success; |
nidhinvarghese | 14:f5c62d30c6fc | 413 | sprintf(buffer3, "/sd/%d_BP.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 414 | success = remove(buffer3); // Should return zero on success |
nidhinvarghese | 14:f5c62d30c6fc | 415 | } |
nidhinvarghese | 14:f5c62d30c6fc | 416 | |
nidhinvarghese | 14:f5c62d30c6fc | 417 | //------------New function added to print ECG data to Sd card using fwrite |
nidhinvarghese | 14:f5c62d30c6fc | 418 | void sd_ecgwrite(int *ecg_ptr) |
nidhinvarghese | 14:f5c62d30c6fc | 419 | { |
nidhinvarghese | 14:f5c62d30c6fc | 420 | fwrite(ecg_ptr, sizeof(int), 1, fpeecg); |
nidhinvarghese | 14:f5c62d30c6fc | 421 | } |
nidhinvarghese | 14:f5c62d30c6fc | 422 | |
nidhinvarghese | 14:f5c62d30c6fc | 423 | |
nidhinvarghese | 14:f5c62d30c6fc | 424 | //------------ Function to write ECG data to main file |
nidhinvarghese | 14:f5c62d30c6fc | 425 | void ecgfile_mainfile(int pid) |
nidhinvarghese | 14:f5c62d30c6fc | 426 | { |
nidhinvarghese | 14:f5c62d30c6fc | 427 | char buffer3[32]; |
nidhinvarghese | 14:f5c62d30c6fc | 428 | sprintf(buffer3, "/sd/%d.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 429 | fpmain = fopen(buffer3, "a"); // Main File is opened in Append mode |
nidhinvarghese | 14:f5c62d30c6fc | 430 | |
nidhinvarghese | 14:f5c62d30c6fc | 431 | sprintf(buffer3, "/sd/%d_ECG.csv", pid); // ECG file is opened in read mode |
nidhinvarghese | 14:f5c62d30c6fc | 432 | fpeecg = fopen(buffer3, "r"); |
nidhinvarghese | 14:f5c62d30c6fc | 433 | |
nidhinvarghese | 14:f5c62d30c6fc | 434 | for(int i=0; i<10; i++) |
nidhinvarghese | 14:f5c62d30c6fc | 435 | { |
nidhinvarghese | 14:f5c62d30c6fc | 436 | int bigbuf[100] = {0} ; |
nidhinvarghese | 14:f5c62d30c6fc | 437 | fread(bigbuf, sizeof(int),100 , fpeecg); |
nidhinvarghese | 14:f5c62d30c6fc | 438 | fwrite(bigbuf, sizeof(int), 100, fpmain); |
nidhinvarghese | 14:f5c62d30c6fc | 439 | } |
nidhinvarghese | 14:f5c62d30c6fc | 440 | fclose(fpeecg); // Both files are Closed |
nidhinvarghese | 14:f5c62d30c6fc | 441 | fclose(fpmain); |
nidhinvarghese | 14:f5c62d30c6fc | 442 | |
nidhinvarghese | 14:f5c62d30c6fc | 443 | /* |
nidhinvarghese | 14:f5c62d30c6fc | 444 | sprintf(buffer3, "/sd/%d_ECG.csv", pid); // ECG file is opened in write mode to empty the file |
nidhinvarghese | 14:f5c62d30c6fc | 445 | fpeecg = fopen(buffer3, "w"); |
nidhinvarghese | 14:f5c62d30c6fc | 446 | fclose(fpecg); |
nidhinvarghese | 14:f5c62d30c6fc | 447 | */ // File is closed |
nidhinvarghese | 14:f5c62d30c6fc | 448 | int success; |
nidhinvarghese | 14:f5c62d30c6fc | 449 | sprintf(buffer3, "/sd/%d_ECG.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 450 | success = remove(buffer3); |
nidhinvarghese | 14:f5c62d30c6fc | 451 | } |
nidhinvarghese | 14:f5c62d30c6fc | 452 | |
nidhinvarghese | 14:f5c62d30c6fc | 453 | |
nidhinvarghese | 14:f5c62d30c6fc | 454 | //---------------------- Function to write GLC data to GLC file |
nidhinvarghese | 14:f5c62d30c6fc | 455 | void sd_glcwrite(uint32_t *glc_ptr, int pid) |
nidhinvarghese | 14:f5c62d30c6fc | 456 | { |
nidhinvarghese | 14:f5c62d30c6fc | 457 | char buffer3[32]; |
nidhinvarghese | 14:f5c62d30c6fc | 458 | sprintf(buffer3, "/sd/%d_GLC.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 459 | fpbg = fopen(buffer3, "a"); |
nidhinvarghese | 14:f5c62d30c6fc | 460 | |
nidhinvarghese | 14:f5c62d30c6fc | 461 | fwrite(glc_ptr, sizeof(uint32_t), 2, fpbg); |
nidhinvarghese | 14:f5c62d30c6fc | 462 | fclose(fpbg); |
nidhinvarghese | 14:f5c62d30c6fc | 463 | |
nidhinvarghese | 14:f5c62d30c6fc | 464 | } |
nidhinvarghese | 14:f5c62d30c6fc | 465 | |
nidhinvarghese | 14:f5c62d30c6fc | 466 | // --------------------------Fuinction to write GLC data to Main file |
nidhinvarghese | 14:f5c62d30c6fc | 467 | |
nidhinvarghese | 14:f5c62d30c6fc | 468 | void glcfile_mainfile(int pid) |
nidhinvarghese | 14:f5c62d30c6fc | 469 | { |
nidhinvarghese | 14:f5c62d30c6fc | 470 | char buffer3[32]; |
nidhinvarghese | 14:f5c62d30c6fc | 471 | sprintf(buffer3, "/sd/%d.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 472 | fpmain = fopen(buffer3, "a"); // Main File is opened in Append mode |
nidhinvarghese | 14:f5c62d30c6fc | 473 | |
nidhinvarghese | 14:f5c62d30c6fc | 474 | sprintf(buffer3, "/sd/%d_GLC.csv", pid); // BG file is opened in read mode |
nidhinvarghese | 14:f5c62d30c6fc | 475 | fpbg = fopen(buffer3, "r"); |
nidhinvarghese | 14:f5c62d30c6fc | 476 | |
nidhinvarghese | 17:22a87e12fb3a | 477 | for(int i=0; i<1; i++) |
nidhinvarghese | 14:f5c62d30c6fc | 478 | { |
nidhinvarghese | 14:f5c62d30c6fc | 479 | int bigbuf[2] = {0} ; |
nidhinvarghese | 14:f5c62d30c6fc | 480 | fread(bigbuf, sizeof(int),2 , fpbg); |
nidhinvarghese | 14:f5c62d30c6fc | 481 | fwrite(bigbuf, sizeof(int), 2, fpmain); |
nidhinvarghese | 14:f5c62d30c6fc | 482 | } |
nidhinvarghese | 14:f5c62d30c6fc | 483 | fclose(fpbg); // Both files are Closed |
nidhinvarghese | 14:f5c62d30c6fc | 484 | fclose(fpmain); |
nidhinvarghese | 14:f5c62d30c6fc | 485 | |
nidhinvarghese | 14:f5c62d30c6fc | 486 | int success; |
nidhinvarghese | 14:f5c62d30c6fc | 487 | sprintf(buffer3, "/sd/%d_GLC.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 488 | success = remove(buffer3); // GLC file is deleted |
nidhinvarghese | 14:f5c62d30c6fc | 489 | } |
nidhinvarghese | 14:f5c62d30c6fc | 490 | |
nidhinvarghese | 14:f5c62d30c6fc | 491 | |
nidhinvarghese | 14:f5c62d30c6fc | 492 | void delete_subfiles(int pid) |
nidhinvarghese | 14:f5c62d30c6fc | 493 | { |
nidhinvarghese | 14:f5c62d30c6fc | 494 | char buffer3[32]; |
nidhinvarghese | 14:f5c62d30c6fc | 495 | int success1 , success2, success3; |
nidhinvarghese | 14:f5c62d30c6fc | 496 | success1 = 1 ; |
nidhinvarghese | 14:f5c62d30c6fc | 497 | sprintf(buffer3, "/sd/%d_BP.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 498 | success1 = remove(buffer3); //Removes PPG file of BP and updates status with 0 if successful |
nidhinvarghese | 14:f5c62d30c6fc | 499 | |
nidhinvarghese | 14:f5c62d30c6fc | 500 | if( success1 == 0 ) |
nidhinvarghese | 14:f5c62d30c6fc | 501 | snd.printf("\nBP file delete : Successful"); // Checks for SUCCESS |
nidhinvarghese | 14:f5c62d30c6fc | 502 | else |
nidhinvarghese | 14:f5c62d30c6fc | 503 | snd.printf("\nBP file delete : UnSuccessful"); |
nidhinvarghese | 14:f5c62d30c6fc | 504 | |
nidhinvarghese | 14:f5c62d30c6fc | 505 | success2 = 1 ; |
nidhinvarghese | 14:f5c62d30c6fc | 506 | sprintf(buffer3, "/sd/%d_GLC.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 507 | success2 = remove(buffer3); //Removes GLC file and updates status with 0 if successful |
nidhinvarghese | 14:f5c62d30c6fc | 508 | |
nidhinvarghese | 14:f5c62d30c6fc | 509 | if( success2 == 0 ) |
nidhinvarghese | 14:f5c62d30c6fc | 510 | snd.printf("\nGLC file delete : Successful"); // Checks for SUCCESS |
nidhinvarghese | 14:f5c62d30c6fc | 511 | else |
nidhinvarghese | 14:f5c62d30c6fc | 512 | snd.printf("\nGLC file delete : UnSuccessful"); |
nidhinvarghese | 14:f5c62d30c6fc | 513 | |
nidhinvarghese | 14:f5c62d30c6fc | 514 | success3 = 1 ; |
nidhinvarghese | 14:f5c62d30c6fc | 515 | sprintf(buffer3, "/sd/%d_ECG.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 516 | success3 = remove(buffer3); //Removes ECG file and updates status with 0 if successful |
nidhinvarghese | 14:f5c62d30c6fc | 517 | |
nidhinvarghese | 14:f5c62d30c6fc | 518 | if( success3 == 0 ) |
nidhinvarghese | 14:f5c62d30c6fc | 519 | snd.printf("\nECG file delete : Successful"); // Checks for SUCCESS |
nidhinvarghese | 14:f5c62d30c6fc | 520 | else |
nidhinvarghese | 14:f5c62d30c6fc | 521 | snd.printf("\nECG file delete : UnSuccessful"); |
nidhinvarghese | 14:f5c62d30c6fc | 522 | |
nidhinvarghese | 10:aeff3309002a | 523 | } |