File content as of revision 5:41cb88f47f42:

/* ELEC2645 Project

Week 19 - Take distance readings from the sensor and limited ticker interrupts
Week 20 - Added the SD library
Week 21 - Existing code has been edited to get consistent distance readings from the sensor and alll inputs and outputs have been added in main.h
Week Easter -
Week 22 -
Week 23 -
Week 24 -

*/


#include "main.h"

int main()
{
    
    init_serial();
    init_K64F();
    init_buttons();
    init_variables();
    lcd.init();
    
    read_pin();
    
    buzzer.period(1.0/500.0); // 500 Hz
    
    buzzer.write(0.5); 

    wait(2);
    
    screen_selection();

    wait(4);

    g_next_state = 1;
    
    screen_selection();
      
    g_current_state = 1;


    while (1) {


        if (g_button_0_flag) {

            pc.printf("g_button_0_flag = %d \n", g_button_0_flag);

            g_button_0_flag = 0;

            button_0_protocol();
            
            pc.printf("Current State = %d \n",g_current_state);
            pc.printf("Next State = %d \n",g_next_state);

        }

        if (g_button_1_flag) {

            pc.printf("g_button_1_flag = %d \n", g_button_1_flag);

            g_button_1_flag = 0;
            
            button_1_protocol();

            pc.printf("Current State = %d \n",g_current_state);
            pc.printf("Next State = %d \n",g_next_state);

        }

        if (g_button_c_flag) {

            pc.printf("g_button_c_flag = %d \n", g_button_c_flag);

            g_button_c_flag = 0;

            button_c_protocol();

            pc.printf("Current State = %d \n",g_current_state);
            pc.printf("Next State = %d \n",g_next_state);

        }

        if (g_setting_distance_flag) {

            g_setting_distance_flag = 0;

            get_setting_distance();

        }

        if (g_intruder_distance_flag) {

            g_setting_distance_flag = 0;

            get_intruder_distance();

        }
        
        if (g_setting_screen_flag) {
            
            g_setting_screen_flag = 0;
            
            loading_bar();
            
        }    

        if (g_led_buzzer_flag) {

            g_led_buzzer_flag = 0;

            led_alarm = !led_alarm;
            
            if (buzzer == 0) {
                
                buzzer = 0.5;
                
            }
            
            else {
                
                buzzer = 0;
                
            }        

        }

        if (g_pin_timeout_flag) {

            g_pin_timeout_flag = 0;

            timeout_protocol();
            
            
        }
            
        if (g_next_state != g_current_state) {
            
            pc.printf("TRANSITION \n");

            screen_selection(); //  the screen is determined by the current value of g_next_state
            
            g_current_state = g_next_state;
            
            pc.printf("Current State = %d \n",g_current_state);
            
        }

        

        if (g_current_state == 4) {
            
            if (setting_distance_ticker_status == 0) {

                setting_distance_ticker_status = 1;

                setting_distance.attach(&setting_distance_isr,0.1);
                
            }

        }

        if (g_current_state == 5) {

                intruder_distance.attach(&intruder_distance_isr,0.1);

        }
        
        else {
            
            intruder_distance.detach();
            
        }    
        

        sleep();
        

    }

}


void init_serial()
{
    // Ensure terminal software matches
    pc.baud(115200);
}

void init_K64F()
{
    // on-board LEDs are active-low, so set pin high to turn them off.
    r_led = 1;
    g_led = 1;
    b_led = 1;

    // since the on-board switches have external pull-ups, we should disable the internal pull-down
    // resistors that are enabled by default using InterruptIn
    sw2.mode(PullNone);
    sw3.mode(PullNone);

}

void init_buttons()
{

    button_0.fall(&button_0_isr);
    button_1.fall(&button_1_isr);
    button_c.fall(&button_c_isr);

    button_0.mode(PullDown);
    button_1.mode(PullDown);
    button_c.mode(PullDown);

}

void init_variables()
{

    one_second_distance = 0;
    one_second_avg_distance = 0;
    initial_setting_distance = 0;

    pin_counter = 0;
    incorrect_pin_flag = 0;

    setting_distance_counter = 0;
    intruder_distance_counter = 0;

    g_button_0_flag = 0;
    g_button_1_flag = 0;
    g_button_c_flag = 0;
    g_setting_distance_flag = 0;
    g_intruder_distance_flag = 0;
    g_pin_timeout_flag = 0;

    setting_distance_ticker_status = 0;

    g_current_state = 0;

}

void setting_distance_isr()
{
    g_setting_distance_flag = 1;

}

void intruder_distance_isr()
{
    g_intruder_distance_flag = 1;

}

void led_buzzer_isr()
{
    g_led_buzzer_flag = 1;

}

