File content as of revision 4:877b4e9cad76:

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

Serial pc(USBTX, USBRX); // tx, rx
DigitalIn en_1(p15);
DigitalIn en_2(p16);
AnalogIn ea_1(p19);
AnalogIn ea_2(p20);

Ticker sample;

// variable globale pour lecture button 1
int previousStateButton1 = 0;
int currentStateButton1;
int validationStateButton1;

// variable globale pour lecture button 2
int previousStateButton2 = 0;
int currentStateButton2;
int validationStateButton2;

// variable globale pour lecture potentiometre 
int tab_counter  =0;
int Nouvelle_moyenne_p19;
int Ancienne_moyenne_p19 = 0;
int Nouvelle_moyenne_p20;
int Ancienne_moyenne_p20 = 0;
unsigned short Tableau_Moyenne_p19[5]={0,0,0,0,0};
unsigned short Tableau_Moyenne_p20[5]={0,0,0,0,0};

int ISRcounter = 0;

Thread *threadNumerique;    // pointeur vers le thread du lecture numérique 
Thread *threadAnalogique;   // pointeur vers le thread du lecture analogique 
Thread *threadCollection;   // pointeur vers le thread d'affichage d'evenement  

// Pour le time stamp
char buffer[32];

// structure de data
typedef struct {
    time_t seconds;
    int pinNumero;
    //int state;
} data;

// Create queue
Queue<data, 32> queue;

// Create memory pool
MemoryPool<data, 32> mpool;

// osEvent to get from queue
osEvent evt;

// Thread pour lecture analogique 
void lecture_analog(void const *args) {
    while (true) 
    {
        Thread::signal_wait(0x2);   // WAITING STATE (waiting for an event)
    
        // create data structure
        data *analogData;
        
        Tableau_Moyenne_p19[tab_counter] = ea_1.read_u16(); //= LIRE PATTE 8 ;
        Tableau_Moyenne_p20[tab_counter] = ea_2.read_u16(); //= LIRE PATTE 8 ;
        
        tab_counter = tab_counter % 5 + 1; // incrémentation de i
        
        if(tab_counter % 5 == 0)    // validation duree de 1.25 seconde sont terminée
        {
        Nouvelle_moyenne_p19 = (int)Tableau_Moyenne_p19[0]+(int)Tableau_Moyenne_p19[1]+(int)Tableau_Moyenne_p19[2]+(int)Tableau_Moyenne_p19[3]+(int)Tableau_Moyenne_p19[4];
        Nouvelle_moyenne_p20 = (int)Tableau_Moyenne_p20[0]+(int)Tableau_Moyenne_p20[1]+(int)Tableau_Moyenne_p20[2]+(int)Tableau_Moyenne_p20[3]+(int)Tableau_Moyenne_p20[4];
        }

        // vérification de la difference de la moyenne de 12.5% pour la première potentiometre 
        if((Ancienne_moyenne_p19 - Nouvelle_moyenne_p19) > 40960 || (Nouvelle_moyenne_p19 - Ancienne_moyenne_p19) > 40960 || (Ancienne_moyenne_p20 - Nouvelle_moyenne_p20) > 40960 || (Nouvelle_moyenne_p20 - Ancienne_moyenne_p20) > 40960)
        {
        //Detection dun evenement
        
        pc.printf("ancienne moyenne pin 19 1 = %d ", Ancienne_moyenne_p19);
        pc.printf("nouvelle moyenne pin 19= %d ", Nouvelle_moyenne_p19);
        pc.printf("difference pin 19 = %d ", (Ancienne_moyenne_p19 - Nouvelle_moyenne_p19)/5);
        pc.printf("ancienne moyenne pin 20= %d ", Ancienne_moyenne_p20);
        pc.printf("nouvelle moyenne pin 20= %d ", Nouvelle_moyenne_p20);
        pc.printf("difference pin 20= %d ", (Ancienne_moyenne_p20 - Nouvelle_moyenne_p20)/5);
        
        
        // associte data structure to memory pool
        analogData = mpool.alloc();
        
        
        
        if((Ancienne_moyenne_p20 - Nouvelle_moyenne_p20) > 40960 || (Nouvelle_moyenne_p20 - Ancienne_moyenne_p20) > 40960)
        {
            analogData->pinNumero = 20;  
        }
        else 
        {
            analogData->pinNumero = 19;      
        }
             
        analogData->seconds = time(NULL); 
        queue.put(analogData);
        }
    
        // vérification de la difference de la moyenne de 12.5% pour le deuxieme potentiometre 
        /*
        else if((Ancienne_moyenne_p20 - Nouvelle_moyenne_p20) > 40960 || (Nouvelle_moyenne_p20 - Ancienne_moyenne_p20) > 40960)
        {
        //Detection dun evenement
        
        pc.printf("ancienne moyenne pin 20= %d ", Ancienne_moyenne_p20);
        pc.printf("nouvelle moyenne pin 20= %d ", Nouvelle_moyenne_p20);
        pc.printf("difference pin 20= %d ", (Ancienne_moyenne_p20 - Nouvelle_moyenne_p20)/5);
        pc.printf("Evenement detectee \n\r");
        
        
        // associte data structure to memory pool
        analogData = mpool.alloc();
        analogData->pinNumero = 20;        
        analogData->seconds = time(NULL); 
        queue.put(analogData);        
        }
        */
    
        // mise a jour de l'ancienne moyenne pour les 2 potentiometres
        if(tab_counter % 5 == 0)
        {      
            Ancienne_moyenne_p20 = Nouvelle_moyenne_p20;
            Ancienne_moyenne_p19 = Nouvelle_moyenne_p19;
        }
}
}

