Pietro Di Zinno / Mbed 2 deprecated Int_Demo_09May2017_Suhasini_HRavg_Nikita

export test

Dependencies:   SDFileSystem ds3231 eeprom_Nikita mbed testUniGraphic_150217

Fork of Int_Demo_09May2017_Suhasini_HRavg_Nikita_ili9341 by nikita teggi

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?

UserRevisionLine numberNew 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 }