void setting_screen_isr()
{
    g_setting_screen_flag = 1;
    
}    

void button_0_isr()
{
    g_button_0_flag = 1;

}

void button_1_isr()
{
    g_button_1_flag = 1;

}

void button_c_isr()
{
    g_button_c_flag = 1;

}

void pin_timeout_isr()
{
    g_pin_timeout_flag = 1;

}

void loading_bar()
{
    setting_alarm_counter = setting_alarm_counter + 5;
    
    if (setting_alarm_counter < 101) {    
                            
        lcd.drawRect(0,20,setting_alarm_counter,5,1);
        
        if (setting_alarm_counter < 10) {
            
            length = sprintf(buffer,"0%d%%",setting_alarm_counter);
            
        }
        
        else {    
            
            length = sprintf(buffer,"%d%%",setting_alarm_counter);
            
        }    
    
        if (length <= 14) {
            
            if (setting_alarm_counter < 100) {
                
                lcd.printString(buffer,33,4);
                
            }
            
            else {
                
                lcd.printString(buffer,30,4);    
                
            }    
        
        }    
    
        lcd.refresh();
        
        
    }    
}    

void button_0_protocol()
{
    if (g_current_state == 2) {

        if (pin_counter < 4) {

            entered_pin[pin_counter] = 0;

            pin_counter++;

        }

        enter_pin();

    }

    else if (g_current_state == 3) {

        if (pin_counter < 4) {

            entered_pin[pin_counter] = 0;

            pin_counter++;

        }

        enter_pin();

    }

    else if (g_current_state == 6) {

        if (pin_counter < 4) {

            entered_pin[pin_counter] = 0;

            pin_counter++;

        }

        enter_pin();

    }

    else if (g_current_state == 7) {

        if (pin_counter < 4) {

            entered_pin[pin_counter] = 0;

            pin_counter++;

        }

        enter_pin();

    }

    else {

        g_next_state = fsm[g_current_state].nextState[0];

    }

}

void button_1_protocol()
{

    if (g_current_state == 2) {

        if (pin_counter < 4) {

            entered_pin[pin_counter] = 1;

            pin_counter++;

        }

        enter_pin();

    }

    else if (g_current_state == 3) {

        if (pin_counter < 4) {

            entered_pin[pin_counter] = 1;

            pin_counter++;

        }

        enter_pin();

    }

    else if (g_current_state == 6) {

        if (pin_counter < 4) {

            entered_pin[pin_counter] = 1;

            pin_counter++;

        }

        enter_pin();

    }

    else if (g_current_state == 7) {

        if (pin_counter < 4) {

            entered_pin[pin_counter] = 1;

            pin_counter++;

        }

        enter_pin();

    }

    else {

        g_next_state = fsm[g_current_state].nextState[1];

    }

}

void button_c_protocol()
{

    if (g_current_state == 2) {

        screen_progression();

    }

    else if (g_current_state == 3) {

        screen_progression();

    }

    else if (g_current_state == 6) {

        screen_progression();

    }

    else if (g_current_state == 7) {

        screen_progression();

    }

    else {

        g_next_state = fsm[g_current_state].nextState[2];

    }

}

void get_setting_distance()
{
    distance[setting_distance_counter] = srf02.getDistanceCm();

    setting_distance_counter++;

    if (setting_distance_counter == 10) {

        setting_distance.detach();

        calculate_setting_distance();

    }

}

void timeout_protocol()
{

    pin_timeout_counter++;

    seconds_till_timeout = 20 - pin_timeout_counter;

    if (seconds_till_timeout == 0) {

        g_next_state = 8;

        pin_timeout_counter = 0;

    }

    else {

        if (seconds_till_timeout >= 10) {

            length = sprintf(buffer,"%d",seconds_till_timeout);

        }

        else {

            length = sprintf(buffer,"0%d",seconds_till_timeout);

        }

        if (length <= 14)
            lcd.printString(buffer,3,4);

        lcd.refresh();

    }

}

void get_intruder_distance()
{

    distance[intruder_distance_counter] = srf02.getDistanceCm();

    intruder_distance_counter++;

    if (intruder_distance_counter == 10) {

        intruder_distance.detach();
        
        calculate_intruder_distance();

    }

}

void calculate_setting_distance()
{

    for (int i = 0; i < 10; i++) {

        one_second_distance = one_second_distance + distance[i];

    }

    initial_setting_distance = (one_second_distance / 10);
    
    pc.printf("Initial Setting Distance = %.2f cm\n",initial_setting_distance);

    setting_distance_counter = 0;

    one_second_distance = 0;

    transition.attach(&screen_5_transition,5);

}

