File content as of revision 7:962b5f044a9b:

/**
@file main.cpp
@brief Program implementation

*/
#include "main.h"

int main()
{
    PHY_PowerDown();
    semihost_powerdown();
    pc.baud(9600);  ///sets baud rate
    timer.attach(&timerExpired,0.2); /// Sets the speed of the timer and attaches a function to run
    timer2.attach(&timer2Expired,1); /// Sets the speed of the timer and attaches a function to run
    timer3.attach(&timer3Expired,2); /// Sets the speed of the timer and attaches a function to run
    LogTog.rise(&logToggle); /// attaches a function to the rise of the LogTog button
    UnitTog.rise(&unitToggle); /// attaches a function to the rise of the UnitTog button
    VisTog.rise(&visToggle); /// attaches a function to the rise of the VisTog button
    pc.attach(&serialISR); /// attach serial ISR
    set_time(1427846400); /// initialise time to 1st April 2015 00:00:00

    BLED.period(0.02);  ///sets the frequency of the Backlight at 50Hz
    BLED=BLEDLevel.read();  ///sets the brightness
    lcd.init(); ///to initilize the display
    introTune(); /// plays the intro tune
    lcd.printString("---+--+--+---",3,0);
    lcd.printString("Distance",18,1);
    lcd.printString("Sensor",25,2);
    lcd.printString("By Jakobi",16,3);
    lcd.printString("Blackburn",16,4);
    lcd.printString("---+--+--+---",3,5);
    wait(2);
    lcd.clear(); /// clears the opening message
    while(1) {
        if (setTimeFlag) { /// if updated time has been sent
            setTimeFlag = 0; /// clear flag
            setTime(); /// update time
        }
        if(distance>=100) { /// uses the 2 second timer if the distance is above 100
            if(timer3Flag) { /// 2 second timer's flag
                pc.printf("Scan Speed = 0.5 \n"); /// prints the scan speed across the serial port
                theMain(); /// Contains the main code

            }
        } else if(distance>=50) { /// uses the 1 second timer if the distance is above 50 and less than 100
            if(timer2Flag) {/// 1 second timer's flag
                pc.printf("Scan Speed = 1 \n"); /// prints the scan speed across the serial port
                theMain(); /// Contains the main code
            }
        } else if(distance<50) { /// uses the 0.2 second timer if the distance is less than 50
            if(timerFlag) {/// 0.2 second timer's flag
                pc.printf("Scan Speed = 5 \n"); /// prints the scan speed across the serial port
                theMain(); /// Contains the main code
            }
        } else {
            error(1); //displays an error message across the mBed leds
        }

        Sleep();
    }
}

void timerExpired()
{
    timerFlag=1;
}

void timer2Expired()
{
    timer2Flag=1;
}
void timer3Expired()
{
    timer3Flag=1;
}

void theMain()
{
    BLED=BLEDLevel.read();  ///sets the brightness
    timerFlag =0; ///resets flags
    timer2Flag=0;
    timer3Flag=0;
    time_t seconds = time(NULL); /// get current time
    /// format time into a string (time and date)
    strftime(buffer, 30 , "%d/%m/%y %R", localtime(&seconds));
    float dist = getDistance()*unitX; ///reads the distance and sets it to a float value.
    ///prints the value to the serial port.
    if(state==1) {
        pc.printf("%s , Distance = %.2f %s \n",buffer,dist,units);   ///prints the value to the serial port.
    } else if(state !=1) {
        pc.printf("%s , Distance = %.0f %s \n",buffer,dist,units);   ///prints the value to the serial port.
    }
    logging(buffer,distance);
    if(visual==0) {
        LCDVis0();
    } else if(visual==1) {
        LCDVis1();
    } else if(visual==2) {
        LCDVis2();
    } else if(visual==3) {
        LCDVis3();
    } else {
        error(2);
    }

}


