File content as of revision 18:374c452e19db:

#include "mbed.h"
#include "N5110.h"
#include "BMP180.h"
#include "PowerControl/PowerControl.h"
#include "PowerControl/EthernetPowerControl.h"

BMP180 bmp180(p28,p27);   // SDA, SCL
N5110 lcd(p7,p8,p9,p10,p11,p13,p26);
BusOut leds(LED4,LED3,LED2,LED1);
Serial serial(USBTX,USBRX);
InterruptIn button1(p16);
InterruptIn button2(p17);
InterruptIn button3 (p15);
InterruptIn button4 (p18);
PwmOut redLED(p24);//red
PwmOut yellowLED(p23);//yellow
PwmOut greenLED(p22);//green
PwmOut buzzer(p21); //buzzer

Ticker timer; //Create ticker object for temperature and pressure readings
Ticker dataLoggerTimer ; // a ticker object for the data logger functions
Timeout powerSaverTimeout; // create a timeout object for the poweerSaver function


int i= 0 ; //integer used to indicate the cell number with in an array
int setTimeFlag = 0; // flag for real time clock ISR
int timerFlag = 1; // Flag for tempesrature pressure reading ISR
int button1Flag = 0;
int button2Flag = 0 ;
int button3Flag = 0 ;
int button4Flag = 0 ;
int unitFlag = 1 ;
int powerSaverFlag = 0 ;
int lcdPowerFlag = 1 ; // Indicates if the LCD is switched on or powered off
int dataLoggerFlag = 0 ;
int saveToFileFlag = 0 ;
int runLoggerFlag = 0 ; // if the logger is switched on allows user to go to this option
int alarmClockFlag = 0 ; //indicates if the alarm clock has been turned on
int thresholdAlarmFlag = 0 ; // indicates if the thresholds are set

int UNIXdate;
int currentTime ;
int powerSaverTime = 60;
int dataLoggerTime = 60;

int temperature;
float pressure;
int averageTemperature ;
int averagePressure ;
int minTemperature ;
int maxTemperature ;
int minPressure;
int maxPressure;




float arrayT[83] ; // An array to store the values of temperature to draw graphs
float arrayP[83] ; // An array to store the values of pressure to draw graphs



char rxString[16]; //buffer to store recieved string from serial
char bufferTime[14]; // buffer to store time
char bufferDate[14]; //buffer to store date
char bufferT[14]; //buffer to store temperature
char bufferP[14];  //buffer to store pressure, each character is 6 pixels wide, screen is 84 pixels (84/6 = 14)
// so can display a string of a maximum 14 characters in length
// or create formatted strings - ensure they aren't more than 14 characters long



char buffer0[14];
char buffer1[14];
char buffer2[14];
char buffer3[14];
char buffer4[14];
char buffer5[14];


int state=0; // used to navigate through the finite machines
int stateplus1 ;
int stateplus2 ;
int stateminus1 ;
int stateminus2 ;

float frequency[]= {659,554,659,554,659,554,659,554,659,554,659,554};
//frequency array
float beat[]= {1,1,1,1,1,1,1,1,1,1,1,1};
//beat array


void savePower();
void loggerData();
void calculateUNIXTime();
void thresholdCheck();
void alarmClockCheck();

struct  State {
    int output;
    char title[14];
    int nextState[2];
};

typedef struct State STyp1; // for the start menu

STyp1 fsmA[5] = {
    {0,"Live Data",{1,4}},
    {1,"Saved Data",{2,0}},
    {2,"Forecast",{3,1}},
    {3,"Alarms",{4,2}},
    {4,"Settings",{0,3}},
};

typedef struct State STyp2; // for the settings menu

STyp2 fsmB[5] = {
    {0,"Date/Time",{1,4}},
    {1,"Units",{2,0}},
    {2,"Alerts",{3,1}},
    {3,"Power",{4,2}},
    {4,"Logger",{0,3}},
};

typedef struct State STyp3; // for the time/date settings

STyp3 fsmC[5] = {
    {12,"Hour:",{1,4}},
    {0,"Min:",{2,0}},
    {21,"Day:",{3,1}},
    {4,"Month:",{4,2}},
    {2015,"Year:",{0,3}},
};


typedef struct State STyp4; // for the units settings

STyp3 fsmD[4] = {
    {1,"C/mb",{1,3}},
    {2,"C/atm",{2,0}},
    {3,"F/mb",{3,1}},
    {4,"F/atm",{0,2}},
};


typedef struct State STyp5; // for the Power saver settings

STyp5 fsmE[2] = {
    {0,"Off",{1,0}},
    {60,"On",{0,1}},
};


