File content as of revision 12:a244f6f9d2fe:

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

#define FallingEdge 0
#define RisingEdge 1
#define USER_BUTTON_PRESSED 1

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 serialCMD();
void sensorRead();
void readISR();
void circBuff();
void writeRemove_SD();
void Network1();

// USER_BUTTON ISRs (Debounce)

void userButtonRise();
void userButtonFall();
void userButtonTimeoutHandler();

// Tickers & Timeouts
Timeout userButtonTimeout; // FOR debouncing User Switch
Ticker read;            //  ***Sets sampling period!*** (ISR Signals sampling Thread)

/* LOCKS */ 
Mutex DataBuffer;
Mutex dataLock;

/* THREADS */
Thread _PrintLCD, _serialCMD, _circBuff;
Thread _sensorRead (osPriorityRealtime); //dataLock Thread
Thread _writeRemove_SD;
Thread _Network1;

/* GLOBAL DATA */
volatile float LDR = 0;
volatile double PRES = 0;
volatile double TEMP = 0;
volatile char TIME[20];

volatile int sampleTime = 15;
// int to hold current switch state
int userButtonState = FallingEdge;

/* DEBOUNCER INTERRUPTS */
InterruptIn userButton(USER_BUTTON);

void userButtonRise () {
    userButton.rise(NULL);
    userButtonState = RisingEdge;
    userButtonTimeout.attach(&userButtonTimeoutHandler, 0.1);
}

void userButtonFall () {
    userButton.fall(NULL);
    _writeRemove_SD.signal_set(USER_BUTTON_PRESSED);
    userButtonState = FallingEdge;
    userButtonTimeout.attach(&userButtonTimeoutHandler, 0.1);
}

void userButtonTimeoutHandler() {
    userButtonTimeout.detach();
    
    switch (userButtonState) {
        case RisingEdge:
            userButton.fall(&userButtonFall);
            break;
        case FallingEdge:
            userButton.rise(userButtonRise);
            break;
    }// End Switch        
} //End ISR       
/*--------------------------------MAIN--------------------------------*/
int main() {
    
    pc.baud(9600);
    pc.attach(&Rx_interrupt, Serial::RxIrq);
    POST();
    
    pc.printf("\n\n\nType HELP for list of available Commands\n\n\n\r");
    _serialCMD.start(serialCMD);
    _sensorRead.start(sensorRead);
    _PrintLCD.start(PrintLCD);
    _circBuff.start(circBuff);
    _writeRemove_SD.start(writeRemove_SD);
    _Network1.start(Network1);
    
    userButton.rise(&userButtonRise);
    read.attach(&readISR, sampleTime);
    
    while (1) {
        Yellow_ext = ON;
        Thread::wait (200);
        Yellow_ext = OFF;
        Thread::wait(200);
        }// End While
} // End Main
/*--------------------------------------------------------------------*/
/*-----------------Circular Buffer------------------------------------*/
void circBuff () {
    
    while(1) { 
            Thread::signal_wait(DATA_READY); // wait for signal from sensorRead
            
            //Lock data buffer
            DataBuffer.lock();
            
            //Format samples, send to FIFO buffer head
            memset(data_buffer[sample_h],NULL,64);
            
            char sampleTime[20];
            memset(sampleTime, NULL,20);
            time( &raw_time );
            sample_epoch = localtime( &raw_time );
            strftime(sampleTime,20,"%d/%m/%Y, %X",sample_epoch);
            
            
            dataLock.lock(); //lock critical section
            sprintf(data_buffer[sample_h],"%s, %2.2f, %4.2f, %.4f\n\r", sampleTime, TEMP, PRES, LDR);
            dataLock.unlock(); //unlock critical section
            
            
            //Set seperate FIFO head and tail for printing data
            data_h = sample_h;
            data_t = sample_t;
            
            //Move sample FIFO buffer head to next row in buffer
            sample_h++;
            //Check sample FIFO buffer head
            if(sample_h >= MAX_SAMPLES){
                sample_h = 0;
            }
            //Check sample FIFO buffer tail
            if(sample_t == sample_h){
                sample_t++;
                if(sample_t >= (MAX_SAMPLES)){
                    sample_t = 0;
                }
            }
            //Unlock data buffer
            DataBuffer.unlock();
    }// End While
}// End Circular buffer
/*-------------------------------------------------------------*/
/*---------------------Read Sensors ---------------------------*/

