heart.cpp

00001 #include "mbed.h"
00002 #include "rtos.h"
00003 #include "Terminal.h"
00004 
00005 DigitalOut led1(LED1);          //asense
00006 DigitalOut led2(LED2);          //vsense
00007 DigitalOut led3(LED3);          //apace 
00008 DigitalOut led4(LED4);          //vpace
00009 DigitalOut aSense(p23);
00010 DigitalOut vSense(p24);
00011 InterruptIn APace(p25);
00012 InterruptIn VPace(p26);
00013 
00014 Terminal console(USBTX, USBRX);
00015 
00016 int heartRate, avgHeartRate, observationInterval, rateCoefficient, observationRate, waitCount, senseWaitTime, testCase, changeModeTo;
00017 int heartMode;                             //0 - Normal, 1 - Manual, 2 - Test
00018 bool observationChange, digitOneReceived, paceReceived, synchDone, testOn, testResult[10]={false}, digitTwoReceived, changeMode, receivedVPace;
00019 char ch;
00020 char modeString[10];
00021 
00022 const int nLRI=1500, nAVI = 60, nPVARP = 150, nURI = 600, nVRP = 100;   //timing constraints for Normal Mode of the Pacemaker
00023 const int delta=20;
00024 
00025 osMutexId displayMutex;
00026 osMutexDef (displayMutex);
00027 osMutexId observationChangeMutex;
00028 osMutexDef(obserationChangeMutex);
00029 osMutexId heartRateMutex;
00030 osMutexDef (heartRateMuex);
00031 
00032 Thread *SerialThreadPTR;
00033 Thread *HeartSensePTR;
00034 Thread *TestModePTR;
00035 Thread *TestDisplayPTR;
00036 RtosTimer *KeyTimeOutTimer;
00037 RtosTimer *SenseWaitTimer;
00038 //testCode
00039 Timer t;
00040 
00041 void resetDisplay()
00042 {
00043     osMutexWait(displayMutex, osWaitForever);
00044     console.cls();
00045     console.locate(30, 6);
00046     console.printf("Heart Display");
00047     console.locate(30, 10);
00048     console.printf("Heart Rate :  %04d bpm", avgHeartRate);
00049     console.locate(30, 12);
00050     console.printf("Observation Interval :  %02d seconds", observationInterval/1000);
00051     console.locate(30, 14);
00052     console.printf("Mode :  %s", modeString);
00053     osMutexRelease(displayMutex);
00054 }
00055 
00056 void updateDisplay()
00057 {
00058     osMutexWait(displayMutex, osWaitForever);
00059     console.locate(44, 10);
00060     console.printf("%04d", avgHeartRate);
00061     console.locate(54, 12);
00062     console.printf("%02d", observationInterval/1000);
00063     osMutexRelease(displayMutex);
00064 }   
00065 
00066 
00067 void heartSense(const void *args)
00068 {
00069     while(1)
00070     {
00071         if(heartMode>0)
00072         {
00073             Thread::signal_wait(0x02);
00074         }
00075         //Thread::wait(500);              //chnage this
00076         senseWaitTime=50+(rand()%2000);
00077         SenseWaitTimer->start(senseWaitTime);
00078         Thread::signal_wait(0x03);
00079         if(rand()%2==0)
00080         {
00081             led1=1;
00082             aSense=1;
00083             Thread::wait(1);
00084             aSense=0;
00085             led1=0;
00086         }
00087         else
00088         {
00089             led2=1;
00090             vSense=1;
00091             Thread::wait(1);
00092             vSense=0;
00093             led2=0;
00094             osMutexWait(heartRateMutex, osWaitForever);
00095             heartRate++;
00096             osMutexRelease(heartRateMutex);
00097             
00098         }
00099     }
00100 }
00101 
00102 void display(const void *args)
00103 {
00104     while(1)
00105     {
00106         Thread::wait(observationInterval);
00107         if(heartMode!=2)
00108         {
00109             waitCount++;
00110             if(!observationChange)
00111             {
00112                 avgHeartRate=heartRate*rateCoefficient/waitCount;
00113                 osMutexWait(heartRateMutex, osWaitForever);
00114                 heartRate=0;
00115                 osMutexRelease(heartRateMutex);
00116                 if(observationRate!=(observationInterval/1000))
00117                 {
00118                     resetDisplay();
00119                     //update observationrate after the current interval stats  are displayed
00120                     observationInterval=observationRate*1000;           
00121                     rateCoefficient=(60000/observationInterval);
00122                 } 
00123                 else
00124                 {
00125                     updateDisplay();
00126                 }
00127                 waitCount=0;   
00128             }        
00129         }
00130     }
00131 }
00132 
00133 void senseWait(const void *args)
00134 {
00135     (*HeartSensePTR).signal_set(0x03);
00136 }
00137 
00138 void keyTimeOut(const void *args)
00139 {
00140     if(digitOneReceived)
00141     {
00142         observationChange=false;
00143     }
00144     else
00145     {
00146         observationChange=false;
00147     }
00148     resetDisplay();
00149 }
00150 
00151 void testMode(const void *args)
00152 {
00153     while(1)
00154     {
00155         if(heartMode!=2)
00156         {
00157             Thread::signal_wait(0x04);  
00158         }
00159         else
00160         {
00161             osMutexWait(displayMutex, osWaitForever);
00162             console.cls();
00163             osMutexRelease(displayMutex);
00164             //synch with PM
00165             //TestCase 1 - Asense at PVARP+; No Vpace within URI-PVARP (detected within URI-PVARP+delta) 
00166             testCase=0;
00167             testResult[testCase]=true;
00168             osMutexWait(displayMutex, osWaitForever);
00169             console.locate(20,testCase);
00170             osMutexRelease(displayMutex);
00171             synchDone=false;
00172             Thread::signal_wait(0x05);
00173             synchDone=true;
00174             t.reset();
00175             t.start();
00176             Thread::wait(nPVARP);
00177             led1=1;
00178             aSense=1;
00179             Thread::wait(1);
00180             aSense=0;
00181             led1=0;
00182             osMutexWait(displayMutex, osWaitForever);
00183             console.printf("AS : %d      ",t.read_ms());
00184             osMutexRelease(displayMutex);
00185             testOn=true;
00186             Thread::wait(nURI-nPVARP-delta);
00187             testOn=false;
00188             if(testResult[testCase])
00189             {
00190                 osMutexWait(displayMutex, osWaitForever);
00191                 console.locate(0,testCase);
00192                 console.printf("test %d pass",testCase+1);
00193                 osMutexRelease(displayMutex);
00194             }
00195             else
00196             {
00197                 osMutexWait(displayMutex, osWaitForever);
00198                 console.locate(0,testCase);
00199                 console.printf("test %d fail",testCase+1);
00200                 osMutexRelease(displayMutex);                
00201             }
00202             
00203             //synch with PM
00204             //TestCase 2 - Asense at URI+; Vpace within AVI+delta
00205             testCase=1;
00206             osMutexWait(displayMutex, osWaitForever);
00207             console.locate(20,testCase);
00208             osMutexRelease(displayMutex);
00209             synchDone=false;
00210             Thread::signal_wait(0x05);
00211             synchDone=true;
00212             t.reset();
00213             Thread::wait(nURI);
00214             led1=1;
00215             aSense=1;
00216             Thread::wait(1);
00217             aSense=0;
00218             led1=0;
00219             osMutexWait(displayMutex, osWaitForever);
00220             console.printf("AS : %d      ",t.read_ms());
00221             osMutexRelease(displayMutex);
00222             testOn=true;
00223             Thread::wait(nAVI+delta);
00224             testOn=false;
00225             if(testResult[testCase])
00226             {
00227                 osMutexWait(displayMutex, osWaitForever);
00228                 console.locate(0,testCase);
00229                 console.printf("test %d pass",testCase+1);
00230                 osMutexRelease(displayMutex);
00231             }
00232             else
00233             {
00234                 osMutexWait(displayMutex, osWaitForever);
00235                 console.locate(0,testCase);
00236                 console.printf("test %d fail",testCase+1);
00237                 osMutexRelease(displayMutex);                
00238             }     
00239             //synch with PM
00240             //TestCase 3 - Asense at URI+; Vsense at AVI-; No pace detected; run this 4 times
00241             testCase=2;
00242             testResult[testCase]=true;
00243             synchDone=false;
00244             Thread::signal_wait(0x05);
00245             synchDone=true;
00246             t.reset();
00247             Thread::wait(nURI);
00248             testOn=true;
00249             for(int i=0;i<5;i++)
00250             {
00251                 /*osMutexWait(displayMutex, osWaitForever);
00252                 console.locate(20,testCase);
00253                 osMutexRelease(displayMutex);*/
00254                 led1=1;
00255                 aSense=1;
00256                 Thread::wait(1);
00257                 aSense=0;
00258                 led1=0;
00259                 /*osMutexWait(displayMutex, osWaitForever);
00260                 console.printf("AS : %d      ",t.read_ms());
00261                 osMutexRelease(displayMutex);*/
00262                 Thread::wait(nAVI-delta);
00263                 led2=1;
00264                 vSense=1;
00265                 Thread::wait(1);
00266                 vSense=0;
00267                 led2=0;  
00268                 /*osMutexWait(displayMutex, osWaitForever);
00269                 console.printf("VS : %d      ",t.read_ms());
00270                 osMutexRelease(displayMutex);*/
00271                 Thread::wait(nLRI-nAVI-delta);                             
00272             }
00273             testOn=false;
00274             if(testResult[testCase])
00275             {
00276                 osMutexWait(displayMutex, osWaitForever);
00277                 console.locate(0,testCase);
00278                 console.printf("test %d pass",testCase+1);
00279                 osMutexRelease(displayMutex);
00280             }
00281             else
00282             {
00283                 osMutexWait(displayMutex, osWaitForever);
00284                 console.locate(0,testCase);
00285                 console.printf("test %d fail",testCase+1);
00286                 osMutexRelease(displayMutex);                
00287             }
00288             //synch with PM
00289             //TestCase 4 - No sensing;Only pacing;
00290             testCase=3;
00291             synchDone=false;
00292             Thread::signal_wait(0x05);
00293             synchDone=true;
00294             t.reset();
00295             testOn=true;
00296             for(int i=0;i<1;i++)
00297             {
00298                 osMutexWait(displayMutex, osWaitForever);
00299                 console.locate(20,testCase);
00300                 osMutexRelease(displayMutex);
00301                 t.reset();
00302                 testResult[testCase]=false;
00303                 Thread::wait(nLRI-nAVI+delta);
00304                 if(!testResult[testCase])
00305                 {
00306                     console.printf("Here");
00307                     break;
00308                 }
00309                 testResult[testCase]=false;           
00310                 Thread::wait(nAVI);    
00311                 if(!testResult[testCase])
00312                 {
00313                     console.printf("There");
00314                     break;
00315                 }
00316             }
00317             testOn=false;
00318             if(testResult[testCase])
00319             {
00320                 osMutexWait(displayMutex, osWaitForever);
00321                 console.locate(0,testCase);
00322                 console.printf("test %d pass",testCase+1);
00323                 osMutexRelease(displayMutex);
00324             }
00325             else
00326             {
00327                 osMutexWait(displayMutex, osWaitForever);
00328                 console.locate(0,testCase);
00329                 console.printf("test %d fail",testCase+1);
00330                 osMutexRelease(displayMutex);                
00331             }
00332 
00333             //synch with PM
00334             //TestCase 5 - Vsense at VRP+; APace at LRI-AVI+delta
00335             testCase=4;
00336             testResult[testCase]=false;
00337             osMutexWait(displayMutex, osWaitForever);
00338             console.locate(20,testCase);
00339             osMutexRelease(displayMutex);
00340             synchDone=false;
00341             Thread::signal_wait(0x05);
00342             synchDone=true;
00343             t.reset();
00344             Thread::wait(nPVARP);
00345             led2=1;
00346             vSense=1;
00347             Thread::wait(1);
00348             vSense=0;
00349             led2=0;
00350             osMutexWait(displayMutex, osWaitForever);
00351             console.printf("VS : %d      ",t.read_ms());
00352             osMutexRelease(displayMutex);
00353             testOn=true;
00354             Thread::wait(nLRI-nAVI+delta);
00355             testOn=false;
00356             if(testResult[testCase])
00357             {
00358                 osMutexWait(displayMutex, osWaitForever);
00359                 console.locate(0,testCase);
00360                 console.printf("test %d pass",testCase+1);
00361                 osMutexRelease(displayMutex);
00362             }
00363             else
00364             {
00365                 osMutexWait(displayMutex, osWaitForever);
00366                 console.locate(0,testCase);
00367                 console.printf("test %d fail",testCase+1);
00368                 osMutexRelease(displayMutex);                
00369             }
00370             
00371             //synch with PM
00372             //TestCase 6 - Asense at VRP+ (within PVARP); A pace should come at LRI-AVI+delta and no VPace should come
00373             testCase=5;
00374             testResult[testCase]=false;
00375             osMutexWait(displayMutex, osWaitForever);
00376             console.locate(20,testCase);
00377             osMutexRelease(displayMutex);
00378             synchDone=false;
00379             Thread::signal_wait(0x05);
00380             synchDone=true;
00381             t.reset();
00382             Thread::wait(nVRP);
00383             led1=1;
00384             aSense=1;
00385             Thread::wait(1);
00386             aSense=0;
00387             led1=0;
00388             osMutexWait(displayMutex, osWaitForever);
00389             console.printf("AS : %d      ",t.read_ms());
00390             osMutexRelease(displayMutex);
00391             testOn=true;
00392             Thread::wait(nLRI-nAVI-nVRP+delta);
00393             testOn=false;
00394             if(testResult[testCase])
00395             {
00396                 osMutexWait(displayMutex, osWaitForever);
00397                 console.locate(0,testCase);
00398                 console.printf("test %d pass",testCase+1);
00399                 osMutexRelease(displayMutex);
00400             }
00401             else
00402             {
00403                 osMutexWait(displayMutex, osWaitForever);
00404                 console.locate(0,testCase);
00405                 console.printf("test %d fail",testCase+1);
00406                 osMutexRelease(displayMutex);                
00407             }
00408             
00409             //synch with PM
00410             //TestCase 7 - Vsense at VRP-; Asense should come at LRI-AVI+delta; Asense does not come after that, which would happen if Vsense was accepted
00411             testCase=6;
00412             testResult[testCase]=false;
00413             osMutexWait(displayMutex, osWaitForever);
00414             console.locate(20,testCase);
00415             osMutexRelease(displayMutex);
00416             synchDone=false;
00417             Thread::signal_wait(0x05);
00418             synchDone=true;
00419             t.reset();
00420             Thread::wait(nVRP-delta-10);            //give vSense within VRP
00421             led2=1;
00422             vSense=1;
00423             Thread::wait(1);
00424             vSense=0;
00425             led2=0;
00426             osMutexWait(displayMutex, osWaitForever);
00427             console.printf("VS : %d      ",t.read_ms());
00428             osMutexRelease(displayMutex);
00429             testOn=true;
00430             Thread::wait(nLRI-nAVI-nVRP+(2*delta)+10);
00431             testOn=false;
00432             if(testResult[testCase])
00433             {
00434                 osMutexWait(displayMutex, osWaitForever);
00435                 console.locate(0,testCase);
00436                 console.printf("test %d pass",testCase+1);
00437                 osMutexRelease(displayMutex);
00438             }
00439             else
00440             {
00441                 osMutexWait(displayMutex, osWaitForever);
00442                 console.locate(0,testCase);
00443                 console.printf("test %d fail",testCase+1);
00444                 osMutexRelease(displayMutex);                
00445             }
00446             t.stop();
00447             //synch with PM
00448             //TestCase 8 - Alarm High case; generate Asense and Vsense at very high rate
00449             testCase=7;
00450             testResult[testCase]=false;
00451             osMutexWait(displayMutex, osWaitForever);
00452             console.locate(0,testCase);
00453             console.printf("Alarm High");
00454             osMutexRelease(displayMutex);
00455             synchDone=false;
00456             Thread::signal_wait(0x05);
00457             synchDone=true;
00458             for(int i=0;i<5000;i++)
00459             {
00460                 led1=1;
00461                 aSense=1;
00462                 Thread::wait(1);
00463                 aSense=0;
00464                 led1=0;
00465                 led2=1;
00466                 vSense=1;
00467                 Thread::wait(1);
00468                 vSense=0;
00469                 led2=0;                            
00470             }
00471             osMutexWait(displayMutex, osWaitForever);
00472             console.locate(0,testCase+1);
00473             console.printf("Testing Complete");
00474             osMutexRelease(displayMutex);
00475             
00476         }
00477         if(changeMode)
00478         {
00479             changeMode=false;
00480             if(changeModeTo==0)
00481             {
00482                 heartMode=0;
00483                 strcpy(modeString,"Random");
00484                 osMutexWait(displayMutex, osWaitForever);
00485                 console.cls();
00486                 console.locate(30, 10);
00487                 console.printf("Heart Rate :  %03d bpm", avgHeartRate);
00488                 console.locate(30, 12);
00489                 console.printf("Observation Interval :  %02d seconds", observationInterval/1000);
00490                 console.locate(30, 14);
00491                 console.printf("Mode :  %s", modeString);
00492                 osMutexRelease(displayMutex);
00493                 (*HeartSensePTR).signal_set(0x02);
00494             }
00495             else
00496             {
00497                 heartMode=1;
00498                 strcpy(modeString,"Manual");
00499                 osMutexWait(displayMutex, osWaitForever);
00500                 console.cls();
00501                 console.locate(30, 10);
00502                 console.printf("Heart Rate :  %03d bpm", avgHeartRate);
00503                 console.locate(30, 12);
00504                 console.printf("Observation Interval :  %02d seconds", observationInterval/1000);
00505                 console.locate(30, 14);
00506                 console.printf("Mode :  %s", modeString);
00507                 osMutexRelease(displayMutex);
00508             }
00509             
00510         }
00511     }
00512 }
00513 
00514 void aPace()
00515 {
00516     if(heartMode==0)
00517     {
00518         SenseWaitTimer->start(50+(rand()%2000));         //TODO move this
00519     }
00520     led3=1;
00521     wait(0.01);
00522     led3=0;
00523     if(heartMode==2 && testOn)
00524     {
00525          receivedVPace=false;
00526         (*TestDisplayPTR).signal_set(0x06);
00527         if(testCase==2)
00528         {
00529             testResult[testCase]=false;            
00530         }
00531         else if(testCase==3 || testCase==4 || testCase==5 || testCase==6)
00532         {
00533              testResult[testCase]=true;   
00534         }
00535     }
00536 }
00537 
00538 void vPace()
00539 {
00540     if(heartMode==0)
00541     {
00542         SenseWaitTimer->start(50+(rand()%2000));         //TODO move this
00543     }
00544     led4=1;
00545     wait(0.01);
00546     led4=0;
00547     osMutexWait(heartRateMutex, osWaitForever);
00548     heartRate++;
00549     osMutexRelease(heartRateMutex);
00550     if(heartMode==2 && !synchDone)
00551     {
00552         (*TestModePTR).signal_set(0x05);
00553     }
00554     if(heartMode==2 && testOn)
00555     {
00556         receivedVPace=true;
00557         (*TestDisplayPTR).signal_set(0x06);
00558         if(testCase==0 || testCase==2 || testCase==5 || testCase==6)
00559         {
00560             testResult[testCase]=false;            
00561         }
00562         else if(testCase==1 || testCase==3)
00563         {
00564             testResult[testCase]=true;
00565         }
00566     }
00567 }
00568 
00569 void testDisplay(const void *args)
00570 {
00571     while(1)
00572     {
00573         Thread::signal_wait(0x06);
00574         if(receivedVPace)
00575         {
00576             osMutexWait(displayMutex, osWaitForever);
00577             console.printf("VP : %d      ",t.read_ms());
00578             osMutexRelease(displayMutex);
00579         }
00580         else
00581         {
00582             osMutexWait(displayMutex, osWaitForever);
00583             console.printf("AP : %d      ",t.read_ms());
00584             osMutexRelease(displayMutex);           
00585         }
00586     }
00587 }
00588         
00589 
00590 void serialThread(const void *args)
00591 {
00592     while(1)
00593     {
00594         Thread::signal_wait(0x01);
00595         if((((ch=='a')||(ch=='A')) && heartMode==1) && !observationChange)
00596         {
00597             //fire A Signal
00598             led1=1;
00599             aSense=1;
00600             Thread::wait(1);
00601             led1=0;
00602             aSense=0;
00603         }
00604         else if((((ch=='v')||(ch=='V')) && heartMode==1) && !observationChange)
00605         {
00606             //fire V Signal
00607             led2=1;
00608             vSense=1;
00609             Thread::wait(1);
00610             vSense=0;
00611             led2=0;
00612             osMutexWait(heartRateMutex, osWaitForever);
00613             heartRate++;
00614             osMutexRelease(heartRateMutex);
00615         }
00616         else if(((((ch=='r')||(ch=='R'))&& heartMode!=0) && !observationChange) && !changeMode)
00617         {
00618             if(heartMode==2)
00619             {
00620                 changeMode=true;
00621                 changeModeTo=0;
00622                 console.locate(30, 14);
00623                 console.printf("Mode :  %s (Pending - Random)", modeString);                
00624             }
00625             else
00626             {                
00627                 heartMode=0;
00628                 strcpy(modeString,"Random");
00629                 resetDisplay();
00630                 (*HeartSensePTR).signal_set(0x02);
00631             }
00632         }
00633         else if(((((ch=='m')||(ch=='M')) && heartMode!=1) && !observationChange) && !changeMode)
00634         {
00635             if(heartMode==2)
00636             {
00637                 changeMode=true;
00638                 changeModeTo=1;
00639                 console.locate(30, 14);
00640                 console.printf("Mode :  %s (Pending - Manual)", modeString);
00641             }
00642             else
00643             {
00644                 heartMode=1;
00645                 strcpy(modeString,"Manual");
00646                 resetDisplay();
00647             }
00648         }
00649         else if((((ch=='t')||(ch=='T')) && heartMode!=2) && !observationChange)
00650         {
00651             heartMode=2;            //spawn Test Thread
00652             strcpy(modeString,"Test");
00653             resetDisplay();
00654             (*TestModePTR).signal_set(0x04);
00655         }
00656         else if((((ch=='o')||(ch=='O')) && !observationChange) && heartMode!=2)
00657         {
00658             observationChange=true;
00659             digitOneReceived=false;
00660             digitTwoReceived=false;
00661             //spawn a timer for  3 seconds
00662             osMutexWait(displayMutex, osWaitForever);
00663             console.locate(29, 16);
00664             console.printf("Observation Interval change : -- seconds");
00665             osMutexRelease(displayMutex);
00666             KeyTimeOutTimer=new RtosTimer(keyTimeOut, osTimerOnce, (void *)0);
00667             KeyTimeOutTimer->start(3000);
00668         }
00669         else if((observationChange) && ((ch>=48) && (ch<=57)) && !digitTwoReceived)
00670         {
00671             if(!digitOneReceived)
00672             {
00673                 KeyTimeOutTimer->start(3000);                       //key time out is 3 seconds
00674                 osMutexWait(observationChangeMutex, osWaitForever);         //mutex to be released either on time out or if 2 digits are received
00675                 observationRate=ch-'0';
00676                 osMutexRelease(observationChangeMutex);
00677                 digitOneReceived=true;
00678                 osMutexWait(displayMutex, osWaitForever);
00679                 console.locate(60, 16);
00680                 console.printf("%02d", observationRate);
00681                 osMutexRelease(displayMutex);
00682             }
00683             else
00684             {
00685                 KeyTimeOutTimer->stop();
00686                 digitTwoReceived=true;
00687                 osMutexWait(observationChangeMutex, osWaitForever);
00688                 observationRate=(observationRate*10)+(ch-'0');
00689                 osMutexRelease(observationChangeMutex);
00690                 observationChange=false;
00691                 osMutexWait(displayMutex, osWaitForever);
00692                 console.locate(60, 16);
00693                 console.printf("%02d", observationRate);
00694                 osMutexRelease(displayMutex);
00695             }
00696         }                
00697     }
00698 }
00699 
00700 // Interupt Routine to read in data from serial port and call the serial thread
00701 void Rx_interrupt() 
00702 {
00703     if(console.readable())
00704     {
00705         ch=LPC_UART0->RBR;                  //read uart buffer data and clear the interrupt flag
00706         (*SerialThreadPTR).signal_set(0x01);     //initiate the serial thread to change the state of the timer
00707     }
00708     
00709 }
00710 
00711 
00712 int main() 
00713 {
00714     console.attach(&Rx_interrupt, Serial::RxIrq);        //attach a uart interrupt for uart
00715     console.cls();
00716     console.locate(30, 6);
00717     console.printf("Heart Display");
00718     console.locate(30, 10);
00719     console.printf("Heart Rate :  ---- bpm");
00720     console.locate(30, 12);
00721     console.printf("Observation Interval :  -- seconds");
00722     console.locate(30, 14);
00723     console.printf("Mode :  Random ");
00724     
00725     //initialize variables
00726     heartMode=0;
00727     heartRate=0;
00728     avgHeartRate=0;
00729     waitCount=0;
00730     observationInterval=5000;
00731     rateCoefficient=(60000/observationInterval);
00732     observationChange=false;
00733     observationRate=5;
00734     digitOneReceived=false;
00735     strcpy(modeString,"Random");
00736     synchDone=true;
00737     testCase=0;
00738     testOn=false;
00739     digitTwoReceived=false;
00740     changeMode=false;
00741     changeModeTo=0;
00742     receivedVPace=false;
00743     
00744     SenseWaitTimer=new RtosTimer(senseWait, osTimerOnce, (void *)0);
00745     Thread SerialThread(serialThread);
00746     SerialThreadPTR=&SerialThread;
00747     SerialThread.set_priority(osPriorityRealtime);
00748     Thread HeartSense(heartSense);
00749     HeartSensePTR=&HeartSense;
00750     HeartSense.set_priority(osPriorityHigh);
00751     Thread Display(display);
00752     Display.set_priority(osPriorityAboveNormal);
00753     Thread TestMode(testMode);
00754     TestModePTR=&TestMode;
00755     TestMode.set_priority(osPriorityAboveNormal);
00756     Thread TestDisplay(testDisplay);
00757     TestDisplayPTR=&TestDisplay;
00758     TestDisplay.set_priority(osPriorityHigh);
00759     APace.fall(&aPace);
00760     VPace.fall(&vPace);
00761     
00762     while(1);
00763 }