void calculate_intruder_distance()
{

    for (int i = 0; i < 10; i++) {

        one_second_distance = one_second_distance + distance[i];

    }

    one_second_avg_distance = one_second_distance / 10;
    
    pc.printf("Intruder Distance = %.2f cm\n",one_second_avg_distance);
    
    intruder_distance_counter = 0;

    one_second_distance = 0;


    if (one_second_avg_distance > (1.05*initial_setting_distance)) {

        g_next_state = 7;

        g_current_state = 7;

        screen_selection();

    }

    else if (one_second_avg_distance < (0.95 * initial_setting_distance)) {

        g_next_state = 7;

        g_current_state = 7;

        screen_selection();

    }

    else {

        intruder_distance.attach(&intruder_distance_isr,0.1);

    }



}

void state_0_screen()
{
    lcd.clear();

    lcd.printString("Mobile",27,1);
    
    lcd.printString("Security",18,2);

    lcd.printString("System",27,3);
    
    lcd_border();
    
    led_alarm = 0;  
    
    buzzer.write(0.0);
    
    lcd.refresh();

}

void state_1_screen()
{
    lcd.clear();

    lcd.printString("Set Alarm",15,1);

    lcd.printString("Set New Pin",9,4);
    
    lcd_border();
    
    for (int i = 0; i < WIDTH; i++) {
        
        lcd.setPixel(i,24);
        
    } 
            
    pin_timeout.detach(); 
    
    alerts.detach();
    
    led_alarm = 0;  
    
    buzzer.write(0);
    
    pin_timeout_counter = 0;
    
    lcd.refresh();

}

void state_2_screen()
{
    lcd.clear();

    lcd.printString("Enter 4 Digit",3,1);

    lcd.printString("Pin Below",15,2);
    
    pin_text_box();
    
    lcd_border();
    
    led_alarm = 0;  
    
    buzzer.write(0.0);
    
    lcd.refresh();

}

void state_3_screen()
{
    lcd.clear();

    lcd.printString("Enter New 4",9,1);

    lcd.printString("Digit Pin",15,2);
    
    pin_text_box();

    lcd_border();
    
    led_alarm = 0;  
    
    buzzer.write(0.0);
    
    lcd.refresh();

}

void state_4_screen()
{
    lcd.clear();

    lcd.printString("Setting",21,1);
    
    lcd_border();
    
    lcd.drawRect(0,20,84,5,0);
        
    lcd.printString("0%",41,4);   
    
    setting_alarm_counter = 0;
    
    led_alarm = 0;
    
    buzzer.write(0.0);
    
    alerts.attach(&led_buzzer_isr,0.5);
    
    setting_screen.attach(&setting_screen_isr,0.25);

    lcd.refresh();

}

void state_5_screen()
{
    lcd.clear();

    lcd.printString("Alarm Set",15,1);

    lcd.printString("DEACTIVATE?",9,4);
    
    lcd_border();
    
    for (int i = 0; i < WIDTH; i++) {
        
        lcd.setPixel(i,20);
        
    } 
    
    alerts.detach();
    
    setting_screen.detach();
    
    led_alarm = 1;
    
    buzzer.write(0.5);
    
    buzz.attach(&alarm_setting_buzz,1);

    lcd.refresh();
    
}

void state_6_screen()
{
    lcd.clear();

    lcd.printString("DEACTIVATE",12,1);

    lcd.printString("Enter Pin",15,2);
    
    lcd_border();
    
    pin_text_box();
    
    led_alarm = 0;
    
    buzzer.write(0.0);
    
    alerts.attach(&led_buzzer_isr,0.5);

    lcd.refresh();

}

void state_7_screen()
{
    lcd.clear();

    lcd.printString("INTRUDER",18,1);

    lcd.printString("Enter Pin",15,2);
    
    lcd.printString("20",3,4);
    
    lcd_border();
    
    lcd.drawRect(1,30,15,10,0); 
    
    pin_text_box();
    
    led_alarm = 0;
    
    buzzer.write(0.0);
    
    alerts.attach(&led_buzzer_isr,0.5);
    
    pin_timeout.attach(&pin_timeout_isr,1);

    lcd.refresh();

}

void state_8_screen()
{
    lcd.clear();

    lcd.printString("ALARM",27,1);

    lcd.printString("TRIGGERED",15,2);
    
    lcd.printString("Menu?",27,4);
    
    lcd_border();
    
    led_alarm = 0;
    
    buzzer.write(0.0);
    
    alerts.detach();
      
    pin_timeout.detach();
    
    alerts.attach(&led_buzzer_isr,0.2);

    lcd.refresh();
}

