main.cpp

00001 #include "PacemakerLibrary.h"
00002 #include "TextLCD.h"
00003 
00004 TextLCD lcd(p15,p16,p17,p18,p19,p20);
00005 
00006 int i=0;
00007 
00008 void incrementHeartRate()
00009 {
00010     heartRateMutex.lock();
00011     heartRate++;
00012     heartRateMutex.unlock();
00013 }
00014 
00015 void setVSignal(bool state)
00016 {
00017     VMutex.lock();
00018     waitVSignal = state;
00019     VMutex.unlock();
00020 }
00021 
00022 void setASignal(bool state)
00023 {
00024     AMutex.lock();
00025     waitASignal = state;
00026     AMutex.unlock();
00027 }
00028 
00029 void setTimeConstraint(int i)
00030 {
00031     timeConstraintMutex.lock();
00032     timeConstraint = i;
00033     timeConstraintMutex.unlock();
00034 }
00035 
00036 void printToLCD()
00037 {
00038     displayMutex.lock();
00039 //    pc.printf("%04d\r\n", avgHeartRate);
00040 //    pc.printf("%02d\r\n", pacemakerIntervalInMs/1000);
00041 //    pc.printf("%04d\r\n", (heartRateHeart*(60/sec)));
00042     lcd.cls();
00043     lcd.locate(0,0);
00044     lcd.printf("Rate: %.2f BPM", avgHeartRate);
00045     lcd.locate(0,1);
00046     switch(pacemakerMode) {
00047         default:
00048         case NORMAL: {
00049             lcd.printf("NORMAL");
00050             break;
00051         }
00052         case EXERCISE: {
00053             lcd.printf("EXERCISE");
00054             break;
00055         }
00056         case SLEEP: {
00057             lcd.printf("SLEEP (ZZZ)");
00058             break;
00059         }
00060         case MANUAL: {
00061             lcd.printf("MANUAL");
00062             break;
00063         }
00064     }
00065     displayMutex.unlock();
00066 }
00067 
00068 void println(const char *c)
00069 {
00070     pc.printf(c);
00071     pc.printf("\r\n");
00072 }
00073 
00074 void switchToNormal()
00075 {
00076     LRI = normalModeLRI;
00077     AVI = normalModeAVI;
00078     PVARP = normalModePVARP;
00079     URI = normalModeURI;
00080     VRP = normalModeVRP;
00081     PVAB = normalModePVAB;
00082 }
00083 
00084 void switchToExercise()
00085 {
00086     LRI = exerciseModeLRI;
00087     AVI = exerciseModeAVI;
00088     PVARP = exerciseModePVARP;
00089     URI = exerciseModeURI;
00090     VRP = exerciseModeVRP;
00091     PVAB = exerciseModePVAB;
00092 }
00093 
00094 void switchToSleep()
00095 {
00096     LRI = sleepModeLRI;
00097     AVI = sleepModeAVI;
00098     PVARP = sleepModePVARP;
00099     URI = sleepModeURI;
00100     VRP = sleepModeVRP;
00101     PVAB = sleepModePVAB;
00102 }
00103 
00104 void changeMode()
00105 {
00106     switch(pacemakerMode) {
00107         default:
00108         case NORMAL: {
00109             switchToNormal();
00110             break;
00111         }
00112         case EXERCISE: {
00113             switchToExercise();
00114             break;
00115         }
00116         case SLEEP: {
00117             switchToSleep();
00118             break;
00119         }
00120         case MANUAL: {
00121             break;
00122         }
00123     }
00124     changePacemakerMode=false;
00125 }
00126 
00127 void pacemakerModeSwitch(const void *args)
00128 {
00129     while(1) {
00130         Thread::signal_wait(signal3);
00131         if(changePacemakerMode) {
00132             changeMode();
00133         }
00134     }
00135 }
00136 
00137 void aSense()
00138 {
00139     if(waitASignal) {
00140         asenseLED=1;
00141         wait(0.001);
00142 //        pc.printf("ASense Received at %d ms\r\n", globalTimer.read_ms());
00143         asenseLED=0;
00144         if(changePacemakerMode) {
00145             (*P_PacemakerModeSwitch).signal_set(signal3);
00146         }
00147         ASenseReceived=true;
00148         (*P_PacemakerReceive).signal_set(signal4);
00149     }
00150 }
00151 
00152 void vSense()
00153 {
00154     if(waitVSignal) {
00155         vsenseLED=1;
00156 //        pc.printf("VSense Received at %d ms\r\n", globalTimer.read_ms());
00157         wait(0.001);
00158         vsenseLED=0;
00159         if(changePacemakerMode) {
00160             (*P_PacemakerModeSwitch).signal_set(signal3);
00161         }
00162         waitVPace=false;
00163         ASenseReceived=false;
00164         (*P_PacemakerReceive).signal_set(signal4);
00165     }
00166 }
00167 
00168 void timeConstraintTimeout(const void *args)
00169 {
00170     if(timeConstraint==AVI_const) {
00171         //trigger vpace
00172         if(waitVPace) {
00173             
00174             APace=false;
00175             (*P_PacemakerSend).signal_set(signal1);
00176             AVI+=AVISTEP;
00177             Dynamic_AVI=1;
00178             Thread::wait(1);
00179                 Dynamic_AVI=0;
00180                 
00181             if(AVI==AVI_MAX) {
00182                 
00183                 AVI=60;
00184                 
00185             }
00186             pc.printf("AVI : %u",AVI);
00187         } else {
00188             waitVPace=true;
00189         }
00190     } else if(timeConstraint==PVAB_const) {
00191         setVSignal(true);
00192         setTimeConstraint(AVI_const);
00193         TimeConstTimerOn=true;
00194         TimeConstTimer->start(AVI-PVAB);
00195     } else if(timeConstraint==VRP_const) {
00196         setVSignal(true);
00197         setTimeConstraint(PVARP_const);;
00198         TimeConstTimerOn=true;
00199         TimeConstTimer->start(PVARP-VRP);
00200     } else if(timeConstraint==PVARP_const) {
00201         setASignal(true);
00202         setTimeConstraint(LRI_const);
00203         TimeConstTimerOn=true;
00204         TimeConstTimer->start(LRI-PVARP-AVI);
00205     } else if(timeConstraint==LRI_const) {
00206         //trigger apace
00207         APace=true;
00208         (*P_PacemakerSend).signal_set(signal1);
00209     }
00210 }
00211 
00212 void atrialEventTimeout(const void *args)
00213 {
00214     if(VPaceNotReceived || waitVPace) {
00215         APace=false;
00216         VPaceNotReceived=false;
00217         (*P_PacemakerSend).signal_set(signal1);
00218     } else {
00219         waitVPace=true;
00220     }
00221 }
00222 
00223 void pacemakerReceive(const void *args)
00224 {
00225     while(1) {
00226         Thread::signal_wait(signal4);
00227         if(TimeConstTimerOn) {
00228             TimeConstTimer->stop();
00229             TimeConstTimerOn=false;
00230         }
00231         if(ASenseReceived) {
00232             setASignal(false);
00233             setVSignal(true);
00234             TimeConstTimerOn=true;
00235             setTimeConstraint(AVI_const);
00236             TimeConstTimer->start(AVI);
00237         } else {
00238             incrementHeartRate();
00239             setVSignal(false);
00240             setASignal(false);
00241             waitVPace=false;
00242             AtrialEventTimer->start(URI);
00243             TimeConstTimerOn=true;
00244             setTimeConstraint(VRP_const);
00245             TimeConstTimer->start(VRP);
00246         }
00247     }
00248 }
00249 
00250 void pacemakerSend(const void *args)
00251 {
00252     while(1) {
00253         Thread::signal_wait(signal1);
00254         if(APace) {
00255             pc.printf("APace Sent at %d ms\r\n", globalTimer.read_ms());
00256             apaceLED=1;
00257             aPace=1;
00258             Thread::wait(1);
00259             aPace=0;
00260             apaceLED=0;
00261             if(changePacemakerMode) {
00262                 changeMode();
00263             }
00264 
00265             setASignal(false);
00266             setVSignal(false);
00267             setTimeConstraint(PVAB_const);
00268             if (pacemakerMode != MANUAL) {
00269                 TimeConstTimerOn=true;
00270                 TimeConstTimer->start(PVAB);
00271             }
00272         } else {
00273             pc.printf("VPace Sent at %d ms\r\n", globalTimer.read_ms());
00274             vpaceLED=1;
00275             vPace=1;
00276             Thread::wait(1);
00277             vPace=0;
00278             vpaceLED=0;
00279             if(changePacemakerMode) {
00280                 changeMode();
00281             }
00282 
00283             setVSignal(false);
00284             setASignal(false);
00285             incrementHeartRate();
00286             waitVPace=false;
00287             AtrialEventTimer->start(URI);
00288             setTimeConstraint(VRP_const);
00289             TimeConstTimerOn=true;
00290             if (pacemakerMode != MANUAL) {
00291                 TimeConstTimerOn=true;
00292                 TimeConstTimer->start(VRP);
00293             }
00294         }
00295     }
00296 }
00297 
00298 void readInt()
00299 {
00300     char c = pc.getc();
00301     int input = c-48;
00302     c = pc.getc();
00303     while (c != '\r') {
00304         input *= 10;
00305         input += c-48;
00306         c = pc.getc();
00307     }
00308 
00309     if (input >= 10 && input <= 90) {
00310         pacemakerInterval=input;
00311         pacemakerIntervalInMs = pacemakerInterval*1000;
00312         displayTimer.reset();
00313         heartRateMutex.lock();
00314         heartRate=0;
00315         heartRateMutex.unlock();
00316         pc.printf("Obs Int Changed: %d\r\n", pacemakerInterval);
00317     } else {
00318         pc.printf("Bad Obs Int: %d\r\n", input);
00319     }
00320 }
00321 
00322 void pacemakerKeyboard(const void *args)
00323 {
00324     while(1) {
00325         Thread::signal_wait(signal2);
00326         if (char_read == 'a' && pacemakerMode == MANUAL) {
00327             APace=true;
00328             (*P_PacemakerSend).signal_set(signal1);
00329         } else if (char_read == 'v' && pacemakerMode == MANUAL) {
00330             if(waitVPace) {
00331                 APace=false;
00332                 VPaceNotReceived=false;
00333                 (*P_PacemakerSend).signal_set(signal1);
00334             } else {
00335                 VPaceNotReceived=true;
00336             }
00337         } else if (char_read == 'n' && pacemakerMode != NORMAL && !changePacemakerMode) {
00338             if (pacemakerMode == MANUAL) {
00339                 // restart A/V timers
00340                 TimeConstTimerOn=true;
00341                 TimeConstTimer->start(VRP);
00342             }
00343             pacemakerMode=NORMAL;
00344             changePacemakerMode=true;
00345         } else if (char_read == 'e' && pacemakerMode != EXERCISE && !changePacemakerMode) {
00346             if (pacemakerMode == MANUAL) {
00347                 // restart A/V timers
00348                 TimeConstTimer->start(VRP);
00349             }
00350             pacemakerMode=EXERCISE;
00351             changePacemakerMode=true;
00352         } else if (char_read == 's' && pacemakerMode != SLEEP && !changePacemakerMode) {
00353             if (pacemakerMode == MANUAL) {
00354                 // restart A/V timers
00355                 TimeConstTimer->start(VRP);
00356             }
00357             pacemakerMode=SLEEP;
00358             changePacemakerMode=true;
00359         } else if (char_read == 'm' && pacemakerMode != MANUAL && !changePacemakerMode) {
00360             pacemakerMode=MANUAL;
00361             changePacemakerMode=true;
00362         } else if (char_read == 'o' && !changePacemakerMode) {
00363             // blocks, reading characters, until "return" is pressed
00364             observationMutex.lock();
00365             readInt();
00366             observationMutex.unlock();
00367         }
00368     }
00369 }
00370 
00371 void pacemakerAlarm(const void *args)
00372 {
00373     while(1) {
00374         Thread::signal_wait(signal5);
00375         while(avgHeartRate > (60000/URI)) {
00376             buzzer=1;
00377             Thread::wait(5);
00378             buzzer=0;
00379             Thread::wait(5);
00380             if(!alarmPrinted) {
00381                 displayMutex.lock();
00382                 println("!!!***Alarm High***!!!");
00383                 displayMutex.unlock();
00384                 alarmPrinted=true;
00385             }
00386         }
00387         while(avgHeartRate < (60000/LRI)) {
00388             buzzer=1;
00389             Thread::wait(10);
00390             buzzer=0;
00391             Thread::wait(10);
00392             if(!alarmPrinted) {
00393                 displayMutex.lock();
00394                 println("!!!***Alarm Low***!!!");
00395                 displayMutex.unlock();
00396                 alarmPrinted=true;
00397             }
00398         }
00399         if(alarmPrinted) {
00400             alarmPrinted=false;
00401 //            resetDisplay();
00402         }
00403     }
00404 }
00405 
00406 void display(const void *args)
00407 {
00408     displayTimer.start();
00409 
00410     while(1) {
00411         observationMutex.lock();
00412         if (displayTimer.read_ms() >= pacemakerIntervalInMs) {
00413             displayTimer.reset();
00414             printToLCD();
00415             avgHeartRate=heartRate*(60.0/pacemakerInterval);
00416             heartRateMutex.lock();
00417             heartRate=0;
00418             heartRateMutex.unlock();
00419             observationMutex.unlock();
00420             (*P_PacemakerAlarm).signal_set(signal5);
00421         } else {
00422             printToLCD();
00423             observationMutex.unlock();
00424             Thread::wait(100);
00425         }
00426     }
00427 }
00428 
00429 int main()
00430 {
00431     setVSignal(true);
00432     setVSignal(true);
00433     switchToNormal();
00434 
00435     ASignal.rise(&aSense);
00436     VSignal.rise(&vSense);
00437 
00438     TimeConstTimer = new RtosTimer(timeConstraintTimeout, osTimerOnce, (void*)0);
00439     AtrialEventTimer = new RtosTimer(atrialEventTimeout, osTimerOnce, (void *)0);
00440 
00441     Thread PacemakerSend(pacemakerSend);
00442     P_PacemakerSend=&PacemakerSend;
00443     PacemakerSend.set_priority(osPriorityHigh);
00444 
00445     Thread PacemakerReceive(pacemakerReceive);
00446     P_PacemakerReceive=&PacemakerReceive;
00447     PacemakerReceive.set_priority(osPriorityAboveNormal);
00448 
00449     Thread PacemakerModeSwitch(pacemakerModeSwitch);
00450     P_PacemakerModeSwitch=&PacemakerModeSwitch;
00451     PacemakerModeSwitch.set_priority(osPriorityAboveNormal);
00452 
00453     Thread PacemakerKeyboard(pacemakerKeyboard);
00454     P_PacemakerKeyboard=&PacemakerKeyboard;
00455     PacemakerKeyboard.set_priority(osPriorityRealtime);
00456 
00457     Thread Display(display);
00458     Display.set_priority(osPriorityAboveNormal);
00459 
00460     Thread PacemakerAlarm(pacemakerAlarm);
00461     P_PacemakerAlarm = &PacemakerAlarm;
00462     PacemakerAlarm.set_priority(osPriorityAboveNormal);
00463 
00464     setTimeConstraint(VRP_const);
00465     TimeConstTimer->start(VRP);
00466 
00467     globalTimer.start();
00468 
00469     while(1) {
00470         if(pc.readable()) {
00471             char_read = pc.getc();
00472             (*P_PacemakerKeyboard).signal_set(signal2);
00473         }
00474     }
00475 }