File content as of revision 2:3d47bb081502:

#include "main.h"
//#include "TextLCD.h"

void incrementHeartRate() {
    heartRateMutex.lock();
    heartRate++;
    heartRateMutex.unlock();    
}

void setVSignal(bool state) {
    expectVMutex.lock();        
    waitVSignal = state;
    expectVMutex.unlock();
}

void setASignal(bool state) {
    expectAMutex.lock();        
    waitASignal = state;
    expectAMutex.unlock();   
}

void setTimeConstraint(int i) {
    timeConstraintMutex.lock();
    timeConstraint = i;
    timeConstraintMutex.unlock();    
}

void printToLCD() {
    displayMutex.lock();
//    pc.printf("%04d\r\n", avgHeartRate);
//    pc.printf("%02d\r\n", observationInterval/1000);
//    pc.printf("%04d\r\n", (heartRateHeart*(60/sec))); 
    displayMutex.unlock();
}

void println(const char *c) {
    pc.printf(c);
    pc.printf("\r\n");
}

void switchToNormal() {
    LRI = normalModeLRI;
    AVI = normalModeAVI;
    PVARP = normalModePVARP;
    URI = normalModeURI;
    VRP = normalModeVRP;
    PVAB = normalModePVAB;
}

void switchToExercise() {
    LRI = exerciseModeLRI;
    AVI = exerciseModeAVI;
    PVARP = exerciseModePVARP;
    URI = exerciseModeURI;
    VRP = exerciseModeVRP;
    PVAB = exerciseModePVAB;
}

void switchToSleep() {
    LRI = sleepModeLRI;
    AVI = sleepModeAVI;
    PVARP = sleepModePVARP;
    URI = sleepModeURI;
    VRP = sleepModeVRP;
    PVAB = sleepModePVAB;
}

void changeMode()
{
    switch(paceMakerMode)
    {
        default:
        case NORMAL:
        {
            switchToNormal();
            break;
        }
        case EXERCISE:
        {
            switchToExercise();
            break;
        }
        case SLEEP:
        {
            switchToSleep();
            break;
        }
        case MANUAL:
        {
            break;
        }
    }    
    modeChanged=false;
}

void pacemakerModeSwitch(const void *args)
{
    while(1)
    {
        Thread::signal_wait(signal3);
        if(modeChanged)
        {
            changeMode();
        }
    }
}
            
void aSense()
{
    if(waitASignal)
    {
        asenseLED=1;
        wait(0.001);
        println("ASense Received");
        asenseLED=0; 
        if(modeChanged)
        {
            (*P_PacemakerModeSwitch).signal_set(signal3);
        }
        aSenseOccurred=true;
        (*P_PacemakerReceive).signal_set(signal4);
    }    
}

void vSense()
{
    heartRateHeart++;
    if(waitVSignal)
    {
        vsenseLED=1;
        println("VSense Received");
        wait(0.001);
        vsenseLED=0;
        if(modeChanged)
        {
            (*P_PacemakerModeSwitch).signal_set(signal3);
        }
        canPaceV=false;
        aSenseOccurred=false;
        (*P_PacemakerReceive).signal_set(signal4);
    }
}

void seconds(const void *args)
{
    sec++;
    if(sec>=60)
    {
        avgHeartRateHeart=heartRateHeart;
        heartRateHeart=0;
        sec=0;
    }
}

void timeOut(const void *args)
{
    // check which time out has occurred
    // generate appropriate pace signal
    // reset timer to new value  
    //apaceLED=1; 
    if(timeConstraint==AVI_const)
    {
        //generate VPace
        if(canPaceV)
        {
            paceA=false;
            (*P_PacemakerSend).signal_set(signal1);
        }
        else
        {
            canPaceV=true;
        }
    }
    else if(timeConstraint==PVAB_const)
    {
        setVSignal(true);
        setTimeConstraint(AVI_const);
        timerRunning=true;
        TimeOutTimer->start(AVI-PVAB);
    }
    else if(timeConstraint==VRP_const)
    {
        //now we can sense a Ventrival event, but not an atrial event as PVARP is not over 
        //restart timer for PVARP
        setVSignal(true);
        setTimeConstraint(PVARP_const);;
        timerRunning=true;
        TimeOutTimer->start(PVARP-VRP);
    }
    else if(timeConstraint==PVARP_const)
    {
        //now we can sense Atrial events as well
        setASignal(true);
        setTimeConstraint(LRI_const);
        timerRunning=true;
        TimeOutTimer->start(LRI-PVARP-AVI);
    }
    else if(timeConstraint==LRI_const)
    {
        //generate APace
        paceA=true;
        (*P_PacemakerSend).signal_set(signal1);
    }
}