void readISR () { // Ticker interrupt defined in main
    
    _sensorRead.signal_set(SENSOR_UPDATE);
}
// Keep short
void sensorRead () {
    
    while (1) {
        
        dataLock.lock(); // Entering Critial Section
    
        // Store Data in global Variables
        LDR = LDR_In.read();
        TEMP = Sensor.getTemperature();
        PRES = Sensor.getPressure();
        
        dataLock.unlock(); // Exiting Critical Section
    
        Green_int = !Green_int; // debugging
            
        //Read sensors, send to mail-queue
        mail_t *mail = mail_box.alloc();
        mail->LDR_Value = LDR; 
        mail->temp_Value = TEMP;
        mail->press_Value = PRES;
        mail_box.put(mail);
        
        
        _circBuff.signal_set(DATA_READY);  // Set signal to buffer to store updated values
        Thread::signal_wait(SENSOR_UPDATE); // Wait for the Timer interrupt
    }
}
/*--------------------------------------------------------------------*/    

/*--------------------------------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:");
                lcd.RowSelect(1);
                lcd.Write(lightString);
                i++;                
            break;
            }
            case 1:
                lcd.Write("Temperature(C):");
                lcd.RowSelect(1);
                lcd.Write(tempString);
                i++;
            break;
        
            case 2:
                lcd.Write("Pressure(mBar):");
                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() {
    
    //Wait for serial input
    while (pc.readable()) {
    
        //Return input to serial
        rx_buffer[rx_in] = pc.getc();
        pc.putc(rx_buffer[rx_in]);
    
        //If enter key is pressed, set serial thread signal
        if(rx_buffer[rx_in] == 0xD){
            _serialCMD.signal_set(ENTER_KEY);
        }
    
        //Increment buffer head
        else{
            rx_in = (rx_in + 1);
        }
    }
}

//Check what command what recieved and execute
void serialCMD(){
    bool xx = 1; // State for CMD STATE
    while(1){
        //Wait for thread signal
        Thread::signal_wait(ENTER_KEY);
        
        //Detach serial interrupt
        pc.attach(NULL, Serial::RxIrq);

        struct tm * s_time;
        char tm_n[4];
        
/*----CARRAGE RETURN-------------*/        
        if(rx_buffer[0] == 0xD){
            pc.puts("\n\r");
            }
/*----READ ALL----------------------------------*/
        else if(strstr(rx_buffer, "READ ALL")){
            pc.puts(" READ ALL\n\r");
        
            //Lock data buffer
            DataBuffer.lock();
        
            //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_t-1); n++){
                    pc.puts(data_buffer[n]);
                }
            }
            
            //Lock data buffer
            DataBuffer.unlock();
        }
/*----DELETE ALL----------------------------------*/
        else if(strstr(rx_buffer, "DELETE ALL")){
            pc.puts(" DELETE ALL\n\r");
            
        //Lock data buffer
            DataBuffer.lock();
            
        //Delete all sampled data
            for(int n=0; n<=MAX_SAMPLES; n++){
                memset(data_buffer[n], NULL, 64);
            }
            data_h = data_t;
            sample_h = sample_t;
            
        //Unlock data buffer
            DataBuffer.unlock();
            pc.printf(" All previous samples deleted!\n\r");
        }
