File content as of revision 5:ea3ec65cbf5f:

#include "mbed.h"
#include "main.h"

#define ENTER_KEY 1
#define MAX_SAMPLES 120

LCD  lcd(PD_15, PF_12, PF_13, PE_9, PF_14, PF_15); 
BMP280 Sensor(D14, D15);

//Define Functions
void PrintLCD ();
void Rx_interrupt();
void Serial_CMD();

//data FIFO buffer
char data_buffer[MAX_SAMPLES][50];
int data_h = 0;
int data_t = 0;

//Time-Date data
struct tm * sample_epoch;
char sample_time[20];

//Serial_CMD
volatile int rx_in=0;
char rx_buffer[32];
time_t raw_time = time(NULL);
char serial_buffer[80];

/* Mail */
typedef struct {
    float LDR_Value;
    float temp_Value;
    float press_Value;
} mail_t;

Mail<mail_t, 16> mail_box;

//Threads
Thread t1;
Thread t2;
Thread S_CMD;
    
/*--------------------------------MAIN--------------------------------*/
int main() {

    t1.start(PrintLCD);
    
    pc.baud(9600);
    pc.attach(&Rx_interrupt, Serial::RxIrq);
    S_CMD.start(Serial_CMD);
    
        while(1) {
            Green_int = !Green_int;
            
            //Read sensors, send to mail-queue
            mail_t *mail = mail_box.alloc();
            mail->LDR_Value = LDR_In.read(); 
            mail->temp_Value = Sensor.getTemperature();
            mail->press_Value = Sensor.getPressure();
            mail_box.put(mail);           
            
            //Format samples, send to FIFO buffer
            memset(data_buffer[data_h],NULL,50);
            time( &raw_time );
            sample_epoch = localtime( &raw_time );
            strftime(sample_time,20,"%d/%m/%Y %X",sample_epoch);
            sprintf(data_buffer[data_h],"%s, %2.2f, %4.2f, %.4f\n\r", sample_time, mail->temp_Value, mail->press_Value, mail->LDR_Value);
            memset(sample_time,NULL,20);
            
            //Print all samples to serial
            for(int n = data_t; n<= MAX_SAMPLES; n++){
                pc.puts(data_buffer[n]);
            }
            
            if(data_t > data_h){
                for(int n = 0; n<= data_h; n++){
                    pc.puts(data_buffer[n]);
                }
            }
            
            //Prepare buffer for next samples
            data_h++;
            if(data_h >= (MAX_SAMPLES)){
                data_h = 0;
            }
            if(data_h == data_t){
                data_t++;
                if(data_t >= (MAX_SAMPLES)){
                    data_t = 0;
                }
            }
            
            Thread::wait (15000);
        }
}
/*--------------------------------------------------------------------*/

/*--------------------------------LCD---------------------------------*/
void PrintLCD () {
    
    int i = 0;
    while(1){
        char lightString[16];
        char tempString[16];
        char pressString[16];

        lcd.Clear();
        lcd.RowSelect(0);
         
        switch (i){
            case 0:{
                osEvent evt = mail_box.get();
        
                if (evt.status == osEventMail) {
                    mail_t *mail = (mail_t*)evt.value.p;
            
                    sprintf(lightString,"%.4f", mail->LDR_Value);
                    sprintf(tempString,"%2.2f", mail->temp_Value);
                    sprintf(pressString,"%4.2f", mail->press_Value);    
                
                    mail_box.free(mail);
                }
               
                lcd.Write("Light Level:");
                lcd.RowSelect(1);
                lcd.Write(lightString);
                i++;                
            break;
            }
            case 1:
                lcd.Write("Temperature:");
                lcd.RowSelect(1);
                lcd.Write(tempString);
                i++;
            break;
        
            case 2:
                lcd.Write("Pressure:");
                lcd.RowSelect(1);
                lcd.Write(pressString);
                i =0;                
            break;
            
            default:            
                i = 0;                
            break;
        }
        
        Red_int = !Red_int;        

        Thread::wait (5000);
    }
}
/*--------------------------------------------------------------------*/

/*------------------------------SERIAL_CMD----------------------------*/
//Interrupt when recieving from serial port
void Rx_interrupt() {
    
    while (pc.readable()) {
        rx_buffer[rx_in] = pc.getc();
        pc.putc(rx_buffer[rx_in]);
        
        if(rx_buffer[rx_in] == 0xD){
            S_CMD.signal_set(ENTER_KEY);
        }
        else{
            rx_in = (rx_in + 1);
        }
    }
}

//Check what command what recieved and execute
void Serial_CMD(){
    
    while(1){
        Thread::signal_wait(ENTER_KEY);
        pc.attach(NULL, Serial::RxIrq);
        
        struct tm * s_time;
        char tm_n[4];
        
        if(strstr(rx_buffer, "READ ALL")){
            
            /*time ( &raw_time );
            s_time = localtime ( &raw_time );
            strftime(serial_buffer, 80, "%d/%m/%Y, %X\n\r", time);
            pc.puts(serial_buffer);*/
        }
        else if(strstr(rx_buffer, "DELETE ALL")){
            pc.printf("DELETE ALL\n\r");
        }
        else if(strstr(rx_buffer, "READ")){
            pc.printf("READ\n\r");
        }
        else if(strstr(rx_buffer, "DELETE")){
            pc.printf("DELETE\n\r");
        }
        else if(strstr(rx_buffer, "SETDATE")){
            time(&raw_time);
            s_time = localtime(&raw_time);
            
            int dd = atoi(strncpy(tm_n,&rx_buffer[8],2));
            s_time->tm_mday = dd;
            memset(tm_n, NULL, 4);
            
            int mm = atoi(strncpy(tm_n,&rx_buffer[11],2));
            s_time->tm_mon = mm-1;
            memset(tm_n, NULL, 4);
            
            int yyyy = atoi(strncpy(tm_n,&rx_buffer[14],4));
            s_time->tm_year = yyyy-1900;
            memset(tm_n, NULL, 4);
            
            set_time(mktime(s_time));
            strftime(serial_buffer, 80, "%d/%m/%Y\n\r", s_time);
            pc.puts(serial_buffer);
        }
        else if(strstr(rx_buffer, "SETTIME")){
            time(&raw_time);
            s_time = localtime(&raw_time);
            
            int ss = atoi(strncpy(tm_n,&rx_buffer[14],2));
            s_time->tm_sec = ss;
            memset(tm_n, NULL, 4);
            
            int mm = atoi(strncpy(tm_n,&rx_buffer[11],2));
            s_time->tm_min = mm;
            memset(tm_n, NULL, 4);
            
            int hh = atoi(strncpy(tm_n,&rx_buffer[8],2));
            s_time->tm_hour = hh;
            memset(tm_n, NULL, 4);
            
            set_time(mktime(s_time));
            strftime(serial_buffer, 80, "%X\n\r", s_time);
            pc.puts(serial_buffer);
        }
        else if(strstr(rx_buffer, "SETT")){
            pc.printf("SETT\n\r");
        }
        else if(strstr(rx_buffer, "STATE")){
            pc.printf("STATE\n\r");
        }
        else if(strstr(rx_buffer, "LOGGING")){
            pc.printf("LOGGING\n\r");
        }
        else{
            pc.printf("ERROR\n\r");    
        }
        
        memset(serial_buffer, NULL, 80);
        memset(rx_buffer, NULL, 32);
        rx_in = 0;
    
        pc.attach(&Rx_interrupt, Serial::RxIrq);
    }
}
/*--------------------------------------------------------------------*/