nikita teggi
Changes done in ECG and BT
Dependencies: SDFileSystem ds3231 eeprom_Nikita mbed testUniGraphic_150217
Fork of
merged_code2_20sept_2017_4th_oct_2017
by 
nikita teggi
sdcard.cpp@56:89eb9a977641, 2017-11-03 (annotated)
- Committer:
- nikitateggi
- Date:
- Fri Nov 03 07:16:44 2017 +0000
- Revision:
- 56:89eb9a977641
- Parent:
- 53:cc6e65480a67
Changes done in ECG and BT
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 | |
| rashmivenkataramaiah | 41:1141a75eacc4 | 5 | #include "mbed.h" |
| rashmivenkataramaiah | 41:1141a75eacc4 | 6 | #include <stdio.h> |
| rashmivenkataramaiah | 41:1141a75eacc4 | 7 | #include "SDFileSystem.h" |
| rashmivenkataramaiah | 41:1141a75eacc4 | 8 | #include "sdcard.h" |
| rashmivenkataramaiah | 41:1141a75eacc4 | 9 | #include "rtc.h" |
| rashmivenkataramaiah | 41:1141a75eacc4 | 10 | #include "struct.h" |
| rashmivenkataramaiah | 41:1141a75eacc4 | 11 | #include "main.h" |
| rashmivenkataramaiah | 41:1141a75eacc4 | 12 | #include "eeprom_pgm.h" |
| nidhinvarghese | 14:f5c62d30c6fc | 13 | |
| nidhinvarghese | 14:f5c62d30c6fc | 14 | Serial snd(USBTX,USBRX); |
| nikitateggi | 24:d992ee8369f4 | 15 | SDFileSystem sd(PTE1, PTE3, PTE2, PTE4, "sd"); |
| nikitateggi | 1:8316c23ec6b9 | 16 | |
| nikitateggi | 24:d992ee8369f4 | 17 | |
| nidhinvarghese | 14:f5c62d30c6fc | 18 | |
| nidhinvarghese | 14:f5c62d30c6fc | 19 | FILE *fpecg; // PPG and ECG File pointers for BP |
| nidhinvarghese | 14:f5c62d30c6fc | 20 | FILE *fpppg; //"" "" |
| nidhinvarghese | 14:f5c62d30c6fc | 21 | |
| nidhinvarghese | 14:f5c62d30c6fc | 22 | FILE *fpmain; // FILE pointer for main file |
| nidhinvarghese | 14:f5c62d30c6fc | 23 | |
| nidhinvarghese | 14:f5c62d30c6fc | 24 | FILE *fpbg; // FILE pointer to BG file |
| nidhinvarghese | 14:f5c62d30c6fc | 25 | FILE *fpeecg; // FILE pointer to ECG file |
| nidhinvarghese | 14:f5c62d30c6fc | 26 | FILE *fpbp; // FILE pointer to BP file |
| nidhinvarghese | 14:f5c62d30c6fc | 27 | |
| nidhinvarghese | 14:f5c62d30c6fc | 28 | FILE *fp; // FILE pointer for random use |
| nidhinvarghese | 14:f5c62d30c6fc | 29 | |
| nidhinvarghese | 14:f5c62d30c6fc | 30 | //Function Added on 16/5/2017 by Nidhin |
| nikitateggi | 22:ffa88619551d | 31 | void sd_open_mainfile(int32_t pid) |
| nidhinvarghese | 14:f5c62d30c6fc | 32 | { |
| nidhinvarghese | 14:f5c62d30c6fc | 33 | char buffer1[32]; |
| nidhinvarghese | 14:f5c62d30c6fc | 34 | sprintf(buffer1,"/sd/%d.csv",pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 35 | fp = fopen(buffer1,"a"); |
| nidhinvarghese | 14:f5c62d30c6fc | 36 | } |
| nidhinvarghese | 14:f5c62d30c6fc | 37 | //------------------------------------------ |
| nidhinvarghese | 14:f5c62d30c6fc | 38 | |
| nidhinvarghese | 14:f5c62d30c6fc | 39 | |
| nidhinvarghese | 14:f5c62d30c6fc | 40 | |
| nikitateggi | 20:7c64e6ecad76 | 41 | /*void sd_open_GLCfile(int pid) // opening the glc file |
| nikitateggi | 1:8316c23ec6b9 | 42 | { |
| nikitateggi | 1:8316c23ec6b9 | 43 | |
| nikitateggi | 1:8316c23ec6b9 | 44 | char buffer[32]; |
| nikitateggi | 1:8316c23ec6b9 | 45 | char buffer1[32]; |
| nikitateggi | 1:8316c23ec6b9 | 46 | time_t epoch_time1; |
| nikitateggi | 1:8316c23ec6b9 | 47 | epoch_time1=rtc_read(); |
| nikitateggi | 1:8316c23ec6b9 | 48 | // strftime(buffer, 32, "GLC_%s", pid); |
| nikitateggi | 1:8316c23ec6b9 | 49 | |
| nikitateggi | 4:6bd81bb1790d | 50 | sprintf(buffer1,"/sd/%d_GLC.csv",pid); |
| nikitateggi | 1:8316c23ec6b9 | 51 | fp = fopen(buffer1,"a"); |
| nikitateggi | 4:6bd81bb1790d | 52 | fprintf(fp,"%s\n",ctime(&epoch_time1) ); //writing the date, time into the file |
| nikitateggi | 1:8316c23ec6b9 | 53 | |
| nikitateggi | 1:8316c23ec6b9 | 54 | |
| nikitateggi | 20:7c64e6ecad76 | 55 | } */ |
| nikitateggi | 3:9a06c2bed650 | 56 | |
| rashmivenkataramaiah | 43:85a7f399cb9d | 57 | void sd_open_GLCfilee(uint32_t pid) // only opening the glc file after entering TEST screen |
| nikitateggi | 2:3b7b71bfc941 | 58 | { |
| nikitateggi | 2:3b7b71bfc941 | 59 | char buffer1[32]; |
| nikitateggi | 4:6bd81bb1790d | 60 | sprintf(buffer1,"/sd/%d_GLC.csv",pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 61 | fpbg = fopen(buffer1,"a"); |
| nidhinvarghese | 14:f5c62d30c6fc | 62 | fclose(fpbg); |
| nidhinvarghese | 14:f5c62d30c6fc | 63 | } |
| nikitateggi | 1:8316c23ec6b9 | 64 | |
| nidhinvarghese | 14:f5c62d30c6fc | 65 | |
| rashmivenkataramaiah | 43:85a7f399cb9d | 66 | void sd_open_ECGfilee(uint32_t pid) // only opening the ECG file after entering TEST screen |
| nikitateggi | 2:3b7b71bfc941 | 67 | { |
| nikitateggi | 2:3b7b71bfc941 | 68 | |
| nikitateggi | 2:3b7b71bfc941 | 69 | char buffer1[32]; |
| nidhinvarghese | 14:f5c62d30c6fc | 70 | sprintf(buffer1,"/sd/%d_ECG.csv",pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 71 | fpeecg = fopen(buffer1,"a"); |
| nidhinvarghese | 14:f5c62d30c6fc | 72 | //fclose(fpeecg); |
| nikitateggi | 4:6bd81bb1790d | 73 | |
| nikitateggi | 2:3b7b71bfc941 | 74 | } |
| nikitateggi | 4:6bd81bb1790d | 75 | |
| nikitateggi | 4:6bd81bb1790d | 76 | |
| rashmivenkataramaiah | 43:85a7f399cb9d | 77 | void sd_open_BPfilee(uint32_t pid) // only opening the BP file after entering TEST screen |
| nikitateggi | 4:6bd81bb1790d | 78 | { |
| nikitateggi | 4:6bd81bb1790d | 79 | |
| nikitateggi | 1:8316c23ec6b9 | 80 | |
| nikitateggi | 4:6bd81bb1790d | 81 | char buffer1[32]; |
| nikitateggi | 4:6bd81bb1790d | 82 | sprintf(buffer1,"/sd/%d_BP.csv",pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 83 | fpbp = fopen(buffer1,"a"); |
| nidhinvarghese | 14:f5c62d30c6fc | 84 | //fprintf(fp,"PATIENT ID %d\n",pid ); Not required in new code as writing in hex |
| nidhinvarghese | 14:f5c62d30c6fc | 85 | fclose(fpbp); |
| nidhinvarghese | 8:adf2ba7e6412 | 86 | } |
| nidhinvarghese | 8:adf2ba7e6412 | 87 | |
| nidhinvarghese | 8:adf2ba7e6412 | 88 | void sd_write (int value) // writing data into the file |
| nidhinvarghese | 8:adf2ba7e6412 | 89 | { |
| nidhinvarghese | 8:adf2ba7e6412 | 90 | fprintf(fp,"%d\n", value); |
| nidhinvarghese | 8:adf2ba7e6412 | 91 | } |
| nidhinvarghese | 8:adf2ba7e6412 | 92 | |
| nikitateggi | 19:1650bbc923cc | 93 | |
| rashmivenkataramaiah | 43:85a7f399cb9d | 94 | uint8_t sd_open_read(uint32_t pid) // opening the file for read // CHNAGED to return value |
| nikitateggi | 19:1650bbc923cc | 95 | { |
| nikitateggi | 19:1650bbc923cc | 96 | |
| nikitateggi | 19:1650bbc923cc | 97 | char buffer1[32]; |
| nikitateggi | 19:1650bbc923cc | 98 | sprintf(buffer1,"/sd/%d.csv",pid); |
| nikitateggi | 19:1650bbc923cc | 99 | fp = fopen(buffer1,"r"); |
| nikitateggi | 19:1650bbc923cc | 100 | if (fp==NULL) |
| nikitateggi | 19:1650bbc923cc | 101 | { |
| nikitateggi | 19:1650bbc923cc | 102 | snd.printf("no"); |
| nikitateggi | 27:907f8ce0025e | 103 | return 0; |
| nikitateggi | 19:1650bbc923cc | 104 | } |
| nikitateggi | 19:1650bbc923cc | 105 | |
| nikitateggi | 19:1650bbc923cc | 106 | else |
| nikitateggi | 19:1650bbc923cc | 107 | { |
| nikitateggi | 19:1650bbc923cc | 108 | snd.printf("yes"); |
| nikitateggi | 27:907f8ce0025e | 109 | return 1; |
| nikitateggi | 19:1650bbc923cc | 110 | } |
| nikitateggi | 19:1650bbc923cc | 111 | } |
| nikitateggi | 19:1650bbc923cc | 112 | |
| nikitateggi | 46:162ed3f051b2 | 113 | void sd_read(uint32_t *v1, uint16_t size) //reading the data from the openend file |
| nikitateggi | 19:1650bbc923cc | 114 | { |
| nikitateggi | 19:1650bbc923cc | 115 | fread(v1,sizeof(v1),size,fp); |
| nikitateggi | 19:1650bbc923cc | 116 | } |
| nikitateggi | 19:1650bbc923cc | 117 | |
| nikitateggi | 19:1650bbc923cc | 118 | void setpos() |
| nikitateggi | 19:1650bbc923cc | 119 | { |
| nikitateggi | 19:1650bbc923cc | 120 | //fseek ( fp , 1 , SEEK_SET ); |
| nikitateggi | 19:1650bbc923cc | 121 | rewind (fp); |
| nikitateggi | 19:1650bbc923cc | 122 | } |
| nikitateggi | 19:1650bbc923cc | 123 | |
| nikitateggi | 19:1650bbc923cc | 124 | void setpos1(uint32_t position) |
| nikitateggi | 19:1650bbc923cc | 125 | { |
| nikitateggi | 19:1650bbc923cc | 126 | fseek ( fp , position, SEEK_SET ); |
| nikitateggi | 19:1650bbc923cc | 127 | //rewind (fp); |
| nikitateggi | 19:1650bbc923cc | 128 | } |
| nikitateggi | 19:1650bbc923cc | 129 | |
| nikitateggi | 19:1650bbc923cc | 130 | |
| nikitateggi | 46:162ed3f051b2 | 131 | uint32_t file_size() |
| nikitateggi | 19:1650bbc923cc | 132 | { |
| nikitateggi | 50:b42238e7f46d | 133 | uint32_t file_length; |
| nikitateggi | 19:1650bbc923cc | 134 | fseek (fp, 0, SEEK_END); |
| nikitateggi | 19:1650bbc923cc | 135 | file_length=ftell(fp); |
| nikitateggi | 19:1650bbc923cc | 136 | file_length=sizeof(char)*file_length; |
| nikitateggi | 19:1650bbc923cc | 137 | rewind(fp); |
| nikitateggi | 19:1650bbc923cc | 138 | return file_length; |
| nikitateggi | 19:1650bbc923cc | 139 | } |
| nikitateggi | 19:1650bbc923cc | 140 | |
| nikitateggi | 19:1650bbc923cc | 141 | |
| nikitateggi | 46:162ed3f051b2 | 142 | uint32_t file_size1() |
| nikitateggi | 19:1650bbc923cc | 143 | { |
| nikitateggi | 50:b42238e7f46d | 144 | uint32_t file_length; |
| nikitateggi | 19:1650bbc923cc | 145 | // fseek (fp, 0, SEEK_END); |
| nikitateggi | 19:1650bbc923cc | 146 | |
| nikitateggi | 19:1650bbc923cc | 147 | file_length=ftell(fp); |
| nikitateggi | 19:1650bbc923cc | 148 | // file_length=sizeof(char)*file_length; |
| nikitateggi | 19:1650bbc923cc | 149 | // rewind(fp); |
| nikitateggi | 19:1650bbc923cc | 150 | return file_length; |
| nikitateggi | 19:1650bbc923cc | 151 | } |
| nikitateggi | 19:1650bbc923cc | 152 | |
| nikitateggi | 19:1650bbc923cc | 153 | |
| nikitateggi | 19:1650bbc923cc | 154 | |
| nikitateggi | 19:1650bbc923cc | 155 | |
| nikitateggi | 19:1650bbc923cc | 156 | |
| nikitateggi | 19:1650bbc923cc | 157 | void sd_read1(BLEMsg_info &f) |
| nikitateggi | 19:1650bbc923cc | 158 | { |
| nikitateggi | 19:1650bbc923cc | 159 | fread(&f,sizeof(BLEMsg_info),1,fp); |
| nikitateggi | 19:1650bbc923cc | 160 | //fscanf(fp,"%08x",&v1); |
| nikitateggi | 19:1650bbc923cc | 161 | } |
| nikitateggi | 19:1650bbc923cc | 162 | |
| nikitateggi | 19:1650bbc923cc | 163 | |
| nikitateggi | 19:1650bbc923cc | 164 | |
| nikitateggi | 19:1650bbc923cc | 165 | |
| nikitateggi | 19:1650bbc923cc | 166 | |
| nikitateggi | 19:1650bbc923cc | 167 | |
| nikitateggi | 19:1650bbc923cc | 168 | |
| nikitateggi | 19:1650bbc923cc | 169 | |
| nikitateggi | 19:1650bbc923cc | 170 | |
| nidhinvarghese | 8:adf2ba7e6412 | 171 | //------------------------------------------------------ |
| nidhinvarghese | 8:adf2ba7e6412 | 172 | |
| nidhinvarghese | 8:adf2ba7e6412 | 173 | //FILE *sd_BP_ecgwrite (int value) // writing data into the file NIDHIN |
| avp2417 | 36:00d96aa14658 | 174 | FILE *sd_BP_ecgwrite (uint32_t *fpdrum11) // writing data into the file NIDHIN |
| nidhinvarghese | 8:adf2ba7e6412 | 175 | { |
| avp2417 | 36:00d96aa14658 | 176 | fwrite(fpdrum11,sizeof(uint32_t),1, fpecg); //Change by Nidhin 30/5/2017 Direct writing to SD card. Org Val 64 |
| nidhinvarghese | 8:adf2ba7e6412 | 177 | return fpecg; |
| nidhinvarghese | 8:adf2ba7e6412 | 178 | } |
| nidhinvarghese | 8:adf2ba7e6412 | 179 | |
| nidhinvarghese | 14:f5c62d30c6fc | 180 | FILE* sd_BP_ppgwrite (uint32_t *fpdrum21) // //Change by Nidhin 30/5/2017 Direct writing to SD card. |
| nidhinvarghese | 8:adf2ba7e6412 | 181 | { |
| nidhinvarghese | 14:f5c62d30c6fc | 182 | fwrite(fpdrum21,sizeof(uint32_t),1, fpppg); //Change by Nidhin 30/5/2017 Direct writing to SD card. OR Val 64 |
| nidhinvarghese | 8:adf2ba7e6412 | 183 | return fpppg; |
| nidhinvarghese | 8:adf2ba7e6412 | 184 | } |
| nidhinvarghese | 8:adf2ba7e6412 | 185 | //-----------------------------------------------SD Read |
| nidhinvarghese | 8:adf2ba7e6412 | 186 | |
| rashmivenkataramaiah | 43:85a7f399cb9d | 187 | void sd_reopen_BPfilee(uint32_t pid) // only opening the BP file after entering TEST screen |
| nidhinvarghese | 8:adf2ba7e6412 | 188 | { |
| nidhinvarghese | 8:adf2ba7e6412 | 189 | |
| nidhinvarghese | 8:adf2ba7e6412 | 190 | |
| nidhinvarghese | 8:adf2ba7e6412 | 191 | char buffer1[32]; |
| nidhinvarghese | 8:adf2ba7e6412 | 192 | sprintf(buffer1,"/sd/%d_BP.csv",pid); |
| nidhinvarghese | 8:adf2ba7e6412 | 193 | fp = fopen(buffer1,"r"); |
| nidhinvarghese | 8:adf2ba7e6412 | 194 | //fprintf(fp,"PATIENT ID %d\n",pid ); |
| nidhinvarghese | 8:adf2ba7e6412 | 195 | |
| nidhinvarghese | 8:adf2ba7e6412 | 196 | |
| nidhinvarghese | 8:adf2ba7e6412 | 197 | } |
| nidhinvarghese | 8:adf2ba7e6412 | 198 | //------------------------------------------------- |
| nidhinvarghese | 8:adf2ba7e6412 | 199 | |
| nidhinvarghese | 8:adf2ba7e6412 | 200 | |
| nidhinvarghese | 8:adf2ba7e6412 | 201 | //--------------------------------------- |
| nidhinvarghese | 8:adf2ba7e6412 | 202 | |
| nidhinvarghese | 8:adf2ba7e6412 | 203 | |
| rashmivenkataramaiah | 43:85a7f399cb9d | 204 | void sd_open_BP_ECGfile(uint32_t pid) |
| nidhinvarghese | 8:adf2ba7e6412 | 205 | { |
| nidhinvarghese | 8:adf2ba7e6412 | 206 | |
| nidhinvarghese | 8:adf2ba7e6412 | 207 | //char buffer[32]; |
| nidhinvarghese | 8:adf2ba7e6412 | 208 | char buffer1[32]; |
| nidhinvarghese | 8:adf2ba7e6412 | 209 | //time_t epoch_time1; |
| nidhinvarghese | 8:adf2ba7e6412 | 210 | //epoch_time1=rtc_read(); |
| nidhinvarghese | 8:adf2ba7e6412 | 211 | // strftime(buffer, 32, "ECG_%d", pid); |
| nidhinvarghese | 8:adf2ba7e6412 | 212 | |
| nidhinvarghese | 8:adf2ba7e6412 | 213 | sprintf(buffer1,"/sd/%d_BP_ECG.csv",pid); |
| nidhinvarghese | 8:adf2ba7e6412 | 214 | fpecg = fopen(buffer1,"a"); |
| nidhinvarghese | 8:adf2ba7e6412 | 215 | if (fpecg == NULL) |
| nidhinvarghese | 8:adf2ba7e6412 | 216 | { |
| nidhinvarghese | 8:adf2ba7e6412 | 217 | exit(1); |
| nidhinvarghese | 8:adf2ba7e6412 | 218 | } |
| nidhinvarghese | 8:adf2ba7e6412 | 219 | //fprintf(fpecg,"%s\n",ctime(&epoch_time1) ); |
| nidhinvarghese | 8:adf2ba7e6412 | 220 | |
| nidhinvarghese | 8:adf2ba7e6412 | 221 | } |
| nidhinvarghese | 8:adf2ba7e6412 | 222 | |
| nidhinvarghese | 8:adf2ba7e6412 | 223 | |
| rashmivenkataramaiah | 43:85a7f399cb9d | 224 | void sd_open_BP_PPGfile(uint32_t pid) |
| nidhinvarghese | 8:adf2ba7e6412 | 225 | { |
| nidhinvarghese | 8:adf2ba7e6412 | 226 | |
| nidhinvarghese | 8:adf2ba7e6412 | 227 | char buffer1[32]; |
| nidhinvarghese | 8:adf2ba7e6412 | 228 | //time_t epoch_time1; |
| nidhinvarghese | 8:adf2ba7e6412 | 229 | //epoch_time1=rtc_read(); |
| nidhinvarghese | 8:adf2ba7e6412 | 230 | // strftime(buffer, 32, "ECG_%d", pid); |
| nidhinvarghese | 8:adf2ba7e6412 | 231 | |
| nidhinvarghese | 8:adf2ba7e6412 | 232 | sprintf(buffer1,"/sd/%d_BP_PPG.csv",pid); |
| nidhinvarghese | 8:adf2ba7e6412 | 233 | fpppg = fopen(buffer1,"a"); |
| nidhinvarghese | 8:adf2ba7e6412 | 234 | if(fpppg == NULL) |
| nidhinvarghese | 8:adf2ba7e6412 | 235 | { |
| nidhinvarghese | 8:adf2ba7e6412 | 236 | exit(1); |
| nidhinvarghese | 8:adf2ba7e6412 | 237 | } |
| nidhinvarghese | 8:adf2ba7e6412 | 238 | |
| nidhinvarghese | 8:adf2ba7e6412 | 239 | //fprintf(fpppg,"%s\n",ctime(&epoch_time1) ); |
| nidhinvarghese | 8:adf2ba7e6412 | 240 | |
| nidhinvarghese | 8:adf2ba7e6412 | 241 | } |
| nidhinvarghese | 8:adf2ba7e6412 | 242 | |
| nidhinvarghese | 8:adf2ba7e6412 | 243 | |
| nidhinvarghese | 8:adf2ba7e6412 | 244 | |
| nidhinvarghese | 8:adf2ba7e6412 | 245 | //-------------------------------------------------- |
| nidhinvarghese | 8:adf2ba7e6412 | 246 | |
| nidhinvarghese | 14:f5c62d30c6fc | 247 | //FUNCTIONS TO CLOSE FILES |
| nidhinvarghese | 14:f5c62d30c6fc | 248 | //__________________________________________________ |
| nidhinvarghese | 14:f5c62d30c6fc | 249 | void sd_close() //close the file with fp |
| nidhinvarghese | 8:adf2ba7e6412 | 250 | { |
| nikitateggi | 1:8316c23ec6b9 | 251 | |
| nidhinvarghese | 8:adf2ba7e6412 | 252 | fclose(fp); |
| nidhinvarghese | 8:adf2ba7e6412 | 253 | } |
| nidhinvarghese | 14:f5c62d30c6fc | 254 | //______________________________________________________ |
| nidhinvarghese | 14:f5c62d30c6fc | 255 | void sd_close_ecg() // Closes ECG file pinted by fpeecg |
| nidhinvarghese | 14:f5c62d30c6fc | 256 | { |
| nidhinvarghese | 14:f5c62d30c6fc | 257 | |
| nidhinvarghese | 14:f5c62d30c6fc | 258 | fclose(fpeecg); |
| nidhinvarghese | 14:f5c62d30c6fc | 259 | } |
| nidhinvarghese | 14:f5c62d30c6fc | 260 | //______________________________________________________ |
| nidhinvarghese | 14:f5c62d30c6fc | 261 | void sd_close_glc() // Closes GLC file pinted by fpbg |
| nidhinvarghese | 14:f5c62d30c6fc | 262 | { |
| nidhinvarghese | 14:f5c62d30c6fc | 263 | |
| nidhinvarghese | 14:f5c62d30c6fc | 264 | fclose(fpbg); |
| nidhinvarghese | 14:f5c62d30c6fc | 265 | } |
| nidhinvarghese | 14:f5c62d30c6fc | 266 | //_____________________________________________________ |
| nidhinvarghese | 14:f5c62d30c6fc | 267 | |
| nidhinvarghese | 14:f5c62d30c6fc | 268 | |
| nidhinvarghese | 14:f5c62d30c6fc | 269 | |
| nidhinvarghese | 14:f5c62d30c6fc | 270 | |
| nidhinvarghese | 14:f5c62d30c6fc | 271 | |
| nidhinvarghese | 14:f5c62d30c6fc | 272 | |
| nidhinvarghese | 8:adf2ba7e6412 | 273 | //fread(buffer, 1, size, fp) |
| nidhinvarghese | 8:adf2ba7e6412 | 274 | //fwrite(&buffer, , |
| nidhinvarghese | 10:aeff3309002a | 275 | //----------------------------------------------------28/4/2017--------------------------------- |
| nidhinvarghese | 10:aeff3309002a | 276 | //---------------------------------------------------------------------------------------------- |
| nidhinvarghese | 10:aeff3309002a | 277 | |
| nidhinvarghese | 10:aeff3309002a | 278 | |
| nidhinvarghese | 10:aeff3309002a | 279 | |
| nidhinvarghese | 10:aeff3309002a | 280 | //------- FUNCTION TO CREATE SINGLE BP FILE --------2/5/2017 (NIDHIN)---------------// |
| rashmivenkataramaiah | 43:85a7f399cb9d | 281 | void create_single_BPfile(uint32_t pid) |
| nidhinvarghese | 10:aeff3309002a | 282 | { |
| nidhinvarghese | 10:aeff3309002a | 283 | |
| nidhinvarghese | 10:aeff3309002a | 284 | //int ecgbuf[64] = {0}; |
| nidhinvarghese | 10:aeff3309002a | 285 | //uint32_t ppgbuf[64] = {0}; |
| nidhinvarghese | 10:aeff3309002a | 286 | |
| nidhinvarghese | 10:aeff3309002a | 287 | char buffer3[32]; |
| nidhinvarghese | 10:aeff3309002a | 288 | sprintf(buffer3, "/sd/%d_BP.csv", pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 289 | fpbp = fopen(buffer3, "a"); // Opens BP file with FILE pointer fpbp in APPEND mode |
| nidhinvarghese | 10:aeff3309002a | 290 | |
| nidhinvarghese | 10:aeff3309002a | 291 | //buffer1[32] = ""; |
| nidhinvarghese | 14:f5c62d30c6fc | 292 | sprintf(buffer3, "/sd/%d_BP_ECG.csv", pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 293 | fpecg = fopen(buffer3, "r"); // Opens ECG file of BP with FILE pointer fpecg in READ mode |
| nidhinvarghese | 10:aeff3309002a | 294 | |
| nidhinvarghese | 10:aeff3309002a | 295 | //char buffer1[32] = ""; |
| nidhinvarghese | 10:aeff3309002a | 296 | sprintf(buffer3, "/sd/%d_BP_PPG.csv", pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 297 | fpppg = fopen(buffer3, "r"); // Opens PPG file of BP with FILE pointer fpppg in READ mode |
| nidhinvarghese | 10:aeff3309002a | 298 | |
| nidhinvarghese | 10:aeff3309002a | 299 | for(int i=0; i<16; i++) |
| nidhinvarghese | 10:aeff3309002a | 300 | { |
| nidhinvarghese | 10:aeff3309002a | 301 | int ecgbuf[64] = {0} ; |
| nidhinvarghese | 14:f5c62d30c6fc | 302 | fread(ecgbuf, sizeof(uint32_t), 64, fpecg); |
| nidhinvarghese | 14:f5c62d30c6fc | 303 | fwrite(ecgbuf, sizeof(uint32_t), 64, fpbp); // Copy ECG data of BP into BP file |
| nidhinvarghese | 10:aeff3309002a | 304 | } |
| nidhinvarghese | 10:aeff3309002a | 305 | |
| nidhinvarghese | 10:aeff3309002a | 306 | for(int i=0; i<26; i++) |
| nidhinvarghese | 10:aeff3309002a | 307 | { |
| nidhinvarghese | 10:aeff3309002a | 308 | int ppgbuf[64] = {0} ; |
| nidhinvarghese | 14:f5c62d30c6fc | 309 | fread(ppgbuf, sizeof(uint32_t), 64, fpppg); |
| nidhinvarghese | 14:f5c62d30c6fc | 310 | fwrite(ppgbuf, sizeof(uint32_t), 64, fpbp); // Copy PPG data of BP into BP file |
| nidhinvarghese | 10:aeff3309002a | 311 | } |
| nidhinvarghese | 10:aeff3309002a | 312 | |
| nidhinvarghese | 14:f5c62d30c6fc | 313 | fclose(fpecg); // Closes the ECG file of BP |
| nidhinvarghese | 14:f5c62d30c6fc | 314 | fclose(fpppg); // Closes the PPG file of BP |
| nidhinvarghese | 14:f5c62d30c6fc | 315 | fclose(fpbp); // Closes the BP file |
| nidhinvarghese | 10:aeff3309002a | 316 | |
| nidhinvarghese | 10:aeff3309002a | 317 | //char buffer1[32] = ""; |
| nidhinvarghese | 14:f5c62d30c6fc | 318 | int status = 1 ; |
| nidhinvarghese | 10:aeff3309002a | 319 | sprintf(buffer3, "/sd/%d_BP_ECG.csv", pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 320 | status = remove(buffer3); //Removes ECG file of BP and updates status with 0 if successful |
| nidhinvarghese | 11:9a6545c2eb5d | 321 | |
| nidhinvarghese | 11:9a6545c2eb5d | 322 | |
| nidhinvarghese | 10:aeff3309002a | 323 | if( status == 0 ) |
| nidhinvarghese | 14:f5c62d30c6fc | 324 | snd.printf("\nECG file delete : Successful"); // Checks for SUCCESS |
| nidhinvarghese | 10:aeff3309002a | 325 | else |
| nidhinvarghese | 10:aeff3309002a | 326 | snd.printf("\nECG file delete : UnSuccessful"); |
| nidhinvarghese | 11:9a6545c2eb5d | 327 | |
| nidhinvarghese | 11:9a6545c2eb5d | 328 | |
| nidhinvarghese | 10:aeff3309002a | 329 | //char buffer1[32] = ""; |
| nidhinvarghese | 14:f5c62d30c6fc | 330 | status = 1 ; |
| nidhinvarghese | 10:aeff3309002a | 331 | sprintf(buffer3, "/sd/%d_BP_PPG.csv", pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 332 | status = remove(buffer3); //Removes PPG file of BP and updates status with 0 if successful |
| nidhinvarghese | 11:9a6545c2eb5d | 333 | |
| nidhinvarghese | 10:aeff3309002a | 334 | if( status == 0 ) |
| nidhinvarghese | 14:f5c62d30c6fc | 335 | snd.printf("\nPPG file delete : Successful"); // Checks for SUCCESS |
| nidhinvarghese | 10:aeff3309002a | 336 | else |
| nidhinvarghese | 10:aeff3309002a | 337 | snd.printf("\nPPG file delete : UnSuccessful"); |
| nidhinvarghese | 11:9a6545c2eb5d | 338 | |
| nidhinvarghese | 14:f5c62d30c6fc | 339 | } |
| nidhinvarghese | 14:f5c62d30c6fc | 340 | |
| avp2417 | 36:00d96aa14658 | 341 | |
| avp2417 | 36:00d96aa14658 | 342 | |
| nidhinvarghese | 14:f5c62d30c6fc | 343 | //Creating strcuture file Common to All Functions |
| rashmivenkataramaiah | 43:85a7f399cb9d | 344 | void structure_file(BLEMsg_info *ptr, uint32_t pid) |
| nidhinvarghese | 14:f5c62d30c6fc | 345 | { |
| rashmivenkataramaiah | 41:1141a75eacc4 | 346 | char buffer3[32]; |
| rashmivenkataramaiah | 41:1141a75eacc4 | 347 | sprintf(buffer3, "/sd/%d.csv", pid); //Printing file path to the buffer |
| rashmivenkataramaiah | 42:c81673b04b6a | 348 | if(get_filecreated_status() == true) //if file created open in append mode |
| rashmivenkataramaiah | 41:1141a75eacc4 | 349 | { |
| rashmivenkataramaiah | 41:1141a75eacc4 | 350 | fpmain = fopen(buffer3, "a"); // open the file PID.csv with FILE pointer fpmain |
| rashmivenkataramaiah | 41:1141a75eacc4 | 351 | snd.printf("\n Append mode\n"); |
| rashmivenkataramaiah | 41:1141a75eacc4 | 352 | } |
| rashmivenkataramaiah | 41:1141a75eacc4 | 353 | else //if file not created, open in write mode |
| rashmivenkataramaiah | 41:1141a75eacc4 | 354 | { |
| rashmivenkataramaiah | 41:1141a75eacc4 | 355 | fpmain = fopen(buffer3, "w"); // open the file PID.csv with FILE pointer fpmain |
| rashmivenkataramaiah | 41:1141a75eacc4 | 356 | snd.printf("\n Write mode\n"); |
| rashmivenkataramaiah | 41:1141a75eacc4 | 357 | } |
| rashmivenkataramaiah | 41:1141a75eacc4 | 358 | |
| nidhinvarghese | 14:f5c62d30c6fc | 359 | fwrite(ptr, sizeof(uint8_t),26, fpmain ); // writing the Structure into the file |
| nidhinvarghese | 14:f5c62d30c6fc | 360 | fclose(fpmain); // Close File |
| nidhinvarghese | 14:f5c62d30c6fc | 361 | } |
| nidhinvarghese | 14:f5c62d30c6fc | 362 | |
| nidhinvarghese | 14:f5c62d30c6fc | 363 | //Copy Data into file. |
| nidhinvarghese | 14:f5c62d30c6fc | 364 | |
| rashmivenkataramaiah | 43:85a7f399cb9d | 365 | void bpfile_mainfile(uint32_t pid) //Copy data of bp file to main |
| nidhinvarghese | 14:f5c62d30c6fc | 366 | { |
| nidhinvarghese | 14:f5c62d30c6fc | 367 | char buffer3[32]; |
| nidhinvarghese | 14:f5c62d30c6fc | 368 | sprintf(buffer3, "/sd/%d.csv", pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 369 | fpmain = fopen(buffer3, "a"); // Opens Main file with FILE pointer "fpmain" in APPEND mode |
| nidhinvarghese | 14:f5c62d30c6fc | 370 | |
| nidhinvarghese | 14:f5c62d30c6fc | 371 | sprintf(buffer3, "/sd/%d_BP.csv", pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 372 | fpbp = fopen(buffer3, "r"); // Opens BP file with FILE pointer "fpbp" in READ mode |
| nidhinvarghese | 14:f5c62d30c6fc | 373 | |
| nidhinvarghese | 14:f5c62d30c6fc | 374 | |
| nidhinvarghese | 14:f5c62d30c6fc | 375 | for(int i=0; i<21; i++) |
| nidhinvarghese | 14:f5c62d30c6fc | 376 | { |
| nidhinvarghese | 14:f5c62d30c6fc | 377 | int bigbuf[128] = {0} ; |
| nidhinvarghese | 14:f5c62d30c6fc | 378 | fread(bigbuf, sizeof(uint32_t), 128, fpbp); |
| nidhinvarghese | 14:f5c62d30c6fc | 379 | fwrite(bigbuf, sizeof(uint32_t), 128, fpmain); // Copy BP raw data into main file |
| nidhinvarghese | 14:f5c62d30c6fc | 380 | } |
| nidhinvarghese | 14:f5c62d30c6fc | 381 | fclose(fpbp); // Close BP file |
| nidhinvarghese | 14:f5c62d30c6fc | 382 | fclose(fpmain); // Close Main File |
| nidhinvarghese | 14:f5c62d30c6fc | 383 | |
| nidhinvarghese | 14:f5c62d30c6fc | 384 | int success; |
| nidhinvarghese | 14:f5c62d30c6fc | 385 | sprintf(buffer3, "/sd/%d_BP.csv", pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 386 | success = remove(buffer3); // Should return zero on success |
| nidhinvarghese | 14:f5c62d30c6fc | 387 | } |
| nidhinvarghese | 14:f5c62d30c6fc | 388 | |
| nidhinvarghese | 14:f5c62d30c6fc | 389 | //------------New function added to print ECG data to Sd card using fwrite |
| suhasini | 26:53ff13a164f3 | 390 | void sd_ecgwrite(uint32_t *ecg_ptr) |
| nidhinvarghese | 14:f5c62d30c6fc | 391 | { |
| nidhinvarghese | 14:f5c62d30c6fc | 392 | fwrite(ecg_ptr, sizeof(int), 1, fpeecg); |
| nidhinvarghese | 14:f5c62d30c6fc | 393 | } |
| nidhinvarghese | 14:f5c62d30c6fc | 394 | |
| nidhinvarghese | 14:f5c62d30c6fc | 395 | |
| nidhinvarghese | 14:f5c62d30c6fc | 396 | //------------ Function to write ECG data to main file |
| rashmivenkataramaiah | 43:85a7f399cb9d | 397 | void ecgfile_mainfile(uint32_t pid) |
| nidhinvarghese | 14:f5c62d30c6fc | 398 | { |
| nidhinvarghese | 14:f5c62d30c6fc | 399 | char buffer3[32]; |
| nidhinvarghese | 14:f5c62d30c6fc | 400 | sprintf(buffer3, "/sd/%d.csv", pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 401 | fpmain = fopen(buffer3, "a"); // Main File is opened in Append mode |
| suhasini | 26:53ff13a164f3 | 402 | snd.printf("opening main file\n"); |
| nidhinvarghese | 14:f5c62d30c6fc | 403 | sprintf(buffer3, "/sd/%d_ECG.csv", pid); // ECG file is opened in read mode |
| nidhinvarghese | 14:f5c62d30c6fc | 404 | fpeecg = fopen(buffer3, "r"); |
| suhasini | 26:53ff13a164f3 | 405 | snd.printf("opening temp file\n"); |
| suhasini | 26:53ff13a164f3 | 406 | for(int i=0; i<20; i++) //the loop runs as 20 times of 100 i.e., 2k |
| nidhinvarghese | 14:f5c62d30c6fc | 407 | { |
| nidhinvarghese | 14:f5c62d30c6fc | 408 | int bigbuf[100] = {0} ; |
| nidhinvarghese | 14:f5c62d30c6fc | 409 | fread(bigbuf, sizeof(int),100 , fpeecg); |
| nidhinvarghese | 14:f5c62d30c6fc | 410 | fwrite(bigbuf, sizeof(int), 100, fpmain); |
| nidhinvarghese | 14:f5c62d30c6fc | 411 | } |
| suhasini | 26:53ff13a164f3 | 412 | snd.printf("to close temp file\n"); |
| nidhinvarghese | 14:f5c62d30c6fc | 413 | fclose(fpeecg); // Both files are Closed |
| suhasini | 26:53ff13a164f3 | 414 | snd.printf("to come out of main file\n"); |
| nidhinvarghese | 14:f5c62d30c6fc | 415 | fclose(fpmain); |
| nidhinvarghese | 14:f5c62d30c6fc | 416 | |
| suhasini | 26:53ff13a164f3 | 417 | snd.printf("COPY complete Files Closed\n"); |
| suhasini | 26:53ff13a164f3 | 418 | |
| nidhinvarghese | 14:f5c62d30c6fc | 419 | sprintf(buffer3, "/sd/%d_ECG.csv", pid); // ECG file is opened in write mode to empty the file |
| suhasini | 26:53ff13a164f3 | 420 | fpeecg = fopen(buffer3, "r"); |
| suhasini | 26:53ff13a164f3 | 421 | fclose(fpeecg); |
| suhasini | 26:53ff13a164f3 | 422 | // File is closed |
| nidhinvarghese | 14:f5c62d30c6fc | 423 | int success; |
| nidhinvarghese | 14:f5c62d30c6fc | 424 | sprintf(buffer3, "/sd/%d_ECG.csv", pid); |
| suhasini | 26:53ff13a164f3 | 425 | success = remove(buffer3); |
| suhasini | 26:53ff13a164f3 | 426 | snd.printf("DELETE STATUS = %d\n", success); |
| nikitateggi | 49:3ff80c4bc1be | 427 | success = 1; |
| nikitateggi | 49:3ff80c4bc1be | 428 | sprintf(buffer3, "/sd/%d_ECG_lpf.csv", pid); |
| nikitateggi | 49:3ff80c4bc1be | 429 | success = remove(buffer3); |
| nikitateggi | 49:3ff80c4bc1be | 430 | snd.printf("DELETE STATUS = %d\n", success); |
| nidhinvarghese | 14:f5c62d30c6fc | 431 | } |
| nidhinvarghese | 14:f5c62d30c6fc | 432 | |
| nidhinvarghese | 14:f5c62d30c6fc | 433 | |
| nidhinvarghese | 14:f5c62d30c6fc | 434 | //---------------------- Function to write GLC data to GLC file |
| rashmivenkataramaiah | 43:85a7f399cb9d | 435 | void sd_glcwrite(uint32_t *glc_ptr, uint32_t pid) |
| nidhinvarghese | 14:f5c62d30c6fc | 436 | { |
| nidhinvarghese | 14:f5c62d30c6fc | 437 | char buffer3[32]; |
| nidhinvarghese | 14:f5c62d30c6fc | 438 | sprintf(buffer3, "/sd/%d_GLC.csv", pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 439 | fpbg = fopen(buffer3, "a"); |
| nidhinvarghese | 14:f5c62d30c6fc | 440 | |
| nidhinvarghese | 14:f5c62d30c6fc | 441 | fwrite(glc_ptr, sizeof(uint32_t), 2, fpbg); |
| nidhinvarghese | 14:f5c62d30c6fc | 442 | fclose(fpbg); |
| nidhinvarghese | 14:f5c62d30c6fc | 443 | |
| nidhinvarghese | 14:f5c62d30c6fc | 444 | } |
| nidhinvarghese | 14:f5c62d30c6fc | 445 | |
| nidhinvarghese | 14:f5c62d30c6fc | 446 | // --------------------------Fuinction to write GLC data to Main file |
| nidhinvarghese | 14:f5c62d30c6fc | 447 | |
| rashmivenkataramaiah | 43:85a7f399cb9d | 448 | void glcfile_mainfile(uint32_t pid) |
| nidhinvarghese | 14:f5c62d30c6fc | 449 | { |
| nidhinvarghese | 14:f5c62d30c6fc | 450 | char buffer3[32]; |
| nidhinvarghese | 14:f5c62d30c6fc | 451 | sprintf(buffer3, "/sd/%d.csv", pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 452 | fpmain = fopen(buffer3, "a"); // Main File is opened in Append mode |
| nidhinvarghese | 14:f5c62d30c6fc | 453 | |
| nidhinvarghese | 14:f5c62d30c6fc | 454 | sprintf(buffer3, "/sd/%d_GLC.csv", pid); // BG file is opened in read mode |
| nidhinvarghese | 14:f5c62d30c6fc | 455 | fpbg = fopen(buffer3, "r"); |
| nidhinvarghese | 14:f5c62d30c6fc | 456 | |
| nidhinvarghese | 17:22a87e12fb3a | 457 | for(int i=0; i<1; i++) |
| nidhinvarghese | 14:f5c62d30c6fc | 458 | { |
| nidhinvarghese | 14:f5c62d30c6fc | 459 | int bigbuf[2] = {0} ; |
| nidhinvarghese | 14:f5c62d30c6fc | 460 | fread(bigbuf, sizeof(int),2 , fpbg); |
| nidhinvarghese | 14:f5c62d30c6fc | 461 | fwrite(bigbuf, sizeof(int), 2, fpmain); |
| nidhinvarghese | 14:f5c62d30c6fc | 462 | } |
| nidhinvarghese | 14:f5c62d30c6fc | 463 | fclose(fpbg); // Both files are Closed |
| nidhinvarghese | 14:f5c62d30c6fc | 464 | fclose(fpmain); |
| nidhinvarghese | 14:f5c62d30c6fc | 465 | |
| nidhinvarghese | 14:f5c62d30c6fc | 466 | int success; |
| nidhinvarghese | 14:f5c62d30c6fc | 467 | sprintf(buffer3, "/sd/%d_GLC.csv", pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 468 | success = remove(buffer3); // GLC file is deleted |
| nidhinvarghese | 14:f5c62d30c6fc | 469 | } |
| nidhinvarghese | 14:f5c62d30c6fc | 470 | |
| nidhinvarghese | 14:f5c62d30c6fc | 471 | |
| rashmivenkataramaiah | 43:85a7f399cb9d | 472 | void delete_subfiles(uint32_t pid) |
| nidhinvarghese | 14:f5c62d30c6fc | 473 | { |
| nidhinvarghese | 14:f5c62d30c6fc | 474 | char buffer3[32]; |
| nidhinvarghese | 14:f5c62d30c6fc | 475 | int success1 , success2, success3; |
| nidhinvarghese | 14:f5c62d30c6fc | 476 | success1 = 1 ; |
| nidhinvarghese | 14:f5c62d30c6fc | 477 | sprintf(buffer3, "/sd/%d_BP.csv", pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 478 | success1 = remove(buffer3); //Removes PPG file of BP and updates status with 0 if successful |
| nidhinvarghese | 14:f5c62d30c6fc | 479 | |
| nidhinvarghese | 14:f5c62d30c6fc | 480 | if( success1 == 0 ) |
| nidhinvarghese | 14:f5c62d30c6fc | 481 | snd.printf("\nBP file delete : Successful"); // Checks for SUCCESS |
| nidhinvarghese | 14:f5c62d30c6fc | 482 | else |
| nidhinvarghese | 14:f5c62d30c6fc | 483 | snd.printf("\nBP file delete : UnSuccessful"); |
| nidhinvarghese | 14:f5c62d30c6fc | 484 | |
| nidhinvarghese | 14:f5c62d30c6fc | 485 | success2 = 1 ; |
| nidhinvarghese | 14:f5c62d30c6fc | 486 | sprintf(buffer3, "/sd/%d_GLC.csv", pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 487 | success2 = remove(buffer3); //Removes GLC file and updates status with 0 if successful |
| nidhinvarghese | 14:f5c62d30c6fc | 488 | |
| nidhinvarghese | 14:f5c62d30c6fc | 489 | if( success2 == 0 ) |
| nidhinvarghese | 14:f5c62d30c6fc | 490 | snd.printf("\nGLC file delete : Successful"); // Checks for SUCCESS |
| nidhinvarghese | 14:f5c62d30c6fc | 491 | else |
| nidhinvarghese | 14:f5c62d30c6fc | 492 | snd.printf("\nGLC file delete : UnSuccessful"); |
| nidhinvarghese | 14:f5c62d30c6fc | 493 | |
| nidhinvarghese | 14:f5c62d30c6fc | 494 | success3 = 1 ; |
| nidhinvarghese | 14:f5c62d30c6fc | 495 | sprintf(buffer3, "/sd/%d_ECG.csv", pid); |
| nidhinvarghese | 14:f5c62d30c6fc | 496 | success3 = remove(buffer3); //Removes ECG file and updates status with 0 if successful |
| nidhinvarghese | 14:f5c62d30c6fc | 497 | |
| nidhinvarghese | 14:f5c62d30c6fc | 498 | if( success3 == 0 ) |
| nidhinvarghese | 14:f5c62d30c6fc | 499 | snd.printf("\nECG file delete : Successful"); // Checks for SUCCESS |
| nidhinvarghese | 14:f5c62d30c6fc | 500 | else |
| nidhinvarghese | 14:f5c62d30c6fc | 501 | snd.printf("\nECG file delete : UnSuccessful"); |
| nikitateggi | 49:3ff80c4bc1be | 502 | |
| nikitateggi | 49:3ff80c4bc1be | 503 | success3 = 1; |
| nikitateggi | 49:3ff80c4bc1be | 504 | sprintf(buffer3, "/sd/%d_ECG_lpf.csv", pid); |
| nikitateggi | 49:3ff80c4bc1be | 505 | success3 = remove(buffer3); |
| nikitateggi | 49:3ff80c4bc1be | 506 | snd.printf("DELETE STATUS = %d\n", success3); |
| nikitateggi | 49:3ff80c4bc1be | 507 | |
| nikitateggi | 49:3ff80c4bc1be | 508 | if( success3 == 0 ) |
| nikitateggi | 49:3ff80c4bc1be | 509 | snd.printf("\nECG_lpf file delete : Successful"); // Checks for SUCCESS |
| nikitateggi | 49:3ff80c4bc1be | 510 | else |
| nikitateggi | 49:3ff80c4bc1be | 511 | snd.printf("\nECG_lpf file delete : UnSuccessful"); |
| nidhinvarghese | 14:f5c62d30c6fc | 512 | |
| nikitateggi | 22:ffa88619551d | 513 | } |
| nikitateggi | 22:ffa88619551d | 514 | |
| nikitateggi | 22:ffa88619551d | 515 | |
| rashmivenkataramaiah | 43:85a7f399cb9d | 516 | void del_ppg_ecg_BPfile(uint32_t pid) |
| avp2417 | 36:00d96aa14658 | 517 | { |
| avp2417 | 36:00d96aa14658 | 518 | int status = 1 ; |
| avp2417 | 36:00d96aa14658 | 519 | char buffer3[32]; |
| avp2417 | 36:00d96aa14658 | 520 | sprintf(buffer3, "/sd/%d_BP_ECG.csv", pid); |
| avp2417 | 36:00d96aa14658 | 521 | status = remove(buffer3); //Removes ECG file of BP and updates status with 0 if successful |
| avp2417 | 36:00d96aa14658 | 522 | |
| avp2417 | 36:00d96aa14658 | 523 | if( status == 0 ) |
| avp2417 | 36:00d96aa14658 | 524 | snd.printf("\n temp ECG file delete for error condition: Successful"); // Checks for SUCCESS |
| avp2417 | 36:00d96aa14658 | 525 | else |
| avp2417 | 36:00d96aa14658 | 526 | snd.printf("\n temp ECG file delete for error condition: UnSuccessful"); |
| avp2417 | 36:00d96aa14658 | 527 | |
| avp2417 | 36:00d96aa14658 | 528 | |
| avp2417 | 36:00d96aa14658 | 529 | //char buffer1[32] = ""; |
| avp2417 | 36:00d96aa14658 | 530 | status = 1 ; |
| avp2417 | 36:00d96aa14658 | 531 | sprintf(buffer3, "/sd/%d_BP_PPG.csv", pid); |
| avp2417 | 36:00d96aa14658 | 532 | status = remove(buffer3); //Removes PPG file of BP and updates status with 0 if successful |
| avp2417 | 36:00d96aa14658 | 533 | |
| avp2417 | 36:00d96aa14658 | 534 | if( status == 0 ) |
| avp2417 | 36:00d96aa14658 | 535 | snd.printf("\n temp PPG file delete for error condition: Successful"); // Checks for SUCCESS |
| avp2417 | 36:00d96aa14658 | 536 | else |
| avp2417 | 36:00d96aa14658 | 537 | snd.printf("\n temp PPG file delete for error condition: UnSuccessful"); |
| avp2417 | 36:00d96aa14658 | 538 | |
| rashmivenkataramaiah | 41:1141a75eacc4 | 539 | } |
| rashmivenkataramaiah | 41:1141a75eacc4 | 540 | |
| rashmivenkataramaiah | 41:1141a75eacc4 | 541 | void sd_read(uint32_t *pid_btpid) //reading the data from the openend file |
| rashmivenkataramaiah | 41:1141a75eacc4 | 542 | { |
| rashmivenkataramaiah | 42:c81673b04b6a | 543 | FILE *fp; |
| nikitateggi | 53:cc6e65480a67 | 544 | uint32_t pid[2]={0,0}; |
| rashmivenkataramaiah | 41:1141a75eacc4 | 545 | fp= fopen("/sd/pid_info.txt","r"); |
| rashmivenkataramaiah | 41:1141a75eacc4 | 546 | if (fp==NULL) |
| rashmivenkataramaiah | 41:1141a75eacc4 | 547 | { |
| rashmivenkataramaiah | 42:c81673b04b6a | 548 | fp= fopen("/sd/pid_info.txt","w"); |
| rashmivenkataramaiah | 42:c81673b04b6a | 549 | fwrite(&pid, sizeof(uint32_t),2,fp); |
| rashmivenkataramaiah | 42:c81673b04b6a | 550 | fclose(fp); |
| rashmivenkataramaiah | 41:1141a75eacc4 | 551 | fp= fopen("/sd/pid_info.txt","r"); |
| rashmivenkataramaiah | 41:1141a75eacc4 | 552 | } |
| rashmivenkataramaiah | 41:1141a75eacc4 | 553 | |
| rashmivenkataramaiah | 41:1141a75eacc4 | 554 | fread(pid_btpid,sizeof(pid_btpid),2,fp); |
| rashmivenkataramaiah | 41:1141a75eacc4 | 555 | fclose(fp); |
| rashmivenkataramaiah | 41:1141a75eacc4 | 556 | |
| rashmivenkataramaiah | 41:1141a75eacc4 | 557 | } |
| rashmivenkataramaiah | 41:1141a75eacc4 | 558 | |
| rashmivenkataramaiah | 41:1141a75eacc4 | 559 | |
| rashmivenkataramaiah | 41:1141a75eacc4 | 560 | void sd_write(uint32_t *pid_btpid) //reading the data from the openend file |
| rashmivenkataramaiah | 41:1141a75eacc4 | 561 | { |
| rashmivenkataramaiah | 41:1141a75eacc4 | 562 | FILE *fp; |
| rashmivenkataramaiah | 41:1141a75eacc4 | 563 | fp= fopen("/sd/pid_info.txt","w"); |
| rashmivenkataramaiah | 41:1141a75eacc4 | 564 | fwrite(pid_btpid,sizeof(pid_btpid),2,fp); |
| rashmivenkataramaiah | 41:1141a75eacc4 | 565 | fclose(fp); |
| rashmivenkataramaiah | 41:1141a75eacc4 | 566 | |
| rashmivenkataramaiah | 41:1141a75eacc4 | 567 | } |
| rashmivenkataramaiah | 41:1141a75eacc4 | 568 | |
| nikitateggi | 49:3ff80c4bc1be | 569 | void delete_sdcard(void) |
| nikitateggi | 49:3ff80c4bc1be | 570 | { |
| nikitateggi | 49:3ff80c4bc1be | 571 | FILE *fp; |
| nikitateggi | 53:cc6e65480a67 | 572 | uint32_t pid[2] = {0,0}; |
| nikitateggi | 49:3ff80c4bc1be | 573 | fp= fopen("/sd/pid_info.txt","w"); |
| nikitateggi | 49:3ff80c4bc1be | 574 | fwrite(&pid, sizeof(uint32_t),2,fp); |
| nikitateggi | 49:3ff80c4bc1be | 575 | fclose(fp); |
| nikitateggi | 49:3ff80c4bc1be | 576 | |
| nikitateggi | 49:3ff80c4bc1be | 577 | } |
| nikitateggi | 49:3ff80c4bc1be | 578 | |
| nikitateggi | 49:3ff80c4bc1be | 579 | |
| nikitateggi | 49:3ff80c4bc1be | 580 | /*void read_sdcard_file() |
| nikitateggi | 49:3ff80c4bc1be | 581 | { |
| nikitateggi | 49:3ff80c4bc1be | 582 | uint32_t pid=0; |
| nikitateggi | 49:3ff80c4bc1be | 583 | snd.printf("Enter the PID number......!!\n"); |
| nikitateggi | 49:3ff80c4bc1be | 584 | snd.scanf("%d", &pid); |
| nikitateggi | 49:3ff80c4bc1be | 585 | snd.printf("%d\n",pid); |
| nikitateggi | 49:3ff80c4bc1be | 586 | readfile(pid); |
| nikitateggi | 49:3ff80c4bc1be | 587 | snd.printf("Finished reading\n"); |
| nikitateggi | 49:3ff80c4bc1be | 588 | |
| nikitateggi | 49:3ff80c4bc1be | 589 | }*/ |
| nikitateggi | 49:3ff80c4bc1be | 590 | |
| nikitateggi | 49:3ff80c4bc1be | 591 | |
| nikitateggi | 49:3ff80c4bc1be | 592 | |
| nikitateggi | 50:b42238e7f46d | 593 | void read_sdcard_file() |
| nikitateggi | 49:3ff80c4bc1be | 594 | { |
| nikitateggi | 50:b42238e7f46d | 595 | |
| nikitateggi | 50:b42238e7f46d | 596 | |
| nikitateggi | 50:b42238e7f46d | 597 | |
| nikitateggi | 49:3ff80c4bc1be | 598 | FILE *fp_read_sdcard_file ; // PPG and ECG File pointers for BP |
| nikitateggi | 49:3ff80c4bc1be | 599 | char buffer[32]; |
| nikitateggi | 50:b42238e7f46d | 600 | uint32_t pid = 0; |
| nikitateggi | 50:b42238e7f46d | 601 | snd.scanf("%d", &pid); |
| nikitateggi | 50:b42238e7f46d | 602 | snd.printf("%d\n",pid); |
| nikitateggi | 50:b42238e7f46d | 603 | |
| nikitateggi | 50:b42238e7f46d | 604 | |
| nikitateggi | 50:b42238e7f46d | 605 | |
| nikitateggi | 49:3ff80c4bc1be | 606 | sprintf(buffer,"/sd/%d.csv",pid); |
| nikitateggi | 49:3ff80c4bc1be | 607 | fp_read_sdcard_file = fopen(buffer, "rb"); |
| nikitateggi | 49:3ff80c4bc1be | 608 | |
| nikitateggi | 49:3ff80c4bc1be | 609 | if(fp_read_sdcard_file == NULL) |
| nikitateggi | 49:3ff80c4bc1be | 610 | { |
| nikitateggi | 49:3ff80c4bc1be | 611 | snd.printf("No FILE Found .... !!\n"); |
| nikitateggi | 49:3ff80c4bc1be | 612 | } |
| nikitateggi | 49:3ff80c4bc1be | 613 | |
| nikitateggi | 49:3ff80c4bc1be | 614 | else |
| nikitateggi | 49:3ff80c4bc1be | 615 | { |
| nikitateggi | 49:3ff80c4bc1be | 616 | read_structure(fp_read_sdcard_file); |
| nikitateggi | 49:3ff80c4bc1be | 617 | snd.printf("Finished Reading File Content....!!\n"); |
| nikitateggi | 49:3ff80c4bc1be | 618 | fclose(fp_read_sdcard_file); |
| nikitateggi | 49:3ff80c4bc1be | 619 | } //end of else loop |
| nikitateggi | 49:3ff80c4bc1be | 620 | |
| nikitateggi | 49:3ff80c4bc1be | 621 | } |
| nikitateggi | 49:3ff80c4bc1be | 622 | |
| nikitateggi | 49:3ff80c4bc1be | 623 | void read_structure(FILE * fp_read_sdcard_file) |
| nikitateggi | 49:3ff80c4bc1be | 624 | |
| nikitateggi | 49:3ff80c4bc1be | 625 | { |
| nikitateggi | 50:b42238e7f46d | 626 | BLEMsg_info pid_file; |
| nikitateggi | 50:b42238e7f46d | 627 | uint32_t buf[1]; // buffer to read the raw data |
| nikitateggi | 50:b42238e7f46d | 628 | uint16_t sample = 0; // variable to hold the no of samples |
| nikitateggi | 50:b42238e7f46d | 629 | |
| nikitateggi | 50:b42238e7f46d | 630 | fread(&pid_file,sizeof(BLEMsg_info),1,fp_read_sdcard_file); // reading the structure data |
| nikitateggi | 49:3ff80c4bc1be | 631 | while (!feof(fp_read_sdcard_file)) |
| nikitateggi | 50:b42238e7f46d | 632 | { |
| nikitateggi | 50:b42238e7f46d | 633 | snd.printf("length = %d\n",pid_file.length); |
| nikitateggi | 50:b42238e7f46d | 634 | snd.printf("device_id = %d\n",pid_file.device_id); |
| nikitateggi | 50:b42238e7f46d | 635 | snd.printf("patient_id = %d\n",pid_file.patient_id); |
| nikitateggi | 50:b42238e7f46d | 636 | snd.printf("date = %d\n",pid_file.date_time.date); |
| nikitateggi | 50:b42238e7f46d | 637 | snd.printf("month = %d\n",pid_file.date_time.month); |
| nikitateggi | 50:b42238e7f46d | 638 | snd.printf("year = %d\n",pid_file.date_time.year); |
| nikitateggi | 50:b42238e7f46d | 639 | snd.printf("hour = %d\n",pid_file.date_time.hour); |
| nikitateggi | 50:b42238e7f46d | 640 | snd.printf("mins = %d\n",pid_file.date_time.mins); |
| nikitateggi | 50:b42238e7f46d | 641 | snd.printf("sec = %d\n",pid_file.date_time.sec); |
| nikitateggi | 50:b42238e7f46d | 642 | snd.printf("test_type = %d\n",pid_file.test_type); |
| nikitateggi | 50:b42238e7f46d | 643 | snd.printf("sampling_freq = %d\n",pid_file.sampling_freq); |
| nikitateggi | 50:b42238e7f46d | 644 | snd.printf("sample1 = %d\n",pid_file.num_samples.num_sample_ppg_dummy); |
| nikitateggi | 50:b42238e7f46d | 645 | snd.printf("samples2 = %d\n",pid_file.num_samples.num_sample_ecg_OTtyp); |
| nikitateggi | 50:b42238e7f46d | 646 | sample=(pid_file.num_samples.num_sample_ppg_dummy + pid_file.num_samples.num_sample_ecg_OTtyp); |
| nikitateggi | 50:b42238e7f46d | 647 | snd.printf("caldata1 = %d\n",pid_file.cal_data.cal_sbp_dummy); |
| nikitateggi | 50:b42238e7f46d | 648 | snd.printf("caldata2 = %d\n",pid_file.cal_data.cal_dbp_OTtyp); |
| nikitateggi | 50:b42238e7f46d | 649 | snd.printf("sample=%d\n", sample); |
| nikitateggi | 50:b42238e7f46d | 650 | for(uint16_t file_start=0;file_start<sample;file_start++) //reading the raw data |
| nikitateggi | 50:b42238e7f46d | 651 | { |
| nikitateggi | 50:b42238e7f46d | 652 | fread(buf,sizeof(uint32_t),1,fp_read_sdcard_file); |
| nikitateggi | 50:b42238e7f46d | 653 | snd.printf("%08x\n", buf[0]); |
| nikitateggi | 50:b42238e7f46d | 654 | } |
| nikitateggi | 50:b42238e7f46d | 655 | /* switch(sample) |
| nikitateggi | 49:3ff80c4bc1be | 656 | { |
| nikitateggi | 49:3ff80c4bc1be | 657 | |
| nikitateggi | 49:3ff80c4bc1be | 658 | case 2: |
| nikitateggi | 49:3ff80c4bc1be | 659 | fread(&buf,sizeof(uint32_t),sample,fp_read_sdcard_file); |
| nikitateggi | 49:3ff80c4bc1be | 660 | for(uint16_t file_start1=0;file_start1<sample;file_start1++) |
| nikitateggi | 49:3ff80c4bc1be | 661 | { |
| nikitateggi | 50:b42238e7f46d | 662 | snd.printf("%08x\n", buf[file_start1]); |
| nikitateggi | 49:3ff80c4bc1be | 663 | } |
| nikitateggi | 49:3ff80c4bc1be | 664 | break; |
| nikitateggi | 49:3ff80c4bc1be | 665 | |
| nikitateggi | 49:3ff80c4bc1be | 666 | case 2000: |
| nikitateggi | 49:3ff80c4bc1be | 667 | for(uint16_t file_start=0;file_start<(sample/1000);file_start++) |
| nikitateggi | 49:3ff80c4bc1be | 668 | { |
| nikitateggi | 49:3ff80c4bc1be | 669 | |
| nikitateggi | 49:3ff80c4bc1be | 670 | fread(&buf,sizeof(uint32_t),1000,fp_read_sdcard_file); |
| nikitateggi | 49:3ff80c4bc1be | 671 | for(uint16_t file_start1=0;file_start1<(1000);file_start1++) |
| nikitateggi | 49:3ff80c4bc1be | 672 | { |
| nikitateggi | 50:b42238e7f46d | 673 | snd.printf("%08x\n", buf[file_start1]); |
| nikitateggi | 49:3ff80c4bc1be | 674 | } |
| nikitateggi | 49:3ff80c4bc1be | 675 | |
| nikitateggi | 49:3ff80c4bc1be | 676 | } |
| nikitateggi | 49:3ff80c4bc1be | 677 | break; |
| nikitateggi | 49:3ff80c4bc1be | 678 | |
| nikitateggi | 50:b42238e7f46d | 679 | case 2688: |
| nikitateggi | 49:3ff80c4bc1be | 680 | for(uint16_t file_start=0;file_start<(sample/1000);file_start++) |
| nikitateggi | 49:3ff80c4bc1be | 681 | { |
| nikitateggi | 49:3ff80c4bc1be | 682 | |
| nikitateggi | 49:3ff80c4bc1be | 683 | fread(&buf,sizeof(uint32_t),1000,fp_read_sdcard_file); |
| nikitateggi | 49:3ff80c4bc1be | 684 | for(uint16_t file_start1=0;file_start1<(1000);file_start1++) |
| nikitateggi | 49:3ff80c4bc1be | 685 | { |
| nikitateggi | 50:b42238e7f46d | 686 | snd.printf("%08x\n", buf[file_start1]); |
| nikitateggi | 49:3ff80c4bc1be | 687 | } |
| nikitateggi | 49:3ff80c4bc1be | 688 | |
| nikitateggi | 49:3ff80c4bc1be | 689 | } |
| nikitateggi | 49:3ff80c4bc1be | 690 | |
| nikitateggi | 49:3ff80c4bc1be | 691 | |
| nikitateggi | 49:3ff80c4bc1be | 692 | for(uint16_t i=0;i<1000;i++) |
| nikitateggi | 49:3ff80c4bc1be | 693 | { |
| nikitateggi | 49:3ff80c4bc1be | 694 | buf[i]=NULL; |
| nikitateggi | 49:3ff80c4bc1be | 695 | } |
| nikitateggi | 49:3ff80c4bc1be | 696 | |
| nikitateggi | 49:3ff80c4bc1be | 697 | fread(&buf,sizeof(uint32_t),(sample-(1000*(sample/1000))),fp_read_sdcard_file); |
| nikitateggi | 49:3ff80c4bc1be | 698 | |
| nikitateggi | 49:3ff80c4bc1be | 699 | for(uint16_t file_start1=0;file_start1<(sample-(1000*(sample/1000)));file_start1++) |
| nikitateggi | 49:3ff80c4bc1be | 700 | { |
| nikitateggi | 50:b42238e7f46d | 701 | snd.printf("%08x\n", buf[file_start1]); |
| nikitateggi | 49:3ff80c4bc1be | 702 | } |
| nikitateggi | 49:3ff80c4bc1be | 703 | break; |
| nikitateggi | 50:b42238e7f46d | 704 | |
| nikitateggi | 50:b42238e7f46d | 705 | |
| nikitateggi | 50:b42238e7f46d | 706 | default: snd.printf("End\n"); |
| nikitateggi | 50:b42238e7f46d | 707 | break; |
| nikitateggi | 50:b42238e7f46d | 708 | |
| nikitateggi | 49:3ff80c4bc1be | 709 | } |
| nikitateggi | 50:b42238e7f46d | 710 | */ |
| nikitateggi | 50:b42238e7f46d | 711 | fread(&pid_file,sizeof(BLEMsg_info),1,fp_read_sdcard_file); |
| nikitateggi | 50:b42238e7f46d | 712 | |
| nikitateggi | 49:3ff80c4bc1be | 713 | } |
| nikitateggi | 49:3ff80c4bc1be | 714 | |
| nikitateggi | 49:3ff80c4bc1be | 715 | } |
| nikitateggi | 49:3ff80c4bc1be | 716 | |
| nikitateggi | 49:3ff80c4bc1be | 717 | |
| nikitateggi | 49:3ff80c4bc1be | 718 | |
| rashmivenkataramaiah | 42:c81673b04b6a | 719 |
Repository toolbox
| Export to desktop IDE |
| Build repository |
Repository details
| Type: | Program |
|---|---|
| Mbed OS support: | Mbed 2 deprecated |
| Created: | 03 Nov 2017 |
| Imports: | 19 |
| Forks: | 1 |
| Commits: | 57 |
| Dependents: | 0 |
| Dependencies: | 5 |
| Followers: | 5 |