typedef struct State Stype6; // for the alarms menu

Stype6 fsmF[2] = {
    {0,"Thresholds",{1,0}},
    {1,"Alarm Clock", {0,1}},
};

typedef struct State Stype7; // yes or no

Stype7 fsmG[2] = {
    {1,"Yes",{1,0}},
    {0,"No", {0,1}},
};

typedef struct State Stype8; // for the thresholds

Stype8 fsmH[4] = {
    {20,"Min T:",{1,3}},
    {30,"Max T:",{2,0}},
    {1000,"Min P:",{3,1}},
    {1100,"Max P:",{0,2}},
};



void button1Pressed()  //ISR to subtract 1 from the value of choice when the first button is pressed
{
    state=fsmA[state].nextState[1];
    button1Flag=1;
}



void button2Pressed() //ISR to add 1 to the value of the choice when the second button is pressed
{
    state=fsmA[state].nextState[0];
    button2Flag=1;
}



void button3Pressed()
{
    button3Flag=1;
}



void button4Pressed()
{
    button4Flag = 1 ;
}




void timerExpired() // ISR which sets the timer flag (flag used to display the buffers on LCD)
{
    yellowLED = 0;
    timerFlag=1;

}



void dataLoggerTimerExpired ()
{
    yellowLED = 0;
    dataLoggerFlag = 1 ;

}




void updateTime()
{
    time_t seconds = time(NULL); // get current time
// format time into a string (time and date)
    currentTime = seconds ; // sets the current time to an integer for alarm clock check
    //serial.printf("current time :%i \n",currentTime);
    //serial.printf("Unix date :%i \n",UNIXdate);
    strftime(bufferTime, 14 , "%I:%M", localtime(&seconds));
    strftime(bufferDate, 14 , "%d/%m/%y", localtime(&seconds));
    if (alarmClockFlag == 1 ) { // if the the alarm clock flag is set by the user
        alarmClockCheck();
    }
}

void display()
{
    lcd.clear();
    lcd.printString(buffer0,0,0);
    lcd.printString(buffer1,0,1);
    lcd.printString(buffer2,0,2);
    lcd.printString(buffer3,0,3);
    lcd.printString(buffer4,0,4);
    lcd.printString(buffer5,0,5);
    wait(0.1);

}



void readData() //Imports the data and saves them to the bufferss
{

    Measurement measurement;  // measurement structure declared in BMP180 class

    // read values (T in Celsius and P in mb) and print over serial port
    measurement = bmp180.readValues();
    // serial.printf("T = %.2f C P = %.2f mb\n",measurement.temperature,measurement.pressure);


    if (unitFlag==1 || unitFlag==2 ) {

        temperature = measurement.temperature;
        int length = sprintf(bufferT,"T = %0.1d C",temperature); // print formatted data to buffer
        // it is important the format specifier ensures the length will fit in the buffer
    }
    if (unitFlag==3 || unitFlag==4 ) {
        temperature =( measurement.temperature*(9/5))+32;
        int length = sprintf(bufferT,"T = %0.1d F",temperature); // print formatted data to buffer
        // it is important the format specifier ensures the length will fit in the buffer
    }




    if (unitFlag==1 || unitFlag==3 ) {
        pressure = measurement.pressure;  // same idea with float
        int  length = sprintf(bufferP,"P = %.2f mb",pressure); // print formatted data to buffer
        // it is important the format specifier ensures the length will fit in the buffer
    }
    if (unitFlag==2 || unitFlag==4 ) {
        pressure = measurement.pressure*0.0009869;  // same idea with floats
        int length = sprintf(bufferP,"P = %.2f atm",pressure); // print formatted data to buffer
        // it is important the format specifier ensures the length will fit in the buffer
    }

    if (thresholdAlarmFlag == 1) { // if the flag is set by the user to notify the thresholds
        serial.printf("thresholds flag checked = 1\n");
        serial.printf("real values: t %i p %f \n",temperature,pressure);
        serial.printf("thresholds: mint%i maxt%i minP%i maxP %i \n",fsmH[0].output,fsmH[1].output,fsmH[2].output,fsmH[3].output);
        thresholdCheck();
    }

}


void wakeUp ()  //Turns the LCD on after the mbed is interrupted
{


    if (lcdPowerFlag == 0) {// if the LCD is powered off
        serial.printf("lcd is off\n");

        if (button1Flag || button2Flag || button3Flag || button4Flag) { // if any of the buttons are pressed

            serial.printf("one of the buttons are pressed to turn on the lcd\n");
            lcdPowerFlag = 1 ; // sets the status of the lcd to powered on
            //serial.printf("lcd is on\n");
            lcd.init();  // turns the LCD on
            powerSaverTimeout.attach(&savePower, powerSaverTime); // setup a timeiut to call the savePower function
            button1Flag = 0 ;
            button2Flag = 0 ;
            button3Flag = 0 ;
            button4Flag = 0 ;

        }
    }

}