void warnings()
{
    WLED=1;
    volume= BuzVol.read();
    if(distance<20) {
        Buzzer.ContNote(1000.0, volume);
        
    } else {
        Buzzer.PlayNote(1000.0, 0.1, volume);
    }
    WLED=0;
}
float getDistance()
{
    int dist0 = sensor.getDistanceCm();

    int dist1 = sensor.getDistanceCm();

    int dist2 = sensor.getDistanceCm();

    int dist3 = sensor.getDistanceCm();

    int dist4 = sensor.getDistanceCm();

    int dist5 = sensor.getDistanceCm();

    int dist6 = sensor.getDistanceCm();

    int dist7 = sensor.getDistanceCm();

    int dist8 = sensor.getDistanceCm();

    int dist9 = sensor.getDistanceCm();

    distance=(dist0+dist1+dist2+dist3+dist4+dist5+dist6+dist7+dist8+dist9)/10;

    warnings();
    return distance;
}

void unitToggle()
{
    state = fsm[state].nextState[UnitTog]; /// read input and update current state
    unitX = fsm[state].unitMultiple; /// set output depending on current state
    units= fsm[state].Unit; ///
    wait(0.2);
    pc.printf("unit multiple = %.2f \n",unitX);
    pc.printf("Units = %s \n",units);
}


void error(int E) /// up to 14. IF 15 shown it is a ack bit error for the SRF02
{
    while(1) {
        leds=0;
        wait(0.2);
        leds=E;
        wait(0.2);
    }
}

void logToggle()
{
    logButtonFlag = !logButtonFlag; //flips the flag
    if(logButtonFlag) {
        LLED=1; // Logging LED will be on if the device is logging
        pc.printf("-------\n Data Logging\n\r");
    } else {
        LLED=0; // Logging LED will be off if the device isn't logging
        pc.printf("-------\n Stopped Logging Data\n\r");
    }
    wait(0.2);
}

void logging(char* data,float data1)
{
    if(logButtonFlag) {
        FILE *fp = fopen("/local/log.csv", "a"); /// open 'log.csv' for appending
        /// if the file doesn't exist it is created, if it exists, data is appended to the end
        fprintf(fp," %s , %.2f\n ",data,data1); /// print string to file
        fclose(fp); /// close file
        pc.printf("Data Logged\n");
        LLED=1; /// keeps the led on if it is logging
    } else {
        pc.printf("WARNING : Unlogged Data\n");
        LLED=0;
    }
}

void setTime()
{
/// print time for debugging
    pc.printf("set time - %s",rxString);
/// atoi() converts a string to an integer
    int time = atoi(rxString);
/// update the time
    set_time(time);
    pc.printf("set time - %d",time);
}
void serialISR()
{
/// when a serial interrupt occurs, read rx string into buffer
    pc.gets(rxString,16);
/// set flag
    setTimeFlag = 1;
}

void introTune()
{
    Buzzer.PlayNote(1319.0,0.084,1.0);
    wait(0.01);
    Buzzer.PlayNote(1319.0,0.084,1.0);
    wait(0.094);
    Buzzer.PlayNote(1319.0,0.084,1.0);
    wait(0.094);
    Buzzer.PlayNote(1047.0,0.084,1.0);
    wait(0.01);
    Buzzer.PlayNote(1319.0,0.084,1.0);
    wait(0.094);
    Buzzer.PlayNote(1568.0,0.084,1.0);
    wait(0.26);
    Buzzer.PlayNote(784.0,0.084,1.0);
}

void checkerBoard() /// creates a checked pattern on the lcd
{
    for(int i=0; i<84; i+=2) {
        for(int j=0; j<48; j+=2) {
            lcd.setPixel(i,j);
        }
    }
    lcd.refresh();
}

void LCDVis0()    /// the max range is 249 (according to the data sheet) and there are 84 pixels wide on the LCD so this creates the amount of cm for each pixel
{
    lcd.clear();
    if(logButtonFlag) {
        lcd.printString("-L-",0,5);
    }
    
    int I = distance*0.337;  /// and then multiplies the current distance by that value as (84/249) =0.337...
    I=I+3;
    if(I>=79){I=79;}
    pc.printf("bar width - %d pixels \n",I);
    lcd.drawRect(0,16,83,16,0);
    lcd.drawRect(2,18,I,12,1);
    if(state==1) {
        sprintf(Dbuffer, "%.2f", distance*unitX);   /// prints the value to the serial port.
    } else if(state !=1) {
        sprintf(Dbuffer, "%.0f", distance*unitX);   /// prints the value to the serial port.
    }
    lcd.printString (buffer,0,0);
    lcd.printString (Dbuffer,26,5);
    lcd.printString (units,50,5);
    lcd.refresh();
}