// Thread pour lecture numérique 
void lecture_num(void const *args) 
{
    while (true) 
    {    
        Thread::signal_wait(0x1);   // WAITING STATE (waiting for an event)
        
        // create data structure
        data *numData;
        
        currentStateButton1 = en_1.read();  // lecture courante numérique button 1
        currentStateButton2 = en_2.read(); // lecture courante numerique button 2
    
        if(previousStateButton1 != currentStateButton1 || previousStateButton2 != currentStateButton2)   // détection de changement d'état pour les 2 buttons
        {    
            Thread::wait(50);    // période de stabilisation de 50ms
        
            validationStateButton1 = en_1.read();   // nouvelle lecture apres stabilisation button 1
            validationStateButton2 = en_2.read();   // nouvelle lecture apres stabilisation button 2
        
            if(currentStateButton1 == validationStateButton1 || currentStateButton2 == validationStateButton2)  
            {   
                // associte data structure to memory pool
                numData = mpool.alloc();
                 
                if(previousStateButton1 != currentStateButton1)
                {
                    numData->pinNumero = 15;
                }
                    
                if(previousStateButton2 != currentStateButton2)
                {
                    numData->pinNumero = 16;
                }
    
                numData->seconds = time(NULL); 
                queue.put(numData);
            } 
            
        }
        previousStateButton1 = validationStateButton1; // mise a jour de l'état précédente button 1
        previousStateButton2 = validationStateButton2; // mise a jour de l'etat precedente button 2
    }
}

// Thread pour afficher les evenements 
void collection(void const *args) {
while (true) {
     
     // get data from queue and store in evt
     evt = queue.get();
     // error check
     if (evt.status == osEventMessage) {
            // retrive information from queue to data structure
            data *dataDisplay = (data*)evt.value.p;
            
            // conversion des secondes en format AA:MM:JJ:HH:MM:SS
            strftime(buffer, 32, "%y:%m:%d:%H:%M:%S \n\r", localtime(&dataDisplay->seconds));
            printf("Time as a custom formatted string = %s\n\r", buffer);
            printf("Pin numero = %d\n\r", dataDisplay->pinNumero);
            
            mpool.free(dataDisplay);    // free memory pool
     }
}
}


// sampling timer 
void interuptTimer() 
{
    if (ISRcounter % 2 == 0) //permet échantillonage chaque 100ms car detecter 1 fois sur 2 
    {
    threadNumerique->signal_set(0x1); //event occurs to trigger in response to signal waiting state
    }
    
    if (ISRcounter % 5 == 0) ////permet échantillonage chaque 250ms
    {
    threadAnalogique->signal_set(0x2); //event occurs to trigger in response to signal waiting state
    }
    
    ISRcounter++;
}


int main() {
    set_time(1505568984);  // Set RTC time to today
    
    Thread thread1;     //Create thread 1, READY state 
    threadNumerique = &thread1;     
    
    Thread thread2;     //Create thread 2, READY state 
    threadAnalogique = &thread2;
    
    Thread thread3;     //Create thread 3, READY state 
    threadCollection = &thread3; 
    
    threadNumerique->start(callback(lecture_num, (void *)NULL)); // RUNNING state
    
    threadAnalogique->start(callback(lecture_analog, (void *)NULL)); // RUNNING state
    
    threadCollection->start(callback(collection, (void *)NULL)); // RUNNING state
    
    sample.attach(&interuptTimer, 0.05); // période d'échantillonage chaque 50ms
    while(1) {}
}