void savePower()   // turns off the LCD to save power
{
    serial.printf("starts saving power\n");
    lcd.turnOff () ; //turns off the lcd
    lcdPowerFlag = 0 ;  // A flag is set to indicate the state of the LCD (is switched off)
    serial.printf("LCD is off\n");

}







void powerSaverCheck()   // checks if the powersaverFlag is set
{

    if (powerSaverFlag) {

        serial.printf("Timeout attached\n");
        powerSaverTimeout.attach(&savePower, powerSaverTime); // setup a timeiut to call the savePower function

    }

    else {
        serial.printf("lcd is on\n");
        powerSaverTimeout.detach();
        serial.printf("Timeout detached\n");

    }
}




void liveData() //
{
    powerSaverCheck();
    while (1) {
        updateTime();
        wakeUp();
        loggerData();
        if (timerFlag) {

            yellowLED = 1;
            timerFlag=0;
            readData();
            strncpy(buffer1, bufferTime, 14);
            strncpy(buffer2, bufferDate, 14);
            strncpy(buffer3, bufferT, 14);
            strncpy(buffer4, bufferP, 14);
            int dispaly = sprintf (buffer5, "");//convert integer to buffer str
            int dispaly1 = sprintf (buffer0, "");//convert integer to buffer str
            display();
        }
        yellowLED = 0;
        if (button3Flag) {
            button3Flag = 0;
            timer.detach();
            break;
        }
    }
}



void loggerData() //  gets the temp and pressure data and stores to suitable arrays (the arrays are used to plot the desired graphs)
{
    if(dataLoggerFlag ==1) {
        int k ;
        int sumTemperature = 0;
        int sumPressure = 0;
        minTemperature = arrayT[0]; // sets the min to the first value in the array
        minPressure = arrayP[0];
        maxTemperature = arrayT[0];
        maxPressure = arrayP[0];
        yellowLED = 1;
        readData();

        dataLoggerFlag=0;
//write the data to the arrays (arrays used to plot graphs)
        //read the data from sensor

        //Store the values in the array
        arrayT[i] = temperature;
        arrayP[i] = pressure/25 ;


// calculate the average value of the arrays and save them to an integer

        for (k = 0 ; k<=i ; k++) { // loops through the arrays

            sumTemperature += arrayT[k]; // calculates the sum of the stored values
            averageTemperature = sumTemperature/(k+1) ; //calculates the average value

            sumPressure += arrayP[k]; // calculates the sum of the stored values
            averagePressure =( 25*(sumPressure/(k+1))) ; //calculates the average value

            if(arrayT[k]>maxTemperature) { // checks if any of the values in the array is bigger than the fist value
                maxTemperature=arrayT[k];  // if any greater values, sets the max value to that
            }
            if(arrayT[k]<minTemperature) { // finds the smallest value of the array
                minTemperature=arrayT[k];
            }
            if(arrayP[k]>maxPressure) { // checks if any of the values in the array is bigger than the fist value
                maxPressure=(25*arrayP[k]);  // if any greater values, sets the max value to that
            }
            if(arrayP[k]<maxPressure) {
                minPressure=(25*arrayP[k]);
            }

        }


        i++; // moves to the next cell in the array
        if (i>83) {
            lcd.clear();
            i=0;
        }
    }
    yellowLED = 0;
}





void dataLogger()  // shows a summery of data and the graphs
{
    int swipe = 1 ;
    while (1) {
        wakeUp();
        updateTime();
        if (runLoggerFlag) {


            loggerData();

            if (button4Flag) {
                button4Flag = 0 ;
                swipe ++;
            }
            if (swipe > 4) {
                swipe = 1;
            }

            strncpy(buffer0, bufferTime, 14);
            int display5 = sprintf (buffer5, " Back    Next");//convert integer to buffer str

            switch (swipe) {
                case 1: {
                    int display1 = sprintf (buffer1, "Temperature");
                    int display2 = sprintf (buffer2, "Min = %d", minTemperature);
                    int display3 = sprintf (buffer3, "Max = %d", maxTemperature);
                    int display4 = sprintf (buffer4, "Avg = %d", averageTemperature);
                    display();
                    break;
                }
                case 2 : {
                    lcd.clear();
                    lcd.printString("  Temperature",0,0);
                    lcd.plotArray(arrayT);
                    break;
                }
                case 3 : {
                    int display11 = sprintf (buffer1, "Pressure");
                    int display22 = sprintf (buffer2, "Min = %d", minPressure);
                    int display33 = sprintf (buffer3, "Max = %d", maxPressure);
                    int display44 = sprintf (buffer4, "Avg = %d", averagePressure);
                    display();
                    break;
                }
                case 4 : {
                    lcd.clear();
                    lcd.printString("   Pressure",0,0);
                    lcd.plotArray(arrayP);
                    break;
                }
                default :
                    break;
            }
        } else {
            lcd.clear();
            lcd.printString("  To Turn On",0,1);
            lcd.printString("    Go To",0,2);
            lcd.printString("   Settings",0,3);
            lcd.printString ("Back",0,5);

        }

        if (button3Flag) {
            button3Flag=0;
            break;
        }
    }
}




