Diff: main.cpp

Revision:

0:8b27cd0189c9

Child:

1:8475f46f050b

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Sat Jan 28 06:22:46 2017 +0000
@@ -0,0 +1,205 @@
+#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;
+
+MemoryPool<int, 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
+    int timestamp;  // Timestamp when the event occured
+} reading;
+
+Queue<reading, 16> queue;
+
+void lecture_analog(void const *args) {
+    pc.printf("Debut des lectures analogiques\r\n");
+    int state[2] = {0,0};
+    int newstate[2] = {0,0};
+    int mean1[5] = {0,0,0,0,0};
+    int mean2[5] = {0,0,0,0,0};
+    int i = 0;
+    int timestamp;
+    reading *message;
+    while (true) {
+        // synchronisation sur la période d'échantillonnage
+        Thread::signal_wait(signal250ms);
+        // lecture de l'étampe temporelle
+        timestamp = 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;
+        newstate[1] = (mean2[0] + mean2[1] + mean2[2] + mean2[3] + mean2[4]) / 5;
+        // génération éventuelle d'un événement
+        if (abs(newstate[0] - state[0]) > 1/8)
+        {
+            state[0] = newstate[0];
+            int *state = analogpool.alloc();
+            *state = state[0];
+            message->type = typeAnalog;
+            message->id = 1;
+            message->position = state;
+            message->timestamp = timestamp;
+            queue.put(message);
+        }
+        if (abs(newstate[1] - state[1]) > 1/8)
+        {
+            state[1] = newstate[1];
+            int *state = analogpool.alloc();
+            *state = state[1];
+            message->type = typeAnalog;
+            message->id = 2;
+            message->position = state;
+            message->timestamp = timestamp;
+            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};
+    int timestamp = 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
+        timestamp = 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];
+        
+        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->timestamp = timestamp;
+                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->timestamp = timestamp;
+                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 %d\r\n", message->id, *(message->position), message->timestamp);
+            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 %d\r\n", message->id, *(message->position), message->timestamp);
+            numericpool.free(message->position);
+        }
+    }
+}
+
+void signalnumeric()
+{
+    led3 = !led3;
+    pnumeric_thread->signal_set(signal100ms | signal50ms);
+}
+
+void signalanalog()
+{
+    panalog_thread->signal_set(signal250ms);
+}
+Ticker flipper;
+void flip() {
+    led4 = !led4;
+}
+int main() {
+    pc.printf("Welcome\r\n");
+    flipper.attach(&flip, 0.5);
+    // initialisation du RTC
+    //analogtimer.attach(&signalanalog, 0.250);
+    numerictimer.attach(&signalnumeric, 0.05);
+    
+    // démarrage des tâches
+    //Thread analog_thread(lecture_analog);
+    Thread numeric_thread(lecture_num);
+    pnumeric_thread = &numeric_thread;
+    Thread q(collection);
+    while(1){
+    }
+}