/*----READ----------------------------------*/
        else if(strstr(rx_buffer, "READ")){
            pc.puts(" READ     \n\r");
            int N = atoi(strncpy(tm_n,&rx_buffer[5],4));
            int S = 0;
            pc.printf("N = %d\n\r",N);
            
        //Lock data buffer
            DataBuffer.lock();
        
        //Check if N is greater than buffer size
            if(N >= MAX_SAMPLES){
                N = MAX_SAMPLES;
            }
            
        //Read N samples from FIFO buffer
            if(N <= 0){
                pc.puts("ERROR - Buffer Empty!\n\r");
            }
            else{
                for(int n=data_h; n>=0; n--){
                    if(S>=N){}
                    else{
                        pc.puts(data_buffer[n]);
                        S++;
                    }
                }
                for(int n=MAX_SAMPLES-1; n<=data_t; n--){
                    if(S>=N){}
                    else{
                        pc.puts(data_buffer[n]);
                        S++;
                    }
                }
            }

        //Unlock data buffer
            DataBuffer.unlock();
        }
/*----DELETE----------------------------------*/
        else if(strstr(rx_buffer, "DELETE")){
            pc.puts(" DELETE     \n\r");
        }
/*----SETDATE----------------------------------*/
        else if(strstr(rx_buffer, "SETDATE")){
            time(&raw_time);
            s_time = localtime(&raw_time);
            
        //Update day in time structure            
            int dd = atoi(strncpy(tm_n,&rx_buffer[8],2));
            s_time->tm_mday = dd;
            memset(tm_n, NULL, 4);
            
        //Update month in time structure
            int mm = atoi(strncpy(tm_n,&rx_buffer[11],2));
            s_time->tm_mon = mm-1;
            memset(tm_n, NULL, 4);
            
        //Update year in time structure
            int yyyy = atoi(strncpy(tm_n,&rx_buffer[14],4));
            s_time->tm_year = yyyy-1900;
            memset(tm_n, NULL, 4);
            
        //Set date from updated time structure
            set_time(mktime(s_time));
            strftime(serial_buffer, 80, "\n\n\r Date set to: %d/%m/%Y\n\r", s_time);
            pc.puts(serial_buffer);
        }
/*----SETTIME---------------------------------*/
        else if(strstr(rx_buffer, "SETTIME")){
            time(&raw_time);
            s_time = localtime(&raw_time);
            
        //Update seconds in time structure
            int ss = atoi(strncpy(tm_n,&rx_buffer[14],2));
            s_time->tm_sec = ss;
            memset(tm_n, NULL, 4);
        
        //Update minutes in time structure
            int mm = atoi(strncpy(tm_n,&rx_buffer[11],2));
            s_time->tm_min = mm;
            memset(tm_n, NULL, 4);
            
        //Update hour in time structure
            int hh = atoi(strncpy(tm_n,&rx_buffer[8],2));
            s_time->tm_hour = hh;
            memset(tm_n, NULL, 4);
        
        //Set time from updated time structure
            set_time(mktime(s_time));
            strftime(serial_buffer, 80, "\n\n\r Time Set to: %X\n\r", s_time);
            pc.puts(serial_buffer);
        }
/*----SETT----------------------------------*/
        else if(strstr(rx_buffer, "SETT")){
            pc.puts(" SETT\n\r");
            read.detach();
            int AA = atoi(strncpy(tm_n,&rx_buffer[5],2));
            
            if (AA < 1 || AA > 60) {
                AA = 15;
                pc.puts("Sample Time out of range.\n\r");
            }
            sampleTime = AA;
            pc.printf("Sample Time set to: %d seconds\n\r", sampleTime);
            read.attach(readISR, sampleTime);
            memset(tm_n, NULL, 4);
        }
/*----STATE----------------------------------*/
        else if(strstr(rx_buffer, "STATE")){
            
            strncpy(tm_n,&rx_buffer[6],3);
            if  (strstr(tm_n, "ON")) {
                if (xx == 1) {
                    pc.puts("Already Sampling\n\r");
                }
                else {
                    read.attach(&readISR, sampleTime);
                    pc.puts("Started Sampling\n\r");
                    xx = 1;
                }
            }
            else if (strstr(tm_n, "OFF")) {
                if ( xx == 0 ) {
                    pc.puts("Already not Sampling\n\r");
                }
                else {
                    read.detach();
                    pc.puts("Sampling stopped. Not taking any samples\n\r");
                    xx = 0;
                }
            }
            else {
                pc.puts("Error - STATE can only be ON or OFF\n\r");
                }
            //pc.puts(" STATE\n\r");
        }