void thresholdCheck()
{
    if (temperature == fsmH[0].output) { //if the current temp is less than the set threshold
        while (1) {
            redLED = 0 ;
            strncpy(buffer0, bufferTime, 14);
            int display2 = sprintf (buffer1, "");
            int display0 = sprintf (buffer2, "Threshold");
            int display1 = sprintf (buffer3, "Reached!");
            int display4 = sprintf (buffer4, "%0.1d!",temperature);
            int display5 = sprintf (buffer5, "Stop");
            display();
            for (int i=0; i<=11; i++) {
                buzzer.period(1/(frequency[i])); // set PWM period
                buzzer=0.5; // set duty cycle
                wait(0.5*beat[i]); // hold for beat period
                redLED = 1 ;
                if (button3Flag) {
                    buzzer = 0 ;
                    button3Flag=0;
                    goto exit ;
                }
            }
        }
    }
    if (temperature == fsmH[1].output) { //if the current temp is greater than the set threshold
        while (1) {
            redLED = 0 ;
            strncpy(buffer0, bufferTime, 14);
            int display2 = sprintf (buffer1, "");
            int display0 = sprintf (buffer2, "Threshold");
            int display1 = sprintf (buffer3, "Reached!");
            int display4 = sprintf (buffer4, "%0.1d!",temperature );
            int display5 = sprintf (buffer5, "Stop");
            display();
            for (int i=0; i<=11; i++) {
                buzzer.period(1/(frequency[i])); // set PWM period
                buzzer=0.5; // set duty cycle
                wait(0.5*beat[i]); // hold for beat period
                redLED = 1 ;
                if (button3Flag) {
                    buzzer = 0 ;
                    button3Flag=0;
                    goto exit ;
                }
            }
        }
    }
    if (pressure == fsmH[2].output) {  //if the current pressure is less than the set threshold
        while (1) {
            redLED = 0 ;
            strncpy(buffer0, bufferTime, 14);
            int display2 = sprintf (buffer1, "");
            int display0 = sprintf (buffer2, "Threshold");
            int display1 = sprintf (buffer3, "Reached!");
            int display4 = sprintf (buffer4, "%0.1f!",pressure);
            int display5 = sprintf (buffer5, "Stop");
            display();
            for (int i=0; i<=11; i++) {
                buzzer.period(1/(frequency[i])); // set PWM period
                buzzer=0.5; // set duty cycle
                wait(0.5*beat[i]); // hold for beat period
                redLED = 1 ;
                if (button3Flag) {
                    buzzer = 0 ;
                    button3Flag=0;
                    goto exit ;
                }
            }
        }
    }
    if (pressure == fsmH[3].output) {  //if the current pressure is greater than the set threshold
        while (1) {
            redLED = 0 ;
            strncpy(buffer0, bufferTime, 14);
            int display2 = sprintf (buffer1, "");
            int display0 = sprintf (buffer2, "Threshold");
            int display1 = sprintf (buffer3, "Reached!");
            int display4 = sprintf (buffer4, "%0.1f!",pressure);
            int display5 = sprintf (buffer5, "Stop");
            display();
            for (int i=0; i<=11; i++) {
                buzzer.period(1/(frequency[i])); // set PWM period
                buzzer=1; // set duty cycle
                wait(0.5*beat[i]); // hold for beat period
                redLED = 1 ;
                if (button3Flag) {
                    buzzer = 0 ;
                    button3Flag=0;
                    goto exit ;
                }
            }
        }
    }
    exit:
    redLED = 0 ;

}


