main.cpp

00001 #include "mbed.h"
00002 #include "rtos.h"
00003 #include "TextLCD.h"
00004  
00005 LocalFileSystem local("local");
00006  
00007 InterruptIn vpace(p5);
00008 InterruptIn apace(p6);
00009 DigitalOut vsignal(p7);
00010 DigitalOut asignal(p8);
00011  
00012 DigitalOut asignal_led(LED1);
00013 DigitalOut vsignal_led(LED2);
00014 DigitalOut apace_led(LED3);
00015 DigitalOut vpace_led(LED4);
00016  
00017 Thread *heartmodeThread;
00018 osThreadId heartmodeTid;
00019 osThreadId beats;
00020 osThreadId displayTid;
00021 osThreadId HeartSenseTid;
00022 osThreadId ledTid;
00023 Timer vClock;
00024  
00025 Queue<char,256> mode_q;
00026 Queue<char,256> signal_q;
00027 Queue<char,256> obsint_q;
00028  
00029 FILE * testresults;
00030  
00031 TextLCD lcd(p15, p16, p17, p18, p19, p20, TextLCD::LCD16x2);
00032 RawSerial pc(USBTX, USBRX);
00033 char key = 'n';
00034 int manual_mode;
00035  
00036 volatile char c;
00037 volatile int mm = 0;
00038  
00039 volatile int om = 0;
00040 int lri = 1000;
00041 int uri = 700;
00042 int avi = 150;
00043 int pvarp = 300;
00044 int vrp = 200;
00045 int arp = 25;
00046  
00047  
00048 int twait = 10;
00049 int thrsh = 1000;
00050 int heartmode = 0;
00051 int v_led = 0;
00052 int vp_led = 0;
00053 int observation_interval = 10000; // In miliseconds
00054 int tmm = 0; //testmode flag
00055  
00056 int heart_beats = 0; // Heart-Beats (sensed or paced) since the last observation interval
00057 Mutex hr_mutex; //hr_mutex.lock()/unlock()
00058  
00059 void HeartSense(void const *args)
00060 {
00061     while(1) {
00062         osEvent ext_signal = osSignalWait(0, osWaitForever);
00063         int evt2 = ext_signal.value.signals;
00064  
00065         switch(evt2) {
00066             case(0x1):
00067 //                v_flag = 1;
00068 //                v_flag = 0;
00069                 osSignalSet(ledTid, 0xD);
00070                 break;
00071  
00072             case(0x10):
00073                 osSignalSet(ledTid, 0xC);
00074                 break;
00075         }
00076     }
00077 }
00078  
00079 void vpace_irq()
00080 {
00081     //lcd.printf("In vpace IRQ/n");
00082     //heartmodeThread->signal_set(0x1);
00083     if(tmm)
00084     {
00085         osSignalSet(heartmodeTid, 0x1);
00086     }
00087     osSignalSet(HeartSenseTid, 0x1);
00088 }
00089  
00090  
00091 void apace_irq()
00092 {
00093     //heartmodeThread->signal_set(0x10);
00094     //lcd.printf("In apace IRQ/n");
00095     if(tmm)
00096     {
00097         osSignalSet(heartmodeTid, 0x10);
00098     }
00099     osSignalSet(HeartSenseTid, 0x10);
00100 }
00101  
00102  
00103 void Rx_interrupt()
00104 {
00105     while(pc.readable()) {
00106         c = pc.getc();
00107         if(c == 'm' && om != 1) {
00108             mode_q.put((char*)c);
00109             mm = 1;
00110         } else if((c == 'r' || c == 't') && om != 1) {
00111             mode_q.put((char*)c);
00112             mm = 0;
00113         } else if((c == 'a' || c == 'v') && mm) {
00114             signal_q.put((char*)c);
00115         } else if(c == 'o' && om != 1) {
00116             mode_q.put((char*)c);
00117             om = 1;
00118         } else if (c == '\r' && om) {
00119             obsint_q.put((char*)c);
00120             om = 0;
00121         } else if ((int)c > 47 && (int)c < 58 && om) {
00122             obsint_q.put((char*)c);
00123         }
00124     }
00125 }
00126  
00127 void ledThread(void const *args)
00128 {
00129     while (1)
00130     {   
00131         osEvent ext_signal = osSignalWait(0, osWaitForever);
00132         int evt = ext_signal.value.signals;
00133         
00134         if (evt == 0xA)
00135         {
00136             asignal_led = 1;
00137             Thread::wait(twait);
00138             asignal_led = 0;
00139         }
00140         else if (evt == 0xB)
00141         {
00142             vsignal_led = 1;
00143             v_led = 1;
00144             
00145             Thread::wait(twait);
00146             vsignal_led = 0;
00147         } 
00148         else if (evt == 0xC)
00149         {
00150             apace_led = 1;
00151             Thread::wait(twait);
00152             apace_led = 0; 
00153         }
00154         else if (evt == 0xD)
00155         {
00156             vpace_led = 1;
00157             vp_led = 1;
00158             
00159             Thread::wait(twait);
00160             vpace_led = 0;
00161         }    
00162     }
00163 }
00164  
00165  
00166 void displayThread(void const *args)
00167 {
00168  
00169     while (1) {
00170         Thread::wait(observation_interval);
00171         lcd.cls();
00172  
00173         hr_mutex.lock();
00174         int hr = (heart_beats*60) / (observation_interval / 1000);
00175         heart_beats = 0;
00176         hr_mutex.unlock();
00177  
00178         lcd.printf("%s%d%s","HR: ", hr, " bpm");
00179     }
00180 }
00181  
00182 void h_beats(void const *args)
00183 {
00184     vClock.start();
00185     while(1) {
00186         if(v_led == 1) {
00187 
00188             hr_mutex.lock();
00189             heart_beats++;
00190             hr_mutex.unlock();
00191             v_led = 0;
00192             vClock.reset();
00193         }
00194  
00195         else if(vp_led == 1) { //osSignalWait(0x1, osWaitForever); when vpace happens, v_flag is set and beats++
00196             hr_mutex.lock();
00197             heart_beats++;
00198             hr_mutex.unlock();
00199             vp_led = 0;
00200             vClock.reset();
00201 
00202         }
00203     }
00204 }
00205  
00206 void test_vrp_vv(FILE * results, Timer * ti)
00207 {
00208     int vrpwait = vrp/2;
00209     int adifu,vdifu,difl = 0;
00210     fprintf(results, "   Test VRP VV\n\n  Time    Action\n");
00211     osSignalWait(0x10, osWaitForever);
00212     osSignalSet(ledTid, 0xC);
00213     osSignalWait(0x1, osWaitForever);
00214     ti->reset();
00215     osSignalSet(ledTid, 0xD);
00216  
00217  
00218  
00219     Thread::wait(vrpwait);
00220     vsignal = 1;
00221     fprintf(results, "%6d%8s\n", ti->read_ms(), "VS");
00222     vsignal = 0;
00223     osSignalSet(ledTid, 0xB);
00224  
00225  
00226     Thread::wait(vrpwait);
00227     vsignal = 1;
00228     difl = ti->read_us();  
00229     fprintf(results, "%6d%8s\n", ti->read_ms(), "VS");
00230     vsignal = 0;
00231     osSignalSet(ledTid, 0xB);
00232  
00233     osSignalWait(0x10, osWaitForever);
00234     adifu = ti->read_us();
00235     fprintf(results, "%6d%8s\n", ti->read_ms(), "AP");
00236     osSignalSet(ledTid, 0xC);
00237  
00238     osSignalWait(0x1, osWaitForever);
00239     vdifu = ti->read_us(); 
00240     fprintf(results, "%6d%8s\n", ti->read_ms(), "VP");
00241     osSignalSet(ledTid, 0xD);
00242  
00243  
00244     int adif = adifu-difl;
00245     int vdif = vdifu-difl;
00246     const char * res = ((adif >= ((lri-avi)*1000 - thrsh)) &&
00247                         (adif < ((lri-avi)*1000 + thrsh)) &&
00248                         (vdif >= (lri*1000 - thrsh)) &&
00249                         (vdif < (lri*1000 + thrsh))) ? "Passed": "Failed";
00250  
00251  
00252     fprintf(results, "\nResult: %s %d %d\n\n", res, adif, vdif);
00253  
00254  
00255 }
00256 void test_pvarp_aa(FILE * results, Timer * ti)
00257 {
00258     int pvarpwait = pvarp/2;
00259     int vdifu = 0;
00260     fprintf(results, "  Test PVARP AA\n\n  Time    Action\n");
00261     osSignalWait(0x10, osWaitForever);
00262     osSignalSet(ledTid, 0xC);
00263     osSignalWait(0x1, osWaitForever);
00264     ti->reset();
00265     osSignalSet(ledTid, 0xD);
00266  
00267  
00268     Thread::wait(pvarpwait);
00269     asignal = 1;
00270     fprintf(results, "%6d%8s\n", ti->read_ms(), "AS");
00271     asignal = 0;
00272     osSignalSet(ledTid, 0xA);
00273  
00274     Thread::wait(pvarpwait);
00275     asignal = 1;
00276     //difl = ti->read_us();
00277     fprintf(results, "%6d%8s\n", ti->read_ms(), "AS");
00278     asignal = 0;
00279     osSignalSet(ledTid, 0xA);
00280  
00281  
00282     osSignalWait(0x1, osWaitForever);
00283     vdifu = ti->read_us();
00284     fprintf(results, "%6d%8s\n", ti->read_ms(), "VP");
00285     osSignalSet(ledTid, 0xD);
00286  
00287  
00288     int vdif = vdifu;
00289     const char * res = ((vdif >= (uri*1000 - thrsh)) &&
00290                         (vdif < (uri*1000 + thrsh))) ? "Passed": "Failed";
00291  
00292  
00293     fprintf(results, "\nResult: %s %d\n\n", res, vdif);
00294 }
00295  
00296  
00297 void test_pvarp_arp_aaa(FILE * results, Timer * ti)
00298 {
00299     int arpwait = arp/2;
00300     int vdifu = 0;
00301     fprintf(results, "Test PVARP ARP AAA\n\n  Time    Action\n");
00302     osSignalWait(0x10, osWaitForever);
00303     osSignalSet(ledTid, 0xC);
00304     osSignalWait(0x1, osWaitForever);
00305     ti->reset();
00306     osSignalSet(ledTid, 0xD);
00307  
00308  
00309     Thread::wait(pvarp);
00310     asignal = 1;
00311     fprintf(results, "%6d%8s\n", ti->read_ms(), "AS");
00312     asignal = 0;
00313     osSignalSet(ledTid, 0xA);
00314  
00315  
00316     Thread::wait(arpwait);
00317     asignal = 1;
00318     fprintf(results, "%6d%8s\n", ti->read_ms(), "AS");
00319     asignal = 0;
00320     osSignalSet(ledTid, 0xA);
00321  
00322  
00323     Thread::wait(arpwait);
00324     asignal = 1;
00325     fprintf(results, "%6d%8s\n", ti->read_ms(), "AS");
00326     asignal = 0;
00327     osSignalSet(ledTid, 0xA);
00328  
00329  
00330     osSignalWait(0x1, osWaitForever);
00331     vdifu = ti->read_us();
00332     fprintf(results, "%6d%8s\n", ti->read_ms(), "VP");
00333     osSignalSet(ledTid, 0xD);
00334  
00335  
00336     int vdif = vdifu;
00337     const char * res = ((vdif >= (uri*1000 - thrsh)) &&
00338                         (vdif < (uri*1000 + thrsh))) ? "Passed": "Failed";
00339  
00340  
00341     fprintf(results, "\nResult: %s %d\n\n", res, vdif);
00342 }
00343  
00344  
00345 void test_pvarp_arp_aav(FILE * results, Timer * ti)
00346 {
00347     int adifu,vdifu,difl = 0;
00348     fprintf(results, "Test PVARP ARP AAV\n\n  Time    Action\n");
00349     osSignalWait(0x10, osWaitForever);
00350     osSignalSet(ledTid, 0xC);
00351     osSignalWait(0x1, osWaitForever);
00352     ti->reset();
00353     osSignalSet(ledTid, 0xD);
00354  
00355  
00356     Thread::wait(pvarp);
00357     asignal = 1;
00358     fprintf(results, "%6d%8s\n", ti->read_ms(), "AS");
00359     asignal = 0;
00360     osSignalSet(ledTid, 0xA);
00361  
00362  
00363     Thread::wait(arp);
00364     asignal = 1;
00365     fprintf(results, "%6d%8s\n", ti->read_ms(), "AS");
00366     asignal = 0;
00367     osSignalSet(ledTid, 0xA);
00368  
00369  
00370     Thread::wait(20);
00371     vsignal = 1;
00372     difl = ti->read_us();
00373     fprintf(results, "%6d%8s\n", ti->read_ms(), "VS");
00374     vsignal = 0;
00375     osSignalSet(ledTid, 0xB);
00376  
00377  
00378  
00379     osSignalWait(0x10, osWaitForever);
00380     adifu = ti->read_us();
00381     fprintf(results, "%6d%8s\n", ti->read_ms(), "AP");
00382     osSignalSet(ledTid, 0xC);
00383  
00384  
00385     osSignalWait(0x1, osWaitForever);
00386     vdifu = ti->read_us();
00387     fprintf(results, "%6d%8s\n", ti->read_ms(), "VP");
00388     osSignalSet(ledTid, 0xD);
00389  
00390     int adif = adifu-difl;
00391     int vdif = vdifu-difl;
00392     const char * res = ((adif >= ((lri-avi)*1000 - thrsh)) &&
00393                         (adif < ((lri-avi)*1000 + thrsh)) &&
00394                         (vdif >= (lri*1000 - thrsh)) &&
00395                         (vdif < (lri*1000 + thrsh))) ? "Passed": "Failed";
00396  
00397  
00398     fprintf(results, "\nResult: %s %d %d\n\n", res, adif, vdif);
00399  
00400  
00401 }
00402  
00403  
00404 void test_vpace_after_a(FILE * results, Timer * ti)
00405 {
00406     int vdifu = 0;
00407     fprintf(results, "Test VPACE After A\n\n  Time    Action\n");
00408     osSignalWait(0x10, osWaitForever);
00409     osSignalSet(ledTid, 0xC);
00410     osSignalWait(0x1, osWaitForever);
00411     ti->reset();
00412     osSignalSet(ledTid, 0xD);
00413  
00414  
00415     Thread::wait(pvarp);
00416     asignal = 1;
00417     fprintf(results, "%6d%8s\n", ti->read_ms(), "AS");
00418     asignal = 0;
00419     osSignalSet(ledTid, 0xA);
00420  
00421  
00422     osSignalWait(0x1, osWaitForever);
00423     vdifu = ti->read_us();
00424     fprintf(results, "%6d%8s\n", ti->read_ms(), "VP");
00425     osSignalSet(ledTid, 0xD);
00426  
00427     int vdif = vdifu;
00428     const char * res = ((vdif >= (uri*1000 - thrsh)) &&
00429                         (vdif < (uri*1000 + thrsh))) ? "Passed": "Failed";
00430  
00431  
00432     fprintf(results, "\nResult: %s %d\n\n", res, vdif);
00433 }
00434  
00435  
00436 void test_apace_vpace_av(FILE * results, Timer * ti)
00437 {
00438     fprintf(results, "Test APACE After V\n\n  Time    Action\n");
00439     int adifu,vdifu = 0;
00440     osSignalWait(0x10, osWaitForever);
00441     osSignalSet(ledTid, 0xC);
00442     osSignalWait(0x1, osWaitForever);
00443     ti->reset();
00444     osSignalSet(ledTid, 0xD);
00445  
00446     osSignalWait(0x10, osWaitForever);
00447     adifu = ti->read_us();
00448     fprintf(results, "%6d%8s\n", ti->read_ms(), "AP");
00449     osSignalSet(ledTid, 0xC);
00450  
00451     osSignalWait(0x1, osWaitForever);
00452     vdifu = ti->read_us();
00453     fprintf(results, "%6d%8s\n", ti->read_ms(), "VP");
00454     osSignalSet(ledTid, 0xD);
00455  
00456     int adif = adifu;
00457     int vdif = vdifu;
00458     const char * res = ((adif >= ((lri-avi)*1000 - thrsh)) &&
00459                         (adif < ((lri-avi)*1000 + thrsh)) &&
00460                         (vdif >= (lri*1000 - thrsh)) &&
00461                         (vdif < (lri*1000 + thrsh))) ? "Passed": "Failed";
00462  
00463  
00464     fprintf(results, "\nResult: %s %d %d\n\n", res, adif, vdif);
00465 }
00466  
00467  
00468 void test_avi_a(FILE * results, Timer * ti)
00469 {
00470     int vdifu,difl = 0;
00471     fprintf(results, "   Test AVI\n\n  Time    Action\n");
00472     osSignalWait(0x10, osWaitForever);
00473     osSignalSet(ledTid, 0xC);
00474     osSignalWait(0x1, osWaitForever);
00475     ti->reset();
00476     osSignalSet(ledTid, 0xD);
00477  
00478  
00479     Thread::wait(uri);
00480     asignal = 1;
00481     difl = ti->read_us();
00482     fprintf(results, "%6d%8s\n", ti->read_ms(), "AS");
00483     asignal = 0;
00484     osSignalSet(ledTid, 0xA);
00485  
00486  
00487     osSignalWait(0x1, osWaitForever);
00488     vdifu = ti->read_us();
00489     fprintf(results, "%6d%8s\n", ti->read_ms(), "VP");
00490     osSignalSet(ledTid, 0xD);
00491  
00492  
00493     int vpc = (avi*1000) + difl;
00494     const char * res = ((vpc >= (vdifu - thrsh)) &&
00495                         (vpc < (vdifu + thrsh))) ? "Passed": "Failed";
00496  
00497  
00498     fprintf(results, "\nResult: %s %d\n\n", res, vpc);
00499  
00500  
00501 }
00502  
00503  
00504 void test_uri_a(FILE * results, Timer * ti)
00505 {
00506     int vdifu = 0;
00507     fprintf(results, "   Test URI\n\n  Time    Action\n");
00508     osSignalWait(0x10, osWaitForever);
00509     osSignalSet(ledTid, 0xC);
00510     osSignalWait(0x1, osWaitForever);
00511     ti->reset();
00512     osSignalSet(ledTid, 0xD);
00513  
00514  
00515     Thread::wait(pvarp);
00516     asignal = 1;
00517     fprintf(results, "%6d%8s\n", ti->read_ms(), "AS");
00518     asignal = 0;
00519     osSignalSet(ledTid, 0xA);
00520  
00521  
00522     osSignalWait(0x1, osWaitForever);
00523     vdifu = ti->read_us();
00524     fprintf(results, "%6d%8s\n", ti->read_ms(), "VP");
00525     osSignalSet(ledTid, 0xD);
00526  
00527     int vdif = vdifu;
00528     const char * res = ((vdif >= (uri*1000 - thrsh)) &&
00529                         (vdif < (uri*1000 + thrsh))) ? "Passed": "Failed";
00530  
00531  
00532     fprintf(results, "\nResult: %s %d\n\n", res, vdif);
00533  
00534  
00535 }
00536  
00537  
00538 void test_normal_10(FILE * results, Timer * ti)
00539 {
00540     fprintf(results, "  Test Normal x10\n\n  Time    Action\n");
00541     int adifu,vdifu,difl,i = 0;
00542     osSignalWait(0x10, osWaitForever);
00543     osSignalSet(ledTid, 0xC);
00544     osSignalWait(0x1, osWaitForever);
00545     ti->reset();
00546     osSignalSet(ledTid, 0xD);
00547  
00548  
00549     while(i < 10) {
00550         Thread::wait(pvarp);
00551         asignal = 1;
00552         fprintf(results, "%6d%8s\n", ti->read_ms(), "AS");
00553         asignal = 0;
00554         osSignalSet(ledTid, 0xA);
00555  
00556  
00557         Thread::wait(75);
00558         vsignal = 1;
00559         difl = ti->read_us();
00560         fprintf(results, "%6d%8s\n", ti->read_ms(), "VS");
00561         vsignal = 0;
00562         osSignalSet(ledTid, 0xB);
00563         
00564         i = i+1;
00565     }
00566  
00567  
00568     osSignalWait(0x10, osWaitForever);
00569     adifu = ti->read_us();
00570     fprintf(results, "%6d%8s\n", ti->read_ms(), "AP");
00571     osSignalSet(ledTid, 0xC);
00572  
00573     osSignalWait(0x1, osWaitForever);
00574     vdifu = ti->read_us();
00575     fprintf(results, "%6d%8s\n", ti->read_ms(), "VP");
00576     osSignalSet(ledTid, 0xD);
00577  
00578  
00579     int adif = adifu - difl;
00580     int vdif = vdifu - difl;
00581     const char * res = ((adif >= ((lri-avi)*1000 - thrsh)) &&
00582                         (adif < ((lri-avi)*1000 + thrsh)) &&
00583                         (vdif >= (lri*1000 - thrsh)) &&
00584                         (vdif < (lri*1000 + thrsh))) ? "Passed": "Failed";
00585  
00586  
00587     fprintf(results, "\nResult: %s %d %d\n\n", res, adif, vdif);
00588 }
00589  
00590  
00591 void testmode(void const *args)
00592 {
00593     Timer *t;
00594     testresults = fopen("/local/test.txt", "w");  // Open "out.txt" on the local file system for writing
00595     t = new Timer();
00596     t->start();
00597  
00598  
00599     test_vrp_vv(testresults, t);
00600     test_pvarp_aa(testresults, t);
00601     test_pvarp_arp_aaa(testresults, t);
00602     test_pvarp_arp_aav(testresults, t);
00603     test_vpace_after_a(testresults, t);
00604     test_apace_vpace_av(testresults, t);
00605     test_avi_a(testresults, t);
00606     test_uri_a(testresults, t);
00607     test_normal_10(testresults, t);
00608     fclose(testresults);
00609 }
00610  
00611  
00612  
00613  
00614 void randommode(void const *args)
00615 {
00616     int aorv,sig = 0;
00617  
00618     //osEvent ext_signal = osSignalWait(0, 1);
00619     //int evt = ext_signal.value.signals;
00620     //osSignalSet(heartmodeTid, 0x1);
00621     //osSignalWait(0, osWaitForever);
00622     while(heartmode == 0) {
00623         aorv = (float)(rand()%2);
00624         sig = aorv ? rand()%(lri - avi) : rand()%(lri);
00625  
00626         osEvent ext_signal = osSignalWait(0, sig);
00627         int evt = ext_signal.value.signals;
00628  
00629         switch(evt) {
00630             case(0x0):
00631                 if(aorv) {
00632                     asignal = 1;
00633                     asignal = 0;
00634                     osSignalSet(ledTid, 0xA);
00635                     break;
00636                 } else {
00637                     vsignal = 1;
00638                     vsignal = 0;
00639                     osSignalSet(ledTid, 0xB);
00640                     break;
00641                 }
00642 //            case(0x1):
00643 //                osSignalSet(ledTid, 0xD);
00644 //                v_flag = 1;
00645 //                v_flag = 0;
00646 //                break;
00647 //
00648 //
00649 //            case(0x10):
00650 //                osSignalSet(ledTid, 0xC);
00651 //                break;
00652  
00653  
00654 //            case(0x100):
00655 //
00656         }
00657     }
00658 }
00659  
00660  
00661 void manualmode(void const *args)
00662 {
00663     while(1) {
00664         osEvent evt = signal_q.get();
00665         if(evt.status == osEventMessage) {
00666             if((char)evt.value.p == 'a') {
00667                 asignal = 1;
00668                 asignal = 0;
00669                 osSignalSet(ledTid, 0xA);
00670             } else if((char)evt.value.p == 'v') {
00671                 vsignal = 1;
00672                 vsignal = 0;
00673                 osSignalSet(ledTid, 0xB);
00674             }
00675         }
00676     }
00677 }
00678  
00679 void obsinterval()
00680 {
00681     char newObsInt[8];
00682     int isChangingObsInt = 1;
00683     int i = 0;
00684     while(isChangingObsInt) {
00685         osEvent evt = obsint_q.get();
00686         if(evt.status == osEventMessage) {
00687             key = (char)evt.value.p;
00688             if(key != '\r' && i < 7 ) {
00689                 newObsInt[i] = key;
00690                 i++;
00691             } else if((key == '\r') && (i > 0)) {
00692                 hr_mutex.lock();
00693                 heart_beats = 0;
00694                 hr_mutex.unlock();
00695                 int obsint;
00696                 newObsInt[i] = '\0';
00697                 sscanf(newObsInt, "%d", &obsint);
00698                 hr_mutex.lock();
00699                 observation_interval = (obsint > 0 ) ? obsint: 1;
00700                 hr_mutex.unlock();
00701                 isChangingObsInt = 0;
00702                 //lcd.printf("%d", observation_interval);
00703             }
00704         }
00705     }
00706 }
00707 osThreadDef(randommode, osPriorityNormal, DEFAULT_STACK_SIZE);
00708 osThreadDef(testmode, osPriorityNormal, DEFAULT_STACK_SIZE);
00709 osThreadDef(manualmode, osPriorityNormal, DEFAULT_STACK_SIZE);
00710 osThreadDef(h_beats, osPriorityNormal, DEFAULT_STACK_SIZE);
00711 osThreadDef(displayThread, osPriorityNormal, DEFAULT_STACK_SIZE);
00712 osThreadDef(HeartSense, osPriorityNormal, DEFAULT_STACK_SIZE);
00713 osThreadDef(ledThread, osPriorityNormal, DEFAULT_STACK_SIZE);
00714  
00715 int main()
00716 {
00717     vpace.rise(&vpace_irq);
00718     apace.rise(&apace_irq);
00719  
00720     pc.attach(&Rx_interrupt, RawSerial::RxIrq);
00721  
00722     //heartmodeThread = new Thread();
00723  
00724 //    Callback<void()> testmodeTask((void*)NULL,(void (*)(void *))&testmode);
00725  
00726     HeartSenseTid = osThreadCreate(osThread(HeartSense), NULL);
00727     heartmodeTid = osThreadCreate(osThread(randommode), NULL);
00728     beats = osThreadCreate(osThread(h_beats), NULL);
00729     displayTid = osThreadCreate(osThread(displayThread), NULL);
00730     ledTid = osThreadCreate(osThread(ledThread), NULL);
00731 //    heartmodeTid = osThreadCreate(osThread(testmode), NULL);
00732 //    heartmodeTid = osThreadCreate(osThread(manualmode), NULL);
00733  
00734     while(true) {
00735         osEvent evt = mode_q.get();
00736         if(evt.status == osEventMessage) {
00737             switch((char)evt.value.p) {
00738                     //pvarp = 0.3s
00739                 case('r'):
00740                     tmm = 0;
00741                     lcd.printf("R");
00742                     osThreadTerminate (heartmodeTid);
00743                     osThreadTerminate (displayTid);
00744                     if (testresults != NULL) {
00745                         fclose(testresults);
00746                     }
00747 //                    asignal_led = 0;
00748 //                    vsignal_led = 0;
00749 //                    apace_led = 0;
00750 //                    vpace_led = 0;
00751  
00752                     displayTid = osThreadCreate(osThread(displayThread), NULL);
00753                     heartmodeTid = osThreadCreate(osThread(randommode), NULL);
00754 //                    Thread::wait(100);
00755                     break;
00756                 case('t'):
00757                     
00758                     tmm = 1;
00759                     lcd.printf("T");
00760                     osThreadTerminate (heartmodeTid);
00761                     osThreadTerminate (displayTid);
00762 //                    asignal_led = 0;
00763 //                    vsignal_led = 0;
00764 //                    apace_led = 0;
00765 //                    vpace_led = 0;
00766                     osSignalClear (heartmodeTid,0);
00767                     displayTid = osThreadCreate(osThread(displayThread), NULL);
00768                     heartmodeTid = osThreadCreate(osThread(testmode), NULL);
00769                     
00770                     if (testresults != NULL) {
00771                         fclose(testresults);
00772                     }
00773  
00774                     break;
00775                 case('m'):
00776                     tmm = 0;
00777                     lcd.printf("M");
00778                     osThreadTerminate (heartmodeTid);
00779                     osThreadTerminate (displayTid);
00780                     if (testresults != NULL) {
00781                         fclose(testresults);
00782                     }
00783 //                    asignal_led = 0;
00784 //                    vsignal_led = 0;
00785 //                    apace_led = 0;
00786 //                    vpace_led = 0;
00787  
00788                     displayTid = osThreadCreate(osThread(displayThread), NULL);
00789                     heartmodeTid = osThreadCreate(osThread(manualmode), NULL);
00790                     manual_mode = 1;
00791  
00792  
00793                     break;
00794                 case('o'):
00795                     tmm = 0;
00796                     lcd.printf("modeO");
00797                     obsinterval();
00798                     osThreadTerminate (displayTid);
00799                     displayTid = osThreadCreate(osThread(displayThread), NULL);
00800                     break;
00801             }
00802         }
00803     }
00804 }