broken

Dependencies:   mbed-rtos mbed

Fork of rtos_basic by Philippe Fontaine

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers main.cpp Source File

main.cpp

00001 #include "mbed.h"
00002 #include "rtos.h"
00003 #include "AnalogBuffer.h"
00004 
00005 const int SEUIL_ANALOG = 0x2000;
00006 
00007 DigitalIn en_1(p15);
00008 DigitalIn en_2(p16);
00009 AnalogIn ea_1(p19);
00010 AnalogIn ea_2(p20);
00011 
00012 bool digital_1;
00013 bool digital_2;
00014 
00015 AnalogBuffer ab_1;
00016 AnalogBuffer ab_2;
00017 
00018 Ticker ticker1, ticker2;
00019 
00020 Thread *t1, *t2;
00021 
00022 Serial pc(USBTX, USBRX); // tx, rx
00023 
00024 typedef struct {
00025     bool isAnalog;
00026     bool digital;
00027     unsigned short analog;
00028     unsigned short id;
00029     time_t rtc_time;
00030 } mail_t;
00031 
00032 Mail<mail_t, 16> mail_box;
00033 
00034 //Benchmark section.
00035 Timer timer;
00036 unsigned int old;
00037 unsigned int newT;
00038 
00039 void lecture_analog(void const *args)
00040 {
00041     unsigned short old_average_1 = 0;
00042     unsigned short old_average_2 = 0;
00043     while (true) {
00044         Thread::signal_wait(0x1);
00045         old = newT;
00046         newT = timer.read_ms();
00047         pc.printf("Time : %d\n",newT-old);
00048         time_t rtc_time = time(NULL); // lecture de l'étampe temporelle
00049         ab_1.put(ea_1.read_u16()); // lecture des échantillons analogiques
00050         ab_2.put(ea_2.read_u16());
00051         unsigned short new_average_1 = ab_1.average(); // calcul de la nouvelle moyenne courante
00052         unsigned short new_average_2 = ab_2.average();
00053         int diff_1 = abs(new_average_1 - old_average_1);
00054         int diff_2 = abs(new_average_2 - old_average_2);
00055 
00056         if (diff_1 > SEUIL_ANALOG) {
00057             mail_t* mail = mail_box.alloc();
00058             mail->isAnalog = true;
00059             mail->analog = new_average_1;
00060             mail->rtc_time = rtc_time;
00061             mail->id = 1;
00062             mail_box.put(mail);
00063             old_average_1 = new_average_1;
00064         }
00065         if (diff_2 > SEUIL_ANALOG) {
00066             mail_t* mail = mail_box.alloc();
00067             mail->isAnalog = true;
00068             mail->analog = new_average_2;
00069             mail->rtc_time = rtc_time;
00070             mail->id = 2;
00071             mail_box.put(mail);
00072             old_average_2 = new_average_2;
00073         }
00074     }
00075 }
00076 
00077 
00078 
00079 void lecture_num(void const *args)
00080 {
00081     while (true) {
00082         Thread::signal_wait(0x1);
00083         //old = newT;
00084 //        newT = timer.read_ms();
00085 //        pc.printf("Time : %d\n",newT-old);
00086         time_t rtc_time = time(NULL); // lecture de l'étampe temporelle
00087         bool new_digital_1 = en_1.read();  // lecture des échantillons numériques
00088         bool new_digital_2 = en_2.read();  // lecture des échantillons numériques
00089 
00090         if ((new_digital_1 != digital_1) || (new_digital_2 != digital_2)) {
00091             // prise en charge du phénomène de rebond
00092             Thread::wait(50);
00093             if (new_digital_1 != digital_1) {
00094                 new_digital_1 = en_1.read();
00095                 if (new_digital_1 != digital_1) {
00096                     // génération éventuelle d'un événement
00097                     mail_t* mail = mail_box.alloc();
00098                     mail->isAnalog = false;
00099                     mail->digital = new_digital_1;
00100                     mail->rtc_time = rtc_time;
00101                     mail->id = 1;
00102                     mail_box.put(mail);
00103                     digital_1 = new_digital_1;
00104                 }
00105             }
00106             if (new_digital_2 != digital_2) {
00107                 new_digital_2 = en_2.read();
00108                 if (new_digital_2 != digital_2) {
00109                     // génération éventuelle d'un événement
00110                     mail_t* mail = mail_box.alloc();
00111                     mail->isAnalog = false;
00112                     mail->digital = new_digital_2;
00113                     mail->rtc_time = rtc_time;
00114                     mail->id = 2;
00115                     mail_box.put(mail);
00116                     digital_2 = new_digital_2;
00117                 }
00118             }
00119         }
00120     }
00121 }
00122 
00123 void collection(void const *args)
00124 {
00125     while (true) {
00126         // attente et lecture d'un événement
00127         // écriture de l'événement en sortie (port série)
00128         osEvent evt = mail_box.get();
00129         if (evt.status == osEventMail) {
00130             mail_t *mail = (mail_t*)evt.value.p;
00131             if(mail->isAnalog) {
00132                 pc.printf("Analog : (%d,%X) %s", mail->id, mail->analog, ctime(&mail->rtc_time));
00133             } else {
00134                 pc.printf("Digital : (%d,%X) %s", mail->id, mail->digital, ctime(&mail->rtc_time));
00135             }
00136             mail_box.free(mail);
00137         }
00138     }
00139 }
00140 
00141 void wakeupThread1()
00142 {
00143     t1->signal_set(0x1);
00144 }
00145 
00146 void wakeupThread2()
00147 {
00148     t2->signal_set(0x1);
00149 }
00150 
00151 int main()
00152 {
00153     // initialisation du RTC
00154     set_time(1485732233);
00155 
00156     timer.start();
00157 
00158     // démarrage des tâches
00159     Thread analogThread(lecture_analog);
00160     Thread digitalThread(lecture_num);
00161     Thread collectionThread(collection);
00162 
00163     t1 = &analogThread;
00164     t2 = &digitalThread;
00165 
00166     ticker1.attach(&wakeupThread1, 0.250);
00167     ticker2.attach(&wakeupThread2, 0.100);
00168 
00169     while(1);
00170 }