void threshold()
{
    powerSaverCheck();
    state = 0;
    //sets the initial threshhold values to the values recieved from the sensor
    readData();
    fsmH[0].output = temperature;
    fsmH[1].output = temperature;
    fsmH[2].output = pressure;
    fsmH[3].output = pressure;

    while (1) {

        wakeUp();
        updateTime();
        loggerData();



        int display0 = sprintf (buffer0, " Back    Save");//convert integer to buffer str
        int display1 = sprintf (buffer1, "");//convert integer to buffer str
        int display2 = sprintf (buffer2, "");//convert integer to buffer str
        int display3 = sprintf (buffer3, ">>%s %d", fsmH[state].title,fsmH[state].output);//convert integer to buffer str
        int display4 = sprintf (buffer4, "");//convert integer to buffer str
        int display5 = sprintf (buffer5, "");//convert integer to buffer str


        display();



        if (button4Flag) {
            button4Flag= 0;
            fsmH[state].output ++;
        }


        //checks the limits of the values
        if (fsmH[0].output >(temperature*2)) { //min temperature
            fsmH[0].output = -(temperature*2) ;
        }
        if (fsmH[1].output>(temperature*2)) { // max temperature
            fsmH[1].output = -(temperature*2) ;
        }
        if (fsmH[2].output>(pressure*2)) { //min pressure
            fsmH[2].output = -(pressure*2) ;
        }
        if (fsmH[3].output>(pressure*2)) { //max pressure
            fsmH[3].output = -(pressure*2) ;
        }


        if (button3Flag) {
            button3Flag=0;
            while (1) {
                int display0 = sprintf (buffer0, "");
                int display1 = sprintf (buffer1, "");
                int display2 = sprintf (buffer2, "Set Thresholds?");
                int display3 = sprintf (buffer3, ">>%s", fsmG[state].title); // yes or no (1 or 0 output)
                int display4 = sprintf (buffer4, "");
                int display5 = sprintf (buffer5, "");
                display();
                thresholdAlarmFlag = fsmG[state].output ; //yes or no (1 or 0)
                if (state>1) {
                    state = 0;
                }
                if (state<0) {
                    state = 1;
                }
                if (button3Flag) {
                    button3Flag=0;
                    serial.printf("thresholds flag :%i \n",fsmG[state].output);
                    serial.printf("thresholds: mint%i maxt%i minP%i maxP %i \n",fsmH[0].output,fsmH[1].output,fsmH[2].output,fsmH[3].output);
                    goto exit;
                }
            }
        }
    }
exit:
    return;
}







void alarmClockCheck()
{
    if (currentTime == UNIXdate) { //if the current time is equal to the time set by user
        //serial.printf("Alarm clock flag is set\n");
        alarmClockFlag =0 ;
        while (1) {
            int display0 = sprintf (buffer0, "");
            int display1 = sprintf (buffer1, "Alarm !");
            strncpy(buffer2, bufferTime, 14);
            int display2 = sprintf (buffer3, "");
            int display4 = sprintf (buffer4, "");
            int display5 = sprintf (buffer5, "Stop");
            display();
            for (int i=0; i<=11; i++) {
                buzzer.period(1/(frequency[i])); // set PWM period
                buzzer=0.5; // set duty cycle
                wait(0.5*beat[i]); // hold for beat period
                if (button3Flag) {
                    buzzer = 0 ;
                    break;
                }
            }
            if (button3Flag) {
                button3Flag=0;
                break;
            }

        }
    }
}







void alarmClock ()
{
    powerSaverCheck();
    state = 0;
    while (1) {

        wakeUp();
        updateTime();
        loggerData();
        stateminus1=fsmC[state].nextState[0];
        stateminus2=fsmC[stateminus1].nextState[0];
        stateplus1=fsmC[state].nextState[1];
        stateplus2=fsmC[stateplus1].nextState[1];




        int display0 = sprintf (buffer0, " Back    Save");//convert integer to buffer str
        int display1 = sprintf (buffer1, "%s %d", fsmC[stateminus2].title,fsmC[stateminus2].output);//convert integer to buffer str
        int display2 = sprintf (buffer2, "%s %d", fsmC[stateminus1].title,fsmC[stateminus1].output);//convert integer to buffer str
        int display3 = sprintf (buffer3, ">>%s %d", fsmC[state].title,fsmC[state].output);//convert integer to buffer str
        int display4 = sprintf (buffer4, "%s %d", fsmC[stateplus1].title,fsmC[stateplus1].output);//convert integer to buffer str
        int display5 = sprintf (buffer5, "%s %d", fsmC[stateplus2].title,fsmC[stateplus2].output);//convert integer to buffer str



        display();



        if (button4Flag) {
            button4Flag= 0;
            fsmC[state].output ++;
            calculateUNIXTime();
        }


        //checks the limits of the values
        if (fsmC[0].output >23) { //hour
            fsmC[0].output = 0 ;
        }
        if (fsmC[1].output>59) { // minute
            fsmC[1].output = 0 ;
        }
        if (fsmC[3].output>11) { //month
            fsmC[3].output = 0 ;
        }
        if (fsmC[2].output>31) { //day
            fsmC[2].output = 1 ;
        }
        if (fsmC[4].output>2030) { //year
            fsmC[4].output = 2015 ;
        }



        if (button3Flag) {
            button3Flag=0;
            while (1) {
                int display0 = sprintf (buffer0, "");
                int display1 = sprintf (buffer1, "");
                int display2 = sprintf (buffer2, "Set Alarm?");
                int display3 = sprintf (buffer3, ">>%s", fsmG[state].title);
                int display4 = sprintf (buffer4, "");
                int display5 = sprintf (buffer5, "");
                display();
                alarmClockFlag = fsmG[state].output ;
                if (state>1) {
                    state = 0;
                }
                if (state<0) {
                    state = 1;
                }
                if (button3Flag) {
                    button3Flag=0;
                    goto exit;
                }
            }
        }
    }
exit:
    return;
}





