File content as of revision 1:8475f46f050b:

#include "mbed.h"
#include "rtos.h"
Serial pc(USBTX, USBRX);
DigitalOut led1(LED1);
DigitalOut led2(LED2);
DigitalOut led3(LED3);
DigitalOut led4(LED4);
DigitalIn en_1(p15, PullUp);
DigitalIn en_2(p16, PullUp);
AnalogIn ea_1(p19);
AnalogIn ea_2(p20);

int signalnewdata = 0x1 << 6;
int signal100ms = 0x1 << 5;
int signal50ms = 0x1 << 4;
int signal250ms = 0x1 << 3;

int typeAnalog = 0;
int typeNumeric = 1;
time_t begin_time = 0;

MemoryPool<float, 16> analogpool;
// TODO
MemoryPool<int, 16> numericpool;

Ticker analogtimer;
Ticker numerictimer;

Thread* panalog_thread;
Thread* pnumeric_thread;


typedef struct
{
    int type;               // Which type of event
    int id;                 // Which pins changed
    int* position;          // Position in the memory pool
    unsigned long seconds;  // Timestamp when the event occured
} reading;

Queue<reading, 16> queue;

void lecture_analog(void const *args) {
    pc.printf("Debut des lectures analogiques\r\n");
    float state[2] = {0,0};
    float newstate[2] = {0,0};
    float mean1[5] = {0,0,0,0,0};
    float mean2[5] = {0,0,0,0,0};
    int i = 0;
    time_t timestamp = time(NULL);
    unsigned long seconds = 0;
    reading *message;
    while (true) {
        // synchronisation sur la période d'échantillonnage
        Thread::signal_wait(signal250ms);
        // lecture de l'étampe temporelle
        seconds = (unsigned long) difftime(begin_time, 0);
        // lecture des échantillons analogiques
        mean1[i] = ea_1;
        mean2[i] = ea_2;
        // calcul de la nouvelle moyenne courante
        newstate[0] = (mean1[0] + mean1[1] + mean1[2] + mean1[3] + mean1[4]) / 5.0;
        newstate[1] = (mean2[0] + mean2[1] + mean2[2] + mean2[3] + mean2[4]) / 5.0;
        // génération éventuelle d'un événement
        led3 = !led3;
        if (abs(newstate[0] - state[0]) > 1.0/8.0)
        {
            state[0] = newstate[0];
            float *state = analogpool.alloc();
            *state = state[0];
            message->type = typeAnalog;
            message->id = 1;
            message->position = (int *) state;
            message->seconds = seconds;
            queue.put(message);
        }
        if (abs(newstate[1] - state[1]) > 1.0/8.0)
        {
            state[1] = newstate[1];
            float *state = analogpool.alloc();
            *state = state[1];
            message->type = typeAnalog;
            message->id = 2;
            message->position = (int *) state;
            message->seconds = seconds;
            queue.put(message);
        }
        i = (i + 1) % 5;
    }
}

void lecture_num(void const *args) {
    pc.printf("Debut des lectures numeriques\r\n");
    bool state[2] = {false, false};
    bool newstate[2] = {false, false};
    bool changed[2] = {false, false};
    unsigned long seconds = 0;
    reading *message;
    while (true) {
        // synchronisation sur la période d'échantillonnage
        //numeric_thread.signal_clr(signal100ms);
        Thread::signal_wait(signal100ms);
        
        // lecture de l'étampe temporelle
        seconds = (unsigned long) difftime(begin_time, 0);
        
        // lecture des échantillons numériques
        newstate[0] = !en_1;
        newstate[1] = !en_2;
        
        // prise en charge du phénomène de rebond
        changed[0] = newstate[0] != state[0];
        changed[1] = newstate[1] != state[1];
        
        int *test = numericpool.alloc();
        *test = 42;
        printf("%d", test);
        numericpool.free(test);
        
        if (changed[0] || changed [1])
        {
            pnumeric_thread->signal_clr(signal50ms);
            //flag isp
            Thread::signal_wait(signal50ms);
            
            newstate[0] = !en_1;
            newstate[1] = !en_2;
            if(newstate[0] != state[0] && changed[0])
            {
                led1 = newstate[0];
                state[0] = newstate[0];
                // génération éventuelle d'un événement
                int *state = numericpool.alloc();
                *state = state[0];
                message->type = typeNumeric;
                message->id = 1;
                message->position = state;
                message->seconds = seconds;
                queue.put(message);
            }
            if(newstate[1] != state[1] && changed[1])
            {
                led2 = newstate[1];
                state[1] = newstate[1];
                // génération éventuelle d'un événement
                int *state = numericpool.alloc();
                *state = state[1];
                message->type = typeNumeric;
                message->id = 2;
                message->position = state;
                message->seconds = seconds;
                queue.put(message);
            }
        }
        else
        {
            Thread::yield();   
        }
    }
}

void collection(void const *args) {
    osEvent event;
    reading* message;
    while (true) {
        
        // attente et lecture d'un événement
        event = queue.get();
        message = (reading*) event.value.p;
        if (message->type == typeNumeric)
        {
            // écriture de l'événement en sortie (port série)
            pc.printf("The state on numeric pin %d has changed to %d at %lus\r\n", message->id, (int *) *(message->position), message->seconds);
            numericpool.free(message->position);
        }
        if (message->type == typeAnalog)
        {
            // écriture de l'événement en sortie (port série)
            pc.printf("The state on analog pin %d has changed to %d at %lus\r\n", message->id, *(message->position), message->seconds);
            analogpool.free((float *) message->position);
        }
    }
}

void signalnumeric()
{
    pnumeric_thread->signal_set(signal100ms | signal50ms);
}

void signalanalog()
{
    panalog_thread->signal_set(signal250ms);
}
Ticker flipper;
void flip() {
    led4 = !led4;
}
int main(){
   // set_time(0);
    begin_time = time(NULL);
    pc.printf("Welcome\r\n");
    flipper.attach(&flip, 0.5);
    // initialisation du RTC
    analogtimer.attach(&signalanalog, 0.250);
    numerictimer.attach(&signalnumeric, 0.5);
    
    // démarrage des tâches
    Thread analog_thread(lecture_analog);
    panalog_thread = &analog_thread;
    Thread numeric_thread(lecture_num);
    pnumeric_thread = &numeric_thread;
    Thread q(collection);
    while(1){
    }
}