/*----LOGGING----------------------------------*/
        else if(strstr(rx_buffer, "LOGGING")){
            pc.puts(" LOGGING\n\r");
        }
/*----HELP--------------------------------------*/
        else if (strstr(rx_buffer, "HELP")) {
            pc.puts("\n\n\nCurrently Available Commands:\n\r");
            pc.puts("\tREAD n   - Read n previous samples\n\r");
            pc.puts("\tREAD ALL - Read All previous samples held in memory\n\r");
            pc.puts("\tSETTIME hh:mm::ss  - Set time in 24hr format\n\r");
            pc.puts("\tSETDATE dd/mm/yyyy - Set time in specified format\n\r");
            pc.puts("\tDELETE ALL   - Delete all sampled held in internal memory\n\r");
            pc.puts("\tSETT - Set sample period. must be an integer in range 0 < T < 61\n\r");
        } 
        else if (strstr(rx_buffer,"tell me a joke")) {
            pc.puts("Why do programmers always get Halloween and Christmas mixed up...?\n\r");
            Thread::wait(7000);
            pc.puts("Because Oct 31 == Dec 25! LOL");
        }
/*----ERROR---*/
        else{
            pc.puts("Error - Command not recognised. Type HELP for a list of available commands\n\r");    
        }
/*----------------------------------------------*/
    
    //Clear serial buffers
        memset(serial_buffer, NULL, 80);
        memset(rx_buffer, NULL, 32);
        rx_in = 0;
    
    //Attach serial interrupt
        pc.attach(&Rx_interrupt, Serial::RxIrq);
    }
}
/*------------------------------------------------*/
/*---------------SD THread------------------------*/
void writeRemove_SD() {
    
    while(1) {
        Thread::signal_wait(USER_BUTTON_PRESSED); //wait for debounce signal
        int sd_state = sdIn;
        switch (sd_state) {
            case 1:
                pc.printf("SD Card not inserted!\n\r");
                pc.printf("Insert SD Card and press User button again\n\r");
                break;
             default:
                pc.printf("This should never happen\n\r");
                break;
            case 0:
                pc.printf("Initalising SD Card\n\r");

                //check init
                if (sd.init() != 0) {
                    pc.printf(" ERROR - SD card failed to initialise.\n\rRestart board\n\r");
                }

                // Create Filing system for SD Card
                FATFileSystem fs("sd", &sd);

                //OpenFiles to write/append to
                pc.printf("Writing to SDC\n\r");

                FILE* fp = fopen("/sd/TheChamberOfSecrets.txt", "a"); //"w" to overwrite file ftb

                // Check for error in opening file
                if (fp == NULL) {
                    pc.printf("*****ERROR - Could not open file for write*****\n\r");
                }
                //HERE IS WHERE TO PRINT DATA TO SD CARD FROM BUFFER (REMEMBER TO EMPTY BUFFER???)
                //Lock data buffer
                DataBuffer.lock();
                dataLock.lock();
                //Print all samples to SD
                for(int n=data_t; n<=MAX_SAMPLES; n++) {
                    fputs(data_buffer[n], fp);
                    fprintf(fp, "\n\r");
                }
                if(data_t>data_h) {
                    for(int n=0; n<=(data_t-1); n++) {
                        fputs(data_buffer[n], fp);

                    }
                }

                //Lock data buffer
                DataBuffer.unlock();
                dataLock.unlock();
                //fprintf(fp, "dd/mm/yy hh:mm:ss, TEMPERATURE, PRESSURE, LIGHT\n\r");

                fclose(fp);

                pc.printf("Write Sucessful!\n\r");

                sd.deinit();
                pc.printf("SD Card Ready to Remove\n\r");
                Green_ext = 1;
                Thread::wait(500);
                Green_ext = 0;
                Thread::wait(500);
                Green_ext = 1;
                Thread::wait(500);
                Green_ext = 0;
                Thread::wait(500);
                Green_ext = 1;
                Thread::wait(500);
                Green_ext = 0;
                Thread::wait(500);
                Green_ext = 1;
                Thread::wait(500);
                Green_ext = 0;
                Thread::wait(500);
        }//End Switch
    }// End While
}// End Thread
/*--------------------------------------------------------------------------*/