void alarmsMenu ()
{
    state = 0 ;
    powerSaverCheck();
    while (1) {
        wakeUp();
        updateTime();
        loggerData();
        int display0 = sprintf (buffer0, " Back    Next");
        int display1 = sprintf (buffer1, "");
        int display2 = sprintf (buffer2, "");
        int display3 = sprintf (buffer3, ">>%s", fsmF[state].title);
        int display4 = sprintf (buffer4, "");
        int display5 = sprintf (buffer5, "");

        display();



        if (state > 1) {
            state = 0 ;
        }
        if (state < 0) {
            state = 1 ;
        }
        if (button3Flag) {
            button3Flag=0;
            state = 0;
            break;
        }
        if (button4Flag) {
            if (state == 0) { // temp and pressure thresholds
                threshold();

            }
            if (state == 1) {// alarm clock

                alarmClock();
            }
        }
    }
}




void dataLoggerSetting()
{
    state = runLoggerFlag ; //inits the state to the saved flag by the user in the past
    powerSaverCheck();
    while (1) {
        wakeUp();
        updateTime();
        loggerData();
        int display0 = sprintf (buffer0, " Back    Save");
        int display1 = sprintf (buffer1, "");
        int display2 = sprintf (buffer2, "Data Logger");
        int display3 = sprintf (buffer3, ">>%s", fsmE[state].title);
        if (state == 1) {
            int display4 = sprintf (buffer4, "%i mins", fsmE[state].output/60);
        } else { // if the power saver is off it doesnt show the time
            int display4 = sprintf (buffer4, "");
        }
        int dispaly5 = sprintf (buffer5, "");


        display();



        runLoggerFlag = state ; //sets the flag to the value of state (0 is off, 1 is on)
        dataLoggerTime = fsmE[state].output; //sets the timer to to value of output from the fsm
        serial.printf("data logger Time = %i \n dataLoggerFlag = %i \n",dataLoggerTime , runLoggerFlag);

        if (button4Flag) {
            button4Flag=0;
            fsmE[state].output += 60 ; //adds a minute to the timer when button 4 is pressed
        }
        if (fsmE[state].output > 1800) {
            fsmE[state].output = 60 ;
        }

        if (state > 1) {
            state = 0 ;
        }

        if (button3Flag) {
            if (state == 1) { // if the data logger is swiched on
                dataLoggerTimer.attach(&dataLoggerTimerExpired, dataLoggerTime); // set the timer
            }
            if (state == 0) { // if the data logger is swiched off
                dataLoggerTimer.detach(); // detach the timer
            }
            dataLoggerFlag = 1;
            button3Flag=0;
            state = 0;
            break;
        }
        wait (0.1);
    }

}












void powerSaverSetting()
{
    state = powerSaverFlag ; //inits the state to the saved flag by the user in the past
    powerSaverCheck();
    while (1) {
        wakeUp();
        updateTime();
        loggerData();
        int display0 = sprintf (buffer0, " Back    Save");
        int display1 = sprintf (buffer1, "");
        int display2 = sprintf (buffer2, "Power Saver");
        int display3 = sprintf (buffer3, ">>%s", fsmE[state].title);
        if (state == 1) {
            int display4 = sprintf (buffer4, "%i mins", fsmE[state].output/60);
        } else { // if the power saver is off it dowsnt show the time
            int display4 = sprintf (buffer4, "");
        }
        int dispaly5 = sprintf (buffer5, "");


        display();



        powerSaverFlag = state ; //sets the flag to the value of state (0 is off, 1 is on)
        powerSaverTime = fsmE[state].output; //sets the timer to to value of output from the fsm
        serial.printf("Power Saver Time = %i \n powerSaverFlag = %i \n",powerSaverTime , powerSaverFlag);

        if (button4Flag) {
            button4Flag=0;
            fsmE[state].output += 60 ; //adds a minute to the timer when button 4 is pressed
        }
        if (fsmE[state].output > 600) {
            fsmE[state].output = 60 ;
        }

        if (state > 1) {
            state = 0 ;
        }

        if (button3Flag) {
            button3Flag=0;
            powerSaverCheck();
            state = 0;
            break;
        }
        wait (0.1);
    }
}