void screen_selection()
{
    
    reset_entered_pin();

    if (g_next_state == 0) {

        state_0_screen();

    }

    else if (g_next_state == 1) {

        state_1_screen();

    }

    else if (g_next_state == 2) {

        state_2_screen();

    }

    else if (g_next_state == 3) {

        state_3_screen();

    }

    else if (g_next_state == 4) {

        state_4_screen();

    }

    else if (g_next_state == 5) {

        state_5_screen();

    }

    else if (g_next_state == 6) {

        state_6_screen();

    }

    else if (g_next_state == 7) {

        state_7_screen();

    }

    else {

        state_8_screen();

    }
    
}

void screen_5_transition()
{
    g_next_state = 5;
    
    screen_selection();

    g_current_state = 5;
    
    setting_distance_ticker_status = 0;

    intruder_distance.attach(&intruder_distance_isr,0.1);
    
}

void screen_progression() 
{
    if (g_current_state == 3) {
        
        if (pin_counter > 3) {
        
            change_pin();
        
            read_pin();
        
            g_next_state = fsm[g_current_state].nextState[2];
        
        }
        else {
            
            g_next_state = fsm[g_current_state].nextState[3];
    
        }
    }        
    
    else {
        
        check_pin();
        
        if (incorrect_pin_flag == 1) {
            
            incorrect_pin_flag = 0;
            
            g_next_state = fsm[g_current_state].nextState[3];
            
            pc.printf("g_next_state = %d\n",g_next_state);
                    
        }
        
        else {
            
            g_next_state = fsm[g_current_state].nextState[2];
            
            pc.printf("g_next_state = %d\n",g_next_state);
               
        }
    
    }
    
} 

void alarm_setting_buzz()
{
    
    buzzer.write(0.0);
    
}    

void lcd_border()
{
    lcd.drawRect(0,0,83,47,0);  
    
    lcd.drawRect(1,1,81,45,0); 
   
}

void pin_text_box()
{
    lcd.drawRect(15,30,15,10,0);    // transparent, just outline
    lcd.drawRect(29,30,15,10,0);    // transparent, just outline
    lcd.drawRect(43,30,15,10,0);    // transparent, just outline
    lcd.drawRect(57,30,15,10,0);    // transparent, just outline
    
}           

void enter_pin()
{
    if (pin_counter == 1) {
        
        lcd.printString("*",20,4);
        
    }
    
    else if (pin_counter == 2) {
        
        lcd.printString("*",34,4);
        
    }
    
    else if (pin_counter == 3) {
        
        lcd.printString("*",48,4);
        
    }
    
    else if (pin_counter == 4) {
        
        lcd.printString("*",62,4);
        
    }                
    
}    

void check_pin()
{
    for (int i = 0; i < 4; i++) {
        
        if (entered_pin[i] != set_pin[i]) {
        
            pc.printf("entered pin doesn't match set pin...");
            
            incorrect_pin_flag = 1;
            
            break;
            
        }
        
    }
    
}

void reset_entered_pin()
{
        for (int i = 0; i < 4; i++) {
            
            entered_pin[i] = -1;
            
        }
        
         pin_counter = 0;
        
}                
        
void change_pin()
{
    delete_file("/sd/test.txt");

    pin = fopen("/sd/test.txt", "a");

    if (pin == NULL) {  // if it can't open the file then print error message

        pc.printf("Error! Unable to open file!\n");

    }

    else {

        pc.printf("Writing to file....\n");

        for(int i = 0; i < 4; i++) {

            int pin_element = entered_pin[i];;  // pin_element variable

            fprintf(pin, "%d,%d\n",i,pin_element);  // print formatted string to file (CSV)
        }

        for(int i = 0; i < 4; i++) {

            pc.printf("[%d] %d\n",i,entered_pin[i]);
        }

        pc.printf("Done.\n");

        fclose(pin);  // ensure you close the file after writing

    }

}

void read_pin()
{
    pin = fopen("/sd/test.txt", "r");
    
    int i = 0;

    pc.printf("Reading into set_pin array...\n");

    while (fscanf(pin, "%d,%d",&index_array[i],&set_pin[i]) != EOF) {
        i++;  // read data into array and increment index
    }

    fclose(pin);  // ensure you close the file after reading

    for(int i = 0; i < 4 ; i++) {

        pc.printf("[%d] %d\n",i,set_pin[i]);

    }
    
    pc.printf("Done.\n");
    
}
   
void delete_file(char filename[])
{
    pc.printf("Deleting file '%s'...",filename);
    FILE *fp = fopen(filename, "r");  // try and open file
    if (fp != NULL) {  // if it does open...
        fclose(fp);    // close it
        remove(filename);  // and then delete
        pc.printf("Done!\n");
    }
    // if we can't open it, it doesn't exist and so we can't delete it
}