void uriTimeOut(const void *args)
{
    // uri is over 
    //check is a vpace has to be generated; If yes then generate the pace; else enable a flag that lets the thread generate the pace
    if(paceVPending || canPaceV)
    {
        //pace V as a pace occurred during URI
        paceA=false;
        paceVPending=false;
        (*P_PacemakerSend).signal_set(signal1);
    }
    else
    {
        canPaceV=true;              //allow the PM to pace V as URI is now over
    }
    
}   

void keyTimeOut(const void *args)
{
    if(digitOneReceived)
    {
        observationChange=false;
    }
    else
    {
        observationChange=false;
    }
}

void pacemakerReceive(const void *args)
{
    while(1)
    {
        Thread::signal_wait(signal4);
        if(timerRunning)
        {
            TimeOutTimer->stop();
            timerRunning=false;
        }
        if(aSenseOccurred)
        {
            setASignal(false);
            setVSignal(true);
            timerRunning=true;
            setTimeConstraint(AVI_const);
            TimeOutTimer->start(AVI);//500);            
        }
        else
        {
            incrementHeartRate();
            setVSignal(false);
            setASignal(false);
            canPaceV=false;
            URITimeOutTimer->start(URI);
            timerRunning=true;
            setTimeConstraint(VRP_const);
            TimeOutTimer->start(VRP);
        }
    }
}
        
void pacemakerSend(const void *args)
{
    while(1)
    {
        Thread::signal_wait(signal1);
        if(paceA)
        {
            println("APace Sent");
            apaceLED=1;
            aPace=1;
            Thread::wait(1);
            aPace=0;
            apaceLED=0;
            if(modeChanged)
            {
                changeMode();
            }
            // start AVI Timer
            setASignal(false);
            setVSignal(false);
            setTimeConstraint(PVAB_const);
            timerRunning=true;
            TimeOutTimer->start(PVAB);
            //generate the APace pulse
        }
        else
        {
            println("VPace Sent");
            vpaceLED=1;
            vPace=1;
            Thread::wait(1);
            vPace=0;
            vpaceLED=0;
            if(modeChanged)
            {
                changeMode();
            }
            // start VRP and URI timers
            setVSignal(false);
            setASignal(false);
            incrementHeartRate();
            canPaceV=false;
            URITimeOutTimer->start(URI);
            setTimeConstraint(VRP_const);
            timerRunning=true;
            TimeOutTimer->start(VRP);
            //generate the VPace pulse
        }
    }
}

void readInt() {
    char c = pc.getc();
    int input = c-48;
    c = pc.getc();
    while (c != '\r') {
        input *= 10;
        input += c-48;
        c = pc.getc();      
    }

    if (input >= 10 && input <= 90) {
        pacemakerInterval=input;
        pc.printf("Obs Int Changed: %d\r\n", pacemakerInterval);     
    } else {
        pc.printf("Bad Obs Int: %d\r\n", input);     
    }
}

void pacemakerKeyboard(const void *args)
{
    while(1)
    {
        Thread::signal_wait(signal2);
        if((((ch=='a')||(ch=='A')) && paceMakerMode==MANUAL) && !observationChange)
        {
            //fire A Pace
            paceA=true;
            (*P_PacemakerSend).signal_set(signal1);
        }
        else if((((ch=='v')||(ch=='V')) && paceMakerMode==MANUAL) && !observationChange)
        {
            //fire V Pace
            if(canPaceV)
            {
                paceA=false;
                paceVPending=false;
                (*P_PacemakerSend).signal_set(signal1);
            }
            else
            {
                paceVPending=true;
            }
        }
        else if(((((ch=='n')||(ch=='N'))&& paceMakerMode!=NORMAL) && !observationChange) && !modeChanged)
        {
            paceMakerMode=NORMAL;
            modeChanged=true;
        }
        else if(((((ch=='e')||(ch=='E')) && paceMakerMode!=EXERCISE) && !observationChange) && !modeChanged)
        {
            paceMakerMode=EXERCISE;
            modeChanged=true;
        }
        else if(((((ch=='s')||(ch=='S')) && paceMakerMode!=SLEEP) && !observationChange) && !modeChanged)
        {
            paceMakerMode=SLEEP;
            modeChanged=true;
        }
        else if(((((ch=='b')||(ch=='B')) ) && !observationChange) )
        {
            ringAlarm=!ringAlarm;
        }
        else if(((((ch=='m')||(ch=='M')) && paceMakerMode!=MANUAL) && !observationChange) && !modeChanged)
        {
            paceMakerMode=MANUAL;
            modeChanged=true;
        }
        else if(((((ch=='o')||(ch=='O')) && !observationChange) && !modeChanged))
        {
            // blocks, reading characters, until "return" is pressed
            readInt();
        }                
    }
}

