export test
Dependencies: SDFileSystem ds3231 eeprom_Nikita mbed testUniGraphic_150217
Fork of Int_Demo_09May2017_Suhasini_HRavg_Nikita_ili9341 by
sdcard.cpp@24:d992ee8369f4, 2017-06-24 (annotated)
- Committer:
- nikitateggi
- Date:
- Sat Jun 24 10:24:32 2017 +0000
- Revision:
- 24:d992ee8369f4
- Parent:
- 22:ffa88619551d
- Child:
- 26:53ff13a164f3
poc with battery monitoring(commented),; updated pid and bufferless heart rate
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 | 24:d992ee8369f4 | 13 | SDFileSystem sd(PTE1, PTE3, PTE2, PTE4, "sd"); |
nikitateggi | 1:8316c23ec6b9 | 14 | |
nikitateggi | 24:d992ee8369f4 | 15 | |
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 |
nikitateggi | 22:ffa88619551d | 37 | void sd_open_mainfile(int32_t 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 | 20:7c64e6ecad76 | 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 | 20:7c64e6ecad76 | 61 | } */ |
nikitateggi | 3:9a06c2bed650 | 62 | |
nikitateggi | 22:ffa88619551d | 63 | void sd_open_GLCfilee(int32_t 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 | 20:7c64e6ecad76 | 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 | 20:7c64e6ecad76 | 87 | */ |
nikitateggi | 22:ffa88619551d | 88 | void sd_open_ECGfilee(int32_t 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 | 20:7c64e6ecad76 | 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 | 20:7c64e6ecad76 | 111 | } */ |
nikitateggi | 1:8316c23ec6b9 | 112 | |
nikitateggi | 22:ffa88619551d | 113 | void sd_open_BPfilee(int32_t 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 | |
nikitateggi | 19:1650bbc923cc | 129 | |
nikitateggi | 19:1650bbc923cc | 130 | void sd_open_read(int32_t pid) // opening the file for read |
nikitateggi | 19:1650bbc923cc | 131 | { |
nikitateggi | 19:1650bbc923cc | 132 | |
nikitateggi | 19:1650bbc923cc | 133 | char buffer1[32]; |
nikitateggi | 19:1650bbc923cc | 134 | sprintf(buffer1,"/sd/%d.csv",pid); |
nikitateggi | 19:1650bbc923cc | 135 | fp = fopen(buffer1,"r"); |
nikitateggi | 19:1650bbc923cc | 136 | if (fp==NULL) |
nikitateggi | 19:1650bbc923cc | 137 | { |
nikitateggi | 19:1650bbc923cc | 138 | snd.printf("no"); |
nikitateggi | 19:1650bbc923cc | 139 | } |
nikitateggi | 19:1650bbc923cc | 140 | |
nikitateggi | 19:1650bbc923cc | 141 | else |
nikitateggi | 19:1650bbc923cc | 142 | { |
nikitateggi | 19:1650bbc923cc | 143 | snd.printf("yes"); |
nikitateggi | 19:1650bbc923cc | 144 | } |
nikitateggi | 19:1650bbc923cc | 145 | } |
nikitateggi | 19:1650bbc923cc | 146 | |
nikitateggi | 19:1650bbc923cc | 147 | void sd_read(uint32_t *v1, int size) //reading the data from the openend file |
nikitateggi | 19:1650bbc923cc | 148 | { |
nikitateggi | 19:1650bbc923cc | 149 | fread(v1,sizeof(v1),size,fp); |
nikitateggi | 19:1650bbc923cc | 150 | } |
nikitateggi | 19:1650bbc923cc | 151 | |
nikitateggi | 19:1650bbc923cc | 152 | void setpos() |
nikitateggi | 19:1650bbc923cc | 153 | { |
nikitateggi | 19:1650bbc923cc | 154 | //fseek ( fp , 1 , SEEK_SET ); |
nikitateggi | 19:1650bbc923cc | 155 | rewind (fp); |
nikitateggi | 19:1650bbc923cc | 156 | } |
nikitateggi | 19:1650bbc923cc | 157 | |
nikitateggi | 19:1650bbc923cc | 158 | void setpos1(uint32_t position) |
nikitateggi | 19:1650bbc923cc | 159 | { |
nikitateggi | 19:1650bbc923cc | 160 | fseek ( fp , position, SEEK_SET ); |
nikitateggi | 19:1650bbc923cc | 161 | //rewind (fp); |
nikitateggi | 19:1650bbc923cc | 162 | } |
nikitateggi | 19:1650bbc923cc | 163 | |
nikitateggi | 19:1650bbc923cc | 164 | |
nikitateggi | 19:1650bbc923cc | 165 | int file_size() |
nikitateggi | 19:1650bbc923cc | 166 | { |
nikitateggi | 19:1650bbc923cc | 167 | int file_length; |
nikitateggi | 19:1650bbc923cc | 168 | fseek (fp, 0, SEEK_END); |
nikitateggi | 19:1650bbc923cc | 169 | file_length=ftell(fp); |
nikitateggi | 19:1650bbc923cc | 170 | file_length=sizeof(char)*file_length; |
nikitateggi | 19:1650bbc923cc | 171 | rewind(fp); |
nikitateggi | 19:1650bbc923cc | 172 | return file_length; |
nikitateggi | 19:1650bbc923cc | 173 | } |
nikitateggi | 19:1650bbc923cc | 174 | |
nikitateggi | 19:1650bbc923cc | 175 | |
nikitateggi | 19:1650bbc923cc | 176 | int file_size1() |
nikitateggi | 19:1650bbc923cc | 177 | { |
nikitateggi | 19:1650bbc923cc | 178 | int file_length; |
nikitateggi | 19:1650bbc923cc | 179 | // fseek (fp, 0, SEEK_END); |
nikitateggi | 19:1650bbc923cc | 180 | |
nikitateggi | 19:1650bbc923cc | 181 | file_length=ftell(fp); |
nikitateggi | 19:1650bbc923cc | 182 | // file_length=sizeof(char)*file_length; |
nikitateggi | 19:1650bbc923cc | 183 | // rewind(fp); |
nikitateggi | 19:1650bbc923cc | 184 | return file_length; |
nikitateggi | 19:1650bbc923cc | 185 | } |
nikitateggi | 19:1650bbc923cc | 186 | |
nikitateggi | 19:1650bbc923cc | 187 | |
nikitateggi | 19:1650bbc923cc | 188 | |
nikitateggi | 19:1650bbc923cc | 189 | |
nikitateggi | 19:1650bbc923cc | 190 | |
nikitateggi | 19:1650bbc923cc | 191 | void sd_read1(BLEMsg_info &f) |
nikitateggi | 19:1650bbc923cc | 192 | { |
nikitateggi | 19:1650bbc923cc | 193 | fread(&f,sizeof(BLEMsg_info),1,fp); |
nikitateggi | 19:1650bbc923cc | 194 | //fscanf(fp,"%08x",&v1); |
nikitateggi | 19:1650bbc923cc | 195 | } |
nikitateggi | 19:1650bbc923cc | 196 | |
nikitateggi | 19:1650bbc923cc | 197 | |
nikitateggi | 19:1650bbc923cc | 198 | |
nikitateggi | 19:1650bbc923cc | 199 | |
nikitateggi | 19:1650bbc923cc | 200 | |
nikitateggi | 19:1650bbc923cc | 201 | |
nikitateggi | 19:1650bbc923cc | 202 | |
nikitateggi | 19:1650bbc923cc | 203 | |
nikitateggi | 19:1650bbc923cc | 204 | |
nidhinvarghese | 8:adf2ba7e6412 | 205 | //------------------------------------------------------ |
nidhinvarghese | 8:adf2ba7e6412 | 206 | |
nidhinvarghese | 8:adf2ba7e6412 | 207 | //FILE *sd_BP_ecgwrite (int value) // writing data into the file NIDHIN |
nidhinvarghese | 15:208b146151ba | 208 | FILE *sd_BP_ecgwrite (int32_t *fpdrum11) // writing data into the file NIDHIN |
nidhinvarghese | 8:adf2ba7e6412 | 209 | { |
nidhinvarghese | 15:208b146151ba | 210 | fwrite(fpdrum11,sizeof(int32_t),1, fpecg); //Change by Nidhin 30/5/2017 Direct writing to SD card. Org Val 64 |
nidhinvarghese | 8:adf2ba7e6412 | 211 | return fpecg; |
nidhinvarghese | 8:adf2ba7e6412 | 212 | } |
nidhinvarghese | 8:adf2ba7e6412 | 213 | |
nidhinvarghese | 14:f5c62d30c6fc | 214 | FILE* sd_BP_ppgwrite (uint32_t *fpdrum21) // //Change by Nidhin 30/5/2017 Direct writing to SD card. |
nidhinvarghese | 8:adf2ba7e6412 | 215 | { |
nidhinvarghese | 14:f5c62d30c6fc | 216 | fwrite(fpdrum21,sizeof(uint32_t),1, fpppg); //Change by Nidhin 30/5/2017 Direct writing to SD card. OR Val 64 |
nidhinvarghese | 8:adf2ba7e6412 | 217 | return fpppg; |
nidhinvarghese | 8:adf2ba7e6412 | 218 | } |
nidhinvarghese | 8:adf2ba7e6412 | 219 | //-----------------------------------------------SD Read |
nidhinvarghese | 8:adf2ba7e6412 | 220 | |
nikitateggi | 22:ffa88619551d | 221 | void sd_reopen_BPfilee(int32_t pid) // only opening the BP file after entering TEST screen |
nidhinvarghese | 8:adf2ba7e6412 | 222 | { |
nidhinvarghese | 8:adf2ba7e6412 | 223 | |
nidhinvarghese | 8:adf2ba7e6412 | 224 | |
nidhinvarghese | 8:adf2ba7e6412 | 225 | char buffer1[32]; |
nidhinvarghese | 8:adf2ba7e6412 | 226 | sprintf(buffer1,"/sd/%d_BP.csv",pid); |
nidhinvarghese | 8:adf2ba7e6412 | 227 | fp = fopen(buffer1,"r"); |
nidhinvarghese | 8:adf2ba7e6412 | 228 | //fprintf(fp,"PATIENT ID %d\n",pid ); |
nidhinvarghese | 8:adf2ba7e6412 | 229 | |
nidhinvarghese | 8:adf2ba7e6412 | 230 | |
nidhinvarghese | 8:adf2ba7e6412 | 231 | } |
nidhinvarghese | 8:adf2ba7e6412 | 232 | //------------------------------------------------- |
nidhinvarghese | 8:adf2ba7e6412 | 233 | |
nidhinvarghese | 8:adf2ba7e6412 | 234 | |
nidhinvarghese | 8:adf2ba7e6412 | 235 | //--------------------------------------- |
nidhinvarghese | 8:adf2ba7e6412 | 236 | |
nidhinvarghese | 8:adf2ba7e6412 | 237 | |
nikitateggi | 22:ffa88619551d | 238 | void sd_open_BP_ECGfile(int32_t pid) |
nidhinvarghese | 8:adf2ba7e6412 | 239 | { |
nidhinvarghese | 8:adf2ba7e6412 | 240 | |
nidhinvarghese | 8:adf2ba7e6412 | 241 | //char buffer[32]; |
nidhinvarghese | 8:adf2ba7e6412 | 242 | char buffer1[32]; |
nidhinvarghese | 8:adf2ba7e6412 | 243 | //time_t epoch_time1; |
nidhinvarghese | 8:adf2ba7e6412 | 244 | //epoch_time1=rtc_read(); |
nidhinvarghese | 8:adf2ba7e6412 | 245 | // strftime(buffer, 32, "ECG_%d", pid); |
nidhinvarghese | 8:adf2ba7e6412 | 246 | |
nidhinvarghese | 8:adf2ba7e6412 | 247 | sprintf(buffer1,"/sd/%d_BP_ECG.csv",pid); |
nidhinvarghese | 8:adf2ba7e6412 | 248 | fpecg = fopen(buffer1,"a"); |
nidhinvarghese | 8:adf2ba7e6412 | 249 | if (fpecg == NULL) |
nidhinvarghese | 8:adf2ba7e6412 | 250 | { |
nidhinvarghese | 8:adf2ba7e6412 | 251 | exit(1); |
nidhinvarghese | 8:adf2ba7e6412 | 252 | } |
nidhinvarghese | 8:adf2ba7e6412 | 253 | //fprintf(fpecg,"%s\n",ctime(&epoch_time1) ); |
nidhinvarghese | 8:adf2ba7e6412 | 254 | |
nidhinvarghese | 8:adf2ba7e6412 | 255 | } |
nidhinvarghese | 8:adf2ba7e6412 | 256 | |
nidhinvarghese | 8:adf2ba7e6412 | 257 | |
nikitateggi | 22:ffa88619551d | 258 | void sd_open_BP_PPGfile(int32_t pid) |
nidhinvarghese | 8:adf2ba7e6412 | 259 | { |
nidhinvarghese | 8:adf2ba7e6412 | 260 | |
nidhinvarghese | 8:adf2ba7e6412 | 261 | char buffer1[32]; |
nidhinvarghese | 8:adf2ba7e6412 | 262 | //time_t epoch_time1; |
nidhinvarghese | 8:adf2ba7e6412 | 263 | //epoch_time1=rtc_read(); |
nidhinvarghese | 8:adf2ba7e6412 | 264 | // strftime(buffer, 32, "ECG_%d", pid); |
nidhinvarghese | 8:adf2ba7e6412 | 265 | |
nidhinvarghese | 8:adf2ba7e6412 | 266 | sprintf(buffer1,"/sd/%d_BP_PPG.csv",pid); |
nidhinvarghese | 8:adf2ba7e6412 | 267 | fpppg = fopen(buffer1,"a"); |
nidhinvarghese | 8:adf2ba7e6412 | 268 | if(fpppg == NULL) |
nidhinvarghese | 8:adf2ba7e6412 | 269 | { |
nidhinvarghese | 8:adf2ba7e6412 | 270 | exit(1); |
nidhinvarghese | 8:adf2ba7e6412 | 271 | } |
nidhinvarghese | 8:adf2ba7e6412 | 272 | |
nidhinvarghese | 8:adf2ba7e6412 | 273 | //fprintf(fpppg,"%s\n",ctime(&epoch_time1) ); |
nidhinvarghese | 8:adf2ba7e6412 | 274 | |
nidhinvarghese | 8:adf2ba7e6412 | 275 | } |
nidhinvarghese | 8:adf2ba7e6412 | 276 | |
nidhinvarghese | 8:adf2ba7e6412 | 277 | |
nidhinvarghese | 8:adf2ba7e6412 | 278 | |
nidhinvarghese | 8:adf2ba7e6412 | 279 | //-------------------------------------------------- |
nidhinvarghese | 8:adf2ba7e6412 | 280 | |
nidhinvarghese | 14:f5c62d30c6fc | 281 | //FUNCTIONS TO CLOSE FILES |
nidhinvarghese | 14:f5c62d30c6fc | 282 | //__________________________________________________ |
nidhinvarghese | 14:f5c62d30c6fc | 283 | void sd_close() //close the file with fp |
nidhinvarghese | 8:adf2ba7e6412 | 284 | { |
nikitateggi | 1:8316c23ec6b9 | 285 | |
nidhinvarghese | 8:adf2ba7e6412 | 286 | fclose(fp); |
nidhinvarghese | 8:adf2ba7e6412 | 287 | } |
nidhinvarghese | 14:f5c62d30c6fc | 288 | //______________________________________________________ |
nidhinvarghese | 14:f5c62d30c6fc | 289 | void sd_close_ecg() // Closes ECG file pinted by fpeecg |
nidhinvarghese | 14:f5c62d30c6fc | 290 | { |
nidhinvarghese | 14:f5c62d30c6fc | 291 | |
nidhinvarghese | 14:f5c62d30c6fc | 292 | fclose(fpeecg); |
nidhinvarghese | 14:f5c62d30c6fc | 293 | } |
nidhinvarghese | 14:f5c62d30c6fc | 294 | //______________________________________________________ |
nidhinvarghese | 14:f5c62d30c6fc | 295 | void sd_close_glc() // Closes GLC file pinted by fpbg |
nidhinvarghese | 14:f5c62d30c6fc | 296 | { |
nidhinvarghese | 14:f5c62d30c6fc | 297 | |
nidhinvarghese | 14:f5c62d30c6fc | 298 | fclose(fpbg); |
nidhinvarghese | 14:f5c62d30c6fc | 299 | } |
nidhinvarghese | 14:f5c62d30c6fc | 300 | //_____________________________________________________ |
nidhinvarghese | 14:f5c62d30c6fc | 301 | |
nidhinvarghese | 14:f5c62d30c6fc | 302 | |
nidhinvarghese | 14:f5c62d30c6fc | 303 | |
nidhinvarghese | 14:f5c62d30c6fc | 304 | |
nidhinvarghese | 14:f5c62d30c6fc | 305 | |
nidhinvarghese | 14:f5c62d30c6fc | 306 | |
nidhinvarghese | 8:adf2ba7e6412 | 307 | //------------------------------------------ |
nidhinvarghese | 8:adf2ba7e6412 | 308 | //REOPEN FUNCTIONs for reading data Nidhin |
nidhinvarghese | 8:adf2ba7e6412 | 309 | |
nikitateggi | 22:ffa88619551d | 310 | int sd_BP_ECGMAX(int32_t pid) |
nidhinvarghese | 8:adf2ba7e6412 | 311 | { |
nidhinvarghese | 8:adf2ba7e6412 | 312 | |
nidhinvarghese | 8:adf2ba7e6412 | 313 | char buffer1[32]; |
nidhinvarghese | 8:adf2ba7e6412 | 314 | |
nidhinvarghese | 8:adf2ba7e6412 | 315 | sprintf(buffer1,"/sd/%d_BP_ECG.csv",pid); |
nidhinvarghese | 8:adf2ba7e6412 | 316 | fpecg = fopen(buffer1,"r"); |
nidhinvarghese | 8:adf2ba7e6412 | 317 | if(fpecg == NULL) |
nidhinvarghese | 8:adf2ba7e6412 | 318 | { |
nidhinvarghese | 8:adf2ba7e6412 | 319 | exit(1); |
nidhinvarghese | 8:adf2ba7e6412 | 320 | } |
nidhinvarghese | 8:adf2ba7e6412 | 321 | |
nidhinvarghese | 8:adf2ba7e6412 | 322 | else |
nidhinvarghese | 8:adf2ba7e6412 | 323 | { |
nidhinvarghese | 8:adf2ba7e6412 | 324 | int ecgmax = 0; |
nidhinvarghese | 8:adf2ba7e6412 | 325 | int a[1] = {0}; |
nidhinvarghese | 8:adf2ba7e6412 | 326 | int samplesecg =0; |
nidhinvarghese | 8:adf2ba7e6412 | 327 | for(ebp=0; ebp<1024; ebp++) |
nidhinvarghese | 8:adf2ba7e6412 | 328 | { |
nidhinvarghese | 8:adf2ba7e6412 | 329 | |
nidhinvarghese | 8:adf2ba7e6412 | 330 | |
nidhinvarghese | 14:f5c62d30c6fc | 331 | fread(a,sizeof(uint32_t), 1,fpecg); |
nidhinvarghese | 11:9a6545c2eb5d | 332 | // snd.printf("\n%d", a[0]); Commented May3_2017 (Nidhin) |
nidhinvarghese | 8:adf2ba7e6412 | 333 | if(a[0] > ecgmax) |
nidhinvarghese | 8:adf2ba7e6412 | 334 | { |
nidhinvarghese | 8:adf2ba7e6412 | 335 | ecgmax=a[0]; |
nidhinvarghese | 8:adf2ba7e6412 | 336 | ecgloc= ebp +1; |
nidhinvarghese | 8:adf2ba7e6412 | 337 | } |
nidhinvarghese | 8:adf2ba7e6412 | 338 | else |
nidhinvarghese | 8:adf2ba7e6412 | 339 | samplesecg =ebp+1; |
nidhinvarghese | 8:adf2ba7e6412 | 340 | |
nidhinvarghese | 8:adf2ba7e6412 | 341 | } |
nidhinvarghese | 8:adf2ba7e6412 | 342 | } |
nidhinvarghese | 8:adf2ba7e6412 | 343 | fclose (fpecg); |
nidhinvarghese | 8:adf2ba7e6412 | 344 | return ecgloc; |
nidhinvarghese | 8:adf2ba7e6412 | 345 | } |
nidhinvarghese | 8:adf2ba7e6412 | 346 | |
nidhinvarghese | 8:adf2ba7e6412 | 347 | // Function to calculate PPG MAx and location |
nidhinvarghese | 8:adf2ba7e6412 | 348 | |
nikitateggi | 22:ffa88619551d | 349 | int sd_BP_PPGMAX(int32_t pid) |
nidhinvarghese | 8:adf2ba7e6412 | 350 | { |
nidhinvarghese | 8:adf2ba7e6412 | 351 | |
nidhinvarghese | 8:adf2ba7e6412 | 352 | char buffer1[32]; |
nidhinvarghese | 8:adf2ba7e6412 | 353 | |
nidhinvarghese | 8:adf2ba7e6412 | 354 | sprintf(buffer1,"/sd/%d_BP_PPG.csv",pid); |
nidhinvarghese | 8:adf2ba7e6412 | 355 | fpppg = fopen(buffer1,"r"); |
nidhinvarghese | 8:adf2ba7e6412 | 356 | if(fpppg == NULL) |
nidhinvarghese | 8:adf2ba7e6412 | 357 | { |
nidhinvarghese | 8:adf2ba7e6412 | 358 | exit(1); |
nidhinvarghese | 8:adf2ba7e6412 | 359 | } |
nidhinvarghese | 8:adf2ba7e6412 | 360 | |
nidhinvarghese | 8:adf2ba7e6412 | 361 | else |
nidhinvarghese | 8:adf2ba7e6412 | 362 | { |
nidhinvarghese | 8:adf2ba7e6412 | 363 | uint32_t ppgmax = 0; |
nidhinvarghese | 8:adf2ba7e6412 | 364 | uint32_t b[1] ={0}; |
nidhinvarghese | 8:adf2ba7e6412 | 365 | int samplesppg = 0; |
nidhinvarghese | 8:adf2ba7e6412 | 366 | for(pbp=0; pbp<1664; pbp++) |
nidhinvarghese | 8:adf2ba7e6412 | 367 | { |
nidhinvarghese | 8:adf2ba7e6412 | 368 | fread(b, sizeof(uint32_t),1, fpppg); |
nidhinvarghese | 11:9a6545c2eb5d | 369 | // snd.printf("\n%d", b[0]); Commented May3_2017 (Nidhin) |
nidhinvarghese | 8:adf2ba7e6412 | 370 | |
nidhinvarghese | 8:adf2ba7e6412 | 371 | if((pbp>ecgloc) && (pbp< (ecgloc+350))) |
nidhinvarghese | 8:adf2ba7e6412 | 372 | { |
nidhinvarghese | 8:adf2ba7e6412 | 373 | if(b[0] > ppgmax) |
nidhinvarghese | 8:adf2ba7e6412 | 374 | { |
nidhinvarghese | 8:adf2ba7e6412 | 375 | ppgmax=b[0]; |
nidhinvarghese | 8:adf2ba7e6412 | 376 | ppgloc= pbp+1; |
nidhinvarghese | 8:adf2ba7e6412 | 377 | } |
nidhinvarghese | 8:adf2ba7e6412 | 378 | else |
nidhinvarghese | 8:adf2ba7e6412 | 379 | samplesppg =pbp+1; |
nidhinvarghese | 8:adf2ba7e6412 | 380 | } |
nidhinvarghese | 8:adf2ba7e6412 | 381 | else |
nidhinvarghese | 8:adf2ba7e6412 | 382 | samplesppg = pbp+1; |
nidhinvarghese | 8:adf2ba7e6412 | 383 | } |
nidhinvarghese | 8:adf2ba7e6412 | 384 | } |
nidhinvarghese | 8:adf2ba7e6412 | 385 | fclose (fpppg); |
nidhinvarghese | 8:adf2ba7e6412 | 386 | return ppgloc; |
nidhinvarghese | 8:adf2ba7e6412 | 387 | } |
nidhinvarghese | 10:aeff3309002a | 388 | |
nidhinvarghese | 8:adf2ba7e6412 | 389 | //fread(buffer, 1, size, fp) |
nidhinvarghese | 8:adf2ba7e6412 | 390 | //fwrite(&buffer, , |
nidhinvarghese | 10:aeff3309002a | 391 | //----------------------------------------------------28/4/2017--------------------------------- |
nidhinvarghese | 10:aeff3309002a | 392 | //---------------------------------------------------------------------------------------------- |
nidhinvarghese | 10:aeff3309002a | 393 | |
nidhinvarghese | 10:aeff3309002a | 394 | |
nidhinvarghese | 10:aeff3309002a | 395 | |
nidhinvarghese | 10:aeff3309002a | 396 | //------- FUNCTION TO CREATE SINGLE BP FILE --------2/5/2017 (NIDHIN)---------------// |
nikitateggi | 22:ffa88619551d | 397 | void create_single_BPfile(int32_t pid) |
nidhinvarghese | 10:aeff3309002a | 398 | { |
nidhinvarghese | 10:aeff3309002a | 399 | |
nidhinvarghese | 10:aeff3309002a | 400 | //int ecgbuf[64] = {0}; |
nidhinvarghese | 10:aeff3309002a | 401 | //uint32_t ppgbuf[64] = {0}; |
nidhinvarghese | 10:aeff3309002a | 402 | |
nidhinvarghese | 10:aeff3309002a | 403 | char buffer3[32]; |
nidhinvarghese | 10:aeff3309002a | 404 | sprintf(buffer3, "/sd/%d_BP.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 405 | fpbp = fopen(buffer3, "a"); // Opens BP file with FILE pointer fpbp in APPEND mode |
nidhinvarghese | 10:aeff3309002a | 406 | |
nidhinvarghese | 10:aeff3309002a | 407 | //buffer1[32] = ""; |
nidhinvarghese | 14:f5c62d30c6fc | 408 | sprintf(buffer3, "/sd/%d_BP_ECG.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 409 | fpecg = fopen(buffer3, "r"); // Opens ECG file of BP with FILE pointer fpecg in READ mode |
nidhinvarghese | 10:aeff3309002a | 410 | |
nidhinvarghese | 10:aeff3309002a | 411 | //char buffer1[32] = ""; |
nidhinvarghese | 10:aeff3309002a | 412 | sprintf(buffer3, "/sd/%d_BP_PPG.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 413 | fpppg = fopen(buffer3, "r"); // Opens PPG file of BP with FILE pointer fpppg in READ mode |
nidhinvarghese | 10:aeff3309002a | 414 | |
nidhinvarghese | 10:aeff3309002a | 415 | for(int i=0; i<16; i++) |
nidhinvarghese | 10:aeff3309002a | 416 | { |
nidhinvarghese | 10:aeff3309002a | 417 | int ecgbuf[64] = {0} ; |
nidhinvarghese | 14:f5c62d30c6fc | 418 | fread(ecgbuf, sizeof(uint32_t), 64, fpecg); |
nidhinvarghese | 14:f5c62d30c6fc | 419 | fwrite(ecgbuf, sizeof(uint32_t), 64, fpbp); // Copy ECG data of BP into BP file |
nidhinvarghese | 10:aeff3309002a | 420 | } |
nidhinvarghese | 10:aeff3309002a | 421 | |
nidhinvarghese | 10:aeff3309002a | 422 | for(int i=0; i<26; i++) |
nidhinvarghese | 10:aeff3309002a | 423 | { |
nidhinvarghese | 10:aeff3309002a | 424 | int ppgbuf[64] = {0} ; |
nidhinvarghese | 14:f5c62d30c6fc | 425 | fread(ppgbuf, sizeof(uint32_t), 64, fpppg); |
nidhinvarghese | 14:f5c62d30c6fc | 426 | fwrite(ppgbuf, sizeof(uint32_t), 64, fpbp); // Copy PPG data of BP into BP file |
nidhinvarghese | 10:aeff3309002a | 427 | } |
nidhinvarghese | 10:aeff3309002a | 428 | |
nidhinvarghese | 14:f5c62d30c6fc | 429 | fclose(fpecg); // Closes the ECG file of BP |
nidhinvarghese | 14:f5c62d30c6fc | 430 | fclose(fpppg); // Closes the PPG file of BP |
nidhinvarghese | 14:f5c62d30c6fc | 431 | fclose(fpbp); // Closes the BP file |
nidhinvarghese | 10:aeff3309002a | 432 | |
nidhinvarghese | 10:aeff3309002a | 433 | //char buffer1[32] = ""; |
nidhinvarghese | 14:f5c62d30c6fc | 434 | int status = 1 ; |
nidhinvarghese | 10:aeff3309002a | 435 | sprintf(buffer3, "/sd/%d_BP_ECG.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 436 | status = remove(buffer3); //Removes ECG file of BP and updates status with 0 if successful |
nidhinvarghese | 11:9a6545c2eb5d | 437 | |
nidhinvarghese | 11:9a6545c2eb5d | 438 | |
nidhinvarghese | 10:aeff3309002a | 439 | if( status == 0 ) |
nidhinvarghese | 14:f5c62d30c6fc | 440 | snd.printf("\nECG file delete : Successful"); // Checks for SUCCESS |
nidhinvarghese | 10:aeff3309002a | 441 | else |
nidhinvarghese | 10:aeff3309002a | 442 | snd.printf("\nECG file delete : UnSuccessful"); |
nidhinvarghese | 11:9a6545c2eb5d | 443 | |
nidhinvarghese | 11:9a6545c2eb5d | 444 | |
nidhinvarghese | 10:aeff3309002a | 445 | //char buffer1[32] = ""; |
nidhinvarghese | 14:f5c62d30c6fc | 446 | status = 1 ; |
nidhinvarghese | 10:aeff3309002a | 447 | sprintf(buffer3, "/sd/%d_BP_PPG.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 448 | status = remove(buffer3); //Removes PPG file of BP and updates status with 0 if successful |
nidhinvarghese | 11:9a6545c2eb5d | 449 | |
nidhinvarghese | 10:aeff3309002a | 450 | if( status == 0 ) |
nidhinvarghese | 14:f5c62d30c6fc | 451 | snd.printf("\nPPG file delete : Successful"); // Checks for SUCCESS |
nidhinvarghese | 10:aeff3309002a | 452 | else |
nidhinvarghese | 10:aeff3309002a | 453 | snd.printf("\nPPG file delete : UnSuccessful"); |
nidhinvarghese | 11:9a6545c2eb5d | 454 | |
nidhinvarghese | 14:f5c62d30c6fc | 455 | } |
nidhinvarghese | 14:f5c62d30c6fc | 456 | |
nidhinvarghese | 14:f5c62d30c6fc | 457 | //Creating strcuture file Common to All Functions |
nikitateggi | 22:ffa88619551d | 458 | void structure_file(BLEMsg_info *ptr, int32_t pid) |
nidhinvarghese | 14:f5c62d30c6fc | 459 | { |
nidhinvarghese | 14:f5c62d30c6fc | 460 | char buffer3[32]; |
nidhinvarghese | 14:f5c62d30c6fc | 461 | sprintf(buffer3, "/sd/%d.csv", pid); //Printing file path to the buffer |
nidhinvarghese | 14:f5c62d30c6fc | 462 | fpmain = fopen(buffer3, "a"); // open the file PID.csv with FILE pointer fpmain |
nidhinvarghese | 14:f5c62d30c6fc | 463 | fwrite(ptr, sizeof(uint8_t),26, fpmain ); // writing the Structure into the file |
nidhinvarghese | 14:f5c62d30c6fc | 464 | fclose(fpmain); // Close File |
nidhinvarghese | 14:f5c62d30c6fc | 465 | } |
nidhinvarghese | 14:f5c62d30c6fc | 466 | |
nidhinvarghese | 14:f5c62d30c6fc | 467 | //Copy Data into file. |
nidhinvarghese | 14:f5c62d30c6fc | 468 | |
nikitateggi | 22:ffa88619551d | 469 | void bpfile_mainfile(int32_t pid) //Copy data of bp file to main |
nidhinvarghese | 14:f5c62d30c6fc | 470 | { |
nidhinvarghese | 14:f5c62d30c6fc | 471 | char buffer3[32]; |
nidhinvarghese | 14:f5c62d30c6fc | 472 | sprintf(buffer3, "/sd/%d.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 473 | fpmain = fopen(buffer3, "a"); // Opens Main file with FILE pointer "fpmain" in APPEND mode |
nidhinvarghese | 14:f5c62d30c6fc | 474 | |
nidhinvarghese | 14:f5c62d30c6fc | 475 | sprintf(buffer3, "/sd/%d_BP.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 476 | fpbp = fopen(buffer3, "r"); // Opens BP file with FILE pointer "fpbp" in READ mode |
nidhinvarghese | 14:f5c62d30c6fc | 477 | |
nidhinvarghese | 14:f5c62d30c6fc | 478 | |
nidhinvarghese | 14:f5c62d30c6fc | 479 | for(int i=0; i<21; i++) |
nidhinvarghese | 14:f5c62d30c6fc | 480 | { |
nidhinvarghese | 14:f5c62d30c6fc | 481 | int bigbuf[128] = {0} ; |
nidhinvarghese | 14:f5c62d30c6fc | 482 | fread(bigbuf, sizeof(uint32_t), 128, fpbp); |
nidhinvarghese | 14:f5c62d30c6fc | 483 | fwrite(bigbuf, sizeof(uint32_t), 128, fpmain); // Copy BP raw data into main file |
nidhinvarghese | 14:f5c62d30c6fc | 484 | } |
nidhinvarghese | 14:f5c62d30c6fc | 485 | fclose(fpbp); // Close BP file |
nidhinvarghese | 14:f5c62d30c6fc | 486 | fclose(fpmain); // Close Main File |
nidhinvarghese | 14:f5c62d30c6fc | 487 | |
nidhinvarghese | 14:f5c62d30c6fc | 488 | int success; |
nidhinvarghese | 14:f5c62d30c6fc | 489 | sprintf(buffer3, "/sd/%d_BP.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 490 | success = remove(buffer3); // Should return zero on success |
nidhinvarghese | 14:f5c62d30c6fc | 491 | } |
nidhinvarghese | 14:f5c62d30c6fc | 492 | |
nidhinvarghese | 14:f5c62d30c6fc | 493 | //------------New function added to print ECG data to Sd card using fwrite |
nidhinvarghese | 14:f5c62d30c6fc | 494 | void sd_ecgwrite(int *ecg_ptr) |
nidhinvarghese | 14:f5c62d30c6fc | 495 | { |
nidhinvarghese | 14:f5c62d30c6fc | 496 | fwrite(ecg_ptr, sizeof(int), 1, fpeecg); |
nidhinvarghese | 14:f5c62d30c6fc | 497 | } |
nidhinvarghese | 14:f5c62d30c6fc | 498 | |
nidhinvarghese | 14:f5c62d30c6fc | 499 | |
nidhinvarghese | 14:f5c62d30c6fc | 500 | //------------ Function to write ECG data to main file |
nikitateggi | 22:ffa88619551d | 501 | void ecgfile_mainfile(int32_t pid) |
nidhinvarghese | 14:f5c62d30c6fc | 502 | { |
nidhinvarghese | 14:f5c62d30c6fc | 503 | char buffer3[32]; |
nidhinvarghese | 14:f5c62d30c6fc | 504 | sprintf(buffer3, "/sd/%d.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 505 | fpmain = fopen(buffer3, "a"); // Main File is opened in Append mode |
nidhinvarghese | 14:f5c62d30c6fc | 506 | |
nidhinvarghese | 14:f5c62d30c6fc | 507 | sprintf(buffer3, "/sd/%d_ECG.csv", pid); // ECG file is opened in read mode |
nidhinvarghese | 14:f5c62d30c6fc | 508 | fpeecg = fopen(buffer3, "r"); |
nidhinvarghese | 14:f5c62d30c6fc | 509 | |
nidhinvarghese | 14:f5c62d30c6fc | 510 | for(int i=0; i<10; i++) |
nidhinvarghese | 14:f5c62d30c6fc | 511 | { |
nidhinvarghese | 14:f5c62d30c6fc | 512 | int bigbuf[100] = {0} ; |
nidhinvarghese | 14:f5c62d30c6fc | 513 | fread(bigbuf, sizeof(int),100 , fpeecg); |
nidhinvarghese | 14:f5c62d30c6fc | 514 | fwrite(bigbuf, sizeof(int), 100, fpmain); |
nidhinvarghese | 14:f5c62d30c6fc | 515 | } |
nidhinvarghese | 14:f5c62d30c6fc | 516 | fclose(fpeecg); // Both files are Closed |
nidhinvarghese | 14:f5c62d30c6fc | 517 | fclose(fpmain); |
nidhinvarghese | 14:f5c62d30c6fc | 518 | |
nidhinvarghese | 14:f5c62d30c6fc | 519 | /* |
nidhinvarghese | 14:f5c62d30c6fc | 520 | sprintf(buffer3, "/sd/%d_ECG.csv", pid); // ECG file is opened in write mode to empty the file |
nidhinvarghese | 14:f5c62d30c6fc | 521 | fpeecg = fopen(buffer3, "w"); |
nidhinvarghese | 14:f5c62d30c6fc | 522 | fclose(fpecg); |
nidhinvarghese | 14:f5c62d30c6fc | 523 | */ // File is closed |
nidhinvarghese | 14:f5c62d30c6fc | 524 | int success; |
nidhinvarghese | 14:f5c62d30c6fc | 525 | sprintf(buffer3, "/sd/%d_ECG.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 526 | success = remove(buffer3); |
nidhinvarghese | 14:f5c62d30c6fc | 527 | } |
nidhinvarghese | 14:f5c62d30c6fc | 528 | |
nidhinvarghese | 14:f5c62d30c6fc | 529 | |
nidhinvarghese | 14:f5c62d30c6fc | 530 | //---------------------- Function to write GLC data to GLC file |
nikitateggi | 22:ffa88619551d | 531 | void sd_glcwrite(uint32_t *glc_ptr, int32_t pid) |
nidhinvarghese | 14:f5c62d30c6fc | 532 | { |
nidhinvarghese | 14:f5c62d30c6fc | 533 | char buffer3[32]; |
nidhinvarghese | 14:f5c62d30c6fc | 534 | sprintf(buffer3, "/sd/%d_GLC.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 535 | fpbg = fopen(buffer3, "a"); |
nidhinvarghese | 14:f5c62d30c6fc | 536 | |
nidhinvarghese | 14:f5c62d30c6fc | 537 | fwrite(glc_ptr, sizeof(uint32_t), 2, fpbg); |
nidhinvarghese | 14:f5c62d30c6fc | 538 | fclose(fpbg); |
nidhinvarghese | 14:f5c62d30c6fc | 539 | |
nidhinvarghese | 14:f5c62d30c6fc | 540 | } |
nidhinvarghese | 14:f5c62d30c6fc | 541 | |
nidhinvarghese | 14:f5c62d30c6fc | 542 | // --------------------------Fuinction to write GLC data to Main file |
nidhinvarghese | 14:f5c62d30c6fc | 543 | |
nikitateggi | 22:ffa88619551d | 544 | void glcfile_mainfile(int32_t pid) |
nidhinvarghese | 14:f5c62d30c6fc | 545 | { |
nidhinvarghese | 14:f5c62d30c6fc | 546 | char buffer3[32]; |
nidhinvarghese | 14:f5c62d30c6fc | 547 | sprintf(buffer3, "/sd/%d.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 548 | fpmain = fopen(buffer3, "a"); // Main File is opened in Append mode |
nidhinvarghese | 14:f5c62d30c6fc | 549 | |
nidhinvarghese | 14:f5c62d30c6fc | 550 | sprintf(buffer3, "/sd/%d_GLC.csv", pid); // BG file is opened in read mode |
nidhinvarghese | 14:f5c62d30c6fc | 551 | fpbg = fopen(buffer3, "r"); |
nidhinvarghese | 14:f5c62d30c6fc | 552 | |
nidhinvarghese | 17:22a87e12fb3a | 553 | for(int i=0; i<1; i++) |
nidhinvarghese | 14:f5c62d30c6fc | 554 | { |
nidhinvarghese | 14:f5c62d30c6fc | 555 | int bigbuf[2] = {0} ; |
nidhinvarghese | 14:f5c62d30c6fc | 556 | fread(bigbuf, sizeof(int),2 , fpbg); |
nidhinvarghese | 14:f5c62d30c6fc | 557 | fwrite(bigbuf, sizeof(int), 2, fpmain); |
nidhinvarghese | 14:f5c62d30c6fc | 558 | } |
nidhinvarghese | 14:f5c62d30c6fc | 559 | fclose(fpbg); // Both files are Closed |
nidhinvarghese | 14:f5c62d30c6fc | 560 | fclose(fpmain); |
nidhinvarghese | 14:f5c62d30c6fc | 561 | |
nidhinvarghese | 14:f5c62d30c6fc | 562 | int success; |
nidhinvarghese | 14:f5c62d30c6fc | 563 | sprintf(buffer3, "/sd/%d_GLC.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 564 | success = remove(buffer3); // GLC file is deleted |
nidhinvarghese | 14:f5c62d30c6fc | 565 | } |
nidhinvarghese | 14:f5c62d30c6fc | 566 | |
nidhinvarghese | 14:f5c62d30c6fc | 567 | |
nikitateggi | 22:ffa88619551d | 568 | void delete_subfiles(int32_t pid) |
nidhinvarghese | 14:f5c62d30c6fc | 569 | { |
nidhinvarghese | 14:f5c62d30c6fc | 570 | char buffer3[32]; |
nidhinvarghese | 14:f5c62d30c6fc | 571 | int success1 , success2, success3; |
nidhinvarghese | 14:f5c62d30c6fc | 572 | success1 = 1 ; |
nidhinvarghese | 14:f5c62d30c6fc | 573 | sprintf(buffer3, "/sd/%d_BP.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 574 | success1 = remove(buffer3); //Removes PPG file of BP and updates status with 0 if successful |
nidhinvarghese | 14:f5c62d30c6fc | 575 | |
nidhinvarghese | 14:f5c62d30c6fc | 576 | if( success1 == 0 ) |
nidhinvarghese | 14:f5c62d30c6fc | 577 | snd.printf("\nBP file delete : Successful"); // Checks for SUCCESS |
nidhinvarghese | 14:f5c62d30c6fc | 578 | else |
nidhinvarghese | 14:f5c62d30c6fc | 579 | snd.printf("\nBP file delete : UnSuccessful"); |
nidhinvarghese | 14:f5c62d30c6fc | 580 | |
nidhinvarghese | 14:f5c62d30c6fc | 581 | success2 = 1 ; |
nidhinvarghese | 14:f5c62d30c6fc | 582 | sprintf(buffer3, "/sd/%d_GLC.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 583 | success2 = remove(buffer3); //Removes GLC file and updates status with 0 if successful |
nidhinvarghese | 14:f5c62d30c6fc | 584 | |
nidhinvarghese | 14:f5c62d30c6fc | 585 | if( success2 == 0 ) |
nidhinvarghese | 14:f5c62d30c6fc | 586 | snd.printf("\nGLC file delete : Successful"); // Checks for SUCCESS |
nidhinvarghese | 14:f5c62d30c6fc | 587 | else |
nidhinvarghese | 14:f5c62d30c6fc | 588 | snd.printf("\nGLC file delete : UnSuccessful"); |
nidhinvarghese | 14:f5c62d30c6fc | 589 | |
nidhinvarghese | 14:f5c62d30c6fc | 590 | success3 = 1 ; |
nidhinvarghese | 14:f5c62d30c6fc | 591 | sprintf(buffer3, "/sd/%d_ECG.csv", pid); |
nidhinvarghese | 14:f5c62d30c6fc | 592 | success3 = remove(buffer3); //Removes ECG file and updates status with 0 if successful |
nidhinvarghese | 14:f5c62d30c6fc | 593 | |
nidhinvarghese | 14:f5c62d30c6fc | 594 | if( success3 == 0 ) |
nidhinvarghese | 14:f5c62d30c6fc | 595 | snd.printf("\nECG file delete : Successful"); // Checks for SUCCESS |
nidhinvarghese | 14:f5c62d30c6fc | 596 | else |
nidhinvarghese | 14:f5c62d30c6fc | 597 | snd.printf("\nECG file delete : UnSuccessful"); |
nidhinvarghese | 14:f5c62d30c6fc | 598 | |
nikitateggi | 22:ffa88619551d | 599 | } |
nikitateggi | 22:ffa88619551d | 600 | |
nikitateggi | 22:ffa88619551d | 601 | |
nikitateggi | 22:ffa88619551d | 602 | uint16_t heart_cal(int pid) // Function created on 10/6/17, Function modified on 13/6/17 Nidhin |
nikitateggi | 22:ffa88619551d | 603 | // Objective ti understand how file pointers work |
nikitateggi | 22:ffa88619551d | 604 | { |
nikitateggi | 22:ffa88619551d | 605 | //FILE *fpeecg2; // Secondary File |
nikitateggi | 22:ffa88619551d | 606 | |
nikitateggi | 22:ffa88619551d | 607 | char buffer3[32]; |
nikitateggi | 22:ffa88619551d | 608 | |
nikitateggi | 22:ffa88619551d | 609 | |
nikitateggi | 22:ffa88619551d | 610 | int32_t buff1[1] ; int32_t buff2[2]; int32_t buff3[1]; // Buff 12 &3 Stores sample 1, 2 & 10th sample |
nikitateggi | 22:ffa88619551d | 611 | int32_t fppos; // Variable to hold pointer position |
nikitateggi | 22:ffa88619551d | 612 | |
nikitateggi | 22:ffa88619551d | 613 | int32_t val1_val10; // VARIABLE holding difference of sample 1 and 10 |
nikitateggi | 22:ffa88619551d | 614 | |
nikitateggi | 22:ffa88619551d | 615 | int32_t peakpos[10]; //array taht holds the peak position //Changed to 10 (ORG 4) Nidhin 20/6/17 |
nikitateggi | 22:ffa88619551d | 616 | int32_t peakval[10]; // Array holding peak values ////Changed to 10 (ORG 4) Nidhin 20/6/17 |
nikitateggi | 22:ffa88619551d | 617 | int32_t pk = 0; // Variable to access array |
nikitateggi | 22:ffa88619551d | 618 | |
nikitateggi | 22:ffa88619551d | 619 | int32_t no_of_peaks =0; // Variable holding toatl number of peaks ; increments on each peak |
nikitateggi | 22:ffa88619551d | 620 | |
nikitateggi | 22:ffa88619551d | 621 | float hrt_rate; // Heart rate in float varoable |
nikitateggi | 22:ffa88619551d | 622 | uint16_t heart_rate; // Heart rate to be type casted to int |
nikitateggi | 22:ffa88619551d | 623 | |
nikitateggi | 22:ffa88619551d | 624 | sprintf(buffer3, "/sd/%d_ECG.csv", pid); // For opening a specific file |
nikitateggi | 22:ffa88619551d | 625 | fpeecg = fopen(buffer3, "r"); |
nikitateggi | 22:ffa88619551d | 626 | |
nikitateggi | 22:ffa88619551d | 627 | /* |
nikitateggi | 22:ffa88619551d | 628 | fppos = ftell(fpeecg); |
nikitateggi | 22:ffa88619551d | 629 | snd.printf("Main pointer is at Position : %d \n", fppos); |
nikitateggi | 22:ffa88619551d | 630 | */ |
nikitateggi | 22:ffa88619551d | 631 | int32_t m =0; // Variable to move the file pointer in fseek function Org Static Nidhin 22/6/17 |
nikitateggi | 22:ffa88619551d | 632 | int32_t i =0; // Variable to count sample number, ORG Static Nidhin 22/6/17 |
nikitateggi | 22:ffa88619551d | 633 | |
nikitateggi | 22:ffa88619551d | 634 | for ( i = 0; i < 1000; i++) // for 1024 samples in file |
nikitateggi | 22:ffa88619551d | 635 | { |
nikitateggi | 22:ffa88619551d | 636 | rewind(fpeecg); // Go to satrt of file each time |
nikitateggi | 22:ffa88619551d | 637 | fseek(fpeecg, m, SEEK_CUR); // Update the count value according to move pointer |
nikitateggi | 22:ffa88619551d | 638 | |
nikitateggi | 22:ffa88619551d | 639 | fread(buff1, sizeof(int32_t), 1, fpeecg); // Read sample 1 |
nikitateggi | 22:ffa88619551d | 640 | //fpeecg2 = fpeecg; |
nikitateggi | 22:ffa88619551d | 641 | fread(buff2, sizeof(int32_t), 1, fpeecg); // Read Sample 2 |
nikitateggi | 22:ffa88619551d | 642 | |
nikitateggi | 22:ffa88619551d | 643 | int32_t n = 28; // Variable to move to 10th sampple from current |
nikitateggi | 22:ffa88619551d | 644 | |
nikitateggi | 22:ffa88619551d | 645 | |
nikitateggi | 22:ffa88619551d | 646 | fseek(fpeecg, n, SEEK_CUR); // Moving to tenth sample |
nikitateggi | 22:ffa88619551d | 647 | fread(buff3, sizeof(int32_t), 1, fpeecg); // Read 3rd sample |
nikitateggi | 22:ffa88619551d | 648 | |
nikitateggi | 22:ffa88619551d | 649 | snd.printf("buff1 = %d , buff2 = %d, buff3 = %d\n",buff1[0],buff2[0],buff3[0] ); //Test Value heald by buffer each round |
nikitateggi | 22:ffa88619551d | 650 | |
nikitateggi | 22:ffa88619551d | 651 | val1_val10 = buff1[0] - buff3[0]; // Difference of sample 1 and 10 |
nikitateggi | 22:ffa88619551d | 652 | |
nikitateggi | 22:ffa88619551d | 653 | if(buff1[0] > buff2[0] && val1_val10 > 10000) // Condition for -ve gradient and difference of 10000 |
nikitateggi | 22:ffa88619551d | 654 | { |
nikitateggi | 22:ffa88619551d | 655 | peakpos[pk] = i; // Peak detected sample number updated in array |
nikitateggi | 22:ffa88619551d | 656 | peakval[pk] = buff1[0]; // Peak value updated in array |
nikitateggi | 22:ffa88619551d | 657 | pk++; // Array pointer incremented |
nikitateggi | 22:ffa88619551d | 658 | i = i+120; // i incremented to 120 for next 120 samples |
nikitateggi | 22:ffa88619551d | 659 | no_of_peaks = no_of_peaks + 1; // no. of peaks incremented |
nikitateggi | 22:ffa88619551d | 660 | //fseek(fpeecg, 480, SEEK_CUR); // push the pointer to |
nikitateggi | 22:ffa88619551d | 661 | //fppos = ftell(fpeecg); Commenetd Nidhin 20/6/17 |
nikitateggi | 22:ffa88619551d | 662 | //snd.printf("in if : The Pointer is moved to positon %d\n", fppos); |
nikitateggi | 22:ffa88619551d | 663 | m = m + 480; |
nikitateggi | 22:ffa88619551d | 664 | |
nikitateggi | 22:ffa88619551d | 665 | } |
nikitateggi | 22:ffa88619551d | 666 | |
nikitateggi | 22:ffa88619551d | 667 | else |
nikitateggi | 22:ffa88619551d | 668 | { |
nikitateggi | 22:ffa88619551d | 669 | m = m+4; |
nikitateggi | 22:ffa88619551d | 670 | //fpeecg = fpeecg2; |
nikitateggi | 22:ffa88619551d | 671 | //i = i+1; |
nikitateggi | 22:ffa88619551d | 672 | //fppos = ftell(fpeecg); COMMENTED NIDHIN 20/6/17 |
nikitateggi | 22:ffa88619551d | 673 | //snd.printf("in Else : The Pointer is moved to positon %d\n", fppos); |
nikitateggi | 22:ffa88619551d | 674 | } |
nikitateggi | 22:ffa88619551d | 675 | } |
nikitateggi | 22:ffa88619551d | 676 | |
nikitateggi | 22:ffa88619551d | 677 | snd.printf("The No: of Peaks is %d\n", no_of_peaks); |
nikitateggi | 22:ffa88619551d | 678 | |
nikitateggi | 22:ffa88619551d | 679 | for(int j=0; j<no_of_peaks; j++) |
nikitateggi | 22:ffa88619551d | 680 | { |
nikitateggi | 22:ffa88619551d | 681 | snd.printf("The Peak %d, is at %d & value is %d\n",j, peakpos[j], peakval[j]); |
nikitateggi | 22:ffa88619551d | 682 | } |
nikitateggi | 22:ffa88619551d | 683 | |
nikitateggi | 22:ffa88619551d | 684 | // Heart rate calculation |
nikitateggi | 22:ffa88619551d | 685 | //Testing |
nikitateggi | 22:ffa88619551d | 686 | int32_t t_diff; |
nikitateggi | 22:ffa88619551d | 687 | t_diff = peakpos[1] - peakpos[0]; |
nikitateggi | 22:ffa88619551d | 688 | snd.printf("t_diff is %d\n", t_diff); |
nikitateggi | 22:ffa88619551d | 689 | |
nikitateggi | 22:ffa88619551d | 690 | hrt_rate = 60.0/(t_diff*2); |
nikitateggi | 22:ffa88619551d | 691 | //snd.printf("Hear rate in float is %f\n", hrt_rate); COMMENETD NIDHIN 20/6/17 |
nikitateggi | 22:ffa88619551d | 692 | |
nikitateggi | 22:ffa88619551d | 693 | hrt_rate = float (hrt_rate*1000); |
nikitateggi | 22:ffa88619551d | 694 | snd.printf("Hear rate in float is %f\n", hrt_rate); |
nikitateggi | 22:ffa88619551d | 695 | |
nikitateggi | 22:ffa88619551d | 696 | heart_rate = uint16_t(hrt_rate + 0.5); |
nikitateggi | 22:ffa88619551d | 697 | snd.printf("The heart rate after type casting is %d\n", heart_rate); |
nikitateggi | 22:ffa88619551d | 698 | |
nikitateggi | 22:ffa88619551d | 699 | /* |
nikitateggi | 22:ffa88619551d | 700 | fppos = ftell(fpeecg); |
nikitateggi | 22:ffa88619551d | 701 | snd.printf("The first data is = %d\n", buff1); |
nikitateggi | 22:ffa88619551d | 702 | snd.printf("The Position after reading first data is = %d\n\n", fppos); |
nikitateggi | 22:ffa88619551d | 703 | |
nikitateggi | 22:ffa88619551d | 704 | fread(buff2, sizeof(int32_t), 1, fpeecg); |
nikitateggi | 22:ffa88619551d | 705 | fppos = ftell(fpeecg); |
nikitateggi | 22:ffa88619551d | 706 | snd.printf("The Second data is = %d\n", buff2); |
nikitateggi | 22:ffa88619551d | 707 | snd.printf("The Position after reading Second data is = %d\n\n", fppos); |
nikitateggi | 22:ffa88619551d | 708 | |
nikitateggi | 22:ffa88619551d | 709 | fseek(fpeecg, 32,SEEK_CUR); |
nikitateggi | 22:ffa88619551d | 710 | |
nikitateggi | 22:ffa88619551d | 711 | fread(buff3, sizeof(int32_t), 1, fpeecg); |
nikitateggi | 22:ffa88619551d | 712 | fppos = ftell(fpeecg); |
nikitateggi | 22:ffa88619551d | 713 | snd.printf("The third data is = %d\n", buff3); |
nikitateggi | 22:ffa88619551d | 714 | snd.printf("The Position after reading Second data is = %d\n\n", fppos); |
nikitateggi | 22:ffa88619551d | 715 | |
nikitateggi | 22:ffa88619551d | 716 | fseek(fpeecg, -24,SEEK_CUR); |
nikitateggi | 22:ffa88619551d | 717 | |
nikitateggi | 22:ffa88619551d | 718 | fread(buff3, sizeof(int32_t), 1, fpeecg); |
nikitateggi | 22:ffa88619551d | 719 | fppos = ftell(fpeecg); |
nikitateggi | 22:ffa88619551d | 720 | snd.printf("The fourth data is = %d\n", buff3); |
nikitateggi | 22:ffa88619551d | 721 | snd.printf("The Position after reading fourth data is = %d\n", fppos); |
nikitateggi | 22:ffa88619551d | 722 | |
nikitateggi | 22:ffa88619551d | 723 | } |
nikitateggi | 22:ffa88619551d | 724 | /* |
nikitateggi | 22:ffa88619551d | 725 | snd.printf("Printing from 500-999\n\n"); |
nikitateggi | 22:ffa88619551d | 726 | fread(ecgbufnew, sizeof(int), 500, fpeecg); |
nikitateggi | 22:ffa88619551d | 727 | for(int i=0; i<500; i++) |
nikitateggi | 22:ffa88619551d | 728 | { |
nikitateggi | 22:ffa88619551d | 729 | //snd.printf("%d\n", ecgbufnew[i]); |
nikitateggi | 22:ffa88619551d | 730 | } |
nikitateggi | 22:ffa88619551d | 731 | |
nikitateggi | 22:ffa88619551d | 732 | rewind(fpeecg); |
nikitateggi | 22:ffa88619551d | 733 | fseek(fpeecg, 996, SEEK_SET); // Try modifying with 996 = 249*4 if not working |
nikitateggi | 22:ffa88619551d | 734 | |
nikitateggi | 22:ffa88619551d | 735 | snd.printf("Printing from 250-749\n\n"); |
nikitateggi | 22:ffa88619551d | 736 | fread(ecgbufnew, sizeof(int), 500, fpeecg); |
nikitateggi | 22:ffa88619551d | 737 | for(int i=0; i<500; i++) |
nikitateggi | 22:ffa88619551d | 738 | { |
nikitateggi | 22:ffa88619551d | 739 | //snd.printf("%d\n", ecgbufnew[i]); |
nikitateggi | 22:ffa88619551d | 740 | } |
nikitateggi | 22:ffa88619551d | 741 | */ |
nikitateggi | 22:ffa88619551d | 742 | fclose(fpeecg); |
nikitateggi | 22:ffa88619551d | 743 | return heart_rate; |
nidhinvarghese | 10:aeff3309002a | 744 | } |