Diff: main.cpp

Revision:

3:ac2e5aceb324

Parent:

2:b178e27d9f22

Child:

4:242a71a6efed

--- a/main.cpp	Mon Nov 30 02:22:22 2015 +0000
+++ b/main.cpp	Mon Nov 30 17:59:05 2015 +0000
@@ -1,20 +1,42 @@
 #include "mbed.h"
 #include "rtos.h"
-
+#include "TextLCD.h"
 InterruptIn A(p8);
 InterruptIn V(p9);
-DigitalOut Apace(p1);
-DigitalOut Vpace(p2);
+int pacemakerrate;
+DigitalOut Apace(p10);
+DigitalOut Vpace(p11);
+DigitalOut ApaceLED(LED1);
+DigitalOut VpaceLED(LED2);
+DigitalOut AsigLED(LED3);
+DigitalOut VsigLED(LED4);
+TextLCD lcd(p15, p16, p17, p18, p19, p20, TextLCD::LCD16x2);
 Serial pc(USBTX, USBRX);
-
-
+Queue<char, 16> AVsigpmv;
+Queue<char, 16> AVsensepmv;
+Queue<char, 16> AVpacepmv;
+Queue<char, 16> AVsigpms;
+Queue<char, 16> AVsensepms;
+Queue<char, 16> AVpacepms;
+Queue<char, 16> AVsigpma;
+Queue<char, 16> AVsensepma;
+Queue<char, 16> AVpacepma;
+Queue<char, 16> AVsigpmm;
+Queue<char, 16> AVsensepmm;
+Queue<char, 16> AVpacepmm;
+Queue<char, 16> AVsigpmd;
+Queue<char, 16> AVsensepmd;
+Queue<char, 16> AVpacepmd;
 void PacemakerKeyboardInput(void const *args);
 void PacemakerModes(void const *args);
-void PacemakerReceive(void const *args);
+
 void PacemakerSend(void const *args);
-
+void PaceMakerAtrialInterval(void const *args);
+void PaceMakerVentricalInterval(void const *args);
+int pacemakerMode;
 int modeSwitchTimeInterval = 5000;
 int flag=0;
+int PVAB;
 const int sleepModeURI = 1000;
 const int sleepModeLRI = 2000;
 const int normalModeURI = 600;
@@ -23,12 +45,18 @@
 const int sportsModeLRI = 600;
 const int manualModeURI = 343;
 const int manualModeLRI = 2000;
-
+int pulses = 0;
+int pacemakerInterval = 10;
+int heartInterval = 10;
+int pacemakerRate = 0;
+int heartRate = 0;
 int LRI = normalModeLRI;
 int URI = normalModeURI;
 Timer k;
+Timer r;
 Timer p;
-Timer t_loc
+Timer t_loc;
+Timer t;
 const int PVARP = 150; 
 const int VRP = PVARP; 
 const int AVI = 65;
@@ -38,9 +66,9 @@
 char AorVsense;
 Thread Pmki(PacemakerKeyboardInput,(void *) 0); 
 Thread Pmm(PacemakerModes,(void *) 0);
-Thread Pmr (PacemakerReceive, (void *) 0);
-Thread Pmr (PacemakerSend, (void *) 0);
-
+Thread Pms (PacemakerSend, (void *) 0);
+Thread PmA (PaceMakerAtrialInterval, (void *) 0);
+Thread PmV (PaceMakerVentricalInterval, (void *) 0);
 void PacemakerKeyboardInput(void const *args){
     k.start();
     char input;
@@ -122,14 +150,22 @@
                 Thread::signal_wait(0x1);
                 if (mode=='M'){
                     if (manualPace=='A'){
-                        Pms.signal_set(0x01);
-                        AorVsense='Am'
-                        manualPace=0;
+                        char* element;
+                        *element='A';
+                        AVpacepms.put(element);
+                        AVpacepma.put(element);
+                        AVpacepmv.put(element);
+                        AVpacepmm.put(element);
+                        AVpacepmd.put(element);
                         }
                     else if (manualPace=='V'){
-                        Pms.signal_set(0x01);
-                        AorVsense='Vm'
-                        manualPace=0;
+                        char* element;
+                        *element='V';
+                        AVpacepms.put(element);
+                        AVpacepma.put(element);
+                        AVpacepmv.put(element);
+                        AVpacepmm.put(element);
+                        AVpacepmd.put(element);
                         }
                     }
                 else {
@@ -142,197 +178,389 @@
             }
         }
     } 
