File content as of revision 12:b24f9818a9f0:

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

Ticker ticker;
DigitalIn en_1(p15);
DigitalIn en_2(p16);
AnalogIn ea_1(p19);
AnalogIn ea_2(p20);
Thread *t1;
Thread *t2;
Thread *t3;

uint8_t compteur = 0;
bool verifierSiStable = false;
float echantillons1[5];
float echantillons2[5];
float seuil = 0.125;

/* Mail */
typedef struct {
    bool type;           // Numérique = 0, analogique = 1
    char* temps;         // Étampe indiquant l’heure et la date de l'occurrence
    uint8_t broche;      // Le numéro de la broche
    float moyenne;       // Moyenne courante échantillonnée sur 5 échantillons successifs
} mail_t;

Semaphore semaphore(200);
Mail<mail_t, 200> mail_box;

// -------------------------------------------------------
// -------------------------------------------------------

void envoyer_mail(bool type, uint8_t broche, float moyenne) {
    time_t secondes = time(NULL);
    mail_t *mail = mail_box.alloc();
    mail->type = type;
    mail->temps = ctime(&secondes);
    mail->broche = broche;
    mail->moyenne = moyenne;
    mail_box.put(mail);
}  

void lecture_analog(void const *args) {
    uint8_t i = 0;
    float moyenne_passee1 = -1;
    float moyenne_passee2 = -1;
        
    while (true) {        
        /*** Synchronisation sur la période d'échantillonnage ***/
        Thread::signal_wait(0x1);
        
        /*** Lecture des échantillons analogiques ***/
        float entreeanal_1 = ea_1.read();
        float entreeanal_2 = ea_2.read();
        //printf("Valeur de entree analogique 1: %f\n", entreeanal_1);
        //printf("Valeur de entree analogique 2: %f\n", entreeanal_2);
        
        echantillons1[i] = entreeanal_1;
        echantillons2[i] = entreeanal_2;
        
        i++;
        if (i == 5) {
            /*** Calcul de la moyenne courante du signal (calculée sur  5 échantillons successifs) ***/
            float moyenne_courante1 = (echantillons1[0] + echantillons1[1] + echantillons1[2] + echantillons1[3] + echantillons1[4]) / 5;
            float moyenne_courante2 = (echantillons2[0] + echantillons2[1] + echantillons2[2] + echantillons2[3] + echantillons2[4]) / 5;
            //printf("moyenne courante = %f, moyenne passee = %f, variation = %f\n", moyenne_courante1, moyenne_passee1,  std::abs(1 - (moyenne_courante1 / moyenne_passee1)));
            
            if (moyenne_passee1 != -1) {
                if ((std::abs(1 - (moyenne_courante1 / moyenne_passee1))) > seuil) {
                    semaphore.wait();
                    envoyer_mail(1, 19, moyenne_courante1); /*** Génération éventuelle d'un événement ***/
                }
            }
            if (moyenne_passee2 != -1) {
                if ((std::abs(1 - (moyenne_courante2 / moyenne_passee2))) > seuil) {
                    semaphore.wait();
                    envoyer_mail(1, 20, moyenne_courante2); /*** Génération éventuelle d'un événement ***/
                }
            }
            moyenne_passee1 = moyenne_courante1;
            moyenne_passee2 = moyenne_courante2;
            i = 0;
        }
    }
}

void lecture_num(void const *args) {    
    while (true) {
        /*** Synchronisation sur la période d'échantillonnage ***/
        Thread::signal_wait(0x1);
                
        /*** Lecture des échantillons numériques ***/
        uint8_t entreenum_1 = en_1.read();
        uint8_t entreenum_2 = en_2.read();
        // printf("Valeur de entree numerique 1: %d\n", entreenum_1);
        // printf("Valeur de entree numerique 2: %d\n", entreenum_2);
        
        /*** Lecture de l'étampe temporelle ***/
        time_t t = std::time(NULL);
        
        /*** Prise en charge du phénomène de rebond ***/
        if (en_1 || en_2) {
            verifierSiStable = true;
            Thread::signal_wait(0x2);
            
            if (en_1 == 1 && entreenum_1 == en_1.read()) {
                semaphore.wait();
                envoyer_mail(0, 15, NULL); /*** Génération d'un évènement... ***/
            } 
            if (en_2 == 1 && entreenum_2 == en_2.read()) {
                semaphore.wait();
                envoyer_mail(0, 16, NULL); /*** Génération d'un évènement... ***/
            } 
        } else {
            Thread::yield();
        } 
    }
}

void collection(void const *args) {
    while (true) {
        /*** Attente et lecture d'un événement ***/
        osEvent evt = mail_box.get();
        if (evt.status == osEventMail) {
            mail_t *mail = (mail_t*)evt.value.p;
            
            /*** Écriture de l'événement en sortie (port série) ***/
            if (mail->type == 0) {
                printf("Une lecture a ete detectee sur l'entree numerique %d\nDate: %s\n", mail->broche, mail->temps);
            }         
            else {
                printf("Une lecture a ete detectee sur l'entree analogique %d\nDate: %sLa moyenne courante est: %f\n\n", mail->broche, mail->temps, mail->moyenne); 
            }  
            mail_box.free(mail);
            semaphore.release();
        } else {
            Thread::yield();
        }
    }
}

void alarm() {
    compteur++;
    
    if (verifierSiStable) {
        t1->signal_set(0x2);
        verifierSiStable = false;
    }
    
    if (compteur % 2 == 0) {        // Entrées numériques échantillionnées à tous les 100 ms
        t1->signal_set(0x1);
    } else if (compteur % 5 == 0) { // Entrées analogiques échantillonnées à tous les 250 ms
        t2->signal_set(0x1);
    }
    
    if (compteur % 10 == 0) {
        compteur = 0;
    }
}

int main() {
    /*** Démarrage des tâches ***/
    printf("Demarrage des taches...\n");

    Thread t_lectureNum(lecture_num);
    Thread t_lectureAnalog(lecture_analog);
    Thread t_collection(collection);
    
    t1 = &t_lectureNum;
    t2 = &t_lectureAnalog;
    t3 = &t_collection;
    
    /*** Initialisation du RTC ***/
    set_time(1485514920);  // Set RTC time to...
    ticker.attach(&alarm, 0.05);

    while(1);
}