main.cpp

00001 #include "mbed.h"
00002 #include "rtos.h"
00003 #include "TextLCD.h"
00004 InterruptIn A(p8);
00005 InterruptIn V(p9);
00006 int pacemakerrate;
00007 DigitalOut Apace(p10);
00008 DigitalOut Vpace(p11);
00009 DigitalOut ApaceLED(LED1);
00010 DigitalOut VpaceLED(LED2);
00011 DigitalOut AsigLED(LED3);
00012 DigitalOut VsigLED(LED4);
00013 TextLCD lcd(p15, p16, p17, p18, p19, p20, TextLCD::LCD16x2);
00014 Serial pc(USBTX, USBRX);
00015 Queue<char, 16> AVsigpmv;
00016 Queue<char, 16> AVsensepmv;
00017 Queue<char, 16> AVpacepmv;
00018 Queue<char, 16> AVsigpms;
00019 Queue<char, 16> AVsensepms;
00020 Queue<char, 16> AVpacepms;
00021 Queue<char, 16> AVsigpma;
00022 Queue<char, 16> AVsensepma;
00023 Queue<char, 16> AVpacepma;
00024 Queue<char, 16> AVsigpmm;
00025 Queue<char, 16> AVsensepmm;
00026 Queue<char, 16> AVpacepmm;
00027 Queue<char, 16> AVsigpmd;
00028 Queue<char, 16> AVsensepmd;
00029 Queue<char, 16> AVpacepmd;
00030 void PacemakerKeyboardInput(void const *args);
00031 void PacemakerModes(void const *args);
00032 
00033 void PacemakerSend(void const *args);
00034 void PaceMakerAtrialInterval(void const *args);
00035 void PaceMakerVentricalInterval(void const *args);
00036 int pacemakerMode;
00037 int modeSwitchTimeInterval = 5000;
00038 int flag=0;
00039 int PVAB;
00040 const int sleepModeURI = 1000;
00041 const int sleepModeLRI = 2000;
00042 const int normalModeURI = 600;
00043 const int normalModeLRI = 1500;
00044 const int sportsModeURI = 343;
00045 const int sportsModeLRI = 600;
00046 const int manualModeURI = 343;
00047 const int manualModeLRI = 2000;
00048 int low[4] = {30,40,100,30};
00049 int high[4] = {60,100,175,175};
00050 int pulses = 0;
00051 int pacemakerInterval = 10;
00052 int newpacemakerInterval;
00053 int heartInterval = 10;
00054 int paceMakerRate = 0;
00055 int heartRate = 0;
00056 int LRI = normalModeLRI;
00057 int URI = normalModeURI;
00058 Timer k;
00059 Timer r;
00060 Timer p;
00061 Timer t_loc;
00062 Timer t;
00063 const int PVARP = 150; 
00064 const int VRP = PVARP; 
00065 const int AVI = 65;
00066 char mode;
00067 char manualPace;
00068 char AorV;
00069 char AorVsense;
00070 Thread Pmki(PacemakerKeyboardInput,(void *) 0); 
00071 Thread Pmm(PacemakerModes,(void *) 0);
00072 //Thread Pms (PacemakerSend, (void *) 0);
00073 //Thread PmA (PaceMakerAtrialInterval, (void *) 0);
00074 //Thread PmV (PaceMakerVentricalInterval, (void *) 0);
00075 void PacemakerKeyboardInput(void const *args){
00076     pc.printf("type something");
00077     k.start();
00078     char input;
00079     while(true){
00080         if (pc.readable()){
00081             
00082         input=pc.getc();
00083         if (k.read()>=modeSwitchTimeInterval && flag==0){
00084             if (input=='F'){
00085                 mode='F';
00086                 Pmm.signal_set(0x1);
00087                 Thread::signal_wait(0x1);
00088                 }
00089             else if (input=='S'){
00090                 mode='S';
00091                 Pmm.signal_set(0x1);
00092                 Thread::signal_wait(0x1);
00093                 }
00094             else if (input=='N'){
00095                 mode='N';
00096                 Pmm.signal_set(0x1);
00097                 Thread::signal_wait(0x1);
00098                 }
00099             else if (input=='O'){
00100                 mode='O';
00101                 input=pc.getc();
00102                 newpacemakerInterval=10*(int)input;
00103                 input=pc.getc();
00104                 newpacemakerInterval=newpacemakerInterval+(int)input;
00105                 Pmm.signal_set(0x1);
00106                 Thread::signal_wait(0x1);
00107                 }
00108             else if (input=='M'){
00109                 mode='M';
00110                 Pmm.signal_set(0x1);
00111                 Thread::signal_wait(0x1);
00112                 }
00113             else if (input=='A'){
00114                 if (mode=='M')
00115                     manualPace='A';
00116                     Pmm.signal_set(0x1);
00117                     Thread::signal_wait(0x1);
00118                     }
00119                 }
00120             else if (input=='V'){
00121                 if (mode=='M'){
00122 
00123                     manualPace='V';
00124                     Pmm.signal_set(0x1);
00125                     Thread::signal_wait(0x1);
00126                     }
00127                 }
00128             }
00129             }
00130         }
00131     
00132     
00133     
00134 void PacemakerModes(void const *args){
00135     while(1){
00136         pc.printf("enter pm mode");
00137         Thread::signal_wait(0x1);
00138         if (mode=='F'){
00139             LRI=sportsModeLRI;
00140             URI=sportsModeURI;
00141             Pmki.signal_set(0x1);
00142             }
00143         else if (mode=='S'){
00144             LRI=sleepModeLRI;
00145             URI=sleepModeURI;
00146             Pmki.signal_set(0x1);
00147             }
00148         else if (mode=='N'){
00149             LRI=normalModeLRI;
00150             URI=normalModeURI;
00151             Pmki.signal_set(0x1);
00152             }
00153         else if (mode=='O'){
00154             pacemakerInterval=newpacemakerInterval;
00155             Pmki.signal_set(0x1);
00156             }
00157         else if (mode=='M'){
00158             LRI=manualModeLRI;
00159             URI=manualModeURI;
00160             Pmki.signal_set(0x1);
00161             while(1){
00162                 Thread::signal_wait(0x1);
00163                 if (mode=='M'){
00164                     if (manualPace=='A'){
00165                         char* element;
00166                         *element='A';
00167                         AVpacepms.put(element);
00168                         AVpacepma.put(element);
00169                         AVpacepmv.put(element);
00170                         AVpacepmm.put(element);
00171                         AVpacepmd.put(element);
00172                         }
00173                     else if (manualPace=='V'){
00174                         char* element;
00175                         *element='V';
00176                         AVpacepms.put(element);
00177                         AVpacepma.put(element);
00178                         AVpacepmv.put(element);
00179                         AVpacepmm.put(element);
00180                         AVpacepmd.put(element);
00181                         }
00182                     }
00183                 else {
00184                     Pmm.signal_set(0x1);
00185                     Pmki.signal_set(0x1);
00186                     break;
00187                     }
00188                 Pmki.signal_set(0x1);
00189                 }
00190             }
00191         }
00192     } 
00193 
00194  void PaceMakerAtrialInterval(void const *args){
00195     char *AorVsig;
00196     char *AorVpace;
00197     char *AorVsense;
00198     osEvent evt;
00199     pc.printf("entering atrial interval");
00200     while (1){
00201             evt = AVsigpma.get(1);
00202             if (evt.status == osEventMessage) {
00203                 AorVsig = (char*)evt.value.p;
00204             }
00205             if (*AorVsig=='A'){
00206                 AorVsig=0;
00207                 char* element;
00208                 *element='A';
00209                 AVsensepms.put(element);
00210                 AVsensepma.put(element);
00211                 AVsensepmv.put(element);
00212                 AVsensepmm.put(element);
00213                 AVsensepmd.put(element);
00214                 break;
00215                 }
00216             evt = AVpacepma.get(1);
00217             if (evt.status == osEventMessage) {
00218                 AorVpace = (char*)evt.value.p;
00219             }
00220             if (*AorVpace=='A'){
00221                 AorVpace=0;
00222                 break;
00223                 }
00224         }
00225     t.reset();
00226     while(1){
00227             osEvent evt = AVsensepma.get(1);
00228             if (evt.status == osEventMessage) {
00229                 AorVsense = (char*)evt.value.p;
00230             }
00231             if (*AorVsense=='V'){
00232                 AorVsense=0;
00233                 break;
00234                 }
00235             evt = AVsensepma.get(1);
00236             if (evt.status == osEventMessage) {
00237                 AorVpace = (char*)evt.value.p;
00238             }
00239             if (*AorVpace=='V'){
00240                 *AorVpace='V';
00241                 break;
00242                 }
00243         }
00244     k.reset();
00245     while(!(k>=PVARP));
00246     while(!(t>=URI));
00247     }   
00248 void updatePacemaker(){
00249     int temp = 60/pacemakerInterval;
00250     paceMakerRate = paceMakerRate + temp;
00251 }
00252 void PaceMakerDisplay(void const *args){
00253     osEvent evt;
00254     char* AorVsense;
00255     char* AorVpace;
00256     while(1){
00257         
00258         while(1){
00259         evt = AVsensepmd.get(1);
00260         if (evt.status == osEventMessage) {
00261             AorVsense = (char*)evt.value.p;
00262             }
00263         if (*AorVsense=='V'){
00264             break;
00265             }
00266         evt = AVpacepmd.get(1);
00267         if (evt.status == osEventMessage) {
00268             AorVpace = (char*)evt.value.p;
00269             }
00270         if (*AorVpace=='V'){
00271             break;
00272             }
00273         }
00274         if (r<=pacemakerInterval*1000){
00275             updatePacemaker();
00276             }
00277         else {
00278             if (paceMakerRate < low[mode]){
00279                 r.reset();
00280                 paceMakerRate=0;
00281                 }
00282             else if (paceMakerRate  >= low[mode]  && paceMakerRate  <= high[mode]){
00283                 //high alarm
00284                 r.reset();
00285                 paceMakerRate=0;
00286                 }
00287             else if (paceMakerRate  > high[mode]){
00288                 //low alarm
00289                 r.reset();
00290                 paceMakerRate=0;
00291                 }
00292             }
00293         
00294         
00295     }
00296     }
00297 void PaceMakerVentricalInterval(void const *args){
00298     char *AorVsig;
00299     char *AorVsense;
00300     char *AorVpace;
00301     osEvent evt;
00302     while(1){
00303         while(1){
00304             evt = AVsigpmv.get(1);
00305             if (evt.status == osEventMessage) {
00306                 AorVsig = (char*)evt.value.p;
00307             }
00308             if (*AorVsig=='V'){
00309                 AorVsig=0;
00310                 char* element;
00311                 *element='V';
00312                 pc.printf("sending V pace");
00313                 AVsensepms.put(element);
00314                 AVsensepma.put(element);
00315                 AVsensepmv.put(element);
00316                 AVsensepmm.put(element);
00317                 AVsensepmd.put(element);
00318                 break;
00319             }
00320             evt = AVsensepmv.get(1);
00321             if (evt.status == osEventMessage) {
00322                 AorVsense = (char*)evt.value.p;
00323             }
00324             if (*AorVsense=='A'){
00325                 AorVsense=0;
00326                 p.reset();
00327                 while(!(p>=PVAB));
00328                 while(1){
00329                     osEvent evt = AVsigpmv.get(1);
00330                     if (evt.status == osEventMessage) {
00331                         AorVsig = (char*)evt.value.p;
00332                         }
00333                     if (*AorVsig=='V'){
00334                         AorVsig=0;
00335                         break;
00336                         }
00337                     evt = AVpacepmv.get(1);
00338                     if (evt.status == osEventMessage) {
00339                         AorVpace = (char*)evt.value.p;
00340                         }
00341                     if (*AorVpace=='V'){
00342                         char* element;
00343                         *element='V';
00344                         AVsensepmv.put(element);
00345                         break;
00346                         }
00347                     p.reset();
00348                     while(!(p>=VRP));
00349                 }
00350                 break;
00351             }
00352             evt = AVpacepmv.get(1);
00353             if (evt.status == osEventMessage) {
00354                 AorVpace = (char*)evt.value.p;
00355             }
00356             if (*AorVpace=='A'){
00357                 AorVpace=0;
00358                 p.reset();
00359                 while(!(p>=PVAB));
00360                 while(1){
00361                     osEvent evt = AVsigpmv.get(1);
00362                     if (evt.status == osEventMessage) {
00363                         AorVsig = (char*)evt.value.p;
00364                         }
00365                     if (*AorVsig=='V'){
00366                         AorVsig=0;
00367                         break;
00368                         }
00369                     evt = AVpacepmv.get(1);
00370                     if (evt.status == osEventMessage) {
00371                         AorVpace = (char*)evt.value.p;
00372                         }
00373                     if (*AorVpace=='V'){
00374                         char* element;
00375                         *element='V';
00376                         pc.printf("sending V pace");
00377                         AVsensepms.put(element);
00378                         AVsensepma.put(element);
00379                         AVsensepmv.put(element);
00380                         AVsensepmm.put(element);
00381                         AVsensepmd.put(element);
00382                         break;
00383                         }
00384                     p.reset();
00385                     while(!(p.read()>=VRP));
00386                 }
00387                 break;
00388                 }
00389         }
00390     }
00391     
00392     }
00393 void PacemakerSend(void const *args){
00394     char *AorV;
00395     while(1){
00396         while(1){
00397             osEvent evt = AVsensepms.get(1);
00398             if (evt.status == osEventMessage) {
00399                 AorV = (char*)evt.value.p;
00400             }
00401             if (*AorV=='A'){
00402                 AorV=0;
00403                 break;
00404                 }
00405             else if (t.read()>=AVI){
00406                 char* element;
00407                 *element='V';
00408                 AVpacepms.put(element);
00409                 AVpacepmv.put(element);
00410                 AVpacepma.put(element);
00411                 Vpace=1;
00412                 wait(.1);
00413                 Vpace=0;
00414                 break;
00415                 }  
00416             else if (pacemakerMode==1){
00417                 while(pacemakerMode!=0);
00418                 break;
00419                 }     
00420         }
00421         while(1){
00422             osEvent evt = AVsensepms.get(1);
00423             if (evt.status == osEventMessage) {
00424                 AorV = (char*)evt.value.p;
00425             }
00426             if (*AorV=='A'){
00427                 AorV=0;
00428                 if (pacemakerMode==1){
00429                     while(pacemakerMode!=0);
00430                     break;
00431                     }
00432                 else{
00433                     t.reset();
00434                     break;
00435                     }
00436                 }
00437             else if (*AorV=='V'){
00438                 AorV=0;
00439                 t.reset();
00440                 while(1){
00441                     osEvent evt = AVsensepms.get(1);
00442                     if (evt.status == osEventMessage) {
00443                         AorV = (char*)evt.value.p;
00444                     }
00445                     if (*AorV=='A'){
00446                         AorV=0;
00447                         if (pacemakerMode==1){
00448                             while(pacemakerMode!=0);
00449                             break;
00450                             }
00451                         else{
00452                             t.reset();
00453                             break;
00454                             }
00455                         }
00456                     else if (pacemakerMode==1){
00457                         while(pacemakerMode!=0);
00458                         break;
00459                         }
00460                     else if (t>= LRI-AVI){
00461                         char* element;
00462                         *element='A';
00463                         pc.printf("sending A pace");
00464                 AVpacepms.put(element);
00465                 AVpacepma.put(element);
00466                 AVpacepmv.put(element);
00467                 AVpacepmm.put(element);
00468                 AVpacepmd.put(element);
00469                         Apace=1;
00470                         wait(.1);
00471                         Apace=0;
00472                         if (pacemakerMode==1){
00473                             while(pacemakerMode!=0);
00474                             break;
00475                             }
00476                         else{
00477                             t.reset();
00478                             break;
00479                             }
00480                         }
00481                     }
00482             }
00483             else if (t.read()>=LRI){
00484                     char* element;
00485                     pc.printf("sending A pace");
00486                     *element='A';
00487                 AVpacepms.put(element);
00488                 AVpacepma.put(element);
00489                 AVpacepmv.put(element);
00490                 AVpacepmm.put(element);
00491                 AVpacepmd.put(element);
00492                     Apace=1;
00493                     wait(.1);
00494                     Apace=0;
00495                     if (pacemakerMode==1){
00496                         while(pacemakerMode!=0);
00497                         break;
00498                         }
00499                     else{
00500                         t.reset();
00501                         break;
00502                         }
00503                 }
00504             else if (pacemakerMode==1){
00505                     while(pacemakerMode!=0);
00506                     break;
00507                 }
00508         
00509             
00510     }
00511     }
00512 }
00513 void Asig();
00514 void Vsig();
00515 int main(){
00516     osEvent evt;
00517     A.mode(PullDown); 
00518     char* AorVpace;   
00519    char* AorVsig;           
00520     A.rise(Asig);               
00521     V.mode(PullDown);              
00522     V.rise(Vsig);               
00523     
00524     while(1){
00525         evt = AVpacepmm.get(1);
00526         if (evt.status == osEventMessage) {
00527             AorVpace = (char*)evt.value.p;
00528         }
00529         if (*AorVpace=='A'){
00530             AorVpace=0;
00531             ApaceLED=1;
00532             wait(.1);
00533             ApaceLED=(0);
00534         }
00535         else if (*AorVpace=='V'){
00536             AorVpace=0;
00537             VpaceLED=1;
00538             wait(.1);
00539             VpaceLED=0;
00540             }
00541         evt = AVsigpmm.get(1);
00542         if (evt.status == osEventMessage) {
00543             AorVsig = (char*)evt.value.p;
00544         }
00545         if (*AorVsig=='A'){
00546             AorVsig=0;
00547             AsigLED=1;
00548             wait(.1);
00549             ApaceLED=(0);
00550         }
00551         else if (*AorVsig=='V'){
00552             AorVsig=0;
00553             VsigLED=1;
00554             wait(.1);
00555             VpaceLED=0;
00556             }
00557         lcd.cls();
00558         lcd.printf("%d", paceMakerRate);
00559         Thread::wait(15);
00560         };
00561 }
00562 
00563 
00564 void Asig() {
00565 char* element;
00566 pc.printf("received A signal");
00567 *element='A';
00568 AVsigpms.put(element);
00569 AVsigpma.put(element);
00570 AVsigpmv.put(element);
00571 AVsigpmm.put(element);
00572 AVsigpmd.put(element);
00573                              
00574 }
00575 void Vsig() {
00576 char* element;
00577 pc.printf("received V signal");
00578 *element='V';
00579 AVsigpms.put(element);
00580 AVsigpma.put(element);
00581 AVsigpmv.put(element);
00582 AVsigpmm.put(element);
00583 AVsigpmd.put(element);
00584                              
00585 }