void alarm(const void *args)
{
    while(1)
    {
        Thread::wait(1000);
        while(((heartRateHeart*(60/sec))>(60000/URI)) && ringAlarm)
        {
            buzzer=1;
            Thread::wait(5);
            buzzer=0;
            Thread::wait(5);
            if(!ringingAlarm)
            {
                displayMutex.lock();
                println("Alarm : HeartRate too high");
                displayMutex.unlock();
                ringingAlarm=true;
            }
        }
        while(((heartRateHeart*(60/sec))<(60000/LRI)) && ringAlarm)
        {
            buzzer=1;
            Thread::wait(10);
            buzzer=0;
            Thread::wait(10);
            if(!ringingAlarm)
            {
                displayMutex.lock();
                println("Alarm : HeartRate too Low");
                displayMutex.unlock();
                ringingAlarm=true;
            }
        }
        if(ringingAlarm)
        {
            ringingAlarm=false;
//            resetDisplay();
        }
    }
}

void display(const void *args)
{
    displayTimer.start();
    
    while(1)
    {
        if (displayTimer.read_ms() >= observationInterval) {
            displayTimer.reset();
            printToLCD();
            waitCount++;
            if(!observationChange)
            {
                avgHeartRate=heartRate*rateCoefficient/waitCount;
                heartRateMutex.lock();
                heartRate=0;
                heartRateMutex.unlock();
                if(pacemakerInterval!=(observationInterval/1000))
                {
                    //resetDisplay();
                    printToLCD();
                    observationInterval=pacemakerInterval*1000;           
                    rateCoefficient=(60000/observationInterval);
                }
                waitCount=0;   
            }     
        } else {
            printToLCD();
            Thread::wait(100);
        }   
    }
}

int main() 
{    
    setVSignal(true);
    setVSignal(true);
    switchToNormal();
    
    ASignal.fall(&aSense);
    VSignal.fall(&vSense);
    TimeOutTimer=new RtosTimer(timeOut, osTimerOnce, (void*)0);
    URITimeOutTimer=new RtosTimer(uriTimeOut, osTimerOnce, (void *)0);
    SecondsTimer=new RtosTimer(seconds, osTimerPeriodic, (void *)0);                //timer that over runs every 1 second and is used to reset the heart rate count coming from the heart
    SecondsTimer->start(1000);                                                      //start the timer to run for every 1 second
    
    Thread PacemakerSend(pacemakerSend);
    P_PacemakerSend=&PacemakerSend;
    PacemakerSend.set_priority(osPriorityHigh);
    
    Thread PacemakerReceive(pacemakerReceive);
    P_PacemakerReceive=&PacemakerReceive;
    PacemakerReceive.set_priority(osPriorityAboveNormal);
    
    Thread PacemakerModeSwitch(pacemakerModeSwitch);
    P_PacemakerModeSwitch=&PacemakerModeSwitch;
    PacemakerModeSwitch.set_priority(osPriorityAboveNormal);
    
    Thread PacemakerKeyboard(pacemakerKeyboard);
    P_PacemakerKeyboard=&PacemakerKeyboard;
    PacemakerKeyboard.set_priority(osPriorityRealtime);
    
    Thread Display(display);
    Display.set_priority(osPriorityAboveNormal);
    Thread Alarm(alarm);
    Alarm.set_priority(osPriorityAboveNormal);
    
    setTimeConstraint(VRP_const);
    TimeOutTimer->start(VRP);
    
    while(1) {
        if(pc.readable())
        {
            ch=pc.getc();
            (*P_PacemakerKeyboard).signal_set(signal2);
        }
    }
}