File content as of revision 3:f09f9670e40e:

// becj2903 - Joseph Marinier

#include "mbed.h"
#include "rtos.h"

#define SIGNAL 1
#define ADDING_INGREDIENT 100 // ms
#define ADDING_4_INGREDIENTS 500 // ms

Semaphore ketchup(2);
Mutex relish;
Mutex mayonnaise;
Semaphore moutarde(2);
Mutex oignon;

Thread thread[4];

struct message_t {
    char text[6];
};

Queue<message_t, 4> *queue;
MemoryPool<message_t, 4> *pool;

void add_ingredient(Semaphore ingredient) { // in Semaphore
    ingredient.wait();
    
    wait_ms(ADDING_INGREDIENT);
    
    ingredient.release();
}

void add_ingredient(Mutex ingredient) { // in Mutex
    ingredient.lock();
    
    wait_ms(ADDING_INGREDIENT);
    
    ingredient.unlock();
}

void doing_hot_dog_1() {
    DigitalOut led(LED1);
    
    while(true) {
        Thread::signal_wait(SIGNAL); // every_2_seconds
        
        add_ingredient(ketchup);
        add_ingredient(relish);
        
        led = !led;
    }
}

void doing_hot_dog_2() {
    DigitalOut led(LED2);
    
    while(true) {
        Thread::signal_wait(SIGNAL); // every_2_seconds
        
        add_ingredient(moutarde);
        add_ingredient(oignon);
        add_ingredient(mayonnaise);
        
        led = !led;
    }
}

bool passing_to_4 = false;

void doing_hot_dog_3() {
    DigitalOut led(LED3);
    
    while(true) {
        Thread::signal_wait(SIGNAL); // every_2_seconds
        
        add_ingredient(ketchup);
        
        if(passing_to_4) {
            message_t *message = pool->alloc();
            message->text[0] = 'h';
            message->text[1] = 'o';
            message->text[2] = 't';
            message->text[3] = 'd';
            message->text[4] = 'o';
            message->text[5] = 'g';
            queue->put(message);
        } else {
            led = !led;
        }
    
        passing_to_4 = !passing_to_4;
    }
}

void doing_hot_dog_4() {
    DigitalOut led(LED4);
    
    while(true) {
        Thread::signal_wait(SIGNAL); // every_2_seconds
        
        osEvent evt = queue->get();
        if (evt.status == osEventMessage) {
            message_t *message = (message_t*)evt.value.p;
            printf("\"%s\" should be \"hotdog\"\r\n", message->text);
            pool->free(message);
            
            relish.lock();
            mayonnaise.lock();
            moutarde.wait();
            oignon.lock();
            
            wait_ms(ADDING_4_INGREDIENTS);
            
            oignon.unlock();
            moutarde.release();
            mayonnaise.unlock();
            relish.unlock();
            
            led = !led;
        }
    }
}

bool every_2_seconds = false;
bool every_4_seconds = false;

void every_second() {
    thread[0].signal_set(SIGNAL);
    
    if(every_2_seconds) {
        thread[1].signal_set(SIGNAL);
        thread[2].signal_set(SIGNAL);
    
        if(every_4_seconds) {
            thread[3].signal_set(SIGNAL);
        }
        every_4_seconds = !every_4_seconds;
    }
    
    every_2_seconds = !every_2_seconds;
}

int main() {
    queue = &Queue<message_t, 4>();
    pool = &MemoryPool<message_t, 4>();

    thread[0] = Thread(osPriorityRealtime);
    thread[0].start(doing_hot_dog_1); // Wow la phrase!
    
    thread[1] = Thread(osPriorityHigh);
    thread[1].start(doing_hot_dog_2); // Ho franchement, c'est cute!
    
    thread[2] = Thread(osPriorityNormal);
    thread[2].start(doing_hot_dog_3); // Hooo wow!
    
    thread[3] = Thread(osPriorityLow);
    thread[3].start(doing_hot_dog_4); // Wow wow wow!
    
    Ticker ticker;
    ticker.attach(&every_second, 1);
    
    Thread::wait(osWaitForever);
}