File content as of revision 4:6c17983d6192:

//Rob I updated the LCD update and read pot thread and they are working
//One key issues was adding timeout for the put and get methods of the queue
//Maybe you can work on the TOD thread and MUTEX (you'll need to add it to the 
//LCD thread and I will finish the scan thread, sounds like Plan?? :-)
//In the end I had to add the memory pool combined with the queue as otherwise
//the queues just keep pointers to data and being that the putting and getting of
//the pot values in the queue is asynchronous you need a buffer to keep the values
//and this is provided by the MemoryPool.


#include "mbed.h"
#include "rtos.h"
#include "C12832_lcd.h"
#include <string>

#define BUFFER 17
#define COOKIEQUEUE 30

C12832_LCD lcd;
Serial pc(USBTX, USBRX); // tx, rx

Serial      pc(USBTX, USBRX);   //To differentiate from LCD functions

AnalogIn pot1(p19);
MemoryPool<float, 10> potReadingBuffer;
Queue<float,10> potReadingQueue;

<<<<<<< local
MemoryPool<char[BUFFER], COOKIEQUEUE> cookieReadingBuffer;
Queue<char[BUFFER],COOKIEQUEUE> cookieReadingQueue;
=======
>>>>>>> other

<<<<<<< local
=======
/******************************************************************
*
*An LCD thread that updates the LCD based on information 
*received from other threads via IPC
*
*Uses the top 3 lines of the LCD to reflect the pot, the 
*temperature, and the cookie. This task must use IPC (with 
*timeout) methods to get data from each of the previous threads
*
*******************************************************************/
>>>>>>> other
void lcdUpdate(void const*){
while(1){
<<<<<<< local
       osEvent evtPot = potReadingQueue.get(1200);
        if (evtPot.status == osEventMessage) {
            float *queuePot = (float*)evtPot.value.p;
            lcd.locate(0,3);
            lcd.printf("Voltage: %.2f V", *queuePot);
            potReadingBuffer.free(queuePot);      
=======
       osEvent evt = potReadingQueue.get();
        if (evt.status == osEventMail) {
            float *queue = (float*)evt.value.p;
            pc.printf("\nVoltage: %.2f V\n\r"   , *queue);
            
            pc.printf("LCD updated");
            Thread::wait(1000);
>>>>>>> other
        }
       osEvent evtCookie = cookieReadingQueue.get(1200);
        if (evtCookie.status == osEventMessage) {
            char (*queueCookie)[BUFFER] = (char (*)[BUFFER])evtCookie.value.p;
            lcd.locate(0,15);
            string str(*queueCookie);
            lcd.printf("F.Cookie: %s", str);    
            cookieReadingBuffer.free(queueCookie);      
        }
        Thread::wait(1000);
    }
}

/******************************************************************
*
*A POT thread that reads the pot value in a polling loop 
*every 10 seconds and sends value to LCD thread via IPC Queue 
*
*******************************************************************/
void readPOT(void const*){    
while(1){
        float *queue = potReadingBuffer.alloc();
        *queue = pot1; 
<<<<<<< local
        potReadingQueue.put(queue,1200);
     
    Thread::wait(10000);
=======
        potReadingQueue.put(queue);
        pc.printf("POT read");
        Thread::wait(10000);
>>>>>>> other
    }
    
}

<<<<<<< local


=======
/******************************************************************
*
*A TEMP thread that read the temperature every 60 seconds 
*and sends the value to the LCD task via IPC Queue
*
*******************************************************************/
>>>>>>> other
void readTemp(void const*){
    while(1){
        pc.printf("TEMP read");
        Thread::wait(60000);
    }
    
}

<<<<<<< local
void readCookie(void const*){
    pc.printf(">Enter your fortune cookie\n>");
    char (*ptrBuffer)[BUFFER] = cookieReadingBuffer.alloc();
    char *ptrChar;
    ptrChar=*ptrBuffer;
=======
/******************************************************************
*
*A SCANF thread that reads in a fortune cookie from user 
*and sends it to the LCD task via IPC Memory Pool
*
*******************************************************************/
void threadCookie(void const*){
    //Checks often but low priority?
>>>>>>> other
    while(1){
<<<<<<< local
        if(pc.readable()){
            *ptrChar=pc.getc();
            pc.putc(*ptrChar);
            if((*ptrChar=='\n') || ((ptrChar-*ptrBuffer)>=(BUFFER-1)) ){
                   if((ptrChar-*ptrBuffer)>=(BUFFER-1)) *++ptrChar='\n';
                   while((ptrChar-*ptrBuffer)<=(BUFFER-1)){
                       *ptrChar++=' ';
                    }
                   *ptrChar='\0';
                   cookieReadingQueue.put(ptrBuffer,500);
                   pc.printf(">Enter your fortune cookie\n>");
                   ptrChar=*ptrBuffer;
            } else {
                ptrChar++;
            }
        }
    Thread::wait(10);
    }
=======
        Thread::wait(1000);
    }  
}


/******************************************************************
*
*A TOD thread that updates the 4th line of the LCD with time 
*of day once a minute. It shares the LCD with the LCD thread 
*using mutual exclusion
*
*******************************************************************/
void threadTOD(void const*){
        while(1){
            pc.printf("TOD updated");
            Thread::wait(60000);
    } 
>>>>>>> other
}

DigitalOut myled(LED1);

int main() {
lcd.cls();

Thread threadLCD(lcdUpdate);
Thread threadPOT(readPOT);
Thread threadTemp(readTemp);
Thread threadCookie(readCookie);

    while(1) {
        Thread::wait(250);       
        
    }
}