void calculateUNIXTime()
{
    time_t rawtime;
    struct tm * timeinfo;

    // get current timeinfo
    time ( &rawtime );
    // convert to struct
    timeinfo = localtime ( &rawtime );
    // now modify the timeinfo to the given date
    timeinfo->tm_year   = (fsmC[4].output) - 1900;
    timeinfo->tm_mon    = (fsmC[3].output) - 1;    //months since January - [0,11]
    timeinfo->tm_mday   = (fsmC[2].output) ;        //day of the month - [1,31]
    timeinfo->tm_hour   = (fsmC[0].output) ;        //hours since midnight - [0,23]
    timeinfo->tm_min    = (fsmC[1].output) ;         //minutes after the hour - [0,59]
    timeinfo->tm_sec    = 0 ;          //seconds after the minute - [0,59]

    //call mktime to create unix time stamp from timeinfo struct
    UNIXdate = mktime ( timeinfo );

}


void notificationSetting ()
{
    while(1) {
        wakeUp();
        powerSaverCheck();
        loggerData();


        if (button4Flag) {
            button4Flag=0;

        }

        if (button3Flag) {
            button3Flag=0;
            state = 0;
            break;
        }
    }
}



void unitsSetting()
{
    state = 0;
    powerSaverCheck();
    while (1) {
        wakeUp();
        updateTime();
        loggerData();
        stateminus1=fsmD[state].nextState[0];
        stateminus2=fsmD[stateminus1].nextState[0];
        stateplus1=fsmD[state].nextState[1];
        stateplus2=fsmD[stateplus1].nextState[1];




        int display0 = sprintf (buffer0, " Back    Save");//convert integer to buffer str
        int display1 = sprintf (buffer1, "%s", fsmD[stateminus2].title);//convert integer to buffer str
        int display2 = sprintf (buffer2, "%s", fsmD[stateminus1].title);//convert integer to buffer str
        int display3 = sprintf (buffer3, ">>%s", fsmD[state].title);//convert integer to buffer str
        int display4 = sprintf (buffer4, "%s", fsmD[stateplus1].title);//convert integer to buffer str
        int dispaly5 = sprintf (buffer5, "");//convert integer to buffer str


        unitFlag = fsmD[state].output;

        display();

        if (button3Flag) {
            button3Flag=0;
            state = 0;
            break;
        }

        wait (0.1);
    }
}







void timeDateSetting()
{
    powerSaverCheck();
    state = 0;
    while (1) {
        wakeUp();
        updateTime();
        loggerData();
        stateminus1=fsmC[state].nextState[0];
        stateminus2=fsmC[stateminus1].nextState[0];
        stateplus1=fsmC[state].nextState[1];
        stateplus2=fsmC[stateplus1].nextState[1];




        int display0 = sprintf (buffer0, " Back    Save");//convert integer to buffer str
        int display1 = sprintf (buffer1, "%s %d", fsmC[stateminus2].title,fsmC[stateminus2].output);//convert integer to buffer str
        int display2 = sprintf (buffer2, "%s %d", fsmC[stateminus1].title,fsmC[stateminus1].output);//convert integer to buffer str
        int display3 = sprintf (buffer3, ">>%s %d", fsmC[state].title,fsmC[state].output);//convert integer to buffer str
        int display4 = sprintf (buffer4, "%s %d", fsmC[stateplus1].title,fsmC[stateplus1].output);//convert integer to buffer str
        int display5 = sprintf (buffer5, "%s %d", fsmC[stateplus2].title,fsmC[stateplus2].output);//convert integer to buffer str



        display();



        if (button4Flag) {
            button4Flag= 0;
            fsmC[state].output ++;
            calculateUNIXTime();
            set_time(UNIXdate); // initialise time from the calculated UNIX time entered by the user
        }


        //checks the limits of the values
        if (fsmC[0].output >23) { //hour
            fsmC[0].output = 0 ;
        }
        if (fsmC[1].output>59) { // minute
            fsmC[1].output = 0 ;
        }
        if (fsmC[3].output>11) { //month
            fsmC[3].output = 0 ;
        }
        if (fsmC[2].output>31) { //day
            fsmC[2].output = 1 ;
        }
        if (fsmC[4].output>2030) { //year
            fsmC[4].output = 2015 ;
        }



        if (button3Flag) {
            button3Flag=0;
            state = 0;
            break;
        }
        wait (0.1);
    }
}