/*---------------------------Networking Thread------------------------------*/
void Network1 ()
{

    printf("Setting up server\n\r");

    //Configure an ethernet connection
    EthernetInterface eth;
    eth.set_network(IP, NETMASK, GATEWAY);
    eth.connect();
    if (eth.get_ip_address() == NULL) {
        pc.printf("Error - Can't get IP. Network not setup\n\r");
        pc.printf("Reset Required. Make sure network cables are plugged in\n\r");
    }
     else {
        printf("The target IP address is '%s'\n\r", eth.get_ip_address());

        //Now setup a web server
        TCPServer srv;           //TCP/IP Server

        SocketAddress clt_addr;  //Address of incoming connection

        /* Open the server on ethernet stack */
        srv.open(&eth);

        /* Bind the HTTP port (TCP 80) to the server */
        srv.bind(eth.get_ip_address(), 80);

        /* Can handle 5 simultaneous connections */
        srv.listen(5);

        TCPSocket clt_sock;      //Socket for communication
        pc.printf("Server Ready\n\r");
        
        while (true) {
            
            using namespace std;
            //Block and wait on an incoming connection
            srv.accept(&clt_sock, &clt_addr);
            //printf("accept %s:%d\n\r", clt_addr.get_ip_address(), clt_addr.get_port());

            //Uses a C++ string to make it easier to concatinate
            string response;
            string strL = "LDR:";
            string strP = ",  Pressure(mBar): ";
            string strT = ",  Temp(C): ";

            //This is a C string
            char l_str[64];
            char p_str[64];
            char t_str[64];

            //Read the LDR value
            dataLock.lock(); // add watchdog?
            float L = LDR ;
            float T = TEMP;
            float P = PRES;

            dataLock.unlock();

            //Convert to a C String
            sprintf(l_str, "%1.3f", L ); // try \n\r??
            sprintf(t_str, "%2.2f", T);
            sprintf(p_str, "%4.2f", P);



            //Build the C++ string response
            response = HTTP_MESSAGE_BODY1;
            // response += strL;
            response += l_str;
            response += strT;
            response += t_str;
            response += strP;
            response += p_str;
            response += HTTP_MESSAGE_BODY2;

            //Send static HTML response (as a C string)
            clt_sock.send(response.c_str(), response.size()+6);

        }// end While
    }//end if
}// end thread
/*---------------------------POST--------------------------------------------*/
void POST () {
    pc.printf(" Basic POST\n\r"); 
    pc.printf(" ALL Leds should be flashing\n\r");
    
    for(unsigned int n = 0; n<10; n++) {
        Green_int = ON;
        Blue_int = ON;
        Red_int = ON;
        Green_ext = ON;
        Yellow_ext = ON;
        Red_ext = ON;
    
        wait (0.2);
        Green_int = OFF;
        Blue_int = OFF;
        Red_int = OFF;
        Green_ext = OFF;
        Yellow_ext = OFF;
        Red_ext = OFF;
        wait (0.2);
    }
    
    pc.printf("Switch states:\n\r");
    pc.printf("\tSW_L: %d\n\r\tSW_R %d\n\r", SW_L.read(), SW_R.read());
    
    float Temp = Sensor.getTemperature();
    float Pres = Sensor.getPressure();
    float ldrs = LDR_In.read();
    
    pc.printf("Sensor test:\n\r");
    pc.printf("T: %f\tP: %f\tL: %f\n\r",Temp,Pres,ldrs);
    
    pc.printf("LCD Test\n\r");
    
    lcd.Clear();
    lcd.RowSelect(1);
    lcd.Write("*******LCD******");
    lcd.RowSelect(2);
    lcd.Write("******TEST******");
    wait(1);
    lcd.Clear();
    pc.printf("Basic POST end\n\r");    
}