void LCDVis1()  /// the max range is 249 (according to the data sheet) and there are 48 pixels high on the LCD so this creates the amount of cm for each pixel
{
    lcd.clear();
    if(logButtonFlag) {
        lcd.printString("-L-",0,5);
    }
    
    int J = distance*0.14;  /// and then multiplies the current distance by that value as (36/249) = 0.19..(as top 12 pixels are for time)
    if(J>=36) {
        J=36;
    }
    pc.printf("bar height - %d pixels \n",J);
    lcd.drawRect(24,9,34,38,0);
    lcd.drawRect(26,47-J,30,J-2,1);
    if(state==1) {
        sprintf(Dbuffer, "%.2f", distance*unitX);   /// prints the value to the serial port.
    } else if(state !=1) {
        sprintf(Dbuffer, "%.0f", distance*unitX);   /// prints the value to the serial port.
    }
    lcd.printString (buffer,0,0);
    lcd.printString (Dbuffer,60,3);
    lcd.printString (units,64,4);
    lcd.refresh();
}

void LCDVis2()
{
    lcd.clear();
    if(logButtonFlag) {
        lcd.printString("-L-",0,5);
    }
    
    car();
    int I = distance*0.277;  /// and then multiplies the current distance by that value as (69/249) =0.277...
    if(I>=84) {
        I=84;
    }
    pc.printf("bar width - %d pixels \n",I);
    lcd.drawRect(I+15,9,69,29,1);
    if(state==1) {
        sprintf(Dbuffer, "%.2f", distance*unitX);   /// prints the value to the serial port.
    } else if(state !=1) {
        sprintf(Dbuffer, "%.0f", distance*unitX);   /// prints the value to the serial port.
    }
    lcd.printString (buffer,0,0);
    lcd.printString (Dbuffer,26,5);
    lcd.printString (units,50,5);
    lcd.refresh();
}
void LCDVis3()
{
    lcd.clear();
    if(logButtonFlag) {
        lcd.printString("-L-",0,5);
    }
    lcd.printString (buffer,0,0);
    int Dist=distance;
    if(state==0) {
        lcd.printString("CM",54,3);
    }
    if(state==1) {
        lcd.decimal();
        lcd.printString("M",54,3);
    }
    if(state==2) {
        lcd.number0(57);
        lcd.printString("MM",73,3);
    }
    int S=Dist %10;
    pc.printf("singles - %d \n",S);
    if(S==0) {
        lcd.number0(38);
    } else if(S==1) {
        lcd.number1(38);
    } else if(S==2) {
        lcd.number2(38);
    } else if(S==3) {
        lcd.number3(38);
    } else if(S==4) {
        lcd.number4(38);
    } else if(S==5) {
        lcd.number5(38);
    } else if(S==6) {
        lcd.number6(38);
    } else if(S==7) {
        lcd.number7(38);
    } else if(S==8) {
        lcd.number8(38);
    } else if(S==9) {
        lcd.number9(38);
    } else {
        error(4);
    }

    int T=Dist/10 %10;
    pc.printf("tens - %d \n",T);
    if(T==0) {
        lcd.number0(19);
    } else if(T==1) {
        lcd.number1(19);
    } else if(T==2) {
        lcd.number2(19);
    } else if(T==3) {
        lcd.number3(19);
    } else if(T==4) {
        lcd.number4(19);
    } else if(T==5) {
        lcd.number5(19);
    } else if(T==6) {
        lcd.number6(19);
    } else if(T==7) {
        lcd.number7(19);
    } else if(T==8) {
        lcd.number8(19);
    } else if(T==9) {
        lcd.number9(19);
    } else {
        error(4);
    }
    int H=Dist/100 %10;
    pc.printf("Hundreds - %d \n",H);
    if(H==0) {

    } else if(H==1) {
        lcd.number1(0);
    } else if(H==2) {
        lcd.number2(0);
    } else if(H==3) {
        lcd.number3(0);
    } else if(H==4) {
        lcd.number4(0);
    } else if(H==5) {
        lcd.number5(0);
    } else if(H==6) {
        lcd.number6(0);
    } else if(H==7) {
        lcd.number7(0);
    } else if(H==8) {
        lcd.number8(0);
    } else if(H==9) {
        lcd.number9(0);
    } else {
        error(4);
    }
    lcd.refresh();
}