void settingsMenu()
{
    state = 0;
    powerSaverCheck();
    while(1) {

        stateminus1=fsmB[state].nextState[0];
        stateminus2=fsmB[stateminus1].nextState[0];
        stateplus1=fsmB[state].nextState[1];
        stateplus2=fsmB[stateplus1].nextState[1];


        wakeUp();
        updateTime();
        loggerData();
        strncpy(buffer0, bufferTime, 14);
        int dispaly = sprintf (buffer1, "%s", fsmB[stateminus2].title);//convert integer to buffer str
        int dispaly1 = sprintf (buffer2, "%s", fsmB[stateminus1].title);//convert integer to buffer str
        int dispaly2 = sprintf (buffer3, ">>%s", fsmB[state].title);//convert integer to buffer str
        int dispaly3 = sprintf (buffer4, "%s", fsmB[stateplus1].title);//convert integer to buffer str
        int dispaly4 = sprintf (buffer5, "%s", fsmB[stateplus2].title);//convert integer to buffer str

        display();


        switch (state) {
            case 0:
                if (button4Flag) {
                    button4Flag=0;
                    timeDateSetting();
                }


                break;
            case 1:


                if (button4Flag) {
                    button4Flag=0;
                    unitsSetting();
                }

                break;
            case 2:

                if (button4Flag) {
                    button4Flag = 0;
                    notificationSetting();
                }
                break;
            case 3:
                if (button4Flag) {
                    button4Flag = 0;
                    powerSaverSetting();
                }
                break;
            case 4:
                if (button4Flag) {
                    button4Flag = 0;
                    dataLoggerSetting();
                }
                break;
            default:
                break;
        }
        if (button3Flag) {
            button3Flag=0;
            state = 0;
            break;
        }
        wait (0.1);
    }
}


void startMenu()   //The menu displayed at the beginning
{
    wakeUp();

    stateminus1=fsmA[state].nextState[1];
    stateminus2=fsmA[stateminus1].nextState[1];
    stateplus1=fsmA[state].nextState[0];
    stateplus2=fsmA[stateplus1].nextState[0];


    strncpy(buffer0, bufferTime, 14);
    int dispaly = sprintf (buffer1, "%s", fsmA[stateminus2].title);//convert integer to buffer str
    int dispaly1 = sprintf (buffer2, "%s", fsmA[stateminus1].title);//convert integer to buffer str
    int dispaly2 = sprintf (buffer3, ">>%s", fsmA[state].title);//convert integer to buffer str
    int dispaly3 = sprintf (buffer4, "%s", fsmA[stateplus1].title);//convert integer to buffer str
    int dispaly4 = sprintf (buffer5, "%s", fsmA[stateplus2].title);//convert integer to buffer str



    switch (state) {
        case 0:
            if (button4Flag) {
                button4Flag=0;
                timerFlag=1;
                timer.attach(&timerExpired,1.0);
                liveData();
            }
            break;
        case 1:
            if (button4Flag) {
                button4Flag=0;
                dataLogger();
            }
            break;
        case 2:
            break;
        case 3:
            if (button4Flag) {
                button4Flag=0;
                alarmsMenu();
            }
            break;
        case 4:
            if (button4Flag) {
                button4Flag=0;
                settingsMenu();
            }
            break;
        default:
            break;
    }
}




int main()
{

    // initiliase barometer
    bmp180.init();
    lcd.init();
    button1.rise(&button1Pressed); // call ISR on rising edge (button1pressed)
    button2.rise(&button2Pressed); // call ISR on rising edge (button2pressed)
    button3.rise(&button3Pressed);
    button4.rise(&button4Pressed);
    dataLoggerTimer.attach(&dataLoggerTimerExpired , dataLoggerTime);
    //set_time(UNIXdate); // initialise time from the calculated UNIX time entered by the user
    redLED.period_us(25);// Set frequency at 40kHz
    yellowLED.period_us(25);// Set frequency at 40kHz
    greenLED.period_us(25);// Set frequency at 40kHz
    powerSaverCheck();

    while(1) {
        updateTime();
        loggerData();
        startMenu();
        display();
        wait (0.1);
    }
}