Diff: main.cpp

Revision:

2:6009cb96f273

Parent:

1:96a4c2a39981

Child:

3:350e3a76ff72

Child:

4:6a242f5bc7fa

--- a/main.cpp	Mon Jan 27 16:50:48 2014 +0000
+++ b/main.cpp	Mon Jan 27 20:58:48 2014 +0000
@@ -1,6 +1,5 @@
 #include "mbed.h"
 #include "rtos.h"
-#include <ctime>
 
 DigitalIn en_1(p15);
 DigitalIn en_2(p16);
@@ -10,55 +9,170 @@
 
 Serial pc(USBTX, USBRX);
 
-void showTime(char *buffer)
+Mutex event_mutex;
+
+struct event
+{
+    char *def;
+    time_t time;
+};
+
+Queue<event, 16> queue;
+
+void put(event *ev)
 {
-    std::time_t time = std::time(0);
+    event_mutex.lock();
+    queue.put(ev);
+    event_mutex.unlock();
+}
+
+void showTime(char *buffer, time_t time)
+{
+    strftime(buffer, 32, "%Y-%m-%d %H:%M:%S\n\r", localtime(&time));
+}
+
+unsigned short moyenne(unsigned short* mean_values)
+{
+    unsigned int mean = 0;
     
-    strftime(buffer, 32, "%Y-%m-%d %H:%M:%S\n\r", localtime(&time));
+    for (int i = 0; i < 5; i++)
+    {
+        mean += mean_values[i];
+    }
+    
+    return mean/5;
 }
 
 void lecture_analog(void const *args)
 {
+    unsigned short values_ea_1[5] = {0};
+    unsigned short values_ea_2[5] = {0};
+    
+    const unsigned short valeur_ecart = 0x1FFF; // le huitième de 0xFFFF
+    
+    int init_mean = 0;
+    
+    int compteur = 0;
+    
     while (true)
     {
         // synchronisation sur la période d'échantillonnage
-        // lecture de l'étampe temporelle
-        // lecture des échantillons analogiques
-        // calcul de la nouvelle moyenne courante
-        // génération éventuelle d'un événement
+        Thread::signal_wait(0x2);
+        
+        if (init_mean < 5)
+        {
+            values_ea_1[init_mean] = ea_1.read_u16();
+            values_ea_2[init_mean] = ea_2.read_u16();
+            init_mean++;
+        }
+        else
+        {
+            event *ev = new event;
+            
+            // lecture de l'étampe temporelle
+            ev->time = time(NULL);
+            
+            // lecture des échantillons analogiques
+            unsigned short value_ea_1 = ea_1.read_u16();
+            unsigned short value_ea_2 = ea_2.read_u16();
+            
+            // calcul de la nouvelle moyenne courante
+            unsigned short mean_value_ea_1 = moyenne(values_ea_1);
+            unsigned short mean_value_ea_2 = moyenne(values_ea_2);
+            
+            // génération éventuelle d'un événement
+            if (abs(value_ea_1 - mean_value_ea_1) > valeur_ecart)
+            {
+                ev->def = "analog1";
+                put(ev);
+            }
+            if (abs(value_ea_2 - mean_value_ea_2) > valeur_ecart)
+            {
+                ev->def = "analog2";
+                put(ev);
+            }
+            
+            values_ea_1[compteur] = value_ea_1;
+            values_ea_2[compteur] = value_ea_2;
+            
+            compteur = (compteur+1) % 5;
+        }
     }
 }
 
-void lecture_digital1(void const *thread)
+void timer250ms(void const *thread)
 {
-    (Thread)
+    Thread *t = (Thread*)thread;
+    t->signal_set(0x02);
 }
 
 void lecture_num(void const *args)
 {
+    int state1 = en_1;
+    int state2 = en_2;
+    bool stateChanged[2] = {false, false};
+    
     while (true)
     {
+        // synchronisation sur la période d'échantillonnage
         Thread::signal_wait(0x1);
-        pc.prinft("HAHAHAHAHAHAHA");
-        // synchronisation sur la période d'échantillonnage
+        
+        event *ev = new event;
+        
         // lecture de l'étampe temporelle
+        ev->time = time(NULL);
+        
         // lecture des échantillons numériques
+        stateChanged[0] = (state1 != en_1);
+        stateChanged[1] = (state2 != en_2);
+        
         // prise en charge du phénomène de rebond
         // génération éventuelle d'un événement
+        if (stateChanged[0] || stateChanged[1])
+        {
+            wait(0.05);
+            if (state1 != en_1 && stateChanged[0])
+            {
+                ev->def = "digital1";
+                put(ev);
+                state1 = en_1;
+            }
+            if (state2 != en_2 && stateChanged[1])
+            {
+                ev->def = "digital2";
+                put(ev);
+                state2 = en_2;
+            }
+            
+            stateChanged[0] = false;
+            stateChanged[1] = false;
+        }
     }
 }
 
+void timer100ms(void const *thread)
+{
+    Thread *t = (Thread*)thread;
+    t->signal_set(0x01);
+}
+
 void collection(void const *args)
 {
-    char *time = new char;
-    
     while (true)
     {
-        showTime(time);
-        pc.printf("time: %s",  time);
-        wait(2);
         // attente et lecture d'un événement
+        osEvent evt = queue.get();
+        
         // écriture de l'événement en sortie (port série)
+        if (evt.status == osEventMessage)
+        {
+            event *ev = (event*)evt.value.p;
+            
+            char *buffer = new char;
+            showTime(buffer, ev->time);
+            
+            pc.printf("%s: %s", ev->def, buffer);
+        }
     }
 }
 
@@ -69,10 +183,14 @@
     
     // démarrage des tâches
     Thread thread1(lecture_num);
-    RtosTimer lect_num(lecture_digital1, osTimerPeriodic, (void*)thread1);
-    lect_num.start(100);
-    //Thread thread2(lecture_analog);
-    //Thread thread3(collection);
+    RtosTimer timer_num(timer100ms, osTimerPeriodic, (void*)&thread1);
+    timer_num.start(100);
+    
+    Thread thread2(lecture_analog);
+    RtosTimer timer_analog(timer250ms, osTimerPeriodic, (void*)&thread2);
+    timer_analog.start(250);
+    
+    Thread thread3(collection);
     
     while(true) {}
 }
\ No newline at end of file