-    
-void PacemakerSend(void const *args){
+
+ void PaceMakerAtrialInterval(void const *args){
+    char *AorVsig;
+    char *AorVpace;
+    char *AorVsense;
+    osEvent evt;
+    while (1){
+            evt = AVsigpma.get(1);
+            if (evt.status == osEventMessage) {
+                AorVsig = (char*)evt.value.p;
+            }
+            if (*AorVsig=='A'){
+                AorVsig=0;
+                char* element;
+                *element='A';
+                AVsensepms.put(element);
+                AVsensepma.put(element);
+                AVsensepmv.put(element);
+                AVsensepmm.put(element);
+                AVsensepmd.put(element);
+                break;
+                }
+            evt = AVpacepma.get(1);
+            if (evt.status == osEventMessage) {
+                AorVpace = (char*)evt.value.p;
+            }
+            if (*AorVpace=='A'){
+                AorVpace=0;
+                break;
+                }
+        }
+    t.reset();
     while(1){
-        Thread::signal_wait(0x1);
-        if (AorVsense=='V'){
-            p.reset();
+            osEvent evt = AVsensepma.get(1);
+            if (evt.status == osEventMessage) {
+                AorVsense = (char*)evt.value.p;
+            }
+            if (*AorVsense=='V'){
+                AorVsense=0;
+                break;
+                }
+            evt = AVsensepma.get(1);
+            if (evt.status == osEventMessage) {
+                AorVpace = (char*)evt.value.p;
+            }
+            if (*AorVpace=='V'){
+                *AorVpace='V';
+                break;
+                }
+        }
+    k.reset();
+    while(!(k>=PVARP));
+    while(!(t>=URI));
+    }   
+void updatePacemaker(){
+    int temp = 60/pacemakerInterval;
+    pacemakerRate = pacemakerRate + temp;
+}
+void PaceMakerDisplay(void const *args){
+    osEvent evt;
+    char* AorVsense;
+    char* AorVpace;
+    while(1){
+        
+        while(1){
+        evt = AVsensepmd.get(1);
+        if (evt.status == osEventMessage) {
+            AorVsense = (char*)evt.value.p;
+            }
+        if (*AorVsense=='V'){
+            break;
+            }
+        evt = AVpacepmd.get(1);
+        if (evt.status == osEventMessage) {
+            AorVpace = (char*)evt.value.p;
+            }
+        if (*AorVpace=='V'){
+            break;
+            }
+        }
+        if (r<=pacemakerInterval*1000){
+            updatePacemaker();
+            }
+        else {
+            if (pacemakerRate < low[mode]){
+                r.reset();
+                paceMakerRate=0;
+                }
+            else if (pacemakerRate  >= low[mode]  && pacemakerRate  <= high[mode]){
+                //high alarm
+                r.reset();
+                paceMakerRate=0;
+                }
+            else if (pacemakerRate  > high[mode]){
+                //low alarm
+                r.reset();
+                paceMakerRate=0;
+                }
+            }
+        
+        
+    }
+    }
+void PaceMakerVentricalInterval(void const *args){
+    char *AorVsig;
+    char *AorVsense;
+    char *AorVpace;
+    osEvent evt;
+    while(1){
+        while(1){
+            evt = AVsigpmv.get(1);
+            if (evt.status == osEventMessage) {
+                AorVsig = (char*)evt.value.p;
             }
-        else if (AorVsense=='A'||p.read()>=LRI-AVI){
-            p.reset();
-            flag=1;
-            while(1){
-                Thread::signal_wait(0x1);
-                if (AorVsense=='A'){
-                    while(1){     
-                        if (p<=LRI){
-                        flag=0;
-                        break;     
-                    }
+            if (*AorVsig=='V'){
+                AorVsig=0;
+                char* element;
+                *element='V';
+                AVsensepms.put(element);
+                AVsensepma.put(element);
+                AVsensepmv.put(element);
+                AVsensepmm.put(element);
+                AVsensepmd.put(element);
+                break;
+            }
+            evt = AVsensepmv.get(1);
+            if (evt.status == osEventMessage) {
+                AorVsense = (char*)evt.value.p;
+            }
+            if (*AorVsense=='A'){
+                AorVsense=0;
+                p.reset();
+                while(!(p>=PVAB));
+                while(1){
+                    osEvent evt = AVsigpmv.get(1);
+                    if (evt.status == osEventMessage) {
+                        AorVsig = (char*)evt.value.p;
+                        }
+                    if (*AorVsig=='V'){
+                        AorVsig=0;
+                        break;
+                        }
+                    evt = AVpacepmv.get(1);
+                    if (evt.status == osEventMessage) {
+                        AorVpace = (char*)evt.value.p;
+                        }
+                    if (*AorVpace=='V'){
+                        char* element;
+                        *element='V';
+                        AVsensepmv.put(element);
+                        break;
+                        }
+                    p.reset();
+                    while(!(p>=VRP));
                 }
-                else if (AorVsense=='V'){
-                   p.reset();
-                   flag=0;
-                   while(1){
-                        if (p<=LRI-AVI){
-                            break;
-                    }
+                break;
+            }
+            evt = AVpacepmv.get(1);
+            if (evt.status == osEventMessage) {
+                AorVpace = (char*)evt.value.p;
+            }
+            if (*AorVpace=='A'){
+                AorVpace=0;
+                p.reset();
+                while(!(p>=PVAB));
+                while(1){
+                    osEvent evt = AVsigpmv.get(1);
+                    if (evt.status == osEventMessage) {
+                        AorVsig = (char*)evt.value.p;
+                        }
+                    if (*AorVsig=='V'){
+                        AorVsig=0;
+                        break;
+                        }
+                    evt = AVpacepmv.get(1);
+                    if (evt.status == osEventMessage) {
+                        AorVpace = (char*)evt.value.p;
+                        }
+                    if (*AorVpace=='V'){
+                        char* element;
+                        *element='V';
+                        AVsensepms.put(element);
+                        AVsensepma.put(element);
+                        AVsensepmv.put(element);
+                        AVsensepmm.put(element);
+                        AVsensepmd.put(element);
+                        break;
+                        }
+                    p.reset();
+                    while(!(p.read()>=VRP));
+                }
+                break;
                 }
-                else if (AorVsense=='Vm'){
-                   flag=0;
-                    p.reset();
-                  Vpace=1;
-                 wait(0.1)
-                    Vpace(0.1)
-                while(1){
-                if (p<=LRI-AVI){
+        }
+    }
+    
+    }
+void PacemakerSend(void const *args){
+    char *AorV;
+    while(1){
+        while(1){
+            osEvent evt = AVsensepms.get(1);
+            if (evt.status == osEventMessage) {
+                AorV = (char*)evt.value.p;
+            }
+            if (*AorV=='A'){
+                AorV=0;
+                break;
+                }
+            else if (t.read()>=AVI){
+                char* element;
+                *element='V';
+                AVpacepms.put(element);
+                AVpacepmv.put(element);
+                AVpacepma.put(element);
+                Vpace=1;
+                wait(.1);
+                Vpace=0;
+                break;
+                }  
+            else if (pacemakerMode==1){
+                while(pacemakerMode!=0);
+                break;
+                }     
+        }
+        while(1){
+            osEvent evt = AVsensepms.get(1);
+            if (evt.status == osEventMessage) {
+                AorV = (char*)evt.value.p;
+            }
+            if (*AorV=='A'){
+                AorV=0;
+                if (pacemakerMode==1){
+                    while(pacemakerMode!=0);
                     break;
                     }
-                }
-                   }
-                else if(p.read()==LRI) {
-                   Vpace=1;
-                 wait(0.1)
-                    Vpace=0;
-                    p.reset();
-                    flag=0;
-                    while(1){
-                if (p<=LRI-AVI){
-                    break;
-                    }
-                   }
-                   }
-            }
-       else  if (AorVsense=='Vm'){
-            p.reset();
-            Vpace=1;
-            wait(0.1)
-            Vpace(0.1)
-            while(1){
-                if (p<=LRI-AVI){
+                else{
+                    t.reset();
                     break;
                     }
                 }
-            }
-        else if (AorVsense=='Am'){
-            p.reset();
-            Apace=1;
-            wait(0.1)
-            Apace(0.1)
-            flag=1;
-            while(1){
-                Thread::signal_wait(0x1);
-                if (AorVsense=='A'){
-                    while(1){     
-                        if (p<=LRI){
-                        flag=0;
-                        break;     
-                    }
-                }
-                else if (AorVsense=='V'){
-                   p.reset();
-                   flag=0;
-                   while(1){
-                        if (p<=LRI-AVI){
-                            break;
+            else if (*AorV=='V'){
+                AorV=0;
+                t.reset();
+                while(1){
+                    osEvent evt = AVsensepms.get(1);
+                    if (evt.status == osEventMessage) {
+                        AorV = (char*)evt.value.p;
                     }
-                }
-                else if (AorVsense=='Vm'){
-                   flag=0;
-                    p.reset();
-                  Vpace=1;
-                 wait(0.1)
-                    Vpace(0.1)
-                while(1){
-                if (p<=LRI-AVI){
-                    break;
-                    }
-                }
-                   }
-                else if(p.read()==LRI) {
-                   Vpace=1;
-                 wait(0.1)
-                    Vpace=0;
-                    p.reset();
-                    flag=0;
-                    while(1){
-                if (p<=LRI-AVI){
-                    break;
-                    }
-                   }
-                   }
-                   
+                    if (*AorV=='A'){
+                        AorV=0;
+                        if (pacemakerMode==1){
+                            while(pacemakerMode!=0);
+                            break;
+                            }
+                        else{
+                            t.reset();
+                            break;
+                            }
+                        }
+                    else if (pacemakerMode==1){
+                        while(pacemakerMode!=0);
+                        break;
+                        }
+                    else if (t>= LRI-AVI){
+                        char* element;
+                        *element='A';
+                AVpacepms.put(element);
+                AVpacepma.put(element);
+                AVpacepmv.put(element);
+                AVpacepmm.put(element);
+                AVpacepmd.put(element);
+                        Apace=1;
+                        wait(.1);
+                        Apace=0;
+                        if (pacemakerMode==1){
+                            while(pacemakerMode!=0);
+                            break;
+                            }
+                        else{
+                            t.reset();
+                            break;
+                            }
+                        }
                     }
             }
-
-            }
-        }
-    }
-void PacemakerReceive(void const *args){
-    while(1){
-        Thread::signal_wait(0x1);
-        if (AorV=='A' && p.read()<PVARP){
-            
-        }
-        else if (AorV=='V' && p.read()<VRP){
-            }
-        else if (AorV=='A' && p.read()>=PVARP){
-            Pms.signal_set(0x01);
-            AorVsense='A'
-            t_loc.reset
-            while(1){
-                Thread::signal_wait(0x1);
-                if(AorV=='V'){
-                    break;
-                    }
+            else if (t.read()>=LRI){
+                    char* element;
+                    *element='A';
+                AVpacepms.put(element);
+                AVpacepma.put(element);
+                AVpacepmv.put(element);
+                AVpacepmm.put(element);
+                AVpacepmd.put(element);
+                    Apace=1;
+                    wait(.1);
+                    Apace=0;
+                    if (pacemakerMode==1){
+                        while(pacemakerMode!=0);
+                        break;
+                        }
+                    else{
+                        t.reset();
+                        break;
+                        }
                 }
-            while(1){
-                if (t_loc>AVI && p>URI){
-                    Pms.signal_set(0x01);
-                    AorVsense='V';
-                    p=0;
-                    t_loc=0;
+            else if (pacemakerMode==1){
+                    while(pacemakerMode!=0);
                     break;
-                    }
-            }
-            }
-            else if (AorV=='V' && p.read()>=VRP){
-                while(1){
-                    if ((t_loc>=AVI && p<=URI) || (t_loc<=AVI && p<=URI) ||(t_loc<=AVI && p>=URI)){
-                        break;
-                    }
                 }
-                while(1){
-                Thread::signal_wait(0x1);
-                if(AorV=='V'){
-                    break;
-                    }
-                }
-            while(1){
-                if (t_loc>AVI && p>URI){
-                    Pms.signal_set(0x01);
-                    AorVsense='V';
-                    p=0;
-                    t_loc=0;
-                    break;
-                    }
-            }
-                
-            }
-            
         
             
-    
+    }
     }
-
+}
+void Asig();
+void Vsig();
 int main(){
-    A.mode(PullDown);              
+    osEvent evt;
+    A.mode(PullDown); 
+    char* AorVpace;   
+   char* AorVsig;           
     A.rise(Asig);               
     V.mode(PullDown);              
     V.rise(Vsig);               
     
-    while(1);
+    while(1){
+        evt = AVpacepmm.get(1);
+        if (evt.status == osEventMessage) {
+            AorVpace = (char*)evt.value.p;
+        }
+        if (*AorVpace=='A'){
+            AorVpace=0;
+            ApaceLED=1;
+            wait(.1);
+            ApaceLED=(0);
+        }
+        else if (*AorVpace=='V'){
+            AorVpace=0;
+            VpaceLED=1;
+            wait(.1);
+            VpaceLED=0;
+            }
+        evt = AVsigpmm.get(1);
+        if (evt.status == osEventMessage) {
+            AorVsig = (char*)evt.value.p;
+        }
+        if (*AorVsig=='A'){
+            AorVsig=0;
+            AsigLED=1;
+            wait(.1);
+            ApaceLED=(0);
+        }
+        else if (*AorVsig=='V'){
+            AorVsig=0;
+            VsigLED=1;
+            wait(.1);
+            VpaceLED=0;
+            }
+        lcd.cls();
+        lcd.printf("%d", pacemakerRate);
+        Thread::wait(15);
+        };
 }
 
 
 void Asig() {
-    Pmr.signal_set(0x1);  
-    AorV='A'; 
+char* element;
+*element='A';
+AVsigpms.put(element);
+AVsigpma.put(element);
+AVsigpmv.put(element);
+AVsigpmm.put(element);
+AVsigpmd.put(element);
                              
 }
 void Vsig() {
-       Pmr.signal_set(0x1);
-       AorV='V';
+char* element;
+*element='V';
+AVsigpms.put(element);
+AVsigpma.put(element);
+AVsigpmv.put(element);
+AVsigpmm.put(element);
+AVsigpmd.put(element);
                              
 }