void car()
{
    lcd.setPixel(4,19);lcd.setPixel(5,19);lcd.setPixel(6,19);lcd.setPixel(10,19);lcd.setPixel(11,19);lcd.setPixel(12,19);
    lcd.setPixel(4,20);lcd.setPixel(5,20);lcd.setPixel(6,20);lcd.setPixel(10,20);lcd.setPixel(11,20);lcd.setPixel(12,20);
    lcd.setPixel(1,21);lcd.setPixel(2,21);lcd.setPixel(3,21);lcd.setPixel(4,21);lcd.setPixel(5,21);lcd.setPixel(6,21);
    lcd.setPixel(7,21);lcd.setPixel(8,21);lcd.setPixel(9,21);lcd.setPixel(10,21);lcd.setPixel(11,21);lcd.setPixel(12,21);
    lcd.setPixel(13,21);lcd.setPixel(0,22);lcd.setPixel(1,22);lcd.setPixel(2,22);lcd.setPixel(3,22);lcd.setPixel(4,22);
    lcd.setPixel(6,22);lcd.setPixel(7,22);lcd.setPixel(8,22);lcd.setPixel(9,22);lcd.setPixel(10,22);lcd.setPixel(12,22);
    lcd.setPixel(13,22);lcd.setPixel(0,23);lcd.setPixel(1,23);lcd.setPixel(2,23);lcd.setPixel(3,23);lcd.setPixel(6,23);
    lcd.setPixel(7,23);lcd.setPixel(8,23);lcd.setPixel(9,23);lcd.setPixel(10,23);lcd.setPixel(12,23);lcd.setPixel(13,23);
    lcd.setPixel(0,24);lcd.setPixel(1,24);lcd.setPixel(2,24);lcd.setPixel(3,24);lcd.setPixel(6,24);lcd.setPixel(7,24);
    lcd.setPixel(8,24);lcd.setPixel(9,24);lcd.setPixel(10,24);lcd.setPixel(12,24);lcd.setPixel(13,24);lcd.setPixel(0,25);
    lcd.setPixel(1,25);lcd.setPixel(2,25);lcd.setPixel(3,25);lcd.setPixel(6,25);lcd.setPixel(7,25);lcd.setPixel(8,25);
    lcd.setPixel(9,25);lcd.setPixel(10,25);lcd.setPixel(12,25);lcd.setPixel(13,25);lcd.setPixel(0,26);lcd.setPixel(1,26);
    lcd.setPixel(2,26);lcd.setPixel(3,26);lcd.setPixel(4,26);lcd.setPixel(6,26);lcd.setPixel(7,26);lcd.setPixel(8,26);
    lcd.setPixel(9,26);lcd.setPixel(10,26);lcd.setPixel(12,26);lcd.setPixel(13,26);lcd.setPixel(1,27);lcd.setPixel(2,27);
    lcd.setPixel(3,27);lcd.setPixel(4,27);lcd.setPixel(5,27);lcd.setPixel(6,27);lcd.setPixel(7,27);lcd.setPixel(8,27);
    lcd.setPixel(9,27);lcd.setPixel(10,27);lcd.setPixel(11,27);lcd.setPixel(12,27);lcd.setPixel(13,27);lcd.setPixel(4,28);
    lcd.setPixel(5,28);lcd.setPixel(6,28);lcd.setPixel(10,28);lcd.setPixel(11,28);lcd.setPixel(12,28);lcd.setPixel(4,29);
    lcd.setPixel(5,29);lcd.setPixel(6,29);lcd.setPixel(10,29);lcd.setPixel(11,29);lcd.setPixel(12,29);
}

void visToggle()
{
    Vstate = Vfsm[Vstate].nextState[VisTog]; /// read input and update current state
    visual = Vfsm[Vstate].visual; /// set output depending on current state
    wait(0.2);
    if(visual==0) {
        pc.printf("----Left to Right----\n\r");
    }
    if(visual==1) {
        pc.printf("----Up to Down----\n\r");
    }
    if(visual==2) {
        pc.printf("----Car & Wall----\n\r");
    }
    if(visual==3) {
        pc.printf("----Numbers----\n\r");
    }
}

int semihost_powerdown(){
    uint32_t arg;
    return __semihost(USR_POWERDOWN, &arg);
}